GltfLoader.cpp

Go to the documentation of this file.

#include "Engine/Mesh/GltfLoader.h"
#include "Engine/Mesh/Vertex.h"
#include "Engine/Texture/ExrLoader.h"
#include "Engine/World/Transform.h"
#include "Engine/Mesh/AssetManager.h"
#include <future>
#include <plog/Log.h>
#include <sstream>
#include "Engine/Core/Engine.h"
#include "Engine/Core/Optional.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Engine/Core/Settings.h"
#ifdef ENABLE_TRACY
#include <tracy/TracyC.h>
#include <tracy/Tracy.hpp>
#include "Engine/Logging/TracyMacros.hpp"
#endif
namespace EngineCore {
    GltfLoader::GltfLoader(NamedThreadPool *threadPool) : threadPool(threadPool) {
    }
 
    GltfLoader::~GltfLoader() {
        if (threadPool) {
            threadPool->wait();
        }
    }
 
    GltfLoader::GltfBufferDataView::GltfBufferDataView(const std::vector<tinygltf::Buffer>& buffers, const std::vector<tinygltf::BufferView>& bufferViews, const tinygltf::Accessor& accessor)
     : accessor(accessor), bufferView(bufferViews[accessor.bufferView]), buffer(buffers[bufferView.buffer]) {
        data = reinterpret_cast<const float *>(&buffer.data[bufferView.byteOffset + accessor.byteOffset]);
    }
 
    GltfLoader::GltfVertexData::GltfVertexData(const std::vector<tinygltf::Buffer> &buffers,
                                                     const std::vector<tinygltf::BufferView> &bufferViews,
                                                     const std::vector<tinygltf::Accessor>& accessors,
                                                     const tinygltf::Primitive &primitive) {
#define EXTRACT_VERTEX_DATA( view, attribKey )                                                               \
    {                                                                                                        \
        constexpr const char * positionKey = attribKey;                                                      \
        if ( primitive.attributes.find( attribKey ) != primitive.attributes.end() )                          \
        {                                                                                                    \
            view.emplace( buffers, bufferViews, accessors.at(primitive.attributes.at( attribKey )));                    \
        }                                                                                                    \
    }
 
        EXTRACT_VERTEX_DATA( positionDataView, "POSITION" )
        EXTRACT_VERTEX_DATA( normalDataView, "NORMAL" )
        EXTRACT_VERTEX_DATA( tangentDataView, "TANGENT" )  // vec4: xyz=tangent, w=handedness
        EXTRACT_VERTEX_DATA( uvDataView, "TEXCOORD_0" )
        EXTRACT_VERTEX_DATA( lightmapDataView, "TEXCOORD_1" )
 
        indexDataView.emplace(GltfBufferDataView( buffers, bufferViews, accessors[primitive.indices] ));
 
 
#undef EXTRACT_VERTEX_DATA
    }
 
    std::vector<Vertex> GltfLoader::getPrimitiveVertices(const tinygltf::Primitive &primitive) {
        throw std::logic_error("Not implemented");
    }
 
    Ecs::PrimitiveData GltfLoader::loadPrimitiveData(GltfVertexData vertexData) {
        TRACY_ZONE_SCOPED_NAMED("Process Primitive");
        assert(vertexData.indexDataView.has_value());
        assert(vertexData.indexDataView->data != nullptr);
        assert(vertexData.indexDataView->accessor.count > 0);
 
        Vertex                vertex;
        std::vector<Vertex>   vertices;
        std::vector<uint32_t> indices;
        vertices.reserve( vertexData.indexDataView->accessor.count );
        indices.reserve( vertexData.indexDataView->accessor.count );
        for (uint32_t index = 0; index < vertexData.indexDataView->accessor.count; index++)
        {
            uint32_t vertexIndex = 0;
            switch (vertexData.indexDataView->accessor.componentType) {
                case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE:
                    vertexIndex = static_cast<uint32_t>(reinterpret_cast<const uint8_t *>(vertexData.indexDataView->data)[index]);
                    break;
                case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT:
                    vertexIndex = static_cast<uint32_t>(reinterpret_cast<const uint16_t *>(vertexData.indexDataView->data)[index]);
                    break;
                case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT:
                    vertexIndex = reinterpret_cast<const uint32_t *>( vertexData.indexDataView->data )[index];
                    break;
                default:
                    PLOGF << "Unsupported index type! Type: "
                          << vertexData.indexDataView->accessor.componentType;
            }
 
            if ( vertexData.positionDataView.has_value() )
            {
                vertex.position = glm::vec4( vertexData.positionDataView->data[3 * vertexIndex + 0],
                                             vertexData.positionDataView->data[3 * vertexIndex + 1],
                                             vertexData.positionDataView->data[3 * vertexIndex + 2],
                                             0.0f );
            }
 
            if ( vertexData.normalDataView.has_value() )
            {
                vertex.normal = glm::vec4( vertexData.normalDataView->data[3 * vertexIndex + 0],
                                           vertexData.normalDataView->data[3 * vertexIndex + 1],
                                           vertexData.normalDataView->data[3 * vertexIndex + 2],
                                           0.0f );
            }
 
            // Extract tangent (vec4: xyz=tangent direction, w=handedness)
            if ( vertexData.tangentDataView.has_value() )
            {
                vertex.tangent = glm::vec4( vertexData.tangentDataView->data[4 * vertexIndex + 0],
                                            vertexData.tangentDataView->data[4 * vertexIndex + 1],
                                            vertexData.tangentDataView->data[4 * vertexIndex + 2],
                                            vertexData.tangentDataView->data[4 * vertexIndex + 3] );  // w = handedness
            }
            else
            {
                // Default tangent when not present (will be computed or ignored)
                vertex.tangent = glm::vec4(1.0f, 0.0f, 0.0f, 1.0f);
            }
 
            if ( vertexData.uvDataView.has_value() )
            {
                vertex.textureCoordinate = {
                    vertexData.uvDataView->data[2 * vertexIndex + 0],
                    vertexData.uvDataView->data[2 * vertexIndex + 1],
                };
            }
            if ( vertexData.lightmapDataView.has_value() )
            {
                vertex.lightmapUvCoordinate = {
                    vertexData.lightmapDataView->data[2 * vertexIndex + 0],
                    vertexData.lightmapDataView->data[2 * vertexIndex + 1],
                };
            }
 
            vertices.emplace_back( vertex );
            indices.emplace_back( static_cast<uint32_t>(vertices.size()) - 1 ); // local vertex index
        }
        return { vertices, indices };
    }
 
