Movement::SplineBase Class Reference

#include "Spline.h"

Inheritance diagram for Movement::SplineBase:

Public Types
enum	EvaluationMode {   ModeLinear ,   ModeCatmullrom ,   ModeBezier3_Unused ,   UninitializedMode ,   ModesEnd }
typedef int	index_type
typedef std::vector< Vector3 >	ControlArray

Public Member Functions
	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, float orientation)
void	init_cyclic_spline (const Vector3 *controls, index_type count, EvaluationMode m, index_type cyclic_point, float orientation)
template<class Init >
void	init_spline_custom (Init &initializer)
void	clear ()
float	SegLength (index_type i) const
std::string	ToString () const

Protected Types
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)

Protected Member Functions
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
ControlArray	points
index_type	index_lo {0}
index_type	index_hi {0}
uint8	m_mode {UninitializedMode}
bool	cyclic {false}
float	initialOrientation {0}

Static Protected Attributes
static EvaluationMethtod	evaluators [ModesEnd]
static EvaluationMethtod	derivative_evaluators [ModesEnd]
static SegLenghtMethtod	seglengths [ModesEnd]
static InitMethtod	initializers [ModesEnd]

Detailed Description

Member Typedef Documentation

ControlArray

typedef std::vector<Vector3> Movement::SplineBase::ControlArray

EvaluationMethtod

typedef void(SplineBase::* Movement::SplineBase::EvaluationMethtod) (index_type, float, Vector3 &) const

protected

index_type

typedef int Movement::SplineBase::index_type

InitMethtod

typedef void(SplineBase::* Movement::SplineBase::InitMethtod) (const Vector3 *, index_type, bool, index_type)

protected

SegLenghtMethtod

typedef float(SplineBase::* Movement::SplineBase::SegLenghtMethtod) (index_type) const

protected

Member Enumeration Documentation

anonymous enum

anonymous enum

protected

Enumerator
STEPS_PER_SEGMENT

        {
            // could be modified, affects segment length evaluation precision
            // lesser value saves more performance in cost of lover precision
            // minimal value is 1
            // client's value is 20, blizzs use 2-3 steps to compute length
            STEPS_PER_SEGMENT = 3
        };

EvaluationMode

enum Movement::SplineBase::EvaluationMode

Enumerator
ModeLinear
ModeCatmullrom
ModeBezier3_Unused
UninitializedMode
ModesEnd

        {
            ModeLinear,
            ModeCatmullrom,
            ModeBezier3_Unused,
            UninitializedMode,
            ModesEnd
        };

Constructor & Destructor Documentation

SplineBase()

Movement::SplineBase::SplineBase ( )

explicitdefault

Member Function Documentation

clear()

void Movement::SplineBase::clear

(

)

    {
        index_lo = 0;
        index_hi = 0;
        points.clear();
    }

References index_hi, index_lo, and points.

Referenced by Movement::Spline< length_type >::clear().

empty()

bool Movement::SplineBase::empty ( ) const

inline

{ return index_lo == index_hi;}

References index_hi, and index_lo.

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

evaluate_derivative()

void Movement::SplineBase::evaluate_derivative ( index_type  Idx, float  u, Vector3 &  hermite  ) const

inline

Caclulates derivation in 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]

{(this->*derivative_evaluators[m_mode])(Idx, u, hermite);}

References m_mode.

Referenced by Movement::Spline< length_type >::evaluate_derivative().

evaluate_percent()

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

inline

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

Parameters

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

{(this->*evaluators[m_mode])(Idx, u, c);}

References m_mode.

Referenced by Movement::Spline< length_type >::evaluate_percent().

EvaluateBezier3()

void Movement::SplineBase::EvaluateBezier3 ( index_type  index, float  t, Vector3 &  result  ) const

protected

    {
        index *= 3u;
        ASSERT(index >= index_lo && index < index_hi);
        C_Evaluate(&points[index], t, s_Bezier3Coeffs, result);
    }

References ASSERT, Movement::C_Evaluate(), index_hi, index_lo, points, and Movement::s_Bezier3Coeffs().

