FrameProcessing.cpp

Go to the documentation of this file.

#include "Engine/Ecs/FrameProcessing.h"
 
#include <set>
#include <variant>
 
#include "Engine/Core/Engine.h"
#include "Engine/Core/Settings.h"
#include "Engine/Ecs/RegistryManager.h"
#include "Engine/Renderer/RenderingDataManager.h"
#include "Engine/Core/Optional.h"
#include "Engine/Ecs/EcsData.h"
#include "Engine/Files/Path.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Engine/Material/MaterialAsset.h"
#include "Engine/Material/MaterialTypes.h"
#include "Engine/Mesh/AssetManager.h"
#include "Engine/Mesh/ClusterLodGenerator.h"
#include "Engine/Mesh/GltfLoader.h"
#include "Engine/Mesh/MeshAsset.h"
#include "Engine/Mesh/ModelAssetManager.h"
#include "Engine/Renderer/NamedThreadPool.h"
#include "Engine/Math/BoundingSphere.h"
#include "Engine/Texture/TextureAsset.h"
#include "Engine/Texture/TextureHandleRegistry.h"
#include "Engine/Logging/LogCategories.h"
#include "plog/Log.h"
 
namespace Ecs
{
 
    TextureAssetPipeline::TextureAssetPipeline( EngineCore::TextureAssetManager * textureAssetManager,
                                                NamedThreadPool * assetLoaderPool )
      : textureAssetManager( textureAssetManager )
      , assetLoaderPool( assetLoaderPool )
    {
    }
 
    void TextureAssetPipeline::submitAsset( const std::filesystem::path & asset )
    {
        assetQueue.push_back( asset );
    }
 
    void TextureAssetPipeline::tick( bool async )
    {
        requestExrHeaders( async );
        loadImageData( async );
        retrieveImageData( async );
    }
 
    void TextureAssetPipeline::requestExrHeaders( bool async )
    {
        std::chrono::time_point<std::chrono::system_clock> startTime =
            std::chrono::high_resolution_clock::now();
        TRACY_ZONE_SCOPED_NAMED_ASSET( "Request Exr Header" );
        if ( assetQueue.empty() )
            return;
        headerFutures.reserve( headerFutures.size() + assetQueue.size() );
        for ( auto it = assetQueue.begin(); it != assetQueue.end(); )
        {
            auto future = assetLoaderPool->submit_task(
                [assetPath = *it]()
                {
                    EngineCore::ExrLoader loader;
                    return loader.loadHeader( assetPath );
                }
            );
 
            headerFutures.emplace_back( *it, std::move( future ) );
            it = assetQueue.erase( it );
        }
    }
 
    void TextureAssetPipeline::loadImageData( bool async )
    {
        TRACY_ZONE_SCOPED_NAMED_ASSET( "Load image data" );
        imageFutures.reserve( imageFutures.size() + headerFutures.size() );
        for ( auto it = headerFutures.begin(); it != headerFutures.end(); )
        {
            EngineCore::ExrHeader header;
            if ( async && it->future.wait_for( std::chrono::seconds( 0 ) ) == std::future_status::ready )
            {
                header = it->future.get();
            }
            else if ( !async )
            {
                header = it->future.get();
            }
            else
            {
                ++it;
                continue;
            }
 
            auto * asset = new EngineCore::ExrTextureAsset();
            asset->requestLoad();
            asset->setHeader( header );
            // set the asset in the asset manager
 
            textureAssetManager->add( it->path, asset );
 
            const std::filesystem::path  assetPath = it->path;
            std::future<tinygltf::Image> future    = assetLoaderPool->submit_task(
                [assetPath]()
                {
                    EngineCore::ExrLoader loader;
                    return loader.load( assetPath );
                }
            );
 
            imageFutures.emplace_back( it->path, std::move( future ) );
            it = headerFutures.erase( it );
        }
    }
 
    void TextureAssetPipeline::retrieveImageData( bool async )
    {
        TRACY_ZONE_SCOPED_NAMED_D_ASSET( "Retrieve Image Data with async " << ( async ? "TRUE" : "FALSE" ) );
        for ( auto it = imageFutures.begin(); it != imageFutures.end(); )
        {
            TRACY_ZONE_SCOPED_NAMED_ASSET( "Trying to load image" );
            bool loaded = false;
            if ( async )
            {
                if ( it->future.valid() &&
                     it->future.wait_for( std::chrono::seconds( 0 ) ) == std::future_status::ready )
                {
                    loaded = true;
                }
                else
                {
                    ++it;
                    continue;
                }
            }
            else
            {
                loaded = true;
            }
 
            if ( loaded )
            {
                TRACY_ZONE_SCOPED_NAMED_ASSET( "Update Asset state" );
                auto asset = UnpackOptional( textureAssetManager->getAsset( it->path ) );
                asset->setImage( it->future.get() );
 
                // Notify RenderingDataManager that a texture has been loaded
                // Pass the path so it can register the Vulkan texture with AssetManager
                if ( renderingDataManager )
                {
                    renderingDataManager->onTextureLoaded( asset, it->path );
                }
 
                it = imageFutures.erase( it );
            }
        }
    }
 
    ModelAssetPipeline::ModelAssetPipeline(
        EngineCore::MeshAssetManager *     meshAssetManager,
        EngineCore::MaterialAssetManager * materialAssetManager,
        EngineCore::ModelAssetManager *    modelAssetManager,
        EngineCore::TextureAssetManager *  textureAssetManager,
        NamedThreadPool *                  assetLoaderPool,
        EngineCore::AssetManager *         assetManager
    )
      : meshAssetManager( meshAssetManager )
      , materialAssetManager( materialAssetManager )
      , modelAssetManager( modelAssetManager )
      , textureAssetManager( textureAssetManager )
      , assetLoaderPool( assetLoaderPool )
      , assetManager_( assetManager )
    {
        assert( meshAssetManager != nullptr );
        assert( materialAssetManager != nullptr );
        assert( textureAssetManager != nullptr );
        assert( assetLoaderPool != nullptr );
    }
 
    void ModelAssetPipeline::submitAsset( const std::filesystem::path & asset )
    {
        assetQueue.push_back( asset );
 
        // Mark the model asset as requested to load
        auto modelAssetOpt = modelAssetManager->getAsset( asset );
        if ( modelAssetOpt.has_value() && modelAssetOpt.value() != nullptr )
        {
            modelAssetOpt.value()->requestLoad();
        }
    }
 
    void ModelAssetPipeline::tick( bool async )
    {
        submitLoadModel( async );
        processModel( async );
        processMaterial( async );
        processMeshData( async );
    }
 
