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