source: orxonox.OLD/orxonox/branches/trackManager/src/lib/math/curve.h @ 3517

/*! 
    \file curve.h
    \brief A basic 3D curve framework
    
    Contains classes to handle curves
*/ 

#ifndef _CURVE_H
#define _CURVE_H

#include "vector.h"

//! An Enumerator that defines what sort of Curves are availible
enum CurveType {BEZIERCURVE, UPOINTCURVE};


//! An abstract class to handle curves. Needed for the Tracking system in orxonox.
/**
   A Curve is a smooth line which tries to approximate a path through the nodes given to it.
   <br>

   <b>Usage of Curves:</b><br>
   \li Creation: Curve* newCurve = new BezierCurve();
   \li Adding some Points: newCurve->addNode([Vector to the point to add]);
   \li Get Point on Curve: newCurve->calcPos(timeIndex);    // where timeindex is in the interval [0,1]
   <br>
   More Fuctionality is:
   \li debug():  outputs some info about this curve.
   \li getNode(i): returns a Vector to the n'th node of the Curve.
   \li getNodeCount(): returns the count of nodes.
   <br>
   General Info:
   \li Curves take rather much power to be created/altered, but are fast calculated at runtime.
*/
class Curve
{
 protected:
  int nodeCount;         //!< The count of nodes the Curve has.
  Vector curvePoint;     //!< The point on the Cureve at a local Time.
  float localTime;       //!< If the time of one point is asked more than once the programm will not calculate it again.
  int derivation;        //!< Which derivation of a Curve is this.

  //! Handles the curve-points (dynamic List)
  struct PathNode
  {
    int number;          //!< The N-th node of this curve.
    float factor;        //!< Curve specific multiplier factor.
    Vector vFactor;      //!< A Vector-factor for multipliing.
    Vector position;     //!< Vector Pointung to this curve-point.
    PathNode* next;      //!< Pointer to the next Node.
  };

  PathNode* firstNode;   //!< First node of the curve.
  PathNode* currentNode; //!< The node we are working with (the Last node).

 private:
  //! rebuilds the Curve with the right algorithm
  virtual void rebuild(void) = 0;
 public:
  Curve* dirCurve;       //!< The derivation-curve of this Curve.
  void addNode(const Vector& newNode);
  void addNode(const Vector& newNode, unsigned int insertPosition);
  Vector getNode(unsigned int nodeToFind);
  /** \returns the Count of nodes of this Curve */
  inline int getNodeCount(void) { return this->nodeCount;}

  /**
     \brief A virtual function to calculate the Position on the Curve
     \returns positionVector
     \param t the timeindex on this curve [0,1]f
  */
  virtual Vector calcPos(float t) = 0; 
  /**
     \brief A virtual function to calculate the Direction of the Curve
     \returns directionVector
     \param t the timeindex on this curve [0,1]f
  */
  virtual Vector calcDir(float t) = 0;
  /**
     \brief A virtual function to calculate the acceleration on the Curve
     \returns accelerationVector
     \param t the timeindex on this curve [0,1]f
  */
  virtual Vector calcAcc(float t) = 0;
  /**
     \brief A virtual function to calculate the Quaternion on the Curve
     \returns directional Quaternion
     \param t the timeindex on this curve [0,1]f
  */
  virtual Quaternion calcQuat(float t) = 0;
 
  // DEBUG
  void debug(void);
};

//!    Class to handle bezier curves in 3-dimesnsional space
/**
   This Curve is good, for Fast Interaction. If you want to change it during the game, go on.
   !!be aware!! BezierCurves only flow through their first and last Node. Their Tangents at those Points a directed to the second and second-last Point.
*/
class BezierCurve : public Curve
{
 private:
  void rebuild(void);
 public:
  BezierCurve(void);
  BezierCurve(int derivation);
  ~BezierCurve(void);
  void init(void);

  Vector calcPos(float t);
  Vector calcDir(float t);
  Vector calcAcc(float t);
  Quaternion calcQuat(float t);
  
  
  Vector getPos(void) const;
};


//! B-Spline
/**
   class to handle b-spline in 3d space
*/
class BSplieCurve : public Curve
{


};

//! Uniform Point Curve-class
/**
   A UPoint Curve is a A Curve, that flows through all the nodes given it.
   The Algorithm to buid the curve is rather slow, but Painting and tracing along the curve has high speed, so do not change this curve during the Game.

   This Curve is very erattic, so i do not recommend to use it.
*/
class UPointCurve : public Curve
{
 private:
  void rebuild(void);
 public:
  UPointCurve(void);
  UPointCurve(int derivation);
  ~UPointCurve(void);
  void init(void);

  Vector calcPos(float t);
  Vector calcDir(float t);
  Vector calcAcc(float t);
  Quaternion calcQuat(float t);
  
  Vector getPos(void) const;
};

#endif /* _CURVE_H */