Variations.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include <Atoms/Globals.h>
#include <AtomsCore/Hash.h>
#include <AtomsUtils/Logger.h>
 
#include <vector>
#include <map>
#include <algorithm>
#include <numeric>
 
namespace Atoms
{
    class Variations;
    class AgentTypeVariation;
    class VariationGeometry;
    class VariationMaterial;
    class VariationGroup;
    class VariationOverride;
    class VariationGroupLod;
    class VariationMaterialColor;
    class VariationTree;
    class VariationTreeGeo;
    class MaterialConstraint;
    class ExcludeGeometry;
    
    typedef Variations*  VariationsPtr; 
    typedef AgentTypeVariation*  AgentTypeVariationPtr; 
    typedef VariationGeometry*  VariationGeometryPtr; 
    typedef VariationMaterial*  VariationMaterialPtr; 
    typedef VariationGroup*  VariationGroupPtr; 
    typedef VariationOverride* VariationOverridePtr; 
    typedef VariationGroupLod* VariationGroupLodPtr; 
    typedef VariationMaterialColor* VariationMaterialColorPtr; 
    typedef VariationTree* VariationTreePtr; 
 
    typedef const Variations*  VariationsCPtr; 
    typedef const AgentTypeVariation*  AgentTypeVariationCPtr; 
    typedef const VariationGeometry*  VariationGeometryCPtr; 
    typedef const VariationMaterial*  VariationMaterialCPtr; 
    typedef const VariationGroup*  VariationGroupCPtr; 
    typedef const VariationOverride* VariationOverrideCPtr; 
    typedef const VariationGroupLod* VariationGroupLodCPtr; 
    typedef const VariationMaterialColor* VariationMaterialColorCPtr; 
    typedef const VariationTree* VariationTreeCPtr; 
    typedef const VariationTreeGeo* VariationTreeGeoCPtr; 
 
    typedef std::map<std::string, VariationTreeGeo> VariationTreeGeoMap;
    typedef std::map<std::string, MaterialConstraint> MaterialConstraintMap;
    typedef std::map<std::string, ExcludeGeometry> ExcludeGeometryMap;
 
 
    class ATOMS_EXPORT VariationGeometry
    {
    public:
        VariationGeometry():
            m_geometryFilter("*") {}
 
        ~VariationGeometry() {}
 
        const std::string& getGeometryFile() const { return m_geometryFile; };
 
        void setGeometryFile(const std::string& geometryFile) { m_geometryFile = geometryFile; };
 
        const std::string& getGeometryFilter() const { return m_geometryFilter; };
 
        void setGeometryFilter(const std::string& filter) { m_geometryFilter = filter; };
 
        void hash(AtomsCore::MurmurHash3& hasher) const;
 
    private:
 
        std::string m_geometryFile;
 
        std::string m_geometryFilter;
    };
 
    /* This class stores material color rgb values.
    */
    class ATOMS_EXPORT VariationMaterialColor
    {
    public:
        VariationMaterialColor() :
            m_red(0),
            m_green(0),
            m_blue(0)
        {}
 
        void setRed(const int red) { m_red = red > 255 ? 255 : red < 0 ? 0 : red; }
        void setGreen(const int green) { m_green = green > 255 ? 255 : green < 0 ? 0 : green; }
        void setBlue(const int blue) { m_blue = blue > 255 ? 255 : blue < 0 ? 0 : blue; }
 
        unsigned int getRed() const { return m_red; }
        unsigned int getGreen() const { return m_green; }
        unsigned int getBlue() const { return m_blue; }
 
        void hash(AtomsCore::MurmurHash3& hasher) const;
 
    private:
        unsigned int m_red;
        unsigned int m_green;
        unsigned int m_blue;
    };
 
 
    /* This class Stores a material file path used by the renderers.
    * It also stores some diffuse/specular/normal attributes used for previsualization inside the DCC
    */
    class ATOMS_EXPORT VariationMaterial
    {       
    public:
 
        VariationMaterial():
            m_diffuseWeight(1.0f),
            m_specularWeight(0.0f),
            m_specularRollOff(0.7f),
            m_specularEccentricity(0.3f)
            {
            m_diffuseFiles.resize(1);
            m_diffuseRGBs.resize(1);
            };
 
