@recast-navigation/core 0.26.0 → 0.28.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;
@@ -169,13 +169,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.
      */
@@ -204,7 +200,20 @@ export declare class Crowd {
      * The NavMeshQuery used to find nearest polys for commands
      */
     navMeshQuery: NavMeshQuery;
-    constructor({ maxAgents, maxAgentRadius, navMesh }: CrowdParams);
+    /**
+     *
+     * @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,
+     * });
+     * ```
+     */
+    constructor(navMesh: NavMesh, { maxAgents, maxAgentRadius }: CrowdParams);
     /**
      * Updates 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 };