source: GTP/trunk/App/Demos/Illum/Ogre/src/Common/include/FrameCapture.h @ 1879

#ifndef FRAMECAPTURE_H
#define FRAMECAPTURE_H

#include "Ogre.h"

using namespace Ogre;

class FrameCapture: public FrameListener
{
        class SceneNodeTransformKey
        {
        public:
                Vector3 translate;
                Quaternion rotation;
                SceneNode* node;

                SceneNodeTransformKey(SceneNode* node)
                {
                        this->node = node;
                        translate = node->getPosition();
                        rotation = node->getOrientation();
                }

                void applyKey()
                {
                        node->setPosition(translate);
                        node->setOrientation(rotation);
                }
        };

        class SceneNodeTransformAnimation
        {
        protected:

         std::vector<SceneNodeTransformKey*> keys;
                 SceneNode* node;
                 std::vector<SceneNodeTransformKey*>::iterator iter;
                 std::vector<SceneNodeTransformKey*>::iterator iterEnd;
          
        public: 

                SceneNodeTransformAnimation(SceneNode* node)
                {
                        this->node = node;
                }
                void addKey()
                {
                        keys.push_back(new SceneNodeTransformKey(node));
                }
                void startPlay()
                {
                        iter = keys.begin();
                        iterEnd = keys.end();
                }
                bool stepFrame()
                {
                        if(iter == iterEnd)
                                return false;
                        
                        (*iter)->applyKey();
                        iter++;
                        return true;
                }
                void reset()
                {
                        keys.clear();
                }
        };

protected:
        std::vector< SceneNodeTransformAnimation*> animables;

public:
        
    FrameCapture(RenderTarget* rendertarget)
        {
         target = rendertarget;
     isPlaying = false;
         isRecording = false;
         isSaving = false;
         framerate = 15;
         frameTime = 1000 / framerate;
         lastTime = 0;
        }
        void addAnimableNode(SceneNode* node)
        {
                SceneNodeTransformAnimation* newTrack = new SceneNodeTransformAnimation(node);
                animables.push_back(newTrack);
        }
        void recordEvent()
        {
                if(!isRecording && !isPlaying)
                        startRecording();
                else if(isRecording) stopRecording();
        }
        void playEvent()
        {
                if(!isRecording && !isPlaying)
                        startPlaying();
                else if(isPlaying) stopPlaying();
        }
        void setSaving(){isSaving = true;}
        void setFrameRate(int fr)
        {
                framerate = fr;
                frameTime = 1000 / framerate;
        }
        
protected:
        bool isPlaying;
        bool isRecording;
        bool isSaving;
        int framerate;
        unsigned long currentFrame;
        unsigned long frameTime;
        unsigned long lastTime;
        RenderTarget* target;

        void startPlaying()
        {
                isPlaying = true;
                std::vector< SceneNodeTransformAnimation*>::iterator iter = animables.begin();
                std::vector< SceneNodeTransformAnimation*>::iterator iterEnd = animables.end();
                while(iter != iterEnd)
                {
                        (*iter)->startPlay();
                        iter++;
                }
                currentFrame = 0;
        }
        void stopPlaying()
        {
                isPlaying = false;
        }
        void startRecording()
        {
      isRecording = true;
          std::vector< SceneNodeTransformAnimation*>::iterator iter = animables.begin();
          std::vector< SceneNodeTransformAnimation*>::iterator iterEnd = animables.end();
          while(iter != iterEnd)
          {
                  (*iter)->reset();     
                  iter++;
          }
        }
        void stopRecording()
        {
                isRecording = false;
        }
        void play()
        {
                std::vector< SceneNodeTransformAnimation*>::iterator iter = animables.begin();
                std::vector< SceneNodeTransformAnimation*>::iterator iterEnd = animables.end();
                while(iter != iterEnd)
                {
                        if(!(*iter)->stepFrame())
                        {
                                isPlaying = false;
                                isSaving = false;
                                return;
                        }
                        iter++;
                }       
                currentFrame++;
        }
        void record()
        {
          unsigned long thisTime = Root::getSingleton().getTimer()->getMilliseconds();
      unsigned long timeElapsed = thisTime - lastTime;
                
          if(timeElapsed < frameTime)
            return;
        
          lastTime = thisTime;
          
      std::vector< SceneNodeTransformAnimation*>::iterator iter = animables.begin();
          std::vector< SceneNodeTransformAnimation*>::iterator iterEnd = animables.end();
          while(iter != iterEnd)
          {
                  (*iter)->addKey();
                  iter++;
          }
        }

        bool frameStarted(const FrameEvent& evt)
    {   
                if(isPlaying)
                        play();
                if(isRecording)
                        record();
                return true;     
    }
        bool frameEnded(const FrameEvent& evt)
    {   
                if(isSaving)
                {
                        String filename = "capture" + StringConverter::toString(currentFrame) + ".tga";
                        target->writeContentsToFile(filename);
                }

                return true;     
    }
};

#endif