    bool GltfLoader::GltfTextureData::hasTextureData() const {
        return image != tinygltf::Image();
    }
 
    GltfLoader::VulkanSchneeExtension::VulkanSchneeExtension(const tinygltf::Value &vs_extension) {
        const std::string version = extractVersion(vs_extension);
 
        // Parse mesh properties
        if (vs_extension.Has("meshProperties")) {
            meshProperties = MeshProperties(vs_extension);
            PLOGI << "IsStatic: " << meshProperties->isStatic << " CollisionEnabled: " << meshProperties->collisionEnabled;
        }
 
        // Parse lighting properties (note: key is "lightingProperties" not "lightProperties")
        if (vs_extension.Has("lightingProperties")) {
            lightProperties = LightProperties(vs_extension);
            PLOGI << "HasLightmaps: " << lightProperties->getHasLightmaps();
        }
 
        // Parse lightmap properties (at root level, sibling of lightingProperties)
        if (vs_extension.Has("lightmapProperties")) {
            lightmapProperties = LightProperties::LightmapProperties(vs_extension.Get("lightmapProperties"));
            PLOGI << "LightmapPath: " << lightmapProperties->lightmapPath;
        }
    }
 
    GltfLoader::VulkanSchneeExtension::MeshProperties::MeshProperties(const tinygltf::Value &extension) {
        const tinygltf::Value &meshProperties = extension.Get("meshProperties");
 
        const tinygltf::Value &isStatic = meshProperties.Get("isStatic");
        const tinygltf::Value &collisionEnabled = meshProperties.Get("collisionEnabled");
 
        this->isStatic = isStatic.Get<bool>();
        this->collisionEnabled = collisionEnabled.Get<bool>();
    }
 
    GltfLoader::VulkanSchneeExtension::LightProperties::LightProperties(const tinygltf::Value &extension) {
        // Note: key is "lightingProperties" not "lightProperties"
        const tinygltf::Value &lightingProperties = extension.Get("lightingProperties");
 
        const tinygltf::Value &castShadowsVal = lightingProperties.Get("castShadows");
        const tinygltf::Value &receiveShadowsVal = lightingProperties.Get("receiveShadows");
        const tinygltf::Value &hasLightmapsVal = lightingProperties.Get("hasLightmaps");
 
        this->castShadows = castShadowsVal.Get<bool>();
        this->receiveShadows = receiveShadowsVal.Get<bool>();
        this->hasLightmaps = hasLightmapsVal.Get<bool>();
 
        // Note: lightmapProperties is now parsed at VulkanSchneeExtension level as a sibling
    }
 
    GltfLoader::VulkanSchneeExtension::LightProperties::LightmapProperties::LightmapProperties(
        const tinygltf::Value &lightmapProps) {
        // Now receiving the lightmapProperties object directly (not its parent)
 
        if (lightmapProps.Has("lightmapPath")) {
            const tinygltf::Value &pathVal = lightmapProps.Get("lightmapPath");
            if (pathVal.IsString()) {
                this->lightmapPath = pathVal.Get<std::string>();
            } else {
                PLOGE << "Lightmap path is not a string. Will return empty string.";
            }
        } else {
            PLOGE << "Lightmap path not found in lightmapProperties. Will return empty string.";
        }
 
        if (lightmapProps.Has("lightmapUvIndex")) {
            const tinygltf::Value &uvIndexVal = lightmapProps.Get("lightmapUvIndex");
            if (uvIndexVal.IsInt()) {
                this->lightmapUvIndex = static_cast<uint32_t>(uvIndexVal.Get<int>());
            } else {
                PLOGE << "Lightmap UV index is not an integer. Will return 0.";
            }
        } else {
            PLOGE << "Lightmap UV index not found in lightmapProperties. Will return 0.";
        }
    }
 
    bool GltfLoader::VulkanSchneeExtension::LightProperties::LightmapProperties::isLightmapPathValid() const {
        return lightmapPath != std::filesystem::path();
    }
 
    bool GltfLoader::VulkanSchneeExtension::LightProperties::getCastShadows() const {
        return this->castShadows;
    }
 
    bool GltfLoader::VulkanSchneeExtension::LightProperties::getReceiveShadows() const {
        return this->receiveShadows;
    }
 
    bool GltfLoader::VulkanSchneeExtension::LightProperties::getHasLightmaps() const {
        return this->hasLightmaps;
    }
 
