src/CameraAnimator.h

Go to the documentation of this file.

#ifndef CAMERAANIMATOR_H
#define CAMERAANIMATOR_H

#include <vector>
#include <fstream>

#include "defines.h"
#include "CameraInstructions.h"
#include "PerspectiveCamera.h"
#include "SceneBuilderFactories.h"

class Camera;

class CameraAnimator
{
    friend class CameraInstructionMove;
    friend class CameraInstructionSet;
    friend class CameraInstructionNormal;
    friend class CameraInstructionStay;

  public:
    CameraAnimator(std::string filename)
        :mActCam(0),
         mPC(0)
    {
  
        parse(filename);
        //       mInstructions.push_back(new CameraInstructionMove(this, Vec3f(-0.1, -0.2, 0.12),30,0));
        //mCameras.push_back(new PerspectiveCamera(Vec3f(0.25, 0.09, -0.23),Vec3f(-0.1, -0.02, 0.12),Vec3f(0,1,0),60,640,480));
    }

    ~CameraAnimator()
    {
        for(unsigned int i=0;i<mCameras.size();i++)
            delete mCameras.at(i);
        for (unsigned int i=0; i<mInstructions.size(); i++)
            delete mInstructions[i];
    }

    Camera* animate()
    {
        LOG(mPC);
        assert(mPC<mInstructions.size() );
        assert(mInstructions.at(mPC)!= 0);

        mInstructions.at(mPC)->execute();
        assert(mActCam<mCameras.size() );
        return mCameras.at(mActCam);
        
    }


  private:
    void parse(std::string filename)
    {
        std::ifstream file(filename.c_str());
        std::string definition;
        file >> definition;
        //  while(definition[0]!='#' && definition!="")
        //{
            if(definition!="definition:")
            {
                std::cout << "need a camera definition in front" << std::endl;
                assert(false);
            }
            //file >> definition;
            //}
        file >> std::ws;
        DepthOfFieldCameraFactory df;
        PerspectiveCameraFactory pf;

        std::string line;
        getline(file,line);
        while(line[0]!='m' && line[0]!='#')
        {
            LOG("parsing line:\"" << line << "\"");
            
            if(line[0]!='#' && line!="")
            {
                std::stringstream linestream(line);
                std::string identifier;
                linestream >> identifier;

                if(identifier=="perspectivecamera")
                {
                    mCameras.push_back( pf.create(identifier, linestream));
                }
                else
                {
                    mCameras.push_back( df.create(identifier, linestream));
                }
            }
            getline(file, line);

        }
        while(line!="movesection:" && !file.eof())
            getline(file,line);
        if(file.eof())
        {
            std::cout << "move section expected" << std::endl;
            assert(false);
        }
        
        getline(file, line);
//        LOG(line);
        if(file.eof() )
            LOG("EOF");
        while(!file.eof() )
        {
            LOG("parsing movesection");
            std::stringstream linestream;
            linestream << line;
            std::string identifier;
            linestream >> identifier;
            linestream >> std::ws;
            //          LOG(linestream.str());
            if(identifier=="move")
            {
                std::string tmp;

                unsigned int camnum;
                Vec3f newpos;
                Vec3f newdir;
                Vec3f newup;
                float newaperture;
                float newdistance;
                unsigned int framenumber;
                unsigned int depthnumber;
                linestream >> camnum;
                linestream >> std::ws;
                linestream >> newpos;
                linestream >> std::ws;
                linestream >> newdir;
                linestream >> std::ws;
                linestream >> newup;
                linestream >> std::ws;
                linestream >> newdistance;
                linestream >> std::ws;
                linestream >> newaperture;
                linestream >> std::ws;
                linestream >> depthnumber;
                linestream >> std::ws;
                linestream >> framenumber;
//                framenumber++; //on normal calculation we get one frame before the position, this is to fix around this
                framenumber--; // we do one frame too much

                if(mInstructions.size() == 0)
                {
//we are at the beginning and need to render one dummy frame with the normal camera
                    mInstructions.push_back(new CameraInstructionNormal(this, camnum) );
                }

                LOG("parsed with Vec: " << newpos << " newdir: " << newdir << " newup:" << newup << "aperture: " << newaperture << "distance " << newdistance << "depthnumber: " << depthnumber << " framenumber: " << framenumber << " camnum" << camnum);
                mInstructions.push_back(new CameraInstructionMove(this, newpos, newdir,newup, newaperture, newdistance, depthnumber, framenumber,camnum)); 
            }
            else if(identifier=="set")
            {
                linestream >> std::ws;
                unsigned int camnum;
                linestream >> camnum;
                assert(camnum<mCameras.size());
                mInstructions.push_back(new CameraInstructionSet(this, camnum));
                mInstructions.push_back(new CameraInstructionNormal(this, camnum));
            }
            else if(identifier=="stay")
            {
                linestream >> std::ws;
                unsigned int frames;
                unsigned int camnum;
                linestream >> camnum;
                linestream >> std::ws;
                linestream >> frames;
                LOG("frames parsed " << frames);
                mInstructions.push_back(new CameraInstructionStay(this,frames, camnum) );
            }
            
            getline(file,line);

        }
//add a last instruction to stay
        if(mInstructions.size()==0)
            LOG("WARNING, PLEASE ADD A NEWLINE AT THE END OF THE LINE, othwerise this will be recognized as empty");
        mInstructions.push_back(new CameraInstructionStay(this, 0, INT_MAX));
    }


    unsigned int mActCam;   
    unsigned int mPC;       
    std::vector<CameraInstructions*> mInstructions;  
    std::vector<Camera*> mCameras;                   
};
 
#endif

---