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

@@ -0,0 +1,581 @@
+import {
+  BooleanType,
+  createClass,
+  LazyReferenceType,
+  MonomorphType,
+  NumberType,
+  PropertyDefinition,
+  PropertyDefinitionMap,
+  PropertyDefinitionReference,
+  ReferenceType,
+  WithPool,
+} from "monomorph";
+import { CoefficientFunctionType } from "./solver/ContactConstraintModule";
+import { Vec3 } from "../math/vec3";
+import { Quat } from "../math/quat";
+import { Sphere } from "../shape/Sphere";
+import { Face } from "./manifold/Face";
+import { Mat4 } from "../math/mat4";
+import { transformTensor } from "../math/tensor";
+import { Mat3 } from "../math/mat3";
+import { Box } from "../shape/Box";
+import { Shape, ShapeType } from "../shape/Shape";
+import { Aabb } from "../shape/Aabb";
+import type { World } from "../world";
+import { BodyPairEdge } from "./broadphase/BodyPairsModule";
+import { BvhNode } from "./broadphase/BvhTree";
+import { CompoundShape } from "../shape/CompoundShape";
+import ConvexHull from "../shape/ConvexHull";
+import { Capsule } from "../shape/Capsule";
+import { HeightMap } from "../shape/HeightMap";
+import { Cylinder } from "../shape/Cylinder";
+import { TriangleMesh } from "../shape/TriangleMesh";
+import { Isometry } from "../math/isometry";
+import { AllFlag } from "./CollisionFilter";
+import { coerceQuatArgument, coerceVec3Argument } from "../helpers";
+import { ConstraintPairEdge } from "./broadphase/ConstraintPairsModule";
+const centerOfMassTransform = /*@__PURE__*/ Mat4.create();
+const shapeCenterOfMassInWorldSpace = /*@__PURE__*/ Vec3.create();
+const negatedBaseOffset = /*@__PURE__*/ Vec3.create();
+const localDirection = /*@__PURE__*/ Vec3.create();
+const rotationVector = /*@__PURE__*/ Vec3.create();
+const axis = /*@__PURE__*/ Vec3.create();
+const rotationQuaternion = /*@__PURE__*/ Quat.create();
+const quaternionDelta = /*@__PURE__*/ Quat.create();
+const accumulatedForce = /*@__PURE__*/ Vec3.create();
+const accelerationDueToForces = /*@__PURE__*/ Vec3.create();
+const accelerationDueToGravity = /*@__PURE__*/ Vec3.create();
+const linearAcceleration = /*@__PURE__*/ Vec3.create();
+const angularAcceleration = /*@__PURE__*/ Vec3.create();
+const worldToLocalTransform = /*@__PURE__*/ Isometry.create();
+const inLocalSurfacePosition = /*@__PURE__*/ Vec3.create();
+export const enum BodyType {
+  dynamic,
+  kinematic,
+  static,
+}
+export const enum ColliderType {
+  hasIntersectionOnly,
+  findContactManifoldOnly,
+  resolveContact,
+  attractor,
+}
+const bodyProps = {
+  type: NumberType(BodyType.dynamic) as PropertyDefinition<BodyType, true>,
+  position: MonomorphType(Vec3),
+  orientation: MonomorphType(Quat),
+  linearVelocity: MonomorphType(Vec3),
+  angularVelocity: MonomorphType(Vec3),
+  computedCenterOfMassPosition: MonomorphType(Vec3, undefined, true),
+  computedBounds: MonomorphType(Aabb, undefined, true),
+  previousPosition: MonomorphType(Vec3, undefined, true),
+  previousOrientation: MonomorphType(Quat, undefined, true),
+  isSleeping: BooleanType(false, true),
+  timeWithoutMoving: NumberType(0.0, true),
+  friction: NumberType(0.0),
+  restitution: NumberType(0.0),
+  frictionFunction: NumberType(CoefficientFunctionType.average) as PropertyDefinition<CoefficientFunctionType, true>,
+  restitutionFunction: NumberType(CoefficientFunctionType.average) as PropertyDefinition<CoefficientFunctionType, true>,
+  mass: NumberType(0.0),
+  density: NumberType(0.0),
+  inverseMass: NumberType(0.0, true),
+  computedLocalInverseInertia: MonomorphType(Mat3, undefined, true),
+  computedWorldInverseInertia: MonomorphType(Mat3, undefined, true),
+  colliderType: NumberType(ColliderType.resolveContact) as PropertyDefinition<ColliderType, true>,
+  gravityScale: NumberType(1.0),
+  linearForces: MonomorphType(Vec3, undefined, true),
+  angularForces: MonomorphType(Vec3, undefined, true),
+  copyForDiff: LazyReferenceType((() => Body) as () => never) as PropertyDefinitionReference<Body | null, true>,
+  firstPotentialPairEdge: LazyReferenceType((() => BodyPairEdge) as () => never) as PropertyDefinitionReference<
+    BodyPairEdge | null,
+    true
+  >,
+  belongsToGroups: NumberType(AllFlag),
+  collidesWithGroups: NumberType(AllFlag),
+  node: LazyReferenceType((() => BvhNode) as () => never) as PropertyDefinitionReference<BvhNode | null, true>,
+  shapeType: NumberType(0) as PropertyDefinition<ShapeType, true>,
+  // we need to do "as 'shape' ..." otherwise they are just 'string' and not the actual specific keys
+  ['shape' + ShapeType.box as 'shape0']: ReferenceType(Box, undefined, true),
+  ['shape' + ShapeType.capsule as 'shape1']: ReferenceType(Capsule, undefined, true),
+  ['shape' + ShapeType.compoundShape as 'shape2']: ReferenceType(CompoundShape, undefined, true),
+  ['shape' + ShapeType.convexHull as 'shape3']: ReferenceType(ConvexHull, undefined, true),
+  ['shape' + ShapeType.cylinder as 'shape4']: ReferenceType(Cylinder, undefined, true),
+  ['shape' + ShapeType.heightMap as 'shape5']: ReferenceType(HeightMap, undefined, true),
+  ['shape' + ShapeType.sphere as 'shape6']: ReferenceType(Sphere, undefined, true),
+  ['shape' + ShapeType.triangleMesh as 'shape7']: ReferenceType(TriangleMesh, undefined, true),
+  isSleepingEnabled: BooleanType(true),
+  linearDamping: NumberType(-1.0),
+  angularDamping: NumberType(-1.0),
+  firstPotentialConstraintPairEdge: LazyReferenceType(
+    (() => ConstraintPairEdge) as () => never
+  ) as PropertyDefinitionReference<ConstraintPairEdge | null, true>,
+  visitGeneration: NumberType(0, true),
+} as const satisfies PropertyDefinitionMap;
+const afterConstructorCode = `
+  this.world = null;
+`;
+export class Body extends createClass<Body, typeof bodyProps>(bodyProps, { afterConstructorCode }) {
+  declare world: World | null;
+  get shape(): Shape | null {
+    return this['shape' + this.shapeType as keyof typeof this] as Shape | null;
+  }
+  set shape(value: Shape) {
+    (this['shape' + this.shapeType as keyof typeof this] as (Shape | null)) = null;
+    (this['shape' + value.type as keyof typeof this] as (Shape | null)) = value;
+    this.shapeType = value.type;
+    updateBody(this);
+  }
+  // physics integration functions
+  /**
+   * integrates the linear velocity of a body
+   */
+  applyLinearVelocityIntegration(timeStepSizeSeconds: number) {
+    this.previousPosition.copy(this.computedCenterOfMassPosition);
+    this.computedCenterOfMassPosition.addScaled(this.linearVelocity, timeStepSizeSeconds);
+  }
+  applyAngularVelocityIntegration(timeStepSizeSeconds: number) {
+    rotationVector.scaleVector(this.angularVelocity, timeStepSizeSeconds);
+    // if the rotation is very small, just skip it
+    const angle = rotationVector.length();
+    if (angle > 1e-6) {
+      // create a quaternion using axis angle from the rotation vector
+      axis.scaleVector(rotationVector, 1 / angle);
+      rotationQuaternion.setAxisAngle(axis, angle);
+      // multiply the orientation by the rotation quaternion
+      this.previousOrientation.copy(this.orientation);
+      this.orientation.multiplyQuats(rotationQuaternion, this.orientation);
+      // normalize the orientation
+      this.orientation.normalize();
+    }
+  }
+  /**
+   * applies gravity to a body
+   */
+  applyAccelerationIntegration(
+    timeStepSizeSeconds: number,
+    gravity: Vec3,
+    isGravityEnabled: boolean,
+    linearDamping: number,
+    angularDamping: number,
+    maxLinearSpeed: number,
+    maxLinearSpeedSquared: number,
+    maxAngularSpeed: number,
+    maxAngularSpeedSquared: number
+  ) {
+    accelerationDueToForces.scaleVector(this.linearForces, this.inverseMass);
+    accelerationDueToGravity.scaleVector(gravity, isGravityEnabled ? this.gravityScale : 0);
+    linearAcceleration.addVectors(accelerationDueToForces, accelerationDueToGravity);
+    this.linearVelocity.addScaled(linearAcceleration, timeStepSizeSeconds);
+    this.dampLinearVelocity(timeStepSizeSeconds, this.linearDamping === -1 ? linearDamping : this.linearDamping);
+    this.clampLinearVelocity(maxLinearSpeed, maxLinearSpeedSquared);
+    this.computeEffectiveInverseInertiaVector(angularAcceleration, this.orientation, this.angularForces);
+    this.angularVelocity.addScaled(angularAcceleration, timeStepSizeSeconds);
+    this.dampAngularVelocity(timeStepSizeSeconds, this.angularDamping === -1 ? angularDamping : this.angularDamping);
+    this.clampAngularVelocity(maxAngularSpeed, maxAngularSpeedSquared);
+  }
+  // physics solve functions
+  subRotationDelta(rotationDelta: Vec3): void {
+    const angle = rotationDelta.length();
+    if (angle <= 1e-6) {
+      return;
+    }
+    axis.scaleVector(rotationDelta, 1 / angle);
+    quaternionDelta.setAxisAngle(axis, -angle);
+    this.orientation.multiplyQuats(quaternionDelta, this.orientation);
+    this.orientation.normalize();
+  }
+  addRotationDelta(rotationDelta: Vec3): void {
+    const angle = rotationDelta.length();
+    if (angle <= 1e-6) {
+      return;
+    }
+    axis.scaleVector(rotationDelta, 1 / angle);
+    quaternionDelta.setAxisAngle(axis, +angle);
+    this.orientation.multiplyQuats(quaternionDelta, this.orientation);
+    this.orientation.normalize();
+  }
+  addRotationPositionImpulse(impulse: Vec3, inverseEffectiveMass: Mat3) {
+    rotationDelta.transformVectorFromMat3(impulse, inverseEffectiveMass);
+    this.addRotationDelta(rotationDelta);
+  }
+  subRotationPositionImpulse(impulse: Vec3, inverseEffectiveMass: Mat3) {
+    rotationDelta.transformVectorFromMat3(impulse, inverseEffectiveMass);
+    this.subRotationDelta(rotationDelta);
+  }
+  computePointVelocity(out: Vec3, point: Vec3) {
+    out.crossVectors(point, this.angularVelocity);
+    out.subtractVectors(this.linearVelocity, out);
+  }
+  computeEffectiveInverseInertiaVector(out: Vec3, rotation: Quat, axis: Vec3): void {
+    // mask out the degrees of freedom that are not allowed
+    // TODO: this is a placeholder, we should mask out the degrees of freedom that are not allowed
+    angularDofsMask.set({ x: 1, y: 1, z: 1 });
+    maskedAxis.multiplyVectors(axis, angularDofsMask);
+    // multiply the vector by the inverse inertia
+    rotationMatrix.fromQuat(rotation); // TODO: add inertia rotation at some point
+    inverseRotationMatrix.transposeMatrix(rotationMatrix); // TODO: is transpose okay here? or invert?
+    rotatedMaskedAxis.transformVectorFromMat3(maskedAxis, inverseRotationMatrix);
+    rotatedMaskedAxis.transformVectorFromMat3(rotatedMaskedAxis, this.computedLocalInverseInertia);
+    rotatedMaskedAxis.transformVectorFromMat3(rotatedMaskedAxis, rotationMatrix);
+    out.multiplyVectors(rotatedMaskedAxis, angularDofsMask);
+  }
+  // TODO: avoid transforms when not necessary (eg, no change in orientation, no change in computedLocalInverseInertia)
+  computeInverseInertiaTensor(out: Mat3): void {
+    transformTensor(this.computedWorldInverseInertia, this.computedLocalInverseInertia, this.orientation);
+    out.copy(this.computedWorldInverseInertia);
+  }
+  computeVelocityOfPointRelativeToCenterOfMass(out: Vec3, point: Vec3): void {
+    out.crossVectors(this.angularVelocity, point);
+    out.addVector(this.linearVelocity);
+  }
+  computeInverseEffectiveMass(direction: Vec3) {
+    angularInverseMass.transformVectorFromMat3(direction, this.computedWorldInverseInertia);
+    return this.inverseMass + angularInverseMass.dot(direction);
+  }
+  // velocity transformation functions
+  dampLinearVelocity(timeStepSizeSeconds: number, linearDamping: number) {
+    this.linearVelocity.scale(Math.max(0, 1 - linearDamping * timeStepSizeSeconds));
+  }
+  dampAngularVelocity(timeStepSizeSeconds: number, angularDamping: number) {
+    this.angularVelocity.scale(Math.max(0, 1 - angularDamping * timeStepSizeSeconds));
+  }
+  clampLinearVelocity(maxSpeed: number, maxSpeedSquared: number) {
+    const squaredLinearSpeed = this.linearVelocity.squaredLength();
+    if (squaredLinearSpeed > maxSpeedSquared) {
+      this.linearVelocity.scale(maxSpeed / Math.sqrt(squaredLinearSpeed));
+    }
+  }
+  clampAngularVelocity(maxSpeed: number, maxSpeedSquared: number) {
+    const squaredAngularSpeed = this.angularVelocity.squaredLength();
+    if (squaredAngularSpeed > maxSpeedSquared) {
+      this.angularVelocity.scale(maxSpeed / Math.sqrt(squaredAngularSpeed));
+    }
+  }
+  // physics collision functions
+  /**
+   * direction is in world space
+   */
+  computeSupportingFace(out: Face, subShapeId: number, direction: Vec3, baseOffset: Vec3): void {
+    if (!this.shape) {
+      throw new Error("Body does not have a shape");
+    }
+    centerOfMassTransform.fromRotationTranslation(this.orientation, this.computedCenterOfMassPosition);
+    negatedBaseOffset.negateVector(baseOffset);
+    centerOfMassTransform.postTranslated(negatedBaseOffset);
+    centerOfMassTransform.multiply3x3Transposed(localDirection, direction);
+    this.shape.computeSupportingFace(out, subShapeId, localDirection, 1, centerOfMassTransform);
+  }
+  computeWorldSpaceSurfaceNormal(outWorldSpaceNormal: Vec3, inWorldSpacePosition: Vec3, subShapeId?: number): void {
+    // get world to local transform
+    worldToLocalTransform.fromInverseRotationAndTranslation(this.orientation, this.computedCenterOfMassPosition);
+    // transform position from world space to local space
+    inLocalSurfacePosition.transformVectorFromMat4(inWorldSpacePosition, worldToLocalTransform.matrix); // local space position
+    // get surface normal in local space
+    this.shape!.computeSurfaceNormal(outWorldSpaceNormal, inLocalSurfacePosition, subShapeId);
+    // transform surface normal from local space to world space
+    worldToLocalTransform.inverseRotateVector(outWorldSpaceNormal, outWorldSpaceNormal);
+    // normalize surface normal
+    outWorldSpaceNormal.normalize();
+  }
+  // diff functions
+  hasChanged() {
+    return (
+      this.copyForDiff !== null &&
+      (this.position.notEquals(this.copyForDiff.position) ||
+        this.orientation.notEquals(this.copyForDiff.orientation) ||
+        this.mass !== this.copyForDiff.mass ||
+        this.density !== this.copyForDiff.density ||
+        this.shape !== this.copyForDiff.shape ||
+        this.type !== this.copyForDiff.type)
+    );
+  }
+  commitChanges() {
+    if (this.hasChanged()) {
+      updateBody(this);
+    }
+  }
+  // impulse and force functions
+  applyLinearForce(force: Vec3) {
+    if (this.type !== BodyType.dynamic) {
+      return;
+    }
+    this.linearForces.addVectors(this.linearForces, force);
+    if (this.isSleeping) {
+      this.isSleeping = false;
+      this.timeWithoutMoving = 0;
+    }
+  }
+  applyAngularForce(force: Vec3) {
+    if (this.type !== BodyType.dynamic) {
+      return;
+    }
+    this.angularForces.addVectors(this.angularForces, force);
+    if (this.isSleeping) {
+      this.isSleeping = false;
+      this.timeWithoutMoving = 0;
+    }
+  }
+  applyForce(force: Vec3, point: Vec3, useLocalFrame: boolean = false) {
+    if (this.type !== BodyType.dynamic) {
+      return;
+    }
+    if (useLocalFrame) {
+      isometry.fromRotationAndTranslation(this.orientation, this.computedCenterOfMassPosition);
+      forcePointInWorldSpace.transformVectorFromMat4(point, isometry.matrix);
+    }
+    momentArm.subtractVectors(forcePointInWorldSpace, this.computedCenterOfMassPosition);
+    torque.crossVectors(momentArm, force);
+    this.angularForces.addVectors(this.angularForces, torque);
+    this.linearForces.addVectors(this.linearForces, force);
+    if (this.isSleeping) {
+      this.isSleeping = false;
+      this.timeWithoutMoving = 0;
+    }
+  }
+  applyLinearImpulse(impulse: Vec3) {
+    if (this.type !== BodyType.dynamic) {
+      return;
+    }
+    deltaVelocity.scaleVector(impulse, this.inverseMass);
+    this.linearVelocity.addVectors(this.linearVelocity, deltaVelocity);
+    this.clampLinearVelocity(this.world!.options.maxLinearSpeed, this.world!.maxLinearSpeedSquared);
+    if (this.isSleeping) {
+      this.isSleeping = false;
+      this.timeWithoutMoving = 0;
+    }
+  }
+  applyAngularImpulse(impulse: Vec3) {
+    if (this.type !== BodyType.dynamic) {
+      return;
+    }
+    deltaSpin.transformVectorFromMat3(impulse, this.computedWorldInverseInertia);
+    this.angularVelocity.addVectors(this.angularVelocity, deltaSpin);
+    this.clampAngularVelocity(this.world!.options.maxAngularSpeed, this.world!.maxAngularSpeedSquared);
+    if (this.isSleeping) {
+      this.isSleeping = false;
+      this.timeWithoutMoving = 0;
+    }
+  }
+  applyImpulse(impulse: Vec3, point: Vec3, useLocalFrame: boolean = false) {
+    if (this.type !== BodyType.dynamic) {
+      return;
+    }
+    if (useLocalFrame) {
+      isometry.fromRotationAndTranslation(this.orientation, this.computedCenterOfMassPosition);
+      impulsePointInWorldSpace.transformVectorFromMat4(point, isometry.matrix);
+    }
+    impulsePointInWorldSpace.copy(point);
+    deltaVelocity.scaleVector(impulse, this.inverseMass);
+    this.linearVelocity.addVectors(this.linearVelocity, deltaVelocity);
+    this.clampLinearVelocity(this.world!.options.maxLinearSpeed, this.world!.maxLinearSpeedSquared);
+    momentArm.subtractVectors(impulsePointInWorldSpace, this.computedCenterOfMassPosition);
+    torque.crossVectors(momentArm, impulse);
+    deltaSpin.transformVectorFromMat3(torque, this.computedWorldInverseInertia);
+    this.angularVelocity.addVectors(this.angularVelocity, deltaSpin);
+    this.clampAngularVelocity(this.world!.options.maxAngularSpeed, this.world!.maxAngularSpeedSquared);
+    if (this.isSleeping) {
+      this.isSleeping = false;
+      this.timeWithoutMoving = 0;
+    }
+  }
+  clearLinearForces() {
+    this.linearForces.zero();
+  }
+  clearAngularForces() {
+    this.angularForces.zero();
+  }
+  clearForces() {
+    this.linearForces.zero();
+    this.angularForces.zero();
+  }
+  // sleep functions
+  isReadyToSleep(sleepTimeThreshold: number) {
+    return this.type !== BodyType.dynamic || this.timeWithoutMoving >= sleepTimeThreshold;
+  }
+  sleep() {
+    if (this.type === BodyType.static) {
+      return;
+    }
+    this.isSleeping = true;
+  }
+  wakeUp() {
+    this.world!.sleepModule.wakeBodyUp(this);
+  }
+  markBodyAsDirty() {
+    this.world!.broadphase.markDynamicBodyAsDirty(this as WithPool<this>);
+  }
+}
+const forcePointInWorldSpace = /*@__PURE__*/ Vec3.create();
+const impulsePointInWorldSpace = /*@__PURE__*/ Vec3.create();
+const angularDofsMask = /*@__PURE__*/ Vec3.create();
+const maskedAxis = /*@__PURE__*/ Vec3.create();
+const rotationMatrix = /*@__PURE__*/ Mat3.create();
+const inverseRotationMatrix = /*@__PURE__*/ Mat3.create();
+const rotatedMaskedAxis = /*@__PURE__*/ Vec3.create();
+const deltaSpin = /*@__PURE__*/ Vec3.create();
+const torque = /*@__PURE__*/ Vec3.create();
+const momentArm = /*@__PURE__*/ Vec3.create();
+const deltaVelocity = /*@__PURE__*/ Vec3.create();
+const angularInverseMass = /*@__PURE__*/ Vec3.create();
+const rotationDelta = /*@__PURE__*/ Vec3.create();
+const isometry = /*@__PURE__*/ Isometry.create();
+const oldCreate = Body.create;
+Body.create = function () {
+  const data = arguments[0];
+  coerceVec3Argument(data, "position");
+  coerceQuatArgument(data, "orientation");
+  const body = oldCreate.apply(this, arguments as any);
+  body.orientation.normalize();
+  body.previousPosition.copy(body.position);
+  body.previousOrientation.copy(body.orientation);
+  if (data.shape) {
+    body.shape = data.shape;
+  }
+  return body;
+};
+function updateCenterOfMassPosition(body: Body) {
+  shapeCenterOfMassInWorldSpace.copy(body.shape!.computedCenterOfMass);
+  shapeCenterOfMassInWorldSpace.transformByQuat(body.orientation);
+  body.computedCenterOfMassPosition.addVectors(body.position, shapeCenterOfMassInWorldSpace);
+}
+export function updateWorldBounds(body: Body) {
+  body.shape!.computeWorldBounds(body.computedBounds, body.computedCenterOfMassPosition, body.orientation);
+}
+function updateMassProperties(body: Body) {
+  if (body.type === BodyType.static) {
+    body.density = Infinity;
+    body.mass = Infinity;
+    body.inverseMass = 0;
+    body.computedLocalInverseInertia.zero();
+    body.computedWorldInverseInertia.zero();
+    return;
+  }
+  if (!body.shape) {
+    throw new Error("DynamicBody.computeMassProperties: shape must be set");
+  }
+  const volume = body.shape.computedVolume;
+  // use default density if neither is specified
+  if (body.mass === 0 && body.density === 0) {
+    body.density = 1000;
+    body.mass = volume * body.density;
+  }
+  // derive mass if density is specified
+  else if (body.mass === 0) {
+    body.mass = volume * body.density;
+  }
+  // derive density if mass is specified
+  else if (body.density === 0) {
+    body.density = body.mass / volume;
+  }
+  // derive mass if both are specified
+  else {
+    body.mass = volume * body.density;
+  }
+  body.inverseMass = 1 / body.mass;
+  body.shape.computeInverseInertiaTensor(body.computedLocalInverseInertia, body.mass);
+  transformTensor(body.computedWorldInverseInertia, body.computedLocalInverseInertia, body.orientation);
+}
+export function updateBody(body: Body) {
+  updateMassProperties(body);
+  updateCenterOfMassPosition(body);
+  updateWorldBounds(body);
+}