        ~VariationMaterial() {}
 
        const std::string& getMaterialFile() const { return m_materialFile; };
 
        void setMaterialFile(const std::string& materialFile) { m_materialFile = materialFile; };
 
        void setDiffuseSlotSize(unsigned int size);
 
        unsigned int getDiffuseSlotSize() const;
 
        const std::string& getDiffuseFile(unsigned int index = 0) const;
 
        const std::string& getSpecularFile() const;
 
        const std::string& getNormalMapFile() const;
 
        void setDiffuseFile(const std::string& diffuseFile, unsigned int index = 0);
 
        void setSpecularFile(const std::string& specularFile);
 
        void setNormalMapFile(const std::string& normalMapFile);
 
        const VariationMaterialColor& getDiffuseColor(unsigned int index = 0) const;
        VariationMaterialColor& getDiffuseColor(unsigned int index = 0);
 
        VariationMaterialColorCPtr getDiffuseColorPtr(unsigned int index = 0);
 
        unsigned int getDiffuseColorRed() const;
 
        unsigned int getDiffuseColorGreen() const;
 
        unsigned int getDiffuseColorBlue() const;
 
        void setDiffuseColorRed(const int red);
 
        void setDiffuseColorGreen(const int green);
 
        void setDiffuseColorBlue(const int blue);
 
        VariationMaterialColor& getSpecularColor();
 
        unsigned int getSpecularColorRed() const;
 
        unsigned int getSpecularColorGreen() const;
 
        unsigned int getSpecularColorBlue() const;
 
        void setSpecularColorRed(const int red);
 
        void setSpecularColorGreen(const int green);
 
        void setSpecularColorBlue(const int blue);
 
        float getDiffuseWeight() const;
        void setDiffuseWeight(float value);
 
        const std::string& getDiffuseHueMetadataName() const;
 
        void setDiffuseHueMetadataName(const std::string& value);
 
        const std::string& getDiffuseSlotMetadataName() const;
 
        void setDiffuseSlotMetadataName(const std::string& value);
 
        float getSpecularWeight() const;
        void setSpecularWeight(float value);
 
        float getSpecularRollOff() const;
        void setSpecularRollOff(float value);
 
        float getSpecularEccentricity() const;
        void setSpecularEccentricity(float value);
 
        void hash(AtomsCore::MurmurHash3& hasher) const;
 
    private:
 
        std::string m_materialFile;
 
        std::vector<std::string> m_diffuseFiles;
 
        std::string m_specularFile;
 
        std::string m_normalMapFile;
 
        float m_diffuseWeight;
 
        float m_specularWeight;
 
        float m_specularRollOff;
 
        float m_specularEccentricity;
 
        std::string m_diffuseHueMetadataName;
 
        std::string m_diffuseSlotMetadataName;
 
        VariationMaterialColor m_specularRGB;
 
        std::vector<VariationMaterialColor> m_diffuseRGBs;
 
    };
 
    class ATOMS_EXPORT BaseVariationGroup
    {
        public:
            BaseVariationGroup(AgentTypeVariationCPtr agentTypeVariation) : m_atVariation(agentTypeVariation) {}
 
            BaseVariationGroup(AgentTypeVariationCPtr agentTypeVariation, const BaseVariationGroup& vg);
 
            ~BaseVariationGroup() {}
 
            inline void clear() { m_combinations.clear(); }
 
            inline unsigned int numCombinations() const { return static_cast<unsigned int>(m_combinations.size()); }
 
            inline bool hasCombination(const std::string& geometryName, const std::string& materialName);
 
            void addCombination(const std::string& geometryName, const std::string& materialName);
 
            inline const std::pair<std::string, std::string>& getCombinationAtIndex(unsigned int index) const;
 
            inline bool removeCombinationAtIndex(unsigned int index);
 
            void hash(AtomsCore::MurmurHash3& hasher) const;
 
            const std::vector<std::pair<std::string, std::string>>& getCombinations() const { return m_combinations; };
 
