npm - @perplexdotgg/bounce - Versions diffs - 1.0.0 - Mend

@perplexdotgg/bounce 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (140) hide show

package/LICENSE +21 -0
package/README.md +30 -0
package/package.json +32 -0
package/src/builders/ConvexHullBuilder.ts +437 -0
package/src/builders/ConvexHullBuilder2d.ts +344 -0
package/src/builders/ConvexHullBuilder3d.ts +1689 -0
package/src/builders/HeightMapBuilder.ts +414 -0
package/src/builders/TriangleMeshBuilder.ts +92 -0
package/src/collision/CastShapesModule.ts +184 -0
package/src/collision/CollideShapesModule.ts +152 -0
package/src/collision/HeightMapCaster.ts +38 -0
package/src/collision/HeightMapCollider.ts +33 -0
package/src/collision/TriangleCaster.ts +249 -0
package/src/collision/TriangleCollider.ts +308 -0
package/src/collision/TriangleCollider2.ts +379 -0
package/src/collision/activeEdge.ts +146 -0
package/src/collision/cast/cast.ts +139 -0
package/src/collision/cast/castCompoundVsCompound.ts +59 -0
package/src/collision/cast/castCompoundVsConvex.ts +116 -0
package/src/collision/cast/castConvexVsCompound.ts +123 -0
package/src/collision/cast/castConvexVsConvex.ts +213 -0
package/src/collision/cast/castConvexVsHeightMap.ts +73 -0
package/src/collision/cast/castConvexVsTriangleMesh.ts +56 -0
package/src/collision/cast/castRayVsCompound.ts +44 -0
package/src/collision/cast/castRayVsConvex.ts +45 -0
package/src/collision/cast/castRayVsHeightMap.ts +58 -0
package/src/collision/cast/castRayVsTriangleMesh.ts +58 -0
package/src/collision/closestPoints/closestPoints.ts +23 -0
package/src/collision/closestPoints/computeBarycentricCoordinates2d.ts +32 -0
package/src/collision/closestPoints/computeBarycentricCoordinates3d.ts +81 -0
package/src/collision/closestPoints/computeClosestPointOnLine.ts +30 -0
package/src/collision/closestPoints/computeClosestPointOnTetrahedron.ts +96 -0
package/src/collision/closestPoints/computeClosestPointOnTriangle.ts +195 -0
package/src/collision/closestPoints/isOriginOutsideOfPlane.ts +25 -0
package/src/collision/closestPoints/isOriginOutsideOfTrianglePlanes.ts +72 -0
package/src/collision/collide/collide.ts +146 -0
package/src/collision/collide/collideCompoundVsCompound.ts +60 -0
package/src/collision/collide/collideCompoundVsConvex.ts +59 -0
package/src/collision/collide/collideCompoundVsHeightMap.ts +73 -0
package/src/collision/collide/collideCompoundVsTriangleMesh.ts +56 -0
package/src/collision/collide/collideConvexVsCompound.ts +57 -0
package/src/collision/collide/collideConvexVsConvex.ts +225 -0
package/src/collision/collide/collideConvexVsConvexImp.ts +236 -0
package/src/collision/collide/collideConvexVsHeightMap.ts +53 -0
package/src/collision/collide/collideConvexVsTriangleMesh.ts +58 -0
package/src/collision/collide/collideHeightMapVsCompound.ts +69 -0
package/src/collision/collide/collideHeightMapVsConvex.ts +53 -0
package/src/collision/collide/collideSphereVsSphere.ts +81 -0
package/src/collision/collide/collideTriangleMeshVsCompound.ts +58 -0
package/src/collision/collide/collideTriangleMeshVsConvex.ts +58 -0
package/src/collision/epa/EpaConvexHullBuilder.ts +397 -0
package/src/collision/epa/StaticArray.ts +154 -0
package/src/collision/epa/TriangleFactory.ts +32 -0
package/src/collision/epa/arrays.ts +99 -0
package/src/collision/epa/binaryHeap.ts +82 -0
package/src/collision/epa/structs.ts +227 -0
package/src/collision/gjk/GjkModule.ts +864 -0
package/src/collision/gjk/PenetrationDepthModule.ts +493 -0
package/src/collision/gjk/SupportPoints.ts +50 -0
package/src/collision/imp/MinkowskiDifference.ts +36 -0
package/src/collision/imp/computeExploredDistanceLowerUpperBound.ts +40 -0
package/src/collision/imp/finalizeImpResult.ts +69 -0
package/src/collision/imp/findContactImp.ts +196 -0
package/src/collision/imp/imp.ts +28 -0
package/src/collision/imp/incrementalMinimumDistanceExploreDirection.ts +207 -0
package/src/collision/mpr/findPortal.ts +152 -0
package/src/collision/mpr/mpr.ts +29 -0
package/src/collision/mpr/updatePortal.ts +52 -0
package/src/constraints/BaseConstraint.ts +50 -0
package/src/constraints/ConstraintOptions.ts +22 -0
package/src/constraints/ConstraintSolver.ts +119 -0
package/src/constraints/DistanceConstraint.ts +229 -0
package/src/constraints/FixedConstraint.ts +203 -0
package/src/constraints/HingeConstraint.ts +460 -0
package/src/constraints/PointConstraint.ts +108 -0
package/src/constraints/components/AngleComponent.ts +226 -0
package/src/constraints/components/AxisComponent.ts +263 -0
package/src/constraints/components/HingeComponent.ts +215 -0
package/src/constraints/components/Motor.ts +36 -0
package/src/constraints/components/PointConstraintComponent.ts +179 -0
package/src/constraints/components/RotationEulerComponent.ts +139 -0
package/src/constraints/components/Spring.ts +30 -0
package/src/constraints/components/SpringComponent.ts +71 -0
package/src/constraints/types.ts +6 -0
package/src/helpers.ts +147 -0
package/src/index.ts +50 -0
package/src/math/BasicTransform.ts +19 -0
package/src/math/NumberValue.ts +13 -0
package/src/math/isometry.ts +64 -0
package/src/math/mat3.ts +529 -0
package/src/math/mat4.ts +588 -0
package/src/math/quat.ts +193 -0
package/src/math/scalar.ts +81 -0
package/src/math/tensor.ts +17 -0
package/src/math/vec3.ts +589 -0
package/src/math/vec4.ts +10 -0
package/src/physics/Body.ts +581 -0
package/src/physics/CollisionFilter.ts +52 -0
package/src/physics/SleepModule.ts +163 -0
package/src/physics/broadphase/BodyPairsModule.ts +363 -0
package/src/physics/broadphase/BvhModule.ts +237 -0
package/src/physics/broadphase/BvhTree.ts +803 -0
package/src/physics/broadphase/ConstraintPairsModule.ts +385 -0
package/src/physics/broadphase/TriangleMeshBvhTree.ts +379 -0
package/src/physics/manifold/ContactManifold.ts +227 -0
package/src/physics/manifold/ContactManifoldModule.ts +623 -0
package/src/physics/manifold/Face.ts +119 -0
package/src/physics/manifold/ManifoldCache.ts +116 -0
package/src/physics/manifold/clipping/clipPolyVsEdge.ts +131 -0
package/src/physics/manifold/clipping/clipPolyVsPlane.ts +73 -0
package/src/physics/manifold/clipping/clipPolyVsPoly.ts +72 -0
package/src/physics/narrowphase/CollideBodiesModule.ts +755 -0
package/src/physics/solver/ContactConstraintModule.ts +659 -0
package/src/physics/solver/ManifoldConstraint.ts +420 -0
package/src/physics/solver/estimateCollisionResponse.ts +146 -0
package/src/shape/Aabb.ts +400 -0
package/src/shape/Box.ts +231 -0
package/src/shape/Capsule.ts +332 -0
package/src/shape/CompoundShape.ts +288 -0
package/src/shape/Convex.ts +130 -0
package/src/shape/ConvexHull.ts +423 -0
package/src/shape/Cylinder.ts +313 -0
package/src/shape/HeightMap.ts +511 -0
package/src/shape/Line.ts +14 -0
package/src/shape/Plane.ts +116 -0
package/src/shape/Ray.ts +81 -0
package/src/shape/Segment.ts +25 -0
package/src/shape/Shape.ts +77 -0
package/src/shape/Sphere.ts +181 -0
package/src/shape/TransformedShape.ts +51 -0
package/src/shape/Triangle.ts +122 -0
package/src/shape/TriangleMesh.ts +186 -0
package/src/types.ts +1 -0
package/src/world.ts +1335 -0
package/tests/BodyPairsModule.test.ts +71 -0
package/tests/BvhTree.test.ts +406 -0
package/tests/test.md +642 -0
package/tests/vec3.test.ts +12 -0
package/tsconfig.json +20 -0
package/vite.config.js +40 -0