    void ModelAssetPipeline::submitLoadModel( bool async )
    {
        TRACY_ZONE_SCOPED_NAMED_ASSET( "Submit Load Model" );
        if ( assetQueue.empty() ) return;
 
        for ( auto it = assetQueue.begin(); it != assetQueue.end(); )
        {
            if ( !EngineCore::Path::doesGltfFileExist( *it ) )
            {
                PLOGW << "Asset " << it->generic_string()
                      << " does not exist. Will thus not be loaded by asset pipeline!";
                assetQueue.erase( it );
                continue;
            }
            std::future<tinygltf::Model> future = assetLoaderPool->submit_task(
                [assetPath = *it, gltfLoader = this->loader]()
                { return EngineCore::UnpackOptional( gltfLoader->loadModel( assetPath ) ); }
            );
 
            modelLoadingFutures.emplace_back( *it, std::move( future ) );
            it = assetQueue.erase( it );
        }
    }
 
    void ModelAssetPipeline::processModel( bool async )
    {
        TRACY_ZONE_SCOPED_NAMED_ASSET( "Process Model" );
        if ( modelLoadingFutures.empty() )
            return;
        for ( auto it = modelLoadingFutures.begin(); it != modelLoadingFutures.end(); )
        {
            std::optional<tinygltf::Model> model;
            if ( async )
            {
                if ( it->future.valid() &&
                     it->future.wait_for( std::chrono::seconds( 0 ) ) == std::future_status::ready )
                {
                    model = std::move( it->future.get() );
                }
                else
                {
                    ++it;
                    continue;
                }
            }
            else
            {
                model = std::move( it->future.get() );
            }
 
            EngineCore::ModelAsset * modelAsset = EngineCore::UnpackOptional( modelAssetManager->getAsset( it->path ) );
            modelAsset->model = std::move( model.value() );
            model.reset();
 
            // Pre-compute texture paths before processTextures moves the image data
            std::vector<std::filesystem::path> imageTexturePaths;
            imageTexturePaths.reserve( modelAsset->model->images.size() );
            for ( size_t i = 0; i < modelAsset->model->images.size(); ++i )
            {
                const tinygltf::Image & image = modelAsset->model->images[i];
                std::filesystem::path   texturePath;
 
                if ( !image.uri.empty() )
                {
                    texturePath = it->path.parent_path() / image.uri;
                }
                else if ( !image.name.empty() )
                {
                    texturePath = it->path.parent_path() / image.name;
                }
                else
                {
                    texturePath = it->path.parent_path() / ( "image_" + std::to_string( i ) );
                }
                imageTexturePaths.push_back( std::move( texturePath ) );
            }
 
            // Pre-register texture handles BEFORE processTextures loads the actual image data.
            // This ensures that when onTextureLoaded is called, the handles already exist
            // and can be updated with descriptor indices.
            // We scan all materials to determine the correct TextureType for each image.
            {
                EngineCore::TextureHandleRegistry* textureRegistry = assetManager_ ? assetManager_->getTextureHandleRegistry() : nullptr;
                if ( textureRegistry )
                {
                    // Track which images are used as which texture types
                    std::unordered_map<int, EngineCore::TextureType> imageTypeMap;
 
                    for ( const tinygltf::Material & material : modelAsset->model->materials )
                    {
                        // Base color -> SRGB
                        int idx = material.pbrMetallicRoughness.baseColorTexture.index;
                        if ( idx >= 0 && idx < static_cast<int>( modelAsset->model->textures.size() ) )
                        {
                            int source = modelAsset->model->textures[idx].source;
                            if ( source >= 0 )
                                imageTypeMap[source] = EngineCore::TextureType::BaseColor;
                        }
 
                        // Normal -> LINEAR
                        idx = material.normalTexture.index;
                        if ( idx >= 0 && idx < static_cast<int>( modelAsset->model->textures.size() ) )
                        {
                            int source = modelAsset->model->textures[idx].source;
                            if ( source >= 0 )
                                imageTypeMap[source] = EngineCore::TextureType::Normal;
                        }
 
                        // Metallic-Roughness -> LINEAR
                        idx = material.pbrMetallicRoughness.metallicRoughnessTexture.index;
                        if ( idx >= 0 && idx < static_cast<int>( modelAsset->model->textures.size() ) )
                        {
                            int source = modelAsset->model->textures[idx].source;
                            if ( source >= 0 )
                                imageTypeMap[source] = EngineCore::TextureType::MetallicRoughness;
                        }
 
                        // Emissive -> SRGB
                        idx = material.emissiveTexture.index;
                        if ( idx >= 0 && idx < static_cast<int>( modelAsset->model->textures.size() ) )
                        {
                            int source = modelAsset->model->textures[idx].source;
                            if ( source >= 0 )
                                imageTypeMap[source] = EngineCore::TextureType::Emissive;
                        }
                    }
 
                    // Create handles for all images with their determined types
                    for ( size_t i = 0; i < imageTexturePaths.size(); ++i )
                    {
                        auto typeIt = imageTypeMap.find( static_cast<int>( i ) );
                        EngineCore::TextureType type = ( typeIt != imageTypeMap.end() )
                                                           ? typeIt->second
                                                           : EngineCore::TextureType::BaseColor;
 
                        // Pre-create the handle so onTextureLoaded can find it
                        switch ( type )
                        {
                            case EngineCore::TextureType::Normal:
                                textureRegistry->getOrCreateHandle<EngineCore::TextureType::Normal>( imageTexturePaths[i] );
                                break;
                            case EngineCore::TextureType::MetallicRoughness:
                                textureRegistry->getOrCreateHandle<EngineCore::TextureType::MetallicRoughness>( imageTexturePaths[i] );
                                break;
                            case EngineCore::TextureType::Emissive:
                                textureRegistry->getOrCreateHandle<EngineCore::TextureType::Emissive>( imageTexturePaths[i] );
                                break;
                            case EngineCore::TextureType::BaseColor:
                            default:
                                textureRegistry->getOrCreateHandle<EngineCore::TextureType::BaseColor>( imageTexturePaths[i] );
                                break;
                        }
                    }
                    PLOGI << "Pre-registered " << imageTexturePaths.size() << " texture handles before loading";
                }
            }
 
            // Extract and register texture assets from the loaded model (moves image data)
            processTextures( modelAsset, it->path );
 
            // synchronously create material assets and then submit the async tasks -> this is important
            // because the meshes will need the material assets later on. And if
            {
                TRACY_ZONE_SCOPED_NAMED_ASSET( "Starting loading for material assets" );
                for ( const tinygltf::Material & material : modelAsset->model->materials )
                {
                    TRACY_ZONE_SCOPED_NAMED_D_ASSET( "Loading material asset " << material.name );
                    auto materialPath = Asset::Path( it->path, material.name );
                    PLOGI << "processModel: Registering material '" << material.name
                          << "' with path handle: " << materialPath.getAssetHandle();
                    auto * materialAsset = new EngineCore::MaterialAsset( std::move( Asset::Path( it->path, material.name ) ), true );
                    materialAssetManager->add( std::move( Asset::Path( it->path, material.name ) ), materialAsset );
                    modelAsset->registerCreatedAssetWithModel( materialAsset );
 
                    // Get TextureHandleRegistry for type-safe handle creation
                    EngineCore::TextureHandleRegistry* textureRegistry = assetManager_ ? assetManager_->getTextureHandleRegistry() : nullptr;
                    PLOGI << "processModel: Processing material '" << material.name
                          << "' from model '" << it->path.string()
                          << "' assetManager_=" << (assetManager_ ? "valid" : "NULL")
                          << " textureRegistry=" << (textureRegistry ? "valid" : "NULL");
 
                    // Extract and set base color texture path if available
                    const int baseColorTexIndex = material.pbrMetallicRoughness.baseColorTexture.index;
                    if ( baseColorTexIndex >= 0 &&
                         baseColorTexIndex < static_cast<int>( modelAsset->model->textures.size() ) )
                    {
                        const tinygltf::Texture & texture = modelAsset->model->textures[baseColorTexIndex];
                        if ( texture.source >= 0 &&
                             texture.source < static_cast<int>( imageTexturePaths.size() ) )
                        {
                            const std::filesystem::path & texturePath = imageTexturePaths[texture.source];
                            materialAsset->setBaseColorTexturePath( texturePath );
                            // Set typed handle for O(1) lookup and correct SRGB format
                            if ( textureRegistry )
                            {
                                auto handle = textureRegistry->getOrCreateHandle<EngineCore::TextureType::BaseColor>( texturePath );
                                materialAsset->setBaseColorTextureHandle( handle );
                            }
                            PLOGD << "Material '" << material.name << "' uses base color texture: " << texturePath;
                        }
                    }
 
                    // Extract and set normal texture path if available
                    const int normalTexIndex = material.normalTexture.index;
                    if ( normalTexIndex >= 0 &&
                         normalTexIndex < static_cast<int>( modelAsset->model->textures.size() ) )
                    {
                        const tinygltf::Texture & texture = modelAsset->model->textures[normalTexIndex];
                        if ( texture.source >= 0 &&
                             texture.source < static_cast<int>( imageTexturePaths.size() ) )
                        {
                            const std::filesystem::path & texturePath = imageTexturePaths[texture.source];
                            materialAsset->setNormalTexturePath( texturePath );
                            // Set typed handle for O(1) lookup and correct LINEAR format (critical fix!)
                            if ( textureRegistry )
                            {
                                auto handle = textureRegistry->getOrCreateHandle<EngineCore::TextureType::Normal>( texturePath );
                                materialAsset->setNormalTextureHandle( handle );
                            }
                            PLOGD << "Material '" << material.name << "' uses normal texture: " << texturePath;
                        }
                    }
 
                    // Extract and set metallic-roughness texture path if available
                    const int metallicRoughnessTexIndex = material.pbrMetallicRoughness.metallicRoughnessTexture.index;
                    if ( metallicRoughnessTexIndex >= 0 &&
                         metallicRoughnessTexIndex < static_cast<int>( modelAsset->model->textures.size() ) )
                    {
                        const tinygltf::Texture & texture = modelAsset->model->textures[metallicRoughnessTexIndex];
                        if ( texture.source >= 0 &&
                             texture.source < static_cast<int>( imageTexturePaths.size() ) )
                        {
                            const std::filesystem::path & texturePath = imageTexturePaths[texture.source];
                            materialAsset->setMetallicRoughnessTexturePath( texturePath );
                            // Set typed handle for O(1) lookup and correct LINEAR format
                            if ( textureRegistry )
                            {
                                auto handle = textureRegistry->getOrCreateHandle<EngineCore::TextureType::MetallicRoughness>( texturePath );
                                materialAsset->setMetallicRoughnessTextureHandle( handle );
                            }
                            PLOGD << "Material '" << material.name << "' uses metallic-roughness texture: " << texturePath;
                        }
                    }
 
                    // Extract and set emissive texture path if available
                    const int emissiveTexIndex = material.emissiveTexture.index;
                    if ( emissiveTexIndex >= 0 &&
                         emissiveTexIndex < static_cast<int>( modelAsset->model->textures.size() ) )
                    {
                        const tinygltf::Texture & texture = modelAsset->model->textures[emissiveTexIndex];
                        if ( texture.source >= 0 &&
                             texture.source < static_cast<int>( imageTexturePaths.size() ) )
                        {
                            const std::filesystem::path & texturePath = imageTexturePaths[texture.source];
                            materialAsset->setEmissiveTexturePath( texturePath );
                            // Set typed handle for O(1) lookup and correct SRGB format
                            if ( textureRegistry )
                            {
                                auto handle = textureRegistry->getOrCreateHandle<EngineCore::TextureType::Emissive>( texturePath );
                                materialAsset->setEmissiveTextureHandle( handle );
                            }
                            PLOGD << "Material '" << material.name << "' uses emissive texture: " << texturePath;
                        }
                    }
 
                    // Extract lightmap path from nodes that use this material
                    // Lightmap properties are at node level in GLTF, not material level
                    {
                        // Get the current material index
                        int materialIndex = static_cast<int>( &material - &modelAsset->model->materials[0] );
 
                        // Search through nodes to find one that uses this material and has lightmap properties
                        for ( const tinygltf::Node & node : modelAsset->model->nodes )
                        {
                            if ( node.mesh < 0 || node.mesh >= static_cast<int>( modelAsset->model->meshes.size() ) )
                                continue;
 
                            const tinygltf::Mesh & mesh = modelAsset->model->meshes[node.mesh];
 
                            // Check if any primitive of this mesh uses our material
                            bool usesMaterial = false;
                            for ( const tinygltf::Primitive & primitive : mesh.primitives )
                            {
                                if ( primitive.material == materialIndex )
                                {
                                    usesMaterial = true;
                                    break;
                                }
                            }
 
                            if ( !usesMaterial )
                                continue;
 
                            // Found a node that uses this material - check for lightmap properties
                            EngineCore::GltfLoader::StaticMeshExtensions nodeExtensions( node.extensions );
                            if ( nodeExtensions.vulkanSchneeExtension.has_value() &&
                                 nodeExtensions.vulkanSchneeExtension->hasLightmapProperties() &&
                                 nodeExtensions.vulkanSchneeExtension->lightProperties.has_value() &&
                                 nodeExtensions.vulkanSchneeExtension->lightProperties->getHasLightmaps() &&
                                 nodeExtensions.vulkanSchneeExtension->lightmapProperties->isLightmapPathValid() )
                            {
                                // Resolve lightmap path relative to the GLTF file (use absolute for consistency)
                                const auto & relativeLightmapPath = nodeExtensions.vulkanSchneeExtension->lightmapProperties->lightmapPath;
                                std::filesystem::path lightmapPath = std::filesystem::absolute( it->path.parent_path() / relativeLightmapPath );
                                materialAsset->setLightmapTexturePath( lightmapPath );
                                // Set typed handle for O(1) lookup and correct HDR float format
                                if ( textureRegistry )
                                {
                                    auto handle = textureRegistry->getOrCreateHandle<EngineCore::TextureType::Lightmap>( lightmapPath );
                                    materialAsset->setLightmapTextureHandle( handle );
                                }
                                PLOGD << "Material '" << material.name << "' uses lightmap texture: " << lightmapPath;
                                break;  // Found lightmap, no need to check more nodes
                            }
                        }
                    }
 
                    materialFutures.push_back( threadPool->submit_task(
                        [material, assetPath = it->path, modelAsset]() -> Ecs::MaterialLoadingData
                        {
                            // extract data from the material and return a pointer to the extracted material
                            // data using GltfLoader to properly parse the material extensions
                            auto asset = Asset::Path( assetPath, material.name );
 
                            // Parse material data using GltfLoader - this extracts shader type from VULKAN_SCHNEE extension
                            EngineCore::GltfLoader::StaticMeshExtensions meshExtensions{};
                            EngineCore::GltfLoader::GltfMaterialData gltfMaterial(
                                *modelAsset->model, material, meshExtensions);
 
                            // Get the material type from the extension (defaults to NORMALS_SHADER if no extension)
                            EngineCore::PipelineNames type = EngineCore::PipelineNames::NORMALS_SHADER;
                            if (gltfMaterial.hasVulkanSchneeExtension()) {
                                type = gltfMaterial.getVulkanSchneeExtension().materialName;
                                PLOGI << "Material '" << material.name << "' has extension, type="
                                      << static_cast<int>(type) << " shaderType="
                                      << gltfMaterial.getVulkanSchneeExtension().shaderType;
                            } else {
                                PLOGI << "Material '" << material.name << "' has NO extension, defaulting to NORMALS_SHADER";
                            }
 
                            // Create the appropriate material data on the heap using std::visit
                            EngineCore::MaterialData* data = std::visit(
                                [](auto&& arg) -> EngineCore::MaterialData* {
                                    using T = std::decay_t<decltype(arg)>;
                                    return new T(arg);
                                },
                                gltfMaterial.getMaterialDataRaw()
                            );
 
                            return { std::move( asset ), type, data };
                        }
                    ) );
                }
            }
 
            {
                TRACY_ZONE_SCOPED_NAMED_ASSET( "Loading mesh assets" );
                // Iterate over nodes instead of meshes to use node names (what users expect)
                // rather than internal mesh names (e.g., "Cube" instead of "Cube.001")
                int nodeIndex = 0;
                for ( const tinygltf::Node & node : modelAsset->model->nodes )
                {
                    // Skip nodes that don't reference a mesh
                    if ( node.mesh < 0 || node.mesh >= static_cast<int>( modelAsset->model->meshes.size() ) )
                    {
                        ++nodeIndex;
                        continue;
                    }
 
                    // Special logging for debugging VarC (node 13) issue
                    if ( node.name.find("VarC") != std::string::npos || node.name.find("scq9") != std::string::npos )
                    {
                        PLOGW << "*** PROCESSING VarC NODE: index=" << nodeIndex << " name=" << node.name
                              << " mesh=" << node.mesh << " ***";
                    }
 
                    const tinygltf::Mesh & mesh = modelAsset->model->meshes[node.mesh];
                    TRACY_ZONE_SCOPED_NAMED_D_ASSET( "Loading full mesh asset" << node.name );
 
                    const auto meshAsset = new EngineCore::MeshAsset(true);
                    const auto meshPath  = Asset::Path( it->path, node.name );
                    meshAssetManager->add( meshPath, meshAsset );
                    modelAsset->registerCreatedAssetWithModel( meshAsset );
 
                    {
                        TRACY_ZONE_SCOPED_NAMED_ASSET( "Submit primitive loading task" );
                        primitiveDataFutures.push_back( assetLoaderPool->submit_task(
                            [gltfLoader = loader, mesh, pool = threadPool, modelAsset, meshPath](
                            ) -> Ecs::PrimitiveDataLoading
                            {
                                TRACY_ZONE_SCOPED_NAMED_D_ASSET( "Loading mesh asset " << meshPath.getAssetName() );
                                std::vector<std::future<PrimitiveData>> primitiveDataFutures;
                                std::vector<Asset::Path> materialPaths;
                                primitiveDataFutures.reserve( mesh.primitives.size() );
                                materialPaths.reserve( mesh.primitives.size() );
 
                                PLOGI << "=== Creating material paths for mesh: " << meshPath.getAssetHandle()
                                      << " (primitives: " << mesh.primitives.size() << ") ===";
                                int primitiveIdx = 0;
                                for ( const tinygltf::Primitive & primitive : mesh.primitives )
                                {
                                    // Resolve material path while model is still available
                                    int matIdx = primitive.material;
                                    PLOGI << "  primitive[" << primitiveIdx << "] matIdx=" << matIdx
                                          << " (materials.size=" << modelAsset->model->materials.size() << ")";
                                    if ( matIdx >= 0 && matIdx < static_cast<int>( modelAsset->model->materials.size() ) )
                                    {
                                        const auto & matName = modelAsset->model->materials[matIdx].name;
                                        materialPaths.emplace_back( meshPath.getFilePath(), matName );
                                        PLOGI << "    -> created path: " << meshPath.getFilePath().string() << " + " << matName;
                                    }
                                    else
                                    {
                                        materialPaths.emplace_back();  // empty path = use default pipeline
                                        PLOGI << "    -> EMPTY path (matIdx out of range or -1)";
                                    }
                                    ++primitiveIdx;
 
                                    auto vertexData = EngineCore::GltfLoader::GltfVertexData(
                                        modelAsset->model->buffers,
                                        modelAsset->model->bufferViews,
                                        modelAsset->model->accessors,
                                        primitive
                                    );
                                    primitiveDataFutures.emplace_back(
                                        std::move( pool->submit_task(
                                            [gltfLoader, vertexData]() -> PrimitiveData
                                            {
                                                TRACY_ZONE_SCOPED_NAMED_ASSET( "Loading Primitive Data" );
                                                return gltfLoader->loadPrimitiveData( vertexData );
                                            }
                                        ) )
                                    );
                                }
 
                                // Log summary of material paths created
                                size_t emptyCount = 0;
                                for (const auto& path : materialPaths) {
                                    if (path.empty()) ++emptyCount;
                                }
                                PLOGI << "=== Material paths summary for " << meshPath.getAssetHandle()
                                      << ": total=" << materialPaths.size() << " empty=" << emptyCount << " ===";
 
                                std::vector<PrimitiveData> data;
                                data.reserve( primitiveDataFutures.size() );
                                for ( auto & primitiveDataFuture : primitiveDataFutures )
                                {
                                    data.emplace_back( primitiveDataFuture.get() );
                                }
                                return { meshPath, std::move( data ), std::move( materialPaths ) };
                            }
                        ) );
                    }
                }
            }
            it = modelLoadingFutures.erase( it );
        }
    }
 