        protected:
 
 
            AgentTypeVariationCPtr m_atVariation;
 
            std::vector<std::pair<std::string, std::string>> m_combinations;
 
            std::pair<std::string, std::string> m_emptyPair;
    };
 
    /* A variation group contains multiple combinations of geoemtry-material.
    * This class is used to store a variation group for a lod definition of an agent type variation
    */
    class ATOMS_EXPORT VariationGroupLod : public BaseVariationGroup
    {
        using BaseVariationGroup::BaseVariationGroup;
    };
 
    /* A variation group contains multiple combinations of geoemtry-material.
    * This class is used to store a variation group of an agent type variation and 
    * the variation groups of lods
    */
    class ATOMS_EXPORT VariationGroup: public BaseVariationGroup
    {
    public:
        using BaseVariationGroup::BaseVariationGroup;
 
        VariationGroup(AgentTypeVariationCPtr agentTypeVariation, const VariationGroup& vg);
 
        inline std::vector<std::string> getLodNames() const;
 
        inline bool hasLod(const std::string& name) const { return m_lods.find(name) != m_lods.end(); }
 
        VariationGroupLod& getLod(const std::string& name);
 
        inline VariationGroupLodCPtr getLodPtr(const std::string &name) const;
 
        inline bool removeLod(const std::string &name);
 
        inline void setLod(const std::string &name, const VariationGroupLod& v) { m_lods.insert(std::make_pair(name, VariationGroupLod(m_atVariation, v))); }
 
        void hash(AtomsCore::MurmurHash3& hasher) const;
 
    private:
 
        std::map<std::string, VariationGroupLod> m_lods;
    };
 
    /* A Material Constraint contain the rule for constraining a geo to a material
    */
    class ATOMS_EXPORT ExcludeGeometry
    {
    public:
        ExcludeGeometry() {}
        ExcludeGeometry(const std::string& sourceGeometry, const std::string& destinationGeometry) : m_sourceGeometry(sourceGeometry), m_destinationGeometry(destinationGeometry) {}
        void hash(AtomsCore::MurmurHash3& hasher) const;
 
        void setSourceGeometry(const std::string& sourceGeometry) { m_sourceGeometry = sourceGeometry; }
        const std::string& getSourceGeometry() const { return m_sourceGeometry; }
 
        void setDestinationGeometry(const std::string& destinationGeometry) { m_destinationGeometry = destinationGeometry; }
        const std::string& getDestinationGeometry() const { return m_destinationGeometry; }
 
    private:
        std::string m_sourceGeometry;
        std::string m_destinationGeometry;
    };
 
    /* A variation override can contain multiple combinations of geometry-material and a list of geometries to filter.
    * This class is used to store overrides to change the look of a variation
    */
    class ATOMS_EXPORT VariationOverride: public BaseVariationGroup
    {
    public:
        using BaseVariationGroup::BaseVariationGroup;
 
        VariationOverride(AgentTypeVariationCPtr agentTypeVariation, const VariationOverride& vg);
 
        unsigned int numGeometryFilter() const { return static_cast<unsigned int>(m_geometryFilter.size()); }
 
        inline bool hasGeometryFilter(const std::string& geometryName) const;
 
        void addGeometryFilter(const std::string& geometryName);
 
        inline const std::string& getGeometryFilterAtIndex(unsigned int index) const;
 
        inline bool removeGeometryFilterAtIndex(unsigned int index);
 
        void hash(AtomsCore::MurmurHash3& hasher) const;
 
        const std::vector<std::string>& getGeometryFilters() const { return m_geometryFilter;}
 
    private:
 
        std::vector<std::string> m_geometryFilter;
 
        static std::string m_emptyString;
    };
 
    class ATOMS_EXPORT MaterialOverride
    {
    public:
        MaterialOverride(AgentTypeVariationCPtr vt) : m_atVariation(vt) {}
 
        void hash(AtomsCore::MurmurHash3& hasher) const;
 
        unsigned int numMaterials() const { return static_cast<unsigned int>(m_materialNames.size()); }
 
        inline bool hasMaterial(const std::string& materialName) const;
 