package/src/constraints/components/Motor.ts ADDED Viewed

@@ -0,0 +1,36 @@
+import { createClass, MonomorphType, NumberType, PropertyDefinitionMap } from "monomorph";
+import { Spring, SpringMode } from "./Spring";
+export const enum MotorMode {
+  Off,
+  Position,
+  Velocity,
+}
+const motorProps = {
+  spring: MonomorphType(Spring, { mode: SpringMode.UseFrequency, damping: 1.0, frequency: 2.0, stiffness: 2.0 }),
+  minForce: NumberType(-Infinity),
+  maxForce: NumberType(+Infinity),
+  minTorque: NumberType(-Infinity),
+  maxTorque: NumberType(+Infinity),
+  mode: NumberType(MotorMode.Off),
+} as const satisfies PropertyDefinitionMap;
+export class Motor extends createClass<Motor, typeof motorProps>(motorProps) {
+  reset(): void {
+    this.spring.reset();
+    this.spring.mode = SpringMode.UseFrequency;
+    this.spring.damping = 1.0;
+    this.spring.frequency = 2.0;
+    this.spring.stiffness = 2.0;
+    this.minForce = -Infinity;
+    this.maxForce = +Infinity;
+    this.minTorque = -Infinity;
+    this.maxTorque = +Infinity;
+    this.mode = MotorMode.Off;
+  }
+  isValid(): boolean {
+    return this.spring.isValid() && this.minForce <= this.maxForce && this.minTorque <= this.maxTorque;
+  }
+}

