SphereLayoutGenerator.impl.h

// ===========================================================================
// 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.
// ===========================================================================
 
namespace Atoms
{   
    const AtomsCore::Vector3& SphereLayoutGenerator::size()
    {
        return m_size;
    }
 
    void SphereLayoutGenerator::setSize(const AtomsCore::Vector3& size)
    {
        m_size = size;
    }
 
    double SphereLayoutGenerator::defaultRadius() const
    {
        return m_defaultRadius;
    }
 
    void SphereLayoutGenerator::setDefaultRadius(double radius)
    {
        m_defaultRadius = radius;
    }
 
    double SphereLayoutGenerator::maxRadius() const
    {
        return m_maxRadius;
    }
 
    void SphereLayoutGenerator::setMaxRadius(double radius)
    {
        m_maxRadius = radius;
    }
 
    bool SphereLayoutGenerator::randomizeRadius() const
    {
        return m_randomizeRadius;
    }
 
    void SphereLayoutGenerator::setRandomizeRadius(bool randomize)
    {
        m_randomizeRadius = randomize;
    }
 
    int SphereLayoutGenerator::iterations() const
    {
        return m_iterations;
    }
 
    void SphereLayoutGenerator::setIterations(int iterations)
    {
        m_iterations = iterations;
    }
 
    const AtomsCore::Vector3& SphereLayoutGenerator::direction() const
    {
        return m_direction;
    }
 
    void SphereLayoutGenerator::setDirection(const AtomsCore::Vector3& dir)
    {
        m_direction = dir;
    }
 
    const AtomsCore::Vector3& SphereLayoutGenerator::upVector() const
    {
        return m_upVector;
    }
 
    void SphereLayoutGenerator::setUpVector(const AtomsCore::Vector3& dir)
    {
        m_upVector = dir;
    }
 
    const AtomsCore::Vector3& SphereLayoutGenerator::randomDirection() const
    {
        return m_randomDirection;
    }
 
    void SphereLayoutGenerator::setRandomDirection(const AtomsCore::Vector3& dir)
    {
        m_randomDirection = dir;
    }
 
    const AtomsCore::Vector3& SphereLayoutGenerator::randomUpVector() const
    {
        return m_randomUpVector;
    }
 
    void SphereLayoutGenerator::setRandomUpVector(const AtomsCore::Vector3& up)
    {
        m_randomUpVector = up;
    }
 
    const AtomsCore::Matrix& SphereLayoutGenerator::matrix() const
    {
 
        return m_matrix;
    }
 
    void SphereLayoutGenerator::setMatrix(const AtomsCore::Matrix& mtx)
    {
        m_matrix = mtx;
    }
 
    unsigned int SphereLayoutGenerator::seed() const
    {
        return m_seed;
    }
 
    void SphereLayoutGenerator::setSeed(unsigned int value)
    {
        m_seed = value;
    }
 
    const std::map<int, std::string>& SphereLayoutGenerator::agentTypeOverride() const
    {
        return m_agentTypeOverride;
    }
 
    void SphereLayoutGenerator::setAgentTypeOverride(const std::map<int, std::string>& value)
    {
        m_agentTypeOverride = value;
    }
 
    const std::map<int, AtomsCore::Vector3>& SphereLayoutGenerator::directionOverride() const
    {
        return m_directionOverride;
    }
 
    void SphereLayoutGenerator::setDirectionOverride(const std::map<int, AtomsCore::Vector3>& value)
    {
        m_directionOverride = value;
    }
 
    const std::map<int, AtomsCore::Vector3>& SphereLayoutGenerator::upVectorOverride() const
    {
        return m_upVectorOverride;
    }
 
    void SphereLayoutGenerator::setUpVectorOverride(const std::map<int, AtomsCore::Vector3>& value)
    {
        m_upVectorOverride = value;
    }
 
    void SphereLayoutGenerator::setCenterOffset(const AtomsCore::Vector3 offset)
    {
        m_centerOffset = offset;
    }
 
}