GridLayoutGenerator.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
{
    unsigned int GridLayoutGenerator::sizeX()
    {
        return m_sizeX;
    }
 
    void GridLayoutGenerator::setSizeX(unsigned int sx)
    {
        m_sizeX = sx < 1 ? 1 : sx;
    }
 
    unsigned int GridLayoutGenerator::sizeY()
    {
        return m_sizeY;
    }
 
    void GridLayoutGenerator::setSizeY(unsigned int sy)
    {
        m_sizeY = sy < 1 ? 1 : sy;
    }
 
    unsigned int GridLayoutGenerator::sizeZ()
    {
        return m_sizeZ;
    }
 
    void GridLayoutGenerator::setSizeZ(unsigned int sz)
    {
        m_sizeZ = sz  < 1 ? 1 : sz;
    }
 
    AtomsCore::Vector3 GridLayoutGenerator::space()
    {
        return m_space;
    }
 
    void GridLayoutGenerator::setSpace(const AtomsCore::Vector3& space)
    {
        m_space = space;
    }
 
    AtomsCore::Vector3 GridLayoutGenerator::randomSpace()
    {
        return m_randomSpace;
    }
 
    void GridLayoutGenerator::setRandomSpace(const AtomsCore::Vector3& space)
    {
        m_randomSpace = space;
    }
    
    AtomsCore::Vector3 GridLayoutGenerator::direction()
    {
        return m_direction;
    }
 
    void GridLayoutGenerator::setDirection(const AtomsCore::Vector3& dir)
    {
        m_direction = dir;
    }
 
    AtomsCore::Vector3 GridLayoutGenerator::upVector()
    {
        return m_upVector;
    }
 
    void GridLayoutGenerator::setUpVector(const AtomsCore::Vector3& dir)
    {
        m_upVector = dir;
    }
 
    AtomsCore::Vector3 GridLayoutGenerator::randomDirection()
    {
        return m_randomDirection;
    }
 
    void GridLayoutGenerator::setRandomDirection(const AtomsCore::Vector3& dir)
    {
        m_randomDirection = dir;
    }
 
    AtomsCore::Matrix GridLayoutGenerator::matrix()
    {
 
        return m_matrix;
    }
 
    void GridLayoutGenerator::setMatrix(const AtomsCore::Matrix& mtx)
    {
        m_matrix = mtx;
    }
 
    unsigned int GridLayoutGenerator::seed()
    {
        return m_seed;
    }
 
    void GridLayoutGenerator::setSeed(unsigned int value)
    {
        m_seed = value;
    }
 
    const std::map<int, std::string>& GridLayoutGenerator::agentTypeOverride() const
    {
        return m_agentTypeOverride;
    }
 
    void GridLayoutGenerator::setAgentTypeOverride(const std::map<int, std::string>& value)
    {
        m_agentTypeOverride = value;
    }
 
    const std::map<int, AtomsCore::Vector3>& GridLayoutGenerator::directionOverride() const
    {
        return m_directionOverride;
    }
 
    void GridLayoutGenerator::setDirectionOverride(const std::map<int, AtomsCore::Vector3>& value)
    {
        m_directionOverride = value;
    }
 
    const std::map<int, AtomsCore::Vector3>& GridLayoutGenerator::upVectorOverride() const
    {
        return m_upVectorOverride;
    }
 
    void GridLayoutGenerator::setUpVectorOverride(const std::map<int, AtomsCore::Vector3>& value)
    {
        m_upVectorOverride = value;
    }
 
    void GridLayoutGenerator::setCenterOffset(const AtomsCore::Vector3 offset)
    {
        m_centerOffset = offset;
    }
 
}