MaterialData.h

#pragma once
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <cstdint>
 
#include "MaterialTypes.h"
 
namespace Engine::Core
{
    struct MaterialData {
        Rendering::PipelineNames pipeline = Rendering::PipelineNames::NORMALS_SHADER;

        uint32_t baseColorTextureIndex = 0xFFFFFFFF;
        uint32_t normalTextureIndex = 0xFFFFFFFF;
        uint32_t roughnessMetallicTextureIndex = 0xFFFFFFFF;
        uint32_t emissiveTextureIndex = 0xFFFFFFFF;
        uint32_t lightmapTextureIndex = 0xFFFFFFFF;
 
        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;                     
 
        float shScale = 1.0f;       
        float ambientTerm = 0.0f;   
        uint32_t debugMode = 0;     
        uint32_t toneMapping = 1;   
 
        bool normalMapBC5 = false;  
        float alphaCutoff = 1.0f;   

        MaterialData() = default;

        explicit MaterialData(Rendering::PipelineNames pipe) : pipeline(pipe) {}

        MaterialData(Rendering::PipelineNames pipe, uint32_t baseColorTexIdx, const glm::vec4& baseColorFac)
            : pipeline(pipe),
              baseColorTextureIndex(baseColorTexIdx),
              baseColorFactor(baseColorFac) {}

        [[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; }

        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

namespace Engine::Assets::Materials {
    using MaterialData = Engine::Core::MaterialData;

    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