From 785e9c68bed29b03fb74edcb5296234cd18b5968 Mon Sep 17 00:00:00 2001 From: Mikko Mononen Date: Tue, 17 Aug 2010 17:46:19 +0000 Subject: [PATCH] Missing DetourNavMeshQuery files, plus sliced findPath. --- Detour/Include/DetourNavMeshQuery.h | 339 +++ Detour/Source/DetourNavMeshQuery.cpp | 2331 +++++++++++++++++ .../Bin/Recast.app/Contents/MacOS/Recast | Bin 937180 -> 942100 bytes .../Xcode/Recast.xcodeproj/memon.pbxuser | 1902 +++++++++++++- .../Recast.xcodeproj/memon.perspectivev3 | 126 +- RecastDemo/Include/NavMeshTesterTool.h | 5 +- RecastDemo/Source/NavMeshTesterTool.cpp | 76 +- 7 files changed, 4630 insertions(+), 149 deletions(-) create mode 100644 Detour/Include/DetourNavMeshQuery.h create mode 100644 Detour/Source/DetourNavMeshQuery.cpp diff --git a/Detour/Include/DetourNavMeshQuery.h b/Detour/Include/DetourNavMeshQuery.h new file mode 100644 index 0000000..c56d6e0 --- /dev/null +++ b/Detour/Include/DetourNavMeshQuery.h @@ -0,0 +1,339 @@ +// +// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. +// + +#ifndef DETOURNAVMESHQUERY_H +#define DETOURNAVMESHQUERY_H + +#include "DetourAlloc.h" +#include "DetourNavMesh.h" + +struct dtQueryFilter +{ + dtQueryFilter() : includeFlags(0xffff), excludeFlags(0) {} + unsigned short includeFlags; // If any of the flags are set, the poly is included. + unsigned short excludeFlags; // If any of the flags are set, the poly is excluded. +}; + +enum dtQueryState +{ + DT_QUERY_FAILED = 0, // Path find failed. + DT_QUERY_RUNNING, // Path find running. + DT_QUERY_READY, // Path find results ready. +}; + +class dtNavMeshQuery +{ +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). + // Returns: True if succeed, else false. + bool init(dtNavMesh* nav, const int maxNodes); + + // Sets the pathfinding cost of the specified area. + // Params: + // area - (in) area ID (0-63). + // cost - (int) travel cost of the area. + void setAreaCost(const int area, float cost); + + // Returns the pathfinding cost of the specified area. + // Params: + // area - (in) area ID (0-63). + float getAreaCost(const int area) const; + + // 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. + // nearestPt[3] - (out, opt) The nearest point on found polygon, null if not needed. + // Returns: Reference identifier for the polygon, or 0 if no polygons found. + dtPolyRef findNearestPoly(const float* center, const float* extents, + const dtQueryFilter* filter, 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. + // maxPolys - (in) The max number of polygons the polys array can hold. + // Returns: Number of polygons in search result array. + int queryPolygons(const float* center, const float* extents, const dtQueryFilter* filter, + dtPolyRef* polys, 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. + // maxPathSize - (in) The max number of polygons the path array can hold. + // Returns: Number of polygons in search result array. + int findPath(dtPolyRef startRef, dtPolyRef endRef, + const float* startPos, const float* endPos, + const dtQueryFilter* filter, + dtPolyRef* path, const int maxPathSize) const; + + // Intializes sliced path find query. + // Note: calling any other dtNavMeshQuery method before calling findPathEnd() + // may results in corrupted data! + // 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. + // Returns: Path query state. + dtQueryState 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. + // Returns: Path query state. + dtQueryState updateSlicedFindPath(const int maxIter); + + // Finalizes sliced path find query. + // path - (out) array holding the search result. + // maxPathSize - (in) The max number of polygons the path array can hold. + // Returns: Number of polygons in search result array. + int finalizeSlicedFindPath(dtPolyRef* path, const int maxPathSize); + + // 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. + // maxStraightPathSize - (in) The max number of points the straight path array can hold. + // Returns: Number of points in the path. + int findStraightPath(const float* startPos, const float* endPos, + const dtPolyRef* path, const int pathSize, + float* straightPath, unsigned char* straightPathFlags, dtPolyRef* straightPathRefs, + const int maxStraightPathSize) 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. + // maxVisitedSize - (in) max number of polygons in the visited array. + // Returns: Number of entries in the visited array. + int moveAlongSurface(dtPolyRef startRef, const float* startPos, const float* endPos, + const dtQueryFilter* filter, + float* resultPos, dtPolyRef* visited, 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) visited path polygons. + // pathSize - (in) max number of polygons in the path array. + // Returns: Number of polygons visited or 0 if failed. + int raycast(dtPolyRef startRef, const float* startPos, const float* endPos, const dtQueryFilter* filter, + float& t, float* hitNormal, dtPolyRef* path, const int pathSize) const; + + // Returns distance to nearest wall from the specified location. + // Params: + // centerRef - (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. + // hitPos[3] - (out) location of the nearest hit. + // hitNormal[3] - (out) normal of the nearest hit. + // Returns: Distance to nearest wall from the test location. + float findDistanceToWall(dtPolyRef centerRef, const float* centerPos, float maxRadius, + const dtQueryFilter* filter, 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. + // maxResult - (int) maximum capacity of search results. + // Returns: Number of results. + int findPolysAroundCircle(dtPolyRef startRef, const float* centerPos, const float radius, + const dtQueryFilter* filter, + dtPolyRef* resultRef, dtPolyRef* resultParent, float* resultCost, + 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. + // maxResult - (int) maximum capacity of search results. + // Returns: Number of results. + int findPolysAroundShape(dtPolyRef startRef, const float* verts, const int nverts, + const dtQueryFilter* filter, + dtPolyRef* resultRef, dtPolyRef* resultParent, float* resultCost, + 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. + // maxResult - (int) maximum capacity of search results. + // Returns: Number of results. + int findLocalNeighbourhood(dtPolyRef startRef, const float* centerPos, const float radius, + const dtQueryFilter* filter, + dtPolyRef* resultRef, dtPolyRef* resultParent, const int maxResult) const; + + // Returns wall segments of specified polygon. + // Params: + // ref - (in) ref to the polygon. + // filter - (in) path polygon filter. + // segments[DT_VERTS_PER_POLYGON*3*2] - (out) wall segments. + // Returns: Number of wall segments. + int getPolyWallSegments(dtPolyRef ref, const dtQueryFilter* filter, float* segments); + + // 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. + bool 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. + bool closestPointOnPolyBoundary(dtPolyRef ref, const float* pos, float* closest) 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. + bool getOffMeshConnectionPolyEndPoints(dtPolyRef prevRef, dtPolyRef polyRef, float* startPos, float* endPos) 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. + bool getPolyHeight(dtPolyRef ref, const float* pos, float* height) const; + + // Returns true if poly reference ins in closed list. + bool isInClosedList(dtPolyRef ref) const; + +private: + + // Returns neighbour tile based on side. + dtMeshTile* getNeighbourTileAt(int x, int y, int side) const; + + // 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. + dtPolyRef findNearestPolyInTile(const dtMeshTile* tile, const float* center, const float* extents, + const dtQueryFilter* filter, float* nearestPt) const; + // Returns closest point on polygon. + bool closestPointOnPolyInTile(const dtMeshTile* tile, const dtPoly* poly, const float* pos, float* closest) const; + + // Returns portal points between two polygons. + bool getPortalPoints(dtPolyRef from, dtPolyRef to, float* left, float* right, + unsigned char& fromType, unsigned char& toType) const; + bool 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. + bool getEdgeMidPoint(dtPolyRef from, dtPolyRef to, float* mid) const; + bool getEdgeMidPoint(dtPolyRef from, const dtPoly* fromPoly, const dtMeshTile* fromTile, + dtPolyRef to, const dtPoly* toPoly, const dtMeshTile* toTile, + float* mid) const; + + dtNavMesh* m_nav; // Pointer to navmesh data. + + struct dtQueryData + { + dtQueryState state; + struct dtNode* lastBestNode; + float lastBestNodeCost; + dtPolyRef startRef, endRef; + float startPos[3], endPos[3]; + dtQueryFilter filter; + }; + dtQueryData m_query; // Sliced query state. + + float m_areaCost[DT_MAX_AREAS]; // Cost per area. + + 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. +dtNavMeshQuery* dtAllocNavMeshQuery(); +void dtFreeNavMeshQuery(dtNavMeshQuery* query); + +#endif // DETOURNAVMESHQUERY_H diff --git a/Detour/Source/DetourNavMeshQuery.cpp b/Detour/Source/DetourNavMeshQuery.cpp new file mode 100644 index 0000000..cbf4bf8 --- /dev/null +++ b/Detour/Source/DetourNavMeshQuery.cpp @@ -0,0 +1,2331 @@ +// +// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. +// + +#include +#include +#include +#include +#include "DetourNavMeshQuery.h" +#include "DetourNode.h" +#include "DetourCommon.h" +#include "DetourAlloc.h" +#include "DetourAssert.h" +#include + + +// Search heuristic scale. +static const float H_SCALE = 0.999f; + +inline int opposite(int side) { return (side+4) & 0x7; } + +inline bool overlapBoxes(const float* amin, const float* amax, + const float* bmin, const float* bmax) +{ + bool overlap = true; + overlap = (amin[0] > bmax[0] || amax[0] < bmin[0]) ? false : overlap; + overlap = (amin[1] > bmax[1] || amax[1] < bmin[1]) ? false : overlap; + overlap = (amin[2] > bmax[2] || amax[2] < bmin[2]) ? false : overlap; + return overlap; +} + +inline bool passFilter(const dtQueryFilter* filter, unsigned short flags) +{ + return (flags & filter->includeFlags) != 0 && (flags & filter->excludeFlags) == 0; +} + +dtNavMeshQuery* dtAllocNavMeshQuery() +{ + return new(dtAlloc(sizeof(dtNavMeshQuery), DT_ALLOC_PERM)) dtNavMeshQuery; +} + +void dtFreeNavMeshQuery(dtNavMeshQuery* navmesh) +{ + if (!navmesh) return; + navmesh->~dtNavMeshQuery(); + dtFree(navmesh); +} + +////////////////////////////////////////////////////////////////////////////////////////// +dtNavMeshQuery::dtNavMeshQuery() : + m_tinyNodePool(0), + m_nodePool(0), + m_openList(0) +{ + for (int i = 0; i < DT_MAX_AREAS; ++i) + m_areaCost[i] = 1.0f; + memset(&m_query, 0, sizeof(dtQueryData)); +} + +dtNavMeshQuery::~dtNavMeshQuery() +{ + if (m_tinyNodePool) + m_tinyNodePool->~dtNodePool(); + if (m_nodePool) + m_nodePool->~dtNodePool(); + if (m_openList) + m_openList->~dtNodeQueue(); + dtFree(m_tinyNodePool); + dtFree(m_nodePool); + dtFree(m_openList); +} + +bool dtNavMeshQuery::init(dtNavMesh* nav, const int maxNodes) +{ + m_nav = nav; + + if (!m_nodePool || m_nodePool->getMaxNodes() < maxNodes) + { + if (m_nodePool) + { + m_nodePool->~dtNodePool(); + dtFree(m_nodePool); + m_nodePool = 0; + } + m_nodePool = new (dtAlloc(sizeof(dtNodePool), DT_ALLOC_PERM)) dtNodePool(maxNodes, dtNextPow2(maxNodes/4)); + if (!m_nodePool) + return false; + } + else + { + m_nodePool->clear(); + } + + if (!m_tinyNodePool) + { + m_tinyNodePool = new (dtAlloc(sizeof(dtNodePool), DT_ALLOC_PERM)) dtNodePool(64, 32); + if (!m_tinyNodePool) + return false; + } + else + { + m_tinyNodePool->clear(); + } + + // TODO: check the open list size too. + if (!m_openList || m_openList->getCapacity() < maxNodes) + { + if (m_openList) + { + m_openList->~dtNodeQueue(); + dtFree(m_openList); + m_openList = 0; + } + m_openList = new (dtAlloc(sizeof(dtNodeQueue), DT_ALLOC_PERM)) dtNodeQueue(maxNodes); + if (!m_openList) + return false; + } + else + { + m_openList->clear(); + } + + return true; +} + +////////////////////////////////////////////////////////////////////////////////////////// +bool dtNavMeshQuery::closestPointOnPoly(dtPolyRef ref, const float* pos, float* closest) const +{ + dtAssert(m_nav); + const dtMeshTile* tile = 0; + const dtPoly* poly = 0; + if (!m_nav->getTileAndPolyByRef(ref, &tile, &poly)) + return false; + if (!tile) return false; + return closestPointOnPolyInTile(tile, poly, pos, closest); +} + +bool dtNavMeshQuery::closestPointOnPolyInTile(const dtMeshTile* tile, const dtPoly* poly, const float* pos, float* closest) const +{ + const unsigned int ip = (unsigned int)(poly - tile->polys); + const dtPolyDetail* pd = &tile->detailMeshes[ip]; + + float closestDistSqr = FLT_MAX; + + for (int j = 0; j < pd->triCount; ++j) + { + const unsigned char* t = &tile->detailTris[(pd->triBase+j)*4]; + const float* v[3]; + for (int k = 0; k < 3; ++k) + { + if (t[k] < poly->vertCount) + v[k] = &tile->verts[poly->verts[t[k]]*3]; + else + v[k] = &tile->detailVerts[(pd->vertBase+(t[k]-poly->vertCount))*3]; + } + float pt[3]; + dtClosestPtPointTriangle(pt, pos, v[0], v[1], v[2]); + float d = dtVdistSqr(pos, pt); + if (d < closestDistSqr) + { + dtVcopy(closest, pt); + closestDistSqr = d; + } + } + + return true; +} + +bool dtNavMeshQuery::closestPointOnPolyBoundary(dtPolyRef ref, const float* pos, float* closest) const +{ + dtAssert(m_nav); + + const dtMeshTile* tile = 0; + const dtPoly* poly = 0; + if (!m_nav->getTileAndPolyByRef(ref, &tile, &poly)) + return false; + + // Collect vertices. + float verts[DT_VERTS_PER_POLYGON*3]; + float edged[DT_VERTS_PER_POLYGON]; + float edget[DT_VERTS_PER_POLYGON]; + int nv = 0; + for (int i = 0; i < (int)poly->vertCount; ++i) + { + dtVcopy(&verts[nv*3], &tile->verts[poly->verts[i]*3]); + nv++; + } + + bool inside = dtDistancePtPolyEdgesSqr(pos, verts, nv, edged, edget); + if (inside) + { + // Point is inside the polygon, return the point. + dtVcopy(closest, pos); + } + else + { + // Point is outside the polygon, dtClamp to nearest edge. + float dmin = FLT_MAX; + int imin = -1; + for (int i = 0; i < nv; ++i) + { + if (edged[i] < dmin) + { + dmin = edged[i]; + imin = i; + } + } + const float* va = &verts[imin*3]; + const float* vb = &verts[((imin+1)%nv)*3]; + dtVlerp(closest, va, vb, edget[imin]); + } + + return true; +} + + +bool dtNavMeshQuery::getPolyHeight(dtPolyRef ref, const float* pos, float* height) const +{ + dtAssert(m_nav); + + const dtMeshTile* tile = 0; + const dtPoly* poly = 0; + if (!m_nav->getTileAndPolyByRef(ref, &tile, &poly)) + return false; + + if (poly->type == DT_POLYTYPE_OFFMESH_CONNECTION) + { + const float* v0 = &tile->verts[poly->verts[0]*3]; + const float* v1 = &tile->verts[poly->verts[1]*3]; + const float d0 = dtVdist(pos, v0); + const float d1 = dtVdist(pos, v1); + const float u = d0 / (d0+d1); + if (height) + *height = v0[1] + (v1[1] - v0[1]) * u; + return true; + } + else + { + const unsigned int ip = (unsigned int)(poly - tile->polys); + const dtPolyDetail* pd = &tile->detailMeshes[ip]; + for (int j = 0; j < pd->triCount; ++j) + { + const unsigned char* t = &tile->detailTris[(pd->triBase+j)*4]; + const float* v[3]; + for (int k = 0; k < 3; ++k) + { + if (t[k] < poly->vertCount) + v[k] = &tile->verts[poly->verts[t[k]]*3]; + else + v[k] = &tile->detailVerts[(pd->vertBase+(t[k]-poly->vertCount))*3]; + } + float h; + if (dtClosestHeightPointTriangle(pos, v[0], v[1], v[2], h)) + { + if (height) + *height = h; + return true; + } + } + } + + return false; +} + +void dtNavMeshQuery::setAreaCost(const int area, float cost) +{ + if (area >= 0 && area < DT_MAX_AREAS) + m_areaCost[area] = cost; +} + +float dtNavMeshQuery::getAreaCost(const int area) const +{ + if (area >= 0 && area < DT_MAX_AREAS) + return m_areaCost[area]; + return -1; +} + +dtPolyRef dtNavMeshQuery::findNearestPoly(const float* center, const float* extents, + const dtQueryFilter* filter, float* nearestPt) const +{ + dtAssert(m_nav); + + // Get nearby polygons from proximity grid. + dtPolyRef polys[128]; + int polyCount = queryPolygons(center, extents, filter, polys, 128); + + // Find nearest polygon amongst the nearby polygons. + dtPolyRef nearest = 0; + float nearestDistanceSqr = FLT_MAX; + for (int i = 0; i < polyCount; ++i) + { + dtPolyRef ref = polys[i]; + float closestPtPoly[3]; + if (!closestPointOnPoly(ref, center, closestPtPoly)) + continue; + float d = dtVdistSqr(center, closestPtPoly); + if (d < nearestDistanceSqr) + { + if (nearestPt) + dtVcopy(nearestPt, closestPtPoly); + nearestDistanceSqr = d; + nearest = ref; + } + } + + return nearest; +} + +dtPolyRef dtNavMeshQuery::findNearestPolyInTile(const dtMeshTile* tile, const float* center, const float* extents, + const dtQueryFilter* filter, float* nearestPt) const +{ + dtAssert(m_nav); + + float bmin[3], bmax[3]; + dtVsub(bmin, center, extents); + dtVadd(bmax, center, extents); + + // Get nearby polygons from proximity grid. + dtPolyRef polys[128]; + int polyCount = queryPolygonsInTile(tile, bmin, bmax, filter, polys, 128); + + // Find nearest polygon amongst the nearby polygons. + dtPolyRef nearest = 0; + float nearestDistanceSqr = FLT_MAX; + for (int i = 0; i < polyCount; ++i) + { + dtPolyRef ref = polys[i]; + const dtPoly* poly = &tile->polys[m_nav->decodePolyIdPoly(ref)]; + float closestPtPoly[3]; + if (!closestPointOnPolyInTile(tile, poly, center, closestPtPoly)) + continue; + + float d = dtVdistSqr(center, closestPtPoly); + if (d < nearestDistanceSqr) + { + if (nearestPt) + dtVcopy(nearestPt, closestPtPoly); + nearestDistanceSqr = d; + nearest = ref; + } + } + + return nearest; +} + +int dtNavMeshQuery::queryPolygonsInTile(const dtMeshTile* tile, const float* qmin, const float* qmax, + const dtQueryFilter* filter, + dtPolyRef* polys, const int maxPolys) const +{ + dtAssert(m_nav); + + if (tile->bvTree) + { + const dtBVNode* node = &tile->bvTree[0]; + const dtBVNode* end = &tile->bvTree[tile->header->bvNodeCount]; + const float* tbmin = tile->header->bmin; + const float* tbmax = tile->header->bmax; + const float qfac = tile->header->bvQuantFactor; + + // Calculate quantized box + unsigned short bmin[3], bmax[3]; + // dtClamp query box to world box. + float minx = dtClamp(qmin[0], tbmin[0], tbmax[0]) - tbmin[0]; + float miny = dtClamp(qmin[1], tbmin[1], tbmax[1]) - tbmin[1]; + float minz = dtClamp(qmin[2], tbmin[2], tbmax[2]) - tbmin[2]; + float maxx = dtClamp(qmax[0], tbmin[0], tbmax[0]) - tbmin[0]; + float maxy = dtClamp(qmax[1], tbmin[1], tbmax[1]) - tbmin[1]; + float maxz = dtClamp(qmax[2], tbmin[2], tbmax[2]) - tbmin[2]; + // Quantize + bmin[0] = (unsigned short)(qfac * minx) & 0xfffe; + bmin[1] = (unsigned short)(qfac * miny) & 0xfffe; + bmin[2] = (unsigned short)(qfac * minz) & 0xfffe; + bmax[0] = (unsigned short)(qfac * maxx + 1) | 1; + bmax[1] = (unsigned short)(qfac * maxy + 1) | 1; + bmax[2] = (unsigned short)(qfac * maxz + 1) | 1; + + // Traverse tree + const dtPolyRef base = m_nav->getPolyRefBase(tile); + int n = 0; + while (node < end) + { + const bool overlap = dtCheckOverlapBox(bmin, bmax, node->bmin, node->bmax); + const bool isLeafNode = node->i >= 0; + + if (isLeafNode && overlap) + { + if (passFilter(filter, tile->polys[node->i].flags)) + { + if (n < maxPolys) + polys[n++] = base | (dtPolyRef)node->i; + } + } + + if (overlap || isLeafNode) + node++; + else + { + const int escapeIndex = -node->i; + node += escapeIndex; + } + } + + return n; + } + else + { + float bmin[3], bmax[3]; + int n = 0; + const dtPolyRef base = m_nav->getPolyRefBase(tile); + for (int i = 0; i < tile->header->polyCount; ++i) + { + // Calc polygon bounds. + dtPoly* p = &tile->polys[i]; + const float* v = &tile->verts[p->verts[0]*3]; + dtVcopy(bmin, v); + dtVcopy(bmax, v); + for (int j = 1; j < p->vertCount; ++j) + { + v = &tile->verts[p->verts[j]*3]; + dtVmin(bmin, v); + dtVmax(bmax, v); + } + if (overlapBoxes(qmin,qmax, bmin,bmax)) + { + if (passFilter(filter, p->flags)) + { + if (n < maxPolys) + polys[n++] = base | (dtPolyRef)i; + } + } + } + return n; + } +} + +int dtNavMeshQuery::queryPolygons(const float* center, const float* extents, const dtQueryFilter* filter, + dtPolyRef* polys, const int maxPolys) const +{ + dtAssert(m_nav); + + float bmin[3], bmax[3]; + dtVsub(bmin, center, extents); + dtVadd(bmax, center, extents); + + // Find tiles the query touches. + int minx, miny, maxx, maxy; + m_nav->calcTileLoc(bmin, &minx, &miny); + m_nav->calcTileLoc(bmax, &maxx, &maxy); + + int n = 0; + for (int y = miny; y <= maxy; ++y) + { + for (int x = minx; x <= maxx; ++x) + { + const dtMeshTile* tile = m_nav->getTileAt(x,y); + if (!tile) continue; + n += queryPolygonsInTile(tile, bmin, bmax, filter, polys+n, maxPolys-n); + if (n >= maxPolys) return n; + } + } + + return n; +} + +int dtNavMeshQuery::findPath(dtPolyRef startRef, dtPolyRef endRef, + const float* startPos, const float* endPos, + const dtQueryFilter* filter, + dtPolyRef* path, const int maxPathSize) const +{ + dtAssert(m_nav); + dtAssert(m_nodePool); + dtAssert(m_openList); + + if (!startRef || !endRef) + return 0; + + if (!maxPathSize) + return 0; + + // Validate input + if (!m_nav->isValidPolyRef(startRef) || !m_nav->isValidPolyRef(endRef)) + return 0; + + if (startRef == endRef) + { + path[0] = startRef; + return 1; + } + + m_nodePool->clear(); + m_openList->clear(); + + dtNode* startNode = m_nodePool->getNode(startRef); + startNode->pidx = 0; + startNode->cost = 0; + startNode->total = dtVdist(startPos, endPos) * H_SCALE; + startNode->id = startRef; + startNode->flags = DT_NODE_OPEN; + m_openList->push(startNode); + + dtNode* lastBestNode = startNode; + float lastBestNodeCost = startNode->total; + + while (!m_openList->empty()) + { + dtNode* bestNode = m_openList->pop(); + // Remove node from open list and put it in closed list. + bestNode->flags &= ~DT_NODE_OPEN; + bestNode->flags |= DT_NODE_CLOSED; + + // Reached the goal, stop searching. + if (bestNode->id == endRef) + { + lastBestNode = bestNode; + break; + } + + float previousEdgeMidPoint[3]; + + // Get current poly and tile. + // The API input has been cheked already, skip checking internal data. + const dtPolyRef bestRef = bestNode->id; + const dtMeshTile* bestTile = 0; + const dtPoly* bestPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(bestRef, &bestTile, &bestPoly); + + // Get parent poly and tile. + dtPolyRef parentRef = 0; + const dtMeshTile* parentTile = 0; + const dtPoly* parentPoly = 0; + if (bestNode->pidx) + parentRef = m_nodePool->getNodeAtIdx(bestNode->pidx)->id; + if (parentRef) + { + m_nav->getTileAndPolyByRefUnsafe(parentRef, &parentTile, &parentPoly); + getEdgeMidPoint(parentRef, parentPoly, parentTile, + bestRef, bestPoly, bestTile, previousEdgeMidPoint); + } + else + { + dtVcopy(previousEdgeMidPoint, startPos); + } + + for (unsigned int i = bestPoly->firstLink; i != DT_NULL_LINK; i = bestTile->links[i].next) + { + dtPolyRef neighbourRef = bestTile->links[i].ref; + + // Skip invalid ids and do not expand back to where we came from. + if (!neighbourRef || neighbourRef == parentRef) + continue; + + // Get neighbour poly and tile. + // The API input has been cheked already, skip checking internal data. + const dtMeshTile* neighbourTile = 0; + const dtPoly* neighbourPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(neighbourRef, &neighbourTile, &neighbourPoly); + + if (!passFilter(filter, neighbourPoly->flags)) + continue; + + dtNode newNode; + newNode.pidx = m_nodePool->getNodeIdx(bestNode); + newNode.id = neighbourRef; + + // Calculate cost. + float edgeMidPoint[3]; + + getEdgeMidPoint(bestRef, bestPoly, bestTile, + neighbourRef, neighbourPoly, neighbourTile, edgeMidPoint); + + // Special case for last node. + float h = 0; + if (neighbourRef == endRef) + { + // Cost + newNode.cost = bestNode->cost + + dtVdist(previousEdgeMidPoint,edgeMidPoint) * m_areaCost[bestPoly->area] + + dtVdist(edgeMidPoint, endPos) * m_areaCost[neighbourPoly->area]; + // Heuristic + h = 0; + } + else + { + // Cost + newNode.cost = bestNode->cost + + dtVdist(previousEdgeMidPoint,edgeMidPoint) * m_areaCost[bestPoly->area]; + // Heuristic + h = dtVdist(edgeMidPoint,endPos)*H_SCALE; + } + newNode.total = newNode.cost + h; + + dtNode* actualNode = m_nodePool->getNode(newNode.id); + if (!actualNode) + continue; + + // The node is already in open list and the new result is worse, skip. + if ((actualNode->flags & DT_NODE_OPEN) && newNode.total >= actualNode->total) + continue; + // The node is already visited and process, and the new result is worse, skip. + if ((actualNode->flags & DT_NODE_CLOSED) && newNode.total >= actualNode->total) + continue; + + // Add or update the node. + actualNode->flags &= ~DT_NODE_CLOSED; + actualNode->pidx = newNode.pidx; + actualNode->cost = newNode.cost; + actualNode->total = newNode.total; + + // Update nearest node to target so far. + if (h < lastBestNodeCost) + { + lastBestNodeCost = h; + lastBestNode = actualNode; + } + + if (actualNode->flags & DT_NODE_OPEN) + { + // Already in open, update node location. + m_openList->modify(actualNode); + } + else + { + // Put the node in open list. + actualNode->flags |= DT_NODE_OPEN; + m_openList->push(actualNode); + } + } + } + + // Reverse the path. + dtNode* prev = 0; + dtNode* node = lastBestNode; + do + { + dtNode* next = m_nodePool->getNodeAtIdx(node->pidx); + node->pidx = m_nodePool->getNodeIdx(prev); + prev = node; + node = next; + } + while (node); + + // Store path + node = prev; + int n = 0; + do + { + path[n++] = node->id; + node = m_nodePool->getNodeAtIdx(node->pidx); + } + while (node && n < maxPathSize); + + return n; +} + + + +dtQueryState dtNavMeshQuery::initSlicedFindPath(dtPolyRef startRef, dtPolyRef endRef, + const float* startPos, const float* endPos, + const dtQueryFilter* filter) +{ + dtAssert(m_nav); + dtAssert(m_nodePool); + dtAssert(m_openList); + + // Init path state. + memset(&m_query, 0, sizeof(dtQueryData)); + m_query.state = DT_QUERY_FAILED; + m_query.startRef = startRef; + m_query.endRef = endRef; + dtVcopy(m_query.startPos, startPos); + dtVcopy(m_query.endPos, endPos); + m_query.filter = *filter; + + if (!startRef || !endRef) + return DT_QUERY_FAILED; + + // Validate input + if (!m_nav->isValidPolyRef(startRef) || !m_nav->isValidPolyRef(endRef)) + return DT_QUERY_FAILED; + + if (startRef == endRef) + { + m_query.state = DT_QUERY_READY; + return DT_QUERY_READY; + } + + m_nodePool->clear(); + m_openList->clear(); + + dtNode* startNode = m_nodePool->getNode(startRef); + startNode->pidx = 0; + startNode->cost = 0; + startNode->total = dtVdist(startPos, endPos) * H_SCALE; + startNode->id = startRef; + startNode->flags = DT_NODE_OPEN; + m_openList->push(startNode); + + m_query.state = DT_QUERY_RUNNING; + m_query.lastBestNode = startNode; + m_query.lastBestNodeCost = startNode->total; + + return m_query.state; +} + +dtQueryState dtNavMeshQuery::updateSlicedFindPath(const int maxIter) +{ + if (m_query.state != DT_QUERY_RUNNING) + return m_query.state; + + // Make sure the request is still valid. + if (!m_nav->isValidPolyRef(m_query.startRef) || !m_nav->isValidPolyRef(m_query.endRef)) + { + m_query.state = DT_QUERY_FAILED; + return DT_QUERY_FAILED; + } + + int iter = 0; + while (iter < maxIter && !m_openList->empty()) + { + iter++; + + dtNode* bestNode = m_openList->pop(); + // Remove node from open list and put it in closed list. + bestNode->flags &= ~DT_NODE_OPEN; + bestNode->flags |= DT_NODE_CLOSED; + + // Reached the goal, stop searching. + if (bestNode->id == m_query.endRef) + { + m_query.lastBestNode = bestNode; + m_query.state = DT_QUERY_READY; + return m_query.state; + } + + float previousEdgeMidPoint[3]; + + // Get current poly and tile. + const dtPolyRef bestRef = bestNode->id; + const dtMeshTile* bestTile = 0; + const dtPoly* bestPoly = 0; + if (!m_nav->getTileAndPolyByRef(bestRef, &bestTile, &bestPoly)) + { + // The polygon has disappeared during the sliced query, fail. + m_query.state = DT_QUERY_FAILED; + return m_query.state; + } + + // Get parent poly and tile. + dtPolyRef parentRef = 0; + const dtMeshTile* parentTile = 0; + const dtPoly* parentPoly = 0; + dtNode* parentNode = 0; + if (bestNode->pidx) + { + parentNode = m_nodePool->getNodeAtIdx(bestNode->pidx); + parentRef = parentNode->id; + } + if (parentRef) + { + if (!m_nav->getTileAndPolyByRef(parentRef, &parentTile, &parentPoly)) + { + // The polygon has disappeared during the sliced query, fail. + m_query.state = DT_QUERY_FAILED; + return m_query.state; + } + getEdgeMidPoint(parentRef, parentPoly, parentTile, + bestRef, bestPoly, bestTile, previousEdgeMidPoint); + } + else + { + dtVcopy(previousEdgeMidPoint, m_query.startPos); + } + + for (unsigned int i = bestPoly->firstLink; i != DT_NULL_LINK; i = bestTile->links[i].next) + { + dtPolyRef neighbourRef = bestTile->links[i].ref; + + // Skip invalid ids and do not expand back to where we came from. + if (!neighbourRef || neighbourRef == parentRef) + continue; + + // Get neighbour poly and tile. + // The API input has been cheked already, skip checking internal data. + const dtMeshTile* neighbourTile = 0; + const dtPoly* neighbourPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(neighbourRef, &neighbourTile, &neighbourPoly); + + if (!passFilter(&m_query.filter, neighbourPoly->flags)) + continue; + + dtNode newNode; + newNode.pidx = m_nodePool->getNodeIdx(bestNode); + newNode.id = neighbourRef; + + // Calculate cost. + float edgeMidPoint[3]; + + getEdgeMidPoint(bestRef, bestPoly, bestTile, + neighbourRef, neighbourPoly, neighbourTile, edgeMidPoint); + + // Special case for last node. + float h = 0; + if (neighbourRef == m_query.endRef) + { + // Cost + newNode.cost = bestNode->cost + + dtVdist(previousEdgeMidPoint,edgeMidPoint) * m_areaCost[bestPoly->area] + + dtVdist(edgeMidPoint, m_query.endPos) * m_areaCost[neighbourPoly->area]; + // Heuristic + h = 0; + } + else + { + // Cost + newNode.cost = bestNode->cost + + dtVdist(previousEdgeMidPoint,edgeMidPoint) * m_areaCost[bestPoly->area]; + // Heuristic + h = dtVdist(edgeMidPoint, m_query.endPos)*H_SCALE; + } + newNode.total = newNode.cost + h; + + dtNode* actualNode = m_nodePool->getNode(newNode.id); + if (!actualNode) + continue; + + // The node is already in open list and the new result is worse, skip. + if ((actualNode->flags & DT_NODE_OPEN) && newNode.total >= actualNode->total) + continue; + // The node is already visited and process, and the new result is worse, skip. + if ((actualNode->flags & DT_NODE_CLOSED) && newNode.total >= actualNode->total) + continue; + + // Add or update the node. + actualNode->flags &= ~DT_NODE_CLOSED; + actualNode->pidx = newNode.pidx; + actualNode->cost = newNode.cost; + actualNode->total = newNode.total; + + // Update nearest node to target so far. + if (h < m_query.lastBestNodeCost) + { + m_query.lastBestNodeCost = h; + m_query.lastBestNode = actualNode; + } + + if (actualNode->flags & DT_NODE_OPEN) + { + // Already in open, update node location. + m_openList->modify(actualNode); + } + else + { + // Put the node in open list. + actualNode->flags |= DT_NODE_OPEN; + m_openList->push(actualNode); + } + } + } + + if (m_openList->empty()) + m_query.state = DT_QUERY_READY; + + return m_query.state; +} + +int dtNavMeshQuery::finalizeSlicedFindPath(dtPolyRef* path, const int maxPathSize) +{ + if (m_query.state != DT_QUERY_READY) + return 0; + + // Reverse the path. + dtAssert(m_query.lastBestNode); + dtNode* prev = 0; + dtNode* node = m_query.lastBestNode; + do + { + dtNode* next = m_nodePool->getNodeAtIdx(node->pidx); + node->pidx = m_nodePool->getNodeIdx(prev); + prev = node; + node = next; + } + while (node); + + // Store path + node = prev; + int n = 0; + do + { + path[n++] = node->id; + node = m_nodePool->getNodeAtIdx(node->pidx); + } + while (node && n < maxPathSize); + + // Reset query. + memset(&m_query, 0, sizeof(dtQueryData)); + + return n; +} + + + +int dtNavMeshQuery::findStraightPath(const float* startPos, const float* endPos, + const dtPolyRef* path, const int pathSize, + float* straightPath, unsigned char* straightPathFlags, dtPolyRef* straightPathRefs, + const int maxStraightPathSize) const +{ + dtAssert(m_nav); + + if (!maxStraightPathSize) + return 0; + + if (!path[0]) + return 0; + + int straightPathSize = 0; + + // TODO: Should this be callers responsibility? + float closestStartPos[3]; + if (!closestPointOnPolyBoundary(path[0], startPos, closestStartPos)) + return 0; + + // Add start point. + dtVcopy(&straightPath[straightPathSize*3], closestStartPos); + if (straightPathFlags) + straightPathFlags[straightPathSize] = DT_STRAIGHTPATH_START; + if (straightPathRefs) + straightPathRefs[straightPathSize] = path[0]; + straightPathSize++; + if (straightPathSize >= maxStraightPathSize) + return straightPathSize; + + float closestEndPos[3]; + if (!closestPointOnPolyBoundary(path[pathSize-1], endPos, closestEndPos)) + return 0; + + if (pathSize > 1) + { + float portalApex[3], portalLeft[3], portalRight[3]; + dtVcopy(portalApex, closestStartPos); + dtVcopy(portalLeft, portalApex); + dtVcopy(portalRight, portalApex); + int apexIndex = 0; + int leftIndex = 0; + int rightIndex = 0; + + unsigned char leftPolyType = 0; + unsigned char rightPolyType = 0; + + dtPolyRef leftPolyRef = path[0]; + dtPolyRef rightPolyRef = path[0]; + + for (int i = 0; i < pathSize; ++i) + { + float left[3], right[3]; + unsigned char fromType, toType; + + if (i+1 < pathSize) + { + // Next portal. + if (!getPortalPoints(path[i], path[i+1], left, right, fromType, toType)) + { + if (!closestPointOnPolyBoundary(path[i], endPos, closestEndPos)) + return 0; + + dtVcopy(&straightPath[straightPathSize*3], closestEndPos); + if (straightPathFlags) + straightPathFlags[straightPathSize] = 0; + if (straightPathRefs) + straightPathRefs[straightPathSize] = path[i]; + straightPathSize++; + + return straightPathSize; + } + + // If starting really close the portal, advance. + if (i == 0) + { + float t; + if (dtDistancePtSegSqr2D(portalApex, left, right, t) < dtSqr(0.001f)) + continue; + } + } + else + { + // End of the path. + dtVcopy(left, closestEndPos); + dtVcopy(right, closestEndPos); + + fromType = toType = DT_POLYTYPE_GROUND; + } + + // Right vertex. + if (dtTriArea2D(portalApex, portalRight, right) <= 0.0f) + { + if (dtVequal(portalApex, portalRight) || dtTriArea2D(portalApex, portalLeft, right) > 0.0f) + { + dtVcopy(portalRight, right); + rightPolyRef = (i+1 < pathSize) ? path[i+1] : 0; + rightPolyType = toType; + rightIndex = i; + } + else + { + dtVcopy(portalApex, portalLeft); + apexIndex = leftIndex; + + unsigned char flags = 0; + if (!leftPolyRef) + flags = DT_STRAIGHTPATH_END; + else if (rightPolyType == DT_POLYTYPE_OFFMESH_CONNECTION) + flags = DT_STRAIGHTPATH_OFFMESH_CONNECTION; + dtPolyRef ref = leftPolyRef; + + if (!dtVequal(&straightPath[(straightPathSize-1)*3], portalApex)) + { + // Append new vertex. + dtVcopy(&straightPath[straightPathSize*3], portalApex); + if (straightPathFlags) + straightPathFlags[straightPathSize] = flags; + if (straightPathRefs) + straightPathRefs[straightPathSize] = ref; + straightPathSize++; + // If reached end of path or there is no space to append more vertices, return. + if (flags == DT_STRAIGHTPATH_END || straightPathSize >= maxStraightPathSize) + return straightPathSize; + } + else + { + // The vertices are equal, update flags and poly. + if (straightPathFlags) + straightPathFlags[straightPathSize-1] = flags; + if (straightPathRefs) + straightPathRefs[straightPathSize-1] = ref; + } + + dtVcopy(portalLeft, portalApex); + dtVcopy(portalRight, portalApex); + leftIndex = apexIndex; + rightIndex = apexIndex; + + // Restart + i = apexIndex; + + continue; + } + } + + // Left vertex. + if (dtTriArea2D(portalApex, portalLeft, left) >= 0.0f) + { + if (dtVequal(portalApex, portalLeft) || dtTriArea2D(portalApex, portalRight, left) < 0.0f) + { + dtVcopy(portalLeft, left); + leftPolyRef = (i+1 < pathSize) ? path[i+1] : 0; + leftPolyType = toType; + leftIndex = i; + } + else + { + dtVcopy(portalApex, portalRight); + apexIndex = rightIndex; + + unsigned char flags = 0; + if (!rightPolyRef) + flags = DT_STRAIGHTPATH_END; + else if (rightPolyType == DT_POLYTYPE_OFFMESH_CONNECTION) + flags = DT_STRAIGHTPATH_OFFMESH_CONNECTION; + dtPolyRef ref = rightPolyRef; + + if (!dtVequal(&straightPath[(straightPathSize-1)*3], portalApex)) + { + // Append new vertex. + dtVcopy(&straightPath[straightPathSize*3], portalApex); + if (straightPathFlags) + straightPathFlags[straightPathSize] = flags; + if (straightPathRefs) + straightPathRefs[straightPathSize] = ref; + straightPathSize++; + // If reached end of path or there is no space to append more vertices, return. + if (flags == DT_STRAIGHTPATH_END || straightPathSize >= maxStraightPathSize) + return straightPathSize; + } + else + { + // The vertices are equal, update flags and poly. + if (straightPathFlags) + straightPathFlags[straightPathSize-1] = flags; + if (straightPathRefs) + straightPathRefs[straightPathSize-1] = ref; + } + + dtVcopy(portalLeft, portalApex); + dtVcopy(portalRight, portalApex); + leftIndex = apexIndex; + rightIndex = apexIndex; + + // Restart + i = apexIndex; + + continue; + } + } + } + } + + // If the point already exists, remove it and add reappend the actual end location. + if (straightPathSize && dtVequal(&straightPath[(straightPathSize-1)*3], closestEndPos)) + straightPathSize--; + + // Add end point. + if (straightPathSize < maxStraightPathSize) + { + dtVcopy(&straightPath[straightPathSize*3], closestEndPos); + if (straightPathFlags) + straightPathFlags[straightPathSize] = DT_STRAIGHTPATH_END; + if (straightPathRefs) + straightPathRefs[straightPathSize] = 0; + straightPathSize++; + } + + return straightPathSize; +} + +int dtNavMeshQuery::moveAlongSurface(dtPolyRef startRef, const float* startPos, const float* endPos, + const dtQueryFilter* filter, + float* resultPos, dtPolyRef* visited, const int maxVisitedSize) const +{ + dtAssert(m_nav); + dtAssert(m_tinyNodePool); + + // Validate input + if (!startRef) return 0; + if (!m_nav->isValidPolyRef(startRef)) return 0; + + static const int MAX_STACK = 48; + dtNode* stack[MAX_STACK]; + int nstack = 0; + + m_tinyNodePool->clear(); + + dtNode* startNode = m_tinyNodePool->getNode(startRef); + startNode->pidx = 0; + startNode->cost = 0; + startNode->total = 0; + startNode->id = startRef; + startNode->flags = DT_NODE_CLOSED; + stack[nstack++] = startNode; + + float bestPos[3]; + float bestDist = FLT_MAX; + dtNode* bestNode = 0; + dtVcopy(bestPos, startPos); + + // Search constraints + float searchPos[3], searchRadSqr; + dtVlerp(searchPos, startPos, endPos, 0.5f); + searchRadSqr = dtSqr(dtVdist(startPos, endPos)/2.0f + 0.001f); + + float verts[DT_VERTS_PER_POLYGON*3]; + + while (nstack) + { + // Pop front. + dtNode* curNode = stack[0]; + for (int i = 0; i < nstack-1; ++i) + stack[i] = stack[i+1]; + nstack--; + + // Get poly and tile. + // The API input has been cheked already, skip checking internal data. + const dtPolyRef curRef = curNode->id; + const dtMeshTile* curTile = 0; + const dtPoly* curPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(curRef, &curTile, &curPoly); + + // Collect vertices. + const int nverts = curPoly->vertCount; + for (int i = 0; i < nverts; ++i) + dtVcopy(&verts[i*3], &curTile->verts[curPoly->verts[i]*3]); + + // If target is inside the poly, stop search. + if (dtPointInPolygon(endPos, verts, nverts)) + { + bestNode = curNode; + dtVcopy(bestPos, endPos); + break; + } + + // Find wall edges and find nearest point inside the walls. + for (int i = 0, j = (int)curPoly->vertCount-1; i < (int)curPoly->vertCount; j = i++) + { + // Find links to neighbours. + static const int MAX_NEIS = 8; + int nneis = 0; + dtPolyRef neis[MAX_NEIS]; + + if (curPoly->neis[j] & DT_EXT_LINK) + { + // Tile border. + for (unsigned int k = curPoly->firstLink; k != DT_NULL_LINK; k = curTile->links[k].next) + { + const dtLink* link = &curTile->links[k]; + if (link->edge == j) + { + if (link->ref != 0 && passFilter(filter, m_nav->getPolyFlags(link->ref))) + { + if (nneis < MAX_NEIS) + neis[nneis++] = link->ref; + } + } + } + } + else if (curPoly->neis[j] && passFilter(filter, curTile->polys[curPoly->neis[j]-1].flags)) + { + // Internal edge, encode id. + neis[nneis++] = m_nav->getPolyRefBase(curTile) | (unsigned int)(curPoly->neis[j]-1); + } + + if (!nneis) + { + // Wall edge, calc distance. + const float* vj = &verts[j*3]; + const float* vi = &verts[i*3]; + float tseg; + const float distSqr = dtDistancePtSegSqr2D(endPos, vj, vi, tseg); + if (distSqr < bestDist) + { + // Update nearest distance. + dtVlerp(bestPos, vj,vi, tseg); + bestDist = distSqr; + bestNode = curNode; + } + } + else + { + for (int k = 0; k < nneis; ++k) + { + // Skip if no node can be allocated. + dtNode* neighbourNode = m_tinyNodePool->getNode(neis[k]); + if (!neighbourNode) + continue; + // Skip if already visited. + if (neighbourNode->flags & DT_NODE_CLOSED) + continue; + + // Skip the link if it is too far from search constraint. + // TODO: Maybe should use getPortalPoints(), but this one is way faster. + const float* vj = &verts[j*3]; + const float* vi = &verts[i*3]; + float tseg; + float distSqr = dtDistancePtSegSqr2D(searchPos, vj, vi, tseg); + if (distSqr > searchRadSqr) + continue; + + // Mark as the node as visited and push to queue. + if (nstack < MAX_STACK) + { + neighbourNode->pidx = m_tinyNodePool->getNodeIdx(curNode); + neighbourNode->flags |= DT_NODE_CLOSED; + stack[nstack++] = neighbourNode; + } + } + } + } + } + + int n = 0; + if (bestNode) + { + // Reverse the path. + dtNode* prev = 0; + dtNode* node = bestNode; + do + { + dtNode* next = m_tinyNodePool->getNodeAtIdx(node->pidx); + node->pidx = m_tinyNodePool->getNodeIdx(prev); + prev = node; + node = next; + } + while (node); + + // Store result + node = prev; + do + { + visited[n++] = node->id; + node = m_tinyNodePool->getNodeAtIdx(node->pidx); + } + while (node && n < maxVisitedSize); + } + + dtVcopy(resultPos, bestPos); + + return n; +} + + +bool dtNavMeshQuery::getPortalPoints(dtPolyRef from, dtPolyRef to, float* left, float* right, + unsigned char& fromType, unsigned char& toType) const +{ + dtAssert(m_nav); + + const dtMeshTile* fromTile = 0; + const dtPoly* fromPoly = 0; + if (!m_nav->getTileAndPolyByRef(from, &fromTile, &fromPoly)) + return false; + fromType = fromPoly->type; + + const dtMeshTile* toTile = 0; + const dtPoly* toPoly = 0; + if (!m_nav->getTileAndPolyByRef(to, &toTile, &toPoly)) + return false; + toType = toPoly->type; + + return getPortalPoints(from, fromPoly, fromTile, to, toPoly, toTile, left, right); +} + +// Returns portal points between two polygons. +bool dtNavMeshQuery::getPortalPoints(dtPolyRef from, const dtPoly* fromPoly, const dtMeshTile* fromTile, + dtPolyRef to, const dtPoly* toPoly, const dtMeshTile* toTile, + float* left, float* right) const +{ + // Find the link that points to the 'to' polygon. + const dtLink* link = 0; + for (unsigned int i = fromPoly->firstLink; i != DT_NULL_LINK; i = fromTile->links[i].next) + { + if (fromTile->links[i].ref == to) + { + link = &fromTile->links[i]; + break; + } + } + if (!link) + return false; + + // Handle off-mesh connections. + if (fromPoly->type == DT_POLYTYPE_OFFMESH_CONNECTION) + { + // Find link that points to first vertex. + for (unsigned int i = fromPoly->firstLink; i != DT_NULL_LINK; i = fromTile->links[i].next) + { + if (fromTile->links[i].ref == to) + { + const int v = fromTile->links[i].edge; + dtVcopy(left, &fromTile->verts[fromPoly->verts[v]*3]); + dtVcopy(right, &fromTile->verts[fromPoly->verts[v]*3]); + return true; + } + } + return false; + } + + if (toPoly->type == DT_POLYTYPE_OFFMESH_CONNECTION) + { + for (unsigned int i = toPoly->firstLink; i != DT_NULL_LINK; i = toTile->links[i].next) + { + if (toTile->links[i].ref == from) + { + const int v = toTile->links[i].edge; + dtVcopy(left, &toTile->verts[toPoly->verts[v]*3]); + dtVcopy(right, &toTile->verts[toPoly->verts[v]*3]); + return true; + } + } + return false; + } + + // Find portal vertices. + const int v0 = fromPoly->verts[link->edge]; + const int v1 = fromPoly->verts[(link->edge+1) % (int)fromPoly->vertCount]; + dtVcopy(left, &fromTile->verts[v0*3]); + dtVcopy(right, &fromTile->verts[v1*3]); + + // If the link is at tile boundary, dtClamp the vertices to + // the link width. + if (link->side != 0xff) + { + // Unpack portal limits. + if (link->bmin != 0 || link->bmax != 255) + { + const float s = 1.0f/255.0f; + const float tmin = link->bmin*s; + const float tmax = link->bmax*s; + dtVlerp(left, &fromTile->verts[v0*3], &fromTile->verts[v1*3], tmin); + dtVlerp(right, &fromTile->verts[v0*3], &fromTile->verts[v1*3], tmax); + } + } + + return true; +} + +// Returns edge mid point between two polygons. +bool dtNavMeshQuery::getEdgeMidPoint(dtPolyRef from, dtPolyRef to, float* mid) const +{ + float left[3], right[3]; + unsigned char fromType, toType; + if (!getPortalPoints(from, to, left,right, fromType, toType)) return false; + mid[0] = (left[0]+right[0])*0.5f; + mid[1] = (left[1]+right[1])*0.5f; + mid[2] = (left[2]+right[2])*0.5f; + return true; +} + +bool dtNavMeshQuery::getEdgeMidPoint(dtPolyRef from, const dtPoly* fromPoly, const dtMeshTile* fromTile, + dtPolyRef to, const dtPoly* toPoly, const dtMeshTile* toTile, + float* mid) const +{ + float left[3], right[3]; + if (!getPortalPoints(from, fromPoly, fromTile, to, toPoly, toTile, left, right)) + return false; + mid[0] = (left[0]+right[0])*0.5f; + mid[1] = (left[1]+right[1])*0.5f; + mid[2] = (left[2]+right[2])*0.5f; + return true; +} + +int dtNavMeshQuery::raycast(dtPolyRef centerRef, const float* startPos, const float* endPos, const dtQueryFilter* filter, + float& t, float* hitNormal, dtPolyRef* path, const int pathSize) const +{ + dtAssert(m_nav); + + t = 0; + + // Validate input + if (!centerRef || !m_nav->isValidPolyRef(centerRef)) + return 0; + + dtPolyRef curRef = centerRef; + float verts[DT_VERTS_PER_POLYGON*3]; + int n = 0; + + hitNormal[0] = 0; + hitNormal[1] = 0; + hitNormal[2] = 0; + + while (curRef) + { + // Cast ray against current polygon. + + // The API input has been cheked already, skip checking internal data. + const dtMeshTile* tile = 0; + const dtPoly* poly = 0; + m_nav->getTileAndPolyByRefUnsafe(curRef, &tile, &poly); + + // Collect vertices. + int nv = 0; + for (int i = 0; i < (int)poly->vertCount; ++i) + { + dtVcopy(&verts[nv*3], &tile->verts[poly->verts[i]*3]); + nv++; + } + + float tmin, tmax; + int segMin, segMax; + if (!dtIntersectSegmentPoly2D(startPos, endPos, verts, nv, tmin, tmax, segMin, segMax)) + { + // Could not hit the polygon, keep the old t and report hit. + return n; + } + // Keep track of furthest t so far. + if (tmax > t) + t = tmax; + + // Store visited polygons. + if (n < pathSize) + path[n++] = curRef; + + // Ray end is completely inside the polygon. + if (segMax == -1) + { + t = FLT_MAX; + return n; + } + + // Follow neighbours. + dtPolyRef nextRef = 0; + + for (unsigned int i = poly->firstLink; i != DT_NULL_LINK; i = tile->links[i].next) + { + const dtLink* link = &tile->links[i]; + + // Find link which contains this edge. + if ((int)link->edge != segMax) + continue; + + // Get pointer to the next polygon. + const dtMeshTile* nextTile = 0; + const dtPoly* nextPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(link->ref, &nextTile, &nextPoly); + + // Skip off-mesh connections. + if (nextPoly->type == DT_POLYTYPE_OFFMESH_CONNECTION) + continue; + + // Skip links based on filter. + if (!passFilter(filter, nextPoly->flags)) + continue; + + // If the link is internal, just return the ref. + if (link->side == 0xff) + { + nextRef = link->ref; + break; + } + + // If the link is at tile boundary, + + // Check if the link spans the whole edge, and accept. + if (link->bmin == 0 && link->bmax == 255) + { + nextRef = link->ref; + break; + } + + // Check for partial edge links. + const int v0 = poly->verts[link->edge]; + const int v1 = poly->verts[(link->edge+1) % poly->vertCount]; + const float* left = &tile->verts[v0*3]; + const float* right = &tile->verts[v1*3]; + + // Check that the intersection lies inside the link portal. + if (link->side == 0 || link->side == 4) + { + // Calculate link size. + const float s = 1.0f/255.0f; + float lmin = left[2] + (right[2] - left[2])*(link->bmin*s); + float lmax = left[2] + (right[2] - left[2])*(link->bmax*s); + if (lmin > lmax) dtSwap(lmin, lmax); + + // Find Z intersection. + float z = startPos[2] + (endPos[2]-startPos[2])*tmax; + if (z >= lmin && z <= lmax) + { + nextRef = link->ref; + break; + } + } + else if (link->side == 2 || link->side == 6) + { + // Calculate link size. + const float s = 1.0f/255.0f; + float lmin = left[0] + (right[0] - left[0])*(link->bmin*s); + float lmax = left[0] + (right[0] - left[0])*(link->bmax*s); + if (lmin > lmax) dtSwap(lmin, lmax); + + // Find X intersection. + float x = startPos[0] + (endPos[0]-startPos[0])*tmax; + if (x >= lmin && x <= lmax) + { + nextRef = link->ref; + break; + } + } + } + + if (!nextRef) + { + // No neighbour, we hit a wall. + + // Calculate hit normal. + const int a = segMax; + const int b = segMax+1 < nv ? segMax+1 : 0; + const float* va = &verts[a*3]; + const float* vb = &verts[b*3]; + const float dx = vb[0] - va[0]; + const float dz = vb[2] - va[2]; + hitNormal[0] = dz; + hitNormal[1] = 0; + hitNormal[2] = -dx; + dtVnormalize(hitNormal); + + return n; + } + + // No hit, advance to neighbour polygon. + curRef = nextRef; + } + + return n; +} + +int dtNavMeshQuery::findPolysAroundCircle(dtPolyRef centerRef, const float* centerPos, const float radius, + const dtQueryFilter* filter, + dtPolyRef* resultRef, dtPolyRef* resultParent, float* resultCost, + const int maxResult) const +{ + dtAssert(m_nav); + dtAssert(m_nodePool); + dtAssert(m_openList); + + // Validate input + if (!centerRef) return 0; + if (!m_nav->isValidPolyRef(centerRef)) return 0; + + m_nodePool->clear(); + m_openList->clear(); + + dtNode* startNode = m_nodePool->getNode(centerRef); + startNode->pidx = 0; + startNode->cost = 0; + startNode->total = 0; + startNode->id = centerRef; + startNode->flags = DT_NODE_OPEN; + m_openList->push(startNode); + + int n = 0; + if (n < maxResult) + { + if (resultRef) + resultRef[n] = startNode->id; + if (resultParent) + resultParent[n] = 0; + if (resultCost) + resultCost[n] = 0; + ++n; + } + + const float radiusSqr = dtSqr(radius); + + while (!m_openList->empty()) + { + dtNode* bestNode = m_openList->pop(); + + float previousEdgeMidPoint[3]; + + // Get poly and tile. + // The API input has been cheked already, skip checking internal data. + const dtPolyRef bestRef = bestNode->id; + const dtMeshTile* bestTile = 0; + const dtPoly* bestPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(bestRef, &bestTile, &bestPoly); + + // Get parent poly and tile. + dtPolyRef parentRef = 0; + const dtMeshTile* parentTile = 0; + const dtPoly* parentPoly = 0; + if (bestNode->pidx) + parentRef = m_nodePool->getNodeAtIdx(bestNode->pidx)->id; + if (parentRef) + { + m_nav->getTileAndPolyByRefUnsafe(parentRef, &parentTile, &parentPoly); + + getEdgeMidPoint(parentRef, parentPoly, parentTile, + bestRef, bestPoly, bestTile, previousEdgeMidPoint); + } + else + { + dtVcopy(previousEdgeMidPoint, centerPos); + } + + for (unsigned int i = bestPoly->firstLink; i != DT_NULL_LINK; i = bestTile->links[i].next) + { + const dtLink* link = &bestTile->links[i]; + dtPolyRef neighbourRef = link->ref; + // Skip invalid neighbours and do not follow back to parent. + if (!neighbourRef || neighbourRef == parentRef) + continue; + + // Expand to neighbour + const dtMeshTile* neighbourTile = 0; + const dtPoly* neighbourPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(neighbourRef, &neighbourTile, &neighbourPoly); + + // Do not advance if the polygon is excluded by the filter. + if (!passFilter(filter, neighbourPoly->flags)) + continue; + + // Find edge and calc distance to the edge. + float va[3], vb[3]; + if (!getPortalPoints(bestRef, bestPoly, bestTile, neighbourRef, neighbourPoly, neighbourTile, va, vb)) + continue; + + // If the circle is not touching the next polygon, skip it. + float tseg; + float distSqr = dtDistancePtSegSqr2D(centerPos, va, vb, tseg); + if (distSqr > radiusSqr) + continue; + + dtNode newNode; + newNode.pidx = m_nodePool->getNodeIdx(bestNode); + newNode.id = neighbourRef; + + // Cost + float edgeMidPoint[3]; + dtVlerp(edgeMidPoint, va, vb, 0.5f); + + newNode.total = bestNode->total + dtVdist(previousEdgeMidPoint, edgeMidPoint); + + dtNode* actualNode = m_nodePool->getNode(newNode.id); + if (!actualNode) + continue; + + if (!((actualNode->flags & DT_NODE_OPEN) && newNode.total > actualNode->total) && + !((actualNode->flags & DT_NODE_CLOSED) && newNode.total > actualNode->total)) + { + actualNode->flags &= ~DT_NODE_CLOSED; + actualNode->pidx = newNode.pidx; + actualNode->total = newNode.total; + + if (actualNode->flags & DT_NODE_OPEN) + { + m_openList->modify(actualNode); + } + else + { + if (n < maxResult) + { + if (resultRef) + resultRef[n] = actualNode->id; + if (resultParent) + resultParent[n] = m_nodePool->getNodeAtIdx(actualNode->pidx)->id; + if (resultCost) + resultCost[n] = actualNode->total; + ++n; + } + actualNode->flags = DT_NODE_OPEN; + m_openList->push(actualNode); + } + } + } + } + + return n; +} + +int dtNavMeshQuery::findPolysAroundShape(dtPolyRef centerRef, const float* verts, const int nverts, + const dtQueryFilter* filter, + dtPolyRef* resultRef, dtPolyRef* resultParent, float* resultCost, + const int maxResult) const +{ + dtAssert(m_nav); + dtAssert(m_nodePool); + dtAssert(m_openList); + + // Validate input + if (!centerRef) return 0; + if (!m_nav->isValidPolyRef(centerRef)) return 0; + + m_nodePool->clear(); + m_openList->clear(); + + dtNode* startNode = m_nodePool->getNode(centerRef); + startNode->pidx = 0; + startNode->cost = 0; + startNode->total = 0; + startNode->id = centerRef; + startNode->flags = DT_NODE_OPEN; + m_openList->push(startNode); + + int n = 0; + if (n < maxResult) + { + if (resultRef) + resultRef[n] = startNode->id; + if (resultParent) + resultParent[n] = 0; + if (resultCost) + resultCost[n] = 0; + ++n; + } + + float centerPos[3] = {0,0,0}; + for (int i = 0; i < nverts; ++i) + dtVadd(centerPos,centerPos,&verts[i*3]); + dtVscale(centerPos,centerPos,1.0f/nverts); + + while (!m_openList->empty()) + { + dtNode* bestNode = m_openList->pop(); + + float previousEdgeMidPoint[3]; + + // Get poly and tile. + // The API input has been cheked already, skip checking internal data. + const dtPolyRef bestRef = bestNode->id; + const dtMeshTile* bestTile = 0; + const dtPoly* bestPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(bestRef, &bestTile, &bestPoly); + + // Get parent poly and tile. + dtPolyRef parentRef = 0; + const dtMeshTile* parentTile = 0; + const dtPoly* parentPoly = 0; + if (bestNode->pidx) + parentRef = m_nodePool->getNodeAtIdx(bestNode->pidx)->id; + if (parentRef) + { + m_nav->getTileAndPolyByRefUnsafe(parentRef, &parentTile, &parentPoly); + getEdgeMidPoint(parentRef, parentPoly, parentTile, + bestRef, bestPoly, bestTile, previousEdgeMidPoint); + } + else + { + dtVcopy(previousEdgeMidPoint, centerPos); + } + + for (unsigned int i = bestPoly->firstLink; i != DT_NULL_LINK; i = bestTile->links[i].next) + { + const dtLink* link = &bestTile->links[i]; + dtPolyRef neighbourRef = link->ref; + // Skip invalid neighbours and do not follow back to parent. + if (!neighbourRef || neighbourRef == parentRef) + continue; + + // Expand to neighbour + const dtMeshTile* neighbourTile = 0; + const dtPoly* neighbourPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(neighbourRef, &neighbourTile, &neighbourPoly); + + // Do not advance if the polygon is excluded by the filter. + if (!passFilter(filter, neighbourPoly->flags)) + continue; + + // Find edge and calc distance to the edge. + float va[3], vb[3]; + if (!getPortalPoints(bestRef, bestPoly, bestTile, neighbourRef, neighbourPoly, neighbourTile, va, vb)) + continue; + + // If the poly is not touching the edge to the next polygon, skip the connection it. + float tmin, tmax; + int segMin, segMax; + if (!dtIntersectSegmentPoly2D(va, vb, verts, nverts, tmin, tmax, segMin, segMax)) + continue; + if (tmin > 1.0f || tmax < 0.0f) + continue; + + dtNode newNode; + newNode.pidx = m_nodePool->getNodeIdx(bestNode); + newNode.id = neighbourRef; + + // Cost + float edgeMidPoint[3]; + dtVlerp(edgeMidPoint, va, vb, 0.5f); + + newNode.total = bestNode->total + dtVdist(previousEdgeMidPoint, edgeMidPoint); + + dtNode* actualNode = m_nodePool->getNode(newNode.id); + if (!actualNode) + continue; + + if (!((actualNode->flags & DT_NODE_OPEN) && newNode.total > actualNode->total) && + !((actualNode->flags & DT_NODE_CLOSED) && newNode.total > actualNode->total)) + { + actualNode->flags &= ~DT_NODE_CLOSED; + actualNode->pidx = newNode.pidx; + actualNode->total = newNode.total; + + if (actualNode->flags & DT_NODE_OPEN) + { + m_openList->modify(actualNode); + } + else + { + if (n < maxResult) + { + if (resultRef) + resultRef[n] = actualNode->id; + if (resultParent) + resultParent[n] = m_nodePool->getNodeAtIdx(actualNode->pidx)->id; + if (resultCost) + resultCost[n] = actualNode->total; + ++n; + } + actualNode->flags = DT_NODE_OPEN; + m_openList->push(actualNode); + } + } + } + } + + return n; +} + + +int dtNavMeshQuery::findLocalNeighbourhood(dtPolyRef centerRef, const float* centerPos, const float radius, + const dtQueryFilter* filter, + dtPolyRef* resultRef, dtPolyRef* resultParent, const int maxResult) const +{ + dtAssert(m_nav); + dtAssert(m_tinyNodePool); + + // Validate input + if (!centerRef) return 0; + if (!m_nav->isValidPolyRef(centerRef)) return 0; + + static const int MAX_STACK = 48; + dtNode* stack[MAX_STACK]; + int nstack = 0; + + m_tinyNodePool->clear(); + + dtNode* startNode = m_tinyNodePool->getNode(centerRef); + startNode->pidx = 0; + startNode->id = centerRef; + startNode->flags = DT_NODE_CLOSED; + stack[nstack++] = startNode; + + const float radiusSqr = dtSqr(radius); + + float pa[DT_VERTS_PER_POLYGON*3]; + float pb[DT_VERTS_PER_POLYGON*3]; + + int n = 0; + if (n < maxResult) + { + resultRef[n] = startNode->id; + if (resultParent) + resultParent[n] = 0; + ++n; + } + + while (nstack) + { + // Pop front. + dtNode* curNode = stack[0]; + for (int i = 0; i < nstack-1; ++i) + stack[i] = stack[i+1]; + nstack--; + + // Get poly and tile. + // The API input has been cheked already, skip checking internal data. + const dtPolyRef curRef = curNode->id; + const dtMeshTile* curTile = 0; + const dtPoly* curPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(curRef, &curTile, &curPoly); + + for (unsigned int i = curPoly->firstLink; i != DT_NULL_LINK; i = curTile->links[i].next) + { + const dtLink* link = &curTile->links[i]; + dtPolyRef neighbourRef = link->ref; + // Skip invalid neighbours. + if (!neighbourRef) + continue; + + // Skip if cannot alloca more nodes. + dtNode* neighbourNode = m_tinyNodePool->getNode(neighbourRef); + if (!neighbourNode) + continue; + // Skip visited. + if (neighbourNode->flags & DT_NODE_CLOSED) + continue; + + // Expand to neighbour + const dtMeshTile* neighbourTile = 0; + const dtPoly* neighbourPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(neighbourRef, &neighbourTile, &neighbourPoly); + + // Skip off-mesh connections. + if (neighbourPoly->type == DT_POLYTYPE_OFFMESH_CONNECTION) + continue; + + // Do not advance if the polygon is excluded by the filter. + if (!passFilter(filter, neighbourPoly->flags)) + continue; + + // Find edge and calc distance to the edge. + float va[3], vb[3]; + if (!getPortalPoints(curRef, curPoly, curTile, neighbourRef, neighbourPoly, neighbourTile, va, vb)) + continue; + + // If the circle is not touching the next polygon, skip it. + float tseg; + float distSqr = dtDistancePtSegSqr2D(centerPos, va, vb, tseg); + if (distSqr > radiusSqr) + continue; + + // Mark node visited, this is done before the overlap test so that + // we will not visit the poly again if the test fails. + neighbourNode->flags |= DT_NODE_CLOSED; + neighbourNode->pidx = m_tinyNodePool->getNodeIdx(curNode); + + // Check that the polygon does not collide with existing polygons. + + // Collect vertices of the neighbour poly. + const int npa = neighbourPoly->vertCount; + for (int k = 0; k < npa; ++k) + dtVcopy(&pa[k*3], &neighbourTile->verts[neighbourPoly->verts[k]*3]); + + bool overlap = false; + for (int j = 0; j < n; ++j) + { + dtPolyRef pastRef = resultRef[j]; + + // Connected polys do not overlap. + bool areConnected = false; + for (unsigned int k = curPoly->firstLink; k != DT_NULL_LINK; k = curTile->links[k].next) + { + if (curTile->links[k].ref == pastRef) + { + areConnected = true; + break; + } + } + if (areConnected) + continue; + + // Potentially overlapping. + const dtMeshTile* pastTile = 0; + const dtPoly* pastPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(pastRef, &pastTile, &pastPoly); + + // Get vertices and test overlap + const int npb = pastPoly->vertCount; + for (int k = 0; k < npb; ++k) + dtVcopy(&pb[k*3], &pastTile->verts[pastPoly->verts[k]*3]); + + if (dtOverlapPolyPoly2D(pa,npa, pb,npb)) + { + overlap = true; + break; + } + } + if (overlap) + continue; + + // This poly is fine, store and advance to the poly. + if (n < maxResult) + { + resultRef[n] = neighbourRef; + if (resultParent) + resultParent[n] = curRef; + ++n; + } + + if (nstack < MAX_STACK) + { + stack[nstack++] = neighbourNode; + } + } + } + + return n; +} + + +struct dtSegInterval +{ + short tmin, tmax; +}; + +static void insertInterval(dtSegInterval* ints, int& nints, const int maxInts, + const short tmin, const short tmax) +{ + if (nints+1 > maxInts) return; + // Find insertion point. + int idx = 0; + while (idx < nints) + { + if (tmax <= ints[idx].tmin) + break; + idx++; + } + // Move current results. + if (nints-idx) + memmove(ints+idx+1, ints+idx, sizeof(dtSegInterval)*(nints-idx)); + // Store + ints[idx].tmin = tmin; + ints[idx].tmax = tmax; + nints++; +} + +int dtNavMeshQuery::getPolyWallSegments(dtPolyRef ref, const dtQueryFilter* filter, float* segments) +{ + dtAssert(m_nav); + + const dtMeshTile* tile = 0; + const dtPoly* poly = 0; + if (!m_nav->getTileAndPolyByRef(ref, &tile, &poly)) + return 0; + + int n = 0; + static const int MAX_INTERVAL = 16; + dtSegInterval ints[MAX_INTERVAL]; + int nints; + + for (int i = 0, j = (int)poly->vertCount-1; i < (int)poly->vertCount; j = i++) + { + // Skip non-solid edges. + nints = 0; + if (poly->neis[j] & DT_EXT_LINK) + { + // Tile border. + for (unsigned int k = poly->firstLink; k != DT_NULL_LINK; k = tile->links[k].next) + { + const dtLink* link = &tile->links[k]; + if (link->edge == j) + { + if (link->ref != 0 && passFilter(filter, m_nav->getPolyFlags(link->ref))) + { + insertInterval(ints, nints, MAX_INTERVAL, link->bmin, link->bmax); + } + } + } + } + else if (poly->neis[j] && passFilter(filter, tile->polys[poly->neis[j]-1].flags)) + { + // Internal edge + continue; + } + + // Add sentinels + insertInterval(ints, nints, MAX_INTERVAL, -1, 0); + insertInterval(ints, nints, MAX_INTERVAL, 255, 256); + + // Store segment. + const float* vj = &tile->verts[poly->verts[j]*3]; + const float* vi = &tile->verts[poly->verts[i]*3]; + for (int k = 1; k < nints; ++k) + { + // Find the space inbetween the opening areas. + const int imin = ints[k-1].tmax; + const int imax = ints[k].tmin; + if (imin == imax) continue; + if (imin == 0 && imax == 255) + { + if (n < DT_VERTS_PER_POLYGON) + { + float* seg = &segments[n*6]; + n++; + dtVcopy(seg+0, vj); + dtVcopy(seg+3, vi); + } + } + else + { + const float tmin = imin/255.0f; + const float tmax = imax/255.0f; + if (n < DT_VERTS_PER_POLYGON) + { + float* seg = &segments[n*6]; + n++; + dtVlerp(seg+0, vj,vi, tmin); + dtVlerp(seg+3, vj,vi, tmax); + } + } + } + } + + return n; +} + +float dtNavMeshQuery::findDistanceToWall(dtPolyRef centerRef, const float* centerPos, float maxRadius, const dtQueryFilter* filter, + float* hitPos, float* hitNormal) const +{ + dtAssert(m_nav); + dtAssert(m_nodePool); + dtAssert(m_openList); + + // Validate input + if (!centerRef) return 0; + if (!m_nav->isValidPolyRef(centerRef)) return 0; + + m_nodePool->clear(); + m_openList->clear(); + + dtNode* startNode = m_nodePool->getNode(centerRef); + startNode->pidx = 0; + startNode->cost = 0; + startNode->total = 0; + startNode->id = centerRef; + startNode->flags = DT_NODE_OPEN; + m_openList->push(startNode); + + float radiusSqr = dtSqr(maxRadius); + + while (!m_openList->empty()) + { + dtNode* bestNode = m_openList->pop(); + + float previousEdgeMidPoint[3]; + + // Get poly and tile. + // The API input has been cheked already, skip checking internal data. + const dtPolyRef bestRef = bestNode->id; + const dtMeshTile* bestTile = 0; + const dtPoly* bestPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(bestRef, &bestTile, &bestPoly); + + // Get parent poly and tile. + dtPolyRef parentRef = 0; + const dtMeshTile* parentTile = 0; + const dtPoly* parentPoly = 0; + if (bestNode->pidx) + parentRef = m_nodePool->getNodeAtIdx(bestNode->pidx)->id; + if (parentRef) + { + m_nav->getTileAndPolyByRefUnsafe(parentRef, &parentTile, &parentPoly); + getEdgeMidPoint(parentRef, parentPoly, parentTile, + bestRef, bestPoly, bestTile, previousEdgeMidPoint); + } + else + { + dtVcopy(previousEdgeMidPoint, centerPos); + } + + // Hit test walls. + for (int i = 0, j = (int)bestPoly->vertCount-1; i < (int)bestPoly->vertCount; j = i++) + { + // Skip non-solid edges. + if (bestPoly->neis[j] & DT_EXT_LINK) + { + // Tile border. + bool solid = true; + for (unsigned int k = bestPoly->firstLink; k != DT_NULL_LINK; k = bestTile->links[k].next) + { + const dtLink* link = &bestTile->links[k]; + if (link->edge == j) + { + if (link->ref != 0 && passFilter(filter, m_nav->getPolyFlags(link->ref))) + solid = false; + break; + } + } + if (!solid) continue; + } + else if (bestPoly->neis[j] && passFilter(filter, bestTile->polys[bestPoly->neis[j]-1].flags)) + { + // Internal edge + continue; + } + + // Calc distance to the edge. + const float* vj = &bestTile->verts[bestPoly->verts[j]*3]; + const float* vi = &bestTile->verts[bestPoly->verts[i]*3]; + float tseg; + float distSqr = dtDistancePtSegSqr2D(centerPos, vj, vi, tseg); + + // Edge is too far, skip. + if (distSqr > radiusSqr) + continue; + + // Hit wall, update radius. + radiusSqr = distSqr; + // Calculate hit pos. + hitPos[0] = vj[0] + (vi[0] - vj[0])*tseg; + hitPos[1] = vj[1] + (vi[1] - vj[1])*tseg; + hitPos[2] = vj[2] + (vi[2] - vj[2])*tseg; + } + + for (unsigned int i = bestPoly->firstLink; i != DT_NULL_LINK; i = bestTile->links[i].next) + { + const dtLink* link = &bestTile->links[i]; + dtPolyRef neighbourRef = link->ref; + // Skip invalid neighbours and do not follow back to parent. + if (!neighbourRef || neighbourRef == parentRef) + continue; + + // Expand to neighbour. + const dtMeshTile* neighbourTile = 0; + const dtPoly* neighbourPoly = 0; + m_nav->getTileAndPolyByRefUnsafe(neighbourRef, &neighbourTile, &neighbourPoly); + + // Skip off-mesh connections. + if (neighbourPoly->type == DT_POLYTYPE_OFFMESH_CONNECTION) + continue; + + // Calc distance to the edge. + const float* va = &bestTile->verts[bestPoly->verts[link->edge]*3]; + const float* vb = &bestTile->verts[bestPoly->verts[(link->edge+1) % bestPoly->vertCount]*3]; + float tseg; + float distSqr = dtDistancePtSegSqr2D(centerPos, va, vb, tseg); + + // If the circle is not touching the next polygon, skip it. + if (distSqr > radiusSqr) + continue; + + if (!passFilter(filter, neighbourPoly->flags)) + continue; + + dtNode newNode; + newNode.pidx = m_nodePool->getNodeIdx(bestNode); + newNode.id = neighbourRef; + + // Cost + float edgeMidPoint[3]; + getEdgeMidPoint(bestRef, bestPoly, bestTile, + neighbourRef, neighbourPoly, neighbourTile, edgeMidPoint); + + newNode.total = bestNode->total + dtVdist(previousEdgeMidPoint, edgeMidPoint); + + dtNode* actualNode = m_nodePool->getNode(newNode.id); + if (!actualNode) + continue; + + if (!((actualNode->flags & DT_NODE_OPEN) && newNode.total > actualNode->total) && + !((actualNode->flags & DT_NODE_CLOSED) && newNode.total > actualNode->total)) + { + actualNode->flags &= ~DT_NODE_CLOSED; + actualNode->pidx = newNode.pidx; + actualNode->total = newNode.total; + + if (actualNode->flags & DT_NODE_OPEN) + { + m_openList->modify(actualNode); + } + else + { + actualNode->flags = DT_NODE_OPEN; + m_openList->push(actualNode); + } + } + } + } + + // Calc hit normal. + dtVsub(hitNormal, centerPos, hitPos); + dtVnormalize(hitNormal); + + return sqrtf(radiusSqr); +} + +bool dtNavMeshQuery::isInClosedList(dtPolyRef ref) const +{ + if (!m_nodePool) return false; + const dtNode* node = m_nodePool->findNode(ref); + return node && node->flags & DT_NODE_CLOSED; +} diff --git a/RecastDemo/Bin/Recast.app/Contents/MacOS/Recast b/RecastDemo/Bin/Recast.app/Contents/MacOS/Recast index 3c791844109a5543fb9ca2da67c6a277f62711fd..453644357d5555e0969918daa9d50d8d729356a1 100755 GIT binary patch delta 196695 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%0A2uG68uwwZpLM1T&SQ8!!rVW7>jHR^)_(4Cn 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 delta 190927 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 BRYv>$V9PSsF$UV9+|lJ-E7}jVI*##j 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%0DNDVhQH<7oBV0;`v{mPxv6#lOAJYb7QX!@ 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 diff --git a/RecastDemo/Build/Xcode/Recast.xcodeproj/memon.pbxuser b/RecastDemo/Build/Xcode/Recast.xcodeproj/memon.pbxuser index 612e29d..bc321f0 100644 --- a/RecastDemo/Build/Xcode/Recast.xcodeproj/memon.pbxuser +++ b/RecastDemo/Build/Xcode/Recast.xcodeproj/memon.pbxuser @@ -20,6 +20,7 @@ 6B42164711806B2F006C347B /* DetourDebugDraw.cpp:344 */, 6B10014C11AD1C1E0098A59A /* RecastMesh.cpp:1398 */, 6BAF3EB31212906D008CFCDF /* CrowdTool.cpp:774 */, + 6BAF42D6121AF2AC008CFCDF /* NavMeshTesterTool.cpp:149 */, ); codeSenseManager = 6B8632AA0F78115100E2684A /* Code sense */; executables = ( @@ -672,6 +673,158 @@ 6BAF4288121ADD46008CFCDF /* PBXTextBookmark */ = 6BAF4288121ADD46008CFCDF /* PBXTextBookmark */; 6BAF4289121ADD46008CFCDF /* PBXTextBookmark */ = 6BAF4289121ADD46008CFCDF /* PBXTextBookmark */; 6BAF428A121ADD46008CFCDF /* PBXTextBookmark */ = 6BAF428A121ADD46008CFCDF /* PBXTextBookmark */; + 6BAF428C121AEBDF008CFCDF /* PBXTextBookmark */ = 6BAF428C121AEBDF008CFCDF /* PBXTextBookmark */; + 6BAF428D121AEBDF008CFCDF /* PBXTextBookmark */ = 6BAF428D121AEBDF008CFCDF /* PBXTextBookmark */; + 6BAF428E121AEBDF008CFCDF /* PBXTextBookmark */ = 6BAF428E121AEBDF008CFCDF /* PBXTextBookmark */; + 6BAF428F121AEBDF008CFCDF /* PBXTextBookmark */ = 6BAF428F121AEBDF008CFCDF /* PBXTextBookmark */; + 6BAF4290121AEBDF008CFCDF /* PBXTextBookmark */ = 6BAF4290121AEBDF008CFCDF /* PBXTextBookmark */; + 6BAF4291121AEBDF008CFCDF /* PBXTextBookmark */ = 6BAF4291121AEBDF008CFCDF /* PBXTextBookmark */; + 6BAF4292121AEBDF008CFCDF /* PBXTextBookmark */ = 6BAF4292121AEBDF008CFCDF /* PBXTextBookmark */; + 6BAF4293121AEBDF008CFCDF /* PBXTextBookmark */ = 6BAF4293121AEBDF008CFCDF /* PBXTextBookmark */; + 6BAF4294121AEBDF008CFCDF /* PBXTextBookmark */ = 6BAF4294121AEBDF008CFCDF /* PBXTextBookmark */; + 6BAF4295121AEC2A008CFCDF /* PBXTextBookmark */ = 6BAF4295121AEC2A008CFCDF /* PBXTextBookmark */; + 6BAF4296121AEC2A008CFCDF /* PBXTextBookmark */ = 6BAF4296121AEC2A008CFCDF /* PBXTextBookmark */; + 6BAF4297121AEC2A008CFCDF /* PBXTextBookmark */ = 6BAF4297121AEC2A008CFCDF /* PBXTextBookmark */; + 6BAF4298121AEC2A008CFCDF /* PBXTextBookmark */ = 6BAF4298121AEC2A008CFCDF /* PBXTextBookmark */; + 6BAF4299121AEC2A008CFCDF /* PBXTextBookmark */ = 6BAF4299121AEC2A008CFCDF /* PBXTextBookmark */; + 6BAF429A121AED31008CFCDF /* PBXTextBookmark */ = 6BAF429A121AED31008CFCDF /* PBXTextBookmark */; + 6BAF429B121AED31008CFCDF /* PBXTextBookmark */ = 6BAF429B121AED31008CFCDF /* PBXTextBookmark */; + 6BAF429C121AED31008CFCDF /* PBXTextBookmark */ = 6BAF429C121AED31008CFCDF /* PBXTextBookmark */; + 6BAF429D121AED31008CFCDF /* PBXTextBookmark */ = 6BAF429D121AED31008CFCDF /* PBXTextBookmark */; + 6BAF429E121AED31008CFCDF /* PBXTextBookmark */ = 6BAF429E121AED31008CFCDF /* PBXTextBookmark */; + 6BAF429F121AED31008CFCDF /* PBXTextBookmark */ = 6BAF429F121AED31008CFCDF /* PBXTextBookmark */; + 6BAF42A0121AED31008CFCDF /* PBXTextBookmark */ = 6BAF42A0121AED31008CFCDF /* PBXTextBookmark */; + 6BAF42A1121AED31008CFCDF /* PBXTextBookmark */ = 6BAF42A1121AED31008CFCDF /* PBXTextBookmark */; + 6BAF42A2121AED31008CFCDF /* PBXTextBookmark */ = 6BAF42A2121AED31008CFCDF /* PBXTextBookmark */; + 6BAF42A3121AED31008CFCDF /* PBXTextBookmark */ = 6BAF42A3121AED31008CFCDF /* PBXTextBookmark */; + 6BAF42A4121AED31008CFCDF /* PBXTextBookmark */ = 6BAF42A4121AED31008CFCDF /* PBXTextBookmark */; + 6BAF42A5121AEFD9008CFCDF /* PBXTextBookmark */ = 6BAF42A5121AEFD9008CFCDF /* PBXTextBookmark */; + 6BAF42A6121AEFD9008CFCDF /* PBXTextBookmark */ = 6BAF42A6121AEFD9008CFCDF /* PBXTextBookmark */; + 6BAF42A7121AEFD9008CFCDF /* PBXTextBookmark */ = 6BAF42A7121AEFD9008CFCDF /* PBXTextBookmark */; + 6BAF42A8121AEFD9008CFCDF /* PBXTextBookmark */ = 6BAF42A8121AEFD9008CFCDF /* PBXTextBookmark */; + 6BAF42A9121AEFD9008CFCDF /* PBXTextBookmark */ = 6BAF42A9121AEFD9008CFCDF /* PBXTextBookmark */; + 6BAF42AA121AEFD9008CFCDF /* PBXTextBookmark */ = 6BAF42AA121AEFD9008CFCDF /* PBXTextBookmark */; + 6BAF42AB121AEFD9008CFCDF /* PBXTextBookmark */ = 6BAF42AB121AEFD9008CFCDF /* PBXTextBookmark */; + 6BAF42AC121AEFD9008CFCDF /* PBXTextBookmark */ = 6BAF42AC121AEFD9008CFCDF /* PBXTextBookmark */; + 6BAF42B3121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42B3121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42B4121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42B4121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42B5121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42B5121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42B6121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42B6121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42B7121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42B7121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42B8121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42B8121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42B9121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42B9121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42BA121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42BA121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42BB121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42BB121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42BC121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42BC121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42BD121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42BD121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42BE121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42BE121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42BF121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42BF121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42C0121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42C0121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42C1121AF141008CFCDF /* PBXTextBookmark */ = 6BAF42C1121AF141008CFCDF /* PBXTextBookmark */; + 6BAF42C3121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42C3121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42C4121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42C4121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42C5121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42C5121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42C6121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42C6121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42C7121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42C7121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42C8121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42C8121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42C9121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42C9121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42CA121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42CA121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42CB121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42CB121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42CC121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42CC121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42CD121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42CD121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42CE121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42CE121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42CF121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42CF121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42D0121AF27C008CFCDF /* PBXTextBookmark */ = 6BAF42D0121AF27C008CFCDF /* PBXTextBookmark */; + 6BAF42D2121AF2A3008CFCDF /* PBXTextBookmark */ = 6BAF42D2121AF2A3008CFCDF /* PBXTextBookmark */; + 6BAF42D3121AF2A8008CFCDF /* PBXTextBookmark */ = 6BAF42D3121AF2A8008CFCDF /* PBXTextBookmark */; + 6BAF42D4121AF2A8008CFCDF /* PBXTextBookmark */ = 6BAF42D4121AF2A8008CFCDF /* PBXTextBookmark */; + 6BAF42D8121AF2AF008CFCDF /* PBXTextBookmark */ = 6BAF42D8121AF2AF008CFCDF /* PBXTextBookmark */; + 6BAF42DB121AF2C3008CFCDF /* PBXTextBookmark */ = 6BAF42DB121AF2C3008CFCDF /* PBXTextBookmark */; + 6BAF42E1121AF3B8008CFCDF /* PBXTextBookmark */ = 6BAF42E1121AF3B8008CFCDF /* PBXTextBookmark */; + 6BAF42E2121AF3B8008CFCDF /* PBXTextBookmark */ = 6BAF42E2121AF3B8008CFCDF /* PBXTextBookmark */; + 6BAF42E3121AF3B8008CFCDF /* PBXTextBookmark */ = 6BAF42E3121AF3B8008CFCDF /* PBXTextBookmark */; + 6BAF42E4121AF3B8008CFCDF /* PBXTextBookmark */ = 6BAF42E4121AF3B8008CFCDF /* PBXTextBookmark */; + 6BAF42E5121AF3B8008CFCDF /* PBXTextBookmark */ = 6BAF42E5121AF3B8008CFCDF /* PBXTextBookmark */; + 6BAF42E6121AF3B8008CFCDF /* PBXTextBookmark */ = 6BAF42E6121AF3B8008CFCDF /* PBXTextBookmark */; + 6BAF42E7121AF3B8008CFCDF /* PBXTextBookmark */ = 6BAF42E7121AF3B8008CFCDF /* PBXTextBookmark */; + 6BAF42E8121AF3B8008CFCDF /* PBXTextBookmark */ = 6BAF42E8121AF3B8008CFCDF /* PBXTextBookmark */; + 6BAF42E9121AF3B8008CFCDF /* PBXTextBookmark */ = 6BAF42E9121AF3B8008CFCDF /* PBXTextBookmark */; + 6BAF42EC121AF3DE008CFCDF /* PBXTextBookmark */ = 6BAF42EC121AF3DE008CFCDF /* PBXTextBookmark */; + 6BAF42EE121AF43D008CFCDF /* PBXTextBookmark */ = 6BAF42EE121AF43D008CFCDF /* PBXTextBookmark */; + 6BAF42EF121AF43D008CFCDF /* PBXTextBookmark */ = 6BAF42EF121AF43D008CFCDF /* PBXTextBookmark */; + 6BAF42F0121AF43D008CFCDF /* PBXTextBookmark */ = 6BAF42F0121AF43D008CFCDF /* PBXTextBookmark */; + 6BAF42F1121AF43D008CFCDF /* PBXTextBookmark */ = 6BAF42F1121AF43D008CFCDF /* PBXTextBookmark */; + 6BAF42F2121AF43D008CFCDF /* PBXTextBookmark */ = 6BAF42F2121AF43D008CFCDF /* PBXTextBookmark */; + 6BAF42F3121AF43D008CFCDF /* PBXTextBookmark */ = 6BAF42F3121AF43D008CFCDF /* PBXTextBookmark */; + 6BAF42F4121AF43D008CFCDF /* PBXTextBookmark */ = 6BAF42F4121AF43D008CFCDF /* PBXTextBookmark */; + 6BAF42F9121AF514008CFCDF /* PBXTextBookmark */ = 6BAF42F9121AF514008CFCDF /* PBXTextBookmark */; + 6BAF42FA121AF514008CFCDF /* PBXTextBookmark */ = 6BAF42FA121AF514008CFCDF /* PBXTextBookmark */; + 6BAF42FB121AF514008CFCDF /* PBXTextBookmark */ = 6BAF42FB121AF514008CFCDF /* PBXTextBookmark */; + 6BAF42FC121AF514008CFCDF /* PBXTextBookmark */ = 6BAF42FC121AF514008CFCDF /* PBXTextBookmark */; + 6BAF42FD121AF514008CFCDF /* PBXTextBookmark */ = 6BAF42FD121AF514008CFCDF /* PBXTextBookmark */; + 6BAF42FE121AF514008CFCDF /* PBXTextBookmark */ = 6BAF42FE121AF514008CFCDF /* PBXTextBookmark */; + 6BAF42FF121AF514008CFCDF /* PBXTextBookmark */ = 6BAF42FF121AF514008CFCDF /* PBXTextBookmark */; + 6BAF4300121AF514008CFCDF /* PBXTextBookmark */ = 6BAF4300121AF514008CFCDF /* PBXTextBookmark */; + 6BAF4301121AF514008CFCDF /* PBXTextBookmark */ = 6BAF4301121AF514008CFCDF /* PBXTextBookmark */; + 6BAF4302121AF514008CFCDF /* PBXTextBookmark */ = 6BAF4302121AF514008CFCDF /* PBXTextBookmark */; + 6BAF4303121AF514008CFCDF /* PBXTextBookmark */ = 6BAF4303121AF514008CFCDF /* PBXTextBookmark */; + 6BAF4304121AF514008CFCDF /* PBXTextBookmark */ = 6BAF4304121AF514008CFCDF /* PBXTextBookmark */; + 6BAF4305121AF514008CFCDF /* PBXTextBookmark */ = 6BAF4305121AF514008CFCDF /* PBXTextBookmark */; + 6BAF4306121AF574008CFCDF /* PBXTextBookmark */ = 6BAF4306121AF574008CFCDF /* PBXTextBookmark */; + 6BAF4307121AF6E0008CFCDF /* PBXTextBookmark */ = 6BAF4307121AF6E0008CFCDF /* PBXTextBookmark */; + 6BAF4308121AF6E0008CFCDF /* PBXTextBookmark */ = 6BAF4308121AF6E0008CFCDF /* PBXTextBookmark */; + 6BAF4309121AF6E0008CFCDF /* PBXTextBookmark */ = 6BAF4309121AF6E0008CFCDF /* PBXTextBookmark */; + 6BAF430A121AF6E0008CFCDF /* PBXTextBookmark */ = 6BAF430A121AF6E0008CFCDF /* PBXTextBookmark */; + 6BAF430C121AF7CD008CFCDF /* PBXTextBookmark */ = 6BAF430C121AF7CD008CFCDF /* PBXTextBookmark */; + 6BAF430D121AF7CD008CFCDF /* PBXTextBookmark */ = 6BAF430D121AF7CD008CFCDF /* PBXTextBookmark */; + 6BAF430E121AF7CD008CFCDF /* PBXTextBookmark */ = 6BAF430E121AF7CD008CFCDF /* PBXTextBookmark */; + 6BAF430F121AF7CD008CFCDF /* PBXTextBookmark */ = 6BAF430F121AF7CD008CFCDF /* PBXTextBookmark */; + 6BAF4310121AF7CD008CFCDF /* PBXTextBookmark */ = 6BAF4310121AF7CD008CFCDF /* PBXTextBookmark */; + 6BAF4311121AF7CD008CFCDF /* PBXTextBookmark */ = 6BAF4311121AF7CD008CFCDF /* PBXTextBookmark */; + 6BAF4312121AF7CD008CFCDF /* PBXTextBookmark */ = 6BAF4312121AF7CD008CFCDF /* PBXTextBookmark */; + 6BAF4313121AF7CD008CFCDF /* PBXTextBookmark */ = 6BAF4313121AF7CD008CFCDF /* PBXTextBookmark */; + 6BAF4314121AF7CD008CFCDF /* PBXTextBookmark */ = 6BAF4314121AF7CD008CFCDF /* PBXTextBookmark */; + 6BAF4315121AF7CD008CFCDF /* PBXTextBookmark */ = 6BAF4315121AF7CD008CFCDF /* PBXTextBookmark */; + 6BAF4321121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4321121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4322121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4322121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4323121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4323121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4324121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4324121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4325121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4325121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4326121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4326121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4327121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4327121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4328121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4328121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4329121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4329121AF998008CFCDF /* PBXTextBookmark */; + 6BAF432A121AF998008CFCDF /* PBXTextBookmark */ = 6BAF432A121AF998008CFCDF /* PBXTextBookmark */; + 6BAF432B121AF998008CFCDF /* PBXTextBookmark */ = 6BAF432B121AF998008CFCDF /* PBXTextBookmark */; + 6BAF432C121AF998008CFCDF /* PBXTextBookmark */ = 6BAF432C121AF998008CFCDF /* PBXTextBookmark */; + 6BAF432D121AF998008CFCDF /* PBXTextBookmark */ = 6BAF432D121AF998008CFCDF /* PBXTextBookmark */; + 6BAF432E121AF998008CFCDF /* PBXTextBookmark */ = 6BAF432E121AF998008CFCDF /* PBXTextBookmark */; + 6BAF432F121AF998008CFCDF /* PBXTextBookmark */ = 6BAF432F121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4330121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4330121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4331121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4331121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4332121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4332121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4333121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4333121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4334121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4334121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4335121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4335121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4336121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4336121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4337121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4337121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4338121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4338121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4339121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4339121AF998008CFCDF /* PBXTextBookmark */; + 6BAF433A121AF998008CFCDF /* PBXTextBookmark */ = 6BAF433A121AF998008CFCDF /* PBXTextBookmark */; + 6BAF433B121AF998008CFCDF /* PBXTextBookmark */ = 6BAF433B121AF998008CFCDF /* PBXTextBookmark */; + 6BAF433C121AF998008CFCDF /* PBXTextBookmark */ = 6BAF433C121AF998008CFCDF /* PBXTextBookmark */; + 6BAF433D121AF998008CFCDF /* PBXTextBookmark */ = 6BAF433D121AF998008CFCDF /* PBXTextBookmark */; + 6BAF433E121AF998008CFCDF /* PBXTextBookmark */ = 6BAF433E121AF998008CFCDF /* PBXTextBookmark */; + 6BAF433F121AF998008CFCDF /* PBXTextBookmark */ = 6BAF433F121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4340121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4340121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4341121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4341121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4342121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4342121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4343121AF998008CFCDF /* PBXTextBookmark */ = 6BAF4343121AF998008CFCDF /* PBXTextBookmark */; + 6BAF4346121AFD0B008CFCDF /* PBXTextBookmark */ = 6BAF4346121AFD0B008CFCDF /* PBXTextBookmark */; + 6BAF4347121AFD0B008CFCDF /* PBXTextBookmark */ = 6BAF4347121AFD0B008CFCDF /* PBXTextBookmark */; + 6BAF4348121AFD0B008CFCDF /* PBXTextBookmark */ = 6BAF4348121AFD0B008CFCDF /* PBXTextBookmark */; + 6BAF4349121AFD0B008CFCDF /* PBXTextBookmark */ = 6BAF4349121AFD0B008CFCDF /* PBXTextBookmark */; + 6BAF434F121B00EF008CFCDF /* PBXTextBookmark */ = 6BAF434F121B00EF008CFCDF /* PBXTextBookmark */; 6BBB4AA1115B4F3400CF791D = 6BBB4AA1115B4F3400CF791D /* PBXTextBookmark */; 6BBB4AA5115B4F3400CF791D = 6BBB4AA5115B4F3400CF791D /* PBXTextBookmark */; 6BBB4AA6115B4F3400CF791D = 6BBB4AA6115B4F3400CF791D /* PBXTextBookmark */; @@ -797,21 +950,21 @@ ignoreCount = 0; lineNumber = 1398; location = Recast; - modificationTime = 303302369.986618; + modificationTime = 303756251.189612; state = 1; }; 6B1185F41006895B0018F96F /* DetourNode.cpp */ = { uiCtxt = { sepNavIntBoundsRect = "{{0, 0}, {933, 2400}}"; - sepNavSelRange = "{3326, 0}"; - sepNavVisRange = "{3038, 580}"; + sepNavSelRange = "{2743, 0}"; + sepNavVisRange = "{2449, 587}"; }; }; 6B1185F61006896B0018F96F /* DetourNode.h */ = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {933, 2432}}"; - sepNavSelRange = "{1049, 0}"; - sepNavVisRange = "{1035, 525}"; + sepNavIntBoundsRect = "{{0, 0}, {933, 2096}}"; + sepNavSelRange = "{1440, 0}"; + sepNavVisRange = "{1065, 607}"; }; }; 6B1185FC10068B040018F96F /* DetourCommon.h */ = { @@ -984,9 +1137,9 @@ }; 6B2AEC520FFB8958005BE9CC /* Sample_TileMesh.cpp */ = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {1223, 17072}}"; + sepNavIntBoundsRect = "{{0, 0}, {1223, 16864}}"; sepNavSelRange = "{11262, 0}"; - sepNavVisRange = "{10933, 434}"; + sepNavVisRange = "{10849, 874}"; sepNavWindowFrame = "{{38, 30}, {1214, 722}}"; }; }; @@ -1058,7 +1211,7 @@ ignoreCount = 0; lineNumber = 344; location = Recast; - modificationTime = 303302369.986238; + modificationTime = 303756251.189394; state = 1; }; 6B555DAE100B211D00247EA3 /* imguiRenderGL.h */ = { @@ -1180,9 +1333,9 @@ }; 6B8DE88B10B69E4C00DF20FB /* DetourNavMesh.h */ = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {933, 6384}}"; - sepNavSelRange = "{9670, 0}"; - sepNavVisRange = "{9355, 1084}"; + sepNavIntBoundsRect = "{{0, 0}, {933, 6048}}"; + sepNavSelRange = "{9902, 0}"; + sepNavVisRange = "{9407, 1261}"; }; }; 6B8DE88C10B69E4C00DF20FB /* DetourNavMeshBuilder.h */ = { @@ -1904,7 +2057,7 @@ fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; name = "NavMeshTesterTool.h: 40"; rLen = 28; - rLoc = 1365; + rLoc = 1427; rType = 0; vrLen = 751; vrLoc = 1073; @@ -1914,7 +2067,7 @@ fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; name = "NavMeshTesterTool.h: 40"; rLen = 0; - rLoc = 1393; + rLoc = 1455; rType = 0; vrLen = 751; vrLoc = 1073; @@ -1924,7 +2077,7 @@ fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; name = "NavMeshTesterTool.h: 41"; rLen = 33; - rLoc = 1397; + rLoc = 1459; rType = 0; vrLen = 752; vrLoc = 1073; @@ -1934,7 +2087,7 @@ fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; name = "NavMeshTesterTool.h: 69"; rLen = 21; - rLoc = 2043; + rLoc = 2105; rType = 0; vrLen = 798; vrLoc = 1302; @@ -1974,7 +2127,7 @@ fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; name = "NavMeshTesterTool.h: 69"; rLen = 21; - rLoc = 2043; + rLoc = 2105; rType = 0; vrLen = 701; vrLoc = 1399; @@ -1984,7 +2137,7 @@ fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; name = "NavMeshTesterTool.h: 69"; rLen = 4; - rLoc = 2054; + rLoc = 2116; rType = 0; vrLen = 701; vrLoc = 1399; @@ -2014,7 +2167,7 @@ fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; name = "NavMeshTesterTool.h: 53"; rLen = 0; - rLoc = 1643; + rLoc = 1705; rType = 0; vrLen = 789; vrLoc = 1269; @@ -2024,7 +2177,7 @@ fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; name = "NavMeshTesterTool.h: 53"; rLen = 0; - rLoc = 1643; + rLoc = 1705; rType = 0; vrLen = 770; vrLoc = 1269; @@ -2558,7 +2711,7 @@ fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; name = "NavMeshTesterTool.h: 90"; rLen = 0; - rLoc = 2603; + rLoc = 2665; rType = 0; vrLen = 613; vrLoc = 2198; @@ -2608,7 +2761,7 @@ fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; name = "NavMeshTesterTool.h: 93"; rLen = 0; - rLoc = 2704; + rLoc = 2766; rType = 0; vrLen = 876; vrLoc = 1975; @@ -2698,7 +2851,7 @@ fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; name = "NavMeshTesterTool.h: 93"; rLen = 0; - rLoc = 2704; + rLoc = 2766; rType = 0; vrLen = 876; vrLoc = 1975; @@ -2877,7 +3030,7 @@ ignoreCount = 0; lineNumber = 774; location = Recast; - modificationTime = 303302369.988047; + modificationTime = 303756251.189829; state = 1; }; 6BAF3EE41212B890008CFCDF /* PBXTextBookmark */ = { @@ -2975,7 +3128,7 @@ fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; name = "NavMeshTesterTool.cpp: 901"; rLen = 0; - rLoc = 10416; + rLoc = 4259; rType = 0; vrLen = 1017; vrLoc = 24722; @@ -3372,16 +3525,16 @@ }; 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */ = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {1219, 4976}}"; - sepNavSelRange = "{1580, 0}"; - sepNavVisRange = "{1320, 500}"; + sepNavIntBoundsRect = "{{0, 0}, {933, 5648}}"; + sepNavSelRange = "{14986, 7}"; + sepNavVisRange = "{14379, 762}"; }; }; 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */ = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {933, 32864}}"; - sepNavSelRange = "{2897, 0}"; - sepNavVisRange = "{2540, 555}"; + sepNavIntBoundsRect = "{{0, 0}, {933, 37920}}"; + sepNavSelRange = "{23224, 0}"; + sepNavVisRange = "{23011, 629}"; }; }; 6BAF40F012197F3D008CFCDF /* PBXTextBookmark */ = { @@ -3539,7 +3692,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 85"; rLen = 0; - rLoc = 2557; + rLoc = 2298; rType = 0; vrLen = 771; vrLoc = 2352; @@ -3549,7 +3702,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 42"; rLen = 0; - rLoc = 1580; + rLoc = 1751; rType = 0; vrLen = 1202; vrLoc = 1296; @@ -3639,7 +3792,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 1"; rLen = 0; - rLoc = 13992; + rLoc = 15460; rType = 0; vrLen = 0; vrLoc = 0; @@ -3709,7 +3862,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 446"; rLen = 0; - rLoc = 1318; + rLoc = 1489; rType = 0; vrLen = 1574; vrLoc = 19399; @@ -3739,7 +3892,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 557"; rLen = 0; - rLoc = 1318; + rLoc = 1489; rType = 0; vrLen = 1923; vrLoc = 22937; @@ -3749,7 +3902,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 553"; rLen = 0; - rLoc = 1318; + rLoc = 1489; rType = 0; vrLen = 1881; vrLoc = 22979; @@ -3809,7 +3962,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 345"; rLen = 0; - rLoc = 13501; + rLoc = 14728; rType = 0; vrLen = 1276; vrLoc = 2729; @@ -3829,7 +3982,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 347"; rLen = 0; - rLoc = 13554; + rLoc = 15022; rType = 0; vrLen = 1739; vrLoc = 14760; @@ -3849,7 +4002,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 243"; rLen = 0; - rLoc = 12022; + rLoc = 13249; rType = 0; vrLen = 1549; vrLoc = 10593; @@ -3899,7 +4052,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 31"; rLen = 0; - rLoc = 1296; + rLoc = 1467; rType = 0; vrLen = 1367; vrLoc = 0; @@ -3989,7 +4142,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 43"; rLen = 0; - rLoc = 1629; + rLoc = 1800; rType = 0; vrLen = 1152; vrLoc = 1296; @@ -3999,7 +4152,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 42"; rLen = 34; - rLoc = 1591; + rLoc = 1762; rType = 0; vrLen = 1152; vrLoc = 1296; @@ -4059,7 +4212,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 434"; rLen = 0; - rLoc = 8776; + rLoc = 2298; rType = 0; vrLen = 945; vrLoc = 11177; @@ -4069,7 +4222,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 46"; rLen = 0; - rLoc = 1727; + rLoc = 1898; rType = 0; vrLen = 1264; vrLoc = 1119; @@ -4099,7 +4252,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 1054"; rLen = 0; - rLoc = 8776; + rLoc = 2298; rType = 0; vrLen = 929; vrLoc = 27740; @@ -4109,7 +4262,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 46"; rLen = 0; - rLoc = 1727; + rLoc = 1898; rType = 0; vrLen = 1264; vrLoc = 1119; @@ -4119,7 +4272,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 1051"; rLen = 0; - rLoc = 8776; + rLoc = 2298; rType = 0; vrLen = 929; vrLoc = 27740; @@ -4129,7 +4282,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 269"; rLen = 15; - rLoc = 12858; + rLoc = 14085; rType = 0; vrLen = 1613; vrLoc = 12036; @@ -4139,7 +4292,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 1390"; rLen = 0; - rLoc = 8776; + rLoc = 2298; rType = 0; vrLen = 839; vrLoc = 36447; @@ -4239,7 +4392,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 103"; rLen = 0; - rLoc = 3099; + rLoc = 2298; rType = 0; vrLen = 659; vrLoc = 2652; @@ -4259,7 +4412,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 1187"; rLen = 0; - rLoc = 32000; + rLoc = 38401; rType = 0; vrLen = 873; vrLoc = 31973; @@ -4409,7 +4562,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 42"; rLen = 0; - rLoc = 1580; + rLoc = 1751; rType = 0; vrLen = 1202; vrLoc = 1296; @@ -4419,7 +4572,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 85"; rLen = 0; - rLoc = 2557; + rLoc = 2298; rType = 0; vrLen = 771; vrLoc = 2352; @@ -4429,7 +4582,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 42"; rLen = 0; - rLoc = 1580; + rLoc = 1751; rType = 0; vrLen = 1152; vrLoc = 1296; @@ -4439,7 +4592,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 42"; rLen = 0; - rLoc = 1580; + rLoc = 1751; rType = 0; vrLen = 433; vrLoc = 1296; @@ -4449,7 +4602,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 42"; rLen = 0; - rLoc = 1580; + rLoc = 1751; rType = 0; vrLen = 1112; vrLoc = 1036; @@ -4539,7 +4692,7 @@ fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; name = "NavMeshTesterTool.cpp: 1086"; rLen = 0; - rLoc = 31188; + rLoc = 32740; rType = 0; vrLen = 815; vrLoc = 30646; @@ -4559,7 +4712,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 42"; rLen = 0; - rLoc = 1580; + rLoc = 1751; rType = 0; vrLen = 1112; vrLoc = 1036; @@ -4699,7 +4852,7 @@ fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; name = "NavMeshTesterTool.cpp: 187"; rLen = 0; - rLoc = 4953; + rLoc = 4259; rType = 0; vrLen = 527; vrLoc = 4664; @@ -4719,7 +4872,7 @@ fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; name = "NavMeshTesterTool.cpp: 186"; rLen = 0; - rLoc = 4949; + rLoc = 4259; rType = 0; vrLen = 567; vrLoc = 4680; @@ -4749,7 +4902,7 @@ fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; name = "NavMeshTesterTool.cpp: 1086"; rLen = 0; - rLoc = 31188; + rLoc = 32740; rType = 0; vrLen = 815; vrLoc = 30646; @@ -4809,7 +4962,7 @@ fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; name = "NavMeshTesterTool.cpp: 306"; rLen = 0; - rLoc = 8126; + rLoc = 4259; rType = 0; vrLen = 522; vrLoc = 7759; @@ -5079,7 +5232,7 @@ fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; name = "NavMeshTesterTool.cpp: 306"; rLen = 0; - rLoc = 8126; + rLoc = 4259; rType = 0; vrLen = 522; vrLoc = 7759; @@ -5259,7 +5412,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 42"; rLen = 0; - rLoc = 1538; + rLoc = 1709; rType = 0; vrLen = 1144; vrLoc = 1296; @@ -5289,7 +5442,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 42"; rLen = 0; - rLoc = 1538; + rLoc = 1709; rType = 0; vrLen = 1144; vrLoc = 1296; @@ -5309,7 +5462,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 42"; rLen = 0; - rLoc = 1538; + rLoc = 1709; rType = 0; vrLen = 1192; vrLoc = 1296; @@ -5319,7 +5472,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 444"; rLen = 0; - rLoc = 12030; + rLoc = 2298; rType = 0; vrLen = 707; vrLoc = 11211; @@ -5349,7 +5502,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 44"; rLen = 4; - rLoc = 1586; + rLoc = 1757; rType = 0; vrLen = 1186; vrLoc = 1296; @@ -5359,7 +5512,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 42"; rLen = 0; - rLoc = 1538; + rLoc = 1709; rType = 0; vrLen = 1192; vrLoc = 1296; @@ -5399,7 +5552,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 444"; rLen = 0; - rLoc = 12030; + rLoc = 2298; rType = 0; vrLen = 707; vrLoc = 11211; @@ -5429,7 +5582,7 @@ fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; name = "NavMeshTesterTool.cpp: 813"; rLen = 0; - rLoc = 22727; + rLoc = 4259; rType = 0; vrLen = 548; vrLoc = 22421; @@ -5459,7 +5612,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 971"; rLen = 0; - rLoc = 26141; + rLoc = 32542; rType = 0; vrLen = 565; vrLoc = 25850; @@ -5499,7 +5652,7 @@ fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; name = "NavMeshTesterTool.cpp: 813"; rLen = 0; - rLoc = 22727; + rLoc = 4259; rType = 0; vrLen = 548; vrLoc = 22421; @@ -5539,7 +5692,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 443"; rLen = 0; - rLoc = 12026; + rLoc = 2298; rType = 0; vrLen = 701; vrLoc = 11217; @@ -5568,8 +5721,8 @@ isa = PBXTextBookmark; fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 344"; - rLen = 8; - rLoc = 9281; + rLen = 0; + rLoc = 2298; rType = 0; vrLen = 1165; vrLoc = 8952; @@ -5699,7 +5852,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 971"; rLen = 0; - rLoc = 26141; + rLoc = 32542; rType = 0; vrLen = 565; vrLoc = 25850; @@ -5969,7 +6122,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 267"; rLen = 18; - rLoc = 12741; + rLoc = 13968; rType = 0; vrLen = 1555; vrLoc = 11945; @@ -5978,8 +6131,8 @@ isa = PBXTextBookmark; fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 133"; - rLen = 24; - rLoc = 3920; + rLen = 0; + rLoc = 2298; rType = 0; vrLen = 914; vrLoc = 3561; @@ -5998,8 +6151,8 @@ isa = PBXTextBookmark; fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 133"; - rLen = 24; - rLoc = 3920; + rLen = 0; + rLoc = 2298; rType = 0; vrLen = 914; vrLoc = 3561; @@ -6009,7 +6162,7 @@ fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; name = "DetourNavMeshQuery.h: 267"; rLen = 18; - rLoc = 12741; + rLoc = 13968; rType = 0; vrLen = 1555; vrLoc = 11945; @@ -6019,7 +6172,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 139"; rLen = 0; - rLoc = 4177; + rLoc = 2298; rType = 0; vrLen = 968; vrLoc = 3345; @@ -6029,7 +6182,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 169"; rLen = 0; - rLoc = 4834; + rLoc = 2298; rType = 0; vrLen = 692; vrLoc = 4008; @@ -6039,7 +6192,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 325"; rLen = 0; - rLoc = 8669; + rLoc = 2298; rType = 0; vrLen = 788; vrLoc = 8090; @@ -6049,7 +6202,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 557"; rLen = 0; - rLoc = 14939; + rLoc = 2298; rType = 0; vrLen = 901; vrLoc = 14127; @@ -6059,7 +6212,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 1067"; rLen = 0; - rLoc = 28507; + rLoc = 34908; rType = 0; vrLen = 873; vrLoc = 27849; @@ -6069,7 +6222,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 1940"; rLen = 0; - rLoc = 51737; + rLoc = 58138; rType = 0; vrLen = 786; vrLoc = 52107; @@ -6079,7 +6232,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 2061"; rLen = 1; - rLoc = 55297; + rLoc = 61698; rType = 0; vrLen = 885; vrLoc = 54109; @@ -6089,7 +6242,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 2061"; rLen = 1; - rLoc = 55297; + rLoc = 61698; rType = 0; vrLen = 885; vrLoc = 54109; @@ -6129,7 +6282,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 2061"; rLen = 1; - rLoc = 55297; + rLoc = 61698; rType = 0; vrLen = 885; vrLoc = 54109; @@ -6189,7 +6342,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 2042"; rLen = 1; - rLoc = 54978; + rLoc = 61379; rType = 0; vrLen = 458; vrLoc = 54536; @@ -6247,7 +6400,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 2042"; rLen = 1; - rLoc = 54978; + rLoc = 61379; rType = 0; vrLen = 458; vrLoc = 54536; @@ -6266,8 +6419,8 @@ isa = PBXTextBookmark; fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 137"; - rLen = 61; - rLoc = 4031; + rLen = 0; + rLoc = 2298; rType = 0; vrLen = 758; vrLoc = 3606; @@ -6306,8 +6459,8 @@ isa = PBXTextBookmark; comments = "error: 'class dtNavMesh' has no member named 'getPolyByRef'"; fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; - rLen = 1; - rLoc = 818; + rLen = 0; + rLoc = 148; rType = 1; }; 6BAF4254121AD7D7008CFCDF /* PBXTextBookmark */ = { @@ -6355,7 +6508,7 @@ fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; name = "NavMeshTesterTool.cpp: 829"; rLen = 0; - rLoc = 22986; + rLoc = 4259; rType = 0; vrLen = 516; vrLoc = 22476; @@ -6378,7 +6531,7 @@ fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; name = "NavMeshTesterTool.cpp: 815"; rLen = 0; - rLoc = 22658; + rLoc = 4259; rType = 0; vrLen = 516; vrLoc = 22476; @@ -6448,7 +6601,7 @@ fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; name = "NavMeshTesterTool.cpp: 815"; rLen = 0; - rLoc = 22658; + rLoc = 4259; rType = 0; vrLen = 516; vrLoc = 22476; @@ -6645,7 +6798,7 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 1893"; rLen = 0; - rLoc = 50401; + rLoc = 56802; rType = 0; vrLen = 1207; vrLoc = 0; @@ -6685,11 +6838,1538 @@ fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; name = "DetourNavMeshQuery.cpp: 101"; rLen = 0; - rLoc = 2897; + rLoc = 2298; rType = 0; vrLen = 555; vrLoc = 2540; }; + 6BAF428C121AEBDF008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6B8DE88B10B69E4C00DF20FB /* DetourNavMesh.h */; + name = "DetourNavMesh.h: 252"; + rLen = 0; + rLoc = 9902; + rType = 0; + vrLen = 1544; + vrLoc = 9124; + }; + 6BAF428D121AEBDF008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 33"; + rLen = 0; + rLoc = 1315; + rType = 0; + vrLen = 714; + vrLoc = 842; + }; + 6BAF428E121AEBDF008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 681"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 595; + vrLoc = 17202; + }; + 6BAF428F121AEBDF008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 92"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 560; + vrLoc = 2540; + }; + 6BAF4290121AEBDF008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6B8DE88B10B69E4C00DF20FB /* DetourNavMesh.h */; + name = "DetourNavMesh.h: 252"; + rLen = 0; + rLoc = 9902; + rType = 0; + vrLen = 1544; + vrLoc = 9124; + }; + 6BAF4291121AEBDF008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 265"; + rLen = 0; + rLoc = 13860; + rType = 0; + vrLen = 1592; + vrLoc = 11910; + }; + 6BAF4292121AEBDF008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 681"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 595; + vrLoc = 17202; + }; + 6BAF4293121AEBDF008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 33"; + rLen = 0; + rLoc = 1315; + rType = 0; + vrLen = 714; + vrLoc = 842; + }; + 6BAF4294121AEBDF008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 687"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 840; + vrLoc = 17256; + }; + 6BAF4295121AEC2A008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 291"; + rLen = 0; + rLoc = 15021; + rType = 0; + vrLen = 1424; + vrLoc = 12535; + }; + 6BAF4296121AEC2A008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 709"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 846; + vrLoc = 17652; + }; + 6BAF4297121AEC2A008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 709"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 846; + vrLoc = 17652; + }; + 6BAF4298121AEC2A008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 291"; + rLen = 0; + rLoc = 15021; + rType = 0; + vrLen = 1424; + vrLoc = 12535; + }; + 6BAF4299121AEC2A008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 705"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 763; + vrLoc = 17255; + }; + 6BAF429A121AED31008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 293"; + rLen = 165; + rLoc = 14804; + rType = 0; + vrLen = 1235; + vrLoc = 12675; + }; + 6BAF429B121AED31008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 688"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 783; + vrLoc = 17257; + }; + 6BAF429C121AED31008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 859"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 1096; + vrLoc = 18802; + }; + 6BAF429D121AED31008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 300"; + rLen = 0; + rLoc = 14973; + rType = 0; + vrLen = 1236; + vrLoc = 12675; + }; + 6BAF429E121AED31008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 687"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 746; + vrLoc = 17256; + }; + 6BAF429F121AED31008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 293"; + rLen = 165; + rLoc = 14804; + rType = 0; + vrLen = 1235; + vrLoc = 12675; + }; + 6BAF42A0121AED31008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 687"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 778; + vrLoc = 17257; + }; + 6BAF42A1121AED31008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 291"; + rLen = 11; + rLoc = 14789; + rType = 0; + vrLen = 1235; + vrLoc = 12675; + }; + 6BAF42A2121AED31008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 688"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 783; + vrLoc = 17257; + }; + 6BAF42A3121AED31008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 293"; + rLen = 165; + rLoc = 14804; + rType = 0; + vrLen = 1235; + vrLoc = 12675; + }; + 6BAF42A4121AED31008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 690"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 834; + vrLoc = 17573; + }; + 6BAF42A5121AEFD9008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 300"; + rLen = 7; + rLoc = 14986; + rType = 0; + vrLen = 1235; + vrLoc = 12675; + }; + 6BAF42A6121AEFD9008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6B1185F41006895B0018F96F /* DetourNode.cpp */; + name = "DetourNode.cpp: 105"; + rLen = 0; + rLoc = 2743; + rType = 0; + vrLen = 587; + vrLoc = 2449; + }; + 6BAF42A7121AEFD9008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6B1185F61006896B0018F96F /* DetourNode.h */; + name = "DetourNode.h: 44"; + rLen = 7; + rLoc = 1304; + rType = 0; + vrLen = 637; + vrLoc = 1065; + }; + 6BAF42A8121AEFD9008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 752"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 853; + vrLoc = 18910; + }; + 6BAF42A9121AEFD9008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 300"; + rLen = 7; + rLoc = 14986; + rType = 0; + vrLen = 1235; + vrLoc = 12675; + }; + 6BAF42AA121AEFD9008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6B1185F41006895B0018F96F /* DetourNode.cpp */; + name = "DetourNode.cpp: 105"; + rLen = 0; + rLoc = 2743; + rType = 0; + vrLen = 587; + vrLoc = 2449; + }; + 6BAF42AB121AEFD9008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6B1185F61006896B0018F96F /* DetourNode.h */; + name = "DetourNode.h: 44"; + rLen = 7; + rLoc = 1304; + rType = 0; + vrLen = 637; + vrLoc = 1065; + }; + 6BAF42AC121AEFD9008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 728"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 575; + vrLoc = 22852; + }; + 6BAF42B3121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 302"; + rLen = 0; + rLoc = 14835; + rType = 0; + vrLen = 1162; + vrLoc = 13270; + }; + 6BAF42B4121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + comments = "error: 'H_SCALE' was not declared in this scope"; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + rLen = 0; + rLoc = 70; + rType = 1; + }; + 6BAF42B5121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 880"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 639; + vrLoc = 22857; + }; + 6BAF42B6121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 104"; + rLen = 0; + rLoc = 5071; + rType = 0; + vrLen = 1545; + vrLoc = 3161; + }; + 6BAF42B7121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 719"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 875; + vrLoc = 18063; + }; + 6BAF42B8121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 104"; + rLen = 0; + rLoc = 4849; + rType = 0; + vrLen = 1468; + vrLoc = 3230; + }; + 6BAF42B9121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 669"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 812; + vrLoc = 17254; + }; + 6BAF42BA121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 105"; + rLen = 0; + rLoc = 4567; + rType = 0; + vrLen = 1467; + vrLoc = 3230; + }; + 6BAF42BB121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 886"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 506; + vrLoc = 22998; + }; + 6BAF42BC121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 105"; + rLen = 0; + rLoc = 4567; + rType = 0; + vrLen = 1132; + vrLoc = 13350; + }; + 6BAF42BD121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 880"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 555; + vrLoc = 22930; + }; + 6BAF42BE121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 108"; + rLen = 0; + rLoc = 5138; + rType = 0; + vrLen = 1689; + vrLoc = 3816; + }; + 6BAF42BF121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 886"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 571; + vrLoc = 22930; + }; + 6BAF42C0121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 302"; + rLen = 0; + rLoc = 14835; + rType = 0; + vrLen = 1162; + vrLoc = 13270; + }; + 6BAF42C1121AF141008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 30"; + rLen = 0; + rLoc = 1149; + rType = 0; + vrLen = 956; + vrLoc = 842; + }; + 6BAF42C3121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 78"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 693; + vrLoc = 2043; + }; + 6BAF42C4121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 34"; + rLen = 15; + rLoc = 1318; + rType = 0; + vrLen = 827; + vrLoc = 672; + }; + 6BAF42C5121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 40"; + rLen = 26; + rLoc = 1287; + rType = 0; + vrLen = 601; + vrLoc = 981; + }; + 6BAF42C6121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 148"; + rLen = 0; + rLoc = 4228; + rType = 0; + vrLen = 594; + vrLoc = 4104; + }; + 6BAF42C7121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 78"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 693; + vrLoc = 2043; + }; + 6BAF42C8121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 34"; + rLen = 15; + rLoc = 1318; + rType = 0; + vrLen = 827; + vrLoc = 672; + }; + 6BAF42C9121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 35"; + rLen = 0; + rLoc = 1237; + rType = 0; + vrLen = 562; + vrLoc = 923; + }; + 6BAF42CA121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 169"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 641; + vrLoc = 4163; + }; + 6BAF42CB121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 35"; + rLen = 0; + rLoc = 1237; + rType = 0; + vrLen = 562; + vrLoc = 923; + }; + 6BAF42CC121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 169"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 572; + vrLoc = 4090; + }; + 6BAF42CD121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 35"; + rLen = 0; + rLoc = 1237; + rType = 0; + vrLen = 562; + vrLoc = 923; + }; + 6BAF42CE121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 148"; + rLen = 0; + rLoc = 4228; + rType = 0; + vrLen = 594; + vrLoc = 4104; + }; + 6BAF42CF121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 40"; + rLen = 26; + rLoc = 1287; + rType = 0; + vrLen = 601; + vrLoc = 981; + }; + 6BAF42D0121AF27C008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 500"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 734; + vrLoc = 12922; + }; + 6BAF42D2121AF2A3008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 497"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 764; + vrLoc = 12877; + }; + 6BAF42D3121AF2A8008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 50"; + rLen = 0; + rLoc = 1751; + rType = 0; + vrLen = 548; + vrLoc = 1422; + }; + 6BAF42D4121AF2A8008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 497"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 556; + vrLoc = 12981; + }; + 6BAF42D6121AF2AC008CFCDF /* NavMeshTesterTool.cpp:149 */ = { + isa = PBXFileBreakpoint; + actions = ( + ); + breakpointStyle = 0; + continueAfterActions = 0; + countType = 0; + delayBeforeContinue = 0; + fileReference = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + functionName = "NavMeshTesterTool::handleUpdate(const float dt)"; + hitCount = 3; + ignoreCount = 0; + lineNumber = 149; + location = Recast; + modificationTime = 303756345.607579; + state = 1; + }; + 6BAF42D8121AF2AF008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 493"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 767; + vrLoc = 12819; + }; + 6BAF42DB121AF2C3008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 493"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 767; + vrLoc = 12819; + }; + 6BAF42E1121AF3B8008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 492"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 836; + vrLoc = 12742; + }; + 6BAF42E2121AF3B8008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6B1185F61006896B0018F96F /* DetourNode.h */; + name = "DetourNode.h: 49"; + rLen = 0; + rLoc = 1440; + rType = 0; + vrLen = 607; + vrLoc = 1065; + }; + 6BAF42E3121AF3B8008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + rLen = 0; + rLoc = 70; + rType = 1; + }; + 6BAF42E4121AF3B8008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 493"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 767; + vrLoc = 12819; + }; + 6BAF42E5121AF3B8008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 891"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 581; + vrLoc = 22961; + }; + 6BAF42E6121AF3B8008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 492"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 836; + vrLoc = 12742; + }; + 6BAF42E7121AF3B8008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 881"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 616; + vrLoc = 22962; + }; + 6BAF42E8121AF3B8008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6B1185F61006896B0018F96F /* DetourNode.h */; + name = "DetourNode.h: 49"; + rLen = 0; + rLoc = 1440; + rType = 0; + vrLen = 607; + vrLoc = 1065; + }; + 6BAF42E9121AF3B8008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 889"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 616; + vrLoc = 22962; + }; + 6BAF42EC121AF3DE008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 889"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 601; + vrLoc = 22920; + }; + 6BAF42EE121AF43D008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 881"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 308; + vrLoc = 23252; + }; + 6BAF42EF121AF43D008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + rLen = 0; + rLoc = 148; + rType = 1; + }; + 6BAF42F0121AF43D008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 497"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 554; + vrLoc = 12979; + }; + 6BAF42F1121AF43D008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 892"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 266; + vrLoc = 23307; + }; + 6BAF42F2121AF43D008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 492"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 554; + vrLoc = 12979; + }; + 6BAF42F3121AF43D008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 881"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 308; + vrLoc = 23252; + }; + 6BAF42F4121AF43D008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 492"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 554; + vrLoc = 12979; + }; + 6BAF42F9121AF514008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 889"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 664; + vrLoc = 22894; + }; + 6BAF42FA121AF514008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 207"; + rLen = 0; + rLoc = 5601; + rType = 0; + vrLen = 821; + vrLoc = 5476; + }; + 6BAF42FB121AF514008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 41"; + rLen = 24; + rLoc = 1317; + rType = 0; + vrLen = 651; + vrLoc = 980; + }; + 6BAF42FC121AF514008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 490"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 840; + vrLoc = 12742; + }; + 6BAF42FD121AF514008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 39"; + rLen = 24; + rLoc = 1259; + rType = 0; + vrLen = 601; + vrLoc = 981; + }; + 6BAF42FE121AF514008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 565"; + rLen = 0; + rLoc = 4259; + rType = 0; + vrLen = 1140; + vrLoc = 14317; + }; + 6BAF42FF121AF514008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 39"; + rLen = 24; + rLoc = 1259; + rType = 0; + vrLen = 603; + vrLoc = 981; + }; + 6BAF4300121AF514008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 548"; + rLen = 0; + rLoc = 5507; + rType = 0; + vrLen = 1097; + vrLoc = 14041; + }; + 6BAF4301121AF514008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 40"; + rLen = 26; + rLoc = 1287; + rType = 0; + vrLen = 651; + vrLoc = 980; + }; + 6BAF4302121AF514008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 226"; + rLen = 0; + rLoc = 5507; + rType = 0; + vrLen = 876; + vrLoc = 5516; + }; + 6BAF4303121AF514008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 41"; + rLen = 24; + rLoc = 1317; + rType = 0; + vrLen = 651; + vrLoc = 980; + }; + 6BAF4304121AF514008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 207"; + rLen = 0; + rLoc = 5601; + rType = 0; + vrLen = 821; + vrLoc = 5476; + }; + 6BAF4305121AF514008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 37"; + rLen = 0; + rLoc = 1253; + rType = 0; + vrLen = 632; + vrLoc = 980; + }; + 6BAF4306121AF574008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 39"; + rLen = 0; + rLoc = 1284; + rType = 0; + vrLen = 653; + vrLoc = 980; + }; + 6BAF4307121AF6E0008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 39"; + rLen = 0; + rLoc = 1284; + rType = 0; + vrLen = 653; + vrLoc = 980; + }; + 6BAF4308121AF6E0008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 34"; + rLen = 15; + rLoc = 1318; + rType = 0; + vrLen = 915; + vrLoc = 596; + }; + 6BAF4309121AF6E0008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 39"; + rLen = 0; + rLoc = 1284; + rType = 0; + vrLen = 653; + vrLoc = 980; + }; + 6BAF430A121AF6E0008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 117"; + rLen = 0; + rLoc = 5075; + rType = 0; + vrLen = 1506; + vrLoc = 3450; + }; + 6BAF430C121AF7CD008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 326"; + rLen = 0; + rLoc = 14973; + rType = 0; + vrLen = 1343; + vrLoc = 14099; + }; + 6BAF430D121AF7CD008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 70"; + rLen = 0; + rLoc = 2286; + rType = 0; + vrLen = 849; + vrLoc = 1547; + }; + 6BAF430E121AF7CD008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 326"; + rLen = 7; + rLoc = 14986; + rType = 0; + vrLen = 1362; + vrLoc = 14099; + }; + 6BAF430F121AF7CD008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 71"; + rLen = 0; + rLoc = 2298; + rType = 0; + vrLen = 885; + vrLoc = 1476; + }; + 6BAF4310121AF7CD008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 326"; + rLen = 11; + rLoc = 14974; + rType = 0; + vrLen = 1362; + vrLoc = 14099; + }; + 6BAF4311121AF7CD008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 71"; + rLen = 0; + rLoc = 2287; + rType = 0; + vrLen = 902; + vrLoc = 1476; + }; + 6BAF4312121AF7CD008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 326"; + rLen = 7; + rLoc = 14986; + rType = 0; + vrLen = 1362; + vrLoc = 14099; + }; + 6BAF4313121AF7CD008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 70"; + rLen = 0; + rLoc = 2286; + rType = 0; + vrLen = 849; + vrLoc = 1547; + }; + 6BAF4314121AF7CD008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 326"; + rLen = 0; + rLoc = 14973; + rType = 0; + vrLen = 1343; + vrLoc = 14099; + }; + 6BAF4315121AF7CD008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 685"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 810; + vrLoc = 17174; + }; + 6BAF4321121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 35"; + rLen = 0; + rLoc = 1220; + rType = 0; + vrLen = 445; + vrLoc = 980; + }; + 6BAF4322121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6B8DE88B10B69E4C00DF20FB /* DetourNavMesh.h */; + name = "DetourNavMesh.h: 252"; + rLen = 0; + rLoc = 9902; + rType = 0; + vrLen = 1261; + vrLoc = 9407; + }; + 6BAF4323121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 326"; + rLen = 7; + rLoc = 14986; + rType = 0; + vrLen = 762; + vrLoc = 14379; + }; + 6BAF4324121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 678"; + rLen = 0; + rLoc = 17554; + rType = 0; + vrLen = 706; + vrLoc = 17303; + }; + 6BAF4325121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6B2AEC520FFB8958005BE9CC /* Sample_TileMesh.cpp */; + name = "Sample_TileMesh.cpp: 480"; + rLen = 0; + rLoc = 11262; + rType = 0; + vrLen = 874; + vrLoc = 10849; + }; + 6BAF4326121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + comments = "error: 'class dtNavMeshQuery' has no member named 'findPathBegin'"; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + rLen = 1; + rLoc = 736; + rType = 1; + }; + 6BAF4327121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 678"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 687; + vrLoc = 17174; + }; + 6BAF4328121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 113"; + rLen = 18; + rLoc = 4510; + rType = 0; + vrLen = 1500; + vrLoc = 3772; + }; + 6BAF4329121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 671"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 692; + vrLoc = 17174; + }; + 6BAF432A121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 113"; + rLen = 12; + rLoc = 4497; + rType = 0; + vrLen = 1500; + vrLoc = 3772; + }; + 6BAF432B121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 675"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 717; + vrLoc = 17174; + }; + 6BAF432C121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 319"; + rLen = 0; + rLoc = 14818; + rType = 0; + vrLen = 1563; + vrLoc = 13487; + }; + 6BAF432D121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 719"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 829; + vrLoc = 18006; + }; + 6BAF432E121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 125"; + rLen = 0; + rLoc = 5014; + rType = 0; + vrLen = 1771; + vrLoc = 4347; + }; + 6BAF432F121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 719"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 829; + vrLoc = 18006; + }; + 6BAF4330121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 121"; + rLen = 20; + rLoc = 4809; + rType = 0; + vrLen = 1775; + vrLoc = 4347; + }; + 6BAF4331121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 719"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 835; + vrLoc = 18006; + }; + 6BAF4332121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 121"; + rLen = 12; + rLoc = 4796; + rType = 0; + vrLen = 1775; + vrLoc = 4347; + }; + 6BAF4333121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 879"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 580; + vrLoc = 22821; + }; + 6BAF4334121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 127"; + rLen = 22; + rLoc = 5076; + rType = 0; + vrLen = 1775; + vrLoc = 4347; + }; + 6BAF4335121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 900"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 431; + vrLoc = 23171; + }; + 6BAF4336121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 148"; + rLen = 0; + rLoc = 4219; + rType = 0; + vrLen = 442; + vrLoc = 3910; + }; + 6BAF4337121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */; + name = "NavMeshTesterTool.h: 35"; + rLen = 0; + rLoc = 1220; + rType = 0; + vrLen = 445; + vrLoc = 980; + }; + 6BAF4338121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6B8DE88B10B69E4C00DF20FB /* DetourNavMesh.h */; + name = "DetourNavMesh.h: 252"; + rLen = 0; + rLoc = 9902; + rType = 0; + vrLen = 1261; + vrLoc = 9407; + }; + 6BAF4339121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 319"; + rLen = 0; + rLoc = 14818; + rType = 0; + vrLen = 834; + vrLoc = 14310; + }; + 6BAF433A121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 719"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 656; + vrLoc = 18229; + }; + 6BAF433B121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 147"; + rLen = 1; + rLoc = 4193; + rType = 0; + vrLen = 481; + vrLoc = 3933; + }; + 6BAF433C121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 326"; + rLen = 0; + rLoc = 14973; + rType = 0; + vrLen = 832; + vrLoc = 14310; + }; + 6BAF433D121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 671"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 541; + vrLoc = 17173; + }; + 6BAF433E121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 326"; + rLen = 0; + rLoc = 14973; + rType = 0; + vrLen = 763; + vrLoc = 14379; + }; + 6BAF433F121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 676"; + rLen = 0; + rLoc = 2299; + rType = 0; + vrLen = 514; + vrLoc = 17173; + }; + 6BAF4340121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40D912196A25008CFCDF /* DetourNavMeshQuery.h */; + name = "DetourNavMeshQuery.h: 326"; + rLen = 7; + rLoc = 14986; + rType = 0; + vrLen = 762; + vrLoc = 14379; + }; + 6BAF4341121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 678"; + rLen = 0; + rLoc = 17554; + rType = 0; + vrLen = 706; + vrLoc = 17303; + }; + 6BAF4342121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6B2AEC520FFB8958005BE9CC /* Sample_TileMesh.cpp */; + name = "Sample_TileMesh.cpp: 480"; + rLen = 0; + rLoc = 11262; + rType = 0; + vrLen = 874; + vrLoc = 10849; + }; + 6BAF4343121AF998008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 737"; + rLen = 0; + rLoc = 20098; + rType = 0; + vrLen = 684; + vrLoc = 19661; + }; + 6BAF4346121AFD0B008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 215"; + rLen = 0; + rLoc = 5747; + rType = 0; + vrLen = 852; + vrLoc = 5645; + }; + 6BAF4347121AFD0B008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 678"; + rLen = 0; + rLoc = 17554; + rType = 0; + vrLen = 782; + vrLoc = 17289; + }; + 6BAF4348121AFD0B008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */; + name = "NavMeshTesterTool.cpp: 215"; + rLen = 0; + rLoc = 5747; + rType = 0; + vrLen = 852; + vrLoc = 5645; + }; + 6BAF4349121AFD0B008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 894"; + rLen = 0; + rLoc = 23399; + rType = 0; + vrLen = 640; + vrLoc = 23011; + }; + 6BAF434F121B00EF008CFCDF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6BAF40DA12196A3D008CFCDF /* DetourNavMeshQuery.cpp */; + name = "DetourNavMeshQuery.cpp: 887"; + rLen = 0; + rLoc = 23224; + rType = 0; + vrLen = 629; + vrLoc = 23011; + }; 6BB788160FC0472B003C24DB /* ChunkyTriMesh.cpp */ = { uiCtxt = { sepNavIntBoundsRect = "{{0, 0}, {1112, 3888}}"; @@ -6706,16 +8386,16 @@ }; 6BB7FC0910EBB6AA006DA0A6 /* NavMeshTesterTool.h */ = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {933, 1584}}"; - sepNavSelRange = "{1168, 10}"; - sepNavVisRange = "{980, 480}"; + sepNavIntBoundsRect = "{{0, 0}, {933, 1648}}"; + sepNavSelRange = "{1220, 0}"; + sepNavVisRange = "{980, 445}"; }; }; 6BB7FC0A10EBB6AA006DA0A6 /* NavMeshTesterTool.cpp */ = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {933, 18640}}"; - sepNavSelRange = "{22658, 0}"; - sepNavVisRange = "{22476, 516}"; + sepNavIntBoundsRect = "{{0, 0}, {933, 19712}}"; + sepNavSelRange = "{5747, 0}"; + sepNavVisRange = "{5645, 852}"; sepNavWindowFrame = "{{38, 30}, {1214, 722}}"; }; }; @@ -7119,7 +8799,7 @@ ignoreCount = 0; lineNumber = 279; location = Recast; - modificationTime = 303302369.9854569; + modificationTime = 303756251.188963; state = 1; }; 6BC7619C11B63C7E00FF5E51 /* PBXTextBookmark */ = { diff --git a/RecastDemo/Build/Xcode/Recast.xcodeproj/memon.perspectivev3 b/RecastDemo/Build/Xcode/Recast.xcodeproj/memon.perspectivev3 index cc83728..cc82dc6 100644 --- a/RecastDemo/Build/Xcode/Recast.xcodeproj/memon.perspectivev3 +++ b/RecastDemo/Build/Xcode/Recast.xcodeproj/memon.perspectivev3 @@ -290,7 +290,7 @@ PBXSmartGroupTreeModuleOutlineStateVisibleRectKey - {{0, 8}, {264, 660}} + {{0, 107}, {264, 660}} PBXTopSmartGroupGIDs @@ -337,7 +337,7 @@ _historyCapacity 0 bookmark - 6BAF428A121ADD46008CFCDF + 6BAF434F121B00EF008CFCDF history 6BBB4AA5115B4F3400CF791D @@ -387,7 +387,6 @@ 6BAF40F212197F3D008CFCDF 6BAF40F312197F3D008CFCDF 6BAF40F412197F3D008CFCDF - 6BAF416F1219811E008CFCDF 6BAF41701219811E008CFCDF 6BAF419E12198419008CFCDF 6BAF419F12198419008CFCDF @@ -398,26 +397,26 @@ 6BAF41A612198419008CFCDF 6BAF41A812198419008CFCDF 6BAF41A912198419008CFCDF - 6BAF41AA12198419008CFCDF 6BAF41AB12198419008CFCDF 6BAF41D0121A5AEE008CFCDF - 6BAF41E3121ACD06008CFCDF - 6BAF421F121ACE5E008CFCDF 6BAF4250121AD7D7008CFCDF - 6BAF4251121AD7D7008CFCDF - 6BAF4264121AD99B008CFCDF 6BAF4267121AD99B008CFCDF 6BAF4269121AD99B008CFCDF - 6BAF427D121ADD46008CFCDF 6BAF427E121ADD46008CFCDF 6BAF427F121ADD46008CFCDF 6BAF4280121ADD46008CFCDF 6BAF4281121ADD46008CFCDF - 6BAF4282121ADD46008CFCDF + 6BAF42A6121AEFD9008CFCDF + 6BAF42E2121AF3B8008CFCDF + 6BAF4321121AF998008CFCDF + 6BAF4322121AF998008CFCDF + 6BAF4323121AF998008CFCDF + 6BAF4325121AF998008CFCDF + 6BAF4346121AFD0B008CFCDF + 6BAF4347121AFD0B008CFCDF prevStack - 6BBB4AD3115B4F3400CF791D 6BBB4AE0115B4F3400CF791D 6BBB4AE6115B4F3400CF791D 6BBB4AE7115B4F3400CF791D @@ -490,9 +489,7 @@ 6BAF410812197F3D008CFCDF 6BAF411712197F3D008CFCDF 6BAF411F12197F3D008CFCDF - 6BAF412E12197F3D008CFCDF 6BAF412F12197F3D008CFCDF - 6BAF414612197F3D008CFCDF 6BAF414812197F3D008CFCDF 6BAF414912197F3D008CFCDF 6BAF414A12197F3D008CFCDF @@ -549,18 +546,10 @@ 6BAF41D3121A5AEE008CFCDF 6BAF41DA121A5D13008CFCDF 6BAF41DB121A5D13008CFCDF - 6BAF41DF121A5D13008CFCDF 6BAF41E9121ACD06008CFCDF - 6BAF41ED121ACD06008CFCDF - 6BAF41EF121ACD06008CFCDF - 6BAF41F0121ACD06008CFCDF - 6BAF41FD121ACD06008CFCDF - 6BAF4222121ACE5E008CFCDF 6BAF4223121ACE5E008CFCDF - 6BAF4238121AD4A8008CFCDF 6BAF4243121AD679008CFCDF 6BAF4245121AD679008CFCDF - 6BAF4247121AD679008CFCDF 6BAF4254121AD7D7008CFCDF 6BAF4255121AD7D7008CFCDF 6BAF4256121AD7D7008CFCDF @@ -569,15 +558,94 @@ 6BAF426D121AD99B008CFCDF 6BAF426F121AD99B008CFCDF 6BAF4270121AD99B008CFCDF - 6BAF4271121AD99B008CFCDF 6BAF4272121AD99B008CFCDF 6BAF4283121ADD46008CFCDF 6BAF4284121ADD46008CFCDF 6BAF4285121ADD46008CFCDF - 6BAF4286121ADD46008CFCDF - 6BAF4287121ADD46008CFCDF 6BAF4288121ADD46008CFCDF 6BAF4289121ADD46008CFCDF + 6BAF4290121AEBDF008CFCDF + 6BAF4291121AEBDF008CFCDF + 6BAF4293121AEBDF008CFCDF + 6BAF4298121AEC2A008CFCDF + 6BAF429D121AED31008CFCDF + 6BAF429F121AED31008CFCDF + 6BAF42A1121AED31008CFCDF + 6BAF42A3121AED31008CFCDF + 6BAF42A9121AEFD9008CFCDF + 6BAF42B5121AF141008CFCDF + 6BAF42B6121AF141008CFCDF + 6BAF42B7121AF141008CFCDF + 6BAF42B8121AF141008CFCDF + 6BAF42B9121AF141008CFCDF + 6BAF42BA121AF141008CFCDF + 6BAF42BB121AF141008CFCDF + 6BAF42BC121AF141008CFCDF + 6BAF42BD121AF141008CFCDF + 6BAF42BE121AF141008CFCDF + 6BAF42BF121AF141008CFCDF + 6BAF42C0121AF141008CFCDF + 6BAF42C7121AF27C008CFCDF + 6BAF42C8121AF27C008CFCDF + 6BAF42C9121AF27C008CFCDF + 6BAF42CA121AF27C008CFCDF + 6BAF42CB121AF27C008CFCDF + 6BAF42CC121AF27C008CFCDF + 6BAF42CD121AF27C008CFCDF + 6BAF42CE121AF27C008CFCDF + 6BAF42CF121AF27C008CFCDF + 6BBB4AD3115B4F3400CF791D + 6BAF42E4121AF3B8008CFCDF + 6BAF42E5121AF3B8008CFCDF + 6BAF42E6121AF3B8008CFCDF + 6BAF42E7121AF3B8008CFCDF + 6BAF42E8121AF3B8008CFCDF + 6BAF42FC121AF514008CFCDF + 6BAF42FD121AF514008CFCDF + 6BAF42FE121AF514008CFCDF + 6BAF42FF121AF514008CFCDF + 6BAF4300121AF514008CFCDF + 6BAF4301121AF514008CFCDF + 6BAF4302121AF514008CFCDF + 6BAF4303121AF514008CFCDF + 6BAF4304121AF514008CFCDF + 6BAF4309121AF6E0008CFCDF + 6BAF430E121AF7CD008CFCDF + 6BAF430F121AF7CD008CFCDF + 6BAF4310121AF7CD008CFCDF + 6BAF4311121AF7CD008CFCDF + 6BAF4312121AF7CD008CFCDF + 6BAF4313121AF7CD008CFCDF + 6BAF4314121AF7CD008CFCDF + 6BAF4327121AF998008CFCDF + 6BAF4328121AF998008CFCDF + 6BAF4329121AF998008CFCDF + 6BAF432A121AF998008CFCDF + 6BAF432B121AF998008CFCDF + 6BAF432C121AF998008CFCDF + 6BAF432D121AF998008CFCDF + 6BAF432E121AF998008CFCDF + 6BAF432F121AF998008CFCDF + 6BAF4330121AF998008CFCDF + 6BAF4331121AF998008CFCDF + 6BAF4332121AF998008CFCDF + 6BAF4333121AF998008CFCDF + 6BAF4334121AF998008CFCDF + 6BAF4335121AF998008CFCDF + 6BAF4336121AF998008CFCDF + 6BAF4337121AF998008CFCDF + 6BAF4338121AF998008CFCDF + 6BAF4339121AF998008CFCDF + 6BAF433A121AF998008CFCDF + 6BAF433B121AF998008CFCDF + 6BAF433C121AF998008CFCDF + 6BAF433D121AF998008CFCDF + 6BAF433E121AF998008CFCDF + 6BAF433F121AF998008CFCDF + 6BAF4340121AF998008CFCDF + 6BAF4341121AF998008CFCDF + 6BAF4342121AF998008CFCDF + 6BAF4348121AFD0B008CFCDF SplitCount @@ -591,18 +659,18 @@ GeometryConfiguration Frame - {{0, 0}, {994, 505}} + {{0, 0}, {994, 559}} RubberWindowFrame 0 59 1280 719 0 0 1280 778 Module PBXNavigatorGroup Proportion - 505pt + 559pt Proportion - 168pt + 114pt Tabs @@ -670,7 +738,7 @@ GeometryConfiguration Frame - {{10, 27}, {994, 141}} + {{10, 27}, {994, 87}} RubberWindowFrame 0 59 1280 719 0 0 1280 778 @@ -892,6 +960,8 @@ 5 WindowOrderList + 6BAF42D9121AF2AF008CFCDF + 6BAF42DA121AF2AF008CFCDF /Users/memon/Code/recastnavigation/RecastDemo/Build/Xcode/Recast.xcodeproj WindowString diff --git a/RecastDemo/Include/NavMeshTesterTool.h b/RecastDemo/Include/NavMeshTesterTool.h index c08c244..a394bb4 100644 --- a/RecastDemo/Include/NavMeshTesterTool.h +++ b/RecastDemo/Include/NavMeshTesterTool.h @@ -32,10 +32,13 @@ class NavMeshTesterTool : public SampleTool dtQueryFilter m_filter; + dtQueryState m_pathFindState; + enum ToolMode { - TOOLMODE_PATHFIND_ITER, + TOOLMODE_PATHFIND_FOLLOW, TOOLMODE_PATHFIND_STRAIGHT, + TOOLMODE_PATHFIND_SLICED, TOOLMODE_RAYCAST, TOOLMODE_DISTANCE_TO_WALL, TOOLMODE_FIND_POLYS_IN_CIRCLE, diff --git a/RecastDemo/Source/NavMeshTesterTool.cpp b/RecastDemo/Source/NavMeshTesterTool.cpp index 2ae5593..cce6302 100644 --- a/RecastDemo/Source/NavMeshTesterTool.cpp +++ b/RecastDemo/Source/NavMeshTesterTool.cpp @@ -145,7 +145,8 @@ NavMeshTesterTool::NavMeshTesterTool() : m_sample(0), m_navMesh(0), m_navQuery(0), - m_toolMode(TOOLMODE_PATHFIND_ITER), + m_pathFindState(DT_QUERY_FAILED), + m_toolMode(TOOLMODE_PATHFIND_FOLLOW), m_startRef(0), m_endRef(0), m_npolys(0), @@ -197,7 +198,9 @@ void NavMeshTesterTool::init(Sample* sample) m_navQuery->setAreaCost(SAMPLE_POLYAREA_JUMP, 1.5f); } - if (m_toolMode == TOOLMODE_PATHFIND_ITER || m_toolMode == TOOLMODE_PATHFIND_STRAIGHT) + if (m_toolMode == TOOLMODE_PATHFIND_FOLLOW || + m_toolMode == TOOLMODE_PATHFIND_STRAIGHT || + m_toolMode == TOOLMODE_PATHFIND_SLICED) { unsigned char flags = 0; if (m_navMesh) @@ -210,9 +213,9 @@ void NavMeshTesterTool::init(Sample* sample) void NavMeshTesterTool::handleMenu() { - if (imguiCheck("Pathfind Iter", m_toolMode == TOOLMODE_PATHFIND_ITER)) + if (imguiCheck("Pathfind Follow", m_toolMode == TOOLMODE_PATHFIND_FOLLOW)) { - m_toolMode = TOOLMODE_PATHFIND_ITER; + m_toolMode = TOOLMODE_PATHFIND_FOLLOW; recalc(); } if (imguiCheck("Pathfind Straight", m_toolMode == TOOLMODE_PATHFIND_STRAIGHT)) @@ -220,6 +223,11 @@ void NavMeshTesterTool::handleMenu() m_toolMode = TOOLMODE_PATHFIND_STRAIGHT; recalc(); } + if (imguiCheck("Pathfind Sliced", m_toolMode == TOOLMODE_PATHFIND_SLICED)) + { + m_toolMode = TOOLMODE_PATHFIND_SLICED; + recalc(); + } if (imguiCheck("Distance to Wall", m_toolMode == TOOLMODE_DISTANCE_TO_WALL)) { m_toolMode = TOOLMODE_DISTANCE_TO_WALL; @@ -301,7 +309,7 @@ void NavMeshTesterTool::handleMenu() imguiSeparator(); - if (m_toolMode == TOOLMODE_PATHFIND_ITER || m_toolMode == TOOLMODE_PATHFIND_STRAIGHT) + if (m_toolMode == TOOLMODE_PATHFIND_FOLLOW || m_toolMode == TOOLMODE_PATHFIND_STRAIGHT) { unsigned char flags = 0; if (m_navMesh) @@ -335,7 +343,7 @@ void NavMeshTesterTool::handleClick(const float* s, const float* p, bool shift) void NavMeshTesterTool::handleStep() { // TODO: merge separate to a path iterator. Use same code in recalc() too. - if (m_toolMode != TOOLMODE_PATHFIND_ITER) + if (m_toolMode != TOOLMODE_PATHFIND_FOLLOW) return; if (!m_sposSet || !m_eposSet || !m_startRef || !m_endRef) @@ -481,6 +489,34 @@ void NavMeshTesterTool::handleStep() void NavMeshTesterTool::handleUpdate(const float dt) { + if (m_pathFindState == DT_QUERY_RUNNING) + { + m_pathFindState = m_navQuery->updateSlicedFindPath(1); + } + + if (m_pathFindState == DT_QUERY_READY) + { + m_npolys = m_navQuery->finalizeSlicedFindPath(m_polys, MAX_POLYS); + m_nstraightPath = 0; + if (m_npolys) + { + // In case of partial path, make sure the end point is clamped to the last polygon. + float epos[3]; + dtVcopy(epos, m_epos); + if (m_polys[m_npolys-1] != m_endRef) + m_navQuery->closestPointOnPoly(m_polys[m_npolys-1], m_epos, epos); + + m_nstraightPath = m_navQuery->findStraightPath(m_spos, epos, m_polys, m_npolys, + m_straightPath, m_straightPathFlags, + m_straightPathPolys, MAX_POLYS); + } + + m_pathFindState = DT_QUERY_FAILED; + } + + + + } void NavMeshTesterTool::reset() @@ -511,7 +547,9 @@ void NavMeshTesterTool::recalc() else m_endRef = 0; - if (m_toolMode == TOOLMODE_PATHFIND_ITER) + m_pathFindState = DT_QUERY_FAILED; + + if (m_toolMode == TOOLMODE_PATHFIND_FOLLOW) { m_pathIterNum = 0; if (m_sposSet && m_eposSet && m_startRef && m_endRef) @@ -684,6 +722,26 @@ void NavMeshTesterTool::recalc() m_nstraightPath = 0; } } + else if (m_toolMode == TOOLMODE_PATHFIND_SLICED) + { + if (m_sposSet && m_eposSet && m_startRef && m_endRef) + { +#ifdef DUMP_REQS + printf("ps %f %f %f %f %f %f 0x%x 0x%x\n", + m_spos[0],m_spos[1],m_spos[2], m_epos[0],m_epos[1],m_epos[2], + m_filter.includeFlags, m_filter.excludeFlags); +#endif + m_npolys = 0; + m_nstraightPath = 0; + + m_pathFindState = m_navQuery->initSlicedFindPath(m_startRef, m_endRef, m_spos, m_epos, &m_filter); + } + else + { + m_npolys = 0; + m_nstraightPath = 0; + } + } else if (m_toolMode == TOOLMODE_RAYCAST) { m_nstraightPath = 0; @@ -855,7 +913,7 @@ void NavMeshTesterTool::handleRender() return; } - if (m_toolMode == TOOLMODE_PATHFIND_ITER) + if (m_toolMode == TOOLMODE_PATHFIND_FOLLOW) { duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_startRef, startCol); duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_endRef, endCol); @@ -910,7 +968,7 @@ void NavMeshTesterTool::handleRender() dd.depthMask(true); } } - else if (m_toolMode == TOOLMODE_PATHFIND_STRAIGHT) + else if (m_toolMode == TOOLMODE_PATHFIND_STRAIGHT || m_toolMode == TOOLMODE_PATHFIND_SLICED) { duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_startRef, startCol); duDebugDrawNavMeshPoly(&dd, *m_navMesh, m_endRef, endCol);