@recast-navigation/generators 0.35.0 → 0.35.2

package/dist/index.mjs

@@ -1,2 +1,973 @@
-import{vec3 as e,recastConfigDefaults as t,Raw as i,RecastBuildContext as a,NavMesh as l,VerticesArray as o,TrianglesArray as r,createRcConfig as s,calcGridSize as n,allocHeightfield as h,createHeightfield as d,TriangleAreasArray as c,markWalkableTriangles as m,rasterizeTriangles as g,filterLowHangingWalkableObstacles as b,filterLedgeSpans as u,filterWalkableLowHeightSpans as f,allocCompactHeightfield as y,buildCompactHeightfield as w,freeHeightfield as S,erodeWalkableArea as p,buildDistanceField as M,buildRegions as R,allocContourSet as C,buildContours as x,Recast as v,allocPolyMesh as k,buildPolyMesh as _,allocPolyMeshDetail as z,buildPolyMeshDetail as A,freeCompactHeightfield as T,freeContourSet as E,NavMeshCreateParams as H,createNavMeshData as D,freePolyMesh as L,freePolyMeshDetail as P,TileCacheMeshProcess as F,TileCache as O,DetourTileCacheParams as I,NavMeshParams as $,RecastChunkyTriMesh as G,statusFailed as N,freeHeightfieldLayerSet as W,cloneRcConfig as B,ChunkIdsArray as j,allocHeightfieldLayerSet as K,buildHeightfieldLayers as U,TileCacheData as V,Detour as X,getHeightfieldLayerHeights as Y,getHeightfieldLayerAreas as Z,getHeightfieldLayerCons as q,buildTileCacheLayer as J,statusToReadableString as Q}from"@recast-navigation/core";const ee=(t,i)=>{const a={x:1/0,y:1/0,z:1/0},l={x:-1/0,y:-1/0,z:-1/0};for(let e=0;e<i.length;e++){const o=i[e],r=t[3*o],s=t[3*o+1],n=t[3*o+2];a.x=Math.min(a.x,r),a.y=Math.min(a.y,s),a.z=Math.min(a.z,n),l.x=Math.max(l.x,r),l.y=Math.max(l.y,s),l.z=Math.max(l.z,n)}return{bbMin:e.toArray(a),bbMax:e.toArray(l)}},te=e=>{let t=0,i=0;return t=Number(e>65535)<<4,e>>=t,i=Number(e>255)<<3,e>>=i,t|=i,i=Number(e>15)<<2,e>>=i,t|=i,i=Number(e>3)<<1,t|=i,t|=(e>>=i)>>1,t},ie=e=>(e--,e|=e>>1,e|=e>>2,e|=e>>4,e|=e>>8,e|=e>>16,++e),ae={...t},le=(e,t,F={},O=!1)=>{if(!i.Module)throw new Error('"init" must be called before using any recast-navigation-js APIs. See: https://github.com/isaac-mason/recast-navigation-js?tab=readme-ov-file#initialization');const I=new a,$={type:"solo",buildContext:I},G=new l,N=e=>(O||($.heightfield&&(S($.heightfield),$.heightfield=void 0),$.compactHeightfield&&(T($.compactHeightfield),$.compactHeightfield=void 0),$.contourSet&&(E($.contourSet),$.contourSet=void 0),$.polyMesh&&(L($.polyMesh),$.polyMesh=void 0),$.polyMeshDetail&&(P($.polyMeshDetail),$.polyMeshDetail=void 0)),G.destroy(),{navMesh:void 0,success:!1,intermediates:$,error:e}),W=e,B=t.length,j=new o;j.copy(W);const K=t,U=t.length/3,V=new r;V.copy(K);const{bbMin:X,bbMax:Y}=ee(e,t),Z=s({...ae,...F});Z.minRegionArea=Z.minRegionArea*Z.minRegionArea,Z.mergeRegionArea=Z.mergeRegionArea*Z.mergeRegionArea,Z.detailSampleDist=Z.detailSampleDist<.9?0:Z.cs*Z.detailSampleDist,Z.detailSampleMaxError=Z.ch*Z.detailSampleMaxError;const q=n(X,Y,Z.cs);Z.width=q.width,Z.height=q.height;const J=h();if($.heightfield=J,!d(I,J,Z.width,Z.height,X,Y,Z.cs,Z.ch))return N("Could not create heightfield");const Q=new c;if(Q.resize(U),m(I,Z.walkableSlopeAngle,j,B,V,U,Q),!g(I,j,B,V,Q,U,J,Z.walkableClimb))return N("Could not rasterize triangles");Q.destroy(),j.destroy(),V.destroy(),b(I,Z.walkableClimb,J),u(I,Z.walkableHeight,Z.walkableClimb,J),f(I,Z.walkableHeight,J);const te=y();if($.compactHeightfield=te,!w(I,Z.walkableHeight,Z.walkableClimb,J,te))return N("Failed to build compact data");if(O||(S(J),$.heightfield=void 0),!p(I,Z.walkableRadius,te))return N("Failed to erode walkable area");if(!M(I,te))return N("Failed to build distance field");if(!R(I,te,Z.borderSize,Z.minRegionArea,Z.mergeRegionArea))return N("Failed to build regions");const ie=C();if($.contourSet=ie,!x(I,te,Z.maxSimplificationError,Z.maxEdgeLen,ie,v.RC_CONTOUR_TESS_WALL_EDGES))return N("Failed to create contours");const le=k();if($.polyMesh=le,!_(I,ie,Z.maxVertsPerPoly,le))return N("Failed to triangulate contours");const oe=z();if($.polyMeshDetail=oe,!A(I,le,te,Z.detailSampleDist,Z.detailSampleMaxError,oe))return N("Failed to build detail mesh");O||(T(te),$.compactHeightfield=void 0,E(ie),$.contourSet=void 0);for(let e=0;e<le.npolys();e++)le.areas(e)==v.RC_WALKABLE_AREA&&le.setAreas(e,0),0==le.areas(e)&&le.setFlags(e,1);const re=new H;re.setPolyMeshCreateParams(le),re.setPolyMeshDetailCreateParams(oe),re.setWalkableHeight(Z.walkableHeight),re.setWalkableRadius(Z.walkableRadius),re.setWalkableClimb(Z.walkableClimb),re.setCellSize(Z.cs),re.setCellHeight(Z.ch),re.setBuildBvTree(!0),F.offMeshConnections&&re.setOffMeshConnections(F.offMeshConnections);const se=D(re);if(!se.success)return N("Failed to create Detour navmesh data");const{navMeshData:ne}=se;return G.initSolo(ne)?{success:!0,navMesh:G,intermediates:$}:N("Failed to create Detour navmesh")},oe={...t,tileSize:32,expectedLayersPerTile:4,maxObstacles:128},re=()=>new F(((e,t,i)=>{for(let a=0;a<e.polyCount();++a)t.set(a,0),i.set(a,1)})),se=(t,M,R={},C=!1)=>{if(!i.Module)throw new Error('"init" must be called before using any recast-navigation-js APIs. See: https://github.com/isaac-mason/recast-navigation-js?tab=readme-ov-file#initialization');const x=new a,k={type:"tilecache",buildContext:x,chunkyTriMesh:void 0,tileIntermediates:[]},_=new O,z=new l,A=t,E=M.length,H=new o;H.copy(A);const D=M,L=M.length/3,P=new r;P.copy(D);const{bbMin:F,bbMax:Q}=ee(t,M),{expectedLayersPerTile:ae,maxObstacles:le,...se}={...oe,...R},ne=()=>{if(H.destroy(),P.destroy(),!C)for(let e=0;e<k.tileIntermediates.length;e++){const t=k.tileIntermediates[e];t.heightfield&&(S(t.heightfield),t.heightfield=void 0),t.compactHeightfield&&(T(t.compactHeightfield),t.compactHeightfield=void 0),t.heightfieldLayerSet&&(W(t.heightfieldLayerSet),t.heightfieldLayerSet=void 0)}},he=e=>(ne(),_.destroy(),z.destroy(),{success:!1,navMesh:void 0,tileCache:void 0,intermediates:k,error:e}),de=s(se),ce=n(F,Q,de.cs);de.width=ce.width,de.height=ce.height,de.minRegionArea=de.minRegionArea*de.minRegionArea,de.mergeRegionArea=de.mergeRegionArea*de.mergeRegionArea,de.detailSampleDist=de.detailSampleDist<.9?0:de.cs*de.detailSampleDist,de.detailSampleMaxError=de.ch*de.detailSampleMaxError;const me=Math.floor(de.tileSize),ge=Math.floor((de.width+me-1)/me),be=Math.floor((de.height+me-1)/me);de.borderSize=de.walkableRadius+3,de.width=de.tileSize+2*de.borderSize,de.height=de.tileSize+2*de.borderSize;const ue=I.create({orig:F,cs:de.cs,ch:de.ch,width:de.tileSize,height:de.tileSize,walkableHeight:de.walkableHeight,walkableRadius:de.walkableRadius,walkableClimb:de.walkableClimb,maxSimplificationError:de.maxSimplificationError,maxTiles:ge*be*ae,maxObstacles:le}),fe=new i.RecastLinearAllocator(32e3),ye=new i.RecastFastLZCompressor,we=R.tileCacheMeshProcess??re();if(!_.init(ue,fe,ye,we))return he("Failed to initialize tile cache");const Se=e.fromArray(F);let pe=Math.min(Math.floor(te(ie(ge*be*ae))),14);pe>14&&(pe=14);const Me=1<<pe,Re=1<<22-pe,Ce=$.create({orig:Se,tileWidth:de.tileSize*de.cs,tileHeight:de.tileSize*de.cs,maxTiles:Me,maxPolys:Re});if(!z.initTiled(Ce))return he("Failed to initialize tiled navmesh");const xe=new G;if(k.chunkyTriMesh=xe,!xe.init(H,P,L,256))return he("Failed to build chunky triangle mesh");const ve=(e,t)=>{const a={tileX:e,tileY:t},l=de.tileSize*de.cs,o=B(de),r=[F[0]+e*l,F[1],F[2]+t*l],s=[F[0]+(e+1)*l,Q[1],F[2]+(t+1)*l];r[0]-=o.borderSize*o.cs,r[2]-=o.borderSize*o.cs,s[0]+=o.borderSize*o.cs,s[2]+=o.borderSize*o.cs,o.set_bmin(0,r[0]),o.set_bmin(1,r[1]),o.set_bmin(2,r[2]),o.set_bmax(0,s[0]),o.set_bmax(1,s[1]),o.set_bmax(2,s[2]);const n=h();if(a.heightfield=n,!d(x,n,o.width,o.height,r,s,o.cs,o.ch))return{n:0};const M=[r[0],r[2]],R=[s[0],s[2]],v=new j;v.resize(512);const _=xe.getChunksOverlappingRect(M,R,v,512);if(0===_)return{n:0};for(let e=0;e<_;++e){const t=v.get(e),i=xe.nodes(t).n,a=xe.getNodeTris(t),l=new c;l.resize(i),m(x,o.walkableSlopeAngle,H,E,a,i,l);const r=g(x,H,E,a,l,i,n,o.walkableClimb);if(l.destroy(),!r)return{n:0}}b(x,de.walkableClimb,n),u(x,de.walkableHeight,de.walkableClimb,n),f(x,de.walkableHeight,n);const z=y();if(!w(x,de.walkableHeight,de.walkableClimb,n,z))return{n:0};if(C||(S(a.heightfield),a.heightfield=void 0),!p(x,de.walkableRadius,z))return{n:0};const A=K();if(!U(x,z,de.borderSize,de.walkableHeight,A))return{n:0};C||(T(z),a.compactHeightfield=void 0);const D=[];for(let a=0;a<A.nlayers();a++){const l=new V,o=A.layers(a),r=new i.dtTileCacheLayerHeader;r.magic=X.DT_TILECACHE_MAGIC,r.version=X.DT_TILECACHE_VERSION,r.tx=e,r.ty=t,r.tlayer=a;const s=o.bmin(),n=o.bmax();r.set_bmin(0,s.x),r.set_bmin(1,s.y),r.set_bmin(2,s.z),r.set_bmax(0,n.x),r.set_bmax(1,n.y),r.set_bmax(2,n.z),r.width=o.width(),r.height=o.height(),r.minx=o.minx(),r.maxx=o.maxx(),r.miny=o.miny(),r.maxy=o.maxy(),r.hmin=o.hmin(),r.hmax=o.hmax();const h=Y(o),d=Z(o),c=q(o),m=J(ye,r,h,d,c,l);if(N(m))return{n:0};D.push(l)}return C||(W(A),a.heightfieldLayerSet=void 0),k.tileIntermediates.push(a),{n:D.length,tiles:D}};for(let e=0;e<be;++e)for(let t=0;t<ge;++t){const{n:i,tiles:a}=ve(t,e);if(i>0&&a)for(let l=0;l<i;l++){const i=a[l],o=_.addTile(i);N(o.status)&&x.log(v.RC_LOG_WARNING,`Failed to add tile to tile cache - tx: ${t}, ty: ${e}`)}}for(let e=0;e<be;e++)for(let t=0;t<ge;t++){const i=_.buildNavMeshTilesAt(t,e,z);if(N(i))return he(`Failed to build nav mesh tiles at ${t}, ${e}`)}return ne(),{success:!0,tileCache:_,navMesh:z,intermediates:k}},ne={...t},he=(t,F,O={},I=!1)=>{if(!i.Module)throw new Error('"init" must be called before using any recast-navigation-js APIs. See: https://github.com/isaac-mason/recast-navigation-js?tab=readme-ov-file#initialization');const W=new a,K={type:"tiled",buildContext:W,chunkyTriMesh:void 0,tileIntermediates:[]},U=new l,V=t,Y=F.length,Z=new o;Z.copy(V);const q=F,J=F.length/3,ae=new r;ae.copy(q);const le=()=>{if(Z.destroy(),ae.destroy(),!I){for(let e=0;e<K.tileIntermediates.length;e++){const t=K.tileIntermediates[e];t.compactHeightfield&&(T(t.compactHeightfield),t.compactHeightfield=void 0),t.heightfield&&(S(t.heightfield),t.heightfield=void 0),t.contourSet&&(E(t.contourSet),t.contourSet=void 0),t.polyMesh&&(L(t.polyMesh),t.polyMesh=void 0),t.polyMeshDetail&&(P(t.polyMeshDetail),t.polyMeshDetail=void 0)}K.chunkyTriMesh&&(K.chunkyTriMesh=void 0)}},oe=e=>(le(),U.destroy(),{success:!1,navMesh:void 0,intermediates:K,error:e}),re=s({...ne,...O}),{bbMin:se,bbMax:he}=ee(t,F),de=n(se,he,re.cs);re.width=de.width,re.height=de.height,re.minRegionArea=re.minRegionArea*re.minRegionArea,re.mergeRegionArea=re.mergeRegionArea*re.mergeRegionArea,re.tileSize=Math.floor(re.tileSize),re.borderSize=re.walkableRadius+3,re.width=re.tileSize+2*re.borderSize,re.height=re.tileSize+2*re.borderSize,re.detailSampleDist=re.detailSampleDist<.9?0:re.cs*re.detailSampleDist,re.detailSampleMaxError=re.ch*re.detailSampleMaxError;const ce=Math.floor(re.tileSize),me=Math.floor((de.width+ce-1)/ce),ge=Math.floor((de.height+ce-1)/ce),be=re.tileSize*re.cs,ue=e.fromArray(se);let fe=Math.min(Math.floor(te(ie(me*ge))),14);fe>14&&(fe=14);const ye=1<<fe,we=1<<22-fe,Se=$.create({orig:ue,tileWidth:re.tileSize*re.cs,tileHeight:re.tileSize*re.cs,maxTiles:ye,maxPolys:we});if(!U.initTiled(Se))return oe("Could not init nav mesh for tiled use");const pe=new G;if(K.chunkyTriMesh=pe,!pe.init(Z,ae,J,256))return oe("Failed to build chunky triangle mesh");const Me=(e,t,i,a)=>{const l=e=>(W.log(v.RC_LOG_ERROR,e),{success:!1,error:e}),o={tileX:e,tileY:t};K.tileIntermediates.push(o);const r=B(re),s=[...i],n=[...a];s[0]-=r.borderSize*r.cs,s[2]-=r.borderSize*r.cs,n[0]+=r.borderSize*r.cs,n[2]+=r.borderSize*r.cs,r.set_bmin(0,s[0]),r.set_bmin(1,s[1]),r.set_bmin(2,s[2]),r.set_bmax(0,n[0]),r.set_bmax(1,n[1]),r.set_bmax(2,n[2]),W.resetTimers(),W.startTimer(v.RC_TIMER_TOTAL),W.log(v.RC_LOG_PROGRESS,`Building tile ${K.tileIntermediates.length} at x: ${e}, y: ${t}`),W.log(v.RC_LOG_PROGRESS,` - ${re.width} x ${re.height} cells`),W.log(v.RC_LOG_PROGRESS,` - ${Y/1e3}fK verts, ${J/1e3}K tris`);const L=h();if(o.heightfield=L,!d(W,L,r.width,r.height,s,n,r.cs,r.ch))return l("Could not create heightfield");(new c).resize(pe.maxTrisPerChunk());const P=[s[0],s[2]],F=[n[0],n[2]],$=new j;$.resize(512);const G=pe.getChunksOverlappingRect(P,F,$,512);if(0===G)return{success:!0};for(let e=0;e<G;++e){const t=$.get(e),i=pe.nodes(t).n,a=pe.getNodeTris(t),o=new c;o.resize(i),m(W,r.walkableSlopeAngle,Z,Y,a,i,o);const s=g(W,Z,Y,a,o,i,L,r.walkableClimb);if(o.destroy(),!s)return l("Could not rasterize triangles")}b(W,r.walkableClimb,L),u(W,r.walkableHeight,r.walkableClimb,L),f(W,r.walkableHeight,L);const N=y();if(o.compactHeightfield=N,!w(W,r.walkableHeight,r.walkableClimb,L,N))return l("Could not build compact heightfield");if(I||(S(o.heightfield),o.heightfield=void 0),!p(W,r.walkableRadius,N))return l("Could not erode walkable area");if(!M(W,N))return l("Failed to build distance field");if(!R(W,N,r.borderSize,r.minRegionArea,r.mergeRegionArea))return l("Failed to build regions");const U=C();if(o.contourSet=U,!x(W,N,r.maxSimplificationError,r.maxEdgeLen,U,v.RC_CONTOUR_TESS_WALL_EDGES))return l("Failed to create contours");const V=k();if(o.polyMesh=V,!_(W,U,r.maxVertsPerPoly,V))return l("Failed to triangulate contours");const X=z();if(o.polyMeshDetail=X,!A(W,V,N,r.detailSampleDist,r.detailSampleMaxError,X))return l("Failed to build detail mesh");I||(T(N),o.compactHeightfield=void 0,E(U),o.contourSet=void 0);for(let e=0;e<V.npolys();e++)V.areas(e)==v.RC_WALKABLE_AREA&&V.setAreas(e,0),0==V.areas(e)&&V.setFlags(e,1);const q=new H;q.setPolyMeshCreateParams(V),q.setPolyMeshDetailCreateParams(X),q.setWalkableHeight(r.walkableHeight),q.setWalkableRadius(r.walkableRadius),q.setWalkableClimb(r.walkableClimb),q.setCellSize(r.cs),q.setCellHeight(r.ch),q.setBuildBvTree(!0),O.offMeshConnections&&q.setOffMeshConnections(O.offMeshConnections),q.setTileX(e),q.setTileY(t);const Q=D(q);return Q.success?(W.log(v.RC_LOG_PROGRESS,`>> Polymesh: ${V.nverts()} vertices  ${V.npolys()} polygons`),{success:!0,data:Q.navMeshData}):l("Failed to create Detour navmesh data")};W.startTimer(v.RC_TIMER_TEMP);const Re=[0,0,0],Ce=[0,0,0];for(let e=0;e<ge;e++)for(let t=0;t<me;t++){Re[0]=se[0]+t*be,Re[1]=se[1],Re[2]=se[2]+e*be,Ce[0]=se[0]+(t+1)*be,Ce[1]=he[1],Ce[2]=se[2]+(e+1)*be;const i=Me(t,e,Re,Ce);if(i.success&&i.data){U.removeTile(U.getTileRefAt(t,e,0));const a=U.addTile(i.data,X.DT_TILE_FREE_DATA,0);N(a.status)&&(W.log(v.RC_LOG_WARNING,`Failed to add tile to nav mesh\n\ttx: ${t}, ty: ${e},status: ${Q(a.status)} (${a.status})`),i.data.destroy())}}return W.stopTimer(v.RC_TIMER_TEMP),I||le(),{success:!0,navMesh:U,intermediates:K}},de=e=>{const t=[],i=[],a={};let l=0;for(const{positions:o,indices:r}of e)for(let e=0;e<r.length;e++){const s=3*r[e],n=o[s],h=o[s+1],d=o[s+2],c=`${n}_${h}_${d}`;let m=a[c];m||(a[c]=m=l,t.push(n,h,d),l++),i.push(m)}return[Float32Array.from(t),Uint32Array.from(i)]};export{re as createDefaultTileCacheMeshProcess,te as dtIlog2,ie as dtNextPow2,le as generateSoloNavMesh,se as generateTileCache,he as generateTiledNavMesh,ee as getBoundingBox,de as mergePositionsAndIndices,ae as soloNavMeshGeneratorConfigDefaults,oe as tileCacheGeneratorConfigDefaults,ne as tiledNavMeshGeneratorConfigDefaults};
-//# sourceMappingURL=index.mjs.map
+import { vec3, recastConfigDefaults, Raw, RecastBuildContext, NavMesh, VerticesArray, TrianglesArray, createRcConfig, calcGridSize, allocHeightfield, createHeightfield, TriangleAreasArray, markWalkableTriangles, rasterizeTriangles, filterLowHangingWalkableObstacles, filterLedgeSpans, filterWalkableLowHeightSpans, allocCompactHeightfield, buildCompactHeightfield, freeHeightfield, erodeWalkableArea, buildDistanceField, buildRegions, allocContourSet, buildContours, Recast, allocPolyMesh, buildPolyMesh, allocPolyMeshDetail, buildPolyMeshDetail, freeCompactHeightfield, freeContourSet, NavMeshCreateParams, createNavMeshData, freePolyMesh, freePolyMeshDetail, TileCacheMeshProcess, TileCache, DetourTileCacheParams, NavMeshParams, RecastChunkyTriMesh, statusFailed, freeHeightfieldLayerSet, cloneRcConfig, ChunkIdsArray, allocHeightfieldLayerSet, buildHeightfieldLayers, TileCacheData, Detour, getHeightfieldLayerHeights, getHeightfieldLayerAreas, getHeightfieldLayerCons, buildTileCacheLayer, statusToReadableString } from '@recast-navigation/core';
+
+const getBoundingBox = (positions, indices) => {
+  const bbMin = {
+    x: Infinity,
+    y: Infinity,
+    z: Infinity
+  };
+  const bbMax = {
+    x: -Infinity,
+    y: -Infinity,
+    z: -Infinity
+  };
+  for (let i = 0; i < indices.length; i++) {
+    const ind = indices[i];
+    const x = positions[ind * 3];
+    const y = positions[ind * 3 + 1];
+    const z = positions[ind * 3 + 2];
+    bbMin.x = Math.min(bbMin.x, x);
+    bbMin.y = Math.min(bbMin.y, y);
+    bbMin.z = Math.min(bbMin.z, z);
+    bbMax.x = Math.max(bbMax.x, x);
+    bbMax.y = Math.max(bbMax.y, y);
+    bbMax.z = Math.max(bbMax.z, z);
+  }
+  return {
+    bbMin: vec3.toArray(bbMin),
+    bbMax: vec3.toArray(bbMax)
+  };
+};
+const dtIlog2 = v => {
+  let r = 0;
+  let shift = 0;
+  r = Number(v > 0xffff) << 4;
+  v >>= r;
+  shift = Number(v > 0xff) << 3;
+  v >>= shift;
+  r |= shift;
+  shift = Number(v > 0xf) << 2;
+  v >>= shift;
+  r |= shift;
+  shift = Number(v > 0x3) << 1;
+  v >>= shift;
+  r |= shift;
+  r |= v >> 1;
+  return r;
+};
+const dtNextPow2 = v => {
+  v--;
+  v |= v >> 1;
+  v |= v >> 2;
+  v |= v >> 4;
+  v |= v >> 8;
+  v |= v >> 16;
+  v++;
+  return v;
+};
+
+const soloNavMeshGeneratorConfigDefaults = {
+  ...recastConfigDefaults
+};
+/**
+ * Builds a Solo NavMesh from the given positions and indices.
+ * @param positions a flat array of positions
+ * @param indices a flat array of indices
+ * @param navMeshGeneratorConfig optional configuration for the NavMesh generator
+ * @param keepIntermediates if true intermediates will be returned
+ */
+const generateSoloNavMesh = (positions, indices, navMeshGeneratorConfig = {}, keepIntermediates = false) => {
+  if (!Raw.Module) {
+    throw new Error('"init" must be called before using any recast-navigation-js APIs. See: https://github.com/isaac-mason/recast-navigation-js?tab=readme-ov-file#initialization');
+  }
+  const buildContext = new RecastBuildContext();
+  const intermediates = {
+    type: 'solo',
+    buildContext
+  };
+  const navMesh = new NavMesh();
+  const cleanup = () => {
+    if (keepIntermediates) return;
+    if (intermediates.heightfield) {
+      freeHeightfield(intermediates.heightfield);
+      intermediates.heightfield = undefined;
+    }
+    if (intermediates.compactHeightfield) {
+      freeCompactHeightfield(intermediates.compactHeightfield);
+      intermediates.compactHeightfield = undefined;
+    }
+    if (intermediates.contourSet) {
+      freeContourSet(intermediates.contourSet);
+      intermediates.contourSet = undefined;
+    }
+    if (intermediates.polyMesh) {
+      freePolyMesh(intermediates.polyMesh);
+      intermediates.polyMesh = undefined;
+    }
+    if (intermediates.polyMeshDetail) {
+      freePolyMeshDetail(intermediates.polyMeshDetail);
+      intermediates.polyMeshDetail = undefined;
+    }
+  };
+  const fail = error => {
+    cleanup();
+    navMesh.destroy();
+    return {
+      navMesh: undefined,
+      success: false,
+      intermediates,
+      error
+    };
+  };
+  /* input geometry */
+  const vertices = positions;
+  const numVertices = indices.length;
+  const verticesArray = new VerticesArray();
+  verticesArray.copy(vertices);
+  const triangles = indices;
+  const numTriangles = indices.length / 3;
+  const trianglesArray = new TrianglesArray();
+  trianglesArray.copy(triangles);
+  const {
+    bbMin,
+    bbMax
+  } = getBoundingBox(positions, indices);
+  //
+  // Step 1. Initialize build config.
+  //
+  const config = createRcConfig({
+    ...soloNavMeshGeneratorConfigDefaults,
+    ...navMeshGeneratorConfig
+  });
+  config.minRegionArea = config.minRegionArea * config.minRegionArea; // Note: area = size*size
+  config.mergeRegionArea = config.mergeRegionArea * config.mergeRegionArea; // Note: area = size*size
+  config.detailSampleDist = config.detailSampleDist < 0.9 ? 0 : config.cs * config.detailSampleDist;
+  config.detailSampleMaxError = config.ch * config.detailSampleMaxError;
+  const gridSize = calcGridSize(bbMin, bbMax, config.cs);
+  config.width = gridSize.width;
+  config.height = gridSize.height;
+  //
+  // Step 2. Rasterize input polygon soup.
+  //
+  // Allocate voxel heightfield where we rasterize our input data to.
+  const heightfield = allocHeightfield();
+  intermediates.heightfield = heightfield;
+  if (!createHeightfield(buildContext, heightfield, config.width, config.height, bbMin, bbMax, config.cs, config.ch)) {
+    return fail('Could not create heightfield');
+  }
+  // Find triangles which are walkable based on their slope and rasterize them.
+  // If your input data is multiple meshes, you can transform them here, calculate
+  // the are type for each of the meshes and rasterize them.
+  const triangleAreasArray = new TriangleAreasArray();
+  triangleAreasArray.resize(numTriangles);
+  markWalkableTriangles(buildContext, config.walkableSlopeAngle, verticesArray, numVertices, trianglesArray, numTriangles, triangleAreasArray);
+  if (!rasterizeTriangles(buildContext, verticesArray, numVertices, trianglesArray, triangleAreasArray, numTriangles, heightfield, config.walkableClimb)) {
+    return fail('Could not rasterize triangles');
+  }
+  triangleAreasArray.destroy();
+  verticesArray.destroy();
+  trianglesArray.destroy();
+  //
+  // Step 3. Filter walkables surfaces.
+  //
+  // Once all geoemtry is rasterized, we do initial pass of filtering to
+  // remove unwanted overhangs caused by the conservative rasterization
+  // as well as filter spans where the character cannot possibly stand.
+  filterLowHangingWalkableObstacles(buildContext, config.walkableClimb, heightfield);
+  filterLedgeSpans(buildContext, config.walkableHeight, config.walkableClimb, heightfield);
+  filterWalkableLowHeightSpans(buildContext, config.walkableHeight, heightfield);
+  //
+  // Step 4. Partition walkable surface to simple regions.
+  //
+  // 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.
+  const compactHeightfield = allocCompactHeightfield();
+  intermediates.compactHeightfield = compactHeightfield;
+  if (!buildCompactHeightfield(buildContext, config.walkableHeight, config.walkableClimb, heightfield, compactHeightfield)) {
+    return fail('Failed to build compact data');
+  }
+  if (!keepIntermediates) {
+    freeHeightfield(heightfield);
+    intermediates.heightfield = undefined;
+  }
+  // Erode the walkable area by agent radius.
+  if (!erodeWalkableArea(buildContext, config.walkableRadius, compactHeightfield)) {
+    return fail('Failed to erode walkable area');
+  }
+  // (Optional) Mark areas
+  // markConvexPolyArea(...)
+  // Prepare for region partitioning, by calculating Distance field along the walkable surface.
+  if (!buildDistanceField(buildContext, compactHeightfield)) {
+    return fail('Failed to build distance field');
+  }
+  // Partition the walkable surface into simple regions without holes.
+  if (!buildRegions(buildContext, compactHeightfield, config.borderSize, config.minRegionArea, config.mergeRegionArea)) {
+    return fail('Failed to build regions');
+  }
+  //
+  // Step 5. Trace and simplify region contours.
+  //
+  const contourSet = allocContourSet();
+  intermediates.contourSet = contourSet;
+  if (!buildContours(buildContext, compactHeightfield, config.maxSimplificationError, config.maxEdgeLen, contourSet, Recast.RC_CONTOUR_TESS_WALL_EDGES)) {
+    return fail('Failed to create contours');
+  }
+  //
+  // Step 6. Build polygons mesh from contours.
+  //
+  const polyMesh = allocPolyMesh();
+  intermediates.polyMesh = polyMesh;
+  if (!buildPolyMesh(buildContext, contourSet, config.maxVertsPerPoly, polyMesh)) {
+    return fail('Failed to triangulate contours');
+  }
+  //
+  // Step 7. Create detail mesh which allows to access approximate height on each polygon.
+  //
+  const polyMeshDetail = allocPolyMeshDetail();
+  intermediates.polyMeshDetail = polyMeshDetail;
+  if (!buildPolyMeshDetail(buildContext, polyMesh, compactHeightfield, config.detailSampleDist, config.detailSampleMaxError, polyMeshDetail)) {
+    return fail('Failed to build detail mesh');
+  }
+  if (!keepIntermediates) {
+    freeCompactHeightfield(compactHeightfield);
+    intermediates.compactHeightfield = undefined;
+    freeContourSet(contourSet);
+    intermediates.contourSet = undefined;
+  }
+  //
+  // Step 8. Create Detour data from Recast poly mesh.
+  //
+  for (let i = 0; i < polyMesh.npolys(); i++) {
+    if (polyMesh.areas(i) == Recast.RC_WALKABLE_AREA) {
+      polyMesh.setAreas(i, 0);
+    }
+    if (polyMesh.areas(i) == 0) {
+      polyMesh.setFlags(i, 1);
+    }
+  }
+  const navMeshCreateParams = new NavMeshCreateParams();
+  navMeshCreateParams.setPolyMeshCreateParams(polyMesh);
+  navMeshCreateParams.setPolyMeshDetailCreateParams(polyMeshDetail);
+  navMeshCreateParams.setWalkableHeight(config.walkableHeight);
+  navMeshCreateParams.setWalkableRadius(config.walkableRadius);
+  navMeshCreateParams.setWalkableClimb(config.walkableClimb);
+  navMeshCreateParams.setCellSize(config.cs);
+  navMeshCreateParams.setCellHeight(config.ch);
+  navMeshCreateParams.setBuildBvTree(true);
+  if (navMeshGeneratorConfig.offMeshConnections) {
+    navMeshCreateParams.setOffMeshConnections(navMeshGeneratorConfig.offMeshConnections);
+  }
+  const createNavMeshDataResult = createNavMeshData(navMeshCreateParams);
+  if (!createNavMeshDataResult.success) {
+    return fail('Failed to create Detour navmesh data');
+  }
+  const {
+    navMeshData
+  } = createNavMeshDataResult;
+  if (!navMesh.initSolo(navMeshData)) {
+    return fail('Failed to create Detour navmesh');
+  }
+  return {
+    success: true,
+    navMesh,
+    intermediates
+  };
+};
+
+const tileCacheGeneratorConfigDefaults = {
+  ...recastConfigDefaults,
+  tileSize: 32,
+  expectedLayersPerTile: 4,
+  maxObstacles: 128
+};
+const createDefaultTileCacheMeshProcess = () => new TileCacheMeshProcess((navMeshCreateParams, polyAreas, polyFlags) => {
+  for (let i = 0; i < navMeshCreateParams.polyCount(); ++i) {
+    polyAreas.set(i, 0);
+    polyFlags.set(i, 1);
+  }
+});
+/**
+ * Builds a TileCache and NavMesh from the given positions and indices.
+ * TileCache assumes small tiles (around 32-64 squared) and does some tricks to make the update fast.
+ * @param positions a flat array of positions
+ * @param indices a flat array of indices
+ * @param navMeshConfig optional configuration for the NavMesh
+ * @param keepIntermediates if true intermediates will be returned
+ */
+const generateTileCache = (positions, indices, navMeshGeneratorConfig = {}, keepIntermediates = false) => {
+  if (!Raw.Module) {
+    throw new Error('"init" must be called before using any recast-navigation-js APIs. See: https://github.com/isaac-mason/recast-navigation-js?tab=readme-ov-file#initialization');
+  }
+  const buildContext = new RecastBuildContext();
+  const intermediates = {
+    type: 'tilecache',
+    buildContext,
+    chunkyTriMesh: undefined,
+    tileIntermediates: []
+  };
+  const tileCache = new TileCache();
+  const navMesh = new NavMesh();
+  /* input geometry */
+  const vertices = positions;
+  const numVertices = indices.length;
+  const verticesArray = new VerticesArray();
+  verticesArray.copy(vertices);
+  const triangles = indices;
+  const numTriangles = indices.length / 3;
+  const trianglesArray = new TrianglesArray();
+  trianglesArray.copy(triangles);
+  const {
+    bbMin,
+    bbMax
+  } = getBoundingBox(positions, indices);
+  const {
+    expectedLayersPerTile,
+    maxObstacles,
+    ...recastConfig
+  } = {
+    ...tileCacheGeneratorConfigDefaults,
+    ...navMeshGeneratorConfig
+  };
+  const cleanup = () => {
+    verticesArray.destroy();
+    trianglesArray.destroy();
+    if (!keepIntermediates) {
+      for (let i = 0; i < intermediates.tileIntermediates.length; i++) {
+        const tileIntermediate = intermediates.tileIntermediates[i];
+        if (tileIntermediate.heightfield) {
+          freeHeightfield(tileIntermediate.heightfield);
+          tileIntermediate.heightfield = undefined;
+        }
+        if (tileIntermediate.compactHeightfield) {
+          freeCompactHeightfield(tileIntermediate.compactHeightfield);
+          tileIntermediate.compactHeightfield = undefined;
+        }
+        if (tileIntermediate.heightfieldLayerSet) {
+          freeHeightfieldLayerSet(tileIntermediate.heightfieldLayerSet);
+          tileIntermediate.heightfieldLayerSet = undefined;
+        }
+      }
+    }
+  };
+  const fail = error => {
+    cleanup();
+    tileCache.destroy();
+    navMesh.destroy();
+    return {
+      success: false,
+      navMesh: undefined,
+      tileCache: undefined,
+      intermediates,
+      error
+    };
+  };
+  //
+  // Step 1. Initialize build config.
+  //
+  const config = createRcConfig(recastConfig);
+  const gridSize = calcGridSize(bbMin, bbMax, config.cs);
+  config.width = gridSize.width;
+  config.height = gridSize.height;
+  config.minRegionArea = config.minRegionArea * config.minRegionArea; // Note: area = size*size
+  config.mergeRegionArea = config.mergeRegionArea * config.mergeRegionArea; // Note: area = size*size
+  config.detailSampleDist = config.detailSampleDist < 0.9 ? 0 : config.cs * config.detailSampleDist;
+  config.detailSampleMaxError = config.ch * config.detailSampleMaxError;
+  const tileSize = Math.floor(config.tileSize);
+  const tileWidth = Math.floor((config.width + tileSize - 1) / tileSize);
+  const tileHeight = Math.floor((config.height + tileSize - 1) / tileSize);
+  // Generation params
+  config.borderSize = config.walkableRadius + 3; // Reserve enough padding.
+  config.width = config.tileSize + config.borderSize * 2;
+  config.height = config.tileSize + config.borderSize * 2;
+  // Tile cache params
+  const tileCacheParams = DetourTileCacheParams.create({
+    orig: bbMin,
+    cs: config.cs,
+    ch: config.ch,
+    width: config.tileSize,
+    height: config.tileSize,
+    walkableHeight: config.walkableHeight,
+    walkableRadius: config.walkableRadius,
+    walkableClimb: config.walkableClimb,
+    maxSimplificationError: config.maxSimplificationError,
+    maxTiles: tileWidth * tileHeight * expectedLayersPerTile,
+    maxObstacles
+  });
+  const allocator = new Raw.RecastLinearAllocator(32000);
+  const compressor = new Raw.RecastFastLZCompressor();
+  const tileCacheMeshProcess = navMeshGeneratorConfig.tileCacheMeshProcess ?? createDefaultTileCacheMeshProcess();
+  if (!tileCache.init(tileCacheParams, allocator, compressor, tileCacheMeshProcess)) {
+    return fail('Failed to initialize tile cache');
+  }
+  const orig = vec3.fromArray(bbMin);
+  // Max tiles and max polys affect how the tile IDs are caculated.
+  // There are 22 bits available for identifying a tile and a polygon.
+  let tileBits = Math.min(Math.floor(dtIlog2(dtNextPow2(tileWidth * tileHeight * expectedLayersPerTile))), 14);
+  if (tileBits > 14) {
+    tileBits = 14;
+  }
+  const polyBits = 22 - tileBits;
+  const maxTiles = 1 << tileBits;
+  const maxPolysPerTile = 1 << polyBits;
+  const navMeshParams = NavMeshParams.create({
+    orig,
+    tileWidth: config.tileSize * config.cs,
+    tileHeight: config.tileSize * config.cs,
+    maxTiles,
+    maxPolys: maxPolysPerTile
+  });
+  if (!navMesh.initTiled(navMeshParams)) {
+    return fail('Failed to initialize tiled navmesh');
+  }
+  const chunkyTriMesh = new RecastChunkyTriMesh();
+  intermediates.chunkyTriMesh = chunkyTriMesh;
+  if (!chunkyTriMesh.init(verticesArray, trianglesArray, numTriangles, 256)) {
+    return fail('Failed to build chunky triangle mesh');
+  }
+  const rasterizeTileLayers = (tileX, tileY) => {
+    // Tile intermediates
+    const tileIntermediates = {
+      tileX,
+      tileY
+    };
+    // Tile bounds
+    const tcs = config.tileSize * config.cs;
+    const tileConfig = cloneRcConfig(config);
+    const tileBoundsMin = [bbMin[0] + tileX * tcs, bbMin[1], bbMin[2] + tileY * tcs];
+    const tileBoundsMax = [bbMin[0] + (tileX + 1) * tcs, bbMax[1], bbMin[2] + (tileY + 1) * tcs];
+    tileBoundsMin[0] -= tileConfig.borderSize * tileConfig.cs;
+    tileBoundsMin[2] -= tileConfig.borderSize * tileConfig.cs;
+    tileBoundsMax[0] += tileConfig.borderSize * tileConfig.cs;
+    tileBoundsMax[2] += tileConfig.borderSize * tileConfig.cs;
+    tileConfig.set_bmin(0, tileBoundsMin[0]);
+    tileConfig.set_bmin(1, tileBoundsMin[1]);
+    tileConfig.set_bmin(2, tileBoundsMin[2]);
+    tileConfig.set_bmax(0, tileBoundsMax[0]);
+    tileConfig.set_bmax(1, tileBoundsMax[1]);
+    tileConfig.set_bmax(2, tileBoundsMax[2]);
+    // Allocate voxel heightfield where we rasterize our input data to.
+    const heightfield = allocHeightfield();
+    tileIntermediates.heightfield = heightfield;
+    if (!createHeightfield(buildContext, heightfield, tileConfig.width, tileConfig.height, tileBoundsMin, tileBoundsMax, tileConfig.cs, tileConfig.ch)) {
+      return {
+        n: 0
+      };
+    }
+    const tbmin = [tileBoundsMin[0], tileBoundsMin[2]];
+    const tbmax = [tileBoundsMax[0], tileBoundsMax[2]];
+    // TODO: Make grow when returning too many items.
+    const maxChunkIds = 512;
+    const chunkIdsArray = new ChunkIdsArray();
+    chunkIdsArray.resize(maxChunkIds);
+    const nChunksOverlapping = chunkyTriMesh.getChunksOverlappingRect(tbmin, tbmax, chunkIdsArray, maxChunkIds);
+    if (nChunksOverlapping === 0) {
+      return {
+        n: 0
+      };
+    }
+    for (let i = 0; i < nChunksOverlapping; ++i) {
+      const nodeId = chunkIdsArray.get(i);
+      const node = chunkyTriMesh.nodes(nodeId);
+      const nNodeTris = node.n;
+      const nodeTrianglesArray = chunkyTriMesh.getNodeTris(nodeId);
+      const triangleAreasArray = new TriangleAreasArray();
+      triangleAreasArray.resize(nNodeTris);
+      // Find triangles which are walkable based on their slope and rasterize them.
+      // If your input data is multiple meshes, you can transform them here, calculate
+      // the are type for each of the meshes and rasterize them.
+      markWalkableTriangles(buildContext, tileConfig.walkableSlopeAngle, verticesArray, numVertices, nodeTrianglesArray, nNodeTris, triangleAreasArray);
+      const success = rasterizeTriangles(buildContext, verticesArray, numVertices, nodeTrianglesArray, triangleAreasArray, nNodeTris, heightfield, tileConfig.walkableClimb);
+      triangleAreasArray.destroy();
+      if (!success) {
+        return {
+          n: 0
+        };
+      }
+    }
+    // Once all geometry is rasterized, we do initial pass of filtering to
+    // remove unwanted overhangs caused by the conservative rasterization
+    // as well as filter spans where the character cannot possibly stand.
+    filterLowHangingWalkableObstacles(buildContext, config.walkableClimb, heightfield);
+    filterLedgeSpans(buildContext, config.walkableHeight, config.walkableClimb, heightfield);
+    filterWalkableLowHeightSpans(buildContext, config.walkableHeight, heightfield);
+    const compactHeightfield = allocCompactHeightfield();
+    if (!buildCompactHeightfield(buildContext, config.walkableHeight, config.walkableClimb, heightfield, compactHeightfield)) {
+      return {
+        n: 0
+      };
+    }
+    if (!keepIntermediates) {
+      freeHeightfield(tileIntermediates.heightfield);
+      tileIntermediates.heightfield = undefined;
+    }
+    // Erode the walkable area by agent radius
+    if (!erodeWalkableArea(buildContext, config.walkableRadius, compactHeightfield)) {
+      return {
+        n: 0
+      };
+    }
+    const heightfieldLayerSet = allocHeightfieldLayerSet();
+    if (!buildHeightfieldLayers(buildContext, compactHeightfield, config.borderSize, config.walkableHeight, heightfieldLayerSet)) {
+      return {
+        n: 0
+      };
+    }
+    if (!keepIntermediates) {
+      freeCompactHeightfield(compactHeightfield);
+      tileIntermediates.compactHeightfield = undefined;
+    }
+    const tiles = [];
+    for (let i = 0; i < heightfieldLayerSet.nlayers(); i++) {
+      const tile = new TileCacheData();
+      const heightfieldLayer = heightfieldLayerSet.layers(i);
+      // Store header
+      const header = new Raw.dtTileCacheLayerHeader();
+      header.magic = Detour.DT_TILECACHE_MAGIC;
+      header.version = Detour.DT_TILECACHE_VERSION;
+      // Tile layer location in the navmesh
+      header.tx = tileX;
+      header.ty = tileY;
+      header.tlayer = i;
+      const heightfieldLayerBin = heightfieldLayer.bmin();
+      const heightfieldLayerBmax = heightfieldLayer.bmax();
+      header.set_bmin(0, heightfieldLayerBin.x);
+      header.set_bmin(1, heightfieldLayerBin.y);
+      header.set_bmin(2, heightfieldLayerBin.z);
+      header.set_bmax(0, heightfieldLayerBmax.x);
+      header.set_bmax(1, heightfieldLayerBmax.y);
+      header.set_bmax(2, heightfieldLayerBmax.z);
+      // Tile info
+      header.width = heightfieldLayer.width();
+      header.height = heightfieldLayer.height();
+      header.minx = heightfieldLayer.minx();
+      header.maxx = heightfieldLayer.maxx();
+      header.miny = heightfieldLayer.miny();
+      header.maxy = heightfieldLayer.maxy();
+      header.hmin = heightfieldLayer.hmin();
+      header.hmax = heightfieldLayer.hmax();
+      const heights = getHeightfieldLayerHeights(heightfieldLayer);
+      const areas = getHeightfieldLayerAreas(heightfieldLayer);
+      const cons = getHeightfieldLayerCons(heightfieldLayer);
+      const status = buildTileCacheLayer(compressor, header, heights, areas, cons, tile);
+      if (statusFailed(status)) {
+        return {
+          n: 0
+        };
+      }
+      tiles.push(tile);
+    }
+    if (!keepIntermediates) {
+      freeHeightfieldLayerSet(heightfieldLayerSet);
+      tileIntermediates.heightfieldLayerSet = undefined;
+    }
+    intermediates.tileIntermediates.push(tileIntermediates);
+    return {
+      n: tiles.length,
+      tiles
+    };
+  };
+  // Preprocess tiles
+  for (let y = 0; y < tileHeight; ++y) {
+    for (let x = 0; x < tileWidth; ++x) {
+      const {
+        n,
+        tiles: newTiles
+      } = rasterizeTileLayers(x, y);
+      if (n > 0 && newTiles) {
+        for (let i = 0; i < n; i++) {
+          const tileCacheData = newTiles[i];
+          const addResult = tileCache.addTile(tileCacheData);
+          if (statusFailed(addResult.status)) {
+            buildContext.log(Recast.RC_LOG_WARNING, `Failed to add tile to tile cache - tx: ${x}, ty: ${y}`);
+            continue;
+          }
+        }
+      }
+    }
+  }
+  // Build initial meshes
+  for (let y = 0; y < tileHeight; y++) {
+    for (let x = 0; x < tileWidth; x++) {
+      const dtStatus = tileCache.buildNavMeshTilesAt(x, y, navMesh);
+      if (statusFailed(dtStatus)) {
+        return fail(`Failed to build nav mesh tiles at ${x}, ${y}`);
+      }
+    }
+  }
+  cleanup();
+  return {
+    success: true,
+    tileCache,
+    navMesh,
+    intermediates
+  };
+};
+
+const tiledNavMeshGeneratorConfigDefaults = {
+  ...recastConfigDefaults
+};
+/**
+ * Builds a Tiled NavMesh
+ * @param positions a flat array of positions
+ * @param indices a flat array of indices
+ * @param navMeshGeneratorConfig optional configuration for the NavMesh generator
+ * @param keepIntermediates if true intermediates will be returned
+ */
+const generateTiledNavMesh = (positions, indices, navMeshGeneratorConfig = {}, keepIntermediates = false) => {
+  if (!Raw.Module) {
+    throw new Error('"init" must be called before using any recast-navigation-js APIs. See: https://github.com/isaac-mason/recast-navigation-js?tab=readme-ov-file#initialization');
+  }
+  const buildContext = new RecastBuildContext();
+  const intermediates = {
+    type: 'tiled',
+    buildContext,
+    chunkyTriMesh: undefined,
+    tileIntermediates: []
+  };
+  const navMesh = new NavMesh();
+  /* input geometry */
+  const vertices = positions;
+  const numVertices = indices.length;
+  const verticesArray = new VerticesArray();
+  verticesArray.copy(vertices);
+  const triangles = indices;
+  const numTriangles = indices.length / 3;
+  const trianglesArray = new TrianglesArray();
+  trianglesArray.copy(triangles);
+  const cleanup = () => {
+    verticesArray.destroy();
+    trianglesArray.destroy();
+    if (keepIntermediates) return;
+    for (let i = 0; i < intermediates.tileIntermediates.length; i++) {
+      const tileIntermediate = intermediates.tileIntermediates[i];
+      if (tileIntermediate.compactHeightfield) {
+        freeCompactHeightfield(tileIntermediate.compactHeightfield);
+        tileIntermediate.compactHeightfield = undefined;
+      }
+      if (tileIntermediate.heightfield) {
+        freeHeightfield(tileIntermediate.heightfield);
+        tileIntermediate.heightfield = undefined;
+      }
+      if (tileIntermediate.contourSet) {
+        freeContourSet(tileIntermediate.contourSet);
+        tileIntermediate.contourSet = undefined;
+      }
+      if (tileIntermediate.polyMesh) {
+        freePolyMesh(tileIntermediate.polyMesh);
+        tileIntermediate.polyMesh = undefined;
+      }
+      if (tileIntermediate.polyMeshDetail) {
+        freePolyMeshDetail(tileIntermediate.polyMeshDetail);
+        tileIntermediate.polyMeshDetail = undefined;
+      }
+    }
+    if (intermediates.chunkyTriMesh) {
+      intermediates.chunkyTriMesh = undefined;
+    }
+  };
+  const fail = error => {
+    cleanup();
+    navMesh.destroy();
+    return {
+      success: false,
+      navMesh: undefined,
+      intermediates,
+      error
+    };
+  };
+  //
+  // Initialize build config.
+  //
+  const config = createRcConfig({
+    ...tiledNavMeshGeneratorConfigDefaults,
+    ...navMeshGeneratorConfig
+  });
+  /* get input bounding box */
+  const {
+    bbMin,
+    bbMax
+  } = getBoundingBox(positions, indices);
+  /* grid size */
+  const gridSize = calcGridSize(bbMin, bbMax, config.cs);
+  config.width = gridSize.width;
+  config.height = gridSize.height;
+  config.minRegionArea = config.minRegionArea * config.minRegionArea; // Note: area = size*size
+  config.mergeRegionArea = config.mergeRegionArea * config.mergeRegionArea; // Note: area = size*size
+  config.tileSize = Math.floor(config.tileSize);
+  config.borderSize = config.walkableRadius + 3; // Reserve enough padding.
+  config.width = config.tileSize + config.borderSize * 2;
+  config.height = config.tileSize + config.borderSize * 2;
+  config.detailSampleDist = config.detailSampleDist < 0.9 ? 0 : config.cs * config.detailSampleDist;
+  config.detailSampleMaxError = config.ch * config.detailSampleMaxError;
+  // tile size
+  const tileSize = Math.floor(config.tileSize);
+  const tileWidth = Math.floor((gridSize.width + tileSize - 1) / tileSize);
+  const tileHeight = Math.floor((gridSize.height + tileSize - 1) / tileSize);
+  const tcs = config.tileSize * config.cs;
+  /* Create dtNavMeshParams, initialise nav mesh for tiled use */
+  const orig = vec3.fromArray(bbMin);
+  // Max tiles and max polys affect how the tile IDs are caculated.
+  // There are 22 bits available for identifying a tile and a polygon.
+  let tileBits = Math.min(Math.floor(dtIlog2(dtNextPow2(tileWidth * tileHeight))), 14);
+  if (tileBits > 14) tileBits = 14;
+  const polyBits = 22 - tileBits;
+  const maxTiles = 1 << tileBits;
+  const maxPolysPerTile = 1 << polyBits;
+  const navMeshParams = NavMeshParams.create({
+    orig,
+    tileWidth: config.tileSize * config.cs,
+    tileHeight: config.tileSize * config.cs,
+    maxTiles,
+    maxPolys: maxPolysPerTile
+  });
+  if (!navMesh.initTiled(navMeshParams)) {
+    return fail('Could not init nav mesh for tiled use');
+  }
+  /* create chunky tri mesh */
+  const chunkyTriMesh = new RecastChunkyTriMesh();
+  intermediates.chunkyTriMesh = chunkyTriMesh;
+  if (!chunkyTriMesh.init(verticesArray, trianglesArray, numTriangles, 256)) {
+    return fail('Failed to build chunky triangle mesh');
+  }
+  /** @internal */
+  const buildTileMesh = (tileX, tileY, tileBoundsMin, tileBoundsMax) => {
+    const failTileMesh = error => {
+      buildContext.log(Recast.RC_LOG_ERROR, error);
+      return {
+        success: false,
+        error
+      };
+    };
+    const tileIntermediate = {
+      tileX,
+      tileY
+    };
+    intermediates.tileIntermediates.push(tileIntermediate);
+    const tileConfig = cloneRcConfig(config);
+    // Expand the heightfield bounding box by border size to find the extents of geometry we need to build this tile.
+    //
+    // This is done in order to make sure that the navmesh tiles connect correctly at the borders,
+    // and the obstacles close to the border work correctly with the dilation process.
+    // No polygons (or contours) will be created on the border area.
+    //
+    // IMPORTANT!
+    //
+    //   :''''''''':
+    //   : +-----+ :
+    //   : |     | :
+    //   : |     |<--- tile to build
+    //   : |     | :
+    //   : +-----+ :<-- geometry needed
+    //   :.........:
+    //
+    // You should use this bounding box to query your input geometry.
+    //
+    // For example if you build a navmesh for terrain, and want the navmesh tiles to match the terrain tile size
+    // you will need to pass in data from neighbour terrain tiles too! In a simple case, just pass in all the 8 neighbours,
+    // or use the bounding box below to only pass in a sliver of each of the 8 neighbours.
+    const expandedTileBoundsMin = [...tileBoundsMin];
+    const expandedTileBoundsMax = [...tileBoundsMax];
+    expandedTileBoundsMin[0] -= tileConfig.borderSize * tileConfig.cs;
+    expandedTileBoundsMin[2] -= tileConfig.borderSize * tileConfig.cs;
+    expandedTileBoundsMax[0] += tileConfig.borderSize * tileConfig.cs;
+    expandedTileBoundsMax[2] += tileConfig.borderSize * tileConfig.cs;
+    tileConfig.set_bmin(0, expandedTileBoundsMin[0]);
+    tileConfig.set_bmin(1, expandedTileBoundsMin[1]);
+    tileConfig.set_bmin(2, expandedTileBoundsMin[2]);
+    tileConfig.set_bmax(0, expandedTileBoundsMax[0]);
+    tileConfig.set_bmax(1, expandedTileBoundsMax[1]);
+    tileConfig.set_bmax(2, expandedTileBoundsMax[2]);
+    // Reset build timer
+    buildContext.resetTimers();
+    // Start the build process
+    buildContext.startTimer(Recast.RC_TIMER_TOTAL);
+    buildContext.log(Recast.RC_LOG_PROGRESS, `Building tile ${intermediates.tileIntermediates.length} at x: ${tileX}, y: ${tileY}`);
+    buildContext.log(Recast.RC_LOG_PROGRESS, ` - ${config.width} x ${config.height} cells`);
+    buildContext.log(Recast.RC_LOG_PROGRESS, ` - ${numVertices / 1000}fK verts, ${numTriangles / 1000}K tris`);
+    // Allocate voxel heightfield where we rasterize our input data to.
+    const heightfield = allocHeightfield();
+    tileIntermediate.heightfield = heightfield;
+    if (!createHeightfield(buildContext, heightfield, tileConfig.width, tileConfig.height, expandedTileBoundsMin, expandedTileBoundsMax, tileConfig.cs, tileConfig.ch)) {
+      return failTileMesh('Could not create heightfield');
+    }
+    // Allocate array that can hold triangle flags.
+    // If you have multiple meshes you need to process, allocate
+    // and array which can hold the max number of triangles you need to process.
+    const triAreas = new TriangleAreasArray();
+    triAreas.resize(chunkyTriMesh.maxTrisPerChunk());
+    const tbmin = [expandedTileBoundsMin[0], expandedTileBoundsMin[2]];
+    const tbmax = [expandedTileBoundsMax[0], expandedTileBoundsMax[2]];
+    // TODO: Make grow when returning too many items.
+    const maxChunkIds = 512;
+    const chunkIdsArray = new ChunkIdsArray();
+    chunkIdsArray.resize(maxChunkIds);
+    const nChunksOverlapping = chunkyTriMesh.getChunksOverlappingRect(tbmin, tbmax, chunkIdsArray, maxChunkIds);
+    if (nChunksOverlapping === 0) {
+      return {
+        success: true
+      };
+    }
+    for (let i = 0; i < nChunksOverlapping; ++i) {
+      const nodeId = chunkIdsArray.get(i);
+      const node = chunkyTriMesh.nodes(nodeId);
+      const nNodeTris = node.n;
+      const nodeTrianglesArray = chunkyTriMesh.getNodeTris(nodeId);
+      const triangleAreasArray = new TriangleAreasArray();
+      triangleAreasArray.resize(nNodeTris);
+      // Find triangles which are walkable based on their slope and rasterize them.
+      // If your input data is multiple meshes, you can transform them here, calculate
+      // the are type for each of the meshes and rasterize them.
+      markWalkableTriangles(buildContext, tileConfig.walkableSlopeAngle, verticesArray, numVertices, nodeTrianglesArray, nNodeTris, triangleAreasArray);
+      const success = rasterizeTriangles(buildContext, verticesArray, numVertices, nodeTrianglesArray, triangleAreasArray, nNodeTris, heightfield, tileConfig.walkableClimb);
+      triangleAreasArray.destroy();
+      if (!success) {
+        return failTileMesh('Could not rasterize triangles');
+      }
+    }
+    // Once all geometry is rasterized, we do initial pass of filtering to
+    // remove unwanted overhangs caused by the conservative rasterization
+    // as well as filter spans where the character cannot possibly stand.
+    filterLowHangingWalkableObstacles(buildContext, tileConfig.walkableClimb, heightfield);
+    filterLedgeSpans(buildContext, tileConfig.walkableHeight, tileConfig.walkableClimb, heightfield);
+    filterWalkableLowHeightSpans(buildContext, tileConfig.walkableHeight, heightfield);
+    // 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.
+    const compactHeightfield = allocCompactHeightfield();
+    tileIntermediate.compactHeightfield = compactHeightfield;
+    if (!buildCompactHeightfield(buildContext, tileConfig.walkableHeight, tileConfig.walkableClimb, heightfield, compactHeightfield)) {
+      return failTileMesh('Could not build compact heightfield');
+    }
+    if (!keepIntermediates) {
+      freeHeightfield(tileIntermediate.heightfield);
+      tileIntermediate.heightfield = undefined;
+    }
+    // Erode the walkable area by agent radius
+    if (!erodeWalkableArea(buildContext, tileConfig.walkableRadius, compactHeightfield)) {
+      return failTileMesh('Could not erode walkable area');
+    }
+    // (Optional) Mark areas
+    // markConvexPolyArea(...)
+    // Prepare for region partitioning, by calculating Distance field along the walkable surface.
+    if (!buildDistanceField(buildContext, compactHeightfield)) {
+      return failTileMesh('Failed to build distance field');
+    }
+    // Partition the walkable surface into simple regions without holes.
+    if (!buildRegions(buildContext, compactHeightfield, tileConfig.borderSize, tileConfig.minRegionArea, tileConfig.mergeRegionArea)) {
+      return failTileMesh('Failed to build regions');
+    }
+    //
+    // Trace and simplify region contours.
+    //
+    const contourSet = allocContourSet();
+    tileIntermediate.contourSet = contourSet;
+    if (!buildContours(buildContext, compactHeightfield, tileConfig.maxSimplificationError, tileConfig.maxEdgeLen, contourSet, Recast.RC_CONTOUR_TESS_WALL_EDGES)) {
+      return failTileMesh('Failed to create contours');
+    }
+    //
+    // Build polygons mesh from contours.
+    //
+    const polyMesh = allocPolyMesh();
+    tileIntermediate.polyMesh = polyMesh;
+    if (!buildPolyMesh(buildContext, contourSet, tileConfig.maxVertsPerPoly, polyMesh)) {
+      return failTileMesh('Failed to triangulate contours');
+    }
+    //
+    // Create detail mesh which allows to access approximate height on each polygon.
+    //
+    const polyMeshDetail = allocPolyMeshDetail();
+    tileIntermediate.polyMeshDetail = polyMeshDetail;
+    if (!buildPolyMeshDetail(buildContext, polyMesh, compactHeightfield, tileConfig.detailSampleDist, tileConfig.detailSampleMaxError, polyMeshDetail)) {
+      return failTileMesh('Failed to build detail mesh');
+    }
+    if (!keepIntermediates) {
+      freeCompactHeightfield(compactHeightfield);
+      tileIntermediate.compactHeightfield = undefined;
+      freeContourSet(contourSet);
+      tileIntermediate.contourSet = undefined;
+    }
+    // Update poly flags from areas.
+    for (let i = 0; i < polyMesh.npolys(); i++) {
+      if (polyMesh.areas(i) == Recast.RC_WALKABLE_AREA) {
+        polyMesh.setAreas(i, 0);
+      }
+      if (polyMesh.areas(i) == 0) {
+        polyMesh.setFlags(i, 1);
+      }
+    }
+    const navMeshCreateParams = new NavMeshCreateParams();
+    navMeshCreateParams.setPolyMeshCreateParams(polyMesh);
+    navMeshCreateParams.setPolyMeshDetailCreateParams(polyMeshDetail);
+    navMeshCreateParams.setWalkableHeight(tileConfig.walkableHeight);
+    navMeshCreateParams.setWalkableRadius(tileConfig.walkableRadius);
+    navMeshCreateParams.setWalkableClimb(tileConfig.walkableClimb);
+    navMeshCreateParams.setCellSize(tileConfig.cs);
+    navMeshCreateParams.setCellHeight(tileConfig.ch);
+    navMeshCreateParams.setBuildBvTree(true);
+    if (navMeshGeneratorConfig.offMeshConnections) {
+      navMeshCreateParams.setOffMeshConnections(navMeshGeneratorConfig.offMeshConnections);
+    }
+    navMeshCreateParams.setTileX(tileX);
+    navMeshCreateParams.setTileY(tileY);
+    const createNavMeshDataResult = createNavMeshData(navMeshCreateParams);
+    if (!createNavMeshDataResult.success) {
+      return failTileMesh('Failed to create Detour navmesh data');
+    }
+    buildContext.log(Recast.RC_LOG_PROGRESS, `>> Polymesh: ${polyMesh.nverts()} vertices  ${polyMesh.npolys()} polygons`);
+    return {
+      success: true,
+      data: createNavMeshDataResult.navMeshData
+    };
+  };
+  buildContext.startTimer(Recast.RC_TIMER_TEMP);
+  const lastBuiltTileBmin = [0, 0, 0];
+  const lastBuiltTileBmax = [0, 0, 0];
+  for (let y = 0; y < tileHeight; y++) {
+    for (let x = 0; x < tileWidth; x++) {
+      lastBuiltTileBmin[0] = bbMin[0] + x * tcs;
+      lastBuiltTileBmin[1] = bbMin[1];
+      lastBuiltTileBmin[2] = bbMin[2] + y * tcs;
+      lastBuiltTileBmax[0] = bbMin[0] + (x + 1) * tcs;
+      lastBuiltTileBmax[1] = bbMax[1];
+      lastBuiltTileBmax[2] = bbMin[2] + (y + 1) * tcs;
+      const result = buildTileMesh(x, y, lastBuiltTileBmin, lastBuiltTileBmax);
+      if (result.success && result.data) {
+        navMesh.removeTile(navMesh.getTileRefAt(x, y, 0));
+        const addTileResult = navMesh.addTile(result.data, Detour.DT_TILE_FREE_DATA, 0);
+        if (statusFailed(addTileResult.status)) {
+          buildContext.log(Recast.RC_LOG_WARNING, `Failed to add tile to nav mesh` + '\n\t' + `tx: ${x}, ty: ${y},` + `status: ${statusToReadableString(addTileResult.status)} (${addTileResult.status})`);
+          result.data.destroy();
+        }
+      }
+    }
+  }
+  buildContext.stopTimer(Recast.RC_TIMER_TEMP);
+  if (!keepIntermediates) {
+    cleanup();
+  }
+  return {
+    success: true,
+    navMesh,
+    intermediates
+  };
+};
+
+const mergePositionsAndIndices = meshes => {
+  const mergedPositions = [];
+  const mergedIndices = [];
+  const positionToIndex = {};
+  let indexCounter = 0;
+  for (const {
+    positions,
+    indices
+  } of meshes) {
+    for (let i = 0; i < indices.length; i++) {
+      const pt = indices[i] * 3;
+      const x = positions[pt];
+      const y = positions[pt + 1];
+      const z = positions[pt + 2];
+      const key = `${x}_${y}_${z}`;
+      let idx = positionToIndex[key];
+      if (!idx) {
+        positionToIndex[key] = idx = indexCounter;
+        mergedPositions.push(x, y, z);
+        indexCounter++;
+      }
+      mergedIndices.push(idx);
+    }
+  }
+  return [Float32Array.from(mergedPositions), Uint32Array.from(mergedIndices)];
+};
+
+export { createDefaultTileCacheMeshProcess, dtIlog2, dtNextPow2, generateSoloNavMesh, generateTileCache, generateTiledNavMesh, getBoundingBox, mergePositionsAndIndices, soloNavMeshGeneratorConfigDefaults, tileCacheGeneratorConfigDefaults, tiledNavMeshGeneratorConfigDefaults };