    std::string GltfLoader::VulkanSchneeExtension::extractVersion(const tinygltf::Value &vs_extension) {
        if (!vs_extension.Has("version")) {
            PLOGE << "Version not found in material extension. Will return empty string.";
            return "";
        }
        return vs_extension.Get("version").Get<std::string>();
    }
 
    GltfLoader::VulkanSchneeMaterialExtension::ShaderParameter::ShaderParameter(const tinygltf::Value &param) {
        this->type = param.Get("type").Get<std::string>();
        this->socketType = param.Get("socketType").Get<std::string>();
 
        // Only extract value if this is a value parameter (not connected)
        if (this->type == "value" && param.Has("value")) {
            this->value = param.Get("value");
        }
    }
 
    GltfLoader::VulkanSchneeMaterialExtension::VulkanSchneeMaterialExtension(const tinygltf::Value &vs_extension) {
        // Extract shader type
        if (vs_extension.Has("shaderType")) {
            this->shaderType = vs_extension.Get("shaderType").Get<std::string>();
        } else {
            PLOGE << "Shader type not found in material extension. Will default to Normals shader";
            this->shaderType = MaterialShader::getPipelineNameFromString(DEFAULT_MATERIAL_PIPELINE);
        }
        this->materialName = MaterialShader::getPipelineNameFromString(this->shaderType);
 
 
        PLOGI << "Loading material extension - Shader Type: " << this->shaderType;
 
        // Extract shader parameters
        if (vs_extension.Has("shaderParameters")) {
            const tinygltf::Value &params = vs_extension.Get("shaderParameters");
            if (params.IsObject()) {
                const auto &paramsObj = params.Get<tinygltf::Value::Object>();
                for (const auto &[key, value]: paramsObj) {
                    this->shaderParameters.emplace(key, ShaderParameter(value));
                }
                PLOGI << "  Shader Parameters: " << this->shaderParameters.size() << " parameter(s) loaded";
                for (const auto &[key, param]: this->shaderParameters) {
                    PLOGI << "    - " << key << " [" << param.socketType << "]: " << param.type;
                }
            }
        }
 
        // Extract node properties
        if (vs_extension.Has("nodeProperties")) {
            const tinygltf::Value &nodeProps = vs_extension.Get("nodeProperties");
            if (nodeProps.IsObject()) {
                const auto &propsObj = nodeProps.Get<tinygltf::Value::Object>();
                for (const auto &[key, value]: propsObj) {
                    // Node properties can be int or float, convert to double
                    if (value.IsInt()) {
                        this->nodeProperties[key] = static_cast<double>(value.Get<int>());
                    } else if (value.IsReal()) {
                        this->nodeProperties[key] = value.Get<double>();
                    }
                }
                PLOGI << "  Node Properties: " << this->nodeProperties.size() << " property(ies) loaded";
                for (const auto &[key, val]: this->nodeProperties) {
                    PLOGI << "    - " << key << ": " << val;
                }
            }
        }
 
        // Extract custom properties (optional)
        if (vs_extension.Has("customProperties")) {
            const tinygltf::Value &customProps = vs_extension.Get("customProperties");
            if (customProps.IsObject()) {
                const auto &customObj = customProps.Get<tinygltf::Value::Object>();
                for (const auto &[key, value]: customObj) {
                    this->customProperties[key] = value;
                }
                PLOGI << "  Custom Properties: " << this->customProperties.size() << " property(ies) loaded";
            }
        }
    }
 
    GltfLoader::MaterialExtensions::MaterialExtensions(const tinygltf::ExtensionMap &material) {
        if (material.find("VULKAN_SCHNEE_materials") != material.end()) {
            this->vulkanSchneeMaterialExtension = VulkanSchneeMaterialExtension(material.at("VULKAN_SCHNEE_materials"));
        } else {
            PLOGI << "  No VULKAN_SCHNEE_materials extension found in material";
        }
    }
 
    bool GltfLoader::VulkanSchneeExtension::hasLightProperties() const {
        return this->lightProperties.has_value();
    }
 
    bool GltfLoader::VulkanSchneeExtension::hasLightmapProperties() const {
        return this->lightmapProperties.has_value();
    }
 
    bool GltfLoader::VulkanSchneeExtension::hasMeshProperties() const {
        return this->meshProperties.has_value();
    }
 
    GltfLoader::StaticMeshExtensions::StaticMeshExtensions(const tinygltf::ExtensionMap &extensions) {
        if (extensions.find("VULKAN_SCHNEE_engine_properties") != extensions.end()) {
            this->vulkanSchneeExtension = VulkanSchneeExtension(extensions.at("VULKAN_SCHNEE_engine_properties"));
        } else {
            PLOGI << "  No VULKAN_SCHNEE_engine_properties extension found in mesh";
        }
    }
 
