MaterialData.h

Go to the documentation of this file.

#pragma once
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
 
#include "MaterialShader.h"
 
namespace EngineCore
{
    class MaterialData {
 
    };
 
    template<typename T>
    struct MaterialNameTrait;
 
#define TYPE_TRAIT_CLASS(name) \
    class name : public MaterialData \
 
#define TYPE_TRAIT(name, materialName) \
    template<> \
    struct MaterialNameTrait<name> { \
        static constexpr PipelineNames value = materialName; \
    }; \


    TYPE_TRAIT_CLASS(NormalMaterialData)
    {
    public:
        NormalMaterialData() : debug(false) {}
        explicit NormalMaterialData(bool debug) : debug(debug) {}

        bool getDebug() const { return debug; }
    private:
        bool debug;
    };
    TYPE_TRAIT(NormalMaterialData, PipelineNames::NORMALS_SHADER)
 
    
    TYPE_TRAIT_CLASS(DiffuseFlatColorMaterialData)
    {
    public:
        DiffuseFlatColorMaterialData() : color(glm::vec3(1, 0, 1)) {}
        explicit DiffuseFlatColorMaterialData(const glm::vec3 &color) : color(color) {}
 
        glm::vec3 getColor() const { return color; }
 
    private:
        glm::vec3 color;
    };
    TYPE_TRAIT(DiffuseFlatColorMaterialData, DIFFUSE_FLAT_COLOR)
 
    
    TYPE_TRAIT_CLASS(DiffuseShaderMaterialData)
    {
    public:
        DiffuseShaderMaterialData(uint32_t base_color_texture_index, const glm::vec4 &base_color_factor)
            : baseColorTextureIndex(base_color_texture_index),
              baseColorFactor(base_color_factor) {}
 
    private:
        uint32_t baseColorTextureIndex;
        glm::vec4 baseColorFactor;
    public:
        [[nodiscard]] uint32_t base_color_texture_index() const {
            return baseColorTextureIndex;
        }
 
        [[nodiscard]] glm::vec4 base_color_factor() const {
            return baseColorFactor;
        }
    };
    TYPE_TRAIT(DiffuseShaderMaterialData, PipelineNames::DIFFUSE_SHADER)
 
    
    TYPE_TRAIT_CLASS(MovableDiffuseShaderMaterialData)
    {
    public:
        // Default constructor with sensible defaults
        MovableDiffuseShaderMaterialData()
            : baseColorTextureIndex(0xFFFFFFFF),
              baseColorFactor(1.0f),
              sh_scale(0.15f),
              ambient_term(0.1f),
              debug_mode(0),
              tone_mapping(1),
              normalTextureIndex(0xFFFFFFFF),
              roughnessMetallicTextureIndex(0xFFFFFFFF),
              emissiveTextureIndex(0xFFFFFFFF),
              lightmapTextureIndex(0xFFFFFFFF),
              roughnessFactor(1.0f),
              metallicFactor(0.0f),
              normalScale(1.0f),
              emissiveFactor(0.0f) {
        }
 
        // Legacy constructor for backwards compatibility
        MovableDiffuseShaderMaterialData(uint32_t base_color_texture_index, const glm::vec4 &base_color_factor,
            float sh_scale, float ambient_term, uint32_t debug_mode, uint32_t tone_mapping)
            : baseColorTextureIndex(base_color_texture_index),
              baseColorFactor(base_color_factor),
              sh_scale(sh_scale),
              ambient_term(ambient_term),
              debug_mode(debug_mode),
              tone_mapping(tone_mapping),
              normalTextureIndex(0xFFFFFFFF),
              roughnessMetallicTextureIndex(0xFFFFFFFF),
              emissiveTextureIndex(0xFFFFFFFF),
              lightmapTextureIndex(0xFFFFFFFF),
              roughnessFactor(1.0f),
              metallicFactor(0.0f),
              normalScale(1.0f),
              emissiveFactor(0.0f) {
        }
 
        // Existing accessors
        [[nodiscard]] uint32_t base_color_texture_index() const { return baseColorTextureIndex; }
        [[nodiscard]] glm::vec4 base_color_factor() const { return baseColorFactor; }
        [[nodiscard]] float sh_scale1() const { return sh_scale; }
        [[nodiscard]] float ambient_term1() const { return ambient_term; }
        [[nodiscard]] uint32_t debug_mode1() const { return debug_mode; }
        [[nodiscard]] uint32_t tone_mapping1() const { return tone_mapping; }
 
        // PBR accessors
        [[nodiscard]] uint32_t normal_texture_index() const { return normalTextureIndex; }
        [[nodiscard]] uint32_t roughness_metallic_texture_index() const { return roughnessMetallicTextureIndex; }
        [[nodiscard]] uint32_t emissive_texture_index() const { return emissiveTextureIndex; }
        [[nodiscard]] uint32_t lightmap_texture_index() const { return lightmapTextureIndex; }
        [[nodiscard]] float roughness_factor() const { return roughnessFactor; }
        [[nodiscard]] float metallic_factor() const { return metallicFactor; }
        [[nodiscard]] float normal_scale() const { return normalScale; }
        [[nodiscard]] glm::vec3 emissive_factor() const { return emissiveFactor; }
 
        // PBR setters
        void setNormalTextureIndex(uint32_t index) { normalTextureIndex = index; }
        void setRoughnessMetallicTextureIndex(uint32_t index) { roughnessMetallicTextureIndex = index; }
        void setEmissiveTextureIndex(uint32_t index) { emissiveTextureIndex = index; }
        void setLightmapTextureIndex(uint32_t index) { lightmapTextureIndex = index; }
        void setRoughnessFactor(float factor) { roughnessFactor = factor; }
        void setMetallicFactor(float factor) { metallicFactor = factor; }
        void setNormalScale(float scale) { normalScale = scale; }
        void setEmissiveFactor(const glm::vec3& factor) { emissiveFactor = factor; }
 
    private:
        // Original fields
        uint32_t baseColorTextureIndex;
        glm::vec4 baseColorFactor;
        float sh_scale;
        float ambient_term;
        uint32_t debug_mode;
        uint32_t tone_mapping;
 
        // PBR extension fields (0xFFFFFFFF = not present)
        uint32_t normalTextureIndex;
        uint32_t roughnessMetallicTextureIndex;
        uint32_t emissiveTextureIndex;
        uint32_t lightmapTextureIndex;
        float roughnessFactor;
        float metallicFactor;
        float normalScale;
        glm::vec3 emissiveFactor;
    };
    TYPE_TRAIT(MovableDiffuseShaderMaterialData, PipelineNames::MOVABLE_DIFFUSE_SHADER)
 
 
    TYPE_TRAIT_CLASS(L0ShaderMaterialData)
    {
    public:
        L0ShaderMaterialData(uint32_t base_color_texture_index, const glm::vec4 &base_color_factor, float sh_scale,
            float ambient_term)
            : baseColorTextureIndex(base_color_texture_index),
              baseColorFactor(base_color_factor),
              sh_scale(sh_scale),
              ambient_term(ambient_term) {
        }
 
        [[nodiscard]] uint32_t base_color_texture_index() const {
            return baseColorTextureIndex;
        }
 
        [[nodiscard]] glm::vec4 base_color_factor() const {
            return baseColorFactor;
        }
 
        [[nodiscard]] float sh_scale1() const {
            return sh_scale;
        }
 
        [[nodiscard]] float ambient_term1() const {
            return ambient_term;
        }
 
    private:
        uint32_t baseColorTextureIndex;
        glm::vec4 baseColorFactor;
        float sh_scale;
        float ambient_term;
    };
    TYPE_TRAIT(L0ShaderMaterialData, PipelineNames::L0_SHADER)
 
    
    TYPE_TRAIT_CLASS(L1ShaderMaterialData)
    {
    public:
        L1ShaderMaterialData(uint32_t base_color_texture_index, const glm::vec4 &base_color_factor, float sh_scale,
            float ambient_term)
            : baseColorTextureIndex(base_color_texture_index),
              baseColorFactor(base_color_factor),
              sh_scale(sh_scale),
              ambient_term(ambient_term) {
        }
 
        [[nodiscard]] uint32_t base_color_texture_index() const {
            return baseColorTextureIndex;
        }
 
        [[nodiscard]] glm::vec4 base_color_factor() const {
            return baseColorFactor;
        }
 
        [[nodiscard]] float sh_scale1() const {
            return sh_scale;
        }
 
        [[nodiscard]] float ambient_term1() const {
            return ambient_term;
        }
 
    private:
        uint32_t baseColorTextureIndex;
        glm::vec4 baseColorFactor;
        float sh_scale;
        float ambient_term;
    };
    TYPE_TRAIT(L1ShaderMaterialData, PipelineNames::L1_SHADER)
 
 
    TYPE_TRAIT_CLASS(L2ShaderMaterialData)
    {
    public:
        L2ShaderMaterialData(uint32_t base_color_texture_index, const glm::vec4 &base_color_factor, float sh_scale,
            float ambient_term)
            : baseColorTextureIndex(base_color_texture_index),
              baseColorFactor(base_color_factor),
              sh_scale(sh_scale),
              ambient_term(ambient_term) {
        }
 
        [[nodiscard]] uint32_t base_color_texture_index() const {
            return baseColorTextureIndex;
        }
 
        [[nodiscard]] glm::vec4 base_color_factor() const {
            return baseColorFactor;
        }
 
        [[nodiscard]] float sh_scale1() const {
            return sh_scale;
        }
 
        [[nodiscard]] float ambient_term1() const {
            return ambient_term;
        }
 
    private:
        uint32_t baseColorTextureIndex;
        glm::vec4 baseColorFactor;
        float sh_scale;
        float ambient_term;
    };
    TYPE_TRAIT(L2ShaderMaterialData, PipelineNames::L2_SHADER);

