material.h

#ifndef OE_SCENE_MATERIAL_H
#define OE_SCENE_MATERIAL_H
 
#include "../common.h"
 
#include <memory>
#include <vector>
#include <string>
#include <map>
#include <glm/mat4x4.hpp>
 
namespace oe::render
{
    class Texture;
    class ShaderBase;
}
 
namespace oe::scene
{
    class Material
    {
        public:
            enum class DrawMode : uint8_t
            {
                TRIANGLES = 0x04,
 
                TRIANGLE_STRIP = 0x05,
 
                TRIANGLE_FAN = 0x06,
 
                POINTS = 0x00,
 
                LINES = 0x01,
            };
 
            struct TransmissiveProperties
            {
                float transmission = 0.0f;
 
                float thickness = 0.0f;
 
                float attenuation_distance = 0.0f;
                glm::vec3 attenuation_color = glm::vec3(1.0f);
            };
 
            DrawMode draw_mode = DrawMode::TRIANGLES;
 
            uint32_t flags = 0;
 
            std::shared_ptr<oe::render::ShaderBase> shader = nullptr;
 
            bool double_sided = false;
 
            bool invert_faces = false;
 
            glm::vec2 texture_tiling = glm::vec2(1.f);
 
            glm::vec2 texture_offset = glm::vec2(0.f);
 
            bool is_blend = false;
 
            TransmissiveProperties transmissive_properties;
 
            float alpha_threshold = 0.5f;
 
            Material* parent = nullptr;
 
            bool inherit_properties = false;
 
            bool inherit_textures = false;
 
            void setTexture(const std::string& name, std::shared_ptr<oe::render::Texture> texture, const int32_t layer = -1);
 
            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
    };
 
    struct PbrMaterial
    {
        glm::vec4 albedoColor = glm::vec4(1.0);
 
        glm::vec3 emissiveColor = glm::vec4(1.0);
 
        glm::vec3 rouMetAoColor = glm::vec3(1.0);
 
        std::shared_ptr<oe::render::Texture> albedoTexture;
 
        std::shared_ptr<oe::render::Texture> emissiveTexture;
 
        std::shared_ptr<oe::render::Texture> normalTexture;
 
        std::shared_ptr<oe::render::Texture> rouMetAoTexture;
    };
 
    #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