package/src/constraints/components/PointConstraintComponent.ts ADDED Viewed

@@ -0,0 +1,179 @@
+import {
+  createClass,
+  LazyReferenceType,
+  MonomorphType,
+  PropertyDefinitionMap,
+  PropertyDefinitionReference,
+} from "monomorph";
+import { ConstraintOptions } from "../ConstraintOptions";
+import { Vec3 } from "../../math/vec3";
+import { Mat3 } from "../../math/mat3";
+import type { World } from "../../world";
+import { Body, BodyType } from "../../physics/Body";
+const pointConstraintComponentProps = {
+  bodyA: LazyReferenceType((() => Body) as () => never) as PropertyDefinitionReference<Body | null, true>,
+  bodyB: LazyReferenceType((() => Body) as () => never) as PropertyDefinitionReference<Body | null, true>,
+  options: MonomorphType(ConstraintOptions, {
+    positionBaumgarte: 0.8,
+    velocityBaumgarte: 1.0,
+    strength: 1.0,
+  }),
+  momentArmA: MonomorphType(Vec3, undefined, true),
+  momentArmB: MonomorphType(Vec3, undefined, true),
+  effectiveMass: MonomorphType(Mat3, undefined, true),
+  effectiveInverseInertiaA: MonomorphType(Mat3, undefined, true),
+  effectiveInverseInertiaB: MonomorphType(Mat3, undefined, true),
+  totalLambda: MonomorphType(Vec3, undefined, true),
+} as const satisfies PropertyDefinitionMap;
+export class PointConstraintComponent extends createClass<
+  PointConstraintComponent,
+  typeof pointConstraintComponentProps
+>(pointConstraintComponentProps) {
+  declare world: World;
+  deactivate(): void {
+    this.effectiveMass.zero();
+    this.totalLambda.zero();
+  }
+  isActive(): boolean {
+    // TODO: should probably just track using an isActive flag
+    return !this.effectiveMass.isExactlyZero();
+  }
+  applyDirectImpulse(impulse: Vec3): void {
+    if (impulse.isExactlyZero()) {
+      return;
+    }
+    const bodyA = this.bodyA!;
+    const bodyB = this.bodyB!;
+    if (bodyA.type === BodyType.dynamic) {
+      bodyA.linearVelocity.subScaledVector(impulse, bodyA.inverseMass);
+      bodyA.angularVelocity.subRotatedVector(impulse, this.effectiveInverseInertiaA);
+    }
+    if (bodyB.type === BodyType.dynamic) {
+      bodyB.linearVelocity.addScaledVector(impulse, bodyB.inverseMass);
+      bodyB.angularVelocity.addRotatedVector(impulse, this.effectiveInverseInertiaB);
+    }
+  }
+  setup(localMomentArmA: Vec3, localMomentArmB: Vec3): void {
+    const bodyA = this.bodyA!;
+    const bodyB = this.bodyB!;
+    rotateLocalToWorldA.fromQuat(bodyA!.orientation);
+    rotateLocalToWorldB.fromQuat(bodyB!.orientation);
+    // calculate the moment arms in world space
+    this.momentArmA.transformVectorFromMat3(localMomentArmA, rotateLocalToWorldA);
+    this.momentArmB.transformVectorFromMat3(localMomentArmB, rotateLocalToWorldB);
+    // calculate the effective mass
+    let totalInverseMass = 0;
+    inverseEffectiveMass.zero();
+    if (bodyA.type === BodyType.dynamic) {
+      totalInverseMass += bodyA.inverseMass;
+      bodyA.computeInverseInertiaTensor(inverseInertia);
+      crossMatrix.asSkewSymmetricMatrix(this.momentArmA);
+      this.effectiveInverseInertiaA.multiplyMatrices(inverseInertia, crossMatrix);
+      tempMatrix.multiplyMatrices(crossMatrix, inverseInertia);
+      tempMatrix.multiplyMat3RightTransposed(crossMatrix);
+      inverseEffectiveMass.addMatrices(inverseEffectiveMass, tempMatrix);
+    }
+    if (bodyB.type === BodyType.dynamic) {
+      totalInverseMass += bodyB.inverseMass;
+      bodyB.computeInverseInertiaTensor(inverseInertia);
+      crossMatrix.asSkewSymmetricMatrix(this.momentArmB);
+      this.effectiveInverseInertiaB.multiplyMatrices(inverseInertia, crossMatrix);
+      tempMatrix.multiplyMatrices(crossMatrix, inverseInertia);
+      tempMatrix.multiplyMat3RightTransposed(crossMatrix);
+      inverseEffectiveMass.addMatrices(inverseEffectiveMass, tempMatrix);
+    }
+    // add the inverse mass
+    totalInverseMassMatrix.identity();
+    totalInverseMassMatrix.multiplyMatrixByScalar(totalInverseMassMatrix, totalInverseMass);
+    inverseEffectiveMass.addMatrices(inverseEffectiveMass, totalInverseMassMatrix);
+    const isValid = this.effectiveMass.invertMat3(inverseEffectiveMass);
+    if (isValid === null) {
+      this.deactivate();
+    }
+    this.effectiveMass.multiplyByScalar(this.options.strength);
+  }
+  warmStart(warmStartImpulseRatio: number): void {
+    this.totalLambda.scale(warmStartImpulseRatio);
+    this.applyDirectImpulse(this.totalLambda);
+  }
+  solveVelocity(): void {
+    const bodyA = this.bodyA!;
+    const bodyB = this.bodyB!;
+    // compute the partial lambda for current velocity
+    bodyA.computePointVelocity(pointVelocityA, this.momentArmA);
+    bodyB.computePointVelocity(pointVelocityB, this.momentArmB);
+    lambda.subtractVectors(pointVelocityA, pointVelocityB);
+    lambda.scale(this.options.velocityBaumgarte);
+    lambda.transformVectorFromMat3(lambda, this.effectiveMass);
+    // accumulate the lambda
+    this.totalLambda.addVector(lambda);
+    // apply the lambda
+    this.applyDirectImpulse(lambda);
+  }
+  solvePosition(): void {
+    const bodyA = this.bodyA!;
+    const bodyB = this.bodyB!;
+    separation.subtractVectors(bodyB.computedCenterOfMassPosition, bodyA.computedCenterOfMassPosition);
+    separation.addVector(this.momentArmB);
+    separation.subtractVector(this.momentArmA);
+    // case: no separation
+    if (separation.isNearZero(1e-18)) {
+      return;
+    }
+    // case: separation
+    lambda.scaleVector(separation, -this.options.positionBaumgarte);
+    lambda.transformVectorFromMat3(lambda, this.effectiveMass);
+    if (bodyA.type === BodyType.dynamic) {
+      bodyA.computedCenterOfMassPosition.subScaledVector(lambda, bodyA.inverseMass);
+      bodyA.subRotationPositionImpulse(lambda, this.effectiveInverseInertiaA);
+    }
+    if (bodyB.type === BodyType.dynamic) {
+      bodyB.computedCenterOfMassPosition.addScaledVector(lambda, bodyB.inverseMass);
+      bodyB.addRotationPositionImpulse(lambda, this.effectiveInverseInertiaB);
+    }
+  }
+}
+const rotateLocalToWorldA = /*@__PURE__*/ Mat3.create();
+const rotateLocalToWorldB = /*@__PURE__*/ Mat3.create();
+const inverseEffectiveMass = /*@__PURE__*/ Mat3.create();
+const inverseInertia = /*@__PURE__*/ Mat3.create();
+const crossMatrix = /*@__PURE__*/ Mat3.create();
+const tempMatrix = /*@__PURE__*/ Mat3.create();
+const totalInverseMassMatrix = /*@__PURE__*/ Mat3.create();
+const pointVelocityA = /*@__PURE__*/ Vec3.create();
+const pointVelocityB = /*@__PURE__*/ Vec3.create();
+const separation = /*@__PURE__*/ Vec3.create();
+const lambda = /*@__PURE__*/ Vec3.create();

