ResourceManager.h

#pragma once
 
#include "IResourceLoader.h"
#include "IResourceManager.h"
#include "ResourceManagerBase.h"
#include "ResourceProxy.h"
 
#include "../Engine.h"
#include "../EntityDefinition.h"
#include "../MemoryContext.h"
 
#include "Foundation/Collections/Pool.h"
#include "Foundation/Platform/Threads.h"
 
#include <deque>
 
namespace Cogs
{
  namespace Core
  {
    class Context;
 
    constexpr ResourceTypes getResourceType(const ResourceBase *) { return ResourceTypes::Unknown; }
    constexpr ResourceTypes getResourceType(const Asset *) { return ResourceTypes::Asset; }
    constexpr ResourceTypes getResourceType(const Model *) { return ResourceTypes::Model; }
    constexpr ResourceTypes getResourceType(const Texture *) { return ResourceTypes::Texture; }
    constexpr ResourceTypes getResourceType(const Effect *) { return ResourceTypes::Effect; }
    constexpr ResourceTypes getResourceType(const Material *) { return ResourceTypes::Material; }
    constexpr ResourceTypes getResourceType(const MaterialInstance *) { return ResourceTypes::MaterialInstance; }
    constexpr ResourceTypes getResourceType(const BufferResource *) { return ResourceTypes::Buffer; }
    constexpr ResourceTypes getResourceType(const Mesh *) { return ResourceTypes::Mesh; }
    constexpr ResourceTypes getResourceType(const Font *) { return ResourceTypes::Font; }
    // GuiDocument omitted.
 
    class IValueTypeManager
    {
    public:
      virtual bool doesManage(DefaultValueType valueType) = 0;
 
      virtual void readSource(Context* ctx, ResourceDefinition& definition, const void* jsonResource) = 0;
 
      virtual void applyFieldValue(void* object, const Reflection::Field* field, const FieldValue& fieldValue) = 0;
 
    };
    class IBlueNoiseManager
    {
    public:
      virtual void enable() = 0;
 
      virtual BlueNoiseHandle getBlueNoiseHandle(bool stable) = 0;
    };
 
 
    template<typename ResourceType, typename LoadInfoType>
    class ResourceManager : public ResourceManagerBase
    {
    public:
      using ResourceHandle = ResourceHandle_t<ResourceType>;
 
      using ResourceProxy = ResourceProxy<ResourceType, ResourceManager>;
 
      struct SwapOperation
      {
        SwapOperation() = default;
        SwapOperation(ResourceHandle destinationHandle, ResourceHandle source) : destinationHandle(destinationHandle), source(source) {}
        SwapOperation(const SwapOperation & other) = delete;
        SwapOperation(SwapOperation && other) = default;
 
        ResourceHandle destinationHandle;
 
        ResourceHandle source;
      };
 
      ResourceManager(Context * context, Collections::ElementOffset capacity = 1024) :
        ResourceManagerBase(context),
        resources(capacity, capacity, context->memory->resourceAllocator, MemBlockType::ResourceManager),
        loadInfos(128, 128, context->memory->resourceAllocator, MemBlockType::ResourceManager)
      {
        resourceType = getResourceType(static_cast<const ResourceType*>(nullptr));
      }
 
      ~ResourceManager() override
      {
        for (auto & loader : loaders) {
          assert(loader);
          delete loader;
          loader = nullptr;
        }
        loaders.clear();
      }
 
      void clear() override
      {
        defaultResource = ResourceHandle();
 
        ResourceManagerBase::clear();
      }
 
      void clearSwapping() override
      {
        LockGuard swapLock(swapMutex);
 
        swapQueue.clear();
      }
 
      ResourceHandle create()
      {
        return ResourceHandle(createResource());
      }
 
      /*
       * Releases the resource handle, e.g. remove access to the resource using the resource ID.
       * The resource will not be deleted until all ResourceHandle instances are released.
       * \param resourceId Resource handle to be released.
       * \returns actual handle. Should only be used to check if the resourceId was found, e.g. valid handle returned.
       */
      ResourceHandle release(ResourceId resourceId)
      {
        return releaseInternal(resourceId);
      }
 
      ResourceHandle loadResource(LoadInfoType * loadInfo)
      {
        return loadResourceInternal(loadInfo);
      }
 
