algorithm - 优化网格生成器

Question

我有一个普通的网格生成器，它采用一组立方体位置并计算它们的可见面。该算法花费了太多时间（显然），但它只运行一次。我应该如何优化这个东西，让它工作得更快？我不认为块是可以接受的，也许我应该使用另一种数据结构或以不同的方式处理位置。我希望你能帮我解决这个问题。谢谢。

Mesh MeshGenerator::GenerateMesh(std::vector<glm::vec3>& rawData)
{
    Mesh mesh;
    MeshFace meshFace;

    bool left = false;
    bool right = false;
    bool front = false;
    bool back  = false;
    bool down = false;
    bool up = false;

    int count = 0;

    // Iterating thorugh blocks
    for (glm::vec3 blockOrigin : rawData)
    {
        for (glm::vec3 block2Origin : rawData) {            

            // X: to left
            if (block2Origin.x - blockOrigin.x == -1
                && block2Origin.y - blockOrigin.y == 0
                && block2Origin.z - blockOrigin.z == 0)
            {
                left = true;
                count++;
            }

            // X: to right
            if (block2Origin.x - blockOrigin.x == 1
                && block2Origin.y - blockOrigin.y == 0
                && block2Origin.z - blockOrigin.z == 0)
            {
                right = true;
                count++;
            }


            // Z: to front
            if (block2Origin.z - blockOrigin.z == 1
                && block2Origin.x - blockOrigin.x == 0
                && block2Origin.y - blockOrigin.y == 0)
            {
                front = true;
                count++;
            }

            // Z: to back
            if (block2Origin.z - blockOrigin.z == -1
                && block2Origin.x - blockOrigin.x == 0
                && block2Origin.y - blockOrigin.y == 0)
            {
                back = true;
                count++;
            }

            // Y: to down
            if (block2Origin.y - blockOrigin.y == -1
                && block2Origin.x - blockOrigin.x == 0
                && block2Origin.z - blockOrigin.z == 0)
            {
                down = true;
                count++;
            }

            // Y: to up
            if (block2Origin.y - blockOrigin.y == 1
                && block2Origin.x - blockOrigin.x == 0
                && block2Origin.z - blockOrigin.z == 0)
            {
                up = true;
                count++;
            }

            if (count == 6) break;
            count = 0;              
        }

        if (!left)
        {
            meshFace.Color = glm::vec4(1,1,1,1);
            meshFace.Position = blockOrigin;
            meshFace.Face = 0;
            mesh.AddMeshFace(meshFace);
        }

        if (!right)
        {
            meshFace.Color = glm::vec4(1, 1, 1, 1);
            meshFace.Position = blockOrigin;
            meshFace.Face = 1;
            mesh.AddMeshFace(meshFace);
        }

        if (!front)
        {
            meshFace.Color = glm::vec4(1, 1, 1, 1);
            meshFace.Position = blockOrigin;
            meshFace.Face = 2;
            mesh.AddMeshFace(meshFace);
        }

        if (!back)
        {
            meshFace.Color = glm::vec4(1, 1, 1, 1);
            meshFace.Position = blockOrigin;
            meshFace.Face = 3;
            mesh.AddMeshFace(meshFace);
        }
        if (!down)
        {
            meshFace.Color = glm::vec4(1, 1, 1, 1);
            meshFace.Position = blockOrigin;
            meshFace.Face = 4;
            mesh.AddMeshFace(meshFace);
        }
        if (!up)
        {
            meshFace.Color = glm::vec4(1, 1, 1, 1);
            meshFace.Position = blockOrigin;
            meshFace.Face = 5;
            mesh.AddMeshFace(meshFace);
        }

        left = false;
        right = false;
        front = false;
        back = false;
        down = false;
        up = false;

        count = 0;
    }


    return mesh;

标签： algorithmperformancegeneratormeshcube