package/src/constraints/components/RotationEulerComponent.ts ADDED Viewed

@@ -0,0 +1,139 @@
+import {
+  createClass,
+  LazyReferenceType,
+  MonomorphType,
+  PropertyDefinitionMap,
+  PropertyDefinitionReference,
+} from "monomorph";
+import { ConstraintOptions } from "../ConstraintOptions";
+import { Mat3 } from "../../math/mat3";
+import { Vec3 } from "../../math/vec3";
+import { Body, BodyType } from "../../physics/Body";
+import type { World } from "../../world";
+import { Quat } from "../../math/quat";
+const rotationEulerComponentProps = {
+  bodyA: LazyReferenceType((() => Body) as () => never) as PropertyDefinitionReference<Body | null, true>,
+  bodyB: LazyReferenceType((() => Body) as () => never) as PropertyDefinitionReference<Body | null, true>,
+  options: MonomorphType(ConstraintOptions, {
+    positionBaumgarte: 0.8,
+    velocityBaumgarte: 1.0,
+    strength: 1.0,
+  }),
+  mInvI1: MonomorphType(Mat3, undefined, true),
+  mInvI2: MonomorphType(Mat3, undefined, true),
+  effectiveMassRotationComponent: MonomorphType(Mat3, undefined, true),
+  totalLambdaRotationComponent: MonomorphType(Vec3, undefined, true),
+} as const satisfies PropertyDefinitionMap;
+export class RotationEulerComponent extends createClass<RotationEulerComponent, typeof rotationEulerComponentProps>(
+  rotationEulerComponentProps
+) {
+  declare world: World;
+  deactivate(): void {
+    this.effectiveMassRotationComponent.zero();
+    this.totalLambdaRotationComponent.zero();
+  }
+  isActive(): boolean {
+    return !this.effectiveMassRotationComponent.isExactlyZero();
+  }
+  applyDirectImpulse(impulse: Vec3): void {
+    if (impulse.isExactlyZero()) {
+      return;
+    }
+    const bodyA = this.bodyA!;
+    const bodyB = this.bodyB!;
+    if (bodyA.type === BodyType.dynamic) {
+      bodyA.angularVelocity.subRotatedVector(impulse, this.mInvI1);
+    }
+    if (bodyB.type === BodyType.dynamic) {
+      bodyB.angularVelocity.addRotatedVector(impulse, this.mInvI2);
+    }
+  }
+  setup(): void {
+    const bodyA = this.bodyA!;
+    const bodyB = this.bodyB!;
+    if (bodyA.type === BodyType.dynamic) {
+      bodyA.computeInverseInertiaTensor(this.mInvI1);
+    } else {
+      this.mInvI1.zero();
+    }
+    if (bodyB.type === BodyType.dynamic) {
+      bodyB.computeInverseInertiaTensor(this.mInvI2);
+    } else {
+      this.mInvI2.zero();
+    }
+    this.effectiveMassRotationComponent.addMatrices(this.mInvI1, this.mInvI2);
+    const isValid = this.effectiveMassRotationComponent.invertMat3(this.effectiveMassRotationComponent);
+    if (isValid === null) {
+      this.deactivate();
+    }
+    this.effectiveMassRotationComponent.multiplyByScalar(this.options.strength);
+  }
+  warmStart(warmStartImpulseRatio: number): void {
+    this.totalLambdaRotationComponent.scale(warmStartImpulseRatio);
+    this.applyDirectImpulse(this.totalLambdaRotationComponent);
+  }
+  solveVelocity(): void {
+    const bodyA = this.bodyA!;
+    const bodyB = this.bodyB!;
+    // compute the partial lambda for current velocity
+    lambda.subtractVectors(bodyA!.angularVelocity, bodyB!.angularVelocity);
+    lambda.scale(this.options.velocityBaumgarte);
+    lambda.transformVectorFromMat3(lambda, this.effectiveMassRotationComponent);
+    this.totalLambdaRotationComponent.addVector(lambda);
+    this.applyDirectImpulse(lambda);
+  }
+  solvePosition(inverseInitialRotationAToB: Quat): void {
+    const bodyA = this.bodyA!;
+    const bodyB = this.bodyB!;
+    inverseRotationA.conjugateQuat(bodyA.orientation);
+    quaternionError.multiplyQuats(bodyB.orientation, inverseInitialRotationAToB);
+    quaternionError.multiplyQuats(quaternionError, inverseRotationA);
+    // TODO: this only works if error is small, handle large errors
+    quaternionError.intoEuler(eulerError);
+    if (eulerError.isNearZero(1e-18)) {
+      return;
+    }
+    lambda.scaleVector(eulerError, -this.options.positionBaumgarte);
+    lambda.transformVectorFromMat3(lambda, this.effectiveMassRotationComponent);
+    if (bodyA.type === BodyType.dynamic) {
+      angularImpulse.transformVectorFromMat3(lambda, this.mInvI1);
+      angularImpulse.scaleVector(angularImpulse, 1);
+      bodyA.subRotationDelta(angularImpulse);
+    }
+    if (bodyB.type === BodyType.dynamic) {
+      angularImpulse.transformVectorFromMat3(lambda, this.mInvI2);
+      angularImpulse.scaleVector(angularImpulse, 1);
+      bodyB.addRotationDelta(angularImpulse);
+    }
+  }
+}
+const lambda = /*@__PURE__*/ Vec3.create();
+const quaternionError = /*@__PURE__*/ Quat.create();
+const inverseRotationA = /*@__PURE__*/ Quat.create();
+const eulerError = /*@__PURE__*/ Vec3.create();
+const angularImpulse = /*@__PURE__*/ Vec3.create();

