subblock_animation.h

Go to the documentation of this file.

#ifndef _subblock_animation
#define _subblock_animation 1

#include <osg/Vec3>
#include <osg/Quat>
#include <osg/Node>
#include <vector>
#include "awHelper.h"

using namespace std;

namespace ArtificialWorld
{
    enum AnimationType {
        ScaleRotateTranslation = 1,
        Alpha = 2,
        NodeMask = 4
    };

    enum AnimationLoopType{
        NoLoop,
        Simple,
        BiDirectional
    };

    enum AnimationInterpolationType{
        Linear,
        Sine
    };

    class AnimationPoint{
    public:
        osg::Vec3 translation;
        osg::Quat rotation;
        osg::Vec3 scale;
        float alpha;
        osg::Node::NodeMask nodeMask;

        bool translationSet;
        bool rotationSet;
        bool scaleSet;
        bool alphaSet;
        bool nodeMaskSet;

        AnimationPoint():translation(0.0, 0.0, 0.0), rotation(0.0, 0.0, 0.0, 0.0), scale(1.0, 1.0, 1.0), alpha(1.0), nodeMask(0x00000000){
            translationSet = false;
            rotationSet = false;
            scaleSet = false;
            alphaSet = false;
            nodeMaskSet = false;
        };
        AnimationPoint(osg::Vec3 trans, osg::Quat rot, osg::Vec3 scal, float alfa, osg::Node::NodeMask nmask):
            translation(trans), rotation(rot), scale(scal), alpha(alfa), nodeMask(nmask)
        {   translationSet = true;
            rotationSet = true;
            scaleSet = true;
            alphaSet = true;
            nodeMaskSet = true;
        }
    };

    class SubBlockAnimation{
    public:
        SubBlockAnimation(){
            animationType = 0;
            interpolation = ArtificialWorld::Linear;
            looping = AnimationLoopType::NoLoop;
            timeForLoop = 1;
        };
        ~SubBlockAnimation(){ animationPoints.clear(); };

        void AddAnimationPoint(AnimationPoint newPoint){ animationPoints.push_back(newPoint); };
        int NumberOfAnimantionPoints(void){ return animationPoints.size(); };
        AnimationPoint* GetAnimationPoint(int index){ return &(animationPoints.at(index)); };
        void ClearAnimationPoints(void){ animationPoints.clear(); };

        void SetAnimationType(unsigned int newType){ animationType = newType; };
        unsigned int GetAnimationType(void){ return animationType; };

        void SetInterpolation(AnimationInterpolationType newInterpolation){ interpolation = newInterpolation; };
        AnimationInterpolationType GetInterpolation(void){ return interpolation; };

        void SetLoopType(AnimationLoopType newLoop){ looping = newLoop; };
        AnimationLoopType GetLoopType(void){ return looping; };

        void SetTimePerLoop(int time){ timeForLoop = time; };
        int GetTimePerLoop(void){ return timeForLoop; };

        void ClearAnimation(void){ 
            ClearAnimationPoints();
            SetAnimationType(0);
            SetInterpolation(Linear);
            SetLoopType(NoLoop);
            SetTimePerLoop(1);
        };

    protected:
        vector<AnimationPoint> animationPoints;
        unsigned int animationType;
        AnimationInterpolationType interpolation;
        AnimationLoopType looping;
        int timeForLoop;
        
    };

}

#endif