From d5729c678b0dc6be70adca6d735dba4dbf90090f Mon Sep 17 00:00:00 2001
From: Cameron hart <cameron.hart@gmail.com>
Date: Fri, 6 May 2011 23:22:08 +0000
Subject: [PATCH] Changed header comments to use Doxygen format and added
 configuration Doxyfile.

---
 DebugUtils/Include/DebugDraw.h                |   40 +-
 Detour/Include/DetourAlloc.h                  |    4 +-
 Detour/Include/DetourNavMesh.h                |  352 ++--
 Detour/Include/DetourNavMeshBuilder.h         |  101 +-
 Detour/Include/DetourNavMeshQuery.h           |  415 ++--
 Detour/Include/DetourNode.h                   |   14 +-
 DetourCrowd/Include/DetourCrowd.h             |   18 +-
 DetourCrowd/Include/DetourLocalBoundary.h     |    6 +-
 DetourCrowd/Include/DetourObstacleAvoidance.h |   26 +-
 DetourCrowd/Include/DetourPathQueue.h         |    8 +-
 DetourTileCache/Include/DetourTileCache.h     |   32 +-
 .../Include/DetourTileCacheBuilder.h          |   26 +-
 Doxyfile                                      | 1699 +++++++++++++++++
 Recast/Include/Recast.h                       |  654 +++----
 Recast/Include/RecastAlloc.h                  |    8 +-
 RecastDemo/Include/ChunkyTriMesh.h            |    8 +-
 RecastDemo/Include/InputGeom.h                |   18 +-
 RecastDemo/Include/Sample.h                   |   16 +-
 RecastDemo/Include/SampleInterfaces.h         |   16 +-
 RecastDemo/Include/Sample_Debug.h             |    2 +-
 20 files changed, 2567 insertions(+), 896 deletions(-)
 create mode 100644 Doxyfile

diff --git a/DebugUtils/Include/DebugDraw.h b/DebugUtils/Include/DebugDraw.h
index 6bd0b62..b24094f 100644
--- a/DebugUtils/Include/DebugDraw.h
+++ b/DebugUtils/Include/DebugDraw.h
@@ -30,7 +30,7 @@ enum duDebugDrawPrimitives
 	DU_DRAW_QUADS,	
 };
 
-// Abstrace debug draw interface.
+/// Abstract debug draw interface.
 struct duDebugDraw
 {
 	virtual ~duDebugDraw() = 0;
@@ -39,38 +39,32 @@ struct duDebugDraw
 
 	virtual void texture(bool state) = 0;
 
-	// Begin drawing primitives.
-	// Params:
-	//  prim - (in) primitive type to draw, one of rcDebugDrawPrimitives.
-	//  nverts - (in) number of vertices to be submitted.
-	//  size - (in) size of a primitive, applies to point size and line width only.
+	/// Begin drawing primitives.
+	///  @param prim [in] primitive type to draw, one of rcDebugDrawPrimitives.
+	///  @param size [in] size of a primitive, applies to point size and line width only.
 	virtual void begin(duDebugDrawPrimitives prim, float size = 1.0f) = 0;
 
-	// Submit a vertex
-	// Params:
-	//  pos - (in) position of the verts.
-	//  color - (in) color of the verts.
+	/// Submit a vertex
+	///  @param pos [in] position of the verts.
+	///  @param color [in] color of the verts.
 	virtual void vertex(const float* pos, unsigned int color) = 0;
 
-	// Submit a vertex
-	// Params:
-	//  x,y,z - (in) position of the verts.
-	//  color - (in) color of the verts.
+	/// Submit a vertex
+	///  @param x,y,z [in] position of the verts.
+	///  @param color [in] color of the verts.
 	virtual void vertex(const float x, const float y, const float z, unsigned int color) = 0;
 
-	// Submit a vertex
-	// Params:
-	//  pos - (in) position of the verts.
-	//  color - (in) color of the verts.
+	/// Submit a vertex
+	///  @param pos [in] position of the verts.
+	///  @param color [in] color of the verts.
 	virtual void vertex(const float* pos, unsigned int color, const float* uv) = 0;
 	
-	// Submit a vertex
-	// Params:
-	//  x,y,z - (in) position of the verts.
-	//  color - (in) color of the verts.
+	/// Submit a vertex
+	///  @param x,y,z [in] position of the verts.
+	///  @param color [in] color of the verts.
 	virtual void vertex(const float x, const float y, const float z, unsigned int color, const float u, const float v) = 0;
 	
-	// End drawing primitives.
+	/// End drawing primitives.
 	virtual void end() = 0;
 };
 
diff --git a/Detour/Include/DetourAlloc.h b/Detour/Include/DetourAlloc.h
index 8693475..dc5c88e 100644
--- a/Detour/Include/DetourAlloc.h
+++ b/Detour/Include/DetourAlloc.h
@@ -21,8 +21,8 @@
 
 enum dtAllocHint
 {
-	DT_ALLOC_PERM,		// Memory persist after a function call.
-	DT_ALLOC_TEMP		// Memory used temporarily within a function.
+	DT_ALLOC_PERM,		///< Memory persist after a function call.
+	DT_ALLOC_TEMP		///< Memory used temporarily within a function.
 };
 
 typedef void* (dtAllocFunc)(int size, dtAllocHint hint);
diff --git a/Detour/Include/DetourNavMesh.h b/Detour/Include/DetourNavMesh.h
index 7179e0e..fd16754 100644
--- a/Detour/Include/DetourNavMesh.h
+++ b/Detour/Include/DetourNavMesh.h
@@ -26,19 +26,19 @@
 // Note: If you want to use 64-bit refs, change the types of both dtPolyRef & dtTileRef.
 // It is also recommended to change dtHashRef() to proper 64-bit hash too.
 
-// Reference to navigation polygon.
+/// Reference to navigation polygon.
 typedef unsigned int dtPolyRef;
 
-// Reference to navigation mesh tile.
+/// Reference to navigation mesh tile.
 typedef unsigned int dtTileRef;
 
-// Maximum number of vertices per navigation polygon.
+/// Maximum number of vertices per navigation polygon.
 static const int DT_VERTS_PER_POLYGON = 6;
 
-static const int DT_NAVMESH_MAGIC = 'D'<<24 | 'N'<<16 | 'A'<<8 | 'V'; //'DNAV';
+static const int DT_NAVMESH_MAGIC = 'D'<<24 | 'N'<<16 | 'A'<<8 | 'V'; ///< 'DNAV'
 static const int DT_NAVMESH_VERSION = 7;
 
-static const int DT_NAVMESH_STATE_MAGIC = 'D'<<24 | 'N'<<16 | 'M'<<8 | 'S'; //'DNMS';
+static const int DT_NAVMESH_STATE_MAGIC = 'D'<<24 | 'N'<<16 | 'M'<<8 | 'S'; ///< 'DNMS'
 static const int DT_NAVMESH_STATE_VERSION = 1;
 
 static const unsigned short DT_EXT_LINK = 0x8000;
@@ -47,127 +47,127 @@ static const unsigned int DT_OFFMESH_CON_BIDIR = 1;
 
 static const int DT_MAX_AREAS = 64;
 
-// Flags for addTile
+/// Flags for addTile
 enum dtTileFlags
 {
-	DT_TILE_FREE_DATA = 0x01,					// Navmesh owns the tile memory and should free it.
+	DT_TILE_FREE_DATA = 0x01,					///< Navmesh owns the tile memory and should free it.
 };
 
-// Flags returned by findStraightPath().
+/// Flags returned by findStraightPath().
 enum dtStraightPathFlags
 {
-	DT_STRAIGHTPATH_START = 0x01,				// The vertex is the start position.
-	DT_STRAIGHTPATH_END = 0x02,					// The vertex is the end position.
-	DT_STRAIGHTPATH_OFFMESH_CONNECTION = 0x04,	// The vertex is start of an off-mesh link.
+	DT_STRAIGHTPATH_START = 0x01,				///< The vertex is the start position.
+	DT_STRAIGHTPATH_END = 0x02,					///< The vertex is the end position.
+	DT_STRAIGHTPATH_OFFMESH_CONNECTION = 0x04,	///< The vertex is start of an off-mesh link.
 };
 
-// Flags describing polygon properties.
+/// Flags describing polygon properties.
 enum dtPolyTypes
 {
-	DT_POLYTYPE_GROUND = 0,						// Regular ground polygons.
-	DT_POLYTYPE_OFFMESH_CONNECTION = 1,			// Off-mesh connections.
+	DT_POLYTYPE_GROUND = 0,						///< Regular ground polygons.
+	DT_POLYTYPE_OFFMESH_CONNECTION = 1,			///< Off-mesh connections.
 };
 
 
-// Structure describing the navigation polygon data.
+/// Structure describing the navigation polygon data.
 struct dtPoly
 {
-	unsigned int firstLink;						// Index to first link in linked list. 
-	unsigned short verts[DT_VERTS_PER_POLYGON];	// Indices to vertices of the poly.
-	unsigned short neis[DT_VERTS_PER_POLYGON];	// Refs to neighbours of the poly.
-	unsigned short flags;						// Flags (see dtPolyFlags).
-	unsigned char vertCount;					// Number of vertices.
-	unsigned char areaAndtype;					// Bit packed: Area ID of the polygon, and Polygon type, see dtPolyTypes..
+	unsigned int firstLink;						///< Index to first link in linked list.
+	unsigned short verts[DT_VERTS_PER_POLYGON];	///< Indices to vertices of the poly.
+	unsigned short neis[DT_VERTS_PER_POLYGON];	///< Refs to neighbours of the poly.
+	unsigned short flags;						///< Flags (see dtPolyFlags).
+	unsigned char vertCount;					///< Number of vertices.
+	unsigned char areaAndtype;					///< Bit packed: Area ID of the polygon, and Polygon type, see dtPolyTypes..
 	inline void setArea(unsigned char a) { areaAndtype = (areaAndtype & 0xc0) | (a & 0x3f); }
 	inline void setType(unsigned char t) { areaAndtype = (areaAndtype & 0x3f) | (t << 6); }
 	inline unsigned char getArea() const { return areaAndtype & 0x3f; }
 	inline unsigned char getType() const { return areaAndtype >> 6; }
 };
 
-// Stucture describing polygon detail triangles.
+/// Stucture describing polygon detail triangles.
 struct dtPolyDetail
 {
-	unsigned int vertBase;						// Offset to detail vertex array.
-	unsigned int triBase;						// Offset to detail triangle array.
-	unsigned char vertCount;					// Number of vertices in the detail mesh.
-	unsigned char triCount;						// Number of triangles.
+	unsigned int vertBase;						///< Offset to detail vertex array.
+	unsigned int triBase;						///< Offset to detail triangle array.
+	unsigned char vertCount;					///< Number of vertices in the detail mesh.
+	unsigned char triCount;						///< Number of triangles.
 };
 
-// Stucture describing a link to another polygon.
+/// Stucture describing a link to another polygon.
 struct dtLink
 {
-	dtPolyRef ref;							// Neighbour reference.
-	unsigned int next;						// Index to next link.
-	unsigned char edge;						// Index to polygon edge which owns this link. 
-	unsigned char side;						// If boundary link, defines on which side the link is.
-	unsigned char bmin, bmax;				// If boundary link, defines the sub edge area.
+	dtPolyRef ref;							///< Neighbour reference.
+	unsigned int next;						///< Index to next link.
+	unsigned char edge;						///< Index to polygon edge which owns this link.
+	unsigned char side;						///< If boundary link, defines on which side the link is.
+	unsigned char bmin, bmax;				///< If boundary link, defines the sub edge area.
 };
 
 struct dtBVNode
 {
-	unsigned short bmin[3], bmax[3];		// BVnode bounds
-	int i;									// Index to item or if negative, escape index.
+	unsigned short bmin[3], bmax[3];		///< BVnode bounds
+	int i;									///< Index to item or if negative, escape index.
 };
 
 struct dtOffMeshConnection
 {
-	float pos[6];							// Both end point locations.
-	float rad;								// Link connection radius.
-	unsigned short poly;					// Poly Id
-	unsigned char flags;					// Link flags
-	unsigned char side;						// End point side.
-	unsigned int userId;					// User ID to identify this connection.
+	float pos[6];							///< Both end point locations.
+	float rad;								///< Link connection radius.
+	unsigned short poly;					///< Poly Id
+	unsigned char flags;					///< Link flags
+	unsigned char side;						///< End point side.
+	unsigned int userId;					///< User ID to identify this connection.
 };
 
 struct dtMeshHeader
 {
-	int magic;								// Magic number, used to identify the data.
-	int version;							// Data version number.
-	int x, y, layer;						// Location of the tile on the grid.
-	unsigned int userId;					// User ID of the tile.
-	int polyCount;							// Number of polygons in the tile.
-	int vertCount;							// Number of vertices in the tile.
-	int maxLinkCount;						// Number of allocated links.
-	int detailMeshCount;					// Number of detail meshes.
-	int detailVertCount;					// Number of detail vertices.
-	int detailTriCount;						// Number of detail triangles.
-	int bvNodeCount;						// Number of BVtree nodes.
-	int offMeshConCount;					// Number of Off-Mesh links.
-	int offMeshBase;						// Index to first polygon which is Off-Mesh link.
-	float walkableHeight;					// Height of the agent.
-	float walkableRadius;					// Radius of the agent
-	float walkableClimb;					// Max climb height of the agent.
-	float bmin[3], bmax[3];					// Bounding box of the tile.
-	float bvQuantFactor;					// BVtree quantization factor (world to bvnode coords)
+	int magic;								///< Magic number, used to identify the data.
+	int version;							///< Data version number.
+	int x, y, layer;						///< Location of the tile on the grid.
+	unsigned int userId;					///< User ID of the tile.
+	int polyCount;							///< Number of polygons in the tile.
+	int vertCount;							///< Number of vertices in the tile.
+	int maxLinkCount;						///< Number of allocated links.
+	int detailMeshCount;					///< Number of detail meshes.
+	int detailVertCount;					///< Number of detail vertices.
+	int detailTriCount;						///< Number of detail triangles.
+	int bvNodeCount;						///< Number of BVtree nodes.
+	int offMeshConCount;					///< Number of Off-Mesh links.
+	int offMeshBase;						///< Index to first polygon which is Off-Mesh link.
+	float walkableHeight;					///< Height of the agent.
+	float walkableRadius;					///< Radius of the agent
+	float walkableClimb;					///< Max climb height of the agent.
+	float bmin[3], bmax[3];					///< Bounding box of the tile.
+	float bvQuantFactor;					///< BVtree quantization factor (world to bvnode coords)
 };
 
 struct dtMeshTile
 {
-	unsigned int salt;						// Counter describing modifications to the tile.
+	unsigned int salt;						///< Counter describing modifications to the tile.
 
-	unsigned int linksFreeList;				// Index to next free link.
-	dtMeshHeader* header;					// Pointer to tile header.
-	dtPoly* polys;							// Pointer to the polygons (will be updated when tile is added).
-	float* verts;							// Pointer to the vertices (will be updated when tile added).
-	dtLink* links;							// Pointer to the links (will be updated when tile added).
-	dtPolyDetail* detailMeshes;				// Pointer to detail meshes (will be updated when tile added).
-	float* detailVerts;						// Pointer to detail vertices (will be updated when tile added).
-	unsigned char* detailTris;				// Pointer to detail triangles (will be updated when tile added).
-	dtBVNode* bvTree;						// Pointer to BVtree nodes (will be updated when tile added).
-	dtOffMeshConnection* offMeshCons;		// Pointer to Off-Mesh links. (will be updated when tile added).
+	unsigned int linksFreeList;				///< Index to next free link.
+	dtMeshHeader* header;					///< Pointer to tile header.
+	dtPoly* polys;							///< Pointer to the polygons (will be updated when tile is added).
+	float* verts;							///< Pointer to the vertices (will be updated when tile added).
+	dtLink* links;							///< Pointer to the links (will be updated when tile added).
+	dtPolyDetail* detailMeshes;				///< Pointer to detail meshes (will be updated when tile added).
+	float* detailVerts;						///< Pointer to detail vertices (will be updated when tile added).
+	unsigned char* detailTris;				///< Pointer to detail triangles (will be updated when tile added).
+	dtBVNode* bvTree;						///< Pointer to BVtree nodes (will be updated when tile added).
+	dtOffMeshConnection* offMeshCons;		///< Pointer to Off-Mesh links. (will be updated when tile added).
 		
-	unsigned char* data;					// Pointer to tile data.
-	int dataSize;							// Size of the tile data.
-	int flags;								// Tile flags, see dtTileFlags.
-	dtMeshTile* next;						// Next free tile or, next tile in spatial grid.
+	unsigned char* data;					///< Pointer to tile data.
+	int dataSize;							///< Size of the tile data.
+	int flags;								///< Tile flags, see dtTileFlags.
+	dtMeshTile* next;						///< Next free tile or, next tile in spatial grid.
 };
 
 struct dtNavMeshParams
 {
-	float orig[3];					// Origin of the nav mesh tile space.
-	float tileWidth, tileHeight;	// Width and height of each tile.
-	int maxTiles;					// Maximum number of tiles the navmesh can contain.
-	int maxPolys;					// Maximum number of polygons each tile can contain.
+	float orig[3];					///< Origin of the nav mesh tile space.
+	float tileWidth, tileHeight;	///< Width and height of each tile.
+	int maxTiles;					///< Maximum number of tiles the navmesh can contain.
+	int maxPolys;					///< Maximum number of polygons each tile can contain.
 };
 
 
@@ -177,142 +177,132 @@ public:
 	dtNavMesh();
 	~dtNavMesh();
 
-	// Initializes the nav mesh for tiled use.
-	// Params:
-	//  params - (in) navmesh initialization params, see dtNavMeshParams.
-	// Returns: True if succeed, else false.
+	/// Initializes the nav mesh for tiled use.
+	///  @param params [in] navmesh initialization params, see dtNavMeshParams.
+	/// @return True if succeed, else false.
 	dtStatus init(const dtNavMeshParams* params);
 
-	// Initializes the nav mesh for single tile use.
-	// Params:
-	//  data - (in) Data of the new tile mesh.
-	//  dataSize - (in) Data size of the new tile mesh.
-	//	flags - (in) Tile flags, see dtTileFlags.
-	// Returns: True if succeed, else false.
+	/// Initializes the nav mesh for single tile use.
+	///  @param data - [in] Data of the new tile mesh.
+	///  @param dataSize - [in] Data size of the new tile mesh.
+	///  @param flags - [in] Tile flags, see dtTileFlags.
+	/// @return True if succeed, else false.
 	dtStatus init(unsigned char* data, const int dataSize, const int flags);
 	
-	// Returns pointer to navmesh initialization params.
+	/// Returns pointer to navmesh initialization params.
 	const dtNavMeshParams* getParams() const;
 	
-	// Adds new tile into the navmesh.
-	// The add will fail if the data is in wrong format,
-	// there is not enough tiles left, or if there is a tile already at the location.
-	// Params:
-	//  data - (in) Data of the new tile mesh.
-	//  dataSize - (in) Data size of the new tile mesh.
-	//	flags - (in) Tile flags, see dtTileFlags.
-	//  lastRef - (in,optional) Last tile ref, the tile will be restored so that
-	//            the reference (as well as poly references) will be the same. Default: 0.
-	//  result - (out,optional) tile ref if the tile was succesfully added.
+	/// Adds new tile into the navmesh.
+	/// The add will fail if the data is in wrong format,
+	/// there is not enough tiles left, or if there is a tile already at the location.
+	///  @param data [in] Data of the new tile mesh.
+	///  @param dataSize [in] Data size of the new tile mesh.
+	///	@param flags [in] Tile flags, see dtTileFlags.
+	///  @param lastRef [in,optional] Last tile ref, the tile will be restored so that
+	///            the reference (as well as poly references) will be the same. Default: 0.
+	///  @param result [out,optional] tile ref if the tile was succesfully added.
 	dtStatus addTile(unsigned char* data, int dataSize, int flags, dtTileRef lastRef, dtTileRef* result);
 	
-	// Removes specified tile.
-	// Params:
-	//  ref - (in) Reference to the tile to remove.
-	//  data - (out) Data associated with deleted tile.
-	//  dataSize - (out) Size of the data associated with deleted tile. 
+	/// Removes specified tile.
+	///  @param ref [in] Reference to the tile to remove.
+	///  @param data [out] Data associated with deleted tile.
+	///  @param dataSize [out] Size of the data associated with deleted tile.
 	dtStatus removeTile(dtTileRef ref, unsigned char** data, int* dataSize);
 
-	// Calculates tile location based in input world position.
-	// Params:
-	//  pos - (in) world position of the query.
-	//  tx - (out) tile x location.
-	//  ty - (out) tile y location.
+	/// Calculates tile location based in input world position.
+	///  @param pos [in] world position of the query.
+	///  @param tx [out] tile x location.
+	///  @param ty [out] tile y location.
 	void calcTileLoc(const float* pos, int* tx, int* ty) const;
 
-	// Returns pointer to tile at specified location.
-	// Params:
-	//  x,y - (in) Location of the tile to get.
-	// Returns: pointer to tile if tile exists or 0 tile does not exists.
+	/// Returns pointer to tile at specified location.
+	///  @param x,y [in] Location of the tile to get.
+	///  @returns pointer to tile if tile exists or 0 tile does not exists.
 	const dtMeshTile* getTileAt(const int x, const int y, const int layer) const;
 
 	int getTilesAt(const int x, const int y,
 				   dtMeshTile const** tiles, const int maxTiles) const;
 	
