@perplexdotgg/bounce 1.0.0

package/src/constraints/HingeConstraint.ts

@@ -0,0 +1,460 @@
+import { BooleanType, createClass, MonomorphType, NumberType, PropertyDefinitionMap } from "monomorph";
+import { baseConstraintProps, ConstraintInterface, ConstraintType, ReferenceFrame } from "./BaseConstraint";
+import { Vec3 } from "../math/vec3";
+import { Spring, SpringMode } from "./components/Spring";
+import { Motor, MotorMode } from "./components/Motor";
+import { Quat } from "../math/quat";
+import { PointConstraintComponent } from "./components/PointConstraintComponent";
+import { HingeComponent } from "./components/HingeComponent";
+import { AngleComponent } from "./components/AngleComponent";
+import type { World } from "../world";
+import { Mat3 } from "../math/mat3";
+import { Mat4 } from "../math/mat4";
+import { clamp, normalizeBetweenMinusPiAndPi } from "../math/scalar";
+import { Line } from "../shape/Line";
+
+const constraintRotationA = /*@__PURE__*/ Mat3.create();
+const constraintRotationB = /*@__PURE__*/ Mat3.create();
+const constraintQuaternionA = /*@__PURE__*/ Quat.create();
+const constraintQuaternionB = /*@__PURE__*/ Quat.create();
+const localAxisZA = /*@__PURE__*/ Vec3.create();
+const localAxisZB = /*@__PURE__*/ Vec3.create();
+const axis = /*@__PURE__*/ Vec3.create();
+const rotateWorldToLocalA = /*@__PURE__*/ Quat.create();
+const rotation = /*@__PURE__*/ Quat.create();
+const transformWorldToLocalA = /*@__PURE__*/ Mat4.create();
+const transformWorldToLocalB = /*@__PURE__*/ Mat4.create();
+const rotateWorldToLocalB = /*@__PURE__*/ Quat.create();
+const rotateLocalToWorldAQuat = /*@__PURE__*/ Quat.create();
+const rotateLocalToWorldAMat3 = /*@__PURE__*/ Mat3.create();
+const rotateLocalToWorldB = /*@__PURE__*/ Mat3.create();
+const worldHingeA = /*@__PURE__*/ Vec3.create();
+const worldHingeB = /*@__PURE__*/ Vec3.create();
+const transformLocalToWorld = /*@__PURE__*/ Mat4.create();
+
+const hingeConstraintProps = {
+  ...baseConstraintProps,
+
+  // init data
+  pointA: MonomorphType(Vec3, { x: 0, y: 0, z: 0 }),
+  pointB: MonomorphType(Vec3, { x: 0, y: 0, z: 0 }),
+  hingeA: MonomorphType(Vec3, { x: 1, y: 0, z: 0 }),
+  hingeB: MonomorphType(Vec3, { x: 1, y: 0, z: 0 }),
+  normalA: MonomorphType(Vec3, { x: 0, y: 1, z: 0 }),
+  normalB: MonomorphType(Vec3, { x: 0, y: 1, z: 0 }),
+  spring: MonomorphType(Spring),
+  motor: MonomorphType(Motor),
+  minHingeAngle: NumberType(-Math.PI),
+  maxHingeAngle: NumberType(+Math.PI),
+  maxFrictionTorque: NumberType(0),
+
+  // constraint data
+  localPointA: MonomorphType(Vec3, undefined, true),
+  localPointB: MonomorphType(Vec3, undefined, true),
+  localHingeA: MonomorphType(Vec3, undefined, true),
+  localHingeB: MonomorphType(Vec3, undefined, true),
+  localNormalA: MonomorphType(Vec3, undefined, true),
+  localNormalB: MonomorphType(Vec3, undefined, true),
+  inverseInitialRotationAB: MonomorphType(Quat, undefined, true),
+  areLimitsEnabled: BooleanType(false, true),
+  targetAngularSpeed: NumberType(0),
+  targetAngle: NumberType(0),
+  hingeAngle: NumberType(0, true),
+  axis1: MonomorphType(Vec3, undefined, true),
+
+  // constraint parts
+  pointConstraintPart: MonomorphType(PointConstraintComponent),
+  rotationConstraintPart: MonomorphType(HingeComponent),
+  rotationLimitsConstraintPart: MonomorphType(AngleComponent),
+  motorConstraintPart: MonomorphType(AngleComponent),
+} as const satisfies PropertyDefinitionMap;
+
+export class HingeConstraint
+  extends createClass<HingeConstraint, typeof hingeConstraintProps>(hingeConstraintProps)
+  implements ConstraintInterface
+{
+  type: ConstraintType.hingeConstraint = ConstraintType.hingeConstraint;
+  declare world: World;
+
+  deactivate(): void {
+    this.pointConstraintPart.deactivate();
+    this.rotationConstraintPart.deactivate();
+    this.rotationLimitsConstraintPart.deactivate();
+    this.motorConstraintPart.deactivate();
+  }
+
+  // TODO: generalize this into a quat or euler function, same or similar one exists on FixedConstraint right now
+  computeInverseInitialRotationAToB(out: Quat, inAxisX1: Vec3, inAxisZ1: Vec3, inAxisX2: Vec3, inAxisZ2: Vec3): void {
+    if (inAxisX1.exactEquals(inAxisX2) && inAxisZ1.exactEquals(inAxisZ2)) {
+      out.identity();
+    } else {
+      // normalize the local axes
+      inAxisX1.normalize();
+      inAxisZ1.normalize();
+      inAxisX2.normalize();
+      inAxisZ2.normalize();
+
+      localAxisZA.crossVectors(inAxisX1, inAxisX2);
+      localAxisZA.normalize();
+      constraintRotationA.setColumns(inAxisX1, inAxisX2, localAxisZA);
+      constraintQuaternionA.fromMat3(constraintRotationA);
+
+      localAxisZB.crossVectors(inAxisZ1, inAxisZ2);
+      localAxisZB.normalize();
+      constraintRotationB.setColumns(inAxisZ1, inAxisZ2, localAxisZB);
+      constraintQuaternionB.fromMat3(constraintRotationB);
+
+      constraintQuaternionA.conjugateQuat(constraintQuaternionA);
+      out.multiplyQuats(constraintQuaternionB, constraintQuaternionA);
+    }
+  }
+
+  getCurrentAngle(): number {
+    rotateWorldToLocalA.conjugateQuat(this.bodyA!.orientation);
+
+    rotation.multiplyQuats(this.bodyB!.orientation, this.inverseInitialRotationAB);
+    rotation.multiplyQuats(rotation, rotateWorldToLocalA);
+
+    axis.transformVectorByQuat(this.localHingeA, this.bodyA!.orientation);
+
+    return rotation.computeRotationAngle(axis);
+  }
+
+  isMinHingeAngleClosest(): boolean {
+    const angleToMin = normalizeBetweenMinusPiAndPi(this.hingeAngle - this.minHingeAngle);
+    const angleToMax = normalizeBetweenMinusPiAndPi(this.hingeAngle - this.maxHingeAngle);
+    return Math.abs(angleToMin) < Math.abs(angleToMax);
+  }
+
+  getSmallestDeltaAngle(): number {
+    const angleToMin = normalizeBetweenMinusPiAndPi(this.hingeAngle - this.minHingeAngle);
+    const angleToMax = normalizeBetweenMinusPiAndPi(this.hingeAngle - this.maxHingeAngle);
+    return Math.abs(angleToMin) < Math.abs(angleToMax) ? angleToMin : angleToMax;
+  }
+
+  isCurrentAngleWithinLimits(): boolean {
+    return this.hingeAngle >= this.minHingeAngle && this.hingeAngle <= this.maxHingeAngle;
+  }
+
+  setupLimits(minAngle: number, maxAngle: number): void {
+    // TODO: this is failing without the tolerance, possibly due to floating point errors?
+    const tolerance = 1e-6;
+    if (minAngle < -Math.PI - tolerance || minAngle > 0 + tolerance) {
+      throw new Error(`expected minAngle to be in the interval [-pi, 0], got ${minAngle} instead`);
+    }
+
+    if (maxAngle < 0 - tolerance || maxAngle > +Math.PI + tolerance) {
+      throw new Error(`expected maxAngle to be in the interval [0, +pi], got ${maxAngle} instead`);
+    }
+
+    this.minHingeAngle = minAngle;
+    this.maxHingeAngle = maxAngle;
+    this.areLimitsEnabled = minAngle > -Math.PI && maxAngle < Math.PI;
+  }
+
+  setupAxis1AndHingeAngle(): void {
+    if (this.areLimitsEnabled === false && this.motor.mode === MotorMode.Off && this.maxFrictionTorque <= 0) {
+      return;
+    }
+
+    rotateWorldToLocalA.conjugateQuat(this.bodyA!.orientation);
+
+    rotation.multiplyQuats(this.bodyB!.orientation, this.inverseInitialRotationAB);
+    rotation.multiplyQuats(rotation, rotateWorldToLocalA);
+
+    this.axis1.transformVectorByQuat(this.localHingeA, this.bodyA!.orientation);
+    this.hingeAngle = rotation.computeRotationAngle(this.axis1);
+  }
+
+  setupRotationLimitsConstraintPart(deltaTime: number): void {
+    if (this.areLimitsEnabled === false || this.isCurrentAngleWithinLimits()) {
+      this.rotationLimitsConstraintPart.deactivate();
+      return;
+    }
+
+    const deltaAngle = this.getSmallestDeltaAngle();
+
+    this.rotationLimitsConstraintPart.setupWithSpring(
+      this.bodyA!,
+      this.bodyB!,
+      this.axis1,
+      0.0,
+      deltaAngle,
+      this.spring,
+      deltaTime
+    );
+  }
+
+  setupMotorConstraintPart(deltaTime: number): void {
+    switch (this.motor.mode) {
+      case MotorMode.Off: {
+        if (this.maxFrictionTorque <= 0) {
+          this.motorConstraintPart.deactivate();
+          return;
+        }
+
+        this.motorConstraintPart.setup(this.bodyA!, this.bodyB!, this.axis1, 0.0);
+        break;
+      }
+
+      case MotorMode.Velocity: {
+        this.motorConstraintPart.setup(this.bodyA!, this.bodyB!, this.axis1, -this.targetAngularSpeed);
+        break;
+      }
+
+      case MotorMode.Position: {
+        if (this.motor.spring.hasStiffness() === false) {
+          this.motorConstraintPart.deactivate();
+          return;
+        }
+
+        const deltaAngle = normalizeBetweenMinusPiAndPi(this.hingeAngle - this.targetAngle);
+
+        this.motorConstraintPart.setupWithSpring(
+          this.bodyA!,
+          this.bodyB!,
+          this.axis1,
+          0.0,
+          deltaAngle,
+          this.motor.spring,
+          deltaTime
+        );
+        break;
+      }
+
+      default: {
+        throw new Error("Invalid motor mode");
+      }
+    }
+  }
+
+  onCreate() {
+    this.setupLimits(this.minHingeAngle, this.maxHingeAngle);
+    this.computeInverseInitialRotationAToB(
+      this.inverseInitialRotationAB,
+      this.normalA,
+      this.hingeA,
+      this.normalB,
+      this.hingeB
+    );
+    this.inverseInitialRotationAB.normalizeQuat(this.inverseInitialRotationAB);
+
+    if (this.referenceFrame === ReferenceFrame.local) {
+      this.localPointA.copy(this.pointA);
+      this.localPointB.copy(this.pointB);
+      this.localHingeA.copy(this.hingeA);
+      this.localNormalA.copy(this.normalA);
+      this.localHingeB.copy(this.hingeB);
+      this.localNormalB.copy(this.normalB);
+    } else {
+      transformWorldToLocalA.fromInverseRotationAndTranslation(
+        this.bodyA!.orientation,
+        this.bodyA!.computedCenterOfMassPosition
+      );
+      transformWorldToLocalB.fromInverseRotationAndTranslation(
+        this.bodyB!.orientation,
+        this.bodyB!.computedCenterOfMassPosition
+      );
+
+      this.localPointA.transformVectorFromMat4(this.pointA, transformWorldToLocalA);
+      this.localPointB.transformVectorFromMat4(this.pointB, transformWorldToLocalB);
+
+      transformWorldToLocalA.multiply3x3(this.localHingeA, this.hingeA);
+      transformWorldToLocalA.multiply3x3(this.localNormalA, this.normalA);
+      transformWorldToLocalB.multiply3x3(this.localHingeB, this.hingeB);
+      transformWorldToLocalB.multiply3x3(this.localNormalB, this.normalB);
+
+      rotateWorldToLocalB.conjugateQuat(this.bodyB!.orientation);
+      rotateLocalToWorldAQuat.copy(this.bodyA!.orientation);
+
+      this.inverseInitialRotationAB.multiplyQuats(rotateWorldToLocalB, this.inverseInitialRotationAB);
+      this.inverseInitialRotationAB.multiplyQuats(this.inverseInitialRotationAB, rotateLocalToWorldAQuat);
+    }
+
+    this.localHingeA.normalize();
+    this.localNormalA.normalize();
+    this.localHingeB.normalize();
+    this.localNormalB.normalize();
+
+    this.deactivate();
+  }
+
+  warmStart(warmStartImpulseRatio: number): void {
+    this.setComponentData();
+    this.motorConstraintPart.warmStart(this.bodyA!, this.bodyB!, warmStartImpulseRatio);
+    this.pointConstraintPart.warmStart(warmStartImpulseRatio);
+    this.rotationConstraintPart.warmStart(warmStartImpulseRatio);
+    this.rotationLimitsConstraintPart.warmStart(this.bodyA!, this.bodyB!, warmStartImpulseRatio);
+  }
+
+  initVelocityConstraint(deltaTimeSeconds: number): void {
+    this.setComponentData();
+    this.pointConstraintPart.setup(this.localPointA, this.localPointB);
+
+    rotateLocalToWorldAMat3.fromQuat(this.bodyA!.orientation);
+    rotateLocalToWorldB.fromQuat(this.bodyB!.orientation);
+
+    worldHingeA.transformVectorFromMat3(this.localHingeA, rotateLocalToWorldAMat3);
+    worldHingeB.transformVectorFromMat3(this.localHingeB, rotateLocalToWorldB);
+
+    this.rotationConstraintPart.setup(worldHingeA, worldHingeB);
+
+    this.setupAxis1AndHingeAngle();
+    this.setupRotationLimitsConstraintPart(deltaTimeSeconds);
+    this.setupMotorConstraintPart(deltaTimeSeconds);
+  }
+
+  solveVelocityConstraint(deltaTimeSeconds: number): void {
+    this.setComponentData();
+    if (this.motorConstraintPart.isActive()) {
+      switch (this.motor.mode) {
+        case MotorMode.Off: {
+          const maxLambda = this.maxFrictionTorque * deltaTimeSeconds;
+          this.motorConstraintPart.solveVelocity(this.bodyA!, this.bodyB!, this.axis1, -maxLambda, +maxLambda);
+          break;
+        }
+
+        case MotorMode.Velocity:
+        case MotorMode.Position: {
+          const minLambda = this.motor.minTorque * deltaTimeSeconds;
+          const maxLambda = this.motor.maxTorque * deltaTimeSeconds;
+          this.motorConstraintPart.solveVelocity(this.bodyA!, this.bodyB!, this.axis1, minLambda, maxLambda);
+          break;
+        }
+
+        default: {
+          throw new Error("Invalid motor mode");
+        }
+      }
+    }
+
+    this.pointConstraintPart.solveVelocity();
+    this.rotationConstraintPart.solveVelocity();
+
+    if (this.rotationLimitsConstraintPart.isActive()) {
+      let minLambda: number;
+      let maxLambda: number;
+
+      // case: limits are equal
+      if (this.minHingeAngle === this.maxHingeAngle) {
+        minLambda = -Infinity;
+        maxLambda = +Infinity;
+      }
+
+      // case: min angle is closest
+      else if (this.isMinHingeAngleClosest()) {
+        minLambda = 0.0;
+        maxLambda = +Infinity;
+      }
+
+      // case: max angle is closest
+      else {
+        minLambda = -Infinity;
+        maxLambda = 0.0;
+      }
+
+      this.rotationLimitsConstraintPart.solveVelocity(this.bodyA!, this.bodyB!, this.axis1, minLambda, maxLambda);
+    }
+  }
+
+  solvePositionConstraint(deltaTimeSeconds: number): void {
+    this.setComponentData();
+
+    this.pointConstraintPart.setup(this.localPointA, this.localPointB);
+    this.pointConstraintPart.solvePosition();
+
+    // have to update the rotations again because the point constraint might have changed them
+
+    rotateLocalToWorldAMat3.fromQuat(this.bodyA!.orientation);
+    rotateLocalToWorldB.fromQuat(this.bodyB!.orientation);
+    worldHingeA.transformVectorFromMat3(this.localHingeA, rotateLocalToWorldAMat3);
+    worldHingeB.transformVectorFromMat3(this.localHingeB, rotateLocalToWorldB);
+    this.rotationConstraintPart.setup(worldHingeA, worldHingeB);
+    this.rotationConstraintPart.solvePosition();
+
+    if (this.areLimitsEnabled && this.spring.frequency <= 0) {
+      this.setupAxis1AndHingeAngle();
+      this.setupRotationLimitsConstraintPart(deltaTimeSeconds);
+      if (this.rotationLimitsConstraintPart.isActive()) {
+        const deltaAngle = this.getSmallestDeltaAngle();
+        this.rotationLimitsConstraintPart.solvePosition(this.bodyA!, this.bodyB!, deltaAngle);
+      }
+    }
+  }
+
+  setTargetAngle(targetAngle: number): void {
+    if (this.areLimitsEnabled) {
+      clamp(targetAngle, this.minHingeAngle, this.maxHingeAngle);
+    }
+  }
+
+  getTotalLambdaPosition(out: Vec3): void {
+    out.copy(this.pointConstraintPart.totalLambda);
+  }
+
+  getTotalLambdaRotation(): [number, number] {
+    return [this.rotationConstraintPart.totalLambdaA, this.rotationConstraintPart.totalLambdaB];
+  }
+
+  getTotalLambdaRotationLimits(): number {
+    return this.rotationLimitsConstraintPart.totalLambda;
+  }
+
+  getTotalLambdaMotor(): number {
+    return this.motorConstraintPart.totalLambda;
+  }
+
+  getWorldData(
+    outPointA: Vec3,
+    outPointB: Vec3,
+    outHingeLineA: Line,
+    outHingeLineB: Line,
+    outNormalLineA: Line,
+    outNormalLineB: Line
+  ): void {
+    transformLocalToWorld.fromRotationTranslation(this.bodyA!.orientation, this.bodyA!.computedCenterOfMassPosition);
+    outHingeLineA.setFromPointAndDirection(this.localPointA, this.localHingeA, 1);
+    outNormalLineA.setFromPointAndDirection(this.localPointA, this.localNormalA, 1);
+    outPointA.transformVectorFromMat4(this.localPointA, transformLocalToWorld);
+    outHingeLineA.a.transformVectorFromMat4(outHingeLineA.a, transformLocalToWorld);
+    outHingeLineA.b.transformVectorFromMat4(outHingeLineA.b, transformLocalToWorld);
+    outNormalLineA.a.transformVectorFromMat4(outNormalLineA.a, transformLocalToWorld);
+    outNormalLineA.b.transformVectorFromMat4(outNormalLineA.b, transformLocalToWorld);
+
+    transformLocalToWorld.fromRotationTranslation(this.bodyB!.orientation, this.bodyB!.computedCenterOfMassPosition);
+    outHingeLineB.setFromPointAndDirection(this.localPointB, this.localHingeB, 1);
+    outNormalLineB.setFromPointAndDirection(this.localPointB, this.localNormalB, 1);
+    outPointB.transformVectorFromMat4(this.localPointB, transformLocalToWorld);
+    outHingeLineB.a.transformVectorFromMat4(outHingeLineB.a, transformLocalToWorld);
+    outHingeLineB.b.transformVectorFromMat4(outHingeLineB.b, transformLocalToWorld);
+    outNormalLineB.a.transformVectorFromMat4(outNormalLineB.a, transformLocalToWorld);
+    outNormalLineB.b.transformVectorFromMat4(outNormalLineB.b, transformLocalToWorld);
+  }
+
+  setComponentData(): void {
+    // @ts-ignore
+    this.world = this.bodyA!.world;
+    this.pointConstraintPart.world = this.world;
+    this.rotationConstraintPart.world = this.world;
+    this.rotationLimitsConstraintPart.world = this.world;
+    this.motorConstraintPart.world = this.world;
+    this.pointConstraintPart.bodyA = this.bodyA!;
+    this.pointConstraintPart.bodyB = this.bodyB!;
+    this.rotationConstraintPart.bodyA = this.bodyA!;
+    this.rotationConstraintPart.bodyB = this.bodyB!;
+    this.rotationLimitsConstraintPart.bodyA = this.bodyA!;
+    this.rotationLimitsConstraintPart.bodyB = this.bodyB!;
+    this.motorConstraintPart.bodyA = this.bodyA!;
+    this.motorConstraintPart.bodyB = this.bodyB!;
+  }
+}
+
+const oldCreate = HingeConstraint.create;
+HingeConstraint.create = function () {
+  const constraint = oldCreate.apply(this, arguments as any);
+  constraint.setComponentData();
+  constraint.onCreate();
+  constraint.world.sleepModule.wakeBodyUp(constraint.bodyA!);
+  constraint.world.sleepModule.wakeBodyUp(constraint.bodyB!);
+  return constraint;
+};

