From fa8d89d287752782ebdd5d9563f04fa72ef0bee9 Mon Sep 17 00:00:00 2001 From: Kawe Mazidjatari <48657826+Mauler125@users.noreply.github.com> Date: Thu, 4 Jul 2024 11:32:56 +0200 Subject: [PATCH] Recast: make assert and allocation code shared All recast/detour allocation and assertion code were identical, with the exception of their names (rc* for recast, dt* for detour). We want to use Recast's rcVectorBase class in Detour code, as there is no Detour equivalent, but copying it in its whole isn't good practice (especially considering there is more boilerplate code we want to get rid of in the future). Moved these to Shared so Detour could use it as well under the name rdVectorBase (rd stands for Recast Detour). No changes to the logic of the code were made in this patch. --- src/naveditor/CrowdTool.cpp | 4 +- src/naveditor/Editor.cpp | 26 +- src/naveditor/Editor_Debug.cpp | 16 +- src/naveditor/Editor_TileMesh.cpp | 40 +-- src/naveditor/NavMeshPruneTool.cpp | 19 +- src/naveditor/main.cpp | 16 +- .../recast/DebugUtils/Source/RecastDump.cpp | 16 +- .../recast/Detour/Include/DetourAlloc.h | 61 ---- .../recast/Detour/Include/DetourNavMesh.h | 8 +- .../Detour/Include/DetourNavMeshBuilder.h | 2 +- .../Detour/Include/DetourNavMeshQuery.h | 6 +- .../recast/Detour/Source/DetourAlloc.cpp | 20 +- .../recast/Detour/Source/DetourAssert.cpp | 8 +- .../recast/Detour/Source/DetourNavMesh.cpp | 34 +-- .../Detour/Source/DetourNavMeshBuilder.cpp | 24 +- .../Detour/Source/DetourNavMeshQuery.cpp | 112 ++++---- .../recast/Detour/Source/DetourNode.cpp | 34 +-- .../recast/DetourCrowd/Include/DetourCrowd.h | 6 +- .../Include/DetourObstacleAvoidance.h | 8 +- .../DetourCrowd/Include/DetourProximityGrid.h | 4 +- .../recast/DetourCrowd/Source/DetourCrowd.cpp | 48 ++-- .../Source/DetourCrowdInternal.cpp | 10 +- .../Source/DetourLocalBoundary.cpp | 4 +- .../Source/DetourObstacleAvoidance.cpp | 72 ++--- .../DetourCrowd/Source/DetourPathCorridor.cpp | 56 ++-- .../DetourCrowd/Source/DetourPathQueue.cpp | 10 +- .../Source/DetourProximityGrid.cpp | 24 +- .../DetourTileCache/Include/DetourTileCache.h | 4 +- .../Include/DetourTileCacheBuilder.h | 16 +- .../Source/DetourTileCache.cpp | 44 +-- .../Source/DetourTileCacheBuilder.cpp | 44 +-- src/thirdparty/recast/Recast/Include/Recast.h | 68 ++--- .../recast/Recast/Include/RecastAssert.h | 53 ---- .../recast/Recast/Source/Recast.cpp | 102 +++---- .../recast/Recast/Source/RecastAlloc.cpp | 20 +- .../recast/Recast/Source/RecastArea.cpp | 22 +- .../recast/Recast/Source/RecastAssert.cpp | 8 +- .../recast/Recast/Source/RecastContour.cpp | 44 +-- .../recast/Recast/Source/RecastFilter.cpp | 8 +- .../recast/Recast/Source/RecastLayers.cpp | 24 +- .../recast/Recast/Source/RecastMesh.cpp | 104 +++---- .../recast/Recast/Source/RecastMeshDetail.cpp | 64 ++--- .../Recast/Source/RecastRasterization.cpp | 18 +- .../recast/Recast/Source/RecastRegion.cpp | 80 +++--- .../Include/SharedAlloc.h} | 263 +++++++++--------- .../Include/SharedAssert.h} | 22 +- 46 files changed, 789 insertions(+), 907 deletions(-) delete mode 100644 src/thirdparty/recast/Detour/Include/DetourAlloc.h delete mode 100644 src/thirdparty/recast/Recast/Include/RecastAssert.h rename src/thirdparty/recast/{Recast/Include/RecastAlloc.h => Shared/Include/SharedAlloc.h} (56%) rename src/thirdparty/recast/{Detour/Include/DetourAssert.h => Shared/Include/SharedAssert.h} (79%) diff --git a/src/naveditor/CrowdTool.cpp b/src/naveditor/CrowdTool.cpp index 718875f5..2e77c8ea 100644 --- a/src/naveditor/CrowdTool.cpp +++ b/src/naveditor/CrowdTool.cpp @@ -113,7 +113,7 @@ CrowdToolState::CrowdToolState() : memset(m_trails, 0, sizeof(m_trails)); - m_vod = dtAllocObstacleAvoidanceDebugData(); + m_vod = rdAllocObstacleAvoidanceDebugData(); m_vod->init(2048); memset(&m_agentDebug, 0, sizeof(m_agentDebug)); @@ -123,7 +123,7 @@ CrowdToolState::CrowdToolState() : CrowdToolState::~CrowdToolState() { - dtFreeObstacleAvoidanceDebugData(m_vod); + rdFreeObstacleAvoidanceDebugData(m_vod); } void CrowdToolState::init(class Editor* editor) diff --git a/src/naveditor/Editor.cpp b/src/naveditor/Editor.cpp index 39c74c98..12e04fe6 100644 --- a/src/naveditor/Editor.cpp +++ b/src/naveditor/Editor.cpp @@ -18,7 +18,7 @@ #include "Pch.h" #include "Recast/Include/Recast.h" -#include "Detour/Include/DetourAssert.h" +#include "Shared/Include/SharedAssert.h" #include "Detour/Include/DetourNavMesh.h" #include "Detour/Include/DetourNavMeshQuery.h" #include "DetourCrowd/Include/DetourCrowd.h" @@ -63,8 +63,8 @@ Editor::Editor() : m_ctx(0) { resetCommonSettings(); - m_navQuery = dtAllocNavMeshQuery(); - m_crowd = dtAllocCrowd(); + m_navQuery = rdAllocNavMeshQuery(); + m_crowd = rdAllocCrowd(); for (int i = 0; i < MAX_TOOLS; i++) m_toolStates[i] = 0; @@ -72,9 +72,9 @@ Editor::Editor() : Editor::~Editor() { - dtFreeNavMeshQuery(m_navQuery); - dtFreeNavMesh(m_navMesh); - dtFreeCrowd(m_crowd); + rdFreeNavMeshQuery(m_navQuery); + rdFreeNavMesh(m_navMesh); + rdFreeCrowd(m_crowd); delete m_tool; for (int i = 0; i < MAX_TOOLS; i++) delete m_toolStates[i]; @@ -349,7 +349,7 @@ dtNavMesh* Editor::loadAll(std::string path) return 0; } - dtNavMesh* mesh = dtAllocNavMesh(); + dtNavMesh* mesh = rdAllocNavMesh(); if (!mesh) { fclose(fp); @@ -378,7 +378,7 @@ dtNavMesh* Editor::loadAll(std::string path) if (!tileHeader.tileRef || !tileHeader.dataSize) break; - unsigned char* data = (unsigned char*)dtAlloc(tileHeader.dataSize, DT_ALLOC_PERM); + unsigned char* data = (unsigned char*)rdAlloc(tileHeader.dataSize, RD_ALLOC_PERM); if (!data) break; @@ -387,7 +387,7 @@ dtNavMesh* Editor::loadAll(std::string path) if (readLen != 1) { - dtFree(data); + rdFree(data); fclose(fp); return 0; } @@ -400,7 +400,7 @@ dtNavMesh* Editor::loadAll(std::string path) { for (int i = 0; i < header.params.reachabilityTableCount; i++) { - int* reachabilityTable = (int*)dtAlloc(header.params.reachabilityTableSize, DT_ALLOC_PERM); + int* reachabilityTable = (int*)rdAlloc(header.params.reachabilityTableSize, RD_ALLOC_PERM); if (!reachabilityTable) break; @@ -409,7 +409,7 @@ dtNavMesh* Editor::loadAll(std::string path) if (readLen != 1) { - dtFree(reachabilityTable); + rdFree(reachabilityTable); fclose(fp); return 0; } @@ -476,12 +476,12 @@ void Editor::saveAll(std::string path, const dtNavMesh* mesh) // Only store if we have 3 or more poly groups. if (mesh->m_params.disjointPolyGroupCount >= DT_MIN_POLY_GROUP_COUNT) { - dtAssert(mesh->m_setTables); + rdAssert(mesh->m_setTables); for (int i = 0; i < header.params.reachabilityTableCount; i++) { const int* const tableData = mesh->m_setTables[i]; - dtAssert(tableData); + rdAssert(tableData); fwrite(tableData, sizeof(int), (header.params.reachabilityTableSize/4), fp); } diff --git a/src/naveditor/Editor_Debug.cpp b/src/naveditor/Editor_Debug.cpp index 64d0bf77..a4c58fad 100644 --- a/src/naveditor/Editor_Debug.cpp +++ b/src/naveditor/Editor_Debug.cpp @@ -48,7 +48,7 @@ Editor_Debug::Editor_Debug() : resetCommonSettings(); // Test -/* m_chf = rcAllocCompactHeightfield(); +/* m_chf = rdAllocCompactHeightfield(); FileIO io; if (!io.openForRead("test.chf")) { @@ -125,7 +125,7 @@ Editor_Debug::Editor_Debug() : { - m_cset = rcAllocContourSet(); + m_cset = rdAllocContourSet(); if (m_cset) { FileIO io; @@ -151,7 +151,7 @@ Editor_Debug::Editor_Debug() : /* if (m_cset) { - m_pmesh = rcAllocPolyMesh(); + m_pmesh = rdAllocPolyMesh(); if (m_pmesh) { rcBuildPolyMesh(m_ctx, *m_cset, 6, *m_pmesh); @@ -163,9 +163,9 @@ Editor_Debug::Editor_Debug() : Editor_Debug::~Editor_Debug() { - rcFreeCompactHeightfield(m_chf); - rcFreeContourSet(m_cset); - rcFreePolyMesh(m_pmesh); + rdFreeCompactHeightfield(m_chf); + rdFreeContourSet(m_cset); + rdFreePolyMesh(m_pmesh); } void Editor_Debug::handleSettings() @@ -357,11 +357,11 @@ bool Editor_Debug::handleBuild() if (m_chf) { - rcFreeContourSet(m_cset); + rdFreeContourSet(m_cset); m_cset = 0; // Create contours. - m_cset = rcAllocContourSet(); + m_cset = rdAllocContourSet(); if (!m_cset) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'cset'."); diff --git a/src/naveditor/Editor_TileMesh.cpp b/src/naveditor/Editor_TileMesh.cpp index d923067b..e7ea4933 100644 --- a/src/naveditor/Editor_TileMesh.cpp +++ b/src/naveditor/Editor_TileMesh.cpp @@ -189,7 +189,7 @@ Editor_TileMesh::Editor_TileMesh() : Editor_TileMesh::~Editor_TileMesh() { cleanup(); - dtFreeNavMesh(m_navMesh); + rdFreeNavMesh(m_navMesh); m_navMesh = 0; } @@ -197,15 +197,15 @@ void Editor_TileMesh::cleanup() { delete [] m_triareas; m_triareas = 0; - rcFreeHeightField(m_solid); + rdFreeHeightField(m_solid); m_solid = 0; - rcFreeCompactHeightfield(m_chf); + rdFreeCompactHeightfield(m_chf); m_chf = 0; - rcFreeContourSet(m_cset); + rdFreeContourSet(m_cset); m_cset = 0; - rcFreePolyMesh(m_pmesh); + rdFreePolyMesh(m_pmesh); m_pmesh = 0; - rcFreePolyMeshDetail(m_dmesh); + rdFreePolyMeshDetail(m_dmesh); m_dmesh = 0; } const hulldef hulls[5] = { @@ -277,7 +277,7 @@ void Editor_TileMesh::handleSettings() if (imguiButton("Load")) { - dtFreeNavMesh(m_navMesh); + rdFreeNavMesh(m_navMesh); m_navMesh = Editor::loadAll(m_modelName.c_str()); m_navQuery->init(m_navMesh, 2048); } @@ -577,7 +577,7 @@ void Editor_TileMesh::handleMeshChanged(InputGeom* geom) cleanup(); - dtFreeNavMesh(m_navMesh); + rdFreeNavMesh(m_navMesh); m_navMesh = 0; if (m_tool) @@ -597,9 +597,9 @@ bool Editor_TileMesh::handleBuild() return false; } - dtFreeNavMesh(m_navMesh); + rdFreeNavMesh(m_navMesh); - m_navMesh = dtAllocNavMesh(); + m_navMesh = rdAllocNavMesh(); if (!m_navMesh) { m_ctx->log(RC_LOG_ERROR, "buildTiledNavigation: Could not allocate navmesh."); @@ -678,7 +678,7 @@ void Editor_TileMesh::buildTile(const float* pos) // Let the navmesh own the data. dtStatus status = m_navMesh->addTile(data,dataSize,DT_TILE_FREE_DATA,0,0); if (dtStatusFailed(status)) - dtFree(data); + rdFree(data); } m_ctx->dumpLog("Build Tile (%d,%d):", tx,ty); @@ -754,7 +754,7 @@ void Editor_TileMesh::buildAllTiles() // Let the navmesh own the data. dtStatus status = m_navMesh->addTile(data,dataSize,DT_TILE_FREE_DATA,0,0); if (dtStatusFailed(status)) - dtFree(data); + rdFree(data); } } } @@ -886,7 +886,7 @@ unsigned char* Editor_TileMesh::buildTileMesh(const int tx, const int ty, const m_ctx->log(RC_LOG_PROGRESS, " - %.1fK verts, %.1fK tris", nverts/1000.0f, ntris/1000.0f); // Allocate voxel heightfield where we rasterize our input data to. - m_solid = rcAllocHeightfield(); + m_solid = rdAllocHeightfield(); if (!m_solid) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'solid'."); @@ -984,7 +984,7 @@ unsigned char* Editor_TileMesh::buildTileMesh(const int tx, const int ty, const // Compact the heightfield so that it is faster to handle from now on. // This will result more cache coherent data as well as the neighbours // between walkable cells will be calculated. - m_chf = rcAllocCompactHeightfield(); + m_chf = rdAllocCompactHeightfield(); if (!m_chf) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'chf'."); @@ -998,7 +998,7 @@ unsigned char* Editor_TileMesh::buildTileMesh(const int tx, const int ty, const if (!m_keepInterResults) { - rcFreeHeightField(m_solid); + rdFreeHeightField(m_solid); m_solid = 0; } @@ -1078,7 +1078,7 @@ unsigned char* Editor_TileMesh::buildTileMesh(const int tx, const int ty, const } // Create contours. - m_cset = rcAllocContourSet(); + m_cset = rdAllocContourSet(); if (!m_cset) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'cset'."); @@ -1096,7 +1096,7 @@ unsigned char* Editor_TileMesh::buildTileMesh(const int tx, const int ty, const } // Build polygon navmesh from the contours. - m_pmesh = rcAllocPolyMesh(); + m_pmesh = rdAllocPolyMesh(); if (!m_pmesh) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'pmesh'."); @@ -1109,7 +1109,7 @@ unsigned char* Editor_TileMesh::buildTileMesh(const int tx, const int ty, const } // Build detail mesh. - m_dmesh = rcAllocPolyMeshDetail(); + m_dmesh = rdAllocPolyMeshDetail(); if (!m_dmesh) { m_ctx->log(RC_LOG_ERROR, "buildNavigation: Out of memory 'dmesh'."); @@ -1128,9 +1128,9 @@ unsigned char* Editor_TileMesh::buildTileMesh(const int tx, const int ty, const //rcFlipPolyMeshDetail(*m_dmesh,m_pmesh->nverts); if (!m_keepInterResults) { - rcFreeCompactHeightfield(m_chf); + rdFreeCompactHeightfield(m_chf); m_chf = 0; - rcFreeContourSet(m_cset); + rdFreeContourSet(m_cset); m_cset = 0; } diff --git a/src/naveditor/NavMeshPruneTool.cpp b/src/naveditor/NavMeshPruneTool.cpp index 28708422..669611c4 100644 --- a/src/naveditor/NavMeshPruneTool.cpp +++ b/src/naveditor/NavMeshPruneTool.cpp @@ -19,7 +19,6 @@ #include "Pch.h" #include "Detour/Include/DetourNavMesh.h" #include "Detour/Include/DetourCommon.h" -#include "Detour/Include/DetourAssert.h" #include "DebugUtils/Include/DetourDebugDraw.h" #include "NavEditor/Include/NavMeshPruneTool.h" #include "NavEditor/Include/InputGeom.h" @@ -33,7 +32,7 @@ class NavmeshFlags { struct TileFlags { - inline void purge() { dtFree(flags); } + inline void purge() { rdFree(flags); } unsigned char* flags; int nflags; dtPolyRef base; @@ -53,7 +52,7 @@ public: { for (int i = 0; i < m_ntiles; ++i) m_tiles[i].purge(); - dtFree(m_tiles); + rdFree(m_tiles); } bool init(const dtNavMesh* nav) @@ -61,7 +60,7 @@ public: m_ntiles = nav->getMaxTiles(); if (!m_ntiles) return true; - m_tiles = (TileFlags*)dtAlloc(sizeof(TileFlags)*m_ntiles, DT_ALLOC_TEMP); + m_tiles = (TileFlags*)rdAlloc(sizeof(TileFlags)*m_ntiles, RD_ALLOC_TEMP); if (!m_tiles) { return false; @@ -78,7 +77,7 @@ public: tf->base = nav->getPolyRefBase(tile); if (tf->nflags) { - tf->flags = (unsigned char*)dtAlloc(tf->nflags, DT_ALLOC_TEMP); + tf->flags = (unsigned char*)rdAlloc(tf->nflags, RD_ALLOC_TEMP); if (!tf->flags) return false; memset(tf->flags, 0, tf->nflags); @@ -102,8 +101,8 @@ public: inline unsigned char getFlags(dtPolyRef ref) { - dtAssert(m_nav); - dtAssert(m_ntiles); + rdAssert(m_nav); + rdAssert(m_ntiles); // Assume the ref is valid, no bounds checks. unsigned int salt, it, ip; m_nav->decodePolyId(ref, salt, it, ip); @@ -112,8 +111,8 @@ public: inline void setFlags(dtPolyRef ref, unsigned char flags) { - dtAssert(m_nav); - dtAssert(m_ntiles); + rdAssert(m_nav); + rdAssert(m_ntiles); // Assume the ref is valid, no bounds checks. unsigned int salt, it, ip; m_nav->decodePolyId(ref, salt, it, ip); @@ -139,7 +138,7 @@ static void floodNavmesh(dtNavMesh* nav, NavmeshFlags* flags, dtPolyRef start, u openList.pop_back(); // Get current poly and tile. - // The API input has been cheked already, skip checking internal data. + // The API input has been checked already, skip checking internal data. const dtMeshTile* tile = 0; const dtPoly* poly = 0; nav->getTileAndPolyByRefUnsafe(ref, &tile, &poly); diff --git a/src/naveditor/main.cpp b/src/naveditor/main.cpp index 8290c8a4..80c5338a 100644 --- a/src/naveditor/main.cpp +++ b/src/naveditor/main.cpp @@ -18,7 +18,7 @@ #include "Pch.h" #include "Recast/Include/Recast.h" -#include "Recast/Include/RecastAlloc.h" +#include "Shared/Include/SharedAlloc.h" #include "DebugUtils/Include/RecastDebugDraw.h" #include "NavEditor/Include/InputGeom.h" #include "NavEditor/Include/TestCase.h" @@ -38,7 +38,7 @@ struct SampleItem Editor* createTile() { return new Editor_TileMesh(); } Editor* createDebug() { return new Editor_Debug(); } -void save_ply(std::vector& pts,std::vector& colors,rcIntArray& tris) +void save_ply(std::vector& pts,std::vector& colors,rdIntArray& tris) { static int counter = 0; char fname[255]; @@ -247,7 +247,7 @@ int main(int argc, char** argv) extern void delaunayHull(rcContext* ctx, const int npts, const float* pts, const int nhull, const int* hull, - rcIntArray& tris, rcIntArray& edges); + rdIntArray& tris, rdIntArray& edges); int main_test_delaunay(int /*argc*/, char** /*argv*/) { @@ -263,15 +263,15 @@ int main_test_delaunay(int /*argc*/, char** /*argv*/) for (auto h : hull) colors[h] = 0xffff0000; - rcIntArray tris; + rdIntArray tris; save_ply(pts, colors, tris); - rcIntArray edges; + rdIntArray edges; delaunayHull(&ctx, pts.size()/3, pts.data(), hull.size(), hull.data(), tris, edges); save_ply(pts, colors, tris); return 0; } -void compact_tris(rcIntArray& tris) +void compact_tris(rdIntArray& tris) { int j = 3; for (int i = 4; i < tris.size(); i++) @@ -297,10 +297,10 @@ int main(int argc, char** argv) for (auto h : hull) colors[h] = 0xffff0000; - rcIntArray tris; + rdIntArray tris; //save_ply(pts, colors, tris); - rcIntArray edges; + rdIntArray edges; delaunayHull(&ctx, pts.size() / 3, pts.data(), hull.size(), hull.data(), tris, edges); compact_tris(tris); save_ply(pts, colors, tris); diff --git a/src/thirdparty/recast/DebugUtils/Source/RecastDump.cpp b/src/thirdparty/recast/DebugUtils/Source/RecastDump.cpp index 79bc9d19..25c73a95 100644 --- a/src/thirdparty/recast/DebugUtils/Source/RecastDump.cpp +++ b/src/thirdparty/recast/DebugUtils/Source/RecastDump.cpp @@ -22,7 +22,7 @@ #include #include #include "Recast/Include/Recast.h" -#include "Recast/Include/RecastAlloc.h" +#include "Shared/Include/SharedAlloc.h" #include "DebugUtils/Include/RecastDump.h" @@ -211,7 +211,7 @@ bool duReadContourSet(struct rcContourSet& cset, duFileIO* io) io->read(&cset.nconts, sizeof(cset.nconts)); - cset.conts = (rcContour*)rcAlloc(sizeof(rcContour)*cset.nconts, RC_ALLOC_PERM); + cset.conts = (rcContour*)rdAlloc(sizeof(rcContour)*cset.nconts, RD_ALLOC_PERM); if (!cset.conts) { printf("duReadContourSet: Could not alloc contours (%d)\n", cset.nconts); @@ -237,13 +237,13 @@ bool duReadContourSet(struct rcContourSet& cset, duFileIO* io) io->read(&cont.reg, sizeof(cont.reg)); io->read(&cont.area, sizeof(cont.area)); - cont.verts = (int*)rcAlloc(sizeof(int)*4*cont.nverts, RC_ALLOC_PERM); + cont.verts = (int*)rdAlloc(sizeof(int)*4*cont.nverts, RD_ALLOC_PERM); if (!cont.verts) { printf("duReadContourSet: Could not alloc contour verts (%d)\n", cont.nverts); return false; } - cont.rverts = (int*)rcAlloc(sizeof(int)*4*cont.nrverts, RC_ALLOC_PERM); + cont.rverts = (int*)rdAlloc(sizeof(int)*4*cont.nrverts, RD_ALLOC_PERM); if (!cont.rverts) { printf("duReadContourSet: Could not alloc contour rverts (%d)\n", cont.nrverts); @@ -366,7 +366,7 @@ bool duReadCompactHeightfield(struct rcCompactHeightfield& chf, duFileIO* io) if (tmp & 1) { - chf.cells = (rcCompactCell*)rcAlloc(sizeof(rcCompactCell)*chf.width*chf.height, RC_ALLOC_PERM); + chf.cells = (rcCompactCell*)rdAlloc(sizeof(rcCompactCell)*chf.width*chf.height, RD_ALLOC_PERM); if (!chf.cells) { printf("duReadCompactHeightfield: Could not alloc cells (%d)\n", chf.width*chf.height); @@ -376,7 +376,7 @@ bool duReadCompactHeightfield(struct rcCompactHeightfield& chf, duFileIO* io) } if (tmp & 2) { - chf.spans = (rcCompactSpan*)rcAlloc(sizeof(rcCompactSpan)*chf.spanCount, RC_ALLOC_PERM); + chf.spans = (rcCompactSpan*)rdAlloc(sizeof(rcCompactSpan)*chf.spanCount, RD_ALLOC_PERM); if (!chf.spans) { printf("duReadCompactHeightfield: Could not alloc spans (%d)\n", chf.spanCount); @@ -386,7 +386,7 @@ bool duReadCompactHeightfield(struct rcCompactHeightfield& chf, duFileIO* io) } if (tmp & 4) { - chf.dist = (unsigned short*)rcAlloc(sizeof(unsigned short)*chf.spanCount, RC_ALLOC_PERM); + chf.dist = (unsigned short*)rdAlloc(sizeof(unsigned short)*chf.spanCount, RD_ALLOC_PERM); if (!chf.dist) { printf("duReadCompactHeightfield: Could not alloc dist (%d)\n", chf.spanCount); @@ -396,7 +396,7 @@ bool duReadCompactHeightfield(struct rcCompactHeightfield& chf, duFileIO* io) } if (tmp & 8) { - chf.areas = (unsigned char*)rcAlloc(sizeof(unsigned char)*chf.spanCount, RC_ALLOC_PERM); + chf.areas = (unsigned char*)rdAlloc(sizeof(unsigned char)*chf.spanCount, RD_ALLOC_PERM); if (!chf.areas) { printf("duReadCompactHeightfield: Could not alloc areas (%d)\n", chf.spanCount); diff --git a/src/thirdparty/recast/Detour/Include/DetourAlloc.h b/src/thirdparty/recast/Detour/Include/DetourAlloc.h deleted file mode 100644 index f87b454a..00000000 --- a/src/thirdparty/recast/Detour/Include/DetourAlloc.h +++ /dev/null @@ -1,61 +0,0 @@ -// -// 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 DETOURALLOCATOR_H -#define DETOURALLOCATOR_H - -#include - -/// Provides hint values to the memory allocator on how long the -/// memory is expected to be used. -enum dtAllocHint -{ - DT_ALLOC_PERM, ///< Memory persist after a function call. - DT_ALLOC_TEMP ///< Memory used temporarily within a function. -}; - -/// A memory allocation function. -// @param[in] size The size, in bytes of memory, to allocate. -// @param[in] rcAllocHint A hint to the allocator on how long the memory is expected to be in use. -// @return A pointer to the beginning of the allocated memory block, or null if the allocation failed. -/// @see dtAllocSetCustom -typedef void* (dtAllocFunc)(size_t size, dtAllocHint hint); - -/// A memory deallocation function. -/// @param[in] ptr A pointer to a memory block previously allocated using #dtAllocFunc. -/// @see dtAllocSetCustom -typedef void (dtFreeFunc)(void* ptr); - -/// Sets the base custom allocation functions to be used by Detour. -/// @param[in] allocFunc The memory allocation function to be used by #dtAlloc -/// @param[in] freeFunc The memory de-allocation function to be used by #dtFree -void dtAllocSetCustom(dtAllocFunc *allocFunc, dtFreeFunc *freeFunc); - -/// Allocates a memory block. -/// @param[in] size The size, in bytes of memory, to allocate. -/// @param[in] hint A hint to the allocator on how long the memory is expected to be in use. -/// @return A pointer to the beginning of the allocated memory block, or null if the allocation failed. -/// @see dtFree -void* dtAlloc(size_t size, dtAllocHint hint); - -/// Deallocates a memory block. -/// @param[in] ptr A pointer to a memory block previously allocated using #dtAlloc. -/// @see dtAlloc -void dtFree(void* ptr); - -#endif diff --git a/src/thirdparty/recast/Detour/Include/DetourNavMesh.h b/src/thirdparty/recast/Detour/Include/DetourNavMesh.h index 54bd16c8..38f714b1 100644 --- a/src/thirdparty/recast/Detour/Include/DetourNavMesh.h +++ b/src/thirdparty/recast/Detour/Include/DetourNavMesh.h @@ -21,7 +21,7 @@ // Only use types for function prototypes #ifndef GAMESDK -#include "Detour/Include/DetourAlloc.h" +#include "Shared/Include/SharedAlloc.h" #include "Detour/Include/DetourStatus.h" #endif // !GAMESDK @@ -765,12 +765,12 @@ inline int calcStaticPathingTableSize(const int numPolyGroups) /// Allocates a navigation mesh object using the Detour allocator. /// @return A navigation mesh that is ready for initialization, or null on failure. /// @ingroup detour -dtNavMesh* dtAllocNavMesh(); +dtNavMesh* rdAllocNavMesh(); /// Frees the specified navigation mesh object using the Detour allocator. -/// @param[in] navmesh A navigation mesh allocated using #dtAllocNavMesh +/// @param[in] navmesh A navigation mesh allocated using #rdAllocNavMesh /// @ingroup detour -void dtFreeNavMesh(dtNavMesh* navmesh); +void rdFreeNavMesh(dtNavMesh* navmesh); #endif // DETOURNAVMESH_H diff --git a/src/thirdparty/recast/Detour/Include/DetourNavMeshBuilder.h b/src/thirdparty/recast/Detour/Include/DetourNavMeshBuilder.h index aa20d6a9..7fc6150b 100644 --- a/src/thirdparty/recast/Detour/Include/DetourNavMeshBuilder.h +++ b/src/thirdparty/recast/Detour/Include/DetourNavMeshBuilder.h @@ -19,7 +19,7 @@ #ifndef DETOURNAVMESHBUILDER_H #define DETOURNAVMESHBUILDER_H -#include "Detour/Include/DetourAlloc.h" +#include "Shared/Include/SharedAlloc.h" /// Represents the source data used to build an navigation mesh tile. /// @ingroup detour diff --git a/src/thirdparty/recast/Detour/Include/DetourNavMeshQuery.h b/src/thirdparty/recast/Detour/Include/DetourNavMeshQuery.h index c4fb94c0..6236d064 100644 --- a/src/thirdparty/recast/Detour/Include/DetourNavMeshQuery.h +++ b/src/thirdparty/recast/Detour/Include/DetourNavMeshQuery.h @@ -583,11 +583,11 @@ private: /// Allocates a query object using the Detour allocator. /// @return An allocated query object, or null on failure. /// @ingroup detour -dtNavMeshQuery* dtAllocNavMeshQuery(); +dtNavMeshQuery* rdAllocNavMeshQuery(); /// Frees the specified query object using the Detour allocator. -/// @param[in] query A query object allocated using #dtAllocNavMeshQuery +/// @param[in] query A query object allocated using #rdAllocNavMeshQuery /// @ingroup detour -void dtFreeNavMeshQuery(dtNavMeshQuery* query); +void rdFreeNavMeshQuery(dtNavMeshQuery* query); #endif // DETOURNAVMESHQUERY_H diff --git a/src/thirdparty/recast/Detour/Source/DetourAlloc.cpp b/src/thirdparty/recast/Detour/Source/DetourAlloc.cpp index 07ede2ab..7438cf19 100644 --- a/src/thirdparty/recast/Detour/Source/DetourAlloc.cpp +++ b/src/thirdparty/recast/Detour/Source/DetourAlloc.cpp @@ -17,33 +17,33 @@ // #include -#include "Detour/Include/DetourAlloc.h" +#include "Shared/Include/SharedAlloc.h" -static void *dtAllocDefault(size_t size, dtAllocHint) +static void *rdAllocDefault(size_t size, rdAllocHint) { return malloc(size); } -static void dtFreeDefault(void *ptr) +static void rdFreeDefault(void *ptr) { free(ptr); } -static dtAllocFunc* sAllocFunc = dtAllocDefault; -static dtFreeFunc* sFreeFunc = dtFreeDefault; +static rdAllocFunc* sAllocFunc = rdAllocDefault; +static rdFreeFunc* sFreeFunc = rdFreeDefault; -void dtAllocSetCustom(dtAllocFunc *allocFunc, dtFreeFunc *freeFunc) +void rdAllocSetCustom(rdAllocFunc *allocFunc, rdFreeFunc *freeFunc) { - sAllocFunc = allocFunc ? allocFunc : dtAllocDefault; - sFreeFunc = freeFunc ? freeFunc : dtFreeDefault; + sAllocFunc = allocFunc ? allocFunc : rdAllocDefault; + sFreeFunc = freeFunc ? freeFunc : rdFreeDefault; } -void* dtAlloc(size_t size, dtAllocHint hint) +void* rdAlloc(size_t size, rdAllocHint hint) { return sAllocFunc(size, hint); } -void dtFree(void* ptr) +void rdFree(void* ptr) { if (ptr) sFreeFunc(ptr); diff --git a/src/thirdparty/recast/Detour/Source/DetourAssert.cpp b/src/thirdparty/recast/Detour/Source/DetourAssert.cpp index 5946d744..919dfbb0 100644 --- a/src/thirdparty/recast/Detour/Source/DetourAssert.cpp +++ b/src/thirdparty/recast/Detour/Source/DetourAssert.cpp @@ -16,18 +16,18 @@ // 3. This notice may not be removed or altered from any source distribution. // -#include "Detour/Include/DetourAssert.h" +#include "Shared/Include/SharedAssert.h" #ifndef NDEBUG -static dtAssertFailFunc* sAssertFailFunc = 0; +static rdAssertFailFunc* sAssertFailFunc = 0; -void dtAssertFailSetCustom(dtAssertFailFunc *assertFailFunc) +void rdAssertFailSetCustom(rdAssertFailFunc *assertFailFunc) { sAssertFailFunc = assertFailFunc; } -dtAssertFailFunc* dtAssertFailGetCustom() +rdAssertFailFunc* rdAssertFailGetCustom() { return sAssertFailFunc; } diff --git a/src/thirdparty/recast/Detour/Source/DetourNavMesh.cpp b/src/thirdparty/recast/Detour/Source/DetourNavMesh.cpp index 8b340a54..cffd181a 100644 --- a/src/thirdparty/recast/Detour/Source/DetourNavMesh.cpp +++ b/src/thirdparty/recast/Detour/Source/DetourNavMesh.cpp @@ -23,8 +23,8 @@ #include "Detour/Include/DetourNode.h" #include "Detour/Include/DetourCommon.h" #include "Detour/Include/DetourMath.h" -#include "Detour/Include/DetourAlloc.h" -#include "Detour/Include/DetourAssert.h" +#include "Shared/Include/SharedAlloc.h" +#include "Shared/Include/SharedAssert.h" #include @@ -135,9 +135,9 @@ inline void freeLink(dtMeshTile* tile, unsigned int link) } -dtNavMesh* dtAllocNavMesh() +dtNavMesh* rdAllocNavMesh() { - void* mem = dtAlloc(sizeof(dtNavMesh), DT_ALLOC_PERM); + void* mem = rdAlloc(sizeof(dtNavMesh), RD_ALLOC_PERM); if (!mem) return 0; return new(mem) dtNavMesh; } @@ -146,11 +146,11 @@ dtNavMesh* dtAllocNavMesh() /// /// This function will only free the memory for tiles with the #DT_TILE_FREE_DATA /// flag set. -void dtFreeNavMesh(dtNavMesh* navmesh) +void rdFreeNavMesh(dtNavMesh* navmesh) { if (!navmesh) return; navmesh->~dtNavMesh(); - dtFree(navmesh); + rdFree(navmesh); } ////////////////////////////////////////////////////////////////////////////////////////// @@ -182,7 +182,7 @@ Notes: - This class does not implement any asynchronous methods. So the ::dtStatus result of all methods will always contain either a success or failure flag. -@see dtNavMeshQuery, dtCreateNavMeshData, dtNavMeshCreateParams, #dtAllocNavMesh, #dtFreeNavMesh +@see dtNavMeshQuery, dtCreateNavMeshData, dtNavMeshCreateParams, #rdAllocNavMesh, #rdFreeNavMesh */ dtNavMesh::dtNavMesh() : @@ -217,24 +217,24 @@ dtNavMesh::~dtNavMesh() // TODO: see [r5apex_ds + F43720] to re-implement this c { if (m_tiles[i].flags & DT_TILE_FREE_DATA) { - dtFree(m_tiles[i].data); + rdFree(m_tiles[i].data); m_tiles[i].data = 0; m_tiles[i].dataSize = 0; } } - dtFree(m_posLookup); - dtFree(m_tiles); + rdFree(m_posLookup); + rdFree(m_tiles); for (int i = 0; i < m_params.reachabilityTableCount; i++) { int* reachabilityTable = m_setTables[i]; if (reachabilityTable) - dtFree(reachabilityTable); + rdFree(reachabilityTable); } - dtFree(m_setTables); + rdFree(m_setTables); } dtStatus dtNavMesh::init(const dtNavMeshParams* params) @@ -251,10 +251,10 @@ dtStatus dtNavMesh::init(const dtNavMeshParams* params) if (!m_tileLutSize) m_tileLutSize = 1; m_tileLutMask = m_tileLutSize-1; - m_tiles = (dtMeshTile*)dtAlloc(sizeof(dtMeshTile)*m_maxTiles, DT_ALLOC_PERM); + m_tiles = (dtMeshTile*)rdAlloc(sizeof(dtMeshTile)*m_maxTiles, RD_ALLOC_PERM); if (!m_tiles) return DT_FAILURE | DT_OUT_OF_MEMORY; - m_posLookup = (dtMeshTile**)dtAlloc(sizeof(dtMeshTile*)*m_tileLutSize, DT_ALLOC_PERM); + m_posLookup = (dtMeshTile**)rdAlloc(sizeof(dtMeshTile*)*m_tileLutSize, RD_ALLOC_PERM); if (!m_posLookup) return DT_FAILURE | DT_OUT_OF_MEMORY; memset(m_tiles, 0, sizeof(dtMeshTile) * m_maxTiles); @@ -265,7 +265,7 @@ dtStatus dtNavMesh::init(const dtNavMeshParams* params) { const int setTableBufSize = sizeof(int**)*reachabilityTableCount; - m_setTables = (int**)dtAlloc(setTableBufSize, DT_ALLOC_PERM); + m_setTables = (int**)rdAlloc(setTableBufSize, RD_ALLOC_PERM); if (!m_setTables) return DT_FAILURE | DT_OUT_OF_MEMORY; @@ -1346,7 +1346,7 @@ dtStatus dtNavMesh::removeTile(dtTileRef ref, unsigned char** data, int* dataSiz if (tile->flags & DT_TILE_FREE_DATA) { // Owns data - dtFree(tile->data); + rdFree(tile->data); tile->data = 0; tile->dataSize = 0; if (data) *data = 0; @@ -1573,7 +1573,7 @@ const dtOffMeshConnection* dtNavMesh::getOffMeshConnectionByRef(dtPolyRef ref) c return 0; const unsigned int idx = ip - tile->header->offMeshBase; - dtAssert(idx < (unsigned int)tile->header->offMeshConCount); + rdAssert(idx < (unsigned int)tile->header->offMeshConCount); return &tile->offMeshCons[idx]; } diff --git a/src/thirdparty/recast/Detour/Source/DetourNavMeshBuilder.cpp b/src/thirdparty/recast/Detour/Source/DetourNavMeshBuilder.cpp index 448d6113..728579fb 100644 --- a/src/thirdparty/recast/Detour/Source/DetourNavMeshBuilder.cpp +++ b/src/thirdparty/recast/Detour/Source/DetourNavMeshBuilder.cpp @@ -24,8 +24,8 @@ #include "Detour/Include/DetourCommon.h" #include "Detour/Include/DetourMath.h" #include "Detour/Include/DetourNavMeshBuilder.h" -#include "Detour/Include/DetourAlloc.h" -#include "Detour/Include/DetourAssert.h" +#include "Shared/Include/SharedAlloc.h" +#include "Shared/Include/SharedAssert.h" static unsigned short MESH_NULL_IDX = 0xffff; @@ -172,7 +172,7 @@ static int createBVTree(dtNavMeshCreateParams* params, dtBVNode* nodes, int /*nn { // Build tree float quantFactor = 1 / params->cs; - BVItem* items = (BVItem*)dtAlloc(sizeof(BVItem)*params->polyCount, DT_ALLOC_TEMP); + BVItem* items = (BVItem*)rdAlloc(sizeof(BVItem)*params->polyCount, RD_ALLOC_TEMP); for (int i = 0; i < params->polyCount; i++) { BVItem& it = items[i]; @@ -235,7 +235,7 @@ static int createBVTree(dtNavMeshCreateParams* params, dtBVNode* nodes, int /*nn int curNode = 0; subdivide(items, params->polyCount, 0, params->polyCount, curNode, nodes); - dtFree(items); + rdFree(items); return curNode; } @@ -283,7 +283,7 @@ static void setReachable(int* const tableData, const int numPolyGroups, bool dtBuildStaticPathingData(dtNavMesh* mesh) { - dtAssert(mesh); + rdAssert(mesh); // Reserve the first 2 poly groups // 0 = technically usable for normal poly groups, but for simplicity we reserve it for now. @@ -365,7 +365,7 @@ bool dtBuildStaticPathingData(dtNavMesh* mesh) const int tableSize = calcStaticPathingTableSize(numPolyGroups); const int tableCount = DT_NUM_REACHABILITY_TABLES; - dtAssert(mesh->m_setTables); + rdAssert(mesh->m_setTables); // NOTE: the game allocates 4 reachability table buffers, original // navmeshes have slightly different data per table. Currently ours are all @@ -373,7 +373,7 @@ bool dtBuildStaticPathingData(dtNavMesh* mesh) // figure out why we need 4 tables and what the differences are. for (int i = 0; i < tableCount; i++) { - int* const reachabilityTable = (int*)dtAlloc(sizeof(int)*tableSize, DT_ALLOC_PERM); + int* const reachabilityTable = (int*)rdAlloc(sizeof(int)*tableSize, RD_ALLOC_PERM); if (!reachabilityTable) return false; @@ -396,7 +396,7 @@ bool dtBuildStaticPathingData(dtNavMesh* mesh) /// @par /// -/// The output data array is allocated using the detour allocator (dtAlloc()). The method +/// The output data array is allocated using the detour allocator (rdAlloc()). The method /// used to free the memory will be determined by how the tile is added to the navigation /// mesh. /// @@ -422,7 +422,7 @@ bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData, if (params->offMeshConCount > 0) { - offMeshConClass = (unsigned char*)dtAlloc(sizeof(unsigned char)*params->offMeshConCount*2, DT_ALLOC_TEMP); + offMeshConClass = (unsigned char*)rdAlloc(sizeof(unsigned char)*params->offMeshConCount*2, RD_ALLOC_TEMP); if (!offMeshConClass) return false; @@ -567,10 +567,10 @@ bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData, //printf("%i %i %i %i(%i links) %i %i %i %i %i\n", headerSize, vertsSize, polysSize, linksSize, maxLinkCount, detailMeshesSize, detailVertsSize, detailTrisSize, bvTreeSize, offMeshConsSize); //printf("%i\n", dataSize); - unsigned char* data = (unsigned char*)dtAlloc(sizeof(unsigned char)*dataSize, DT_ALLOC_PERM); + unsigned char* data = (unsigned char*)rdAlloc(sizeof(unsigned char)*dataSize, RD_ALLOC_PERM); if (!data) { - dtFree(offMeshConClass); + rdFree(offMeshConClass); return false; } memset(data, 0, dataSize); @@ -797,7 +797,7 @@ bool dtCreateNavMeshData(dtNavMeshCreateParams* params, unsigned char** outData, } } - dtFree(offMeshConClass); + rdFree(offMeshConClass); *outData = data; *outDataSize = dataSize; diff --git a/src/thirdparty/recast/Detour/Source/DetourNavMeshQuery.cpp b/src/thirdparty/recast/Detour/Source/DetourNavMeshQuery.cpp index f3f5b4fa..043aaae2 100644 --- a/src/thirdparty/recast/Detour/Source/DetourNavMeshQuery.cpp +++ b/src/thirdparty/recast/Detour/Source/DetourNavMeshQuery.cpp @@ -23,8 +23,8 @@ #include "Detour/Include/DetourNode.h" #include "Detour/Include/DetourCommon.h" #include "Detour/Include/DetourMath.h" -#include "Detour/Include/DetourAlloc.h" -#include "Detour/Include/DetourAssert.h" +#include "Shared/Include/SharedAlloc.h" +#include "Shared/Include/SharedAssert.h" #include /// @class dtQueryFilter @@ -103,18 +103,18 @@ inline float dtQueryFilter::getCost(const float* pa, const float* pb, static const float H_SCALE = 0.999f; // Search heuristic scale. -dtNavMeshQuery* dtAllocNavMeshQuery() +dtNavMeshQuery* rdAllocNavMeshQuery() { - void* mem = dtAlloc(sizeof(dtNavMeshQuery), DT_ALLOC_PERM); + void* mem = rdAlloc(sizeof(dtNavMeshQuery), RD_ALLOC_PERM); if (!mem) return 0; return new(mem) dtNavMeshQuery; } -void dtFreeNavMeshQuery(dtNavMeshQuery* navmesh) +void rdFreeNavMeshQuery(dtNavMeshQuery* navmesh) { if (!navmesh) return; navmesh->~dtNavMeshQuery(); - dtFree(navmesh); + rdFree(navmesh); } ////////////////////////////////////////////////////////////////////////////////////////// @@ -133,7 +133,7 @@ void dtFreeNavMeshQuery(dtNavMeshQuery* navmesh) /// considered impassable. A @e portal is a passable segment between polygons. /// A portal may be treated as a wall based on the dtQueryFilter used for a query. /// -/// @see dtNavMesh, dtQueryFilter, #dtAllocNavMeshQuery(), #dtAllocNavMeshQuery() +/// @see dtNavMesh, dtQueryFilter, #rdAllocNavMeshQuery(), #rdAllocNavMeshQuery() dtNavMeshQuery::dtNavMeshQuery() : m_nav(0), @@ -153,9 +153,9 @@ dtNavMeshQuery::~dtNavMeshQuery() if (m_openList) m_openList->~dtNodeQueue(); - dtFree(m_tinyNodePool); - dtFree(m_nodePool); - dtFree(m_openList); + rdFree(m_tinyNodePool); + rdFree(m_nodePool); + rdFree(m_openList); } /// @par @@ -176,10 +176,10 @@ dtStatus dtNavMeshQuery::init(const dtNavMesh* nav, const int maxNodes) if (m_nodePool) { m_nodePool->~dtNodePool(); - dtFree(m_nodePool); + rdFree(m_nodePool); m_nodePool = 0; } - m_nodePool = new (dtAlloc(sizeof(dtNodePool), DT_ALLOC_PERM)) dtNodePool(maxNodes, dtNextPow2(maxNodes/4)); + m_nodePool = new (rdAlloc(sizeof(dtNodePool), RD_ALLOC_PERM)) dtNodePool(maxNodes, dtNextPow2(maxNodes/4)); if (!m_nodePool) return DT_FAILURE | DT_OUT_OF_MEMORY; } @@ -190,7 +190,7 @@ dtStatus dtNavMeshQuery::init(const dtNavMesh* nav, const int maxNodes) if (!m_tinyNodePool) { - m_tinyNodePool = new (dtAlloc(sizeof(dtNodePool), DT_ALLOC_PERM)) dtNodePool(64, 32); + m_tinyNodePool = new (rdAlloc(sizeof(dtNodePool), RD_ALLOC_PERM)) dtNodePool(64, 32); if (!m_tinyNodePool) return DT_FAILURE | DT_OUT_OF_MEMORY; } @@ -204,10 +204,10 @@ dtStatus dtNavMeshQuery::init(const dtNavMesh* nav, const int maxNodes) if (m_openList) { m_openList->~dtNodeQueue(); - dtFree(m_openList); + rdFree(m_openList); m_openList = 0; } - m_openList = new (dtAlloc(sizeof(dtNodeQueue), DT_ALLOC_PERM)) dtNodeQueue(maxNodes); + m_openList = new (rdAlloc(sizeof(dtNodeQueue), RD_ALLOC_PERM)) dtNodeQueue(maxNodes); if (!m_openList) return DT_FAILURE | DT_OUT_OF_MEMORY; } @@ -222,7 +222,7 @@ dtStatus dtNavMeshQuery::init(const dtNavMesh* nav, const int maxNodes) dtStatus dtNavMeshQuery::findRandomPoint(const dtQueryFilter* filter, float (*frand)(), dtPolyRef* randomRef, float* randomPt) const { - dtAssert(m_nav); + rdAssert(m_nav); if (!m_nav || !filter || !frand || !randomRef || !randomPt) return DT_FAILURE | DT_INVALID_PARAM; @@ -314,9 +314,9 @@ dtStatus dtNavMeshQuery::findRandomPointAroundCircle(dtPolyRef startRef, const f const dtQueryFilter* filter, float (*frand)(), dtPolyRef* randomRef, float* randomPt) const { - dtAssert(m_nav); - dtAssert(m_nodePool); - dtAssert(m_openList); + rdAssert(m_nav); + rdAssert(m_nodePool); + rdAssert(m_openList); // Validate input if (!m_nav->isValidPolyRef(startRef) || @@ -506,7 +506,7 @@ dtStatus dtNavMeshQuery::findRandomPointAroundCircle(dtPolyRef startRef, const f /// dtStatus dtNavMeshQuery::closestPointOnPoly(dtPolyRef ref, const float* pos, float* closest, bool* posOverPoly) const { - dtAssert(m_nav); + rdAssert(m_nav); if (!m_nav->isValidPolyRef(ref) || !pos || !dtVisfinite(pos) || !closest) @@ -531,7 +531,7 @@ dtStatus dtNavMeshQuery::closestPointOnPoly(dtPolyRef ref, const float* pos, flo /// dtStatus dtNavMeshQuery::closestPointOnPolyBoundary(dtPolyRef ref, const float* pos, float* closest) const { - dtAssert(m_nav); + rdAssert(m_nav); const dtMeshTile* tile = 0; const dtPoly* poly = 0; @@ -586,7 +586,7 @@ dtStatus dtNavMeshQuery::closestPointOnPolyBoundary(dtPolyRef ref, const float* /// dtStatus dtNavMeshQuery::getPolyHeight(dtPolyRef ref, const float* pos, float* height) const { - dtAssert(m_nav); + rdAssert(m_nav); const dtMeshTile* tile = 0; const dtPoly* poly = 0; @@ -692,7 +692,7 @@ dtStatus dtNavMeshQuery::findNearestPoly(const float* center, const float* halfE const dtQueryFilter* filter, dtPolyRef* nearestRef, float* nearestPt, bool* isOverPoly) const { - dtAssert(m_nav); + rdAssert(m_nav); if (!nearestRef) return DT_FAILURE | DT_INVALID_PARAM; @@ -721,7 +721,7 @@ dtStatus dtNavMeshQuery::findNearestPoly(const float* center, const float* halfE void dtNavMeshQuery::queryPolygonsInTile(const dtMeshTile* tile, const float* qmin, const float* qmax, const dtQueryFilter* filter, dtPolyQuery* query) const { - dtAssert(m_nav); + rdAssert(m_nav); static const int batchSize = 32; dtPolyRef polyRefs[batchSize]; dtPoly* polys[batchSize]; @@ -905,7 +905,7 @@ dtStatus dtNavMeshQuery::queryPolygons(const float* center, const float* halfExt dtStatus dtNavMeshQuery::queryPolygons(const float* center, const float* halfExtents, const dtQueryFilter* filter, dtPolyQuery* query) const { - dtAssert(m_nav); + rdAssert(m_nav); if (!center || !dtVisfinite(center) || !halfExtents || !dtVisfinite(halfExtents) || @@ -957,9 +957,9 @@ dtStatus dtNavMeshQuery::findPath(dtPolyRef startRef, dtPolyRef endRef, const dtQueryFilter* filter, dtPolyRef* path, int* pathCount, const int maxPath) const { - dtAssert(m_nav); - dtAssert(m_nodePool); - dtAssert(m_openList); + rdAssert(m_nav); + rdAssert(m_nodePool); + rdAssert(m_openList); if (!pathCount) return DT_FAILURE | DT_INVALID_PARAM; @@ -1162,7 +1162,7 @@ dtStatus dtNavMeshQuery::getPathToNode(dtNode* endNode, dtPolyRef* path, int* pa int writeCount; for (writeCount = length; writeCount > maxPath; writeCount--) { - dtAssert(curNode); + rdAssert(curNode); curNode = m_nodePool->getNodeAtIdx(curNode->pidx); } @@ -1170,13 +1170,13 @@ dtStatus dtNavMeshQuery::getPathToNode(dtNode* endNode, dtPolyRef* path, int* pa // Write path for (int i = writeCount - 1; i >= 0; i--) { - dtAssert(curNode); + rdAssert(curNode); path[i] = curNode->id; curNode = m_nodePool->getNodeAtIdx(curNode->pidx); } - dtAssert(!curNode); + rdAssert(!curNode); *pathCount = dtMin(length, maxPath); @@ -1199,9 +1199,9 @@ dtStatus dtNavMeshQuery::initSlicedFindPath(dtPolyRef startRef, dtPolyRef endRef const float* startPos, const float* endPos, const unsigned int options) { - dtAssert(m_nav); - dtAssert(m_nodePool); - dtAssert(m_openList); + rdAssert(m_nav); + rdAssert(m_nodePool); + rdAssert(m_openList); // Init path state. memset(&m_query, 0, sizeof(dtQueryData)); @@ -1260,7 +1260,7 @@ dtStatus dtNavMeshQuery::initSlicedFindPath(dtPolyRef startRef, dtPolyRef endRef dtStatus dtNavMeshQuery::updateSlicedFindPath(const int maxIter, int* doneIters, const dtQueryFilter* filter) { - dtAssert(filter); + rdAssert(filter); if (!dtStatusInProgress(m_query.status)) return m_query.status; @@ -1487,8 +1487,8 @@ dtStatus dtNavMeshQuery::updateSlicedFindPath(const int maxIter, int* doneIters, dtStatus dtNavMeshQuery::finalizeSlicedFindPath(dtPolyRef* path, int* pathCount, const int maxPath, const dtQueryFilter* filter) { - dtAssert(filter); - dtAssert(pathCount); + rdAssert(filter); + rdAssert(pathCount); if (!filter || !pathCount) return DT_FAILURE | DT_INVALID_PARAM; @@ -1515,7 +1515,7 @@ dtStatus dtNavMeshQuery::finalizeSlicedFindPath(dtPolyRef* path, int* pathCount, else { // Reverse the path. - dtAssert(m_query.lastBestNode); + rdAssert(m_query.lastBestNode); if (m_query.lastBestNode->id != m_query.endRef) m_query.status |= DT_PARTIAL_RESULT; @@ -1619,7 +1619,7 @@ dtStatus dtNavMeshQuery::finalizeSlicedFindPathPartial(const dtPolyRef* existing if (!node) { m_query.status |= DT_PARTIAL_RESULT; - dtAssert(m_query.lastBestNode); + rdAssert(m_query.lastBestNode); node = m_query.lastBestNode; } @@ -1790,7 +1790,7 @@ dtStatus dtNavMeshQuery::findStraightPath(const float* startPos, const float* en float* straightPath, unsigned char* straightPathFlags, dtPolyRef* straightPathRefs, int* straightPathCount, const int maxStraightPath, const int options) const { - dtAssert(m_nav); + rdAssert(m_nav); if (!straightPathCount) return DT_FAILURE | DT_INVALID_PARAM; @@ -2040,8 +2040,8 @@ dtStatus dtNavMeshQuery::moveAlongSurface(dtPolyRef startRef, const float* start const dtQueryFilter* filter, float* resultPos, dtPolyRef* visited, int* visitedCount, const int maxVisitedSize) const { - dtAssert(m_nav); - dtAssert(m_tinyNodePool); + rdAssert(m_nav); + rdAssert(m_tinyNodePool); if (!visitedCount) return DT_FAILURE | DT_INVALID_PARAM; @@ -2243,7 +2243,7 @@ dtStatus dtNavMeshQuery::moveAlongSurface(dtPolyRef startRef, const float* start dtStatus dtNavMeshQuery::getPortalPoints(dtPolyRef from, dtPolyRef to, float* left, float* right, unsigned char& fromType, unsigned char& toType) const { - dtAssert(m_nav); + rdAssert(m_nav); const dtMeshTile* fromTile = 0; const dtPoly* fromPoly = 0; @@ -2462,7 +2462,7 @@ dtStatus dtNavMeshQuery::raycast(dtPolyRef startRef, const float* startPos, cons const dtQueryFilter* filter, const unsigned int options, dtRaycastHit* hit, dtPolyRef prevRef) const { - dtAssert(m_nav); + rdAssert(m_nav); if (!hit) return DT_FAILURE | DT_INVALID_PARAM; @@ -2717,9 +2717,9 @@ dtStatus dtNavMeshQuery::findPolysAroundCircle(dtPolyRef startRef, const float* dtPolyRef* resultRef, dtPolyRef* resultParent, float* resultCost, int* resultCount, const int maxResult) const { - dtAssert(m_nav); - dtAssert(m_nodePool); - dtAssert(m_openList); + rdAssert(m_nav); + rdAssert(m_nodePool); + rdAssert(m_openList); if (!resultCount) return DT_FAILURE | DT_INVALID_PARAM; @@ -2891,9 +2891,9 @@ dtStatus dtNavMeshQuery::findPolysAroundShape(dtPolyRef startRef, const float* v dtPolyRef* resultRef, dtPolyRef* resultParent, float* resultCost, int* resultCount, const int maxResult) const { - dtAssert(m_nav); - dtAssert(m_nodePool); - dtAssert(m_openList); + rdAssert(m_nav); + rdAssert(m_nodePool); + rdAssert(m_openList); if (!resultCount) return DT_FAILURE | DT_INVALID_PARAM; @@ -3089,8 +3089,8 @@ dtStatus dtNavMeshQuery::findLocalNeighbourhood(dtPolyRef startRef, const float* dtPolyRef* resultRef, dtPolyRef* resultParent, int* resultCount, const int maxResult) const { - dtAssert(m_nav); - dtAssert(m_tinyNodePool); + rdAssert(m_nav); + rdAssert(m_tinyNodePool); if (!resultCount) return DT_FAILURE | DT_INVALID_PARAM; @@ -3310,7 +3310,7 @@ dtStatus dtNavMeshQuery::getPolyWallSegments(dtPolyRef ref, const dtQueryFilter* float* segmentVerts, dtPolyRef* segmentRefs, int* segmentCount, const int maxSegments) const { - dtAssert(m_nav); + rdAssert(m_nav); if (!segmentCount) return DT_FAILURE | DT_INVALID_PARAM; @@ -3466,9 +3466,9 @@ dtStatus dtNavMeshQuery::findDistanceToWall(dtPolyRef startRef, const float* cen const dtQueryFilter* filter, float* hitDist, float* hitPos, float* hitNormal) const { - dtAssert(m_nav); - dtAssert(m_nodePool); - dtAssert(m_openList); + rdAssert(m_nav); + rdAssert(m_nodePool); + rdAssert(m_openList); // Validate input if (!m_nav->isValidPolyRef(startRef) || diff --git a/src/thirdparty/recast/Detour/Source/DetourNode.cpp b/src/thirdparty/recast/Detour/Source/DetourNode.cpp index 72e9eead..eeaf942d 100644 --- a/src/thirdparty/recast/Detour/Source/DetourNode.cpp +++ b/src/thirdparty/recast/Detour/Source/DetourNode.cpp @@ -17,8 +17,8 @@ // #include "Detour/Include/DetourNode.h" -#include "Detour/Include/DetourAlloc.h" -#include "Detour/Include/DetourAssert.h" +#include "Shared/Include/SharedAlloc.h" +#include "Shared/Include/SharedAssert.h" #include "Detour/Include/DetourCommon.h" #include @@ -56,18 +56,18 @@ dtNodePool::dtNodePool(int maxNodes, int hashSize) : m_hashSize(hashSize), m_nodeCount(0) { - dtAssert(dtNextPow2(m_hashSize) == (unsigned int)m_hashSize); + rdAssert(dtNextPow2(m_hashSize) == (unsigned int)m_hashSize); // pidx is special as 0 means "none" and 1 is the first node. For that reason // we have 1 fewer nodes available than the number of values it can contain. - dtAssert(m_maxNodes > 0 && m_maxNodes <= DT_NULL_IDX && m_maxNodes <= (1 << DT_NODE_PARENT_BITS) - 1); + rdAssert(m_maxNodes > 0 && m_maxNodes <= DT_NULL_IDX && m_maxNodes <= (1 << DT_NODE_PARENT_BITS) - 1); - m_nodes = (dtNode*)dtAlloc(sizeof(dtNode)*m_maxNodes, DT_ALLOC_PERM); - m_next = (dtNodeIndex*)dtAlloc(sizeof(dtNodeIndex)*m_maxNodes, DT_ALLOC_PERM); - m_first = (dtNodeIndex*)dtAlloc(sizeof(dtNodeIndex)*hashSize, DT_ALLOC_PERM); + m_nodes = (dtNode*)rdAlloc(sizeof(dtNode)*m_maxNodes, RD_ALLOC_PERM); + m_next = (dtNodeIndex*)rdAlloc(sizeof(dtNodeIndex)*m_maxNodes, RD_ALLOC_PERM); + m_first = (dtNodeIndex*)rdAlloc(sizeof(dtNodeIndex)*hashSize, RD_ALLOC_PERM); - dtAssert(m_nodes); - dtAssert(m_next); - dtAssert(m_first); + rdAssert(m_nodes); + rdAssert(m_next); + rdAssert(m_first); memset(m_first, 0xff, sizeof(dtNodeIndex)*m_hashSize); memset(m_next, 0xff, sizeof(dtNodeIndex)*m_maxNodes); @@ -75,9 +75,9 @@ dtNodePool::dtNodePool(int maxNodes, int hashSize) : dtNodePool::~dtNodePool() { - dtFree(m_nodes); - dtFree(m_next); - dtFree(m_first); + rdFree(m_nodes); + rdFree(m_next); + rdFree(m_first); } void dtNodePool::clear() @@ -158,15 +158,15 @@ dtNodeQueue::dtNodeQueue(int n) : m_capacity(n), m_size(0) { - dtAssert(m_capacity > 0); + rdAssert(m_capacity > 0); - m_heap = (dtNode**)dtAlloc(sizeof(dtNode*)*(m_capacity+1), DT_ALLOC_PERM); - dtAssert(m_heap); + m_heap = (dtNode**)rdAlloc(sizeof(dtNode*)*(m_capacity+1), RD_ALLOC_PERM); + rdAssert(m_heap); } dtNodeQueue::~dtNodeQueue() { - dtFree(m_heap); + rdFree(m_heap); } void dtNodeQueue::bubbleUp(int i, dtNode* node) diff --git a/src/thirdparty/recast/DetourCrowd/Include/DetourCrowd.h b/src/thirdparty/recast/DetourCrowd/Include/DetourCrowd.h index ce26ac5f..0de56111 100644 --- a/src/thirdparty/recast/DetourCrowd/Include/DetourCrowd.h +++ b/src/thirdparty/recast/DetourCrowd/Include/DetourCrowd.h @@ -357,12 +357,12 @@ private: /// Allocates a crowd object using the Detour allocator. /// @return A crowd object that is ready for initialization, or null on failure. /// @ingroup crowd -dtCrowd* dtAllocCrowd(); +dtCrowd* rdAllocCrowd(); /// Frees the specified crowd object using the Detour allocator. -/// @param[in] ptr A crowd object allocated using #dtAllocCrowd +/// @param[in] ptr A crowd object allocated using #rdAllocCrowd /// @ingroup crowd -void dtFreeCrowd(dtCrowd* ptr); +void rdFreeCrowd(dtCrowd* ptr); #endif // DETOURCROWD_H diff --git a/src/thirdparty/recast/DetourCrowd/Include/DetourObstacleAvoidance.h b/src/thirdparty/recast/DetourCrowd/Include/DetourObstacleAvoidance.h index cc46347a..0f1b5a7f 100644 --- a/src/thirdparty/recast/DetourCrowd/Include/DetourObstacleAvoidance.h +++ b/src/thirdparty/recast/DetourCrowd/Include/DetourObstacleAvoidance.h @@ -73,8 +73,8 @@ private: float* m_tpen; }; -dtObstacleAvoidanceDebugData* dtAllocObstacleAvoidanceDebugData(); -void dtFreeObstacleAvoidanceDebugData(dtObstacleAvoidanceDebugData* ptr); +dtObstacleAvoidanceDebugData* rdAllocObstacleAvoidanceDebugData(); +void rdFreeObstacleAvoidanceDebugData(dtObstacleAvoidanceDebugData* ptr); static const int DT_MAX_PATTERN_DIVS = 32; ///< Max numver of adaptive divs. @@ -152,8 +152,8 @@ private: int m_nsegments; }; -dtObstacleAvoidanceQuery* dtAllocObstacleAvoidanceQuery(); -void dtFreeObstacleAvoidanceQuery(dtObstacleAvoidanceQuery* ptr); +dtObstacleAvoidanceQuery* rdAllocObstacleAvoidanceQuery(); +void rdFreeObstacleAvoidanceQuery(dtObstacleAvoidanceQuery* ptr); #endif // DETOUROBSTACLEAVOIDANCE_H diff --git a/src/thirdparty/recast/DetourCrowd/Include/DetourProximityGrid.h b/src/thirdparty/recast/DetourCrowd/Include/DetourProximityGrid.h index d8968efd..5d9901e9 100644 --- a/src/thirdparty/recast/DetourCrowd/Include/DetourProximityGrid.h +++ b/src/thirdparty/recast/DetourCrowd/Include/DetourProximityGrid.h @@ -66,8 +66,8 @@ private: dtProximityGrid& operator=(const dtProximityGrid&); }; -dtProximityGrid* dtAllocProximityGrid(); -void dtFreeProximityGrid(dtProximityGrid* ptr); +dtProximityGrid* rdAllocProximityGrid(); +void rdFreeProximityGrid(dtProximityGrid* ptr); #endif // DETOURPROXIMITYGRID_H diff --git a/src/thirdparty/recast/DetourCrowd/Source/DetourCrowd.cpp b/src/thirdparty/recast/DetourCrowd/Source/DetourCrowd.cpp index 6028e48f..ee30cc8e 100644 --- a/src/thirdparty/recast/DetourCrowd/Source/DetourCrowd.cpp +++ b/src/thirdparty/recast/DetourCrowd/Source/DetourCrowd.cpp @@ -28,22 +28,22 @@ #include "Detour\Include\DetourNavMeshQuery.h" #include "Detour\Include\DetourCommon.h" #include "Detour\Include\DetourMath.h" -#include "Detour\Include\DetourAssert.h" -#include "Detour\Include\DetourAlloc.h" +#include "Shared\Include\SharedAssert.h" +#include "Shared\Include\SharedAlloc.h" -dtCrowd* dtAllocCrowd() +dtCrowd* rdAllocCrowd() { - void* mem = dtAlloc(sizeof(dtCrowd), DT_ALLOC_PERM); + void* mem = rdAlloc(sizeof(dtCrowd), RD_ALLOC_PERM); if (!mem) return 0; return new(mem) dtCrowd; } -void dtFreeCrowd(dtCrowd* ptr) +void rdFreeCrowd(dtCrowd* ptr) { if (!ptr) return; ptr->~dtCrowd(); - dtFree(ptr); + rdFree(ptr); } @@ -67,7 +67,7 @@ of the crowd features. A common method for setting up the crowd is as follows: --# Allocate the crowd using #dtAllocCrowd. +-# Allocate the crowd using #rdAllocCrowd. -# Initialize the crowd using #init(). -# Set the avoidance configurations using #setObstacleAvoidanceParams(). -# Add agents using #addAgent() and make an initial movement request using #requestMoveTarget(). @@ -92,7 +92,7 @@ Notes: - This class is meant to provide 'local' movement. There is a limit of 256 polygons in the path corridor. So it is not meant to provide automatic pathfinding services over long distances. -@see dtAllocCrowd(), dtFreeCrowd(), init(), dtCrowdAgent +@see rdAllocCrowd(), rdFreeCrowd(), init(), dtCrowdAgent */ @@ -120,26 +120,26 @@ void dtCrowd::purge() { for (int i = 0; i < m_maxAgents; ++i) m_agents[i].~dtCrowdAgent(); - dtFree(m_agents); + rdFree(m_agents); m_agents = 0; m_maxAgents = 0; - dtFree(m_activeAgents); + rdFree(m_activeAgents); m_activeAgents = 0; - dtFree(m_agentAnims); + rdFree(m_agentAnims); m_agentAnims = 0; - dtFree(m_pathResult); + rdFree(m_pathResult); m_pathResult = 0; - dtFreeProximityGrid(m_grid); + rdFreeProximityGrid(m_grid); m_grid = 0; - dtFreeObstacleAvoidanceQuery(m_obstacleQuery); + rdFreeObstacleAvoidanceQuery(m_obstacleQuery); m_obstacleQuery = 0; - dtFreeNavMeshQuery(m_navquery); + rdFreeNavMeshQuery(m_navquery); m_navquery = 0; } @@ -156,13 +156,13 @@ bool dtCrowd::init(const int maxAgents, const float maxAgentRadius, dtNavMesh* n // Larger than agent radius because it is also used for agent recovery. dtVset(m_agentPlacementHalfExtents, m_maxAgentRadius*2.0f, m_maxAgentRadius*1.5f, m_maxAgentRadius*2.0f); - m_grid = dtAllocProximityGrid(); + m_grid = rdAllocProximityGrid(); if (!m_grid) return false; if (!m_grid->init(m_maxAgents*4, maxAgentRadius*3)) return false; - m_obstacleQuery = dtAllocObstacleAvoidanceQuery(); + m_obstacleQuery = rdAllocObstacleAvoidanceQuery(); if (!m_obstacleQuery) return false; if (!m_obstacleQuery->init(6, 8)) @@ -187,22 +187,22 @@ bool dtCrowd::init(const int maxAgents, const float maxAgentRadius, dtNavMesh* n // Allocate temp buffer for merging paths. m_maxPathResult = 256; - m_pathResult = (dtPolyRef*)dtAlloc(sizeof(dtPolyRef)*m_maxPathResult, DT_ALLOC_PERM); + m_pathResult = (dtPolyRef*)rdAlloc(sizeof(dtPolyRef)*m_maxPathResult, RD_ALLOC_PERM); if (!m_pathResult) return false; if (!m_pathq.init(m_maxPathResult, MAX_PATHQUEUE_NODES, nav)) return false; - m_agents = (dtCrowdAgent*)dtAlloc(sizeof(dtCrowdAgent)*m_maxAgents, DT_ALLOC_PERM); + m_agents = (dtCrowdAgent*)rdAlloc(sizeof(dtCrowdAgent)*m_maxAgents, RD_ALLOC_PERM); if (!m_agents) return false; - m_activeAgents = (dtCrowdAgent**)dtAlloc(sizeof(dtCrowdAgent*)*m_maxAgents, DT_ALLOC_PERM); + m_activeAgents = (dtCrowdAgent**)rdAlloc(sizeof(dtCrowdAgent*)*m_maxAgents, RD_ALLOC_PERM); if (!m_activeAgents) return false; - m_agentAnims = (dtCrowdAgentAnimation*)dtAlloc(sizeof(dtCrowdAgentAnimation)*m_maxAgents, DT_ALLOC_PERM); + m_agentAnims = (dtCrowdAgentAnimation*)rdAlloc(sizeof(dtCrowdAgentAnimation)*m_maxAgents, RD_ALLOC_PERM); if (!m_agentAnims) return false; @@ -220,7 +220,7 @@ bool dtCrowd::init(const int maxAgents, const float maxAgentRadius, dtNavMesh* n } // The navquery is mostly used for local searches, no need for large node pool. - m_navquery = dtAllocNavMeshQuery(); + m_navquery = rdAllocNavMeshQuery(); if (!m_navquery) return false; if (dtStatusFailed(m_navquery->init(nav, MAX_COMMON_NODES))) @@ -463,7 +463,7 @@ void dtCrowd::updateMoveRequest(const float /*dt*/) { const dtPolyRef* path = ag->corridor.getPath(); const int npath = ag->corridor.getPathCount(); - dtAssert(npath); + rdAssert(npath); static const int MAX_RES = 32; float reqPos[3]; @@ -579,7 +579,7 @@ void dtCrowd::updateMoveRequest(const float /*dt*/) { const dtPolyRef* path = ag->corridor.getPath(); const int npath = ag->corridor.getPathCount(); - dtAssert(npath); + rdAssert(npath); // Apply results. float targetPos[3]; diff --git a/src/thirdparty/recast/DetourCrowd/Source/DetourCrowdInternal.cpp b/src/thirdparty/recast/DetourCrowd/Source/DetourCrowdInternal.cpp index 056c0f55..243b2787 100644 --- a/src/thirdparty/recast/DetourCrowd/Source/DetourCrowdInternal.cpp +++ b/src/thirdparty/recast/DetourCrowd/Source/DetourCrowdInternal.cpp @@ -28,8 +28,8 @@ #include "Detour\Include\DetourNavMeshQuery.h" #include "Detour\Include\DetourCommon.h" #include "Detour\Include\DetourMath.h" -#include "Detour\Include\DetourAssert.h" -#include "Detour\Include\DetourAlloc.h" +#include "Shared\Include\SharedAssert.h" +#include "Shared\Include\SharedAlloc.h" void integrate(dtCrowdAgent* ag, const float dt) @@ -146,7 +146,7 @@ int addNeighbour(const int idx, const float dist, const int tgt = i+1; const int n = dtMin(nneis-i, maxNeis-tgt); - dtAssert(tgt+n <= maxNeis); + rdAssert(tgt+n <= maxNeis); if (n > 0) memmove(&neis[tgt], &neis[i], sizeof(dtCrowdNeighbour)*n); @@ -218,7 +218,7 @@ int addToOptQueue(dtCrowdAgent* newag, dtCrowdAgent** agents, const int nagents, const int tgt = i+1; const int n = dtMin(nagents-i, maxAgents-tgt); - dtAssert(tgt+n <= maxAgents); + rdAssert(tgt+n <= maxAgents); if (n > 0) memmove(&agents[tgt], &agents[i], sizeof(dtCrowdAgent*)*n); @@ -254,7 +254,7 @@ int addToPathQueue(dtCrowdAgent* newag, dtCrowdAgent** agents, const int nagents const int tgt = i+1; const int n = dtMin(nagents-i, maxAgents-tgt); - dtAssert(tgt+n <= maxAgents); + rdAssert(tgt+n <= maxAgents); if (n > 0) memmove(&agents[tgt], &agents[i], sizeof(dtCrowdAgent*)*n); diff --git a/src/thirdparty/recast/DetourCrowd/Source/DetourLocalBoundary.cpp b/src/thirdparty/recast/DetourCrowd/Source/DetourLocalBoundary.cpp index 84ab90b8..5b5b17a3 100644 --- a/src/thirdparty/recast/DetourCrowd/Source/DetourLocalBoundary.cpp +++ b/src/thirdparty/recast/DetourCrowd/Source/DetourLocalBoundary.cpp @@ -21,7 +21,7 @@ #include "DetourCrowd\Include\DetourLocalBoundary.h" #include "Detour\Include\DetourNavMeshQuery.h" #include "Detour\Include\DetourCommon.h" -#include "Detour\Include\DetourAssert.h" +#include "Shared\Include\SharedAssert.h" dtLocalBoundary::dtLocalBoundary() : @@ -68,7 +68,7 @@ void dtLocalBoundary::addSegment(const float dist, const float* s) break; const int tgt = i+1; const int n = dtMin(m_nsegs-i, MAX_LOCAL_SEGS-tgt); - dtAssert(tgt+n <= MAX_LOCAL_SEGS); + rdAssert(tgt+n <= MAX_LOCAL_SEGS); if (n > 0) memmove(&m_segs[tgt], &m_segs[i], sizeof(Segment)*n); seg = &m_segs[i]; diff --git a/src/thirdparty/recast/DetourCrowd/Source/DetourObstacleAvoidance.cpp b/src/thirdparty/recast/DetourCrowd/Source/DetourObstacleAvoidance.cpp index 2fbd310f..c36b4676 100644 --- a/src/thirdparty/recast/DetourCrowd/Source/DetourObstacleAvoidance.cpp +++ b/src/thirdparty/recast/DetourCrowd/Source/DetourObstacleAvoidance.cpp @@ -19,8 +19,8 @@ #include "DetourCrowd\Include\DetourObstacleAvoidance.h" #include "Detour\Include\DetourCommon.h" #include "Detour\Include\DetourMath.h" -#include "Detour\Include\DetourAlloc.h" -#include "Detour\Include\DetourAssert.h" +#include "Shared\Include\SharedAlloc.h" +#include "Shared\Include\SharedAssert.h" #include #include #include @@ -67,18 +67,18 @@ static int isectRaySeg(const float* ap, const float* u, -dtObstacleAvoidanceDebugData* dtAllocObstacleAvoidanceDebugData() +dtObstacleAvoidanceDebugData* rdAllocObstacleAvoidanceDebugData() { - void* mem = dtAlloc(sizeof(dtObstacleAvoidanceDebugData), DT_ALLOC_PERM); + void* mem = rdAlloc(sizeof(dtObstacleAvoidanceDebugData), RD_ALLOC_PERM); if (!mem) return 0; return new(mem) dtObstacleAvoidanceDebugData; } -void dtFreeObstacleAvoidanceDebugData(dtObstacleAvoidanceDebugData* ptr) +void rdFreeObstacleAvoidanceDebugData(dtObstacleAvoidanceDebugData* ptr) { if (!ptr) return; ptr->~dtObstacleAvoidanceDebugData(); - dtFree(ptr); + rdFree(ptr); } @@ -97,39 +97,39 @@ dtObstacleAvoidanceDebugData::dtObstacleAvoidanceDebugData() : dtObstacleAvoidanceDebugData::~dtObstacleAvoidanceDebugData() { - dtFree(m_vel); - dtFree(m_ssize); - dtFree(m_pen); - dtFree(m_vpen); - dtFree(m_vcpen); - dtFree(m_spen); - dtFree(m_tpen); + rdFree(m_vel); + rdFree(m_ssize); + rdFree(m_pen); + rdFree(m_vpen); + rdFree(m_vcpen); + rdFree(m_spen); + rdFree(m_tpen); } bool dtObstacleAvoidanceDebugData::init(const int maxSamples) { - dtAssert(maxSamples); + rdAssert(maxSamples); m_maxSamples = maxSamples; - m_vel = (float*)dtAlloc(sizeof(float)*3*m_maxSamples, DT_ALLOC_PERM); + m_vel = (float*)rdAlloc(sizeof(float)*3*m_maxSamples, RD_ALLOC_PERM); if (!m_vel) return false; - m_pen = (float*)dtAlloc(sizeof(float)*m_maxSamples, DT_ALLOC_PERM); + m_pen = (float*)rdAlloc(sizeof(float)*m_maxSamples, RD_ALLOC_PERM); if (!m_pen) return false; - m_ssize = (float*)dtAlloc(sizeof(float)*m_maxSamples, DT_ALLOC_PERM); + m_ssize = (float*)rdAlloc(sizeof(float)*m_maxSamples, RD_ALLOC_PERM); if (!m_ssize) return false; - m_vpen = (float*)dtAlloc(sizeof(float)*m_maxSamples, DT_ALLOC_PERM); + m_vpen = (float*)rdAlloc(sizeof(float)*m_maxSamples, RD_ALLOC_PERM); if (!m_vpen) return false; - m_vcpen = (float*)dtAlloc(sizeof(float)*m_maxSamples, DT_ALLOC_PERM); + m_vcpen = (float*)rdAlloc(sizeof(float)*m_maxSamples, RD_ALLOC_PERM); if (!m_vcpen) return false; - m_spen = (float*)dtAlloc(sizeof(float)*m_maxSamples, DT_ALLOC_PERM); + m_spen = (float*)rdAlloc(sizeof(float)*m_maxSamples, RD_ALLOC_PERM); if (!m_spen) return false; - m_tpen = (float*)dtAlloc(sizeof(float)*m_maxSamples, DT_ALLOC_PERM); + m_tpen = (float*)rdAlloc(sizeof(float)*m_maxSamples, RD_ALLOC_PERM); if (!m_tpen) return false; @@ -146,13 +146,13 @@ void dtObstacleAvoidanceDebugData::addSample(const float* vel, const float ssize { if (m_nsamples >= m_maxSamples) return; - dtAssert(m_vel); - dtAssert(m_ssize); - dtAssert(m_pen); - dtAssert(m_vpen); - dtAssert(m_vcpen); - dtAssert(m_spen); - dtAssert(m_tpen); + rdAssert(m_vel); + rdAssert(m_ssize); + rdAssert(m_pen); + rdAssert(m_vpen); + rdAssert(m_vcpen); + rdAssert(m_spen); + rdAssert(m_tpen); dtVcopy(&m_vel[m_nsamples*3], vel); m_ssize[m_nsamples] = ssize; m_pen[m_nsamples] = pen; @@ -189,18 +189,18 @@ void dtObstacleAvoidanceDebugData::normalizeSamples() } -dtObstacleAvoidanceQuery* dtAllocObstacleAvoidanceQuery() +dtObstacleAvoidanceQuery* rdAllocObstacleAvoidanceQuery() { - void* mem = dtAlloc(sizeof(dtObstacleAvoidanceQuery), DT_ALLOC_PERM); + void* mem = rdAlloc(sizeof(dtObstacleAvoidanceQuery), RD_ALLOC_PERM); if (!mem) return 0; return new(mem) dtObstacleAvoidanceQuery; } -void dtFreeObstacleAvoidanceQuery(dtObstacleAvoidanceQuery* ptr) +void rdFreeObstacleAvoidanceQuery(dtObstacleAvoidanceQuery* ptr) { if (!ptr) return; ptr->~dtObstacleAvoidanceQuery(); - dtFree(ptr); + rdFree(ptr); } @@ -219,22 +219,22 @@ dtObstacleAvoidanceQuery::dtObstacleAvoidanceQuery() : dtObstacleAvoidanceQuery::~dtObstacleAvoidanceQuery() { - dtFree(m_circles); - dtFree(m_segments); + rdFree(m_circles); + rdFree(m_segments); } bool dtObstacleAvoidanceQuery::init(const int maxCircles, const int maxSegments) { m_maxCircles = maxCircles; m_ncircles = 0; - m_circles = (dtObstacleCircle*)dtAlloc(sizeof(dtObstacleCircle)*m_maxCircles, DT_ALLOC_PERM); + m_circles = (dtObstacleCircle*)rdAlloc(sizeof(dtObstacleCircle)*m_maxCircles, RD_ALLOC_PERM); if (!m_circles) return false; memset(m_circles, 0, sizeof(dtObstacleCircle)*m_maxCircles); m_maxSegments = maxSegments; m_nsegments = 0; - m_segments = (dtObstacleSegment*)dtAlloc(sizeof(dtObstacleSegment)*m_maxSegments, DT_ALLOC_PERM); + m_segments = (dtObstacleSegment*)rdAlloc(sizeof(dtObstacleSegment)*m_maxSegments, RD_ALLOC_PERM); if (!m_segments) return false; memset(m_segments, 0, sizeof(dtObstacleSegment)*m_maxSegments); diff --git a/src/thirdparty/recast/DetourCrowd/Source/DetourPathCorridor.cpp b/src/thirdparty/recast/DetourCrowd/Source/DetourPathCorridor.cpp index b84ff3e7..292f6b92 100644 --- a/src/thirdparty/recast/DetourCrowd/Source/DetourPathCorridor.cpp +++ b/src/thirdparty/recast/DetourCrowd/Source/DetourPathCorridor.cpp @@ -20,8 +20,8 @@ #include "DetourCrowd\Include\DetourPathCorridor.h" #include "Detour\Include\DetourNavMeshQuery.h" #include "Detour\Include\DetourCommon.h" -#include "Detour\Include\DetourAssert.h" -#include "Detour\Include\DetourAlloc.h" +#include "Shared\Include\SharedAssert.h" +#include "Shared\Include\SharedAlloc.h" int dtMergeCorridorStartMoved(dtPolyRef* path, const int npath, const int maxPath, @@ -100,7 +100,7 @@ int dtMergeCorridorEndMoved(dtPolyRef* path, const int npath, const int maxPath, const int ppos = furthestPath+1; const int vpos = furthestVisited+1; const int count = dtMin(nvisited-vpos, maxPath-ppos); - dtAssert(ppos+count <= maxPath); + rdAssert(ppos+count <= maxPath); if (count) memcpy(path+ppos, visited+vpos, sizeof(dtPolyRef)*count); @@ -206,7 +206,7 @@ dtPathCorridor::dtPathCorridor() : dtPathCorridor::~dtPathCorridor() { - dtFree(m_path); + rdFree(m_path); } /// @par @@ -214,8 +214,8 @@ dtPathCorridor::~dtPathCorridor() /// @warning Cannot be called more than once. bool dtPathCorridor::init(const int maxPath) { - dtAssert(!m_path); - m_path = (dtPolyRef*)dtAlloc(sizeof(dtPolyRef)*maxPath, DT_ALLOC_PERM); + rdAssert(!m_path); + m_path = (dtPolyRef*)rdAlloc(sizeof(dtPolyRef)*maxPath, RD_ALLOC_PERM); if (!m_path) return false; m_npath = 0; @@ -229,7 +229,7 @@ bool dtPathCorridor::init(const int maxPath) /// equal to the position. void dtPathCorridor::reset(dtPolyRef ref, const float* pos) { - dtAssert(m_path); + rdAssert(m_path); dtVcopy(m_pos, pos); dtVcopy(m_target, pos); m_path[0] = ref; @@ -252,8 +252,8 @@ int dtPathCorridor::findCorners(float* cornerVerts, unsigned char* cornerFlags, dtPolyRef* cornerPolys, const int maxCorners, dtNavMeshQuery* navquery, const dtQueryFilter* /*filter*/) { - dtAssert(m_path); - dtAssert(m_npath); + rdAssert(m_path); + rdAssert(m_npath); static const float MIN_TARGET_DIST = 0.01f; @@ -310,7 +310,7 @@ This function is not suitable for long distance searches. void dtPathCorridor::optimizePathVisibility(const float* next, const float pathOptimizationRange, dtNavMeshQuery* navquery, const dtQueryFilter* filter) { - dtAssert(m_path); + rdAssert(m_path); // Clamp the ray to max distance. float goal[3]; @@ -352,9 +352,9 @@ the call to match the needs to the agent. */ bool dtPathCorridor::optimizePathTopology(dtNavMeshQuery* navquery, const dtQueryFilter* filter) { - dtAssert(navquery); - dtAssert(filter); - dtAssert(m_path); + rdAssert(navquery); + rdAssert(filter); + rdAssert(m_path); if (m_npath < 3) return false; @@ -381,9 +381,9 @@ bool dtPathCorridor::moveOverOffmeshConnection(dtPolyRef offMeshConRef, dtPolyRe float* startPos, float* endPos, dtNavMeshQuery* navquery) { - dtAssert(navquery); - dtAssert(m_path); - dtAssert(m_npath); + rdAssert(navquery); + rdAssert(m_path); + rdAssert(m_npath); // Advance the path up to and over the off-mesh connection. dtPolyRef prevRef = 0, polyRef = m_path[0]; @@ -409,7 +409,7 @@ bool dtPathCorridor::moveOverOffmeshConnection(dtPolyRef offMeshConRef, dtPolyRe refs[1] = polyRef; const dtNavMesh* nav = navquery->getAttachedNavMesh(); - dtAssert(nav); + rdAssert(nav); dtStatus status = nav->getOffMeshConnectionPolyEndPoints(refs[0], refs[1], startPos, endPos); if (dtStatusSucceed(status)) @@ -438,8 +438,8 @@ or it can't be reached using a local search. */ bool dtPathCorridor::movePosition(const float* npos, dtNavMeshQuery* navquery, const dtQueryFilter* filter) { - dtAssert(m_path); - dtAssert(m_npath); + rdAssert(m_path); + rdAssert(m_npath); // Move along navmesh and update new position. float result[3]; @@ -476,8 +476,8 @@ The resulting target will differ from the desired target if the desired target i */ bool dtPathCorridor::moveTargetPosition(const float* npos, dtNavMeshQuery* navquery, const dtQueryFilter* filter) { - dtAssert(m_path); - dtAssert(m_npath); + rdAssert(m_path); + rdAssert(m_npath); // Move along navmesh and update new position. float result[3]; @@ -510,9 +510,9 @@ bool dtPathCorridor::moveTargetPosition(const float* npos, dtNavMeshQuery* navqu /// @warning The size of the path must not exceed the size of corridor's path buffer set during #init(). void dtPathCorridor::setCorridor(const float* target, const dtPolyRef* path, const int npath) { - dtAssert(m_path); - dtAssert(npath > 0); - dtAssert(npath <= m_maxPath); + rdAssert(m_path); + rdAssert(npath > 0); + rdAssert(npath <= m_maxPath); dtVcopy(m_target, target); memcpy(m_path, path, sizeof(dtPolyRef)*npath); @@ -521,7 +521,7 @@ void dtPathCorridor::setCorridor(const float* target, const dtPolyRef* path, con bool dtPathCorridor::fixPathStart(dtPolyRef safeRef, const float* safePos) { - dtAssert(m_path); + rdAssert(m_path); dtVcopy(m_pos, safePos); if (m_npath < 3 && m_npath > 0) @@ -543,9 +543,9 @@ bool dtPathCorridor::fixPathStart(dtPolyRef safeRef, const float* safePos) bool dtPathCorridor::trimInvalidPath(dtPolyRef safeRef, const float* safePos, dtNavMeshQuery* navquery, const dtQueryFilter* filter) { - dtAssert(navquery); - dtAssert(filter); - dtAssert(m_path); + rdAssert(navquery); + rdAssert(filter); + rdAssert(m_path); // Keep valid path as far as possible. int n = 0; diff --git a/src/thirdparty/recast/DetourCrowd/Source/DetourPathQueue.cpp b/src/thirdparty/recast/DetourCrowd/Source/DetourPathQueue.cpp index 0bd74d1d..08372a7b 100644 --- a/src/thirdparty/recast/DetourCrowd/Source/DetourPathQueue.cpp +++ b/src/thirdparty/recast/DetourCrowd/Source/DetourPathQueue.cpp @@ -20,7 +20,7 @@ #include "DetourCrowd\Include\DetourPathQueue.h" #include "Detour\Include\DetourNavMesh.h" #include "Detour\Include\DetourNavMeshQuery.h" -#include "Detour\Include\DetourAlloc.h" +#include "Shared\Include\SharedAlloc.h" #include "Detour\Include\DetourCommon.h" @@ -41,11 +41,11 @@ dtPathQueue::~dtPathQueue() void dtPathQueue::purge() { - dtFreeNavMeshQuery(m_navquery); + rdFreeNavMeshQuery(m_navquery); m_navquery = 0; for (int i = 0; i < MAX_QUEUE; ++i) { - dtFree(m_queue[i].path); + rdFree(m_queue[i].path); m_queue[i].path = 0; } } @@ -54,7 +54,7 @@ bool dtPathQueue::init(const int maxPathSize, const int maxSearchNodeCount, dtNa { purge(); - m_navquery = dtAllocNavMeshQuery(); + m_navquery = rdAllocNavMeshQuery(); if (!m_navquery) return false; if (dtStatusFailed(m_navquery->init(nav, maxSearchNodeCount))) @@ -64,7 +64,7 @@ bool dtPathQueue::init(const int maxPathSize, const int maxSearchNodeCount, dtNa for (int i = 0; i < MAX_QUEUE; ++i) { m_queue[i].ref = DT_PATHQ_INVALID; - m_queue[i].path = (dtPolyRef*)dtAlloc(sizeof(dtPolyRef)*m_maxPathSize, DT_ALLOC_PERM); + m_queue[i].path = (dtPolyRef*)rdAlloc(sizeof(dtPolyRef)*m_maxPathSize, RD_ALLOC_PERM); if (!m_queue[i].path) return false; } diff --git a/src/thirdparty/recast/DetourCrowd/Source/DetourProximityGrid.cpp b/src/thirdparty/recast/DetourCrowd/Source/DetourProximityGrid.cpp index 13249829..a4f1a00e 100644 --- a/src/thirdparty/recast/DetourCrowd/Source/DetourProximityGrid.cpp +++ b/src/thirdparty/recast/DetourCrowd/Source/DetourProximityGrid.cpp @@ -21,22 +21,22 @@ #include "DetourCrowd\Include\DetourProximityGrid.h" #include "Detour\Include\DetourCommon.h" #include "Detour\Include\DetourMath.h" -#include "Detour\Include\DetourAlloc.h" -#include "Detour\Include\DetourAssert.h" +#include "Shared\Include\SharedAlloc.h" +#include "Shared\Include\SharedAssert.h" -dtProximityGrid* dtAllocProximityGrid() +dtProximityGrid* rdAllocProximityGrid() { - void* mem = dtAlloc(sizeof(dtProximityGrid), DT_ALLOC_PERM); + void* mem = rdAlloc(sizeof(dtProximityGrid), RD_ALLOC_PERM); if (!mem) return 0; return new(mem) dtProximityGrid; } -void dtFreeProximityGrid(dtProximityGrid* ptr) +void rdFreeProximityGrid(dtProximityGrid* ptr) { if (!ptr) return; ptr->~dtProximityGrid(); - dtFree(ptr); + rdFree(ptr); } @@ -59,28 +59,28 @@ dtProximityGrid::dtProximityGrid() : dtProximityGrid::~dtProximityGrid() { - dtFree(m_buckets); - dtFree(m_pool); + rdFree(m_buckets); + rdFree(m_pool); } bool dtProximityGrid::init(const int poolSize, const float cellSize) { - dtAssert(poolSize > 0); - dtAssert(cellSize > 0.0f); + rdAssert(poolSize > 0); + rdAssert(cellSize > 0.0f); m_cellSize = cellSize; m_invCellSize = 1.0f / m_cellSize; // Allocate hashs buckets m_bucketsSize = dtNextPow2(poolSize); - m_buckets = (unsigned short*)dtAlloc(sizeof(unsigned short)*m_bucketsSize, DT_ALLOC_PERM); + m_buckets = (unsigned short*)rdAlloc(sizeof(unsigned short)*m_bucketsSize, RD_ALLOC_PERM); if (!m_buckets) return false; // Allocate pool of items. m_poolSize = poolSize; m_poolHead = 0; - m_pool = (Item*)dtAlloc(sizeof(Item)*m_poolSize, DT_ALLOC_PERM); + m_pool = (Item*)rdAlloc(sizeof(Item)*m_poolSize, RD_ALLOC_PERM); if (!m_pool) return false; diff --git a/src/thirdparty/recast/DetourTileCache/Include/DetourTileCache.h b/src/thirdparty/recast/DetourTileCache/Include/DetourTileCache.h index a5d471e6..b5111fb2 100644 --- a/src/thirdparty/recast/DetourTileCache/Include/DetourTileCache.h +++ b/src/thirdparty/recast/DetourTileCache/Include/DetourTileCache.h @@ -256,7 +256,7 @@ private: int m_nupdate; }; -dtTileCache* dtAllocTileCache(); -void dtFreeTileCache(dtTileCache* tc); +dtTileCache* rdAllocTileCache(); +void rdFreeTileCache(dtTileCache* tc); #endif diff --git a/src/thirdparty/recast/DetourTileCache/Include/DetourTileCacheBuilder.h b/src/thirdparty/recast/DetourTileCache/Include/DetourTileCacheBuilder.h index 673bbd7d..beab1f5b 100644 --- a/src/thirdparty/recast/DetourTileCache/Include/DetourTileCacheBuilder.h +++ b/src/thirdparty/recast/DetourTileCache/Include/DetourTileCacheBuilder.h @@ -19,7 +19,7 @@ #ifndef DETOURTILECACHEBUILDER_H #define DETOURTILECACHEBUILDER_H -#include "Detour/Include/DetourAlloc.h" +#include "Shared/Include/SharedAlloc.h" #include "Detour/Include/DetourStatus.h" static const int DT_TILECACHE_MAGIC = 'D'<<24 | 'T'<<16 | 'L'<<8 | 'R'; ///< 'DTLR'; @@ -84,12 +84,12 @@ struct dtTileCacheAlloc virtual void* alloc(const size_t size) { - return dtAlloc(size, DT_ALLOC_TEMP); + return rdAlloc(size, RD_ALLOC_TEMP); } virtual void free(void* ptr) { - dtFree(ptr); + rdFree(ptr); } }; @@ -112,17 +112,17 @@ dtStatus dtBuildTileCacheLayer(dtTileCacheCompressor* comp, const unsigned char* cons, unsigned char** outData, int* outDataSize); -void dtFreeTileCacheLayer(dtTileCacheAlloc* alloc, dtTileCacheLayer* layer); +void rdFreeTileCacheLayer(dtTileCacheAlloc* alloc, dtTileCacheLayer* layer); dtStatus dtDecompressTileCacheLayer(dtTileCacheAlloc* alloc, dtTileCacheCompressor* comp, unsigned char* compressed, const int compressedSize, dtTileCacheLayer** layerOut); -dtTileCacheContourSet* dtAllocTileCacheContourSet(dtTileCacheAlloc* alloc); -void dtFreeTileCacheContourSet(dtTileCacheAlloc* alloc, dtTileCacheContourSet* cset); +dtTileCacheContourSet* rdAllocTileCacheContourSet(dtTileCacheAlloc* alloc); +void rdFreeTileCacheContourSet(dtTileCacheAlloc* alloc, dtTileCacheContourSet* cset); -dtTileCachePolyMesh* dtAllocTileCachePolyMesh(dtTileCacheAlloc* alloc); -void dtFreeTileCachePolyMesh(dtTileCacheAlloc* alloc, dtTileCachePolyMesh* lmesh); +dtTileCachePolyMesh* rdAllocTileCachePolyMesh(dtTileCacheAlloc* alloc); +void rdFreeTileCachePolyMesh(dtTileCacheAlloc* alloc, dtTileCachePolyMesh* lmesh); dtStatus dtMarkCylinderArea(dtTileCacheLayer& layer, const float* orig, const float cs, const float ch, const float* pos, const float radius, const float height, const unsigned char areaId); diff --git a/src/thirdparty/recast/DetourTileCache/Source/DetourTileCache.cpp b/src/thirdparty/recast/DetourTileCache/Source/DetourTileCache.cpp index 7763fa13..0c965bdb 100644 --- a/src/thirdparty/recast/DetourTileCache/Source/DetourTileCache.cpp +++ b/src/thirdparty/recast/DetourTileCache/Source/DetourTileCache.cpp @@ -4,23 +4,23 @@ #include "Detour/Include/DetourNavMesh.h" #include "Detour/Include/DetourCommon.h" #include "Detour/Include/DetourMath.h" -#include "Detour/Include/DetourAlloc.h" -#include "Detour/Include/DetourAssert.h" +#include "Shared/Include/SharedAlloc.h" +#include "Shared/Include/SharedAssert.h" #include #include -dtTileCache* dtAllocTileCache() +dtTileCache* rdAllocTileCache() { - void* mem = dtAlloc(sizeof(dtTileCache), DT_ALLOC_PERM); + void* mem = rdAlloc(sizeof(dtTileCache), RD_ALLOC_PERM); if (!mem) return 0; return new(mem) dtTileCache; } -void dtFreeTileCache(dtTileCache* tc) +void rdFreeTileCache(dtTileCache* tc) { if (!tc) return; tc->~dtTileCache(); - dtFree(tc); + rdFree(tc); } static bool contains(const dtCompressedTileRef* a, const int n, const dtCompressedTileRef v) @@ -46,11 +46,11 @@ struct NavMeshTileBuildContext inline ~NavMeshTileBuildContext() { purge(); } void purge() { - dtFreeTileCacheLayer(alloc, layer); + rdFreeTileCacheLayer(alloc, layer); layer = 0; - dtFreeTileCacheContourSet(alloc, lcset); + rdFreeTileCacheContourSet(alloc, lcset); lcset = 0; - dtFreeTileCachePolyMesh(alloc, lmesh); + rdFreeTileCachePolyMesh(alloc, lmesh); lmesh = 0; } struct dtTileCacheLayer* layer; @@ -86,15 +86,15 @@ dtTileCache::~dtTileCache() { if (m_tiles[i].flags & DT_COMPRESSEDTILE_FREE_DATA) { - dtFree(m_tiles[i].data); + rdFree(m_tiles[i].data); m_tiles[i].data = 0; } } - dtFree(m_obstacles); + rdFree(m_obstacles); m_obstacles = 0; - dtFree(m_posLookup); + rdFree(m_posLookup); m_posLookup = 0; - dtFree(m_tiles); + rdFree(m_tiles); m_tiles = 0; m_nreqs = 0; m_nupdate = 0; @@ -127,7 +127,7 @@ dtStatus dtTileCache::init(const dtTileCacheParams* params, memcpy(&m_params, params, sizeof(m_params)); // Alloc space for obstacles. - m_obstacles = (dtTileCacheObstacle*)dtAlloc(sizeof(dtTileCacheObstacle)*m_params.maxObstacles, DT_ALLOC_PERM); + m_obstacles = (dtTileCacheObstacle*)rdAlloc(sizeof(dtTileCacheObstacle)*m_params.maxObstacles, RD_ALLOC_PERM); if (!m_obstacles) return DT_FAILURE | DT_OUT_OF_MEMORY; memset(m_obstacles, 0, sizeof(dtTileCacheObstacle)*m_params.maxObstacles); @@ -144,10 +144,10 @@ dtStatus dtTileCache::init(const dtTileCacheParams* params, if (!m_tileLutSize) m_tileLutSize = 1; m_tileLutMask = m_tileLutSize-1; - m_tiles = (dtCompressedTile*)dtAlloc(sizeof(dtCompressedTile)*m_params.maxTiles, DT_ALLOC_PERM); + m_tiles = (dtCompressedTile*)rdAlloc(sizeof(dtCompressedTile)*m_params.maxTiles, RD_ALLOC_PERM); if (!m_tiles) return DT_FAILURE | DT_OUT_OF_MEMORY; - m_posLookup = (dtCompressedTile**)dtAlloc(sizeof(dtCompressedTile*)*m_tileLutSize, DT_ALLOC_PERM); + m_posLookup = (dtCompressedTile**)rdAlloc(sizeof(dtCompressedTile*)*m_tileLutSize, RD_ALLOC_PERM); if (!m_posLookup) return DT_FAILURE | DT_OUT_OF_MEMORY; memset(m_tiles, 0, sizeof(dtCompressedTile)*m_params.maxTiles); @@ -316,7 +316,7 @@ dtStatus dtTileCache::removeTile(dtCompressedTileRef ref, unsigned char** data, if (tile->flags & DT_COMPRESSEDTILE_FREE_DATA) { // Owns data - dtFree(tile->data); + rdFree(tile->data); tile->data = 0; tile->dataSize = 0; if (data) *data = 0; @@ -648,8 +648,8 @@ dtStatus dtTileCache::buildNavMeshTilesAt(const int tx, const int ty, dtNavMesh* dtStatus dtTileCache::buildNavMeshTile(const dtCompressedTileRef ref, dtNavMesh* navmesh) { - dtAssert(m_talloc); - dtAssert(m_tcomp); + rdAssert(m_talloc); + rdAssert(m_tcomp); unsigned int idx = decodeTileIdTile(ref); if (idx > (unsigned int)m_params.maxTiles) @@ -701,7 +701,7 @@ dtStatus dtTileCache::buildNavMeshTile(const dtCompressedTileRef ref, dtNavMesh* if (dtStatusFailed(status)) return status; - bc.lcset = dtAllocTileCacheContourSet(m_talloc); + bc.lcset = rdAllocTileCacheContourSet(m_talloc); if (!bc.lcset) return DT_FAILURE | DT_OUT_OF_MEMORY; status = dtBuildTileCacheContours(m_talloc, *bc.layer, walkableClimbVx, @@ -709,7 +709,7 @@ dtStatus dtTileCache::buildNavMeshTile(const dtCompressedTileRef ref, dtNavMesh* if (dtStatusFailed(status)) return status; - bc.lmesh = dtAllocTileCachePolyMesh(m_talloc); + bc.lmesh = rdAllocTileCachePolyMesh(m_talloc); if (!bc.lmesh) return DT_FAILURE | DT_OUT_OF_MEMORY; status = dtBuildTileCachePolyMesh(m_talloc, *bc.lcset, *bc.lmesh); @@ -765,7 +765,7 @@ dtStatus dtTileCache::buildNavMeshTile(const dtCompressedTileRef ref, dtNavMesh* status = navmesh->addTile(navData,navDataSize,DT_TILE_FREE_DATA,0,0); if (dtStatusFailed(status)) { - dtFree(navData); + rdFree(navData); return status; } } diff --git a/src/thirdparty/recast/DetourTileCache/Source/DetourTileCacheBuilder.cpp b/src/thirdparty/recast/DetourTileCache/Source/DetourTileCacheBuilder.cpp index d6347805..942499a7 100644 --- a/src/thirdparty/recast/DetourTileCache/Source/DetourTileCacheBuilder.cpp +++ b/src/thirdparty/recast/DetourTileCache/Source/DetourTileCacheBuilder.cpp @@ -19,7 +19,7 @@ #include "Detour/Include/DetourCommon.h" #include "Detour/Include/DetourMath.h" #include "Detour/Include/DetourStatus.h" -#include "Detour/Include/DetourAssert.h" +#include "Shared/Include/SharedAssert.h" #include "DetourTileCache/Include/DetourTileCacheBuilder.h" #include @@ -54,18 +54,18 @@ static const int MAX_REM_EDGES = 48; // TODO: make this an expression. -dtTileCacheContourSet* dtAllocTileCacheContourSet(dtTileCacheAlloc* alloc) +dtTileCacheContourSet* rdAllocTileCacheContourSet(dtTileCacheAlloc* alloc) { - dtAssert(alloc); + rdAssert(alloc); dtTileCacheContourSet* cset = (dtTileCacheContourSet*)alloc->alloc(sizeof(dtTileCacheContourSet)); memset(cset, 0, sizeof(dtTileCacheContourSet)); return cset; } -void dtFreeTileCacheContourSet(dtTileCacheAlloc* alloc, dtTileCacheContourSet* cset) +void rdFreeTileCacheContourSet(dtTileCacheAlloc* alloc, dtTileCacheContourSet* cset) { - dtAssert(alloc); + rdAssert(alloc); if (!cset) return; for (int i = 0; i < cset->nconts; ++i) @@ -74,18 +74,18 @@ void dtFreeTileCacheContourSet(dtTileCacheAlloc* alloc, dtTileCacheContourSet* c alloc->free(cset); } -dtTileCachePolyMesh* dtAllocTileCachePolyMesh(dtTileCacheAlloc* alloc) +dtTileCachePolyMesh* rdAllocTileCachePolyMesh(dtTileCacheAlloc* alloc) { - dtAssert(alloc); + rdAssert(alloc); dtTileCachePolyMesh* lmesh = (dtTileCachePolyMesh*)alloc->alloc(sizeof(dtTileCachePolyMesh)); memset(lmesh, 0, sizeof(dtTileCachePolyMesh)); return lmesh; } -void dtFreeTileCachePolyMesh(dtTileCacheAlloc* alloc, dtTileCachePolyMesh* lmesh) +void rdFreeTileCachePolyMesh(dtTileCacheAlloc* alloc, dtTileCachePolyMesh* lmesh) { - dtAssert(alloc); + rdAssert(alloc); if (!lmesh) return; alloc->free(lmesh->verts); @@ -178,7 +178,7 @@ dtStatus dtBuildTileCacheRegions(dtTileCacheAlloc* alloc, dtTileCacheLayer& layer, const int walkableClimb) { - dtAssert(alloc); + rdAssert(alloc); const int w = (int)layer.header->width; const int h = (int)layer.header->height; @@ -741,7 +741,7 @@ dtStatus dtBuildTileCacheContours(dtTileCacheAlloc* alloc, const int walkableClimb, const float maxError, dtTileCacheContourSet& lcset) { - dtAssert(alloc); + rdAssert(alloc); const int w = (int)layer.header->width; const int h = (int)layer.header->height; @@ -1741,7 +1741,7 @@ dtStatus dtBuildTileCachePolyMesh(dtTileCacheAlloc* alloc, dtTileCacheContourSet& lcset, dtTileCachePolyMesh& mesh) { - dtAssert(alloc); + rdAssert(alloc); int maxVertices = 0; int maxTris = 0; @@ -2104,7 +2104,7 @@ dtStatus dtBuildTileCacheLayer(dtTileCacheCompressor* comp, const int headerSize = dtAlign4(sizeof(dtTileCacheLayerHeader)); const int gridSize = (int)header->width * (int)header->height; const int maxDataSize = headerSize + comp->maxCompressedSize(gridSize*3); - unsigned char* data = (unsigned char*)dtAlloc(maxDataSize, DT_ALLOC_PERM); + unsigned char* data = (unsigned char*)rdAlloc(maxDataSize, RD_ALLOC_PERM); if (!data) return DT_FAILURE | DT_OUT_OF_MEMORY; memset(data, 0, maxDataSize); @@ -2114,10 +2114,10 @@ dtStatus dtBuildTileCacheLayer(dtTileCacheCompressor* comp, // Concatenate grid data for compression. const int bufferSize = gridSize*3; - unsigned char* buffer = (unsigned char*)dtAlloc(bufferSize, DT_ALLOC_TEMP); + unsigned char* buffer = (unsigned char*)rdAlloc(bufferSize, RD_ALLOC_TEMP); if (!buffer) { - dtFree(data); + rdFree(data); return DT_FAILURE | DT_OUT_OF_MEMORY; } @@ -2132,22 +2132,22 @@ dtStatus dtBuildTileCacheLayer(dtTileCacheCompressor* comp, dtStatus status = comp->compress(buffer, bufferSize, compressed, maxCompressedSize, &compressedSize); if (dtStatusFailed(status)) { - dtFree(buffer); - dtFree(data); + rdFree(buffer); + rdFree(data); return status; } *outData = data; *outDataSize = headerSize + compressedSize; - dtFree(buffer); + rdFree(buffer); return DT_SUCCESS; } -void dtFreeTileCacheLayer(dtTileCacheAlloc* alloc, dtTileCacheLayer* layer) +void rdFreeTileCacheLayer(dtTileCacheAlloc* alloc, dtTileCacheLayer* layer) { - dtAssert(alloc); + rdAssert(alloc); // The layer is allocated as one conitguous blob of data. alloc->free(layer); } @@ -2156,8 +2156,8 @@ dtStatus dtDecompressTileCacheLayer(dtTileCacheAlloc* alloc, dtTileCacheCompress unsigned char* compressed, const int compressedSize, dtTileCacheLayer** layerOut) { - dtAssert(alloc); - dtAssert(comp); + rdAssert(alloc); + rdAssert(comp); if (!layerOut) return DT_FAILURE | DT_INVALID_PARAM; diff --git a/src/thirdparty/recast/Recast/Include/Recast.h b/src/thirdparty/recast/Recast/Include/Recast.h index 749e530f..e1ebea1e 100644 --- a/src/thirdparty/recast/Recast/Include/Recast.h +++ b/src/thirdparty/recast/Recast/Include/Recast.h @@ -399,7 +399,7 @@ struct rcHeightfieldLayer /// Represents a set of heightfield layers. /// @ingroup recast -/// @see rcAllocHeightfieldLayerSet, rcFreeHeightfieldLayerSet +/// @see rdAllocHeightfieldLayerSet, rdFreeHeightfieldLayerSet struct rcHeightfieldLayerSet { rcHeightfieldLayerSet(); @@ -500,80 +500,80 @@ private: /// @name Allocation Functions /// Functions used to allocate and de-allocate Recast objects. -/// @see rcAllocSetCustom +/// @see rdAllocSetCustom /// @{ /// Allocates a heightfield object using the Recast allocator. /// @return A heightfield that is ready for initialization, or null on failure. /// @ingroup recast -/// @see rcCreateHeightfield, rcFreeHeightField -rcHeightfield* rcAllocHeightfield(); +/// @see rcCreateHeightfield, rdFreeHeightField +rcHeightfield* rdAllocHeightfield(); /// Frees the specified heightfield object using the Recast allocator. -/// @param[in] heightfield A heightfield allocated using #rcAllocHeightfield +/// @param[in] heightfield A heightfield allocated using #rdAllocHeightfield /// @ingroup recast -/// @see rcAllocHeightfield -void rcFreeHeightField(rcHeightfield* heightfield); +/// @see rdAllocHeightfield +void rdFreeHeightField(rcHeightfield* heightfield); /// Allocates a compact heightfield object using the Recast allocator. /// @return A compact heightfield that is ready for initialization, or null on failure. /// @ingroup recast -/// @see rcBuildCompactHeightfield, rcFreeCompactHeightfield -rcCompactHeightfield* rcAllocCompactHeightfield(); +/// @see rcBuildCompactHeightfield, rdFreeCompactHeightfield +rcCompactHeightfield* rdAllocCompactHeightfield(); /// Frees the specified compact heightfield object using the Recast allocator. -/// @param[in] compactHeightfield A compact heightfield allocated using #rcAllocCompactHeightfield +/// @param[in] compactHeightfield A compact heightfield allocated using #rdAllocCompactHeightfield /// @ingroup recast -/// @see rcAllocCompactHeightfield -void rcFreeCompactHeightfield(rcCompactHeightfield* compactHeightfield); +/// @see rdAllocCompactHeightfield +void rdFreeCompactHeightfield(rcCompactHeightfield* compactHeightfield); /// Allocates a heightfield layer set using the Recast allocator. /// @return A heightfield layer set that is ready for initialization, or null on failure. /// @ingroup recast -/// @see rcBuildHeightfieldLayers, rcFreeHeightfieldLayerSet -rcHeightfieldLayerSet* rcAllocHeightfieldLayerSet(); +/// @see rcBuildHeightfieldLayers, rdFreeHeightfieldLayerSet +rcHeightfieldLayerSet* rdAllocHeightfieldLayerSet(); /// Frees the specified heightfield layer set using the Recast allocator. -/// @param[in] layerSet A heightfield layer set allocated using #rcAllocHeightfieldLayerSet +/// @param[in] layerSet A heightfield layer set allocated using #rdAllocHeightfieldLayerSet /// @ingroup recast -/// @see rcAllocHeightfieldLayerSet -void rcFreeHeightfieldLayerSet(rcHeightfieldLayerSet* layerSet); +/// @see rdAllocHeightfieldLayerSet +void rdFreeHeightfieldLayerSet(rcHeightfieldLayerSet* layerSet); /// Allocates a contour set object using the Recast allocator. /// @return A contour set that is ready for initialization, or null on failure. /// @ingroup recast -/// @see rcBuildContours, rcFreeContourSet -rcContourSet* rcAllocContourSet(); +/// @see rcBuildContours, rdFreeContourSet +rcContourSet* rdAllocContourSet(); /// Frees the specified contour set using the Recast allocator. -/// @param[in] contourSet A contour set allocated using #rcAllocContourSet +/// @param[in] contourSet A contour set allocated using #rdAllocContourSet /// @ingroup recast -/// @see rcAllocContourSet -void rcFreeContourSet(rcContourSet* contourSet); +/// @see rdAllocContourSet +void rdFreeContourSet(rcContourSet* contourSet); /// Allocates a polygon mesh object using the Recast allocator. /// @return A polygon mesh that is ready for initialization, or null on failure. /// @ingroup recast -/// @see rcBuildPolyMesh, rcFreePolyMesh -rcPolyMesh* rcAllocPolyMesh(); +/// @see rcBuildPolyMesh, rdFreePolyMesh +rcPolyMesh* rdAllocPolyMesh(); /// Frees the specified polygon mesh using the Recast allocator. -/// @param[in] polyMesh A polygon mesh allocated using #rcAllocPolyMesh +/// @param[in] polyMesh A polygon mesh allocated using #rdAllocPolyMesh /// @ingroup recast -/// @see rcAllocPolyMesh -void rcFreePolyMesh(rcPolyMesh* polyMesh); +/// @see rdAllocPolyMesh +void rdFreePolyMesh(rcPolyMesh* polyMesh); /// Allocates a detail mesh object using the Recast allocator. /// @return A detail mesh that is ready for initialization, or null on failure. /// @ingroup recast -/// @see rcBuildPolyMeshDetail, rcFreePolyMeshDetail -rcPolyMeshDetail* rcAllocPolyMeshDetail(); +/// @see rcBuildPolyMeshDetail, rdFreePolyMeshDetail +rcPolyMeshDetail* rdAllocPolyMeshDetail(); /// Frees the specified detail mesh using the Recast allocator. -/// @param[in] detailMesh A detail mesh allocated using #rcAllocPolyMeshDetail +/// @param[in] detailMesh A detail mesh allocated using #rdAllocPolyMeshDetail /// @ingroup recast -/// @see rcAllocPolyMeshDetail -void rcFreePolyMeshDetail(rcPolyMeshDetail* detailMesh); +/// @see rdAllocPolyMeshDetail +void rdFreePolyMeshDetail(rcPolyMeshDetail* detailMesh); /// @} @@ -843,7 +843,7 @@ void rcCalcGridSize(const float* minBounds, const float* maxBounds, float cellSi /// Initializes a new heightfield. /// See the #rcConfig documentation for more information on the configuration parameters. /// -/// @see rcAllocHeightfield, rcHeightfield +/// @see rdAllocHeightfield, rcHeightfield /// @ingroup recast /// /// @param[in,out] context The build context to use during the operation. @@ -1081,7 +1081,7 @@ int rcGetHeightFieldSpanCount(rcContext* context, const rcHeightfield& heightfie /// /// See the #rcConfig documentation for more information on the configuration parameters. /// -/// @see rcAllocCompactHeightfield, rcHeightfield, rcCompactHeightfield, rcConfig +/// @see rdAllocCompactHeightfield, rcHeightfield, rcCompactHeightfield, rcConfig /// @ingroup recast /// /// @param[in,out] context The build context to use during the operation. diff --git a/src/thirdparty/recast/Recast/Include/RecastAssert.h b/src/thirdparty/recast/Recast/Include/RecastAssert.h deleted file mode 100644 index 617a4b75..00000000 --- a/src/thirdparty/recast/Recast/Include/RecastAssert.h +++ /dev/null @@ -1,53 +0,0 @@ -// -// 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 RECASTASSERT_H -#define RECASTASSERT_H - -#ifdef NDEBUG - -// From http://cnicholson.net/2009/02/stupid-c-tricks-adventures-in-assert/ -# define rcAssert(x) do { (void)sizeof(x); } while ((void)(__LINE__==-1), false) - -#else - -/// An assertion failure function. -// @param[in] expression asserted expression. -// @param[in] file Filename of the failed assertion. -// @param[in] line Line number of the failed assertion. -/// @see rcAssertFailSetCustom -typedef void (rcAssertFailFunc)(const char* expression, const char* file, int line); - -/// Sets the base custom assertion failure function to be used by Recast. -/// @param[in] assertFailFunc The function to be used in case of failure of #dtAssert -void rcAssertFailSetCustom(rcAssertFailFunc* assertFailFunc); - -/// Gets the base custom assertion failure function to be used by Recast. -rcAssertFailFunc* rcAssertFailGetCustom(); - -# include -# define rcAssert(expression) \ - { \ - rcAssertFailFunc* failFunc = rcAssertFailGetCustom(); \ - if (failFunc == NULL) { assert(expression); } \ - else if (!(expression)) { (*failFunc)(#expression, __FILE__, __LINE__); } \ - } - -#endif - -#endif // RECASTASSERT_H diff --git a/src/thirdparty/recast/Recast/Source/Recast.cpp b/src/thirdparty/recast/Recast/Source/Recast.cpp index 85d5c08f..a74e5e40 100644 --- a/src/thirdparty/recast/Recast/Source/Recast.cpp +++ b/src/thirdparty/recast/Recast/Source/Recast.cpp @@ -17,8 +17,8 @@ // #include "Recast/Include/Recast.h" -#include "Recast/Include/RecastAlloc.h" -#include "Recast/Include/RecastAssert.h" +#include "Shared/Include/SharedAlloc.h" +#include "Shared/Include/SharedAssert.h" #include #include @@ -30,10 +30,10 @@ namespace /// Allocates and constructs an object of the given type, returning a pointer. /// @param[in] allocLifetime Allocation lifetime hint template -T* rcNew(const rcAllocHint allocLifetime) +T* rcNew(const rdAllocHint allocLifetime) { - T* ptr = (T*)rcAlloc(sizeof(T), allocLifetime); - ::new(rcNewTag(), (void*)ptr) T(); + T* ptr = (T*)rdAlloc(sizeof(T), allocLifetime); + ::new(rdNewTag(), (void*)ptr) T(); return ptr; } @@ -45,7 +45,7 @@ void rcDelete(T* ptr) if (ptr) { ptr->~T(); - rcFree((void*)ptr); + rdFree((void*)ptr); } } } // anonymous namespace @@ -83,12 +83,12 @@ void rcContext::doResetLog() // Defined out of line to fix the weak v-tables warning } -rcHeightfield* rcAllocHeightfield() +rcHeightfield* rdAllocHeightfield() { - return rcNew(RC_ALLOC_PERM); + return rcNew(RD_ALLOC_PERM); } -void rcFreeHeightField(rcHeightfield* heightfield) +void rdFreeHeightField(rcHeightfield* heightfield) { rcDelete(heightfield); } @@ -109,22 +109,22 @@ rcHeightfield::rcHeightfield() rcHeightfield::~rcHeightfield() { // Delete span array. - rcFree(spans); + rdFree(spans); // Delete span pools. while (pools) { rcSpanPool* next = pools->next; - rcFree(pools); + rdFree(pools); pools = next; } } -rcCompactHeightfield* rcAllocCompactHeightfield() +rcCompactHeightfield* rdAllocCompactHeightfield() { - return rcNew(RC_ALLOC_PERM); + return rcNew(RD_ALLOC_PERM); } -void rcFreeCompactHeightfield(rcCompactHeightfield* compactHeightfield) +void rdFreeCompactHeightfield(rcCompactHeightfield* compactHeightfield) { rcDelete(compactHeightfield); } @@ -151,18 +151,18 @@ rcCompactHeightfield::rcCompactHeightfield() rcCompactHeightfield::~rcCompactHeightfield() { - rcFree(cells); - rcFree(spans); - rcFree(dist); - rcFree(areas); + rdFree(cells); + rdFree(spans); + rdFree(dist); + rdFree(areas); } -rcHeightfieldLayerSet* rcAllocHeightfieldLayerSet() +rcHeightfieldLayerSet* rdAllocHeightfieldLayerSet() { - return rcNew(RC_ALLOC_PERM); + return rcNew(RD_ALLOC_PERM); } -void rcFreeHeightfieldLayerSet(rcHeightfieldLayerSet* layerSet) +void rdFreeHeightfieldLayerSet(rcHeightfieldLayerSet* layerSet) { rcDelete(layerSet); } @@ -177,20 +177,20 @@ rcHeightfieldLayerSet::~rcHeightfieldLayerSet() { for (int i = 0; i < nlayers; ++i) { - rcFree(layers[i].heights); - rcFree(layers[i].areas); - rcFree(layers[i].cons); + rdFree(layers[i].heights); + rdFree(layers[i].areas); + rdFree(layers[i].cons); } - rcFree(layers); + rdFree(layers); } -rcContourSet* rcAllocContourSet() +rcContourSet* rdAllocContourSet() { - return rcNew(RC_ALLOC_PERM); + return rcNew(RD_ALLOC_PERM); } -void rcFreeContourSet(rcContourSet* contourSet) +void rdFreeContourSet(rcContourSet* contourSet) { rcDelete(contourSet); } @@ -213,18 +213,18 @@ rcContourSet::~rcContourSet() { for (int i = 0; i < nconts; ++i) { - rcFree(conts[i].verts); - rcFree(conts[i].rverts); + rdFree(conts[i].verts); + rdFree(conts[i].rverts); } - rcFree(conts); + rdFree(conts); } -rcPolyMesh* rcAllocPolyMesh() +rcPolyMesh* rdAllocPolyMesh() { - return rcNew(RC_ALLOC_PERM); + return rcNew(RD_ALLOC_PERM); } -void rcFreePolyMesh(rcPolyMesh* polyMesh) +void rdFreePolyMesh(rcPolyMesh* polyMesh) { rcDelete(polyMesh); } @@ -250,28 +250,28 @@ rcPolyMesh::rcPolyMesh() rcPolyMesh::~rcPolyMesh() { - rcFree(verts); - rcFree(polys); - rcFree(regs); - rcFree(flags); - rcFree(areas); + rdFree(verts); + rdFree(polys); + rdFree(regs); + rdFree(flags); + rdFree(areas); } -rcPolyMeshDetail* rcAllocPolyMeshDetail() +rcPolyMeshDetail* rdAllocPolyMeshDetail() { - return rcNew(RC_ALLOC_PERM); + return rcNew(RD_ALLOC_PERM); } -void rcFreePolyMeshDetail(rcPolyMeshDetail* detailMesh) +void rdFreePolyMeshDetail(rcPolyMeshDetail* detailMesh) { if (detailMesh == NULL) { return; } - rcFree(detailMesh->meshes); - rcFree(detailMesh->verts); - rcFree(detailMesh->tris); - rcFree(detailMesh); + rdFree(detailMesh->meshes); + rdFree(detailMesh->verts); + rdFree(detailMesh->tris); + rdFree(detailMesh); } rcPolyMeshDetail::rcPolyMeshDetail() @@ -315,7 +315,7 @@ bool rcCreateHeightfield(rcContext* context, rcHeightfield& heightfield, int siz rcVcopy(heightfield.bmax, maxBounds); heightfield.cs = cellSize; heightfield.ch = cellHeight; - heightfield.spans = (rcSpan**)rcAlloc(sizeof(rcSpan*) * heightfield.width * heightfield.height, RC_ALLOC_PERM); + heightfield.spans = (rcSpan**)rdAlloc(sizeof(rcSpan*) * heightfield.width * heightfield.height, RD_ALLOC_PERM); if (!heightfield.spans) { return false; @@ -403,7 +403,7 @@ int rcGetHeightFieldSpanCount(rcContext* context, const rcHeightfield& heightfie bool rcBuildCompactHeightfield(rcContext* context, const int walkableHeight, const int walkableClimb, const rcHeightfield& heightfield, rcCompactHeightfield& compactHeightfield) { - rcAssert(context); + rdAssert(context); rcScopedTimer timer(context, RC_TIMER_BUILD_COMPACTHEIGHTFIELD); @@ -423,21 +423,21 @@ bool rcBuildCompactHeightfield(rcContext* context, const int walkableHeight, con compactHeightfield.bmax[2] += walkableHeight * heightfield.ch; compactHeightfield.cs = heightfield.cs; compactHeightfield.ch = heightfield.ch; - compactHeightfield.cells = (rcCompactCell*)rcAlloc(sizeof(rcCompactCell) * xSize * ySize, RC_ALLOC_PERM); + compactHeightfield.cells = (rcCompactCell*)rdAlloc(sizeof(rcCompactCell) * xSize * ySize, RD_ALLOC_PERM); if (!compactHeightfield.cells) { context->log(RC_LOG_ERROR, "rcBuildCompactHeightfield: Out of memory 'chf.cells' (%d)", xSize * ySize); return false; } memset(compactHeightfield.cells, 0, sizeof(rcCompactCell) * xSize * ySize); - compactHeightfield.spans = (rcCompactSpan*)rcAlloc(sizeof(rcCompactSpan) * spanCount, RC_ALLOC_PERM); + compactHeightfield.spans = (rcCompactSpan*)rdAlloc(sizeof(rcCompactSpan) * spanCount, RD_ALLOC_PERM); if (!compactHeightfield.spans) { context->log(RC_LOG_ERROR, "rcBuildCompactHeightfield: Out of memory 'chf.spans' (%d)", spanCount); return false; } memset(compactHeightfield.spans, 0, sizeof(rcCompactSpan) * spanCount); - compactHeightfield.areas = (unsigned char*)rcAlloc(sizeof(unsigned char) * spanCount, RC_ALLOC_PERM); + compactHeightfield.areas = (unsigned char*)rdAlloc(sizeof(unsigned char) * spanCount, RD_ALLOC_PERM); if (!compactHeightfield.areas) { context->log(RC_LOG_ERROR, "rcBuildCompactHeightfield: Out of memory 'chf.areas' (%d)", spanCount); diff --git a/src/thirdparty/recast/Recast/Source/RecastAlloc.cpp b/src/thirdparty/recast/Recast/Source/RecastAlloc.cpp index 6c7a3197..592243ae 100644 --- a/src/thirdparty/recast/Recast/Source/RecastAlloc.cpp +++ b/src/thirdparty/recast/Recast/Source/RecastAlloc.cpp @@ -16,33 +16,33 @@ // 3. This notice may not be removed or altered from any source distribution. // -#include "Recast/Include/RecastAlloc.h" +#include "Shared/Include/SharedAlloc.h" -static void* rcAllocDefault(size_t size, rcAllocHint) +static void* rdAllocDefault(size_t size, rdAllocHint) { return malloc(size); } -static void rcFreeDefault(void *ptr) +static void rdFreeDefault(void *ptr) { free(ptr); } -static rcAllocFunc* sRecastAllocFunc = rcAllocDefault; -static rcFreeFunc* sRecastFreeFunc = rcFreeDefault; +static rdAllocFunc* sRecastAllocFunc = rdAllocDefault; +static rdFreeFunc* sRecastFreeFunc = rdFreeDefault; -void rcAllocSetCustom(rcAllocFunc* allocFunc, rcFreeFunc* freeFunc) +void rdAllocSetCustom(rdAllocFunc* allocFunc, rdFreeFunc* freeFunc) { - sRecastAllocFunc = allocFunc ? allocFunc : rcAllocDefault; - sRecastFreeFunc = freeFunc ? freeFunc : rcFreeDefault; + sRecastAllocFunc = allocFunc ? allocFunc : rdAllocDefault; + sRecastFreeFunc = freeFunc ? freeFunc : rdFreeDefault; } -void* rcAlloc(size_t size, rcAllocHint hint) +void* rdAlloc(size_t size, rdAllocHint hint) { return sRecastAllocFunc(size, hint); } -void rcFree(void* ptr) +void rdFree(void* ptr) { if (ptr != NULL) { diff --git a/src/thirdparty/recast/Recast/Source/RecastArea.cpp b/src/thirdparty/recast/Recast/Source/RecastArea.cpp index 8c898570..72a0ba20 100644 --- a/src/thirdparty/recast/Recast/Source/RecastArea.cpp +++ b/src/thirdparty/recast/Recast/Source/RecastArea.cpp @@ -23,8 +23,8 @@ #include #include #include "Recast/Include/Recast.h" -#include "Recast/Include/RecastAlloc.h" -#include "Recast/Include/RecastAssert.h" +#include "Shared/Include/SharedAlloc.h" +#include "Shared/Include/SharedAssert.h" /// @par /// @@ -36,14 +36,14 @@ /// @see rcCompactHeightfield, rcBuildCompactHeightfield, rcConfig::walkableRadius bool rcErodeWalkableArea(rcContext* ctx, int radius, rcCompactHeightfield& chf) { - rcAssert(ctx); + rdAssert(ctx); const int w = chf.width; const int h = chf.height; rcScopedTimer timer(ctx, RC_TIMER_ERODE_AREA); - unsigned char* dist = (unsigned char*)rcAlloc(sizeof(unsigned char)*chf.spanCount, RC_ALLOC_TEMP); + unsigned char* dist = (unsigned char*)rdAlloc(sizeof(unsigned char)*chf.spanCount, RD_ALLOC_TEMP); if (!dist) { ctx->log(RC_LOG_ERROR, "erodeWalkableArea: Out of memory 'dist' (%d).", chf.spanCount); @@ -213,7 +213,7 @@ bool rcErodeWalkableArea(rcContext* ctx, int radius, rcCompactHeightfield& chf) if (dist[i] < thr) chf.areas[i] = RC_NULL_AREA; - rcFree(dist); + rdFree(dist); return true; } @@ -238,14 +238,14 @@ static void insertSort(unsigned char* a, const int n) /// @see rcCompactHeightfield bool rcMedianFilterWalkableArea(rcContext* ctx, rcCompactHeightfield& chf) { - rcAssert(ctx); + rdAssert(ctx); const int w = chf.width; const int h = chf.height; rcScopedTimer timer(ctx, RC_TIMER_MEDIAN_AREA); - unsigned char* areas = (unsigned char*)rcAlloc(sizeof(unsigned char)*chf.spanCount, RC_ALLOC_TEMP); + unsigned char* areas = (unsigned char*)rdAlloc(sizeof(unsigned char)*chf.spanCount, RD_ALLOC_TEMP); if (!areas) { ctx->log(RC_LOG_ERROR, "medianFilterWalkableArea: Out of memory 'areas' (%d).", chf.spanCount); @@ -303,7 +303,7 @@ bool rcMedianFilterWalkableArea(rcContext* ctx, rcCompactHeightfield& chf) memcpy(chf.areas, areas, sizeof(unsigned char)*chf.spanCount); - rcFree(areas); + rdFree(areas); return true; } @@ -316,7 +316,7 @@ bool rcMedianFilterWalkableArea(rcContext* ctx, rcCompactHeightfield& chf) void rcMarkBoxArea(rcContext* ctx, const float* bmin, const float* bmax, unsigned char areaId, rcCompactHeightfield& chf) { - rcAssert(ctx); + rdAssert(ctx); rcScopedTimer timer(ctx, RC_TIMER_MARK_BOX_AREA); @@ -382,7 +382,7 @@ void rcMarkConvexPolyArea(rcContext* ctx, const float* verts, const int nverts, const float hmin, const float hmax, unsigned char areaId, rcCompactHeightfield& chf) { - rcAssert(ctx); + rdAssert(ctx); rcScopedTimer timer(ctx, RC_TIMER_MARK_CONVEXPOLY_AREA); @@ -530,7 +530,7 @@ void rcMarkCylinderArea(rcContext* ctx, const float* pos, const float r, const float h, unsigned char areaId, rcCompactHeightfield& chf) { - rcAssert(ctx); + rdAssert(ctx); rcScopedTimer timer(ctx, RC_TIMER_MARK_CYLINDER_AREA); diff --git a/src/thirdparty/recast/Recast/Source/RecastAssert.cpp b/src/thirdparty/recast/Recast/Source/RecastAssert.cpp index 0ecbc08d..8044763c 100644 --- a/src/thirdparty/recast/Recast/Source/RecastAssert.cpp +++ b/src/thirdparty/recast/Recast/Source/RecastAssert.cpp @@ -16,18 +16,18 @@ // 3. This notice may not be removed or altered from any source distribution. // -#include "Recast/Include/RecastAssert.h" +#include "Shared/Include/SharedAssert.h" #ifndef NDEBUG -static rcAssertFailFunc* sRecastAssertFailFunc = 0; +static rdAssertFailFunc* sRecastAssertFailFunc = 0; -void rcAssertFailSetCustom(rcAssertFailFunc *assertFailFunc) +void rdAssertFailSetCustom(rdAssertFailFunc *assertFailFunc) { sRecastAssertFailFunc = assertFailFunc; } -rcAssertFailFunc* rcAssertFailGetCustom() +rdAssertFailFunc* rdAssertFailGetCustom() { return sRecastAssertFailFunc; } diff --git a/src/thirdparty/recast/Recast/Source/RecastContour.cpp b/src/thirdparty/recast/Recast/Source/RecastContour.cpp index 0c59c440..02a0beeb 100644 --- a/src/thirdparty/recast/Recast/Source/RecastContour.cpp +++ b/src/thirdparty/recast/Recast/Source/RecastContour.cpp @@ -21,8 +21,8 @@ #include #include #include "Recast/Include/Recast.h" -#include "Recast/Include/RecastAlloc.h" -#include "Recast/Include/RecastAssert.h" +#include "Shared/Include/SharedAlloc.h" +#include "Shared/Include/SharedAssert.h" static int getCornerHeight(int x, int y, int i, int dir, @@ -102,7 +102,7 @@ static int getCornerHeight(int x, int y, int i, int dir, static void walkContour(int x, int y, int i, const rcCompactHeightfield& chf, - unsigned char* flags, rcIntArray& points) + unsigned char* flags, rdIntArray& points) { // Choose the first non-connected edge unsigned char dir = 0; @@ -206,7 +206,7 @@ static float distancePtSeg(const int x, const int y, return dx*dx + dy*dy; } -static void simplifyContour(rcIntArray& points, rcIntArray& simplified, +static void simplifyContour(rdIntArray& points, rdIntArray& simplified, const float maxError, const int maxEdgeLen, const int buildFlags) { // Add initial points. @@ -576,7 +576,7 @@ static bool inCone(int i, int n, const int* verts, const int* pj) } -static void removeDegenerateSegments(rcIntArray& simplified) +static void removeDegenerateSegments(rdIntArray& simplified) { // Remove adjacent vertices which are equal on xy-plane, // or else the triangulator will get confused. @@ -605,7 +605,7 @@ static void removeDegenerateSegments(rcIntArray& simplified) static bool mergeContours(rcContour& ca, rcContour& cb, int ia, int ib) { const int maxVerts = ca.nverts + cb.nverts + 2; - int* verts = (int*)rcAlloc(sizeof(int)*maxVerts*4, RC_ALLOC_PERM); + int* verts = (int*)rdAlloc(sizeof(int)*maxVerts*4, RD_ALLOC_PERM); if (!verts) return false; @@ -635,11 +635,11 @@ static bool mergeContours(rcContour& ca, rcContour& cb, int ia, int ib) nv++; } - rcFree(ca.verts); + rdFree(ca.verts); ca.verts = verts; ca.nverts = nv; - rcFree(cb.verts); + rdFree(cb.verts); cb.verts = 0; cb.nverts = 0; @@ -730,7 +730,7 @@ static void mergeRegionHoles(rcContext* ctx, rcContourRegion& region) for (int i = 0; i < region.nholes; i++) maxVerts += region.holes[i].contour->nverts; - rcScopedDelete diags((rcPotentialDiagonal*)rcAlloc(sizeof(rcPotentialDiagonal)*maxVerts, RC_ALLOC_TEMP)); + rdScopedDelete diags((rcPotentialDiagonal*)rdAlloc(sizeof(rcPotentialDiagonal)*maxVerts, RD_ALLOC_TEMP)); if (!diags) { ctx->log(RC_LOG_WARNING, "mergeRegionHoles: Failed to allocated diags %d.", maxVerts); @@ -819,12 +819,12 @@ static void mergeRegionHoles(rcContext* ctx, rcContourRegion& region) /// /// See the #rcConfig documentation for more information on the configuration parameters. /// -/// @see rcAllocContourSet, rcCompactHeightfield, rcContourSet, rcConfig +/// @see rdAllocContourSet, rcCompactHeightfield, rcContourSet, rcConfig bool rcBuildContours(rcContext* ctx, const rcCompactHeightfield& chf, const float maxError, const int maxEdgeLen, rcContourSet& cset, const int buildFlags) { - rcAssert(ctx); + rdAssert(ctx); const int w = chf.width; const int h = chf.height; @@ -851,12 +851,12 @@ bool rcBuildContours(rcContext* ctx, const rcCompactHeightfield& chf, cset.maxError = maxError; int maxContours = rcMax((int)chf.maxRegions, 8); - cset.conts = (rcContour*)rcAlloc(sizeof(rcContour)*maxContours, RC_ALLOC_PERM); + cset.conts = (rcContour*)rdAlloc(sizeof(rcContour)*maxContours, RD_ALLOC_PERM); if (!cset.conts) return false; cset.nconts = 0; - rcScopedDelete flags((unsigned char*)rcAlloc(sizeof(unsigned char)*chf.spanCount, RC_ALLOC_TEMP)); + rdScopedDelete flags((unsigned char*)rdAlloc(sizeof(unsigned char)*chf.spanCount, RD_ALLOC_TEMP)); if (!flags) { ctx->log(RC_LOG_ERROR, "rcBuildContours: Out of memory 'flags' (%d).", chf.spanCount); @@ -900,8 +900,8 @@ bool rcBuildContours(rcContext* ctx, const rcCompactHeightfield& chf, ctx->stopTimer(RC_TIMER_BUILD_CONTOURS_TRACE); - rcIntArray verts(256); - rcIntArray simplified(64); + rdIntArray verts(256); + rdIntArray simplified(64); for (int y = 0; y < h; ++y) { @@ -943,7 +943,7 @@ bool rcBuildContours(rcContext* ctx, const rcCompactHeightfield& chf, // This happens when a region has holes. const int oldMax = maxContours; maxContours *= 2; - rcContour* newConts = (rcContour*)rcAlloc(sizeof(rcContour)*maxContours, RC_ALLOC_PERM); + rcContour* newConts = (rcContour*)rdAlloc(sizeof(rcContour)*maxContours, RD_ALLOC_PERM); for (int j = 0; j < cset.nconts; ++j) { newConts[j] = cset.conts[j]; @@ -951,7 +951,7 @@ bool rcBuildContours(rcContext* ctx, const rcCompactHeightfield& chf, cset.conts[j].verts = 0; cset.conts[j].rverts = 0; } - rcFree(cset.conts); + rdFree(cset.conts); cset.conts = newConts; ctx->log(RC_LOG_WARNING, "rcBuildContours: Expanding max contours from %d to %d.", oldMax, maxContours); @@ -960,7 +960,7 @@ bool rcBuildContours(rcContext* ctx, const rcCompactHeightfield& chf, rcContour* cont = &cset.conts[cset.nconts++]; cont->nverts = simplified.size()/4; - cont->verts = (int*)rcAlloc(sizeof(int)*cont->nverts*4, RC_ALLOC_PERM); + cont->verts = (int*)rdAlloc(sizeof(int)*cont->nverts*4, RD_ALLOC_PERM); if (!cont->verts) { ctx->log(RC_LOG_ERROR, "rcBuildContours: Out of memory 'verts' (%d).", cont->nverts); @@ -979,7 +979,7 @@ bool rcBuildContours(rcContext* ctx, const rcCompactHeightfield& chf, } cont->nrverts = verts.size()/4; - cont->rverts = (int*)rcAlloc(sizeof(int)*cont->nrverts*4, RC_ALLOC_PERM); + cont->rverts = (int*)rdAlloc(sizeof(int)*cont->nrverts*4, RD_ALLOC_PERM); if (!cont->rverts) { ctx->log(RC_LOG_ERROR, "rcBuildContours: Out of memory 'rverts' (%d).", cont->nrverts); @@ -1008,7 +1008,7 @@ bool rcBuildContours(rcContext* ctx, const rcCompactHeightfield& chf, if (cset.nconts > 0) { // Calculate winding of all polygons. - rcScopedDelete winding((signed char*)rcAlloc(sizeof(signed char)*cset.nconts, RC_ALLOC_TEMP)); + rdScopedDelete winding((signed char*)rdAlloc(sizeof(signed char)*cset.nconts, RD_ALLOC_TEMP)); if (!winding) { ctx->log(RC_LOG_ERROR, "rcBuildContours: Out of memory 'hole' (%d).", cset.nconts); @@ -1029,7 +1029,7 @@ bool rcBuildContours(rcContext* ctx, const rcCompactHeightfield& chf, // Collect outline contour and holes contours per region. // We assume that there is one outline and multiple holes. const int nregions = chf.maxRegions+1; - rcScopedDelete regions((rcContourRegion*)rcAlloc(sizeof(rcContourRegion)*nregions, RC_ALLOC_TEMP)); + rdScopedDelete regions((rcContourRegion*)rdAlloc(sizeof(rcContourRegion)*nregions, RD_ALLOC_TEMP)); if (!regions) { ctx->log(RC_LOG_ERROR, "rcBuildContours: Out of memory 'regions' (%d).", nregions); @@ -1037,7 +1037,7 @@ bool rcBuildContours(rcContext* ctx, const rcCompactHeightfield& chf, } memset(regions, 0, sizeof(rcContourRegion)*nregions); - rcScopedDelete holes((rcContourHole*)rcAlloc(sizeof(rcContourHole)*cset.nconts, RC_ALLOC_TEMP)); + rdScopedDelete holes((rcContourHole*)rdAlloc(sizeof(rcContourHole)*cset.nconts, RD_ALLOC_TEMP)); if (!holes) { ctx->log(RC_LOG_ERROR, "rcBuildContours: Out of memory 'holes' (%d).", cset.nconts); diff --git a/src/thirdparty/recast/Recast/Source/RecastFilter.cpp b/src/thirdparty/recast/Recast/Source/RecastFilter.cpp index 114ccf89..813b1058 100644 --- a/src/thirdparty/recast/Recast/Source/RecastFilter.cpp +++ b/src/thirdparty/recast/Recast/Source/RecastFilter.cpp @@ -17,13 +17,13 @@ // #include "Recast/Include/Recast.h" -#include "Recast/Include/RecastAssert.h" +#include "Shared/Include/SharedAssert.h" #include void rcFilterLowHangingWalkableObstacles(rcContext* context, const int walkableClimb, rcHeightfield& heightfield) { - rcAssert(context); + rdAssert(context); rcScopedTimer timer(context, RC_TIMER_FILTER_LOW_OBSTACLES); @@ -62,7 +62,7 @@ void rcFilterLowHangingWalkableObstacles(rcContext* context, const int walkableC void rcFilterLedgeSpans(rcContext* context, const int walkableHeight, const int walkableClimb, rcHeightfield& heightfield) { - rcAssert(context); + rdAssert(context); rcScopedTimer timer(context, RC_TIMER_FILTER_BORDER); @@ -156,7 +156,7 @@ void rcFilterLedgeSpans(rcContext* context, const int walkableHeight, const int void rcFilterWalkableLowHeightSpans(rcContext* context, const int walkableHeight, rcHeightfield& heightfield) { - rcAssert(context); + rdAssert(context); rcScopedTimer timer(context, RC_TIMER_FILTER_WALKABLE); diff --git a/src/thirdparty/recast/Recast/Source/RecastLayers.cpp b/src/thirdparty/recast/Recast/Source/RecastLayers.cpp index 7217ded4..b9178af5 100644 --- a/src/thirdparty/recast/Recast/Source/RecastLayers.cpp +++ b/src/thirdparty/recast/Recast/Source/RecastLayers.cpp @@ -23,8 +23,8 @@ #include #include #include "Recast/Include/Recast.h" -#include "Recast/Include/RecastAlloc.h" -#include "Recast/Include/RecastAssert.h" +#include "Shared/Include/SharedAlloc.h" +#include "Shared/Include/SharedAssert.h" // Must be 255 or smaller (not 256) because layer IDs are stored as @@ -88,19 +88,19 @@ struct rcLayerSweepSpan /// /// See the #rcConfig documentation for more information on the configuration parameters. /// -/// @see rcAllocHeightfieldLayerSet, rcCompactHeightfield, rcHeightfieldLayerSet, rcConfig +/// @see rdAllocHeightfieldLayerSet, rcCompactHeightfield, rcHeightfieldLayerSet, rcConfig bool rcBuildHeightfieldLayers(rcContext* ctx, rcCompactHeightfield& chf, const int borderSize, const int walkableHeight, rcHeightfieldLayerSet& lset) { - rcAssert(ctx); + rdAssert(ctx); rcScopedTimer timer(ctx, RC_TIMER_BUILD_LAYERS); const int w = chf.width; const int h = chf.height; - rcScopedDelete srcReg((unsigned char*)rcAlloc(sizeof(unsigned char)*chf.spanCount, RC_ALLOC_TEMP)); + rdScopedDelete srcReg((unsigned char*)rdAlloc(sizeof(unsigned char)*chf.spanCount, RD_ALLOC_TEMP)); if (!srcReg) { ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'srcReg' (%d).", chf.spanCount); @@ -109,7 +109,7 @@ bool rcBuildHeightfieldLayers(rcContext* ctx, rcCompactHeightfield& chf, memset(srcReg,0xff,sizeof(unsigned char)*chf.spanCount); const int nsweeps = chf.width; - rcScopedDelete sweeps((rcLayerSweepSpan*)rcAlloc(sizeof(rcLayerSweepSpan)*nsweeps, RC_ALLOC_TEMP)); + rdScopedDelete sweeps((rcLayerSweepSpan*)rdAlloc(sizeof(rcLayerSweepSpan)*nsweeps, RD_ALLOC_TEMP)); if (!sweeps) { ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'sweeps' (%d).", nsweeps); @@ -220,7 +220,7 @@ bool rcBuildHeightfieldLayers(rcContext* ctx, rcCompactHeightfield& chf, // Allocate and init layer regions. const int nregs = (int)regId; - rcScopedDelete regs((rcLayerRegion*)rcAlloc(sizeof(rcLayerRegion)*nregs, RC_ALLOC_TEMP)); + rdScopedDelete regs((rcLayerRegion*)rdAlloc(sizeof(rcLayerRegion)*nregs, RD_ALLOC_TEMP)); if (!regs) { ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'regs' (%d).", nregs); @@ -480,7 +480,7 @@ bool rcBuildHeightfieldLayers(rcContext* ctx, rcCompactHeightfield& chf, return true; // Create layers. - rcAssert(lset.layers == 0); + rdAssert(lset.layers == 0); const int lw = w - borderSize*2; const int lh = h - borderSize*2; @@ -496,7 +496,7 @@ bool rcBuildHeightfieldLayers(rcContext* ctx, rcCompactHeightfield& chf, lset.nlayers = (int)layerId; - lset.layers = (rcHeightfieldLayer*)rcAlloc(sizeof(rcHeightfieldLayer)*lset.nlayers, RC_ALLOC_PERM); + lset.layers = (rcHeightfieldLayer*)rdAlloc(sizeof(rcHeightfieldLayer)*lset.nlayers, RD_ALLOC_PERM); if (!lset.layers) { ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'layers' (%d).", lset.nlayers); @@ -514,7 +514,7 @@ bool rcBuildHeightfieldLayers(rcContext* ctx, rcCompactHeightfield& chf, const int gridSize = sizeof(unsigned char)*lw*lh; - layer->heights = (unsigned char*)rcAlloc(gridSize, RC_ALLOC_PERM); + layer->heights = (unsigned char*)rdAlloc(gridSize, RD_ALLOC_PERM); if (!layer->heights) { ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'heights' (%d).", gridSize); @@ -522,7 +522,7 @@ bool rcBuildHeightfieldLayers(rcContext* ctx, rcCompactHeightfield& chf, } memset(layer->heights, 0xff, gridSize); - layer->areas = (unsigned char*)rcAlloc(gridSize, RC_ALLOC_PERM); + layer->areas = (unsigned char*)rdAlloc(gridSize, RD_ALLOC_PERM); if (!layer->areas) { ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'areas' (%d).", gridSize); @@ -530,7 +530,7 @@ bool rcBuildHeightfieldLayers(rcContext* ctx, rcCompactHeightfield& chf, } memset(layer->areas, 0, gridSize); - layer->cons = (unsigned char*)rcAlloc(gridSize, RC_ALLOC_PERM); + layer->cons = (unsigned char*)rdAlloc(gridSize, RD_ALLOC_PERM); if (!layer->cons) { ctx->log(RC_LOG_ERROR, "rcBuildHeightfieldLayers: Out of memory 'cons' (%d).", gridSize); diff --git a/src/thirdparty/recast/Recast/Source/RecastMesh.cpp b/src/thirdparty/recast/Recast/Source/RecastMesh.cpp index 1267336d..fb52f86a 100644 --- a/src/thirdparty/recast/Recast/Source/RecastMesh.cpp +++ b/src/thirdparty/recast/Recast/Source/RecastMesh.cpp @@ -21,8 +21,8 @@ #include #include #include "Recast/Include/Recast.h" -#include "Recast/Include/RecastAlloc.h" -#include "Recast/Include/RecastAssert.h" +#include "Shared/Include/SharedAlloc.h" +#include "Shared/Include/SharedAssert.h" #include struct rcEdge { @@ -38,16 +38,16 @@ static bool buildMeshAdjacency(unsigned short* polys, const int npolys, // https://web.archive.org/web/20080704083314/http://www.terathon.com/code/edges.php int maxEdgeCount = npolys*vertsPerPoly; - unsigned short* firstEdge = (unsigned short*)rcAlloc(sizeof(unsigned short)*(nverts + maxEdgeCount), RC_ALLOC_TEMP); + unsigned short* firstEdge = (unsigned short*)rdAlloc(sizeof(unsigned short)*(nverts + maxEdgeCount), RD_ALLOC_TEMP); if (!firstEdge) return false; unsigned short* nextEdge = firstEdge + nverts; int edgeCount = 0; - rcEdge* edges = (rcEdge*)rcAlloc(sizeof(rcEdge)*maxEdgeCount, RC_ALLOC_TEMP); + rcEdge* edges = (rcEdge*)rdAlloc(sizeof(rcEdge)*maxEdgeCount, RD_ALLOC_TEMP); if (!edges) { - rcFree(firstEdge); + rdFree(firstEdge); return false; } @@ -116,8 +116,8 @@ static bool buildMeshAdjacency(unsigned short* polys, const int npolys, } } - rcFree(firstEdge); - rcFree(edges); + rdFree(firstEdge); + rdFree(edges); return true; } @@ -654,7 +654,7 @@ static bool canRemoveVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned sho // Find edges which share the removed vertex. const int maxEdges = numTouchedVerts*2; int nedges = 0; - rcScopedDelete edges((int*)rcAlloc(sizeof(int)*maxEdges*3, RC_ALLOC_TEMP)); + rdScopedDelete edges((int*)rdAlloc(sizeof(int)*maxEdges*3, RD_ALLOC_TEMP)); if (!edges) { ctx->log(RC_LOG_WARNING, "canRemoveVertex: Out of memory 'edges' (%d).", maxEdges*3); @@ -743,7 +743,7 @@ static bool removeVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned short } int nedges = 0; - rcScopedDelete edges((int*)rcAlloc(sizeof(int)*numRemovedVerts*nvp*4, RC_ALLOC_TEMP)); + rdScopedDelete edges((int*)rdAlloc(sizeof(int)*numRemovedVerts*nvp*4, RD_ALLOC_TEMP)); if (!edges) { ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'edges' (%d).", numRemovedVerts*nvp*4); @@ -751,7 +751,7 @@ static bool removeVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned short } int nhole = 0; - rcScopedDelete hole((int*)rcAlloc(sizeof(int)*numRemovedVerts*nvp, RC_ALLOC_TEMP)); + rdScopedDelete hole((int*)rdAlloc(sizeof(int)*numRemovedVerts*nvp, RD_ALLOC_TEMP)); if (!hole) { ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'hole' (%d).", numRemovedVerts*nvp); @@ -759,7 +759,7 @@ static bool removeVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned short } int nhreg = 0; - rcScopedDelete hreg((int*)rcAlloc(sizeof(int)*numRemovedVerts*nvp, RC_ALLOC_TEMP)); + rdScopedDelete hreg((int*)rdAlloc(sizeof(int)*numRemovedVerts*nvp, RD_ALLOC_TEMP)); if (!hreg) { ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'hreg' (%d).", numRemovedVerts*nvp); @@ -767,7 +767,7 @@ static bool removeVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned short } int nharea = 0; - rcScopedDelete harea((int*)rcAlloc(sizeof(int)*numRemovedVerts*nvp, RC_ALLOC_TEMP)); + rdScopedDelete harea((int*)rdAlloc(sizeof(int)*numRemovedVerts*nvp, RD_ALLOC_TEMP)); if (!harea) { ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'harea' (%d).", numRemovedVerts*nvp); @@ -884,21 +884,21 @@ static bool removeVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned short break; } - rcScopedDelete tris((int*)rcAlloc(sizeof(int)*nhole*3, RC_ALLOC_TEMP)); + rdScopedDelete tris((int*)rdAlloc(sizeof(int)*nhole*3, RD_ALLOC_TEMP)); if (!tris) { ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'tris' (%d).", nhole*3); return false; } - rcScopedDelete tverts((int*)rcAlloc(sizeof(int)*nhole*4, RC_ALLOC_TEMP)); + rdScopedDelete tverts((int*)rdAlloc(sizeof(int)*nhole*4, RD_ALLOC_TEMP)); if (!tverts) { ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'tverts' (%d).", nhole*4); return false; } - rcScopedDelete thole((int*)rcAlloc(sizeof(int)*nhole, RC_ALLOC_TEMP)); + rdScopedDelete thole((int*)rdAlloc(sizeof(int)*nhole, RD_ALLOC_TEMP)); if (!thole) { ctx->log(RC_LOG_WARNING, "removeVertex: Out of memory 'thole' (%d).", nhole); @@ -925,19 +925,19 @@ static bool removeVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned short } // Merge the hole triangles back to polygons. - rcScopedDelete polys((unsigned short*)rcAlloc(sizeof(unsigned short)*(ntris+1)*nvp, RC_ALLOC_TEMP)); + rdScopedDelete polys((unsigned short*)rdAlloc(sizeof(unsigned short)*(ntris+1)*nvp, RD_ALLOC_TEMP)); if (!polys) { ctx->log(RC_LOG_ERROR, "removeVertex: Out of memory 'polys' (%d).", (ntris+1)*nvp); return false; } - rcScopedDelete pregs((unsigned short*)rcAlloc(sizeof(unsigned short)*ntris, RC_ALLOC_TEMP)); + rdScopedDelete pregs((unsigned short*)rdAlloc(sizeof(unsigned short)*ntris, RD_ALLOC_TEMP)); if (!pregs) { ctx->log(RC_LOG_ERROR, "removeVertex: Out of memory 'pregs' (%d).", ntris); return false; } - rcScopedDelete pareas((unsigned char*)rcAlloc(sizeof(unsigned char)*ntris, RC_ALLOC_TEMP)); + rdScopedDelete pareas((unsigned char*)rdAlloc(sizeof(unsigned char)*ntris, RD_ALLOC_TEMP)); if (!pareas) { ctx->log(RC_LOG_ERROR, "removeVertex: Out of memory 'pareas' (%d).", ntris); @@ -1050,10 +1050,10 @@ static bool removeVertex(rcContext* ctx, rcPolyMesh& mesh, const unsigned short /// @note If the mesh data is to be used to construct a Detour navigation mesh, then the upper /// limit must be restricted to <= #DT_VERTS_PER_POLYGON. /// -/// @see rcAllocPolyMesh, rcContourSet, rcPolyMesh, rcConfig +/// @see rdAllocPolyMesh, rcContourSet, rcPolyMesh, rcConfig bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, const int nvp, rcPolyMesh& mesh) { - rcAssert(ctx); + rdAssert(ctx); rcScopedTimer timer(ctx, RC_TIMER_BUILD_POLYMESH); @@ -1082,7 +1082,7 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, const int nvp, rcPolyMe return false; } - rcScopedDelete vflags((unsigned char*)rcAlloc(sizeof(unsigned char)*maxVertices, RC_ALLOC_TEMP)); + rdScopedDelete vflags((unsigned char*)rdAlloc(sizeof(unsigned char)*maxVertices, RD_ALLOC_TEMP)); if (!vflags) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'vflags' (%d).", maxVertices); @@ -1090,25 +1090,25 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, const int nvp, rcPolyMe } memset(vflags, 0, maxVertices); - mesh.verts = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxVertices*3, RC_ALLOC_PERM); + mesh.verts = (unsigned short*)rdAlloc(sizeof(unsigned short)*maxVertices*3, RD_ALLOC_PERM); if (!mesh.verts) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.verts' (%d).", maxVertices); return false; } - mesh.polys = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxTris*nvp*2, RC_ALLOC_PERM); + mesh.polys = (unsigned short*)rdAlloc(sizeof(unsigned short)*maxTris*nvp*2, RD_ALLOC_PERM); if (!mesh.polys) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.polys' (%d).", maxTris*nvp*2); return false; } - mesh.regs = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxTris, RC_ALLOC_PERM); + mesh.regs = (unsigned short*)rdAlloc(sizeof(unsigned short)*maxTris, RD_ALLOC_PERM); if (!mesh.regs) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.regs' (%d).", maxTris); return false; } - mesh.areas = (unsigned char*)rcAlloc(sizeof(unsigned char)*maxTris, RC_ALLOC_PERM); + mesh.areas = (unsigned char*)rdAlloc(sizeof(unsigned char)*maxTris, RD_ALLOC_PERM); if (!mesh.areas) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.areas' (%d).", maxTris); @@ -1125,7 +1125,7 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, const int nvp, rcPolyMe memset(mesh.regs, 0, sizeof(unsigned short)*maxTris); memset(mesh.areas, 0, sizeof(unsigned char)*maxTris); - rcScopedDelete nextVert((int*)rcAlloc(sizeof(int)*maxVertices, RC_ALLOC_TEMP)); + rdScopedDelete nextVert((int*)rdAlloc(sizeof(int)*maxVertices, RD_ALLOC_TEMP)); if (!nextVert) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'nextVert' (%d).", maxVertices); @@ -1133,7 +1133,7 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, const int nvp, rcPolyMe } memset(nextVert, 0, sizeof(int)*maxVertices); - rcScopedDelete firstVert((int*)rcAlloc(sizeof(int)*VERTEX_BUCKET_COUNT, RC_ALLOC_TEMP)); + rdScopedDelete firstVert((int*)rdAlloc(sizeof(int)*VERTEX_BUCKET_COUNT, RD_ALLOC_TEMP)); if (!firstVert) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'firstVert' (%d).", VERTEX_BUCKET_COUNT); @@ -1142,19 +1142,19 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, const int nvp, rcPolyMe for (int i = 0; i < VERTEX_BUCKET_COUNT; ++i) firstVert[i] = -1; - rcScopedDelete indices((int*)rcAlloc(sizeof(int)*maxVertsPerCont, RC_ALLOC_TEMP)); + rdScopedDelete indices((int*)rdAlloc(sizeof(int)*maxVertsPerCont, RD_ALLOC_TEMP)); if (!indices) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'indices' (%d).", maxVertsPerCont); return false; } - rcScopedDelete tris((int*)rcAlloc(sizeof(int)*maxVertsPerCont*3, RC_ALLOC_TEMP)); + rdScopedDelete tris((int*)rdAlloc(sizeof(int)*maxVertsPerCont*3, RD_ALLOC_TEMP)); if (!tris) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'tris' (%d).", maxVertsPerCont*3); return false; } - rcScopedDelete polys((unsigned short*)rcAlloc(sizeof(unsigned short)*(maxVertsPerCont+1)*nvp, RC_ALLOC_TEMP)); + rdScopedDelete polys((unsigned short*)rdAlloc(sizeof(unsigned short)*(maxVertsPerCont+1)*nvp, RD_ALLOC_TEMP)); if (!polys) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'polys' (%d).", maxVertsPerCont*nvp); @@ -1360,7 +1360,7 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, const int nvp, rcPolyMe } // Just allocate the mesh flags array. The user is resposible to fill it. - mesh.flags = (unsigned short*)rcAlloc(sizeof(unsigned short)*mesh.npolys, RC_ALLOC_PERM); + mesh.flags = (unsigned short*)rdAlloc(sizeof(unsigned short)*mesh.npolys, RD_ALLOC_PERM); if (!mesh.flags) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMesh: Out of memory 'mesh.flags' (%d).", mesh.npolys); @@ -1380,10 +1380,10 @@ bool rcBuildPolyMesh(rcContext* ctx, rcContourSet& cset, const int nvp, rcPolyMe return true; } -/// @see rcAllocPolyMesh, rcPolyMesh +/// @see rdAllocPolyMesh, rcPolyMesh bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, rcPolyMesh& mesh) { - rcAssert(ctx); + rdAssert(ctx); if (!nmeshes || !meshes) return true; @@ -1409,7 +1409,7 @@ bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, r } mesh.nverts = 0; - mesh.verts = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxVerts*3, RC_ALLOC_PERM); + mesh.verts = (unsigned short*)rdAlloc(sizeof(unsigned short)*maxVerts*3, RD_ALLOC_PERM); if (!mesh.verts) { ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'mesh.verts' (%d).", maxVerts*3); @@ -1417,7 +1417,7 @@ bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, r } mesh.npolys = 0; - mesh.polys = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxPolys*2*mesh.nvp, RC_ALLOC_PERM); + mesh.polys = (unsigned short*)rdAlloc(sizeof(unsigned short)*maxPolys*2*mesh.nvp, RD_ALLOC_PERM); if (!mesh.polys) { ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'mesh.polys' (%d).", maxPolys*2*mesh.nvp); @@ -1425,7 +1425,7 @@ bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, r } memset(mesh.polys, 0xff, sizeof(unsigned short)*maxPolys*2*mesh.nvp); - mesh.regs = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxPolys, RC_ALLOC_PERM); + mesh.regs = (unsigned short*)rdAlloc(sizeof(unsigned short)*maxPolys, RD_ALLOC_PERM); if (!mesh.regs) { ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'mesh.regs' (%d).", maxPolys); @@ -1433,7 +1433,7 @@ bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, r } memset(mesh.regs, 0, sizeof(unsigned short)*maxPolys); - mesh.areas = (unsigned char*)rcAlloc(sizeof(unsigned char)*maxPolys, RC_ALLOC_PERM); + mesh.areas = (unsigned char*)rdAlloc(sizeof(unsigned char)*maxPolys, RD_ALLOC_PERM); if (!mesh.areas) { ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'mesh.areas' (%d).", maxPolys); @@ -1441,7 +1441,7 @@ bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, r } memset(mesh.areas, 0, sizeof(unsigned char)*maxPolys); - mesh.flags = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxPolys, RC_ALLOC_PERM); + mesh.flags = (unsigned short*)rdAlloc(sizeof(unsigned short)*maxPolys, RD_ALLOC_PERM); if (!mesh.flags) { ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'mesh.flags' (%d).", maxPolys); @@ -1449,7 +1449,7 @@ bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, r } memset(mesh.flags, 0, sizeof(unsigned short)*maxPolys); - rcScopedDelete nextVert((int*)rcAlloc(sizeof(int)*maxVerts, RC_ALLOC_TEMP)); + rdScopedDelete nextVert((int*)rdAlloc(sizeof(int)*maxVerts, RD_ALLOC_TEMP)); if (!nextVert) { ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'nextVert' (%d).", maxVerts); @@ -1457,7 +1457,7 @@ bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, r } memset(nextVert, 0, sizeof(int)*maxVerts); - rcScopedDelete firstVert((int*)rcAlloc(sizeof(int)*VERTEX_BUCKET_COUNT, RC_ALLOC_TEMP)); + rdScopedDelete firstVert((int*)rdAlloc(sizeof(int)*VERTEX_BUCKET_COUNT, RD_ALLOC_TEMP)); if (!firstVert) { ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'firstVert' (%d).", VERTEX_BUCKET_COUNT); @@ -1466,7 +1466,7 @@ bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, r for (int i = 0; i < VERTEX_BUCKET_COUNT; ++i) firstVert[i] = -1; - rcScopedDelete vremap((unsigned short*)rcAlloc(sizeof(unsigned short)*maxVertsPerMesh, RC_ALLOC_PERM)); + rdScopedDelete vremap((unsigned short*)rdAlloc(sizeof(unsigned short)*maxVertsPerMesh, RD_ALLOC_PERM)); if (!vremap) { ctx->log(RC_LOG_ERROR, "rcMergePolyMeshes: Out of memory 'vremap' (%d).", maxVertsPerMesh); @@ -1561,14 +1561,14 @@ bool rcMergePolyMeshes(rcContext* ctx, rcPolyMesh** meshes, const int nmeshes, r bool rcCopyPolyMesh(rcContext* ctx, const rcPolyMesh& src, rcPolyMesh& dst) { - rcAssert(ctx); + rdAssert(ctx); // Destination must be empty. - rcAssert(dst.verts == 0); - rcAssert(dst.polys == 0); - rcAssert(dst.regs == 0); - rcAssert(dst.areas == 0); - rcAssert(dst.flags == 0); + rdAssert(dst.verts == 0); + rdAssert(dst.polys == 0); + rdAssert(dst.regs == 0); + rdAssert(dst.areas == 0); + rdAssert(dst.flags == 0); dst.nverts = src.nverts; dst.npolys = src.npolys; @@ -1581,7 +1581,7 @@ bool rcCopyPolyMesh(rcContext* ctx, const rcPolyMesh& src, rcPolyMesh& dst) dst.borderSize = src.borderSize; dst.maxEdgeError = src.maxEdgeError; - dst.verts = (unsigned short*)rcAlloc(sizeof(unsigned short)*src.nverts*3, RC_ALLOC_PERM); + dst.verts = (unsigned short*)rdAlloc(sizeof(unsigned short)*src.nverts*3, RD_ALLOC_PERM); if (!dst.verts) { ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.verts' (%d).", src.nverts*3); @@ -1589,7 +1589,7 @@ bool rcCopyPolyMesh(rcContext* ctx, const rcPolyMesh& src, rcPolyMesh& dst) } memcpy(dst.verts, src.verts, sizeof(unsigned short)*src.nverts*3); - dst.polys = (unsigned short*)rcAlloc(sizeof(unsigned short)*src.npolys*2*src.nvp, RC_ALLOC_PERM); + dst.polys = (unsigned short*)rdAlloc(sizeof(unsigned short)*src.npolys*2*src.nvp, RD_ALLOC_PERM); if (!dst.polys) { ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.polys' (%d).", src.npolys*2*src.nvp); @@ -1597,7 +1597,7 @@ bool rcCopyPolyMesh(rcContext* ctx, const rcPolyMesh& src, rcPolyMesh& dst) } memcpy(dst.polys, src.polys, sizeof(unsigned short)*src.npolys*2*src.nvp); - dst.regs = (unsigned short*)rcAlloc(sizeof(unsigned short)*src.npolys, RC_ALLOC_PERM); + dst.regs = (unsigned short*)rdAlloc(sizeof(unsigned short)*src.npolys, RD_ALLOC_PERM); if (!dst.regs) { ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.regs' (%d).", src.npolys); @@ -1605,7 +1605,7 @@ bool rcCopyPolyMesh(rcContext* ctx, const rcPolyMesh& src, rcPolyMesh& dst) } memcpy(dst.regs, src.regs, sizeof(unsigned short)*src.npolys); - dst.areas = (unsigned char*)rcAlloc(sizeof(unsigned char)*src.npolys, RC_ALLOC_PERM); + dst.areas = (unsigned char*)rdAlloc(sizeof(unsigned char)*src.npolys, RD_ALLOC_PERM); if (!dst.areas) { ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.areas' (%d).", src.npolys); @@ -1613,7 +1613,7 @@ bool rcCopyPolyMesh(rcContext* ctx, const rcPolyMesh& src, rcPolyMesh& dst) } memcpy(dst.areas, src.areas, sizeof(unsigned char)*src.npolys); - dst.flags = (unsigned short*)rcAlloc(sizeof(unsigned short)*src.npolys, RC_ALLOC_PERM); + dst.flags = (unsigned short*)rdAlloc(sizeof(unsigned short)*src.npolys, RD_ALLOC_PERM); if (!dst.flags) { ctx->log(RC_LOG_ERROR, "rcCopyPolyMesh: Out of memory 'dst.flags' (%d).", src.npolys); diff --git a/src/thirdparty/recast/Recast/Source/RecastMeshDetail.cpp b/src/thirdparty/recast/Recast/Source/RecastMeshDetail.cpp index 54b83bde..2afca9d9 100644 --- a/src/thirdparty/recast/Recast/Source/RecastMeshDetail.cpp +++ b/src/thirdparty/recast/Recast/Source/RecastMeshDetail.cpp @@ -23,8 +23,8 @@ #include #include #include "Recast/Include/Recast.h" -#include "Recast/Include/RecastAlloc.h" -#include "Recast/Include/RecastAssert.h" +#include "Shared/Include/SharedAlloc.h" +#include "Shared/Include/SharedAssert.h" #include static const unsigned RC_UNSET_HEIGHT = 0xffff; @@ -33,7 +33,7 @@ static const unsigned RC_UNSET_HEIGHT = 0xffff; struct rcHeightPatch { inline rcHeightPatch() : data(0), xmin(0), ymin(0), width(0), height(0) {} - inline ~rcHeightPatch() { rcFree(data); } + inline ~rcHeightPatch() { rdFree(data); } unsigned short* data; int xmin, ymin, width, height; }; @@ -523,7 +523,7 @@ static void completeFacet(rcContext* ctx, const float* pts, int npts, int* edges #undef addEdgeN void delaunayHull(rcContext* ctx, const int npts, const float* pts, const int nhull, const int* hull, - rcIntArray& tris, rcIntArray& edges) + rdIntArray& tris, rdIntArray& edges) { int nfaces = 0; int nedges = 0; @@ -662,7 +662,7 @@ inline int next(int i, int n) { return i+1 < n ? i+1 : 0; } #define STEP_DIR next #define REV_STEP_DIR prev #endif -static void triangulateHull(const int /*nverts*/, const float* verts, const int nhull, const int* hull, const int nin, rcIntArray& tris) +static void triangulateHull(const int /*nverts*/, const float* verts, const int nhull, const int* hull, const int nin, rdIntArray& tris) { int start = 0, left = 1, right = nhull-1; @@ -756,7 +756,7 @@ static bool onHull(int a, int b, int nhull, int* hull) } // Find edges that lie on hull and mark them as such. -static void setTriFlags(rcIntArray& tris, int nhull, int* hull) +static void setTriFlags(rdIntArray& tris, int nhull, int* hull) { // Matches DT_DETAIL_EDGE_BOUNDARY const int DETAIL_EDGE_BOUNDARY = 0x1; @@ -778,7 +778,7 @@ static bool buildPolyDetail(rcContext* ctx, const float* in, const int nin, const float sampleDist, const float sampleMaxError, const int heightSearchRadius, const rcCompactHeightfield& chf, const rcHeightPatch& hp, float* verts, int& nverts, - rcIntArray& tris, rcIntArray& edges, rcIntArray& samples) + rdIntArray& tris, rdIntArray& edges, rdIntArray& samples) { static const int MAX_VERTS = 127; static const int MAX_TRIS = 255; // Max tris for delaunay is 2n-2-k (n=num verts, k=num hull verts). @@ -1025,7 +1025,7 @@ static bool buildPolyDetail(rcContext* ctx, const float* in, const int nin, static void seedArrayWithPolyCenter(rcContext* ctx, const rcCompactHeightfield& chf, const unsigned short* poly, const int npoly, const unsigned short* verts, const int bs, - rcHeightPatch& hp, rcIntArray& array) + rcHeightPatch& hp, rdIntArray& array) { // Note: Reads to the compact heightfield are offset by border size (bs) // since border size offset is already removed from the polymesh vertices. @@ -1065,7 +1065,7 @@ static void seedArrayWithPolyCenter(rcContext* ctx, const rcCompactHeightfield& } } - rcAssert(startSpanIndex != -1); + rdAssert(startSpanIndex != -1); // Find center of the polygon int pcx = 0, pcy = 0; for (int j = 0; j < npoly; ++j) @@ -1155,7 +1155,7 @@ static void seedArrayWithPolyCenter(rcContext* ctx, const rcCompactHeightfield& } -static void push3(rcIntArray& queue, int v1, int v2, int v3) +static void push3(rdIntArray& queue, int v1, int v2, int v3) { queue.resize(queue.size() + 3); queue[queue.size() - 3] = v1; @@ -1166,7 +1166,7 @@ static void push3(rcIntArray& queue, int v1, int v2, int v3) static void getHeightData(rcContext* ctx, const rcCompactHeightfield& chf, const unsigned short* poly, const int npoly, const unsigned short* verts, const int bs, - rcHeightPatch& hp, rcIntArray& queue, + rcHeightPatch& hp, rdIntArray& queue, int region) { // Note: Reads to the compact heightfield are offset by border size (bs) @@ -1284,12 +1284,12 @@ static void getHeightData(rcContext* ctx, const rcCompactHeightfield& chf, /// /// See the #rcConfig documentation for more information on the configuration parameters. /// -/// @see rcAllocPolyMeshDetail, rcPolyMesh, rcCompactHeightfield, rcPolyMeshDetail, rcConfig +/// @see rdAllocPolyMeshDetail, rcPolyMesh, rcCompactHeightfield, rcPolyMeshDetail, rcConfig bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompactHeightfield& chf, const float sampleDist, const float sampleMaxError, rcPolyMeshDetail& dmesh) { - rcAssert(ctx); + rdAssert(ctx); rcScopedTimer timer(ctx, RC_TIMER_BUILD_POLYMESHDETAIL); @@ -1303,22 +1303,22 @@ bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompa const int borderSize = mesh.borderSize; const int heightSearchRadius = rcMax(1, (int)ceilf(mesh.maxEdgeError)); - rcIntArray edges(64); - rcIntArray tris(512); - rcIntArray arr(512); - rcIntArray samples(512); + rdIntArray edges(64); + rdIntArray tris(512); + rdIntArray arr(512); + rdIntArray samples(512); float verts[256*3]; rcHeightPatch hp; int nPolyVerts = 0; int maxhw = 0, maxhh = 0; - rcScopedDelete bounds((int*)rcAlloc(sizeof(int)*mesh.npolys*4, RC_ALLOC_TEMP)); + rdScopedDelete bounds((int*)rdAlloc(sizeof(int)*mesh.npolys*4, RD_ALLOC_TEMP)); if (!bounds) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'bounds' (%d).", mesh.npolys*4); return false; } - rcScopedDelete poly((float*)rcAlloc(sizeof(float)*nvp*3, RC_ALLOC_TEMP)); + rdScopedDelete poly((float*)rdAlloc(sizeof(float)*nvp*3, RD_ALLOC_TEMP)); if (!poly) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'poly' (%d).", nvp*3); @@ -1356,7 +1356,7 @@ bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompa maxhh = rcMax(maxhh, ymax-ymin); } - hp.data = (unsigned short*)rcAlloc(sizeof(unsigned short)*maxhw*maxhh, RC_ALLOC_TEMP); + hp.data = (unsigned short*)rdAlloc(sizeof(unsigned short)*maxhw*maxhh, RD_ALLOC_TEMP); if (!hp.data) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'hp.data' (%d).", maxhw*maxhh); @@ -1366,7 +1366,7 @@ bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompa dmesh.nmeshes = mesh.npolys; dmesh.nverts = 0; dmesh.ntris = 0; - dmesh.meshes = (unsigned int*)rcAlloc(sizeof(unsigned int)*dmesh.nmeshes*4, RC_ALLOC_PERM); + dmesh.meshes = (unsigned int*)rdAlloc(sizeof(unsigned int)*dmesh.nmeshes*4, RD_ALLOC_PERM); if (!dmesh.meshes) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'dmesh.meshes' (%d).", dmesh.nmeshes*4); @@ -1377,14 +1377,14 @@ bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompa int tcap = vcap*2; dmesh.nverts = 0; - dmesh.verts = (float*)rcAlloc(sizeof(float)*vcap*3, RC_ALLOC_PERM); + dmesh.verts = (float*)rdAlloc(sizeof(float)*vcap*3, RD_ALLOC_PERM); if (!dmesh.verts) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'dmesh.verts' (%d).", vcap*3); return false; } dmesh.ntris = 0; - dmesh.tris = (unsigned char*)rcAlloc(sizeof(unsigned char)*tcap*4, RC_ALLOC_PERM); + dmesh.tris = (unsigned char*)rdAlloc(sizeof(unsigned char)*tcap*4, RD_ALLOC_PERM); if (!dmesh.tris) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'dmesh.tris' (%d).", tcap*4); @@ -1454,7 +1454,7 @@ bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompa while (dmesh.nverts+nverts > vcap) vcap += 256; - float* newv = (float*)rcAlloc(sizeof(float)*vcap*3, RC_ALLOC_PERM); + float* newv = (float*)rdAlloc(sizeof(float)*vcap*3, RD_ALLOC_PERM); if (!newv) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'newv' (%d).", vcap*3); @@ -1462,7 +1462,7 @@ bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompa } if (dmesh.nverts) memcpy(newv, dmesh.verts, sizeof(float)*3*dmesh.nverts); - rcFree(dmesh.verts); + rdFree(dmesh.verts); dmesh.verts = newv; } for (int j = 0; j < nverts; ++j) @@ -1478,7 +1478,7 @@ bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompa { while (dmesh.ntris+ntris > tcap) tcap += 256; - unsigned char* newt = (unsigned char*)rcAlloc(sizeof(unsigned char)*tcap*4, RC_ALLOC_PERM); + unsigned char* newt = (unsigned char*)rdAlloc(sizeof(unsigned char)*tcap*4, RD_ALLOC_PERM); if (!newt) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'newt' (%d).", tcap*4); @@ -1486,7 +1486,7 @@ bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompa } if (dmesh.ntris) memcpy(newt, dmesh.tris, sizeof(unsigned char)*4*dmesh.ntris); - rcFree(dmesh.tris); + rdFree(dmesh.tris); dmesh.tris = newt; } for (int j = 0; j < ntris; ++j) @@ -1504,10 +1504,10 @@ bool rcBuildPolyMeshDetail(rcContext* ctx, const rcPolyMesh& mesh, const rcCompa return true; } -/// @see rcAllocPolyMeshDetail, rcPolyMeshDetail +/// @see rdAllocPolyMeshDetail, rcPolyMeshDetail bool rcMergePolyMeshDetails(rcContext* ctx, rcPolyMeshDetail** meshes, const int nmeshes, rcPolyMeshDetail& mesh) { - rcAssert(ctx); + rdAssert(ctx); rcScopedTimer timer(ctx, RC_TIMER_MERGE_POLYMESHDETAIL); @@ -1524,7 +1524,7 @@ bool rcMergePolyMeshDetails(rcContext* ctx, rcPolyMeshDetail** meshes, const int } mesh.nmeshes = 0; - mesh.meshes = (unsigned int*)rcAlloc(sizeof(unsigned int)*maxMeshes*4, RC_ALLOC_PERM); + mesh.meshes = (unsigned int*)rdAlloc(sizeof(unsigned int)*maxMeshes*4, RD_ALLOC_PERM); if (!mesh.meshes) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'pmdtl.meshes' (%d).", maxMeshes*4); @@ -1532,7 +1532,7 @@ bool rcMergePolyMeshDetails(rcContext* ctx, rcPolyMeshDetail** meshes, const int } mesh.ntris = 0; - mesh.tris = (unsigned char*)rcAlloc(sizeof(unsigned char)*maxTris*4, RC_ALLOC_PERM); + mesh.tris = (unsigned char*)rdAlloc(sizeof(unsigned char)*maxTris*4, RD_ALLOC_PERM); if (!mesh.tris) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'dmesh.tris' (%d).", maxTris*4); @@ -1540,7 +1540,7 @@ bool rcMergePolyMeshDetails(rcContext* ctx, rcPolyMeshDetail** meshes, const int } mesh.nverts = 0; - mesh.verts = (float*)rcAlloc(sizeof(float)*maxVerts*3, RC_ALLOC_PERM); + mesh.verts = (float*)rdAlloc(sizeof(float)*maxVerts*3, RD_ALLOC_PERM); if (!mesh.verts) { ctx->log(RC_LOG_ERROR, "rcBuildPolyMeshDetail: Out of memory 'dmesh.verts' (%d).", maxVerts*3); diff --git a/src/thirdparty/recast/Recast/Source/RecastRasterization.cpp b/src/thirdparty/recast/Recast/Source/RecastRasterization.cpp index 60a60686..a8139db4 100644 --- a/src/thirdparty/recast/Recast/Source/RecastRasterization.cpp +++ b/src/thirdparty/recast/Recast/Source/RecastRasterization.cpp @@ -19,8 +19,8 @@ #include #include #include "Recast/Include/Recast.h" -#include "Recast/Include/RecastAlloc.h" -#include "Recast/Include/RecastAssert.h" +#include "Shared/Include/SharedAlloc.h" +#include "Shared/Include/SharedAssert.h" /// Check whether two bounding boxes overlap /// @@ -49,7 +49,7 @@ static rcSpan* allocSpan(rcHeightfield& hf) { // Create new page. // Allocate memory for the new pool. - rcSpanPool* spanPool = (rcSpanPool*)rcAlloc(sizeof(rcSpanPool), RC_ALLOC_PERM); + rcSpanPool* spanPool = (rcSpanPool*)rdAlloc(sizeof(rcSpanPool), RD_ALLOC_PERM); if (spanPool == NULL) { return NULL; @@ -194,7 +194,7 @@ bool rcAddSpan(rcContext* context, rcHeightfield& heightfield, const unsigned short spanMin, const unsigned short spanMax, const unsigned char areaID, const int flagMergeThreshold) { - rcAssert(context); + rdAssert(context); if (!addSpan(heightfield, x, z, spanMin, spanMax, areaID, flagMergeThreshold)) { @@ -228,7 +228,7 @@ static void dividePoly(const float* inVerts, int inVertsCount, float* outVerts2, int* outVerts2Count, float axisOffset, rcAxis axis) { - rcAssert(inVertsCount <= 12); + rdAssert(inVertsCount <= 12); // How far positive or negative away from the separating axis is each vertex. float inVertAxisDelta[12]; @@ -459,7 +459,7 @@ bool rcRasterizeTriangle(rcContext* context, const float* v0, const float* v1, const float* v2, const unsigned char areaID, rcHeightfield& heightfield, const int flagMergeThreshold) { - rcAssert(context != NULL); + rdAssert(context != NULL); rcScopedTimer timer(context, RC_TIMER_RASTERIZE_TRIANGLES); @@ -480,7 +480,7 @@ bool rcRasterizeTriangles(rcContext* context, const int* tris, const unsigned char* triAreaIDs, const int numTris, rcHeightfield& heightfield, const int flagMergeThreshold) { - rcAssert(context != NULL); + rdAssert(context != NULL); rcScopedTimer timer(context, RC_TIMER_RASTERIZE_TRIANGLES); @@ -507,7 +507,7 @@ bool rcRasterizeTriangles(rcContext* context, const unsigned short* tris, const unsigned char* triAreaIDs, const int numTris, rcHeightfield& heightfield, const int flagMergeThreshold) { - rcAssert(context != NULL); + rdAssert(context != NULL); rcScopedTimer timer(context, RC_TIMER_RASTERIZE_TRIANGLES); @@ -533,7 +533,7 @@ bool rcRasterizeTriangles(rcContext* context, const float* verts, const unsigned char* triAreaIDs, const int numTris, rcHeightfield& heightfield, const int flagMergeThreshold) { - rcAssert(context != NULL); + rdAssert(context != NULL); rcScopedTimer timer(context, RC_TIMER_RASTERIZE_TRIANGLES); diff --git a/src/thirdparty/recast/Recast/Source/RecastRegion.cpp b/src/thirdparty/recast/Recast/Source/RecastRegion.cpp index 0230a25b..13c25609 100644 --- a/src/thirdparty/recast/Recast/Source/RecastRegion.cpp +++ b/src/thirdparty/recast/Recast/Source/RecastRegion.cpp @@ -23,8 +23,8 @@ #include #include #include "Recast/Include/Recast.h" -#include "Recast/Include/RecastAlloc.h" -#include "Recast/Include/RecastAssert.h" +#include "Shared/Include/SharedAlloc.h" +#include "Shared/Include/SharedAssert.h" namespace { @@ -254,7 +254,7 @@ static bool floodRegion(int x, int y, int i, unsigned short level, unsigned short r, rcCompactHeightfield& chf, unsigned short* srcReg, unsigned short* srcDist, - rcTempVector& stack) + rdTempVector& stack) { const int w = chf.width; @@ -362,7 +362,7 @@ struct DirtyEntry static void expandRegions(int maxIter, unsigned short level, rcCompactHeightfield& chf, unsigned short* srcReg, unsigned short* srcDist, - rcTempVector& stack, + rdTempVector& stack, bool fillStack) { const int w = chf.width; @@ -398,7 +398,7 @@ static void expandRegions(int maxIter, unsigned short level, } } - rcTempVector dirtyEntries; + rdTempVector dirtyEntries; int iter = 0; while (stack.size() > 0) { @@ -471,7 +471,7 @@ static void expandRegions(int maxIter, unsigned short level, static void sortCellsByLevel(unsigned short startLevel, rcCompactHeightfield& chf, const unsigned short* srcReg, - unsigned int nbStacks, rcTempVector* stacks, + unsigned int nbStacks, rdTempVector* stacks, unsigned short loglevelsPerStack) // the levels per stack (2 in our case) as a bit shift { const int w = chf.width; @@ -506,8 +506,8 @@ static void sortCellsByLevel(unsigned short startLevel, } -static void appendStacks(const rcTempVector& srcStack, - rcTempVector& dstStack, +static void appendStacks(const rdTempVector& srcStack, + rdTempVector& dstStack, const unsigned short* srcReg) { for (int j=0; j regions; + rdTempVector regions; if (!regions.reserve(nreg)) { ctx->log(RC_LOG_ERROR, "mergeAndFilterRegions: Out of memory 'regions' (%d).", nreg); return false; @@ -860,8 +860,8 @@ static bool mergeAndFilterRegions(rcContext* ctx, int minRegionArea, int mergeRe } // Remove too small regions. - rcIntArray stack(32); - rcIntArray trace(32); + rdIntArray stack(32); + rdIntArray trace(32); for (int i = 0; i < nreg; ++i) { rcRegion& reg = regions[i]; @@ -1050,7 +1050,7 @@ static bool mergeAndFilterLayerRegions(rcContext* ctx, int minRegionArea, const int h = chf.height; const int nreg = maxRegionId+1; - rcTempVector regions; + rdTempVector regions; // Construct regions if (!regions.reserve(nreg)) { @@ -1061,7 +1061,7 @@ static bool mergeAndFilterLayerRegions(rcContext* ctx, int minRegionArea, regions.push_back(rcRegion((unsigned short) i)); // Find region neighbours and overlapping regions. - rcIntArray lregs(32); + rdIntArray lregs(32); for (int y = 0; y < h; ++y) { for (int x = 0; x < w; ++x) @@ -1130,7 +1130,7 @@ static bool mergeAndFilterLayerRegions(rcContext* ctx, int minRegionArea, regions[i].id = 0; // Merge montone regions to create non-overlapping areas. - rcIntArray stack(32); + rdIntArray stack(32); for (int i = 1; i < nreg; ++i) { rcRegion& root = regions[i]; @@ -1258,27 +1258,27 @@ static bool mergeAndFilterLayerRegions(rcContext* ctx, int minRegionArea, /// @see rcCompactHeightfield, rcBuildRegions, rcBuildRegionsMonotone bool rcBuildDistanceField(rcContext* ctx, rcCompactHeightfield& chf) { - rcAssert(ctx); + rdAssert(ctx); rcScopedTimer timer(ctx, RC_TIMER_BUILD_DISTANCEFIELD); if (chf.dist) { - rcFree(chf.dist); + rdFree(chf.dist); chf.dist = 0; } - unsigned short* src = (unsigned short*)rcAlloc(sizeof(unsigned short)*chf.spanCount, RC_ALLOC_TEMP); + unsigned short* src = (unsigned short*)rdAlloc(sizeof(unsigned short)*chf.spanCount, RD_ALLOC_TEMP); if (!src) { ctx->log(RC_LOG_ERROR, "rcBuildDistanceField: Out of memory 'src' (%d).", chf.spanCount); return false; } - unsigned short* dst = (unsigned short*)rcAlloc(sizeof(unsigned short)*chf.spanCount, RC_ALLOC_TEMP); + unsigned short* dst = (unsigned short*)rdAlloc(sizeof(unsigned short)*chf.spanCount, RD_ALLOC_TEMP); if (!dst) { ctx->log(RC_LOG_ERROR, "rcBuildDistanceField: Out of memory 'dst' (%d).", chf.spanCount); - rcFree(src); + rdFree(src); return false; } @@ -1302,7 +1302,7 @@ bool rcBuildDistanceField(rcContext* ctx, rcCompactHeightfield& chf) chf.dist = src; } - rcFree(dst); + rdFree(dst); return true; } @@ -1358,7 +1358,7 @@ struct rcSweepSpan bool rcBuildRegionsMonotone(rcContext* ctx, rcCompactHeightfield& chf, const int borderSize, const int minRegionArea, const int mergeRegionArea) { - rcAssert(ctx); + rdAssert(ctx); rcScopedTimer timer(ctx, RC_TIMER_BUILD_REGIONS); @@ -1366,7 +1366,7 @@ bool rcBuildRegionsMonotone(rcContext* ctx, rcCompactHeightfield& chf, const int h = chf.height; unsigned short id = 1; - rcScopedDelete srcReg((unsigned short*)rcAlloc(sizeof(unsigned short)*chf.spanCount, RC_ALLOC_TEMP)); + rdScopedDelete srcReg((unsigned short*)rdAlloc(sizeof(unsigned short)*chf.spanCount, RD_ALLOC_TEMP)); if (!srcReg) { ctx->log(RC_LOG_ERROR, "rcBuildRegionsMonotone: Out of memory 'src' (%d).", chf.spanCount); @@ -1375,7 +1375,7 @@ bool rcBuildRegionsMonotone(rcContext* ctx, rcCompactHeightfield& chf, memset(srcReg,0,sizeof(unsigned short)*chf.spanCount); const int nsweeps = rcMax(chf.width,chf.height); - rcScopedDelete sweeps((rcSweepSpan*)rcAlloc(sizeof(rcSweepSpan)*nsweeps, RC_ALLOC_TEMP)); + rdScopedDelete sweeps((rcSweepSpan*)rdAlloc(sizeof(rcSweepSpan)*nsweeps, RD_ALLOC_TEMP)); if (!sweeps) { ctx->log(RC_LOG_ERROR, "rcBuildRegionsMonotone: Out of memory 'sweeps' (%d).", nsweeps); @@ -1398,7 +1398,7 @@ bool rcBuildRegionsMonotone(rcContext* ctx, rcCompactHeightfield& chf, chf.borderSize = borderSize; - rcIntArray prev(256); + rdIntArray prev(256); // Sweep one line at a time. for (int y = borderSize; y < h-borderSize; ++y) @@ -1494,7 +1494,7 @@ bool rcBuildRegionsMonotone(rcContext* ctx, rcCompactHeightfield& chf, rcScopedTimer timerFilter(ctx, RC_TIMER_BUILD_REGIONS_FILTER); // Merge regions and filter out small regions. - rcIntArray overlaps; + rdIntArray overlaps; chf.maxRegions = id; if (!mergeAndFilterRegions(ctx, minRegionArea, mergeRegionArea, chf.maxRegions, chf, srcReg, overlaps)) return false; @@ -1531,14 +1531,14 @@ bool rcBuildRegionsMonotone(rcContext* ctx, rcCompactHeightfield& chf, bool rcBuildRegions(rcContext* ctx, rcCompactHeightfield& chf, const int borderSize, const int minRegionArea, const int mergeRegionArea) { - rcAssert(ctx); + rdAssert(ctx); rcScopedTimer timer(ctx, RC_TIMER_BUILD_REGIONS); const int w = chf.width; const int h = chf.height; - rcScopedDelete buf((unsigned short*)rcAlloc(sizeof(unsigned short)*chf.spanCount*2, RC_ALLOC_TEMP)); + rdScopedDelete buf((unsigned short*)rdAlloc(sizeof(unsigned short)*chf.spanCount*2, RD_ALLOC_TEMP)); if (!buf) { ctx->log(RC_LOG_ERROR, "rcBuildRegions: Out of memory 'tmp' (%d).", chf.spanCount*4); @@ -1549,11 +1549,11 @@ bool rcBuildRegions(rcContext* ctx, rcCompactHeightfield& chf, const int LOG_NB_STACKS = 3; const int NB_STACKS = 1 << LOG_NB_STACKS; - rcTempVector lvlStacks[NB_STACKS]; + rdTempVector lvlStacks[NB_STACKS]; for (int i=0; i stack; + rdTempVector stack; stack.reserve(256); unsigned short* srcReg = buf; @@ -1644,7 +1644,7 @@ bool rcBuildRegions(rcContext* ctx, rcCompactHeightfield& chf, rcScopedTimer timerFilter(ctx, RC_TIMER_BUILD_REGIONS_FILTER); // Merge regions and filter out small regions. - rcIntArray overlaps; + rdIntArray overlaps; chf.maxRegions = regionId; if (!mergeAndFilterRegions(ctx, minRegionArea, mergeRegionArea, chf.maxRegions, chf, srcReg, overlaps)) return false; @@ -1667,7 +1667,7 @@ bool rcBuildRegions(rcContext* ctx, rcCompactHeightfield& chf, bool rcBuildLayerRegions(rcContext* ctx, rcCompactHeightfield& chf, const int borderSize, const int minRegionArea) { - rcAssert(ctx); + rdAssert(ctx); rcScopedTimer timer(ctx, RC_TIMER_BUILD_REGIONS); @@ -1675,7 +1675,7 @@ bool rcBuildLayerRegions(rcContext* ctx, rcCompactHeightfield& chf, const int h = chf.height; unsigned short id = 1; - rcScopedDelete srcReg((unsigned short*)rcAlloc(sizeof(unsigned short)*chf.spanCount, RC_ALLOC_TEMP)); + rdScopedDelete srcReg((unsigned short*)rdAlloc(sizeof(unsigned short)*chf.spanCount, RD_ALLOC_TEMP)); if (!srcReg) { ctx->log(RC_LOG_ERROR, "rcBuildLayerRegions: Out of memory 'src' (%d).", chf.spanCount); @@ -1684,7 +1684,7 @@ bool rcBuildLayerRegions(rcContext* ctx, rcCompactHeightfield& chf, memset(srcReg,0,sizeof(unsigned short)*chf.spanCount); const int nsweeps = rcMax(chf.width,chf.height); - rcScopedDelete sweeps((rcSweepSpan*)rcAlloc(sizeof(rcSweepSpan)*nsweeps, RC_ALLOC_TEMP)); + rdScopedDelete sweeps((rcSweepSpan*)rdAlloc(sizeof(rcSweepSpan)*nsweeps, RD_ALLOC_TEMP)); if (!sweeps) { ctx->log(RC_LOG_ERROR, "rcBuildLayerRegions: Out of memory 'sweeps' (%d).", nsweeps); @@ -1707,7 +1707,7 @@ bool rcBuildLayerRegions(rcContext* ctx, rcCompactHeightfield& chf, chf.borderSize = borderSize; - rcIntArray prev(256); + rdIntArray prev(256); // Sweep one line at a time. for (int y = borderSize; y < h-borderSize; ++y) diff --git a/src/thirdparty/recast/Recast/Include/RecastAlloc.h b/src/thirdparty/recast/Shared/Include/SharedAlloc.h similarity index 56% rename from src/thirdparty/recast/Recast/Include/RecastAlloc.h rename to src/thirdparty/recast/Shared/Include/SharedAlloc.h index 44b572cd..22b9a1b4 100644 --- a/src/thirdparty/recast/Recast/Include/RecastAlloc.h +++ b/src/thirdparty/recast/Shared/Include/SharedAlloc.h @@ -16,40 +16,37 @@ // 3. This notice may not be removed or altered from any source distribution. // -#ifndef RECASTALLOC_H -#define RECASTALLOC_H +#ifndef RECASTDETOURALLOC_H +#define RECASTDETOURALLOC_H -#include "RecastAssert.h" - -#include -#include +#include "SharedAssert.h" /// Provides hint values to the memory allocator on how long the /// memory is expected to be used. -enum rcAllocHint +enum rdAllocHint { - RC_ALLOC_PERM, ///< Memory will persist after a function call. - RC_ALLOC_TEMP ///< Memory used temporarily within a function. + RD_ALLOC_PERM, ///< Memory will persist after a function call. + RD_ALLOC_TEMP ///< Memory used temporarily within a function. }; /// A memory allocation function. // @param[in] size The size, in bytes of memory, to allocate. -// @param[in] rcAllocHint A hint to the allocator on how long the memory is expected to be in use. +// @param[in] rdAllocHint A hint to the allocator on how long the memory is expected to be in use. // @return A pointer to the beginning of the allocated memory block, or null if the allocation failed. -/// @see rcAllocSetCustom -typedef void* (rcAllocFunc)(size_t size, rcAllocHint hint); +/// @see rdAllocSetCustom +typedef void* (rdAllocFunc)(size_t size, rdAllocHint hint); /// A memory deallocation function. -/// @param[in] ptr A pointer to a memory block previously allocated using #rcAllocFunc. -/// @see rcAllocSetCustom -typedef void (rcFreeFunc)(void* ptr); +/// @param[in] ptr A pointer to a memory block previously allocated using #rdAllocFunc. +/// @see rdAllocSetCustom +typedef void (rdFreeFunc)(void* ptr); /// Sets the base custom allocation functions to be used by Recast. -/// @param[in] allocFunc The memory allocation function to be used by #rcAlloc -/// @param[in] freeFunc The memory de-allocation function to be used by #rcFree +/// @param[in] allocFunc The memory allocation function to be used by #rdAlloc +/// @param[in] freeFunc The memory de-allocation function to be used by #rdFree /// -/// @see rcAlloc, rcFree -void rcAllocSetCustom(rcAllocFunc *allocFunc, rcFreeFunc *freeFunc); +/// @see rdAlloc, rdFree +void rdAllocSetCustom(rdAllocFunc *allocFunc, rdFreeFunc *freeFunc); /// Allocates a memory block. /// @@ -57,102 +54,102 @@ void rcAllocSetCustom(rcAllocFunc *allocFunc, rcFreeFunc *freeFunc); /// @param[in] hint A hint to the allocator on how long the memory is expected to be in use. /// @return A pointer to the beginning of the allocated memory block, or null if the allocation failed. /// -/// @see rcFree, rcAllocSetCustom -void* rcAlloc(size_t size, rcAllocHint hint); +/// @see rdFree, rdAllocSetCustom +void* rdAlloc(size_t size, rdAllocHint hint); /// Deallocates a memory block. If @p ptr is NULL, this does nothing. /// /// @warning This function leaves the value of @p ptr unchanged. So it still /// points to the same (now invalid) location, and not to null. /// -/// @param[in] ptr A pointer to a memory block previously allocated using #rcAlloc. +/// @param[in] ptr A pointer to a memory block previously allocated using #rdAlloc. /// -/// @see rcAlloc, rcAllocSetCustom -void rcFree(void* ptr); +/// @see rdAlloc, rdAllocSetCustom +void rdFree(void* ptr); /// An implementation of operator new usable for placement new. The default one is part of STL (which we don't use). -/// rcNewTag is a dummy type used to differentiate our operator from the STL one, in case users import both Recast +/// rdNewTag is a dummy type used to differentiate our operator from the STL one, in case users import both Recast /// and STL. -struct rcNewTag {}; -inline void* operator new(size_t, const rcNewTag&, void* p) { return p; } -inline void operator delete(void*, const rcNewTag&, void*) {} +struct rdNewTag {}; +inline void* operator new(size_t, const rdNewTag&, void* p) { return p; } +inline void operator delete(void*, const rdNewTag&, void*) {} -/// Signed to avoid warnnings when comparing to int loop indexes, and common error with comparing to zero. +/// Signed to avoid warnings when comparing to int loop indexes, and common error with comparing to zero. /// MSVC2010 has a bug where ssize_t is unsigned (!!!). -typedef intptr_t rcSizeType; -#define RC_SIZE_MAX INTPTR_MAX +typedef intptr_t rdSizeType; +#define RD_SIZE_MAX INTPTR_MAX /// Macros to hint to the compiler about the likeliest branch. Please add a benchmark that demonstrates a performance /// improvement before introducing use cases. #if defined(__GNUC__) || defined(__clang__) -#define rcLikely(x) __builtin_expect((x), true) -#define rcUnlikely(x) __builtin_expect((x), false) +#define rdLikely(x) __builtin_expect((x), true) +#define rdUnlikely(x) __builtin_expect((x), false) #else -#define rcLikely(x) (x) -#define rcUnlikely(x) (x) +#define rdLikely(x) (x) +#define rdUnlikely(x) (x) #endif /// Variable-sized storage type. Mimics the interface of std::vector with some notable differences: -/// * Uses rcAlloc()/rcFree() to handle storage. +/// * Uses rdAlloc()/rdFree() to handle storage. /// * No support for a custom allocator. /// * Uses signed size instead of size_t to avoid warnings in for loops: "for (int i = 0; i < foo.size(); i++)" /// * Omits methods of limited utility: insert/erase, (bad performance), at (we don't use exceptions), operator=. /// * assign() and the pre-sizing constructor follow C++11 semantics -- they don't construct a temporary if no value is provided. /// * push_back() and resize() support adding values from the current vector. Range-based constructors and assign(begin, end) do not. /// * No specialization for bool. -template -class rcVectorBase { - rcSizeType m_size; - rcSizeType m_cap; +template +class rdVectorBase { + rdSizeType m_size; + rdSizeType m_cap; T* m_data; // Constructs a T at the give address with either the copy constructor or the default. - static void construct(T* p, const T& v) { ::new(rcNewTag(), (void*)p) T(v); } - static void construct(T* p) { ::new(rcNewTag(), (void*)p) T; } + static void construct(T* p, const T& v) { ::new(rdNewTag(), (void*)p) T(v); } + static void construct(T* p) { ::new(rdNewTag(), (void*)p) T; } static void construct_range(T* begin, T* end); static void construct_range(T* begin, T* end, const T& value); static void copy_range(T* dst, const T* begin, const T* end); - void destroy_range(rcSizeType begin, rcSizeType end); + void destroy_range(rdSizeType begin, rdSizeType end); // Creates an array of the given size, copies all of this vector's data into it, and returns it. - T* allocate_and_copy(rcSizeType size); - void resize_impl(rcSizeType size, const T* value); + T* allocate_and_copy(rdSizeType size); + void resize_impl(rdSizeType size, const T* value); // Requires: min_capacity > m_cap. - rcSizeType get_new_capacity(rcSizeType min_capacity); + rdSizeType get_new_capacity(rdSizeType min_capacity); public: - typedef rcSizeType size_type; + typedef rdSizeType size_type; typedef T value_type; - rcVectorBase() : m_size(0), m_cap(0), m_data(0) {} - rcVectorBase(const rcVectorBase& other) : m_size(0), m_cap(0), m_data(0) { assign(other.begin(), other.end()); } - explicit rcVectorBase(rcSizeType count) : m_size(0), m_cap(0), m_data(0) { resize(count); } - rcVectorBase(rcSizeType count, const T& value) : m_size(0), m_cap(0), m_data(0) { resize(count, value); } - rcVectorBase(const T* begin, const T* end) : m_size(0), m_cap(0), m_data(0) { assign(begin, end); } - ~rcVectorBase() { destroy_range(0, m_size); rcFree(m_data); } + rdVectorBase() : m_size(0), m_cap(0), m_data(0) {} + rdVectorBase(const rdVectorBase& other) : m_size(0), m_cap(0), m_data(0) { assign(other.begin(), other.end()); } + explicit rdVectorBase(rdSizeType count) : m_size(0), m_cap(0), m_data(0) { resize(count); } + rdVectorBase(rdSizeType count, const T& value) : m_size(0), m_cap(0), m_data(0) { resize(count, value); } + rdVectorBase(const T* begin, const T* end) : m_size(0), m_cap(0), m_data(0) { assign(begin, end); } + ~rdVectorBase() { destroy_range(0, m_size); rdFree(m_data); } // Unlike in std::vector, we return a bool to indicate whether the alloc was successful. - bool reserve(rcSizeType size); + bool reserve(rdSizeType size); - void assign(rcSizeType count, const T& value) { clear(); resize(count, value); } + void assign(rdSizeType count, const T& value) { clear(); resize(count, value); } void assign(const T* begin, const T* end); - void resize(rcSizeType size) { resize_impl(size, NULL); } - void resize(rcSizeType size, const T& value) { resize_impl(size, &value); } + void resize(rdSizeType size) { resize_impl(size, NULL); } + void resize(rdSizeType size, const T& value) { resize_impl(size, &value); } // Not implemented as resize(0) because resize requires T to be default-constructible. void clear() { destroy_range(0, m_size); m_size = 0; } void push_back(const T& value); - void pop_back() { rcAssert(m_size > 0); back().~T(); m_size--; } + void pop_back() { rdAssert(m_size > 0); back().~T(); m_size--; } - rcSizeType size() const { return m_size; } - rcSizeType capacity() const { return m_cap; } + rdSizeType size() const { return m_size; } + rdSizeType capacity() const { return m_cap; } bool empty() const { return size() == 0; } - const T& operator[](rcSizeType i) const { rcAssert(i >= 0 && i < m_size); return m_data[i]; } - T& operator[](rcSizeType i) { rcAssert(i >= 0 && i < m_size); return m_data[i]; } + const T& operator[](rdSizeType i) const { rdAssert(i >= 0 && i < m_size); return m_data[i]; } + T& operator[](rdSizeType i) { rdAssert(i >= 0 && i < m_size); return m_data[i]; } - const T& front() const { rcAssert(m_size); return m_data[0]; } - T& front() { rcAssert(m_size); return m_data[0]; } - const T& back() const { rcAssert(m_size); return m_data[m_size - 1]; } - T& back() { rcAssert(m_size); return m_data[m_size - 1]; } + const T& front() const { rdAssert(m_size); return m_data[0]; } + T& front() { rdAssert(m_size); return m_data[0]; } + const T& back() const { rdAssert(m_size); return m_data[m_size - 1]; } + T& back() { rdAssert(m_size); return m_data[m_size - 1]; } const T* data() const { return m_data; } T* data() { return m_data; } @@ -161,14 +158,14 @@ class rcVectorBase { const T* begin() const { return m_data; } const T* end() const { return m_data + m_size; } - void swap(rcVectorBase& other); + void swap(rdVectorBase& other); // Explicitly deleted. - rcVectorBase& operator=(const rcVectorBase& other); + rdVectorBase& operator=(const rdVectorBase& other); }; -template -bool rcVectorBase::reserve(rcSizeType count) { +template +bool rdVectorBase::reserve(rdSizeType count) { if (count <= m_cap) { return true; } @@ -177,37 +174,37 @@ bool rcVectorBase::reserve(rcSizeType count) { return false; } destroy_range(0, m_size); - rcFree(m_data); + rdFree(m_data); m_data = new_data; m_cap = count; return true; } -template -T* rcVectorBase::allocate_and_copy(rcSizeType size) { - rcAssert(RC_SIZE_MAX / static_cast(sizeof(T)) >= size); - T* new_data = static_cast(rcAlloc(sizeof(T) * size, H)); +template +T* rdVectorBase::allocate_and_copy(rdSizeType size) { + rdAssert(RD_SIZE_MAX / static_cast(sizeof(T)) >= size); + T* new_data = static_cast(rdAlloc(sizeof(T) * size, H)); if (new_data) { copy_range(new_data, m_data, m_data + m_size); } return new_data; } -template -void rcVectorBase::assign(const T* begin, const T* end) { +template +void rdVectorBase::assign(const T* begin, const T* end) { clear(); reserve(end - begin); m_size = end - begin; copy_range(m_data, begin, end); } -template -void rcVectorBase::push_back(const T& value) { - // rcLikely increases performance by ~50% on BM_rcVector_PushPreallocated, - // and by ~2-5% on BM_rcVector_Push. - if (rcLikely(m_size < m_cap)) { +template +void rdVectorBase::push_back(const T& value) { + // rdLikely increases performance by ~50% on BM_rdVector_PushPreallocated, + // and by ~2-5% on BM_rdVector_Push. + if (rdLikely(m_size < m_cap)) { construct(m_data + m_size++, value); return; } - const rcSizeType new_cap = get_new_capacity(m_cap + 1); + const rdSizeType new_cap = get_new_capacity(m_cap + 1); T* data = allocate_and_copy(new_cap); // construct between allocate and destroy+free in case value is // in this vector. @@ -215,20 +212,20 @@ void rcVectorBase::push_back(const T& value) { destroy_range(0, m_size); m_size++; m_cap = new_cap; - rcFree(m_data); + rdFree(m_data); m_data = data; } -template -rcSizeType rcVectorBase::get_new_capacity(rcSizeType min_capacity) { - rcAssert(min_capacity <= RC_SIZE_MAX); - if (rcUnlikely(m_cap >= RC_SIZE_MAX / 2)) - return RC_SIZE_MAX; +template +rdSizeType rdVectorBase::get_new_capacity(rdSizeType min_capacity) { + rdAssert(min_capacity <= RD_SIZE_MAX); + if (rdUnlikely(m_cap >= RD_SIZE_MAX / 2)) + return RD_SIZE_MAX; return 2 * m_cap > min_capacity ? 2 * m_cap : min_capacity; } -template -void rcVectorBase::resize_impl(rcSizeType size, const T* value) { +template +void rdVectorBase::resize_impl(rdSizeType size, const T* value) { if (size < m_size) { destroy_range(size, m_size); m_size = size; @@ -241,7 +238,7 @@ void rcVectorBase::resize_impl(rcSizeType size, const T* value) { } m_size = size; } else { - const rcSizeType new_cap = get_new_capacity(size); + const rdSizeType new_cap = get_new_capacity(size); T* new_data = allocate_and_copy(new_cap); // We defer deconstructing/freeing old data until after constructing // new elements in case "value" is there. @@ -251,18 +248,18 @@ void rcVectorBase::resize_impl(rcSizeType size, const T* value) { construct_range(new_data + m_size, new_data + size); } destroy_range(0, m_size); - rcFree(m_data); + rdFree(m_data); m_data = new_data; m_cap = new_cap; m_size = size; } } } -template -void rcVectorBase::swap(rcVectorBase& other) { +template +void rdVectorBase::swap(rdVectorBase& other) { // TODO: Reorganize headers so we can use rcSwap here. - rcSizeType tmp_cap = other.m_cap; - rcSizeType tmp_size = other.m_size; + rdSizeType tmp_cap = other.m_cap; + rdSizeType tmp_size = other.m_size; T* tmp_data = other.m_data; other.m_cap = m_cap; @@ -274,62 +271,62 @@ void rcVectorBase::swap(rcVectorBase& other) { m_data = tmp_data; } // static -template -void rcVectorBase::construct_range(T* begin, T* end) { +template +void rdVectorBase::construct_range(T* begin, T* end) { for (T* p = begin; p < end; p++) { construct(p); } } // static -template -void rcVectorBase::construct_range(T* begin, T* end, const T& value) { +template +void rdVectorBase::construct_range(T* begin, T* end, const T& value) { for (T* p = begin; p < end; p++) { construct(p, value); } } // static -template -void rcVectorBase::copy_range(T* dst, const T* begin, const T* end) { - for (rcSizeType i = 0 ; i < end - begin; i++) { +template +void rdVectorBase::copy_range(T* dst, const T* begin, const T* end) { + for (rdSizeType i = 0 ; i < end - begin; i++) { construct(dst + i, begin[i]); } } -template -void rcVectorBase::destroy_range(rcSizeType begin, rcSizeType end) { - for (rcSizeType i = begin; i < end; i++) { +template +void rdVectorBase::destroy_range(rdSizeType begin, rdSizeType end) { + for (rdSizeType i = begin; i < end; i++) { m_data[i].~T(); } } template -class rcTempVector : public rcVectorBase { - typedef rcVectorBase Base; +class rdTempVector : public rdVectorBase { + typedef rdVectorBase Base; public: - rcTempVector() : Base() {} - explicit rcTempVector(rcSizeType size) : Base(size) {} - rcTempVector(rcSizeType size, const T& value) : Base(size, value) {} - rcTempVector(const rcTempVector& other) : Base(other) {} - rcTempVector(const T* begin, const T* end) : Base(begin, end) {} + rdTempVector() : Base() {} + explicit rdTempVector(rdSizeType size) : Base(size) {} + rdTempVector(rdSizeType size, const T& value) : Base(size, value) {} + rdTempVector(const rdTempVector& other) : Base(other) {} + rdTempVector(const T* begin, const T* end) : Base(begin, end) {} }; template -class rcPermVector : public rcVectorBase { - typedef rcVectorBase Base; +class rdPermVector : public rdVectorBase { + typedef rdVectorBase Base; public: - rcPermVector() : Base() {} - explicit rcPermVector(rcSizeType size) : Base(size) {} - rcPermVector(rcSizeType size, const T& value) : Base(size, value) {} - rcPermVector(const rcPermVector& other) : Base(other) {} - rcPermVector(const T* begin, const T* end) : Base(begin, end) {} + rdPermVector() : Base() {} + explicit rdPermVector(rdSizeType size) : Base(size) {} + rdPermVector(rdSizeType size, const T& value) : Base(size, value) {} + rdPermVector(const rdPermVector& other) : Base(other) {} + rdPermVector(const T* begin, const T* end) : Base(begin, end) {} }; -/// Legacy class. Prefer rcVector. -class rcIntArray +/// Legacy class. Prefer rdVector. +class rdIntArray { - rcTempVector m_impl; + rdTempVector m_impl; public: - rcIntArray() {} - rcIntArray(int n) : m_impl(n, 0) {} + rdIntArray() {} + rdIntArray(int n) : m_impl(n, 0) {} void push(int item) { m_impl.push_back(item); } void resize(int size) { m_impl.resize(size); } void clear() { m_impl.clear(); } @@ -348,18 +345,18 @@ public: /// A simple helper class used to delete an array when it goes out of scope. /// @note This class is rarely if ever used by the end user. -template class rcScopedDelete +template class rdScopedDelete { T* ptr; public: /// Constructs an instance with a null pointer. - inline rcScopedDelete() : ptr(0) {} + inline rdScopedDelete() : ptr(0) {} /// Constructs an instance with the specified pointer. /// @param[in] p An pointer to an allocated array. - inline rcScopedDelete(T* p) : ptr(p) {} - inline ~rcScopedDelete() { rcFree(ptr); } + inline rdScopedDelete(T* p) : ptr(p) {} + inline ~rdScopedDelete() { rdFree(ptr); } /// The root array pointer. /// @return The root array pointer. @@ -367,8 +364,8 @@ public: private: // Explicitly disabled copy constructor and copy assignment operator. - rcScopedDelete(const rcScopedDelete&); - rcScopedDelete& operator=(const rcScopedDelete&); + rdScopedDelete(const rdScopedDelete&); + rdScopedDelete& operator=(const rdScopedDelete&); }; -#endif +#endif // RECASTDETOURALLOC_H diff --git a/src/thirdparty/recast/Detour/Include/DetourAssert.h b/src/thirdparty/recast/Shared/Include/SharedAssert.h similarity index 79% rename from src/thirdparty/recast/Detour/Include/DetourAssert.h rename to src/thirdparty/recast/Shared/Include/SharedAssert.h index e05fd66f..0b00663a 100644 --- a/src/thirdparty/recast/Detour/Include/DetourAssert.h +++ b/src/thirdparty/recast/Shared/Include/SharedAssert.h @@ -16,8 +16,8 @@ // 3. This notice may not be removed or altered from any source distribution. // -#ifndef DETOURASSERT_H -#define DETOURASSERT_H +#ifndef RECASTDETOURASSERT_H +#define RECASTDETOURASSERT_H // Note: This header file's only purpose is to include define assert. // Feel free to change the file and include your own implementation instead. @@ -25,7 +25,7 @@ #ifdef NDEBUG // From http://cnicholson.net/2009/02/stupid-c-tricks-adventures-in-assert/ -# define dtAssert(x) do { (void)sizeof(x); } while((void)(__LINE__==-1),false) +# define rdAssert(x) do { (void)sizeof(x); } while((void)(__LINE__==-1),false) #else @@ -33,24 +33,24 @@ // @param[in] expression asserted expression. // @param[in] file Filename of the failed assertion. // @param[in] line Line number of the failed assertion. -/// @see dtAssertFailSetCustom -typedef void (dtAssertFailFunc)(const char* expression, const char* file, int line); +/// @see rdAssertFailSetCustom +typedef void (rdAssertFailFunc)(const char* expression, const char* file, int line); /// Sets the base custom assertion failure function to be used by Detour. -/// @param[in] assertFailFunc The function to be invoked in case of failure of #dtAssert -void dtAssertFailSetCustom(dtAssertFailFunc *assertFailFunc); +/// @param[in] assertFailFunc The function to be invoked in case of failure of #rdAssert +void rdAssertFailSetCustom(rdAssertFailFunc *assertFailFunc); /// Gets the base custom assertion failure function to be used by Detour. -dtAssertFailFunc* dtAssertFailGetCustom(); +rdAssertFailFunc* rdAssertFailGetCustom(); # include -# define dtAssert(expression) \ +# define rdAssert(expression) \ { \ - dtAssertFailFunc* failFunc = dtAssertFailGetCustom(); \ + rdAssertFailFunc* failFunc = rdAssertFailGetCustom(); \ if(failFunc == NULL) { assert(expression); } \ else if(!(expression)) { (*failFunc)(#expression, __FILE__, __LINE__); } \ } #endif -#endif // DETOURASSERT_H +#endif // RECASTDETOURASSERT_H