diff --git a/Engine/source/gfx/gl/gfxGLDevice.cpp b/Engine/source/gfx/gl/gfxGLDevice.cpp index 8019f21bf..e9ba531a9 100644 --- a/Engine/source/gfx/gl/gfxGLDevice.cpp +++ b/Engine/source/gfx/gl/gfxGLDevice.cpp @@ -704,6 +704,9 @@ inline void GFXGLDevice::postDrawPrimitive(U32 primitiveCount) { mDeviceStatistics.mDrawCalls++; mDeviceStatistics.mPolyCount += primitiveCount; + + mVolatileVBs.clear(); + mVolatilePBs.clear(); } void GFXGLDevice::drawPrimitive( GFXPrimitiveType primType, U32 vertexStart, U32 primitiveCount ) diff --git a/Engine/source/navigation/ChunkyTriMesh.cpp b/Engine/source/navigation/ChunkyTriMesh.cpp new file mode 100644 index 000000000..242bf285a --- /dev/null +++ b/Engine/source/navigation/ChunkyTriMesh.cpp @@ -0,0 +1,315 @@ +// +// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. +// + +#include "ChunkyTriMesh.h" +#include +#include +#include + +struct BoundsItem +{ + float bmin[2]; + float bmax[2]; + int i; +}; + +static int compareItemX(const void* va, const void* vb) +{ + const BoundsItem* a = (const BoundsItem*)va; + const BoundsItem* b = (const BoundsItem*)vb; + if (a->bmin[0] < b->bmin[0]) + return -1; + if (a->bmin[0] > b->bmin[0]) + return 1; + return 0; +} + +static int compareItemY(const void* va, const void* vb) +{ + const BoundsItem* a = (const BoundsItem*)va; + const BoundsItem* b = (const BoundsItem*)vb; + if (a->bmin[1] < b->bmin[1]) + return -1; + if (a->bmin[1] > b->bmin[1]) + return 1; + return 0; +} + +static void calcExtends(const BoundsItem* items, const int /*nitems*/, + const int imin, const int imax, + float* bmin, float* bmax) +{ + bmin[0] = items[imin].bmin[0]; + bmin[1] = items[imin].bmin[1]; + + bmax[0] = items[imin].bmax[0]; + bmax[1] = items[imin].bmax[1]; + + for (int i = imin+1; i < imax; ++i) + { + const BoundsItem& it = items[i]; + if (it.bmin[0] < bmin[0]) bmin[0] = it.bmin[0]; + if (it.bmin[1] < bmin[1]) bmin[1] = it.bmin[1]; + + if (it.bmax[0] > bmax[0]) bmax[0] = it.bmax[0]; + if (it.bmax[1] > bmax[1]) bmax[1] = it.bmax[1]; + } +} + +inline int longestAxis(float x, float y) +{ + return y > x ? 1 : 0; +} + +static void subdivide(BoundsItem* items, int nitems, int imin, int imax, int trisPerChunk, + int& curNode, rcChunkyTriMeshNode* nodes, const int maxNodes, + int& curTri, int* outTris, const int* inTris) +{ + int inum = imax - imin; + int icur = curNode; + + if (curNode >= maxNodes) + return; + + rcChunkyTriMeshNode& node = nodes[curNode++]; + + if (inum <= trisPerChunk) + { + // Leaf + calcExtends(items, nitems, imin, imax, node.bmin, node.bmax); + + // Copy triangles. + node.i = curTri; + node.n = inum; + + for (int i = imin; i < imax; ++i) + { + const int* src = &inTris[items[i].i*3]; + int* dst = &outTris[curTri*3]; + curTri++; + dst[0] = src[0]; + dst[1] = src[1]; + dst[2] = src[2]; + } + } + else + { + // Split + calcExtends(items, nitems, imin, imax, node.bmin, node.bmax); + + int axis = longestAxis(node.bmax[0] - node.bmin[0], + node.bmax[1] - node.bmin[1]); + + if (axis == 0) + { + // Sort along x-axis + qsort(items+imin, static_cast(inum), sizeof(BoundsItem), compareItemX); + } + else if (axis == 1) + { + // Sort along y-axis + qsort(items+imin, static_cast(inum), sizeof(BoundsItem), compareItemY); + } + + int isplit = imin+inum/2; + + // Left + subdivide(items, nitems, imin, isplit, trisPerChunk, curNode, nodes, maxNodes, curTri, outTris, inTris); + // Right + subdivide(items, nitems, isplit, imax, trisPerChunk, curNode, nodes, maxNodes, curTri, outTris, inTris); + + int iescape = curNode - icur; + // Negative index means escape. + node.i = -iescape; + } +} + +bool rcCreateChunkyTriMesh(const float* verts, const int* tris, int ntris, + int trisPerChunk, rcChunkyTriMesh* cm) +{ + int nchunks = (ntris + trisPerChunk-1) / trisPerChunk; + + cm->nodes = new rcChunkyTriMeshNode[nchunks*4]; + if (!cm->nodes) + return false; + + cm->tris = new int[ntris*3]; + if (!cm->tris) + return false; + + cm->ntris = ntris; + + // Build tree + BoundsItem* items = new BoundsItem[ntris]; + if (!items) + return false; + + for (int i = 0; i < ntris; i++) + { + const int* t = &tris[i*3]; + BoundsItem& it = items[i]; + it.i = i; + // Calc triangle XZ bounds. + it.bmin[0] = it.bmax[0] = verts[t[0]*3+0]; + it.bmin[1] = it.bmax[1] = verts[t[0]*3+2]; + for (int j = 1; j < 3; ++j) + { + const float* v = &verts[t[j]*3]; + if (v[0] < it.bmin[0]) it.bmin[0] = v[0]; + if (v[2] < it.bmin[1]) it.bmin[1] = v[2]; + + if (v[0] > it.bmax[0]) it.bmax[0] = v[0]; + if (v[2] > it.bmax[1]) it.bmax[1] = v[2]; + } + } + + int curTri = 0; + int curNode = 0; + subdivide(items, ntris, 0, ntris, trisPerChunk, curNode, cm->nodes, nchunks*4, curTri, cm->tris, tris); + + delete [] items; + + cm->nnodes = curNode; + + // Calc max tris per node. + cm->maxTrisPerChunk = 0; + for (int i = 0; i < cm->nnodes; ++i) + { + rcChunkyTriMeshNode& node = cm->nodes[i]; + const bool isLeaf = node.i >= 0; + if (!isLeaf) continue; + if (node.n > cm->maxTrisPerChunk) + cm->maxTrisPerChunk = node.n; + } + + return true; +} + + +inline bool checkOverlapRect(const float amin[2], const float amax[2], + const float bmin[2], const float bmax[2]) +{ + bool overlap = true; + overlap = (amin[0] > bmax[0] || amax[0] < bmin[0]) ? false : overlap; + overlap = (amin[1] > bmax[1] || amax[1] < bmin[1]) ? false : overlap; + return overlap; +} + +int rcGetChunksOverlappingRect(const rcChunkyTriMesh* cm, + float bmin[2], float bmax[2], + int* ids, const int maxIds) +{ + // Traverse tree + int i = 0; + int n = 0; + while (i < cm->nnodes) + { + const rcChunkyTriMeshNode* node = &cm->nodes[i]; + const bool overlap = checkOverlapRect(bmin, bmax, node->bmin, node->bmax); + const bool isLeafNode = node->i >= 0; + + if (isLeafNode && overlap) + { + if (n < maxIds) + { + ids[n] = i; + n++; + } + } + + if (overlap || isLeafNode) + i++; + else + { + const int escapeIndex = -node->i; + i += escapeIndex; + } + } + + return n; +} + + + +static bool checkOverlapSegment(const float p[2], const float q[2], + const float bmin[2], const float bmax[2]) +{ + static const float EPSILON = 1e-6f; + + float tmin = 0; + float tmax = 1; + float d[2]; + d[0] = q[0] - p[0]; + d[1] = q[1] - p[1]; + + for (int i = 0; i < 2; i++) + { + if (fabsf(d[i]) < EPSILON) + { + // Ray is parallel to slab. No hit if origin not within slab + if (p[i] < bmin[i] || p[i] > bmax[i]) + return false; + } + else + { + // Compute intersection t value of ray with near and far plane of slab + float ood = 1.0f / d[i]; + float t1 = (bmin[i] - p[i]) * ood; + float t2 = (bmax[i] - p[i]) * ood; + if (t1 > t2) { float tmp = t1; t1 = t2; t2 = tmp; } + if (t1 > tmin) tmin = t1; + if (t2 < tmax) tmax = t2; + if (tmin > tmax) return false; + } + } + return true; +} + +int rcGetChunksOverlappingSegment(const rcChunkyTriMesh* cm, + float p[2], float q[2], + int* ids, const int maxIds) +{ + // Traverse tree + int i = 0; + int n = 0; + while (i < cm->nnodes) + { + const rcChunkyTriMeshNode* node = &cm->nodes[i]; + const bool overlap = checkOverlapSegment(p, q, node->bmin, node->bmax); + const bool isLeafNode = node->i >= 0; + + if (isLeafNode && overlap) + { + if (n < maxIds) + { + ids[n] = i; + n++; + } + } + + if (overlap || isLeafNode) + i++; + else + { + const int escapeIndex = -node->i; + i += escapeIndex; + } + } + + return n; +} diff --git a/Engine/source/navigation/ChunkyTriMesh.h b/Engine/source/navigation/ChunkyTriMesh.h new file mode 100644 index 000000000..0870d64ef --- /dev/null +++ b/Engine/source/navigation/ChunkyTriMesh.h @@ -0,0 +1,59 @@ +// +// 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 CHUNKYTRIMESH_H +#define CHUNKYTRIMESH_H + +struct rcChunkyTriMeshNode +{ + float bmin[2]; + float bmax[2]; + int i; + int n; +}; + +struct rcChunkyTriMesh +{ + inline rcChunkyTriMesh() : nodes(0), nnodes(0), tris(0), ntris(0), maxTrisPerChunk(0) {} + inline ~rcChunkyTriMesh() { delete [] nodes; delete [] tris; } + + rcChunkyTriMeshNode* nodes; + int nnodes; + int* tris; + int ntris; + int maxTrisPerChunk; + +private: + // Explicitly disabled copy constructor and copy assignment operator. + rcChunkyTriMesh(const rcChunkyTriMesh&); + rcChunkyTriMesh& operator=(const rcChunkyTriMesh&); +}; + +/// Creates partitioned triangle mesh (AABB tree), +/// where each node contains at max trisPerChunk triangles. +bool rcCreateChunkyTriMesh(const float* verts, const int* tris, int ntris, + int trisPerChunk, rcChunkyTriMesh* cm); + +/// Returns the chunk indices which overlap the input rectable. +int rcGetChunksOverlappingRect(const rcChunkyTriMesh* cm, float bmin[2], float bmax[2], int* ids, const int maxIds); + +/// Returns the chunk indices which overlap the input segment. +int rcGetChunksOverlappingSegment(const rcChunkyTriMesh* cm, float p[2], float q[2], int* ids, const int maxIds); + + +#endif // CHUNKYTRIMESH_H diff --git a/Engine/source/navigation/duDebugDrawTorque.cpp b/Engine/source/navigation/duDebugDrawTorque.cpp index 5799b837e..1079e22a7 100644 --- a/Engine/source/navigation/duDebugDrawTorque.cpp +++ b/Engine/source/navigation/duDebugDrawTorque.cpp @@ -51,7 +51,7 @@ duDebugDrawTorque::~duDebugDrawTorque() void duDebugDrawTorque::depthMask(bool state) { - mDesc.setZReadWrite(state, state); + mDesc.setZReadWrite(state, false); } void duDebugDrawTorque::texture(bool state) @@ -94,7 +94,7 @@ void duDebugDrawTorque::begin(duDebugDrawPrimitives prim, float size) case DU_DRAW_QUADS: mPrimType = GFXTriangleList; mQuadsMode = true; break; } - mDesc.setCullMode(GFXCullNone); + mDesc.setCullMode(GFXCullCW); mDesc.setBlend(true); } diff --git a/Engine/source/navigation/navMesh.cpp b/Engine/source/navigation/navMesh.cpp index 2cdeaddeb..1d6090d65 100644 --- a/Engine/source/navigation/navMesh.cpp +++ b/Engine/source/navigation/navMesh.cpp @@ -173,6 +173,12 @@ DefineEngineFunction(NavMeshUpdateOne, void, (S32 meshid, S32 objid, bool remove } NavMesh::NavMesh() +: m_triareas(0), + m_solid(0), + m_chf(0), + m_cset(0), + m_pmesh(0), + m_dmesh(0) { mTypeMask |= StaticShapeObjectType | MarkerObjectType; mFileName = StringTable->EmptyString(); @@ -184,8 +190,7 @@ NavMesh::NavMesh() mWaterMethod = Ignore; - dMemset(&cfg, 0, sizeof(cfg)); - mCellSize = mCellHeight = 0.2f; + mCellSize = mCellHeight = 0.01f; mWalkableHeight = 2.0f; mWalkableClimb = 0.3f; mWalkableRadius = 0.5f; @@ -599,6 +604,13 @@ DefineEngineMethod(NavMesh, deleteLinks, void, (),, //object->eraseLinks(); } +static void buildCallback(SceneObject* object, void* key) +{ + SceneContainer::CallbackInfo* info = reinterpret_cast(key); + if (!object->mPathfindingIgnore) + object->buildPolyList(info->context, info->polyList, info->boundingBox, info->boundingSphere); +} + bool NavMesh::build(bool background, bool saveIntermediates) { if(mBuilding) @@ -622,14 +634,53 @@ bool NavMesh::build(bool background, bool saveIntermediates) return false; } - updateConfig(); + Box3F worldBox = getWorldBox(); + SceneContainer::CallbackInfo info; + info.context = PLC_Navigation; + info.boundingBox = worldBox; + m_geo = new RecastPolyList; + info.polyList = m_geo; + info.key = this; + getContainer()->findObjects(worldBox, StaticObjectType | DynamicShapeObjectType, buildCallback, &info); + + // Parse water objects into the same list, but remember how much geometry was /not/ water. + U32 nonWaterVertCount = m_geo->getVertCount(); + U32 nonWaterTriCount = m_geo->getTriCount(); + if (mWaterMethod != Ignore) + { + getContainer()->findObjects(worldBox, WaterObjectType, buildCallback, &info); + } + + // Check for no geometry. + if (!m_geo->getVertCount()) + { + m_geo->clear(); + return false; + } + + m_geo->getChunkyMesh(); + + // Needed for the recast config and generation params. + Box3F rc_box = DTStoRC(getWorldBox()); + S32 gw = 0, gh = 0; + rcCalcGridSize(rc_box.minExtents, rc_box.maxExtents, mCellSize, &gw, &gh); + const S32 ts = (S32)mTileSize; + const S32 tw = (gw + ts - 1) / ts; + const S32 th = (gh + ts - 1) / ts; + Con::printf("NavMesh::Build - Tiles %d x %d", tw, th); + + U32 tileBits = mMin(getNextBinLog2(tw * th), 14); + if (tileBits > 14) tileBits = 14; + U32 maxTiles = 1 << tileBits; + U32 polyBits = 22 - tileBits; + mMaxPolysPerTile = 1 << polyBits; // Build navmesh parameters from console members. dtNavMeshParams params; - rcVcopy(params.orig, cfg.bmin); - params.tileWidth = cfg.tileSize * mCellSize; - params.tileHeight = cfg.tileSize * mCellSize; - params.maxTiles = mCeil(getWorldBox().len_x() / params.tileWidth) * mCeil(getWorldBox().len_y() / params.tileHeight); + rcVcopy(params.orig, rc_box.minExtents); + params.tileWidth = mTileSize * mCellSize; + params.tileHeight = mTileSize * mCellSize; + params.maxTiles = maxTiles; params.maxPolys = mMaxPolysPerTile; // Initialise our navmesh. @@ -690,29 +741,29 @@ void NavMesh::inspectPostApply() void NavMesh::updateConfig() { - // Build rcConfig object from our console members. - dMemset(&cfg, 0, sizeof(cfg)); - cfg.cs = mCellSize; - cfg.ch = mCellHeight; - Box3F box = DTStoRC(getWorldBox()); - rcVcopy(cfg.bmin, box.minExtents); - rcVcopy(cfg.bmax, box.maxExtents); - rcCalcGridSize(cfg.bmin, cfg.bmax, cfg.cs, &cfg.width, &cfg.height); + //// Build rcConfig object from our console members. + //dMemset(&cfg, 0, sizeof(cfg)); + //cfg.cs = mCellSize; + //cfg.ch = mCellHeight; + //Box3F box = DTStoRC(getWorldBox()); + //rcVcopy(cfg.bmin, box.minExtents); + //rcVcopy(cfg.bmax, box.maxExtents); + //rcCalcGridSize(cfg.bmin, cfg.bmax, cfg.cs, &cfg.width, &cfg.height); - cfg.walkableHeight = mCeil(mWalkableHeight / mCellHeight); - cfg.walkableClimb = mCeil(mWalkableClimb / mCellHeight); - cfg.walkableRadius = mCeil(mWalkableRadius / mCellSize); - cfg.walkableSlopeAngle = mWalkableSlope; - cfg.borderSize = cfg.walkableRadius + 3; + //cfg.walkableHeight = mCeil(mWalkableHeight / mCellHeight); + //cfg.walkableClimb = mCeil(mWalkableClimb / mCellHeight); + //cfg.walkableRadius = mCeil(mWalkableRadius / mCellSize); + //cfg.walkableSlopeAngle = mWalkableSlope; + //cfg.borderSize = cfg.walkableRadius + 3; - cfg.detailSampleDist = mDetailSampleDist; - cfg.detailSampleMaxError = mDetailSampleMaxError; - cfg.maxEdgeLen = mMaxEdgeLen; - cfg.maxSimplificationError = mMaxSimplificationError; - cfg.maxVertsPerPoly = mMaxVertsPerPoly; - cfg.minRegionArea = mMinRegionArea; - cfg.mergeRegionArea = mMergeRegionArea; - cfg.tileSize = mTileSize / cfg.cs; + //cfg.detailSampleDist = mDetailSampleDist; + //cfg.detailSampleMaxError = mDetailSampleMaxError; + //cfg.maxEdgeLen = mMaxEdgeLen; + //cfg.maxSimplificationError = mMaxSimplificationError; + //cfg.maxVertsPerPoly = mMaxVertsPerPoly; + //cfg.minRegionArea = mMinRegionArea; + //cfg.mergeRegionArea = mMergeRegionArea; + //cfg.tileSize = mTileSize / cfg.cs; } S32 NavMesh::getTile(const Point3F& pos) @@ -740,6 +791,36 @@ void NavMesh::updateTiles(bool dirty) if(!isProperlyAdded()) return; + // this is just here so that load regens the mesh, we should be saving it out. + if (!m_geo) + { + Box3F worldBox = getWorldBox(); + SceneContainer::CallbackInfo info; + info.context = PLC_Navigation; + info.boundingBox = worldBox; + m_geo = new RecastPolyList; + info.polyList = m_geo; + info.key = this; + getContainer()->findObjects(worldBox, StaticObjectType | DynamicShapeObjectType, buildCallback, &info); + + // Parse water objects into the same list, but remember how much geometry was /not/ water. + U32 nonWaterVertCount = m_geo->getVertCount(); + U32 nonWaterTriCount = m_geo->getTriCount(); + if (mWaterMethod != Ignore) + { + getContainer()->findObjects(worldBox, WaterObjectType, buildCallback, &info); + } + + // Check for no geometry. + if (!m_geo->getVertCount()) + { + m_geo->clear(); + return; + } + + m_geo->getChunkyMesh(); + } + mTiles.clear(); mTileData.clear(); mDirtyTiles.clear(); @@ -748,13 +829,15 @@ void NavMesh::updateTiles(bool dirty) if(box.isEmpty()) return; - updateConfig(); - // Calculate tile dimensions. - const U32 ts = cfg.tileSize; - const U32 tw = (cfg.width + ts-1) / ts; - const U32 th = (cfg.height + ts-1) / ts; - const F32 tcs = cfg.tileSize * cfg.cs; + const F32* bmin = box.minExtents; + const F32* bmax = box.maxExtents; + S32 gw = 0, gh = 0; + rcCalcGridSize(bmin, bmax, mCellSize, &gw, &gh); + const S32 ts = (S32)mTileSize; + const S32 tw = (gw + ts - 1) / ts; + const S32 th = (gh + ts - 1) / ts; + const F32 tcs = mTileSize * mCellSize; // Iterate over tiles. F32 tileBmin[3], tileBmax[3]; @@ -762,13 +845,13 @@ void NavMesh::updateTiles(bool dirty) { for(U32 x = 0; x < tw; ++x) { - tileBmin[0] = cfg.bmin[0] + x*tcs; - tileBmin[1] = cfg.bmin[1]; - tileBmin[2] = cfg.bmin[2] + y*tcs; + tileBmin[0] = bmin[0] + x*tcs; + tileBmin[1] = bmin[1]; + tileBmin[2] = bmin[2] + y*tcs; - tileBmax[0] = cfg.bmin[0] + (x+1)*tcs; - tileBmax[1] = cfg.bmax[1]; - tileBmax[2] = cfg.bmin[2] + (y+1)*tcs; + tileBmax[0] = bmin[0] + (x+1)*tcs; + tileBmax[1] = bmax[1]; + tileBmax[2] = bmin[2] + (y+1)*tcs; mTiles.push_back( Tile(RCtoDTS(tileBmin, tileBmax), @@ -846,112 +929,127 @@ void NavMesh::buildNextTile() } } -static void buildCallback(SceneObject* object,void *key) -{ - SceneContainer::CallbackInfo* info = reinterpret_cast(key); - if (!object->mPathfindingIgnore) - object->buildPolyList(info->context,info->polyList,info->boundingBox,info->boundingSphere); -} - unsigned char *NavMesh::buildTileData(const Tile &tile, TileData &data, U32 &dataSize) { + + cleanup(); + + const rcChunkyTriMesh* chunkyMesh = m_geo->getChunkyMesh(); + // Push out tile boundaries a bit. F32 tileBmin[3], tileBmax[3]; rcVcopy(tileBmin, tile.bmin); rcVcopy(tileBmax, tile.bmax); - tileBmin[0] -= cfg.borderSize * cfg.cs; - tileBmin[2] -= cfg.borderSize * cfg.cs; - tileBmax[0] += cfg.borderSize * cfg.cs; - tileBmax[2] += cfg.borderSize * cfg.cs; - - // Parse objects from level into RC-compatible format. - Box3F box = RCtoDTS(tileBmin, tileBmax); - SceneContainer::CallbackInfo info; - info.context = PLC_Navigation; - info.boundingBox = box; - data.geom.clear(); - info.polyList = &data.geom; - info.key = this; - getContainer()->findObjects(box, StaticObjectType | DynamicShapeObjectType, buildCallback, &info); - - // Parse water objects into the same list, but remember how much geometry was /not/ water. - U32 nonWaterVertCount = data.geom.getVertCount(); - U32 nonWaterTriCount = data.geom.getTriCount(); - if(mWaterMethod != Ignore) - { - getContainer()->findObjects(box, WaterObjectType, buildCallback, &info); - } - - // Check for no geometry. - if (!data.geom.getVertCount()) - { - data.geom.clear(); - return NULL; - } - - // Figure out voxel dimensions of this tile. - U32 width = 0, height = 0; - width = cfg.tileSize + cfg.borderSize * 2; - height = cfg.tileSize + cfg.borderSize * 2; + // Setup our rcConfig + dMemset(&m_cfg, 0, sizeof(m_cfg)); + m_cfg.cs = mCellSize; + m_cfg.ch = mCellHeight; + m_cfg.walkableSlopeAngle = mWalkableSlope; + m_cfg.walkableHeight = (S32)mCeil(mWalkableHeight / m_cfg.ch); + m_cfg.walkableClimb = (S32)mFloor(mWalkableClimb / m_cfg.ch); + m_cfg.walkableRadius = (S32)mCeil(mWalkableRadius / m_cfg.cs); + m_cfg.maxEdgeLen = (S32)(mMaxEdgeLen / mCellSize); + m_cfg.maxSimplificationError = mMaxSimplificationError; + m_cfg.minRegionArea = (S32)mSquared((F32)mMinRegionArea); + m_cfg.mergeRegionArea = (S32)mSquared((F32)mMergeRegionArea); + m_cfg.maxVertsPerPoly = (S32)mMaxVertsPerPoly; + m_cfg.tileSize = (S32)mTileSize; + m_cfg.borderSize = mMax(m_cfg.walkableRadius + 3, mBorderSize); // use the border size if it is bigger. + m_cfg.width = m_cfg.tileSize + m_cfg.borderSize * 2; + m_cfg.height = m_cfg.tileSize + m_cfg.borderSize * 2; + m_cfg.detailSampleDist = mDetailSampleDist < 0.9f ? 0 : mCellSize * mDetailSampleDist; + m_cfg.detailSampleMaxError = mCellHeight * mDetailSampleMaxError; + rcVcopy(m_cfg.bmin, tileBmin); + rcVcopy(m_cfg.bmax, tileBmax); + m_cfg.bmin[0] -= m_cfg.borderSize * m_cfg.cs; + m_cfg.bmin[2] -= m_cfg.borderSize * m_cfg.cs; + m_cfg.bmax[0] += m_cfg.borderSize * m_cfg.cs; + m_cfg.bmax[2] += m_cfg.borderSize * m_cfg.cs; // Create a heightfield to voxelise our input geometry. - data.hf = rcAllocHeightfield(); - if(!data.hf) + m_solid = rcAllocHeightfield(); + if(!m_solid) { Con::errorf("Out of memory (rcHeightField) for NavMesh %s", getIdString()); return NULL; } - if(!rcCreateHeightfield(ctx, *data.hf, width, height, tileBmin, tileBmax, cfg.cs, cfg.ch)) + if (!rcCreateHeightfield(ctx, *m_solid, m_cfg.width, m_cfg.height, m_cfg.bmin, m_cfg.bmax, m_cfg.cs, m_cfg.ch)) { Con::errorf("Could not generate rcHeightField for NavMesh %s", getIdString()); return NULL; } - unsigned char *areas = new unsigned char[data.geom.getTriCount()]; - - dMemset(areas, 0, data.geom.getTriCount() * sizeof(unsigned char)); - - // Mark walkable triangles with the appropriate area flags, and rasterize. - if(mWaterMethod == Solid) + m_triareas = new unsigned char[chunkyMesh->maxTrisPerChunk]; + if (!m_triareas) { - // Treat water as solid: i.e. mark areas as walkable based on angle. - rcMarkWalkableTriangles(ctx, cfg.walkableSlopeAngle, - data.geom.getVerts(), data.geom.getVertCount(), - data.geom.getTris(), data.geom.getTriCount(), areas); - } - else - { - // Treat water as impassable: leave all area flags 0. - rcMarkWalkableTriangles(ctx, cfg.walkableSlopeAngle, - data.geom.getVerts(), nonWaterVertCount, - data.geom.getTris(), nonWaterTriCount, areas); - } - rcRasterizeTriangles(ctx, - data.geom.getVerts(), data.geom.getVertCount(), - data.geom.getTris(), areas, data.geom.getTriCount(), - *data.hf, cfg.walkableClimb); - - delete[] areas; - - // Filter out areas with low ceilings and other stuff. - rcFilterLowHangingWalkableObstacles(ctx, cfg.walkableClimb, *data.hf); - rcFilterLedgeSpans(ctx, cfg.walkableHeight, cfg.walkableClimb, *data.hf); - rcFilterWalkableLowHeightSpans(ctx, cfg.walkableHeight, *data.hf); - - data.chf = rcAllocCompactHeightfield(); - if(!data.chf) - { - Con::errorf("Out of memory (rcCompactHeightField) for NavMesh %s", getIdString()); + Con::errorf("NavMesh::buildTileData: Out of memory 'm_triareas' (%d).", chunkyMesh->maxTrisPerChunk); return NULL; } - if(!rcBuildCompactHeightfield(ctx, cfg.walkableHeight, cfg.walkableClimb, *data.hf, *data.chf)) + + F32 tbmin[2], tbmax[2]; + tbmin[0] = m_cfg.bmin[0]; + tbmin[1] = m_cfg.bmin[2]; + tbmax[0] = m_cfg.bmax[0]; + tbmax[1] = m_cfg.bmax[2]; + int cid[512]; + const int ncid = rcGetChunksOverlappingRect(chunkyMesh, tbmin, tbmax, cid, 512); + if (!ncid) + return 0; + + for (int i = 0; i < ncid; ++i) { - Con::errorf("Could not generate rcCompactHeightField for NavMesh %s", getIdString()); + const rcChunkyTriMeshNode& node = chunkyMesh->nodes[cid[i]]; + const int* ctris = &chunkyMesh->tris[node.i * 3]; + const int nctris = node.n; + + memset(m_triareas, 0, nctris * sizeof(unsigned char)); + rcMarkWalkableTriangles(ctx, m_cfg.walkableSlopeAngle, + m_geo->getVerts(), m_geo->getVertCount(), ctris, nctris, m_triareas); + + if (!rcRasterizeTriangles(ctx, m_geo->getVerts(), m_geo->getVertCount(), ctris, m_triareas, nctris, *m_solid, m_cfg.walkableClimb)) + return NULL; + } + + if (!mSaveIntermediates) + { + delete[] m_triareas; + m_triareas = 0; + } + + // these should be optional. + //if (m_filterLowHangingObstacles) + rcFilterLowHangingWalkableObstacles(ctx, m_cfg.walkableClimb, *m_solid); + //if (m_filterLedgeSpans) + rcFilterLedgeSpans(ctx, m_cfg.walkableHeight, m_cfg.walkableClimb, *m_solid); + //if (m_filterWalkableLowHeightSpans) + rcFilterWalkableLowHeightSpans(ctx, m_cfg.walkableHeight, *m_solid); + + + // 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(); + if (!m_chf) + { + Con::errorf("NavMesh::buildTileData: Out of memory 'chf'."); return NULL; } - if(!rcErodeWalkableArea(ctx, cfg.walkableRadius, *data.chf)) + if (!rcBuildCompactHeightfield(ctx, m_cfg.walkableHeight, m_cfg.walkableClimb, *m_solid, *m_chf)) { - Con::errorf("Could not erode walkable area for NavMesh %s", getIdString()); + Con::errorf("NavMesh::buildTileData: Could not build compact data."); + return NULL; + } + + if (!mSaveIntermediates) + { + rcFreeHeightField(m_solid); + m_solid = NULL; + } + + // Erode the walkable area by agent radius. + if (!rcErodeWalkableArea(ctx, m_cfg.walkableRadius, *m_chf)) + { + Con::errorf("NavMesh::buildTileData: Could not erode."); return NULL; } @@ -962,132 +1060,186 @@ unsigned char *NavMesh::buildTileData(const Tile &tile, TileData &data, U32 &dat //rcMarkConvexPolyArea(m_ctx, vols[i].verts, vols[i].nverts, vols[i].hmin, vols[i].hmax, (unsigned char)vols[i].area, *m_chf); //-------------------------- - if(false) + // Partition the heightfield so that we can use simple algorithm later to triangulate the walkable areas. + // There are 3 martitioning methods, each with some pros and cons: + // These should be implemented. + // 1) Watershed partitioning + // - the classic Recast partitioning + // - creates the nicest tessellation + // - usually slowest + // - partitions the heightfield into nice regions without holes or overlaps + // - the are some corner cases where this method creates produces holes and overlaps + // - holes may appear when a small obstacles is close to large open area (triangulation can handle this) + // - overlaps may occur if you have narrow spiral corridors (i.e stairs), this make triangulation to fail + // * generally the best choice if you precompute the nacmesh, use this if you have large open areas + // 2) Monotone partioning + // - fastest + // - partitions the heightfield into regions without holes and overlaps (guaranteed) + // - creates long thin polygons, which sometimes causes paths with detours + // * use this if you want fast navmesh generation + // 3) Layer partitoining + // - quite fast + // - partitions the heighfield into non-overlapping regions + // - relies on the triangulation code to cope with holes (thus slower than monotone partitioning) + // - produces better triangles than monotone partitioning + // - does not have the corner cases of watershed partitioning + // - can be slow and create a bit ugly tessellation (still better than monotone) + // if you have large open areas with small obstacles (not a problem if you use tiles) + // * good choice to use for tiled navmesh with medium and small sized tiles + + + if (/*m_partitionType == SAMPLE_PARTITION_WATERSHED*/ true) { - if(!rcBuildRegionsMonotone(ctx, *data.chf, cfg.borderSize, cfg.minRegionArea, cfg.mergeRegionArea)) + // Prepare for region partitioning, by calculating distance field along the walkable surface. + if (!rcBuildDistanceField(ctx, *m_chf)) { - Con::errorf("Could not build regions for NavMesh %s", getIdString()); + Con::errorf("NavMesh::buildTileData: Could not build distance field."); + return 0; + } + + // Partition the walkable surface into simple regions without holes. + if (!rcBuildRegions(ctx, *m_chf, m_cfg.borderSize, m_cfg.minRegionArea, m_cfg.mergeRegionArea)) + { + Con::errorf("NavMesh::buildTileData: Could not build watershed regions."); return NULL; } } - else + else if (/*m_partitionType == SAMPLE_PARTITION_MONOTONE*/ false) { - if(!rcBuildDistanceField(ctx, *data.chf)) + // Partition the walkable surface into simple regions without holes. + // Monotone partitioning does not need distancefield. + if (!rcBuildRegionsMonotone(ctx, *m_chf, m_cfg.borderSize, m_cfg.minRegionArea, m_cfg.mergeRegionArea)) { - Con::errorf("Could not build distance field for NavMesh %s", getIdString()); + Con::errorf("NavMesh::buildTileData: Could not build monotone regions."); return NULL; } - if(!rcBuildRegions(ctx, *data.chf, cfg.borderSize, cfg.minRegionArea, cfg.mergeRegionArea)) + } + else // SAMPLE_PARTITION_LAYERS + { + // Partition the walkable surface into simple regions without holes. + if (!rcBuildLayerRegions(ctx, *m_chf, m_cfg.borderSize, m_cfg.minRegionArea)) { - Con::errorf("Could not build regions for NavMesh %s", getIdString()); + Con::errorf("NavMesh::buildTileData: Could not build layer regions."); return NULL; } } - data.cs = rcAllocContourSet(); - if(!data.cs) + m_cset = rcAllocContourSet(); + if (!m_cset) { - Con::errorf("Out of memory (rcContourSet) for NavMesh %s", getIdString()); - return NULL; - } - if(!rcBuildContours(ctx, *data.chf, cfg.maxSimplificationError, cfg.maxEdgeLen, *data.cs)) - { - Con::errorf("Could not construct rcContourSet for NavMesh %s", getIdString()); - return NULL; - } - if(data.cs->nconts <= 0) - { - Con::errorf("No contours in rcContourSet for NavMesh %s", getIdString()); + Con::errorf("NavMesh::buildTileData: Out of memory 'cset'"); return NULL; } - data.pm = rcAllocPolyMesh(); - if(!data.pm) + if (!rcBuildContours(ctx, *m_chf, m_cfg.maxSimplificationError, m_cfg.maxEdgeLen, *m_cset)) { - Con::errorf("Out of memory (rcPolyMesh) for NavMesh %s", getIdString()); - return NULL; - } - if(!rcBuildPolyMesh(ctx, *data.cs, cfg.maxVertsPerPoly, *data.pm)) - { - Con::errorf("Could not construct rcPolyMesh for NavMesh %s", getIdString()); + Con::errorf("NavMesh::buildTileData: Could not create contours"); return NULL; } - data.pmd = rcAllocPolyMeshDetail(); - if(!data.pmd) + if (m_cset->nconts == 0) + return NULL; + + // Build polygon navmesh from the contours. + m_pmesh = rcAllocPolyMesh(); + if (!m_pmesh) { - Con::errorf("Out of memory (rcPolyMeshDetail) for NavMesh %s", getIdString()); + Con::errorf("NavMesh::buildTileData: Out of memory 'pmesh'."); return NULL; } - if(!rcBuildPolyMeshDetail(ctx, *data.pm, *data.chf, cfg.detailSampleDist, cfg.detailSampleMaxError, *data.pmd)) + if (!rcBuildPolyMesh(ctx, *m_cset, m_cfg.maxVertsPerPoly, *m_pmesh)) { - Con::errorf("Could not construct rcPolyMeshDetail for NavMesh %s", getIdString()); + Con::errorf("NavMesh::buildTileData: Could not triangulate contours."); return NULL; } - if(data.pm->nverts >= 0xffff) + // Build detail mesh. + m_dmesh = rcAllocPolyMeshDetail(); + if (!m_dmesh) { - Con::errorf("Too many vertices in rcPolyMesh for NavMesh %s", getIdString()); + Con::errorf("NavMesh::buildTileData: Out of memory 'dmesh'."); return NULL; } - for(U32 i = 0; i < data.pm->npolys; i++) - { - if(data.pm->areas[i] == RC_WALKABLE_AREA) - data.pm->areas[i] = GroundArea; - if(data.pm->areas[i] == GroundArea) - data.pm->flags[i] |= WalkFlag; - if(data.pm->areas[i] == WaterArea) - data.pm->flags[i] |= SwimFlag; + if (!rcBuildPolyMeshDetail(ctx, *m_pmesh, *m_chf, m_cfg.detailSampleDist, m_cfg.detailSampleMaxError, *m_dmesh)) + { + Con::errorf("NavMesh::buildTileData: Could build polymesh detail."); + return NULL; + } + + if (!mSaveIntermediates) + { + rcFreeCompactHeightfield(m_chf); + m_chf = 0; + rcFreeContourSet(m_cset); + m_cset = 0; } unsigned char* navData = 0; int navDataSize = 0; - - dtNavMeshCreateParams params; - dMemset(¶ms, 0, sizeof(params)); - - params.verts = data.pm->verts; - params.vertCount = data.pm->nverts; - params.polys = data.pm->polys; - params.polyAreas = data.pm->areas; - params.polyFlags = data.pm->flags; - params.polyCount = data.pm->npolys; - params.nvp = data.pm->nvp; - - params.detailMeshes = data.pmd->meshes; - params.detailVerts = data.pmd->verts; - params.detailVertsCount = data.pmd->nverts; - params.detailTris = data.pmd->tris; - params.detailTriCount = data.pmd->ntris; - - params.offMeshConVerts = mLinkVerts.address(); - params.offMeshConRad = mLinkRads.address(); - params.offMeshConDir = mLinkDirs.address(); - params.offMeshConAreas = mLinkAreas.address(); - params.offMeshConFlags = mLinkFlags.address(); - params.offMeshConUserID = mLinkIDs.address(); - params.offMeshConCount = mLinkIDs.size(); - - params.walkableHeight = mWalkableHeight; - params.walkableRadius = mWalkableRadius; - params.walkableClimb = mWalkableClimb; - params.tileX = tile.x; - params.tileY = tile.y; - params.tileLayer = 0; - rcVcopy(params.bmin, data.pm->bmin); - rcVcopy(params.bmax, data.pm->bmax); - params.cs = cfg.cs; - params.ch = cfg.ch; - params.buildBvTree = true; - - if(!dtCreateNavMeshData(¶ms, &navData, &navDataSize)) + if (m_cfg.maxVertsPerPoly <= DT_VERTS_PER_POLYGON) { - Con::errorf("Could not create dtNavMeshData for tile (%d, %d) of NavMesh %s", - tile.x, tile.y, getIdString()); - return NULL; - } + if (m_pmesh->nverts >= 0xffff) + { + // The vertex indices are ushorts, and cannot point to more than 0xffff vertices. + Con::errorf("NavMesh::buildTileData: Too many vertices per tile %d (max: %d).", m_pmesh->nverts, 0xffff); + return NULL; + } + for (U32 i = 0; i < m_pmesh->npolys; i++) + { + if (m_pmesh->areas[i] == RC_WALKABLE_AREA) + m_pmesh->areas[i] = GroundArea; + + if (m_pmesh->areas[i] == GroundArea) + m_pmesh->flags[i] |= WalkFlag; + if (m_pmesh->areas[i] == WaterArea) + m_pmesh->flags[i] |= SwimFlag; + } + + dtNavMeshCreateParams params; + dMemset(¶ms, 0, sizeof(params)); + + params.verts = m_pmesh->verts; + params.vertCount = m_pmesh->nverts; + params.polys = m_pmesh->polys; + params.polyAreas = m_pmesh->areas; + params.polyFlags = m_pmesh->flags; + params.polyCount = m_pmesh->npolys; + params.nvp = m_pmesh->nvp; + + params.detailMeshes = m_dmesh->meshes; + params.detailVerts = m_dmesh->verts; + params.detailVertsCount = m_dmesh->nverts; + params.detailTris = m_dmesh->tris; + params.detailTriCount = m_dmesh->ntris; + + params.offMeshConVerts = mLinkVerts.address(); + params.offMeshConRad = mLinkRads.address(); + params.offMeshConDir = mLinkDirs.address(); + params.offMeshConAreas = mLinkAreas.address(); + params.offMeshConFlags = mLinkFlags.address(); + params.offMeshConUserID = mLinkIDs.address(); + params.offMeshConCount = mLinkIDs.size(); + + params.walkableHeight = mWalkableHeight; + params.walkableRadius = mWalkableRadius; + params.walkableClimb = mWalkableClimb; + params.tileX = tile.x; + params.tileY = tile.y; + params.tileLayer = 0; + rcVcopy(params.bmin, m_pmesh->bmin); + rcVcopy(params.bmax, m_pmesh->bmax); + params.cs = m_cfg.cs; + params.ch = m_cfg.ch; + params.buildBvTree = true; + + if (!dtCreateNavMeshData(¶ms, &navData, &navDataSize)) + { + Con::errorf("NavMesh::buildTileData: Could not build Detour navmesh."); + return NULL; + } + } dataSize = navDataSize; return navData; @@ -1331,6 +1483,22 @@ void NavMesh::renderToDrawer() { } +void NavMesh::cleanup() +{ + delete[] m_triareas; + m_triareas = 0; + rcFreeHeightField(m_solid); + m_solid = 0; + rcFreeCompactHeightfield(m_chf); + m_chf = 0; + rcFreeContourSet(m_cset); + m_cset = 0; + rcFreePolyMesh(m_pmesh); + m_pmesh = 0; + rcFreePolyMeshDetail(m_dmesh); + m_dmesh = 0; +} + void NavMesh::prepRenderImage(SceneRenderState *state) { ObjectRenderInst *ri = state->getRenderPass()->allocInst(); diff --git a/Engine/source/navigation/navMesh.h b/Engine/source/navigation/navMesh.h index 5c78f81f9..5342a700e 100644 --- a/Engine/source/navigation/navMesh.h +++ b/Engine/source/navigation/navMesh.h @@ -366,9 +366,6 @@ private: /// @name Intermediate data /// @{ - /// Config struct. - rcConfig cfg; - /// Updates our config from console members. void updateConfig(); @@ -419,6 +416,18 @@ private: /// Use this object to manage update events. static SimObjectPtr smEventManager; + +protected: + RecastPolyList* m_geo; + unsigned char* m_triareas; + rcHeightfield* m_solid; + rcCompactHeightfield* m_chf; + rcContourSet* m_cset; + rcPolyMesh* m_pmesh; + rcPolyMeshDetail* m_dmesh; + rcConfig m_cfg; + + void cleanup(); }; typedef NavMesh::WaterMethod NavMeshWaterMethod; diff --git a/Engine/source/navigation/recastPolyList.cpp b/Engine/source/navigation/recastPolyList.cpp index 565a47892..5736e27fc 100644 --- a/Engine/source/navigation/recastPolyList.cpp +++ b/Engine/source/navigation/recastPolyList.cpp @@ -27,7 +27,7 @@ #include "gfx/primBuilder.h" #include "gfx/gfxStateBlock.h" -RecastPolyList::RecastPolyList() +RecastPolyList::RecastPolyList() : mChunkyMesh(0) { nverts = 0; verts = NULL; @@ -44,6 +44,28 @@ RecastPolyList::~RecastPolyList() clear(); } +rcChunkyTriMesh* RecastPolyList::getChunkyMesh() +{ + if (!mChunkyMesh) + { + mChunkyMesh = new rcChunkyTriMesh; + if (!mChunkyMesh) + { + Con::errorf("Build tile navigation: out of memory"); + return NULL; + } + + if (!rcCreateChunkyTriMesh(getVerts(), getTris(), getTriCount(), 256, mChunkyMesh)) + { + Con::errorf("Build tile navigation: out of memory"); + return NULL; + } + + } + + return mChunkyMesh; +} + void RecastPolyList::clear() { nverts = 0; diff --git a/Engine/source/navigation/recastPolyList.h b/Engine/source/navigation/recastPolyList.h index 4425c2317..b57aeb099 100644 --- a/Engine/source/navigation/recastPolyList.h +++ b/Engine/source/navigation/recastPolyList.h @@ -26,6 +26,10 @@ #include "collision/abstractPolyList.h" #include "core/util/tVector.h" +#ifndef CHUNKYTRIMESH_H +#include "ChunkyTriMesh.h" +#endif + /// Represents polygons in the same manner as the .obj file format. Handy for /// padding data to Recast, since it expects this data format. At the moment, /// this class only accepts triangles. @@ -70,6 +74,9 @@ public: /// Default destructor. ~RecastPolyList(); + rcChunkyTriMesh* getChunkyMesh(); + + protected: /// Number of vertices defined. U32 nverts; @@ -93,6 +100,8 @@ protected: /// Another inherited utility function. const PlaneF& getIndexedPlane(const U32 index) override { return planes[index]; } + rcChunkyTriMesh* mChunkyMesh; + private: };