@recast-navigation/core 0.0.7 → 0.1.1

package/dist/nav-mesh-builder.d.ts

@@ -1,5 +1,5 @@
 import type R from '@recast-navigation/wasm';
-export declare type NavMeshCreateParams = {
+export declare type CreateNavMeshDataParams = {
     verts: number[];
     vertCount: number;
     polys: number[];
@@ -32,13 +32,9 @@ export declare type NavMeshCreateParams = {
     ch: number;
     buildBvTree: boolean;
 };
-export declare type CreateNavMeshDataResult = {
-    success: boolean;
-    navMeshData: readonly number[];
-    navMeshDataSize: number;
-};
+export declare type CreateNavMeshDataResult = R.CreateNavMeshDataResult;
 export declare class NavMeshBuilder {
     raw: R.NavMeshBuilder;
     constructor();
-    createNavMeshData(params: NavMeshCreateParams): CreateNavMeshDataResult;
+    createNavMeshData(params: CreateNavMeshDataParams): CreateNavMeshDataResult;
 }

package/dist/nav-mesh-generator.d.ts

@@ -97,6 +97,14 @@ export declare type NavMeshConfig = {
      * @default 1
      */
     detailSampleMaxError: number;
+    /**
+     * How many layers (or "floors") each navmesh tile is expected to have.
+     */
+    expectedLayersPerTile: number;
+    /**
+     * The max number of layers a navmesh can have.
+     */
+    maxLayers: number;
 };
 export declare type NavMeshGeneratorResult = {
     success: boolean;

package/dist/nav-mesh-query.d.ts

@@ -1,6 +1,6 @@
 import type R from '@recast-navigation/wasm';
 import { NavMesh } from './nav-mesh';
-import { NavPath, Vector3 } from './utils';
+import { Vector3 } from './utils';
 export declare type NavMeshQueryParams = {
     navMesh: NavMesh;
     /**
@@ -28,7 +28,7 @@ export declare class NavMeshQuery {
      *g
      * @returns an array of Vector3 positions that make up the path, or an empty array if no path was found.
      */
-    computePath(start: Vector3, end: Vector3): NavPath;
+    computePath(start: Vector3, end: Vector3): Vector3[];
     /**
      * Gets the Bounding box extent specified by setDefaultQueryExtent
      */

package/dist/nav-mesh.d.ts

@@ -1,16 +1,164 @@
 import type R from '@recast-navigation/wasm';
-import { DebugNavMesh } from './debug-nav-mesh';
+import { Vector3 } from './utils';
+export declare class dtPoly {
+    raw: R.dtPoly;
+    constructor(raw: R.dtPoly);
+    firstLink(): number;
+    verts(index: number): number;
+    neis(index: number): number;
+    flags(): number;
+    vertCount(): number;
+    areaAndType(): number;
+    getType(): number;
+}
+export declare class dtPolyDetail {
+    raw: R.dtPolyDetail;
+    constructor(raw: R.dtPolyDetail);
+    vertBase(): number;
+    triBase(): number;
+    vertCount(): number;
+    triCount(): number;
+}
+export declare class dtLink {
+    raw: R.dtLink;
+    constructor(raw: R.dtLink);
+    ref(): number;
+    next(): number;
+    edge(): number;
+    side(): number;
+    bmin(): number;
+    bmax(): number;
+}
+export declare class dtBVNode {
+    raw: R.dtBVNode;
+    constructor(raw: R.dtBVNode);
+    bmin(): Vector3;
+    bmax(): Vector3;
+    i(): number;
+}
+export declare class dtOffMeshConnection {
+    raw: R.dtOffMeshConnection;
+    constructor(raw: R.dtOffMeshConnection);
+    pos(index: number): number;
+    rad(): number;
+    poly(): number;
+    flags(): number;
+    side(): number;
+    userId(): number;
+}
+export declare class dtMeshHeader {
+    raw: R.dtMeshHeader;
+    constructor(raw: R.dtMeshHeader);
+    magic(): number;
+    version(): number;
+    x(): number;
+    y(): number;
+    layer(): number;
+    userId(): number;
+    polyCount(): number;
+    vertCount(): number;
+    maxLinkCount(): number;
+    detailMeshCount(): number;
+    detailVertCount(): number;
+    detailTriCount(): number;
+    bvNodeCount(): number;
+    offMeshConCount(): number;
+    offMeshBase(): number;
+    walkableHeight(): number;
+    walkableRadius(): number;
+    walkableClimb(): number;
+    bmin(index: number): number;
+    bmax(index: number): number;
+    bvQuantFactor(): number;
+}
+export declare class dtMeshTile {
+    raw: R.dtMeshTile;
+    constructor(raw: R.dtMeshTile);
+    salt(): number;
+    linksFreeList(): number;
+    header(): dtMeshHeader | null;
+    polys(index: number): dtPoly;
+    verts(index: number): number;
+    links(index: number): dtLink;
+    detailMeshes(index: number): dtPolyDetail;
+    detailVerts(index: number): number;
+    detailTris(index: number): number;
+    bvTree(index: number): dtBVNode;
+    offMeshCons(index: number): dtOffMeshConnection;
+    data(index: number): number;
+    dataSize(): number;
+    flags(): number;
+    next(): dtMeshTile;
+}
+export declare class NavMeshGetTilesAtResult {
+    raw: R.NavMeshGetTilesAtResult;
+    constructor(raw: R.NavMeshGetTilesAtResult);
+    tiles(index: number): dtMeshTile;
+    tileCount(): number;
+}
+export declare class NavMeshAddTileResult {
+    raw: R.NavMeshAddTileResult;
+    constructor(raw: R.NavMeshAddTileResult);
+    tileRef(): number;
+    status(): number;
+}
+export declare class NavMeshRemoveTileResult {
+    raw: R.NavMeshRemoveTileResult;
+    constructor(raw: R.NavMeshRemoveTileResult);
+    data(): number[];
+    dataSize(): number;
+}
+export declare class NavMeshCalcTileLocResult {
+    raw: R.NavMeshCalcTileLocResult;
+    constructor(raw: R.NavMeshCalcTileLocResult);
+    tileX(): number;
+    tileY(): number;
+}
+export declare class NavMeshGetTileAndPolyByRefResult {
+    raw: R.NavMeshGetTileAndPolyByRefResult;
+    constructor(raw: R.NavMeshGetTileAndPolyByRefResult);
+    tile(): dtMeshTile;
+    poly(): dtPoly;
+    status(): number;
+}
+export declare class NavMeshGetOffMeshConnectionPolyEndPointsResult {
+    raw: R.NavMeshGetOffMeshConnectionPolyEndPointsResult;
+    constructor(raw: R.NavMeshGetOffMeshConnectionPolyEndPointsResult);
+    status(): number;
+    startPos(): Vector3;
+    endPos(): Vector3;
+}
+export declare class NavMeshGetPolyFlagsResult {
+    raw: R.NavMeshGetPolyFlagsResult;
+    constructor(raw: R.NavMeshGetPolyFlagsResult);
+    flags(): number;
+    status(): number;
+}
+export declare class NavMeshGetPolyAreaResult {
+    raw: R.NavMeshGetPolyAreaResult;
+    constructor(raw: R.NavMeshGetPolyAreaResult);
+    area(): number;
+    status(): number;
+}
+export declare class NavMeshStoreTileStateResult {
+    raw: R.NavMeshStoreTileStateResult;
+    constructor(raw: R.NavMeshStoreTileStateResult);
+    data(): number[];
+    dataSize(): number;
+}
+export declare class DebugNavMesh {
+    raw: R.DebugNavMesh;
+    positions: number[];
+    indices: number[];
+    constructor(debugNavMesh: R.DebugNavMesh);
+}
 export declare type NavMeshParams = {
-    orig: number[];
+    orig: Vector3;
     tileWidth: number;
     tileHeight: number;
     maxTiles: number;
     maxPolys: number;
 };
-export declare type NavMeshAddTileResult = {
-    status: number;
-    tileRef: number;
-};
 export declare class NavMesh {
     raw: R.NavMesh;
     constructor(raw?: R.NavMesh);
@@ -27,7 +175,7 @@ export declare class NavMesh {
      * @param params parameters for the NavMesh
      * @returns the status of the operation
      */
-    initTiled(params: NavMeshParams): boolean;
+    initTiled({ orig, tileWidth, tileHeight, maxTiles, maxPolys, }: NavMeshParams): boolean;
     /**
      * Adds a tile to the NavMesh.
      * @param data the nav mesh data
@@ -38,11 +186,150 @@ export declare class NavMesh {
      */
     addTile(data: number[], dataSize: number, flags: number, lastRef: number): NavMeshAddTileResult;
     /**
-     * Destroys the NavMesh.
+     * Removes a tile from the NavMesh
+     * @param ref the tile ref
+     * @returns the nav mesh data, so it can be added back later
      */
-    destroy(): void;
+    removeTile(ref: number): NavMeshRemoveTileResult;
+    /**
+     * Calculates the tile grid location for the specified world position.
+     * @param pos The world position for the query. [(x, y, z)]
+     * @returns
+     */
+    calcTileLoc(pos: Vector3): NavMeshCalcTileLocResult;
+    /**
+     * Gets the tile at the specified grid location.
+     * @param x The tile's x-location. (x, y, layer)
+     * @param y The tile's y-location. (x, y, layer)
+     * @param layer The tile's layer. (x, y, layer)
+     * @returns The tile, or null if the tile does not exist.
+     */
+    getTileAt(x: number, y: number, layer: number): dtMeshTile | null;
+    /**
+     * Gets all tiles at the specified grid location. (All layers.)
+     * @param x The tile's x-location. (x, y)
+     * @param y The tile's y-location. (x, y)
+     * @param maxTiles The maximum tiles the tiles parameter can hold.
+     */
+    getTilesAt(x: number, y: number, maxTiles: number): NavMeshGetTilesAtResult;
+    /**
+     * Gets the tile reference for the tile at specified grid location.
+     * @param x The tile's x-location. (x, y, layer)
+     * @param y The tile's y-location. (x, y, layer)
+     * @param layer The tile's layer. (x, y, layer)
+     * @returns The tile reference of the tile, or 0 if there is none.
+     */
+    getTileRefAt(x: number, y: number, layer: number): number;
+    /**
+     * Gets the tile reference for the specified tile.
+     * @param tile
+     * @returns
+     */
+    getTileRef(tile: dtMeshTile): number;
+    /**
+     * Gets the tile for the specified tile reference.
+     * @param ref The tile reference of the tile to retrieve.
+     * @returns The tile for the specified reference, or null if the reference is invalid.
+     */
+    getTileByRef(ref: number): dtMeshTile | null;
+    /**
+     * Returns the maximum number of tiles supported by the navigation mesh.
+     */
+    getMaxTiles(): number;
+    /**
+     * Gets the tile at the specified index.
+     * @param i the tile index. [Limit: 0 >= index < #getMaxTiles()]
+     * @returns
+     */
+    getTile(i: number): dtMeshTile;
+    /**
+     * Gets the tile and polygon for the specified polygon reference.
+     * @param ref The reference for the a polygon.
+     * @returns
+     */
+    getTileAndPolyByRef(ref: number): NavMeshGetTileAndPolyByRefResult;
+    /**
+     * Gets the tile and polygon for the specified polygon reference.
+     * @param ref A known valid reference for a polygon.
+     * @returns
+     */
+    getTileAndPolyByRefUnsafe(ref: number): NavMeshGetTileAndPolyByRefResult;
+    /**
+     * Checks the validity of a polygon reference.
+     * @param ref
+     * @returns
+     */
+    isValidPolyRef(ref: number): boolean;
+    /**
+     * Gets the polygon reference for the tile's base polygon.
+     * @param tile
+     * @returns
+     */
+    getPolyRefBase(tile: dtMeshTile): number;
+    /**
+     * Gets the endpoints for an off-mesh connection, ordered by "direction of travel".
+     * @param prevRef The reference of the polygon before the connection.
+     * @param polyRef The reference of the off-mesh connection polygon.
+     * @returns
+     */
+    getOffMeshConnectionPolyEndPoints(prevRef: number, polyRef: number): NavMeshGetOffMeshConnectionPolyEndPointsResult;
+    /**
+     * Gets the specified off-mesh connection.
+     * @param ref The polygon reference of the off-mesh connection.
+     * @returns
+     */
+    getOffMeshConnectionByRef(ref: number): dtOffMeshConnection;
+    /**
+     * Sets the user defined flags for the specified polygon.
+     * @param ref The polygon reference.
+     * @param flags The new flags for the polygon.
+     */
+    setPolyFlags(ref: number, flags: number): number;
+    /**
+     * Gets the user defined flags for the specified polygon.
+     * @param ref The polygon reference.
+     * @returns
+     */
+    getPolyFlags(ref: number): NavMeshGetPolyFlagsResult;
+    /**
+     * Sets the user defined area for the specified polygon.
+     * @param ref The polygon reference.
+     * @param flags The new flags for the polygon.
+     */
+    setPolyArea(ref: number, area: number): number;
+    /**
+     * Gets the user defined area for the specified polygon.
+     * @param ref The polygon reference.
+     * @returns
+     */
+    getPolyArea(ref: number): NavMeshGetPolyAreaResult;
+    /**
+     * Gets the size of the buffer required by #storeTileState to store the specified tile's state.
+     * @param tile
+     * @returns The size of the buffer required to store the state.
+     */
+    getTileStateSize(tile: dtMeshTile): number;
+    /**
+     * Stores the non-structural state of the tile in the specified buffer. (Flags, area ids, etc.)
+     * @param tile The tile.
+     * @param maxDataSize The size of the data buffer. [Limit: >= #getTileStateSize]
+     * @returns
+     */
+    storeTileState(tile: dtMeshTile, maxDataSize: number): NavMeshStoreTileStateResult;
+    /**
+     * Restores the state of the tile.
+     * @param tile The tile.
+     * @param data The new state. (Obtained from @see storeTileState)
+     * @param maxDataSize The size of the state within the data buffer.
+     * @returns
+     */
+    restoreTileState(tile: dtMeshTile, data: number[], maxDataSize: number): number;
     /**
      * Returns a DebugNavMesh that can be used to visualize the NavMesh.
      */
     getDebugNavMesh(): DebugNavMesh;
+    /**
+     * Destroys the NavMesh.
+     */
+    destroy(): void;
 }

package/dist/utils.d.ts

@@ -11,12 +11,15 @@ export declare const vec3: {
         y: number;
         z: number;
     };
-};
-export declare type NavPath = Vector3[];
-export declare const navPath: {
-    fromRaw: (v: R.NavPath) => {
+    fromArray: ([x, y, z]: number[]) => {
         x: number;
         y: number;
         z: number;
-    }[];
+    };
+    toArray: ({ x, y, z }: Vector3) => number[];
+};
+export declare const array: <T>(getter: (index: number) => T, count: number) => T[];
+export declare const emscripten: {
+    isNull: (obj: unknown) => boolean;
+    getPointer: (obj: unknown) => number;
 };

package/dist/wasm.d.ts

@@ -1,5 +1,6 @@
 import Recast from '@recast-navigation/wasm';
 export declare const Wasm: {
     Recast: typeof Recast;
+    DtStatus: Recast.DtStatus;
 };
 export declare const init: () => Promise<void>;

package/package.json

@@ -6,7 +6,7 @@
     "email": "isaac@isaacmason.com",
     "url": "https://isaacmason.com/"
   },
-  "version": "0.0.7",
+  "version": "0.1.1",
   "license": "MIT",
   "homepage": "https://github.com/isaac-mason/recast-navigation-js",
   "bugs": {
@@ -26,7 +26,7 @@
   },
   "devDependencies": {
     "@babel/core": "^7.18.6",
-    "@recast-navigation/wasm": "0.0.7",
+    "@recast-navigation/wasm": "0.1.1",
     "@rollup/plugin-commonjs": "^24.0.1",
     "@rollup/plugin-node-resolve": "^15.0.1",
     "@rollup/plugin-terser": "^0.4.0",

package/dist/debug-nav-mesh.d.ts

@@ -1,7 +0,0 @@
-import R from '@recast-navigation/wasm';
-export declare class DebugNavMesh {
-    raw: R.DebugNavMesh;
-    positions: number[];
-    indices: number[];
-    constructor(debugNavMesh: R.DebugNavMesh);
-}