    GltfLoader::GltfMaterialData::GltfMaterialData(const tinygltf::Model &model, const tinygltf::Material &material,
                                                   const StaticMeshExtensions &meshSettings) : material(material) {
        TRACY_ZONE_SCOPED_NAMED("Loading material data");
 
        PLOGI << "Loading material: " << material.name;
 
        if (!material.extensions.empty()) {
            materialExtensions = MaterialExtensions(material.extensions);
            PLOGI << "  Material has Vulkan Schnee extension";
        } else {
            PLOGI << "  Material has no extensions, using default shader";
        }
 
        // Parse standard glTF PBR data
        parsePbrData(model, material);
 
        // Initialize baseColorFactor BEFORE setupMaterialData() so it's available as a fallback
        const std::vector<double> baseColor = material.pbrMetallicRoughness.baseColorFactor;
        if (!baseColor.empty()) {
            if (baseColor.size() < 4)
                throw std::runtime_error("Tried to load a color which was not rgba!");
            baseColorFactor.r = static_cast<float>(baseColor[0]);
            baseColorFactor.g = static_cast<float>(baseColor[1]);
            baseColorFactor.b = static_cast<float>(baseColor[2]);
            baseColorFactor.a = static_cast<float>(baseColor[3]);
        } else {
            baseColorFactor = glm::vec4(1.0f); // white as default when there is no color specified
        }
 
        // Initialize textureIndex BEFORE setupMaterialData() so it's available for material data creation
        if (meshSettings.vulkanSchneeExtension.has_value()) {
            const auto &vulkanSchneeExtension = meshSettings.vulkanSchneeExtension.value();
 
            if (vulkanSchneeExtension.hasLightmapProperties()
                && vulkanSchneeExtension.lightProperties.value().getHasLightmaps()
                && vulkanSchneeExtension.lightmapProperties.value().isLightmapPathValid()
            ) {
                const auto &lightMapSettings = vulkanSchneeExtension.lightmapProperties.value();
 
                // Store the lightmap path for later resolution to descriptor index
                lightmapPath = lightMapSettings.lightmapPath;
 
                // Load lightmap texture data from EXR file
                ExrLoader exrLoader = {};
                lightmapTextureData = GltfTextureData(exrLoader.load(lightMapSettings.lightmapPath));
                PLOGI << "Loaded lightmap texture from: " << lightmapPath;
 
                // Also keep the old behavior for backwards compatibility (textureData stores lightmap)
                textureData = lightmapTextureData;
                textureIndex = std::numeric_limits<int>::max();
            } else {
                const tinygltf::TextureInfo &textureInfo = material.pbrMetallicRoughness.baseColorTexture;
                if (textureInfo.index != -1) {
                    const tinygltf::Texture &texture = model.textures[textureInfo.index];
                    const tinygltf::Image &image = model.images[texture.source];
 
                    textureData = GltfTextureData(image);
                    textureIndex = textureInfo.index;
                }
            }
        } else {
            // No vulkan schnee extension - still try to get base color texture
            const tinygltf::TextureInfo &textureInfo = material.pbrMetallicRoughness.baseColorTexture;
            if (textureInfo.index != -1) {
                const tinygltf::Texture &texture = model.textures[textureInfo.index];
                const tinygltf::Image &image = model.images[texture.source];
 
                textureData = GltfTextureData(image);
                textureIndex = textureInfo.index;
            }
        }
 
        setupMaterialData();
 
        if (!meshSettings.vulkanSchneeExtension.has_value()) {
            PLOGI << "Mesh has no vulkan schnee extension in exported mesh data";
            return;
        }
    }
 
    void GltfLoader::GltfMaterialData::parsePbrData(const tinygltf::Model &model, const tinygltf::Material &material) {
        // Parse metallic/roughness factors
        roughnessFactor = static_cast<float>(material.pbrMetallicRoughness.roughnessFactor);
        metallicFactor = static_cast<float>(material.pbrMetallicRoughness.metallicFactor);
 
        // Parse metallic/roughness texture - extract image data for loading into descriptor array
        const auto& metallicRoughnessTexture = material.pbrMetallicRoughness.metallicRoughnessTexture;
        if (metallicRoughnessTexture.index != -1) {
            gltfMetallicRoughnessTextureIndex = metallicRoughnessTexture.index;
            const tinygltf::Texture& texture = model.textures[metallicRoughnessTexture.index];
            if (texture.source >= 0 && texture.source < static_cast<int>(model.images.size())) {
                metallicRoughnessTextureData = GltfTextureData(model.images[texture.source]);
                PLOGD << "  Metallic/roughness texture extracted (GLTF index " << metallicRoughnessTexture.index
                      << ", image source " << texture.source << ")";
            }
        }
 
        // Parse normal texture - extract image data for loading into descriptor array
        if (material.normalTexture.index != -1) {
            gltfNormalTextureIndex = material.normalTexture.index;
            normalScale = static_cast<float>(material.normalTexture.scale);
            const tinygltf::Texture& texture = model.textures[material.normalTexture.index];
            if (texture.source >= 0 && texture.source < static_cast<int>(model.images.size())) {
                normalTextureData = GltfTextureData(model.images[texture.source]);
                PLOGD << "  Normal texture extracted (GLTF index " << material.normalTexture.index
                      << ", image source " << texture.source << ", scale " << normalScale << ")";
            }
        }
 
        // Parse emissive texture - extract image data for loading into descriptor array
        if (material.emissiveTexture.index != -1) {
            gltfEmissiveTextureIndex = material.emissiveTexture.index;
            const tinygltf::Texture& texture = model.textures[material.emissiveTexture.index];
            if (texture.source >= 0 && texture.source < static_cast<int>(model.images.size())) {
                emissiveTextureData = GltfTextureData(model.images[texture.source]);
                PLOGD << "  Emissive texture extracted (GLTF index " << material.emissiveTexture.index
                      << ", image source " << texture.source << ")";
            }
        }
 
        // Parse emissive factor
        const auto& emissive = material.emissiveFactor;
        if (emissive.size() >= 3) {
            emissiveFactor = glm::vec3(
                static_cast<float>(emissive[0]),
                static_cast<float>(emissive[1]),
                static_cast<float>(emissive[2])
            );
            if (glm::length(emissiveFactor) > 0.0f) {
                PLOGD << "  Emissive factor: (" << emissiveFactor.x << ", " << emissiveFactor.y << ", " << emissiveFactor.z << ")";
            }
        }
 
        PLOGD << "  Metallic: " << metallicFactor << ", Roughness: " << roughnessFactor;
    }
 
