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/BaseConstraint.ts ADDED Viewed

@@ -0,0 +1,50 @@
+import {
+  BooleanType,
+  LazyReferenceType,
+  NumberType,
+  PropertyDefinitionMap,
+  PropertyDefinitionReference,
+} from "monomorph";
+// unless we use require for these files, this file (BaseConstraint.ts) will be included after it is needed in the final build
+import type { Body } from "../physics/Body";
+import type { ConstraintPairNode } from "../physics/broadphase/ConstraintPairsModule";
+export const enum ReferenceFrame {
+  local,
+  world,
+}
+export const enum ConstraintType {
+  pointConstraint,
+  fixedConstraint,
+  distanceConstraint,
+  hingeConstraint,
+}
+export const baseConstraintProps = {
+  // unless we use require here, this file will be imported after it is needed
+  bodyA: LazyReferenceType((() => require('../physics/Body').Body) as () => never) as PropertyDefinitionReference<Body | null, true>,
+  bodyB: LazyReferenceType((() => require('../physics/Body').Body) as () => never) as PropertyDefinitionReference<Body | null, true>,
+  constraintPairNode: LazyReferenceType((() => require('../physics/broadphase/ConstraintPairsModule').ConstraintPairNode) as () => never) as PropertyDefinitionReference<
+    ConstraintPairNode | null,
+    true
+  >,
+  referenceFrame: NumberType(0),
+  isEnabled: BooleanType(true),
+} as const satisfies PropertyDefinitionMap;
+export interface ConstraintInterface {
+  type: ConstraintType;
+  bodyA: Body | null;
+  bodyB: Body | null;
+  constraintPairNode: ConstraintPairNode | null;
+  referenceFrame: ReferenceFrame;
+  isEnabled: boolean;
+  deactivate(): void;
+  initVelocityConstraint(deltaTimeSeconds: number): void;
+  warmStart(deltaTimeSeconds: number, warmStartImpulseRatio: number): void;
+  solveVelocityConstraint(deltaTimeSeconds: number): void;
+  solvePositionConstraint(deltaTimeSeconds: number): void;
+  setComponentData(): void;
+}

package/src/constraints/ConstraintOptions.ts ADDED Viewed

@@ -0,0 +1,22 @@
+import { createClass, NumberType, PropertyDefinitionMap } from "monomorph";
+const constraintOptionsProps = {
+  /**
+   * Value used to scale the amount of position error to correct per solve iteration. Expected to be in the interval [0, 1]
+   */
+  positionBaumgarte: NumberType(0.8),
+  /**
+   * Value used to scale the amount of velocity error to correct per solve iteration. Expected to be in the interval [0, 1]
+   */
+  velocityBaumgarte: NumberType(1.0),
+  /**
+   * Value used to scale the strength of the constraint. recommend to tune in the interval of [0, 1], with 0 being no correction, 1 being full correction
+   */
+  strength: NumberType(1.0),
+} as const satisfies PropertyDefinitionMap;
+export class ConstraintOptions extends createClass<ConstraintOptions, typeof constraintOptionsProps>(
+  constraintOptionsProps
+) {}

package/src/constraints/ConstraintSolver.ts ADDED Viewed

