@awayfl/awayfl-player
Version:
Flash Player emulator for executing SWF files (published for FP versions 6 and up) in javascript
960 lines (959 loc) • 348 kB
TypeScript
///<reference path='./debugDraw/nape-debug-draw.d.ts'/>
declare module nape {
export module callbacks {
export class Callback {
public zpp_inner: zpp_nape.callbacks.ZPP_Callback;
public event: nape.callbacks.CbEvent;
public listener: nape.callbacks.Listener;
public toString(): String;
constructor();
}
export class BodyCallback extends nape.callbacks.Callback {
public body: nape.phys.Body;
public toString(): String;
constructor();
}
export class Listener {
public zpp_inner: zpp_nape.callbacks.ZPP_Listener;
public type: nape.callbacks.ListenerType;
public event: nape.callbacks.CbEvent;
public precedence: number;
public space: nape.space.Space;
public toString(): String;
constructor();
}
export class BodyListener extends nape.callbacks.Listener {
public zpp_inner_zn: zpp_nape.callbacks.ZPP_BodyListener;
public options: nape.callbacks.OptionType;
public handler: (__0: nape.callbacks.BodyCallback) => void;
constructor(event: nape.callbacks.CbEvent, options: any, handler: (__0: nape.callbacks.BodyCallback) => void, precedence?: number);
}
export class CbEvent {
public static BEGIN: nape.callbacks.CbEvent;
public static ONGOING: nape.callbacks.CbEvent;
public static END: nape.callbacks.CbEvent;
public static WAKE: nape.callbacks.CbEvent;
public static SLEEP: nape.callbacks.CbEvent;
public static BREAK: nape.callbacks.CbEvent;
public static PRE: nape.callbacks.CbEvent;
public toString(): String;
constructor();
}
export class CbType {
public zpp_inner: zpp_nape.callbacks.ZPP_CbType;
public id: number;
public userData: any;
public interactors: nape.phys.InteractorList;
public constraints: nape.constraint.ConstraintList;
public static ANY_BODY: nape.callbacks.CbType;
public static ANY_CONSTRAINT: nape.callbacks.CbType;
public static ANY_SHAPE: nape.callbacks.CbType;
public static ANY_COMPOUND: nape.callbacks.CbType;
public including(includes: any): nape.callbacks.OptionType;
public excluding(excludes: any): nape.callbacks.OptionType;
public toString(): String;
constructor();
}
export class CbTypeIterator {
public zpp_inner: nape.callbacks.CbTypeList;
public zpp_i: number;
public zpp_critical: boolean;
public zpp_next: nape.callbacks.CbTypeIterator;
public hasNext: () => boolean;
public next: () => nape.callbacks.CbType;
public static zpp_pool: nape.callbacks.CbTypeIterator;
public static get(list: nape.callbacks.CbTypeList): nape.callbacks.CbTypeIterator;
constructor();
}
export class CbTypeList {
public zpp_inner: zpp_nape.util.ZPP_CbTypeList;
public length: number;
public add: (obj: nape.callbacks.CbType) => boolean;
public empty: () => boolean;
public iterator: () => nape.callbacks.CbTypeIterator;
public foreach: (lambda: (__0: nape.callbacks.CbType) => void) => nape.callbacks.CbTypeList;
public static fromArray(array: any[]): nape.callbacks.CbTypeList;
public has(obj: nape.callbacks.CbType): boolean;
public at(index: number): nape.callbacks.CbType;
public push(obj: nape.callbacks.CbType): boolean;
public unshift(obj: nape.callbacks.CbType): boolean;
public pop(): nape.callbacks.CbType;
public shift(): nape.callbacks.CbType;
public remove(obj: nape.callbacks.CbType): boolean;
public clear(): void;
public copy(deep?: boolean): nape.callbacks.CbTypeList;
public merge(xs: nape.callbacks.CbTypeList): void;
public toString(): String;
public filter(lambda: (__0: nape.callbacks.CbType) => boolean): nape.callbacks.CbTypeList;
constructor();
}
export class ConstraintCallback extends nape.callbacks.Callback {
public constraint: nape.constraint.Constraint;
public toString(): String;
constructor();
}
export class ConstraintListener extends nape.callbacks.Listener {
public zpp_inner_zn: zpp_nape.callbacks.ZPP_ConstraintListener;
public options: nape.callbacks.OptionType;
public handler: (__0: nape.callbacks.ConstraintCallback) => void;
constructor(event: nape.callbacks.CbEvent, options: any, handler: (__0: nape.callbacks.ConstraintCallback) => void, precedence?: number);
}
export class InteractionCallback extends nape.callbacks.Callback {
public int1: nape.phys.Interactor;
public int2: nape.phys.Interactor;
public arbiters: nape.dynamics.ArbiterList;
public toString(): String;
constructor();
}
export class InteractionListener extends nape.callbacks.Listener {
public zpp_inner_zn: zpp_nape.callbacks.ZPP_InteractionListener;
public options1: nape.callbacks.OptionType;
public options2: nape.callbacks.OptionType;
public interactionType: nape.callbacks.InteractionType;
public handler: (__0: nape.callbacks.InteractionCallback) => void;
public allowSleepingCallbacks: boolean;
constructor(event: nape.callbacks.CbEvent, interactionType: nape.callbacks.InteractionType, options1: any, options2: any, handler: (__0: nape.callbacks.InteractionCallback) => void, precedence?: number);
}
export class InteractionType {
public static COLLISION: nape.callbacks.InteractionType;
public static SENSOR: nape.callbacks.InteractionType;
public static FLUID: nape.callbacks.InteractionType;
public static ANY: nape.callbacks.InteractionType;
public toString(): String;
constructor();
}
export class ListenerIterator {
public zpp_inner: nape.callbacks.ListenerList;
public zpp_i: number;
public zpp_critical: boolean;
public zpp_next: nape.callbacks.ListenerIterator;
public hasNext: () => boolean;
public next: () => nape.callbacks.Listener;
public static zpp_pool: nape.callbacks.ListenerIterator;
public static get(list: nape.callbacks.ListenerList): nape.callbacks.ListenerIterator;
constructor();
}
export class ListenerList {
public zpp_inner: zpp_nape.util.ZPP_ListenerList;
public length: number;
public add: (obj: nape.callbacks.Listener) => boolean;
public empty: () => boolean;
public iterator: () => nape.callbacks.ListenerIterator;
public foreach: (lambda: (__0: nape.callbacks.Listener) => void) => nape.callbacks.ListenerList;
public static fromArray(array: any[]): nape.callbacks.ListenerList;
public has(obj: nape.callbacks.Listener): boolean;
public at(index: number): nape.callbacks.Listener;
public push(obj: nape.callbacks.Listener): boolean;
public unshift(obj: nape.callbacks.Listener): boolean;
public pop(): nape.callbacks.Listener;
public shift(): nape.callbacks.Listener;
public remove(obj: nape.callbacks.Listener): boolean;
public clear(): void;
public copy(deep?: boolean): nape.callbacks.ListenerList;
public merge(xs: nape.callbacks.ListenerList): void;
public toString(): String;
public filter(lambda: (__0: nape.callbacks.Listener) => boolean): nape.callbacks.ListenerList;
constructor();
}
export class ListenerType {
public static BODY: nape.callbacks.ListenerType;
public static CONSTRAINT: nape.callbacks.ListenerType;
public static INTERACTION: nape.callbacks.ListenerType;
public static PRE: nape.callbacks.ListenerType;
public toString(): String;
constructor();
}
export class OptionType {
public zpp_inner: zpp_nape.callbacks.ZPP_OptionType;
public includes: nape.callbacks.CbTypeList;
public excludes: nape.callbacks.CbTypeList;
public including(includes?: any): nape.callbacks.OptionType;
public excluding(excludes?: any): nape.callbacks.OptionType;
public toString(): String;
constructor(includes?: any, excludes?: any);
}
export class PreCallback extends nape.callbacks.Callback {
public arbiter: nape.dynamics.Arbiter;
public int1: nape.phys.Interactor;
public int2: nape.phys.Interactor;
public swapped: boolean;
public toString(): String;
constructor();
}
export class PreFlag {
public static ACCEPT: nape.callbacks.PreFlag;
public static IGNORE: nape.callbacks.PreFlag;
public static ACCEPT_ONCE: nape.callbacks.PreFlag;
public static IGNORE_ONCE: nape.callbacks.PreFlag;
public toString(): String;
constructor();
}
export class PreListener extends nape.callbacks.Listener {
public zpp_inner_zn: zpp_nape.callbacks.ZPP_InteractionListener;
public options1: nape.callbacks.OptionType;
public options2: nape.callbacks.OptionType;
public handler: (__0: nape.callbacks.PreCallback) => nape.callbacks.PreFlag;
public pure: boolean;
public interactionType: nape.callbacks.InteractionType;
constructor(interactionType: nape.callbacks.InteractionType, options1: any, options2: any, handler: (__0: nape.callbacks.PreCallback) => nape.callbacks.PreFlag, precedence?: number, pure?: boolean);
}
}
export module constraint {
export class Constraint {
public zpp_inner: zpp_nape.constraint.ZPP_Constraint;
public userData: any;
public debugDraw: boolean;
public compound: nape.phys.Compound;
public space: nape.space.Space;
public isSleeping: boolean;
public active: boolean;
public ignore: boolean;
public stiff: boolean;
public frequency: number;
public damping: number;
public maxForce: number;
public maxError: number;
public breakUnderForce: boolean;
public breakUnderError: boolean;
public removeOnBreak: boolean;
public cbTypes: nape.callbacks.CbTypeList;
public static zpp_internalAlloc: boolean;
public impulse(): nape.geom.MatMN;
public bodyImpulse(body: nape.phys.Body): nape.geom.Vec3;
public visitBodies(lambda: (__0: nape.phys.Body) => void): void;
public toString(): String;
public copy(): nape.constraint.Constraint;
constructor();
}
export class AngleJoint extends nape.constraint.Constraint {
public zpp_inner_zn: zpp_nape.constraint.ZPP_AngleJoint;
public body1: nape.phys.Body;
public body2: nape.phys.Body;
public jointMin: number;
public jointMax: number;
public ratio: number;
public isSlack: () => boolean;
public impulse(): nape.geom.MatMN;
public bodyImpulse(body: nape.phys.Body): nape.geom.Vec3;
public visitBodies(lambda: (__0: nape.phys.Body) => void): void;
constructor(body1: nape.phys.Body, body2: nape.phys.Body, jointMin: number, jointMax: number, ratio?: number);
}
export class ConstraintIterator {
public zpp_inner: nape.constraint.ConstraintList;
public zpp_i: number;
public zpp_critical: boolean;
public zpp_next: nape.constraint.ConstraintIterator;
public hasNext: () => boolean;
public next: () => nape.constraint.Constraint;
public static zpp_pool: nape.constraint.ConstraintIterator;
public static get(list: nape.constraint.ConstraintList): nape.constraint.ConstraintIterator;
constructor();
}
export class ConstraintList {
public zpp_inner: zpp_nape.util.ZPP_ConstraintList;
public length: number;
public add: (obj: nape.constraint.Constraint) => boolean;
public empty: () => boolean;
public iterator: () => nape.constraint.ConstraintIterator;
public foreach: (lambda: (__0: nape.constraint.Constraint) => void) => nape.constraint.ConstraintList;
public static fromArray(array: any[]): nape.constraint.ConstraintList;
public has(obj: nape.constraint.Constraint): boolean;
public at(index: number): nape.constraint.Constraint;
public push(obj: nape.constraint.Constraint): boolean;
public unshift(obj: nape.constraint.Constraint): boolean;
public pop(): nape.constraint.Constraint;
public shift(): nape.constraint.Constraint;
public remove(obj: nape.constraint.Constraint): boolean;
public clear(): void;
public copy(deep?: boolean): nape.constraint.ConstraintList;
public merge(xs: nape.constraint.ConstraintList): void;
public toString(): String;
public filter(lambda: (__0: nape.constraint.Constraint) => boolean): nape.constraint.ConstraintList;
constructor();
}
export class DistanceJoint extends nape.constraint.Constraint {
public zpp_inner_zn: zpp_nape.constraint.ZPP_DistanceJoint;
public body1: nape.phys.Body;
public body2: nape.phys.Body;
public anchor1: nape.geom.Vec2;
public anchor2: nape.geom.Vec2;
public jointMin: number;
public jointMax: number;
public isSlack: () => boolean;
public impulse(): nape.geom.MatMN;
public bodyImpulse(body: nape.phys.Body): nape.geom.Vec3;
public visitBodies(lambda: (__0: nape.phys.Body) => void): void;
constructor(body1: nape.phys.Body, body2: nape.phys.Body, anchor1: nape.geom.Vec2, anchor2: nape.geom.Vec2, jointMin: number, jointMax: number);
}
export class LineJoint extends nape.constraint.Constraint {
public zpp_inner_zn: zpp_nape.constraint.ZPP_LineJoint;
public body1: nape.phys.Body;
public body2: nape.phys.Body;
public anchor1: nape.geom.Vec2;
public anchor2: nape.geom.Vec2;
public direction: nape.geom.Vec2;
public jointMin: number;
public jointMax: number;
public impulse(): nape.geom.MatMN;
public bodyImpulse(body: nape.phys.Body): nape.geom.Vec3;
public visitBodies(lambda: (__0: nape.phys.Body) => void): void;
constructor(body1: nape.phys.Body, body2: nape.phys.Body, anchor1: nape.geom.Vec2, anchor2: nape.geom.Vec2, direction: nape.geom.Vec2, jointMin: number, jointMax: number);
}
export class MotorJoint extends nape.constraint.Constraint {
public zpp_inner_zn: zpp_nape.constraint.ZPP_MotorJoint;
public body1: nape.phys.Body;
public body2: nape.phys.Body;
public ratio: number;
public rate: number;
public impulse(): nape.geom.MatMN;
public bodyImpulse(body: nape.phys.Body): nape.geom.Vec3;
public visitBodies(lambda: (__0: nape.phys.Body) => void): void;
constructor(body1: nape.phys.Body, body2: nape.phys.Body, rate?: number, ratio?: number);
}
export class PivotJoint extends nape.constraint.Constraint {
public zpp_inner_zn: zpp_nape.constraint.ZPP_PivotJoint;
public body1: nape.phys.Body;
public body2: nape.phys.Body;
public anchor1: nape.geom.Vec2;
public anchor2: nape.geom.Vec2;
public impulse(): nape.geom.MatMN;
public bodyImpulse(body: nape.phys.Body): nape.geom.Vec3;
public visitBodies(lambda: (__0: nape.phys.Body) => void): void;
constructor(body1: nape.phys.Body, body2: nape.phys.Body, anchor1: nape.geom.Vec2, anchor2: nape.geom.Vec2);
}
export class PulleyJoint extends nape.constraint.Constraint {
public zpp_inner_zn: zpp_nape.constraint.ZPP_PulleyJoint;
public body1: nape.phys.Body;
public body2: nape.phys.Body;
public body3: nape.phys.Body;
public body4: nape.phys.Body;
public anchor1: nape.geom.Vec2;
public anchor2: nape.geom.Vec2;
public anchor3: nape.geom.Vec2;
public anchor4: nape.geom.Vec2;
public jointMin: number;
public jointMax: number;
public ratio: number;
public isSlack: () => boolean;
public impulse(): nape.geom.MatMN;
public bodyImpulse(body: nape.phys.Body): nape.geom.Vec3;
public visitBodies(lambda: (__0: nape.phys.Body) => void): void;
constructor(body1: nape.phys.Body, body2: nape.phys.Body, body3: nape.phys.Body, body4: nape.phys.Body, anchor1: nape.geom.Vec2, anchor2: nape.geom.Vec2, anchor3: nape.geom.Vec2, anchor4: nape.geom.Vec2, jointMin: number, jointMax: number, ratio?: number);
}
export class UserConstraint extends nape.constraint.Constraint {
public zpp_inner_zn: zpp_nape.constraint.ZPP_UserConstraint;
public __bindVec2(): nape.geom.Vec2;
public __copy(): nape.constraint.UserConstraint;
public __broken(): void;
public __validate(): void;
public __draw(debug: nape.util.Debug): void;
public __prepare(): void;
public __position(err: number[]): void;
public __velocity(err: number[]): void;
public __eff_mass(eff: number[]): void;
public __clamp(jAcc: number[]): void;
public __impulse(imp: number[], body: nape.phys.Body, out: nape.geom.Vec3): void;
public impulse(): nape.geom.MatMN;
public bodyImpulse(body: nape.phys.Body): nape.geom.Vec3;
public visitBodies(lambda: (__0: nape.phys.Body) => void): void;
public __invalidate(): void;
public __registerBody(oldBody: nape.phys.Body, newBody: nape.phys.Body): nape.phys.Body;
constructor(dimensions: number, velocityOnly?: boolean);
}
export class WeldJoint extends nape.constraint.Constraint {
public zpp_inner_zn: zpp_nape.constraint.ZPP_WeldJoint;
public body1: nape.phys.Body;
public body2: nape.phys.Body;
public anchor1: nape.geom.Vec2;
public anchor2: nape.geom.Vec2;
public phase: number;
public impulse(): nape.geom.MatMN;
public bodyImpulse(body: nape.phys.Body): nape.geom.Vec3;
public visitBodies(lambda: (__0: nape.phys.Body) => void): void;
constructor(body1: nape.phys.Body, body2: nape.phys.Body, anchor1: nape.geom.Vec2, anchor2: nape.geom.Vec2, phase?: number);
}
}
export module dynamics {
export class Arbiter {
public zpp_inner: zpp_nape.dynamics.ZPP_Arbiter;
public isSleeping: boolean;
public type: nape.dynamics.ArbiterType;
public isCollisionArbiter: () => boolean;
public isFluidArbiter: () => boolean;
public isSensorArbiter: () => boolean;
public collisionArbiter: nape.dynamics.CollisionArbiter;
public fluidArbiter: nape.dynamics.FluidArbiter;
public shape1: nape.shape.Shape;
public shape2: nape.shape.Shape;
public body1: nape.phys.Body;
public body2: nape.phys.Body;
public state: nape.callbacks.PreFlag;
public totalImpulse(body?: nape.phys.Body, freshOnly?: boolean): nape.geom.Vec3;
public toString(): String;
constructor();
}
export class ArbiterIterator {
public zpp_inner: nape.dynamics.ArbiterList;
public zpp_i: number;
public zpp_critical: boolean;
public zpp_next: nape.dynamics.ArbiterIterator;
public hasNext: () => boolean;
public next: () => nape.dynamics.Arbiter;
public static zpp_pool: nape.dynamics.ArbiterIterator;
public static get(list: nape.dynamics.ArbiterList): nape.dynamics.ArbiterIterator;
constructor();
}
export class ArbiterList {
public zpp_inner: zpp_nape.util.ZPP_ArbiterList;
public length: number;
public static fromArray(array: any[]): nape.dynamics.ArbiterList;
public zpp_gl(): number;
public zpp_vm(): void;
public has(obj: nape.dynamics.Arbiter): boolean;
public at(index: number): nape.dynamics.Arbiter;
public push(obj: nape.dynamics.Arbiter): boolean;
public unshift(obj: nape.dynamics.Arbiter): boolean;
public pop(): nape.dynamics.Arbiter;
public shift(): nape.dynamics.Arbiter;
public add(obj: nape.dynamics.Arbiter): boolean;
public remove(obj: nape.dynamics.Arbiter): boolean;
public clear(): void;
public empty(): boolean;
public iterator(): nape.dynamics.ArbiterIterator;
public copy(deep?: boolean): nape.dynamics.ArbiterList;
public merge(xs: nape.dynamics.ArbiterList): void;
public toString(): String;
public foreach(lambda: (__0: nape.dynamics.Arbiter) => void): nape.dynamics.ArbiterList;
public filter(lambda: (__0: nape.dynamics.Arbiter) => boolean): nape.dynamics.ArbiterList;
constructor();
}
export class ArbiterType {
public static COLLISION: nape.dynamics.ArbiterType;
public static SENSOR: nape.dynamics.ArbiterType;
public static FLUID: nape.dynamics.ArbiterType;
public toString(): String;
constructor();
}
export class CollisionArbiter extends nape.dynamics.Arbiter {
public contacts: nape.dynamics.ContactList;
public normal: nape.geom.Vec2;
public radius: number;
public referenceEdge1: nape.shape.Edge;
public referenceEdge2: nape.shape.Edge;
public elasticity: number;
public dynamicFriction: number;
public staticFriction: number;
public rollingFriction: number;
public firstVertex(): boolean;
public secondVertex(): boolean;
public normalImpulse(body?: nape.phys.Body, freshOnly?: boolean): nape.geom.Vec3;
public tangentImpulse(body?: nape.phys.Body, freshOnly?: boolean): nape.geom.Vec3;
public totalImpulse(body?: nape.phys.Body, freshOnly?: boolean): nape.geom.Vec3;
public rollingImpulse(body?: nape.phys.Body, freshOnly?: boolean): number;
constructor();
}
export class Contact {
public zpp_inner: zpp_nape.dynamics.ZPP_Contact;
public arbiter: nape.dynamics.CollisionArbiter;
public penetration: number;
public position: nape.geom.Vec2;
public fresh: boolean;
public friction: number;
public normalImpulse(body?: nape.phys.Body): nape.geom.Vec3;
public tangentImpulse(body?: nape.phys.Body): nape.geom.Vec3;
public rollingImpulse(body?: nape.phys.Body): number;
public totalImpulse(body?: nape.phys.Body): nape.geom.Vec3;
public toString(): String;
constructor();
}
export class ContactIterator {
public zpp_inner: nape.dynamics.ContactList;
public zpp_i: number;
public zpp_critical: boolean;
public zpp_next: nape.dynamics.ContactIterator;
public hasNext: () => boolean;
public next: () => nape.dynamics.Contact;
public static zpp_pool: nape.dynamics.ContactIterator;
public static get(list: nape.dynamics.ContactList): nape.dynamics.ContactIterator;
constructor();
}
export class ContactList {
public zpp_inner: zpp_nape.util.ZPP_ContactList;
public length: number;
public add: (obj: nape.dynamics.Contact) => boolean;
public empty: () => boolean;
public iterator: () => nape.dynamics.ContactIterator;
public foreach: (lambda: (__0: nape.dynamics.Contact) => void) => nape.dynamics.ContactList;
public static fromArray(array: any[]): nape.dynamics.ContactList;
public has(obj: nape.dynamics.Contact): boolean;
public at(index: number): nape.dynamics.Contact;
public push(obj: nape.dynamics.Contact): boolean;
public unshift(obj: nape.dynamics.Contact): boolean;
public pop(): nape.dynamics.Contact;
public shift(): nape.dynamics.Contact;
public remove(obj: nape.dynamics.Contact): boolean;
public clear(): void;
public copy(deep?: boolean): nape.dynamics.ContactList;
public merge(xs: nape.dynamics.ContactList): void;
public toString(): String;
public filter(lambda: (__0: nape.dynamics.Contact) => boolean): nape.dynamics.ContactList;
constructor();
}
export class FluidArbiter extends nape.dynamics.Arbiter {
public position: nape.geom.Vec2;
public overlap: number;
public buoyancyImpulse(body?: nape.phys.Body): nape.geom.Vec3;
public dragImpulse(body?: nape.phys.Body): nape.geom.Vec3;
public totalImpulse(body?: nape.phys.Body, freshOnly?: boolean): nape.geom.Vec3;
constructor();
}
export class InteractionFilter {
public zpp_inner: zpp_nape.dynamics.ZPP_InteractionFilter;
public userData: any;
public shapes: nape.shape.ShapeList;
public collisionGroup: number;
public collisionMask: number;
public sensorGroup: number;
public sensorMask: number;
public fluidGroup: number;
public fluidMask: number;
public shouldCollide(filter: nape.dynamics.InteractionFilter): boolean;
public shouldSense(filter: nape.dynamics.InteractionFilter): boolean;
public shouldFlow(filter: nape.dynamics.InteractionFilter): boolean;
public copy(): nape.dynamics.InteractionFilter;
public toString(): String;
constructor(collisionGroup?: number, collisionMask?: number, sensorGroup?: number, sensorMask?: number, fluidGroup?: number, fluidMask?: number);
}
export class InteractionGroup {
public zpp_inner: zpp_nape.dynamics.ZPP_InteractionGroup;
public group: nape.dynamics.InteractionGroup;
public ignore: boolean;
public interactors: nape.phys.InteractorList;
public groups: nape.dynamics.InteractionGroupList;
public toString(): String;
constructor(ignore?: boolean);
}
export class InteractionGroupIterator {
public zpp_inner: nape.dynamics.InteractionGroupList;
public zpp_i: number;
public zpp_critical: boolean;
public zpp_next: nape.dynamics.InteractionGroupIterator;
public hasNext: () => boolean;
public next: () => nape.dynamics.InteractionGroup;
public static zpp_pool: nape.dynamics.InteractionGroupIterator;
public static get(list: nape.dynamics.InteractionGroupList): nape.dynamics.InteractionGroupIterator;
constructor();
}
export class InteractionGroupList {
public zpp_inner: zpp_nape.util.ZPP_InteractionGroupList;
public length: number;
public add: (obj: nape.dynamics.InteractionGroup) => boolean;
public empty: () => boolean;
public iterator: () => nape.dynamics.InteractionGroupIterator;
public foreach: (lambda: (__0: nape.dynamics.InteractionGroup) => void) => nape.dynamics.InteractionGroupList;
public static fromArray(array: any[]): nape.dynamics.InteractionGroupList;
public has(obj: nape.dynamics.InteractionGroup): boolean;
public at(index: number): nape.dynamics.InteractionGroup;
public push(obj: nape.dynamics.InteractionGroup): boolean;
public unshift(obj: nape.dynamics.InteractionGroup): boolean;
public pop(): nape.dynamics.InteractionGroup;
public shift(): nape.dynamics.InteractionGroup;
public remove(obj: nape.dynamics.InteractionGroup): boolean;
public clear(): void;
public copy(deep?: boolean): nape.dynamics.InteractionGroupList;
public merge(xs: nape.dynamics.InteractionGroupList): void;
public toString(): String;
public filter(lambda: (__0: nape.dynamics.InteractionGroup) => boolean): nape.dynamics.InteractionGroupList;
constructor();
}
}
export module geom {
export class AABB {
public zpp_inner: zpp_nape.geom.ZPP_AABB;
public min: nape.geom.Vec2;
public max: nape.geom.Vec2;
public x: number;
public y: number;
public width: number;
public height: number;
public copy(): nape.geom.AABB;
public toString(): String;
constructor(x?: number, y?: number, width?: number, height?: number);
}
export class ConvexResult {
public zpp_inner: zpp_nape.geom.ZPP_ConvexRayResult;
public normal: nape.geom.Vec2;
public position: nape.geom.Vec2;
public toi: number;
public shape: nape.shape.Shape;
public dispose: () => void;
public toString(): String;
constructor();
}
export class ConvexResultIterator {
public zpp_inner: nape.geom.ConvexResultList;
public zpp_i: number;
public zpp_critical: boolean;
public zpp_next: nape.geom.ConvexResultIterator;
public hasNext: () => boolean;
public next: () => nape.geom.ConvexResult;
public static zpp_pool: nape.geom.ConvexResultIterator;
public static get(list: nape.geom.ConvexResultList): nape.geom.ConvexResultIterator;
constructor();
}
export class ConvexResultList {
public zpp_inner: zpp_nape.util.ZPP_ConvexResultList;
public length: number;
public add: (obj: nape.geom.ConvexResult) => boolean;
public empty: () => boolean;
public iterator: () => nape.geom.ConvexResultIterator;
public foreach: (lambda: (__0: nape.geom.ConvexResult) => void) => nape.geom.ConvexResultList;
public static fromArray(array: any[]): nape.geom.ConvexResultList;
public has(obj: nape.geom.ConvexResult): boolean;
public at(index: number): nape.geom.ConvexResult;
public push(obj: nape.geom.ConvexResult): boolean;
public unshift(obj: nape.geom.ConvexResult): boolean;
public pop(): nape.geom.ConvexResult;
public shift(): nape.geom.ConvexResult;
public remove(obj: nape.geom.ConvexResult): boolean;
public clear(): void;
public copy(deep?: boolean): nape.geom.ConvexResultList;
public merge(xs: nape.geom.ConvexResultList): void;
public toString(): String;
public filter(lambda: (__0: nape.geom.ConvexResult) => boolean): nape.geom.ConvexResultList;
constructor();
}
export class Geom {
public static distanceBody(body1: nape.phys.Body, body2: nape.phys.Body, out1: nape.geom.Vec2, out2: nape.geom.Vec2): number;
public static distance(shape1: nape.shape.Shape, shape2: nape.shape.Shape, out1: nape.geom.Vec2, out2: nape.geom.Vec2): number;
public static intersectsBody(body1: nape.phys.Body, body2: nape.phys.Body): boolean;
public static intersects(shape1: nape.shape.Shape, shape2: nape.shape.Shape): boolean;
public static contains(shape1: nape.shape.Shape, shape2: nape.shape.Shape): boolean;
}
export class GeomPoly {
public zpp_pool: nape.geom.GeomPoly;
public zpp_disp: boolean;
public zpp_inner: zpp_nape.geom.ZPP_GeomPoly;
public empty: () => boolean;
public iterator: () => nape.geom.GeomVertexIterator;
public forwardIterator: () => nape.geom.GeomVertexIterator;
public backwardsIterator: () => nape.geom.GeomVertexIterator;
public current: () => nape.geom.Vec2;
public skipBackwards: (times: number) => nape.geom.GeomPoly;
public isClockwise: () => boolean;
public isSimple: () => boolean;
public isMonotone: () => boolean;
public isDegenerate: () => boolean;
public static get(vertices?: any): nape.geom.GeomPoly;
public size(): number;
public push(vertex: nape.geom.Vec2): nape.geom.GeomPoly;
public pop(): nape.geom.GeomPoly;
public unshift(vertex: nape.geom.Vec2): nape.geom.GeomPoly;
public shift(): nape.geom.GeomPoly;
public skipForward(times: number): nape.geom.GeomPoly;
public erase(count: number): nape.geom.GeomPoly;
public clear(): nape.geom.GeomPoly;
public copy(): nape.geom.GeomPoly;
public dispose(): void;
public toString(): String;
public area(): number;
public winding(): nape.geom.Winding;
public contains(point: nape.geom.Vec2): boolean;
public isConvex(): boolean;
public simplify(epsilon: number): nape.geom.GeomPoly;
public simpleDecomposition(output?: nape.geom.GeomPolyList): nape.geom.GeomPolyList;
public monotoneDecomposition(output?: nape.geom.GeomPolyList): nape.geom.GeomPolyList;
public convexDecomposition(delaunay?: boolean, output?: nape.geom.GeomPolyList): nape.geom.GeomPolyList;
public triangularDecomposition(delaunay?: boolean, output?: nape.geom.GeomPolyList): nape.geom.GeomPolyList;
public inflate(inflation: number): nape.geom.GeomPoly;
public cut(start: nape.geom.Vec2, end: nape.geom.Vec2, boundedStart?: boolean, boundedEnd?: boolean, output?: nape.geom.GeomPolyList): nape.geom.GeomPolyList;
public transform(matrix: nape.geom.Mat23): nape.geom.GeomPoly;
public bounds(): nape.geom.AABB;
public top(): nape.geom.Vec2;
public bottom(): nape.geom.Vec2;
public left(): nape.geom.Vec2;
public right(): nape.geom.Vec2;
constructor(vertices?: any);
}
export class GeomPolyIterator {
public zpp_inner: nape.geom.GeomPolyList;
public zpp_i: number;
public zpp_critical: boolean;
public zpp_next: nape.geom.GeomPolyIterator;
public hasNext: () => boolean;
public next: () => nape.geom.GeomPoly;
public static zpp_pool: nape.geom.GeomPolyIterator;
public static get(list: nape.geom.GeomPolyList): nape.geom.GeomPolyIterator;
constructor();
}
export class GeomPolyList {
public zpp_inner: zpp_nape.util.ZPP_GeomPolyList;
public length: number;
public add: (obj: nape.geom.GeomPoly) => boolean;
public empty: () => boolean;
public iterator: () => nape.geom.GeomPolyIterator;
public foreach: (lambda: (__0: nape.geom.GeomPoly) => void) => nape.geom.GeomPolyList;
public static fromArray(array: any[]): nape.geom.GeomPolyList;
public has(obj: nape.geom.GeomPoly): boolean;
public at(index: number): nape.geom.GeomPoly;
public push(obj: nape.geom.GeomPoly): boolean;
public unshift(obj: nape.geom.GeomPoly): boolean;
public pop(): nape.geom.GeomPoly;
public shift(): nape.geom.GeomPoly;
public remove(obj: nape.geom.GeomPoly): boolean;
public clear(): void;
public copy(deep?: boolean): nape.geom.GeomPolyList;
public merge(xs: nape.geom.GeomPolyList): void;
public toString(): String;
public filter(lambda: (__0: nape.geom.GeomPoly) => boolean): nape.geom.GeomPolyList;
constructor();
}
export class GeomVertexIterator {
public zpp_inner: zpp_nape.geom.ZPP_GeomVertexIterator;
public hasNext(): boolean;
public next(): nape.geom.Vec2;
constructor();
}
export type IsoFunctionDef = (__0: number, __1: number) => number;
export class MarchingSquares {
public static run(iso: nape.geom.IsoFunctionDef, bounds: nape.geom.AABB, cellsize: nape.geom.Vec2, quality?: number, subgrid?: nape.geom.Vec2, combine?: boolean, output?: nape.geom.GeomPolyList): nape.geom.GeomPolyList;
}
export class Mat23 {
public zpp_inner: zpp_nape.geom.ZPP_Mat23;
public a: number;
public b: number;
public c: number;
public d: number;
public tx: number;
public ty: number;
public reset: () => nape.geom.Mat23;
public determinant: number;
public static rotation(angle: number): nape.geom.Mat23;
public static translation(tx: number, ty: number): nape.geom.Mat23;
public static scale(sx: number, sy: number): nape.geom.Mat23;
public copy(): nape.geom.Mat23;
public set(matrix: nape.geom.Mat23): nape.geom.Mat23;
public setAs(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number): nape.geom.Mat23;
public singular(): boolean;
public inverse(): nape.geom.Mat23;
public transpose(): nape.geom.Mat23;
public concat(matrix: nape.geom.Mat23): nape.geom.Mat23;
public transform(point: nape.geom.Vec2, noTranslation?: boolean, weak?: boolean): nape.geom.Vec2;
public inverseTransform(point: nape.geom.Vec2, noTranslation?: boolean, weak?: boolean): nape.geom.Vec2;
public toString(): String;
public equiorthogonal(): boolean;
public orthogonal(): boolean;
public equiorthogonalise(): nape.geom.Mat23;
public orthogonalise(): nape.geom.Mat23;
constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number);
}
export class MatMN {
public zpp_inner: zpp_nape.geom.ZPP_MatMN;
public rows: number;
public cols: number;
public x: (row: number, col: number) => number;
public setx: (row: number, col: number, x: number) => number;
public toString(): String;
public transpose(): nape.geom.MatMN;
public mul(matrix: nape.geom.MatMN): nape.geom.MatMN;
constructor(rows: number, cols: number);
}
export class Ray {
public zpp_inner: zpp_nape.geom.ZPP_Ray;
public userData: any;
public origin: nape.geom.Vec2;
public direction: nape.geom.Vec2;
public maxDistance: number;
public static fromSegment(start: nape.geom.Vec2, end: nape.geom.Vec2): nape.geom.Ray;
public aabb(): nape.geom.AABB;
public at(distance: number, weak?: boolean): nape.geom.Vec2;
public copy(): nape.geom.Ray;
constructor(origin: nape.geom.Vec2, direction: nape.geom.Vec2);
}
export class RayResult {
public zpp_inner: zpp_nape.geom.ZPP_ConvexRayResult;
public normal: nape.geom.Vec2;
public distance: number;
public inner: boolean;
public shape: nape.shape.Shape;
public dispose: () => void;
public toString(): String;
constructor();
}
export class RayResultIterator {
public zpp_inner: nape.geom.RayResultList;
public zpp_i: number;
public zpp_critical: boolean;
public zpp_next: nape.geom.RayResultIterator;
public hasNext: () => boolean;
public next: () => nape.geom.RayResult;
public static zpp_pool: nape.geom.RayResultIterator;
public static get(list: nape.geom.RayResultList): nape.geom.RayResultIterator;
constructor();
}
export class RayResultList {
public zpp_inner: zpp_nape.util.ZPP_RayResultList;
public length: number;
public add: (obj: nape.geom.RayResult) => boolean;
public empty: () => boolean;
public iterator: () => nape.geom.RayResultIterator;
public foreach: (lambda: (__0: nape.geom.RayResult) => void) => nape.geom.RayResultList;
public static fromArray(array: any[]): nape.geom.RayResultList;
public has(obj: nape.geom.RayResult): boolean;
public at(index: number): nape.geom.RayResult;
public push(obj: nape.geom.RayResult): boolean;
public unshift(obj: nape.geom.RayResult): boolean;
public pop(): nape.geom.RayResult;
public shift(): nape.geom.RayResult;
public remove(obj: nape.geom.RayResult): boolean;
public clear(): void;
public copy(deep?: boolean): nape.geom.RayResultList;
public merge(xs: nape.geom.RayResultList): void;
public toString(): String;
public filter(lambda: (__0: nape.geom.RayResult) => boolean): nape.geom.RayResultList;
constructor();
}
export class Vec2 {
public zpp_inner: zpp_nape.geom.ZPP_Vec2;
public zpp_pool: nape.geom.Vec2;
public zpp_disp: boolean;
public dispose: () => void;
public copy: (weak?: boolean) => nape.geom.Vec2;
public x: number;
public y: number;
public length: number;
public set: (vector: nape.geom.Vec2) => nape.geom.Vec2;
public setxy: (x: number, y: number) => nape.geom.Vec2;
public angle: number;
public static weak: (x?: number, y?: number) => nape.geom.Vec2;
public static get: (x?: number, y?: number, weak?: boolean) => nape.geom.Vec2;
public static dsq: (a: nape.geom.Vec2, b: nape.geom.Vec2) => number;
public static distance: (a: nape.geom.Vec2, b: nape.geom.Vec2) => number;
public static fromPolar(length: number, angle: number, weak?: boolean): nape.geom.Vec2;
public lsq(): number;
public rotate(angle: number): nape.geom.Vec2;
public reflect(vec: nape.geom.Vec2, weak?: boolean): nape.geom.Vec2;
public normalise(): nape.geom.Vec2;
public unit(weak?: boolean): nape.geom.Vec2;
public add(vector: nape.geom.Vec2, weak?: boolean): nape.geom.Vec2;
public addMul(vector: nape.geom.Vec2, scalar: number, weak?: boolean): nape.geom.Vec2;
public sub(vector: nape.geom.Vec2, weak?: boolean): nape.geom.Vec2;
public mul(scalar: number, weak?: boolean): nape.geom.Vec2;
public addeq(vector: nape.geom.Vec2): nape.geom.Vec2;
public subeq(vector: nape.geom.Vec2): nape.geom.Vec2;
public muleq(scalar: number): nape.geom.Vec2;
public dot(vector: nape.geom.Vec2): number;
public cross(vector: nape.geom.Vec2): number;
public perp(weak?: boolean): nape.geom.Vec2;
public toString(): String;
constructor(x?: number, y?: number);
}
export class Vec2Iterator {
public zpp_inner: nape.geom.Vec2List;
public zpp_i: number;
public zpp_critical: boolean;
public zpp_next: nape.geom.Vec2Iterator;
public hasNext: () => boolean;
public next: () => nape.geom.Vec2;
public static zpp_pool: nape.geom.Vec2Iterator;
public static get(list: nape.geom.Vec2List): nape.geom.Vec2Iterator;
constructor();
}
export class Vec2List {
public zpp_inner: zpp_nape.util.ZPP_Vec2List;
public length: number;
public static fromArray(array: any[]): nape.geom.Vec2List;
public zpp_gl(): number;
public zpp_vm(): void;
public has(obj: nape.geom.Vec2): boolean;
public at(index: number): nape.geom.Vec2;
public push(obj: nape.geom.Vec2): boolean;
public unshift(obj: nape.geom.Vec2): boolean;
public pop(): nape.geom.Vec2;
public shift(): nape.geom.Vec2;
public add(obj: nape.geom.Vec2): boolean;
public remove(obj: nape.geom.Vec2): boolean;
public clear(): void;
public empty(): boolean;
public iterator(): nape.geom.Vec2Iterator;
public copy(deep?: boolean): nape.geom.Vec2List;
public merge(xs: nape.geom.Vec2List): void;
public toString(): String;
public foreach(lambda: (__0: nape.geom.Vec2) => void): nape.geom.Vec2List;
public filter(lambda: (__0: nape.geom.Vec2) => boolean): nape.geom.Vec2List;
constructor();
}
export class Vec3 {
public zpp_inner: zpp_nape.geom.ZPP_Vec3;
public zpp_pool: nape.geom.Vec3;
public zpp_disp: boolean;
public x: number;
public y: number;
public z: number;
public length: number;
public static get(x?: number, y?: number, z?: number): nape.geom.Vec3;
public dispose(): void;
public lsq(): number;
public set(vector: nape.geom.Vec3): nape.geom.Vec3;
public setxyz(x: number, y: number, z: number): nape.geom.Vec3;
public xy(weak?: boolean): nape.geom.Vec2;
public toString(): String;
constructor(x?: number, y?: number, z?: number);
}
export class Winding {
public static UNDEFINED: nape.geom.Winding;
public static CLOCKWISE: nape.geom.Winding;
public static ANTICLOCKWISE: nape.geom.Winding;
public toString(): String;
constructor();
}
}
export module phys {
export class Interactor {
public zpp_inner_i: zpp_nape.phys.ZPP_Interactor;
public id: number;
public userData: any;
public isShape: () => boolean;
public isBody: () => boolean;
public isCompound: () => boolean;
public castShape: nape.shape.Shape;
public castBody: nape.phys.Body;
public castCompound: nape.phys.Compound;
public group: nape.dynamics.InteractionGroup;
public cbTypes: nape.callbacks.CbTypeList;
public static zpp_internalAlloc: boolean;
public toString(): String;
constructor();
}
export class Body extends nape.phys.Interactor {
public zpp_inner: zpp_nape.phys.ZPP_Body;
public debugDraw: boolean;
public type: nape.phys.BodyType;
public isBullet: boolean;
public disableCCD: boolean;
public isStatic: () => boolean;
public isDynamic: () => boolean;
public isKinematic: () => boolean;
public shapes: nape.shape.ShapeList;
public compound: nape.phys.Compound;
public space: nape.space.Space;
public arbiters: nape.dynamics.ArbiterList;
public isSleeping: boolean;
public constraints: nape.constraint.ConstraintList;
public position: nape.geom.Vec2;
public velocity: nape.geom.Vec2;
public kinematicVel: nape.geom.Vec2;
public surfaceVel: nape.geom.Vec2;
public force: nape.geom.Vec2;
public constraintVelocity: nape.geom.Vec3;
public rotation: number;
public angularVel: number;
public kinAngVel: number;
public torque: number;
public bounds: nape.geom.AABB;
public allowMovement: boolean;
public allowRotation: boolean;
public massMode: nape.phys.MassMode;
public constraintMass: number;
public mass: number;
public gravMassMode: nape.phys.Grav