repo_optimizer_multipart.h

#pragma once

#include "repo_optimizer_abstract.h"
#include "../../core/model/collection/repo_scene.h"
#include "../../core/model/bson/repo_node_mesh.h"

#define REPO_MP_TEXTURE_WORK_AROUND

namespace repo {
    namespace manipulator {
        namespace modeloptimizer {
            class MultipartOptimizer : AbstractOptimizer
            {
            public:
                MultipartOptimizer();

                virtual ~MultipartOptimizer();

                bool apply(repo::core::model::RepoScene *scene);

            private:
#ifdef REPO_MP_TEXTURE_WORK_AROUND
                bool collectMeshData(
                    const repo::core::model::RepoScene        *scene,
                    const repo::core::model::RepoNode         *node,
                    const std::set<repoUUID>                  &meshGroup,
                    std::vector<float>                        &mat,
                    std::vector<std::vector<repo_vector_t>>                &vertices,
                    std::vector<std::vector<repo_vector_t>>               &normals,
                    std::vector<std::vector<repo_face_t>>                &faces,
                    std::vector<std::vector<std::vector<repo_vector2d_t>>> &uvChannels,
                    std::vector<std::vector<repo_color4d_t>>               &colors,
                    std::vector<std::vector<repo_mesh_mapping_t>>          &meshMapping,
                    std::unordered_map<repoUUID, repoUUID, RepoUUIDHasher>    &matIDMap
                    );
#endif
                bool collectMeshData(
                    const repo::core::model::RepoScene        *scene,
                    const repo::core::model::RepoNode         *node,
                    const std::set<repoUUID>                  &meshGroup,
                    std::vector<float>                        &mat,
                    std::vector<repo_vector_t>                &vertices,
                    std::vector<repo_vector_t>                &normals,
                    std::vector<repo_face_t>                  &faces,
                    std::vector<std::vector<repo_vector2d_t>> &uvChannels,
                    std::vector<repo_color4d_t>               &colors,
                    std::vector<repo_mesh_mapping_t>          &meshMapping,
                    std::unordered_map<repoUUID, repoUUID, RepoUUIDHasher>    &matIDMap
                    );

#ifdef REPO_MP_TEXTURE_WORK_AROUND
                std::vector<repo::core::model::MeshNode*>createSuperMesh(
                    const repo::core::model::RepoScene *scene,
                    const std::set<repoUUID>           &meshGroup,
                    std::unordered_map<repoUUID, repoUUID, RepoUUIDHasher> &matIDs,
                    const bool                         &texture);
#endif
                repo::core::model::MeshNode* createSuperMesh(
                    const repo::core::model::RepoScene *scene,
                    const std::set<repoUUID>           &meshGroup,
                    std::unordered_map<repoUUID, repoUUID, RepoUUIDHasher> &matIDs);

                bool generateMultipartScene(repo::core::model::RepoScene *scene);

                repoUUID getMaterialID(
                    const repo::core::model::RepoScene *scene,
                    const repo::core::model::MeshNode  *mesh
                    );

                bool hasTexture(
                    const repo::core::model::RepoScene *scene,
                    const repo::core::model::MeshNode  *mesh,
                    repoUUID                           &texID);

                bool isTransparent(
                    const repo::core::model::RepoScene *scene,
                    const repo::core::model::MeshNode  *mesh);

#ifdef REPO_MP_TEXTURE_WORK_AROUND
                bool processMeshGroup(
                    const repo::core::model::RepoScene                                         *scene,
                    const std::set<repoUUID>                                                   & meshes,
                    const repoUUID                                                             &rootID,
                    repo::core::model::RepoNodeSet                                             &mergedMeshes,
                    std::unordered_map<repoUUID, repo::core::model::RepoNode*, RepoUUIDHasher> &matNodes,
                    std::unordered_map<repoUUID, repoUUID, RepoUUIDHasher>                     &matIDs,
                    const bool                                                                 &texture
                    );
#endif
                bool processMeshGroup(
                    const repo::core::model::RepoScene                                         *scene,
                    const std::set<repoUUID>                                                   & meshes,
                    const repoUUID                                                             &rootID,
                    repo::core::model::RepoNodeSet                                             &mergedMeshes,
                    std::unordered_map<repoUUID, repo::core::model::RepoNode*, RepoUUIDHasher> &matNodes,
                    std::unordered_map<repoUUID, repoUUID, RepoUUIDHasher>                    &matIDs);

                void sortMeshes(
                    const repo::core::model::RepoScene                                      *scene,
                    const repo::core::model::RepoNodeSet                                    &meshes,
                    std::unordered_map<uint32_t, std::vector<std::set<repoUUID>>>           &normalMeshes,
                    std::unordered_map<uint32_t, std::vector<std::set<repoUUID>>>           &transparentMeshes,
                    std::unordered_map < uint32_t, std::unordered_map < repoUUID,
                    std::vector<std::set<repoUUID>>, RepoUUIDHasher >> &texturedMeshes);
            };
        }
    }
}