AgentsLayoutToolData.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 <AtomsCore/AtomsMath.h>
#include <Atoms/Globals.h>
#include <Atoms/AgentGroup.h>
#include <AtomsCore/Metadata/Vector3Metadata.h>
#include <string>
#include <vector>
#include <map>
#include <map>
 
 
namespace Atoms
{
    class ATOMS_EXPORT AgentsLayoutToolData
    {
    public:
 
        enum RotationAxis
        {
            kRotX = 0,
            kRotY,
            kRotZ,
        };
 
        enum Mode
        {
            kAdd = 0,
            kSelect,
            kMove,
            kRotate,
            kScale,
            kTimeOffset,
            kVariation,
            kSocialLayout,
            kClip
        };
 
        enum UP
        {
            kX = 0,
            kY,
            kZ,
            kAgentUp
        };
 
        enum Space
        {
            kLocal = 0,
            kGlobal
        };
 
        enum GlobalRotationMode
        {
            kRotationPositionAndDirection = 0,
            kRotationPosition
        };
 
        enum FalloffMode
        {
            kLinear = 0,
            kEaseInEaseOut
        };
 
        enum GlobalSpaceMode
        {
            kScalePositionAndAgent = 0,
            kScalePosition
        };
 
        enum SocialLayoutMode
        {
            kAverageOrientation = 0,
            kAveragePosition, 
            kLookTowardCenter,
            kLookTowardLocator,
            kOrientationNoise,
            kDistanceNoise,
            kAgentSeparation
        };
 
        enum Layout
        {
            kPoint = 0,
            kGrid,
            kPoisson,
            kPolygon,
            kMeshScatter
        };
 
        enum Poisson
        {
            kCircle = 0,
            kSquare = 1,
            kImage = 2
        };
 
        enum AgentMode
        {
            kAgentMode = 0,
            kJointMode
        };
 
        enum AgentGroupSelectionMode
        {
            kAllAgentGroups = 0,
            kVisibleAgentGroups,
            kSelectedAgentGroups
        };
 
 
        AgentsLayoutToolData();
 
        ~AgentsLayoutToolData();
 
        static AgentsLayoutToolData& instance();
 
        /*
        inline void setNode(MObject& node) { m_nodeHandle = node;}
        inline ObjectType node() { return m_nodeHandle.object(); }
        void updateCachedNodes();
        inline int getNumCachedNodes() { return m_nodeHandles.size(); };
        inline ObjectType getCachedNode(unsigned int index) { return m_nodeHandles[index].object(); };
        void removeCachedNode(const ObjectType &node);
        */
 
        inline void setMode(unsigned short mode) { m_mode = mode; m_falloffDirty = true;}
        inline unsigned short mode() { return m_mode; }
 
        inline void setRotationAxis(unsigned short mode) { m_rotationAxis = mode; }
        inline unsigned short rotationAxis() { return m_rotationAxis; }
 
        inline void setAgentMode(unsigned short mode) { m_agentMode = mode; }
        inline unsigned short agentMode() { return m_agentMode; }
 
        inline void setAgentGroupSelectionMode(unsigned short mode) { m_agentGroupSelectionMode = mode; }
        inline unsigned short  agentGroupSelectionMode() { return m_agentGroupSelectionMode; }
 
        inline void setLayout(unsigned short layout) { m_layout = layout; generateSamples(); }
        inline unsigned short layout() { return m_layout; }
 
        inline void setUseHeightFields(bool val) { m_useHeightFields = val; }
        inline short useHeightFields() { return m_useHeightFields; }
 
        inline void setMoveSpace(bool val) { m_moveSpace = val; }
        inline short moveSpace() { return m_moveSpace; }
 
        inline void setRotationSpace(bool val) { m_rotationSpace = val; }
        inline short rotationSpace() { return m_rotationSpace; }
 
        inline void setGlobalRotationMode(unsigned short val) { m_globalRotationMode = val; }
        inline short globalRotationMode() { return m_globalRotationMode; }
    
        inline void setScaleSpace(bool val) { m_scaleSpace = val; }
        inline short scaleSpace() { return m_scaleSpace; }
 
        inline void setGlobalScaleMode(unsigned short val) { m_globalScaleMode = val; }
        inline short globalScaleMode() { return m_globalScaleMode; }
 
        inline void setRandomSelected(bool val) { m_randomSelected = val; }
        inline bool randomSelected() { return m_randomSelected; }
 
