CreateEntityRecursive()

Entity Spices::GltfCollection::CreateEntityRecursive ( World * world, const std::string & tag, uint32_t node, const glm::mat4 & model, std::shared_ptr< LoadingState > loadingState )

private

Create Entity recursive from gltf file nodes.

Parameters

[in]	world	World Pointer.
[in]	tag	Entity name.
[in]	node	gltf nodes index.
[in]	model	recursive model matrix.
[in]	loadingState	LoadingState.

Create this entity.

‍**

Create this entity.

‍**

Definition at line 60 of file GltfCollection.cpp.

    {
        GltfNodes::Item& item = m_Nodes->m_NodesData[node];
 
        auto self   = shared_from_this();
 
 
        Entity entity = world->CreateEntity(tag);
 
        auto& transformComp = entity.GetComponent<TransformComponent>();
 
        glm::vec3 position;
        glm::vec3 rotation;
        glm::vec3 scale;
 
        DecomposeTransform(model * item.matrix, position, rotation, scale);
        rotation = glm::vec3(glm::degrees(rotation.x), glm::degrees(rotation.y), glm::degrees(rotation.z));
 
        transformComp.SetPosition(position);
        transformComp.SetRotation(rotation);
        transformComp.SetScale(scale);
 
 
        std::vector<Entity> childrens;
 
        for (auto& n : item.children)
        {
            childrens.push_back(CreateEntityRecursive(world, tag, n, item.matrix, loadingState));
        }
 
        if (!childrens.empty())
        {
            auto& entityComp = entity.AddComponent<EntityComponent>();
 
            for (auto& e : childrens)
            {
                entityComp.AddEntity(e);
            }
        }
 
        if (item.mesh < -0.5f)
        {
            return entity;
        }
 
        Mesh::Builder builder;
 
        for (int i = 0; i < self->m_Meshes->m_MeshesData[item.mesh].primitives.size(); i++)
        {
            std::stringstream ss;
            ss << self->m_Meshes->m_MeshesData[item.mesh].name << '_' << node;
 
            std::shared_ptr<GltfPack> pack = std::make_shared<GltfPack>(ss.str(), [&](GltfPack* gltfPack) {
                GltfLoader::LoadPack(gltfPack, self->m_Meshes->m_MeshesData[item.mesh].primitives[i], self->m_Accessors.get(), self->m_Buffers.get(), self->m_BufferViews.get());
            });
 
            std::shared_ptr<Material> material = GltfLoader::LoadMaterial(self->m_Materials->m_MaterialsData[self->m_Meshes->m_MeshesData[item.mesh].primitives[i].material], self->m_Images.get());
 
            pack->SetMaterial(material);
 
            builder.AddPack(pack);
        }
 
        std::shared_ptr<Mesh> mesh = builder.Build();
 
        auto& meshComp = entity.AddComponent<MeshComponent>();
 
        meshComp.SetMesh(mesh);
 
        //++loadingState->loadedMeshes;
 
        //* @brief Mark the world with MeshAddedToWorld bit.
        //*/
        //if (loadingState->loadedMeshes.load() == self->m_Meshes->GetNMeshes())
        //{
        //  world->Mark(World::WorldMarkBits::MeshAddedToWorld);
        //}
 
        return entity;
 
    }

References Spices::World::CreateEntity(), and Spices::GltfNodes::Item::mesh.