package/src/constraints/components/Spring.ts ADDED Viewed

@@ -0,0 +1,30 @@
+import { createClass, NumberType, PropertyDefinitionMap } from "monomorph";
+export const enum SpringMode {
+  UseFrequency,
+  UseStiffness,
+}
+const springProps = {
+  mode: NumberType(SpringMode.UseFrequency),
+  damping: NumberType(0),
+  frequency: NumberType(0),
+  stiffness: NumberType(0),
+} as const satisfies PropertyDefinitionMap;
+export class Spring extends createClass<Spring, typeof springProps>(springProps) {
+  reset(): void {
+    this.mode = SpringMode.UseFrequency;
+    this.frequency = 0;
+    this.damping = 0;
+    this.stiffness = 0;
+  }
+  hasStiffness(): boolean {
+    return this.frequency > 0;
+  }
+  isValid(): boolean {
+    return this.frequency >= 0 && this.damping >= 0 && this.stiffness >= 0;
+  }
+}

package/src/constraints/components/SpringComponent.ts ADDED Viewed

@@ -0,0 +1,71 @@
+import { createClass, NumberType, PropertyDefinitionMap } from "monomorph";
+import { squared } from "../../math/scalar";
+const springComponentProps = {
+  bias: NumberType(0),
+  softness: NumberType(0),
+} as const satisfies PropertyDefinitionMap;
+export class SpringComponent extends createClass<SpringComponent, typeof springComponentProps>(springComponentProps) {
+  getBias(lambda: number): number {
+    return this.softness * lambda + this.bias;
+  }
+  isActive(): boolean {
+    return this.softness !== 0;
+  }
+  setupSpringProperties(
+    deltaTime: number,
+    inverseEffectiveMass: number,
+    bias: number,
+    constraint: number,
+    stiffness: number,
+    damping: number
+  ): number {
+    this.softness = 1 / (deltaTime * (damping * deltaTime * stiffness));
+    this.bias = bias + deltaTime * stiffness * this.softness * constraint;
+    return 1 / (inverseEffectiveMass + this.softness);
+  }
+  setupSpringPropertiesWithBias(bias: number): void {
+    this.bias = bias;
+    this.softness = 0;
+  }
+  setupWithFrequency(
+    deltaTime: number,
+    inverseEffectiveMass: number,
+    bias: number,
+    constraint: number,
+    frequency: number,
+    damping: number
+  ): number {
+    const effectiveMass = 1 / inverseEffectiveMass;
+    if (frequency > 0) {
+      const omega = 2 * Math.PI * frequency;
+      const k = effectiveMass * squared(omega);
+      const c = 2 * effectiveMass * damping * omega;
+      return this.setupSpringProperties(deltaTime, inverseEffectiveMass, bias, constraint, k, c);
+    } else {
+      this.setupSpringPropertiesWithBias(bias);
+      return effectiveMass;
+    }
+  }
+  setupWithStiffness(
+    deltaTime: number,
+    inverseEffectiveMass: number,
+    bias: number,
+    constraint: number,
+    stiffness: number,
+    damping: number
+  ): number {
+    if (stiffness > 0) {
+      return this.setupSpringProperties(deltaTime, inverseEffectiveMass, bias, constraint, stiffness, damping);
+    } else {
+      this.setupSpringPropertiesWithBias(bias);
+      return 1 / inverseEffectiveMass;
+    }
+  }
+}

