texture_manager.h

#ifndef OE_RENDER_TEXTURE_MANAGER_H
#define OE_RENDER_TEXTURE_MANAGER_H
 
#include "../common.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& = {});
 
            std::shared_ptr<Texture> getDefaultTexture() const
            {
                return _dummy_texture;
            }
 
            bool hasTexture(const std::string& name) const;
 
            std::shared_ptr<Texture> getTexture(const std::string& name) const;
 
            template <typename T = Texture, typename... Args>
            std::shared_ptr<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!");
                }
 
                std::shared_ptr<Texture> result = std::make_shared<T>(std::forward<Args>(args)...);
 
                if (result)
                {
                    _textures[name] = result;
                }
 
                return result;
            }
 
            bool removeTexture(const std::string& name);
 
            bool hasCubemap(const std::string& name) const;
 
            std::shared_ptr<Cubemap> getCubemap(const std::string& name) const;
 
            std::shared_ptr<Cubemap> getDefaultCubemap() const
            {
                return _dummy_cubemap;
            }
 
            template <typename T = Cubemap, typename... Args>
            std::shared_ptr<Cubemap> generateCubemap(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!");
                }
 
                std::shared_ptr<Cubemap> result = std::make_shared<T>(std::forward<Args>(args)...);
 
                if (result)
                {
                    _cubemaps[name] = result;
                }
 
                return result;
            }
 
            bool removeCubemap(const std::string& name);
 
            static void setVerticalFlipOnLoad(const bool flip);
 
        private:
            std::map<std::string, std::shared_ptr<Texture>> _textures;
            std::map<std::string, std::shared_ptr<Cubemap>> _cubemaps;
            std::shared_ptr<Texture> _dummy_texture;
            std::shared_ptr<Cubemap> _dummy_cubemap;
 
    };
}
 
#endif