package/src/constraints/PointConstraint.ts

@@ -0,0 +1,108 @@
+import { createClass, MonomorphType, PropertyDefinitionMap } from "monomorph";
+import { baseConstraintProps, ConstraintInterface, ConstraintType, ReferenceFrame } from "./BaseConstraint";
+import { Vec3 } from "../math/vec3";
+import { PointConstraintComponent } from "./components/PointConstraintComponent";
+import type { World } from "../world";
+import { Isometry } from "../math/isometry";
+import { Mat4 } from "../math/mat4";
+
+const transformWorldToLocalA = /*@__PURE__*/ Isometry.create();
+const transformWorldToLocalB = /*@__PURE__*/ Isometry.create();
+const transformLocalToWorld = /*@__PURE__*/ Mat4.create();
+
+baseConstraintProps;
+
+const pointConstraintProps = {
+  ...baseConstraintProps,
+  positionA: MonomorphType(Vec3),
+  positionB: MonomorphType(Vec3),
+  localPositionA: MonomorphType(Vec3, undefined, true),
+  localPositionB: MonomorphType(Vec3, undefined, true),
+  translationComponent: MonomorphType(PointConstraintComponent),
+} as const satisfies PropertyDefinitionMap;
+
+export class PointConstraint
+  extends createClass<PointConstraint, typeof pointConstraintProps>(pointConstraintProps)
+  implements ConstraintInterface
+{
+  type: ConstraintType.pointConstraint = ConstraintType.pointConstraint;
+  declare world: World;
+
+  deactivate(): void {
+    this.translationComponent.deactivate();
+  }
+
+  computeLocalPositions(): void {
+    if (this.referenceFrame === ReferenceFrame.local) {
+      this.localPositionA.copy(this.positionA);
+      this.localPositionB.copy(this.positionB);
+    } else {
+      transformWorldToLocalA.fromInverseRotationAndTranslation(
+        this.bodyA!.orientation,
+        this.bodyA!.computedCenterOfMassPosition
+      );
+      transformWorldToLocalB.fromInverseRotationAndTranslation(
+        this.bodyB!.orientation,
+        this.bodyB!.computedCenterOfMassPosition
+      );
+
+      this.localPositionA.transformVectorFromMat4(this.positionA, transformWorldToLocalA.matrix);
+      this.localPositionB.transformVectorFromMat4(this.positionB, transformWorldToLocalB.matrix);
+    }
+  }
+
+  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);
+  }
+
+  initVelocityConstraint(deltaTimeSeconds: number): void {
+    this.setComponentData();
+    this.translationComponent.setup(this.localPositionA, this.localPositionB);
+  }
+
+  warmStart(deltaTimeSeconds: number, warmStartImpulseRatio: number): void {
+    this.setComponentData();
+    this.translationComponent.warmStart(warmStartImpulseRatio);
+  }
+
+  solveVelocityConstraint(deltaTimeSeconds: number): void {
+    this.setComponentData();
+    this.translationComponent.solveVelocity();
+  }
+
+  solvePositionConstraint(deltaTimeSeconds: number): void {
+    this.setComponentData();
+    this.translationComponent.setup(this.localPositionA, this.localPositionB);
+    this.translationComponent.solvePosition();
+  }
+
+  setComponentData(): void {
+    // @ts-ignore
+    this.world = this.bodyA!.world;
+    // @ts-ignore
+    this.translationComponent.world = this.bodyA!.world;
+    this.translationComponent.bodyA = this.bodyA!;
+    this.translationComponent.bodyB = this.bodyB!;
+  }
+}
+
+const oldCreate = PointConstraint.create;
+PointConstraint.create = function () {
+  const constraint = oldCreate.apply(this, arguments as any);
+  constraint.setComponentData();
+  constraint.computeLocalPositions();
+  constraint.deactivate();
+  constraint.world.sleepModule.wakeBodyUp(constraint.bodyA!);
+  constraint.world.sleepModule.wakeBodyUp(constraint.bodyB!);
+
+  return constraint;
+};