ResourcesManager.hpp

#pragma once
 
#include "graphics/GPUTypes.hpp"
#include "graphics/Program.hpp"
#include "resources/Font.hpp"
#include "resources/Mesh.hpp"
#include "Common.hpp"
 
 
enum class Storage : uint {
    NONE = 0,
    GPU  = 1,          
    CPU  = 2,          
    BOTH = (GPU | CPU), 
    FORCE_FRAME = 4 
};
 
inline Storage operator|(Storage t0, Storage t1) {
    return static_cast<Storage>(static_cast<uint>(t0) | static_cast<uint>(t1));
}
 
inline bool operator&(Storage t0, Storage t1) {
    return bool(static_cast<uint>(t0) & static_cast<uint>(t1));
}
 
using Data = std::vector<char>;
 
class Resources {
 
    friend class Image;
 
public:
    static Resources & manager();
 
    void addResources(const std::string & path);
 
    void reload();
 
    void clean();
 
    Resources & operator=(const Resources &) = delete;
 
    Resources(const Resources &) = delete;
 
    Resources & operator=(Resources &&) = delete;
 
    Resources(Resources &&) = delete;
 
private:
    Resources() = default;
 
    void parseArchive(const std::string & archivePath);
 
    void parseDirectory(const std::string & directoryPath);
 
    std::string getImagePath(const std::string & name);
 
    std::vector<std::string> getCubemapPaths(const std::string & name);
 
    std::vector<std::string> getLayeredPaths(const std::string & name, const std::string & suffix);
 
    char * getRawData(const std::string & path, size_t & size);
 
public:
    std::string getString(const std::string & filename);
 
    std::string getStringWithIncludes(const std::string & filename, std::vector<std::string> & names);
 
    std::string getStringWithIncludes(const std::string& filename);
    
    const Mesh * getMesh(const std::string & name, Storage options);
 
    const Texture * getTexture(const std::string & name, const Layout & format, Storage options, const std::string & refName = "");
 
    const Texture * getTexture(const std::string & name);
 
    const Texture * getDefaultTexture(TextureShape shape);
 
    Program * getProgram(const std::string & name, const std::string & vertexName = "", const std::string & fragmentName= "", const std::string & tessControlName = "", const std::string & tessEvalName = "");
 
    Program * getProgram2D(const std::string & name);
 
    Program * getProgramCompute(const std::string & name);
 
    Font * getFont(const std::string & name);
 
    const Data * getData(const std::string & filename);
 
public:
 
    static char * loadRawDataFromExternalFile(const std::string & path, size_t & size);
 
    static std::string loadStringFromExternalFile(const std::string & path);
 
    static void saveRawDataToExternalFile(const std::string & path, char * rawContent, size_t size);
 
    static void saveStringToExternalFile(const std::string & path, const std::string & content);
 
    static bool externalFileExists(const std::string & path);
 
    struct FileInfos {
        std::string path; 
        std::string name; 
 
        FileInfos(const std::string& apath, const std::string& aname);
    };
 
    void getFiles(const std::string & extension, std::vector<FileInfos> & files) const;
 
private:
    ~Resources() = default;
 
    struct ProgramInfos {
        
        ProgramInfos(const std::string & vertex, const std::string & fragment, const std::string & tessControl, const std::string & tessEval);
 
        ProgramInfos(const std::string & compute);
 
        std::string vertexName; 
        std::string fragmentName; 
        std::string tessContName; 
        std::string tessEvalName; 
        std::string computeName; 
    };
 
    std::unordered_map<std::string, std::string> _files; 
    std::unordered_map<std::string, Texture> _textures;  
    std::unordered_map<std::string, Mesh> _meshes;     
    std::unordered_map<std::string, Font> _fonts;          
    std::unordered_map<std::string, Data> _blobs;      
    std::unordered_map<std::string, Program> _programs;  
    std::unordered_map<std::string, ProgramInfos> _progInfos;  
};