    protected:
      ResourceType * createInternal() override
      {
        return resources.create();
      }
 
      void destroyInternal(ResourceBase * resource) override
      {
        resources.destroy(static_cast<ResourceType *>(resource));
      }
 
    private:
      void destroyInternalLocked(ResourceBase * resource) override
      {
        resources.destroy(static_cast<ResourceType *>(resource));
      }
 
    protected:
      void handleLoadInternal(ResourceLoadInfoBase * loadInfo) override
      {
        handleLoad(static_cast<LoadInfoType *>(loadInfo));
      }
 
      ActivationResult handleActivationInternal(ResourceHandleBase r, ResourceBase * resource) override
      {
        return handleActivation(r, static_cast<ResourceType *>(resource));
      }
 
      void handleDeletionInternal(ResourceBase * resource) override
      {
        handleDeletion(static_cast<ResourceType *>(resource));
      }
 
      void handleFailedLoadInternal(ResourceLoadInfoBase * loadInfo) override
      {
        handleFailedLoad(static_cast<LoadInfoType *>(loadInfo));
      }
 
    public:
      ResourceProxy createLocked()
      {
        auto handle = create();
 
        return lock(handle);
      }
 
      ResourceProxy lock(const ResourceHandle & handle)
      {
        auto proxy = create();
        proxy->setProxy();
        return ResourceProxy(*this, handle, proxy);
      }
 
      void unlockProxy(const ResourceHandle & handle, const ResourceHandle & proxy)
      {
        LockGuard swapLock(swapMutex);
 
        swapQueue.emplace_back(handle, proxy);
      }
 
      inline ResourceHandle generateHandle(ResourceBase * resource)
      {
        return ResourceHandle(resource);
      }
 
      virtual void handleLoad(LoadInfoType * /*loadInfo*/) {}
 
      virtual void handleFailedLoad(const LoadInfoType * /*loadInfo*/) {}
 
      virtual ActivationResult handleActivation(ResourceHandle /*handle*/, ResourceType * /*resource*/) { return ActivationResult::Success; }
 
      virtual void handleDeletion(ResourceType * /*resource*/) {}
 
      ResourceType * get(const ResourceHandleBase & handle)
      {
        if (!HandleIsValid(handle) && !handle.get()) {
          return static_cast<ResourceType*>(defaultResource.get());
        }
 
        return const_cast<ResourceType *>(static_cast<const ResourceType*>(handle.get()));
      }
 
      void processSwapping() override
      {
        LockGuard swapLock(swapMutex);
 
        for (auto & swapResource : swapQueue) {
          auto source = swapResource.source.resolve();
          auto destination = swapResource.destinationHandle.resolve();
 
          assert(source && "Source resource for swap cannot be null.");
          assert(destination && "Destination resource for swap cannot be null.");
 
          *destination = std::move(*swapResource.source.resolve());
          destination->setLoaded();
          destination->setChanged();
          context->engine->setDirty();
        }
 
        swapQueue.clear();
      }
 
      ResourceHandle getHandle(const ResourceId id) const
      {
        return getResourceHandle(id);
      }
 
      void registerLoader(IResourceLoader<ResourceType, LoadInfoType> * loader)
      {
        loaders.push_back(loader);
      }
 
      void destroyLoadInfoInternal(ResourceLoadInfoBase * loadInfo) override
      {
        LockGuard lock(loadInfoMutex);
 
        loadInfos.destroy(static_cast<LoadInfoType *>(loadInfo));
      }
 
      LoadInfoType * createLoadInfo()
      {
        LockGuard lock(loadInfoMutex);
 
        return loadInfos.create();
      }
 
    protected:
      IResourceLoader<ResourceType, LoadInfoType> * findLoader(const LoadInfoType * loadInfo)
      {
        for (auto loader : loaders) {
          if (loader->canLoad(context, *loadInfo)) {
            return loader;
          }
        }
 
        return nullptr;
      }
 
      Mutex swapMutex;
 
      Collections::Pool<ResourceType> resources;
 
      std::vector<IResourceLoader<ResourceType, LoadInfoType> *> loaders;
 
      std::deque<SwapOperation> swapQueue;
 
      ResourceHandle defaultResource;
 
    private:
      Mutex loadInfoMutex;
      Collections::Pool<LoadInfoType> loadInfos;
    };
 
  }
}