D:/work/nytro/include/graphics/nyAnimation.h

Go to the documentation of this file.

#ifndef __NYTRO_Animation_H
#define __NYTRO_Animation_H

//*****************************************************************************
// Nytro GameEngine
//
// © Copyright 7thFACTOR Entertainment
// All rights reserved
//*****************************************************************************

#include "system/nyCommon.h"
#include "system/nyBase.h"
#include "graphics/nyColor.h"
#include "math/nyMath.h"

namespace Nytro
{
    namespace Audio
    {
        class SoundSource;
    };

    namespace Scene
    {
        class SceneNode;
    };

    namespace Game
    {
        class FlowGraph;
    };

    namespace Graphics
    {
        using namespace Scene;
        using namespace Game;
        using namespace Audio;

        class Animation;
        class AnimationTrack;
        
        enum EAnimationLoop
        {
            eAnimationLoop_None = 0,
            eAnimationLoop_Repeat,
            eAnimationLoop_PingPong
        };

        enum EAnimationInterpolation
        {
            eAnimationInterpolation_Linear = 0,
            eAnimationInterpolation_Bezier,
            eAnimationInterpolation_TCB
        };

        class NYTRO_API AnimationKeyValue
        {
            public:

                union
                {
                    int8        m_int8;
                    int16       m_int16;
                    int32       m_int32;
                    int64       m_int64;
                    float32     m_float32;
                    float64     m_float64;
                    float32     m_vector[3];
                    float32     m_quat[4];
                    float32     m_color[4];
                };
        };

        class NYTRO_API AnimationKey
        {
            public:

                enum EAnimationKeyFlag
                {
                    eAnimationKeyFlag_Active    = NYTRO_BIT(0),
                    eAnimationKeyFlag_UseEase   = NYTRO_BIT(1)
                };

                AnimationKey();
                virtual ~AnimationKey();

                void set( voidptr pData );
                void interpolate( EAnimationInterpolation aIpolType, AnimationKey& rKey, float32 aT, voidptr pData );

                AnimationKey&   operator += ( AnimationKey& rAnimationKey );
                AnimationKey&   operator -= ( AnimationKey& rAnimationKey );
                AnimationKey&   operator *= ( AnimationKey& rAnimationKey );
                AnimationKey&   operator /= ( AnimationKey& rAnimationKey );

                AnimationKey    operator + ( AnimationKey& rAnimationKey );
                AnimationKey    operator - ( AnimationKey& rAnimationKey );
                AnimationKey    operator * ( AnimationKey& rAnimationKey );
                AnimationKey    operator / ( AnimationKey& rAnimationKey );

                AnimationKey&   operator += ( float32 rValue );
                AnimationKey&   operator -= ( float32 rValue );
                AnimationKey&   operator *= ( float32 rValue );
                AnimationKey&   operator /= ( float32 rValue );

                AnimationKey    operator + ( float32 rValue );
                AnimationKey    operator - ( float32 rValue );
                AnimationKey    operator * ( float32 rValue );
                AnimationKey    operator / ( float32 rValue );

                uint32              m_flags;
                float32             m_time;
                uint32              m_type; 
                float32             m_tension,
                                    m_continuity,
                                    m_bias,
                                    m_easeIn,
                                    m_easeOut;
                AnimationKeyValue   m_value,
                                    m_leftTangent,
                                    m_rightTangent;
        };

        class NYTRO_API AnimationTrackController : public Base
        {
            public:

                enum EAnimationTrackCtrlOp
                {
                    eAnimationTrackCtrlOp_Add,
                    eAnimationTrackCtrlOp_Subtract,
                    eAnimationTrackCtrlOp_Multiply,
                    eAnimationTrackCtrlOp_Divide,
                    eAnimationTrackCtrlOp_Replace
                };

                AnimationTrackController();
                virtual ~AnimationTrackController();

                AnimationTrack*         getTrack();
                AnimationKey            getResultKey();
                EAnimationTrackCtrlOp   getOperand();
                virtual void            initialize();
                virtual void            release();
                virtual void            setTrack( AnimationTrack* pTrack );
                virtual void            setOperand( EAnimationTrackCtrlOp aValue );
                virtual void            controlValue( float32 aTime, voidptr pCurrentValue );

            protected:

                AnimationTrack*         m_pTrack;
                AnimationKey            m_resultKey;
                EAnimationTrackCtrlOp   m_operand;
        };

        class NYTRO_API AnimationTrack : public Base
        {
            public:

                enum EAnimationTrackType
                {
                    eAnimationTrackType_Int8,
                    eAnimationTrackType_Int16,
                    eAnimationTrackType_Int32,
                    eAnimationTrackType_Int64,
                    eAnimationTrackType_Float32,
                    eAnimationTrackType_Float64,
                    eAnimationTrackType_Vector2,
                    eAnimationTrackType_Vector3,
                    eAnimationTrackType_Quaternion,
                    eAnimationTrackType_Color
                };

                enum EAnimationTrackFlag
                {
                    eAnimationTrackFlag_Active = NYTRO_BIT(0)
                };

                AnimationTrack();
                virtual ~AnimationTrack();