-	// Returns reference to tile at specified location.
-	// Params:
-	//  x,y - (in) Location of the tile to get.
-	// Returns: reference to tile if tile exists or 0 tile does not exists.
+	/// Returns reference to tile at specified location.
+	///  @param x,y [in] Location of the tile to get.
+	///  @returns reference to tile if tile exists or 0 tile does not exists.
 	dtTileRef getTileRefAt(int x, int y, int layer) const;
 
-	// Returns tile references of a tile based on tile pointer.
+	/// Returns tile references of a tile based on tile pointer.
 	dtTileRef getTileRef(const dtMeshTile* tile) const;
 
-	// Returns tile based on references.
+	/// Returns tile based on references.
 	const dtMeshTile* getTileByRef(dtTileRef ref) const;
 	
-	// Returns max number of tiles.
+	/// Returns max number of tiles.
 	int getMaxTiles() const;
 	
-	// Returns pointer to tile in the tile array.
-	// Params:
-	//  i - (in) Index to the tile to retrieve, max index is getMaxTiles()-1.
-	// Returns: Pointer to specified tile.
+	/// Returns pointer to tile in the tile array.
+	///  @param i [in] Index to the tile to retrieve, max index is getMaxTiles()-1.
+	///  @returns Pointer to specified tile.
 	const dtMeshTile* getTile(int i) const;
 
-	// Returns pointer to tile and polygon pointed by the polygon reference.
-	// Params:
-	//  ref - (in) reference to a polygon.
-	//  tile - (out) pointer to the tile containing the polygon.
-	//  poly - (out) pointer to the polygon.
+	/// Returns pointer to tile and polygon pointed by the polygon reference.
+	///  @param ref [in] reference to a polygon.
+	///  @param tile [out] pointer to the tile containing the polygon.
+	///  @param poly [out] pointer to the polygon.
 	dtStatus getTileAndPolyByRef(const dtPolyRef ref, const dtMeshTile** tile, const dtPoly** poly) const;
 	
-	// Returns pointer to tile and polygon pointed by the polygon reference.
-	// Note: this function does not check if 'ref' s valid, and is thus faster. Use only with valid refs!
-	// Params:
-	//  ref - (in) reference to a polygon.
-	//  tile - (out) pointer to the tile containing the polygon.
-	//  poly - (out) pointer to the polygon.
+	/// Returns pointer to tile and polygon pointed by the polygon reference.
+	/// Note: this function does not check if 'ref' s valid, and is thus faster. Use only with valid refs!
+	///
+	///  @param ref [in] reference to a polygon.
+	///  @param tile [out] pointer to the tile containing the polygon.
+	///  @param poly [out] pointer to the polygon.
 	void getTileAndPolyByRefUnsafe(const dtPolyRef ref, const dtMeshTile** tile, const dtPoly** poly) const;
 
-	// Returns true if polygon reference points to valid data.
+	/// Returns true if polygon reference points to valid data.
 	bool isValidPolyRef(dtPolyRef ref) const;
 	
-	// Returns base poly id for specified tile, polygon refs can be deducted from this.
+	/// Returns base poly id for specified tile, polygon refs can be deducted from this.
 	dtPolyRef getPolyRefBase(const dtMeshTile* tile) const;
 	
-	// Returns start and end location of an off-mesh link polygon.
-	// Params:
-	//	prevRef - (in) ref to the polygon before the link (used to select direction).
-	//	polyRef - (in) ref to the off-mesh link polygon.
-	//	startPos[3] - (out) start point of the link.
-	//	endPos[3] - (out) end point of the link.
-	// Returns: true if link is found.
+	/// Returns start and end location of an off-mesh link polygon.
+	///  @param prevRef [in] ref to the polygon before the link (used to select direction).
+	///  @param polyRef [in] ref to the off-mesh link polygon.
+	///  @param startPos[3] [out] start point of the link.
+	///  @param endPos[3] [out] end point of the link.
+	///  @returns true if link is found.
 	dtStatus getOffMeshConnectionPolyEndPoints(dtPolyRef prevRef, dtPolyRef polyRef, float* startPos, float* endPos) const;
 
-	// Returns pointer to off-mesh connection based on polyref, or null if ref not valid.
+	/// Returns pointer to off-mesh connection based on polyref, or null if ref not valid.
 	const dtOffMeshConnection* getOffMeshConnectionByRef(dtPolyRef ref) const;
 	
-	// Sets polygon flags.
+	/// Sets polygon flags.
 	dtStatus setPolyFlags(dtPolyRef ref, unsigned short flags);
 
-	// Return polygon flags.
+	/// Return polygon flags.
 	dtStatus getPolyFlags(dtPolyRef ref, unsigned short* resultFlags) const;
 
-	// Set polygon type.
+	/// Set polygon type.
 	dtStatus setPolyArea(dtPolyRef ref, unsigned char area);
 
-	// Return polygon area type.
+	/// Return polygon area type.
 	dtStatus getPolyArea(dtPolyRef ref, unsigned char* resultArea) const;
 
 
-	// Returns number of bytes required to store tile state.
+	/// Returns number of bytes required to store tile state.
 	int getTileStateSize(const dtMeshTile* tile) const;
 	
-	// Stores tile state to buffer.
+	/// Stores tile state to buffer.
 	dtStatus storeTileState(const dtMeshTile* tile, unsigned char* data, const int maxDataSize) const;
 	
-	// Restores tile state.
+	/// Restores tile state.
 	dtStatus restoreTileState(dtMeshTile* tile, const unsigned char* data, const int maxDataSize);
 	
 
-	// Encodes a tile id.
+	/// Encodes a tile id.
 	inline dtPolyRef encodePolyId(unsigned int salt, unsigned int it, unsigned int ip) const
 	{
 		return ((dtPolyRef)salt << (m_polyBits+m_tileBits)) | ((dtPolyRef)it << m_polyBits) | (dtPolyRef)ip;
 	}
 	
-	// Decodes a tile id.
+	/// Decodes a tile id.
 	inline void decodePolyId(dtPolyRef ref, unsigned int& salt, unsigned int& it, unsigned int& ip) const
 	{
 		const dtPolyRef saltMask = ((dtPolyRef)1<<m_saltBits)-1;
@@ -323,21 +313,21 @@ public:
 		ip = (unsigned int)(ref & polyMask);
 	}
 
-	// Decodes a tile salt.
+	/// Decodes a tile salt.
 	inline unsigned int decodePolyIdSalt(dtPolyRef ref) const
 	{
 		const dtPolyRef saltMask = ((dtPolyRef)1<<m_saltBits)-1;
 		return (unsigned int)((ref >> (m_polyBits+m_tileBits)) & saltMask);
 	}
 	
-	// Decodes a tile id.
+	/// Decodes a tile id.
 	inline unsigned int decodePolyIdTile(dtPolyRef ref) const
 	{
 		const dtPolyRef tileMask = ((dtPolyRef)1<<m_tileBits)-1;
 		return (unsigned int)((ref >> m_polyBits) & tileMask);
 	}
 	
-	// Decodes a poly id.
+	/// Decodes a poly id.
 	inline unsigned int decodePolyIdPoly(dtPolyRef ref) const
 	{
 		const dtPolyRef polyMask = ((dtPolyRef)1<<m_polyBits)-1;
@@ -346,65 +336,65 @@ public:
 	
 private:
 
-	// Returns pointer to tile in the tile array.
+	/// Returns pointer to tile in the tile array.
 	dtMeshTile* getTile(int i);
 
-	// Returns neighbour tile based on side. 
+	/// Returns neighbour tile based on side.
 	int getTilesAt(const int x, const int y,
 				   dtMeshTile** tiles, const int maxTiles) const;
 
-	// Returns neighbour tile based on side. 
+	/// Returns neighbour tile based on side.
 	int getNeighbourTilesAt(const int x, const int y, const int side,
 							dtMeshTile** tiles, const int maxTiles) const;
 	
-	// Returns all polygons in neighbour tile based on portal defined by the segment.
+	/// Returns all polygons in neighbour tile based on portal defined by the segment.
 	int findConnectingPolys(const float* va, const float* vb,
 							const dtMeshTile* tile, int side,
 							dtPolyRef* con, float* conarea, int maxcon) const;
 	
-	// Builds internal polygons links for a tile.
+	/// Builds internal polygons links for a tile.
 	void connectIntLinks(dtMeshTile* tile);
-	// Builds internal polygons links for a tile.
+	/// Builds internal polygons links for a tile.
 	void connectIntOffMeshLinks(dtMeshTile* tile);
 
-	// Builds external polygon links for a tile.
+	/// Builds external polygon links for a tile.
 	void connectExtLinks(dtMeshTile* tile, dtMeshTile* target, int side);
-	// Builds external polygon links for a tile.
+	/// Builds external polygon links for a tile.
 	void connectExtOffMeshLinks(dtMeshTile* tile, dtMeshTile* target, int side);
 	
-	// Removes external links at specified side.
+	/// Removes external links at specified side.
 	void unconnectExtLinks(dtMeshTile* tile, dtMeshTile* target);
 	
 
 	// TODO: These methods are duplicates from dtNavMeshQuery, but are needed for off-mesh connection finding.
 	
-	// Queries polygons within a tile.
+	/// Queries polygons within a tile.
 	int queryPolygonsInTile(const dtMeshTile* tile, const float* qmin, const float* qmax,
 							dtPolyRef* polys, const int maxPolys) const;
-	// Find nearest polygon within a tile.
+	/// Find nearest polygon within a tile.
 	dtPolyRef findNearestPolyInTile(const dtMeshTile* tile, const float* center,
 									const float* extents, float* nearestPt) const;
-	// Returns closest point on polygon.
+	/// Returns closest point on polygon.
 	void closestPointOnPolyInTile(const dtMeshTile* tile, unsigned int ip,
 								  const float* pos, float* closest) const;
 	
-	dtNavMeshParams m_params;			// Current initialization params. TODO: do not store this info twice.
-	float m_orig[3];					// Origin of the tile (0,0)
-	float m_tileWidth, m_tileHeight;	// Dimensions of each tile.
-	int m_maxTiles;						// Max number of tiles.
-	int m_tileLutSize;					// Tile hash lookup size (must be pot).
-	int m_tileLutMask;					// Tile hash lookup mask.
+	dtNavMeshParams m_params;			///< Current initialization params. TODO: do not store this info twice.
+	float m_orig[3];					///< Origin of the tile (0,0)
+	float m_tileWidth, m_tileHeight;	///< Dimensions of each tile.
+	int m_maxTiles;						///< Max number of tiles.
+	int m_tileLutSize;					///< Tile hash lookup size (must be pot).
+	int m_tileLutMask;					///< Tile hash lookup mask.
 
-	dtMeshTile** m_posLookup;			// Tile hash lookup.
-	dtMeshTile* m_nextFree;				// Freelist of tiles.
-	dtMeshTile* m_tiles;				// List of tiles.
+	dtMeshTile** m_posLookup;			///< Tile hash lookup.
+	dtMeshTile* m_nextFree;				///< Freelist of tiles.
+	dtMeshTile* m_tiles;				///< List of tiles.
 		
-	unsigned int m_saltBits;			// Number of salt bits in the tile ID.
-	unsigned int m_tileBits;			// Number of tile bits in the tile ID.
-	unsigned int m_polyBits;			// Number of poly bits in the tile ID.
+	unsigned int m_saltBits;			///< Number of salt bits in the tile ID.
+	unsigned int m_tileBits;			///< Number of tile bits in the tile ID.
+	unsigned int m_polyBits;			///< Number of poly bits in the tile ID.
 };
 
-// Helper function to allocate navmesh class using Detour allocator.
+/// Helper function to allocate navmesh class using Detour allocator.
 dtNavMesh* dtAllocNavMesh();
 void dtFreeNavMesh(dtNavMesh* navmesh);
 
diff --git a/Detour/Include/DetourNavMeshBuilder.h b/Detour/Include/DetourNavMeshBuilder.h
index e3ad25e..fdb96ec 100644
--- a/Detour/Include/DetourNavMeshBuilder.h
+++ b/Detour/Include/DetourNavMeshBuilder.h
@@ -22,56 +22,73 @@
 #include "DetourAlloc.h"
 
 
-// The units of the parameters are specified in parenthesis as follows:
-// (vx) voxels, (wu) world units
+/// The units of the parameters are specified in parenthesis as follows:
+/// (vx) voxels, (wu) world units
 struct dtNavMeshCreateParams
 {
-	// Navmesh vertices.
-	const unsigned short* verts;			// Array of vertices, each vertex has 3 components. (vx).
-	int vertCount;							// Vertex count
-	// Navmesh polygons
-	const unsigned short* polys;			// Array of polygons, uses same format as rcPolyMesh. 
-	const unsigned short* polyFlags;		// Array of flags per polygon.
-	const unsigned char* polyAreas;			// Array of area ids per polygon.
-	int polyCount;							// Number of polygons
-	int nvp;								// Number of verts per polygon.
-	// Navmesh Detail (optional)
-	const unsigned int* detailMeshes;		// Detail meshes, uses same format as rcPolyMeshDetail.
-	const float* detailVerts;				// Detail mesh vertices, uses same format as rcPolyMeshDetail (wu).
-	int detailVertsCount;					// Total number of detail vertices
-	const unsigned char* detailTris;		// Array of detail tris per detail mesh.
-	int detailTriCount;						// Total number of detail triangles.
-	// Off-Mesh Connections.
-	const float* offMeshConVerts;			// Off-mesh connection vertices (wu).
-	const float* offMeshConRad;				// Off-mesh connection radii (wu).
-	const unsigned short* offMeshConFlags;	// Off-mesh connection flags.
-	const unsigned char* offMeshConAreas;	// Off-mesh connection area ids.
-	const unsigned char* offMeshConDir;		// Off-mesh connection direction flags (1 = bidir, 0 = oneway).
-	const unsigned int* offMeshConUserID;	// Off-mesh connection user id (optional).
-	int offMeshConCount;					// Number of off-mesh connections
-	// Tile location
-	unsigned int userId;					// User ID bound to the tile.
-	int tileX, tileY, tileLayer;			// Tile location (tile coords).
-	float bmin[3], bmax[3];					// Tile bounds (wu).
-	// Settings
-	float walkableHeight;					// Agent height (wu).
-	float walkableRadius;					// Agent radius (wu).
-	float walkableClimb;					// Agent max climb (wu).
-	float cs;								// Cell size (xz) (wu).
-	float ch;								// Cell height (y) (wu).
-	bool buildBvTree;						// Flag indicating if BVTree for polygon query should be build.
+	/// @name Navmesh vertices.
+	///@{
+	const unsigned short* verts;			///< Array of vertices, each vertex has 3 components. (vx).
+	int vertCount;							///< Vertex count
+	///@{
+
+	/// @name Navmesh polygons
+	///@{
+	const unsigned short* polys;			///< Array of polygons, uses same format as rcPolyMesh.
+	const unsigned short* polyFlags;		///< Array of flags per polygon.
+	const unsigned char* polyAreas;			///< Array of area ids per polygon.
+	int polyCount;							///< Number of polygons
+	int nvp;								///< Number of verts per polygon.
+	///@}
+
+	/// @name Navmesh Detail (optional)
+	///@{
+	const unsigned int* detailMeshes;		///< Detail meshes, uses same format as rcPolyMeshDetail.
+	const float* detailVerts;				///< Detail mesh vertices, uses same format as rcPolyMeshDetail (wu).
+	int detailVertsCount;					///< Total number of detail vertices
+	const unsigned char* detailTris;		///< Array of detail tris per detail mesh.
+	int detailTriCount;						///< Total number of detail triangles.
+	///@}
+
+	/// @name Off-Mesh Connections.
+	///@{
+	const float* offMeshConVerts;			///< Off-mesh connection vertices (wu).
+	const float* offMeshConRad;				///< Off-mesh connection radii (wu).
+	const unsigned short* offMeshConFlags;	///< Off-mesh connection flags.
+	const unsigned char* offMeshConAreas;	///< Off-mesh connection area ids.
+	const unsigned char* offMeshConDir;		///< Off-mesh connection direction flags (1 = bidir, 0 = oneway).
+	const unsigned int* offMeshConUserID;	///< Off-mesh connection user id (optional).
+	int offMeshConCount;					///< Number of off-mesh connections
+	///@}
+
+	/// @name Tile location
+	///@{
+	unsigned int userId;					///< User ID bound to the tile.
+	int tileX, tileY, tileLayer;			///< Tile location (tile coords).
+	float bmin[3], bmax[3];					///< Tile bounds (wu).
+	///@}
+
+	/// @name Settings
+	///@{
+	float walkableHeight;					///< Agent height (wu).
+	float walkableRadius;					///< Agent radius (wu).
+	float walkableClimb;					///< Agent max climb (wu).
+	float cs;								///< Cell size (xz) (wu).
+	float ch;								///< Cell height (y) (wu).
+	bool buildBvTree;						///< Flag indicating if BVTree for polygon query should be build.
+	///@}
 };
 
-// Build navmesh data from given input data.
+/// Build navmesh data from given input data.
 bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData, int* outDataSize);
 
-// Swaps endianess of navmesh header.
+/// Swaps endianess of navmesh header.
 bool dtNavMeshHeaderSwapEndian(unsigned char* data, const int dataSize);
 
-// Swaps endianess of the navmesh data. This function assumes that the header is in correct
-// endianess already. Call dtNavMeshHeaderSwapEndian() first on the data if the data is
-// assumed to be in wrong endianess to start with. If converting from native endianess to foreign,
-// call dtNavMeshHeaderSwapEndian() after the data has been swapped.
+/// Swaps endianess of the navmesh data. This function assumes that the header is in correct
+/// endianess already. Call dtNavMeshHeaderSwapEndian() first on the data if the data is
+/// assumed to be in wrong endianess to start with. If converting from native endianess to foreign,
+/// call dtNavMeshHeaderSwapEndian() after the data has been swapped.
 bool dtNavMeshDataSwapEndian(unsigned char* data, const int dataSize);
 
 #endif // DETOURNAVMESHBUILDER_H
diff --git a/Detour/Include/DetourNavMeshQuery.h b/Detour/Include/DetourNavMeshQuery.h
index c3cfe8a..f876b10 100644
--- a/Detour/Include/DetourNavMeshQuery.h
+++ b/Detour/Include/DetourNavMeshQuery.h
@@ -30,30 +30,29 @@
 
 //#define DT_VIRTUAL_QUERYFILTER 1
 
-// Class for polygon filtering and cost calculation during query operations.
-// - It is possible to derive a custom query filter from dtQueryFilter by overriding
-//   the virtual functions passFilter() and getCost().
-// - Both functions should be as fast as possible. Use cached local copy of data
-//   instead of accessing your own objects where possible.
-// - You do not need to adhere to the flags and cost logic provided by the default
-//   implementation.
-// - In order for the A* to work properly, the cost should be proportional to
-//   the travel distance. Using cost modifier less than 1.0 is likely to lead
-//   to problems during pathfinding.
+/// Class for polygon filtering and cost calculation during query operations.
+/// - It is possible to derive a custom query filter from dtQueryFilter by overriding
+///   the virtual functions passFilter() and getCost().
+/// - Both functions should be as fast as possible. Use cached local copy of data
+///   instead of accessing your own objects where possible.
+/// - You do not need to adhere to the flags and cost logic provided by the default
+///   implementation.
+/// - In order for the A* to work properly, the cost should be proportional to
+///   the travel distance. Using cost modifier less than 1.0 is likely to lead
+///   to problems during pathfinding.
 class dtQueryFilter
 {
-	float m_areaCost[DT_MAX_AREAS];		// Array storing cost per area type, used by default implementation.
-	unsigned short m_includeFlags;		// Include poly flags, used by default implementation.
-	unsigned short m_excludeFlags;		// Exclude poly flags, used by default implementation.
+	float m_areaCost[DT_MAX_AREAS];		///< Array storing cost per area type, used by default implementation.
+	unsigned short m_includeFlags;		///< Include poly flags, used by default implementation.
+	unsigned short m_excludeFlags;		///< Exclude poly flags, used by default implementation.
 	
 public:
 	dtQueryFilter();
 	
-	// Returns true if the polygon is can visited.
-	// Params:
-	//  ref - (in) reference to the polygon test.
-	//  tile - (in) pointer to the tile of the polygon test.
-	//  poly - (in) pointer to the polygon test.
+	/// Returns true if the polygon is can visited.
+	///  @param ref [in] reference to the polygon test.
+	///  @param tile [in] pointer to the tile of the polygon test.
+	///  @param poly [in] pointer to the polygon test.
 #ifdef DT_VIRTUAL_QUERYFILTER
 	virtual bool passFilter(const dtPolyRef ref,
 							const dtMeshTile* tile,
@@ -64,16 +63,15 @@ public:
 					const dtPoly* poly) const;
 #endif
 
-	// Returns cost to travel from 'pa' to 'pb'.'
-	// The segment is fully contained inside 'cur'.
-	// 'pa' lies on the edge between 'prev' and 'cur', 
-	// 'pb' lies on the edge between 'cur' and 'next'.
-	// Params:
-	//  pa - (in) segment start position.
-	//  pb - (in) segment end position.
-	//  prevRef, prevTile, prevPoly - (in) data describing the previous polygon, can be null.
-	//  curRef, curTile, curPoly - (in) data describing the current polygon.
-	//  nextRef, nextTile, nextPoly - (in) data describing the next polygon, can be null.
+	/// Returns cost to travel from 'pa' to 'pb'.'
+	/// The segment is fully contained inside 'cur'.
+	/// 'pa' lies on the edge between 'prev' and 'cur',
+	/// 'pb' lies on the edge between 'cur' and 'next'.
+	///  @param pa [in] segment start position.
+	///  @param pb [in] segment end position.
+	///  @param prevRef, prevTile, prevPoly [in] data describing the previous polygon, can be null.
+	///  @param curRef, curTile, curPoly [in] data describing the current polygon.
+	///  @param nextRef, nextTile, nextPoly [in] data describing the next polygon, can be null.
 #ifdef DT_VIRTUAL_QUERYFILTER
 	virtual float getCost(const float* pa, const float* pb,
 						  const dtPolyRef prevRef, const dtMeshTile* prevTile, const dtPoly* prevPoly,
@@ -86,7 +84,8 @@ public:
 				  const dtPolyRef nextRef, const dtMeshTile* nextTile, const dtPoly* nextPoly) const;
 #endif
 	
-	// Getters and setters for the default implementation data.
+	/// @name Getters and setters for the default implementation data.
+	///@{
 	inline float getAreaCost(const int i) const { return m_areaCost[i]; }
 	inline void setAreaCost(const int i, const float cost) { m_areaCost[i] = cost; } 
 
@@ -95,6 +94,7 @@ public:
 
 	inline unsigned short getExcludeFlags() const { return m_excludeFlags; }
 	inline void setExcludeFlags(const unsigned short flags) { m_excludeFlags = flags; }	
+	///@}
 };
 
 class dtNavMeshQuery
