OnCreatePack()

bool Spices::CubePack::OnCreatePack ( bool isCreateBuffer = true )

overridevirtual

This interface is used for build specific mesh pack data.

Parameters

[in]

isCreateBuffer

Whether it needs to create buffer.

Returns

Returns true if Create Pack successfully.

Reimplemented from Spices::MeshPack.

Definition at line 359 of file MeshPack.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        if (MeshPack::OnCreatePack(isCreateBuffer)) return true;
 
        auto ApplyMatrixInPositions = [&](auto& positions, const glm::mat4& matrix) {
            
            for (uint64_t i = 0; i < positions.size(); i++)
            {
                glm::vec4 p  = matrix * glm::vec4(positions[i], 1.0f);
                positions[i] = { p.x, p.y, p.z };
            }
        };
 
        auto ApplyMatrixInNormals = [&](auto& normals, const glm::mat4& matrix) {
 
            for (uint64_t i = 0; i < normals.size(); i++)
            {
                glm::vec4 n = matrix * glm::vec4(normals[i], 1.0f);
                normals[i]  = { n.x, n.y, n.z };
            }
        };
 
        auto CopyToVertices = [&](auto& resources) {
 
            uint64_t nPositions = m_MeshResource.positions.attributes->size();
            m_MeshResource.positions.attributes->insert(
                m_MeshResource.positions.attributes->end(), 
                resources.positions.attributes->begin(),
                resources.positions.attributes->end()
            );
 
            uint64_t nNormals = m_MeshResource.normals.attributes->size();
            m_MeshResource.normals.attributes->insert(
                m_MeshResource.normals.attributes->end(),
                resources.normals.attributes->begin(),
                resources.normals.attributes->end()
            );
 
            uint64_t nColors = m_MeshResource.colors.attributes->size();
            m_MeshResource.colors.attributes->insert(
                m_MeshResource.colors.attributes->end(),
                resources.colors.attributes->begin(),
                resources.colors.attributes->end()
            );
 
            uint64_t nTexCoords = m_MeshResource.texCoords.attributes->size();
            m_MeshResource.texCoords.attributes->insert(
                m_MeshResource.texCoords.attributes->end(),
                resources.texCoords.attributes->begin(),
                resources.texCoords.attributes->end()
            );
 
            uint64_t nVertices = m_MeshResource.vertices.attributes->size();
            for (auto& vertex : *resources.vertices.attributes)
            {
                m_MeshResource.vertices.attributes->push_back({
                        vertex.x + nPositions ,
                        vertex.y + nNormals   ,
                        vertex.z + nColors    ,
                        vertex.w + nTexCoords
                });
            }
 
            uint64_t nPrimVertices = m_MeshResource.primitiveVertices.attributes->size();
            for (auto& primitiveVertex : *resources.primitiveVertices.attributes)
            {
                m_MeshResource.primitiveVertices.attributes->push_back({
                    primitiveVertex.x + nVertices,
                    primitiveVertex.y + nVertices,
                    primitiveVertex.z + nVertices
                });
            }
        };
 
        // Front
        {
            PlanePack pack(m_Rows, m_Columns);
            pack.OnCreatePack(false);
            const glm::mat4 tran = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -0.5f));
 
            auto& resources = pack.GetResource();
 
            const auto positions = resources.positions.attributes;
            ApplyMatrixInPositions(*positions, tran);
 
            const auto normals = resources.normals.attributes;
            ApplyMatrixInNormals(*normals, tran);
 
            CopyToVertices(resources);
        }
        
        // Back
        {
            PlanePack pack(m_Rows, m_Columns);
            pack.OnCreatePack(false);
            const glm::mat4 tran = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.5f));
            const glm::mat4 rot = glm::toMat4(glm::quat({0.0f, glm::radians(180.0f), 0.0f}));
 
            auto& resources = pack.GetResource();
 
            const auto positions = resources.positions.attributes;
            ApplyMatrixInPositions(*positions, tran * rot);
 
            const auto normals = resources.normals.attributes;
            ApplyMatrixInNormals(*normals, tran * rot);
 
            CopyToVertices(resources);          
        }
        
        // Left
        {
            PlanePack pack(m_Rows, m_Columns);
            pack.OnCreatePack(false);
            const glm::mat4 tran = glm::translate(glm::mat4(1.0f), glm::vec3(0.5f, 0.0f, 0.0f));
            const glm::mat4 rot = glm::toMat4(glm::quat({ 0.0f, glm::radians(-90.0f), 0.0f }));
 
            auto& resources = pack.GetResource();
 
            const auto positions = resources.positions.attributes;
            ApplyMatrixInPositions(*positions, tran * rot);
 
            const auto normals = resources.normals.attributes;
            ApplyMatrixInNormals(*normals, tran * rot);
 
            CopyToVertices(resources);          
        }
        
        // Right
        {
            PlanePack pack(m_Rows, m_Columns);
            pack.OnCreatePack(false);
            const glm::mat4 tran = glm::translate(glm::mat4(1.0f), glm::vec3(-0.5f, 0.0f, 0.0f));
            const glm::mat4 rot = glm::toMat4(glm::quat({ 0.0f, glm::radians(90.0f), 0.0f }));
 
            auto& resources = pack.GetResource();
 
            const auto positions = resources.positions.attributes;
            ApplyMatrixInPositions(*positions, tran * rot);
 
            const auto normals = resources.normals.attributes;
            ApplyMatrixInNormals(*normals, tran * rot);
 
            CopyToVertices(resources);
        }
        
        // Top
        {
            PlanePack pack(m_Rows, m_Columns);
            pack.OnCreatePack(false);
            const glm::mat4 tran = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, -0.5f, 0.0f));
            const glm::mat4 rot = glm::toMat4(glm::quat({ glm::radians(-90.0f), 0.0f, 0.0f }));
 
            auto& resources = pack.GetResource();
 
            const auto positions = resources.positions.attributes;
            ApplyMatrixInPositions(*positions, tran * rot);
 
            const auto normals = resources.normals.attributes;
            ApplyMatrixInNormals(*normals, tran * rot);
 
            CopyToVertices(resources);
        }
        
        // Button
        {
            PlanePack pack(m_Rows, m_Columns);
            pack.OnCreatePack(false);
            const glm::mat4 tran = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.5f, 0.0f));
            const glm::mat4 rot = glm::toMat4(glm::quat({ glm::radians(90.0f), 0.0f, 0.0f }));
 
            auto& resources = pack.GetResource();
 
            const auto positions = resources.positions.attributes;
            ApplyMatrixInPositions(*positions, tran * rot);
 
            const auto normals = resources.normals.attributes;
            ApplyMatrixInNormals(*normals, tran * rot);
 
            CopyToVertices(resources);
        }
        
        if (isCreateBuffer)
        {
            MeshProcessor::GenerateMeshLodClusterHierarchy(this);
            CreateBuffer();
        }
 
        return true;
    }

References Spices::MeshPack::CreateBuffer(), Spices::MeshProcessor::GenerateMeshLodClusterHierarchy(), Spices::MeshPack::GetResource(), m_Columns, m_Rows, Spices::MeshPack::OnCreatePack(), Spices::PlanePack::OnCreatePack(), and Spices::PlanePack::PlanePack().