ModelManager.h

#pragma once
 
#include <memory>
#include <map>
#include <queue>
#include <thread>
 
#include "ResourceManager.h"
#include "DataFetcherManager.h"
 
#include "Model.h"
#include "Mesh.h"
 
#include "IModelLoader.h"
 
namespace Cogs
{
  class IGraphicsDevice;
 
  namespace Core
  {
    class COGSCORE_DLL_API ModelManager : public ResourceManager<Model, ModelLoadInfo>
    {
    public:
      ModelManager(Context * context);
      
      ~ModelManager();
 
      ModelHandle loadModel(const StringView & resourceName, ResourceId resourceId, ModelLoadFlags flags);
 
      void cancelModelLoad(ModelHandle handle);
 
      void handleLoad(ModelLoadInfo * loadInfo) override;
 
      void handleReload(ResourceHandleBase handle) override;
 
      void processDeletion() override;
 
      void handleDeletion(Model * model) override;
 
      void destroyInternal(ResourceBase * resource) override;
 
    protected:
 
      void postProcessLoading() override final;
 
    private:
      std::thread::id main;
 
      // Process a fetch data blob. Returns true if it was actually processed.
      bool processFetchedItem(ILoadedModelLoader* loadedLoader, ModelLoadInfo* loadInfo, std::unique_ptr<FileContents> data);
 
      std::unique_ptr<struct ModelManagerData> data;
 
      struct FetchedItem {
        std::unique_ptr<FileContents> data;
        ModelLoadInfo* loadInfo = nullptr;
        ILoadedModelLoader* 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;
 
 
    };
  }
}