asset_manager.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "assets.hpp"
#include "pack.hpp"
#include "types.hpp"
 
#include <filesystem>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <toast/events/listener.hpp>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace assets {
 
struct AssetInfo {
  std::string path;
  std::string type;
};
 
struct Paths {
  std::filesystem::path project;    
  std::filesystem::path artworks;
  std::filesystem::path cache;
  std::filesystem::path saved;
  std::filesystem::path core;
};

class AssetManager {
public:
  AssetManager();
  ~AssetManager() = default;
 
  static auto get() noexcept -> AssetManager&;
 
  [[nodiscard]]
  static auto isInitialized() noexcept -> bool {
    return instance != nullptr;
  }

  auto load(toast::UID uid) -> Asset*;

  auto load(std::string_view uri) -> Asset*;

  auto save(toast::UID uid) -> bool;

  auto save(std::string_view uri) -> bool;

  auto saveBytes(std::string_view uri, const std::vector<uint8_t>& data) -> bool;
  void replacePrefab(toast::UID uid, const Prefab& prefab);

  auto loadBytes(std::string_view uri) -> std::optional<std::vector<uint8_t>>;

  auto tryLoadBytes(std::string_view uri) -> std::optional<std::vector<uint8_t>>;

  void reloadManifest();

  void clearUnusedAssets();

  static void setPaths(Paths&& paths);

  static void registerDatabase(std::string_view name, std::filesystem::path root);

  static void clearDatabases();

  static auto projectRoot() -> const std::filesystem::path&;

  static auto resolveURI(std::string_view uri) -> std::optional<toast::UID>;

  static auto getURI(toast::UID uid) -> std::string;

  auto search(std::string_view query) -> std::vector<Handle<Asset>>;
 
  auto listByType(std::string_view type) -> std::vector<toast::UID>;

  static auto typeOf(toast::UID uid) -> std::string;
 
  struct ReloadedAsset {
    toast::UID uid;
    std::string type;
    bool replaced = false;
    std::shared_ptr<const Prefab> prefab;
  };

  void pollModifiedAssets();
 
  [[nodiscard]]
  auto hasPendingReloads() const -> bool;

  auto applyPendingReloads() -> std::vector<ReloadedAsset>;
 
  [[nodiscard]]
  auto getCachePath() const -> const std::filesystem::path&;

  static void setLoadMode(SaveMode mode);

  static auto getLoadMode() -> SaveMode;

  static void mountPack(std::string_view scheme, const std::filesystem::path& pak_path);
 
private:
  static inline AssetManager* instance = nullptr;
 
  static inline SaveMode load_mode = SaveMode::editor;
 
  static inline std::unordered_map<std::string, std::unique_ptr<PackArchive>> mounts;
 
  event::Listener listener;
  mutable std::mutex mutex;
  std::unordered_map<uint64_t, AssetInfo> manifest;
  std::unordered_map<uint64_t, std::unique_ptr<Asset>> cache;
  std::unordered_map<uint64_t, std::filesystem::file_time_type> asset_mtimes;
  std::unordered_set<uint64_t> pending_reloads;
  std::vector<std::unique_ptr<Asset>> retired_assets;

  auto createAsset(const AssetInfo& info, std::vector<uint8_t>& raw_data) -> std::unique_ptr<Asset>;
 
  static inline std::unordered_map<std::string, std::filesystem::path> roots;
 
  auto resolveVirtualPath(std::string_view virtual_path) -> std::optional<std::filesystem::path>;
  auto readVirtualPath(std::string_view virtual_path) -> std::optional<std::vector<uint8_t>>;
  auto openFile(const std::filesystem::path& path) -> std::optional<std::vector<uint8_t>>;
  auto saveFile(const std::filesystem::path& path, const std::vector<uint8_t>& data) -> bool;
};
 
}