@@ -103,249 +103,232 @@ public:
 	dtNavMeshQuery();
 	~dtNavMeshQuery();
 	
-	// Initializes the nav mesh query.
-	// Params:
-	//  nav - (in) pointer to navigation mesh data.
-	//  maxNodes - (in) Maximum number of search nodes to use (max 65536).
+	/// Initializes the nav mesh query.
+	///  @param nav [in] pointer to navigation mesh data.
+	///  @param maxNodes [in] Maximum number of search nodes to use (max 65536).
 	dtStatus init(const dtNavMesh* nav, const int maxNodes);
 	
-	// Finds the nearest navigation polygon around the center location.
-	// Params:
-	//	center[3] - (in) The center of the search box.
-	//	extents[3] - (in) The extents of the search box.
-	//  filter - (in) path polygon filter.
-	//  nearestRef - (out) Reference to the nearest polygon.
-	//  nearestPt[3] - (out, opt) The nearest point on found polygon, null if not needed.
+	/// Finds the nearest navigation polygon around the center location.
+	///  @param center[3] [in] The center of the search box.
+	///  @param extents[3] [in] The extents of the search box.
+	///  @param filter [in] path polygon filter.
+	///  @param nearestRef [out] Reference to the nearest polygon.
+	///  @param nearestPt[3] [out, opt] The nearest point on found polygon, null if not needed.
 	dtStatus findNearestPoly(const float* center, const float* extents,
 							 const dtQueryFilter* filter,
 							 dtPolyRef* nearestRef, float* nearestPt) const;
 	
-	// Returns polygons which overlap the query box.
-	// Params:
-	//	center[3] - (in) the center of the search box.
-	//	extents[3] - (in) the extents of the search box.
-	//  filter - (in) path polygon filter.
-	//	polys - (out) array holding the search result.
-	//  polyCount - (out) Number of polygons in search result array.
-	//	maxPolys - (in) The max number of polygons the polys array can hold.
+	/// Returns polygons which overlap the query box.
+	///  @param center[3] [in] the center of the search box.
+	///  @param extents[3] [in] the extents of the search box.
+	///  @param filter [in] path polygon filter.
+	///  @param polys [out] array holding the search result.
+	///  @param polyCount [out] Number of polygons in search result array.
+	///  @param maxPolys [in] The max number of polygons the polys array can hold.
 	dtStatus queryPolygons(const float* center, const float* extents,
 						   const dtQueryFilter* filter,
 						   dtPolyRef* polys, int* polyCount, const int maxPolys) const;
 	
-	// Finds path from start polygon to end polygon.
-	// If target polygon canno be reached through the navigation graph,
-	// the last node on the array is nearest node to the end polygon.
-	// Start end end positions are needed to calculate more accurate
-	// traversal cost at start end end polygons.
-	// Params:
-	//	startRef - (in) ref to path start polygon.
-	//	endRef - (in) ref to path end polygon.
-	//	startPos[3] - (in) Path start location.
-	//	endPos[3] - (in) Path end location.
-	//  filter - (in) path polygon filter.
-	//	path - (out) array holding the search result.
-	//  pathCount - (out) Number of polygons in search result array.
-	//	maxPath - (in) The max number of polygons the path array can hold. Must be at least 1.
+	/// Finds path from start polygon to end polygon.
+	/// If target polygon canno be reached through the navigation graph,
+	/// the last node on the array is nearest node to the end polygon.
+	/// Start end end positions are needed to calculate more accurate
+	/// traversal cost at start end end polygons.
+	///  @param startRef [in] ref to path start polygon.
+	///  @param endRef [in] ref to path end polygon.
+	///  @param startPos[3] [in] Path start location.
+	///  @param endPos[3] [in] Path end location.
+	///  @param filter [in] path polygon filter.
+	///  @param path [out] array holding the search result.
+	///  @param pathCount [out] Number of polygons in search result array.
+	///  @param maxPath [in] The max number of polygons the path array can hold. Must be at least 1.
 	dtStatus findPath(dtPolyRef startRef, dtPolyRef endRef,
 					  const float* startPos, const float* endPos,
 					  const dtQueryFilter* filter,
 					  dtPolyRef* path, int* pathCount, const int maxPath) const;
 	
-	// Intializes sliced path find query.
-	// Note 1: calling any other dtNavMeshQuery method before calling findPathEnd()
-	// may results in corrupted data!
-	// Note 2: The pointer to filter is store, and used in subsequent
-	// calls to updateSlicedFindPath().
-	// Params:
-	//	startRef - (in) ref to path start polygon.
-	//	endRef - (in) ref to path end polygon.
-	//	startPos[3] - (in) Path start location.
-	//	endPos[3] - (in) Path end location.
-	//  filter - (in) path polygon filter.
+	/// Intializes sliced path find query.
+	/// Note 1: calling any other dtNavMeshQuery method before calling findPathEnd()
+	/// may results in corrupted data!
+	/// Note 2: The pointer to filter is store, and used in subsequent
+	/// calls to updateSlicedFindPath().
+	///  @param startRef [in] ref to path start polygon.
+	///  @param endRef [in] ref to path end polygon.
+	///  @param startPos[3] [in] Path start location.
+	///  @param endPos[3] [in] Path end location.
+	///  @param filter [in] path polygon filter.
 	dtStatus initSlicedFindPath(dtPolyRef startRef, dtPolyRef endRef,
 								const float* startPos, const float* endPos,
 								const dtQueryFilter* filter);
 
-	// Updates sliced path find query.
-	// Params:
-	//  maxIter - (in) Max number of iterations to update.
-	//  doneIters - (out,opt) Number of iterations done during the update.
-	// Returns: Path query state.
+	/// Updates sliced path find query.
+	///  @param maxIter [in] Max number of iterations to update.
+	///  @param doneIters [out,opt] Number of iterations done during the update.
+	/// Returns: Path query state.
 	dtStatus updateSlicedFindPath(const int maxIter, int* doneIters);
 
-	// Finalizes sliced path find query and returns found path.
-	//	path - (out) array holding the search result.
-	//  pathCount - (out) Number of polygons in search result array.
-	//	maxPath - (in) The max number of polygons the path array can hold.
+	/// Finalizes sliced path find query and returns found path.
+	///  @param path [out] array holding the search result.
+	///  @param pathCount [out] Number of polygons in search result array.
+	///  @param maxPath [in] The max number of polygons the path array can hold.
 	dtStatus finalizeSlicedFindPath(dtPolyRef* path, int* pathCount, const int maxPath);
 	
-	// Finalizes partial sliced path find query and returns path to the furthest
-	// polygon on the existing path that was visited during the search.
-	//	existing - (out) Array of polygons in the existing path.
-	//  existingSize - (out) Number of polygons in existing path array.
-	//	path - (out) array holding the search result.
-	//  pathCount - (out) Number of polygons in search result array.
-	//	maxPath - (in) The max number of polygons the path array can hold.
+	/// Finalizes partial sliced path find query and returns path to the furthest
+	/// polygon on the existing path that was visited during the search.
+	///  @param existing [out] Array of polygons in the existing path.
+	///  @param existingSize [out] Number of polygons in existing path array.
+	///  @param path [out] array holding the search result.
+	///  @param pathCount [out] Number of polygons in search result array.
+	///  @param maxPath [in] The max number of polygons the path array can hold.
 	dtStatus finalizeSlicedFindPathPartial(const dtPolyRef* existing, const int existingSize,
 										   dtPolyRef* path, int* pathCount, const int maxPath);
 	
-	// Finds a straight path from start to end locations within the corridor
-	// described by the path polygons.
-	// Start and end locations will be clamped on the corridor.
-	// The returned polygon references are point to polygon which was entered when
-	// a path point was added. For the end point, zero will be returned. This allows
-	// to match for example off-mesh link points to their representative polygons.
-	// Params:
-	//	startPos[3] - (in) Path start location.
-	//	endPo[3] - (in) Path end location.
-	//	path - (in) Array of connected polygons describing the corridor.
-	//	pathSize - (in) Number of polygons in path array.
-	//	straightPath - (out) Points describing the straight path.
-	//  straightPathFlags - (out, opt) Flags describing each point type, see dtStraightPathFlags.
-	//  straightPathRefs - (out, opt) References to polygons at point locations.
-	//  straightPathCount - (out) Number of points in the path.
-	//	maxStraightPath - (in) The max number of points the straight path array can hold. Must be at least 1.
+	/// Finds a straight path from start to end locations within the corridor
+	/// described by the path polygons.
+	/// Start and end locations will be clamped on the corridor.
+	/// The returned polygon references are point to polygon which was entered when
+	/// a path point was added. For the end point, zero will be returned. This allows
+	/// to match for example off-mesh link points to their representative polygons.
+	///  @param startPos[3] [in] Path start location.
+	///  @param endPos[3] [in] Path end location.
+	///  @param path [in] Array of connected polygons describing the corridor.
+	///  @param pathSize [in] Number of polygons in path array.
+	///  @param straightPath [out] Points describing the straight path.
+	///  @param straightPathFlags [out, opt] Flags describing each point type, see dtStraightPathFlags.
+	///  @param straightPathRefs [out, opt] References to polygons at point locations.
+	///  @param straightPathCount [out] Number of points in the path.
+	///  @param maxStraightPath [in] The max number of points the straight path array can hold. Must be at least 1.
 	dtStatus findStraightPath(const float* startPos, const float* endPos,
 							  const dtPolyRef* path, const int pathSize,
 							  float* straightPath, unsigned char* straightPathFlags, dtPolyRef* straightPathRefs,
 							  int* straightPathCount, const int maxStraightPath) const;
 	
-	// Moves from startPos to endPos constrained to the navmesh.
-	// If the endPos is reachable, the resultPos will be endPos,
-	// or else the resultPos will be the nearest point in navmesh.
-	// Note: The resulting point is not projected to the ground, use getPolyHeight() to get height.
-	// Note: The algorithm is optimized for small delta movement and small number of polygons. 
-	// Params:
-	//  startRef - (in) ref to the polygon where startPos lies.
-	//  startPos[3] - (in) start position of the mover.
-	//  endPos[3] - (in) desired end position of the mover.
-	//  filter - (in) path polygon filter.
-	//  resultPos[3] - (out) new position of the mover.
-	//  visited - (out) array of visited polygons.
-	//  visitedCount - (out) Number of entries in the visited array.
-	//  maxVisitedSize - (in) max number of polygons in the visited array.
+	/// Moves from startPos to endPos constrained to the navmesh.
+	/// If the endPos is reachable, the resultPos will be endPos,
+	/// or else the resultPos will be the nearest point in navmesh.
+	/// Note: The resulting point is not projected to the ground, use getPolyHeight() to get height.
+	/// Note: The algorithm is optimized for small delta movement and small number of polygons.
+	///  @param startRef [in] ref to the polygon where startPos lies.
+	///  @param startPos[3] [in] start position of the mover.
+	///  @param endPos[3] [in] desired end position of the mover.
+	///  @param filter [in] path polygon filter.
+	///  @param resultPos[3] [out] new position of the mover.
+	///  @param visited [out] array of visited polygons.
+	///  @param visitedCount [out] Number of entries in the visited array.
+	///  @param maxVisitedSize [in] max number of polygons in the visited array.
 	dtStatus moveAlongSurface(dtPolyRef startRef, const float* startPos, const float* endPos,
 							  const dtQueryFilter* filter,
 							  float* resultPos, dtPolyRef* visited, int* visitedCount, const int maxVisitedSize) const;
 	
-	// Casts 'walkability' ray along the navmesh surface from startPos towards the endPos.
-	// Params:
-	//	startRef - (in) ref to the polygon where the start lies.
-	//	startPos[3] - (in) start position of the query.
-	//	endPos[3] - (in) end position of the query.
-	//	t - (out) hit parameter along the segment, FLT_MAX if no hit.
-	//	hitNormal[3] - (out) normal of the nearest hit.
-	//  filter - (in) path polygon filter.
-	//  path - (out,opt) visited path polygons.
-	//  pathCount - (out,opt) Number of polygons visited.
-	//  maxPath - (in) max number of polygons in the path array.
+	/// Casts 'walkability' ray along the navmesh surface from startPos towards the endPos.
+	///  @param startRef [in] ref to the polygon where the start lies.
+	///  @param startPos[3] [in] start position of the query.
+	///  @param endPos[3] [in] end position of the query.
+	///  @param t [out] hit parameter along the segment, FLT_MAX if no hit.
+	///  @param hitNormal[3] [out] normal of the nearest hit.
+	///  @param filter [in] path polygon filter.
+	///  @param path [out,opt] visited path polygons.
+	///  @param pathCount [out,opt] Number of polygons visited.
+	///  @param maxPath [in] max number of polygons in the path array.
 	dtStatus raycast(dtPolyRef startRef, const float* startPos, const float* endPos,
 					 const dtQueryFilter* filter,
 					 float* t, float* hitNormal, dtPolyRef* path, int* pathCount, const int maxPath) const;
 	
-	// Returns distance to nearest wall from the specified location.
-	// Params:
-	//	startRef - (in) ref to the polygon where the center lies.
-	//	centerPos[3] - (in) center if the query circle.
-	//	maxRadius - (in) max search radius.
-	//  filter - (in) path polygon filter.
-	//  hitDist - (out) distance to nearest wall from the test location.
-	//	hitPos[3] - (out) location of the nearest hit.
-	//	hitNormal[3] - (out) normal of the nearest hit.
+	/// Returns distance to nearest wall from the specified location.
+	///  @param startRef [in] ref to the polygon where the center lies.
+	///  @param centerPos[3] [in] center if the query circle.
+	///  @param maxRadius [in] max search radius.
+	///  @param filter [in] path polygon filter.
+	///  @param hitDist [out] distance to nearest wall from the test location.
+	///  @param hitPos[3] [out] location of the nearest hit.
+	///  @param hitNormal[3] [out] normal of the nearest hit.
 	dtStatus findDistanceToWall(dtPolyRef startRef, const float* centerPos, const float maxRadius,
 								const dtQueryFilter* filter,
 								float* hitDist, float* hitPos, float* hitNormal) const;
 	
-	// Finds polygons found along the navigation graph which touch the specified circle.
-	// Params:
-	//	startRef - (in) ref to the polygon where the search starts.
-	//	centerPos[3] - (in) center if the query circle.
-	//	radius - (in) radius of the query circle.
-	//  filter - (in) path polygon filter.
-	//	resultRef - (out, opt) refs to the polygons touched by the circle.
-	//	resultParent - (out, opt) parent of each result polygon.
-	//	resultCost - (out, opt) search cost at each result polygon.
-	//  resultCount - (out, opt) Number of results.
-	//	maxResult - (int) maximum capacity of search results.
+	/// Finds polygons found along the navigation graph which touch the specified circle.
+	///  @param startRef [in] ref to the polygon where the search starts.
+	///  @param centerPos[3] [in] center if the query circle.
+	///  @param radius [in] radius of the query circle.
+	///  @param filter [in] path polygon filter.
+	///  @param resultRef [out, opt] refs to the polygons touched by the circle.
+	///  @param resultParent [out, opt] parent of each result polygon.
+	///  @param resultCost [out, opt] search cost at each result polygon.
+	///  @param resultCount [out, opt] Number of results.
+	///  @param maxResult [int] maximum capacity of search results.
 	dtStatus findPolysAroundCircle(dtPolyRef startRef, const float* centerPos, const float radius,
 								   const dtQueryFilter* filter,
 								   dtPolyRef* resultRef, dtPolyRef* resultParent, float* resultCost,
 								   int* resultCount, const int maxResult) const;
 	
-	// Finds polygons found along the navigation graph which touch the convex polygon shape.
-	// Params:
-	//	startRef - (in) ref to the polygon where the search starts.
-	//	verts[3*n] - (in) vertices describing convex polygon shape (CCW).
-	//	nverts - (in) number of vertices in the polygon.
-	//  filter - (in) path polygon filter.
-	//	resultRef - (out, opt) refs to the polygons touched by the circle.
-	//	resultParent - (out, opt) parent of each result polygon.
-	//	resultCost - (out, opt) search cost at each result polygon.
-	//  resultCount - (out) number of results.
-	//	maxResult - (int) maximum capacity of search results.
+	/// Finds polygons found along the navigation graph which touch the convex polygon shape.
+	///  @param startRef [in] ref to the polygon where the search starts.
+	///  @param verts[3*n] [in] vertices describing convex polygon shape (CCW).
+	///  @param nverts [in] number of vertices in the polygon.
+	///  @param filter [in] path polygon filter.
+	///  @param resultRef [out, opt] refs to the polygons touched by the circle.
+	///  @param resultParent [out, opt] parent of each result polygon.
+	///  @param resultCost [out, opt] search cost at each result polygon.
+	///  @param resultCount [out] number of results.
+	///  @param maxResult [int] maximum capacity of search results.
 	dtStatus findPolysAroundShape(dtPolyRef startRef, const float* verts, const int nverts,
 								  const dtQueryFilter* filter,
 								  dtPolyRef* resultRef, dtPolyRef* resultParent, float* resultCost,
 								  int* resultCount, const int maxResult) const;
 	
-	// Finds non-overlapping local neighbourhood around center location.
-	// Note: The algorithm is optimized for small query radius and small number of polygons. 
-	// Params:
-	//	startRef - (in) ref to the polygon where the search starts.
-	//	centerPos[3] - (in) center if the query circle.
-	//	radius - (in) radius of the query circle.
-	//  filter - (in) path polygon filter.
-	//	resultRef - (out) refs to the polygons touched by the circle.
-	//	resultParent - (out, opt) parent of each result polygon.
-	//  resultCount - (out) number of results.
-	//	maxResult - (int) maximum capacity of search results.
+	/// Finds non-overlapping local neighbourhood around center location.
+	/// Note: The algorithm is optimized for small query radius and small number of polygons.
+	///  @param startRef [in] ref to the polygon where the search starts.
+	///  @param centerPos[3] [in] center if the query circle.
+	///  @param radius [in] radius of the query circle.
+	///  @param filter [in] path polygon filter.
+	///  @param resultRef [out] refs to the polygons touched by the circle.
+	///  @param resultParent [out, opt] parent of each result polygon.
+	///  @param resultCount [out] number of results.
+	///  @param maxResult [int] maximum capacity of search results.
 	dtStatus findLocalNeighbourhood(dtPolyRef startRef, const float* centerPos, const float radius,
 									const dtQueryFilter* filter,
 									dtPolyRef* resultRef, dtPolyRef* resultParent,
 									int* resultCount, const int maxResult) const;
 	
-	// Returns wall segments of specified polygon.
-	// If 'segmentRefs' is specified, both the wall and portal segments are returned.
-	// Wall segments will have null (0) polyref, and portal segments store the polygon they lead to.
-	// Params:
-	//  ref - (in) ref to the polygon.
-	//  filter - (in) path polygon filter.
-	//  segmentVerts[6*maxSegments] - (out) wall segments (2 endpoints per segment).
-	//  segmentRefs[maxSegments] - (out,opt) reference to a neighbour.
-	//  segmentCount - (out) number of wall segments.
-	//  maxSegments - (in) max number of segments that can be stored in 'segments'.
+	/// Returns wall segments of specified polygon.
+	/// If 'segmentRefs' is specified, both the wall and portal segments are returned.
+	/// Wall segments will have null (0) polyref, and portal segments store the polygon they lead to.
+	///  @param ref [in] ref to the polygon.
+	///  @param filter [in] path polygon filter.
+	///  @param segmentVerts[6*maxSegments] [out] wall segments (2 endpoints per segment).
+	///  @param segmentRefs[maxSegments] [out,opt] reference to a neighbour.
+	///  @param segmentCount [out] number of wall segments.
+	///  @param maxSegments [in] max number of segments that can be stored in 'segments'.
 	dtStatus getPolyWallSegments(dtPolyRef ref, const dtQueryFilter* filter,
 								 float* segmentVerts, dtPolyRef* segmentRefs, int* segmentCount,
 								 const int maxSegments) const;
 	