package/src/constraints/types.ts ADDED Viewed

@@ -0,0 +1,6 @@
+import { DistanceConstraint } from "./DistanceConstraint";
+import { FixedConstraint } from "./FixedConstraint";
+import { HingeConstraint } from "./HingeConstraint";
+import { PointConstraint } from "./PointConstraint";
+export type Constraint = PointConstraint | DistanceConstraint | FixedConstraint | HingeConstraint;

package/src/helpers.ts ADDED Viewed

@@ -0,0 +1,147 @@
+import { Monomorph, MonomorphInstance, PoolClass, PropertyDefinitionMap } from "monomorph";
+export function assert(condition: boolean, message: string) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+export function destroyAllInstancesInPool<T extends PoolClass<MonomorphInstance<P, I>>, P extends PropertyDefinitionMap = T extends PoolClass<MonomorphInstance<infer iP, infer iI>> ? iP : never, I extends any = T extends PoolClass<MonomorphInstance<infer iP, infer iI>> ? iI : never>(pool: T) {
+  for (let i = 0; i < pool.array.length; i++) {
+    const instance = pool.array[i];
+    if (!instance) {
+      continue;
+    }
+    if (instance.isDestroyed()) {
+      continue;
+    }
+    instance.destroy();
+  }
+}
+export class ArrayPool<T extends { index: number }> {
+  pool: PoolClass<T>;
+  array: T[];
+  _count: number;
+  _capacity: number;
+  constructor(theClass: any, capacity: number) {
+    this._count = 0;
+    this._capacity = capacity;
+    this.pool = new theClass.Pool(capacity);
+    // preallocate the pool with instances
+    for (let i = 0; i < capacity; i++) {
+      theClass.create(undefined, this.pool);
+    }
+    this.array = this.pool.array;
+  }
+  get count() {
+    return this._count;
+  }
+  get capacity() {
+    return this._capacity;
+  }
+  create() {
+    if (this._count >= this.capacity) {
+      return null;
+    }
+    const instance = this.array[this._count];
+    instance.index = this._count;
+    this._count++;
+    return instance;
+  }
+  remove(instance: T) {
+    // get indices of instances to swap
+    const index = instance.index;
+    const lastIndex = this._count - 1;
+    if (index === lastIndex) {
+      // if the instance is the last one, just decrement the count
+      this._count--;
+      return;
+    }
+    // swap instances
+    this.array[index] = this.array[lastIndex];
+    this.array[lastIndex] = instance;
+    // swap their indices
+    this.array[index].index = index;
+    this.array[lastIndex].index = lastIndex;
+    // decrement the count
+    this._count--;
+  }
+  clear() {
+    this._count = 0;
+  }
+}
+export function coerceVec3Argument<S extends any>(obj: S, key: keyof S) {
+  let value = obj[key] as any;
+  if (!value) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    value = { x: value[0], y: value[1], z: value[2] };
+  }
+  obj[key] = value;
+}
+export function coerceQuatArgument<S extends any>(obj: S, key: keyof S) {
+  let value = obj[key] as any;
+  if (!value) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    if (Array.length === 3) {
+      let x = value[0] * (180 / Math.PI);
+      let y = value[1] * (180 / Math.PI);
+      let z = value[2] * (180 / Math.PI);
+      let halfToRad = Math.PI / 360;
+      x *= halfToRad;
+      z *= halfToRad;
+      y *= halfToRad;
+      let sx = Math.sin(x);
+      let cx = Math.cos(x);
+      let sy = Math.sin(y);
+      let cy = Math.cos(y);
+      let sz = Math.sin(z);
+      let cz = Math.cos(z);
+      value = { x: 0, y: 0, z: 0, w: 0 };
+      value.x = sx * cy * cz + cx * sy * sz;
+      value.y = cx * sy * cz - sx * cy * sz;
+      value.z = cx * cy * sz + sx * sy * cz;
+      value.w = cx * cy * cz - sx * sy * sz;
+    }
+  } else if (!("w" in value)) {
+    let x = value.x * (180 / Math.PI);
+    let y = value.y * (180 / Math.PI);
+    let z = value.z * (180 / Math.PI);
+    let halfToRad = Math.PI / 360;
+    x *= halfToRad;
+    z *= halfToRad;
+    y *= halfToRad;
+    let sx = Math.sin(x);
+    let cx = Math.cos(x);
+    let sy = Math.sin(y);
+    let cy = Math.cos(y);
+    let sz = Math.sin(z);
+    let cz = Math.cos(z);
+    value = { x: 0, y: 0, z: 0, w: 0 };
+    value.x = sx * cy * cz + cx * sy * sz;
+    value.y = cx * sy * cz - sx * cy * sz;
+    value.z = cx * cy * sz + sx * sy * cz;
+    value.w = cx * cy * cz - sx * sy * sz;
+  }
+  obj[key] = value;
+}