EvaluateCatmullRom()

void Movement::SplineBase::EvaluateCatmullRom ( index_type  index, float  t, Vector3 &  result  ) const

protected

    {
        ASSERT(index >= index_lo && index < index_hi);
        C_Evaluate(&points[index - 1], t, s_catmullRomCoeffs, result);
    }

References ASSERT, Movement::C_Evaluate(), index_hi, index_lo, points, and Movement::s_catmullRomCoeffs().

EvaluateDerivativeBezier3()

void Movement::SplineBase::EvaluateDerivativeBezier3 ( index_type  index, float  t, Vector3 &  result  ) const

protected

    {
        index *= 3u;
        ASSERT(index >= index_lo && index < index_hi);
        C_Evaluate_Derivative(&points[index], t, s_Bezier3Coeffs, result);
    }

References ASSERT, Movement::C_Evaluate_Derivative(), index_hi, index_lo, points, and Movement::s_Bezier3Coeffs().

EvaluateDerivativeCatmullRom()

void Movement::SplineBase::EvaluateDerivativeCatmullRom ( index_type  index, float  t, Vector3 &  result  ) const

protected

    {
        ASSERT(index >= index_lo && index < index_hi);
        C_Evaluate_Derivative(&points[index - 1], t, s_catmullRomCoeffs, result);
    }

References ASSERT, Movement::C_Evaluate_Derivative(), index_hi, index_lo, points, and Movement::s_catmullRomCoeffs().

EvaluateDerivativeLinear()

void Movement::SplineBase::EvaluateDerivativeLinear ( index_type  index, float  , Vector3 &  result  ) const

protected

    {
        ASSERT(index >= index_lo && index < index_hi);
        result = points[index + 1] - points[index];
    }

References ASSERT, index_hi, index_lo, and points.

EvaluateLinear()

void Movement::SplineBase::EvaluateLinear ( index_type  index, float  u, Vector3 &  result  ) const

protected

    {
        ASSERT(index >= index_lo && index < index_hi);
        result = points[index] + (points[index + 1] - points[index]) * u;
    }

References ASSERT, index_hi, index_lo, and points.

first()

index_type Movement::SplineBase::first ( ) const

inline

Bounds for spline indexes. All indexes should be in range [first, last).

{ return index_lo;}

References index_lo.

Referenced by Movement::MoveSpline::_updateState(), Movement::MoveSpline::computeFallElevation(), Movement::MoveSpline::currentPathIdx(), Movement::MoveSpline::init_spline(), Movement::Spline< length_type >::length(), and Movement::PacketBuilder::WriteCommonMonsterMovePart().

getPoint()

const Vector3 & Movement::SplineBase::getPoint ( index_type  i ) const

inline

{ return points[i];}

References points.

Referenced by Movement::MoveSpline::computeFallElevation(), Movement::MoveSpline::CurrentDestination(), Movement::MoveSpline::FinalDestination(), Movement::MoveSpline::init_spline(), Movement::FallInitializer::operator()(), Movement::WriteCatmullRomCyclicPath(), Movement::WriteCatmullRomPath(), Movement::PacketBuilder::WriteCommonMonsterMovePart(), and Movement::WriteLinearPath().

getPointCount()

index_type Movement::SplineBase::getPointCount ( ) const

inline

{ return points.size();}

References points.

Referenced by Movement::WriteCatmullRomCyclicPath(), Movement::WriteCatmullRomPath(), and Movement::WriteLinearPath().

getPoints()

const ControlArray & Movement::SplineBase::getPoints ( ) const

inline

{ return points;}

References points.

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

init_cyclic_spline()

void Movement::SplineBase::init_cyclic_spline	(	const Vector3 *	controls,
		index_type	count,
		EvaluationMode	m,
		index_type	cyclic_point,
		float	orientation
	)

    {
        m_mode = m;
        cyclic = true;
        initialOrientation = orientation;
 
        (this->*initializers[m_mode])(controls, count, cyclic, cyclic_point);
    }

References cyclic, initializers, initialOrientation, and m_mode.