-	// Returns closest point on navigation polygon.
-	// Uses detail polygons to find the closest point to the navigation polygon surface. 
-	// Params:
-	//	ref - (in) ref to the polygon.
-	//	pos[3] - (in) the point to check.
-	//	closest[3] - (out) closest point.
-	// Returns: true if closest point found.
+	/// Returns closest point on navigation polygon.
+	/// Uses detail polygons to find the closest point to the navigation polygon surface.
+	///  @param ref [in] ref to the polygon.
+	///  @param pos[3] [in] the point to check.
+	///  @param closest[3] [out] closest point.
+	///  @returns true if closest point found.
 	dtStatus closestPointOnPoly(dtPolyRef ref, const float* pos, float* closest) const;
 	
-	// Returns closest point on navigation polygon boundary.
-	// Uses the navigation polygon boundary to snap the point to poly boundary
-	// if it is outside the polygon. Much faster than closestPointToPoly. Does not affect height.
-	// Params:
-	//	ref - (in) ref to the polygon.
-	//	pos[3] - (in) the point to check.
-	//	closest[3] - (out) closest point.
-	// Returns: true if closest point found.
+	/// Returns closest point on navigation polygon boundary.
+	/// Uses the navigation polygon boundary to snap the point to poly boundary
+	/// if it is outside the polygon. Much faster than closestPointToPoly. Does not affect height.
+	///  @param ref [in] ref to the polygon.
+	///  @param pos[3] [in] the point to check.
+	///  @param closest[3] [out] closest point.
+	///  @returns true if closest point found.
 	dtStatus closestPointOnPolyBoundary(dtPolyRef ref, const float* pos, float* closest) const;
 	
-	// Returns height of the polygon at specified location.
-	// Params:
-	//	ref - (in) ref to the polygon.
-	//	pos[3] - (in) the point where to locate the height.
-	//	height - (out) height at the location.
-	// Returns: true if over polygon.
+	/// Returns height of the polygon at specified location.
+	///  @param ref [in] ref to the polygon.
+	///  @param pos[3] [in] the point where to locate the height.
+	///  @param height [out] height at the location.
+	///  @returns true if over polygon.
 	dtStatus getPolyHeight(dtPolyRef ref, const float* pos, float* height) const;
 		
-	// Returns true if poly reference ins in closed list.
+	/// Returns true if poly reference ins in closed list.
 	bool isInClosedList(dtPolyRef ref) const;
 	
 	class dtNodePool* getNodePool() const { return m_nodePool; }
@@ -354,32 +337,32 @@ public:
 	
 private:
 	
-	// Returns neighbour tile based on side. 
+	/// Returns neighbour tile based on side.
 	dtMeshTile* getNeighbourTileAt(int x, int y, int side) const;
 
-	// Queries polygons within a tile.
+	/// Queries polygons within a tile.
 	int queryPolygonsInTile(const dtMeshTile* tile, const float* qmin, const float* qmax, const dtQueryFilter* filter,
 							dtPolyRef* polys, const int maxPolys) const;
-	// Find nearest polygon within a tile.
+	/// Find nearest polygon within a tile.
 	dtPolyRef findNearestPolyInTile(const dtMeshTile* tile, const float* center, const float* extents,
 									const dtQueryFilter* filter, float* nearestPt) const;
-	// Returns closest point on polygon.
+	/// Returns closest point on polygon.
 	void closestPointOnPolyInTile(const dtMeshTile* tile, const dtPoly* poly, const float* pos, float* closest) const;
 	
-	// Returns portal points between two polygons.
+	/// Returns portal points between two polygons.
 	dtStatus getPortalPoints(dtPolyRef from, dtPolyRef to, float* left, float* right,
 							 unsigned char& fromType, unsigned char& toType) const;
 	dtStatus getPortalPoints(dtPolyRef from, const dtPoly* fromPoly, const dtMeshTile* fromTile,
 							 dtPolyRef to, const dtPoly* toPoly, const dtMeshTile* toTile,
 							 float* left, float* right) const;
 	
-	// Returns edge mid point between two polygons.
+	/// Returns edge mid point between two polygons.
 	dtStatus getEdgeMidPoint(dtPolyRef from, dtPolyRef to, float* mid) const;
 	dtStatus getEdgeMidPoint(dtPolyRef from, const dtPoly* fromPoly, const dtMeshTile* fromTile,
 							 dtPolyRef to, const dtPoly* toPoly, const dtMeshTile* toTile,
 							 float* mid) const;
 	
-	const dtNavMesh* m_nav;				// Pointer to navmesh data.
+	const dtNavMesh* m_nav;				///< Pointer to navmesh data.
 
 	struct dtQueryData
 	{
@@ -390,14 +373,14 @@ private:
 		float startPos[3], endPos[3];
 		const dtQueryFilter* filter;
 	};
-	dtQueryData m_query;				// Sliced query state.
+	dtQueryData m_query;				///< Sliced query state.
 
-	class dtNodePool* m_tinyNodePool;	// Pointer to small node pool.
-	class dtNodePool* m_nodePool;		// Pointer to node pool.
-	class dtNodeQueue* m_openList;		// Pointer to open list queue.
+	class dtNodePool* m_tinyNodePool;	///< Pointer to small node pool.
+	class dtNodePool* m_nodePool;		///< Pointer to node pool.
+	class dtNodeQueue* m_openList;		///< Pointer to open list queue.
 };
 
-// Helper function to allocate navmesh query class using Detour allocator.
+/// Helper function to allocate navmesh query class using Detour allocator.
 dtNavMeshQuery* dtAllocNavMeshQuery();
 void dtFreeNavMeshQuery(dtNavMeshQuery* query);
 
diff --git a/Detour/Include/DetourNode.h b/Detour/Include/DetourNode.h
index e6aa6b9..b68c922 100644
--- a/Detour/Include/DetourNode.h
+++ b/Detour/Include/DetourNode.h
@@ -32,12 +32,12 @@ static const dtNodeIndex DT_NULL_IDX = (dtNodeIndex)~0;
 
 struct dtNode
 {
-	float pos[3];				// Position of the node.
-	float cost;					// Cost from previous node to current node.
-	float total;				// Cost up to the node.
-	unsigned int pidx : 30;		// Index to parent node.
-	unsigned int flags : 2;		// Node flags 0/open/closed.
-	dtPolyRef id;				// Polygon ref the node corresponds to.
+	float pos[3];				///< Position of the node.
+	float cost;					///< Cost from previous node to current node.
+	float total;				///< Cost up to the node.
+	unsigned int pidx : 30;		///< Index to parent node.
+	unsigned int flags : 2;		///< Node flags 0/open/closed.
+	dtPolyRef id;				///< Polygon ref the node corresponds to.
 };
 
 
@@ -156,4 +156,4 @@ private:
 };		
 
 
-#endif // DETOURNODE_H
\ No newline at end of file
+#endif // DETOURNODE_H
diff --git a/DetourCrowd/Include/DetourCrowd.h b/DetourCrowd/Include/DetourCrowd.h
index 3d5d998..ec4c02c 100644
--- a/DetourCrowd/Include/DetourCrowd.h
+++ b/DetourCrowd/Include/DetourCrowd.h
@@ -149,14 +149,14 @@ class dtCrowd
 
 	struct MoveRequest
 	{
-		unsigned char state;			// State of the request
-		int idx;						// Agent index
-		dtPolyRef ref;					// Goal ref
-		float pos[3];					// Goal position
-		dtPathQueueRef pathqRef;		// Path find query ref
-		dtPolyRef aref;					// Goal adjustment ref
-		float apos[3];					// Goal adjustment pos
-		dtPolyRef temp[MAX_TEMP_PATH];	// Adjusted path to the goal
+		unsigned char state;			///< State of the request
+		int idx;						///< Agent index
+		dtPolyRef ref;					///< Goal ref
+		float pos[3];					///< Goal position
+		dtPathQueueRef pathqRef;		///< Path find query ref
+		dtPolyRef aref;					///< Goal adjustment ref
+		float apos[3];					///< Goal adjustment pos
+		dtPolyRef temp[MAX_TEMP_PATH];	///< Adjusted path to the goal
 		int ntemp;
 	};
 	MoveRequest* m_moveRequests;
@@ -204,4 +204,4 @@ public:
 };
 
 
-#endif // CROWDMANAGER_H
\ No newline at end of file
+#endif // CROWDMANAGER_H
diff --git a/DetourCrowd/Include/DetourLocalBoundary.h b/DetourCrowd/Include/DetourLocalBoundary.h
index 149659e..d307803 100644
--- a/DetourCrowd/Include/DetourLocalBoundary.h
+++ b/DetourCrowd/Include/DetourLocalBoundary.h
@@ -28,8 +28,8 @@ class dtLocalBoundary
 	
 	struct Segment
 	{
-		float s[6];	// Segment start/end
-		float d;	// Distance for pruning.
+		float s[6];	///< Segment start/end
+		float d;	///< Distance for pruning.
 	};
 	
 	float m_center[3];
@@ -52,4 +52,4 @@ public:
 	inline const float* getSegment(int i) const { return m_segs[i].s; }
 };
 
-#endif // DETOURLOCALBOUNDARY_H
\ No newline at end of file
+#endif // DETOURLOCALBOUNDARY_H
diff --git a/DetourCrowd/Include/DetourObstacleAvoidance.h b/DetourCrowd/Include/DetourObstacleAvoidance.h
index 13dbe72..8ff6211 100644
--- a/DetourCrowd/Include/DetourObstacleAvoidance.h
+++ b/DetourCrowd/Include/DetourObstacleAvoidance.h
@@ -21,16 +21,16 @@
 
 struct dtObstacleCircle
 {
-	float p[3];				// Position of the obstacle
-	float vel[3];			// Velocity of the obstacle
-	float dvel[3];			// Velocity of the obstacle
-	float rad;				// Radius of the obstacle
-	float dp[3], np[3];		// Use for side selection during sampling.
+	float p[3];				///< Position of the obstacle
+	float vel[3];			///< Velocity of the obstacle
+	float dvel[3];			///< Velocity of the obstacle
+	float rad;				///< Radius of the obstacle
+	float dp[3], np[3];		///< Use for side selection during sampling.
 };
 
 struct dtObstacleSegment
 {
-	float p[3], q[3];		// End points of the obstacle segment
+	float p[3], q[3];		///< End points of the obstacle segment
 	bool touch;
 };
 
@@ -73,8 +73,8 @@ dtObstacleAvoidanceDebugData* dtAllocObstacleAvoidanceDebugData();
 void dtFreeObstacleAvoidanceDebugData(dtObstacleAvoidanceDebugData* ptr);
 
 
-static const int DT_MAX_PATTERN_DIVS = 32;	// Max numver of adaptive divs.
-static const int DT_MAX_PATTERN_RINGS = 4;	// Max number of adaptive rings.
+static const int DT_MAX_PATTERN_DIVS = 32;	///< Max numver of adaptive divs.
+static const int DT_MAX_PATTERN_RINGS = 4;	///< Max number of adaptive rings.
 
 struct dtObstacleAvoidanceParams
 {
@@ -84,10 +84,10 @@ struct dtObstacleAvoidanceParams
 	float weightSide;
 	float weightToi;
 	float horizTime;
-	unsigned char gridSize;	// grid
-	unsigned char adaptiveDivs;	// adaptive
-	unsigned char adaptiveRings;	// adaptive
-	unsigned char adaptiveDepth;	// adaptive
+	unsigned char gridSize;	///< grid
+	unsigned char adaptiveDivs;	///< adaptive
+	unsigned char adaptiveRings;	///< adaptive
+	unsigned char adaptiveDepth;	///< adaptive
 };
 
 class dtObstacleAvoidanceQuery
@@ -151,4 +151,4 @@ dtObstacleAvoidanceQuery* dtAllocObstacleAvoidanceQuery();
 void dtFreeObstacleAvoidanceQuery(dtObstacleAvoidanceQuery* ptr);
 
 
-#endif // DETOUROBSTACLEAVOIDANCE_H
\ No newline at end of file
+#endif // DETOUROBSTACLEAVOIDANCE_H
diff --git a/DetourCrowd/Include/DetourPathQueue.h b/DetourCrowd/Include/DetourPathQueue.h
index cc144cb..fe3920b 100644
--- a/DetourCrowd/Include/DetourPathQueue.h
+++ b/DetourCrowd/Include/DetourPathQueue.h
@@ -31,16 +31,16 @@ class dtPathQueue
 	struct PathQuery
 	{
 		dtPathQueueRef ref;
-		// Path find start and end location.
+		/// Path find start and end location.
 		float startPos[3], endPos[3];
 		dtPolyRef startRef, endRef;
-		// Result.
+		/// Result.
 		dtPolyRef* path;
 		int npath;
-		// State.
+		/// State.
 		dtStatus status;
 		int keepAlive;
-		const dtQueryFilter* filter; // TODO: This is potentially dangerous!
+		const dtQueryFilter* filter; ///< TODO: This is potentially dangerous!
 	};
 	
 	static const int MAX_QUEUE = 8;
diff --git a/DetourTileCache/Include/DetourTileCache.h b/DetourTileCache/Include/DetourTileCache.h
index 1b67da9..2d46e15 100644
--- a/DetourTileCache/Include/DetourTileCache.h
+++ b/DetourTileCache/Include/DetourTileCache.h
@@ -9,15 +9,15 @@ typedef unsigned int dtObstacleRef;
 
 typedef unsigned int dtCompressedTileRef;
 