@@ -0,0 +1,119 @@
+import { InputType } from "monomorph";
+import type { World } from "../world";
+import { ConstraintInterface } from "./BaseConstraint";
+import { DistanceConstraint } from "./DistanceConstraint";
+import { FixedConstraint } from "./FixedConstraint";
+import { HingeConstraint } from "./HingeConstraint";
+import { PointConstraint } from "./PointConstraint";
+import { ConstraintPairsModule } from "../physics/broadphase/ConstraintPairsModule";
+import type { Constraint } from "./types";
+export class ConstraintSolver {
+  // removeConstraintConnectedToBody: typeof ConstraintSolver.prototype._removeConstraintConnectedToBody;
+  world: World;
+  constraintPairs: ConstraintPairsModule;
+  fixedConstraints: typeof FixedConstraint.Pool;
+  pointConstraints: typeof PointConstraint.Pool;
+  distanceConstraints: typeof DistanceConstraint.Pool;
+  hingeConstraints: typeof HingeConstraint.Pool;
+  constructor(world: World, constraintPairs: ConstraintPairsModule) {
+    // this.removeConstraintConnectedToBody = this._removeConstraintConnectedToBody.bind(this);
+    this.world = world;
+    this.constraintPairs = constraintPairs;
+    this.fixedConstraints = new FixedConstraint.Pool();
+    this.pointConstraints = new PointConstraint.Pool();
+    this.distanceConstraints = new DistanceConstraint.Pool();
+    this.hingeConstraints = new HingeConstraint.Pool();
+  }
+  createFixedConstraint(params: InputType<FixedConstraint>) {
+    const constraint = /*@__PURE__*/ FixedConstraint.create(params, this.fixedConstraints);
+    this.constraintPairs.createPair(constraint);
+    constraint.bodyA?.wakeUp();
+    constraint.bodyB?.wakeUp();
+    return constraint;
+  }
+  createPointConstraint(params: InputType<PointConstraint>) {
+    const constraint = /*@__PURE__*/ PointConstraint.create(params, this.pointConstraints);
+    this.constraintPairs.createPair(constraint);
+    constraint.bodyA?.wakeUp();
+    constraint.bodyB?.wakeUp();
+    return constraint;
+  }
+  createDistanceConstraint(params: InputType<DistanceConstraint>) {
+    const constraint = /*@__PURE__*/ DistanceConstraint.create(params, this.distanceConstraints);
+    this.constraintPairs.createPair(constraint);
+    constraint.bodyA?.wakeUp();
+    constraint.bodyB?.wakeUp();
+    return constraint;
+  }
+  createHingeConstraint(params: InputType<HingeConstraint>) {
+    const constraint = /*@__PURE__*/ HingeConstraint.create(params, this.hingeConstraints);
+    this.constraintPairs.createPair(constraint);
+    constraint.bodyA?.wakeUp();
+    constraint.bodyB?.wakeUp();
+    return constraint;
+  }
+  destroyConstraint(constraint: Constraint) {
+    this.constraintPairs.destroyPair(constraint);
+    constraint.destroy();
+  }
+  *constraints(): IterableIterator<ConstraintInterface> {
+    yield* this.fixedConstraints;
+    yield* this.pointConstraints;
+    yield* this.distanceConstraints;
+    yield* this.hingeConstraints;
+  }
+  initVelocityConstraints(deltaTimeSeconds: number) {
+    // iterate over all constraint allocations
+    for (const constraint of this.constraints()) {
+      if (this.world.sleepModule.isBodyPairAwake(constraint.bodyA!, constraint.bodyB!)) {
+        constraint.initVelocityConstraint(deltaTimeSeconds);
+      }
+    }
+  }
+  // TODO: should we reset warm start when waking?
+  warmStartConstraints(deltaTimeSeconds: number, warmStartImpulseRatio: number) {
+    // iterate over all constraint allocations
+    for (const constraint of this.constraints()) {
+      if (this.world.sleepModule.isBodyPairAwake(constraint.bodyA!, constraint.bodyB!)) {
+        constraint.warmStart(deltaTimeSeconds, warmStartImpulseRatio);
+      }
+    }
+  }
+  solveVelocityConstraintsStep(deltaTimeSeconds: number) {
+    // iterate over all constraint allocations
+    for (const constraint of this.constraints()) {
+      if (this.world.sleepModule.isBodyPairAwake(constraint.bodyA!, constraint.bodyB!)) {
+        constraint.solveVelocityConstraint(deltaTimeSeconds);
+      }
+    }
+  }
+  solvePositionConstraintsStep(deltaTimeSeconds: number): void {
+    // iterate over all constraint allocations
+    for (const constraint of this.constraints()) {
+      if (this.world.sleepModule.isBodyPairAwake(constraint.bodyA!, constraint.bodyB!)) {
+        constraint.solvePositionConstraint(deltaTimeSeconds);
+      }
+    }
+  }
+  solvePositionConstraints(deltaTimeSeconds: number): void {
+    // iterate as many times as there are solver position iterations, TODO: how to handle custom iterations per constraint or at least constraint type or allocation?
+    for (let i = 0; i < this.world.options.solvePositionIterations; i++) {
+      this.solvePositionConstraintsStep(deltaTimeSeconds);
+    }
+  }
+}

