AnimationState.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
{
    void AnimationState::setName(const std::string &name)
    {
        m_name = name;
    }
 
    
    const std::string& AnimationState::name() const
    {
        return m_name;
    }
 
    
    void AnimationState::setId(int id)
    {
        m_id = id;
    }
 
 
    int AnimationState::id() const
    {
        return m_id;
    }
 
    bool AnimationState::isEmpty() const
    {
        return (!m_isLocomotion && m_clips.size() == 0) && (m_isLocomotion && m_locomotionName.length() == 0);
    }
 
    void AnimationState::addClip(const AnimationStateClip &clip)
    {
        m_clips.push_back(clip);
    }
 
    void AnimationState::removeClip(unsigned int &clipId)
    {
        if (clipId < m_clips.size())
        {
            auto it = m_clips.begin();
            std::advance(it, clipId);
            m_clips.erase(it);
        }
    }
 
    const AnimationStateClip& AnimationState::clip(unsigned int clipId) const
    {
        return m_clips[clipId];
    }
 
    AnimationStateClip& AnimationState::clip(unsigned int clipId)
    {
        return m_clips[clipId];
    }
 
    unsigned int AnimationState::numClips() const
    {
        return static_cast<unsigned int>(m_clips.size());
    }
 
    void AnimationState::clearClips()
    {
        m_clips.clear();
    }
 
    void AnimationState::setMaxTurnAngle(const AtomsCore::Vector3& angle)
    {
        m_maxTurnAngle = angle;
    }
 
    const AtomsCore::Vector3& AnimationState::maxTurnAngle() const
    {
        return m_maxTurnAngle;
    }
 
    void AnimationState::setMaxAcceleration(const AtomsCore::Vector2& acceleration)
    {
        m_maxAcceleration = acceleration;
    }
 
    const AtomsCore::Vector2& AnimationState::maxAcceleration() const
    {
        return m_maxAcceleration;
    }
 
    void AnimationState::setAverageNumFrames(const AtomsCore::Vector2i& averageNumFrames)
    {
        m_averageNumFrames = averageNumFrames;
    }
 
    const AtomsCore::Vector2i& AnimationState::averageNumFrames() const
    {
        return m_averageNumFrames;
    }
 
    void AnimationState::setBlendInFrames(unsigned int frames)
    {
        m_blendInFrames = frames;
    }
 
    unsigned int AnimationState::blendInFrames() const
    {
        return m_blendInFrames;
    }
 
    void AnimationState::setBlendOutFrames(unsigned int frames)
    {
        m_blendOutFrames = frames;
    }
 
    unsigned int AnimationState::blendOutFrames() const
    {
        return m_blendOutFrames;
    }
 
    void AnimationState::setRandomLoop(bool value)
    {
        m_randomLoop = value;
    }
 
    bool AnimationState::randomLoop() const
    {
        return m_randomLoop;
    }
 
    const std::vector<unsigned int>& AnimationState::validClips() const
    {
        return m_validClips;
    }
 
    const std::vector<unsigned int>& AnimationState::validMotionTypeClips(unsigned int motionType) const
    {
        return m_validMotionTypeClips[motionType];
    }
 
    void AnimationState::setVelocity(double velocity)
    {
        m_velocity = velocity;
    }
    
    double AnimationState::velocity() const
    {
        return m_velocity;
    }
 
    void AnimationState::setIsLocomotion(const bool value)
    {
        m_isLocomotion = value;
    }
 
    bool AnimationState::isLocomotion() const
    {
        return m_isLocomotion;
    }
 
    void AnimationState::setLocomotionName(const std::string& value)
    {
        m_locomotionName = value;
    }
 
    const std::string& AnimationState::locomotionName() const
    {
        return m_locomotionName;
    }
}