Public API Reference

csgeom/spline.h

Go to the documentation of this file.

/*
    Copyright (C) 2001 by Jorrit Tyberghein

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_SPLINE_H__
#define __CS_SPLINE_H__

#include "csextern.h"

class CS_CRYSTALSPACE_EXPORT csSpline
{
protected:
  int dimensions;
  int num_points;
  float* time_points;
  float* points;
  bool precalculation_valid;
  int idx;

public:
  csSpline (int d, int p);

  virtual ~csSpline ();

  int GetDimensionCount () const { return dimensions; }

  int GetPointCount () const { return num_points; }

  void InsertPoint (int idx);

  void RemovePoint (int idx);

  void SetTimeValues (float const* t);

  void SetTimeValue (int idx, float t);

  float const* GetTimeValues () const { return time_points; }

  float GetTimeValue (int idx) const { return GetTimeValues ()[idx]; }

  void SetDimensionValues (int dim, float const* d);

  void SetDimensionValue (int dim, int idx, float d);

  float const* GetDimensionValues (int dim) const
  { return &points[dim*num_points]; }

  float GetDimensionValue (int dim, int idx) const
  {
    float const* d = &points[dim*num_points];
    return d[idx];
  }

  void SetIndexValues (int idx, float const* d);
  
  float* GetIndexValues (int idx) const;
  
  virtual void Calculate (float time) = 0;

  int GetCurrentIndex () const { return idx; }

  virtual float GetInterpolatedDimension (int dim) const = 0;
};

class CS_CRYSTALSPACE_EXPORT csCubicSpline : public csSpline
{
private:
  bool derivatives_valid;
  float* derivative_points;

  // The following values are calculated by Calculate() and
  // are used later by GetInterpolatedDimension().
  float A, B, C, D;     // For computation of a spline value.

private:
  void PrecalculateDerivatives (int dim);
  void PrecalculateDerivatives ();

public:
  csCubicSpline (int d, int p);

  virtual ~csCubicSpline ();

  virtual void Calculate (float time);

  virtual float GetInterpolatedDimension (int dim) const;
};

class CS_CRYSTALSPACE_EXPORT csBSpline : public csSpline
{
private:
  // The following values are calculated by Calculate() and
  // are used later by GetInterpolatedDimension().
  float t;

protected:
  virtual float BaseFunction (int i, float t) const;

public:
  csBSpline (int d, int p);

  virtual ~csBSpline ();

  virtual void Calculate (float time);

  virtual float GetInterpolatedDimension (int dim) const;
};

class CS_CRYSTALSPACE_EXPORT csCatmullRomSpline : public csBSpline
{
protected:
  virtual float BaseFunction (int i, float t) const;

public:
  csCatmullRomSpline (int d, int p) : csBSpline (d, p) { }

  virtual ~csCatmullRomSpline () {}

  csCatmullRomSpline * Clone();
};

#endif // __CS_SPLINE_H__

---