package/src/constraints/DistanceConstraint.ts ADDED Viewed

@@ -0,0 +1,229 @@
+import { createClass, MonomorphType, NumberType, PropertyDefinitionMap } from "monomorph";
+import { baseConstraintProps, ConstraintInterface, ConstraintType, ReferenceFrame } from "./BaseConstraint";
+import { Vec3 } from "../math/vec3";
+import { Spring } from "./components/Spring";
+import { AxisComponent } from "./components/AxisComponent";
+import type { World } from "../world";
+import { Mat4 } from "../math/mat4";
+const transformLocalToWorld = /*@__PURE__*/ Mat4.create();
+const worldToLocalTransformA = /*@__PURE__*/ Mat4.create();
+const worldToLocalTransformB = /*@__PURE__*/ Mat4.create();
+const localToWorldTransformA = /*@__PURE__*/ Mat4.create();
+const localToWorldTransformB = /*@__PURE__*/ Mat4.create();
+const armA = /*@__PURE__*/ Vec3.create();
+const armB = /*@__PURE__*/ Vec3.create();
+const vectorAB = /*@__PURE__*/ Vec3.create();
+const distanceConstraintProps = {
+  ...baseConstraintProps,
+  positionA: MonomorphType(Vec3, { x: 0, y: 0, z: 0 }),
+  positionB: MonomorphType(Vec3, { x: 0, y: 0, z: 0 }),
+  minDistance: NumberType(-1),
+  maxDistance: NumberType(-1),
+  spring: MonomorphType(Spring),
+  axisComponent: MonomorphType(AxisComponent),
+  localPositionA: MonomorphType(Vec3, undefined, true),
+  localPositionB: MonomorphType(Vec3, undefined, true),
+  worldPositionA: MonomorphType(Vec3, undefined, true),
+  worldPositionB: MonomorphType(Vec3, undefined, true),
+  worldNormal: MonomorphType(Vec3, undefined, true),
+  minLambda: NumberType(0, true),
+  maxLambda: NumberType(0, true),
+} as const satisfies PropertyDefinitionMap;
+export class DistanceConstraint
+  extends createClass<DistanceConstraint, typeof distanceConstraintProps>(distanceConstraintProps)
+  implements ConstraintInterface
+{
+  type: ConstraintType.distanceConstraint = ConstraintType.distanceConstraint;
+  declare world: World;
+  deactivate(): void {
+    this.axisComponent.deactivate();
+  }
+  getLocalPoints(outA: Vec3, outB: Vec3): void {
+    outA.copy(this.localPositionA);
+    outB.copy(this.localPositionB);
+  }
+  getWorldPoints(outA: Vec3, outB: Vec3): void {
+    transformLocalToWorld.fromRotationTranslation(this.bodyA!.orientation, this.bodyA!.position);
+    outA.transformVectorFromMat4(this.localPositionA, transformLocalToWorld);
+    transformLocalToWorld.fromRotationTranslation(this.bodyB!.orientation, this.bodyB!.position);
+    outB.transformVectorFromMat4(this.localPositionB, transformLocalToWorld);
+  }
+  computeLocalPositions(): void {
+    if (this.referenceFrame === ReferenceFrame.local) {
+      this.localPositionA.copy(this.positionA);
+      this.localPositionB.copy(this.positionB);
+    } else {
+      worldToLocalTransformA.fromInverseRotationAndTranslation(
+        this.bodyA!.orientation,
+        this.bodyA!.computedCenterOfMassPosition
+      );
+      worldToLocalTransformB.fromInverseRotationAndTranslation(
+        this.bodyB!.orientation,
+        this.bodyB!.computedCenterOfMassPosition
+      );
+      this.localPositionA.transformVectorFromMat4(this.positionA, worldToLocalTransformA);
+      this.localPositionB.transformVectorFromMat4(this.positionB, worldToLocalTransformB);
+    }
+  }
+  computeWorldPositions(): void {
+    if (this.referenceFrame === ReferenceFrame.local) {
+      localToWorldTransformA.fromRotationTranslation(this.bodyA!.orientation, this.bodyA!.computedCenterOfMassPosition);
+      localToWorldTransformB.fromRotationTranslation(this.bodyB!.orientation, this.bodyB!.computedCenterOfMassPosition);
+      this.worldPositionA.transformVectorFromMat4(this.positionA, localToWorldTransformA);
+      this.worldPositionB.transformVectorFromMat4(this.positionB, localToWorldTransformB);
+    } else {
+      this.worldPositionA.copy(this.positionA);
+      this.worldPositionB.copy(this.positionB);
+    }
+  }
+  computeDistanceLimits(): void {
+    const distance = this.worldPositionA.distance(this.worldPositionB);
+    let minDistance: number;
+    let maxDistance: number;
+    if (this.minDistance < 0 && this.maxDistance < 0) {
+      minDistance = distance;
+      maxDistance = distance;
+    } else {
+      minDistance = this.minDistance < 0 ? Math.min(distance, this.maxDistance) : this.minDistance;
+      maxDistance = this.maxDistance < 0 ? Math.max(distance, this.minDistance) : this.maxDistance;
+    }
+    // #v-ifdef DEV
+    // assert that minDistance is less than or equal to maxDistance
+    if (minDistance > maxDistance) {
+      throw new Error(
+        "DistanceConstraint.computeDistanceLimits: minDistance must be less than or equal to maxDistance"
+      );
+    }
+    // #v-endif
+    this.minDistance = minDistance;
+    this.maxDistance = maxDistance;
+  }
+  warmStart(deltaTimeSeconds: number, warmStartImpulseRatio: number): void {
+    this.setComponentData();
+    this.axisComponent.warmStart(this.worldNormal, warmStartImpulseRatio);
+  }
+  initVelocityConstraint(deltaTimeSeconds: number): void {
+    this.setComponentData();
+    // update world positions
+    this.computeWorldPositions();
+    // update world normal
+    vectorAB.subtractVectors(this.worldPositionB, this.worldPositionA);
+    const distanceAB = vectorAB.length();
+    if (distanceAB > 0) {
+      this.worldNormal.copy(vectorAB).scale(1 / distanceAB);
+    } else {
+      // TODO: should we assert here?
+    }
+    // update moment arms
+    armA.subtractVectors(this.worldPositionB, this.bodyA!.computedCenterOfMassPosition);
+    armB.subtractVectors(this.worldPositionB, this.bodyB!.computedCenterOfMassPosition);
+    let error: number | undefined = undefined;
+    // case: no distance difference, push out or pull in
+    if (this.minDistance === this.maxDistance) {
+      error = distanceAB - this.minDistance;
+      this.minLambda = -Infinity;
+      this.maxLambda = +Infinity;
+    }
+    // case: below min distance, push out
+    else if (distanceAB <= this.minDistance) {
+      error = distanceAB - this.minDistance;
+      this.minLambda = 0;
+      this.maxLambda = +Infinity;
+    }
+    // case: above max distance, pull in
+    else if (distanceAB >= this.maxDistance) {
+      error = distanceAB - this.maxDistance;
+      this.minLambda = -Infinity;
+      this.maxLambda = 0;
+    }
+    // case: between min and max distance, no action
+    else {
+      this.axisComponent.deactivate();
+    }
+    if (error !== undefined) {
+      this.axisComponent.setup(deltaTimeSeconds, armA, armB, this.worldNormal, 0, error, this.spring);
+    }
+  }
+  solveVelocityConstraint(deltaTimeSeconds: number): void {
+    this.setComponentData();
+    if (!this.axisComponent.isActive()) {
+      return;
+    }
+    this.axisComponent.solveVelocity(this.worldNormal, this.minLambda, this.maxLambda);
+  }
+  solvePositionConstraint(deltaTimeSeconds: number): void {
+    this.setComponentData();
+    // only solve if no spring effect
+    if (this.spring.frequency > 0) {
+      return;
+    }
+    this.computeWorldPositions();
+    vectorAB.subtractVectors(this.worldPositionB, this.worldPositionA);
+    const distance = vectorAB.dot(this.worldNormal);
+    let positionError = 0;
+    if (distance < this.minDistance) {
+      positionError = distance - this.minDistance;
+    } else if (distance > this.maxDistance) {
+      positionError = distance - this.maxDistance;
+    }
+    if (positionError === 0) {
+      return;
+    }
+    this.initVelocityConstraint(deltaTimeSeconds);
+    this.axisComponent.solvePosition(this.worldNormal, positionError);
+  }
+  setComponentData(): void {
+    // @ts-ignore
+    this.world = this.bodyA!.world;
+    // @ts-ignore
+    this.axisComponent.world = this.bodyA!.world;
+    this.axisComponent.bodyA = this.bodyA!;
+    this.axisComponent.bodyB = this.bodyB!;
+  }
+}
+const oldCreate = DistanceConstraint.create;
+DistanceConstraint.create = function () {
+  const constraint = oldCreate.apply(this, arguments as any);
+  constraint.setComponentData();
+  constraint.computeLocalPositions();
+  constraint.computeWorldPositions();
+  constraint.computeDistanceLimits();
+  constraint.worldNormal.fromArray([0, 1, 0]);
+  constraint.deactivate();
+  constraint.world.sleepModule.wakeBodyUp(constraint.bodyA!);
+  constraint.world.sleepModule.wakeBodyUp(constraint.bodyB!);
+  return constraint;
+};