        inline void setUpVector(short val) { m_upVector = val; }
        inline short upVector() { return m_upVector; }
 
        inline void setSelectedObjects(std::vector<std::string>& obList) { m_selectedObjects = obList; }
        inline std::vector<std::string>& selectedObjects() { return m_selectedObjects; }
 
        inline void setTargetObjects(std::vector<std::string>& obList) { m_targetObjects = obList; }
        inline std::vector<std::string>& targetObjects() { return m_targetObjects; }
 
        inline void setAgentTypes(std::vector<std::string>& agentTypes) { m_agentTypes = agentTypes; }
        inline std::vector<std::string>& agentTypes() { return m_agentTypes; }
 
        inline void setAgentTypeWeights(std::vector<int>& weights) { m_agentTypeWeights = weights; }
        inline std::vector<int>& agentTypeWeights() { return m_agentTypeWeights; }
 
        std::string agentType();
 
        inline bool translateLockX() { return m_translateLockX; }
        inline bool translateLockY() { return m_translateLockY; }
        inline bool translateLockZ() { return m_translateLockZ; }
 
        inline void setTranslateLockX(bool val) { m_translateLockX = val; }
        inline void setTranslateLockY(bool val) { m_translateLockY = val; }
        inline void setTranslateLockZ(bool val) { m_translateLockZ = val; }
 
        inline bool rotateLockX() { return m_rotateLockX; }
        inline bool rotateLockY() { return m_rotateLockY; }
        inline bool rotateLockZ() { return m_rotateLockZ; }
 
        inline void setRotateLockX(bool val) { m_rotateLockX = val; }
        inline void setRotateLockY(bool val) { m_rotateLockY = val; }
        inline void setRotateLockZ(bool val) { m_rotateLockZ = val; }
 
        inline bool scaleLockX() { return m_scaleLockX; }
        inline bool scaleLockY() { return m_scaleLockY; }
        inline bool scaleLockZ() { return m_scaleLockZ; }
 
        inline void setScaleLockX(bool val) { m_scaleLockX = val; }
        inline void setScaleLockY(bool val) { m_scaleLockY = val; }
        inline void setScaleLockZ(bool val) { m_scaleLockZ = val; }
 
        inline void setDirection(const AtomsCore::Vector3& val) { m_direction = val; }
        inline AtomsCore::Vector3 direction() { return m_direction; }
 
        inline void setDirectionRandom(const AtomsCore::Vector3& val) { m_directionRandom = val; }
        inline AtomsCore::Vector3 directionRandom() { return m_directionRandom; }
 
        inline void setGridSize(const AtomsCore::Vector3i& val) { m_gridSize = val; generateSamples();}
        inline AtomsCore::Vector3i gridSize() { return m_gridSize; }
 
        inline void setGridSpace(const AtomsCore::Vector3& val) { m_gridSpace = val; generateSamples();}
        inline AtomsCore::Vector3 gridSpace() { return m_gridSpace; }
 
        inline void setGridSpaceRandom(const AtomsCore::Vector3& val) { m_gridSpaceRandom = val; generateSamples();}
        inline AtomsCore::Vector3 gridSpaceRandom() { return m_gridSpaceRandom; }
 
        inline void setGridRotation(const AtomsCore::Vector3& val) { m_gridRotation = val;}
        inline AtomsCore::Vector3 gridRotation() { return m_gridRotation; }
 
        inline void setPointOffset(const AtomsCore::Vector3& val) { m_pointOffset = val; }
        inline AtomsCore::Vector3 pointOffset() { return m_pointOffset; }
 
        inline void setPoissonRadius(double val) { m_poissonRadius = val; generateSamples();}
        inline double poissonRadius() { return m_poissonRadius; }
 
        inline void setPoissonMinDistance(double val) { m_poissonMinDistance = val; generateSamples();}
        inline double poissonMinDistance() { return m_poissonMinDistance; }
 
        inline void setPoissonNumPoints(int val) { m_poissonPoints = val; generateSamples(); }
        inline int poissonNumPoints() { return m_poissonPoints; }
 
        inline void setPoissonSeed(int val) { m_poissonSeed = val; generateSamples(); }
        inline int poissonSeed() { return m_poissonSeed; }
 
        inline void setPoissonShape(short val) { m_poissonShape = val; generateSamples(); }
        inline short poissonShape() { return m_poissonShape; }
 
        inline void setDrawScale(double value) { m_drawScale = value; }
        inline double drawScale() { return m_drawScale; }
 