    bool GltfLoader::GltfMaterialData::hasTexture() const {
        return textureIndex != std::numeric_limits<uint32_t>::max();
    }
 
    uint32_t GltfLoader::GltfMaterialData::getTextureIndex() const {
        return textureIndex;
    }
 
    GltfLoader::GltfTextureData GltfLoader::GltfMaterialData::getTextureData() const {
        return textureData;
    }
 
    bool GltfLoader::GltfMaterialData::hasVulkanSchneeExtension() const {
        return materialExtensions.has_value() &&
               materialExtensions->vulkanSchneeMaterialExtension.has_value();
    }
 
    const GltfLoader::VulkanSchneeMaterialExtension &GltfLoader::GltfMaterialData::getVulkanSchneeExtension() const {
        if (!hasVulkanSchneeExtension()) {
            throw std::runtime_error("Material does not have Vulkan Schnee extension");
        }
        return materialExtensions->vulkanSchneeMaterialExtension.value();
    }
 
    std::string GltfLoader::GltfMaterialData::getShaderName() const {
        if (hasVulkanSchneeExtension()) {
            const std::string shaderName = getVulkanSchneeExtension().shaderType;
            return shaderName;
        }
        return "diffuseFlatColor"; // Default shader
    }
 
    std::variant<NormalMaterialData, DiffuseFlatColorMaterialData, DiffuseShaderMaterialData,
        MovableDiffuseShaderMaterialData, L0ShaderMaterialData, L1ShaderMaterialData, L2ShaderMaterialData,
        DynamicTexturesMaterialData, StaticLightmapMaterialData> GltfLoader::GltfMaterialData::getMaterialDataRaw() const {
        return materialData;
    }
 
    void GltfLoader::GltfMaterialData::setupMaterialData() {
        if (!materialExtensions.has_value()) {
            PLOGI << "setupMaterialData: No material extensions, defaulting to NormalMaterialData";
            materialData = NormalMaterialData();
            return;
        }
 
        if (!materialExtensions->vulkanSchneeMaterialExtension.has_value()) {
            PLOGI << "setupMaterialData: No vulkan schnee material extension, defaulting to NormalMaterialData";
            materialData = NormalMaterialData();
            return;
        }
 
        const VulkanSchneeMaterialExtension &ext = materialExtensions->vulkanSchneeMaterialExtension.value();
        PLOGI << "setupMaterialData: shaderType=" << ext.shaderType
              << ", materialName=" << static_cast<int>(ext.materialName)
              << " (STATIC_LIGHTMAP=" << static_cast<int>(PipelineNames::STATIC_LIGHTMAP) << ")";
 
#define MATCH_MATERIAL(name, type, ...) \
    if (ext.materialName == PipelineNames::name) { \
        materialData = type(__VA_ARGS__); \
        return; \
    }
 
        auto shaderParams = materialExtensions->vulkanSchneeMaterialExtension->shaderParameters;
 
        const auto it = shaderParams.find("Color");
        std::array<float, 4> colors{};
        if (it != shaderParams.end()) {
            const auto arr = it->second.value.Get<tinygltf::Value::Array>();
            colors = {
                static_cast<float>(arr[0].GetNumberAsDouble()),
                static_cast<float>(arr[1].GetNumberAsDouble()),
                static_cast<float>(arr[2].GetNumberAsDouble()),
                static_cast<float>(arr[3].GetNumberAsDouble())
            };
        }
 
 
        MATCH_MATERIAL(NORMALS_SHADER, NormalMaterialData);
 
 
        if (ext.materialName == PipelineNames::DIFFUSE_FLAT_COLOR) {
            glm::vec3 diffuseColor;
            // Use "Color" shader parameter if available and non-zero, otherwise fall back to PBR baseColorFactor
            bool colorParamValid = (it != shaderParams.end()) && (colors[0] != 0.0f || colors[1] != 0.0f || colors[2] != 0.0f);
            if (colorParamValid) {
                diffuseColor = {colors[0], colors[1], colors[2]};
                PLOGI << "FLAT_COLOR using shader Color param: " << diffuseColor.r << ", " << diffuseColor.g << ", " << diffuseColor.b;
            } else {
                // Use PBR baseColorFactor as fallback (typically from glTF material's pbrMetallicRoughness)
                diffuseColor = glm::vec3(baseColorFactor);
                PLOGI << "FLAT_COLOR using baseColorFactor fallback: " << diffuseColor.r << ", " << diffuseColor.g << ", " << diffuseColor.b
                      << " (Color param " << (it != shaderParams.end() ? "was zero" : "not found") << ")";
            }
            materialData = DiffuseFlatColorMaterialData(diffuseColor);
            return;
        };
 
        const uint32_t texIndex = getTextureIndex();
        const glm::vec4 colorFactor = baseColorFactor;
 
        // Extract properties with defaults
        float shScale = 0.15f;
        float ambientTerm = 0.1f;
        uint32_t debugMode = 0;
        uint32_t toneMapping = 0;
 
        if (ext.nodeProperties.count("sh_scale")) shScale = static_cast<float>(ext.nodeProperties.at("sh_scale"));
        if (ext.nodeProperties.count("ambient_term")) ambientTerm = static_cast<float>(ext.nodeProperties.at("ambient_term"));
        if (ext.nodeProperties.count("debug_mode")) debugMode = static_cast<uint32_t>(ext.nodeProperties.at("debug_mode"));
        if (ext.nodeProperties.count("tone_mapping")) {
            // Map string enum back if it was stored as string, but here it's double
            toneMapping = static_cast<uint32_t>(ext.nodeProperties.at("tone_mapping"));
        }
 
        MATCH_MATERIAL(DIFFUSE_SHADER, DiffuseShaderMaterialData, texIndex, colorFactor);
        MATCH_MATERIAL(L0_SHADER, L0ShaderMaterialData, texIndex, colorFactor, shScale, ambientTerm);
        MATCH_MATERIAL(L1_SHADER, L1ShaderMaterialData, texIndex, colorFactor, shScale, ambientTerm);
        MATCH_MATERIAL(L2_SHADER, L2ShaderMaterialData, texIndex, colorFactor, shScale, ambientTerm);
        MATCH_MATERIAL(MOVABLE_DIFFUSE_SHADER, MovableDiffuseShaderMaterialData, texIndex, colorFactor, shScale, ambientTerm, debugMode, toneMapping);
        MATCH_MATERIAL(DYNAMIC_TEXTURES, DynamicTexturesMaterialData, texIndex, colorFactor, shScale, ambientTerm, debugMode, toneMapping);
 
        // Static lightmap material - uses PBR textures and lightmap
        if (ext.materialName == PipelineNames::STATIC_LIGHTMAP) {
            // For static lightmap, default ambient_term to 1.0 (full brightness) if not specified
            // This ensures materials without lightmaps appear fully lit rather than dark
            float lightmapAmbientTerm = ext.nodeProperties.count("ambient_term")
                ? ambientTerm : 1.0f;
 
            StaticLightmapMaterialData staticLightmapData(
                texIndex,                    // base color texture index
                colorFactor,                 // base color factor
                normalTextureIndex,          // normal texture index
                0xFFFFFFFF,                  // lightmap texture index (set later by AssetManager)
                roughnessFactor,             // roughness factor
                metallicFactor,              // metallic factor
                normalScale,                 // normal scale
                emissiveFactor,              // emissive factor
                shScale,                     // SH scale
                lightmapAmbientTerm,         // ambient term (defaults to 1.0 for lightmap materials)
                debugMode,                   // debug mode
                toneMapping                  // tone mapping
            );
            materialData = staticLightmapData;
            PLOGI << "Created StaticLightmapMaterialData with baseColorTex=" << texIndex
                  << " (normalTex not loaded - PBR texture loading not yet implemented)";
            return;
        }
 
        // If we reach here, no material type matched - default to NormalMaterialData
        PLOGW << "setupMaterialData: No material type matched for materialName="
              << static_cast<int>(ext.materialName) << ", shaderType=" << ext.shaderType
              << ". Defaulting to NormalMaterialData.";
        materialData = NormalMaterialData();
 
#undef MATCH_MATERIAL
    }
 
