@perplexdotgg/bounce 1.0.0 → 1.0.1

package/src/constraints/HingeConstraint.ts

@@ -1,460 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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;
-};