DetourCommon.h File Reference

#include "DetourMath.h"

Include dependency graph for DetourCommon.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
General helper functions
template<class T >
void	dtIgnoreUnused (const T &)
template<class T >
void	dtSwap (T &a, T &b)
template<class T >
T	dtMin (T a, T b)
template<class T >
T	dtMax (T a, T b)
template<class T >
T	dtAbs (T a)
template<class T >
T	dtSqr (T a)
template<class T >
T	dtClamp (T v, T mn, T mx)
Vector helper functions.
void	dtVcross (float *dest, const float *v1, const float *v2)
float	dtVdot (const float *v1, const float *v2)
void	dtVmad (float *dest, const float *v1, const float *v2, const float s)
void	dtVlerp (float *dest, const float *v1, const float *v2, const float t)
void	dtVadd (float *dest, const float *v1, const float *v2)
void	dtVsub (float *dest, const float *v1, const float *v2)
void	dtVscale (float *dest, const float *v, const float t)
void	dtVmin (float *mn, const float *v)
void	dtVmax (float *mx, const float *v)
void	dtVset (float *dest, const float x, const float y, const float z)
void	dtVcopy (float *dest, const float *a)
float	dtVlen (const float *v)
float	dtVlenSqr (const float *v)
float	dtVdist (const float *v1, const float *v2)
float	dtVdistSqr (const float *v1, const float *v2)
float	dtVdist2D (const float *v1, const float *v2)
float	dtVdist2DSqr (const float *v1, const float *v2)
void	dtVnormalize (float *v)
bool	dtVequal (const float *p0, const float *p1)
float	dtVdot2D (const float *u, const float *v)
float	dtVperp2D (const float *u, const float *v)
Computational geometry helper functions.
float	dtTriArea2D (const float *a, const float *b, const float *c)
bool	dtOverlapQuantBounds (const unsigned short amin[3], const unsigned short amax[3], const unsigned short bmin[3], const unsigned short bmax[3])
bool	dtOverlapBounds (const float *amin, const float *amax, const float *bmin, const float *bmax)
void	dtClosestPtPointTriangle (float *closest, const float *p, const float *a, const float *b, const float *c)
bool	dtClosestHeightPointTriangle (const float *p, const float *a, const float *b, const float *c, float &h)
bool	dtIntersectSegmentPoly2D (const float *p0, const float *p1, const float *verts, int nverts, float &tmin, float &tmax, int &segMin, int &segMax)
bool	dtIntersectSegSeg2D (const float *ap, const float *aq, const float *bp, const float *bq, float &s, float &t)
bool	dtPointInPolygon (const float *pt, const float *verts, const int nverts)
bool	dtDistancePtPolyEdgesSqr (const float *pt, const float *verts, const int nverts, float *ed, float *et)
float	dtDistancePtSegSqr2D (const float *pt, const float *p, const float *q, float &t)
void	dtCalcPolyCenter (float *tc, const unsigned short *idx, int nidx, const float *verts)
bool	dtOverlapPolyPoly2D (const float *polya, const int npolya, const float *polyb, const int npolyb)
Miscellanious functions.
unsigned int	dtNextPow2 (unsigned int v)
unsigned int	dtIlog2 (unsigned int v)
int	dtAlign4 (int x)
int	dtOppositeTile (int side)
void	dtSwapByte (unsigned char *a, unsigned char *b)
void	dtSwapEndian (unsigned short *v)
void	dtSwapEndian (short *v)
void	dtSwapEndian (unsigned int *v)
void	dtSwapEndian (int *v)
void	dtSwapEndian (float *v)
void	dtRandomPointInConvexPoly (const float *pts, const int npts, float *areas, const float s, const float t, float *out)

Function Documentation

template<class T >

T dtAbs ( T  a )

inline

Returns the absolute value.

Parameters

[in]

a

The value.

Returns

The absolute value of the specified value.

{ return a < 0 ? -a : a; }

Here is the caller graph for this function:

int dtAlign4 ( int  x )

inline

{ return (x+3) & ~3; }

Here is the caller graph for this function:

void dtCalcPolyCenter	(	float *	tc,
		const unsigned short *	idx,
		int	nidx,
		const float *	verts
	)

Derives the centroid of a convex polygon.

Parameters

