ResourceManager.h

Go to the documentation of this file.

#pragma once
 
#include <unordered_map>
#include <unordered_set>
#include <string>
#include <list>
#include <vector>
#include <mutex>
#include <queue>
#include <variant>
#include "ship/resource/ResourceIdentifier.h"
#include "ship/resource/Resource.h"
#include "ship/resource/ResourceLoader.h"
#include "ship/resource/archive/Archive.h"
#include "ship/resource/archive/ArchiveManager.h"
#include "ship/core/Component.h"
#include "ship/thread/ThreadPool.h"
 
#define BS_THREAD_POOL_ENABLE_PRIORITY
#define BS_THREAD_POOL_ENABLE_PAUSE
#include <BS_thread_pool.hpp>
 
namespace Ship {
struct File;
class Keystore;
 
struct ResourceFilter {
    ResourceFilter(const std::list<std::string>& includeMasks, const std::list<std::string>& excludeMasks,
                   const uintptr_t owner, const std::shared_ptr<Archive> parent);
 
    const std::list<std::string> IncludeMasks;
    const std::list<std::string> ExcludeMasks;
    const uintptr_t Owner = 0;
    const std::shared_ptr<Archive> Parent = nullptr;
};
 
class ResourceManager : public Component {
    friend class ResourceLoader;
    typedef enum class ResourceLoadError { None, NotCached, NotFound } ResourceLoadError;
 
  public:
    explicit ResourceManager(std::shared_ptr<ThreadPool> threadPool = nullptr,
                             std::shared_ptr<Keystore> keystore = nullptr);
    ~ResourceManager();
 
    std::shared_ptr<ArchiveManager> GetArchiveManager();
    std::shared_ptr<ResourceLoader> GetResourceLoader();
 
    std::shared_ptr<IResource> GetCachedResource(const std::string& filePath, bool loadExact = false);
 
    std::shared_ptr<IResource> GetCachedResource(const ResourceIdentifier& identifier, bool loadExact = false);
 
    std::shared_ptr<IResource> LoadResource(const std::string& filePath, bool loadExact = false,
                                            std::shared_ptr<ResourceInitData> initData = nullptr);
 
    template <typename T>
    std::shared_ptr<T> LoadResource(const std::string& filePath, bool loadExact = false,
                                    std::shared_ptr<ResourceInitData> initData = nullptr) {
        return std::static_pointer_cast<T>(LoadResource(filePath, loadExact, std::move(initData)));
    }
 
    std::shared_ptr<IResource> LoadResource(const ResourceIdentifier& identifier, bool loadExact = false,
                                            std::shared_ptr<ResourceInitData> initData = nullptr);
 
    template <typename T>
    std::shared_ptr<T> LoadResource(const ResourceIdentifier& identifier, bool loadExact = false,
                                    std::shared_ptr<ResourceInitData> initData = nullptr) {
        return std::static_pointer_cast<T>(LoadResource(identifier, loadExact, std::move(initData)));
    }
 
    std::shared_ptr<IResource> LoadResource(uint64_t crc, bool loadExact = false,
                                            std::shared_ptr<ResourceInitData> initData = nullptr);
 
    std::shared_ptr<IResource> LoadResourceProcess(const std::string& filePath, bool loadExact = false,
                                                   std::shared_ptr<ResourceInitData> initData = nullptr);
 
    std::shared_ptr<IResource> LoadResourceProcess(const ResourceIdentifier& identifier, bool loadExact = false,
                                                   std::shared_ptr<ResourceInitData> initData = nullptr);
 
    std::shared_future<std::shared_ptr<IResource>>
    LoadResourceAsync(const std::string& filePath, bool loadExact = false, BS::priority_t priority = BS::pr::normal,
                      std::shared_ptr<ResourceInitData> initData = nullptr);
 
    std::shared_future<std::shared_ptr<IResource>>
    LoadResourceAsync(const ResourceIdentifier& identifier, bool loadExact = false,
                      BS::priority_t priority = BS::pr::normal, std::shared_ptr<ResourceInitData> initData = nullptr);
 
