ResourceManager.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "Resource.hpp"
#include "ResourceHandle.hpp"
#include "Importer/ResourceImportOptions.hpp"
#include "Importer/ResourceImporterRegistry.hpp"
 
#include "CeresEngine/Foundation/Async.hpp"
#include "CeresEngine/Foundation/UUID.hpp"
#include "CeresEngine/Foundation/Container/List.hpp"
#include "CeresEngine/Foundation/IO/Stream.hpp"
#include "CeresEngine/Foundation/IO/URLSession.hpp"
#include "CeresEngine/Foundation/Threading/Threading.hpp"
 
#include "CeresEngine/Serialization/Serialization.hpp"
 
namespace CeresEngine {
 
    class URLSession;
 
    struct ResourceLoadOptions {
        Optional<ResourceID> resourceID;
    };
 
    struct ResourceSaveOptions {
 
    };
 
    class ResourceManager final {
        friend class PackageManager;
 
    private:
        URLSession& mURLSession;
 
        ExecutionContext& mExecutionContext;
 
        const SerializationContext& mSerializationContext;
 
        PackageManager* mPackageManager = nullptr;
 
    private:
        LockedObject<HashMap<UUID, ResourceHandleData*>> mResourceHandles;
 
        ResourceURL mBaseURL;
 
        struct LoadedResource;
 
        using LoadedResourceMap = HashMap<UUID, LoadedResource>;
 
        LockedObject<LoadedResourceMap> mResources;
 
        struct LoadingResource;
 
        using LoadingResourcesList = List<LoadingResource>;
 
        LockedObject<LoadingResourcesList> mLoadingResources;
 
        struct SavingResource;
 
        using SavingResourcesList = List<SavingResource>;
 
        LockedObject<SavingResourcesList> mSavingResources;
 
        struct ImportingResource;
 
        using ImportingResourcesList = List<ImportingResource>;
 
        LockedObject<ImportingResourcesList> mImportingResources;
 
    public:
        ResourceImporterRegistry importers;
 
    public:
        ResourceManager(URLSession& urlSession, ExecutionContext& executionContext, const SerializationContext& serializationContext = SerializationContext::getDefault());
 
        ~ResourceManager();
 
    public: // Resource Getting (without loading)
        template<typename T> [[nodiscard]] ResourceHandle<T> getResource(const StringView name) { return static_resource_cast<T>(getResource(name)); }
 
        template<typename T> [[nodiscard]] ResourceHandle<T> getResource(const UUID& uuid) { return static_resource_cast<T>(getResource(uuid)); }
 
        [[nodiscard]] HResource getResource(StringView name);
 
        [[nodiscard]] HResource getResource(const UUID& uuid);
 
    public: // Resource Locating
        template<typename T> [[nodiscard]] Async<ResourceHandle<T>> locate(const StringView name) {
            return locate(name) | [](HResource&& resource) {
                return static_resource_cast<T>(resource);
            };
        }
 
        [[nodiscard]] Async<HResource> locate(StringView name);
 
    public: // Resource Loading & Saving
        template<typename T> [[nodiscard]] Async<ResourceHandle<T>> load(const ResourceURL url, const Optional<ResourceID> resourceID = {}) {
            return load(url, resourceID) | [](HResource&& resource) {
                return static_resource_cast<T>(resource);
            };
        }
 
        template<typename T> [[nodiscard]] Async<ResourceHandle<T>> load(const ResourceID id) {
            return load(id) | [](HResource&& resource) {
                return static_resource_cast<T>(resource);
            };
        }
 
        template<typename T> [[nodiscard]] Async<ResourceHandle<T>> load(InputStream inputStream, const Optional<ResourceID> resourceID = {}) {
            return load(std::move(inputStream), resourceID) | [](HResource&& resource) {
                return static_resource_cast<T>(resource);
            };
        }
 
        [[nodiscard]] Async<HResource> load(ResourceURL url, Optional<ResourceID> resourceID = {});
 
        [[nodiscard]] Async<HResource> load(ResourceID id);
 
        [[nodiscard]] Async<HResource> load(InputStream inputStream, Optional<ResourceID> resourceID = {});
 
        [[nodiscard]] Async<> save(ResourceURL url, HResource resource);
 
        [[nodiscard]] Async<> save(OutputStream outputStream, HResource resource);
 
    public: // Resource Creation & Replacement
        template<typename T, typename... Args> [[nodiscard]] ResourceHandle<T> create(Args&&... args) {
            const ResourceDataPtr resourceData = createResourceData();
            return static_resource_cast<T>(createInternal(*resourceData, constructResource<T>(*resourceData, std::forward<Args>(args)...)));
        }
 
        [[nodiscard]] HResource create(const ResourcePtr& resource) { return create(ResourcePtr(resource)); }
 
        [[nodiscard]] HResource create(ResourcePtr&& resourcePtr);
 
        template<typename T, typename... Args> [[nodiscard]] ResourceHandle<T> createWithID(const UUID& uuid, Args&&... args) {
            if constexpr(std::is_constructible_v<T, ResourceData&, Args...>) {
                const ResourceDataPtr resourceData = createResourceData();
                return static_resource_cast<T>(createWithID(uuid, ce_shared_new<T>(*resourceData, std::forward<Args>(args)...)));
            } else {
                return static_resource_cast<T>(createWithID(uuid, ce_shared_new<T>(std::forward<Args>(args)...)));
            }
        }
 
        [[nodiscard]] HResource createWithID(const UUID& uuid, const ResourcePtr& resource) { return createWithID(uuid, ResourcePtr(resource)); }
 
        [[nodiscard]] HResource createWithID(const UUID& uuid, ResourcePtr&& resourcePtr);
 
    public: // Resource Importing
        template<typename T> [[nodiscard]] Async<ResourceHandle<T>> import(const ResourceURL url, UPtr<ResourceImportOptions>&& importOptions = nullptr) {
            return import(url, std::move(importOptions)) | [](HResource&& resource) {
                return static_resource_cast<T>(resource);
            };
        }
 
        [[nodiscard]] Async<HResource> import(ResourceURL url, UPtr<ResourceImportOptions>&& importOptions = nullptr);
 
    public:
        [[nodiscard]] const ResourceURL& getBaseURL() const noexcept { return mBaseURL; }
 
        void setBaseURL(const ResourceURL& baseURL);
 
        [[nodiscard]] URLSession& getURLSession() const noexcept { return mURLSession; }
 
        [[nodiscard]] ExecutionContext& getExecutionContext() const noexcept { return mExecutionContext; }
 
        [[nodiscard]] PackageManager* getPackageManager() const noexcept { return mPackageManager; }
 
    private:
        HResource createInternal(ResourceData& resourceData, ResourcePtr&& resource);
 
    private: // ResourceData interface
        friend class ResourceData;
 
        ResourceDataPtr createResourceData(const UUID& uuid = UUID());
 
    private:
        friend class ResourceHandleData;
 
        void notifyStrongHandleDestroy(ResourceHandleData* resourceHandleData);
 
        void notifyHandleDestroy(const ResourceHandleData* resourceHandleData);
    };
 
} // namespace CeresEngine