        inline bool timeOffsetGroupAgents() { return m_timeOffsetGroupAgents; }
        inline void setTimeOffsetGroupAgents(const bool value) { m_timeOffsetGroupAgents = value; }
 
        inline const std::string &copiedVariationName(const std::string &agentType) { return m_copiedVariationName[agentType]; }
        inline void setCopiedVariationName(const std::string &agentType, const std::string &name) { m_copiedVariationName[agentType] = name; }
 
        inline const bool falloffEnabled() { return m_falloffEnabled; }
        inline void setFalloffEnabled(const bool value) { m_falloffEnabled = value; m_falloffDirty = true; }
 
        inline const double falloffRadius() { return m_falloffRadius; }
        inline void setFalloffRadius(const double value) { m_falloffRadius = value; m_falloffDirty = true; }
 
        inline void setFalloffMode(const unsigned int mode) { m_falloffMode = mode; }
        inline const unsigned int falloffMode() { return m_falloffMode; }
 
        inline void clearFalloffDirty() { m_falloffDirty = false; }
        inline bool falloffDirty() { return m_falloffDirty; }
        inline void markFalloffDirty() { m_falloffDirty = true; }
    
        virtual void generateSamples();
 
        inline std::vector<AtomsCore::Vector3> cachedSamples() { return m_cachedSamples; }
        inline void setCachedSamples(std::vector<AtomsCore::Vector3>& samples) { m_cachedSamples = samples; }
 
        void agentSelectionChanged();
 
        virtual void reset();
 
        inline void setJointModeAgentGroupId(size_t mode) { m_jointModeAgentId = mode; }
        inline size_t jointModeAgentGroupId() { return m_jointModeAgentId; }
 
        inline void setJointModeJointId(int mode) { m_jointModeJointId = mode; }
        inline int jointModeJointId() { return m_jointModeJointId; }
 
        inline void setJointModeGroupIndex(int index) { m_jointModeGroupIndex = index; }
        inline int jointModeGroupIndex() { return m_jointModeGroupIndex; }
 
        inline double polyMinRadius() { return m_polyMinRadius;  };
        inline double polyMaxRadius() { return m_polyMaxRadius; };
        inline int polyNumAgents() { return m_polyNumAgents; };
        inline int polyIterations() { return m_polyIterations; };
        inline int polySeed() { return m_polySeed; };
        inline bool polyRandom() { return m_polyRandom; };
 
        inline void setPolyMinRadius(double value) { m_polyMinRadius = value; m_polyHash++;  };
        inline void setPolyMaxRadius(double value) { m_polyMaxRadius = value; m_polyHash++; };
        inline void setPolyNumAgents(int value) { m_polyNumAgents = value; m_polyHash++; };
        inline void setPolyIterations(int value) { m_polyIterations = value; m_polyHash++;};
        inline void setPolySeed(int value) { m_polySeed = value; m_polyHash++;};
        inline void setPolyRandom(bool value) { m_polyRandom = value; m_polyHash++;};
        inline long polyHash() { return m_polyHash; }
 
        inline void setDuplicateAgentGroupIds(const std::string groupName, const int id1, const int id2) { m_agentDuplicateIds[groupName][id1] = id2; };
        inline void resetDuplicateAgentGroupIds() { m_agentDuplicateIds.clear(); };
        int getDuplicateAgentGroupIds(const std::string &groupName, const int id);
 
        inline SocialLayoutMode socialLayoutMode() { return m_socialLayoutMode; };
        inline void setSocialLayoutMode(SocialLayoutMode mode) { m_socialLayoutMode = mode; };
        inline std::vector<int> &getSocialAgentIds() { return m_socialAgentIds; }
        inline std::vector<AtomsCore::Vector3> &socialAgentPositions() { return m_socialAgentPositions; }
        inline std::vector<AtomsCore::Vector3> &socialAgentDirections() { return m_socialAgentDirections; }
        inline std::vector<AtomsCore::Quaternion> &socialAgentRotations() { return m_socialAgentRotations; }
        inline AtomsCore::Vector3 &socialAveragePosition() { return m_socialAgentsAveragePosition; }
        inline AtomsCore::Vector3 &socialAverageDirection() { return m_socialAgentsAverageDirection; }
        inline AtomsCore::Vector3 &socialReferencePosition() { return m_socialReferencePosition; }
        inline void setSocialReferencePosition(const AtomsCore::Vector3 &pos) { m_socialReferencePosition = pos; }
        inline std::vector<int> &socialGroupSizes() { return m_socialGroupSizes; }
 