Referenced by Movement::Spline< length_type >::init_cyclic_spline().

init_spline()

void Movement::SplineBase::init_spline	(	const Vector3 *	controls,
		index_type	count,
		EvaluationMode	m,
		float	orientation
	)

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

    {
        m_mode = m;
        cyclic = false;
        initialOrientation = orientation;
 
        (this->*initializers[m_mode])(controls, count, cyclic, 0);
    }

References cyclic, initializers, initialOrientation, and m_mode.

Referenced by Movement::Spline< length_type >::init_spline().

init_spline_custom()

template<class Init >

void Movement::SplineBase::init_spline_custom ( Init &  initializer )

inline

As i can see there are a lot of ways how spline can be initialized would be no harm to have some custom initializers.

        {
            initializer(m_mode, cyclic, points, index_lo, index_hi);
        }

References cyclic, index_hi, index_lo, m_mode, and points.

Referenced by TransportMgr::GeneratePath().

InitBezier3()

void Movement::SplineBase::InitBezier3 ( const Vector3 *  controls, index_type  count, bool  , index_type    )

protected

    {
        index_type c = count / 3u * 3u;
        index_type t = c / 3u;
 
        points.resize(c);
        memcpy(&points[0], controls, sizeof(Vector3) * c);
 
        index_lo = 0;
        index_hi = t - 1;
        //mov_assert(points.size() % 3 == 0);
    }

References index_hi, index_lo, and points.

InitCatmullRom()

void Movement::SplineBase::InitCatmullRom ( const Vector3 *  controls, index_type  count, bool  cyclic, index_type  cyclic_point  )

protected

    {
        const int real_size = count + (cyclic ? (1 + 2) : (1 + 1));
 
        points.resize(real_size);
 
        int lo_index = 1;
        int high_index = lo_index + count - 1;
 
        memcpy(&points[lo_index], controls, sizeof(Vector3) * count);
 
        // first and last two indexes are space for special 'virtual points'
        // these points are required for proper C_Evaluate and C_Evaluate_Derivative methtod work
        if (cyclic)
        {
            if (cyclic_point == 0)
                points[0] = controls[count - 1];
            else
                points[0] = controls[0] - G3D::Vector3{ std::cos(initialOrientation), std::sin(initialOrientation), 0.0f };
 
            points[high_index + 1] = controls[cyclic_point];
            points[high_index + 2] = controls[cyclic_point + 1];
        }
        else
        {
            if (m_mode == ModeCatmullrom)
                points[0] = controls[0] - G3D::Vector3{ std::cos(initialOrientation), std::sin(initialOrientation), 0.0f };
            else
                points[0] = controls[0].lerp(controls[1], -1);
 
            points[high_index + 1] = controls[count - 1];
        }
 
        index_lo = lo_index;
        index_hi = high_index + (cyclic ? 1 : 0);
    }

References cyclic, index_hi, index_lo, initialOrientation, m_mode, ModeCatmullrom, and points.

InitLinear()

void Movement::SplineBase::InitLinear ( const Vector3 *  controls, index_type  count, bool  cyclic, index_type  cyclic_point  )

protected

    {
        ASSERT(count >= 2);
        const int real_size = count + 1;
 
        points.resize(real_size);
 
        memcpy(&points[0], controls, sizeof(Vector3) * count);
 
        // first and last two indexes are space for special 'virtual points'
        // these points are required for proper C_Evaluate and C_Evaluate_Derivative methtod work
        if (cyclic)
            points[count] = controls[cyclic_point];
        else
            points[count] = controls[count - 1];
 
        index_lo = 0;
        index_hi = cyclic ? count : (count - 1);
    }

References ASSERT, cyclic, index_hi, index_lo, and points.

isCyclic()

bool Movement::SplineBase::isCyclic ( ) const

inline

{ return cyclic;}

References cyclic.

Referenced by Movement::MoveSpline::_updateState(), and Movement::MoveSpline::init_spline().

last()

index_type Movement::SplineBase::last ( ) const

inline

{ return index_hi;}

References index_hi.

Referenced by Movement::MoveSpline::_Finalize(), Movement::MoveSpline::_updateState(), Movement::MoveSpline::currentPathIdx(), Movement::MoveSpline::FinalDestination(), Movement::MoveSpline::init_spline(), and Movement::Spline< length_type >::length().

mode()

EvaluationMode Movement::SplineBase::mode ( ) const

inline

{ return (EvaluationMode)m_mode;}

References m_mode.

Referenced by ToString(), and Movement::PacketBuilder::WriteCreate().

SegLength()

float Movement::SplineBase::SegLength ( index_type  i ) const

inline

Calculates distance between [i; i+1] points, assumes that index i is in bounds.

{ return (this->*seglengths[m_mode])(i);}

References m_mode.

Referenced by Movement::CommonInitializer::operator()().

SegLengthBezier3()

float Movement::SplineBase::SegLengthBezier3 ( index_type  index ) const

protected

    {
        index *= 3u;
        ASSERT(index >= index_lo && index < index_hi);
 
        Vector3 curPos, nextPos;
        const Vector3* p = &points[index];
 
        C_Evaluate(p, 0.f, s_Bezier3Coeffs, nextPos);
        curPos = nextPos;
 
        index_type i = 1;
        double length = 0;
        while (i <= STEPS_PER_SEGMENT)
        {
            C_Evaluate(p, float(i) / float(STEPS_PER_SEGMENT), s_Bezier3Coeffs, nextPos);
            length += (nextPos - curPos).length();
            curPos = nextPos;
            ++i;
        }
        return length;
    }

References ASSERT, Movement::C_Evaluate(), index_hi, index_lo, points, Movement::s_Bezier3Coeffs(), and STEPS_PER_SEGMENT.

SegLengthCatmullRom()

float Movement::SplineBase::SegLengthCatmullRom ( index_type  index ) const

protected

    {
        ASSERT(index >= index_lo && index < index_hi);
 
        Vector3 curPos, nextPos;
        const Vector3* p = &points[index - 1];
        curPos = nextPos = p[1];
 
        index_type i = 1;
        double length = 0;
        while (i <= STEPS_PER_SEGMENT)
        {
            C_Evaluate(p, float(i) / float(STEPS_PER_SEGMENT), s_catmullRomCoeffs, nextPos);
            length += (nextPos - curPos).length();
            curPos = nextPos;
            ++i;
        }
        return length;
    }

References ASSERT, Movement::C_Evaluate(), index_hi, index_lo, points, Movement::s_catmullRomCoeffs(), and STEPS_PER_SEGMENT.

SegLengthLinear()

float Movement::SplineBase::SegLengthLinear ( index_type  index ) const

protected

    {
        ASSERT(index >= index_lo && index < index_hi);
        return (points[index] - points[index + 1]).length();
    }

References ASSERT, index_hi, index_lo, and points.

ToString()

std::string Movement::SplineBase::ToString

(

)

const

    {
        std::stringstream str;
        const char* mode_str[ModesEnd] = {"Linear", "CatmullRom", "Bezier3", "Uninitialized"};
 
        index_type count = this->points.size();
        str << "mode: " << mode_str[mode()] << std::endl;
        str << "points count: " << count << std::endl;
        for (index_type i = 0; i < count; ++i)
            str << "point " << i << " : " << points[i].toString() << std::endl;
 
        return str.str();
    }

References mode(), ModesEnd, and points.

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

UninitializedSplineEvaluationMethod()

void Movement::SplineBase::UninitializedSplineEvaluationMethod ( index_type  , float  , Vector3 &    ) const

inlineprotected

{ ABORT(); }

References ABORT.

UninitializedSplineInitMethod()

void Movement::SplineBase::UninitializedSplineInitMethod ( Vector3 const *  , index_type  , bool  , index_type    )

inlineprotected

{ ABORT(); }

References ABORT.

UninitializedSplineSegLenghtMethod()

float Movement::SplineBase::UninitializedSplineSegLenghtMethod ( index_type  ) const

inlineprotected

