SphereLayoutGenerator.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/LayoutGenerators/DynamicLayoutGenerator.h>
 
namespace Atoms
{
    class ATOMS_EXPORT SphereLayoutGenerator: public DynamicLayoutGenerator
    {
    public:
 
        SphereLayoutGenerator();
 
        virtual ~SphereLayoutGenerator();
 
        virtual std::vector<AgentInitData> generate(double time)
        #ifdef __APPLE__
                override
        #endif
        ;
 
        inline const AtomsCore::Vector3& size();
 
        inline void setSize(const AtomsCore::Vector3& size);
        
        inline double defaultRadius() const;
 
        inline void setDefaultRadius(double radius);
 
        inline double maxRadius() const;
 
        inline void setMaxRadius(double radius);
 
        inline bool randomizeRadius() const;
 
        inline void setRandomizeRadius(bool randomize);
 
        inline int iterations() const;
 
        inline void setIterations(int iterations);
 
        inline const AtomsCore::Vector3& direction() const;
 
        inline void setDirection(const AtomsCore::Vector3& dir);
 
        inline const AtomsCore::Vector3& randomDirection() const;
 
        inline void setRandomDirection(const AtomsCore::Vector3& dir);
 
        inline const AtomsCore::Vector3& upVector() const;
 
        inline void setUpVector(const AtomsCore::Vector3& up);
 
        inline const AtomsCore::Vector3& randomUpVector() const;
 
        inline void setRandomUpVector(const AtomsCore::Vector3& up);
 
        inline const AtomsCore::Matrix& matrix() const;
 
        inline void setMatrix(const AtomsCore::Matrix& mtx);
 
        inline unsigned int seed() const;
 
        inline void setSeed(unsigned int value);
 
        inline const std::map<int, std::string>& agentTypeOverride() const;
 
        inline void setAgentTypeOverride(const std::map<int, std::string>& value);
 
        inline const std::map<int, AtomsCore::Vector3>& directionOverride() const;
 
        inline void setDirectionOverride(const std::map<int, AtomsCore::Vector3>& value);
 
        inline const std::map<int, AtomsCore::Vector3>& upVectorOverride() const;
 
        inline void setUpVectorOverride(const std::map<int, AtomsCore::Vector3>& value);
 
        inline void setCenterOffset(const AtomsCore::Vector3 offset);
 
        inline const char* typeName() override { return "sphereLayout"; };
 
    private:
 
        std::map<int, std::string> m_agentTypeOverride;
 
        std::map<int, AtomsCore::Vector3> m_directionOverride;
 
        std::map<int, AtomsCore::Vector3> m_upVectorOverride;
 
        AtomsCore::Matrix m_matrix;
 
        AtomsCore::Vector3 m_direction;
 
        AtomsCore::Vector3 m_randomDirection;
 
        AtomsCore::Vector3 m_upVector;
 
        AtomsCore::Vector3 m_randomUpVector;
 
        AtomsCore::Vector3 m_centerOffset;
 
        AtomsCore::Vector3 m_size;
 
        double m_defaultRadius;
 
        double m_maxRadius;
 
        int m_iterations;
 
        unsigned int m_seed;
 
        AtomsCore::Rand48 m_random;
 
        AtomsCore::Rand48 m_randomRadius;
 
        bool m_randomizeRadius;
    };
}
 
#include "SphereLayoutGenerator.impl.h"