texManager.h

#pragma once
 
#ifndef _texManager_H_
#include<map>
#include<unordered_map>
#include"../../source/rendering/texture.h"
 
 
namespace Aire
{
    using TexMap = std::map<ResourceHandle, TexturePtr>;
    using TexNameMap = std::unordered_map<string, TexturePtr>;
 
    using CubeMapHash = std::map<ResourceHandle, CubeMapPtr>;
    using CubeMapNameHash = std::unordered_map<string, CubeMapPtr>;
 
    using ImagePointer = unsigned char*;
 
    class TextureManager {
    
    private:
        TexMap texMap;
        TexNameMap texNameMap;
        TextureManager();
        CubeMapHash cubeMapHash;
        CubeMapNameHash  cubeMapNameHash;
 
    public:
        //singleton pattern
        TextureManager(const TextureManager&) = delete;
        TextureManager& operator=(const TextureManager&) = delete;
        static TextureManager& get_instance() {
            static TextureManager instance;
            return instance;
        }
        ~TextureManager();
 
         TextureHandle createTextureByImage(const char* filename,bool flipped);
 
         struct CubemapFaces {
             const char* filename;
             bool flipped;
         };
 
         CubeMapHandle createCubeMapByImage(const std::vector<CubemapFaces> cubemapFaces, std::string cubeMapName);
 
        GLuint createTextureInGpu(std::string name, 
            int xOffset,
            int yOffset,
            GLenum format = GL_RGBA,
            GLenum type = GL_UNSIGNED_BYTE,
            int level = 0);
 
        GLuint createTextureInGpu(TexturePtr const&,
            int xOffset = 0,
            int yOffset = 0,
            GLenum format = GL_RGBA,
            GLenum type = GL_UNSIGNED_BYTE,
            int level = 0);
 
        void createCubeMapInGpu(CubeMapPtr const&);
 
        void removeTextureInGpu(std::string name,bool isCubeMap);
 
        void removeTextureInGpu(TexturePtr const&);
 
 
        //additional
        
        void freeTextureInCpu(const TextureHandle& handle);
 
        void freeTextureInCpu(const std::string & name);
 
        void freeTextureInCpu(const TexturePtr& tpr);
 
 
        void freeCubeMapInCpu(const std::string& name);
 
        void freeCubeMapInCpu(const CubeMapHandle& handle);
 
        void freeCubeMapInCpu(const CubeMapPtr& cpr);
 
        void freeAllDataInCpu();
 
        TexturePtr getTexturePtr(TextureHandle h);
 
        TexturePtr getTexturePtrByName(std::string name);
 
        CubeMapPtr getCubeMapPtr(CubeMapHandle h);
 
        CubeMapPtr getCubeMapPtrByName(std::string name);
 
        bool isloaded(std::string path);
 
        TextureHandle getTexturePtrByPath(std::string path);
 
    };
 
    inline TextureManager::TextureManager()
    {
    }
}
 
#endif // !_texManager_H_