PositionPath.h

#ifndef POSITION_PATH_
#define POSITION_PATH_

#include <stdio.h>
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <math.h>

#include "Geometry.h"

#define PP_LINEAR                               1
#define PP_SINE                                 2
#define PP_COSINE                               3
#define PP_JUMP                                 4


typedef struct Position6DOF
{
        float x, y, z;
        float roll, pitch, yaw;
}Position;


class PositionPath
{
public:
        PositionPath ();

        ~PositionPath ();

        Position GetPosition (int time);

        void SetConstantPosition (float x, float y, float z, float roll, float pitch, float yaw);

        bool IsDefined (int time);

        bool HasDynamicRotation ();

        bool HasStaticRotation ();

        BoundingBox GetTranslationBox ();

        void StartPath (int offset, float x, float y, float z, float roll, float pitch, float yaw);

        void CompletePath (float x, float y, float z, float roll, float pitch, float yaw);

        void AddCheckpoint (float x, float y, float z, float roll, float pitch, float yaw);

        void SetDuration (int time);

        void SetGlobalTransition (int mode, float parameter);

        void SetTransitionModes (int mode_x, int mode_y, int mode_z, int mode_roll, int mode_pitch, int mode_yaw);

        void SetParameters (float param_x, float param_y, float param_z, float param_roll, float param_pitch, float param_yaw);

        void Shift (float x, float y, float z);

        void PrintToConsole ();

private:
        bool is_constant;

        bool has_dynamic_rotation;

        bool has_static_rotation;

        BoundingBox translation_box;

        Position constant_position;

        typedef struct PathNode
        {
                int     start_time;                                             
                int end_time;                                           
                Position start_position;                        
                Position end_position;                          
                bool global_transition_evaluator;       
                int transition_evaluator[6];            
                float transition_parameter[6];          
                PathNode * next;                                        
                PathNode * previous;                            
        }Path;

        Path * first_node;

        bool not_complete;

        PathNode * current_node;

        PathNode * node_pointer;

        void SeekTime (int time);

        void DeletePath ();

        void Initialize ();

        void ConservativeUpdate (PathNode * node);

        Position EvaluateNode (PathNode * node, float progress);

        float inline EvaluateValue (int mode, float value, float parameter);

};

#endif

---