package/src/constraints/FixedConstraint.ts ADDED Viewed

@@ -0,0 +1,203 @@
+import { createClass, MonomorphType, PropertyDefinitionMap } from "monomorph";
+import { baseConstraintProps, ConstraintInterface, ConstraintType, ReferenceFrame } from "./BaseConstraint";
+import { Vec3 } from "../math/vec3";
+import { Quat } from "../math/quat";
+import { PointConstraintComponent } from "./components/PointConstraintComponent";
+import { RotationEulerComponent } from "./components/RotationEulerComponent";
+import type { World } from "../world";
+import { Mat4 } from "../math/mat4";
+import { Mat3 } from "../math/mat3";
+const transformLocalToWorld = /*@__PURE__*/ Mat4.create();
+const constraintRotationA = /*@__PURE__*/ Mat3.create();
+const constraintRotationB = /*@__PURE__*/ Mat3.create();
+const constraintQuaternionA = /*@__PURE__*/ Quat.create();
+const constraintQuaternionB = /*@__PURE__*/ Quat.create();
+const anchor = /*@__PURE__*/ Vec3.create();
+const transformWorldToLocalA = /*@__PURE__*/ Mat4.create();
+const transformWorldToLocalB = /*@__PURE__*/ Mat4.create();
+const inverseRotationB = /*@__PURE__*/ Quat.create();
+const fixedConstraintProps = {
+  ...baseConstraintProps,
+  positionA: MonomorphType(Vec3, { x: 0, y: 0, z: 0 }),
+  positionB: MonomorphType(Vec3, { x: 0, y: 0, z: 0 }),
+  axisXA: MonomorphType(Vec3, { x: 1, y: 0, z: 0 }),
+  axisXB: MonomorphType(Vec3, { x: 1, y: 0, z: 0 }),
+  axisYA: MonomorphType(Vec3, { x: 0, y: 1, z: 0 }),
+  axisYB: MonomorphType(Vec3, { x: 0, y: 1, z: 0 }),
+  localPositionA: MonomorphType(Vec3, undefined, true),
+  localPositionB: MonomorphType(Vec3, undefined, true),
+  localAxisXA: MonomorphType(Vec3, undefined, true),
+  localAxisXB: MonomorphType(Vec3, undefined, true),
+  localAxisYA: MonomorphType(Vec3, undefined, true),
+  localAxisYB: MonomorphType(Vec3, undefined, true),
+  localAxisZA: MonomorphType(Vec3, undefined, true),
+  localAxisZB: MonomorphType(Vec3, undefined, true),
+  inverseInitialRotationAToB: MonomorphType(Quat, undefined, true),
+  translationComponent: MonomorphType(PointConstraintComponent),
+  rotationComponent: MonomorphType(RotationEulerComponent),
+} as const satisfies PropertyDefinitionMap;
+export class FixedConstraint
+  extends createClass<FixedConstraint, typeof fixedConstraintProps>(fixedConstraintProps)
+  implements ConstraintInterface
+{
+  type: ConstraintType.fixedConstraint = ConstraintType.fixedConstraint;
+  declare world: World;
+  deactivate(): void {
+    this.translationComponent.deactivate();
+    this.rotationComponent.deactivate();
+  }
+  getLocalPoints(outA: Vec3, outB: Vec3): void {
+    outA.copy(this.localPositionA);
+    outB.copy(this.localPositionB);
+  }
+  getWorldPoints(outA: Vec3, outB: Vec3): void {
+    transformLocalToWorld.fromRotationTranslation(this.bodyA!.orientation, this.bodyA!.computedCenterOfMassPosition);
+    outA.transformVectorFromMat4(this.localPositionA, transformLocalToWorld);
+    transformLocalToWorld.fromRotationTranslation(this.bodyB!.orientation, this.bodyB!.computedCenterOfMassPosition);
+    outB.transformVectorFromMat4(this.localPositionB, transformLocalToWorld);
+  }
+  getInverseInitialRotationAToB(out: Quat): void {
+    this.localAxisXA.copy(this.axisXA);
+    this.localAxisXB.copy(this.axisXB);
+    this.localAxisYA.copy(this.axisYA);
+    this.localAxisYB.copy(this.axisYB);
+    if (this.localAxisXA.exactEquals(this.localAxisXB) && this.localAxisYA.exactEquals(this.localAxisYB)) {
+      this.inverseInitialRotationAToB.identity();
+    } else {
+      // normalize the local axes
+      this.localAxisXA.normalize();
+      this.localAxisXB.normalize();
+      this.localAxisYA.normalize();
+      this.localAxisYB.normalize();
+      this.localAxisZA.crossVectors(this.localAxisXA, this.localAxisYA);
+      this.localAxisZA.normalize();
+      constraintRotationA.setColumns(this.localAxisXA, this.localAxisYA, this.localAxisZA);
+      constraintQuaternionA.fromMat3(constraintRotationA);
+      this.localAxisZB.crossVectors(this.localAxisXB, this.localAxisYB);
+      this.localAxisZB.normalize();
+      constraintRotationB.setColumns(this.localAxisXB, this.localAxisYB, this.localAxisZB);
+      constraintQuaternionB.fromMat3(constraintRotationB);
+      constraintQuaternionA.conjugateQuat(constraintQuaternionA);
+      out.multiplyQuats(constraintQuaternionB, constraintQuaternionA);
+    }
+  }
+  computeLocalPositions(): void {
+    if (this.referenceFrame === ReferenceFrame.local) {
+      this.localPositionA.copy(this.positionA);
+      this.localPositionB.copy(this.positionB);
+    } else {
+      const inverseMassA = this.bodyA!.inverseMass;
+      const inverseMassB = this.bodyB!.inverseMass;
+      const totalInverseMass = inverseMassA + inverseMassB;
+      // case: at least one body is dynamic
+      if (totalInverseMass !== 0) {
+        anchor.scaleVector(this.bodyA!.computedCenterOfMassPosition, inverseMassA);
+        anchor.addScaledToVector(anchor, this.bodyB!.computedCenterOfMassPosition, inverseMassB);
+        anchor.scaleVector(anchor, 1 / totalInverseMass);
+      }
+      // case: both bodies are static
+      else {
+        anchor.copy(this.bodyA!.computedCenterOfMassPosition);
+      }
+      // store local positions
+      transformWorldToLocalA.fromInverseRotationAndTranslation(
+        this.bodyA!.orientation,
+        this.bodyA!.computedCenterOfMassPosition
+      );
+      transformWorldToLocalB.fromInverseRotationAndTranslation(
+        this.bodyB!.orientation,
+        this.bodyB!.computedCenterOfMassPosition
+      );
+      this.localPositionA.transformVectorFromMat4(anchor, transformWorldToLocalA);
+      this.localPositionB.transformVectorFromMat4(anchor, transformWorldToLocalB);
+      // correct the inverse initial rotation from body A to body B
+      inverseRotationB.conjugateQuat(this.bodyB!.orientation);
+      this.inverseInitialRotationAToB.multiplyQuats(inverseRotationB, this.inverseInitialRotationAToB);
+      this.inverseInitialRotationAToB.multiplyQuats(this.inverseInitialRotationAToB, this.bodyA!.orientation);
+    }
+  }
+  initVelocityConstraint(deltaTimeSeconds: number): void {
+    if (!this.isEnabled) {
+      return;
+    }
+    this.setComponentData();
+    this.translationComponent.setup(this.localPositionA, this.localPositionB);
+    this.rotationComponent.setup();
+  }
+  warmStart(deltaTimeSeconds: number, warmStartImpulseRatio: number): void {
+    if (!this.isEnabled) {
+      return;
+    }
+    this.setComponentData();
+    this.translationComponent.warmStart(warmStartImpulseRatio);
+    this.rotationComponent.warmStart(warmStartImpulseRatio);
+  }
+  solveVelocityConstraint(deltaTimeSeconds: number): void {
+    if (!this.isEnabled) {
+      return;
+    }
+    this.setComponentData();
+    this.translationComponent.solveVelocity();
+    this.rotationComponent.solveVelocity();
+  }
+  solvePositionConstraint(deltaTimeSeconds: number): void {
+    if (!this.isEnabled) {
+      return;
+    }
+    this.setComponentData();
+    this.translationComponent.setup(this.localPositionA, this.localPositionB);
+    this.translationComponent.solvePosition();
+    this.rotationComponent.setup();
+    this.rotationComponent.solvePosition(this.inverseInitialRotationAToB);
+  }
+  setComponentData(): void {
+    // @ts-ignore
+    this.world = this.bodyA!.world;
+    // @ts-ignore
+    this.translationComponent.world = this.bodyA!.world;
+    // @ts-ignore
+    this.rotationComponent.world = this.bodyA!.world;
+    this.translationComponent.bodyA = this.bodyA!;
+    this.translationComponent.bodyB = this.bodyB!;
+    this.rotationComponent.bodyA = this.bodyA!;
+    this.rotationComponent.bodyB = this.bodyB!;
+  }
+}
+const oldCreate = FixedConstraint.create;
+FixedConstraint.create = function () {
+  const constraint = oldCreate.apply(this, arguments as any);
+  constraint.setComponentData();
+  constraint.getInverseInitialRotationAToB(constraint.inverseInitialRotationAToB);
+  constraint.computeLocalPositions();
+  constraint.deactivate();
+  constraint.world.sleepModule.wakeBodyUp(constraint.bodyA!);
+  constraint.world.sleepModule.wakeBodyUp(constraint.bodyB!);
+  return constraint;
+};