-// Flags for addTile
+/// Flags for addTile
 enum dtCompressedTileFlags
 {
-	DT_COMPRESSEDTILE_FREE_DATA = 0x01,					// Navmesh owns the tile memory and should free it.
+	DT_COMPRESSEDTILE_FREE_DATA = 0x01,					///< Navmesh owns the tile memory and should free it.
 };
 
 struct dtCompressedTile
 {
-	unsigned int salt;						// Counter describing modifications to the tile.
+	unsigned int salt;						///< Counter describing modifications to the tile.
 	struct dtTileCacheLayerHeader* header;
 	unsigned char* compressed;
 	int compressedSize;
@@ -108,40 +108,40 @@ public:
 	void getObstacleBounds(const struct dtTileCacheObstacle* ob, float* bmin, float* bmax) const;
 	
 
-	// Encodes a tile id.
+	/// Encodes a tile id.
 	inline dtCompressedTileRef encodeTileId(unsigned int salt, unsigned int it) const
 	{
 		return ((dtCompressedTileRef)salt << m_tileBits) | (dtCompressedTileRef)it;
 	}
 	
-	// Decodes a tile salt.
+	/// Decodes a tile salt.
 	inline unsigned int decodeTileIdSalt(dtCompressedTileRef ref) const
 	{
 		const dtCompressedTileRef saltMask = ((dtCompressedTileRef)1<<m_saltBits)-1;
 		return (unsigned int)((ref >> m_tileBits) & saltMask);
 	}
 	
-	// Decodes a tile id.
+	/// Decodes a tile id.
 	inline unsigned int decodeTileIdTile(dtCompressedTileRef ref) const
 	{
 		const dtCompressedTileRef tileMask = ((dtCompressedTileRef)1<<m_tileBits)-1;
 		return (unsigned int)(ref & tileMask);
 	}
 
-	// Encodes an obstacle id.
+	/// Encodes an obstacle id.
 	inline dtObstacleRef encodeObstacleId(unsigned int salt, unsigned int it) const
 	{
 		return ((dtObstacleRef)salt << 16) | (dtObstacleRef)it;
 	}
 	
-	// Decodes an obstacle salt.
+	/// Decodes an obstacle salt.
 	inline unsigned int decodeObstacleIdSalt(dtObstacleRef ref) const
 	{
 		const dtObstacleRef saltMask = ((dtObstacleRef)1<<16)-1;
 		return (unsigned int)((ref >> 16) & saltMask);
 	}
 	
-	// Decodes an obstacle id.
+	/// Decodes an obstacle id.
 	inline unsigned int decodeObstacleIdObstacle(dtObstacleRef ref) const
 	{
 		const dtObstacleRef tileMask = ((dtObstacleRef)1<<16)-1;
@@ -163,15 +163,15 @@ private:
 		dtObstacleRef ref;
 	};
 	
-	int m_tileLutSize;						// Tile hash lookup size (must be pot).
-	int m_tileLutMask;						// Tile hash lookup mask.
+	int m_tileLutSize;						///< Tile hash lookup size (must be pot).
+	int m_tileLutMask;						///< Tile hash lookup mask.
 	
-	dtCompressedTile** m_posLookup;			// Tile hash lookup.
-	dtCompressedTile* m_nextFreeTile;		// Freelist of tiles.
-	dtCompressedTile* m_tiles;				// List of tiles.
+	dtCompressedTile** m_posLookup;			///< Tile hash lookup.
+	dtCompressedTile* m_nextFreeTile;		///< Freelist of tiles.
+	dtCompressedTile* m_tiles;				///< List of tiles.
 	
-	unsigned int m_saltBits;				// Number of salt bits in the tile ID.
-	unsigned int m_tileBits;				// Number of tile bits in the tile ID.
+	unsigned int m_saltBits;				///< Number of salt bits in the tile ID.
+	unsigned int m_tileBits;				///< Number of tile bits in the tile ID.
 	
 	dtTileCacheParams m_params;
 	
diff --git a/DetourTileCache/Include/DetourTileCacheBuilder.h b/DetourTileCache/Include/DetourTileCacheBuilder.h
index 332fb94..edeccdf 100644
--- a/DetourTileCache/Include/DetourTileCacheBuilder.h
+++ b/DetourTileCache/Include/DetourTileCacheBuilder.h
@@ -22,7 +22,7 @@
 #include "DetourAlloc.h"
 #include "DetourStatus.h"
 
-static const int DT_TILECACHE_MAGIC = 'D'<<24 | 'T'<<16 | 'L'<<8 | 'R'; //'DTLR';
+static const int DT_TILECACHE_MAGIC = 'D'<<24 | 'T'<<16 | 'L'<<8 | 'R'; ///< 'DTLR';
 static const int DT_TILECACHE_VERSION = 1;
 
 static const unsigned char DT_TILECACHE_NULL_AREA = 0;
@@ -30,19 +30,19 @@ static const unsigned char DT_TILECACHE_WALKABLE_AREA = 63;
 
 struct dtTileCacheLayerHeader
 {
-	int magic;								// Data magic
-	int version;							// Data version
+	int magic;								///< Data magic
+	int version;							///< Data version
 	int tx,ty,tlayer;
 	float bmin[3], bmax[3];
-	unsigned short hmin, hmax;				// Height min/max range
-	unsigned char width, height;			// Dimension of the layer.
-	unsigned char minx, maxx, miny, maxy;	// Usable sub-region.
+	unsigned short hmin, hmax;				///< Height min/max range
+	unsigned char width, height;			///< Dimension of the layer.
+	unsigned char minx, maxx, miny, maxy;	///< Usable sub-region.
 };
 
 struct dtTileCacheLayer
 {
 	dtTileCacheLayerHeader* header;
-	unsigned char regCount;					// Region count.
+	unsigned char regCount;					///< Region count.
 	unsigned char* heights;
 	unsigned char* areas;
 	unsigned char* cons;
@@ -65,12 +65,12 @@ struct dtTileCacheContourSet
 
 struct dtTileCachePolyMesh
 {
-	int nverts;				// Number of vertices.
-	int npolys;				// Number of polygons.
-	unsigned short* verts;	// Vertices of the mesh, 3 elements per vertex.
-	unsigned short* polys;	// Polygons of the mesh, nvp*2 elements per polygon.
-	unsigned short* flags;	// Per polygon flags.
-	unsigned char* areas;	// Area ID of polygons.
+	int nverts;				///< Number of vertices.
+	int npolys;				///< Number of polygons.
+	unsigned short* verts;	///< Vertices of the mesh, 3 elements per vertex.
+	unsigned short* polys;	///< Polygons of the mesh, nvp*2 elements per polygon.
+	unsigned short* flags;	///< Per polygon flags.
+	unsigned char* areas;	///< Area ID of polygons.
 };
 
 
diff --git a/Doxyfile b/Doxyfile
new file mode 100644
index 0000000..6469f16
--- /dev/null
+++ b/Doxyfile
@@ -0,0 +1,1699 @@
+# Doxyfile 1.7.3
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+#       TAG = value [value, ...]
+# For lists items can also be appended using:
+#       TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file 
+# that follow. The default is UTF-8 which is also the encoding used for all 
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the 
+# iconv built into libc) for the transcoding. See 
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
+# by quotes) that should identify the project.
+
+PROJECT_NAME           = recastnavigation
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. 
+# This could be handy for archiving the generated documentation or 
+# if some version control system is used.
+
+PROJECT_NUMBER         = 
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer
+# a quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          = 
+
+# With the PROJECT_LOGO tag one can specify an logo or icon that is 
+# included in the documentation. The maximum height of the logo should not 
+# exceed 55 pixels and the maximum width should not exceed 200 pixels. 
+# Doxygen will copy the logo to the output directory.
+
+PROJECT_LOGO           = RecastDemo/Build/Icon.png
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
+# base path where the generated documentation will be put. 
+# If a relative path is entered, it will be relative to the location 
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = Docs
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 
+# 4096 sub-directories (in 2 levels) under the output directory of each output 
+# format and will distribute the generated files over these directories. 
+# Enabling this option can be useful when feeding doxygen a huge amount of 
+# source files, where putting all generated files in the same directory would 
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS         = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all 
+# documentation generated by doxygen is written. Doxygen will use this 
+# information to generate all constant output in the proper language. 
+# The default language is English, other supported languages are: 
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, 
+# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German, 
+# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English 
+# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, 
+# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak, 
+# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
+# include brief member descriptions after the members that are listed in 
+# the file and class documentation (similar to JavaDoc). 
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
+# the brief description of a member or function before the detailed description. 
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator 
+# that is used to form the text in various listings. Each string 
+# in this list, if found as the leading text of the brief description, will be 
+# stripped from the text and the result after processing the whole list, is 
+# used as the annotated text. Otherwise, the brief description is used as-is. 
+# If left blank, the following values are used ("$name" is automatically 
+# replaced with the name of the entity): "The $name class" "The $name widget" 
+# "The $name file" "is" "provides" "specifies" "contains" 
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
+# Doxygen will generate a detailed section even if there is only a brief 
+# description.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all 
+# inherited members of a class in the documentation of that class as if those 
+# members were ordinary class members. Constructors, destructors and assignment 
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
+# path before files name in the file list and in the header files. If set 
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES        = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
+# can be used to strip a user-defined part of the path. Stripping is 
+# only done if one of the specified strings matches the left-hand part of 
+# the path. The tag can be used to show relative paths in the file list. 
+# If left blank the directory from which doxygen is run is used as the 
+# path to strip.
+
+STRIP_FROM_PATH        = 
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of 
+# the path mentioned in the documentation of a class, which tells 
+# the reader which header file to include in order to use a class. 
+# If left blank only the name of the header file containing the class 
+# definition is used. Otherwise one should specify the include paths that 
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH    = 
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter 
+# (but less readable) file names. This can be useful if your file system 
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen 
+# will interpret the first line (until the first dot) of a JavaDoc-style 
+# comment as the brief description. If set to NO, the JavaDoc 
+# comments will behave just like regular Qt-style comments 
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF      = YES
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will 
+# interpret the first line (until the first dot) of a Qt-style 
+# comment as the brief description. If set to NO, the comments 
+# will behave just like regular Qt-style comments (thus requiring 
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen 
+# treat a multi-line C++ special comment block (i.e. a block of //! or /// 
+# comments) as a brief description. This used to be the default behaviour. 
+# The new default is to treat a multi-line C++ comment block as a detailed 
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
+# member inherits the documentation from any documented member that it 
+# re-implements.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce 
+# a new page for each member. If set to NO, the documentation of a member will 
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. 
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of aliases that acts 
+# as commands in the documentation. An alias has the form "name=value". 
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to 
+# put the command \sideeffect (or @sideeffect) in the documentation, which 
+# will result in a user-defined paragraph with heading "Side Effects:". 
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES                = 
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C 
+# sources only. Doxygen will then generate output that is more tailored for C. 
+# For instance, some of the names that are used will be different. The list 
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C  = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java 
+# sources only. Doxygen will then generate output that is more tailored for 
+# Java. For instance, namespaces will be presented as packages, qualified 
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran 
+# sources only. Doxygen will then generate output that is more tailored for 
+# Fortran.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL 
+# sources. Doxygen will then generate output that is tailored for 
+# VHDL.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it 
+# parses. With this tag you can assign which parser to use for a given extension. 
+# Doxygen has a built-in mapping, but you can override or extend it using this 
+# tag. The format is ext=language, where ext is a file extension, and language 
+# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C, 
+# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make 
+# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C 
+# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions 
+# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
+
+EXTENSION_MAPPING      = 
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want 
+# to include (a tag file for) the STL sources as input, then you should 
+# set this tag to YES in order to let doxygen match functions declarations and 
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. 
+# func(std::string) {}). This also makes the inheritance and collaboration 
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to 
+# enable parsing support.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. 
+# Doxygen will parse them like normal C++ but will assume all classes use public 
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate getter 
+# and setter methods for a property. Setting this option to YES (the default) 
+# will make doxygen replace the get and set methods by a property in the 
+# documentation. This will only work if the methods are indeed getting or 
+# setting a simple type. If this is not the case, or you want to show the 
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
+# tag is set to YES, then doxygen will reuse the documentation of the first 
+# member in the group (if any) for the other members of the group. By default 
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of 
+# the same type (for instance a group of public functions) to be put as a 
+# subgroup of that type (e.g. under the Public Functions section). Set it to 
+# NO to prevent subgrouping. Alternatively, this can be done per class using 
+# the \nosubgrouping command.
+
+SUBGROUPING            = YES
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum 
+# is documented as struct, union, or enum with the name of the typedef. So 
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct 
+# with name TypeT. When disabled the typedef will appear as a member of a file, 
+# namespace, or class. And the struct will be named TypeS. This can typically 
+# be useful for C code in case the coding convention dictates that all compound 
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to 
+# determine which symbols to keep in memory and which to flush to disk. 
+# When the cache is full, less often used symbols will be written to disk. 
+# For small to medium size projects (<1000 input files) the default value is 
+# probably good enough. For larger projects a too small cache size can cause 
+# doxygen to be busy swapping symbols to and from disk most of the time 
+# causing a significant performance penalty. 
+# If the system has enough physical memory increasing the cache will improve the 
+# performance by keeping more symbols in memory. Note that the value works on 
+# a logarithmic scale so increasing the size by one will roughly double the 
+# memory usage. The cache size is given by this formula: 
+# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, 
+# corresponding to a cache size of 2^16 = 65536 symbols
+
+SYMBOL_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
+# documentation are documented, even if no documentation was available. 
+# Private class members and static file members will be hidden unless 
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
+# will be included in the documentation.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file 
+# will be included in the documentation.
+
+EXTRACT_STATIC         = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) 
+# defined locally in source files will be included in the documentation. 
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. When set to YES local 
+# methods, which are defined in the implementation section but not in 
+# the interface are included in the documentation. 
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be 
+# extracted and appear in the documentation as a namespace called 
+# 'anonymous_namespace{file}', where file will be replaced with the base 
+# name of the file that contains the anonymous namespace. By default 
+# anonymous namespaces are hidden.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
+# undocumented members of documented classes, files or namespaces. 
+# If set to NO (the default) these members will be included in the 
+# various overviews, but no documentation section is generated. 
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
+# undocumented classes that are normally visible in the class hierarchy. 
+# If set to NO (the default) these classes will be included in the various 
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all 
+# friend (class|struct|union) declarations. 
+# If set to NO (the default) these declarations will be included in the 
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any 
+# documentation blocks found inside the body of a function. 
+# If set to NO (the default) these blocks will be appended to the 
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation 
+# that is typed after a \internal command is included. If the tag is set 
+# to NO (the default) then the documentation will be excluded. 
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS          = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
+# file names in lower-case letters. If set to YES upper-case letters are also 
+# allowed. This is useful if you have classes or files whose names only differ 
+# in case and if your file system supports case sensitive file names. Windows 
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
+# will show members with their full class and namespace scopes in the 
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
+# will put a list of the files that are included by a file in the documentation 
+# of that file.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen 
+# will list include files with double quotes in the documentation 
+# rather than with sharp brackets.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
+# is inserted in the documentation for inline members.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
+# will sort the (detailed) documentation of file and class members 
+# alphabetically by member name. If set to NO the members will appear in 
+# declaration order.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the 
+# brief documentation of file, namespace and class members alphabetically 
+# by member name. If set to NO (the default) the members will appear in 
+# declaration order.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen 
+# will sort the (brief and detailed) documentation of class members so that 
+# constructors and destructors are listed first. If set to NO (the default) 
+# the constructors will appear in the respective orders defined by 
+# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS. 
+# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO 
+# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the 
+# hierarchy of group names into alphabetical order. If set to NO (the default) 
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be 
+# sorted by fully-qualified names, including namespaces. If set to 
+# NO (the default), the class list will be sorted only by class name, 
+# not including the namespace part. 
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. 
+# Note: This option applies only to the class list, not to the 
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
+# do proper type resolution of all parameters of a function it will reject a 
+# match between the prototype and the implementation of a member function even
+# if there is only one candidate or it is obvious which candidate to choose
+# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen 
+# will still accept a match between prototype and implementation in such cases.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or 
+# disable (NO) the todo list. This list is created by putting \todo 
+# commands in the documentation.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or 
+# disable (NO) the test list. This list is created by putting \test 
+# commands in the documentation.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or 
+# disable (NO) the bug list. This list is created by putting \bug 
+# commands in the documentation.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or 
+# disable (NO) the deprecated list. This list is created by putting 
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional 
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS       = 
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
+# the initial value of a variable or macro consists of for it to appear in 
+# the documentation. If the initializer consists of more lines than specified 
+# here it will be hidden. Use a value of 0 to hide initializers completely. 
+# The appearance of the initializer of individual variables and macros in the 
+# documentation can be controlled using \showinitializer or \hideinitializer 
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated 
+# at the bottom of the documentation of classes and structs. If set to YES the 
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES        = YES
+
+# If the sources in your project are distributed over multiple directories 
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy 
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES       = NO
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. 
+# This will remove the Files entry from the Quick Index and from the 
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the 
+# Namespaces page.  This will remove the Namespaces entry from the Quick Index 
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that 
+# doxygen should invoke to get the current version for each file (typically from 
+# the version control system). Doxygen will invoke the program by executing (via 
+# popen()) the command <command> <input-file>, where <command> is the value of 
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file 
+# provided by doxygen. Whatever the program writes to standard output 
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER    = 
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed 
+# by doxygen. The layout file controls the global structure of the generated 
+# output files in an output format independent way. The create the layout file 
+# that represents doxygen's defaults, run doxygen with the -l option. 
+# You can optionally specify a file name after the option, if omitted 
+# DoxygenLayout.xml will be used as the name of the layout file.
+
+LAYOUT_FILE            = 
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated 
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are 
+# generated by doxygen. Possible values are YES and NO. If left blank 
+# NO is used.
+
+WARNINGS               = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for 
+# potential errors in the documentation, such as not documenting some 
+# parameters in a documented function, or documenting parameters that 
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR      = YES
+
+# The WARN_NO_PARAMDOC option can be enabled to get warnings for 
+# functions that are documented, but have no documentation for their parameters 
+# or return value. If set to NO (the default) doxygen will only warn about 
+# wrong or incomplete parameter documentation, but not about the absence of 
+# documentation.
+
+WARN_NO_PARAMDOC       = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that 
+# doxygen can produce. The string should contain the $file, $line, and $text 
+# tags, which will be replaced by the file and line number from which the 
+# warning originated and the warning text. Optionally the format may contain 
+# $version, which will be replaced by the version of the file (if it could 
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning 
+# and error messages should be written. If left blank the output is written 
+# to stderr.
+
+WARN_LOGFILE           = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain 
+# documented source files. You may enter file names like "myfile.cpp" or 
+# directories like "/usr/src/myproject". Separate the files or directories 
+# with spaces.
+
+INPUT                  = Detour \
+                         DebugUtils \
+                         DetourCrowd \
+                         DetourTileCache \
+                         Recast
+
+# This tag can be used to specify the character encoding of the source files 
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is 
+# also the default input encoding. Doxygen uses libiconv (or the iconv built 
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for 
+# the list of possible encodings.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the 
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank the following patterns are tested: 
+# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh 
+# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py 
+# *.f90 *.f *.for *.vhd *.vhdl
+
+FILE_PATTERNS          = *.cpp \
+                         *.h
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories 
+# should be searched for input files as well. Possible values are YES and NO. 
+# If left blank NO is used.
+
+RECURSIVE              = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should 
+# excluded from the INPUT source files. This way you can easily exclude a 
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE                = Doxyfile \
+                         License.txt \
+                         Readme.txt \
+                         TODO.txt \
+                         RecastDemo/Contrib \
+                         RecastDemo/Build \
+                         RecastDemo/Bin
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or 
+# directories that are symbolic links (a Unix file system feature) are excluded 
+# from the input.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the 
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
+# certain files from those directories. Note that the wildcards are matched 
+# against the file with absolute path, so to exclude all test directories 
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       = CMakeLists.txt
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names 
+# (namespaces, classes, functions, etc.) that should be excluded from the 
+# output. The symbol name can be a fully qualified name, a word, or if the 
+# wildcard * is used, a substring. Examples: ANamespace, AClass, 
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS        = 
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or 
+# directories that contain example code fragments that are included (see 
+# the \include command).
+
+EXAMPLE_PATH           = 
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the 
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
+# and *.h) to filter out the source-files in the directories. If left 
+# blank all files are included.
+
+EXAMPLE_PATTERNS       = 
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be 
+# searched for input files to be used with the \include or \dontinclude 
+# commands irrespective of the value of the RECURSIVE tag. 
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or 
+# directories that contain image that are included in the documentation (see 
+# the \image command).
+
+IMAGE_PATH             = 
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should 
+# invoke to filter for each input file. Doxygen will invoke the filter program 
+# by executing (via popen()) the command <filter> <input-file>, where <filter> 
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
+# input file. Doxygen will then use the output that the filter program writes 
+# to standard output.  If FILTER_PATTERNS is specified, this tag will be 
+# ignored.
+
+INPUT_FILTER           = 
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern 
+# basis.  Doxygen will compare the file name with each pattern and apply the 
+# filter if there is a match.  The filters are a list of the form: 
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further 
+# info on how filters are used. If FILTER_PATTERNS is empty or if 
+# non of the patterns match the file name, INPUT_FILTER is applied.
+
+FILTER_PATTERNS        = 
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using 
+# INPUT_FILTER) will be used to filter the input files when producing source 
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES    = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file 
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) 
+# and it is also possible to disable source filtering for a specific pattern 
+# using *.ext= (so without naming a filter). This option only has effect when 
+# FILTER_SOURCE_FILES is enabled.
+
+FILTER_SOURCE_PATTERNS = 
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will 
+# be generated. Documented entities will be cross-referenced with these sources. 
+# Note: To get rid of all source code in the generated output, make sure also 
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body 
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
+# doxygen to hide any special comment blocks from generated source code 
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES 
+# then for each documented function all documented 
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES 
+# then for each documented function all documented entities 
+# called/used by that function will be listed.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) 
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from 
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will 
+# link to the source code.  Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code 
+# will point to the HTML generated by the htags(1) tool instead of doxygen 
+# built-in source browser. The htags tool is part of GNU's global source 
+# tagging system (see http://www.gnu.org/software/global/global.html). You 
+# will need version 4.8.6 or higher.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
+# will generate a verbatim copy of the header file for each class for 
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS       = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
+# of all compounds will be generated. Enable this if the project 
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX     = YES
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX    = 5
+
+# In case all classes in a project start with a common prefix, all 
+# classes will be put under the same header in the alphabetical index. 
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX          = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
+# generate HTML output.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for 
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank 
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard header.
+
+HTML_HEADER            = 
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for 
+# each generated HTML page. If it is left blank doxygen will generate a 
+# standard footer.
+
+HTML_FOOTER            = 
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading 
+# style sheet that is used by each HTML page. It can be used to 
+# fine-tune the look of the HTML output. If the tag is left blank doxygen 
+# will generate a default style sheet. Note that doxygen will try to copy 
+# the style sheet file to the HTML output directory, so don't put your own 
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET        = 
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. 
+# Doxygen will adjust the colors in the stylesheet and background images 
+# according to this color. Hue is specified as an angle on a colorwheel, 
+# see http://en.wikipedia.org/wiki/Hue for more information. 
+# For instance the value 0 represents red, 60 is yellow, 120 is green, 
+# 180 is cyan, 240 is blue, 300 purple, and 360 is red again. 
+# The allowed range is 0 to 359.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of 
+# the colors in the HTML output. For a value of 0 the output will use 
+# grayscales only. A value of 255 will produce the most vivid colors.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to 
+# the luminance component of the colors in the HTML output. Values below 
+# 100 gradually make the output lighter, whereas values above 100 make 
+# the output darker. The value divided by 100 is the actual gamma applied, 
+# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2, 
+# and 100 does not change the gamma.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML 
+# page will contain the date and time when the page was generated. Setting 
+# this to NO can help when comparing the output of multiple runs.
+
+HTML_TIMESTAMP         = YES
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
+# files or namespaces will be aligned in HTML using tables. If set to 
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS     = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML 
+# documentation will contain sections that can be hidden and shown after the 
+# page has loaded. For this to work a browser that supports 
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox 
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files 
+# will be generated that can be used as input for Apple's Xcode 3 
+# integrated development environment, introduced with OSX 10.5 (Leopard). 
+# To create a documentation set, doxygen will generate a Makefile in the 
+# HTML output directory. Running make will produce the docset in that 
+# directory and running "make install" will install the docset in 
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find 
+# it at startup. 
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html 
+# for more information.
+
+GENERATE_DOCSET        = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the 
+# feed. A documentation feed provides an umbrella under which multiple 
+# documentation sets from a single provider (such as a company or product suite) 
+# can be grouped.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that 
+# should uniquely identify the documentation set bundle. This should be a 
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen 
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify 
+# the documentation publisher. This should be a reverse domain-name style 
+# string, e.g. com.mycompany.MyDocSet.documentation.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files 
+# will be generated that can be used as input for tools like the 
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) 
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP      = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can 
+# be used to specify the file name of the resulting .chm file. You 
+# can add a path in front of the file if the result should not be 
+# written to the html output directory.
+
+CHM_FILE               = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can 
+# be used to specify the location (absolute path including file name) of 
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run 
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION           = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag 
+# controls if a separate .chi index file is generated (YES) or that 
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI           = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING 
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file 
+# content.
+
+CHM_INDEX_ENCODING     = 
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag 
+# controls whether a binary table of contents is generated (YES) or a 
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members 
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and 
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated 
+# that can be used as input for Qt's qhelpgenerator to generate a 
+# Qt Compressed Help (.qch) of the generated HTML documentation.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can 
+# be used to specify the file name of the resulting .qch file. 
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE               = 
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating 
+# Qt Help Project output. For more information please see 
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating 
+# Qt Help Project output. For more information please see 
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to 
+# add. For more information please see 
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME   = 
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the 
+# custom filter to add. For more information please see 
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters"> 
+# Qt Help Project / Custom Filters</a>.
+
+QHP_CUST_FILTER_ATTRS  = 
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this 
+# project's 
+# filter section matches. 
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes"> 
+# Qt Help Project / Filter Attributes</a>.
+
+QHP_SECT_FILTER_ATTRS  = 
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can 
+# be used to specify the location of Qt's qhelpgenerator. 
+# If non-empty doxygen will try to run qhelpgenerator on the generated 
+# .qhp file.
+
+QHG_LOCATION           = 
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files  
+# will be generated, which together with the HTML files, form an Eclipse help 
+# plugin. To install this plugin and make it available under the help contents 
+# menu in Eclipse, the contents of the directory containing the HTML and XML 
+# files needs to be copied into the plugins directory of eclipse. The name of 
+# the directory within the plugins directory should be the same as 
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before 
+# the help appears.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the eclipse help plugin. When installing the plugin 
+# the directory name containing the HTML and XML files should also have 
+# this name.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
+# top of each HTML page. The value NO (the default) enables the index and 
+# the value YES disables it.
+
+DISABLE_INDEX          = NO
+
+# This tag can be used to set the number of enum values (range [0,1..20]) 
+# that doxygen will group on one line in the generated HTML documentation. 
+# Note that a value of 0 will completely suppress the enum values from
+# appearing in the overview section.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index 
+# structure should be generated to display hierarchical information. 
+# If the tag value is set to YES, a side panel will be generated 
+# containing a tree-like index structure (just like the one that 
+# is generated for HTML Help). For this to work a browser that supports 
+# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser). 
+# Windows users are probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW      = NO
+
+# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories, 
+# and Class Hierarchy pages using a tree view instead of an ordered list.
+
+USE_INLINE_TREES       = NO
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be 
+# used to set the initial width (in pixels) of the frame in which the tree 
+# is shown.
+
+TREEVIEW_WIDTH         = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open 
+# links to external symbols imported via tag files in a separate window.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# Use this tag to change the font size of Latex formulas included 
+# as images in the HTML documentation. The default is 10. Note that 
+# when you change the font size after a successful doxygen run you need 
+# to manually remove any form_*.png images from the HTML output directory 
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images 
+# generated for formulas are transparent PNGs. Transparent PNGs are 
+# not supported properly for IE 6.0, but are supported on all modern browsers. 
+# Note that when changing this option you need to delete any form_*.png files 
+# in the HTML output before the changes have effect.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax 
+# (see http://www.mathjax.org) which uses client side Javascript for the 
+# rendering instead of using prerendered bitmaps. Use this if you do not 
+# have LaTeX installed or if you want to formulas look prettier in the HTML 
+# output. When enabled you also need to install MathJax separately and 
+# configure the path to it using the MATHJAX_RELPATH option.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you need to specify the location relative to the 
+# HTML output directory using the MATHJAX_RELPATH option. The destination 
+# directory should contain the MathJax.js script. For instance, if the mathjax 
+# directory is located at the same level as the HTML output directory, then 
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the
+# mathjax.org site, so you can quickly see the result without installing 
+# MathJax, but it is strongly recommended to install a local copy of MathJax 
+# before deployment.
+
+MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box 
+# for the HTML output. The underlying search engine uses javascript 
+# and DHTML and should work on any modern browser. Note that when using 
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets 
+# (GENERATE_DOCSET) there is already a search function so this one should 
+# typically be disabled. For large projects the javascript based search engine 
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+
+SEARCHENGINE           = NO
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be 
+# implemented using a PHP enabled web server instead of at the web client 
+# using Javascript. Doxygen will generate the search PHP script and index 
+# file to put on the web server. The advantage of the server 
+# based approach is that it scales better to large projects and allows 
+# full text search. The disadvantages are that it is more difficult to setup 
+# and does not have live searching capabilities.
+
+SERVER_BASED_SEARCH    = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will 
+# generate Latex output.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be 
+# invoked. If left blank `latex' will be used as the default command name. 
+# Note that when enabling USE_PDFLATEX this option is only used for 
+# generating bitmaps for formulas in the HTML output, but not in the 
+# Makefile that is written to the output directory.
+
+LATEX_CMD_NAME         = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to 
+# generate index for LaTeX. If left blank `makeindex' will be used as the 
+# default command name.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact 
+# LaTeX documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used 
+# by the printer. Possible values are: a4, letter, legal and 
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE             = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES         = 
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for 
+# the generated latex document. The header should contain everything until 
+# the first chapter. If it is left blank doxygen will generate a 
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER           = 
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated 
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will 
+# contain links (just like the HTML output) instead of page references 
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS         = NO
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of 
+# plain latex in the generated Makefile. Set this option to YES to get a 
+# higher quality PDF documentation.
+
+USE_PDFLATEX           = NO
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. 
+# command to the generated LaTeX files. This will instruct LaTeX to keep 
+# running if errors occur, instead of asking the user for help. 
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE        = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not 
+# include the index chapters (such as File Index, Compound Index, etc.) 
+# in the output.
+
+LATEX_HIDE_INDICES     = NO
+
+# If LATEX_SOURCE_CODE is set to YES then doxygen will include 
+# source code with syntax highlighting in the LaTeX output. 
+# Note that which sources are shown also depends on other settings 
+# such as SOURCE_BROWSER.
+
+LATEX_SOURCE_CODE      = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output 
+# The RTF output is optimized for Word 97 and may not look very pretty with 
+# other RTF readers or editors.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact 
+# RTF documents. This may be useful for small projects and may help to 
+# save some trees in general.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated 
+# will contain hyperlink fields. The RTF file will 
+# contain links (just like the HTML output) instead of page references. 
+# This makes the output suitable for online browsing using WORD or other 
+# programs which support those fields. 
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's 
+# config file, i.e. a series of assignments. You only have to provide 
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE    = 
+
+# Set optional variables used in the generation of an rtf document. 
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE    = 
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will 
+# generate man pages
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to 
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION          = .3dbus
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output, 
+# then it will generate one additional man file for each entity 
+# documented in the real man page(s). These additional files 
+# only source the real man page, but without them the man command 
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS              = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will 
+# generate an XML file that captures the structure of 
+# the code including all documentation.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. 
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT             = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_SCHEMA             = 
+
+# The XML_DTD tag can be used to specify an XML DTD, 
+# which can be used by a validating XML parser to check the 
+# syntax of the XML files.
+
+XML_DTD                = 
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will 
+# dump the program listings (including syntax highlighting 
+# and cross-referencing information) to the XML output. Note that 
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will 
+# generate an AutoGen Definitions (see autogen.sf.net) file 
+# that captures the structure of the code including all 
+# documentation. Note that this feature is still experimental 
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will 
+# generate a Perl module file that captures the structure of 
+# the code including all documentation. Note that this 
+# feature is still experimental and incomplete at the 
+# moment.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate 
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able 
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be 
+# nicely formatted so it can be parsed by a human reader.  This is useful 
+# if you want to understand what is going on.  On the other hand, if this 
+# tag is set to NO the size of the Perl module output will be much smaller 
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file 
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. 
+# This is useful so different doxyrules.make files included by the same 
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will 
+# evaluate all C-preprocessor directives found in the sources and include 
+# files.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro 
+# names in the source code. If set to NO (the default) only conditional 
+# compilation will be performed. Macro expansion can be done in a controlled 
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION        = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES 
+# then the macro expansion is limited to the macros specified with the 
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files 
+# in the INCLUDE_PATH (see below) will be search if a #include is found.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that 
+# contain include files that are not input files but should be processed by 
+# the preprocessor.
+
+INCLUDE_PATH           = 
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard 
+# patterns (like *.h and *.hpp) to filter out the header-files in the 
+# directories. If left blank, the patterns specified with FILE_PATTERNS will 
+# be used.
+
+INCLUDE_FILE_PATTERNS  = 
+
+# The PREDEFINED tag can be used to specify one or more macro names that 
+# are defined before the preprocessor is started (similar to the -D option of 
+# gcc). The argument of the tag is a list of macros of the form: name 
+# or name=definition (no spaces). If the definition and the = are 
+# omitted =1 is assumed. To prevent a macro definition from being 
+# undefined via #undef or recursively expanded use the := operator 
+# instead of the = operator.
+
+PREDEFINED             = 
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then 
+# this tag can be used to specify a list of macro names that should be expanded. 
+# The macro definition that is found in the sources will be used. 
+# Use the PREDEFINED tag if you want to use a different macro definition that
+# overrules the definition found in the source code.
+
+EXPAND_AS_DEFINED      = 
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then 
+# doxygen's preprocessor will remove all references to function-like macros 
+# that are alone on a line, have an all uppercase name, and do not end with a 
+# semicolon, because these will confuse the parser if not removed.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles. 
+# Optionally an initial location of the external documentation 
+# can be added for each tagfile. The format of a tag file without 
+# this location is as follows: 
+#   TAGFILES = file1 file2 ... 
+# Adding location for the tag files is done as follows: 
+#   TAGFILES = file1=loc1 "file2 = loc2" ... 
+# where "loc1" and "loc2" can be relative or absolute paths or 
+# URLs. If a location is present for each tag, the installdox tool 
+# does not have to be run to correct the links. 
+# Note that each tag file must have a unique name 
+# (where the name does NOT include the path) 
+# If a tag file is not located in the directory in which doxygen 
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES               = 
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create 
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE       = 
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed 
+# in the class index. If set to NO only the inherited external classes 
+# will be listed.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed 
+# in the modules index. If set to NO, only the current project's groups will 
+# be listed.
+
+EXTERNAL_GROUPS        = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script 
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base 
+# or super classes. Setting the tag to NO turns the diagrams off. Note that 
+# this option also works with HAVE_DOT disabled, but it is recommended to 
+# install and use dot, since it yields more powerful graphs.
+
+CLASS_DIAGRAMS         = YES
+
+# You can define message sequence charts within doxygen comments using the \msc 
+# command. Doxygen will then run the mscgen tool (see 
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the 
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where 
+# the mscgen tool resides. If left empty the tool is assumed to be found in the 
+# default search path.
+
+MSCGEN_PATH            = 
+
+# If set to YES, the inheritance and collaboration graphs will hide 
+# inheritance and usage relations if the target is undocumented 
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is 
+# available from the path. This tool is part of Graphviz, a graph visualization 
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section 
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT               = NO
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is 
+# allowed to run in parallel. When set to 0 (the default) doxygen will 
+# base this on the number of processors available in the system. You can set it 
+# explicitly to a value larger than 0 to get control over the balance 
+# between CPU load and processing speed.
+
+DOT_NUM_THREADS        = 0
+
+# By default doxygen will write a font called Helvetica to the output 
+# directory and reference it in all dot files that doxygen generates. 
+# When you want a differently looking font you can specify the font name 
+# using DOT_FONTNAME. You need to make sure dot is able to find the font, 
+# which can be done by putting it in a standard location or by setting the 
+# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory 
+# containing the font.
+
+DOT_FONTNAME           = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. 
+# The default size is 10pt.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the output directory to look for the 
+# FreeSans.ttf font (which doxygen will put there itself). If you specify a 
+# different font using DOT_FONTNAME you can set the path where dot 
+# can find it using this tag.
+
+DOT_FONTPATH           = 
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect inheritance relations. Setting this tag to YES will force the 
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for each documented class showing the direct and 
+# indirect implementation dependencies (inheritance, containment, and 
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and 
+# collaboration diagrams in a style similar to the OMG's Unified Modeling 
+# Language.
+
+UML_LOOK               = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the 
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS     = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT 
+# tags are set to YES then doxygen will generate a graph for each documented 
+# file showing the direct and indirect include dependencies of the file with 
+# other documented files.
+
+INCLUDE_GRAPH          = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and 
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each 
+# documented header file showing the documented files that directly or 
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then 
+# doxygen will generate a call dependency graph for every global function 
+# or class method. Note that enabling this option will significantly increase 
+# the time of a run. So in most cases it will be better to enable call graphs 
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH             = NO
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then 
+# doxygen will generate a caller dependency graph for every global function 
+# or class method. Note that enabling this option will significantly increase 
+# the time of a run. So in most cases it will be better to enable caller 
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH           = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
+# will generate a graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES 
+# then doxygen will show the dependencies a directory has on other directories 
+# in a graphical way. The dependency relations are determined by the #include 
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images 
+# generated by dot. Possible values are png, svg, gif or svg. 
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT       = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be 
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH               = 
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that 
+# contain dot files that are included in the documentation (see the 
+# \dotfile command).
+
+DOTFILE_DIRS           = 
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that 
+# contain msc files that are included in the documentation (see the 
+# \mscfile command).
+
+MSCFILE_DIRS           = 
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of 
+# nodes that will be shown in the graph. If the number of nodes in a graph 
+# becomes larger than this value, doxygen will truncate the graph, which is 
+# visualized by representing a node as a red box. Note that doxygen if the 
+# number of direct children of the root node in a graph is already larger than 
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note 
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the 
+# graphs generated by dot. A depth value of 3 means that only nodes reachable 
+# from the root by following a path via at most 3 edges will be shown. Nodes 
+# that lay further from the root node will be omitted. Note that setting this 
+# option to 1 or 2 may greatly reduce the computation time needed for large 
+# code bases. Also note that the size of a graph can be further restricted by 
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent 
+# background. This is disabled by default, because dot on Windows does not 
+# seem to support this out of the box. Warning: Depending on the platform used, 
+# enabling this option may lead to badly anti-aliased labels on the edges of 
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output 
+# files in one run (i.e. multiple -o and -T options on the command line). This 
+# makes dot run faster, but since only newer versions of dot (>1.8.10) 
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS      = NO
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will 
+# generate a legend page explaining the meaning of the various boxes and 
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will 
+# remove the intermediate dot files that are used to generate 
+# the various graphs.
+
+DOT_CLEANUP            = YES
diff --git a/Recast/Include/Recast.h b/Recast/Include/Recast.h
index 205a80f..14fc2ea 100644
--- a/Recast/Include/Recast.h
+++ b/Recast/Include/Recast.h
@@ -62,101 +62,104 @@ enum rcTimerLabel
 	RC_MAX_TIMERS
 };
 