        inline void addMaterial(const std::string& materialName, const double weight=1.0);
 
        inline const std::string& getMaterialNameAtIndex(unsigned int index) const;
 
        inline const double getMaterialWeightAtIndex(unsigned int index) const;
 
        inline bool removeMaterialAtIndex(unsigned int index);
 
    private:
        std::vector<std::string> m_materialNames;
        std::vector<double> m_materialWeights;
        AgentTypeVariationCPtr m_atVariation;
 
        static std::string m_emptyString;
    };
 
    /* A Variation Tree Geo contains a hierarchy of meshes for the Variation Tree
    */
    class ATOMS_EXPORT VariationTreeGeo
    {
    public:
        enum GeoType
        {
            kGeo = 0,
            kNone,
            kVariationType,
            kExtraGeo
        };
 
        VariationTreeGeo(AgentTypeVariationCPtr vt, const std::string &name) : m_atVariation(vt), m_name(name), m_weight(1), m_locked(false), m_type(GeoType::kVariationType), m_materialOverride(vt) {}
        VariationTreeGeo(AgentTypeVariationCPtr vt, const std::string& name, const double weight, const bool locked, const GeoType geoType): m_atVariation(vt), m_name(name), m_weight(weight), m_locked(locked), m_type(geoType), m_materialOverride(vt) { }
 
        void hash(AtomsCore::MurmurHash3& hasher) const;
 
        void addChild(const std::string& name, VariationTreeGeo& vg);
        const VariationTreeGeoMap& getChildren() const { return m_children; }
        void clearChildren() { m_children.clear(); }
 
        void setLocked(const bool locked) { m_locked = locked; }
        const bool getLocked() const { return m_locked; }
 
        void setWeight(const double weight) { m_weight = weight; }
        const double getWeight() const { return m_weight; }
 
        void setGeoType(const GeoType geoType) { m_type = geoType; }
        const GeoType getGeoType() const { return m_type; }
 
        const MaterialOverride& getMaterialOverride() const { return m_materialOverride; };
        MaterialOverride& getMaterialOverride() { return m_materialOverride; };
 
        void addExcludeGeometry(const std::string& name, const ExcludeGeometry& eg);
        const ExcludeGeometryMap& getExcludeGeometries() const { return m_excludeGeometries; };
        ExcludeGeometryMap& getExcludeGeometries() { return m_excludeGeometries; };
 
        const std::string& getName() const { return m_name; }
 
        AgentTypeVariationCPtr getAgentTypeVariation() const { return m_atVariation; }
 
    private:
        
        AgentTypeVariationCPtr m_atVariation;
        std::string m_name;
        double m_weight;
        bool m_locked;
        GeoType m_type;
        MaterialOverride m_materialOverride;
        ExcludeGeometryMap m_excludeGeometries;
        VariationTreeGeoMap m_children;
    };
 
    /* A Material Constraint contain the rule for constraining a geo to a material
    */
    class ATOMS_EXPORT MaterialConstraint
    {
    public:
        MaterialConstraint() {}
        MaterialConstraint(const std::string &material, const std::string& geometryName, const std::string& destinationMaterialName ) : m_material(material), m_geometryName(geometryName), m_destinationMaterialName(destinationMaterialName) {}
        void hash(AtomsCore::MurmurHash3& hasher) const;
 
        void setMaterial(const std::string& material) { m_material = material; }
        const std::string& getMaterial() const { return m_material; }
 
        void setGeometryName(const std::string& geometryName) { m_geometryName = geometryName; }
        const std::string& getGeometryName() const { return m_geometryName; }
 
        void setDestinationMaterialName(const std::string& destinationMaterialName) { m_destinationMaterialName = destinationMaterialName; }
        const std::string& getDestinationMaterialName() const { return m_destinationMaterialName; }
 
    private:
        std::string m_material;
        std::string m_geometryName;
        std::string m_destinationMaterialName;
    };
 
    /* A variation tree contains the rules for building variations at run time
    */
    class ATOMS_EXPORT VariationTree
    {
    public:
 
