ResourceManager.hpp

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <string>
 
namespace Video {
class Renderer;
class LowLevelRenderer;
class Texture2D;
namespace Geometry {
class Rectangle;
}
} // namespace Video
namespace Geometry {
class Cube;
class Model;
} // namespace Geometry
 
class TextureAsset;
class ScriptFile;
 
class ResourceManager {
    friend class Hub;
 
  public:
 
    explicit ResourceManager(Video::Renderer* renderer);
 
    ~ResourceManager();
 
 
    Geometry::Model* CreateModel(const std::string& name);
 
 
    void FreeModel(Geometry::Model* model);
 
 
    Video::Texture2D* CreateTexture2D(const char* data, int dataLength);
 
 
    void FreeTexture2D(Video::Texture2D* texture);
 
 
    TextureAsset* CreateTextureAsset(const std::string& name);
 
 
    void FreeTextureAsset(TextureAsset* textureAsset);
 
 
    int GetTextureAssetInstanceCount(TextureAsset* textureAsset);
 
 
    ScriptFile* CreateScriptFile(const std::string& name);
 
 
    void FreeScriptFile(ScriptFile* scriptFile);
 
 
    TextureAsset* GetDefaultAlbedo();
 
 
    TextureAsset* GetDefaultNormal();
 
 
    TextureAsset* GetDefaultRoughnessMetallic();
 
  private:
    ResourceManager(ResourceManager const&) = delete;
    void operator=(ResourceManager const&) = delete;
 
    Video::LowLevelRenderer* lowLevelRenderer;
 
    // Rectangle
    Video::Geometry::Rectangle* rectangle = nullptr;
    int rectangleCount = 0;
 
    // Cube
    Geometry::Cube* cube = nullptr;
 
    int cubeCount = 0;
 
    // Model.
    struct ModelInstance {
        Geometry::Model* model;
        int count;
    };
    std::map<std::string, ModelInstance> models;
    std::map<Geometry::Model*, std::string> modelsInverse;
 
    // Texture2D.
    struct Texture2DInstance {
        Video::Texture2D* texture;
        int count;
    };
    std::map<const char*, Texture2DInstance> textures;
    std::map<Video::Texture2D*, const char*> texturesInverse;
 
    // Texture asset.
    struct TextureAssetInstance {
        TextureAsset* textureAsset;
        int count;
    };
    std::map<std::string, TextureAssetInstance> textureAssets;
    std::map<TextureAsset*, std::string> textureAssetsInverse;
 
    // ScriptFile.
    struct ScriptFileInstance {
        ScriptFile* scriptFile;
        int count;
    };
    std::map<std::string, ScriptFileInstance> scriptFiles;
    std::map<ScriptFile*, std::string> scriptFilesInverse;
 
    TextureAsset* defaultAlbedo;
    TextureAsset* defaultNormal;
    TextureAsset* defaultRoughnessMetallic;
};