Performs a 'sloppy' colocation check of the specified points. @param[in] p0 A point. [(x, y, z)] @param[in] p1 A point. [(x, y, z)] @return True if

If a value that is EqualsFunc to @a member is present, returns a pointer to the version stored in the data structure, otherwise returns NULL.

Returns true if the ray intersects this node */

@brief Returns a value in host format (i.e., don't worry about endian issues) */

Returns a + (b - a) * f; */

Removes the last element and returns it. By default, shrinks the underlying array. */

----------------------------------------------------------------------------

Make unit length in place */

slot index starts at 0

----------------------------------------------------------------------------

Returns the old value, before the add. */

Iterate through all members. It is an error to mutate the HashGrid while iterating through it. Each member can be accessed by "dereferencing

Throws out all elements of the set. */

@par Much faster than closestPointOnPoly(). If the provided position lies within the polygon's xz-bounds (above or below), then @p pos and @p closes

Atomic test-and-set: if <code>*this == comperand</code> then <code>*this := exchange</code> else do nothing. In both cases, returns the old v

Returns true if there is a value that is exactly equal to @a v. This will check all neighboring cells to avoid roundoff error at cell boundar

@par This function will only free the memory for tiles with the #DT_TILE_FREE_DATA flag set.

Determines if two axis-aligned bounding boxes overlap. @param[in] amin Minimum bounds of box A. [(x, y, z)] @param[in] amax Maximum bounds of box A.

Determines if two axis-aligned bounding boxes overlap. @param[in] amin Minimum bounds of box A. [(x, y, z)] @param[in] amax Maximum bounds of box A.

Returns a random point in a convex polygon. Adapted from Graphics Gems article.

Derives the distance between the specified points on the xz-plane. @param[in] v1 A point. [(x, y, z)] @param[in] v2 A point. [(x, y, z)] @return The

Derives the square of the scalar length of the vector. (len * len) @param[in] v The vector. [(x, y, z)] @return The square of the scalar length of th

Performs a scaled vector addition. (@p v1 + (@p v2 * @p s)) @param[out] dest The result vector. [(x, y, z)] @param[in] v1 The base vector. [(x, y, z

Selects the maximum value of each element from the specified vectors. @param[in,out] mx A vector. (Will be updated with the result.) [(x, y, z)] @par

Selects the minimum value of each element from the specified vectors. @param[in,out] mn A vector. (Will be updated with the result.) [(x, y, z)] @par

Normalizes the vector. @param[in,out] v The vector to normalize. [(x, y, z)]

Derives the xz-plane 2D perp product of the two vectors. (uz*vx - ux*vz) @param[in] u The LHV vector [(x, y, z)] @param[in] v The RHV vector [(x,

exp q = [sin(A) * v, cos(A)] where q = [Av, 0]. Only defined for pure-vector quaternions */

@par @note If the search box does not intersect any polygons the search will return #DT_SUCCESS, but @p nearestRef will be zero. So if in doubt, chec

@par If the end polygon cannot be reached through the navigation graph, the last polygon in the path will be the nearest the end polygon. If the pat

@par This method peforms what is often called 'string pulling'. The start position is clamped to the first polygon in the path, and the end position

Note that the result is always copied, making this inefficient for return values that are not VALUEs. */

Returns a pointer to the underlying row-major data. There is no padding at the end of the row. Be careful--this will be reallocated during a r

Given a real-space position, returns the cell coord containing it.*/

@param parentMask The mask that this node returned from culledBy. */

If a value that is EqualsFunc to @a member is present, returns a pointer to the version stored in the data structure, otherwise returns NULL.

@par Will return #DT_FAILURE if the provided position is outside the xz-bounds of the polygon.

Computes the inverse of this coordinate frame. */

Grows to include the bounds of a */

Optimized implementation of out = A * B. It is safe (but slow) to call with A, B, and out possibly pointer equal to one another.*/ This is a

Computes 1 / sqrt(x). */

Sets the include flags for the filter. @param[in] flags The new flags.