#include <Spline.h>

Public Types
typedef length_type	LengthType

typedef std::vector< length_type >	LengthArray

Public Types inherited from Movement::SplineBase
enum	EvaluationMode { ModeLinear, ModeCatmullrom, ModeBezier3_Unused, UninitializedMode, ModesEnd }

typedef int	index_type

typedef std::vector< Vector3 >	ControlArray

Public Member Functions
	Spline ()

void	evaluate_percent (float t, Vector3 &c) const

void	evaluate_derivative (float t, Vector3 &hermite) const

void	evaluate_percent (index_type Idx, float u, Vector3 &c) const

void	evaluate_derivative (index_type Idx, float u, Vector3 &c) const

index_type	computeIndexInBounds (float t) const

void	computeIndex (float t, index_type &out_idx, float &out_u) const

void	init_spline (const Vector3 *controls, index_type count, EvaluationMode m)

void	init_cyclic_spline (const Vector3 *controls, index_type count, EvaluationMode m, index_type cyclic_point)

void	initLengths ()

template<class T >
void	initLengths (T &cacher)

length_type	length () const

length_type	length (index_type first, index_type last) const

length_type	length (index_type Idx) const

void	set_length (index_type i, length_type length)

void	clear ()

Protected Member Functions
index_type	computeIndexInBounds (length_type length) const

Protected Attributes
LengthArray	lengths

Protected Attributes inherited from Movement::SplineBase
ControlArray	points

index_type	index_lo

index_type	index_hi

uint8	m_mode

bool	cyclic

Additional Inherited Members
Protected Types inherited from Movement::SplineBase
enum	{ STEPS_PER_SEGMENT = 3 }

Member Typedef Documentation

template<typename length_type>

typedef std::vector<length_type> Movement::Spline< length_type >::LengthArray

template<typename length_type>

typedef length_type Movement::Spline< length_type >::LengthType

Constructor & Destructor Documentation

template<typename length_type>

Movement::Spline< length_type >::Spline ( )

inlineexplicit

147 { }

Member Function Documentation

template<typename length_type >

void Movement::Spline< length_type >::clear ( )

 {
  SplineBase::clear();
  lengths.clear();
 }

Here is the caller graph for this function:

template<typename length_type >

void Movement::Spline< length_type >::computeIndex	(	float	t,
		index_type &	out_idx,
		float &	out_u
	)		const

 {
  ASSERT(t >= 0.f && t <= 1.f);
  length_type length_ = t * length();
  index = computeIndexInBounds(length_);
  ASSERT(index < index_hi);
  u = (length_ - length(index)) / (float)length(index, index+1);
 }

Here is the call graph for this function:

template<typename length_type>

SplineBase::index_type Movement::Spline< length_type >::computeIndexInBounds ( length_type length ) const

protected

 {
 // Temporary disabled: causes infinite loop with t = 1.f
 /*
  index_type hi = index_hi;
  index_type lo = index_lo;
 
  index_type i = lo + (float)(hi - lo) * t;
 
  while ((lengths[i] > length) || (lengths[i + 1] <= length))
  {
  if (lengths[i] > length)
  hi = i - 1; // too big
  else if (lengths[i + 1] <= length)
  lo = i + 1; // too small
 
  i = (hi + lo) / 2;
  }*/
 
  index_type i = index_lo;
  index_type N = index_hi;
  while (i+1 < N && lengths[i+1] < length_)
  ++i;
 
  return i;
 }

template<typename length_type>

SplineBase::index_type Movement::Spline< length_type >::computeIndexInBounds ( float t ) const

 {
  ASSERT(t >= 0.f && t <= 1.f);
  return computeIndexInBounds(t * length());
 }

Here is the call graph for this function:

template<typename length_type >

void Movement::Spline< length_type >::evaluate_derivative	(	float	t,
		Vector3 &	hermite
	)		const

Calculates derivation for given t

Parameters

t	- percent of spline's length, assumes that t in range [0, 1].

 {
  index_type Index;
  float u;
  computeIndex(t, Index, u);
  evaluate_derivative(Index, u, hermite);
 }

Here is the caller graph for this function:

template<typename length_type>

void Movement::Spline< length_type >::evaluate_derivative	(	index_type	Idx,
		float	u,
		Vector3 &	c
	)		const

inline

Caclulates derivation for index Idx, and percent of segment length t

Parameters

Idx	- spline segment index, should be in range [first, last)
t	- percent of spline segment length, assumes that t in range [0, 1].

165 { SplineBase::evaluate_derivative(Idx, u, c);}

template<typename length_type >

void Movement::Spline< length_type >::evaluate_percent	(	float	t,
		Vector3 &	c
	)		const

Calculates the position for given t

Parameters

t	- percent of spline's length, assumes that t in range [0, 1].

 {
  index_type Index;
  float u;
  computeIndex(t, Index, u);
  evaluate_percent(Index, u, c);
 }

Here is the caller graph for this function:

template<typename length_type>

void Movement::Spline< length_type >::evaluate_percent	(	index_type	Idx,
		float	u,
		Vector3 &	c
	)		const

inline

Calculates the position for given segment Idx, and percent of segment length t

Parameters

t	= partial_segment_length / whole_segment_length
Idx	- spline segment index, should be in range [first, last).

160 { SplineBase::evaluate_percent(Idx, u, c);}

template<typename length_type>

void Movement::Spline< length_type >::init_cyclic_spline	(	const Vector3 *	controls,
		index_type	count,
		EvaluationMode	m,
		index_type	cyclic_point
	)

inline

173 { SplineBase::init_cyclic_spline(controls, count, m, cyclic_point);}

Here is the caller graph for this function:

template<typename length_type>

void Movement::Spline< length_type >::init_spline	(	const Vector3 *	controls,
		index_type	count,
		EvaluationMode	m
	)

inline

Initializes spline. Don't call other methods while spline not initialized.

172 { SplineBase::init_spline(controls, count, m);}

Here is the caller graph for this function:

template<typename length_type >

void Movement::Spline< length_type >::initLengths ( )

Initializes lengths with SplineBase::SegLength method.

 {
  index_type i = index_lo;
  length_type length = 0;
  lengths.resize(index_hi+1);
  while (i < index_hi)
  {
  length += SegLength(i);
  lengths[++i] = length;
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename length_type>

template<class T >

void Movement::Spline< length_type >::initLengths ( T & cacher )

inline

Initializes lengths in some custom way Note that value returned by cacher must be greater or equal to previous value.

  {
  index_type i = index_lo;
  lengths.resize(index_hi+1);
  length_type prev_length = 0, new_length = 0;
  while (i < index_hi)
  {
  new_length = cacher(*this, i);
  // length overflowed, assign to max positive value
  if (new_length < 0)
  new_length = std::numeric_limits<length_type>::max();
  lengths[++i] = new_length;
 
  ASSERT(prev_length <= new_length);
  prev_length = new_length;
  }
  }