@newkrok/nape-js 3.3.0 → 3.3.2

package/dist/index.d.ts

@@ -85,27 +85,104 @@ declare class Vec2 {
 /** @internal Opaque handle for any Haxe-compiled nape object. */
 type NapeInner = any;
 
+/**
+ * ZPP_AABB — Internal axis-aligned bounding box for the nape physics engine.
+ *
+ * Stores min/max coordinates and provides intersection/combine/contain tests.
+ * Lazily creates Vec2 wrappers for the min and max points.
+ *
+ * Converted from nape-compiled.js lines 63546–63965, 134951.
+ */
+type Any$4 = any;
+declare class ZPP_AABB {
+    static zpp_pool: ZPP_AABB | null;
+    static __name__: string[];
+    static _nape: Any$4;
+    static _zpp: Any$4;
+    static _wrapFn: ((zpp: ZPP_AABB) => Any$4) | null;
+    _invalidate: ((self: ZPP_AABB) => void) | null;
+    _validate: (() => void) | null;
+    _immutable: boolean;
+    outer: Any$4;
+    next: ZPP_AABB | null;
+    minx: number;
+    miny: number;
+    maxx: number;
+    maxy: number;
+    wrap_min: Any$4;
+    wrap_max: Any$4;
+    __class__: Any$4;
+    /** Static factory with pooling. */
+    static get(minx: number, miny: number, maxx: number, maxy: number): ZPP_AABB;
+    validate(): void;
+    invalidate(): void;
+    wrapper(): Any$4;
+    alloc(): void;
+    free(): void;
+    copy(): ZPP_AABB;
+    width(): number;
+    height(): number;
+    perimeter(): number;
+    /** Helper: create a Vec2 wrapper from the compiled namespace pools. */
+    private static _makeVec2Wrapper;
+    getmin(): void;
+    dom_min(): void;
+    mod_min(min: Any$4): void;
+    getmax(): void;
+    dom_max(): void;
+    mod_max(max: Any$4): void;
+    intersectX(x: ZPP_AABB): boolean;
+    intersectY(x: ZPP_AABB): boolean;
+    intersect(x: ZPP_AABB): boolean;
+    combine(x: ZPP_AABB): void;
+    contains(x: ZPP_AABB): boolean;
+    containsPoint(v: {
+        x: number;
+        y: number;
+    }): boolean;
+    setCombine(a: ZPP_AABB, b: ZPP_AABB): void;
+    setExpand(a: ZPP_AABB, fatten: number): void;
+    setExpandPoint(x: number, y: number): void;
+    toString(): string;
+}
+
 /**
  * Axis-aligned bounding box defined by min/max corners or x/y/width/height.
+ *
+ * Internally wraps a ZPP_AABB and is registered as the public
+ * `nape.geom.AABB` class in the compiled namespace.
+ *
+ * Converted from nape-compiled.js lines 14950–15653.
  */
 declare class AABB {
-    /** @internal */
-    readonly _inner: NapeInner;
+    static __name__: string[];
+    /** @internal The internal ZPP_AABB this wrapper owns. */
+    zpp_inner: ZPP_AABB;
+    /**
+     * Backward-compatible accessor — returns `this` so that compiled engine
+     * code that receives `aabb._inner` can still access `zpp_inner`.
+     * @internal
+     */
+    get _inner(): NapeInner;
     constructor(x?: number, y?: number, width?: number, height?: number);
-    /** @internal */
-    static _wrap(inner: NapeInner): AABB;
-    get min(): Vec2;
-    set min(value: Vec2);
-    get max(): Vec2;
-    set max(value: Vec2);
+    /** @internal Wrap a ZPP_AABB (or legacy compiled AABB) with caching. */
+    static _wrap(inner: any): AABB;
     get x(): number;
-    set x(value: number);
+    set x(x: number);
     get y(): number;
-    set y(value: number);
+    set y(y: number);
     get width(): number;
-    set width(value: number);
+    set width(width: number);
     get height(): number;
-    set height(value: number);
+    set height(height: number);
+    get min(): any;
+    set min(min: any);
+    get max(): any;
+    set max(max: any);
+    /** @internal Assign source Vec2 values to target Vec2 wrapper. */
+    private _assignVec2;
+    /** @internal Dispose a weak Vec2 back to the pool. */
+    private _disposeVec2;
     copy(): AABB;
     toString(): string;
 }
@@ -163,15 +240,88 @@ declare class NapeList<T> implements Iterable<T> {
     toString(): string;
 }
 
+/**
+ * ZPP_Material — Internal material representation for the nape physics engine.
+ *
+ * Stores physical material properties (friction, elasticity, density) and
+ * manages the list of shapes that reference this material for invalidation.
+ *
+ * Converted from nape-compiled.js lines 87523–87601, 135477–135481.
+ */
+type Any$3 = any;
+declare class ZPP_Material {
+    static zpp_pool: ZPP_Material | null;
+    static WAKE: number;
+    static PROPS: number;
+    static ANGDRAG: number;
+    static ARBITERS: number;
+    static __name__: string[];
+    /**
+     * Namespace references, set by the compiled module after import.
+     * _nape  = the `nape` public namespace (for wrapper creation)
+     * _zpp   = the `zpp_nape` internal namespace (for ZNPList_ZPP_Shape)
+     */
+    static _nape: Any$3;
+    static _zpp: Any$3;
+    /**
+     * Wrapper factory callback, registered by the modernized Material class.
+     * When set, wrapper() uses this instead of creating a compiled Material.
+     */
+    static _wrapFn: ((zpp: ZPP_Material) => Any$3) | null;
+    elasticity: number;
+    dynamicFriction: number;
+    staticFriction: number;
+    density: number;
+    rollingFriction: number;
+    shapes: Any$3;
+    wrap_shapes: Any$3;
+    outer: Any$3;
+    userData: Any$3;
+    next: ZPP_Material | null;
+    __class__: Any$3;
+    constructor();
+    /** Create/return the public nape.phys.Material wrapper for this internal object. */
+    wrapper(): Any$3;
+    /** Called when this object is returned to the pool. */
+    free(): void;
+    /** Called when this object is taken from the pool. */
+    alloc(): void;
+    /** Initialize the shapes list (called during feature construction). */
+    feature_cons(): void;
+    /** Register a shape that uses this material. */
+    addShape(shape: Any$3): void;
+    /** Unregister a shape that no longer uses this material. */
+    remShape(shape: Any$3): void;
+    /** Create a copy with the same property values. */
+    copy(): ZPP_Material;
+    /** Copy all property values from another ZPP_Material. */
+    set(x: ZPP_Material): void;
+    /** Notify all shapes using this material that properties changed. */
+    invalidate(x: number): void;
+}
+
 /**
  * Physical material properties applied to shapes.
+ *
+ * Controls elasticity (bounciness), friction coefficients, density, and
+ * rolling friction.  Internally wraps a ZPP_Material and is registered as
+ * the public `nape.phys.Material` class in the compiled namespace.
+ *
+ * Converted from nape-compiled.js lines 38254–38573.
  */
 declare class Material {
-    /** @internal */
-    readonly _inner: NapeInner;
+    static __name__: string[];
+    /** @internal The internal ZPP_Material this wrapper owns. */
+    zpp_inner: ZPP_Material;
+    /**
+     * Backward-compatible accessor — returns `this` so that compiled engine
+     * code that receives `material._inner` can still access `zpp_inner`.
+     * @internal
+     */
+    get _inner(): NapeInner;
     constructor(elasticity?: number, dynamicFriction?: number, staticFriction?: number, density?: number, rollingFriction?: number);
-    /** @internal */
-    static _wrap(inner: NapeInner): Material;
+    /** @internal Wrap a ZPP_Material (or legacy compiled Material) with caching. */
+    static _wrap(inner: any): Material;
     get elasticity(): number;
     set elasticity(value: number);
     get dynamicFriction(): number;
@@ -185,38 +335,163 @@ declare class Material {
     get userData(): Record<string, unknown>;
     copy(): Material;
     toString(): string;
+    static wood(): Material;
+    static steel(): Material;
+    static ice(): Material;
+    static rubber(): Material;
+    static glass(): Material;
+    static sand(): Material;
+}
+
+/**
+ * ZPP_FluidProperties — Internal fluid properties for the nape physics engine.
+ *
+ * Stores density, viscosity, and per-fluid gravity override.
+ * Manages the list of shapes that reference these properties for invalidation.
+ *
+ * Converted from nape-compiled.js lines 87335–87523, 135403.
+ */
+type Any$2 = any;
+declare class ZPP_FluidProperties {
+    static zpp_pool: ZPP_FluidProperties | null;
+    static __name__: string[];
+    static _nape: Any$2;
+    static _zpp: Any$2;
+    static _wrapFn: ((zpp: ZPP_FluidProperties) => Any$2) | null;
+    viscosity: number;
+    density: number;
+    gravityx: number;
+    gravityy: number;
+    wrap_gravity: Any$2;
+    shapes: Any$2;
+    wrap_shapes: Any$2;
+    outer: Any$2;
+    userData: Any$2;
+    next: ZPP_FluidProperties | null;
+    __class__: Any$2;
+    constructor();
+    /** Create/return the public nape.phys.FluidProperties wrapper. */
+    wrapper(): Any$2;
+    free(): void;
+    alloc(): void;
+    feature_cons(): void;
+    addShape(shape: Any$2): void;
+    remShape(shape: Any$2): void;
+    /** Copy with object pooling. */
+    copy(): ZPP_FluidProperties;
+    /** Called when gravity Vec2 wrapper is invalidated (user set new gravity). */
+    gravity_invalidate(x: Any$2): void;
+    /** Sync the gravity Vec2 wrapper with internal values. */
+    gravity_validate(): void;
+    /** Lazily create and return the gravity Vec2 wrapper. */
+    getgravity(): void;
+    /** Notify all shapes that fluid properties changed. */
+    invalidate(): void;
 }
 
 /**
  * Fluid properties for shapes that act as fluid regions.
+ *
+ * Controls density, viscosity, and per-fluid gravity override.
+ * Internally wraps a ZPP_FluidProperties and is registered as
+ * the public `nape.phys.FluidProperties` class in the compiled namespace.
+ *
+ * Converted from nape-compiled.js lines 37002–37511.
  */
 declare class FluidProperties {
-    /** @internal */
-    readonly _inner: NapeInner;
+    static __name__: string[];
+    /** @internal The internal ZPP_FluidProperties this wrapper owns. */
+    zpp_inner: ZPP_FluidProperties;
+    /**
+     * Backward-compatible accessor — returns `this` so that compiled engine
+     * code that receives `fluidProps._inner` can still access `zpp_inner`.
+     * @internal
+     */
+    get _inner(): NapeInner;
     constructor(density?: number, viscosity?: number);
-    /** @internal */
-    static _wrap(inner: NapeInner): FluidProperties;
+    /** @internal Wrap a ZPP_FluidProperties (or legacy compiled FluidProperties) with caching. */
+    static _wrap(inner: any): FluidProperties;
     get density(): number;
     set density(value: number);
     get viscosity(): number;
     set viscosity(value: number);
-    get gravity(): Vec2;
-    set gravity(value: Vec2);
+    get gravity(): any;
+    set gravity(gravity: any);
     get userData(): Record<string, unknown>;
+    get shapes(): any;
     copy(): FluidProperties;
     toString(): string;
 }
 
+/**
+ * ZPP_InteractionFilter — Internal interaction filter for the nape physics engine.
+ *
+ * Stores collision/sensor/fluid group and mask bitmasks that determine
+ * which shapes interact with each other.
+ *
+ * Converted from nape-compiled.js lines 63255–63366, 135329.
+ */
+type Any$1 = any;
+declare class ZPP_InteractionFilter {
+    static zpp_pool: ZPP_InteractionFilter | null;
+    static __name__: string[];
+    static _nape: Any$1;
+    static _zpp: Any$1;
+    static _wrapFn: ((zpp: ZPP_InteractionFilter) => Any$1) | null;
+    collisionGroup: number;
+    collisionMask: number;
+    sensorGroup: number;
+    sensorMask: number;
+    fluidGroup: number;
+    fluidMask: number;
+    shapes: Any$1;
+    wrap_shapes: Any$1;
+    outer: Any$1;
+    userData: Any$1;
+    next: ZPP_InteractionFilter | null;
+    __class__: Any$1;
+    constructor();
+    /** Create/return the public nape.dynamics.InteractionFilter wrapper. */
+    wrapper(): Any$1;
+    free(): void;
+    alloc(): void;
+    feature_cons(): void;
+    addShape(shape: Any$1): void;
+    remShape(shape: Any$1): void;
+    /** Create a copy with object pooling. */
+    copy(): ZPP_InteractionFilter;
+    /** Test whether two filters allow collision between their shapes. */
+    shouldCollide(x: ZPP_InteractionFilter): boolean;
+    /** Test whether two filters allow sensor interaction. */
+    shouldSense(x: ZPP_InteractionFilter): boolean;
+    /** Test whether two filters allow fluid interaction. */
+    shouldFlow(x: ZPP_InteractionFilter): boolean;
+    /** Notify all shapes that the filter changed. */
+    invalidate(): void;
+}
+
 /**
  * Bit-mask based interaction filter for controlling which shapes
  * collide, sense, or interact as fluids.
+ *
+ * Internally wraps a ZPP_InteractionFilter and is registered as
+ * the public `nape.dynamics.InteractionFilter` class in the compiled namespace.
+ *
+ * Converted from nape-compiled.js lines 14361–14640.
  */
 declare class InteractionFilter {
-    /** @internal */
-    readonly _inner: NapeInner;
+    static __name__: string[];
+    /** @internal The internal ZPP_InteractionFilter this wrapper owns. */
+    zpp_inner: ZPP_InteractionFilter;
+    /**
+     * Backward-compatible accessor — returns `this` so that compiled engine
+     * code that receives `filter._inner` can still access `zpp_inner`.
+     * @internal
+     */
+    get _inner(): NapeInner;
     constructor(collisionGroup?: number, collisionMask?: number, sensorGroup?: number, sensorMask?: number, fluidGroup?: number, fluidMask?: number);
-    /** @internal */
-    static _wrap(inner: NapeInner): InteractionFilter;
+    /** @internal Wrap a ZPP_InteractionFilter (or legacy compiled InteractionFilter) with caching. */
+    static _wrap(inner: any): InteractionFilter;
     get collisionGroup(): number;
     set collisionGroup(value: number);
     get collisionMask(): number;
@@ -230,9 +505,10 @@ declare class InteractionFilter {
     get fluidMask(): number;
     set fluidMask(value: number);
     get userData(): Record<string, unknown>;
-    shouldCollide(other: InteractionFilter): boolean;
-    shouldSense(other: InteractionFilter): boolean;
-    shouldFlow(other: InteractionFilter): boolean;
+    get shapes(): any;
+    shouldCollide(filter: InteractionFilter): boolean;
+    shouldSense(filter: InteractionFilter): boolean;
+    shouldFlow(filter: InteractionFilter): boolean;
     copy(): InteractionFilter;
     toString(): string;
 }
@@ -555,20 +831,73 @@ declare class Polygon extends Shape {
     validity(): NapeInner;
 }
 
+/**
+ * ZPP_InteractionGroup — Internal interaction group for the nape physics engine.
+ *
+ * Hierarchical groups that can override interaction filters. When two shapes
+ * share a common group with `ignore = true`, their interaction is suppressed.
+ *
+ * Converted from nape-compiled.js lines 63367–63463, 135330–135331.
+ */
+type Any = any;
+declare class ZPP_InteractionGroup {
+    static SHAPE: number;
+    static BODY: number;
+    static __name__: string[];
+    static _zpp: Any;
+    static _wrapFn: ((zpp: ZPP_InteractionGroup) => Any) | null;
+    outer: Any;
+    ignore: boolean;
+    group: ZPP_InteractionGroup | null;
+    groups: Any;
+    wrap_groups: Any;
+    interactors: Any;
+    wrap_interactors: Any;
+    depth: number;
+    __class__: Any;
+    constructor();
+    /** Set or change the parent group. */
+    setGroup(group: ZPP_InteractionGroup | null): void;
+    /** Wake all interactors and propagate to child groups. */
+    invalidate(force?: boolean): void;
+    /** Add a child group. */
+    addGroup(group: ZPP_InteractionGroup): void;
+    /** Remove a child group. */
+    remGroup(group: ZPP_InteractionGroup): void;
+    /** Register an interactor in this group. */
+    addInteractor(intx: Any): void;
+    /** Unregister an interactor from this group. */
+    remInteractor(intx: Any, flag?: number): void;
+}
+
 /**
  * Hierarchical interaction group for controlling interactions
  * between sets of interactors.
+ *
+ * Internally wraps a ZPP_InteractionGroup and is registered as
+ * the public `nape.dynamics.InteractionGroup` class in the compiled namespace.
+ *
+ * Converted from nape-compiled.js lines 14641–14733.
  */
 declare class InteractionGroup {
-    /** @internal */
-    readonly _inner: NapeInner;
+    static __name__: string[];
+    /** @internal The internal ZPP_InteractionGroup this wrapper owns. */
+    zpp_inner: ZPP_InteractionGroup;
+    /**
+     * Backward-compatible accessor — returns `this` so that compiled engine
+     * code that receives `group._inner` can still access `zpp_inner`.
+     * @internal
+     */
+    get _inner(): NapeInner;
     constructor(ignore?: boolean);
-    /** @internal */
-    static _wrap(inner: NapeInner): InteractionGroup;
-    get group(): InteractionGroup;
+    /** @internal Wrap a ZPP_InteractionGroup (or legacy compiled InteractionGroup) with caching. */
+    static _wrap(inner: any): InteractionGroup;
+    get group(): InteractionGroup | null;
     set group(value: InteractionGroup | null);
     get ignore(): boolean;
     set ignore(value: boolean);
+    get interactors(): any;
+    get groups(): any;
     toString(): string;
 }