        VariationTree(AgentTypeVariationCPtr agentTypeVariation) : m_atVariation(agentTypeVariation), m_geoMatSuffixRepl(std::pair<std::string, std::string>("_GEO", "_*_MAT")) {}
 
        VariationTree(AgentTypeVariationCPtr agentTypeVariation, const VariationTree& variationTree);
 
        ~VariationTree() {}
 
        inline void clear();
 
        const VariationTreeGeoMap& getVariationTypes() const { return m_variationTypes; };
 
        bool hasVariationType(const std::string& name) const { return m_variationTypes.find(name) != m_variationTypes.end(); };
 
        const VariationTreeGeoMap& getExtraGeos() const { return m_extraGeos; };
 
        const MaterialConstraintMap& getMaterialConstraints() const { return m_materialConstraints; };
 
        const ExcludeGeometryMap& getExcludeGeometries() const { return m_excludeGeometries; };
 
        inline void addVariationType(const std::string& name, const VariationTreeGeo& vg);
 
        inline void addExtraGeo(const std::string& name, const VariationTreeGeo& vg);
 
        inline void addMaterialConstraint(const std::string& name, const MaterialConstraint& mc); 
 
        inline void addExcludeGeometry(const std::string& name, const ExcludeGeometry& mc);
 
        inline void setGeoMatSuffixReplacement(const std::string& geo, const std::string& mat) { m_geoMatSuffixRepl.first = geo; m_geoMatSuffixRepl.second = mat;}
 
        inline const std::pair<std::string, std::string>& getGeoMatSuffixReplacement() const { return m_geoMatSuffixRepl; }
 
        void addGeoMatAliases(const std::string& geo, const std::string& mat);
 
        inline const std::vector<std::pair<std::string, std::string>>& getGeoMatAliases() const { return m_geoMatAlias; }
 
        inline void setMaterialPrefix(const std::string& materialPrefix) { m_materialPrefix = materialPrefix; }
 
        inline const std::string& getMaterialPrefix() const { return m_materialPrefix; }
 
        void hash(AtomsCore::MurmurHash3& hasher) const;
 
        std::vector<std::pair<std::string, std::string>> build(const std::string &variationType, unsigned agentSeed, unsigned int seed, std::vector<std::string>& debugMessages, const bool storeDebugMessages = false) const;
 
        // ! returns the agent type variation
        AgentTypeVariationCPtr getAgentTypeVariation() const { return m_atVariation; }
 
    private:
 
        AgentTypeVariationCPtr m_atVariation;
 
        VariationTreeGeoMap m_variationTypes;
 
        VariationTreeGeoMap m_extraGeos;
 
        MaterialConstraintMap m_materialConstraints;
 
        ExcludeGeometryMap m_excludeGeometries;
 
        std::vector<std::pair<std::string, std::string>> m_geoMatAlias;
 
        std::pair<std::string, std::string> m_geoMatSuffixRepl;
 
        std::string m_materialPrefix;
 
        std::vector<std::string> m_debugMessages;
    };
 
    /* This class stores a list geometries file path and materials file path and
    * a list of variations groups. Each variation group uses the geometries and materials to define
    * an agent variation.
    */
    class ATOMS_EXPORT AgentTypeVariation
    {
    public:
        AgentTypeVariation() : m_variationTree(this) {};
 
        ~AgentTypeVariation() {}
 
        AgentTypeVariation(const AgentTypeVariation &atv);
 
        inline void clear();
 
        inline std::vector<std::string> getGeometryNames() const;
 
        inline std::vector<std::string> getMaterialNames() const;
 
        inline std::vector<std::string> getGroupNames() const;
 
        inline std::vector<std::string> getOverrideNames() const;
 
        inline VariationGeometry& getGeometry(const std::string &name) { return m_geos[name]; }
 
        inline VariationMaterial& getMaterial(const std::string &name) { return m_mats[name]; }
 
        VariationGroup& getGroup(const std::string &name);
 
        VariationOverride& getOverride(const std::string& name);
 
        inline VariationTree& getVariationTree() { return m_variationTree; }
 
        inline const VariationTree& getVariationTree() const { return m_variationTree; }
 
        inline void setGeometry(const std::string &name, const VariationGeometry& v) { m_geos[name] = v; }
 