-// Build context provides several optional utilities needed for the build process,
-// such as timing, logging, and build time collecting. 
+/// Build context provides several optional utilities needed for the build process,
+/// such as timing, logging, and build time collecting.
 class rcContext
 {
 public:
 	inline rcContext(bool state = true) : m_logEnabled(state), m_timerEnabled(state) {}
 	virtual ~rcContext() {}
 
-	// Enables or disables logging.
+	/// Enables or disables logging.
 	inline void enableLog(bool state) { m_logEnabled = state; }
-	// Resets log.
+	/// Resets log.
 	inline void resetLog() { if (m_logEnabled) doResetLog(); }
-	// Logs a message.
+	/// Logs a message.
 	void log(const rcLogCategory category, const char* format, ...);
 
-	// Enables or disables timer.
+	/// Enables or disables timer.
 	inline void enableTimer(bool state) { m_timerEnabled = state; }
-	// Resets all timers.
+	/// Resets all timers.
 	inline void resetTimers() { if (m_timerEnabled) doResetTimers(); }
-	// Starts timer, used for performance timing.
+	/// Starts timer, used for performance timing.
 	inline void startTimer(const rcTimerLabel label) { if (m_timerEnabled) doStartTimer(label); }
-	// Stops timer, used for performance timing.
+	/// Stops timer, used for performance timing.
 	inline void stopTimer(const rcTimerLabel label) { if (m_timerEnabled) doStopTimer(label); }
-	// Returns time accumulated between timer start/stop.
+	/// Returns time accumulated between timer start/stop.
 	inline int getAccumulatedTime(const rcTimerLabel label) const { return m_timerEnabled ? doGetAccumulatedTime(label) : -1; }
 
 protected:
-	// Virtual functions to override for custom implementations.
+
+	/// @name Virtual functions to override for custom implementations.
+	///@{
 	virtual void doResetLog() {}
 	virtual void doLog(const rcLogCategory /*category*/, const char* /*msg*/, const int /*len*/) {}
 	virtual void doResetTimers() {}
 	virtual void doStartTimer(const rcTimerLabel /*label*/) {}
 	virtual void doStopTimer(const rcTimerLabel /*label*/) {}
 	virtual int doGetAccumulatedTime(const rcTimerLabel /*label*/) const { return -1; }
+	///@}
 	
 	bool m_logEnabled;
 	bool m_timerEnabled;
 };
 
 
-// The units of the parameters are specified in parenthesis as follows:
-// (vx) voxels, (wu) world units
+/// The units of the parameters are specified in parenthesis as follows:
+/// (vx) voxels, (wu) world units
 struct rcConfig
 {
-	int width, height;				// Dimensions of the rasterized heightfield (vx)
-	int tileSize;					// Width and Height of a tile (vx)
-	int borderSize;					// Non-navigable Border around the heightfield (vx)
-	float cs, ch;					// Grid cell size and height (wu)
-	float bmin[3], bmax[3];			// Grid bounds (wu)
-	float walkableSlopeAngle;		// Maximum walkable slope angle in degrees.
-	int walkableHeight;				// Minimum height where the agent can still walk (vx)
-	int walkableClimb;				// Maximum height between grid cells the agent can climb (vx)
-	int walkableRadius;				// Radius of the agent in cells (vx)
-	int maxEdgeLen;					// Maximum contour edge length (vx)
-	float maxSimplificationError;	// Maximum distance error from contour to cells (vx)
-	int minRegionArea;				// Regions whose area is smaller than this threshold will be removed. (vx)
-	int mergeRegionArea;			// Regions whose area is smaller than this threshold will be merged (vx)
-	int maxVertsPerPoly;			// Max number of vertices per polygon
-	float detailSampleDist;			// Detail mesh sample spacing.
-	float detailSampleMaxError;		// Detail mesh simplification max sample error.
+	int width, height;				///< Dimensions of the rasterized heightfield (vx)
+	int tileSize;					///< Width and Height of a tile (vx)
+	int borderSize;					///< Non-navigable Border around the heightfield (vx)
+	float cs, ch;					///< Grid cell size and height (wu)
+	float bmin[3], bmax[3];			///< Grid bounds (wu)
+	float walkableSlopeAngle;		///< Maximum walkable slope angle in degrees.
+	int walkableHeight;				///< Minimum height where the agent can still walk (vx)
+	int walkableClimb;				///< Maximum height between grid cells the agent can climb (vx)
+	int walkableRadius;				///< Radius of the agent in cells (vx)
+	int maxEdgeLen;					///< Maximum contour edge length (vx)
+	float maxSimplificationError;	///< Maximum distance error from contour to cells (vx)
+	int minRegionArea;				///< Regions whose area is smaller than this threshold will be removed. (vx)
+	int mergeRegionArea;			///< Regions whose area is smaller than this threshold will be merged (vx)
+	int maxVertsPerPoly;			///< Max number of vertices per polygon
+	float detailSampleDist;			///< Detail mesh sample spacing.
+	float detailSampleMaxError;		///< Detail mesh simplification max sample error.
 };
 
-// Define number of bits in the above structure for smin/smax.
-// The max height is used for clamping rasterized values.
+/// Define number of bits in the above structure for smin/smax.
 static const int RC_SPAN_HEIGHT_BITS = 13;
+/// The max height is used for clamping rasterized values.
 static const int RC_SPAN_MAX_HEIGHT = (1<<RC_SPAN_HEIGHT_BITS)-1;
 
-// Heightfield span.
+/// Heightfield span.
 struct rcSpan
 {
-	unsigned int smin : 13;			// Span min height.
-	unsigned int smax : 13;			// Span max height.
-	unsigned int area : 6;			// Span area type.
-	rcSpan* next;					// Next span in column.
+	unsigned int smin : 13;			///< Span min height.
+	unsigned int smax : 13;			///< Span max height.
+	unsigned int area : 6;			///< Span area type.
+	rcSpan* next;					///< Next span in column.
 };
 
-// Number of spans allocated per pool.
+/// Number of spans allocated per pool.
 static const int RC_SPANS_PER_POOL = 2048;
 
-// Memory pool used for quick span allocation.
+/// Memory pool used for quick span allocation.
 struct rcSpanPool
 {
-	rcSpanPool* next;					// Pointer to next pool.
-	rcSpan items[RC_SPANS_PER_POOL];	// Array of spans.
+	rcSpanPool* next;					///< Pointer to next pool.
+	rcSpan items[RC_SPANS_PER_POOL];	///< Array of spans.
 };
 
-// Dynamic span-heightfield.
+/// Dynamic span-heightfield.
 struct rcHeightfield
 {
-	int width, height;			// Dimension of the heightfield.
-	float bmin[3], bmax[3];		// Bounding box of the heightfield
-	float cs, ch;				// Cell size and height.
-	rcSpan** spans;				// Heightfield of spans (width*height).
-	rcSpanPool* pools;			// Linked list of span pools.
-	rcSpan* freelist;			// Pointer to next free span.
+	int width, height;			///< Dimension of the heightfield.
+	float bmin[3], bmax[3];		///< Bounding box of the heightfield
+	float cs, ch;				///< Cell size and height.
+	rcSpan** spans;				///< Heightfield of spans (width*height).
+	rcSpanPool* pools;			///< Linked list of span pools.
+	rcSpan* freelist;			///< Pointer to next free span.
 };
 
 rcHeightfield* rcAllocHeightfield();
@@ -165,33 +168,33 @@ void rcFreeHeightField(rcHeightfield* hf);
 
 struct rcCompactCell
 {
-	unsigned int index : 24;	// Index to first span in column.
-	unsigned int count : 8;		// Number of spans in this column.
+	unsigned int index : 24;	///< Index to first span in column.
+	unsigned int count : 8;		///< Number of spans in this column.
 };
 
 struct rcCompactSpan
 {
-	unsigned short y;			// Bottom coordinate of the span.
+	unsigned short y;			///< Bottom coordinate of the span.
 	unsigned short reg;
-	unsigned int con : 24;		// Connections to neighbour cells.
-	unsigned int h : 8;			// Height of the span.
+	unsigned int con : 24;		///< Connections to neighbour cells.
+	unsigned int h : 8;			///< Height of the span.
 };
 
-// Compact static heightfield. 
+/// Compact static heightfield.
 struct rcCompactHeightfield
 {
-	int width, height;					// Width and height of the heightfield.
-	int spanCount;						// Number of spans in the heightfield.
-	int walkableHeight, walkableClimb;	// Agent properties.
-	int borderSize;						// Border size of the heighfield.
-	unsigned short maxDistance;			// Maximum distance value stored in heightfield.
-	unsigned short maxRegions;			// Maximum Region Id stored in heightfield.
-	float bmin[3], bmax[3];				// Bounding box of the heightfield.
-	float cs, ch;						// Cell size and height.
-	rcCompactCell* cells;				// Pointer to width*height cells.
-	rcCompactSpan* spans;				// Pointer to spans.
-	unsigned short* dist;				// Pointer to per span distance to border.
-	unsigned char* areas;				// Pointer to per span area ID.
+	int width, height;					///< Width and height of the heightfield.
+	int spanCount;						///< Number of spans in the heightfield.
+	int walkableHeight, walkableClimb;	///< Agent properties.
+	int borderSize;						///< Border size of the heighfield.
+	unsigned short maxDistance;			///< Maximum distance value stored in heightfield.
+	unsigned short maxRegions;			///< Maximum Region Id stored in heightfield.
+	float bmin[3], bmax[3];				///< Bounding box of the heightfield.
+	float cs, ch;						///< Cell size and height.
+	rcCompactCell* cells;				///< Pointer to width*height cells.
+	rcCompactSpan* spans;				///< Pointer to spans.
+	unsigned short* dist;				///< Pointer to per span distance to border.
+	unsigned char* areas;				///< Pointer to per span area ID.
 };
 
 rcCompactHeightfield* rcAllocCompactHeightfield();
@@ -201,20 +204,20 @@ void rcFreeCompactHeightfield(rcCompactHeightfield* chf);
 
 struct rcHeightfieldLayer
 {
-	float bmin[3], bmax[3];				// Bounding box of the heightfield.
-	float cs, ch;						// Cell size and height.
-	int width, height;					// Width and height of the layer.
-	int minx,maxx,miny,maxy;			// Bounding box of usable data.
-	int hmin, hmax;						// Height min/max
-	unsigned char* heights;				// Heighfield.
-	unsigned char* areas;				// Area types.
-	unsigned char* cons;				// Connections.
+	float bmin[3], bmax[3];				///< Bounding box of the heightfield.
+	float cs, ch;						///< Cell size and height.
+	int width, height;					///< Width and height of the layer.
+	int minx,maxx,miny,maxy;			///< Bounding box of usable data.
+	int hmin, hmax;						///< Height min/max
+	unsigned char* heights;				///< Heighfield.
+	unsigned char* areas;				///< Area types.
+	unsigned char* cons;				///< Connections.
 };
 
 struct rcHeightfieldLayerSet
 {
-	rcHeightfieldLayer* layers;			// Pointer to layers.
-	int nlayers;						// Number of layers.
+	rcHeightfieldLayer* layers;			///< Pointer to layers.
+	int nlayers;						///< Number of layers.
 };
 
 rcHeightfieldLayerSet* rcAllocHeightfieldLayerSet();