        inline void setDisplayTimeOffsetBarOnScreenBottom(const bool value) { m_displayTimeOffsetBarOnScreenBottom = value; }
        inline bool displayTimeOffsetBarOnScreenBottom() { return m_displayTimeOffsetBarOnScreenBottom; }
 
        inline void setSocialSeparationForce(double value) { m_socialSeparationForce = value; };
        inline void setSocialSeparationRadius(double value) { m_socialSeparationRadius = value; };
        inline void setSocialDistanceNoise(const AtomsCore::Vector3 &value) { m_socialDistanceNoise = value; };
        inline void setSocialOrientationNoise(const AtomsCore::Vector3 &value) { m_socialOrientationNoise = value; };
        inline double socialSeparationRadius() { return m_socialSeparationRadius; };
        inline double socialSeparationForce() { return m_socialSeparationForce; };
        inline const AtomsCore::Vector3& socialDistanceNoise() { return m_socialDistanceNoise; };
        inline const AtomsCore::Vector3& socialOrientationNoise() { return m_socialOrientationNoise; };
        inline const std::vector<AtomsCore::Vector3> &socialFinalDirections() { return m_socialFinalDirections; };
        inline const std::vector<AtomsCore::Vector3> &socialFinalPositions() { return m_socialFinalPositions; };
        inline void setSocialFinalDirections(const std::vector<AtomsCore::Vector3> &value) { m_socialFinalDirections = value; };
        inline void setSocialFinalPositions(const std::vector<AtomsCore::Vector3> &value) { m_socialFinalPositions = value; };
 
        inline void setMeshScatterIterations(const int value) { m_meshScatterIterations = value; }
        inline void setMeshScatterDefaultRadius(const double value) { m_meshScatterDefaultRadius = value; }
        inline void setMeshScatterMaxRadius(const double value) { m_meshScatterMaxRadius = value; }
        inline void setMeshScatterSeed(const int value) { m_meshScatterSeed = value; }
        inline void setMeshScatterMode(const int value) { m_meshScatterMode = value; }
        inline void setRandRadius(const bool value) { m_meshScatterRandRadius = value; }
        inline void setMeshScatterMesh(const AtomsUtils::Mesh &mesh) { m_meshScatterMesh = mesh;    }
        inline int meshScatterIterations() { return m_meshScatterIterations; }
        inline double meshScatterDefaultRadius() { return m_meshScatterDefaultRadius; }
        inline double meshScatterMaxRadius() { return m_meshScatterMaxRadius; }
        inline int meshScatterSeed() { return m_meshScatterSeed; }
        inline int meshScatterMode() { return m_meshScatterMode; }
        inline bool meshRandRadius() { return m_meshScatterRandRadius; }
 
        int getSocialIndex(const int id) const;
 
        void initSocialLayoutData(const std::vector<Atoms::AgentGroup *> &agentGroups);
        void editAgentsWithSocialValue(double value);
 
        static void searchAgents(const std::vector<Atoms::AgentGroup * > &agentGroups, const bool useSearchRadius, const double searchRadius, const bool ignoreOneAgent, const bool usePercentage, const int percentage, const bool useAgentType, const std::vector<std::string> &agentTypeNames, const bool useMetadata, const std::string &metadataName, const double metadataMin, const double metadataMax, const std::string& metadataStrValue, std::vector<std::vector<int>> &selection);
        static double getPelvisHeightFromAgentType(Atoms::AgentTypeCPtr agentType);
 
        inline void setApplyPelvisHeightOffset(bool val) { m_applyPelvisHeightOffset = val; }
        inline bool applyPelvisHeightOffset() { return m_applyPelvisHeightOffset; }
    
    protected:
 
        void cachePelvisTransformation(const std::vector<Atoms::AgentGroup *> &agentGroups);
        void getHeightFieldsFromAgentGroup(AtomsPtr<Atoms::AgentGroup>& agentGroup, std::string &hfName, std::string &gfName, Atoms::HeightField* &hf, Atoms::HeightField* &gf);
        bool computeHeightField(Atoms::Agent *agent, AtomsCore::Poser &poser, Atoms::HeightField *hf, Atoms::HeightField *gf, AtomsCore::Vector3 &jointRootWorldTranlsate, AtomsCore::Quaternion &jointRootWorldRotation, AtomsCore::Vector3 &jointRootWorldScale, AtomsCore::Vector3f &currPose, AtomsCore::Vector3 &agentUp, AtomsPtr<AtomsCore::Vector3Metadata> &upVec, double &pelvisHeight, bool useHeightFields);
        void findModules(const AtomsPtr<Atoms::AgentGroup> &agentGroup, bool &isPointLayout, bool &isCacheReader, std::string &currentModuleName);
 
