Movement::Spline< length_type > Class Template Reference

#include "Spline.h"

Inheritance diagram for Movement::Spline< length_type >:

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 ()=default
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 ()
Public Member Functions inherited from Movement::SplineBase
	SplineBase ()=default
void	evaluate_percent (index_type Idx, float u, Vector3 &c) const
void	evaluate_derivative (index_type Idx, float u, Vector3 &hermite) const
index_type	first () const
index_type	last () const
bool	empty () const
EvaluationMode	mode () const
bool	isCyclic () const
const ControlArray &	getPoints () const
index_type	getPointCount () const
const Vector3 &	getPoint (index_type i) 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)
template<class Init >
void	init_spline_custom (Init &initializer)
void	clear ()
float	SegLength (index_type i) const
std::string	ToString () const

Protected Member Functions
index_type	computeIndexInBounds (length_type length) const
Protected Member Functions inherited from Movement::SplineBase
void	EvaluateLinear (index_type, float, Vector3 &) const
void	EvaluateCatmullRom (index_type, float, Vector3 &) const
void	EvaluateBezier3 (index_type, float, Vector3 &) const
void	EvaluateDerivativeLinear (index_type, float, Vector3 &) const
void	EvaluateDerivativeCatmullRom (index_type, float, Vector3 &) const
void	EvaluateDerivativeBezier3 (index_type, float, Vector3 &) const
float	SegLengthLinear (index_type) const
float	SegLengthCatmullRom (index_type) const
float	SegLengthBezier3 (index_type) const
void	InitLinear (const Vector3 *, index_type, bool, index_type)
void	InitCatmullRom (const Vector3 *, index_type, bool, index_type)
void	InitBezier3 (const Vector3 *, index_type, bool, index_type)
void	UninitializedSplineEvaluationMethod (index_type, float, Vector3 &) const
float	UninitializedSplineSegLenghtMethod (index_type) const
void	UninitializedSplineInitMethod (Vector3 const *, index_type, bool, index_type)

Protected Attributes
LengthArray	lengths
Protected Attributes inherited from Movement::SplineBase
ControlArray	points
index_type	index_lo {0}
index_type	index_hi {0}
uint8	m_mode {UninitializedMode}
bool	cyclic {false}

Additional Inherited Members
Protected Types inherited from Movement::SplineBase
enum	{ STEPS_PER_SEGMENT = 3 }
typedef void(SplineBase::*	EvaluationMethtod) (index_type, float, Vector3 &) const
typedef float(SplineBase::*	SegLenghtMethtod) (index_type) const
typedef void(SplineBase::*	InitMethtod) (const Vector3 *, index_type, bool, index_type)
Static Protected Attributes inherited from Movement::SplineBase
static EvaluationMethtod	evaluators [ModesEnd]
static EvaluationMethtod	derivative_evaluators [ModesEnd]
static SegLenghtMethtod	seglengths [ModesEnd]
static InitMethtod	initializers [ModesEnd]

Detailed Description

template<typename length_type>
class Movement::Spline< length_type >

Member Typedef Documentation

LengthArray

template<typename length_type >

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

LengthType

template<typename length_type >

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

Constructor & Destructor Documentation

Spline()

template<typename length_type >

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

explicitdefault

Referenced by TransportMgr::GeneratePath().

Member Function Documentation

clear()

template<typename length_type >

void Movement::Spline< length_type >::clear

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

References Movement::SplineBase::clear().

Referenced by Movement::MoveSpline::Initialize().

computeIndex()

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);
    }

References ASSERT.

computeIndexInBounds() [1/2]

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());
    }

References ASSERT.

computeIndexInBounds() [2/2]

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;
    }

evaluate_derivative() [1/2]

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);
    }

Referenced by Movement::MoveSpline::ComputePosition(), and TransportMgr::GeneratePath().

evaluate_derivative() [2/2]

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].

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

References Movement::SplineBase::evaluate_derivative().

evaluate_percent() [1/2]

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);
    }

Referenced by Movement::MoveSpline::ComputePosition().

evaluate_percent() [2/2]

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).

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

References Movement::SplineBase::evaluate_percent().

init_cyclic_spline()

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

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

References Movement::SplineBase::init_cyclic_spline().

Referenced by Movement::MoveSpline::init_spline().

init_spline()

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.

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

References Movement::SplineBase::init_spline().

Referenced by TransportMgr::GeneratePath(), and Movement::MoveSpline::init_spline().

initLengths() [1/2]

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;
        }
    }

Referenced by TransportMgr::GeneratePath(), and Movement::MoveSpline::init_spline().

initLengths() [2/2]

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;
            }
        }

References ASSERT, Movement::SplineBase::index_hi, Movement::SplineBase::index_lo, and Movement::Spline< length_type >::lengths.

length() [1/3]

template<typename length_type >

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

inline

Returns length of the whole spline.

{ return lengths[index_hi];}

References Movement::SplineBase::index_hi, and Movement::Spline< length_type >::lengths.

Referenced by Movement::MoveSpline::ComputePosition(), Movement::MoveSpline::Duration(), TransportMgr::GeneratePath(), Movement::MoveSpline::init_spline(), Movement::MoveSpline::next_timestamp(), and Movement::Spline< length_type >::set_length().

length() [2/3]

template<typename length_type >

length_type Movement::Spline< length_type >::length ( index_type  first, index_type  last  ) const

inline

Returns length between given nodes.

{ return lengths[last] - lengths[first];}

References Movement::SplineBase::first(), Movement::SplineBase::last(), and Movement::Spline< length_type >::lengths.

length() [3/3]

template<typename length_type >

length_type Movement::Spline< length_type >::length ( index_type  Idx ) const

inline

{ return lengths[Idx];}

References Movement::Spline< length_type >::lengths.

set_length()

template<typename length_type >

void Movement::Spline< length_type >::set_length ( index_type  i, length_type  length  )

inline

{ lengths[i] = length;}

References Movement::Spline< length_type >::length(), and Movement::Spline< length_type >::lengths.

Referenced by Movement::MoveSpline::init_spline().

Member Data Documentation

lengths

template<typename length_type >

LengthArray Movement::Spline< length_type >::lengths

protected

Referenced by Movement::Spline< length_type >::initLengths(), Movement::Spline< length_type >::length(), and Movement::Spline< length_type >::set_length().