LoadFromOBJ()

bool Spices::MeshLoader::LoadFromOBJ ( const std::string & fileName, MeshPack * outMeshPack )

staticprivate

Load data from a .obj file.

Parameters

[in]	fileName	Mesh file path in disk.
[in,out]	outMeshPack	mesh pack pointer, only pass this to it.

Returns

Returns true if load data successfully.

Definition at line 54 of file MeshLoader.cpp.

    {
        SPICES_PROFILE_ZONE;
 
        bool isFind = false;
        std::string filePath;
        int index = 0;
        for (auto& it : ResourceSystem::GetSearchFolder())
        {
            filePath = it + defaultOBJMeshPath + fileName + ".obj";
            if (FileLibrary::FileLibrary_Exists(filePath.c_str()))
            {
                isFind = true;
                break;
            }
            index++;
        }
        if (!isFind) return false;
        
        if (!FileLibrary::FileLibrary_Exists(filePath.c_str())) {
            return false;
        }
        
        tinyobj::attrib_t attrib;
        std::vector<tinyobj::shape_t> shapes;
        std::vector<tinyobj::material_t> materials;
        std::string warn, err;
        
        if (!tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, filePath.c_str()))
        {
            return false;
        }
        
        outMeshPack->m_MeshResource.positions.attributes->resize(attrib.vertices.size() / 3);
        for (uint32_t i = 0; i < attrib.vertices.size() / 3; i++)
        {
            (*outMeshPack->m_MeshResource.positions.attributes)[i].x =  attrib.vertices[3 * i + 0];
            (*outMeshPack->m_MeshResource.positions.attributes)[i].y =  attrib.vertices[3 * i + 1];
            (*outMeshPack->m_MeshResource.positions.attributes)[i].z = -attrib.vertices[3 * i + 2];
        }
        if (attrib.vertices.empty())
        {
            outMeshPack->m_MeshResource.positions.attributes->resize(1);
 
            (*outMeshPack->m_MeshResource.positions.attributes)[0].x = 0.0f;
            (*outMeshPack->m_MeshResource.positions.attributes)[0].y = 0.0f;
            (*outMeshPack->m_MeshResource.positions.attributes)[0].z = 0.0f;
        }
 
        outMeshPack->m_MeshResource.normals.attributes->resize(attrib.normals.size() / 3);
        for (uint32_t i = 0; i < attrib.normals.size() / 3; i++)
        {
            (*outMeshPack->m_MeshResource.normals.attributes)[i].x =  attrib.normals[3 * i + 0];
            (*outMeshPack->m_MeshResource.normals.attributes)[i].y =  attrib.normals[3 * i + 1];
            (*outMeshPack->m_MeshResource.normals.attributes)[i].z = -attrib.normals[3 * i + 2];
        }
        if (attrib.normals.empty())
        {
            outMeshPack->m_MeshResource.normals.attributes->resize(1);
 
            (*outMeshPack->m_MeshResource.normals.attributes)[0].x = 0.0f;
            (*outMeshPack->m_MeshResource.normals.attributes)[0].y = 1.0f;
            (*outMeshPack->m_MeshResource.normals.attributes)[0].z = 0.0f;
        }
 
        outMeshPack->m_MeshResource.colors.attributes->resize(attrib.colors.size() / 3);
        for (uint32_t i = 0; i < attrib.colors.size() / 3; i++)
        {
            (*outMeshPack->m_MeshResource.colors.attributes)[i].x = attrib.colors[3 * i + 0];
            (*outMeshPack->m_MeshResource.colors.attributes)[i].y = attrib.colors[3 * i + 1];
            (*outMeshPack->m_MeshResource.colors.attributes)[i].z = attrib.colors[3 * i + 2];
        }
        if (attrib.colors.empty())
        {
            outMeshPack->m_MeshResource.colors.attributes->resize(1);
 
            (*outMeshPack->m_MeshResource.colors.attributes)[0].x = 1.0f;
            (*outMeshPack->m_MeshResource.colors.attributes)[0].y = 1.0f;
            (*outMeshPack->m_MeshResource.colors.attributes)[0].z = 1.0f;
        }
 
        outMeshPack->m_MeshResource.texCoords.attributes->resize(attrib.texcoords.size() / 2);
        for (uint32_t i = 0; i < attrib.texcoords.size() / 2; i++)
        {
            (*outMeshPack->m_MeshResource.texCoords.attributes)[i].x =        attrib.texcoords[2 * i + 0];
            (*outMeshPack->m_MeshResource.texCoords.attributes)[i].y = 1.0f - attrib.texcoords[2 * i + 1];
        }
        if (attrib.texcoords.empty())
        {
            outMeshPack->m_MeshResource.texCoords.attributes->resize(1);
 
            (*outMeshPack->m_MeshResource.texCoords.attributes)[0].x = 0.0f;
            (*outMeshPack->m_MeshResource.texCoords.attributes)[0].y = 0.0f;
        }
 
        std::unordered_map<glm::uvec4, uint32_t> verticesMap;
        for (const auto& shape : shapes)
        {
            uint32_t start = outMeshPack->m_MeshResource.primitiveVertices.attributes->size();
            outMeshPack->m_MeshResource.primitiveVertices.attributes->resize(start + shape.mesh.indices.size() / 3);
 
            for (uint32_t i = 0; i < shape.mesh.indices.size() / 3; i++)
            {
                std::array<glm::uvec4, 3> vertexArray{};
                for (uint32_t j = 0; j < 3; j++)
                {
                    const auto& ind = shape.mesh.indices[3 * i + j];
 
                    vertexArray[j] = glm::uvec4(
                        ind.vertex_index   == -1 ? 0 : ind.vertex_index,
                        ind.normal_index   == -1 ? 0 : ind.normal_index,
                        ind.vertex_index   == -1 ? 0 : ind.vertex_index,
                        ind.texcoord_index == -1 ? 0 : ind.texcoord_index
                    );
 
                    if (verticesMap.count(vertexArray[j]) == 0)
                    {
                        verticesMap[vertexArray[j]] = static_cast<uint32_t>(outMeshPack->m_MeshResource.vertices.attributes->size());
                        outMeshPack->m_MeshResource.vertices.attributes->push_back(vertexArray[j]);
                    }
                }
 
                (*outMeshPack->m_MeshResource.primitiveVertices.attributes)[start + i].x = verticesMap[vertexArray[0]];
                (*outMeshPack->m_MeshResource.primitiveVertices.attributes)[start + i].y = verticesMap[vertexArray[1]];
                (*outMeshPack->m_MeshResource.primitiveVertices.attributes)[start + i].z = verticesMap[vertexArray[2]];
            }
        }
 
        MeshProcessor::GenerateMeshLodClusterHierarchy(outMeshPack);
        WriteSASSET(index, fileName, outMeshPack);
 
        return true;
    }

References Spices::FileLibrary::FileLibrary_Exists(), Spices::MeshProcessor::GenerateMeshLodClusterHierarchy(), and WriteSASSET().

Referenced by Load().