[out]	tc	The centroid of the polgyon. [(x, y, z)]
[in]	idx	The polygon indices. [(vertIndex) * nidx]
[in]	nidx	The number of indices in the polygon. [Limit: >= 3]
[in]	verts	The polygon vertices. [(x, y, z) * vertCount]

{
 tc[0] = 0.0f;
 tc[1] = 0.0f;
 tc[2] = 0.0f;
 for (int j = 0; j < nidx; ++j)
 {
 const float* v = &verts[idx[j]*3];
 tc[0] += v[0];
 tc[1] += v[1];
 tc[2] += v[2];
 }
 const float s = 1.0f / nidx;
 tc[0] *= s;
 tc[1] *= s;
 tc[2] *= s;
}

template<class T >

T dtClamp ( T  v, T  mn, T  mx  )

inline

Clamps the value to the specified range.

Parameters

[in]	v	The value to clamp.
[in]	mn	The minimum permitted return value.
[in]	mx	The maximum permitted return value.

Returns

The value, clamped to the specified range.

{ return v < mn ? mn : (v > mx ? mx : v); }

Here is the caller graph for this function:

bool dtClosestHeightPointTriangle	(	const float *	p,
		const float *	a,
		const float *	b,
		const float *	c,
		float &	h
	)

Derives the y-axis height of the closest point on the triangle from the specified reference point.

Parameters

[in]	p	The reference point from which to test. [(x, y, z)]
[in]	a	Vertex A of triangle ABC. [(x, y, z)]
[in]	b	Vertex B of triangle ABC. [(x, y, z)]
[in]	c	Vertex C of triangle ABC. [(x, y, z)]
[out]	h	The resulting height.