    TYPE_TRAIT_CLASS(DynamicTexturesMaterialData)
    {
    public:
        // Default constructor with sensible defaults
        DynamicTexturesMaterialData()
            : baseColorTextureIndex(0xFFFFFFFF),
              baseColorFactor(1.0f),
              sh_scale(0.15f),
              ambient_term(0.1f),
              debug_mode(0),
              tone_mapping(1),
              normalTextureIndex(0xFFFFFFFF),
              roughnessMetallicTextureIndex(0xFFFFFFFF),
              emissiveTextureIndex(0xFFFFFFFF),
              lightmapTextureIndex(0xFFFFFFFF),
              roughnessFactor(1.0f),
              metallicFactor(0.0f),
              normalScale(1.0f),
              emissiveFactor(0.0f) {
        }
 
        // Legacy constructor for backwards compatibility
        DynamicTexturesMaterialData(uint32_t base_color_texture_index, const glm::vec4 &base_color_factor,
            float sh_scale, float ambient_term, uint32_t debug_mode, uint32_t tone_mapping)
            : baseColorTextureIndex(base_color_texture_index),
              baseColorFactor(base_color_factor),
              sh_scale(sh_scale),
              ambient_term(ambient_term),
              debug_mode(debug_mode),
              tone_mapping(tone_mapping),
              normalTextureIndex(0xFFFFFFFF),
              roughnessMetallicTextureIndex(0xFFFFFFFF),
              emissiveTextureIndex(0xFFFFFFFF),
              lightmapTextureIndex(0xFFFFFFFF),
              roughnessFactor(1.0f),
              metallicFactor(0.0f),
              normalScale(1.0f),
              emissiveFactor(0.0f) {
        }
 
        // Existing accessors
        [[nodiscard]] uint32_t base_color_texture_index() const { return baseColorTextureIndex; }
        [[nodiscard]] glm::vec4 base_color_factor() const { return baseColorFactor; }
        [[nodiscard]] float sh_scale1() const { return sh_scale; }
        [[nodiscard]] float ambient_term1() const { return ambient_term; }
        [[nodiscard]] uint32_t debug_mode1() const { return debug_mode; }
        [[nodiscard]] uint32_t tone_mapping1() const { return tone_mapping; }
 
        // PBR accessors
        [[nodiscard]] uint32_t normal_texture_index() const { return normalTextureIndex; }
        [[nodiscard]] uint32_t roughness_metallic_texture_index() const { return roughnessMetallicTextureIndex; }
        [[nodiscard]] uint32_t emissive_texture_index() const { return emissiveTextureIndex; }
        [[nodiscard]] uint32_t lightmap_texture_index() const { return lightmapTextureIndex; }
        [[nodiscard]] float roughness_factor() const { return roughnessFactor; }
        [[nodiscard]] float metallic_factor() const { return metallicFactor; }
        [[nodiscard]] float normal_scale() const { return normalScale; }
        [[nodiscard]] glm::vec3 emissive_factor() const { return emissiveFactor; }
 
        // PBR setters
        void setNormalTextureIndex(uint32_t index) { normalTextureIndex = index; }
        void setRoughnessMetallicTextureIndex(uint32_t index) { roughnessMetallicTextureIndex = index; }
        void setEmissiveTextureIndex(uint32_t index) { emissiveTextureIndex = index; }
        void setLightmapTextureIndex(uint32_t index) { lightmapTextureIndex = index; }
        void setRoughnessFactor(float factor) { roughnessFactor = factor; }
        void setMetallicFactor(float factor) { metallicFactor = factor; }
        void setNormalScale(float scale) { normalScale = scale; }
        void setEmissiveFactor(const glm::vec3& factor) { emissiveFactor = factor; }
 
    private:
        // Original fields
        uint32_t baseColorTextureIndex;
        glm::vec4 baseColorFactor;
        float sh_scale;
        float ambient_term;
        uint32_t debug_mode;
        uint32_t tone_mapping;
 
        // PBR extension fields (0xFFFFFFFF = not present)
        uint32_t normalTextureIndex;
        uint32_t roughnessMetallicTextureIndex;
        uint32_t emissiveTextureIndex;
        uint32_t lightmapTextureIndex;
        float roughnessFactor;
        float metallicFactor;
        float normalScale;
        glm::vec3 emissiveFactor;
    };
    TYPE_TRAIT(DynamicTexturesMaterialData, PipelineNames::DYNAMIC_TEXTURES)
 
    
    TYPE_TRAIT_CLASS(StaticLightmapMaterialData)
    {
    public:
        // Default constructor with sensible defaults
        StaticLightmapMaterialData()
            : baseColorTextureIndex(0xFFFFFFFF),
              baseColorFactor(1.0f),
              normalTextureIndex(0xFFFFFFFF),
              lightmapTextureIndex(0xFFFFFFFF),
              roughnessFactor(1.0f),
              metallicFactor(0.0f),
              normalScale(1.0f),
              emissiveFactor(0.0f),
              sh_scale(0.15f),
              ambient_term(1.0f),  // Default to full brightness when no lightmap present
              debug_mode(0),
              tone_mapping(0) {
        }
 
        // Full constructor
        StaticLightmapMaterialData(uint32_t baseColorTexIdx, const glm::vec4& baseColorFac,
            uint32_t normalTexIdx, uint32_t lightmapTexIdx,
            float roughness, float metallic, float normScale,
            const glm::vec3& emissive, float shScale, float ambientTerm,
            uint32_t debugMode, uint32_t toneMap)
            : baseColorTextureIndex(baseColorTexIdx),
              baseColorFactor(baseColorFac),
              normalTextureIndex(normalTexIdx),
              lightmapTextureIndex(lightmapTexIdx),
              roughnessFactor(roughness),
              metallicFactor(metallic),
              normalScale(normScale),
              emissiveFactor(emissive),
              sh_scale(shScale),
              ambient_term(ambientTerm),
              debug_mode(debugMode),
              tone_mapping(toneMap) {
        }
 
        // Accessors
        [[nodiscard]] uint32_t base_color_texture_index() const { return baseColorTextureIndex; }
        [[nodiscard]] glm::vec4 base_color_factor() const { return baseColorFactor; }
        [[nodiscard]] uint32_t normal_texture_index() const { return normalTextureIndex; }
        [[nodiscard]] uint32_t lightmap_texture_index() const { return lightmapTextureIndex; }
        [[nodiscard]] float roughness_factor() const { return roughnessFactor; }
        [[nodiscard]] float metallic_factor() const { return metallicFactor; }
        [[nodiscard]] float normal_scale() const { return normalScale; }
        [[nodiscard]] glm::vec3 emissive_factor() const { return emissiveFactor; }
        [[nodiscard]] float sh_scale1() const { return sh_scale; }
        [[nodiscard]] float ambient_term1() const { return ambient_term; }
        [[nodiscard]] uint32_t debug_mode1() const { return debug_mode; }
        [[nodiscard]] uint32_t tone_mapping1() const { return tone_mapping; }
 
        // Setters
        void setBaseColorTextureIndex(uint32_t index) { baseColorTextureIndex = index; }
        void setNormalTextureIndex(uint32_t index) { normalTextureIndex = index; }
        void setLightmapTextureIndex(uint32_t index) { lightmapTextureIndex = index; }
        void setRoughnessFactor(float factor) { roughnessFactor = factor; }
        void setMetallicFactor(float factor) { metallicFactor = factor; }
        void setNormalScale(float scale) { normalScale = scale; }
        void setEmissiveFactor(const glm::vec3& factor) { emissiveFactor = factor; }
 
    private:
        uint32_t baseColorTextureIndex;
        glm::vec4 baseColorFactor;
        uint32_t normalTextureIndex;
        uint32_t lightmapTextureIndex;
        float roughnessFactor;
        float metallicFactor;
        float normalScale;
        glm::vec3 emissiveFactor;
        float sh_scale;
        float ambient_term;
        uint32_t debug_mode;
        uint32_t tone_mapping;
    };
    TYPE_TRAIT(StaticLightmapMaterialData, PipelineNames::STATIC_LIGHTMAP)
 
}