{ ABORT(); }

References ABORT.

Member Data Documentation

cyclic

bool Movement::SplineBase::cyclic {false}

protected

{false};

Referenced by init_cyclic_spline(), init_spline(), init_spline_custom(), InitCatmullRom(), InitLinear(), and isCyclic().

derivative_evaluators

SplineBase::EvaluationMethtod Movement::SplineBase::derivative_evaluators

staticprotected

Initial value:

=
    {
        &SplineBase::EvaluateDerivativeLinear,
        &SplineBase::EvaluateDerivativeCatmullRom,
        &SplineBase::EvaluateDerivativeBezier3,
        &SplineBase::UninitializedSplineEvaluationMethod,
    }

evaluators

SplineBase::EvaluationMethtod Movement::SplineBase::evaluators

staticprotected

Initial value:

=
    {
        &SplineBase::EvaluateLinear,
        &SplineBase::EvaluateCatmullRom,
        &SplineBase::EvaluateBezier3,
        &SplineBase::UninitializedSplineEvaluationMethod,
    }

index_hi

index_type Movement::SplineBase::index_hi {0}

protected

{0};

Referenced by clear(), empty(), EvaluateBezier3(), EvaluateCatmullRom(), EvaluateDerivativeBezier3(), EvaluateDerivativeCatmullRom(), EvaluateDerivativeLinear(), EvaluateLinear(), init_spline_custom(), InitBezier3(), InitCatmullRom(), Movement::Spline< length_type >::initLengths(), InitLinear(), last(), Movement::Spline< length_type >::length(), SegLengthBezier3(), SegLengthCatmullRom(), and SegLengthLinear().

index_lo

index_type Movement::SplineBase::index_lo {0}

protected

{0};

Referenced by clear(), empty(), EvaluateBezier3(), EvaluateCatmullRom(), EvaluateDerivativeBezier3(), EvaluateDerivativeCatmullRom(), EvaluateDerivativeLinear(), EvaluateLinear(), first(), init_spline_custom(), InitBezier3(), InitCatmullRom(), Movement::Spline< length_type >::initLengths(), InitLinear(), SegLengthBezier3(), SegLengthCatmullRom(), and SegLengthLinear().

initializers

SplineBase::InitMethtod Movement::SplineBase::initializers

staticprotected

Initial value:

=
    {
        
        &SplineBase::InitCatmullRom,    
        &SplineBase::InitCatmullRom,
        &SplineBase::InitBezier3,
        &SplineBase::UninitializedSplineInitMethod,
    }

Referenced by init_cyclic_spline(), and init_spline().

initialOrientation

float Movement::SplineBase::initialOrientation {0}

protected

{0};

Referenced by init_cyclic_spline(), init_spline(), and InitCatmullRom().

m_mode

uint8 Movement::SplineBase::m_mode {UninitializedMode}

protected

{UninitializedMode};

Referenced by evaluate_derivative(), evaluate_percent(), init_cyclic_spline(), init_spline(), init_spline_custom(), InitCatmullRom(), mode(), and SegLength().

points

ControlArray Movement::SplineBase::points

protected

Referenced by clear(), EvaluateBezier3(), EvaluateCatmullRom(), EvaluateDerivativeBezier3(), EvaluateDerivativeCatmullRom(), EvaluateDerivativeLinear(), EvaluateLinear(), getPoint(), getPointCount(), getPoints(), init_spline_custom(), InitBezier3(), InitCatmullRom(), InitLinear(), SegLengthBezier3(), SegLengthCatmullRom(), SegLengthLinear(), and ToString().

seglengths

SplineBase::SegLenghtMethtod Movement::SplineBase::seglengths

staticprotected

Initial value:

=
    {
        &SplineBase::SegLengthLinear,
        &SplineBase::SegLengthCatmullRom,
        &SplineBase::SegLengthBezier3,
        &SplineBase::UninitializedSplineSegLenghtMethod,
    }

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/Movement/Spline/Spline.h
• azerothcore-wotlk/src/server/game/Movement/Spline/Spline.cpp