Animator.h

Go to the documentation of this file.

#ifndef ANIMATOR_H
#define ANIMATOR_H

#include <vrecko/Ability.h>
#include <vrecko/IOPins.h>
#include <vrecko/Timer.h>
#include <helpers/DynamicArray.h>

using namespace vrecko;

namespace APObjectUtils
{


#ifndef ANIMATOR_IMP_EXP
    #ifdef AP_OBJECTUTILS_EXPORTS
        #define ANIMATOR_IMP_EXP __declspec(dllexport)
    #else
        #define ANIMATOR_IMP_EXP __declspec(dllimport)
    #endif
#endif


    class ANIMATOR_IMP_EXP Animator: public Ability
    {
    public:

        class AnimationPoint {
        public:
            AnimationPoint();

            osg::Vec3 translation;
            osg::Quat rotation;
            osg::Vec3 scale;

            float fAlpha;

            osg::Node::NodeMask nodeMask;
        };

        static Animator* getAnimatorOnObject(vrecko::EnvironmentObject *object);
            // Returns an animator if there is one.
        
        static Animator* addAnimatorToObject(vrecko::EnvironmentObject *object, bool bReuseOldIfPossible = true);
            // Creates an Animator ability and assignes it to the object.
            // If the object already had an ability of this type, it will be returned
            // and no new ability will be created.


        // Which properties are being animated?
        enum AnimationTypes {
            AnimSRT = 1, // Scaling + Rotation + Translation
            AnimAlpha = 2, // Transparency
            AnimNodeMask = 4 // Node mask
                // (The mask is interpolated: The masks of the nearest animation points are ORed)
        };
        enum LoopType {
            NoLoop, // No looping
            Simple, // Simple looping
            BiDi // Bi-directional looping (ping-pong)
        };
        enum InterpolationType {
            Linear, // linear interpolation
            Sine // sine interpolation with soft start and finish
        };

        Animator();
        virtual ~Animator();

        virtual void preInitialize();
        virtual bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *pParametersNode);
        virtual void update();
//      virtual void processEvent(const std::string &strInputName, void *pValue);
        virtual void clean();

        bool removeAnimation();

        bool isAnimating() { return bAnimating; };

        bool stopAnimation();
        bool startAnimation();

        bool animateToPoint(int pointIndex);
        
        /* Stops the animation and sets to position to the specified one.
           Allowed values are from 0.0f to "animationPointsNumber - 1" where 0.0f = start,
           "animationPointsNumber - 1" = end */
        bool resetToPos(float fPos);


        bool setAnimationPointsNumber(unsigned int number);
        inline unsigned int getAnimationPointsNumber() { return points.dwNum; }

        bool setEnabledAnimations(unsigned long dwAnimations);
            // the [dwAnimations] is a combination of Animator::AnimationTypes
        inline unsigned long getEnabledAnimations() { return enabledAnimations; }
            // the [dwAnimations] is a combination of Animator::AnimationTypes

        bool setTranslation(int pointIndex, const osg::Vec3 &trans);
        osg::Vec3 &getTranslation(int pointIndex);

        bool setRotation(int pointIndex, const osg::Quat &rot);
        inline osg::Quat &getRotation(int pointIndex);

        bool setScale(int pointIndex, const osg::Vec3 &scale);
        osg::Vec3 &getScale(int pointIndex);

        bool setAlpha(int pointIndex, float alpha); // 0.0 to 1.0
        float getAlpha(int pointIndex);

        bool setNodeMask(int pointIndex, osg::Node::NodeMask nodeMask);
        osg::Node::NodeMask getNodeMask(int pointIndex);

        bool setTimePerLoop(float timeInS) { timePerLoop = timeInS; return true; };
        inline float getTimePerLoop() { return timePerLoop; }

        bool setLoopType(LoopType newType) { loopType = newType; return true; };
        inline LoopType getLoopType() { return loopType; };

        bool setInterpolationType(InterpolationType newType) { interpolationType = newType; return true; };
        inline InterpolationType getInterpolationType() { return interpolationType; };

        bool setTransformationFromMatrix(int startPointIndex, int endPointIndex, const osg::Matrix &matrix);
        
        /* Returns the tranformation matrix belonging to the specified _actual_ position.
           Allowed values are from 0.0f to "animationPointsNumber - 1" where 0.0f = start,
           "animationPointsNumber - 1" = end */
        bool getAnimMatrix(float fActPos, osg::Matrix &outMatrix);

    protected:
        EnvironmentObject *owner;

        unsigned int enabledAnimations;
        LoopType loopType;
        InterpolationType interpolationType;

        DynamicArray<AnimationPoint> points;

        osg::ref_ptr<osg::StateSet> stateSet;

/*      osg::Vec3 translationFrom, translationTo;
        osg::Vec3 rotationAxisStart, rotationAxisDirFrom, rotationAxisDirTo;
        float rotationAngleFrom, rotationAngleTo;
        osg::Matrix cachedRotationTransformation1, cachedRotationTransformation2;
            // Cached transformations to transform TO and FROM rotation axis start.

        osg::Vec3 scaleFrom, scaleTo;
//      osg::Quat scaleOrientation;
*/

        float timePerLoop; // time in seconds

        bool bAnimating;
        float fActTime; // MAIN CONTROL of the animation (0.0 to "animationPointsNumber - 1" for one loop)
        int iActDir; // current direction of the animation (1 or -1)

        osg::Timer_t lastTimerTick;

        float convertActTimeToActPos();
            // Returns a number (0.0 <= number <= (animationPointsNumber - 1))
            // Includes any ease in or out, dumping or whatever will be available.
        float convertActPosToNormPos(float fActPos, int *outPoint1, int *outPoint2);
            // Returns normalized position (0.0 <= "normPos" <= 1.0) along with
            // the boundary points (1 and 2)

        bool updateActTime();
        bool updateAnimation(float fActPos);

        bool calcAnimMatrix(float fNormPos, int iPoint1, int iPoint2, osg::Matrix &outMatrix);
            // 0.0f <= [fNormPos] <= 1.0

        DECLARE_INPUT(Trigger, MessageVoid);
        DECLARE_INPUT(AnimateToPoint, MessageInt);

        DECLARE_OUTPUT(AnimationEnded, MessageBool);
    };

}


#endif