package/src/index.ts ADDED Viewed

@@ -0,0 +1,50 @@
+export { Mat3 } from "./math/mat3";
+export { Line } from "./shape/Line";
+export { Mat4 } from "./math/mat4";
+export { Plane } from "./shape/Plane";
+export { type CastRayResult } from "./physics/narrowphase/CollideBodiesModule" ;
+export { QueryPrecision } from "./collision/cast/cast";
+export { Ray } from "./shape/Ray";
+export { baseConstraintProps, ReferenceFrame } from "./constraints/BaseConstraint";
+export { type Constraint } from "./constraints/types";
+export { ContactManifold } from "./physics/manifold/ContactManifold";
+export { FixedConstraint } from "./constraints/FixedConstraint";
+export { PointConstraint } from "./constraints/PointConstraint";
+export { DistanceConstraint } from "./constraints/DistanceConstraint";
+export { HingeConstraint } from "./constraints/HingeConstraint";
+export * as CollisionFilter from "./physics/CollisionFilter";
+export { AllFlag, NoneFlag } from "./physics/CollisionFilter";
+export { Isometry } from "./math/isometry";
+export { clamp, squared, degreesToRadians } from "./math/scalar";
+export { PolygonConvexSupport, SupportMode, ConvexRadiusObject } from "./shape/Convex";
+export { destroyAllInstancesInPool } from "./helpers";
+export { NumberValue } from "./math/NumberValue";
+export { GjkCastShapeResult, GjkModule } from "./collision/gjk/GjkModule";
+export { ColliderType, Body, BodyType } from "./physics/Body";
+export { Face } from "./physics/manifold/Face";
+export { Capsule } from "./shape/Capsule";
+export { default as ConvexHull } from "./shape/ConvexHull";
+export { CastCollector, type CastSettings, CastResult } from "./collision/cast/cast";
+export { Aabb } from "./shape/Aabb";
+export { BvhTree, type BvhTreeOptions, BvhNode } from "./physics/broadphase/BvhTree";
+export { BodyPairsModule, BodyPairNode } from "./physics/broadphase/BodyPairsModule";
+export { CoefficientFunctionType } from "./physics/solver/ContactConstraintModule";
+export {
+  ActiveEdgeMode,
+  CollectFacesMode,
+  BackFaceMode,
+  type CollisionSettings,
+  CollisionCollector,
+  CollisionResult,
+} from "./collision/collide/collide";
+export { Box } from "./shape/Box";
+export { PenetrationDepthModule } from "./collision/gjk/PenetrationDepthModule";
+export { CollideShapesModule } from "./collision/CollideShapesModule";
+export { ShapeType, type Shape, type ConvexShape } from "./shape/Shape";
+export { Quat } from "./math/quat";
+export { Vec3 } from "./math/vec3";
+export { Sphere } from "./shape/Sphere";
+export { World } from "./world";
+export { CompoundShape } from "./shape/CompoundShape";
+export { BasicTransform } from "./math/BasicTransform";
+export { TransformedShape } from "./shape/TransformedShape";

