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 setRandomDirection(const AtomsMath::Vector3f &randomDirection) { m_randomDirection = randomDirection; }
        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, AtomsCore::Vector3> scaleOverride() const { AtomsUtils::Logger::warning() << "LayoutGenerator.scaleOverride method is deprecated."; return std::map<int, AtomsCore::Vector3>(); };
 
        inline void setScaleOverride(const std::map<int, AtomsCore::Vector3>& value) { AtomsUtils::Logger::warning() << "LayoutGenerator.setScaleOverride method is deprecated, please use setScaleAttributeCache instead."; }
 
        inline void setScaleAttributeCache(const BehaviourModuleAttributeCache<AtomsCore::Vector3>& scaleAttributeCache) { m_scaleAttributeCache = scaleAttributeCache; }
 
        inline const char* typeName() override { return "meshScatter"; };
 
    private:
        // scale attribute cache
        BehaviourModuleAttributeCache<AtomsCore::Vector3> m_scaleAttributeCache;
 
        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_randomDirection;
        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;
    };
}