    size_t UnloadResource(const ResourceIdentifier& identifier);
 
    size_t UnloadResource(const std::string& filePath);
 
    bool WriteResource(const ResourceIdentifier& identifier, const std::vector<uint8_t>& data, bool unloadFile);
 
    bool WriteResource(uint64_t hash, const std::vector<uint8_t>& data, bool unloadFile);
 
    std::shared_ptr<std::vector<std::shared_ptr<IResource>>> LoadResources(const std::string& searchMask);
 
    std::shared_ptr<std::vector<std::shared_ptr<IResource>>> LoadResources(const ResourceFilter& filter);
 
    std::shared_future<std::shared_ptr<std::vector<std::shared_ptr<IResource>>>>
    LoadResourcesAsync(const std::string& searchMask, BS::priority_t priority = BS::pr::normal);
 
    std::shared_future<std::shared_ptr<std::vector<std::shared_ptr<IResource>>>>
    LoadResourcesAsync(const ResourceFilter& filter, BS::priority_t priority = BS::pr::normal);
 
    void DirtyResources(const std::string& searchMask);
 
    void DirtyResources(const ResourceFilter& filter);
 
    void UnloadResources(const std::string& searchMask);
 
    void UnloadResources(const ResourceFilter& filter);
 
    void UnloadResourcesAsync(const std::string& searchMask, BS::priority_t priority = BS::pr::normal);
 
    void UnloadResourcesAsync(const ResourceFilter& filter, BS::priority_t priority = BS::pr::normal);
 
    bool OtrSignatureCheck(const char* fileName);
 
    bool IsAltAssetsEnabled();
 
    void SetAltAssetsEnabled(bool isEnabled);
 
    std::shared_ptr<File> LoadFileProcess(const ResourceIdentifier& identifier);
 
    std::shared_ptr<File> LoadFileProcess(const std::string& filePath);
 
    std::shared_ptr<File> LoadFileProcess(uint64_t hash);
 
    size_t GetResourceSize(std::shared_ptr<IResource> resource);
 
    size_t GetResourceSize(const char* name);
 
    size_t GetResourceSize(uint64_t crc);
 
    bool GetResourceIsCustom(std::shared_ptr<IResource> resource);
 
    bool GetResourceIsCustom(const char* name);
 
    bool GetResourceIsCustom(uint64_t crc);
 
    void* GetResourceRawPointer(std::shared_ptr<IResource> resource);
 
    void* GetResourceRawPointer(const char* name);
 
    void* GetResourceRawPointer(uint64_t crc);
 
  protected:
    void OnInit(const nlohmann::json& initArgs = nlohmann::json::object()) override;
 
    std::shared_ptr<std::vector<std::shared_ptr<IResource>>> LoadResourcesProcess(const ResourceFilter& filter);
    void UnloadResourcesProcess(const ResourceFilter& filter);
    std::variant<ResourceLoadError, std::shared_ptr<IResource>> CheckCache(const ResourceIdentifier& identifier,
                                                                           bool loadExact = false);
    std::variant<ResourceLoadError, std::shared_ptr<IResource>> CheckCache(const std::string& filePath,
                                                                           bool loadExact = false);
 
    std::shared_ptr<IResource> GetCachedResource(std::variant<ResourceLoadError, std::shared_ptr<IResource>> cacheLine);
 
  private:
    std::unordered_map<ResourceIdentifier, std::variant<ResourceLoadError, std::shared_ptr<IResource>>,
                       ResourceIdentifierHash>
        mResourceCache;
    std::shared_ptr<ResourceLoader> mResourceLoader;
    std::shared_ptr<ArchiveManager> mArchiveManager;
    std::mutex mMutex;
    bool mAltAssetsEnabled = false;
    // Private information for which owner and archive are default.
    uintptr_t mDefaultCacheOwner = 0;
    std::shared_ptr<Archive> mDefaultCacheArchive = nullptr;
    std::shared_ptr<ThreadPool> mThreadPool;
    std::shared_ptr<Keystore> mKeystore;
 
    std::shared_ptr<ThreadPool> GetThreadPool();
};
} // namespace Ship