package/package.json

@@ -6,7 +6,7 @@
     "email": "isaac@isaacmason.com",
     "url": "https://isaacmason.com/"
   },
-  "version": "0.35.0",
+  "version": "0.35.2",
   "license": "MIT",
   "homepage": "https://github.com/isaac-mason/recast-navigation-js",
   "bugs": {
@@ -27,8 +27,8 @@
     "lint": "eslint src"
   },
   "dependencies": {
-    "@recast-navigation/core": "0.35.0",
-    "@recast-navigation/wasm": "0.35.0"
+    "@recast-navigation/core": "0.35.2",
+    "@recast-navigation/wasm": "0.35.2"
   },
   "devDependencies": {
     "@babel/core": "^7.24.5",
@@ -38,7 +38,6 @@
     "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-node-resolve": "^15.0.1",
-    "@rollup/plugin-terser": "^0.4.3",
     "@rollup/plugin-typescript": "^11.1.6",
     "eslint": "^9.6.0",
     "prettier": "^3.1.0",

package/dist/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","sources":["../src/generators/common.ts","../src/generators/generate-solo-nav-mesh.ts","../src/generators/generate-tile-cache.ts","../src/generators/generate-tiled-nav-mesh.ts","../src/generators/merge-positions-and-indices.ts"],"sourcesContent":[null,null,null,null,null],"names":["getBoundingBox","positions","indices","bbMin","x","Infinity","y","z","bbMax","i","length","ind","Math","min","max","vec3","toArray","dtIlog2","v","r","shift","Number","dtNextPow2","soloNavMeshGeneratorConfigDefaults","recastConfigDefaults","generateSoloNavMesh","navMeshGeneratorConfig","keepIntermediates","Raw","Module","Error","buildContext","RecastBuildContext","intermediates","type","navMesh","NavMesh","fail","error","heightfield","freeHeightfield","undefined","compactHeightfield","freeCompactHeightfield","contourSet","freeContourSet","polyMesh","freePolyMesh","polyMeshDetail","freePolyMeshDetail","destroy","success","vertices","numVertices","verticesArray","VerticesArray","copy","triangles","numTriangles","trianglesArray","TrianglesArray","config","createRcConfig","minRegionArea","mergeRegionArea","detailSampleDist","cs","detailSampleMaxError","ch","gridSize","calcGridSize","width","height","allocHeightfield","createHeightfield","triangleAreasArray","TriangleAreasArray","resize","markWalkableTriangles","walkableSlopeAngle","rasterizeTriangles","walkableClimb","filterLowHangingWalkableObstacles","filterLedgeSpans","walkableHeight","filterWalkableLowHeightSpans","allocCompactHeightfield","buildCompactHeightfield","erodeWalkableArea","walkableRadius","buildDistanceField","buildRegions","borderSize","allocContourSet","buildContours","maxSimplificationError","maxEdgeLen","Recast","RC_CONTOUR_TESS_WALL_EDGES","allocPolyMesh","buildPolyMesh","maxVertsPerPoly","allocPolyMeshDetail","buildPolyMeshDetail","npolys","areas","RC_WALKABLE_AREA","setAreas","setFlags","navMeshCreateParams","NavMeshCreateParams","setPolyMeshCreateParams","setPolyMeshDetailCreateParams","setWalkableHeight","setWalkableRadius","setWalkableClimb","setCellSize","setCellHeight","setBuildBvTree","offMeshConnections","setOffMeshConnections","createNavMeshDataResult","createNavMeshData","navMeshData","initSolo","tileCacheGeneratorConfigDefaults","tileSize","expectedLayersPerTile","maxObstacles","createDefaultTileCacheMeshProcess","TileCacheMeshProcess","polyAreas","polyFlags","polyCount","set","generateTileCache","chunkyTriMesh","tileIntermediates","tileCache","TileCache","recastConfig","cleanup","tileIntermediate","heightfieldLayerSet","freeHeightfieldLayerSet","floor","tileWidth","tileHeight","tileCacheParams","DetourTileCacheParams","create","orig","maxTiles","allocator","RecastLinearAllocator","compressor","RecastFastLZCompressor","tileCacheMeshProcess","init","fromArray","tileBits","maxPolysPerTile","navMeshParams","NavMeshParams","maxPolys","initTiled","RecastChunkyTriMesh","rasterizeTileLayers","tileX","tileY","tcs","tileConfig","cloneRcConfig","tileBoundsMin","tileBoundsMax","set_bmin","set_bmax","n","tbmin","tbmax","chunkIdsArray","ChunkIdsArray","nChunksOverlapping","getChunksOverlappingRect","nodeId","get","nNodeTris","nodes","nodeTrianglesArray","getNodeTris","allocHeightfieldLayerSet","buildHeightfieldLayers","tiles","nlayers","tile","TileCacheData","heightfieldLayer","layers","header","dtTileCacheLayerHeader","magic","Detour","DT_TILECACHE_MAGIC","version","DT_TILECACHE_VERSION","tx","ty","tlayer","heightfieldLayerBin","bmin","heightfieldLayerBmax","bmax","minx","maxx","miny","maxy","hmin","hmax","heights","getHeightfieldLayerHeights","getHeightfieldLayerAreas","cons","getHeightfieldLayerCons","status","buildTileCacheLayer","statusFailed","push","newTiles","tileCacheData","addResult","addTile","log","RC_LOG_WARNING","dtStatus","buildNavMeshTilesAt","tiledNavMeshGeneratorConfigDefaults","generateTiledNavMesh","buildTileMesh","failTileMesh","RC_LOG_ERROR","expandedTileBoundsMin","expandedTileBoundsMax","resetTimers","startTimer","RC_TIMER_TOTAL","RC_LOG_PROGRESS","maxTrisPerChunk","setTileX","setTileY","nverts","data","RC_TIMER_TEMP","lastBuiltTileBmin","lastBuiltTileBmax","result","removeTile","getTileRefAt","addTileResult","DT_TILE_FREE_DATA","statusToReadableString","stopTimer","mergePositionsAndIndices","meshes","mergedPositions","mergedIndices","positionToIndex","indexCounter","pt","key","idx","Float32Array","from","Uint32Array"],"mappings":"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"}