CameraPath.h

Go to the documentation of this file.

#ifndef _CAMERA_PATH_H
#define _CAMERA_PATH_H

#include <vrecko/ReaderWriter.h>

#include <vrecko/Ability.h>
#include <vrecko/EnvironmentObject.h>
#include <vrecko/Scene.h>
#include <vrecko/EventDispatcher.h>
#include <vrecko/Logger.h>

#include <helpers/XercesXMLUtils.h>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/sax/HandlerBase.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/PlatformUtils.hpp>

#include <osg/Group>
#include <osg/Geode>
#include <osg/Geometry>
#include <osg/Shape>
#include <osg/ShapeDrawable>
#include <osg/PositionAttitudeTransform>
#include <osg/LineWidth>
#include <osg/LightModel>
#include <osg/ShadeModel>
#include <osg/PolygonMode>

#include <osg/Timer>
#include <vector>

using namespace vrecko;
using namespace vrecko;

namespace APCameraMovement {

#define CONTROL_POINT_RADIUS 1.0
#define CONTROL_POINT_COLOR osg::Vec4(1.0, 0.0, 0.0, 0.5)

#define VECTOR_POINT_RADIUS 1.0
#define VECTOR_POINT_COLOR osg::Vec4(0.0, 0.0, 1.0, 0.5)

#define CONTROL_LINE_WIDTH 1.0
#define CONTROL_LINE_COLOR osg::Vec4(0.0, 0.0, 1.0, 1.0)

#define PATH_LINE_WIDTH 1.0
#define PATH_LINE_COLOR osg::Vec4(1.0, 0.0, 0.0, 1.0)

#define DEFAULT_VECPW osg::Vec3(CONTROL_POINT_RADIUS*3, 0.0, 0.0)
#define DEFAULT_VECCPW osg::Vec3(-(CONTROL_POINT_RADIUS*3), 0.0, 0.0)
#define DEFAULT_CDIR osg::Quat(0.0, 0.0, 0.0, 1.0)

#define TOP_VECTOR osg::Vec3(0.0, 1.0, 0.0)
#define DIR_VECTOR osg::Vec3(0.0, 0.0, 1.0)

#define STEP 0.01
#define MULT 6
#define SPEED 2

    struct ControlPoint {
        osg::Vec3 position;
        osg::Vec3 vectorPathWise;
        osg::Vec3 vectorCounterPathWise;
        osg::Quat cameraRotation;

        double totalPathLength; // total length from first to this point
        double pathLength; // length of the curve [i-1;i]
        unsigned int pathIndex; // index where the curve [i-1;i] ends
    };

    class CameraPath : public Ability {
        public:
            CameraPath();
            ~CameraPath();

            // called as the first initialization method, before loadXMLParameters
            virtual void preInitialize();

            // called as the last initialization method, after loadXMLParameters
            virtual void postInitialize();

            // loads XML parameters from given node
            virtual bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *pParametersNode);

            // processes an event
//          void processEvent(const std::string &strInputName, void *pValue);

            // ability update method
            virtual void update();

            // visualisies the path incl. points
            void draw();

            void setDirty(bool d) { dirty = d; }
            std::vector<ControlPoint>* getControlPoints() { return &controlPoints; }

            void addPoint(osg::Vec3 pos, osg::Vec3 vecPW = DEFAULT_VECPW, osg::Vec3 vecCPW = DEFAULT_VECCPW, osg::Quat cDir = DEFAULT_CDIR) {
                ControlPoint p;
                p.position = pos;
                p.vectorPathWise = vecPW;
                p.vectorCounterPathWise = vecCPW;
                p.cameraRotation = cDir;
                controlPoints.push_back(p);
            }

            inline bool animating() { return isAnimating; }

            bool startAnimation();
            bool stopAnimation();
            bool updateActTime();
            float convertActTimeToActPos();
            bool updateAnimation(float fActPos);

        private:

            // control points defining the path
            std::vector<ControlPoint> controlPoints;

            // the path vertices to be drawn as line strip
            std::vector<osg::Vec3> pathPoints;

            // pointer to parent enviroment object
            EnvironmentObject* pEOOwner;

            bool dirty;
            bool isAnimating;
            osg::Timer_t lastTimerTick;

            // actual position of camera when animating (relative distance on the curve)
            float fActTime;

            // computes the path
            void computePath();

            // pointer to avatar view
            World::AvatarView *avView;




            // parameters corresponding to macros above
            float controlPointRadius;     // sphere radius of a main control point
            osg::Vec4 controlPointColor;  // color of a main control point

            float vectorPointRadius;      // sphere radius of a point defining a vector
            osg::Vec4 vectorPointColor;   // color of a point defining a vector

            float controlLineWidth;       // width of a line showing the vectors
            osg::Vec4 controlLineColor;   // color of a line showing the vectors

            float pathLineWidth;          // width of a line showing the path
            osg::Vec4 pathLineColor;      // color of a line showing the path

            float speed;  // speed of the camera (float per second)
            float step;   // a step of one ferguson curve (how many pieces there are between two control points)

            bool freeLook;  // defines whether user can rotate with camera while moving


            DECLARE_INPUT(Trigger, MessageVoid);
    };

}

#endif