package/src/physics/CollisionFilter.ts ADDED Viewed

@@ -0,0 +1,52 @@
+export const NoneFlag = 0;
+export const AllFlag = ~(~0 << 31);
+export function createBitFlags<T extends readonly string[]>(
+  keys: T
+): {
+  [K in T[number] | "None" | "All"]: number;
+} {
+  const result: any = {};
+  result["None"] = 0;
+  result["All"] = ~0;
+  let index = 0;
+  for (const key of keys) {
+    result[key] = 1 << index++;
+  }
+  return result;
+}
+export function shouldPairCollide(groupA: number, maskA: number, groupB: number, maskB: number): boolean {
+  return (groupA & maskB) !== 0 && (groupB & maskA) !== 0;
+}
+export function shouldCollide(maskA: number, groupB: number): boolean {
+  return (groupB & maskA) !== 0;
+}
+export function addFlag(flag: number, value: number): number {
+  return flag | value;
+}
+export function removeFlag(flag: number, value: number): number {
+  return flag & ~value;
+}
+export function toggleFlag(flag: number, value: number): number {
+  return flag ^ value;
+}
+export function hasFlag(flag: number, value: number): boolean {
+  return (flag & value) !== 0;
+}
+export function doesNotHaveFlag(flag: number, value: number): boolean {
+  return (flag & value) === 0;
+}
+export function setFlags(...values: number[]): number {
+  return values.reduce((acc, value) => acc | value, 0);
+}