@@ -224,117 +227,116 @@ void rcFreeHeightfieldLayerSet(rcHeightfieldLayerSet* lset);
 
 struct rcContour
 {
-	int* verts;			// Vertex coordinates, each vertex contains 4 components.
-	int nverts;			// Number of vertices.
-	int* rverts;		// Raw vertex coordinates, each vertex contains 4 components.
-	int nrverts;		// Number of raw vertices.
-	unsigned short reg;	// Region ID of the contour.
-	unsigned char area;	// Area ID of the contour.
+	int* verts;			///< Vertex coordinates, each vertex contains 4 components.
+	int nverts;			///< Number of vertices.
+	int* rverts;		///< Raw vertex coordinates, each vertex contains 4 components.
+	int nrverts;		///< Number of raw vertices.
+	unsigned short reg;	///< Region ID of the contour.
+	unsigned char area;	///< Area ID of the contour.
 };
 
 struct rcContourSet
 {
-	rcContour* conts;		// Pointer to all contours.
-	int nconts;				// Number of contours.
-	float bmin[3], bmax[3];	// Bounding box of the heightfield.
-	float cs, ch;			// Cell size and height.
-	int width, height;		// Region where the contours were build.
-	int borderSize;			// Border size of the heighfield where the contours were build from.
+	rcContour* conts;		///< Pointer to all contours.
+	int nconts;				///< Number of contours.
+	float bmin[3], bmax[3];	///< Bounding box of the heightfield.
+	float cs, ch;			///< Cell size and height.
+	int width, height;		///< Region where the contours were build.
+	int borderSize;			///< Border size of the heighfield where the contours were build from.
 };
 
 rcContourSet* rcAllocContourSet();
 void rcFreeContourSet(rcContourSet* cset);
 
 
-// Polymesh store a connected mesh of polygons.
-// The polygons are store in an array where each polygons takes
-// 'nvp*2' elements. The first 'nvp' elements are indices to vertices
-// and the second 'nvp' elements are indices to neighbour polygons.
-// If a polygon has less than 'bvp' vertices, the remaining indices
-// are set to RC_MESH_NULL_IDX. If an polygon edge does not have a neighbour
-// the neighbour index is set to RC_MESH_NULL_IDX.
-// Vertices can be transformed into world space as follows:
-//   x = bmin[0] + verts[i*3+0]*cs;
-//   y = bmin[1] + verts[i*3+1]*ch;
-//   z = bmin[2] + verts[i*3+2]*cs;
+/// Polymesh store a connected mesh of polygons.
+/// The polygons are store in an array where each polygons takes
+/// 'nvp*2' elements. The first 'nvp' elements are indices to vertices
+/// and the second 'nvp' elements are indices to neighbour polygons.
+/// If a polygon has less than 'bvp' vertices, the remaining indices
+/// are set to RC_MESH_NULL_IDX. If an polygon edge does not have a neighbour
+/// the neighbour index is set to RC_MESH_NULL_IDX.
+/// Vertices can be transformed into world space as follows:
+///   x = bmin[0] + verts[i*3+0]*cs;
+///   y = bmin[1] + verts[i*3+1]*ch;
+///   z = bmin[2] + verts[i*3+2]*cs;
 struct rcPolyMesh
 {	
-	unsigned short* verts;	// Vertices of the mesh, 3 elements per vertex.
-	unsigned short* polys;	// Polygons of the mesh, nvp*2 elements per polygon.
-	unsigned short* regs;	// Region ID of the polygons.
-	unsigned short* flags;	// Per polygon flags.
-	unsigned char* areas;	// Area ID of polygons.
-	int nverts;				// Number of vertices.
-	int npolys;				// Number of polygons.
-	int maxpolys;			// Number of allocated polygons.
-	int nvp;				// Max number of vertices per polygon.
-	float bmin[3], bmax[3];	// Bounding box of the mesh.
-	float cs, ch;			// Cell size and height.
-	int borderSize;			// Border size of the heighfield where the mesh was build from.
+	unsigned short* verts;	///< Vertices of the mesh, 3 elements per vertex.
+	unsigned short* polys;	///< Polygons of the mesh, nvp*2 elements per polygon.
+	unsigned short* regs;	///< Region ID of the polygons.
+	unsigned short* flags;	///< Per polygon flags.
+	unsigned char* areas;	///< Area ID of polygons.
+	int nverts;				///< Number of vertices.
+	int npolys;				///< Number of polygons.
+	int maxpolys;			///< Number of allocated polygons.
+	int nvp;				///< Max number of vertices per polygon.
+	float bmin[3], bmax[3];	///< Bounding box of the mesh.
+	float cs, ch;			///< Cell size and height.
+	int borderSize;			///< Border size of the heighfield where the mesh was build from.
 };
 
 rcPolyMesh* rcAllocPolyMesh();
 void rcFreePolyMesh(rcPolyMesh* pmesh);
 
 
-// Detail mesh generated from a rcPolyMesh.
-// Each submesh represents a polygon in the polymesh and they are stored in
-// exactly same order. Each submesh is described as 4 values:
-// base vertex, vertex count, base triangle, triangle count. That is,
-//   const unsigned char* t = &dmesh.tris[(tbase+i)*4]; and
-//   const float* v = &dmesh.verts[(vbase+t[j])*3];
-// If the input polygon has 'n' vertices, those vertices are first in the
-// submesh vertex list. This allows to compres the mesh by not storing the
-// first vertices and using the polymesh vertices instead.
-// Max number of vertices per submesh is 127 and
-// max number of triangles per submesh is 255.
-
+/// Detail mesh generated from a rcPolyMesh.
+/// Each submesh represents a polygon in the polymesh and they are stored in
+/// exactly same order. Each submesh is described as 4 values:
+/// base vertex, vertex count, base triangle, triangle count. That is,
+///   const unsigned char* t = &dmesh.tris[(tbase+i)*4]; and
+///   const float* v = &dmesh.verts[(vbase+t[j])*3];
+/// If the input polygon has 'n' vertices, those vertices are first in the
+/// submesh vertex list. This allows to compres the mesh by not storing the
+/// first vertices and using the polymesh vertices instead.
+/// Max number of vertices per submesh is 127 and
+/// max number of triangles per submesh is 255.
 struct rcPolyMeshDetail
 {
-	unsigned int* meshes;	// Pointer to all mesh data.
-	float* verts;			// Pointer to all vertex data.
-	unsigned char* tris;	// Pointer to all triangle data.
-	int nmeshes;			// Number of meshes.
-	int nverts;				// Number of total vertices.
-	int ntris;				// Number of triangles.
+	unsigned int* meshes;	///< Pointer to all mesh data.
+	float* verts;			///< Pointer to all vertex data.
+	unsigned char* tris;	///< Pointer to all triangle data.
+	int nmeshes;			///< Number of meshes.
+	int nverts;				///< Number of total vertices.
+	int ntris;				///< Number of triangles.
 };
 
 rcPolyMeshDetail* rcAllocPolyMeshDetail();
 void rcFreePolyMeshDetail(rcPolyMeshDetail* dmesh);
 
 
-// If heightfield region ID has the following bit set, the region is on border area
-// and excluded from many calculations.
+/// If heightfield region ID has the following bit set, the region is on border area
+/// and excluded from many calculations.
 static const unsigned short RC_BORDER_REG = 0x8000;
 
-// If contour region ID has the following bit set, the vertex will be later
-// removed in order to match the segments and vertices at tile boundaries.
+/// If contour region ID has the following bit set, the vertex will be later
+/// removed in order to match the segments and vertices at tile boundaries.
 static const int RC_BORDER_VERTEX = 0x10000;
 
 static const int RC_AREA_BORDER = 0x20000;
 
 enum rcBuildContoursFlags
 {
-	RC_CONTOUR_TESS_WALL_EDGES = 0x01,	// Tessellate wall edges
-	RC_CONTOUR_TESS_AREA_EDGES = 0x02,	// Tessellate edges between areas.
+	RC_CONTOUR_TESS_WALL_EDGES = 0x01,	///< Tessellate wall edges
+	RC_CONTOUR_TESS_AREA_EDGES = 0x02,	///< Tessellate edges between areas.
 };
 
-// Mask used with contours to extract region id.
+/// Mask used with contours to extract region id.
 static const int RC_CONTOUR_REG_MASK = 0xffff;
 
-// Null index which is used with meshes to mark unset or invalid indices.
+/// Null index which is used with meshes to mark unset or invalid indices.
 static const unsigned short RC_MESH_NULL_IDX = 0xffff;
 
-// Area ID that is considered empty.
+/// Area ID that is considered empty.
 static const unsigned char RC_NULL_AREA = 0;
 
-// Area ID that is considered generally walkable.
+/// Area ID that is considered generally walkable.
 static const unsigned char RC_WALKABLE_AREA = 63;
 
-// Value returned by rcGetCon() if the direction is not connected.
+/// Value returned by rcGetCon() if the direction is not connected.
 static const int RC_NOT_CONNECTED = 0x3f;
 
-// Compact span neighbour helpers.
+/// Compact span neighbour helpers.
 inline void rcSetCon(rcCompactSpan& s, int dir, int i)
 {
 	const unsigned int shift = (unsigned int)dir*6;
@@ -360,7 +362,8 @@ inline int rcGetDirOffsetY(int dir)
 	return offset[dir&0x03];
 }
 
-// Common helper functions
+/// @name Common helper functions
+///@{
 template<class T> inline void rcSwap(T& a, T& b) { T t = a; a = b; b = t; }
 template<class T> inline T rcMin(T a, T b) { return a < b ? a : b; }
 template<class T> inline T rcMax(T a, T b) { return a > b ? a : b; }
@@ -369,8 +372,10 @@ template<class T> inline T rcSqr(T a) { return a*a; }
 template<class T> inline T rcClamp(T v, T mn, T mx) { return v < mn ? mn : (v > mx ? mx : v); }
 float rcSqrt(float x);
 inline int rcAlign4(int x) { return (x+3) & ~3; }
+///@}
 
-// Common vector helper functions.
+/// @name Common vector helper functions.
+///@{
 inline void rcVcross(float* dest, const float* v1, const float* v2)
 {
 	dest[0] = v1[1]*v2[2] - v1[2]*v2[1];
@@ -455,283 +460,256 @@ inline bool rcVequal(const float* p0, const float* p1)
 	const float d = rcVdistSqr(p0, p1);
 	return d < thr;
 }
+///@}
 
-// Calculated bounding box of array of vertices.
-// Params:
-//	verts - (in) array of vertices
-//	nv - (in) vertex count
-//	bmin, bmax - (out) bounding box
+/// Calculated bounding box of array of vertices.
+///  @param verts [in] array of vertices
+///  @param nv [in] vertex count
+///  @param bmin,bmax [out] bounding box
 void rcCalcBounds(const float* verts, int nv, float* bmin, float* bmax);
 
-// Calculates grid size based on bounding box and grid cell size.
-// Params:
-//	bmin, bmax - (in) bounding box
-//	cs - (in) grid cell size
-//	w - (out) grid width
-//	h - (out) grid height
+/// Calculates grid size based on bounding box and grid cell size.
+///  @param bmin,bmax [in] bounding box
+///  @param cs [in] grid cell size
+///  @param w [out] grid width
+///  @param h [out] grid height
 void rcCalcGridSize(const float* bmin, const float* bmax, float cs, int* w, int* h);
 
-// Creates and initializes new heightfield.
-// Params:
-//	hf - (in/out) heightfield to initialize.
-//	width - (in) width of the heightfield.
-//	height - (in) height of the heightfield.
-//	bmin, bmax - (in) bounding box of the heightfield
-//	cs - (in) grid cell size
-//	ch - (in) grid cell height
+/// Creates and initializes new heightfield.
+///  @param hf [in,out] heightfield to initialize.
+///  @param width [in] width of the heightfield.
+///  @param height [in] height of the heightfield.
+///  @param bmin,bmax [in] bounding box of the heightfield
+///  @param cs [in] grid cell size
+///  @param ch [in] grid cell height
 bool rcCreateHeightfield(rcContext* ctx, rcHeightfield& hf, int width, int height,
 						 const float* bmin, const float* bmax,
 						 float cs, float ch);
 
-// Sets the RC_WALKABLE_AREA for every triangle whose slope is below
-// the maximum walkable slope angle.
-// Params:
-//	walkableSlopeAngle - (in) maximum slope angle in degrees.
-//	verts - (in) array of vertices
-//	nv - (in) vertex count
-//	tris - (in) array of triangle vertex indices
-//	nt - (in) triangle count
-//	areas - (out) array of triangle area types
+/// Sets the RC_WALKABLE_AREA for every triangle whose slope is below
+/// the maximum walkable slope angle.
+///  @param walkableSlopeAngle [in] maximum slope angle in degrees.
+///  @param verts [in] array of vertices
+///  @param nv [in] vertex count
+///  @param tris [in] array of triangle vertex indices
+///  @param nt [in] triangle count
+///  @param areas [out] array of triangle area types
 void rcMarkWalkableTriangles(rcContext* ctx, const float walkableSlopeAngle, const float* verts, int nv,
 							 const int* tris, int nt, unsigned char* areas); 
 
-// Sets the RC_NULL_AREA for every triangle whose slope is steeper than
-// the maximum walkable slope angle.
-// Params:
-//	walkableSlopeAngle - (in) maximum slope angle in degrees.
-//	verts - (in) array of vertices
-//	nv - (in) vertex count
-//	tris - (in) array of triangle vertex indices
-//	nt - (in) triangle count
-//	areas - (out) array of triangle are types
+/// Sets the RC_NULL_AREA for every triangle whose slope is steeper than
+/// the maximum walkable slope angle.
+///  @param walkableSlopeAngle [in] maximum slope angle in degrees.
+///  @param verts [in] array of vertices
+///  @param nv [in] vertex count
+///  @param tris [in] array of triangle vertex indices
+///  @param nt [in] triangle count
+///  @param areas [out] array of triangle are types
 void rcClearUnwalkableTriangles(rcContext* ctx, const float walkableSlopeAngle, const float* verts, int nv,
 								const int* tris, int nt, unsigned char* areas); 
 
-// Adds span to heightfield.
-// The span addition can set to favor flags. If the span is merged to
-// another span and the new smax is within 'flagMergeThr' units away
-// from the existing span the span flags are merged and stored.
-// Params:
-//	solid - (in) heightfield where the spans is added to
-//  x,y - (in) location on the heightfield where the span is added
-//  smin,smax - (in) spans min/max height
-//  flags - (in) span flags (zero or WALKABLE)
-//  flagMergeThr - (in) merge threshold.
+/// Adds span to heightfield.
+/// The span addition can set to favor flags. If the span is merged to
+/// another span and the new smax is within 'flagMergeThr' units away
+/// from the existing span the span flags are merged and stored.
+///  @param x,y [in] location on the heightfield where the span is added
+///  @param smin,smax [in] spans min/max height
+///  @param area
+///  @param flagMergeThr [in] merge threshold.
 void rcAddSpan(rcContext* ctx, rcHeightfield& hf, const int x, const int y,
 			   const unsigned short smin, const unsigned short smax,
 			   const unsigned char area, const int flagMergeThr);
 
-// Rasterizes a triangle into heightfield spans.
-// Params:
-//	v0,v1,v2 - (in) the vertices of the triangle.
-//	area - (in) area type of the triangle.
-//	solid - (in) heightfield where the triangle is rasterized
-//  flagMergeThr - (in) distance in voxel where walkable flag is favored over non-walkable.
+/// Rasterizes a triangle into heightfield spans.
+///  @param v0,v1,v2 [in] the vertices of the triangle.
+///  @param area [in] area type of the triangle.
+///  @param solid [in] heightfield where the triangle is rasterized
+///  @param flagMergeThr [in] distance in voxel where walkable flag is favored over non-walkable.
 void rcRasterizeTriangle(rcContext* ctx, const float* v0, const float* v1, const float* v2,
 						 const unsigned char area, rcHeightfield& solid,
 						 const int flagMergeThr = 1);
 
-// Rasterizes indexed triangle mesh into heightfield spans.
-// Params:
-//	verts - (in) array of vertices
-//	nv - (in) vertex count
-//	tris - (in) array of triangle vertex indices
-//	area - (in) array of triangle area types.
-//	nt - (in) triangle count
-//	solid - (in) heightfield where the triangles are rasterized
-//  flagMergeThr - (in) distance in voxel where walkable flag is favored over non-walkable.
+/// Rasterizes indexed triangle mesh into heightfield spans.
+///  @param verts [in] array of vertices
+///  @param nv [in] vertex count
+///  @param tris [in] array of triangle vertex indices
+///  @param areas [in] array of triangle area types.
+///  @param nt [in] triangle count
+///  @param solid [in] heightfield where the triangles are rasterized
+///  @param flagMergeThr [in] distance in voxel where walkable flag is favored over non-walkable.
 void rcRasterizeTriangles(rcContext* ctx, const float* verts, const int nv,
 						  const int* tris, const unsigned char* areas, const int nt,
 						  rcHeightfield& solid, const int flagMergeThr = 1);
 
-// Rasterizes indexed triangle mesh into heightfield spans.
-// Params:
-//	verts - (in) array of vertices
-//	nv - (in) vertex count
-//	tris - (in) array of triangle vertex indices
-//	area - (in) array of triangle area types.
-//	nt - (in) triangle count
-//	solid - (in) heightfield where the triangles are rasterized
-//  flagMergeThr - (in) distance in voxel where walkable flag is favored over non-walkable.
+/// Rasterizes indexed triangle mesh into heightfield spans.
+///  @param verts [in] array of vertices
+///  @param nv [in] vertex count
+///  @param tris [in] array of triangle vertex indices
+///  @param areas [in] array of triangle area types.
+///  @param nt [in] triangle count
+///  @param solid [in] heightfield where the triangles are rasterized
+///  @param flagMergeThr [in] distance in voxel where walkable flag is favored over non-walkable.
 void rcRasterizeTriangles(rcContext* ctx, const float* verts, const int nv,
 						  const unsigned short* tris, const unsigned char* areas, const int nt,
 						  rcHeightfield& solid, const int flagMergeThr = 1);
 
-// Rasterizes the triangles into heightfield spans.
-// Params:
-//	verts - (in) array of vertices
-//	area - (in) array of triangle area types.
-//	nt - (in) triangle count
-//	solid - (in) heightfield where the triangles are rasterized
+/// Rasterizes the triangles into heightfield spans.
+///  @param verts [in] array of vertices
+///  @param areas [in] array of triangle area types.
+///  @param nt [in] triangle count
+///  @param solid [in] heightfield where the triangles are rasterized
 void rcRasterizeTriangles(rcContext* ctx, const float* verts, const unsigned char* areas, const int nt,
 						  rcHeightfield& solid, const int flagMergeThr = 1);
 
-// Marks non-walkable low obstacles as walkable if they are closer than walkableClimb
-// from a walkable surface. Applying this filter allows to step over low hanging
-// low obstacles.
-// Params:
-//	walkableHeight - (in) minimum height where the agent can still walk
-//	solid - (in/out) heightfield describing the solid space
-// TODO: Missuses ledge flag, must be called before rcFilterLedgeSpans!
+/// Marks non-walkable low obstacles as walkable if they are closer than walkableClimb
+/// from a walkable surface. Applying this filter allows to step over low hanging
+/// low obstacles.
+///  @param walkableClimb [in] maximum height between grid cells the agent can climb
+///  @param solid [in,out] heightfield describing the solid space
+/// @warning TODO: Misses ledge flag, must be called before rcFilterLedgeSpans!
 void rcFilterLowHangingWalkableObstacles(rcContext* ctx, const int walkableClimb, rcHeightfield& solid);
 
-// Removes WALKABLE flag from all spans that are at ledges. This filtering
-// removes possible overestimation of the conservative voxelization so that
-// the resulting mesh will not have regions hanging in air over ledges.
-// Params:
-//	walkableHeight - (in) minimum height where the agent can still walk
-//	walkableClimb - (in) maximum height between grid cells the agent can climb
-//	solid - (in/out) heightfield describing the solid space
+/// Removes WALKABLE flag from all spans that are at ledges. This filtering
+/// removes possible overestimation of the conservative voxelization so that
+/// the resulting mesh will not have regions hanging in air over ledges.
+///  @param walkableHeight [in] minimum height where the agent can still walk
+///  @param walkableClimb [in] maximum height between grid cells the agent can climb
+///  @param solid [in,out] heightfield describing the solid space
 void rcFilterLedgeSpans(rcContext* ctx, const int walkableHeight,
 						const int walkableClimb, rcHeightfield& solid);
 
-// Removes WALKABLE flag from all spans which have smaller than
-// 'walkableHeight' clearance above them.
-// Params:
-//	walkableHeight - (in) minimum height where the agent can still walk
-//	solid - (in/out) heightfield describing the solid space
+/// Removes WALKABLE flag from all spans which have smaller than
+/// 'walkableHeight' clearance above them.
+///  @param walkableHeight [in] minimum height where the agent can still walk
+///  @param solid [in,out] heightfield describing the solid space
 void rcFilterWalkableLowHeightSpans(rcContext* ctx, int walkableHeight, rcHeightfield& solid);
 
-// Returns number of spans contained in a heightfield.
-// Params:
-//	hf - (in) heightfield to be compacted
-// Returns number of spans.
+/// Returns number of spans contained in a heightfield.
+///  @param hf [in] heightfield to be compacted
+///  @returns number of spans.
 int rcGetHeightFieldSpanCount(rcContext* ctx, rcHeightfield& hf);
 
