@par The output data array is allocated using the detour allocator (dtAlloc()). The method used to free the memory will be determined by how the til

memory management

@par @warning This function assumes that the header is in the correct endianess already. Call #dtNavMeshHeaderSwapEndian() first on the data if the d

/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

Returns true if specific detail is set.

Derives the cross product of two vectors. (@p v1 x @p v2) @param[out] dest The cross product. [(x, y, z)] @param[in] v1 A Vector [(x, y, z)] @param[

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

Helper function to consume the next character in the input buffer and peek at the one following (without consuming it). */

The elapsed cycle time between tick and tock. An attempt is made to factor out all tick/tock overhead, so that back-to-back calls should retu

Amount of time between the most recent tick and tock calls. 0 if tick has never been called. */

Derives a standard polygon reference. @note This function is generally meant for internal use only. @param[in] salt The tile's salt value. @param[in]

C++ STL style iterator method. Returns one after the last iterator element. */

C++ STL style iterator method. Returns one after the last iterator element. */

C++ STL style iterator method. Returns one after the last iterator element. */

pushBack */

Mutates the array of N control points that begins at \a A. It is useful to override this method by one that wraps the values if they are angles

Return the position at time s. The spline is defined outside of the time samples by extrapolation or cycling. */

\copydoc _exists */

2^x */

Returns a new Rect2D that is bigger/smaller by the specified amount (negative is shrink.) */

Distance from corner(0) to the next corner along the box's local axis a. */

Distance from corner(0) to the next corner along axis a. */

Returns a negative z-value. */

Clear without freeing the underlying array. */

Potentially less accurate but faster than direction(). Only works if System::hasSSE is true. */

Unsafe access to the underlying data structure with no wrapping support; requires that (x, y) is in bounds. */

Returns a normalized vector. May be computed with lower precision than unit */

0.3048 m */

/////////////////////////////////////////////////////////////////////////////////////

@par @p hitPos is not adjusted using the height detail data. @p hitDist will equal the search radius if there is no wall within the radius. In this

Returns the index of (the first occurance of) an index or -1 if not found. */

Finds the index of the first '\\' or '/' character, starting at index \a start (if \a start is -1, starts at the end of the string). \sa G3D::findSl

@par This method is optimized for a small search radius and small number of result polygons. Candidate polygons are found by searching the navigatio

Finds the next element, setting isDone if one can't be found. Looks at the current element first. */

@par At least one result array must be provided. The order of the result set is from least to highest cost to reach the polygon. A common use case

@par The order of the result set is from least to highest cost. At least one result array must be provided. A common use case for this method is to

Finds the index of the first '\\' or '/' character, starting at index \a start. \sa G3D::findLastSlash, G3D::isSlash */

Given a 16-bit integer, returns the integer with the bytes in the opposite order. */

Given a 32-bit integer, returns the integer with the bytes in the opposite order. */

\copydoc _fopen */

Frees the heap structures for the nodes. */

Creates a Ray from a origin and a (nonzero) unit direction. */

Creates a line from a point and a (nonzero) direction. */

* Constructs a line from two (not equal) points. */

Constructs a line from two (not equal) points. */

Returns true if the point is nearly in the plane. */

Note: two quats can represent the Quat::sameRotation and not be equal. */

(A<SUP>T</SUP>A)<SUP>-1</SUP>A<SUP>T</SUP>) computed using Gauss-Jordan elimination. */