01-Assimp库解析网格文件

解析STL文件，获取Mesh结构数据

struct Vector3f
{
    float x;
    float y;
    float z;
};

struct Vertex {
    Vector3f position;
    Vector3f normal;
};

struct TriangleFace {
    unsigned int indices[3];
    float faceNormalX, faceNormalY, faceNormalZ;
};

struct MeshData {
    unsigned int vertexCount;
    unsigned int faceCount;
    Vertex* pVertices;
    TriangleFace* pFaces;
    float bboxMinX, bboxMinY, bboxMinZ;
    float bboxMaxX, bboxMaxY, bboxMaxZ;
};

#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include <vector>
#include <algorithm>

extern "C" __declspec(dllexport) MeshData* ParseSTL(const char* filePath)
{
    // 创建Assimp导入器
    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile(filePath, aiProcess_Triangulate | aiProcess_FlipUVs);

    if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
    {
        importer.FreeScene();
        return nullptr;
    }

    // 初始化网格数据
    MeshData* meshData = new MeshData();
    meshData->vertexCount = 0;
    meshData->faceCount = 0;
    meshData->pVertices = nullptr;
    meshData->pFaces = nullptr;

    // 遍历所有网格
    for (unsigned int i = 0; i < scene->mNumMeshes; ++i)
    {
        aiMesh* mesh = scene->mMeshes[i];
        meshData->vertexCount += mesh->mNumVertices;
        meshData->faceCount += mesh->mNumFaces;
    }

    // 分配内存
    meshData->pVertices = new Vertex[meshData->vertexCount];
    meshData->pFaces = new TriangleFace[meshData->faceCount];

    unsigned int vertexIndex = 0;
    unsigned int faceIndex = 0;

    // 再次遍历所有网格，填充数据
    for (unsigned int i = 0; i < scene->mNumMeshes; ++i)
    {
        aiMesh* mesh = scene->mMeshes[i];

        for (unsigned int j = 0; j < mesh->mNumVertices; ++j)
        {
            Vertex& vertex = meshData->pVertices[vertexIndex++];
            vertex.position.x = mesh->mVertices[j].x;
            vertex.position.y = mesh->mVertices[j].y;
            vertex.position.z = mesh->mVertices[j].z;

            if (mesh->HasNormals())
            {
                vertex.normal.x = mesh->mNormals[j].x;
                vertex.normal.y = mesh->mNormals[j].y;
                vertex.normal.z = mesh->mNormals[j].z;
            }
            else
            {
                vertex.normal.x = 0.0f;
                vertex.normal.y = 0.0f;
                vertex.normal.z = 0.0f;
            }
        }

        for (unsigned int j = 0; j < mesh->mNumFaces; ++j)
        {
            aiFace& face = mesh->mFaces[j];
            TriangleFace& triangleFace = meshData->pFaces[faceIndex++];
            triangleFace.indices[0] = face.mIndices[0];
            triangleFace.indices[1] = face.mIndices[1];
            triangleFace.indices[2] = face.mIndices[2];

            if (mesh->HasNormals())
            {
                aiVector3D faceNormal = mesh->mNormals[face.mIndices[0]] +
                                        mesh->mNormals[face.mIndices[1]] +
                                        mesh->mNormals[face.mIndices[2]];
                faceNormal.Normalize();
                triangleFace.faceNormalX = faceNormal.x;
                triangleFace.faceNormalY = faceNormal.y;
                triangleFace.faceNormalZ = faceNormal.z;
            }
            else
            {
                triangleFace.faceNormalX = 0.0f;
                triangleFace.faceNormalY = 0.0f;
                triangleFace.faceNormalZ = 0.0f;
            }
        }
    }

    // 计算边界框
    meshData->bboxMinX = meshData->bboxMinY = meshData->bboxMinZ = std::numeric_limits<float>::max();
    meshData->bboxMaxX = meshData->bboxMaxY = meshData->bboxMaxZ = std::numeric_limits<float>::lowest();

    for (unsigned int i = 0; i < meshData->vertexCount; ++i)
    {
        meshData->bboxMinX = std::min(meshData->bboxMinX, meshData->pVertices[i].position.x);
        meshData->bboxMinY = std::min(meshData->bboxMinY, meshData->pVertices[i].position.y);
        meshData->bboxMinZ = std::min(meshData->bboxMinZ, meshData->pVertices[i].position.z);

        meshData->bboxMaxX = std::max(meshData->bboxMaxX, meshData->pVertices[i].position.x);
        meshData->bboxMaxY = std::max(meshData->bboxMaxY, meshData->pVertices[i].position.y);
        meshData->bboxMaxZ = std::max(meshData->bboxMaxZ, meshData->pVertices[i].position.z);
    }

    importer.FreeScene();
    return meshData;
}