                vector<AnimationKey>&               getKeys();
                vector<AnimationTrackController*>&  getControllers();
                voidptr                             getVariable();
                EAnimationLoop                      getLoopMode();
                float32                             getSpeed();
                AnimationKey&                       getDefaultKeyVariable();
                uint32                              getAnimationTrackFlags();
                void                                setAnimationTrackFlags( uint32 aFlags );
                void                                setVariable( voidptr pValue );
                void                                setLoopMode( EAnimationLoop aValue );
                void                                setSpeed( float32 aValue );
                void                                setInterpolationType( EAnimationInterpolation aType )
                {
                    m_interpolationType = aType;
                }

                EAnimationInterpolation             getInterpolationType() const
                {
                    return m_interpolationType;
                }

                virtual void            process( float32 aTime );
                virtual void            bindToVariable( EAnimationTrackType aType, voidptr pData );
                virtual AnimationKey*   addKey( float32 aTime, voidptr pData );
                virtual void            computeTangents();

                AnimationKey*           addKey( float32 aTime, float32 aData );
                AnimationKey*           addKey( float32 aTime, float64 aData );
                AnimationKey*           addKey( float32 aTime, int64 aData );
                AnimationKey*           addKey( float32 aTime, int32 aData );
                AnimationKey*           addKey( float32 aTime, int16 aData );
                AnimationKey*           addKey( float32 aTime, int8 aData );
                AnimationKey*           addKey( float32 aTime, Vector3D& aData );
                AnimationKey*           addKey( float32 aTime, Quaternion& aData );
                AnimationKey*           addKey( float32 aTime, Color& aData );

            protected:

                uint32                              m_animationTrackFlags;
                vector<AnimationKey>                m_keys;
                EAnimationInterpolation             m_interpolationType;
                AnimationKey                        m_defaultKeyVariable;
                vector<AnimationTrackController*>   m_controllers;
                voidptr                             m_pVariable;
                EAnimationLoop                      m_loopMode;
                float32                             m_speed,
                                                    m_direction;
        };

        class NYTRO_API AnimationEvent : public Base
        {
            public:
                
                AnimationEvent();
                virtual ~AnimationEvent();

                void    setTime( float32 aValue );
                void    setActive( bool bActive );
                void    setTriggered( bool bTrigger );
                void    setDescription( const char* pValue );

                float32     getTime();
                bool        isActive();
                bool        isTriggered();
                string      getDescription();

                virtual void onTrigger();

            protected:

                float32     m_time;
                bool        m_bActive, m_bTriggered;
                string      m_description;
        };

        class NYTRO_API SoundAnimationEvent : public AnimationEvent
        {
            public:

                SoundAnimationEvent();
                virtual ~SoundAnimationEvent();

                NYTRO_CLASS_NAME( SoundAnimationEvent );
                virtual void onTrigger();

                string              m_soundFile, m_parentName;
                float32             m_volume;
                bool                m_bFollowParent;
                SceneNode*          m_pParent;
                SoundSource*        m_pSound;
        };

        class NYTRO_API FlowGraphAnimationEvent : public AnimationEvent
        {
            public:

                FlowGraphAnimationEvent();
                virtual ~FlowGraphAnimationEvent();

                NYTRO_CLASS_NAME( FlowGraphAnimationEvent );
                virtual void    onTrigger();
                
                FlowGraph*      m_pGraph;
        };

        class NYTRO_API Animation : public Base
        {
            public:

                enum EAnimationFlag
                {
                    eAnimationFlag_AutoDuration = NYTRO_BIT(0)
                };

                Animation();
                virtual ~Animation();

                float32                     getDuration();
                float32                     getTime();
                float32                     getTimeScale();
                vector<AnimationTrack*>&    getTracks();
                EAnimationLoop              getLoopMode();

                void                        setDuration( float32 aValue );
                void                        setTime( float32 aValue );
                void                        setTimeScale( float32 aValue );
                void                        setLoopMode( EAnimationLoop aValue );
                uint32                      getAnimationFlags();
                void                        setAnimationFlags( uint32 aFlags );

                virtual void                process( float32 aTimeDelta );
                virtual AnimationTrack*     addTrack( const char* pName, AnimationTrack::EAnimationTrackType aType, voidptr pData );
                virtual void                play();
                virtual AnimationTrack*     findTrackByName( const char* pName );
                virtual void                loadFromXmlElements( XmlElement* pElem );
                        void                freeData();

            protected:

                uint32                  m_animationFlags;
                float32                 m_duration,
                                        m_time;
                float32                 m_timeScale,
                                        m_direction;
                EAnimationLoop          m_loopMode;
                vector<AnimationTrack*> m_tracks;
                vector<AnimationEvent*> m_events;
        };

        class NYTRO_API AnimationSetData : public Resource
        {
            public:

                NYTRO_CLASS_NAME( AnimationSetData );

                AnimationSetData();
                virtual ~AnimationSetData();

                EResult                 load( const char* pFilename = NULL );
                EResult                 unload();
                void                    free();
                map<string,Animation*>& getAnimations();

            protected:

                map<string,Animation*>  m_animations;
        };
    };
};

#endif