@recast-navigation/generators 0.0.0-canary-20261030-064e4acc

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright © 2025 Isaac Mason
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @recast-navigation/generators
+
+This package contains "Preset" NavMesh generators for @recast-navigation/core that make getting started easy.
+
+These can also be used as a basis for your own generator.
+
+Please refer to the [main package's README](https://github.com/isaac-mason/recast-navigation-js/tree/main/packages/recast-navigation/README.md) for usage information.

package/dist/generators/common.d.ts

@@ -0,0 +1,10 @@
+import { type OffMeshConnectionParams } from '@recast-navigation/core';
+export declare const getBoundingBox: (positions: ArrayLike<number>, indices: ArrayLike<number>) => {
+    bbMin: import("@recast-navigation/core").Vector3Tuple;
+    bbMax: import("@recast-navigation/core").Vector3Tuple;
+};
+export declare const dtIlog2: (v: number) => number;
+export declare const dtNextPow2: (v: number) => number;
+export type OffMeshConnectionGeneratorParams = {
+    offMeshConnections?: OffMeshConnectionParams[];
+};

package/dist/generators/generate-solo-nav-mesh.d.ts

@@ -0,0 +1,82 @@
+import { NavMesh, RecastBuildContext, type RecastCompactHeightfield, type RecastConfig, type RecastContourSet, type RecastHeightfield, type RecastPolyMesh, type RecastPolyMeshDetail, type UnsignedCharArray, type Vector3Tuple } from '@recast-navigation/core';
+import type { Pretty } from '../types';
+import { type OffMeshConnectionGeneratorParams } from './common';
+export type SoloNavMeshGeneratorConfig = Pretty<Omit<RecastConfig, 'tileSize'> & OffMeshConnectionGeneratorParams & {
+    /**
+     * @default true
+     */
+    buildBvTree?: boolean;
+    /**
+     * The minimum and maximum bounds of the heightfield's AABB in world units.
+     * If not provided, the bounding box will be calculated from the input positions and indices
+     */
+    bounds?: [bbMin: Vector3Tuple, bbMax: Vector3Tuple];
+}>;
+export declare const soloNavMeshGeneratorConfigDefaults: {
+    buildBvTree: true;
+    borderSize: number;
+    tileSize: number;
+    cs: number;
+    ch: number;
+    walkableSlopeAngle: number;
+    walkableHeight: number;
+    walkableClimb: number;
+    walkableRadius: number;
+    maxEdgeLen: number;
+    maxSimplificationError: number;
+    minRegionArea: number;
+    mergeRegionArea: number;
+    maxVertsPerPoly: number;
+    detailSampleDist: number;
+    detailSampleMaxError: number;
+};
+export type SoloNavMeshGeneratorIntermediates = {
+    type: 'solo';
+    buildContext: RecastBuildContext;
+    heightfield?: RecastHeightfield;
+    compactHeightfield?: RecastCompactHeightfield;
+    contourSet?: RecastContourSet;
+    polyMesh?: RecastPolyMesh;
+    polyMeshDetail?: RecastPolyMeshDetail;
+};
+type GenerateSoloNavMeshDataSuccessResult = {
+    navMeshData: UnsignedCharArray;
+    success: true;
+    intermediates: SoloNavMeshGeneratorIntermediates;
+};
+type GenerateSoloNavMeshDataFailResult = {
+    navMeshData: undefined;
+    success: false;
+    intermediates: SoloNavMeshGeneratorIntermediates;
+    error: string;
+};
+export type GenerateSoloNavMeshDataResult = GenerateSoloNavMeshDataSuccessResult | GenerateSoloNavMeshDataFailResult;
+/**
+ * Builds Solo NavMesh data 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
+ */
+export declare const generateSoloNavMeshData: (positions: ArrayLike<number>, indices: ArrayLike<number>, navMeshGeneratorConfig?: Partial<SoloNavMeshGeneratorConfig>, keepIntermediates?: boolean) => GenerateSoloNavMeshDataResult;
+type GenerateSoloNavMeshSuccessResult = {
+    navMesh: NavMesh;
+    success: true;
+    intermediates: SoloNavMeshGeneratorIntermediates;
+};
+type GenerateSoloNavMeshFailResult = {
+    navMesh: undefined;
+    success: false;
+    intermediates: SoloNavMeshGeneratorIntermediates;
+    error: string;
+};
+export type GenerateSoloNavMeshResult = GenerateSoloNavMeshSuccessResult | GenerateSoloNavMeshFailResult;
+/**
+ * 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
+ */
+export declare const generateSoloNavMesh: (positions: ArrayLike<number>, indices: ArrayLike<number>, navMeshGeneratorConfig?: Partial<SoloNavMeshGeneratorConfig>, keepIntermediates?: boolean) => GenerateSoloNavMeshResult;
+export {};

package/dist/generators/generate-tile-cache.d.ts

@@ -0,0 +1,63 @@
+import { NavMesh, RecastBuildContext, RecastChunkyTriMesh, type RecastCompactHeightfield, type RecastConfig, type RecastHeightfield, type RecastHeightfieldLayerSet, TileCache, TileCacheMeshProcess, type Vector3Tuple } from '@recast-navigation/core';
+import type { Pretty } from '../types';
+type TileCacheRecastConfig = Omit<RecastConfig, 'minRegionArea' | 'maxEdgeLen'>;
+export type TileCacheGeneratorConfig = Pretty<TileCacheRecastConfig & {
+    /**
+     * The minimum and maximum bounds of the heightfield's AABB in world units.
+     * If not provided, the bounding box will be calculated from the input positions and indices
+     */
+    bounds?: [bbMin: Vector3Tuple, bbMax: Vector3Tuple];
+    /**
+     * How many layers (or "floors") each navmesh tile is expected to have.
+     */
+    expectedLayersPerTile: number;
+    /**
+     * The max number of obstacles
+     */
+    maxObstacles: number;
+    /**
+     * The tile cache mesh process implementation.
+     * If not provided, a default one is created via `createDefaultTileCacheMeshProcess()`
+     * @default createDefaultTileCacheMeshProcess()
+     */
+    tileCacheMeshProcess?: TileCacheMeshProcess;
+}>;
+export declare const tileCacheGeneratorConfigDefaults: TileCacheGeneratorConfig;
+export type TileCacheGeneratorTileIntermediates = {
+    tileX: number;
+    tileY: number;
+    heightfield?: RecastHeightfield;
+    compactHeightfield?: RecastCompactHeightfield;
+    heightfieldLayerSet?: RecastHeightfieldLayerSet;
+};
+export type TileCacheGeneratorIntermediates = {
+    type: 'tilecache';
+    buildContext: RecastBuildContext;
+    chunkyTriMesh?: RecastChunkyTriMesh;
+    tileIntermediates: TileCacheGeneratorTileIntermediates[];
+};
+type TileCacheGeneratorSuccessResult = {
+    tileCache: TileCache;
+    navMesh: NavMesh;
+    success: true;
+    intermediates: TileCacheGeneratorIntermediates;
+};
+type TileCacheGeneratorFailResult = {
+    tileCache: undefined;
+    navMesh: undefined;
+    success: false;
+    error: string;
+    intermediates: TileCacheGeneratorIntermediates;
+};
+export type TileCacheGeneratorResult = TileCacheGeneratorSuccessResult | TileCacheGeneratorFailResult;
+export declare const createDefaultTileCacheMeshProcess: () => TileCacheMeshProcess;
+/**
+ * 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
+ */
+export declare const generateTileCache: (positions: ArrayLike<number>, indices: ArrayLike<number>, navMeshGeneratorConfig?: Partial<TileCacheGeneratorConfig>, keepIntermediates?: boolean) => TileCacheGeneratorResult;
+export {};

package/dist/generators/generate-tiled-nav-mesh.d.ts

@@ -0,0 +1,111 @@
+import { type FloatArray, type IntArray, NavMesh, type OffMeshConnectionParams, type RawModule, RecastBuildContext, RecastChunkyTriMesh, type RecastCompactHeightfield, type RecastConfig, type RecastContourSet, type RecastHeightfield, type RecastPolyMesh, type RecastPolyMeshDetail, type UnsignedCharArray, type Vector3Tuple } from '@recast-navigation/core';
+import type { Pretty } from '../types';
+import { type OffMeshConnectionGeneratorParams } from './common';
+export declare const buildTiledNavMeshRcConfig: ({ recastConfig, navMeshBounds: [navMeshBoundsMin, navMeshBoundsMax], }: {
+    recastConfig: RecastConfig;
+    navMeshBounds: [min: Vector3Tuple, max: Vector3Tuple];
+}) => {
+    config: RawModule.rcConfig;
+    gridSize: RawModule.RecastCalcGridSizeResult;
+    tileSize: number;
+    tileWidth: number;
+    tileHeight: number;
+    tcs: number;
+    orig: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    maxTiles: number;
+    maxPolysPerTile: number;
+};
+export type TiledNavMeshGeneratorConfig = Pretty<RecastConfig & OffMeshConnectionGeneratorParams & {
+    /**
+     * The minimum and maximum bounds of the heightfield's AABB in world units.
+     * If not provided, the bounding box will be calculated from the input positions and indices
+     */
+    bounds?: [bbMin: Vector3Tuple, bbMax: Vector3Tuple];
+    /**
+     * @default 128
+     */
+    chunkyTriMeshTrisPerChunk?: number;
+    /**
+     * @default true
+     */
+    buildBvTree?: boolean;
+}>;
+export declare const tiledNavMeshGeneratorConfigDefaults: {
+    chunkyTriMeshTrisPerChunk: number;
+    buildBvTree: true;
+    borderSize: number;
+    tileSize: number;
+    cs: number;
+    ch: number;
+    walkableSlopeAngle: number;
+    walkableHeight: number;
+    walkableClimb: number;
+    walkableRadius: number;
+    maxEdgeLen: number;
+    maxSimplificationError: number;
+    minRegionArea: number;
+    mergeRegionArea: number;
+    maxVertsPerPoly: number;
+    detailSampleDist: number;
+    detailSampleMaxError: number;
+};
+type TileIntermediates = {
+    x: number;
+    y: number;
+    heightfield?: RecastHeightfield;
+    compactHeightfield?: RecastCompactHeightfield;
+    contourSet?: RecastContourSet;
+    polyMesh?: RecastPolyMesh;
+    polyMeshDetail?: RecastPolyMeshDetail;
+};
+type GenerateTileNavMeshDataSuccessResult = {
+    success: true;
+    data?: UnsignedCharArray;
+    intermediates: TileIntermediates;
+};
+type GenerateTileNavMeshDataFailResult = {
+    success: false;
+    error: string;
+    intermediates: TileIntermediates;
+};
+export type GenerateTileNavMeshDataResult = GenerateTileNavMeshDataSuccessResult | GenerateTileNavMeshDataFailResult;
+export declare const generateTileNavMeshData: (positions: FloatArray, indices: IntArray, rcConfig: RawModule.rcConfig, chunkyTriMesh: RecastChunkyTriMesh, tile: {
+    x: number;
+    y: number;
+    bmin: Vector3Tuple;
+    bmax: Vector3Tuple;
+}, options?: {
+    offMeshConnections?: OffMeshConnectionParams[];
+    buildBvTree?: boolean;
+}, keepIntermediates?: boolean, buildContextParam?: RecastBuildContext) => GenerateTileNavMeshDataResult;
+export type TiledNavMeshGeneratorIntermediates = {
+    type: 'tiled';
+    buildContext: RecastBuildContext;
+    chunkyTriMesh?: RecastChunkyTriMesh;
+    tileIntermediates: TileIntermediates[];
+};
+type GenerateTiledNavMeshSuccessResult = {
+    navMesh: NavMesh;
+    success: true;
+    intermediates: TiledNavMeshGeneratorIntermediates;
+};
+type GenerateTiledNavMeshFailResult = {
+    navMesh: undefined;
+    success: false;
+    intermediates: TiledNavMeshGeneratorIntermediates;
+    error: string;
+};
+export type GenerateTiledNavMeshResult = GenerateTiledNavMeshSuccessResult | GenerateTiledNavMeshFailResult;
+/**
+ * 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
+ */
+export declare const generateTiledNavMesh: (positions: ArrayLike<number>, indices: ArrayLike<number>, navMeshGeneratorConfig?: Partial<TiledNavMeshGeneratorConfig>, keepIntermediates?: boolean) => GenerateTiledNavMeshResult;
+export {};

package/dist/generators/index.d.ts

@@ -0,0 +1,5 @@
+export * from './common';
+export * from './generate-solo-nav-mesh';
+export * from './generate-tile-cache';
+export * from './generate-tiled-nav-mesh';
+export * from './merge-positions-and-indices';

package/dist/generators/merge-positions-and-indices.d.ts

@@ -0,0 +1,4 @@
+export declare const mergePositionsAndIndices: (meshes: Array<{
+    positions: ArrayLike<number>;
+    indices: ArrayLike<number>;
+}>) => [Float32Array, Uint32Array];

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './generators';