    GltfLoader::GltfMeshPrimitiveData::GltfMeshPrimitiveData(tinygltf::Model model, tinygltf::Primitive primitive,
                                                             StaticMeshExtensions meshSettings) {
        TRACY_ZONE_SCOPED_NAMED("Loading primitive data");
        if (primitive.material != -1) {
            // the primitive has a material
            materialData = GltfMaterialData(model, model.materials[primitive.material], meshSettings);
        }
 
        Vertex vertex;
 
        int uvCoordinateAccessorIndex;
        if (auto &vkScExtension = meshSettings.vulkanSchneeExtension;
            vkScExtension.has_value()
            && vkScExtension->hasLightProperties()
            && vkScExtension->lightProperties->getHasLightmaps()
            && vkScExtension->hasLightmapProperties()) {
            const uint32_t lightmapIndex = meshSettings.vulkanSchneeExtension.value().lightmapProperties.value().
                    lightmapUvIndex;
            std::stringstream strStream;
            strStream << "TEXCOORD_" << lightmapIndex;
            uvCoordinateAccessorIndex = primitive.attributes.find(strStream.str())->second;
        } else {
            uvCoordinateAccessorIndex = primitive.attributes.find("TEXCOORD_0")->second;
        }
 
        if (!(model.accessors.size() > static_cast<size_t>(uvCoordinateAccessorIndex) && uvCoordinateAccessorIndex != -
              1)) {
            PLOGE << "Failed to load UV coordinate accessor";
        }
        const int &positionAccessorIndex = primitive.attributes.find("POSITION")->second;
        if (!(model.accessors.size() > static_cast<size_t>(positionAccessorIndex) && positionAccessorIndex >= 0)) {
            PLOGE << "Failed to load position accessor";
        }
 
        // ADDED: Check for NORMAL attribute and load it if present
        bool hasNormals = false;
        const float *vertexNormals = nullptr;
        auto normalAttributeIt = primitive.attributes.find("NORMAL");
        if (normalAttributeIt != primitive.attributes.end()) {
            int normalAccessorIndex = normalAttributeIt->second;
            if (model.accessors.size() > static_cast<size_t>(normalAccessorIndex) && normalAccessorIndex >= 0) {
                const tinygltf::Accessor &normalAccessor = model.accessors[normalAccessorIndex];
                const tinygltf::BufferView &normalBufferView = model.bufferViews[normalAccessor.bufferView];
                const tinygltf::Buffer &normalBuffer = model.buffers[normalBufferView.buffer];
                vertexNormals = reinterpret_cast<const float *>(
                    &normalBuffer.data[normalBufferView.byteOffset + normalAccessor.byteOffset]);
                hasNormals = true;
                PLOGI << "NORMAL attribute found and loaded.";
            } else {
                PLOGW << "NORMAL attribute found but accessor invalid.";
            }
        } else {
            PLOGW << "NORMAL attribute NOT found. Normals will be (0.0, 0.0, 0.0).";
        } {
            const tinygltf::Accessor &accessor = model.accessors[uvCoordinateAccessorIndex];
            if (accessor.componentType != TINYGLTF_COMPONENT_TYPE_FLOAT || accessor.type != TINYGLTF_TYPE_VEC2) {
                PLOGE << "UV coordinates are not in supported format";
            }
            const tinygltf::BufferView &bufferView = model.bufferViews[accessor.bufferView];
            const tinygltf::Buffer &buffer = model.buffers[bufferView.buffer];
 
            const float *uvData = reinterpret_cast<const float *>(&buffer.data[
                bufferView.byteOffset + accessor.byteOffset]);
 
            const tinygltf::Accessor &positionAccessor = model.accessors[positionAccessorIndex];
            const tinygltf::BufferView &positionBufferView = model.bufferViews[positionAccessor.bufferView];
            const tinygltf::Buffer &positionBuffer = model.buffers[positionBufferView.buffer];
            const float *vertexPositions = reinterpret_cast<const float *>(
                &positionBuffer.data[positionBufferView.byteOffset + positionAccessor.byteOffset]);
 
            // Get the index accessor.
            const tinygltf::Accessor &indexAccessor = model.accessors[primitive.indices];
            const tinygltf::BufferView &indexBufferView = model.bufferViews[indexAccessor.bufferView];
            const tinygltf::Buffer &indexBuffer = model.buffers[indexBufferView.buffer];
            const void *indexDataPointer =
                    static_cast<const void *>(&indexBuffer.data[indexBufferView.byteOffset + indexAccessor.byteOffset]);
 
            // Loop through indices.
            for (size_t i = 0u; i < indexAccessor.count; i++) {
                uint32_t vertexIndex = 0;
                switch (indexAccessor.componentType) {
                    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE:
                        vertexIndex = static_cast<uint32_t>(reinterpret_cast<const uint8_t *>(indexDataPointer)[i]);
                        break;
                    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT:
                        vertexIndex = static_cast<uint32_t>(reinterpret_cast<const uint16_t *>(indexDataPointer)[i]);
                        break;
                    case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT:
                        vertexIndex = reinterpret_cast<const uint32_t *>(indexDataPointer)[i];
                        break;
                    default:
                        PLOGF << "Unsupported index type! Type: " << indexAccessor.componentType;
                }
 
                vertex.position = glm::vec4(
                    vertexPositions[3 * vertexIndex + 0], vertexPositions[3 * vertexIndex + 1],
                    vertexPositions[3 * vertexIndex + 2], 0.0f
                );
 
                vertex.textureCoordinate = glm::vec2(uvData[2 * vertexIndex + 0], // U component
                                                     uvData[2 * vertexIndex + 1] // V component
                );
 
                // ADDED: Assign normal if available
                if (hasNormals) {
                    vertex.normal = glm::vec4(
                        vertexNormals[3 * vertexIndex + 0], vertexNormals[3 * vertexIndex + 1],
                        vertexNormals[3 * vertexIndex + 2], 0.0f
                    );
                } else {
                    vertex.normal = glm::vec4(0.0f); // Default to (0,0,0,0) if no normals
                }
 
                vertices.push_back(vertex);
                indices.push_back(static_cast<uint32_t>(vertices.size() - 1));
            }
        }
    }
 
