MeshScatterLayoutGenerator.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 <vector>
#include <Atoms/LayoutGenerators/DynamicLayoutGenerator.h>
#include <AtomsUtils/Mesh.h>
#include <AtomsUtils/Image.h>
 
namespace Atoms
{
    class ATOMS_EXPORT MeshScatterLayoutGenerator: public Atoms::DynamicLayoutGenerator
    {
    public:
 
        enum ScatterMode
        {
            kRandom = 0,
            kVertices,
            kFaceCenter,
            kVerticesIteration,
            kFaceCenterIteration
        };
 
        MeshScatterLayoutGenerator();
 
        virtual ~MeshScatterLayoutGenerator();
 
        virtual std::vector<Atoms::AgentInitData> generate(double time)
        #ifdef __APPLE__
                override
        #endif
        ;
 
        void setMesh(const AtomsUtils::Mesh &mesh, short mode = 0);
        inline void setDefaultRadius(double radius){m_defaultRadius = radius;}
        inline void setDensityMap(AtomsUtils::Image* densityMap){m_densityMap = densityMap;}
        inline void setMaxRadius(double radius){m_maxRadius = radius;}
        inline void setUseDensityMap(bool state){m_useDensityMap = state;}
        inline void setRandomizeRadius(bool state){m_randomizeRadius = state;}
        inline void setIterations(int iterations){m_iterations = iterations;}
        inline void setDirection(const AtomsMath::Vector3f &direction){m_direction = direction;}
        inline void setRandomDirection(const AtomsMath::Vector3f &randomDirection) { m_randomDirection = randomDirection; }
        inline void setUpVector(const AtomsMath::Vector3f &direction) { m_upVector = direction; }
        inline void setScale(const AtomsMath::Vector3f &direction) { m_scale = direction; }
        inline void setMeshMatrix(const AtomsMath::Matrix &matrix){m_meshMatrix = matrix;}
        inline void setRandomSeed(unsigned int seed){m_randomSeed = seed;}
        inline void setEraseMap(AtomsUtils::Image* densityMap) { m_eraseMap = densityMap; }
        inline void setEraseThreshold(double radius) { m_eraseThreshold = radius; }
        inline void setUseEraseMap(bool state) { m_useEraseMap = state; }
        inline void useNormalAsUpVector(bool value) { m_useNormalAsUp = value; }
        inline void setUseNavMesh(bool value) { m_useNavMesh = value; }
        inline void setNavMeshName(const std::string & value) { m_navMeshName = value; };
        inline void setClamp(const bool useClampVector, const AtomsCore::Vector3 &clampVector, const double clampAngle) { m_useClampVector = useClampVector; m_clampVector = clampVector; m_clampAngle = clampAngle;}
        inline void setOtherSamples(const std::vector<AtomsCore::Vector3> &otherSamples) { m_otherSamples = otherSamples; }
        inline void setAgentMaxNum(const int agentMaxNum) { m_agentMaxNum = agentMaxNum; }
 
        inline const std::map<int, std::string>& agentTypeOverride() const { return m_agentTypeOverride; };
 
        inline void setAgentTypeOverride(const std::map<int, std::string>& value) { m_agentTypeOverride = value; }
 
        inline const std::map<int, AtomsCore::Vector3>& directionOverride() const { return m_directionOverride; };
 
        inline void setDirectionOverride(const std::map<int, AtomsCore::Vector3>& value) { m_directionOverride = value; }
 
        inline const std::map<int, AtomsCore::Vector3>& upVectorOverride() const { return m_upVectorOverride; };
 
        inline void setUpVectorOverride(const std::map<int, AtomsCore::Vector3>& value) { m_upVectorOverride = value; }
 
        inline const std::map<int, AtomsCore::Vector3>& scaleOverride() const { return m_scaleOverride; };
 
        inline void setScaleOverride(const std::map<int, AtomsCore::Vector3>& value) { m_scaleOverride = value; }
 
        inline const char* typeName() override { return "meshScatter"; };
 
    private:
        int m_iterations;
        int m_agentMaxNum;
        double m_defaultRadius;
        double m_maxRadius;
        double m_eraseThreshold;
        AtomsUtils::Mesh m_mesh;
        AtomsUtils::Image* m_densityMap;
        AtomsUtils::Image* m_eraseMap;
        AtomsMath::Vector3 m_direction;
        AtomsMath::Vector3 m_randomDirection;
        AtomsMath::Vector3 m_upVector;
        AtomsMath::Vector3 m_scale;
        AtomsMath::Vector3 m_clampVector;
        AtomsMath::Matrix m_meshMatrix;
        double m_clampAngle;
        unsigned int m_randomSeed;
        short m_scatterMode;
        bool m_randomizeRadius;
        bool m_useDensityMap;
        bool m_useEraseMap;
        bool m_useNormalAsUp;
        bool m_useNavMesh;
        bool m_useClampVector;
        std::string m_navMeshName;
 
        AtomsCore::Rand48 m_random;
        
        std::vector<AtomsCore::Vector3> m_otherSamples;
        std::map<int, std::string> m_agentTypeOverride;
        std::map<int, AtomsCore::Vector3> m_directionOverride;
        std::map<int, AtomsCore::Vector3> m_upVectorOverride;
        std::map<int, AtomsCore::Vector3> m_scaleOverride;
    };
}