118a4a92d6
- Add multi local game
- Some minor changes in html/css
Django
- add path for /game and /multiLocalGamePage
- add template for multiLocalGame
1604 lines
71 KiB
TypeScript
1604 lines
71 KiB
TypeScript
declare module "utils/EventTarget" {
|
|
export class EventTarget {
|
|
private _listeners;
|
|
addEventListener(type: string, listener: Function): EventTarget;
|
|
hasEventListener(type: string, listener: Function): boolean;
|
|
hasAnyEventListener(type: string): boolean;
|
|
removeEventListener(type: string, listener: Function): EventTarget;
|
|
dispatchEvent(event: any): EventTarget;
|
|
}
|
|
}
|
|
declare module "math/Quaternion" {
|
|
import { Vec3 } from "math/Vec3";
|
|
export class Quaternion {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
w: number;
|
|
constructor(x?: number, y?: number, z?: number, w?: number);
|
|
set(x: number, y: number, z: number, w: number): Quaternion;
|
|
toString(): string;
|
|
toArray(): [number, number, number, number];
|
|
setFromAxisAngle(vector: Vec3, angle: number): Quaternion;
|
|
toAxisAngle(targetAxis?: Vec3): [Vec3, number];
|
|
setFromVectors(u: Vec3, v: Vec3): Quaternion;
|
|
mult(quat: Quaternion, target?: Quaternion): Quaternion;
|
|
inverse(target?: Quaternion): Quaternion;
|
|
conjugate(target?: Quaternion): Quaternion;
|
|
normalize(): Quaternion;
|
|
normalizeFast(): Quaternion;
|
|
vmult(v: Vec3, target?: Vec3): Vec3;
|
|
copy(quat: Quaternion): Quaternion;
|
|
toEuler(target: Vec3, order?: string): void;
|
|
setFromEuler(x: number, y: number, z: number, order?: string): Quaternion;
|
|
clone(): Quaternion;
|
|
slerp(toQuat: Quaternion, t: number, target?: Quaternion): Quaternion;
|
|
integrate(angularVelocity: Vec3, dt: number, angularFactor: Vec3, target?: Quaternion): Quaternion;
|
|
}
|
|
}
|
|
declare module "math/Mat3" {
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Quaternion } from "math/Quaternion";
|
|
export class Mat3 {
|
|
elements: number[];
|
|
constructor(elements?: number[]);
|
|
identity(): void;
|
|
setZero(): void;
|
|
setTrace(vector: Vec3): void;
|
|
getTrace(target?: Vec3): Vec3;
|
|
vmult(v: Vec3, target?: Vec3): Vec3;
|
|
smult(s: number): void;
|
|
mmult(matrix: Mat3, target?: Mat3): Mat3;
|
|
scale(vector: Vec3, target?: Mat3): Mat3;
|
|
solve(b: Vec3, target?: Vec3): Vec3;
|
|
e(row: number, column: number): number;
|
|
e(row: number, column: number, value: number): void;
|
|
copy(matrix: Mat3): Mat3;
|
|
toString(): string;
|
|
reverse(target?: Mat3): Mat3;
|
|
setRotationFromQuaternion(q: Quaternion): Mat3;
|
|
transpose(target?: Mat3): Mat3;
|
|
}
|
|
}
|
|
declare module "math/Vec3" {
|
|
import { Mat3 } from "math/Mat3";
|
|
export class Vec3 {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
static ZERO: Vec3;
|
|
static UNIT_X: Vec3;
|
|
static UNIT_Y: Vec3;
|
|
static UNIT_Z: Vec3;
|
|
constructor(x?: number, y?: number, z?: number);
|
|
cross(vector: Vec3, target?: Vec3): Vec3;
|
|
set(x: number, y: number, z: number): Vec3;
|
|
setZero(): void;
|
|
vadd(vector: Vec3): Vec3;
|
|
vadd(vector: Vec3, target: Vec3): void;
|
|
vsub(vector: Vec3): Vec3;
|
|
vsub(vector: Vec3, target: Vec3): void;
|
|
crossmat(): Mat3;
|
|
normalize(): number;
|
|
unit(target?: Vec3): Vec3;
|
|
length(): number;
|
|
lengthSquared(): number;
|
|
distanceTo(p: Vec3): number;
|
|
distanceSquared(p: Vec3): number;
|
|
scale(scalar: number, target?: Vec3): Vec3;
|
|
vmul(vector: Vec3, target?: Vec3): Vec3;
|
|
addScaledVector(scalar: number, vector: Vec3, target?: Vec3): Vec3;
|
|
dot(vector: Vec3): number;
|
|
isZero(): boolean;
|
|
negate(target?: Vec3): Vec3;
|
|
tangents(t1: Vec3, t2: Vec3): void;
|
|
toString(): string;
|
|
toArray(): [number, number, number];
|
|
copy(vector: Vec3): Vec3;
|
|
lerp(vector: Vec3, t: number, target: Vec3): void;
|
|
almostEquals(vector: Vec3, precision?: number): boolean;
|
|
almostZero(precision?: number): boolean;
|
|
isAntiparallelTo(vector: Vec3, precision?: number): boolean;
|
|
clone(): Vec3;
|
|
}
|
|
}
|
|
declare module "math/Transform" {
|
|
import { Vec3 } from "math/Vec3";
|
|
import { Quaternion } from "math/Quaternion";
|
|
export type TransformOptions = ConstructorParameters<typeof Transform>[0];
|
|
export class Transform {
|
|
position: Vec3;
|
|
quaternion: Quaternion;
|
|
constructor(options?: {
|
|
position?: Vec3;
|
|
quaternion?: Quaternion;
|
|
});
|
|
pointToLocal(worldPoint: Vec3, result?: Vec3): Vec3;
|
|
pointToWorld(localPoint: Vec3, result?: Vec3): Vec3;
|
|
vectorToWorldFrame(localVector: Vec3, result?: Vec3): Vec3;
|
|
static pointToLocalFrame(position: Vec3, quaternion: Quaternion, worldPoint: Vec3, result?: Vec3): Vec3;
|
|
static pointToWorldFrame(position: Vec3, quaternion: Quaternion, localPoint: Vec3, result?: Vec3): Vec3;
|
|
static vectorToWorldFrame(quaternion: Quaternion, localVector: Vec3, result?: Vec3): Vec3;
|
|
static vectorToLocalFrame(position: Vec3, quaternion: Quaternion, worldVector: Vec3, result?: Vec3): Vec3;
|
|
}
|
|
}
|
|
declare module "material/Material" {
|
|
export type MaterialOptions = ConstructorParameters<typeof Material>[0];
|
|
export class Material {
|
|
name: string;
|
|
id: number;
|
|
friction: number;
|
|
restitution: number;
|
|
static idCounter: number;
|
|
constructor(options?: {
|
|
friction?: number;
|
|
restitution?: number;
|
|
} | string);
|
|
}
|
|
}
|
|
declare module "shapes/Shape" {
|
|
import type { Vec3 } from "math/Vec3";
|
|
import type { Quaternion } from "math/Quaternion";
|
|
import type { Body } from "objects/Body";
|
|
import type { Material } from "material/Material";
|
|
export const SHAPE_TYPES: {
|
|
readonly SPHERE: 1;
|
|
readonly PLANE: 2;
|
|
readonly BOX: 4;
|
|
readonly COMPOUND: 8;
|
|
readonly CONVEXPOLYHEDRON: 16;
|
|
readonly HEIGHTFIELD: 32;
|
|
readonly PARTICLE: 64;
|
|
readonly CYLINDER: 128;
|
|
readonly TRIMESH: 256;
|
|
};
|
|
export type ShapeType = typeof SHAPE_TYPES[keyof typeof SHAPE_TYPES];
|
|
export type ShapeOptions = ConstructorParameters<typeof Shape>[0];
|
|
export class Shape {
|
|
id: number;
|
|
type: ShapeType | 0;
|
|
boundingSphereRadius: number;
|
|
collisionResponse: boolean;
|
|
collisionFilterGroup: number;
|
|
collisionFilterMask: number;
|
|
material: Material | null;
|
|
body: Body | null;
|
|
static idCounter: number;
|
|
static types: {
|
|
readonly SPHERE: 1;
|
|
readonly PLANE: 2;
|
|
readonly BOX: 4;
|
|
readonly COMPOUND: 8;
|
|
readonly CONVEXPOLYHEDRON: 16;
|
|
readonly HEIGHTFIELD: 32;
|
|
readonly PARTICLE: 64;
|
|
readonly CYLINDER: 128;
|
|
readonly TRIMESH: 256;
|
|
};
|
|
constructor(options?: {
|
|
type?: ShapeType;
|
|
collisionResponse?: boolean;
|
|
collisionFilterGroup?: number;
|
|
collisionFilterMask?: number;
|
|
material?: Material;
|
|
});
|
|
updateBoundingSphereRadius(): void;
|
|
volume(): number;
|
|
calculateLocalInertia(mass: number, target: Vec3): void;
|
|
calculateWorldAABB(pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
|
|
}
|
|
}
|
|
declare module "collision/RaycastResult" {
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Body } from "objects/Body";
|
|
import type { Shape } from "shapes/Shape";
|
|
export class RaycastResult {
|
|
rayFromWorld: Vec3;
|
|
rayToWorld: Vec3;
|
|
hitNormalWorld: Vec3;
|
|
hitPointWorld: Vec3;
|
|
hasHit: boolean;
|
|
shape: Shape | null;
|
|
body: Body | null;
|
|
hitFaceIndex: number;
|
|
distance: number;
|
|
shouldStop: boolean;
|
|
constructor();
|
|
reset(): void;
|
|
abort(): void;
|
|
set(rayFromWorld: Vec3, rayToWorld: Vec3, hitNormalWorld: Vec3, hitPointWorld: Vec3, shape: Shape, body: Body, distance: number): void;
|
|
}
|
|
}
|
|
declare module "shapes/Sphere" {
|
|
import { Shape } from "shapes/Shape";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Quaternion } from "math/Quaternion";
|
|
export class Sphere extends Shape {
|
|
radius: number;
|
|
constructor(radius: number);
|
|
calculateLocalInertia(mass: number, target?: Vec3): Vec3;
|
|
volume(): number;
|
|
updateBoundingSphereRadius(): void;
|
|
calculateWorldAABB(pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
|
|
}
|
|
}
|
|
declare module "shapes/ConvexPolyhedron" {
|
|
import { Shape } from "shapes/Shape";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Quaternion } from "math/Quaternion";
|
|
export type ConvexPolyhedronContactPoint = {
|
|
point: Vec3;
|
|
normal: Vec3;
|
|
depth: number;
|
|
};
|
|
export class ConvexPolyhedron extends Shape {
|
|
vertices: Vec3[];
|
|
faces: number[][];
|
|
faceNormals: Vec3[];
|
|
worldVertices: Vec3[];
|
|
worldVerticesNeedsUpdate: boolean;
|
|
worldFaceNormals: Vec3[];
|
|
worldFaceNormalsNeedsUpdate: boolean;
|
|
uniqueAxes: Vec3[] | null;
|
|
uniqueEdges: Vec3[];
|
|
constructor(props?: {
|
|
vertices?: Vec3[];
|
|
faces?: number[][];
|
|
normals?: Vec3[];
|
|
axes?: Vec3[];
|
|
boundingSphereRadius?: number;
|
|
});
|
|
computeEdges(): void;
|
|
computeNormals(): void;
|
|
getFaceNormal(i: number, target: Vec3): void;
|
|
static computeNormal(va: Vec3, vb: Vec3, vc: Vec3, target: Vec3): void;
|
|
clipAgainstHull(posA: Vec3, quatA: Quaternion, hullB: ConvexPolyhedron, posB: Vec3, quatB: Quaternion, separatingNormal: Vec3, minDist: number, maxDist: number, result: ConvexPolyhedronContactPoint[]): void;
|
|
findSeparatingAxis(hullB: ConvexPolyhedron, posA: Vec3, quatA: Quaternion, posB: Vec3, quatB: Quaternion, target: Vec3, faceListA?: number[] | null, faceListB?: number[] | null): boolean;
|
|
testSepAxis(axis: Vec3, hullB: ConvexPolyhedron, posA: Vec3, quatA: Quaternion, posB: Vec3, quatB: Quaternion): number | false;
|
|
calculateLocalInertia(mass: number, target: Vec3): void;
|
|
getPlaneConstantOfFace(face_i: number): number;
|
|
clipFaceAgainstHull(separatingNormal: Vec3, posA: Vec3, quatA: Quaternion, worldVertsB1: Vec3[], minDist: number, maxDist: number, result: ConvexPolyhedronContactPoint[]): void;
|
|
clipFaceAgainstPlane(inVertices: Vec3[], outVertices: Vec3[], planeNormal: Vec3, planeConstant: number): Vec3[];
|
|
computeWorldVertices(position: Vec3, quat: Quaternion): void;
|
|
computeLocalAABB(aabbmin: Vec3, aabbmax: Vec3): void;
|
|
computeWorldFaceNormals(quat: Quaternion): void;
|
|
updateBoundingSphereRadius(): void;
|
|
calculateWorldAABB(pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
|
|
volume(): number;
|
|
getAveragePointLocal(target?: Vec3): Vec3;
|
|
transformAllPoints(offset: Vec3, quat: Quaternion): void;
|
|
pointIsInside(p: Vec3): 1 | -1 | false;
|
|
static project(shape: ConvexPolyhedron, axis: Vec3, pos: Vec3, quat: Quaternion, result: number[]): void;
|
|
}
|
|
}
|
|
declare module "shapes/Box" {
|
|
import { Shape } from "shapes/Shape";
|
|
import { Vec3 } from "math/Vec3";
|
|
import { ConvexPolyhedron } from "shapes/ConvexPolyhedron";
|
|
import type { Quaternion } from "math/Quaternion";
|
|
export class Box extends Shape {
|
|
halfExtents: Vec3;
|
|
convexPolyhedronRepresentation: ConvexPolyhedron;
|
|
constructor(halfExtents: Vec3);
|
|
updateConvexPolyhedronRepresentation(): void;
|
|
calculateLocalInertia(mass: number, target?: Vec3): Vec3;
|
|
static calculateInertia(halfExtents: Vec3, mass: number, target: Vec3): void;
|
|
getSideNormals(sixTargetVectors: Vec3[], quat: Quaternion): Vec3[];
|
|
volume(): number;
|
|
updateBoundingSphereRadius(): void;
|
|
forEachWorldCorner(pos: Vec3, quat: Quaternion, callback: (x: number, y: number, z: number) => void): void;
|
|
calculateWorldAABB(pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
|
|
}
|
|
}
|
|
declare module "shapes/Plane" {
|
|
import { Shape } from "shapes/Shape";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Quaternion } from "math/Quaternion";
|
|
export class Plane extends Shape {
|
|
worldNormal: Vec3;
|
|
worldNormalNeedsUpdate: boolean;
|
|
boundingSphereRadius: number;
|
|
constructor();
|
|
computeWorldNormal(quat: Quaternion): void;
|
|
calculateLocalInertia(mass: number, target?: Vec3): Vec3;
|
|
volume(): number;
|
|
calculateWorldAABB(pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
|
|
updateBoundingSphereRadius(): void;
|
|
}
|
|
}
|
|
declare module "utils/Utils" {
|
|
export class Utils {
|
|
static defaults(options: Record<string, any> | undefined, defaults: Record<string, any>): Record<string, any>;
|
|
}
|
|
}
|
|
declare module "shapes/Heightfield" {
|
|
import { Shape } from "shapes/Shape";
|
|
import { ConvexPolyhedron } from "shapes/ConvexPolyhedron";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { AABB } from "collision/AABB";
|
|
import type { Quaternion } from "math/Quaternion";
|
|
export type HeightfieldOptions = ConstructorParameters<typeof Heightfield>[1];
|
|
type HeightfieldPillar = {
|
|
convex: any;
|
|
offset: any;
|
|
};
|
|
export class Heightfield extends Shape {
|
|
data: number[][];
|
|
maxValue: number | null;
|
|
minValue: number | null;
|
|
elementSize: number;
|
|
cacheEnabled: boolean;
|
|
pillarConvex: ConvexPolyhedron;
|
|
pillarOffset: Vec3;
|
|
private _cachedPillars;
|
|
constructor(data: number[][], options?: {
|
|
maxValue?: number | null;
|
|
minValue?: number | null;
|
|
elementSize?: number;
|
|
});
|
|
update(): void;
|
|
updateMinValue(): void;
|
|
updateMaxValue(): void;
|
|
setHeightValueAtIndex(xi: number, yi: number, value: number): void;
|
|
getRectMinMax(iMinX: number, iMinY: number, iMaxX: number, iMaxY: number, result?: number[]): void;
|
|
getIndexOfPosition(x: number, y: number, result: number[], clamp: boolean): boolean;
|
|
getTriangleAt(x: number, y: number, edgeClamp: boolean, a: Vec3, b: Vec3, c: Vec3): boolean;
|
|
getNormalAt(x: number, y: number, edgeClamp: boolean, result: Vec3): void;
|
|
getAabbAtIndex(xi: number, yi: number, { lowerBound, upperBound }: AABB): void;
|
|
getHeightAt(x: number, y: number, edgeClamp: boolean): number;
|
|
getCacheConvexTrianglePillarKey(xi: number, yi: number, getUpperTriangle: boolean): string;
|
|
getCachedConvexTrianglePillar(xi: number, yi: number, getUpperTriangle: boolean): HeightfieldPillar;
|
|
setCachedConvexTrianglePillar(xi: number, yi: number, getUpperTriangle: boolean, convex: ConvexPolyhedron, offset: Vec3): void;
|
|
clearCachedConvexTrianglePillar(xi: number, yi: number, getUpperTriangle: boolean): void;
|
|
getTriangle(xi: number, yi: number, upper: boolean, a: Vec3, b: Vec3, c: Vec3): void;
|
|
getConvexTrianglePillar(xi: number, yi: number, getUpperTriangle: boolean): void;
|
|
calculateLocalInertia(mass: number, target?: Vec3): Vec3;
|
|
volume(): number;
|
|
calculateWorldAABB(pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
|
|
updateBoundingSphereRadius(): void;
|
|
setHeightsFromImage(image: HTMLImageElement, scale: Vec3): void;
|
|
}
|
|
}
|
|
declare module "utils/Octree" {
|
|
import { AABB } from "collision/AABB";
|
|
import type { Transform } from "math/Transform";
|
|
import type { Ray } from "collision/Ray";
|
|
class OctreeNode {
|
|
root: OctreeNode | null;
|
|
aabb: AABB;
|
|
data: number[];
|
|
children: OctreeNode[];
|
|
constructor(options?: {
|
|
root?: Octree | null;
|
|
aabb?: AABB;
|
|
});
|
|
reset(): void;
|
|
insert(aabb: AABB, elementData: number, level?: number): boolean;
|
|
subdivide(): void;
|
|
aabbQuery(aabb: AABB, result: number[]): number[];
|
|
rayQuery(ray: Ray, treeTransform: Transform, result: number[]): number[];
|
|
removeEmptyNodes(): void;
|
|
}
|
|
export class Octree extends OctreeNode {
|
|
maxDepth: number;
|
|
constructor(aabb?: AABB, options?: {
|
|
maxDepth?: number;
|
|
});
|
|
}
|
|
}
|
|
declare module "shapes/Trimesh" {
|
|
import { Shape } from "shapes/Shape";
|
|
import { Vec3 } from "math/Vec3";
|
|
import { AABB } from "collision/AABB";
|
|
import { Octree } from "utils/Octree";
|
|
import type { Quaternion } from "math/Quaternion";
|
|
export class Trimesh extends Shape {
|
|
vertices: Float32Array;
|
|
indices: Int16Array;
|
|
normals: Float32Array;
|
|
aabb: AABB;
|
|
edges: Int16Array | null;
|
|
scale: Vec3;
|
|
tree: Octree;
|
|
constructor(vertices: number[], indices: number[]);
|
|
updateTree(): void;
|
|
getTrianglesInAABB(aabb: AABB, result: number[]): number[];
|
|
setScale(scale: Vec3): void;
|
|
updateNormals(): void;
|
|
updateEdges(): void;
|
|
getEdgeVertex(edgeIndex: number, firstOrSecond: number, vertexStore: Vec3): void;
|
|
getEdgeVector(edgeIndex: number, vectorStore: Vec3): void;
|
|
static computeNormal(va: Vec3, vb: Vec3, vc: Vec3, target: Vec3): void;
|
|
getVertex(i: number, out: Vec3): Vec3;
|
|
private _getUnscaledVertex;
|
|
getWorldVertex(i: number, pos: Vec3, quat: Quaternion, out: Vec3): Vec3;
|
|
getTriangleVertices(i: number, a: Vec3, b: Vec3, c: Vec3): void;
|
|
getNormal(i: number, target: Vec3): Vec3;
|
|
calculateLocalInertia(mass: number, target: Vec3): Vec3;
|
|
computeLocalAABB(aabb: AABB): void;
|
|
updateAABB(): void;
|
|
updateBoundingSphereRadius(): void;
|
|
calculateWorldAABB(pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
|
|
volume(): number;
|
|
static createTorus(radius?: number, tube?: number, radialSegments?: number, tubularSegments?: number, arc?: number): Trimesh;
|
|
}
|
|
}
|
|
declare module "math/JacobianElement" {
|
|
import { Vec3 } from "math/Vec3";
|
|
export class JacobianElement {
|
|
spatial: Vec3;
|
|
rotational: Vec3;
|
|
constructor();
|
|
multiplyElement(element: JacobianElement): number;
|
|
multiplyVectors(spatial: Vec3, rotational: Vec3): number;
|
|
}
|
|
}
|
|
declare module "equations/Equation" {
|
|
import { JacobianElement } from "math/JacobianElement";
|
|
import type { Body } from "objects/Body";
|
|
import type { Shape } from "shapes/Shape";
|
|
export class Equation {
|
|
id: number;
|
|
minForce: number;
|
|
maxForce: number;
|
|
bi: Body;
|
|
bj: Body;
|
|
si: Shape;
|
|
sj: Shape;
|
|
a: number;
|
|
b: number;
|
|
eps: number;
|
|
jacobianElementA: JacobianElement;
|
|
jacobianElementB: JacobianElement;
|
|
enabled: boolean;
|
|
multiplier: number;
|
|
static idCounter: number;
|
|
constructor(bi: Body, bj: Body, minForce?: number, maxForce?: number);
|
|
setSpookParams(stiffness: number, relaxation: number, timeStep: number): void;
|
|
computeB(a: number, b: number, h: number): number;
|
|
computeGq(): number;
|
|
computeGW(): number;
|
|
computeGWlambda(): number;
|
|
computeGiMf(): number;
|
|
computeGiMGt(): number;
|
|
addToWlambda(deltalambda: number): void;
|
|
computeC(): number;
|
|
}
|
|
}
|
|
declare module "solver/Solver" {
|
|
import type { Equation } from "equations/Equation";
|
|
import type { World } from "world/World";
|
|
export class Solver {
|
|
equations: Equation[];
|
|
constructor();
|
|
solve(dt: number, world: World): number;
|
|
addEquation(eq: Equation): void;
|
|
removeEquation(eq: Equation): void;
|
|
removeAllEquations(): void;
|
|
}
|
|
}
|
|
declare module "solver/GSSolver" {
|
|
import { Solver } from "solver/Solver";
|
|
import type { World } from "world/World";
|
|
export class GSSolver extends Solver {
|
|
iterations: number;
|
|
tolerance: number;
|
|
constructor();
|
|
solve(dt: number, world: World): number;
|
|
}
|
|
}
|
|
declare module "collision/Broadphase" {
|
|
import { Body } from "objects/Body";
|
|
import type { AABB } from "collision/AABB";
|
|
import type { World } from "world/World";
|
|
export class Broadphase {
|
|
world: World | null;
|
|
useBoundingBoxes: boolean;
|
|
dirty: boolean;
|
|
constructor();
|
|
collisionPairs(world: World, p1: Body[], p2: Body[]): void;
|
|
needBroadphaseCollision(bodyA: Body, bodyB: Body): boolean;
|
|
intersectionTest(bodyA: Body, bodyB: Body, pairs1: Body[], pairs2: Body[]): void;
|
|
doBoundingSphereBroadphase(bodyA: Body, bodyB: Body, pairs1: Body[], pairs2: Body[]): void;
|
|
doBoundingBoxBroadphase(bodyA: Body, bodyB: Body, pairs1: Body[], pairs2: Body[]): void;
|
|
makePairsUnique(pairs1: Body[], pairs2: Body[]): void;
|
|
setWorld(world: World): void;
|
|
static boundingSphereCheck(bodyA: Body, bodyB: Body): boolean;
|
|
aabbQuery(world: World, aabb: AABB, result: Body[]): Body[];
|
|
}
|
|
}
|
|
declare module "collision/NaiveBroadphase" {
|
|
import { Broadphase } from "collision/Broadphase";
|
|
import type { AABB } from "collision/AABB";
|
|
import type { Body } from "objects/Body";
|
|
import type { World } from "world/World";
|
|
export class NaiveBroadphase extends Broadphase {
|
|
constructor();
|
|
collisionPairs(world: World, pairs1: Body[], pairs2: Body[]): void;
|
|
aabbQuery(world: World, aabb: AABB, result?: Body[]): Body[];
|
|
}
|
|
}
|
|
declare module "utils/Pool" {
|
|
export class Pool {
|
|
objects: any[];
|
|
type: any;
|
|
release(...args: any[]): Pool;
|
|
get(): any;
|
|
constructObject(): void;
|
|
resize(size: number): Pool;
|
|
}
|
|
}
|
|
declare module "utils/Vec3Pool" {
|
|
import { Pool } from "utils/Pool";
|
|
import { Vec3 } from "math/Vec3";
|
|
export class Vec3Pool extends Pool {
|
|
type: typeof Vec3;
|
|
constructObject(): Vec3;
|
|
}
|
|
}
|
|
declare module "equations/ContactEquation" {
|
|
import { Equation } from "equations/Equation";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Body } from "objects/Body";
|
|
export class ContactEquation extends Equation {
|
|
restitution: number;
|
|
ri: Vec3;
|
|
rj: Vec3;
|
|
ni: Vec3;
|
|
constructor(bodyA: Body, bodyB: Body, maxForce?: number);
|
|
computeB(h: number): number;
|
|
getImpactVelocityAlongNormal(): number;
|
|
}
|
|
}
|
|
declare module "equations/FrictionEquation" {
|
|
import { Equation } from "equations/Equation";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Body } from "objects/Body";
|
|
export class FrictionEquation extends Equation {
|
|
ri: Vec3;
|
|
rj: Vec3;
|
|
t: Vec3;
|
|
constructor(bodyA: Body, bodyB: Body, slipForce: number);
|
|
computeB(h: number): number;
|
|
}
|
|
}
|
|
declare module "shapes/Particle" {
|
|
import { Shape } from "shapes/Shape";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Quaternion } from "math/Quaternion";
|
|
export class Particle extends Shape {
|
|
constructor();
|
|
calculateLocalInertia(mass: number, target?: Vec3): Vec3;
|
|
volume(): number;
|
|
updateBoundingSphereRadius(): void;
|
|
calculateWorldAABB(pos: Vec3, quat: Quaternion, min: Vec3, max: Vec3): void;
|
|
}
|
|
}
|
|
declare module "shapes/Cylinder" {
|
|
import { ConvexPolyhedron } from "shapes/ConvexPolyhedron";
|
|
export class Cylinder extends ConvexPolyhedron {
|
|
radiusTop: number;
|
|
radiusBottom: number;
|
|
height: number;
|
|
numSegments: number;
|
|
constructor(radiusTop?: number, radiusBottom?: number, height?: number, numSegments?: number);
|
|
}
|
|
}
|
|
declare module "material/ContactMaterial" {
|
|
import type { Material } from "material/Material";
|
|
export type ContactMaterialOptions = ConstructorParameters<typeof ContactMaterial>[2];
|
|
export class ContactMaterial {
|
|
id: number;
|
|
materials: [Material, Material];
|
|
friction: number;
|
|
restitution: number;
|
|
contactEquationStiffness: number;
|
|
contactEquationRelaxation: number;
|
|
frictionEquationStiffness: number;
|
|
frictionEquationRelaxation: number;
|
|
static idCounter: number;
|
|
constructor(m1: Material, m2: Material, options: {
|
|
friction?: number;
|
|
restitution?: number;
|
|
contactEquationStiffness?: number;
|
|
contactEquationRelaxation?: number;
|
|
frictionEquationStiffness?: number;
|
|
frictionEquationRelaxation?: number;
|
|
});
|
|
}
|
|
}
|
|
declare module "world/Narrowphase" {
|
|
import { Shape } from "shapes/Shape";
|
|
import { Vec3 } from "math/Vec3";
|
|
import { Quaternion } from "math/Quaternion";
|
|
import { Body } from "objects/Body";
|
|
import { Vec3Pool } from "utils/Vec3Pool";
|
|
import { ContactEquation } from "equations/ContactEquation";
|
|
import { FrictionEquation } from "equations/FrictionEquation";
|
|
import type { Box } from "shapes/Box";
|
|
import type { Sphere } from "shapes/Sphere";
|
|
import type { ConvexPolyhedron } from "shapes/ConvexPolyhedron";
|
|
import type { Particle } from "shapes/Particle";
|
|
import type { Plane } from "shapes/Plane";
|
|
import type { Trimesh } from "shapes/Trimesh";
|
|
import type { Heightfield } from "shapes/Heightfield";
|
|
import { Cylinder } from "shapes/Cylinder";
|
|
import type { ContactMaterial } from "material/ContactMaterial";
|
|
import type { World } from "world/World";
|
|
export const COLLISION_TYPES: {
|
|
sphereSphere: 1;
|
|
spherePlane: 3;
|
|
boxBox: 4;
|
|
sphereBox: 5;
|
|
planeBox: 6;
|
|
convexConvex: 16;
|
|
sphereConvex: 17;
|
|
planeConvex: 18;
|
|
boxConvex: 20;
|
|
sphereHeightfield: 33;
|
|
boxHeightfield: 36;
|
|
convexHeightfield: 48;
|
|
sphereParticle: 65;
|
|
planeParticle: 66;
|
|
boxParticle: 68;
|
|
convexParticle: 80;
|
|
cylinderCylinder: 128;
|
|
sphereCylinder: 129;
|
|
planeCylinder: 130;
|
|
boxCylinder: 132;
|
|
convexCylinder: 144;
|
|
heightfieldCylinder: 160;
|
|
particleCylinder: 192;
|
|
sphereTrimesh: 257;
|
|
planeTrimesh: 258;
|
|
};
|
|
export type CollisionType = typeof COLLISION_TYPES[keyof typeof COLLISION_TYPES];
|
|
export class Narrowphase {
|
|
contactPointPool: ContactEquation[];
|
|
frictionEquationPool: FrictionEquation[];
|
|
result: ContactEquation[];
|
|
frictionResult: FrictionEquation[];
|
|
v3pool: Vec3Pool;
|
|
world: World;
|
|
currentContactMaterial: ContactMaterial;
|
|
enableFrictionReduction: boolean;
|
|
get [COLLISION_TYPES.sphereSphere](): (si: Sphere, sj: Sphere, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => boolean | void;
|
|
get [COLLISION_TYPES.spherePlane](): (si: Sphere, sj: Plane, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.boxBox](): (si: Box, sj: Box, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.sphereBox](): (si: Sphere, sj: Box, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.planeBox](): (si: Plane, sj: Box, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.convexConvex](): (si: ConvexPolyhedron, sj: ConvexPolyhedron, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined, faceListA?: number[] | null | undefined, faceListB?: number[] | null | undefined) => true | void;
|
|
get [COLLISION_TYPES.sphereConvex](): (si: Sphere, sj: ConvexPolyhedron, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.planeConvex](): (planeShape: Plane, convexShape: ConvexPolyhedron, planePosition: Vec3, convexPosition: Vec3, planeQuat: Quaternion, convexQuat: Quaternion, planeBody: Body, convexBody: Body, si?: Shape | undefined, sj?: Shape | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.boxConvex](): (si: Box, sj: ConvexPolyhedron, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.sphereHeightfield](): (sphereShape: Sphere, hfShape: Heightfield, spherePos: Vec3, hfPos: Vec3, sphereQuat: Quaternion, hfQuat: Quaternion, sphereBody: Body, hfBody: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.boxHeightfield](): (si: Box, sj: Heightfield, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.convexHeightfield](): (convexShape: ConvexPolyhedron, hfShape: Heightfield, convexPos: Vec3, hfPos: Vec3, convexQuat: Quaternion, hfQuat: Quaternion, convexBody: Body, hfBody: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.sphereParticle](): (sj: Sphere, si: Particle, xj: Vec3, xi: Vec3, qj: Quaternion, qi: Quaternion, bj: Body, bi: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.planeParticle](): (sj: Plane, si: Particle, xj: Vec3, xi: Vec3, qj: Quaternion, qi: Quaternion, bj: Body, bi: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.boxParticle](): (si: Box, sj: Particle, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.convexParticle](): (sj: ConvexPolyhedron, si: Particle, xj: Vec3, xi: Vec3, qj: Quaternion, qi: Quaternion, bj: Body, bi: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.cylinderCylinder](): (si: ConvexPolyhedron, sj: ConvexPolyhedron, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined, faceListA?: number[] | null | undefined, faceListB?: number[] | null | undefined) => true | void;
|
|
get [COLLISION_TYPES.sphereCylinder](): (si: Sphere, sj: ConvexPolyhedron, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.planeCylinder](): (planeShape: Plane, convexShape: ConvexPolyhedron, planePosition: Vec3, convexPosition: Vec3, planeQuat: Quaternion, convexQuat: Quaternion, planeBody: Body, convexBody: Body, si?: Shape | undefined, sj?: Shape | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.boxCylinder](): (si: Box, sj: ConvexPolyhedron, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.convexCylinder](): (si: ConvexPolyhedron, sj: ConvexPolyhedron, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined, faceListA?: number[] | null | undefined, faceListB?: number[] | null | undefined) => true | void;
|
|
get [COLLISION_TYPES.heightfieldCylinder](): (hfShape: Heightfield, convexShape: Cylinder, hfPos: Vec3, convexPos: Vec3, hfQuat: Quaternion, convexQuat: Quaternion, hfBody: Body, convexBody: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.particleCylinder](): (si: Particle, sj: Cylinder, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.sphereTrimesh](): (sphereShape: Sphere, trimeshShape: Trimesh, spherePos: Vec3, trimeshPos: Vec3, sphereQuat: Quaternion, trimeshQuat: Quaternion, sphereBody: Body, trimeshBody: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
get [COLLISION_TYPES.planeTrimesh](): (planeShape: Plane, trimeshShape: Trimesh, planePos: Vec3, trimeshPos: Vec3, planeQuat: Quaternion, trimeshQuat: Quaternion, planeBody: Body, trimeshBody: Body, rsi?: Shape | null | undefined, rsj?: Shape | null | undefined, justTest?: boolean | undefined) => true | void;
|
|
constructor(world: World);
|
|
createContactEquation(bi: Body, bj: Body, si: Shape, sj: Shape, overrideShapeA?: Shape | null, overrideShapeB?: Shape | null): ContactEquation;
|
|
createFrictionEquationsFromContact(contactEquation: ContactEquation, outArray: FrictionEquation[]): boolean;
|
|
createFrictionFromAverage(numContacts: number): void;
|
|
getContacts(p1: Body[], p2: Body[], world: World, result: ContactEquation[], oldcontacts: ContactEquation[], frictionResult: FrictionEquation[], frictionPool: FrictionEquation[]): void;
|
|
sphereSphere(si: Sphere, sj: Sphere, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): boolean | void;
|
|
spherePlane(si: Sphere, sj: Plane, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
boxBox(si: Box, sj: Box, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
sphereBox(si: Sphere, sj: Box, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
planeBox(si: Plane, sj: Box, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
convexConvex(si: ConvexPolyhedron, sj: ConvexPolyhedron, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean, faceListA?: number[] | null, faceListB?: number[] | null): true | void;
|
|
sphereConvex(si: Sphere, sj: ConvexPolyhedron, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
planeConvex(planeShape: Plane, convexShape: ConvexPolyhedron, planePosition: Vec3, convexPosition: Vec3, planeQuat: Quaternion, convexQuat: Quaternion, planeBody: Body, convexBody: Body, si?: Shape, sj?: Shape, justTest?: boolean): true | void;
|
|
boxConvex(si: Box, sj: ConvexPolyhedron, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
sphereHeightfield(sphereShape: Sphere, hfShape: Heightfield, spherePos: Vec3, hfPos: Vec3, sphereQuat: Quaternion, hfQuat: Quaternion, sphereBody: Body, hfBody: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
boxHeightfield(si: Box, sj: Heightfield, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
convexHeightfield(convexShape: ConvexPolyhedron, hfShape: Heightfield, convexPos: Vec3, hfPos: Vec3, convexQuat: Quaternion, hfQuat: Quaternion, convexBody: Body, hfBody: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
sphereParticle(sj: Sphere, si: Particle, xj: Vec3, xi: Vec3, qj: Quaternion, qi: Quaternion, bj: Body, bi: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
planeParticle(sj: Plane, si: Particle, xj: Vec3, xi: Vec3, qj: Quaternion, qi: Quaternion, bj: Body, bi: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
boxParticle(si: Box, sj: Particle, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
convexParticle(sj: ConvexPolyhedron, si: Particle, xj: Vec3, xi: Vec3, qj: Quaternion, qi: Quaternion, bj: Body, bi: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
heightfieldCylinder(hfShape: Heightfield, convexShape: Cylinder, hfPos: Vec3, convexPos: Vec3, hfQuat: Quaternion, convexQuat: Quaternion, hfBody: Body, convexBody: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
particleCylinder(si: Particle, sj: Cylinder, xi: Vec3, xj: Vec3, qi: Quaternion, qj: Quaternion, bi: Body, bj: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
sphereTrimesh(sphereShape: Sphere, trimeshShape: Trimesh, spherePos: Vec3, trimeshPos: Vec3, sphereQuat: Quaternion, trimeshQuat: Quaternion, sphereBody: Body, trimeshBody: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
planeTrimesh(planeShape: Plane, trimeshShape: Trimesh, planePos: Vec3, trimeshPos: Vec3, planeQuat: Quaternion, trimeshQuat: Quaternion, planeBody: Body, trimeshBody: Body, rsi?: Shape | null, rsj?: Shape | null, justTest?: boolean): true | void;
|
|
}
|
|
}
|
|
declare module "collision/ArrayCollisionMatrix" {
|
|
import type { Body } from "objects/Body";
|
|
export class ArrayCollisionMatrix {
|
|
matrix: number[];
|
|
constructor();
|
|
get(bi: Body, bj: Body): number;
|
|
set(bi: Body, bj: Body, value: boolean): void;
|
|
reset(): void;
|
|
setNumObjects(n: number): void;
|
|
}
|
|
}
|
|
declare module "collision/OverlapKeeper" {
|
|
export class OverlapKeeper {
|
|
current: number[];
|
|
previous: number[];
|
|
constructor();
|
|
getKey(i: number, j: number): number;
|
|
set(i: number, j: number): void;
|
|
tick(): void;
|
|
getDiff(additions: number[], removals: number[]): void;
|
|
}
|
|
}
|
|
declare module "utils/TupleDictionary" {
|
|
export class TupleDictionary {
|
|
data: {
|
|
[id: string]: any;
|
|
keys: string[];
|
|
};
|
|
get(i: number, j: number): any;
|
|
set(i: number, j: number, value: any): void;
|
|
delete(i: number, j: number): void;
|
|
reset(): void;
|
|
}
|
|
}
|
|
declare module "constraints/Constraint" {
|
|
import type { Body } from "objects/Body";
|
|
import type { Equation } from "equations/Equation";
|
|
export type ConstraintOptions = ConstructorParameters<typeof Constraint>[2];
|
|
export class Constraint {
|
|
equations: Equation[];
|
|
bodyA: Body;
|
|
bodyB: Body;
|
|
id: number;
|
|
collideConnected: boolean;
|
|
static idCounter: number;
|
|
constructor(bodyA: Body, bodyB: Body, options?: {
|
|
collideConnected?: boolean;
|
|
wakeUpBodies?: boolean;
|
|
});
|
|
update(): void;
|
|
enable(): void;
|
|
disable(): void;
|
|
}
|
|
}
|
|
declare module "world/World" {
|
|
import { EventTarget } from "utils/EventTarget";
|
|
import { Narrowphase } from "world/Narrowphase";
|
|
import { Vec3 } from "math/Vec3";
|
|
import { Material } from "material/Material";
|
|
import { ContactMaterial } from "material/ContactMaterial";
|
|
import { ArrayCollisionMatrix } from "collision/ArrayCollisionMatrix";
|
|
import { OverlapKeeper } from "collision/OverlapKeeper";
|
|
import { TupleDictionary } from "utils/TupleDictionary";
|
|
import { RaycastResult } from "collision/RaycastResult";
|
|
import { Body } from "objects/Body";
|
|
import type { Broadphase } from "collision/Broadphase";
|
|
import type { Solver } from "solver/Solver";
|
|
import type { ContactEquation } from "equations/ContactEquation";
|
|
import type { FrictionEquation } from "equations/FrictionEquation";
|
|
import type { RayOptions, RaycastCallback } from "collision/Ray";
|
|
import type { Constraint } from "constraints/Constraint";
|
|
import type { Shape } from "shapes/Shape";
|
|
export type WorldOptions = ConstructorParameters<typeof World>[0];
|
|
export class World extends EventTarget {
|
|
dt: number;
|
|
allowSleep: boolean;
|
|
contacts: ContactEquation[];
|
|
frictionEquations: FrictionEquation[];
|
|
quatNormalizeSkip: number;
|
|
quatNormalizeFast: boolean;
|
|
time: number;
|
|
stepnumber: number;
|
|
default_dt: number;
|
|
nextId: number;
|
|
gravity: Vec3;
|
|
frictionGravity?: Vec3;
|
|
broadphase: Broadphase;
|
|
bodies: Body[];
|
|
hasActiveBodies: boolean;
|
|
solver: Solver;
|
|
constraints: Constraint[];
|
|
narrowphase: Narrowphase;
|
|
collisionMatrix: ArrayCollisionMatrix;
|
|
collisionMatrixPrevious: ArrayCollisionMatrix;
|
|
bodyOverlapKeeper: OverlapKeeper;
|
|
shapeOverlapKeeper: OverlapKeeper;
|
|
contactmaterials: ContactMaterial[];
|
|
contactMaterialTable: TupleDictionary;
|
|
defaultMaterial: Material;
|
|
defaultContactMaterial: ContactMaterial;
|
|
doProfiling: boolean;
|
|
profile: {
|
|
solve: number;
|
|
makeContactConstraints: number;
|
|
broadphase: number;
|
|
integrate: number;
|
|
narrowphase: number;
|
|
};
|
|
accumulator: number;
|
|
subsystems: any[];
|
|
addBodyEvent: {
|
|
type: 'addBody';
|
|
body: Body | null;
|
|
};
|
|
removeBodyEvent: {
|
|
type: 'removeBody';
|
|
body: Body | null;
|
|
};
|
|
idToBodyMap: {
|
|
[id: number]: Body;
|
|
};
|
|
lastCallTime?: number;
|
|
constructor(options?: {
|
|
gravity?: Vec3;
|
|
frictionGravity?: Vec3;
|
|
allowSleep?: boolean;
|
|
broadphase?: Broadphase;
|
|
solver?: Solver;
|
|
quatNormalizeFast?: boolean;
|
|
quatNormalizeSkip?: number;
|
|
});
|
|
getContactMaterial(m1: Material, m2: Material): ContactMaterial;
|
|
collisionMatrixTick(): void;
|
|
addConstraint(c: Constraint): void;
|
|
removeConstraint(c: Constraint): void;
|
|
rayTest(from: Vec3, to: Vec3, result: RaycastResult | RaycastCallback): void;
|
|
raycastAll(from?: Vec3, to?: Vec3, options?: RayOptions, callback?: RaycastCallback): boolean;
|
|
raycastAny(from?: Vec3, to?: Vec3, options?: RayOptions, result?: RaycastResult): boolean;
|
|
raycastClosest(from?: Vec3, to?: Vec3, options?: RayOptions, result?: RaycastResult): boolean;
|
|
addBody(body: Body): void;
|
|
removeBody(body: Body): void;
|
|
getBodyById(id: number): Body;
|
|
getShapeById(id: number): Shape | null;
|
|
addContactMaterial(cmat: ContactMaterial): void;
|
|
removeContactMaterial(cmat: ContactMaterial): void;
|
|
fixedStep(dt?: number, maxSubSteps?: number): void;
|
|
step(dt: number, timeSinceLastCalled?: number, maxSubSteps?: number): void;
|
|
internalStep(dt: number): void;
|
|
emitContactEvents(): void;
|
|
clearForces(): void;
|
|
}
|
|
}
|
|
declare module "collision/Ray" {
|
|
import { Vec3 } from "math/Vec3";
|
|
import { Quaternion } from "math/Quaternion";
|
|
import { RaycastResult } from "collision/RaycastResult";
|
|
import { Shape } from "shapes/Shape";
|
|
import { AABB } from "collision/AABB";
|
|
import type { Body } from "objects/Body";
|
|
import type { Sphere } from "shapes/Sphere";
|
|
import type { Box } from "shapes/Box";
|
|
import type { Plane } from "shapes/Plane";
|
|
import type { Heightfield } from "shapes/Heightfield";
|
|
import type { ConvexPolyhedron } from "shapes/ConvexPolyhedron";
|
|
import type { Trimesh } from "shapes/Trimesh";
|
|
import type { World } from "world/World";
|
|
export const RAY_MODES: {
|
|
readonly CLOSEST: 1;
|
|
readonly ANY: 2;
|
|
readonly ALL: 4;
|
|
};
|
|
export type RayMode = typeof RAY_MODES[keyof typeof RAY_MODES];
|
|
export type RayOptions = {
|
|
from?: Vec3;
|
|
to?: Vec3;
|
|
mode?: RayMode;
|
|
result?: RaycastResult;
|
|
skipBackfaces?: boolean;
|
|
collisionFilterMask?: number;
|
|
collisionFilterGroup?: number;
|
|
checkCollisionResponse?: boolean;
|
|
callback?: RaycastCallback;
|
|
};
|
|
export type RaycastCallback = (result: RaycastResult) => void;
|
|
export class Ray {
|
|
from: Vec3;
|
|
to: Vec3;
|
|
direction: Vec3;
|
|
precision: number;
|
|
checkCollisionResponse: boolean;
|
|
skipBackfaces: boolean;
|
|
collisionFilterMask: number;
|
|
collisionFilterGroup: number;
|
|
mode: number;
|
|
result: RaycastResult;
|
|
hasHit: boolean;
|
|
callback: RaycastCallback;
|
|
static CLOSEST: 1;
|
|
static ANY: 2;
|
|
static ALL: 4;
|
|
get [Shape.types.SPHERE](): (sphere: Sphere, quat: Quaternion, position: Vec3, body: Body, reportedShape: Shape) => void;
|
|
get [Shape.types.PLANE](): (shape: Plane, quat: Quaternion, position: Vec3, body: Body, reportedShape: Shape) => void;
|
|
get [Shape.types.BOX](): (box: Box, quat: Quaternion, position: Vec3, body: Body, reportedShape: Shape) => void;
|
|
get [Shape.types.CYLINDER](): (shape: ConvexPolyhedron, quat: Quaternion, position: Vec3, body: Body, reportedShape: Shape, options?: {
|
|
faceList: number[];
|
|
} | undefined) => void;
|
|
get [Shape.types.CONVEXPOLYHEDRON](): (shape: ConvexPolyhedron, quat: Quaternion, position: Vec3, body: Body, reportedShape: Shape, options?: {
|
|
faceList: number[];
|
|
} | undefined) => void;
|
|
get [Shape.types.HEIGHTFIELD](): (shape: Heightfield, quat: Quaternion, position: Vec3, body: Body, reportedShape: Shape) => void;
|
|
get [Shape.types.TRIMESH](): (mesh: Trimesh, quat: Quaternion, position: Vec3, body: Body, reportedShape: Shape, options?: {
|
|
faceList?: any[] | undefined;
|
|
} | undefined) => void;
|
|
constructor(from?: Vec3, to?: Vec3);
|
|
intersectWorld(world: World, options: RayOptions): boolean;
|
|
intersectBody(body: Body, result?: RaycastResult): void;
|
|
intersectBodies(bodies: Body[], result?: RaycastResult): void;
|
|
private updateDirection;
|
|
private intersectShape;
|
|
_intersectBox(box: Box, quat: Quaternion, position: Vec3, body: Body, reportedShape: Shape): void;
|
|
_intersectPlane(shape: Plane, quat: Quaternion, position: Vec3, body: Body, reportedShape: Shape): void;
|
|
getAABB(aabb: AABB): void;
|
|
_intersectHeightfield(shape: Heightfield, quat: Quaternion, position: Vec3, body: Body, reportedShape: Shape): void;
|
|
_intersectSphere(sphere: Sphere, quat: Quaternion, position: Vec3, body: Body, reportedShape: Shape): void;
|
|
_intersectConvex(shape: ConvexPolyhedron, quat: Quaternion, position: Vec3, body: Body, reportedShape: Shape, options?: {
|
|
faceList: number[];
|
|
}): void;
|
|
_intersectTrimesh(mesh: Trimesh, quat: Quaternion, position: Vec3, body: Body, reportedShape: Shape, options?: {
|
|
faceList?: any[];
|
|
}): void;
|
|
private reportIntersection;
|
|
static pointInTriangle(p: Vec3, a: Vec3, b: Vec3, c: Vec3): boolean;
|
|
}
|
|
}
|
|
declare module "collision/AABB" {
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Ray } from "collision/Ray";
|
|
import type { Transform } from "math/Transform";
|
|
import type { Quaternion } from "math/Quaternion";
|
|
export class AABB {
|
|
lowerBound: Vec3;
|
|
upperBound: Vec3;
|
|
constructor(options?: {
|
|
upperBound?: Vec3;
|
|
lowerBound?: Vec3;
|
|
});
|
|
setFromPoints(points: Vec3[], position?: Vec3, quaternion?: Quaternion, skinSize?: number): AABB;
|
|
copy(aabb: AABB): AABB;
|
|
clone(): AABB;
|
|
extend(aabb: AABB): void;
|
|
overlaps(aabb: AABB): boolean;
|
|
volume(): number;
|
|
contains(aabb: AABB): boolean;
|
|
getCorners(a: Vec3, b: Vec3, c: Vec3, d: Vec3, e: Vec3, f: Vec3, g: Vec3, h: Vec3): void;
|
|
toLocalFrame(frame: Transform, target: AABB): AABB;
|
|
toWorldFrame(frame: Transform, target: AABB): AABB;
|
|
overlapsRay(ray: Ray): boolean;
|
|
}
|
|
}
|
|
declare module "objects/Body" {
|
|
import { EventTarget } from "utils/EventTarget";
|
|
import { Vec3 } from "math/Vec3";
|
|
import { Mat3 } from "math/Mat3";
|
|
import { Quaternion } from "math/Quaternion";
|
|
import { AABB } from "collision/AABB";
|
|
import type { Shape } from "shapes/Shape";
|
|
import type { Material } from "material/Material";
|
|
import type { World } from "world/World";
|
|
export const BODY_TYPES: {
|
|
readonly DYNAMIC: 1;
|
|
readonly STATIC: 2;
|
|
readonly KINEMATIC: 4;
|
|
};
|
|
export type BodyType = typeof BODY_TYPES[keyof typeof BODY_TYPES];
|
|
export const BODY_SLEEP_STATES: {
|
|
readonly AWAKE: 0;
|
|
readonly SLEEPY: 1;
|
|
readonly SLEEPING: 2;
|
|
};
|
|
export type BodySleepState = typeof BODY_SLEEP_STATES[keyof typeof BODY_SLEEP_STATES];
|
|
export type BodyOptions = ConstructorParameters<typeof Body>[0];
|
|
export class Body extends EventTarget {
|
|
static idCounter: number;
|
|
static COLLIDE_EVENT_NAME: string;
|
|
static DYNAMIC: 1;
|
|
static STATIC: 2;
|
|
static KINEMATIC: 4;
|
|
static AWAKE: 0;
|
|
static SLEEPY: 1;
|
|
static SLEEPING: 2;
|
|
static wakeupEvent: {
|
|
type: string;
|
|
};
|
|
static sleepyEvent: {
|
|
type: string;
|
|
};
|
|
static sleepEvent: {
|
|
type: string;
|
|
};
|
|
id: number;
|
|
index: number;
|
|
world: World | null;
|
|
vlambda: Vec3;
|
|
collisionFilterGroup: number;
|
|
collisionFilterMask: number;
|
|
collisionResponse: boolean;
|
|
position: Vec3;
|
|
previousPosition: Vec3;
|
|
interpolatedPosition: Vec3;
|
|
initPosition: Vec3;
|
|
velocity: Vec3;
|
|
initVelocity: Vec3;
|
|
force: Vec3;
|
|
mass: number;
|
|
invMass: number;
|
|
material: Material | null;
|
|
linearDamping: number;
|
|
type: BodyType;
|
|
allowSleep: boolean;
|
|
sleepState: BodySleepState;
|
|
sleepSpeedLimit: number;
|
|
sleepTimeLimit: number;
|
|
timeLastSleepy: number;
|
|
wakeUpAfterNarrowphase: boolean;
|
|
torque: Vec3;
|
|
quaternion: Quaternion;
|
|
initQuaternion: Quaternion;
|
|
previousQuaternion: Quaternion;
|
|
interpolatedQuaternion: Quaternion;
|
|
angularVelocity: Vec3;
|
|
initAngularVelocity: Vec3;
|
|
shapes: Shape[];
|
|
shapeOffsets: Vec3[];
|
|
shapeOrientations: Quaternion[];
|
|
inertia: Vec3;
|
|
invInertia: Vec3;
|
|
invInertiaWorld: Mat3;
|
|
invMassSolve: number;
|
|
invInertiaSolve: Vec3;
|
|
invInertiaWorldSolve: Mat3;
|
|
fixedRotation: boolean;
|
|
angularDamping: number;
|
|
linearFactor: Vec3;
|
|
angularFactor: Vec3;
|
|
aabb: AABB;
|
|
aabbNeedsUpdate: boolean;
|
|
boundingRadius: number;
|
|
wlambda: Vec3;
|
|
isTrigger: boolean;
|
|
constructor(options?: {
|
|
collisionFilterGroup?: number;
|
|
collisionFilterMask?: number;
|
|
collisionResponse?: boolean;
|
|
position?: Vec3;
|
|
velocity?: Vec3;
|
|
mass?: number;
|
|
material?: Material;
|
|
linearDamping?: number;
|
|
type?: BodyType;
|
|
allowSleep?: boolean;
|
|
sleepSpeedLimit?: number;
|
|
sleepTimeLimit?: number;
|
|
quaternion?: Quaternion;
|
|
angularVelocity?: Vec3;
|
|
fixedRotation?: boolean;
|
|
angularDamping?: number;
|
|
linearFactor?: Vec3;
|
|
angularFactor?: Vec3;
|
|
shape?: Shape;
|
|
isTrigger?: boolean;
|
|
});
|
|
wakeUp(): void;
|
|
sleep(): void;
|
|
sleepTick(time: number): void;
|
|
updateSolveMassProperties(): void;
|
|
pointToLocalFrame(worldPoint: Vec3, result?: Vec3): Vec3;
|
|
vectorToLocalFrame(worldVector: Vec3, result?: Vec3): Vec3;
|
|
pointToWorldFrame(localPoint: Vec3, result?: Vec3): Vec3;
|
|
vectorToWorldFrame(localVector: Vec3, result?: Vec3): Vec3;
|
|
addShape(shape: Shape, _offset?: Vec3, _orientation?: Quaternion): Body;
|
|
removeShape(shape: Shape): Body;
|
|
updateBoundingRadius(): void;
|
|
updateAABB(): void;
|
|
updateInertiaWorld(force?: boolean): void;
|
|
applyForce(force: Vec3, relativePoint?: Vec3): void;
|
|
applyLocalForce(localForce: Vec3, localPoint?: Vec3): void;
|
|
applyTorque(torque: Vec3): void;
|
|
applyImpulse(impulse: Vec3, relativePoint?: Vec3): void;
|
|
applyLocalImpulse(localImpulse: Vec3, localPoint?: Vec3): void;
|
|
updateMassProperties(): void;
|
|
getVelocityAtWorldPoint(worldPoint: Vec3, result: Vec3): Vec3;
|
|
integrate(dt: number, quatNormalize: boolean, quatNormalizeFast: boolean): void;
|
|
}
|
|
}
|
|
declare module "collision/ObjectCollisionMatrix" {
|
|
import type { Body } from "objects/Body";
|
|
export class ObjectCollisionMatrix {
|
|
matrix: Record<string, boolean>;
|
|
constructor();
|
|
get(bi: Body, bj: Body): boolean;
|
|
set(bi: Body, bj: Body, value: boolean): void;
|
|
reset(): void;
|
|
setNumObjects(n: number): void;
|
|
}
|
|
}
|
|
declare module "collision/GridBroadphase" {
|
|
import { Broadphase } from "collision/Broadphase";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Body } from "objects/Body";
|
|
import type { World } from "world/World";
|
|
export class GridBroadphase extends Broadphase {
|
|
nx: number;
|
|
ny: number;
|
|
nz: number;
|
|
aabbMin: Vec3;
|
|
aabbMax: Vec3;
|
|
bins: Body[][];
|
|
binLengths: number[];
|
|
constructor(aabbMin?: Vec3, aabbMax?: Vec3, nx?: number, ny?: number, nz?: number);
|
|
collisionPairs(world: World, pairs1: Body[], pairs2: Body[]): void;
|
|
}
|
|
}
|
|
declare module "collision/SAPBroadphase" {
|
|
import { Broadphase } from "collision/Broadphase";
|
|
import type { AABB } from "collision/AABB";
|
|
import type { Body } from "objects/Body";
|
|
import type { World } from "world/World";
|
|
export class SAPBroadphase extends Broadphase {
|
|
axisList: Body[];
|
|
world: World | null;
|
|
axisIndex: 0 | 1 | 2;
|
|
private _addBodyHandler;
|
|
private _removeBodyHandler;
|
|
static checkBounds(bi: Body, bj: Body, axisIndex: 0 | 1 | 2): boolean;
|
|
static insertionSortX(a: Body[]): Body[];
|
|
static insertionSortY(a: Body[]): Body[];
|
|
static insertionSortZ(a: Body[]): Body[];
|
|
constructor(world: World);
|
|
setWorld(world: World): void;
|
|
collisionPairs(world: World, p1: Body[], p2: Body[]): void;
|
|
sortList(): void;
|
|
autoDetectAxis(): void;
|
|
aabbQuery(world: World, aabb: AABB, result?: Body[]): Body[];
|
|
}
|
|
}
|
|
declare module "constraints/PointToPointConstraint" {
|
|
import { Constraint } from "constraints/Constraint";
|
|
import { ContactEquation } from "equations/ContactEquation";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Body } from "objects/Body";
|
|
export class PointToPointConstraint extends Constraint {
|
|
pivotA: Vec3;
|
|
pivotB: Vec3;
|
|
equationX: ContactEquation;
|
|
equationY: ContactEquation;
|
|
equationZ: ContactEquation;
|
|
constructor(bodyA: Body, pivotA: Vec3 | undefined, bodyB: Body, pivotB?: Vec3, maxForce?: number);
|
|
update(): void;
|
|
}
|
|
}
|
|
declare module "equations/ConeEquation" {
|
|
import { Vec3 } from "math/Vec3";
|
|
import { Equation } from "equations/Equation";
|
|
import type { Body } from "objects/Body";
|
|
export type ConeEquationOptions = ConstructorParameters<typeof ConeEquation>[2];
|
|
export class ConeEquation extends Equation {
|
|
axisA: Vec3;
|
|
axisB: Vec3;
|
|
angle: number;
|
|
constructor(bodyA: Body, bodyB: Body, options?: {
|
|
maxForce?: number;
|
|
axisA?: Vec3;
|
|
axisB?: Vec3;
|
|
angle?: number;
|
|
});
|
|
computeB(h: number): number;
|
|
}
|
|
}
|
|
declare module "equations/RotationalEquation" {
|
|
import { Equation } from "equations/Equation";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Body } from "objects/Body";
|
|
export type RotationalEquationOptions = ConstructorParameters<typeof RotationalEquation>[2];
|
|
export class RotationalEquation extends Equation {
|
|
axisA: Vec3;
|
|
axisB: Vec3;
|
|
maxAngle: number;
|
|
constructor(bodyA: Body, bodyB: Body, options?: {
|
|
axisA?: Vec3;
|
|
axisB?: Vec3;
|
|
maxAngle?: number;
|
|
maxForce?: number;
|
|
});
|
|
computeB(h: number): number;
|
|
}
|
|
}
|
|
declare module "constraints/ConeTwistConstraint" {
|
|
import { PointToPointConstraint } from "constraints/PointToPointConstraint";
|
|
import { ConeEquation } from "equations/ConeEquation";
|
|
import { RotationalEquation } from "equations/RotationalEquation";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Body } from "objects/Body";
|
|
export type ConeTwistConstraintOptions = ConstructorParameters<typeof ConeTwistConstraint>[2];
|
|
export class ConeTwistConstraint extends PointToPointConstraint {
|
|
axisA: Vec3;
|
|
axisB: Vec3;
|
|
angle: number;
|
|
twistAngle: number;
|
|
coneEquation: ConeEquation;
|
|
twistEquation: RotationalEquation;
|
|
constructor(bodyA: Body, bodyB: Body, options?: {
|
|
pivotA?: Vec3;
|
|
pivotB?: Vec3;
|
|
axisA?: Vec3;
|
|
axisB?: Vec3;
|
|
angle?: number;
|
|
twistAngle?: number;
|
|
maxForce?: number;
|
|
collideConnected?: boolean;
|
|
});
|
|
update(): void;
|
|
}
|
|
}
|
|
declare module "constraints/DistanceConstraint" {
|
|
import { Constraint } from "constraints/Constraint";
|
|
import { ContactEquation } from "equations/ContactEquation";
|
|
import type { Body } from "objects/Body";
|
|
export class DistanceConstraint extends Constraint {
|
|
distance: number;
|
|
distanceEquation: ContactEquation;
|
|
constructor(bodyA: Body, bodyB: Body, distance?: number, maxForce?: number);
|
|
update(): void;
|
|
}
|
|
}
|
|
declare module "equations/RotationalMotorEquation" {
|
|
import { Equation } from "equations/Equation";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Body } from "objects/Body";
|
|
export class RotationalMotorEquation extends Equation {
|
|
axisA: Vec3;
|
|
axisB: Vec3;
|
|
targetVelocity: number;
|
|
constructor(bodyA: Body, bodyB: Body, maxForce?: number);
|
|
computeB(h: number): number;
|
|
}
|
|
}
|
|
declare module "constraints/LockConstraint" {
|
|
import { PointToPointConstraint } from "constraints/PointToPointConstraint";
|
|
import { RotationalEquation } from "equations/RotationalEquation";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Body } from "objects/Body";
|
|
import type { RotationalMotorEquation } from "equations/RotationalMotorEquation";
|
|
export type LockConstraintOptions = ConstructorParameters<typeof LockConstraint>[2];
|
|
export class LockConstraint extends PointToPointConstraint {
|
|
xA: Vec3;
|
|
xB: Vec3;
|
|
yA: Vec3;
|
|
yB: Vec3;
|
|
zA: Vec3;
|
|
zB: Vec3;
|
|
rotationalEquation1: RotationalEquation;
|
|
rotationalEquation2: RotationalEquation;
|
|
rotationalEquation3: RotationalEquation;
|
|
motorEquation?: RotationalMotorEquation;
|
|
constructor(bodyA: Body, bodyB: Body, options?: {
|
|
maxForce?: number;
|
|
});
|
|
update(): void;
|
|
}
|
|
}
|
|
declare module "constraints/HingeConstraint" {
|
|
import { PointToPointConstraint } from "constraints/PointToPointConstraint";
|
|
import { RotationalEquation } from "equations/RotationalEquation";
|
|
import { RotationalMotorEquation } from "equations/RotationalMotorEquation";
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Body } from "objects/Body";
|
|
export type HingeConstraintOptions = ConstructorParameters<typeof HingeConstraint>[2];
|
|
export class HingeConstraint extends PointToPointConstraint {
|
|
axisA: Vec3;
|
|
axisB: Vec3;
|
|
rotationalEquation1: RotationalEquation;
|
|
rotationalEquation2: RotationalEquation;
|
|
motorEquation: RotationalMotorEquation;
|
|
constructor(bodyA: Body, bodyB: Body, options?: {
|
|
pivotA?: Vec3;
|
|
pivotB?: Vec3;
|
|
axisA?: Vec3;
|
|
axisB?: Vec3;
|
|
collideConnected?: boolean;
|
|
maxForce?: number;
|
|
});
|
|
enableMotor(): void;
|
|
disableMotor(): void;
|
|
setMotorSpeed(speed: number): void;
|
|
setMotorMaxForce(maxForce: number): void;
|
|
update(): void;
|
|
}
|
|
}
|
|
declare module "objects/Spring" {
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Body } from "objects/Body";
|
|
export type SpringOptions = ConstructorParameters<typeof Spring>[2];
|
|
export class Spring {
|
|
restLength: number;
|
|
stiffness: number;
|
|
damping: number;
|
|
bodyA: Body;
|
|
bodyB: Body;
|
|
localAnchorA: Vec3;
|
|
localAnchorB: Vec3;
|
|
constructor(bodyA: Body, bodyB: Body, options?: {
|
|
restLength?: number;
|
|
stiffness?: number;
|
|
damping?: number;
|
|
localAnchorA?: Vec3;
|
|
localAnchorB?: Vec3;
|
|
worldAnchorA?: Vec3;
|
|
worldAnchorB?: Vec3;
|
|
});
|
|
setWorldAnchorA(worldAnchorA: Vec3): void;
|
|
setWorldAnchorB(worldAnchorB: Vec3): void;
|
|
getWorldAnchorA(result: Vec3): void;
|
|
getWorldAnchorB(result: Vec3): void;
|
|
applyForce(): void;
|
|
}
|
|
}
|
|
declare module "objects/WheelInfo" {
|
|
import { Vec3 } from "math/Vec3";
|
|
import { Transform } from "math/Transform";
|
|
import { RaycastResult } from "collision/RaycastResult";
|
|
import type { Body } from "objects/Body";
|
|
export type WheelInfoOptions = ConstructorParameters<typeof WheelInfo>[0];
|
|
export type WheelRaycastResult = RaycastResult & Partial<{
|
|
suspensionLength: number;
|
|
directionWorld: Vec3;
|
|
groundObject: number;
|
|
}>;
|
|
export class WheelInfo {
|
|
maxSuspensionTravel: number;
|
|
customSlidingRotationalSpeed: number;
|
|
useCustomSlidingRotationalSpeed: boolean;
|
|
sliding: boolean;
|
|
chassisConnectionPointLocal: Vec3;
|
|
chassisConnectionPointWorld: Vec3;
|
|
directionLocal: Vec3;
|
|
directionWorld: Vec3;
|
|
axleLocal: Vec3;
|
|
axleWorld: Vec3;
|
|
suspensionRestLength: number;
|
|
suspensionMaxLength: number;
|
|
radius: number;
|
|
suspensionStiffness: number;
|
|
dampingCompression: number;
|
|
dampingRelaxation: number;
|
|
frictionSlip: number;
|
|
forwardAcceleration: number;
|
|
sideAcceleration: number;
|
|
steering: number;
|
|
rotation: number;
|
|
deltaRotation: number;
|
|
rollInfluence: number;
|
|
maxSuspensionForce: number;
|
|
engineForce: number;
|
|
brake: number;
|
|
isFrontWheel: boolean;
|
|
clippedInvContactDotSuspension: number;
|
|
suspensionRelativeVelocity: number;
|
|
suspensionForce: number;
|
|
slipInfo: number;
|
|
skidInfo: number;
|
|
suspensionLength: number;
|
|
sideImpulse: number;
|
|
forwardImpulse: number;
|
|
raycastResult: WheelRaycastResult;
|
|
worldTransform: Transform;
|
|
isInContact: boolean;
|
|
constructor(options?: {
|
|
chassisConnectionPointLocal?: Vec3;
|
|
chassisConnectionPointWorld?: Vec3;
|
|
directionLocal?: Vec3;
|
|
directionWorld?: Vec3;
|
|
axleLocal?: Vec3;
|
|
axleWorld?: Vec3;
|
|
suspensionRestLength?: number;
|
|
suspensionMaxLength?: number;
|
|
radius?: number;
|
|
suspensionStiffness?: number;
|
|
dampingCompression?: number;
|
|
dampingRelaxation?: number;
|
|
frictionSlip?: number;
|
|
forwardAcceleration?: number;
|
|
sideAcceleration?: number;
|
|
steering?: number;
|
|
rotation?: number;
|
|
deltaRotation?: number;
|
|
rollInfluence?: number;
|
|
maxSuspensionForce?: number;
|
|
isFrontWheel?: boolean;
|
|
clippedInvContactDotSuspension?: number;
|
|
suspensionRelativeVelocity?: number;
|
|
suspensionForce?: number;
|
|
slipInfo?: number;
|
|
skidInfo?: number;
|
|
suspensionLength?: number;
|
|
maxSuspensionTravel?: number;
|
|
useCustomSlidingRotationalSpeed?: boolean;
|
|
customSlidingRotationalSpeed?: number;
|
|
});
|
|
updateWheel(chassis: Body): void;
|
|
}
|
|
}
|
|
declare module "objects/RaycastVehicle" {
|
|
import type { Body } from "objects/Body";
|
|
import { WheelInfo } from "objects/WheelInfo";
|
|
import type { WheelInfoOptions } from "objects/WheelInfo";
|
|
import type { Transform } from "math/Transform";
|
|
import type { Constraint } from "constraints/Constraint";
|
|
import type { World } from "world/World";
|
|
export type RaycastVehicleOptions = ConstructorParameters<typeof RaycastVehicle>[0];
|
|
export class RaycastVehicle {
|
|
chassisBody: Body;
|
|
wheelInfos: WheelInfo[];
|
|
sliding: boolean;
|
|
world: World | null;
|
|
indexRightAxis: number;
|
|
indexForwardAxis: number;
|
|
indexUpAxis: number;
|
|
constraints: Constraint[];
|
|
preStepCallback: () => void;
|
|
currentVehicleSpeedKmHour: number;
|
|
numWheelsOnGround: number;
|
|
constructor(options: {
|
|
chassisBody: Body;
|
|
indexRightAxis?: number;
|
|
indexForwardAxis?: number;
|
|
indexUpAxis?: number;
|
|
});
|
|
addWheel(options?: WheelInfoOptions): number;
|
|
setSteeringValue(value: number, wheelIndex: number): void;
|
|
applyEngineForce(value: number, wheelIndex: number): void;
|
|
setBrake(brake: number, wheelIndex: number): void;
|
|
addToWorld(world: World): void;
|
|
private getVehicleAxisWorld;
|
|
updateVehicle(timeStep: number): void;
|
|
updateSuspension(deltaTime: number): void;
|
|
removeFromWorld(world: World): void;
|
|
castRay(wheel: WheelInfo): number;
|
|
updateWheelTransformWorld(wheel: WheelInfo): void;
|
|
updateWheelTransform(wheelIndex: number): void;
|
|
getWheelTransformWorld(wheelIndex: number): Transform;
|
|
updateFriction(timeStep: number): void;
|
|
}
|
|
}
|
|
declare module "objects/RigidVehicle" {
|
|
import { Vec3 } from "math/Vec3";
|
|
import { Body } from "objects/Body";
|
|
import { HingeConstraint } from "constraints/HingeConstraint";
|
|
import type { World } from "world/World";
|
|
export type RigidVehicleOptions = ConstructorParameters<typeof RigidVehicle>[0];
|
|
export class RigidVehicle {
|
|
wheelBodies: Body[];
|
|
coordinateSystem: Vec3;
|
|
chassisBody: Body;
|
|
constraints: (HingeConstraint & {
|
|
motorTargetVelocity?: number;
|
|
})[];
|
|
wheelAxes: Vec3[];
|
|
wheelForces: number[];
|
|
constructor(options?: {
|
|
coordinateSystem?: Vec3;
|
|
chassisBody?: Body;
|
|
});
|
|
addWheel(options?: {
|
|
body?: Body;
|
|
position?: Vec3;
|
|
axis?: Vec3;
|
|
direction?: Vec3;
|
|
}): number;
|
|
setSteeringValue(value: number, wheelIndex: number): void;
|
|
setMotorSpeed(value: number, wheelIndex: number): void;
|
|
disableMotor(wheelIndex: number): void;
|
|
setWheelForce(value: number, wheelIndex: number): void;
|
|
applyWheelForce(value: number, wheelIndex: number): void;
|
|
addToWorld(world: World): void;
|
|
private _update;
|
|
removeFromWorld(world: World): void;
|
|
getWheelSpeed(wheelIndex: number): number;
|
|
}
|
|
}
|
|
declare module "objects/SPHSystem" {
|
|
import { Vec3 } from "math/Vec3";
|
|
import type { Body } from "objects/Body";
|
|
export class SPHSystem {
|
|
particles: Body[];
|
|
density: number;
|
|
smoothingRadius: number;
|
|
speedOfSound: number;
|
|
viscosity: number;
|
|
eps: number;
|
|
pressures: number[];
|
|
densities: number[];
|
|
neighbors: Body[][];
|
|
constructor();
|
|
add(particle: Body): void;
|
|
remove(particle: Body): void;
|
|
getNeighbors(particle: Body, neighbors: Body[]): void;
|
|
update(): void;
|
|
w(r: number): number;
|
|
gradw(rVec: Vec3, resultVec: Vec3): void;
|
|
nablaw(r: number): number;
|
|
}
|
|
}
|
|
declare module "solver/SplitSolver" {
|
|
import { Solver } from "solver/Solver";
|
|
import { Body } from "objects/Body";
|
|
import type { Equation } from "equations/Equation";
|
|
import type { World } from "world/World";
|
|
import { GSSolver } from "solver/GSSolver";
|
|
type SplitSolverNode = {
|
|
body: Body | null;
|
|
children: SplitSolverNode[];
|
|
eqs: Equation[];
|
|
visited: boolean;
|
|
};
|
|
export class SplitSolver extends Solver {
|
|
iterations: number;
|
|
tolerance: number;
|
|
subsolver: GSSolver;
|
|
nodes: SplitSolverNode[];
|
|
nodePool: SplitSolverNode[];
|
|
constructor(subsolver: GSSolver);
|
|
createNode(): SplitSolverNode;
|
|
solve(dt: number, world: World): number;
|
|
}
|
|
}
|
|
declare module "cannon-es" {
|
|
export * from "collision/ObjectCollisionMatrix";
|
|
export * from "collision/AABB";
|
|
export * from "collision/ArrayCollisionMatrix";
|
|
export * from "collision/Broadphase";
|
|
export * from "collision/GridBroadphase";
|
|
export * from "collision/NaiveBroadphase";
|
|
export * from "collision/Ray";
|
|
export * from "collision/RaycastResult";
|
|
export * from "collision/SAPBroadphase";
|
|
export * from "constraints/ConeTwistConstraint";
|
|
export * from "constraints/Constraint";
|
|
export * from "constraints/DistanceConstraint";
|
|
export * from "constraints/LockConstraint";
|
|
export * from "constraints/PointToPointConstraint";
|
|
export * from "constraints/HingeConstraint";
|
|
export * from "equations/ContactEquation";
|
|
export * from "equations/Equation";
|
|
export * from "equations/FrictionEquation";
|
|
export * from "equations/RotationalEquation";
|
|
export * from "equations/RotationalMotorEquation";
|
|
export * from "material/ContactMaterial";
|
|
export * from "material/Material";
|
|
export * from "math/Quaternion";
|
|
export * from "math/Mat3";
|
|
export * from "math/Transform";
|
|
export * from "math/Vec3";
|
|
export * from "math/JacobianElement";
|
|
export * from "objects/Body";
|
|
export * from "objects/Spring";
|
|
export * from "objects/RaycastVehicle";
|
|
export * from "objects/WheelInfo";
|
|
export * from "objects/RigidVehicle";
|
|
export * from "objects/SPHSystem";
|
|
export * from "shapes/Box";
|
|
export * from "shapes/ConvexPolyhedron";
|
|
export * from "shapes/Cylinder";
|
|
export * from "shapes/Particle";
|
|
export * from "shapes/Plane";
|
|
export * from "shapes/Shape";
|
|
export * from "shapes/Sphere";
|
|
export * from "shapes/Heightfield";
|
|
export * from "shapes/Trimesh";
|
|
export * from "solver/GSSolver";
|
|
export * from "solver/Solver";
|
|
export * from "solver/SplitSolver";
|
|
export * from "utils/Pool";
|
|
export * from "utils/EventTarget";
|
|
export * from "utils/Vec3Pool";
|
|
export * from "world/Narrowphase";
|
|
export * from "world/World";
|
|
}
|