package/src/math/BasicTransform.ts ADDED Viewed

@@ -0,0 +1,19 @@
+import { createClass, MonomorphType, NumberType, PropertyDefinitionMap } from "monomorph";
+import { Quat } from "./quat";
+import { Vec3 } from "./vec3";
+const basicTransformProps = {
+  position: MonomorphType(Vec3),
+  rotation: MonomorphType(Quat),
+  scale: NumberType(1.0),
+} as const satisfies PropertyDefinitionMap;
+export class BasicTransform extends createClass<BasicTransform, typeof basicTransformProps>(basicTransformProps) {
+  equals(other: BasicTransform, tolerance: number = 1e-6) {
+    return (
+      this.position.equals(other.position, tolerance) &&
+      this.rotation.equals(other.rotation, tolerance) &&
+      Math.abs(this.scale - other.scale) < tolerance
+    );
+  }
+}

package/src/math/NumberValue.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { createClass, NumberType, PropertyDefinitionMap } from "monomorph";
+const numberValueProps = {
+  value: NumberType(0.0),
+} as const satisfies PropertyDefinitionMap;
+export class NumberValue extends createClass<NumberValue, typeof numberValueProps>(numberValueProps) {
+  toObject() {
+    return {
+      value: this.value,
+    };
+  }
+}