@recast-navigation/core 0.27.0 → 0.29.0

package/dist/arrays.d.ts

@@ -1,4 +1,4 @@
-import RawModule from './raw-module';
+import { RawModule } from './raw';
 type TypedArray = typeof Int32Array | typeof Uint32Array | typeof Uint8Array | typeof Uint16Array | typeof Float32Array;
 declare abstract class BaseArray<RawType extends RawModule.IntArray | RawModule.UnsignedIntArray | RawModule.UnsignedCharArray | RawModule.UnsignedShortArray | RawModule.FloatArray, T extends TypedArray> {
     raw: RawType;
@@ -9,40 +9,75 @@ declare abstract class BaseArray<RawType extends RawModule.IntArray | RawModule.
     set(i: number, value: number): void;
     resize(size: number): void;
     copy(data: InstanceType<T> | number[]): void;
-    free(): void;
+    destroy(): void;
     getHeapView(): InstanceType<T>;
     toTypedArray(): InstanceType<T>;
     protected abstract getHeap(): InstanceType<T>;
 }
 export declare class IntArray extends BaseArray<RawModule.IntArray, typeof Int32Array> {
     typedArrayClass: Int32ArrayConstructor;
-    constructor(raw?: RawModule.IntArray);
+    /**
+     * Creates a new IntArray.
+     */
+    constructor();
+    /**
+     * Creates a wrapper around an existing raw IntArray object.
+     */
+    constructor(raw: RawModule.IntArray);
     protected getHeap(): Int32Array;
-    static fromRaw(raw?: RawModule.IntArray): IntArray;
+    static fromRaw(raw: RawModule.IntArray): IntArray;
 }
 export declare class UnsignedIntArray extends BaseArray<RawModule.UnsignedIntArray, typeof Uint32Array> {
     typedArrayClass: Uint32ArrayConstructor;
-    constructor(raw?: RawModule.UnsignedIntArray);
+    /**
+     * Creates a new UnsignedIntArray.
+     */
+    constructor();
+    /**
+     * Creates a wrapper around an existing raw UnsignedIntArray object.
+     */
+    constructor(raw: RawModule.UnsignedIntArray);
     protected getHeap(): Uint32Array;
-    static fromRaw(raw?: RawModule.UnsignedIntArray): UnsignedIntArray;
+    static fromRaw(raw: RawModule.UnsignedIntArray): UnsignedIntArray;
 }
 export declare class UnsignedCharArray extends BaseArray<RawModule.UnsignedCharArray, typeof Uint8Array> {
     typedArrayClass: Uint8ArrayConstructor;
-    constructor(raw?: RawModule.UnsignedCharArray);
+    /**
+     * Creates a new UnsignedCharArray.
+     */
+    constructor();
+    /**
+     * Creates a wrapper around an existing raw UnsignedCharArray object.
+     */
+    constructor(raw: RawModule.UnsignedCharArray);
     protected getHeap(): Uint8Array;
-    static fromRaw(raw?: RawModule.UnsignedCharArray): UnsignedCharArray;
+    static fromRaw(raw: RawModule.UnsignedCharArray): UnsignedCharArray;
 }
 export declare class UnsignedShortArray extends BaseArray<RawModule.UnsignedShortArray, typeof Uint16Array> {
     typedArrayClass: Uint16ArrayConstructor;
-    constructor(raw?: RawModule.UnsignedShortArray);
+    /**
+     * Creates a new UnsignedShortArray.
+     */
+    constructor();
+    /**
+     * Creates a wrapper around an existing raw UnsignedShortArray object.
+     */
+    constructor(raw: RawModule.UnsignedShortArray);
     protected getHeap(): Uint16Array;
-    static fromRaw(raw?: RawModule.UnsignedShortArray): UnsignedShortArray;
+    static fromRaw(raw: RawModule.UnsignedShortArray): UnsignedShortArray;
 }
 export declare class FloatArray extends BaseArray<RawModule.FloatArray, typeof Float32Array> {
     typedArrayClass: Float32ArrayConstructor;
-    constructor(raw?: RawModule.FloatArray);
+    /**
+     * Creates a new FloatArray.
+     */
+    constructor();
+    /**
+     * Creates a wrapper around an existing raw FloatArray object.
+     */
+    constructor(raw: RawModule.FloatArray);
     protected getHeap(): Float32Array;
-    static fromRaw(raw?: RawModule.FloatArray): FloatArray;
+    static fromRaw(raw: RawModule.FloatArray): FloatArray;
 }
 export declare const VerticesArray: typeof FloatArray;
 export declare const TrianglesArray: typeof IntArray;

package/dist/crowd.d.ts

@@ -1,6 +1,6 @@
 import type { NavMesh } from './nav-mesh';
 import { NavMeshQuery, QueryFilter } from './nav-mesh-query';
-import type R from './raw-module';
+import { RawModule } from './raw';
 import { Vector3 } from './utils';
 export type CrowdAgentParams = {
     /**
@@ -67,7 +67,7 @@ export declare const crowdAgentParamsDefaults: CrowdAgentParams;
 export declare class CrowdAgent implements CrowdAgentParams {
     crowd: Crowd;
     agentIndex: number;
-    raw: R.dtCrowdAgent;
+    raw: RawModule.dtCrowdAgent;
     get radius(): number;
     set radius(value: number);
     get height(): number;
@@ -90,6 +90,13 @@ export declare class CrowdAgent implements CrowdAgentParams {
     set queryFilterType(value: number);
     get userData(): unknown;
     set userData(value: unknown);
+    /**
+     * The interpolated position of the agent.
+     *
+     * Use this if stepping the crowd with interpolation.
+     * This will not be updated if stepping the crowd without interpolation.
+     */
+    interpolatedPosition: Vector3;
     constructor(crowd: Crowd, agentIndex: number);
     /**
      * Updates the agent's target.
@@ -118,10 +125,17 @@ export declare class CrowdAgent implements CrowdAgentParams {
      */
     position(): Vector3;
     /**
-     * The velocity of the agent.
-     * @returns
+     * The actual velocity of the agent. The change from velocityDesiredObstacleAdjusted -> velocity is constrained by max acceleration.
      */
     velocity(): Vector3;
+    /**
+     * The desired velocity of the agent. Based on the current path, calculated from scratch each frame.
+     */
+    desiredVelocity(): Vector3;
+    /**
+     * The desired velocity adjusted by obstacle avoidance, calculated from scratch each frame.
+     */
+    desiredVelocityObstacleAdjusted(): Vector3;
     /**
      * Returns the next target position on the path to the target
      * @returns
@@ -169,13 +183,9 @@ export type CrowdParams = {
      * [Limit: > 0]
      */
     maxAgentRadius: number;
-    /**
-     * The navigation mesh to use for planning.
-     */
-    navMesh: NavMesh;
 };
 export declare class Crowd {
-    raw: R.dtCrowd;
+    raw: RawModule.dtCrowd;
     /**
      * The agents in the crowd.
      */
@@ -187,28 +197,57 @@ export declare class Crowd {
      */
     navMesh: NavMesh;
     /**
-     * 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.
-     */
-    maximumSubStepCount: number;
-    /**
-     * Get the time step of the navigation tick update.
+     * The NavMeshQuery used to find nearest polys for commands
      */
-    timeStep: number;
+    navMeshQuery: NavMeshQuery;
     /**
-     * Time factor applied when updating crowd agents (default 1). A value of 0 will pause crowd updates.
+     * Accumulator for fixed updates with interpolation
      */
-    timeFactor: number;
+    private accumulator;
     /**
-     * The NavMeshQuery used to find nearest polys for commands
+     *
+     * @param navMesh the navmesh the crowd will use for planning
+     * @param param1 the crowd parameters
+     *
+     * @example
+     * ```ts
+     * const crowd = new Crowd(navMesh, {
+     *   maxAgents: 100,
+     *   maxAgentRadius: 1,
+     * });
+     * ```
      */
-    navMeshQuery: NavMeshQuery;
-    constructor({ maxAgents, maxAgentRadius, navMesh }: CrowdParams);
+    constructor(navMesh: NavMesh, { maxAgents, maxAgentRadius }: CrowdParams);
     /**
-     * Updates the crowd
+     * Steps the crowd forward in time with a fixed time step.
+     *
+     * There are two modes. The simple mode is fixed timestepping without interpolation. In this case you only use the first argument. The second case uses interpolation. In that you also provide the time since the function was last used, as well as the maximum fixed timesteps to take.
+     *
+     * @param dt The fixed time step size to use.
+     * @param timeSinceLastCalled The time elapsed since the function was last called.
+     * @param maxSubSteps Maximum number of fixed steps to take per function call.
+     *
+     * @example fixed time stepping
+     * ```ts
+     * const deltaTime = 1 / 60;
+     * crowd.update(deltaTime);
+     * ```
+     *
+     * @example variable time stepping
+     * ```ts
+     * crowd.update(timeSinceLastUpdate);
+     * ```
+     *
+     * @example fixed time stepping with interpolation
+     * ```ts
+     * const deltaTime = 1 / 60;
+     * const maxSubSteps = 10;
+     * crowd.update(deltaTime, timeSinceLastUpdate, maxSubSteps);
+     *
+     * console.log(agent.interpolatedPosition);
+     * ```
      */
-    update(deltaTime: number): void;
+    update(dt: number, timeSinceLastCalled?: number, maxSubSteps?: number): void;
     /**
      * Adds a new agent to the crowd.
      */

package/dist/detour.d.ts

@@ -1,5 +1,5 @@
 import { UnsignedCharArray } from './arrays';
-import type R from './raw-module';
+import { type RawModule } from './raw';
 import { RecastPolyMesh, RecastPolyMeshDetail } from './recast';
 import { Vector3, Vector3Tuple } from './utils';
 export declare const statusSucceed: (status: number) => boolean;
@@ -8,16 +8,16 @@ export declare const statusInProgress: (status: number) => boolean;
 export declare const statusDetail: (status: number, detail: number) => boolean;
 export declare const statusToReadableString: (status: number) => string;
 export declare class DetourPolyDetail {
-    raw: R.dtPolyDetail;
-    constructor(raw: R.dtPolyDetail);
+    raw: RawModule.dtPolyDetail;
+    constructor(raw: RawModule.dtPolyDetail);
     vertBase(): number;
     triBase(): number;
     vertCount(): number;
     triCount(): number;
 }
 export declare class DetourLink {
-    raw: R.dtLink;
-    constructor(raw: R.dtLink);
+    raw: RawModule.dtLink;
+    constructor(raw: RawModule.dtLink);
     ref(): number;
     next(): number;
     edge(): number;
@@ -26,15 +26,15 @@ export declare class DetourLink {
     bmax(): number;
 }
 export declare class DetourBVNode {
-    raw: R.dtBVNode;
-    constructor(raw: R.dtBVNode);
+    raw: RawModule.dtBVNode;
+    constructor(raw: RawModule.dtBVNode);
     bmin(): Vector3;
     bmax(): Vector3;
     i(): number;
 }
 export declare class DetourOffMeshConnection {
-    raw: R.dtOffMeshConnection;
-    constructor(raw: R.dtOffMeshConnection);
+    raw: RawModule.dtOffMeshConnection;
+    constructor(raw: RawModule.dtOffMeshConnection);
     pos(index: number): number;
     rad(): number;
     poly(): number;
@@ -43,8 +43,8 @@ export declare class DetourOffMeshConnection {
     userId(): number;
 }
 export declare class DetourMeshHeader {
-    raw: R.dtMeshHeader;
-    constructor(raw: R.dtMeshHeader);
+    raw: RawModule.dtMeshHeader;
+    constructor(raw: RawModule.dtMeshHeader);
     magic(): number;
     version(): number;
     x(): number;
@@ -68,8 +68,8 @@ export declare class DetourMeshHeader {
     bvQuantFactor(): number;
 }
 export declare class DetourPoly {
-    raw: R.dtPoly;
-    constructor(raw: R.dtPoly);
+    raw: RawModule.dtPoly;
+    constructor(raw: RawModule.dtPoly);
     firstLink(): number;
     verts(index: number): number;
     neis(index: number): number;
@@ -79,8 +79,8 @@ export declare class DetourPoly {
     getType(): number;
 }
 export declare class DetourMeshTile {
-    raw: R.dtMeshTile;
-    constructor(raw: R.dtMeshTile);
+    raw: RawModule.dtMeshTile;
+    constructor(raw: RawModule.dtMeshTile);
     salt(): number;
     linksFreeList(): number;
     header(): DetourMeshHeader | null;
@@ -117,8 +117,15 @@ export type OffMeshConnectionParams = {
     userId?: number;
 };
 export declare class NavMeshCreateParams {
-    raw: R.dtNavMeshCreateParams;
-    constructor(raw?: R.dtNavMeshCreateParams);
+    raw: RawModule.dtNavMeshCreateParams;
+    /**
+     * Creates a new NavMeshCreateParams object.
+     */
+    constructor();
+    /**
+     * Creates a wrapper around an existing raw NavMeshCreateParams object.
+     */
+    constructor(raw: RawModule.dtNavMeshCreateParams);
     setPolyMeshCreateParams(polyMesh: RecastPolyMesh): void;
     setPolyMeshDetailCreateParams(polyMeshDetail: RecastPolyMeshDetail): void;
     setOffMeshConnections(offMeshConnections: OffMeshConnectionParams[]): void;

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import Wasm from './raw-module';
 export * from './arrays';
 export * from './crowd';
 export * from './detour';
@@ -9,4 +8,3 @@ export * from './recast';
 export * from './serdes';
 export * from './tile-cache';
 export * from './utils';
-export { Wasm };