{
 float v0[3], v1[3], v2[3];
 dtVsub(v0, c,a);
 dtVsub(v1, b,a);
 dtVsub(v2, p,a);
 
 const float dot00 = dtVdot2D(v0, v0);
 const float dot01 = dtVdot2D(v0, v1);
 const float dot02 = dtVdot2D(v0, v2);
 const float dot11 = dtVdot2D(v1, v1);
 const float dot12 = dtVdot2D(v1, v2);
 
 // Compute barycentric coordinates
 const float invDenom = 1.0f / (dot00 * dot11 - dot01 * dot01);
 const float u = (dot11 * dot02 - dot01 * dot12) * invDenom;
 const float v = (dot00 * dot12 - dot01 * dot02) * invDenom;

 // The (sloppy) epsilon is needed to allow to get height of points which
 // are interpolated along the edges of the triangles.
 static const float EPS = 1e-4f;
 
 // If point lies inside the triangle, return interpolated ycoord.
 if (u >= -EPS && v >= -EPS && (u+v) <= 1+EPS)
 {
 h = a[1] + v0[1]*u + v1[1]*v;
 return true;
 }
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void dtClosestPtPointTriangle	(	float *	closest,
		const float *	p,
		const float *	a,
		const float *	b,
		const float *	c
	)

Derives the closest point on a triangle from the specified reference point.

Parameters

[out]	closest	The closest point on the triangle.
[in]	p	The reference point from which to test. [(x, y, z)]
[in]	a	Vertex A of triangle ABC. [(x, y, z)]
[in]	b	Vertex B of triangle ABC. [(x, y, z)]
[in]	c	Vertex C of triangle ABC. [(x, y, z)]

{
 // Check if P in vertex region outside A
 float ab[3], ac[3], ap[3];
 dtVsub(ab, b, a);
 dtVsub(ac, c, a);
 dtVsub(ap, p, a);
 float d1 = dtVdot(ab, ap);
 float d2 = dtVdot(ac, ap);
 if (d1 <= 0.0f && d2 <= 0.0f)
 {
 // barycentric coordinates (1,0,0)
 dtVcopy(closest, a);
 return;
 }
 
 // Check if P in vertex region outside B
 float bp[3];
 dtVsub(bp, p, b);
 float d3 = dtVdot(ab, bp);
 float d4 = dtVdot(ac, bp);
 if (d3 >= 0.0f && d4 <= d3)
 {
 // barycentric coordinates (0,1,0)
 dtVcopy(closest, b);
 return;
 }
 
 // Check if P in edge region of AB, if so return projection of P onto AB
 float vc = d1*d4 - d3*d2;
 if (vc <= 0.0f && d1 >= 0.0f && d3 <= 0.0f)
 {
 // barycentric coordinates (1-v,v,0)
 float v = d1 / (d1 - d3);
 closest[0] = a[0] + v * ab[0];
 closest[1] = a[1] + v * ab[1];
 closest[2] = a[2] + v * ab[2];
 return;
 }
 
 // Check if P in vertex region outside C
 float cp[3];
 dtVsub(cp, p, c);
 float d5 = dtVdot(ab, cp);
 float d6 = dtVdot(ac, cp);
 if (d6 >= 0.0f && d5 <= d6)
 {
 // barycentric coordinates (0,0,1)
 dtVcopy(closest, c);
 return;
 }
 
 // Check if P in edge region of AC, if so return projection of P onto AC
 float vb = d5*d2 - d1*d6;
 if (vb <= 0.0f && d2 >= 0.0f && d6 <= 0.0f)
 {
 // barycentric coordinates (1-w,0,w)
 float w = d2 / (d2 - d6);
 closest[0] = a[0] + w * ac[0];
 closest[1] = a[1] + w * ac[1];
 closest[2] = a[2] + w * ac[2];
 return;
 }
 
 // Check if P in edge region of BC, if so return projection of P onto BC
 float va = d3*d6 - d5*d4;
 if (va <= 0.0f && (d4 - d3) >= 0.0f && (d5 - d6) >= 0.0f)
 {
 // barycentric coordinates (0,1-w,w)
 float w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
 closest[0] = b[0] + w * (c[0] - b[0]);
 closest[1] = b[1] + w * (c[1] - b[1]);
 closest[2] = b[2] + w * (c[2] - b[2]);
 return;
 }
 
 // P inside face region. Compute Q through its barycentric coordinates (u,v,w)
 float denom = 1.0f / (va + vb + vc);
 float v = vb * denom;
 float w = vc * denom;
 closest[0] = a[0] + ab[0] * v + ac[0] * w;
 closest[1] = a[1] + ab[1] * v + ac[1] * w;
 closest[2] = a[2] + ab[2] * v + ac[2] * w;
}

Here is the call graph for this function:

bool dtDistancePtPolyEdgesSqr	(	const float *	pt,
		const float *	verts,
		const int	nverts,
		float *	ed,
		float *	et
	)

{
 // TODO: Replace pnpoly with triArea2D tests?
 int i, j;
 bool c = false;
 for (i = 0, j = nverts-1; i < nverts; j = i++)
 {
 const float* vi = &verts[i*3];
 const float* vj = &verts[j*3];
 if (((vi[2] > pt[2]) != (vj[2] > pt[2])) &&
 (pt[0] < (vj[0]-vi[0]) * (pt[2]-vi[2]) / (vj[2]-vi[2]) + vi[0]) )
 c = !c;
 ed[j] = dtDistancePtSegSqr2D(pt, vj, vi, et[j]);
 }
 return c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

float dtDistancePtSegSqr2D	(	const float *	pt,
		const float *	p,
		const float *	q,
		float &	t
	)

{
 float pqx = q[0] - p[0];
 float pqz = q[2] - p[2];
 float dx = pt[0] - p[0];
 float dz = pt[2] - p[2];
 float d = pqx*pqx + pqz*pqz;
 t = pqx*dx + pqz*dz;
 if (d > 0) t /= d;
 if (t < 0) t = 0;
 else if (t > 1) t = 1;
 dx = p[0] + t*pqx - pt[0];
 dz = p[2] + t*pqz - pt[2];
 return dx*dx + dz*dz;
}

Here is the caller graph for this function:

template<class T >

void dtIgnoreUnused

(

const T &

)

Used to ignore a function parameter. VS complains about unused parameters and this silences the warning.

Parameters

[in]

_

Unused parameter

{ }

unsigned int dtIlog2 ( unsigned int  v )

inline

{
 unsigned int r;
 unsigned int shift;
 r = (v > 0xffff) << 4; v >>= r;
 shift = (v > 0xff) << 3; v >>= shift; r |= shift;
 shift = (v > 0xf) << 2; v >>= shift; r |= shift;
 shift = (v > 0x3) << 1; v >>= shift; r |= shift;
 r |= (v >> 1);
 return r;
}

bool dtIntersectSegmentPoly2D	(	const float *	p0,
		const float *	p1,
		const float *	verts,
		int	nverts,
		float &	tmin,
		float &	tmax,
		int &	segMin,
		int &	segMax
	)

{
 static const float EPS = 0.00000001f;
 
 tmin = 0;
 tmax = 1;
 segMin = -1;
 segMax = -1;
 
 float dir[3];
 dtVsub(dir, p1, p0);
 
 for (int i = 0, j = nverts-1; i < nverts; j=i++)
 {
 float edge[3], diff[3];
 dtVsub(edge, &verts[i*3], &verts[j*3]);
 dtVsub(diff, p0, &verts[j*3]);
 const float n = dtVperp2D(edge, diff);
 const float d = dtVperp2D(dir, edge);
 if (fabsf(d) < EPS)
 {
 // S is nearly parallel to this edge
 if (n < 0)
 return false;
 else
 continue;
 }
 const float t = n / d;
 if (d < 0)
 {
 // segment S is entering across this edge
 if (t > tmin)
 {
 tmin = t;
 segMin = j;
 // S enters after leaving polygon
 if (tmin > tmax)
 return false;
 }
 }
 else
 {
 // segment S is leaving across this edge
 if (t < tmax)
 {
 tmax = t;
 segMax = j;
 // S leaves before entering polygon
 if (tmax < tmin)
 return false;
 }
 }
 }
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool dtIntersectSegSeg2D	(	const float *	ap,
		const float *	aq,
		const float *	bp,
		const float *	bq,
		float &	s,
		float &	t
	)

{
 float u[3], v[3], w[3];
 dtVsub(u,aq,ap);
 dtVsub(v,bq,bp);
 dtVsub(w,ap,bp);
 float d = vperpXZ(u,v);
 if (fabsf(d) < 1e-6f) return false;
 s = vperpXZ(v,w) / d;
 t = vperpXZ(u,w) / d;
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

T dtMax ( T  a, T  b  )

inline

Returns the maximum of two values.

Parameters

[in]	a	Value A
[in]	b	Value B

Returns

The maximum of the two values.

{ return a > b ? a : b; }

Here is the caller graph for this function:

template<class T >

T dtMin ( T  a, T  b  )

inline

Returns the minimum of two values.

Parameters

[in]	a	Value A
[in]	b	Value B

Returns

The minimum of the two values.

{ return a < b ? a : b; }

Here is the caller graph for this function:

unsigned int dtNextPow2 ( unsigned int  v )

inline

{
 v--;
 v |= v >> 1;
 v |= v >> 2;
 v |= v >> 4;
 v |= v >> 8;
 v |= v >> 16;
 v++;
 return v;
}

Here is the caller graph for this function:

int dtOppositeTile ( int  side )

inline

{ return (side+4) & 0x7; }

Here is the caller graph for this function:

bool dtOverlapBounds ( const float *  amin, const float *  amax, const float *  bmin, const float *  bmax  )

inline

Determines if two axis-aligned bounding boxes overlap.

Parameters

[in]	amin	Minimum bounds of box A. [(x, y, z)]
[in]	amax	Maximum bounds of box A. [(x, y, z)]
[in]	bmin	Minimum bounds of box B. [(x, y, z)]
[in]	bmax	Maximum bounds of box B. [(x, y, z)]

Returns

True if the two AABB's overlap.

See also

dtOverlapQuantBounds

{
 bool overlap = true;
 overlap = (amin[0] > bmax[0] || amax[0] < bmin[0]) ? false : overlap;
 overlap = (amin[1] > bmax[1] || amax[1] < bmin[1]) ? false : overlap;
 overlap = (amin[2] > bmax[2] || amax[2] < bmin[2]) ? false : overlap;
 return overlap;
}

Here is the caller graph for this function:

bool dtOverlapPolyPoly2D	(	const float *	polya,
		const int	npolya,
		const float *	polyb,
		const int	npolyb
	)

Determines if the two convex polygons overlap on the xz-plane.

Parameters

[in]	polya	Polygon A vertices. [(x, y, z) * npolya]
[in]	npolya	The number of vertices in polygon A.
[in]	polyb	Polygon B vertices. [(x, y, z) * npolyb]
[in]	npolyb	The number of vertices in polygon B.

Returns

True if the two polygons overlap.

All vertices are projected onto the xz-plane, so the y-values are ignored.

{
 const float eps = 1e-4f;
 
 for (int i = 0, j = npolya-1; i < npolya; j=i++)
 {
 const float* va = &polya[j*3];
 const float* vb = &polya[i*3];
 const float n[3] = { vb[2]-va[2], 0, -(vb[0]-va[0]) };
 float amin,amax,bmin,bmax;
 projectPoly(n, polya, npolya, amin,amax);
 projectPoly(n, polyb, npolyb, bmin,bmax);
 if (!overlapRange(amin,amax, bmin,bmax, eps))
 {
 // Found separating axis
 return false;
 }
 }
 for (int i = 0, j = npolyb-1; i < npolyb; j=i++)
 {
 const float* va = &polyb[j*3];
 const float* vb = &polyb[i*3];
 const float n[3] = { vb[2]-va[2], 0, -(vb[0]-va[0]) };
 float amin,amax,bmin,bmax;
 projectPoly(n, polya, npolya, amin,amax);
 projectPoly(n, polyb, npolyb, bmin,bmax);
 if (!overlapRange(amin,amax, bmin,bmax, eps))
 {
 // Found separating axis
 return false;
 }
 }
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool dtOverlapQuantBounds ( const unsigned short  amin[3], const unsigned short  amax[3], const unsigned short  bmin[3], const unsigned short  bmax[3]  )

inline

Determines if two axis-aligned bounding boxes overlap.

Parameters

[in]	amin	Minimum bounds of box A. [(x, y, z)]
[in]	amax	Maximum bounds of box A. [(x, y, z)]
[in]	bmin	Minimum bounds of box B. [(x, y, z)]
[in]	bmax	Maximum bounds of box B. [(x, y, z)]

Returns

True if the two AABB's overlap.

See also

dtOverlapBounds

{
 bool overlap = true;
 overlap = (amin[0] > bmax[0] || amax[0] < bmin[0]) ? false : overlap;
 overlap = (amin[1] > bmax[1] || amax[1] < bmin[1]) ? false : overlap;
 overlap = (amin[2] > bmax[2] || amax[2] < bmin[2]) ? false : overlap;
 return overlap;
}

Here is the caller graph for this function:

bool dtPointInPolygon	(	const float *	pt,
		const float *	verts,
		const int	nverts
	)

Determines if the specified point is inside the convex polygon on the xz-plane.

Parameters

[in]	pt	The point to check. [(x, y, z)]
[in]	verts	The polygon vertices. [(x, y, z) * nverts]
[in]	nverts	The number of vertices. [Limit: >= 3]

Returns

True if the point is inside the polygon.

All points are projected onto the xz-plane, so the y-values are ignored.

{
 // TODO: Replace pnpoly with triArea2D tests?
 int i, j;
 bool c = false;
 for (i = 0, j = nverts-1; i < nverts; j = i++)
 {
 const float* vi = &verts[i*3];
 const float* vj = &verts[j*3];
 if (((vi[2] > pt[2]) != (vj[2] > pt[2])) &&
 (pt[0] < (vj[0]-vi[0]) * (pt[2]-vi[2]) / (vj[2]-vi[2]) + vi[0]) )
 c = !c;
 }
 return c;
}

Here is the caller graph for this function:

void dtRandomPointInConvexPoly	(	const float *	pts,
		const int	npts,
		float *	areas,
		const float	s,
		const float	t,
		float *	out
	)

{
 // Calc triangle araes
 float areasum = 0.0f;
 for (int i = 2; i < npts; i++) {
 areas[i] = dtTriArea2D(&pts[0], &pts[(i-1)*3], &pts[i*3]);
 areasum += dtMax(0.001f, areas[i]);
 }
 // Find sub triangle weighted by area.
 const float thr = s*areasum;
 float acc = 0.0f;
 float u = 0.0f;
 int tri = 0;
 for (int i = 2; i < npts; i++) {
 const float dacc = areas[i];
 if (thr >= acc && thr < (acc+dacc))
 {
 u = (thr - acc) / dacc;
 tri = i;
 break;
 }
 acc += dacc;
 }
 
 float v = dtMathSqrtf(t);
 
 const float a = 1 - v;
 const float b = (1 - u) * v;
 const float c = u * v;
 const float* pa = &pts[0];
 const float* pb = &pts[(tri-1)*3];
 const float* pc = &pts[tri*3];
 
 out[0] = a*pa[0] + b*pb[0] + c*pc[0];
 out[1] = a*pa[1] + b*pb[1] + c*pc[1];
 out[2] = a*pa[2] + b*pb[2] + c*pc[2];
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

T dtSqr ( T  a )

inline

Returns the square of the value.

Parameters

[in]

a

The value.

Returns

The square of the value.

{ return a*a; }

Here is the caller graph for this function:

template<class T >

void dtSwap ( T &  a, T &  b  )

inline

Swaps the values of the two parameters.

Parameters

[in,out]	a	Value A
[in,out]	b	Value B

{ T t = a; a = b; b = t; }

Here is the caller graph for this function:

void dtSwapByte ( unsigned char *  a, unsigned char *  b  )

inline

{
 unsigned char tmp = *a;
 *a = *b;
 *b = tmp;
}

Here is the caller graph for this function:

void dtSwapEndian ( unsigned short *  v )

inline

{
 unsigned char* x = (unsigned char*)v;
 dtSwapByte(x+0, x+1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void dtSwapEndian ( short *  v )

inline

{
 unsigned char* x = (unsigned char*)v;
 dtSwapByte(x+0, x+1);
}

Here is the call graph for this function:

void dtSwapEndian ( unsigned int *  v )

inline

{
 unsigned char* x = (unsigned char*)v;
 dtSwapByte(x+0, x+3); dtSwapByte(x+1, x+2);
}

Here is the call graph for this function:

void dtSwapEndian ( int *  v )

inline

{
 unsigned char* x = (unsigned char*)v;
 dtSwapByte(x+0, x+3); dtSwapByte(x+1, x+2);
}

Here is the call graph for this function:

void dtSwapEndian ( float *  v )

inline

{
 unsigned char* x = (unsigned char*)v;
 dtSwapByte(x+0, x+3); dtSwapByte(x+1, x+2);
}

Here is the call graph for this function:

float dtTriArea2D ( const float *  a, const float *  b, const float *  c  )

inline

Derives the signed xz-plane area of the triangle ABC, or the relationship of line AB to point C.

Parameters

[in]	a	Vertex A. [(x, y, z)]
[in]	b	Vertex B. [(x, y, z)]
[in]	c	Vertex C. [(x, y, z)]

Returns

The signed xz-plane area of the triangle.

The vertices are projected onto the xz-plane, so the y-values are ignored.

This is a low cost function than can be used for various purposes. Its main purpose is for point/line relationship testing.

In all cases: A value of zero indicates that all vertices are collinear or represent the same point. (On the xz-plane.)

When used for point/line relationship tests, AB usually represents a line against which the C point is to be tested. In this case:

A positive value indicates that point C is to the left of line AB, looking from A toward B.
A negative value indicates that point C is to the right of lineAB, looking from A toward B.

When used for evaluating a triangle:

The absolute value of the return value is two times the area of the triangle when it is projected onto the xz-plane.

A positive return value indicates:

• The vertices are wrapped in the normal Detour wrap direction.
• The triangle's 3D face normal is in the general up direction.

A negative return value indicates:

• The vertices are reverse wrapped. (Wrapped opposite the normal Detour wrap direction.)
• The triangle's 3D face normal is in the general down direction.

{
 const float abx = b[0] - a[0];
 const float abz = b[2] - a[2];
 const float acx = c[0] - a[0];
 const float acz = c[2] - a[2];
 return acx*abz - abx*acz;
}

Here is the caller graph for this function:

void dtVadd ( float *  dest, const float *  v1, const float *  v2  )

inline

Performs a vector addition. (v1 + v2)

Parameters

[out]	dest	The result vector. [(x, y, z)]
[in]	v1	The base vector. [(x, y, z)]
[in]	v2	The vector to add to v1. [(x, y, z)]

{
 dest[0] = v1[0]+v2[0];
 dest[1] = v1[1]+v2[1];
 dest[2] = v1[2]+v2[2];
}

Here is the caller graph for this function:

void dtVcopy ( float *  dest, const float *  a  )

inline

Performs a vector copy.

Parameters

[out]	dest	The result. [(x, y, z)]
[in]	a	The vector to copy. [(x, y, z)]

{
    dest[0] = a[0];
    dest[1] = a[1];
    dest[2] = a[2];
}

Here is the caller graph for this function:

void dtVcross ( float *  dest, const float *  v1, const float *  v2  )

inline

Derives the cross product of two vectors. (v1 x v2)

Parameters

[out]	dest	The cross product. [(x, y, z)]
[in]	v1	A Vector [(x, y, z)]
[in]	v2	A vector [(x, y, z)]

{
    dest[0] = v1[1]*v2[2] - v1[2]*v2[1];
    dest[1] = v1[2]*v2[0] - v1[0]*v2[2];
    dest[2] = v1[0]*v2[1] - v1[1]*v2[0]; 
}

float dtVdist ( const float *  v1, const float *  v2  )

inline

Returns the distance between two points.

Parameters

[in]	v1	A point. [(x, y, z)]
[in]	v2	A point. [(x, y, z)]

Returns

The distance between the two points.

{
    const float dx = v2[0] - v1[0];
    const float dy = v2[1] - v1[1];
    const float dz = v2[2] - v1[2];
    return dtMathSqrtf(dx*dx + dy*dy + dz*dz);
}

Here is the call graph for this function:

Here is the caller graph for this function:

float dtVdist2D ( const float *  v1, const float *  v2  )

inline

Derives the distance between the specified points on the xz-plane.

Parameters

[in]	v1	A point. [(x, y, z)]
[in]	v2	A point. [(x, y, z)]

Returns

The distance between the point on the xz-plane.

The vectors are projected onto the xz-plane, so the y-values are ignored.

{
    const float dx = v2[0] - v1[0];
    const float dz = v2[2] - v1[2];
    return dtMathSqrtf(dx*dx + dz*dz);
}

Here is the call graph for this function:

Here is the caller graph for this function:

float dtVdist2DSqr ( const float *  v1, const float *  v2  )

inline

Derives the square of the distance between the specified points on the xz-plane.

Parameters

[in]	v1	A point. [(x, y, z)]
[in]	v2	A point. [(x, y, z)]

Returns

The square of the distance between the point on the xz-plane.

{
    const float dx = v2[0] - v1[0];
    const float dz = v2[2] - v1[2];
    return dx*dx + dz*dz;
}

Here is the caller graph for this function:

float dtVdistSqr ( const float *  v1, const float *  v2  )

inline

Returns the square of the distance between two points.

Parameters

[in]	v1	A point. [(x, y, z)]
[in]	v2	A point. [(x, y, z)]

Returns

The square of the distance between the two points.

{
    const float dx = v2[0] - v1[0];
    const float dy = v2[1] - v1[1];
    const float dz = v2[2] - v1[2];
    return dx*dx + dy*dy + dz*dz;
}

Here is the caller graph for this function:

float dtVdot ( const float *  v1, const float *  v2  )

inline

Derives the dot product of two vectors. (v1 . v2)

Parameters

[in]	v1	A Vector [(x, y, z)]
[in]	v2	A vector [(x, y, z)]

Returns

The dot product.

{
    return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
}

Here is the caller graph for this function:

float dtVdot2D ( const float *  u, const float *  v  )

inline

Derives the dot product of two vectors on the xz-plane. (u . v)

Parameters

[in]	u	A vector [(x, y, z)]
[in]	v	A vector [(x, y, z)]

Returns

The dot product on the xz-plane.

The vectors are projected onto the xz-plane, so the y-values are ignored.

{
    return u[0]*v[0] + u[2]*v[2];
}

Here is the caller graph for this function:

bool dtVequal ( const float *  p0, const float *  p1  )

inline

Performs a 'sloppy' colocation check of the specified points.

Parameters

[in]	p0	A point. [(x, y, z)]
[in]	p1	A point. [(x, y, z)]

Returns

True if the points are considered to be at the same location.

Basically, this function will return true if the specified points are close enough to eachother to be considered colocated.

{
    static const float thr = dtSqr(1.0f/16384.0f);
    const float d = dtVdistSqr(p0, p1);
    return d < thr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

float dtVlen ( const float *  v )

inline

Derives the scalar length of the vector.

Parameters

[in]

v

The vector. [(x, y, z)]

Returns

The scalar length of the vector.

{
    return dtMathSqrtf(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
}

Here is the call graph for this function:

float dtVlenSqr ( const float *  v )

inline

Derives the square of the scalar length of the vector. (len * len)

Parameters

[in]

v

The vector. [(x, y, z)]

Returns

The square of the scalar length of the vector.

{
    return v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
}

Here is the caller graph for this function:

void dtVlerp ( float *  dest, const float *  v1, const float *  v2, const float  t  )

inline

Performs a linear interpolation between two vectors. (v1 toward v2)

Parameters

[out]	dest	The result vector. [(x, y, x)]
[in]	v1	The starting vector.
[in]	v2	The destination vector.
[in]	t	The interpolation factor. [Limits: 0 <= value <= 1.0]

{
    dest[0] = v1[0]+(v2[0]-v1[0])*t;
    dest[1] = v1[1]+(v2[1]-v1[1])*t;
    dest[2] = v1[2]+(v2[2]-v1[2])*t;
}

Here is the caller graph for this function:

void dtVmad ( float *  dest, const float *  v1, const float *  v2, const float  s  )

inline

Performs a scaled vector addition. (v1 + (v2 * s))

Parameters

[out]	dest	The result vector. [(x, y, z)]
[in]	v1	The base vector. [(x, y, z)]
[in]	v2	The vector to scale and add to v1. [(x, y, z)]
[in]	s	The amount to scale v2 by before adding to v1.

{
    dest[0] = v1[0]+v2[0]*s;
    dest[1] = v1[1]+v2[1]*s;
    dest[2] = v1[2]+v2[2]*s;
}

Here is the caller graph for this function:

void dtVmax ( float *  mx, const float *  v  )

inline

Selects the maximum value of each element from the specified vectors.

Parameters

[in,out]	mx	A vector. (Will be updated with the result.) [(x, y, z)]
[in]	v	A vector. [(x, y, z)]

{
    mx[0] = dtMax(mx[0], v[0]);
    mx[1] = dtMax(mx[1], v[1]);
    mx[2] = dtMax(mx[2], v[2]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void dtVmin ( float *  mn, const float *  v  )

inline

Selects the minimum value of each element from the specified vectors.

Parameters

[in,out]	mn	A vector. (Will be updated with the result.) [(x, y, z)]
[in]	v	A vector. [(x, y, z)]

{
    mn[0] = dtMin(mn[0], v[0]);
    mn[1] = dtMin(mn[1], v[1]);
    mn[2] = dtMin(mn[2], v[2]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void dtVnormalize ( float *  v )

inline

Normalizes the vector.

Parameters

[in,out]

v

The vector to normalize. [(x, y, z)]

{
    float d = 1.0f / dtMathSqrtf(dtSqr(v[0]) + dtSqr(v[1]) + dtSqr(v[2]));
    v[0] *= d;
    v[1] *= d;
    v[2] *= d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

float dtVperp2D ( const float *  u, const float *  v  )

inline

Derives the xz-plane 2D perp product of the two vectors. (uz*vx - ux*vz)

Parameters

[in]	u	The LHV vector [(x, y, z)]
[in]	v	The RHV vector [(x, y, z)]

Returns

The dot product on the xz-plane.

The vectors are projected onto the xz-plane, so the y-values are ignored.

{
    return u[2]*v[0] - u[0]*v[2];
}

Here is the caller graph for this function:

void dtVscale ( float *  dest, const float *  v, const float  t  )

inline

Scales the vector by the specified value. (v * t)

Parameters

[out]	dest	The result vector. [(x, y, z)]
[in]	v	The vector to scale. [(x, y, z)]
[in]	t	The scaling factor.

{
    dest[0] = v[0]*t;
    dest[1] = v[1]*t;
    dest[2] = v[2]*t;
}

Here is the caller graph for this function:

void dtVset ( float *  dest, const float  x, const float  y, const float  z  )

inline

Sets the vector elements to the specified values.

Parameters

[out]	dest	The result vector. [(x, y, z)]
[in]	x	The x-value of the vector.
[in]	y	The y-value of the vector.
[in]	z	The z-value of the vector.

{
    dest[0] = x; dest[1] = y; dest[2] = z;
}

Here is the caller graph for this function:

void dtVsub ( float *  dest, const float *  v1, const float *  v2  )

inline

Performs a vector subtraction. (v1 - v2)

Parameters

[out]	dest	The result vector. [(x, y, z)]
[in]	v1	The base vector. [(x, y, z)]
[in]	v2	The vector to subtract from v1. [(x, y, z)]

{
    dest[0] = v1[0]-v2[0];
    dest[1] = v1[1]-v2[1];
    dest[2] = v1[2]-v2[2];
}

Here is the caller graph for this function: