material.h

#ifndef OE_SCENE_MATERIAL_H
#define OE_SCENE_MATERIAL_H
 
#include <vector>
#include <string>
#include <map>
#include <glm/mat4x4.hpp>
 
namespace oe::render
{
    class Texture;
    class ShaderBase;
}
 
namespace oe::scene
{
    struct TextureProperty
    {
        std::string name;
 
        render::Texture* texture = nullptr;
    };
 
    struct TextureCoordinatesTransform
    {
        glm::vec2 tiling = glm::vec2(1.f);
 
        glm::vec2 offset = glm::vec2(0.f);
    };
 
    struct TransmissiveProperties
    {
        float transmission = 0.0f;
 
        float thickness = 0.0f;
 
        float attenuation_distance = 0.0f;
        glm::vec3 attenuation_color = glm::vec3(1.0f);
    };
 
    class Material
    {
        public:
            std::vector<TextureProperty> textures;
 
            TextureCoordinatesTransform texture_coordinates_0;
 
            TextureCoordinatesTransform texture_coordinates_1;
 
            uint32_t flags = 0;
 
            oe::render::ShaderBase* shader = nullptr;
 
            bool double_sided = false;
 
            bool invert_faces = false;
 
            bool is_blend = false;
 
            TransmissiveProperties transmissive_properties;
 
            float alpha_threshold = 0.5f;
 
            Material* parent = nullptr;
 
            bool inherit_properties = false;
 
            bool inherit_textures = false;
 
            /*
             * @brief Set Texture at specified layer
             *
             * @param name Texture uniform name
             * @param texture texture pointer
             * @param layer layer (set to -1 to use the next available)
             */
            void setTexture(const std::string& name, render::Texture* texture/*, const int32_t layer = -1*/)
            {
                textures.push_back(
                {
                    .name = name,
                    .texture = texture
                });
            }
 
            /*
             * @brief Get Texture stored at specified layer
             */
            //std::shared_ptr<oe::render::Texture> getTexture(const uint32_t& layer) const noexcept;
 
            uint32_t getNextAvailableTextureLayer(const uint32_t start = 0) const;
 
            /*const auto& getTextures() const
            {
                return _textures;
            }*/
 
            template <typename T>
            Material* setProperty(const std::string& name, const T& value) = delete;
 
            template <typename T>
            Material* setArray(const std::string& name, const std::vector<T>& value) = delete;
 
        private:
            // todo for _textures : std::map<std::pair<TextureSettings, share<Texture>>
            // TextureSettings would contain (among others?): scale, offset and rot
            // todo² : see how to populate
            //std::map<std::string, std::pair<uint32_t, std::shared_ptr<oe::render::Texture>>> _textures;
            //std::map<uint32_t, std::shared_ptr<oe::render::Texture>> _textures_layers;
 
            friend class oe::render::ShaderBase;
 
            // Generate all material's properties containers
            #define OE_ENGINE_SCENE_MATERIAL_GENERATE_PROPERTY(TYPE, PROPERTY) \
                std::map<const std::string, TYPE> _prop_ ## PROPERTY; \
                std::map<const std::string, std::vector<TYPE>> _prop_ ## PROPERTY ## _arrays; \
 
                OE_ENGINE_SCENE_MATERIAL_GENERATE_PROPERTY(bool, bool)
                OE_ENGINE_SCENE_MATERIAL_GENERATE_PROPERTY(int32_t, int32_t)
                OE_ENGINE_SCENE_MATERIAL_GENERATE_PROPERTY(uint32_t, uint32_t)
                OE_ENGINE_SCENE_MATERIAL_GENERATE_PROPERTY(float, float)
                OE_ENGINE_SCENE_MATERIAL_GENERATE_PROPERTY(double, double)
                OE_ENGINE_SCENE_MATERIAL_GENERATE_PROPERTY(glm::ivec2, ivec2)
                OE_ENGINE_SCENE_MATERIAL_GENERATE_PROPERTY(glm::vec2, vec2)
                OE_ENGINE_SCENE_MATERIAL_GENERATE_PROPERTY(glm::vec3, vec3)
                OE_ENGINE_SCENE_MATERIAL_GENERATE_PROPERTY(glm::vec4, vec4)
                OE_ENGINE_SCENE_MATERIAL_GENERATE_PROPERTY(glm::mat4, mat4)
 
            #undef OE_ENGINE_SCENE_MATERIAL_GENERATE_PROPERTY
    };
 
    #define OE_ENGINE_SCENE_MATERIAL_GENERATE_SETTER(TYPE, PROPERTY) \
        template <> inline Material* Material::setProperty(const std::string& name, const TYPE& value) \
        { \
            _prop_ ## PROPERTY[name] = value; \
            return this; \
        } \
        template <> inline Material* Material::setArray(const std::string& name, const std::vector<TYPE>& value) \
        { \
            _prop_ ## PROPERTY ## _arrays[name] = value; \
            return this; \
        }
 
        OE_ENGINE_SCENE_MATERIAL_GENERATE_SETTER(int32_t, int32_t)
        OE_ENGINE_SCENE_MATERIAL_GENERATE_SETTER(uint32_t, uint32_t)
        OE_ENGINE_SCENE_MATERIAL_GENERATE_SETTER(float, float)
        OE_ENGINE_SCENE_MATERIAL_GENERATE_SETTER(double, double)
        OE_ENGINE_SCENE_MATERIAL_GENERATE_SETTER(glm::ivec2, ivec2)
        OE_ENGINE_SCENE_MATERIAL_GENERATE_SETTER(glm::vec2, vec2)
        OE_ENGINE_SCENE_MATERIAL_GENERATE_SETTER(glm::vec3, vec3)
        OE_ENGINE_SCENE_MATERIAL_GENERATE_SETTER(glm::vec4, vec4)
        OE_ENGINE_SCENE_MATERIAL_GENERATE_SETTER(glm::mat4, mat4)
 
        template <> inline Material* Material::setProperty(const std::string& name, const size_t& value)
        {
            return setProperty<int32_t>(name, value);
        }
 
        // Bool specialization, should be treated as an int
        template <> inline Material* Material::setProperty(const std::string& name, const bool& value)
        {
            return setProperty<uint32_t>(name, value);
        }
 
        template <> inline Material* Material::setArray(const std::string& name, const std::vector<bool>& values)
        {
            std::vector<uint32_t> result(values.begin(), values.end());
            return setArray<uint32_t>(name, result);
        }
 
    #undef OE_ENGINE_SCENE_MATERIAL_GENERATE_SETTER
}
 
#endif