@recast-navigation/core 0.5.0 → 0.7.0

package/dist/crowd.d.ts

@@ -79,112 +79,133 @@ export type CrowdAgentParams = {
      */
     userData: unknown;
 };
-export declare class Crowd {
-    raw: R.dtCrowd;
+export declare const crowdAgentParamsDefaults: CrowdAgentParams;
+export declare class CrowdAgent {
+    crowd: Crowd;
+    agentIndex: number;
+    raw: R.dtCrowdAgent;
+    constructor(crowd: Crowd, agentIndex: number);
     /**
-     * The indices of the active agents in the crowd.
+     * Updates the agent's target.
+     * @param position The new target position.
+     * @returns True if the request was successful.
      */
-    agents: number[];
+    goto(position: Vector3): boolean;
     /**
-     * The NavMesh the crowd is interacting with.
+     * Resets the current move request for the specified agent.
      */
-    navMesh: NavMesh;
+    resetMoveTarget(): void;
     /**
-     * If delta time in navigation tick update is greater than the time step a number of sub iterations are done.
-     * If more iterations are need to reach deltatime they will be discarded.
-     * A value of 0 will set to no maximum and update will use as many substeps as needed.
+     * Teleports the agent to the specified position.
+     * @param position
      */
-    maximumSubStepCount: number;
+    teleport(position: Vector3): void;
     /**
-     * Get the time step of the navigation tick update.
+     * The position of the agent.
+     * @returns
      */
-    timeStep: number;
+    position(): Vector3;
     /**
-     * Time factor applied when updating crowd agents (default 1). A value of 0 will pause crowd updates.
+     * The velocity of the agent.
+     * @returns
      */
-    timeFactor: number;
+    velocity(): Vector3;
     /**
-     * The NavMeshQuery used to find nearest polys for commands
+     * Returns the next target position on the path to the target
+     * @returns
      */
-    navMeshQuery: NavMeshQuery;
-    constructor({ maxAgents, maxAgentRadius, navMesh }: CrowdParams);
+    nextTargetPath(): Vector3;
     /**
-     * Adds a new agent to the crowd.
+     * Returns the state of the agent.
+     *
+     * 0 = DT_CROWDAGENT_STATE_INVALID
+     * 1 = DT_CROWDAGENT_STATE_WALKING
+     * 2 = DT_CROWDAGENT_STATE_OFFMESH
      */
-    addAgent(position: Vector3, crowdAgentParams: Partial<CrowdAgentParams>): number;
+    state(): number;
     /**
-     * Removes the agent from the crowd.
+     * Returns the local path corridor corners for the agent
+     * @returns
      */
-    removeAgent(agentIndex: number): void;
+    corners(): Vector3[];
     /**
-     * Submits a new move request for the specified agent.
+     * Returns the agents parameters.
+     * @returns
      */
-    goto(agentIndex: number, position: Vector3): boolean;
+    parameters(): CrowdAgentParams;
     /**
-     * Teleports the agent to the given position.
+     * Updates the agent's parameters.
+     * Any parameters not specified in the crowdAgentParams object will be unchanged.
+     * @param crowdAgentParams agent parameters to update.
      */
-    teleport(agentIndex: number, position: Vector3): void;
+    updateParameters(crowdAgentParams: Partial<CrowdAgentParams>): void;
     /**
-     * Resets the current move request for the specified agent.
+     * Sets the agent's parameters.
+     * Any parameters not specified in the crowdAgentParams object will be set to their default values.
+     * @param crowdAgentParams agent parameters
      */
-    resetMoveTarget(agentIndex: number): void;
+    setParameters(crowdAgentParams: CrowdAgentParams): void;
+}
+export declare class Crowd {
+    raw: R.dtCrowd;
     /**
-     * Updates the crowd
+     * The agents in the crowd.
      */
-    update(deltaTime: number): void;
+    agents: {
+        [idx: string]: CrowdAgent;
+    };
     /**
-     * Returns the maximum number of agents that can be managed by the crowd.
+     * The NavMesh the crowd is interacting with.
      */
-    getAgentCount(): number;
+    navMesh: NavMesh;
     /**
-     * Returns the number of active agents in the crowd.
+     * If delta time in navigation tick update is greater than the time step a number of sub iterations are done.
+     * If more iterations are need to reach deltatime they will be discarded.
+     * A value of 0 will set to no maximum and update will use as many substeps as needed.
      */
-    getActiveAgentCount(): number;
+    maximumSubStepCount: number;
     /**
-     * Returns the indices of all active agents.
+     * Get the time step of the navigation tick update.
      */
-    getAgents(): number[];
+    timeStep: number;
     /**
-     * Returns the position of the specified agent.
+     * Time factor applied when updating crowd agents (default 1). A value of 0 will pause crowd updates.
      */
-    getAgentPosition(agentIndex: number): Vector3;
+    timeFactor: number;
     /**
-     * Returns the velocity of the specified agent.
+     * The NavMeshQuery used to find nearest polys for commands
      */
-    getAgentVelocity(agentIndex: number): Vector3;
+    navMeshQuery: NavMeshQuery;
+    constructor({ maxAgents, maxAgentRadius, navMesh }: CrowdParams);
     /**
-     * Returns the next target position on the path to the specified agents target.
+     * Updates the crowd
      */
-    getAgentNextTargetPath(agentIndex: number): Vector3;
+    update(deltaTime: number): void;
     /**
-     * Returns the state of the specified agent.
-     *
-     * 0 = DT_CROWDAGENT_STATE_INVALID
-     * 1 = DT_CROWDAGENT_STATE_WALKING
-     * 2 = DT_CROWDAGENT_STATE_OFFMESH
+     * Adds a new agent to the crowd.
      */
-    getAgentState(agentIndex: number): number;
+    addAgent(position: Vector3, crowdAgentParams: Partial<CrowdAgentParams>): CrowdAgent;
     /**
-     * Returns the local path corridor corners for the specified agent.
+     * Gets the agent with the specified index, or null if no agent has the given index.
+     * @param agentIndex
+     * @returns
      */
-    getAgentCorners(agentIndex: number): Vector3[];
+    getAgent(agentIndex: number): CrowdAgent | null;
     /**
-     * Returns the parameters for the specified agent.
+     * Removes the agent from the crowd.
      */
-    getAgentParameters(agentIndex: number): CrowdAgentParams;
+    removeAgent(agent: number | CrowdAgent): void;
     /**
-     * Sets the parameters for the specified agent.
-     * Any parameters not specified in the crowdAgentParams object will be set to their default values.
-     * @param agentIndex
-     * @param crowdAgentParams
+     * Returns the maximum number of agents that can be managed by the crowd.
      */
-    setAgentParameters(agentIndex: number, crowdAgentParams: Partial<CrowdAgentParams>): void;
+    getAgentCount(): number;
     /**
-     * Updates the parameters for the specified agent.
-     * Any parameters not specified in the crowdAgentParams object will be unchanged.
-     * @param agentIndex
-     * @param crowdAgentParams
+     * Returns the number of active agents in the crowd.
+     */
+    getActiveAgentCount(): number;
+    /**
+     * Returns all the agents managed by the crowd.
      */
-    updateAgentParameters(agentIndex: number, crowdAgentParams: Partial<CrowdAgentParams>): void;
+    getAgents(): CrowdAgent[];
     destroy(): void;
 }

package/dist/detour.d.ts

@@ -1,5 +1,6 @@
 import type R from './raw-module';
-import { Vector3 } from './utils';
+import { RecastPolyMesh, RecastPolyMeshDetail } from './recast';
+import { Vector3, Vector3Tuple } from './utils';
 export declare class DetourPolyDetail {
     raw: R.dtPolyDetail;
     constructor(raw: R.dtPolyDetail);
@@ -60,7 +61,7 @@ export declare class DetourMeshHeader {
     bmax(index: number): number;
     bvQuantFactor(): number;
 }
-export declare class dtPoly {
+export declare class DetourPoly {
     raw: R.dtPoly;
     constructor(raw: R.dtPoly);
     firstLink(): number;
@@ -77,7 +78,7 @@ export declare class DetourMeshTile {
     salt(): number;
     linksFreeList(): number;
     header(): DetourMeshHeader | null;
-    polys(index: number): dtPoly;
+    polys(index: number): DetourPoly;
     verts(index: number): number;
     links(index: number): DetourLink;
     detailMeshes(index: number): DetourPolyDetail;
@@ -90,3 +91,68 @@ export declare class DetourMeshTile {
     flags(): number;
     next(): DetourMeshTile;
 }
+export declare const createNavMeshData: (navMeshCreateParams: NavMeshCreateParams) => R.CreateNavMeshDataResult;
+export declare class NavMeshCreateParams {
+    raw: R.dtNavMeshCreateParams;
+    constructor(raw?: R.dtNavMeshCreateParams);
+    setPolyMeshCreateParams(polyMesh: RecastPolyMesh): void;
+    setPolyMeshDetailCreateParams(polyMeshDetail: RecastPolyMeshDetail): void;
+    setOffMeshConCount(offMeshConCount: number): void;
+    verts(index: number): number;
+    setVerts(index: number, value: number): void;
+    vertCount(): number;
+    polys(index: number): number;
+    setPolys(index: number, value: number): void;
+    polyAreas(index: number): number;
+    setPolyAreas(index: number, value: number): void;
+    polyFlags(index: number): number;
+    setPolyFlags(index: number, value: number): void;
+    polyCount(): number;
+    nvp(): number;
+    setNvp(value: number): void;
+    detailMeshes(index: number): number;
+    setDetailMeshes(index: number, value: number): void;
+    detailVerts(index: number): number;
+    setDetailVerts(index: number, value: number): void;
+    detailVertsCount(): number;
+    detailTris(index: number): number;
+    setDetailTris(index: number, value: number): void;
+    detailTriCount(): number;
+    offMeshConVerts(index: number): number;
+    setOffMeshConVerts(index: number, value: number): void;
+    offMeshConRad(index: number): number;
+    setOffMeshConRad(index: number, value: number): void;
+    offMeshConDir(index: number): number;
+    setOffMeshConDir(index: number, value: number): void;
+    offMeshConAreas(index: number): number;
+    setOffMeshConAreas(index: number, value: number): void;
+    offMeshConFlags(index: number): number;
+    setOffMeshConFlags(index: number, value: number): void;
+    offMeshConUserID(index: number): number;
+    setOffMeshConUserID(index: number, value: number): void;
+    offMeshConCount(): number;
+    userId(): number;
+    setUserId(value: number): void;
+    tileX(): number;
+    setTileX(value: number): void;
+    tileY(): number;
+    setTileY(value: number): void;
+    tileLayer(): number;
+    setTileLayer(value: number): void;
+    boundsMin(): Vector3Tuple;
+    setBoundsMin(value: Vector3Tuple): void;
+    boundsMax(): Vector3Tuple;
+    setBoundsMax(value: Vector3Tuple): void;
+    walkableHeight(): number;
+    setWalkableHeight(value: number): void;
+    walkableRadius(): number;
+    setWalkableRadius(value: number): void;
+    walkableClimb(): number;
+    setWalkableClimb(value: number): void;
+    cellSize(): number;
+    setCellSize(value: number): void;
+    cellHeight(): number;
+    setCellHeight(value: number): void;
+    buildBvTree(): boolean;
+    setBuildBvTree(value: boolean): void;
+}

package/dist/generators/common.d.ts

@@ -1,8 +1,6 @@
-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;
+export declare const getBoundingBox: (positions: ArrayLike<number>, indices: ArrayLike<number>) => {
+    bbMin: import("../utils").Vector3Tuple;
+    bbMax: import("../utils").Vector3Tuple;
 };
+export declare const dtIlog2: (v: number) => number;
+export declare const dtNextPow2: (v: number) => number;

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

@@ -1,9 +1,10 @@
 import { NavMesh } from '../nav-mesh';
-import { RecastConfigType, RecastCompactHeightfield, RecastContourSet, RecastHeightfield } from '../recast';
+import { RecastConfigType, RecastCompactHeightfield, RecastContourSet, RecastHeightfield, RecastBuildContext } from '../recast';
 export type SoloNavMeshGeneratorConfig = Omit<RecastConfigType, 'tileSize'>;
 export declare const soloNavMeshGeneratorConfigDefaults: SoloNavMeshGeneratorConfig;
 export type SoloNavMeshGeneratorIntermediates = {
     type: 'solo';
+    buildContext: RecastBuildContext;
     heightfield?: RecastHeightfield;
     compactHeightfield?: RecastCompactHeightfield;
     contourSet?: RecastContourSet;

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

@@ -0,0 +1,50 @@
+import { NavMesh } from '../nav-mesh';
+import { RecastBuildContext, RecastChunkyTriMesh, RecastCompactHeightfield, RecastConfigType, RecastHeightfield, RecastHeightfieldLayerSet } from '../recast';
+import { TileCache } from '../tile-cache';
+export type TileCacheGeneratorConfig = 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 tileCacheGeneratorConfigDefaults: TileCacheGeneratorConfig;
+export type TileCacheGeneratorIntermediates = {
+    type: 'tilecache';
+    buildContext: RecastBuildContext;
+    chunkyTriMesh?: RecastChunkyTriMesh;
+    tileIntermediates: {
+        tileX: number;
+        tileY: number;
+        heightfield: RecastHeightfield;
+        heightfieldLayerSet: RecastHeightfieldLayerSet;
+        compactHeightfield: RecastCompactHeightfield;
+    }[];
+};
+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;
+/**
+ * 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

@@ -1,48 +1,37 @@
 import { NavMesh } from '../nav-mesh';
-import type R from '../raw-module';
-import { RecastCompactHeightfield, RecastConfigType, RecastHeightfield, RecastHeightfieldLayerSet } from '../recast';
-import { TileCache } from '../tile-cache';
-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;
-};
+import { RecastBuildContext, RecastChunkyTriMesh, RecastCompactHeightfield, RecastConfigType, RecastContourSet, RecastHeightfield } from '../recast';
+import { Pretty } from '../types';
+export type TiledNavMeshGeneratorConfig = Pretty<RecastConfigType>;
 export declare const tiledNavMeshGeneratorConfigDefaults: TiledNavMeshGeneratorConfig;
 export type TiledNavMeshGeneratorIntermediates = {
     type: 'tiled';
-    chunkyTriMesh?: R.rcChunkyTriMesh;
+    buildContext: RecastBuildContext;
+    chunkyTriMesh?: RecastChunkyTriMesh;
     tileIntermediates: {
-        tx: number;
-        ty: number;
-        heightfield: RecastHeightfield;
-        heightfieldLayerSet: RecastHeightfieldLayerSet;
-        compactHeightfield: RecastCompactHeightfield;
+        tileX: number;
+        tileY: number;
+        heightfield?: RecastHeightfield;
+        compactHeightfield?: RecastCompactHeightfield;
+        contourSet?: RecastContourSet;
     }[];
 };
 type TiledNavMeshGeneratorSuccessResult = {
-    tileCache: TileCache;
     navMesh: NavMesh;
     success: true;
     intermediates?: TiledNavMeshGeneratorIntermediates;
 };
 type TiledNavMeshGeneratorFailResult = {
-    tileCache: undefined;
     navMesh: undefined;
     success: false;
-    error: string;
     intermediates?: TiledNavMeshGeneratorIntermediates;
+    error: string;
 };
 export type TiledNavMeshGeneratorResult = TiledNavMeshGeneratorSuccessResult | TiledNavMeshGeneratorFailResult;
 /**
- * Builds a Tiled NavMesh from the given positions and indices.
+ * Builds a Tiled NavMesh
  * @param positions a flat array of positions
  * @param indices a flat array of indices
- * @param navMeshConfig optional configuration for the NavMesh
+ * @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) => TiledNavMeshGeneratorResult;

package/dist/generators/index.d.ts

@@ -1,2 +1,4 @@
+export * from './common';
 export * from './generate-solo-nav-mesh';
+export * from './generate-tile-cache';
 export * from './generate-tiled-nav-mesh';