    void ModelAssetPipeline::processMaterial( bool async )
    {
        if ( materialFutures.empty() )
            return;
        for ( auto it = materialFutures.begin(); it != materialFutures.end(); )
        {
            Ecs::MaterialLoadingData materialLoadingData;
            if ( async )
            {
                if ( it->valid() && it->wait_for( std::chrono::seconds( 0 ) ) == std::future_status::ready )
                {
                    materialLoadingData = std::move( it->get() );
                }
                else
                {
                    ++it;
                    continue;
                }
            }
            else
            {
                materialLoadingData = std::move( it->get() );
            }
 
            EngineCore::MaterialAsset * materialAsset = EngineCore::UnpackOptional( materialAssetManager->getAsset( materialLoadingData.path ) );
            materialAsset->type = materialLoadingData.type;
            PLOGI << "processMaterial: Setting type for material '"
                  << materialLoadingData.path.getAssetHandle()
                  << "' to " << static_cast<int>(materialLoadingData.type);
 
            auto& registry = RegistryManager::get();
            switch ( materialAsset->type )
            {
                case EngineCore::PipelineNames::NORMALS_SHADER:
                {
                    const auto* normalsData = static_cast<EngineCore::NormalMaterialData*>(materialLoadingData.data);
                    registry.emplace<EngineCore::NormalMaterialData>(materialAsset->data, *normalsData);
                    break;
                }
                case EngineCore::PipelineNames::DIFFUSE_FLAT_COLOR:
                {
                    const auto* flatColorData = static_cast<EngineCore::DiffuseFlatColorMaterialData*>(materialLoadingData.data);
                    registry.emplace<EngineCore::DiffuseFlatColorMaterialData>(materialAsset->data, *flatColorData);
                    break;
                }
                case EngineCore::PipelineNames::DIFFUSE_SHADER:
                {
                    const auto* diffuseData = static_cast<EngineCore::DiffuseShaderMaterialData*>(materialLoadingData.data);
                    registry.emplace<EngineCore::DiffuseShaderMaterialData>(materialAsset->data, *diffuseData);
                    break;
                }
                case EngineCore::PipelineNames::DYNAMIC_TEXTURES:
                {
                    const auto* dynamicData = static_cast<EngineCore::DynamicTexturesMaterialData*>(materialLoadingData.data);
                    registry.emplace<EngineCore::DynamicTexturesMaterialData>(materialAsset->data, *dynamicData);
                    break;
                }
                case EngineCore::PipelineNames::L0_SHADER:
                {
                    const auto* l0Data = static_cast<EngineCore::L0ShaderMaterialData*>(materialLoadingData.data);
                    registry.emplace<EngineCore::L0ShaderMaterialData>(materialAsset->data, *l0Data);
                    break;
                }
                case EngineCore::PipelineNames::L1_SHADER:
                {
                    const auto* l1Data = static_cast<EngineCore::L1ShaderMaterialData*>(materialLoadingData.data);
                    registry.emplace<EngineCore::L1ShaderMaterialData>(materialAsset->data, *l1Data);
                    break;
                }
                case EngineCore::PipelineNames::L2_SHADER:
                {
                    const auto* l2Data = static_cast<EngineCore::L2ShaderMaterialData*>(materialLoadingData.data);
                    registry.emplace<EngineCore::L2ShaderMaterialData>(materialAsset->data, *l2Data);
                    break;
                }
                case EngineCore::PipelineNames::MOVABLE_DIFFUSE_SHADER:
                {
                    const auto* movableData = static_cast<EngineCore::MovableDiffuseShaderMaterialData*>(materialLoadingData.data);
                    registry.emplace<EngineCore::MovableDiffuseShaderMaterialData>(materialAsset->data, *movableData);
                    break;
                }
                case EngineCore::PipelineNames::STATIC_LIGHTMAP:
                {
                    const auto* lightmapData = static_cast<EngineCore::StaticLightmapMaterialData*>(materialLoadingData.data);
                    registry.emplace<EngineCore::StaticLightmapMaterialData>(materialAsset->data, *lightmapData);
                    break;
                }
            }
 
            // Notify RenderingDataManager that a material has been loaded
            if ( renderingDataManager )
            {
                renderingDataManager->onMaterialLoaded( materialAsset );
            }
 
            it = materialFutures.erase( it );
        }
    }
 