-// Builds compact representation of the heightfield.
-// Params:
-//	walkableHeight - (in) minimum height where the agent can still walk
-//	walkableClimb - (in) maximum height between grid cells the agent can climb
-//	hf - (in) heightfield to be compacted
-//	chf - (out) compact heightfield representing the open space.
-// Returns false if operation ran out of memory.
+/// Builds compact representation of the heightfield.
+///  @param walkableHeight [in] minimum height where the agent can still walk
+///  @param walkableClimb [in] maximum height between grid cells the agent can climb
+///  @param hf [in] heightfield to be compacted
+///  @param chf [out] compact heightfield representing the open space.
+///  @returns false if operation ran out of memory.
 bool rcBuildCompactHeightfield(rcContext* ctx, const int walkableHeight, const int walkableClimb,
 							   rcHeightfield& hf, rcCompactHeightfield& chf);
 
-// Erodes walkable area.
-// Params:
-//  radius - (in) radius of erosion (max 255).
-//	chf - (in/out) compact heightfield to erode.
-// Returns false if operation ran out of memory.
+/// Erodes walkable area.
+///  @param radius [in] radius of erosion (max 255).
+///  @param chf [in,out] compact heightfield to erode.
+///  @returns false if operation ran out of memory.
 bool rcErodeWalkableArea(rcContext* ctx, int radius, rcCompactHeightfield& chf);
 
-// Applies median filter to walkable area types, removing noise.
-// Params:
-//	chf - (in/out) compact heightfield to erode.
-// Returns false if operation ran out of memory.
+/// Applies median filter to walkable area types, removing noise.
+///  @param chf [in,out] compact heightfield to erode.
+///  @returns false if operation ran out of memory.
 bool rcMedianFilterWalkableArea(rcContext* ctx, rcCompactHeightfield& chf);
 
-// Marks the area of the convex polygon into the area type of the compact heightfield.
-// Params:
-//  bmin/bmax - (in) bounds of the axis aligned box.
-//  areaId - (in) area ID to mark.
-//	chf - (in/out) compact heightfield to mark.
+/// Marks the area of the convex polygon into the area type of the compact heightfield.
+///  @param bmin,bmax [in] bounds of the axis aligned box.
+///  @param areaId [in] area ID to mark.
+///  @param chf [in,out] compact heightfield to mark.
 void rcMarkBoxArea(rcContext* ctx, const float* bmin, const float* bmax, unsigned char areaId,
 				   rcCompactHeightfield& chf);
 
-// Marks the area of the convex polygon into the area type of the compact heightfield.
-// Params:
-//  verts - (in) vertices of the convex polygon.
-//  nverts - (in) number of vertices in the polygon.
-//  hmin/hmax - (in) min and max height of the polygon.
-//  areaId - (in) area ID to mark.
-//	chf - (in/out) compact heightfield to mark.
+/// Marks the area of the convex polygon into the area type of the compact heightfield.
+///  @param verts [in] vertices of the convex polygon.
+///  @param nverts [in] number of vertices in the polygon.
+///  @param hmin,hmax [in] min and max height of the polygon.
+///  @param areaId [in] area ID to mark.
+///  @param chf [in,out] compact heightfield to mark.
 void rcMarkConvexPolyArea(rcContext* ctx, const float* verts, const int nverts,
 						  const float hmin, const float hmax, unsigned char areaId,
 						  rcCompactHeightfield& chf);
 
-// Marks the area of the cylinder into the area type of the compact heightfield.
-// Params:
-//  pos - (in) center bottom location of hte cylinder.
-//  r - (in) radius of the cylinder.
-//  h - (in) height of the cylinder.
-//  areaId - (in) area ID to mark.
-//	chf - (in/out) compact heightfield to mark.
+/// Marks the area of the cylinder into the area type of the compact heightfield.
+///  @param pos [in] center bottom location of hte cylinder.
+///  @param r [in] radius of the cylinder.
+///  @param h [in] height of the cylinder.
+///  @param areaId [in] area ID to mark.
+///  @param chf [in,out] compact heightfield to mark.
 void rcMarkCylinderArea(rcContext* ctx, const float* pos,
 						const float r, const float h, unsigned char areaId,
 						rcCompactHeightfield& chf);
 
-// Builds distance field and stores it into the combat heightfield.
-// Params:
-//	chf - (in/out) compact heightfield representing the open space.
-// Returns false if operation ran out of memory.
+/// Builds distance field and stores it into the combat heightfield.
+///  @param chf [in,out] compact heightfield representing the open space.
+///  @returns false if operation ran out of memory.
 bool rcBuildDistanceField(rcContext* ctx, rcCompactHeightfield& chf);
 
-// Divides the walkable heighfied into simple regions using watershed partitioning.
-// Each region has only one contour and no overlaps.
-// The regions are stored in the compact heightfield 'reg' field.
-// The process sometimes creates small regions. If the area of a regions is
-// smaller than 'mergeRegionArea' then the region will be merged with a neighbour
-// region if possible. If multiple regions form an area which is smaller than
-// 'minRegionArea' all the regions belonging to that area will be removed.
-// Here area means the count of spans in an area.
-// Params:
-//	chf - (in/out) compact heightfield representing the open space.
-//  borderSize - (in) Non-navigable Border around the heightfield.
-//	minRegionArea - (in) the smallest allowed region area.
-//	maxMergeRegionArea - (in) the largest allowed region area which can be merged.
-// Returns false if operation ran out of memory.
+/// Divides the walkable heighfied into simple regions using watershed partitioning.
+/// Each region has only one contour and no overlaps.
+/// The regions are stored in the compact heightfield 'reg' field.
+/// The process sometimes creates small regions. If the area of a regions is
+/// smaller than 'mergeRegionArea' then the region will be merged with a neighbour
+/// region if possible. If multiple regions form an area which is smaller than
+/// 'minRegionArea' all the regions belonging to that area will be removed.
+/// Here area means the count of spans in an area.
+///  @param chf [in,out] compact heightfield representing the open space.
+///  @param borderSize [in] Non-navigable Border around the heightfield.
+///  @param minRegionArea [in] the smallest allowed region area.
+///  @param maxMergeRegionArea [in] the largest allowed region area which can be merged.
+///  @returns false if operation ran out of memory.
 bool rcBuildRegions(rcContext* ctx, rcCompactHeightfield& chf,
 					const int borderSize, const int minRegionArea, const int mergeRegionArea);
 
-// Divides the walkable heighfied into simple regions using simple monotone partitioning.
-// Each region has only one contour and no overlaps.
-// The regions are stored in the compact heightfield 'reg' field.
-// The process sometimes creates small regions. If the area of a regions is
-// smaller than 'mergeRegionArea' then the region will be merged with a neighbour
-// region if possible. If multiple regions form an area which is smaller than
-// 'minRegionArea' all the regions belonging to that area will be removed.
-// Here area means the count of spans in an area.
-// Params:
-//	chf - (in/out) compact heightfield representing the open space.
-//  borderSize - (in) Non-navigable Border around the heightfield.
-//	minRegionArea - (in) the smallest allowed regions size.
-//	maxMergeRegionArea - (in) the largest allowed regions size which can be merged.
-// Returns false if operation ran out of memory.
+/// Divides the walkable heighfied into simple regions using simple monotone partitioning.
+/// Each region has only one contour and no overlaps.
+/// The regions are stored in the compact heightfield 'reg' field.
+/// The process sometimes creates small regions. If the area of a regions is
+/// smaller than 'mergeRegionArea' then the region will be merged with a neighbour
+/// region if possible. If multiple regions form an area which is smaller than
+/// 'minRegionArea' all the regions belonging to that area will be removed.
+/// Here area means the count of spans in an area.
+///  @param chf [in,out] compact heightfield representing the open space.
+///  @param borderSize [in] Non-navigable Border around the heightfield.
+///  @param minRegionArea [in] the smallest allowed regions size.
+///  @param maxMergeRegionArea [in] the largest allowed regions size which can be merged.
+///  @returns false if operation ran out of memory.
 bool rcBuildRegionsMonotone(rcContext* ctx, rcCompactHeightfield& chf,
 							const int borderSize, const int minRegionArea, const int mergeRegionArea);
 
-// Builds 2D layer representation of a heighfield.
-// Params:
-//  chf - (in) compact heightfield representing the open space.
-//  borderSize - (in) Non-navigable Border around the heightfield.
-//	walkableHeight - (in) minimum height where the agent can still walk.
-//  lset - (out) set of 2D heighfield layers.
-// Returns false if operation ran out of memory.
+/// Builds 2D layer representation of a heighfield.
+///  @param chf [in] compact heightfield representing the open space.
+///  @param borderSize [in] Non-navigable Border around the heightfield.
+///  @param walkableHeight [in] minimum height where the agent can still walk.
+///  @param lset [out] set of 2D heighfield layers.
+///  @returns false if operation ran out of memory.
 bool rcBuildHeightfieldLayers(rcContext* ctx, rcCompactHeightfield& chf, 
 							  const int borderSize, const int walkableHeight,
 							  rcHeightfieldLayerSet& lset);
 
-// Builds simplified contours from the regions outlines.
-// Params:
-//	chf - (in) compact heightfield which has regions set.
-//	maxError - (in) maximum allowed distance between simplified contour and cells.
-//	maxEdgeLen - (in) maximum allowed contour edge length in cells.
-//	cset - (out) Resulting contour set.
-//	flags - (in) build flags, see rcBuildContoursFlags.
-// Returns false if operation ran out of memory.
+/// Builds simplified contours from the regions outlines.
+///  @param chf [in] compact heightfield which has regions set.
+///  @param maxError [in] maximum allowed distance between simplified contour and cells.
+///  @param maxEdgeLen [in] maximum allowed contour edge length in cells.
+///  @param cset [out] Resulting contour set.
+///  @param flags [in] build flags, see rcBuildContoursFlags.
+///  @returns false if operation ran out of memory.
 bool rcBuildContours(rcContext* ctx, rcCompactHeightfield& chf,
 					 const float maxError, const int maxEdgeLen,
 					 rcContourSet& cset, const int flags = RC_CONTOUR_TESS_WALL_EDGES);
 
-// Builds connected convex polygon mesh from contour polygons.
-// Params:
-//	cset - (in) contour set.
-//	nvp - (in) maximum number of vertices per polygon.
-//	mesh - (out) poly mesh.
-// Returns false if operation ran out of memory.
+/// Builds connected convex polygon mesh from contour polygons.
+///  @param cset [in] contour set.
+///  @param nvp [in] maximum number of vertices per polygon.
+///  @param mesh [out] poly mesh.
+///  @returns false if operation ran out of memory.
 bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, const int nvp, rcPolyMesh& mesh);
 
 bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, rcPolyMesh& mesh);
 
-// Builds detail triangle mesh for each polygon in the poly mesh.
-// Params:
-//	mesh - (in) poly mesh to detail.
-//	chf - (in) compact height field, used to query height for new vertices.
-//  sampleDist - (in) spacing between height samples used to generate more detail into mesh.
-//  sampleMaxError - (in) maximum allowed distance between simplified detail mesh and height sample.
-//	dmesh - (out) detail mesh.
-// Returns false if operation ran out of memory.
+/// Builds detail triangle mesh for each polygon in the poly mesh.
+///  @param mesh [in] poly mesh to detail.
+///  @param chf [in] compact height field, used to query height for new vertices.
+///  @param sampleDist [in] spacing between height samples used to generate more detail into mesh.
+///  @param sampleMaxError [in] maximum allowed distance between simplified detail mesh and height sample.
+///  @param dmesh [out] detail mesh.
+///  @returns false if operation ran out of memory.
 bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompactHeightfield& chf,
 						   const float sampleDist, const float sampleMaxError,
 						   rcPolyMeshDetail& dmesh);
diff --git a/Recast/Include/RecastAlloc.h b/Recast/Include/RecastAlloc.h
index 9a31637..7aa928c 100644
--- a/Recast/Include/RecastAlloc.h
+++ b/Recast/Include/RecastAlloc.h
@@ -21,8 +21,8 @@
 
 enum rcAllocHint
 {
-	RC_ALLOC_PERM,		// Memory persist after a function call.
-	RC_ALLOC_TEMP		// Memory used temporarily within a function.
+	RC_ALLOC_PERM,		///< Memory persist after a function call.
+	RC_ALLOC_TEMP		///< Memory used temporarily within a function.
 };
 
 typedef void* (rcAllocFunc)(int size, rcAllocHint hint);
@@ -35,7 +35,7 @@ void rcFree(void* ptr);
 
 
 
-// Simple dynamic array ints.
+/// Simple dynamic array ints.
 class rcIntArray
 {
 	int* m_data;
@@ -54,7 +54,7 @@ public:
 	inline int size() const { return m_size; }
 };
 
-// Simple internal helper class to delete array in scope
+/// Simple internal helper class to delete array in scope
 template<class T> class rcScopedDelete
 {
 	T* ptr;
diff --git a/RecastDemo/Include/ChunkyTriMesh.h b/RecastDemo/Include/ChunkyTriMesh.h
index 9be7788..0336c1d 100644
--- a/RecastDemo/Include/ChunkyTriMesh.h
+++ b/RecastDemo/Include/ChunkyTriMesh.h
@@ -37,15 +37,15 @@ struct rcChunkyTriMesh
 	int maxTrisPerChunk;
 };
 
-// Creates partitioned triangle mesh (AABB tree),
-// where each node contains at max trisPerChunk triangles.
+/// Creates partitioned triangle mesh (AABB tree),
+/// where each node contains at max trisPerChunk triangles.
 bool rcCreateChunkyTriMesh(const float* verts, const int* tris, int ntris,
 						   int trisPerChunk, rcChunkyTriMesh* cm);
 
-// Returns the chunk indices which overlap the input rectable.
+/// Returns the chunk indices which overlap the input rectable.
 int rcGetChunksOverlappingRect(const rcChunkyTriMesh* cm, float bmin[2], float bmax[2], int* ids, const int maxIds);
 
-// Returns the chunk indices which overlap the input segment.
+/// Returns the chunk indices which overlap the input segment.
 int rcGetChunksOverlappingSegment(const rcChunkyTriMesh* cm, float p[2], float q[2], int* ids, const int maxIds);
 
 
diff --git a/RecastDemo/Include/InputGeom.h b/RecastDemo/Include/InputGeom.h
index 349e6d5..b508f68 100644
--- a/RecastDemo/Include/InputGeom.h
+++ b/RecastDemo/Include/InputGeom.h
@@ -37,7 +37,8 @@ class InputGeom
 	rcMeshLoaderObj* m_mesh;
 	float m_meshBMin[3], m_meshBMax[3];
 	
-	// Off-Mesh connections.
+	/// @name Off-Mesh connections.
+	///@{
 	static const int MAX_OFFMESH_CONNECTIONS = 256;
 	float m_offMeshConVerts[MAX_OFFMESH_CONNECTIONS*3*2];
 	float m_offMeshConRads[MAX_OFFMESH_CONNECTIONS];
@@ -46,11 +47,14 @@ class InputGeom
 	unsigned short m_offMeshConFlags[MAX_OFFMESH_CONNECTIONS];
 	unsigned int m_offMeshConId[MAX_OFFMESH_CONNECTIONS];
 	int m_offMeshConCount;
+	///@}
 
-	// Convex Volumes.
+	/// @name Convex Volumes.
+	///@{
 	static const int MAX_VOLUMES = 256;
 	ConvexVolume m_volumes[MAX_VOLUMES];
 	int m_volumeCount;
+	///@}
 	
 public:
 	InputGeom();
@@ -61,14 +65,15 @@ public:
 	bool load(class rcContext* ctx, const char* filepath);
 	bool save(const char* filepath);
 	
-	// Method to return static mesh data.
+	/// Method to return static mesh data.
 	inline const rcMeshLoaderObj* getMesh() const { return m_mesh; }
 	inline const float* getMeshBoundsMin() const { return m_meshBMin; }
 	inline const float* getMeshBoundsMax() const { return m_meshBMax; }
 	inline const rcChunkyTriMesh* getChunkyMesh() const { return m_chunkyMesh; }
 	bool raycastMesh(float* src, float* dst, float& tmin);
 
-	// Off-Mesh connections.
+	/// @name Off-Mesh connections.
+	///@{
 	int getOffMeshConnectionCount() const { return m_offMeshConCount; }
 	const float* getOffMeshConnectionVerts() const { return m_offMeshConVerts; }
 	const float* getOffMeshConnectionRads() const { return m_offMeshConRads; }
@@ -80,14 +85,17 @@ public:
 							  unsigned char bidir, unsigned char area, unsigned short flags);
 	void deleteOffMeshConnection(int i);
 	void drawOffMeshConnections(struct duDebugDraw* dd, bool hilight = false);
+	///@}
 
-	// Box Volumes.
+	/// @name Box Volumes.
+	///@{
 	int getConvexVolumeCount() const { return m_volumeCount; }
 	const ConvexVolume* getConvexVolumes() const { return m_volumes; }
 	void addConvexVolume(const float* verts, const int nverts,
 						 const float minh, const float maxh, unsigned char area);
 	void deleteConvexVolume(int i);
 	void drawConvexVolumes(struct duDebugDraw* dd, bool hilight = false);
+	///@}
 };
 
 #endif // INPUTGEOM_H
diff --git a/RecastDemo/Include/Sample.h b/RecastDemo/Include/Sample.h
index 48dc9e0..87e8425 100644
--- a/RecastDemo/Include/Sample.h
+++ b/RecastDemo/Include/Sample.h
@@ -23,7 +23,7 @@
 #include "SampleInterfaces.h"
 
 
-// Tool types.
+/// Tool types.
 enum SampleToolType
 {
 	TOOL_NONE = 0,
@@ -36,8 +36,8 @@ enum SampleToolType
 	TOOL_CROWD,
 };
 
-// These are just sample areas to use consistent values across the samples.
-// The use should specify these base on his needs.
+/// These are just sample areas to use consistent values across the samples.
+/// The use should specify these base on his needs.
 enum SamplePolyAreas
 {
 	SAMPLE_POLYAREA_GROUND,
@@ -49,11 +49,11 @@ enum SamplePolyAreas
 };
 enum SamplePolyFlags
 {
-	SAMPLE_POLYFLAGS_WALK = 0x01,		// Ability to walk (ground, grass, road)
-	SAMPLE_POLYFLAGS_SWIM = 0x02,		// Ability to swim (water).
-	SAMPLE_POLYFLAGS_DOOR = 0x04,		// Ability to move through doors.
-	SAMPLE_POLYFLAGS_JUMP = 0x08,		// Ability to jump.
-	SAMPLE_POLYFLAGS_ALL = 0xffff		// All abilities.
+	SAMPLE_POLYFLAGS_WALK = 0x01,		///< Ability to walk (ground, grass, road)
+	SAMPLE_POLYFLAGS_SWIM = 0x02,		///< Ability to swim (water).
+	SAMPLE_POLYFLAGS_DOOR = 0x04,		///< Ability to move through doors.
+	SAMPLE_POLYFLAGS_JUMP = 0x08,		///< Ability to jump.
+	SAMPLE_POLYFLAGS_ALL = 0xffff		///< All abilities.
 };
 
 struct SampleTool
diff --git a/RecastDemo/Include/SampleInterfaces.h b/RecastDemo/Include/SampleInterfaces.h
index a0ea6ef..5095188 100644
--- a/RecastDemo/Include/SampleInterfaces.h
+++ b/RecastDemo/Include/SampleInterfaces.h
@@ -26,7 +26,7 @@
 
 // These are example implementations of various interfaces used in Recast and Detour.
 
-// Recast build context.
+/// Recast build context.
 class BuildContext : public rcContext
 {
 	TimeVal m_startTime[RC_MAX_TIMERS];
@@ -43,24 +43,26 @@ public:
 	BuildContext();
 	virtual ~BuildContext();
 	
-	// Dumps the log to stdout.
+	/// Dumps the log to stdout.
 	void dumpLog(const char* format, ...);
-	// Returns number of log messages.
+	/// Returns number of log messages.
 	int getLogCount() const;
-	// Returns log message text.
+	/// Returns log message text.
 	const char* getLogText(const int i) const;
 	
 protected:	
-	// Virtual functions for custom implementations.
+	/// Virtual functions for custom implementations.
+	///@{
 	virtual void doResetLog();
 	virtual void doLog(const rcLogCategory /*category*/, const char* /*msg*/, const int /*len*/);
 	virtual void doResetTimers();
 	virtual void doStartTimer(const rcTimerLabel /*label*/);
 	virtual void doStopTimer(const rcTimerLabel /*label*/);
 	virtual int doGetAccumulatedTime(const rcTimerLabel /*label*/) const;
+	///@}
 };
 
-// OpenGL debug draw implementation.
+/// OpenGL debug draw implementation.
 class DebugDrawGL : public duDebugDraw
 {
 public:
@@ -74,7 +76,7 @@ public:
 	virtual void end();
 };
 
-// stdio file implementation.
+/// stdio file implementation.
 class FileIO : public duFileIO
 {
 	FILE* m_fp;
diff --git a/RecastDemo/Include/Sample_Debug.h b/RecastDemo/Include/Sample_Debug.h
index 5df1ccf..1790dbb 100644
--- a/RecastDemo/Include/Sample_Debug.h
+++ b/RecastDemo/Include/Sample_Debug.h
@@ -23,7 +23,7 @@
 #include "DetourNavMesh.h"
 #include "Recast.h"
 
-// Sample used for random debugging.
+/// Sample used for random debugging.
 class Sample_Debug : public Sample
 {
 protected: