repo_model_import_config.h

#pragma once

#include <string>
#include <map>
#include <stdint.h>

#include "../../../repo_bouncer_global.h"

namespace repo{
    namespace manipulator{
        namespace modelconvertor{
            class REPO_API_EXPORT ModelImportConfig
            {
            public:
                ModelImportConfig(const std::string &configFile = std::string());
                ~ModelImportConfig();

                virtual bool getCalculateTangentSpace() const
                {
                    return boolSettings.at(CALCULATE_TANGENT_SPACE);
                }

                virtual float getCalculateTangentSpaceMaxSmoothingAngle() const
                {
                    return floatSettings.at(CALCULATE_TANGENT_SPACE_MAX_SMOOTHING_ANGLE);
                }

                virtual bool getConvertToUVCoordinates()  const
                {
                    return boolSettings.at(CONVERT_TO_UV_COORDINATES);
                }

                virtual bool getDegeneratesToPointsLines() const
                {
                    return boolSettings.at(DEGENERATES_TO_POINTS_LINES);
                }

                virtual bool getDebone() const
                {
                    return boolSettings.at(DEBONE);
                }

                virtual float getDeboneThreshold() const
                {
                    return floatSettings.at(DEBONE_THRESHOLD);
                }

                virtual bool getDeboneOnlyIfAll() const
                {
                    return boolSettings.at(DEBONE_ONLY_IF_ALL);
                }

                virtual bool getFindInstances() const
                {
                    return boolSettings.at(FIND_INSTANCES);
                }

                virtual bool getFindInvalidData() const
                {
                    return boolSettings.at(FIND_INAVLID_DATA);
                }

                virtual float getFindInvalidDataAnimationAccuracy() const
                {
                    return floatSettings.at(FIND_INAVLID_DATA_ANIMATION_ACCURACY);
                }

                virtual bool getFixInfacingNormals() const
                {
                    return boolSettings.at(FIX_INFACING_NORMALS);
                }

                virtual bool getFlipUVCoordinates() const
                {
                    return boolSettings.at(FLIP_UV_COORDINATES);
                }

                virtual bool getFlipWindingOrder() const
                {
                    return boolSettings.at(FLIP_WINDING_ORDER);
                }

                virtual bool getGenerateNormals() const
                {
                    return boolSettings.at(GENERATE_NORMALS);
                }

                virtual bool getGenerateNormalsFlat() const
                {
                    return boolSettings.at(GENERATE_NORMALS_FLAT);
                }

                virtual bool getGenerateNormalsSmooth() const
                {
                    return boolSettings.at(GENERATE_NORMALS_SMOOTH);
                }

                virtual float getGenerateNormalsSmoothCreaseAngle() const
                {
                    return floatSettings.at(GENERATE_NORMALS_SMOOTH_CREASE_ANGLE);
                }

                virtual bool getImproveCacheLocality() const
                {
                    return boolSettings.at(IMPROVE_CACHE_LOCALITY);
                }

                virtual int getImproveCacheLocalityVertexCacheSize() const
                {
                    return intSettings.at(IMPROVE_CACHE_LOCALITY_VERTEX_CACHE_SIZE);
                }

                virtual bool getJoinIdenticalVertices() const
                {
                    return boolSettings.at(JOIN_IDENTICAL_VERTICES);
                }

                virtual bool getLimitBoneWeights() const
                {
                    return boolSettings.at(LIMIT_BONE_WEIGHTS);
                }

                virtual int getLimitBoneWeightsMaxWeight() const
                {
                    return intSettings.at(LIMIT_BONE_WEIGHTS_MAX_WEIGHTS);
                }

                virtual bool getMakeLeftHanded() const
                {
                    return boolSettings.at(MAKE_LEFT_HANDED);
                }

                virtual bool getOptimizeMeshes() const
                {
                    return boolSettings.at(OPTIMIZE_MESHES);
                }

                virtual bool getPreTransformUVCoordinates() const
                {
                    return boolSettings.at(PRE_TRANSFORM_UV_COORDINATES);
                }

                virtual bool getPreTransformVertices() const
                {
                    return boolSettings.at(PRE_TRANSFORM_VERTICES);
                }

                virtual bool getPreTransformVerticesNormalize() const
                {
                    return boolSettings.at(PRE_TRANSFORM_VERTICES_NORMALIZE);
                }

                virtual bool getRemoveComponents() const
                {
                    return boolSettings.at(REMOVE_COMPONENTS);
                }

                virtual bool getRemoveComponentsAnimations() const
                {
                    return boolSettings.at(REMOVE_COMPONENTS_ANIMATIONS);
                }

                virtual bool getRemoveComponentsBiTangents() const
                {
                    return boolSettings.at(REMOVE_COMPONENTS_BI_TANGENTS);
                }

                virtual bool getRemoveComponentsBoneWeights() const
                {
                    return boolSettings.at(REMOVE_COMPONENTS_BONE_WEIGHTS);
                }

                virtual bool getRemoveComponentsCameras() const
                {
                    return boolSettings.at(REMOVE_COMPONENTS_CAMERAS);
                }

                virtual bool getRemoveComponentsColors() const
                {
                    return boolSettings.at(REMOVE_COMPONENTS_COLORS);
                }

                virtual bool getRemoveComponentsLights() const
                {
                    return boolSettings.at(REMOVE_COMPONENTS_LIGHTS);
                }

                virtual bool getRemoveComponentsMaterials() const
                {
                    return boolSettings.at(REMOVE_COMPONENTS_MATERIALS);
                }

                virtual bool getRemoveComponentsMeshes() const
                {
                    return boolSettings.at(REMOVE_COMPONENTS_MESHES);
                }

                virtual bool getRemoveComponentsNormals() const
                {
                    return boolSettings.at(REMOVE_COMPONENTS_NORMALS);
                }

                virtual bool getRemoveComponentsTextures() const
                {
                    return boolSettings.at(REMOVE_COMPONENTS_TEXTURES);
                }

                virtual bool getRemoveComponentsTextureCoordinates() const
                {
                    return boolSettings.at(REMOVE_COMPONENTS_TEXTURE_COORDINATES);
                }

                virtual bool getRemoveRedundantMaterials() const
                {
                    return boolSettings.at(REMOVE_REDUNDANT_MATERIALS);
                }

                virtual std::string getRemoveRedundantMaterialsSkip() const
                {
                    return stringSettings.at(REMOVE_REDUNDANT_MATERIALS_SKIP);
                }

                virtual bool getRemoveRedundantNodes() const
                {
                    return boolSettings.at(REMOVE_REDUNDANT_NODES);
                }

                virtual std::string getRemoveRedundantNodesSkip() const
                {
                    return stringSettings.at(REMOVE_REDUNDANT_NODES_SKIP);
                }

                virtual bool getSkipIFCSpaceRepresentation() const
                {
                    return boolSettings.at(IFC_SKIP_SPACE_REPRESENTATIONS);
                }

                virtual bool getSortAndRemove() const
                {
                    return boolSettings.at(SORT_AND_REMOVE);
                }

                virtual bool getSortAndRemoveLines() const
                {
                    return boolSettings.at(SORT_AND_REMOVE_LINES);
                }

                virtual bool getSortAndRemovePoints() const
                {
                    return boolSettings.at(SORT_AND_REMOVE_POINTS);
                }

                virtual bool getSortAndRemovePolygons() const
                {
                    return boolSettings.at(SORT_AND_REMOVE_POLYGONS);
                }

                virtual bool getSortAndRemoveTriangles() const
                {
                    return boolSettings.at(SORT_AND_REMOVE_TRIANGLES);
                }

                virtual bool getSplitByBoneCount() const
                {
                    return boolSettings.at(SPLIT_BY_BONE_COUNT);
                }

                virtual int getSplitByBoneCountMaxBones() const
                {
                    return boolSettings.at(SPLIT_BY_BONE_COUNT_MAX_BONES);
                }

                virtual bool getSplitLargeMeshes() const
                {
                    return boolSettings.at(SPLIT_LARGE_MESHES);
                }

                virtual int getSplitLargeMeshesTriangleLimit() const
                {
                    return intSettings.at(SPLIT_LARGE_MESHES_TRIANGLE_LIMIT);
                }

                virtual int getSplitLargeMeshesVertexLimit() const
                {
                    return intSettings.at(SPLIT_LARGE_MESHES_VERTEX_LIMIT);
                }

                virtual bool getTriangulate() const
                {
                    return boolSettings.at(TRIANGULATE);
                }

                virtual bool getValidateDataStructures() const
                {
                    return boolSettings.at(VALIDATE_DATA_STRUCTURES);
                }

                virtual void setCalculateTangentSpace(bool on)
                {
                    setValue(CALCULATE_TANGENT_SPACE, on);
                }

                virtual void setCalculateTangentSpaceMaxSmoothingAngle(float angle)
                {
                    setValue(CALCULATE_TANGENT_SPACE_MAX_SMOOTHING_ANGLE, angle);
                }

                virtual void setConvertToUVCoordinates(bool on)
                {
                    setValue(CONVERT_TO_UV_COORDINATES, on);
                }

                virtual void setDegeneratesToPointsLines(bool on)
                {
                    setValue(DEGENERATES_TO_POINTS_LINES, on);
                }

                virtual void setDebone(bool on) { setValue(DEBONE, on); }

                virtual void setDeboneThreshold(float t)
                {
                    setValue(DEBONE_THRESHOLD, t);
                }

                virtual void setDeboneOnlyIfAll(bool on)
                {
                    setValue(DEBONE_ONLY_IF_ALL, on);
                }

                virtual void setFindInstances(bool on)
                {
                    setValue(FIND_INSTANCES, on);
                }

                virtual void setFindInvalidData(bool on)
                {
                    setValue(FIND_INAVLID_DATA, on);
                }

                virtual void setFindInvalidDataAnimationAccuracy(float f)
                {
                    setValue(FIND_INAVLID_DATA_ANIMATION_ACCURACY, f);
                }

                virtual void setFixInfacingNormals(bool on)
                {
                    setValue(FIX_INFACING_NORMALS, on);
                }

                virtual void setFlipUVCoordinates(bool on)
                {
                    setValue(FLIP_UV_COORDINATES, on);
                }

                virtual void setFlipWindingOrder(bool on)
                {
                    setValue(FLIP_WINDING_ORDER, on);
                }

                virtual void setGenerateNormals(bool on)
                {
                    setValue(GENERATE_NORMALS, on);
                }

                virtual void setGenerateNormalsFlat(bool on)
                {
                    setValue(GENERATE_NORMALS_FLAT, on);
                }

                virtual void setGenerateNormalsSmooth(bool on)
                {
                    setValue(GENERATE_NORMALS_SMOOTH, on);
                }

                virtual void setGenerateNormalsSmoothCreaseAngle(float f)
                {
                    setValue(GENERATE_NORMALS_SMOOTH_CREASE_ANGLE, f);
                }

                virtual void setImproveCacheLocality(bool on)
                {
                    setValue(IMPROVE_CACHE_LOCALITY, on);
                }

                virtual void setImproveCacheLocalityCacheSize(int vertexCount)
                {
                    setValue(IMPROVE_CACHE_LOCALITY_VERTEX_CACHE_SIZE, vertexCount);
                }

                virtual void setJoinIdenticalVertices(bool on)
                {
                    setValue(JOIN_IDENTICAL_VERTICES, on);
                }

                virtual void setLimitBoneWeights(bool on)
                {
                    setValue(LIMIT_BONE_WEIGHTS, on);
                }

                virtual void setLimitBoneWeightsMaxWeights(int i)
                {
                    setValue(LIMIT_BONE_WEIGHTS_MAX_WEIGHTS, i);
                }

                virtual void setMakeLeftHanded(bool on)
                {
                    setValue(MAKE_LEFT_HANDED, on);
                }

                virtual void setOptimizeMeshes(bool on)
                {
                    setValue(OPTIMIZE_MESHES, on);
                }

                virtual void setPreTransformUVCoordinates(bool on)
                {
                    setValue(PRE_TRANSFORM_UV_COORDINATES, on);
                }

                virtual void setPreTransformVertices(bool on)
                {
                    setValue(PRE_TRANSFORM_VERTICES, on);
                }

                virtual void setPreTransforVerticesNormalize(bool on)
                {
                    setValue(PRE_TRANSFORM_VERTICES_NORMALIZE, on);
                }

                virtual void setRemoveComponents(bool on)
                {
                    setValue(REMOVE_COMPONENTS, on);
                }

                virtual void setRemoveComponentsAnimations(bool on)
                {
                    setValue(REMOVE_COMPONENTS_ANIMATIONS, on);
                }

                virtual void setRemoveComponentsBiTangents(bool on)
                {
                    setValue(REMOVE_COMPONENTS_BI_TANGENTS, on);
                }

                virtual void setRemoveComponentsBoneWeights(bool on)
                {
                    setValue(REMOVE_COMPONENTS_BONE_WEIGHTS, on);
                }

                virtual void setRemoveComponentsCameras(bool on)
                {
                    setValue(REMOVE_COMPONENTS_CAMERAS, on);
                }

                virtual void setRemoveComponentsColors(bool on)
                {
                    setValue(REMOVE_COMPONENTS_COLORS, on);
                }

                virtual void setRemoveComponentsLights(bool on)
                {
                    setValue(REMOVE_COMPONENTS_LIGHTS, on);
                }

                virtual void setRemoveComponentsMaterials(bool on)
                {
                    setValue(REMOVE_COMPONENTS_MATERIALS, on);
                }

                virtual void setRemoveComponentsMeshes(bool on)
                {
                    setValue(REMOVE_COMPONENTS_MESHES, on);
                }

                virtual void setRemoveComponentsNormals(bool on)
                {
                    setValue(REMOVE_COMPONENTS_NORMALS, on);
                }

                virtual void setRemoveComponentsTextures(bool on)
                {
                    setValue(REMOVE_COMPONENTS_TEXTURES, on);
                }

                virtual void setRemoveComponentsTextureCoordinates(bool on)
                {
                    setValue(REMOVE_COMPONENTS_TEXTURE_COORDINATES, on);
                }

                virtual void setRemoveRedundantMaterials(bool on)
                {
                    setValue(REMOVE_REDUNDANT_MATERIALS, on);
                }

                virtual void setRemoveRedundantMaterialsSkip(const std::string& skip)
                {
                    setValue(REMOVE_REDUNDANT_MATERIALS_SKIP, skip);
                }

                virtual void setRemoveRedundantNodes(bool on)
                {
                    setValue(REMOVE_REDUNDANT_NODES, on);
                }

                virtual void setRemoveRedundantNodesSkip(const std::string& skip)
                {
                    setValue(REMOVE_REDUNDANT_NODES_SKIP, skip);
                }

                virtual void getSkipIFCSpaceRepresentation(const bool &skip)
                {
                    setValue(IFC_SKIP_SPACE_REPRESENTATIONS, skip);
                }

                virtual void setSortAndRemove(bool on)
                {
                    setValue(SORT_AND_REMOVE, on);
                }

                virtual void setSortAndRemoveLines(bool on)
                {
                    setValue(SORT_AND_REMOVE_LINES, on);
                }

                virtual void setSortAndRemovePoints(bool on)
                {
                    setValue(SORT_AND_REMOVE_POINTS, on);
                }

                virtual void setSortAndRemovePolygons(bool on)
                {
                    setValue(SORT_AND_REMOVE_POLYGONS, on);
                }

                virtual void setSortAndRemoveTriangles(bool on)
                {
                    setValue(SORT_AND_REMOVE_TRIANGLES, on);
                }

                virtual void setSplitByBoneCount(bool on)
                {
                    setValue(SPLIT_BY_BONE_COUNT, on);
                }

                virtual void setSplitByBoneCountMaxBones(int max)
                {
                    setValue(SPLIT_BY_BONE_COUNT_MAX_BONES, max);
                }

                virtual void setSplitLargeMeshes(bool on)
                {
                    setValue(SPLIT_LARGE_MESHES, on);
                }

                virtual void setSplitLargeMeshesTriangleLimit(int limit)
                {
                    setValue(SPLIT_LARGE_MESHES_TRIANGLE_LIMIT, limit);
                }

                virtual void setSplitLargeMeshesVertexLimit(int limit)
                {
                    setValue(SPLIT_LARGE_MESHES_VERTEX_LIMIT, limit);
                }

                virtual void setTriangulate(bool on)
                {
                    setValue(TRIANGULATE, on);
                }

                virtual void setValidateDataStructures(bool on)
                {
                    setValue(VALIDATE_DATA_STRUCTURES, on);
                }

            protected:
                void reset();

                void readConfig(
                    std::ifstream &conf);

                void setValue(std::string label, bool value)
                {
                    boolSettings[label] = value;
                }

                void setValue(std::string label, int32_t value)
                {
                    intSettings[label] = value;
                }

                void setValue(std::string label, float value)
                {
                    floatSettings[label] = value;
                }

                void setValue(std::string label, std::string value)
                {
                    stringSettings[label] = value;
                }

                std::map<std::string, bool> boolSettings;
                std::map<std::string, int32_t> intSettings;
                std::map<std::string, float> floatSettings;
                std::map<std::string, std::string> stringSettings;

                static const std::string CALCULATE_TANGENT_SPACE;
                static const std::string CALCULATE_TANGENT_SPACE_MAX_SMOOTHING_ANGLE;
                static const std::string CONVERT_TO_UV_COORDINATES;
                static const std::string DEGENERATES_TO_POINTS_LINES;
                static const std::string DEBONE;
                static const std::string DEBONE_THRESHOLD;
                static const std::string DEBONE_ONLY_IF_ALL;
                static const std::string FIND_INSTANCES;
                static const std::string FIND_INAVLID_DATA;
                static const std::string FIND_INAVLID_DATA_ANIMATION_ACCURACY;
                static const std::string FIX_INFACING_NORMALS;
                static const std::string FLIP_UV_COORDINATES;
                static const std::string FLIP_WINDING_ORDER;
                static const std::string GENERATE_NORMALS;
                static const std::string GENERATE_NORMALS_FLAT;
                static const std::string GENERATE_NORMALS_SMOOTH;
                static const std::string GENERATE_NORMALS_SMOOTH_CREASE_ANGLE;
                static const std::string IFC_SKIP_SPACE_REPRESENTATIONS;
                static const std::string IMPROVE_CACHE_LOCALITY;
                static const std::string IMPROVE_CACHE_LOCALITY_VERTEX_CACHE_SIZE;
                static const std::string JOIN_IDENTICAL_VERTICES;
                static const std::string LIMIT_BONE_WEIGHTS;
                static const std::string LIMIT_BONE_WEIGHTS_MAX_WEIGHTS;
                static const std::string MAKE_LEFT_HANDED;
                static const std::string OPTIMIZE_MESHES;
                static const std::string PRE_TRANSFORM_UV_COORDINATES;
                static const std::string PRE_TRANSFORM_VERTICES;
                static const std::string PRE_TRANSFORM_VERTICES_NORMALIZE;
                static const std::string REMOVE_COMPONENTS;
                static const std::string REMOVE_COMPONENTS_ANIMATIONS;
                static const std::string REMOVE_COMPONENTS_BI_TANGENTS;
                static const std::string REMOVE_COMPONENTS_BONE_WEIGHTS;
                static const std::string REMOVE_COMPONENTS_CAMERAS;
                static const std::string REMOVE_COMPONENTS_COLORS;
                static const std::string REMOVE_COMPONENTS_LIGHTS;
                static const std::string REMOVE_COMPONENTS_MATERIALS;
                static const std::string REMOVE_COMPONENTS_MESHES;
                static const std::string REMOVE_COMPONENTS_NORMALS;
                static const std::string REMOVE_COMPONENTS_TEXTURES;
                static const std::string REMOVE_COMPONENTS_TEXTURE_COORDINATES;
                static const std::string REMOVE_REDUNDANT_MATERIALS;
                static const std::string REMOVE_REDUNDANT_MATERIALS_SKIP;
                static const std::string REMOVE_REDUNDANT_NODES;
                static const std::string REMOVE_REDUNDANT_NODES_SKIP;
                static const std::string SORT_AND_REMOVE;
                static const std::string SORT_AND_REMOVE_POINTS;
                static const std::string SORT_AND_REMOVE_LINES;
                static const std::string SORT_AND_REMOVE_TRIANGLES;
                static const std::string SORT_AND_REMOVE_POLYGONS;
                static const std::string SPLIT_BY_BONE_COUNT;
                static const std::string SPLIT_BY_BONE_COUNT_MAX_BONES;
                static const std::string SPLIT_LARGE_MESHES;
                static const std::string SPLIT_LARGE_MESHES_TRIANGLE_LIMIT;
                static const std::string SPLIT_LARGE_MESHES_VERTEX_LIMIT;
                static const std::string TRIANGULATE;
                static const std::string VALIDATE_DATA_STRUCTURES;
            };
        }//namespace modelconvertor
    }//namespace manipulator
}//namespace repo