    void ModelAssetPipeline::processMeshData( bool async )
    {
        // First, poll any pending meshlet generation futures (must run even if primitiveDataFutures is empty)
        if ( async && !meshletGenerationFutures.empty() )
        {
            TRACY_ZONE_SCOPED_NAMED( "Poll meshlet generation futures" );
            for ( auto it = meshletGenerationFutures.begin(); it != meshletGenerationFutures.end(); )
            {
                if ( it->valid() && it->wait_for( std::chrono::seconds( 0 ) ) == std::future_status::ready )
                {
                    auto completedGeneration = it->get();
                    PLOGD << "Meshlet generation completed for: " << completedGeneration.meshPath.getFilePath();
 
                    // Queue the completed generation for processing at a safe point
                    // This prevents race conditions with the main thread reading the registry
                    pendingMeshletCompletions_.push_back(std::move(completedGeneration));
 
                    it = meshletGenerationFutures.erase( it );
                }
                else
                {
                    ++it;
                }
            }
        }
 
        if ( primitiveDataFutures.empty() )
            return;
        TRACY_ZONE_SCOPED_NAMED_ASSET( "Dispatching primitive data" );
        for ( auto it = primitiveDataFutures.begin(); it != primitiveDataFutures.end(); )
        {
            TRACY_ZONE_SCOPED_NAMED_ASSET( "Meshlet generation for primitive" );
            Ecs::PrimitiveDataLoading primitiveDataLoadingData;
            if ( async )
            {
                if ( it->valid() && it->wait_for( std::chrono::seconds( 0 ) ) == std::future_status::ready )
                {
                    primitiveDataLoadingData = std::move( it->get() );
                }
                else
                {
                    ++it;
                    continue;
                }
            }
            else
            {
                primitiveDataLoadingData = std::move( it->get() );
            }
 
            auto & registry = RegistryManager::get();
            EngineCore::MeshAsset * meshAsset = EngineCore::UnpackOptional( meshAssetManager->getAsset( primitiveDataLoadingData.path ) );
            MeshPrimitiveData & data = registry.emplace<Ecs::MeshPrimitiveData>( meshAsset->data );
            data.primitives.resize( primitiveDataLoadingData.data.size() );
            {
                TRACY_ZONE_SCOPED_NAMED( "Set material paths" );
                // Only set material paths here - raw primitive data goes directly to background task
                PLOGI << "processMeshData: Setting material paths for " << primitiveDataLoadingData.data.size()
                      << " primitives (mesh: " << primitiveDataLoadingData.path.getAssetHandle()
                      << " entity=" << static_cast<uint32_t>(meshAsset->data) << ")";
                for ( uint32_t i = 0; i < primitiveDataLoadingData.data.size(); ++i )
                {
                    // Don't store raw data in ECS - it will be moved directly to background task
                    // data.primitives[i].data will be populated with optimized data after meshlet generation
                    if ( i < primitiveDataLoadingData.materialPaths.size() )
                    {
                        data.primitives[i].materialPath = primitiveDataLoadingData.materialPaths[i];
                        PLOGI << "  primitive[" << i << "] materialPath = "
                              << (primitiveDataLoadingData.materialPaths[i].empty() ? "(empty)" : primitiveDataLoadingData.materialPaths[i].getAssetHandle());
                    }
                    else
                    {
                        PLOGW << "  primitive[" << i << "] has no materialPath (index out of range)";
                    }
                }
            }
 
            {
                TRACY_ZONE_SCOPED_NAMED( "Submit meshlet generation tasks" );
                // Move input data directly to background task - no intermediate ECS storage
                // This avoids expensive copy of vertex/index data on main thread
                entt::entity meshEntity = meshAsset->getEntity();
 
                meshletGenerationFutures.push_back( threadPool->submit_task(
                    [path = primitiveDataLoadingData.path, meshEntity,
                     inputPrimitives = std::move(primitiveDataLoadingData.data)]() mutable -> CompletedMeshletGeneration
                    {
                        CompletedMeshletGeneration result;
                        result.meshPath = path;
                        result.meshEntity = meshEntity;
                        result.primitiveResults.reserve(inputPrimitives.size());
 
                        std::vector<glm::vec3> allMeshPoints; // For mesh bounding sphere
 
                        for (auto& inputData : inputPrimitives)
                        {
                            TRACY_ZONE_SCOPED_NAMED_ASSET( "Generate Meshlets" );
 
                            PrimitiveMeshletResult primResult;
 
                            if (inputData.vertices.empty() || inputData.indices.empty()) {
                                result.primitiveResults.push_back(std::move(primResult));
                                continue;
                            }
 
                            auto inVertices = inputData.vertices;
                            auto inIndices  = inputData.indices;
 
                            PLOGI << "=== GENERATE MESHLETS STARTED ===";
                            PLOGI << "Starting meshlet generation - vertices: " << inVertices.size()
                                  << ", indices: " << inIndices.size();
 
                            // --- 0. Vertex Optimization ---
                            std::vector<uint32_t> remap( inVertices.size() );
                            size_t uniqueVertexCount;
                            {
                                TRACY_ZONE_SCOPED_NAMED( "Generate Vertex Remap" );
                                uniqueVertexCount = meshopt_generateVertexRemap(
                                    remap.data(),
                                    inIndices.data(),
                                    inIndices.size(),
                                    inVertices.data(),
                                    inVertices.size(),
                                    sizeof( Vertex )
                                );
                            }
 
                            {
                                std::vector<Vertex>   uniqueVertices( uniqueVertexCount );
                                std::vector<uint32_t> uniqueIndices( inIndices.size() );
 
                                {
                                    TRACY_ZONE_SCOPED_NAMED( "Remap vertex buffer" );
                                    meshopt_remapVertexBuffer(
                                        uniqueVertices.data(),
                                        inVertices.data(),
                                        inVertices.size(),
                                        sizeof( Vertex ),
                                        remap.data()
                                    );
                                }
                                {
                                    TRACY_ZONE_SCOPED_NAMED( "Remap index buffer" );
                                    meshopt_remapIndexBuffer(
                                        uniqueIndices.data(), inIndices.data(), inIndices.size(), remap.data()
                                    );
                                }
 
                                // Store optimized data in result
                                primResult.optimizedData.vertices = std::move(uniqueVertices);
                                primResult.optimizedData.indices = std::move(uniqueIndices);
                            }
 
                            {
                                TRACY_ZONE_SCOPED_NAMED( "Optimize vertex cache" );
                                meshopt_optimizeVertexCache(
                                    primResult.optimizedData.indices.data(),
                                    primResult.optimizedData.indices.data(),
                                    primResult.optimizedData.indices.size(),
                                    primResult.optimizedData.vertices.size()
                                );
                            }
                            {
                                TRACY_ZONE_SCOPED_NAMED( "Optimize vertex fetch" );
                                meshopt_optimizeVertexFetch(
                                    primResult.optimizedData.vertices.data(),
                                    primResult.optimizedData.indices.data(),
                                    primResult.optimizedData.indices.size(),
                                    primResult.optimizedData.vertices.data(),
                                    primResult.optimizedData.vertices.size(),
                                    sizeof( Vertex )
                                );
                            }
 
                            // --- 1. Meshlet Generation ---
                            constexpr size_t maxVerticesPerMeshlet  = 252;
                            constexpr size_t maxTrianglesPerMeshlet = 252;
                            constexpr float  coneWeight             = 0.5f;
                            size_t maxMeshlets;
                            {
                                TRACY_ZONE_SCOPED_NAMED( "Generate meshlet bounds" );
                                maxMeshlets = meshopt_buildMeshletsBound(
                                    primResult.optimizedData.indices.size(), maxVerticesPerMeshlet, maxTrianglesPerMeshlet
                                );
                            }
 
                            primResult.meshletData.meshlets.resize( maxMeshlets );
                            primResult.meshletData.meshletVertices.resize(
                                maxMeshlets * maxVerticesPerMeshlet
                            );
                            primResult.meshletData.meshletTriangles.resize(
                                maxMeshlets * maxTrianglesPerMeshlet * 3
                            );
                            size_t meshletCount;
                            {
                                TRACY_ZONE_SCOPED_NAMED( "Build meshlets" );
                                meshletCount = meshopt_buildMeshlets(
                                    primResult.meshletData.meshlets.data(),
                                    primResult.meshletData.meshletVertices.data(),
                                    primResult.meshletData.meshletTriangles.data(),
                                    primResult.optimizedData.indices.data(),
                                    primResult.optimizedData.indices.size(),
                                    &primResult.optimizedData.vertices[0].position.x,
                                    primResult.optimizedData.vertices.size(),
                                    sizeof( Vertex ),
                                    maxVerticesPerMeshlet,
                                    maxTrianglesPerMeshlet,
                                    coneWeight
                                );
                            }
 
                            // --- 2. Finalize and Optimize within Meshlets ---
                            {
                                TRACY_ZONE_SCOPED_NAMED( "Optimize meshlets" );
                                if ( meshletCount > 0 )
                                {
                                    const auto & [vertex_offset, triangle_offset, vertex_count, triangle_count] =
                                        primResult.meshletData.meshlets[meshletCount - 1];
 
                                    primResult.meshletData.meshlets.resize( meshletCount );
                                    primResult.meshletData.meshletVertices.resize(
                                        vertex_offset + vertex_count
                                    );
                                    primResult.meshletData.meshletTriangles.resize(
                                        triangle_offset + ( triangle_count * 3 )
                                    );
 
                                    for ( size_t i = 0; i < meshletCount; ++i )
                                    {
                                        const meshopt_Meshlet & m = primResult.meshletData.meshlets[i];
                                        meshopt_optimizeMeshlet(
                                            &primResult.meshletData.meshletVertices[m.vertex_offset],
                                            &primResult.meshletData.meshletTriangles[m.triangle_offset],
                                            m.triangle_count,
                                            m.vertex_count
                                        );
                                    }
                                }
                                else
                                {
                                    primResult.meshletData.meshlets.clear();
                                    primResult.meshletData.meshletVertices.clear();
                                    primResult.meshletData.meshletTriangles.clear();
                                }
                            }
 
                            // --- 3. Pre-unpack vertex/triangle data for GPU (avoids main thread stall) ---
                            {
                                TRACY_ZONE_SCOPED_NAMED( "Pre-unpack meshlet data" );
 
                                // Calculate total counts for pre-allocation
                                size_t totalVertices = 0;
                                size_t totalTriangles = 0;
                                for (const auto& meshlet : primResult.meshletData.meshlets) {
                                    totalVertices += meshlet.vertex_count;
                                    totalTriangles += meshlet.triangle_count;
                                }
 
                                primResult.unpackedData.vertices.reserve(totalVertices);
                                primResult.unpackedData.triangles.reserve(totalTriangles);
 
                                const auto& primitiveVertices = primResult.optimizedData.vertices;
                                const auto& meshletVerticesData = primResult.meshletData.meshletVertices;
                                const auto& meshletTrianglesData = primResult.meshletData.meshletTriangles;
 
                                for (const auto& meshlet : primResult.meshletData.meshlets) {
                                    // Unpack vertices: resolve local indices to actual vertex data
                                    for (uint32_t i = 0; i < meshlet.vertex_count; ++i) {
                                        uint32_t local_vertex_index = meshletVerticesData[meshlet.vertex_offset + i];
                                        primResult.unpackedData.vertices.push_back(primitiveVertices[local_vertex_index]);
                                    }
 
                                    // Pack triangles: store 3 x 8-bit indices in single uint32 (4x bandwidth reduction)
                                    for (uint32_t i = 0; i < meshlet.triangle_count; ++i) {
                                        const uint8_t* base_idx_ptr = &meshletTrianglesData[meshlet.triangle_offset + i * 3];
                                        primResult.unpackedData.triangles.push_back(
                                            Ecs::PackedTriangle::pack(base_idx_ptr[0], base_idx_ptr[1], base_idx_ptr[2]));
                                    }
                                }
 
                                PLOGI << "Pre-unpacked " << totalVertices << " vertices, "
                                      << totalTriangles << " triangles on background thread";
                            }
 
                            {
                                TRACY_ZONE_SCOPED_NAMED( "Generate primitive bounds" );
                                std::vector<glm::vec3> primitivePoints;
                                primitivePoints.reserve( primResult.optimizedData.vertices.size() );
                                for ( const auto & v : primResult.optimizedData.vertices )
                                {
                                    primitivePoints.push_back( v.position );
                                    allMeshPoints.push_back( v.position );
                                }
                                Math::BoundingSphere::calculate( primResult.boundingSphere, primitivePoints );
                            }
 
                            PLOGI << "Generated " << primResult.meshletData.meshlets.size()
                                  << " meshlets for primitive ("
                                  << primResult.optimizedData.indices.size() / 3 << " triangles).";
 
                            // Generate LOD hierarchy if mesh has enough meshlets
                            if (primResult.meshletData.meshlets.size() >= 4) {
                                TRACY_ZONE_SCOPED_NAMED( "Generate LOD Hierarchy" );
 
                                EngineCore::LodGenerationConfig lodConfig;
                                lodConfig.maxTrianglesPerCluster = 128;
                                lodConfig.simplificationRatio = 0.5f;
                                lodConfig.targetError = 0.01f;
                                lodConfig.maxLodLevels = 6;
                                lodConfig.minTrianglesForLod = 256;
 
                                primResult.lodHierarchy = EngineCore::ClusterLodGenerator::generate(
                                    primResult.optimizedData.vertices,
                                    primResult.optimizedData.indices,
                                    primResult.meshletData.meshlets,
                                    primResult.meshletData.meshletVertices,
                                    primResult.meshletData.meshletTriangles,
                                    lodConfig
                                );
 
                                if (primResult.lodHierarchy.has_value() &&
                                    primResult.lodHierarchy->lodLevelCount > 1) {
                                    VS_LOG(LogLOD, Warning, "[DIAG] Generated LOD hierarchy: {} levels, {} clusters, {} groups, {} total meshlets",
                                          primResult.lodHierarchy->lodLevelCount,
                                          primResult.lodHierarchy->clusters.size(),
                                          primResult.lodHierarchy->groups.size(),
                                          primResult.lodHierarchy->meshletData.meshlets.size());
                                } else {
                                    VS_LOG(LogLOD, Warning, "[DIAG] LOD generation returned empty (triangles={}, minRequired=256)",
                                          primResult.optimizedData.indices.size() / 3);
                                }
                            } else {
                                VS_LOG(LogLOD, Warning, "[DIAG] Skipping LOD: only {} meshlets (need >= 4)",
                                      primResult.meshletData.meshlets.size());
                            }
 
                            result.primitiveResults.push_back(std::move(primResult));
                        }
 
                        // Calculate the overall mesh bounding sphere
                        {
                            TRACY_ZONE_SCOPED_NAMED_ASSET( "Generate mesh bounds" );
                            Math::BoundingSphere::calculate( result.meshBoundingSphere, allMeshPoints );
                        }
 
                        return result;
                    }
                ) );
 
                it = primitiveDataFutures.erase( it );
            }
        }
 
        // Handle meshlet generation futures based on async mode
        if ( !async && !meshletGenerationFutures.empty() )
        {
            // Synchronous: wait for all meshlet generation tasks to complete
            TRACY_ZONE_SCOPED_NAMED( "Wait for meshlet generation" );
            for ( auto & future : meshletGenerationFutures )
            {
                auto completedGeneration = future.get();
 
                // Queue the completed generation for processing at a safe point
                pendingMeshletCompletions_.push_back(std::move(completedGeneration));
            }
            meshletGenerationFutures.clear();
        }
    }
 
