Function LoadGeometry

amd_geometryfx_sample/src/GeometryFX_Sample.cpp:396–451

}

std::vector<AMD::GeometryFX_Filter::MeshHandle> LoadGeometry(
    const char *filename, AMD::GeometryFX_Filter &meshManager, const int chunkSize = 65535)
{
    const auto propertyStore = aiCreatePropertyStore ();
    aiSetImportPropertyInteger (propertyStore,
        AI_CONFIG_PP_SLM_TRIANGLE_LIMIT, chunkSize);
    aiSetImportPropertyInteger (propertyStore,
        AI_CONFIG_PP_SBP_REMOVE, aiPrimitiveType_LINE | aiPrimitiveType_POINT);
    aiSetImportPropertyInteger (propertyStore,
        AI_CONFIG_PP_PTV_NORMALIZE, 1);

    const auto pScene = aiImportFileExWithProperties (filename,
        aiProcess_Triangulate | aiProcess_ConvertToLeftHanded | aiProcess_SortByPType |
        aiProcess_JoinIdenticalVertices | aiProcess_SplitLargeMeshes |
        aiProcess_PreTransformVertices,
        nullptr,
        propertyStore);

    if (pScene)
    {
        std::vector<int> indexCounts;
        std::vector<int> vertexCounts;
        for (unsigned int i = 0; i < pScene->mNumMeshes; ++i)
        {
            indexCounts.push_back(pScene->mMeshes[i]->mNumFaces * 3);
            vertexCounts.push_back(pScene->mMeshes[i]->mNumVertices);
        }

        auto handles =
            meshManager.RegisterMeshes(pScene->mNumMeshes, vertexCounts.data(), indexCounts.data());

        for (unsigned int i = 0; i < pScene->mNumMeshes; ++i)
        {
            // The mesh is triangulated, so we can use 3 indices per face here
            std::vector<int> indices(pScene->mMeshes[i]->mNumFaces * 3);
            for (unsigned j = 0; j < pScene->mMeshes[i]->mNumFaces; ++j)
            {
                for (int k = 0; k < 3; ++k)
                {
                    indices[j * 3 + k] = pScene->mMeshes[i]->mFaces[j].mIndices[k];
                }
            }

            meshManager.SetMeshData(handles[i], pScene->mMeshes[i]->mVertices, indices.data());
        }

        aiReleaseImport (pScene);
        aiReleasePropertyStore (propertyStore);

        return handles;
    }

    aiReleasePropertyStore (propertyStore);

    return std::vector<AMD::GeometryFX_Filter::MeshHandle>();
}

class Application