    std::vector<Vertex> GltfLoader::GltfMeshPrimitiveData::getVertices() const {
        return vertices;
    }
 
    std::vector<uint32_t> GltfLoader::GltfMeshPrimitiveData::getIndices() const {
        return indices;
    }
 
    GltfLoader::GltfMaterialData GltfLoader::GltfMeshPrimitiveData::getMaterialData() const {
        return materialData;
    }
 
    Texture *GltfLoader::GltfMeshPrimitiveData::getColorTexturePtr() const {
        return colorTexturePtr;
    }
 
    uint32_t GltfLoader::GltfMeshPrimitiveData::getColorTextureIndex() const {
        return textureIndex;
    }
 
    GltfLoader::GltfMeshData::GltfMeshData(const tinygltf::Model &model, const tinygltf::Mesh &mesh,
                                           const tinygltf::Node &node, const glm::mat4 &transform) {
        TRACY_ZONE_SCOPED_NAMED("Loading Mesh data");
        this->transform = transform;
        this->mesh = mesh;
        this->name = node.name;
 
        const auto extensions = StaticMeshExtensions(node.extensions);
 
        primitives.resize(this->mesh.primitives.size());
        for (uint32_t i = 0u; i < this->mesh.primitives.size(); i++) {
            primitives[i] = GltfMeshPrimitiveData(model, this->mesh.primitives[i], extensions);
        }
    }
 