    std::vector<CompletedMeshletGeneration> ModelAssetPipeline::takePendingMeshletCompletions()
    {
        std::vector<CompletedMeshletGeneration> result = std::move(pendingMeshletCompletions_);
        pendingMeshletCompletions_.clear();
        return result;
    }
 
void ModelAssetPipeline::processTextures( EngineCore::ModelAsset * modelAsset,
                                              const std::filesystem::path & modelPath )
    {
        TRACY_ZONE_SCOPED_NAMED_ASSET( "Process glTF Textures" );
 
        if ( !modelAsset || !modelAsset->model.has_value() )
        {
            PLOGW << "Cannot process textures: model asset is null or model not loaded";
            return;
        }
 
        tinygltf::Model & model = modelAsset->model.value();
 
        for ( size_t i = 0; i < model.images.size(); ++i )
        {
            TRACY_ZONE_SCOPED_NAMED_ASSET( "Processing texture" );
            tinygltf::Image & image = model.images[i];
 
            // Determine the texture path - use URI for external files, or generate path for embedded
            std::filesystem::path texturePath;
            {
                TRACY_ZONE_SCOPED_NAMED( "Getting Texture Path" );
                if ( !image.uri.empty() )
                {
                    // External image file - resolve relative to the model file
                    texturePath = modelPath.parent_path() / image.uri;
                }
                else if ( !image.name.empty() )
                {
                    // Embedded image with a name - use model path + name as key
                    texturePath = modelPath.parent_path() / image.name;
                }
                else
                {
                    // Embedded image without name - use model path + index as key
                    texturePath = modelPath.parent_path() / ( "image_" + std::to_string( i ) );
                }
            }
 
            // Check if texture is already registered (avoid duplicates)
            if ( textureAssetManager->getAsset( texturePath ).has_value() )
            {
                PLOGD << "Texture already registered: " << texturePath;
                continue;
            }
 
            PLOGD << "processTextures - imageIndex=" << i << " path=" << texturePath << " dims=" << image.width << "x" << image.height;
 
            // Create and register the texture asset
            auto * textureAsset = new EngineCore::GltfTextureAsset();
            textureAssetManager->add( texturePath, textureAsset );
            modelAsset->registerCreatedAssetWithModel( textureAsset );
 
            PLOGD << "processTextures - created textureAsset with entity=" << static_cast<uint32_t>(textureAsset->getEntity()) << " for path=" << texturePath;
 
            // Set the image data - tinygltf has already loaded the pixel data
            textureAsset->setImage( std::move( image ) );
 
            // Notify RenderingDataManager to create Vulkan texture and register with AssetManager
            if ( renderingDataManager )
            {
                renderingDataManager->onTextureLoaded( textureAsset, texturePath );
            }
        }
 
        // Process lightmap textures from node extensions
        // Lightmaps are EXR files specified in VulkanSchnee extension, not part of GLTF images array
        {
            TRACY_ZONE_SCOPED_NAMED_ASSET( "Process lightmap textures" );
            std::set<std::filesystem::path> processedLightmaps;  // Avoid duplicates
 
            // Pre-register lightmap handles BEFORE loading, so onTextureLoaded can find them
            // This mirrors the pre-registration we do for regular textures
            EngineCore::TextureHandleRegistry* textureRegistry = assetManager_ ? assetManager_->getTextureHandleRegistry() : nullptr;
            if ( textureRegistry )
            {
                for ( const tinygltf::Node & node : model.nodes )
                {
                    if ( node.extensions.empty() )
                        continue;
 
                    EngineCore::GltfLoader::StaticMeshExtensions nodeExtensions( node.extensions );
 
                    if ( nodeExtensions.vulkanSchneeExtension.has_value() &&
                         nodeExtensions.vulkanSchneeExtension->hasLightmapProperties() &&
                         nodeExtensions.vulkanSchneeExtension->lightProperties.has_value() &&
                         nodeExtensions.vulkanSchneeExtension->lightProperties->getHasLightmaps() &&
                         nodeExtensions.vulkanSchneeExtension->lightmapProperties->isLightmapPathValid() )
                    {
                        const auto & relativeLightmapPath = nodeExtensions.vulkanSchneeExtension->lightmapProperties->lightmapPath;
                        std::filesystem::path lightmapPath = modelPath.parent_path() / relativeLightmapPath;
                        std::filesystem::path absoluteLightmapPath = std::filesystem::absolute( lightmapPath );
 
                        // Pre-create handle with Lightmap type (HDR float format)
                        textureRegistry->getOrCreateHandle<EngineCore::TextureType::Lightmap>( absoluteLightmapPath );
                    }
                }
                PLOGI << "Pre-registered lightmap texture handles";
            }
 
            for ( const tinygltf::Node & node : model.nodes )
            {
                if ( node.extensions.empty() )
                    continue;
 
                EngineCore::GltfLoader::StaticMeshExtensions nodeExtensions( node.extensions );
 
                // Check if node has lightmap properties
                if ( nodeExtensions.vulkanSchneeExtension.has_value() &&
                     nodeExtensions.vulkanSchneeExtension->hasLightmapProperties() &&
                     nodeExtensions.vulkanSchneeExtension->lightProperties.has_value() &&
                     nodeExtensions.vulkanSchneeExtension->lightProperties->getHasLightmaps() &&
                     nodeExtensions.vulkanSchneeExtension->lightmapProperties->isLightmapPathValid() )
                {
                    // Resolve lightmap path relative to the GLTF file
                    const auto & relativeLightmapPath = nodeExtensions.vulkanSchneeExtension->lightmapProperties->lightmapPath;
                    std::filesystem::path lightmapPath = modelPath.parent_path() / relativeLightmapPath;
 
                    // Resolve to absolute path for consistent handling
                    std::filesystem::path absoluteLightmapPath = std::filesystem::absolute( lightmapPath );
 
                    // Skip if already processed
                    if ( processedLightmaps.count( absoluteLightmapPath ) > 0 )
                        continue;
                    processedLightmaps.insert( absoluteLightmapPath );
 
                    // Check if texture is already registered
                    if ( textureAssetManager->getAsset( absoluteLightmapPath ).has_value() )
                    {
                        PLOGD << "Lightmap texture already registered: " << absoluteLightmapPath;
                        continue;
                    }
 
                    // Check if the lightmap file exists
                    PLOGI << "Lightmap path resolution: relative=" << relativeLightmapPath
                          << " resolved=" << lightmapPath
                          << " absolute=" << absoluteLightmapPath;
 
                    if ( !std::filesystem::exists( absoluteLightmapPath ) )
                    {
                        PLOGW << "Lightmap EXR file not found: " << absoluteLightmapPath;
                        continue;
                    }
 
                    // Load the EXR lightmap texture (use absolute path for reliability)
                    PLOGI << "Loading lightmap EXR: " << absoluteLightmapPath;
                    EngineCore::ExrLoader exrLoader;
                    tinygltf::Image lightmapImage = exrLoader.load( absoluteLightmapPath );
 
                    // Check if EXR loading succeeded
                    if ( lightmapImage.image.empty() || lightmapImage.width == 0 || lightmapImage.height == 0 )
                    {
                        PLOGW << "Failed to load lightmap EXR (empty image): " << lightmapPath;
                        continue;
                    }
 
                    // Create and register the texture asset (use absolute path as key for consistency)
                    auto * textureAsset = new EngineCore::GltfTextureAsset();
                    textureAssetManager->add( absoluteLightmapPath, textureAsset );
                    modelAsset->registerCreatedAssetWithModel( textureAsset );
 
                    // Set the image data
                    textureAsset->setImage( std::move( lightmapImage ) );
 
                    // Notify RenderingDataManager to create Vulkan texture and register with AssetManager
                    if ( renderingDataManager )
                    {
                        renderingDataManager->onTextureLoaded( textureAsset, absoluteLightmapPath );
                    }
 
                    PLOGI << "Loaded lightmap texture: " << absoluteLightmapPath;
                }
            }
        }
    }
}  // namespace Ecs