repo_mesh_map_reorganiser.h

#pragma once
#include <unordered_map>
#include "../../core/model/bson/repo_node_mesh.h"

namespace repo{
    namespace manipulator{
        namespace modelutility{
            class MeshMapReorganiser
            {
            public:
                MeshMapReorganiser(
                    const repo::core::model::MeshNode *mesh,
                    const size_t                        &vertThreshold);
                ~MeshMapReorganiser();

                std::vector<std::vector<float>> getIDMapArrays() const;

                std::vector<std::vector<repo_mesh_mapping_t>> getMappingsPerSubMesh() const;

                repo::core::model::MeshNode getRemappedMesh() const;

                std::vector<uint16_t> getSerialisedFaces() const;

                std::unordered_map<repoUUID, std::vector<uint32_t>, RepoUUIDHasher> getSplitMapping() const;

            private:
                void finishSubMesh(
                    repo_mesh_mapping_t &mapping,
                    std::vector<float> &minBox,
                    std::vector<float> &maxBox,
                    const size_t &nVertices,
                    const size_t &nFaces
                    );

                void newMatMapEntry(
                    const repo_mesh_mapping_t &mapping,
                    const size_t        &sVertices,
                    const size_t        &sFaces
                    );

                void completeLastMatMapEntry(
                    const size_t        &eVertices,
                    const size_t        &eFaces,
                    const std::vector<float>  &minBox = std::vector<float>(),
                    const std::vector<float>  &maxBox = std::vector<float>()
                    );

                bool performSplitting();

                bool splitLargeMesh(
                    const repo_mesh_mapping_t        currentSubMesh,
                    std::vector<repo_mesh_mapping_t> &newMappings,
                    size_t                           &idMapIdx,
                    size_t                           &orgFaceIdx,
                    size_t                           &totalVertexCount,
                    size_t                           &totalFaceCount);

                void startSubMesh(
                    repo_mesh_mapping_t &mapping,
                    const repoUUID      &meshID,
                    const repoUUID      &matID,
                    const size_t        &sVertices,
                    const size_t        &sFaces
                    );

                void updateBoundingBoxes(
                    std::vector<float>  &min,
                    std::vector<float>  &max,
                    const repo_vector_t &smMin,
                    const repo_vector_t &smMax);

                void updateIDMapArray(
                    const size_t &n,
                    const size_t &value);

                bool reMapSuccess;

                const repo::core::model::MeshNode *mesh;
                const size_t maxVertices;
                const std::vector<repo_vector_t> oldVertices;
                const std::vector<repo_vector_t> oldNormals;
                const std::vector<std::vector<repo_vector2d_t>> oldUVs;
                const std::vector<repo_face_t>   oldFaces;
                const std::vector<repo_color4d_t>   oldColors;

                std::vector<repo_vector_t> newVertices;
                std::vector<repo_vector_t> newNormals;
                std::vector<repo_face_t>   newFaces;
                std::vector<repo_color4d_t>   newColors;
                std::vector<std::vector<repo_vector2d_t>> newUVs;

                std::vector<uint16_t> serialisedFaces;

                std::vector<std::vector<float>> idMapBuf;
                std::unordered_map<repoUUID, std::vector<uint32_t>, RepoUUIDHasher> splitMap;
                std::vector<std::vector<repo_mesh_mapping_t>> matMap;
                std::vector<repo_mesh_mapping_t> reMappedMappings;
            };
        }
    }
}