    GltfLoader::StaticMeshSettings::StaticMeshSettings(const tinygltf::Value &extras) {
        const tinygltf::Value &hasLightMap = extras.Get("HasLightmaps");
        bUsesLightMaps = hasLightMap.Get<bool>();
 
        const tinygltf::Value &lightMapPathValue = extras.Get("LightMapPath");
        lightMapPath = std::filesystem::path(lightMapPathValue.Get<std::string>());
 
        const tinygltf::Value &lightMapUvIndexValue = extras.Get("LightMapUvIndex");
        lightMapUvIndex = lightMapUvIndexValue.Get<int>();
    }
 
    void GltfLoader::load(const std::filesystem::path &path, std::vector<GltfMeshData> &meshes) const {
 
        tinygltf::Model model = EngineCore::UnpackOptional(loadModel(path));
 
        const size_t nodeCount = model.nodes.size();
        std::vector<GltfMeshData> meshList;
        meshList.reserve(nodeCount);
 
        TRACY_LOCKABLE(std::mutex, lock, "mesh list mutex");
 
        for (const tinygltf::Node &node: model.nodes) {
            TRACY_ZONE_SCOPED_NAMED("Loading Node");
 
            // Skip nodes without meshes (cameras, lights, empties, armatures)
            if (node.mesh < 0) {
                continue;
            }
 
            auto transform = Transform();
            {
                TRACY_ZONE_SCOPED_NAMED("Loading Mesh Transform");
                if (!node.translation.empty()) {
                    // x,y,z
                    const auto translation = glm::vec3(node.translation[0], node.translation[1], node.translation[2]);
                    transform.setLocation(translation);
                }
 
                if (!node.rotation.empty()) {
                    // x,y,z,w
                    const auto rotation = glm::quat(node.rotation[3], node.rotation[0], node.rotation[1],
                                                    node.rotation[2]);
                    transform.setRotationQuat(rotation);
                }
 
                if (!node.scale.empty()) {
                    const auto scale = glm::vec3(node.scale[0], node.scale[1], node.scale[2]);
                    transform.setScale(scale);
                }
            }
 
            const GltfMeshData data(model, model.meshes[node.mesh], node, transform.toMatrix());
 
            meshes.push_back(data);
        }
 
    }
 
    std::optional<tinygltf::Model> GltfLoader::loadModel(const std::filesystem::path &path) const {
        // loader for tinygltf
        TRACY_ZONE_SCOPED_NAMED("Loading Mesh");
        tinygltf::Model model;
        tinygltf::TinyGLTF loader;
        std::string error{};
        std::string warning{};
 
        loader.SetStoreOriginalJSONForExtrasAndExtensions(true); {
            TRACY_ZONE_SCOPED_NAMED("File Read");
 
            if (!loader.LoadASCIIFromFile(&model, &error, &warning, path.generic_string())) {
                std::stringstream errorStream{};
                errorStream << "Failed to load mesh: " << path.generic_string() << " with gltf loading error: " << error;
                throw std::runtime_error(errorStream.str());
            }
            if (!error.empty()) {
                PLOGE_ASSET << "Failed to load mesh: " << path.generic_string() << " with error: " << error;
            }
            if (!warning.empty()) {
                PLOGE_ASSET << "Loaded asset " << path.generic_string() << " with warnings " << warning;
            }
        }
        return model;
    }
 
    tinygltf::Model GltfLoader::loadAsync(const std::filesystem::path &path) const {
        TRACY_ZONE_SCOPED_NAMED("Loading Mesh Async (Deferred)");
 
        tinygltf::TinyGLTF loader;
 
        // Set a no-op image loader to skip actual image file loading
        // This allows parsing image metadata from JSON without loading image files from disk
        auto noOpImageLoader = [](tinygltf::Image* image, const int image_idx, std::string* err,
                                  std::string* warn, int width, int height,
                                  const unsigned char* data, int size, void* user_data) -> bool {
            //PLOGI << "Skipping image load for image " << image_idx << " (deferred mode)";
            return true;  // Return true to indicate success without actually loading
        };
        loader.SetImageLoader(noOpImageLoader, nullptr);
        loader.SetStoreOriginalJSONForExtrasAndExtensions(true);
 
        tinygltf::Model model;
        std::string error, warning;
        if (!loader.LoadASCIIFromFile(&model, &error, &warning, path.generic_string())) {
            PLOGE << "Failed to load mesh: " << path.generic_string();
        }
        if (!error.empty()) {
            PLOGE << "Error loading mesh: " << error;
        }
        if (!warning.empty()) {
            PLOGW << "Warning loading mesh: " << warning;
        }
 
        return model;
    }
 
    tinygltf::Model GltfLoader::loadMetadataOnly(const std::filesystem::path &path) const {
        TRACY_ZONE_SCOPED_NAMED("Loading GLTF Metadata Only");
 
        tinygltf::TinyGLTF loader;
 
        // Only parse nodes (names and transforms) - skip everything else
        loader.SetParseStages(tinygltf::PARSE_NODES_ONLY);
 
        tinygltf::Model model;
        std::string error, warning;
 
        const std::string pathStr = path.generic_string();
        const std::string ext = path.extension().string();
 
        bool success = false;
        if (ext == ".glb" || ext == ".GLB") {
            success = loader.LoadBinaryFromFile(&model, &error, &warning, pathStr);
        } else {
            success = loader.LoadASCIIFromFile(&model, &error, &warning, pathStr);
        }
 
        if (!success) {
            PLOGE << "Failed to load GLTF metadata: " << path.generic_string();
        }
        if (!error.empty()) {
            PLOGE << "Error loading GLTF metadata: " << error;
        }
        if (!warning.empty()) {
            PLOGW << "Warning loading GLTF metadata: " << warning;
        }
 
        return model;
    }
}