        unsigned short m_mode;
 
        unsigned short m_layout;
 
        unsigned short m_agentMode;
        unsigned short m_agentGroupSelectionMode;
 
        unsigned short m_globalRotationMode;
        unsigned short m_globalScaleMode;
 
        unsigned short m_rotationAxis;
 
        bool m_useHeightFields;
 
        bool m_randomSelected;
 
        bool m_timeOffsetGroupAgents;
 
        // 0:x 1:y 2:z
        short m_upVector;
 
        bool m_translateLockX;
        bool m_translateLockY;
        bool m_translateLockZ;
 
        bool m_rotateLockX;
        bool m_rotateLockY;
        bool m_rotateLockZ;
 
        bool m_scaleLockX;
        bool m_scaleLockY;
        bool m_scaleLockZ;
 
        short m_moveSpace;
        short m_rotationSpace;
        short m_scaleSpace;
 
        bool m_displayTimeOffsetBarOnScreenBottom;
 
        AtomsCore::Vector3 m_pointOffset;
 
        AtomsCore::Vector3i m_gridSize;
        AtomsCore::Vector3 m_gridSpace;
        AtomsCore::Vector3 m_gridSpaceRandom;
        AtomsCore::Vector3 m_gridRotation;
 
        AtomsCore::Vector3 m_direction;
        AtomsCore::Vector3 m_directionRandom;
 
        std::map<std::string, std::map<int, int>> m_agentDuplicateIds;
 
        double m_poissonRadius;
        double m_poissonMinDistance;
        double m_poissonPoints;
        short m_poissonShape;
        unsigned int m_poissonSeed;
        std::string m_poissonMask;
 
        std::map<std::string, std::string> m_copiedVariationName;
 
        double m_drawScale;
 
        std::vector<std::string> m_agentTypes;
        std::vector<int> m_agentTypeWeights;
 
        std::vector<std::string> m_selectedObjects;
 
        std::vector<std::string> m_targetObjects;
 
        std::vector<AtomsCore::Vector3> m_cachedSamples;
 
        size_t m_jointModeAgentId;
 
        int m_jointModeJointId;
        int m_jointModeGroupIndex;
 
        bool m_falloffEnabled;
        double m_falloffRadius;
        bool m_falloffDirty;
        unsigned short m_falloffMode;
 
        double m_polyMinRadius;
        double m_polyMaxRadius;
        int m_polyNumAgents;
        int m_polyIterations;
        int m_polySeed;
        bool m_polyRandom;
 
        long m_polyHash;
 
        std::vector<int> m_socialAgentIds;
        std::vector<int> m_socialGroupSizes;
        std::vector<AtomsCore::Vector3> m_socialAgentPositions;
        std::vector<AtomsCore::Vector3> m_socialAgentDirections;
        std::vector<AtomsCore::Quaternion> m_socialAgentRotations;
        std::vector<AtomsCore::Vector3> m_agentRandomOffsetDistances;
        std::vector<AtomsCore::Vector3> m_agentRandomOffsetDirections;
        std::vector<std::string> m_socialAgentGroupNames;
        AtomsCore::Vector3 m_socialAgentsAveragePosition;
        AtomsCore::Vector3 m_socialAgentsAverageDirection;
        AtomsCore::Vector3 m_socialReferencePosition;
        std::vector<AtomsCore::Vector3> m_socialFinalPositions;
        std::vector<AtomsCore::Vector3> m_socialFinalDirections;
        SocialLayoutMode m_socialLayoutMode;
 
        AtomsCore::Vector3 m_socialOrientationNoise;
        AtomsCore::Vector3 m_socialDistanceNoise;
        double m_socialSeparationForce;
        double m_socialSeparationRadius;
        AtomsUtils::KdTreePoint m_socialKdTree;
 
        AtomsUtils::Mesh m_meshScatterMesh;
        int m_meshScatterIterations;
        double m_meshScatterDefaultRadius;
        double m_meshScatterMaxRadius;
        int  m_meshScatterSeed;
        int m_meshScatterMode;
        bool m_meshScatterRandRadius;
 
        AtomsCore::Rand48 m_random;
 
        bool m_applyPelvisHeightOffset;
    };
}