        inline void setMaterial(const std::string &name, const VariationMaterial& v) { m_mats[name] = v; }
 
        inline void setClothSetup(const std::string &path) { m_clothSetup = path; }
 
        inline void setLookFile(const std::string &path) { m_lookFile = path; }
 
        inline void setGroup(const std::string &name, const VariationGroup& v) { m_groups.insert(std::make_pair(name, VariationGroup(this, v))); }
 
        inline void setOverride(const std::string& name, const VariationOverride& v) { m_overrides.insert(std::make_pair(name, VariationOverride(this, v))); }
 
        inline VariationGeometryCPtr getGeometryPtr(const std::string &name) const;
 
        inline VariationMaterialCPtr getMaterialPtr(const std::string &name) const;
 
        inline VariationGroupCPtr getGroupPtr(const std::string &name) const;
 
        inline VariationOverrideCPtr getOverridePtr(const std::string& name) const;
 
        inline const std::string &getClothSetup() const { return m_clothSetup; }
 
        inline const std::string &getLookFile() const { return m_lookFile; }
 
        inline bool hasGeometry(const std::string &name) const { return m_geos.find(name) != m_geos.end(); }
 
        inline bool hasMaterial(const std::string &name) const { return m_mats.find(name) != m_mats.end(); }
 
        inline bool hasGroup(const std::string &name) const { return m_groups.find(name) != m_groups.end(); }
 
        inline bool hasOverride(const std::string& name) const { return m_overrides.find(name) != m_overrides.end(); }
 
        inline bool removeGeometry(const std::string &name);
 
        inline bool removeMaterial(const std::string &name);
 
        inline bool removeGroup(const std::string &name);   
 
        inline bool removeOverride(const std::string& name);
 
        inline bool removeAllGroups();
 
        inline bool removeAllOverrides();
 
        void hash(AtomsCore::MurmurHash3& hasher) const;
 
        void buildCombinations(const std::string& variationName, 
            const std::string& lodName, 
            const int variationSeed, 
            const int agentSeed, 
            const std::vector<std::string>& variationOverrides, 
            const std::vector<std::string>& geoMatOverrides, 
            const std::vector<std::string>& geometryFilters, 
            std::vector<std::string>& debugMessages, 
            std::vector<std::pair<std::string, 
            std::string>>& combinations, 
            const bool storeDebugMessages = false) const;
 
    private:
 
        std::map<std::string, VariationGeometry> m_geos;
 
        std::map<std::string, VariationMaterial> m_mats;
 
        std::map<std::string, VariationGroup> m_groups;
 
        std::map<std::string, VariationOverride> m_overrides;
 
        VariationTree m_variationTree;
 
        std::string m_clothSetup;
 
        std::string m_lookFile;
    };
 
 
    class ATOMS_EXPORT Variations
    {
    public:
 
        Variations() {}
 
        ~Variations() {}
 
        void clear() { m_agentTypeVariations.clear(); };
 
        inline std::vector<std::string> getAgentTypeNames() const;
 
        inline AgentTypeVariation& getAgentTypeVariation(const std::string &agentTypeName) { return m_agentTypeVariations[agentTypeName]; }
 
        inline void setAgentTypeVariation(const std::string &agentTypeName, const AgentTypeVariation& atv) { if (agentTypeName != "") m_agentTypeVariations[agentTypeName] = atv; }
 
        inline AgentTypeVariationCPtr getAgentTypeVariationPtr(const std::string &agentTypeName) const;
 
        inline bool hasAgentTypeVariation(const std::string &agentTypeName) { return m_agentTypeVariations.find(agentTypeName) != m_agentTypeVariations.end(); }
        
        inline bool removeAgentTypeVariation(const std::string &agentTypeName);
 
        bool writeToFile(const std::string &filePath);
 
        std::string toString(const bool prettyprint = false);
 
        void hash(AtomsCore::MurmurHash3& hasher) const;
 
        inline size_t size() const;
 
    private:
 
        std::map<std::string, AgentTypeVariation> m_agentTypeVariations;
    };
}
 
#include <Atoms/Variations.impl.h>