MaterialData.h

Go to the documentation of this file.

#pragma once
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <cstdint>
 
#include "MaterialTypes.h"
 
namespace Engine::Core
{
    struct MaterialData {
        // Core pipeline/shader selection
        Rendering::PipelineNames pipeline = Rendering::PipelineNames::NORMALS_SHADER;
 
        // Texture indices (0xFFFFFFFF = not present/ unused)
        uint32_t baseColorTextureIndex = 0xFFFFFFFF;
        uint32_t normalTextureIndex = 0xFFFFFFFF;
        uint32_t roughnessMetallicTextureIndex = 0xFFFFFFFF;
        uint32_t emissiveTextureIndex = 0xFFFFFFFF;
        uint32_t lightmapTextureIndex = 0xFFFFFFFF;
 
        // Material factors
        glm::vec4 baseColorFactor = glm::vec4(1.0f);
        glm::vec3 emissiveFactor = glm::vec3(0.0f);
        float roughnessFactor = 1.0f;
        float metallicFactor = 0.0f;
        float normalScale = 1.0f;
 
        // Shader configuration (used by PBR/Lighting shaders)
        float shScale = 1.0f;
        float ambientTerm = 0.0f;
        uint32_t debugMode = 0;
        uint32_t toneMapping = 1;  // 0=None, 1=Reinhard, 2=ACES
 
        // Feature flags
        bool normalMapBC5 = false;  // Normal map uses BC5 (2-channel RG) encoding
        float alphaCutoff = 1.0f;   // < 1.0f enables alpha mask (default: opaque)
 
        // Default constructor
        MaterialData() = default;
 
        // Convenience constructors for common material types
        explicit MaterialData(Rendering::PipelineNames pipe) : pipeline(pipe) {}
 
        MaterialData(Rendering::PipelineNames pipe, uint32_t baseColorTexIdx, const glm::vec4& baseColorFac)
            : pipeline(pipe),
              baseColorTextureIndex(baseColorTexIdx),
              baseColorFactor(baseColorFac) {}
 
        // Feature tests
        [[nodiscard]] bool hasBaseColorTexture() const { return baseColorTextureIndex != 0xFFFFFFFF; }
        [[nodiscard]] bool hasNormalTexture() const { return normalTextureIndex != 0xFFFFFFFF; }
        [[nodiscard]] bool hasMetallicRoughnessTexture() const { return roughnessMetallicTextureIndex != 0xFFFFFFFF; }
        [[nodiscard]] bool hasEmissiveTexture() const { return emissiveTextureIndex != 0xFFFFFFFF; }
        [[nodiscard]] bool hasLightmapTexture() const { return lightmapTextureIndex != 0xFFFFFFFF; }
        [[nodiscard]] bool isAlphaMasked() const { return alphaCutoff < 1.0f; }
 
        // Setters for fluent interface
        MaterialData& withBaseColorTexture(uint32_t idx) { baseColorTextureIndex = idx; return *this; }
        MaterialData& withNormalTexture(uint32_t idx) { normalTextureIndex = idx; return *this; }
        MaterialData& withMetallicRoughnessTexture(uint32_t idx) { roughnessMetallicTextureIndex = idx; return *this; }
        MaterialData& withEmissiveTexture(uint32_t idx) { emissiveTextureIndex = idx; return *this; }
        MaterialData& withLightmapTexture(uint32_t idx) { lightmapTextureIndex = idx; return *this; }
        MaterialData& withBaseColorFactor(const glm::vec4& fac) { baseColorFactor = fac; return *this; }
        MaterialData& withEmissiveFactor(const glm::vec3& fac) { emissiveFactor = fac; return *this; }
        MaterialData& withRoughness(float r) { roughnessFactor = r; return *this; }
        MaterialData& withMetallic(float m) { metallicFactor = m; return *this; }
        MaterialData& withNormalScale(float s) { normalScale = s; return *this; }
        MaterialData& withShScale(float s) { shScale = s; return *this; }
        MaterialData& withAmbientTerm(float a) { ambientTerm = a; return *this; }
        MaterialData& withDebugMode(uint32_t d) { debugMode = d; return *this; }
        MaterialData& withToneMapping(uint32_t t) { toneMapping = t; return *this; }
        MaterialData& withAlphaCutoff(float cutoff) { alphaCutoff = cutoff; return *this; }
        MaterialData& withNormalMapBC5(bool bc5) { normalMapBC5 = bc5; return *this; }
    };
 
} // namespace Engine::Core
 
// Backwards compatibility aliases
namespace Engine::Assets::Materials {
    using MaterialData = Engine::Core::MaterialData;
 
    // Type aliases for migration compatibility (can be removed once all code is updated)
    using NormalMaterialData = Engine::Core::MaterialData;
    using DiffuseFlatColorMaterialData = Engine::Core::MaterialData;
    using DiffuseShaderMaterialData = Engine::Core::MaterialData;
    using MovableDiffuseShaderMaterialData = Engine::Core::MaterialData;
    using L0ShaderMaterialData = Engine::Core::MaterialData;
    using L1ShaderMaterialData = Engine::Core::MaterialData;
    using L2ShaderMaterialData = Engine::Core::MaterialData;
    using DynamicTexturesMaterialData = Engine::Core::MaterialData;
    using StaticLightmapMaterialData = Engine::Core::MaterialData;
} // namespace Engine::Assets::Materials