@newkrok/nape-js 3.3.4 → 3.3.5

package/dist/index.d.cts

@@ -25,13 +25,13 @@ declare function getNape(): any;
  *
  * Converted from nape-compiled.js lines 83820–84273, 134996.
  */
-type Any$6 = any;
+type Any$d = any;
 declare class ZPP_Vec2 {
     static zpp_pool: ZPP_Vec2 | null;
     static __name__: string[];
-    static _nape: Any$6;
-    static _zpp: Any$6;
-    static _wrapFn: ((zpp: ZPP_Vec2) => Any$6) | null;
+    static _nape: Any$d;
+    static _zpp: Any$d;
+    static _wrapFn: ((zpp: ZPP_Vec2) => Any$d) | null;
     x: number;
     y: number;
     next: ZPP_Vec2 | null;
@@ -40,18 +40,18 @@ declare class ZPP_Vec2 {
     pushmod: boolean;
     _inuse: boolean;
     weak: boolean;
-    outer: Any$6;
+    outer: Any$d;
     _immutable: boolean;
     _isimmutable: (() => void) | null;
     _validate: (() => void) | null;
     _invalidate: ((self: ZPP_Vec2) => void) | null;
-    __class__: Any$6;
+    __class__: Any$d;
     /** Static factory with optional pooling and immutability. */
     static get(x: number, y: number, immutable?: boolean): ZPP_Vec2;
     validate(): void;
     invalidate(): void;
     immutable(): void;
-    wrapper(): Any$6;
+    wrapper(): Any$d;
     free(): void;
     alloc(): void;
     elem(): ZPP_Vec2;
@@ -203,20 +203,20 @@ type NapeInner = any;
  *
  * Converted from nape-compiled.js lines 83412–83434.
  */
-type Any$5 = any;
+type Any$c = any;
 declare class ZPP_Vec3 {
     static __name__: string[];
-    static _zpp: Any$5;
-    static _wrapFn: ((zpp: ZPP_Vec3) => Any$5) | null;
-    outer: Any$5;
+    static _zpp: Any$c;
+    static _wrapFn: ((zpp: ZPP_Vec3) => Any$c) | null;
+    outer: Any$c;
     x: number;
     y: number;
     z: number;
     immutable: boolean;
     _validate: (() => void) | null;
-    __class__: Any$5;
+    __class__: Any$c;
     validate(): void;
-    wrapper(): Any$5;
+    wrapper(): Any$c;
 }
 
 /**
@@ -272,6 +272,188 @@ declare class Vec3 {
     toString(): string;
 }
 
+/**
+ * ZPP_Mat23 — Internal 2×3 transformation matrix for the nape physics engine.
+ *
+ * Represents affine transforms with components [a, b, c, d, tx, ty].
+ * Supports object pooling and lazy wrapper creation.
+ *
+ * Converted from nape-compiled.js lines 73495–73561, 133826.
+ */
+type Any$b = any;
+declare class ZPP_Mat23 {
+    static __name__: string[];
+    static _nape: Any$b;
+    static _wrapFn: ((zpp: ZPP_Mat23) => Any$b) | null;
+    static zpp_pool: ZPP_Mat23 | null;
+    outer: Any$b;
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    tx: number;
+    ty: number;
+    _invalidate: (() => void) | null;
+    next: ZPP_Mat23 | null;
+    __class__: Any$b;
+    /** Static factory with pooling. */
+    static get(): ZPP_Mat23;
+    /** Create an identity matrix from pool. */
+    static identity(): ZPP_Mat23;
+    /** Create a public wrapper, recycling any existing inner. */
+    wrapper(): Any$b;
+    invalidate(): void;
+    set(m: ZPP_Mat23): void;
+    setas(a: number, b: number, c: number, d: number, tx: number, ty: number): void;
+    free(): void;
+    alloc(): void;
+}
+
+/**
+ * 2x3 affine transformation matrix [a b tx; c d ty].
+ *
+ * Converted from nape-compiled.js lines 20507–21760.
+ */
+declare class Mat23 {
+    static __name__: string[];
+    zpp_inner: ZPP_Mat23;
+    get _inner(): NapeInner;
+    constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number);
+    static rotation(angle: number): Mat23;
+    static translation(tx: number, ty: number): Mat23;
+    static scale(sx: number, sy: number): Mat23;
+    static _wrap(inner: any): Mat23;
+    private _setProp;
+    get a(): number;
+    set a(v: number);
+    get b(): number;
+    set b(v: number);
+    get c(): number;
+    set c(v: number);
+    get d(): number;
+    set d(v: number);
+    get tx(): number;
+    set tx(v: number);
+    get ty(): number;
+    set ty(v: number);
+    get determinant(): number;
+    copy(): Mat23;
+    set(matrix: Mat23): this;
+    setAs(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number): this;
+    reset(): this;
+    singular(): boolean;
+    inverse(): Mat23;
+    transpose(): Mat23;
+    concat(matrix: Mat23): Mat23;
+    transform(point: Vec2, noTranslation?: boolean, weak?: boolean): Vec2;
+    inverseTransform(point: Vec2, noTranslation?: boolean, weak?: boolean): Vec2;
+    equiorthogonal(): boolean;
+    orthogonal(): boolean;
+    private _orthogonaliseImpl;
+    equiorthogonalise(): this;
+    orthogonalise(): this;
+    toString(): string;
+}
+
+/**
+ * ZPP_GeomPoly — Internal polygon geometry holder for the nape physics engine.
+ *
+ * Simple data container linking a public GeomPoly wrapper to its vertex list.
+ *
+ * Converted from nape-compiled.js lines 69554–69563.
+ */
+type Any$a = any;
+declare class ZPP_GeomPoly {
+    static __name__: string[];
+    outer: Any$a;
+    vertices: Any$a;
+    __class__: Any$a;
+    constructor(outer?: Any$a);
+}
+
+type Any$9 = any;
+/**
+ * A polygon represented as a circular doubly-linked list of vertices.
+ *
+ * Supports construction from Array<Vec2>, Vec2List, or another GeomPoly.
+ * Provides geometric queries (area, winding, containment, convexity)
+ * and decomposition algorithms (simple, monotone, convex, triangular).
+ *
+ * Converted from nape-compiled.js lines 16271–19420.
+ */
+declare class GeomPoly {
+    static __name__: string[];
+    zpp_inner: ZPP_GeomPoly;
+    zpp_pool: GeomPoly | null;
+    zpp_disp: boolean;
+    get _inner(): Any$9;
+    constructor(vertices?: Any$9);
+    private _checkDisposed;
+    /** @internal Get compiled ZPP_GeomVert class */
+    private static _gvClass;
+    /** @internal Create a ZPP_GeomVert from pool or new */
+    private static _createVert;
+    /** @internal Insert vertex after current head (push pattern) */
+    private static _pushVert;
+    /** @internal Insert vertex before current head (unshift pattern) */
+    private static _unshiftVert;
+    /** @internal Free a vertex: cleanup wrap + return to pool */
+    private static _freeVert;
+    /** @internal Remove head, new head = prev (pop direction) */
+    private _popHead;
+    /** @internal Remove head, new head = next (shift direction) */
+    private _shiftHead;
+    /** @internal Check if polygon is degenerate (< 3 vertices) */
+    private _isDegenRing;
+    /** @internal Iterate all vertices, calling fn for each */
+    private _forEachVert;
+    /** @internal Find extremal vertex (min/max of x or y) */
+    private _extremalVert;
+    /** @internal Add vertices from constructor/get argument */
+    private static _addVertices;
+    /** @internal After copying, dispose weak Vec2 inputs */
+    private static _disposeWeakInputs;
+    static get(vertices?: Any$9): GeomPoly;
+    empty(): boolean;
+    size(): number;
+    iterator(): Any$9;
+    forwardIterator(): Any$9;
+    backwardsIterator(): Any$9;
+    current(): Vec2;
+    push(vertex: Vec2): this;
+    pop(): this;
+    unshift(vertex: Vec2): this;
+    shift(): this;
+    skipForward(times: number): this;
+    skipBackwards(times: number): this;
+    erase(count: number): this;
+    clear(): this;
+    copy(): GeomPoly;
+    dispose(): void;
+    area(): number;
+    winding(): Any$9;
+    contains(point: Vec2): boolean;
+    isClockwise(): boolean;
+    isConvex(): boolean;
+    isSimple(): boolean;
+    isMonotone(): boolean;
+    isDegenerate(): boolean;
+    simplify(epsilon: number): GeomPoly;
+    simpleDecomposition(output?: Any$9): Any$9;
+    monotoneDecomposition(output?: Any$9): Any$9;
+    convexDecomposition(delaunay?: boolean, output?: Any$9): Any$9;
+    triangularDecomposition(delaunay?: boolean, output?: Any$9): Any$9;
+    inflate(inflation: number): GeomPoly;
+    cut(start: Vec2, end: Vec2, boundedStart?: boolean, boundedEnd?: boolean, output?: Any$9): Any$9;
+    transform(matrix: Any$9): this;
+    bounds(): Any$9;
+    top(): Vec2;
+    bottom(): Vec2;
+    left(): Vec2;
+    right(): Vec2;
+    toString(): string;
+}
+
 /**
  * ZPP_AABB — Internal axis-aligned bounding box for the nape physics engine.
  *
@@ -280,30 +462,30 @@ declare class Vec3 {
  *
  * Converted from nape-compiled.js lines 63546–63965, 134951.
  */
-type Any$4 = any;
+type Any$8 = 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;
+    static _nape: Any$8;
+    static _zpp: Any$8;
+    static _wrapFn: ((zpp: ZPP_AABB) => Any$8) | null;
     _invalidate: ((self: ZPP_AABB) => void) | null;
     _validate: (() => void) | null;
     _immutable: boolean;
-    outer: Any$4;
+    outer: Any$8;
     next: ZPP_AABB | null;
     minx: number;
     miny: number;
     maxx: number;
     maxy: number;
-    wrap_min: Any$4;
-    wrap_max: Any$4;
-    __class__: Any$4;
+    wrap_min: Any$8;
+    wrap_max: Any$8;
+    __class__: Any$8;
     /** Static factory with pooling. */
     static get(minx: number, miny: number, maxx: number, maxy: number): ZPP_AABB;
     validate(): void;
     invalidate(): void;
-    wrapper(): Any$4;
+    wrapper(): Any$8;
     alloc(): void;
     free(): void;
     copy(): ZPP_AABB;
@@ -314,10 +496,10 @@ declare class ZPP_AABB {
     private static _makeVec2Wrapper;
     getmin(): void;
     dom_min(): void;
-    mod_min(min: Any$4): void;
+    mod_min(min: Any$8): void;
     getmax(): void;
     dom_max(): void;
-    mod_max(max: Any$4): void;
+    mod_max(max: Any$8): void;
     intersectX(x: ZPP_AABB): boolean;
     intersectY(x: ZPP_AABB): boolean;
     intersect(x: ZPP_AABB): boolean;
@@ -435,7 +617,7 @@ declare class NapeList<T> implements Iterable<T> {
  *
  * Converted from nape-compiled.js lines 87523–87601, 135477–135481.
  */
-type Any$3 = any;
+type Any$7 = any;
 declare class ZPP_Material {
     static zpp_pool: ZPP_Material | null;
     static WAKE: number;
@@ -448,27 +630,27 @@ declare class ZPP_Material {
      * _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;
+    static _nape: Any$7;
+    static _zpp: Any$7;
     /**
      * 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;
+    static _wrapFn: ((zpp: ZPP_Material) => Any$7) | null;
     elasticity: number;
     dynamicFriction: number;
     staticFriction: number;
     density: number;
     rollingFriction: number;
-    shapes: Any$3;
-    wrap_shapes: Any$3;
-    outer: Any$3;
-    userData: Any$3;
+    shapes: Any$7;
+    wrap_shapes: Any$7;
+    outer: Any$7;
+    userData: Any$7;
     next: ZPP_Material | null;
-    __class__: Any$3;
+    __class__: Any$7;
     constructor();
     /** Create/return the public nape.phys.Material wrapper for this internal object. */
-    wrapper(): Any$3;
+    wrapper(): Any$7;
     /** Called when this object is returned to the pool. */
     free(): void;
     /** Called when this object is taken from the pool. */
@@ -476,9 +658,9 @@ declare class ZPP_Material {
     /** Initialize the shapes list (called during feature construction). */
     feature_cons(): void;
     /** Register a shape that uses this material. */
-    addShape(shape: Any$3): void;
+    addShape(shape: Any$7): void;
     /** Unregister a shape that no longer uses this material. */
-    remShape(shape: Any$3): void;
+    remShape(shape: Any$7): void;
     /** Create a copy with the same property values. */
     copy(): ZPP_Material;
     /** Copy all property values from another ZPP_Material. */
@@ -538,36 +720,36 @@ declare class Material {
  *
  * Converted from nape-compiled.js lines 87335–87523, 135403.
  */
-type Any$2 = any;
+type Any$6 = 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;
+    static _nape: Any$6;
+    static _zpp: Any$6;
+    static _wrapFn: ((zpp: ZPP_FluidProperties) => Any$6) | 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;
+    wrap_gravity: Any$6;
+    shapes: Any$6;
+    wrap_shapes: Any$6;
+    outer: Any$6;
+    userData: Any$6;
     next: ZPP_FluidProperties | null;
-    __class__: Any$2;
+    __class__: Any$6;
     constructor();
     /** Create/return the public nape.phys.FluidProperties wrapper. */
-    wrapper(): Any$2;
+    wrapper(): Any$6;
     free(): void;
     alloc(): void;
     feature_cons(): void;
-    addShape(shape: Any$2): void;
-    remShape(shape: Any$2): void;
+    addShape(shape: Any$6): void;
+    remShape(shape: Any$6): 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;
+    gravity_invalidate(x: Any$6): void;
     /** Sync the gravity Vec2 wrapper with internal values. */
     gravity_validate(): void;
     /** Lazily create and return the gravity Vec2 wrapper. */
@@ -618,33 +800,33 @@ declare class FluidProperties {
  *
  * Converted from nape-compiled.js lines 63255–63366, 135329.
  */
-type Any$1 = any;
+type Any$5 = 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;
+    static _nape: Any$5;
+    static _zpp: Any$5;
+    static _wrapFn: ((zpp: ZPP_InteractionFilter) => Any$5) | 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;
+    shapes: Any$5;
+    wrap_shapes: Any$5;
+    outer: Any$5;
+    userData: Any$5;
     next: ZPP_InteractionFilter | null;
-    __class__: Any$1;
+    __class__: Any$5;
     constructor();
     /** Create/return the public nape.dynamics.InteractionFilter wrapper. */
-    wrapper(): Any$1;
+    wrapper(): Any$5;
     free(): void;
     alloc(): void;
     feature_cons(): void;
-    addShape(shape: Any$1): void;
-    remShape(shape: Any$1): void;
+    addShape(shape: Any$5): void;
+    remShape(shape: Any$5): void;
     /** Create a copy with object pooling. */
     copy(): ZPP_InteractionFilter;
     /** Test whether two filters allow collision between their shapes. */
@@ -1026,22 +1208,22 @@ declare class Polygon extends Shape {
  *
  * Converted from nape-compiled.js lines 63367–63463, 135330–135331.
  */
-type Any = any;
+type Any$4 = 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;
+    static _zpp: Any$4;
+    static _wrapFn: ((zpp: ZPP_InteractionGroup) => Any$4) | null;
+    outer: Any$4;
     ignore: boolean;
     group: ZPP_InteractionGroup | null;
-    groups: Any;
-    wrap_groups: Any;
-    interactors: Any;
-    wrap_interactors: Any;
+    groups: Any$4;
+    wrap_groups: Any$4;
+    interactors: Any$4;
+    wrap_interactors: Any$4;
     depth: number;
-    __class__: Any;
+    __class__: Any$4;
     constructor();
     /** Set or change the parent group. */
     setGroup(group: ZPP_InteractionGroup | null): void;
@@ -1052,9 +1234,9 @@ declare class ZPP_InteractionGroup {
     /** Remove a child group. */
     remGroup(group: ZPP_InteractionGroup): void;
     /** Register an interactor in this group. */
-    addInteractor(intx: Any): void;
+    addInteractor(intx: Any$4): void;
     /** Unregister an interactor from this group. */
-    remInteractor(intx: Any, flag?: number): void;
+    remInteractor(intx: Any$4, flag?: number): void;
 }
 
 /**
@@ -1101,24 +1283,77 @@ declare enum CbEvent {
     PRE = "PRE"
 }
 
+/**
+ * ZPP_CbType — Internal callback type for the nape physics engine.
+ *
+ * Manages three types of listener lists (interaction, body, constraint)
+ * with priority-ordered insertion. Tracks interactors and constraints
+ * that use this callback type, and invalidates callback sets on change.
+ *
+ * Converted from nape-compiled.js lines 48256–48482.
+ */
+type Any$3 = any;
+declare class ZPP_CbType {
+    static __name__: string[];
+    static _zpp: Any$3;
+    outer: Any$3;
+    userData: Any$3;
+    id: number;
+    cbsets: Any$3;
+    interactors: Any$3;
+    wrap_interactors: Any$3;
+    constraints: Any$3;
+    wrap_constraints: Any$3;
+    listeners: Any$3;
+    bodylisteners: Any$3;
+    conlisteners: Any$3;
+    __class__: Any$3;
+    constructor();
+    /** Sort comparator by id. */
+    static setlt(a: ZPP_CbType, b: ZPP_CbType): boolean;
+    addInteractor(intx: Any$3): void;
+    remInteractor(intx: Any$3): void;
+    addConstraint(con: Any$3): void;
+    remConstraint(con: Any$3): void;
+    addint(x: Any$3): void;
+    removeint(x: Any$3): void;
+    invalidateint(): void;
+    addbody(x: Any$3): void;
+    removebody(x: Any$3): void;
+    invalidatebody(): void;
+    addconstraint(x: Any$3): void;
+    removeconstraint(x: Any$3): void;
+    invalidateconstraint(): void;
+}
+
+type Any$2 = any;
 /**
  * Callback type — used to tag interactors so that listeners
  * can filter which interactions they respond to.
+ *
+ * Converted from nape-compiled.js lines 689–770.
  */
 declare class CbType {
-    /** @internal */
-    readonly _inner: NapeInner;
+    static __name__: string[];
+    zpp_inner: ZPP_CbType;
+    get _inner(): NapeInner;
     constructor();
-    /** @internal */
-    static _wrap(inner: NapeInner): CbType;
-    /** Built-in type matching any body. */
     static get ANY_BODY(): CbType;
-    /** Built-in type matching any constraint. */
     static get ANY_CONSTRAINT(): CbType;
-    /** Built-in type matching any shape. */
     static get ANY_SHAPE(): CbType;
-    /** Built-in type matching any compound. */
     static get ANY_COMPOUND(): CbType;
+    static get_ANY_BODY(): CbType;
+    static get_ANY_CONSTRAINT(): CbType;
+    static get_ANY_SHAPE(): CbType;
+    static get_ANY_COMPOUND(): CbType;
+    get id(): number;
+    get userData(): Any$2;
+    get interactors(): Any$2;
+    get constraints(): Any$2;
+    including(includes: Any$2): Any$2;
+    excluding(excludes: Any$2): Any$2;
+    toString(): string;
+    static _wrap(inner: any): CbType;
 }
 
 /**
@@ -1142,14 +1377,62 @@ declare enum PreFlag {
 }
 
 /**
- * Composite callback type option — allows including and excluding CbTypes.
+ * ZPP_OptionType — Internal callback option type for the nape physics engine.
+ *
+ * Manages include/exclude lists of callback types with ordered insertion,
+ * set intersection tests, and handler delegation for live changes.
+ *
+ * Converted from nape-compiled.js lines 51337–51655.
+ */
+type Any$1 = any;
+declare class ZPP_OptionType {
+    static __name__: string[];
+    static _nape: Any$1;
+    static _zpp: Any$1;
+    outer: Any$1;
+    handler: ((val: Any$1, included: boolean, added: boolean) => void) | null;
+    includes: Any$1;
+    excludes: Any$1;
+    wrap_includes: Any$1;
+    wrap_excludes: Any$1;
+    __class__: Any$1;
+    constructor();
+    /** Coerce a value to OptionType (null → new, OptionType → pass-through, CbType → including). */
+    static argument(val: Any$1): Any$1;
+    setup_includes(): void;
+    setup_excludes(): void;
+    excluded(xs: Any$1): boolean;
+    included(xs: Any$1): boolean;
+    compatible(xs: Any$1): boolean;
+    /** Check whether two sorted-by-id lists share any element. */
+    nonemptyintersection(xs: Any$1, ys: Any$1): boolean;
+    /** Insert into the ordered include or exclude list, using pool nodes. */
+    private insertOrdered;
+    effect_change(val: Any$1, included: boolean, added: boolean): void;
+    append_type(list: Any$1, val: Any$1): void;
+    set(options: ZPP_OptionType): this;
+    append(list: Any$1, val: Any$1): void;
+}
+
+type Any = any;
+/**
+ * Composite callback option type — allows including and excluding CbTypes.
+ *
+ * Converted from nape-compiled.js lines 2647–2698.
  */
 declare class OptionType {
-    /** @internal */
-    readonly _inner: NapeInner;
-    constructor(cbTypes?: CbType | CbType[]);
-    /** @internal */
-    static _wrap(inner: NapeInner): OptionType;
+    static __name__: string[];
+    zpp_inner: ZPP_OptionType;
+    get _inner(): NapeInner;
+    constructor(includes?: Any, excludes?: Any);
+    get includes(): Any;
+    get excludes(): Any;
+    get_includes(): Any;
+    get_excludes(): Any;
+    including(includes: Any): this;
+    excluding(excludes: Any): this;
+    toString(): string;
+    static _wrap(inner: any): OptionType;
 }
 
 /**
@@ -1353,4 +1636,4 @@ declare class PulleyJoint extends Constraint {
     set ratio(value: number);
 }
 
-export { AABB, AngleJoint, Body, BodyListener, BodyType, CbEvent, CbType, Circle, Constraint, ConstraintListener, DistanceJoint, FluidProperties, InteractionFilter, InteractionGroup, InteractionListener, InteractionType, LineJoint, Listener, Material, MotorJoint, NapeList, OptionType, PivotJoint, Polygon, PreFlag, PreListener, PulleyJoint, Shape, ShapeType, Space, Vec2, Vec3, WeldJoint, getNape };
+export { AABB, AngleJoint, Body, BodyListener, BodyType, CbEvent, CbType, Circle, Constraint, ConstraintListener, DistanceJoint, FluidProperties, GeomPoly, InteractionFilter, InteractionGroup, InteractionListener, InteractionType, LineJoint, Listener, Mat23, Material, MotorJoint, NapeList, OptionType, PivotJoint, Polygon, PreFlag, PreListener, PulleyJoint, Shape, ShapeType, Space, Vec2, Vec3, WeldJoint, getNape };