@recast-navigation/core 0.2.0 → 0.4.0

package/dist/crowd.d.ts

@@ -1,5 +1,6 @@
 import type R from '@recast-navigation/wasm';
 import type { NavMesh } from './nav-mesh';
+import { NavMeshQuery } from './nav-mesh-query';
 import { Vector3 } from './utils';
 export type CrowdParams = {
     /**
@@ -79,7 +80,7 @@ export type CrowdAgentParams = {
     userData: unknown;
 };
 export declare class Crowd {
-    raw: R.Crowd;
+    raw: R.dtCrowd;
     /**
      * The indices of the active agents in the crowd.
      */
@@ -102,7 +103,10 @@ export declare class Crowd {
      * Time factor applied when updating crowd agents (default 1). A value of 0 will pause crowd updates.
      */
     timeFactor: number;
-    private tmpVec1;
+    /**
+     * The NavMeshQuery used to find nearest polys for commands
+     */
+    navMeshQuery: NavMeshQuery;
     constructor({ maxAgents, maxAgentRadius, navMesh }: CrowdParams);
     /**
      * Adds a new agent to the crowd.
@@ -115,7 +119,7 @@ export declare class Crowd {
     /**
      * Submits a new move request for the specified agent.
      */
-    goto(agentIndex: number, position: Vector3): void;
+    goto(agentIndex: number, position: Vector3): boolean;
     /**
      * Teleports the agent to the given position.
      */
@@ -182,15 +186,5 @@ export declare class Crowd {
      * @param crowdAgentParams
      */
     updateAgentParameters(agentIndex: number, crowdAgentParams: Partial<CrowdAgentParams>): void;
-    /**
-     * Gets the bounding box extent for doing spatial queries.
-     */
-    getDefaultQueryExtent(): Vector3;
-    /**
-     * Sets the Bounding box extent for doing spatial queries (getClosestPoint, getRandomPointAround, ...)
-     * The queries will try to find a solution within those bounds.
-     * The default is (1,1,1)
-     */
-    setDefaultQueryExtent(extent: Vector3): void;
     destroy(): void;
 }

package/dist/detour.d.ts

@@ -0,0 +1,92 @@
+import type R from '@recast-navigation/wasm';
+import { Vector3 } from './utils';
+export declare class DetourPolyDetail {
+    raw: R.dtPolyDetail;
+    constructor(raw: R.dtPolyDetail);
+    vertBase(): number;
+    triBase(): number;
+    vertCount(): number;
+    triCount(): number;
+}
+export declare class DetourLink {
+    raw: R.dtLink;
+    constructor(raw: R.dtLink);
+    ref(): number;
+    next(): number;
+    edge(): number;
+    side(): number;
+    bmin(): number;
+    bmax(): number;
+}
+export declare class DetourBVNode {
+    raw: R.dtBVNode;
+    constructor(raw: R.dtBVNode);
+    bmin(): Vector3;
+    bmax(): Vector3;
+    i(): number;
+}
+export declare class DetourOffMeshConnection {
+    raw: R.dtOffMeshConnection;
+    constructor(raw: R.dtOffMeshConnection);
+    pos(index: number): number;
+    rad(): number;
+    poly(): number;
+    flags(): number;
+    side(): number;
+    userId(): number;
+}
+export declare class DetourMeshHeader {
+    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 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 DetourMeshTile {
+    raw: R.dtMeshTile;
+    constructor(raw: R.dtMeshTile);
+    salt(): number;
+    linksFreeList(): number;
+    header(): DetourMeshHeader | null;
+    polys(index: number): dtPoly;
+    verts(index: number): number;
+    links(index: number): DetourLink;
+    detailMeshes(index: number): DetourPolyDetail;
+    detailVerts(index: number): number;
+    detailTris(index: number): number;
+    bvTree(index: number): DetourBVNode;
+    offMeshCons(index: number): DetourOffMeshConnection;
+    data(index: number): number;
+    dataSize(): number;
+    flags(): number;
+    next(): DetourMeshTile;
+}

package/dist/generators/common.d.ts

@@ -0,0 +1,8 @@
+export declare const getVertsAndTris: (positions: ArrayLike<number>, indices: ArrayLike<number>) => {
+    verts: number[];
+    nVerts: number;
+    tris: number[];
+    nTris: number;
+    bbMin: import("three").Vector3Tuple;
+    bbMax: import("three").Vector3Tuple;
+};

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

@@ -0,0 +1,30 @@
+import { NavMesh } from '../nav-mesh';
+import { RecastConfigType, RecastCompactHeightfield, RecastContourSet, RecastHeightfield } from '../recast';
+export type SoloNavMeshGeneratorConfig = Omit<RecastConfigType, 'tileSize'>;
+export declare const soloNavMeshGeneratorConfigDefaults: SoloNavMeshGeneratorConfig;
+export type SoloNavMeshGeneratorIntermediates = {
+    heightfield?: RecastHeightfield;
+    compactHeightfield?: RecastCompactHeightfield;
+    contourSet?: RecastContourSet;
+};
+type SoloNavMeshGeneratorSuccessResult = {
+    navMesh: NavMesh;
+    success: true;
+    intermediates?: SoloNavMeshGeneratorIntermediates;
+};
+type SoloNavMeshGeneratorFailResult = {
+    navMesh: undefined;
+    success: false;
+    intermediates?: SoloNavMeshGeneratorIntermediates;
+    error: string;
+};
+export type SoloNavMeshGeneratorResult = SoloNavMeshGeneratorSuccessResult | SoloNavMeshGeneratorFailResult;
+/**
+ * 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) => SoloNavMeshGeneratorResult;
+export {};

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

@@ -0,0 +1,48 @@
+import type R from '@recast-navigation/wasm';
+import { NavMesh } from '../nav-mesh';
+import { TileCache } from '../tile-cache';
+import { RecastConfigType, RecastCompactHeightfield, RecastHeightfield, RecastHeightfieldLayerSet } from '../recast';
+export type TiledNavMeshGeneratorConfig = RecastConfigType & {
+    /**
+     * How many layers (or "floors") each navmesh tile is expected to have.
+     */
+    expectedLayersPerTile: number;
+    /**
+     * The max number of obstacles
+     */
+    maxObstacles: number;
+};
+export declare const tiledNavMeshGeneratorConfigDefaults: TiledNavMeshGeneratorConfig;
+export type TiledNavMeshGeneratorIntermediates = {
+    chunkyTriMesh?: R.rcChunkyTriMesh;
+    tileIntermediates: {
+        tx: number;
+        ty: number;
+        heightfield: RecastHeightfield;
+        heightfieldLayerSet: RecastHeightfieldLayerSet;
+        compactHeightfield: RecastCompactHeightfield;
+    }[];
+};
+type TiledNavMeshGeneratorSuccessResult = {
+    tileCache: TileCache;
+    navMesh: NavMesh;
+    success: true;
+    intermediates?: TiledNavMeshGeneratorIntermediates;
+};
+type TiledNavMeshGeneratorFailResult = {
+    tileCache: undefined;
+    navMesh: undefined;
+    success: false;
+    error: string;
+    intermediates?: TiledNavMeshGeneratorIntermediates;
+};
+export type TiledNavMeshGeneratorResult = TiledNavMeshGeneratorSuccessResult | TiledNavMeshGeneratorFailResult;
+/**
+ * Builds a Tiled NavMesh from the given positions and indices.
+ * @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 generateTiledNavMesh: (positions: ArrayLike<number>, indices: ArrayLike<number>, navMeshGeneratorConfig?: Partial<TiledNavMeshGeneratorConfig>, keepIntermediates?: boolean) => TiledNavMeshGeneratorResult;
+export {};

package/dist/generators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './generate-solo-nav-mesh';
+export * from './generate-tiled-nav-mesh';

package/dist/index.d.ts

@@ -1,13 +1,10 @@
 export * from './crowd';
-export * from './dt-status';
+export * from './detour';
+export * from './generators';
 export * from './nav-mesh';
-export * from './nav-mesh-builder';
-export * from './nav-mesh-exporter';
-export * from './nav-mesh-generator';
-export * from './nav-mesh-importer';
 export * from './nav-mesh-query';
-export * from './obstacle';
-export * from './wrappers';
+export * from './raw';
+export * from './recast';
+export * from './serdes';
 export * from './tile-cache';
 export * from './utils';
-export * from './wasm';