LoadPack()

bool Spices::GltfLoader::LoadPack ( GltfPack * pack, const GltfMeshes::Primitive & primitive, GltfAccessors * accessors, GltfBuffers * buffers, GltfBufferViews * bufferViews )

static

Load a gltf mesh to GltfPack.

Parameters

[in]	pack	GltfPack.
[in]	primitive	Gltf Primitive.
[in]	accessors	Gltf Accessors.
[in]	buffers	Gltf Buffers.
[in]	bufferViews	Gltf BufferViews. @reutrn Returns true if load succeed.

Definition at line 57 of file GltfLoader.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        // Positions
        {
            if (primitive.POSITION < 0)
            {
                SPICES_CORE_ERROR("Positions buffer invalid.")
                return false;
            }
            const GltfAccessors::Item& positionAccessor     = accessors->m_AccessorsData[primitive.POSITION];
            const GltfBufferViews::Item& positionBufferView = bufferViews->m_BufferViewsData[positionAccessor.bufferView];
            const GltfBuffers::Item& positionBuffer         = buffers->m_BuffersData[positionBufferView.buffer];
 
            const VkFormat format                           = GltfHelper::GetFormat(positionAccessor.type, positionAccessor.componentType);
            const uint32_t bytes                            = GltfHelper::SizeOfFormat(format);
 
            pack->m_MeshResource.positions.attributes->resize(positionAccessor.count);
            for (uint32_t i = 0; i < pack->m_MeshResource.positions.attributes->size(); i++)
            {
                const uint32_t offset = i * bytes;
 
                auto p = reinterpret_cast<glm::vec3*>(&(*positionBuffer.buffer)[positionAccessor.byteOffset + positionBufferView.byteOffset + offset]);
                (*pack->m_MeshResource.positions.attributes)[i] = *p;
 
                glm::vec3& pos = (*pack->m_MeshResource.positions.attributes)[i];
                pos.z = -pos.z;
            }
        }
 
        // Normals
        bool hasNormal = false;
        {
            if (primitive.NORMAL < 0)
            {
                  pack->m_MeshResource.normals.attributes->resize(1);
                (*pack->m_MeshResource.normals.attributes)[0] = glm::vec3(0.0f, 1.0f, 0.0f);
            }
            else
            {
                hasNormal = true;
 
                const GltfAccessors::Item& normalAccessor     = accessors->m_AccessorsData[primitive.NORMAL];
                const GltfBufferViews::Item& normalBufferView = bufferViews->m_BufferViewsData[normalAccessor.bufferView];
                const GltfBuffers::Item& normalBuffer         = buffers->m_BuffersData[normalBufferView.buffer];
 
                const VkFormat format                         = GltfHelper::GetFormat(normalAccessor.type, normalAccessor.componentType);
                const uint32_t bytes                          = GltfHelper::SizeOfFormat(format);
 
                pack->m_MeshResource.normals.attributes->resize(normalAccessor.count);
                for (uint32_t i = 0; i < pack->m_MeshResource.normals.attributes->size(); i++)
                {
                    const uint32_t offset = i * bytes;
 
                    auto n = reinterpret_cast<glm::vec3*>(&(*normalBuffer.buffer)[normalAccessor.byteOffset + normalBufferView.byteOffset + offset]);
                    (*pack->m_MeshResource.normals.attributes)[i] = *n;
 
                    glm::vec3& nor = (*pack->m_MeshResource.normals.attributes)[i];
                    nor.z = -nor.z;
                }
            }
        }
        
        // Colors
        bool hasColor = false;
        {
              pack->m_MeshResource.colors.attributes->resize(1);
            (*pack->m_MeshResource.colors.attributes)[0] = glm::vec3(0.0f);
        }
 
        // TexCoords
        bool hasTexCoords = false;
        {
            if (primitive.TEXCOORD_0 < 0)
            {
                  pack->m_MeshResource.texCoords.attributes->resize(1);
                (*pack->m_MeshResource.texCoords.attributes)[0] = glm::vec2(0.0f);
            }
            else
            {
                hasTexCoords = true;
 
                const GltfAccessors::Item& texCoordAccessor     = accessors->m_AccessorsData[primitive.TEXCOORD_0];
                const GltfBufferViews::Item& texCoordBufferView = bufferViews->m_BufferViewsData[texCoordAccessor.bufferView];
                const GltfBuffers::Item& texCoordBuffer         = buffers->m_BuffersData[texCoordBufferView.buffer];
 
                const VkFormat format                           = GltfHelper::GetFormat(texCoordAccessor.type, texCoordAccessor.componentType);
                const uint32_t bytes                            = GltfHelper::SizeOfFormat(format);
 
                pack->m_MeshResource.texCoords.attributes->resize(texCoordAccessor.count);
                for (uint32_t i = 0; i < pack->m_MeshResource.texCoords.attributes->size(); i++)
                {
                    const uint32_t offset = i * bytes;
 
                    auto u = reinterpret_cast<glm::vec2*>(&(*texCoordBuffer.buffer)[texCoordAccessor.byteOffset + texCoordBufferView.byteOffset + offset]);
                    (*pack->m_MeshResource.texCoords.attributes)[i] = *u;
 
                    glm::vec2& uv = (*pack->m_MeshResource.texCoords.attributes)[i];
                    //uv.y = 1.0f - uv.y;
                }
            }
        }
 
        // Vertices
        {
            const GltfAccessors::Item& positionAccessor = accessors->m_AccessorsData[primitive.POSITION];
 
            pack->m_MeshResource.vertices.attributes->resize(positionAccessor.count);
            
            for(uint32_t i = 0; i < pack->m_MeshResource.vertices.attributes->size(); i++)
            {
                (*pack->m_MeshResource.vertices.attributes)[i] = glm::uvec4(i, hasNormal ? i : 0, hasColor ? i : 0, hasTexCoords ? i: 0);
            }
        }
 
        // primVertices
        {
            if (primitive.indices < 0)
            {
                SPICES_CORE_ERROR("indices buffer invalid.")
                return false;
            }
            const GltfAccessors::Item& indicesAccessor     = accessors->m_AccessorsData[primitive.indices];
            const GltfBufferViews::Item& indicesBufferView = bufferViews->m_BufferViewsData[indicesAccessor.bufferView];
            const GltfBuffers::Item& indicesBuffer         = buffers->m_BuffersData[indicesBufferView.buffer];
 
            const VkFormat format                          = GltfHelper::GetFormat(indicesAccessor.type, indicesAccessor.componentType);
            const uint32_t bytes                           = GltfHelper::SizeOfFormat(format);
 
            pack->m_MeshResource.primitiveVertices.attributes->resize(indicesAccessor.count / 3);
            for (uint32_t i = 0; i < pack->m_MeshResource.primitiveVertices.attributes->size(); i++)
            {
                const uint32_t offset = i * 3 * bytes;
 
                auto x = reinterpret_cast<unsigned short*>(&(*indicesBuffer.buffer)[indicesAccessor.byteOffset + indicesBufferView.byteOffset + offset + 0]);
                auto y = reinterpret_cast<unsigned short*>(&(*indicesBuffer.buffer)[indicesAccessor.byteOffset + indicesBufferView.byteOffset + offset + bytes]);
                auto z = reinterpret_cast<unsigned short*>(&(*indicesBuffer.buffer)[indicesAccessor.byteOffset + indicesBufferView.byteOffset + offset + bytes * 2]);
 
                (*pack->m_MeshResource.primitiveVertices.attributes)[i] = glm::uvec3(*x, *y, *z);
            }
        }
 
        return true;
    }

References Spices::GltfBufferViews::Item::buffer, Spices::GltfAccessors::Item::bufferView, Spices::GltfAccessors::Item::byteOffset, Spices::GltfBufferViews::Item::byteOffset, Spices::GltfAccessors::Item::count, Spices::GltfMeshes::Primitive::indices, Spices::GltfMeshes::Primitive::NORMAL, Spices::GltfMeshes::Primitive::POSITION, and Spices::GltfMeshes::Primitive::TEXCOORD_0.