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 VariationGroupLod;
    class VariationMaterialColor;
    
    typedef Variations*  VariationsPtr; 
    typedef AgentTypeVariation*  AgentTypeVariationPtr; 
    typedef VariationGeometry*  VariationGeometryPtr; 
    typedef VariationMaterial*  VariationMaterialPtr; 
    typedef VariationGroup*  VariationGroupPtr; 
    typedef VariationGroupLod* VariationGroupLodPtr; 
    typedef VariationMaterialColor* VariationMaterialColorPtr; 
 
    typedef const Variations*  VariationsCPtr; 
    typedef const AgentTypeVariation*  AgentTypeVariationCPtr; 
    typedef const VariationGeometry*  VariationGeometryCPtr; 
    typedef const VariationMaterial*  VariationMaterialCPtr; 
    typedef const VariationGroup*  VariationGroupCPtr; 
    typedef const VariationGroupLod* VariationGroupLodCPtr; 
    typedef const VariationMaterialColor* VariationMaterialColorCPtr; 
 
 
    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 setDiffuseSlotSize(unsigned int size) { if (size > 1) { m_diffuseFiles.resize(size); m_diffuseRGBs.resize(size); } }
 
        unsigned int getDiffuseSlotSize() const { return static_cast<unsigned int>(m_diffuseFiles.size()); }
 
        const std::string& getDiffuseFile(unsigned int index = 0) const { return m_diffuseFiles[index]; };
 
        const std::string& getSpecularFile() const { return m_specularFile; };
 
        const std::string& getNormalMapFile() const { return m_normalMapFile; };
 
        void setMaterialFile(const std::string& materialFile) { m_materialFile = materialFile; };
 
        void setDiffuseFile(const std::string& diffuseFile, unsigned int index = 0) { m_diffuseFiles[index] = diffuseFile; };
 
        void setSpecularFile(const std::string& specularFile) { m_specularFile = specularFile; };
 
        void setNormalMapFile(const std::string& normalMapFile) { m_normalMapFile = normalMapFile; };
 
        const VariationMaterialColor& getDiffuseColor(unsigned int index = 0) const { return m_diffuseRGBs[index]; }
        VariationMaterialColor& getDiffuseColor(unsigned int index = 0) { return m_diffuseRGBs[index]; }
 
        VariationMaterialColorCPtr getDiffuseColorPtr(unsigned int index = 0) { return &(m_diffuseRGBs[index]); }
 
        unsigned int getDiffuseColorRed() const { return m_diffuseRGBs[0].getRed(); }
 
        unsigned int getDiffuseColorGreen() const { return m_diffuseRGBs[0].getGreen(); }
 
        unsigned int getDiffuseColorBlue() const { return m_diffuseRGBs[0].getBlue(); }
 
        void setDiffuseColorRed(const int red) { m_diffuseRGBs[0].setRed(red); }
 
        void setDiffuseColorGreen(const int green) { m_diffuseRGBs[0].setGreen(green); }
 
        void setDiffuseColorBlue(const int blue) { m_diffuseRGBs[0].setBlue(blue); }
 
        VariationMaterialColor& getSpecularColor() { return m_specularRGB; }
 
        unsigned int getSpecularColorRed() const { return m_specularRGB.getRed(); }
 
        unsigned int getSpecularColorGreen() const { return m_specularRGB.getGreen(); }
 
        unsigned int getSpecularColorBlue() const { return m_specularRGB.getBlue(); }
 
        void setSpecularColorRed(const int red) { m_specularRGB.setRed(red); }
 
        void setSpecularColorGreen(const int green) { m_specularRGB.setGreen(green); }
 
        void setSpecularColorBlue(const int blue) { m_specularRGB.setBlue(blue); }
 
 
        float getDiffuseWeight() const { return m_diffuseWeight; }
        void setDiffuseWeight(float value) { m_diffuseWeight = value; }
 
        float getSpecularWeight() const { return m_specularWeight; }
        void setSpecularWeight(float value) { m_specularWeight = value; }
 
        float getSpecularRollOff() const { return m_specularRollOff; }
        void setSpecularRollOff(float value) { m_specularRollOff = value; }
 
        float getSpecularEccentricity() const { return m_specularEccentricity; }
        void setSpecularEccentricity(float value) { m_specularEccentricity = 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;
 
        VariationMaterialColor m_specularRGB;
 
        std::vector<VariationMaterialColor> m_diffuseRGBs;
    };
 
    /* 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:
        VariationGroupLod(AgentTypeVariationCPtr agentTypeVariation) : m_atVariation(agentTypeVariation) {}
 
        VariationGroupLod(AgentTypeVariationCPtr agentTypeVariation, const VariationGroupLod &lod);
 
        ~VariationGroupLod() {}
 
        inline void clear() { m_combinations.clear(); }
 
        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;
 
    private:
 
 
        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 of an agent type variation and 
    * the variation groups of lods
    */
    class ATOMS_EXPORT VariationGroup
    {
    public:
        VariationGroup(AgentTypeVariationCPtr agentTypeVariation) : m_atVariation(agentTypeVariation) {}
 
        VariationGroup(AgentTypeVariationCPtr agentTypeVariation, const VariationGroup &vg);
 
        ~VariationGroup() {}
 
        inline void clear() { m_combinations.clear(); }
 
        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);
    
        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:
 
 
        AgentTypeVariationCPtr m_atVariation;
 
        std::vector<std::pair<std::string, std::string>> m_combinations;
 
        std::pair<std::string, std::string> m_emptyPair;
 
        std::map<std::string, VariationGroupLod> m_lods;
 
        std::string m_thumbnailPath;
    };
 
    /* 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() {}
 
        ~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 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);
 
        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 VariationGeometryCPtr getGeometryPtr(const std::string &name) const;
 
        inline VariationMaterialCPtr getMaterialPtr(const std::string &name) const;
 
        inline VariationGroupCPtr getGroupPtr(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 removeGeometry(const std::string &name);
 
        inline bool removeMaterial(const std::string &name);
 
        inline bool removeGroup(const std::string &name);   
 
        inline bool removeAllGroups();
 
        void hash(AtomsCore::MurmurHash3& hasher) const;
 
    private:
 
        std::map<std::string, VariationGeometry> m_geos;
 
        std::map<std::string, VariationMaterial> m_mats;
 
        std::map<std::string, VariationGroup> m_groups;
 
        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>