GltfSpawner.cpp

Go to the documentation of this file.

#include "Engine/Entity/GltfSpawner.h"
#include "Engine/Entity/Scene.h"
#include "Engine/Entity/StaticMeshActor.h"
#include "Engine/Files/AssetPath.h"
#include "Engine/Mesh/GltfLoader.h"
#include "Engine/Mesh/AssetManager.h"
#include "Engine/World/Transform.h"
#include <glm/gtc/type_ptr.hpp>
 
namespace EngineCore {
 
    namespace {
        // Extract transform from tinygltf node
        Ecs::LocalTransform extractNodeTransform(const tinygltf::Node& node) {
            Transform transform;
 
            if (!node.translation.empty()) {
                transform.setLocation(glm::vec3(
                    node.translation[0],
                    node.translation[1],
                    node.translation[2]
                ));
            }
 
            if (!node.rotation.empty()) {
                // tinygltf stores quaternion as [x, y, z, w]
                transform.setRotationQuat(glm::quat(
                    static_cast<float>(node.rotation[3]),  // w
                    static_cast<float>(node.rotation[0]),  // x
                    static_cast<float>(node.rotation[1]),  // y
                    static_cast<float>(node.rotation[2])   // z
                ));
            }
 
            if (!node.scale.empty()) {
                transform.setScale(glm::vec3(
                    node.scale[0],
                    node.scale[1],
                    node.scale[2]
                ));
            }
 
            return Ecs::LocalTransform{ transform.toMatrix() };
        }
    }
 
    std::vector<StaticMeshActor*> GltfSpawner::spawnAll(
        Scene* scene,
        const std::filesystem::path& gltfPath)
    {
        std::vector<StaticMeshActor*> spawnedActors;
 
        // 1. Quick metadata-only parse - skips ALL buffer/image loading
        //    Only parses JSON structure to get node names and transforms
        GltfLoader loader;
        tinygltf::Model model = loader.loadMetadataOnly(gltfPath);
 
        // 2. Submit to async pipeline for heavy processing (vertex data, meshlets, etc.)
        //    This happens on background threads
        AssetManager* assetManager = scene->getAssetManager();
        if (assetManager) {
            assetManager->loadEcsModel(gltfPath);
        }
 
        // 3. Create actors immediately using the parsed metadata
        //    The actual mesh data will arrive later through the async pipeline
        spawnedActors.reserve(model.nodes.size());
 
        for (const tinygltf::Node& node : model.nodes) {
            // Skip nodes without meshes (cameras, lights, empties, armatures)
            if (node.mesh < 0) {
                continue;
            }
 
            Asset::Path meshPath(gltfPath, node.name);
            Ecs::LocalTransform spawnTransform = extractNodeTransform(node);
 
            auto* actor = scene->spawnActor<StaticMeshActor>(spawnTransform, meshPath);
            spawnedActors.push_back(actor);
        }
 
        return spawnedActors;
    }
 
}