texture_manager.h

#ifndef OE_RENDER_TEXTURE_MANAGER_H
#define OE_RENDER_TEXTURE_MANAGER_H
 
#include "texture.h"
#include "cubemap.h"
 
#include <map>
#include <memory>
#include <string>
#include <glm/vec3.hpp>
 
namespace oe::io
{
    class FileSystem;
}
 
namespace oe::render
{
    struct CheckerboardTextureInfo
    {
        glm::vec3 color1 = glm::vec3(0.0f, 0.0f, 0.0f);
 
        glm::vec3 color2 = glm::vec3(1.0f, 0.0f, 1.0f);
    };
 
    struct TextureManagerCreateInfo
    {
        CheckerboardTextureInfo default_texture_info;
    };
 
    class Shader;
 
    class TextureManager
    {
        public:
            TextureManager(const TextureManagerCreateInfo& = {});
 
            const Texture* getDefaultTexture() const
            {
                return &_dummy_texture;
            }
 
            Texture* getDefaultTexture()
            {
                return &_dummy_texture;
            }
 
            bool hasTexture(const std::string& name) const;
 
            const Texture* getTexture(const std::string& name) const;
 
            Texture* getTexture(const std::string& name);
 
            template <typename T = Texture, typename... Args>
            Texture* registerTexture(const std::string& name, Args&&... args)
            {
                if (name.length() == 0)
                {
                    throw std::invalid_argument("Texture name is missing!");
                }
 
                if (hasTexture(name))
                {
                    throw std::invalid_argument("Texture " + name + "already exists!");
                }
 
                _textures[name] = std::make_unique<T>(std::forward<Args>(args)...);
 
                return _textures[name].get();
            }
 
            bool removeTexture(const std::string& name);
 
            bool hasCubemap(const std::string& name) const;
 
            const Cubemap* getCubemap(const std::string& name) const;
 
            Cubemap* getCubemap(const std::string& name);
 
            const Cubemap* getDefaultCubemap() const
            {
                return &_dummy_cubemap;
            }
 
            Cubemap* getDefaultCubemap()
            {
                return &_dummy_cubemap;
            }
 
            template <typename T = Cubemap, typename... Args>
            Cubemap* registerCubemap(const std::string& name, Args&&... args)
            {
                if (name.length() == 0)
                {
                    throw std::invalid_argument("Cubemap name is missing!");
                }
 
                if (hasCubemap(name))
                {
                    throw std::invalid_argument("Cubemap " + name + "already exists!");
                }
 
                _cubemaps[name] = std::make_unique<T>(std::forward<Args>(args)...);
 
                return _cubemaps[name].get();
            }
 
            bool removeCubemap(const std::string& name);
 
            static void setVerticalFlipOnLoad(const bool flip);
 
        private:
            Texture _dummy_texture;
            Cubemap _dummy_cubemap;
 
            std::map<std::string, std::unique_ptr<Texture>> _textures;
            std::map<std::string, std::unique_ptr<Cubemap>> _cubemaps;
    };
}
 
#endif