TextureManager.h

#pragma once
 
#include <map>
#include <queue>
#include <thread>
 
#include "ResourceManager.h"
 
#include "DataFetcherManager.h"
 
#include "Texture.h"
 
#include "ITextureLoader.h"
 
namespace Cogs
{
  namespace Core
  {
    class COGSCORE_DLL_API TextureManager : public ResourceManager<Texture, TextureLoadInfo>
    {
    public:
      TextureManager(Context * context) : ResourceManager(context) {}
 
      ~TextureManager();
 
      void initialize() override;
 
      void clear() override;
 
      TextureHandle loadTexture(const void * imageData, ResourceDimensions target, int width, int height, int depth, int layers, TextureFormat format, int stride, const ResourceId resourceId, TextureLoadFlags flags);
 
      void cancelTextureLoad(TextureHandle handle);
 
      TextureHandle loadTexture(const void * imageData, ResourceDimensions target, int width, int height, int depth, int layers, TextureFormat format, int stride, const TextureHandle& resourceHandle, TextureLoadFlags flags);
 
      template<typename RESOURCE>
      TextureHandle loadTexture2D(const void * imageData, int width, int height, TextureFormat format, int stride, RESOURCE resource, TextureLoadFlags flags) {
        return loadTexture(imageData, ResourceDimensions::Texture2D, width, height, 1, 1, format, stride, resource, flags);
      }
 
      TextureHandle loadExternalTexture(intptr_t externalHandle, ResourceDimensions target, int width, int height, int depth, int layers, TextureFormat format, const ResourceId resourceId, TextureLoadFlags flags);
 
      TextureHandle loadTexture(const StringView & resourceName, const ResourceId resourceId, TextureLoadFlags flags);
 
      TextureHandle loadTextureFromMemory(const void* dataPtr, const size_t dataSize, const StringView& resourcePath, const ResourceId resourceId, TextureLoadFlags flags);
 
      TextureHandle loadTexture(TextureLoadInfo * loadInfo);
 
      TextureHandle getTexture(const StringView & path, bool isQuery = false);
 
      void handleLoad(TextureLoadInfo * loadInfo) override;
 
      void handleReload(ResourceHandleBase handle) override;
 
      void loadFromData(TextureLoadInfo * loadInfo);
 
 
      ActivationResult handleActivation(TextureHandle handle, Texture * texture) override;
 
      void handleDeletion(Texture * texture) override;
 
      TextureHandle white = TextureHandle::NoHandle;
      TextureHandle whiteCube = TextureHandle::NoHandle;
 
    protected:
      void postProcessLoading() override final;
 
    private:
      std::thread::id main;
 
      bool invokeLoader(ITextureLoader* loader, TextureLoadInfo* loadInfo);
 
      bool invokeLoader(ILoadedTextureLoader* loadedLoader, TextureLoadInfo* loadInfo);
 
      // Process a fetch data blob. Returns true if it was actually processed.
      bool processFetchedItem(ILoadedTextureLoader* loadedLoader, TextureLoadInfo* loadInfo, std::unique_ptr<FileContents> data);
 
      struct FetchedItem {
        std::unique_ptr<FileContents> data;
        TextureLoadInfo* loadInfo = nullptr;
        ILoadedTextureLoader* loadedLoader = nullptr;
      };
 
      // Models that has been fetched, but has not yet had the loader run on it.
      std::queue<FetchedItem> fetchedItems;
 
      struct {
        Cogs::Mutex lock;
        std::map<size_t, DataFetcherManager::FetchId> map;
      } fetchIds;
 
      // Takes ownership of loadInfo and passes it to setProcessed eventually.
      void loadFromPath(TextureLoadInfo* loadInfo);
 
    };
  }
}