@perplexdotgg/bounce 1.0.0

package/src/shape/Aabb.ts

@@ -0,0 +1,400 @@
+import { createClass, MonomorphType, PropertyDefinitionMap } from "monomorph";
+import { Vec3 } from "../math/vec3";
+import { Face } from "../physics/manifold/Face";
+import { Isometry } from "../math/isometry";
+import { Segment } from "./Segment";
+import { Ray } from "./Ray";
+import { Quat } from "../math/quat";
+
+const epsilon = 1e-7;
+const newMin = /*@__PURE__*/ Vec3.create();
+const newMax = /*@__PURE__*/ Vec3.create();
+const col = /*@__PURE__*/ Vec3.create();
+const a = /*@__PURE__*/ Vec3.create();
+const b = /*@__PURE__*/ Vec3.create();
+
+interface Vec3Like {
+  x: number;
+  y: number;
+  z: number;
+}
+
+const aabbProps = {
+  min: MonomorphType(Vec3),
+  max: MonomorphType(Vec3),
+  centroid: MonomorphType(Vec3, undefined, true),
+} as const satisfies PropertyDefinitionMap;
+
+export class Aabb extends createClass<Aabb, typeof aabbProps>(aabbProps) {
+  computeSupport(out: Vec3, direction: Vec3) {
+    out.x = direction.x < 0 ? this.min.x : this.max.x;
+    out.y = direction.y < 0 ? this.min.y : this.max.y;
+    out.z = direction.z < 0 ? this.min.z : this.max.z;
+  }
+
+  computeSupportingFace(out: Face, inDirection: Vec3): void {
+    const absX = Math.abs(inDirection.x);
+    const absY = Math.abs(inDirection.y);
+    const absZ = Math.abs(inDirection.z);
+
+    const axis = absX > absY ? (absX > absZ ? 0 : 2) : absY > absZ ? 1 : 2;
+    const component = inDirection.getComponentAtIndex(axis);
+    if (component < 0) {
+      switch (axis) {
+        case 0: {
+          out.pushVertexValues(this.max.x, this.min.y, this.min.z);
+          out.pushVertexValues(this.max.x, this.max.y, this.min.z);
+          out.pushVertexValues(this.max.x, this.max.y, this.max.z);
+          out.pushVertexValues(this.max.x, this.min.y, this.max.z);
+          break;
+        }
+
+        case 1: {
+          out.pushVertexValues(this.min.x, this.max.y, this.min.z);
+          out.pushVertexValues(this.min.x, this.max.y, this.max.z);
+          out.pushVertexValues(this.max.x, this.max.y, this.max.z);
+          out.pushVertexValues(this.max.x, this.max.y, this.min.z);
+          break;
+        }
+
+        case 2: {
+          out.pushVertexValues(this.min.x, this.min.y, this.max.z);
+          out.pushVertexValues(this.max.x, this.min.y, this.max.z);
+          out.pushVertexValues(this.max.x, this.max.y, this.max.z);
+          out.pushVertexValues(this.min.x, this.max.y, this.max.z);
+          break;
+        }
+      }
+    } else {
+      switch (axis) {
+        case 0: {
+          out.pushVertexValues(this.min.x, this.min.y, this.min.z);
+          out.pushVertexValues(this.min.x, this.min.y, this.max.z);
+          out.pushVertexValues(this.min.x, this.max.y, this.max.z);
+          out.pushVertexValues(this.min.x, this.max.y, this.min.z);
+          break;
+        }
+
+        case 1: {
+          out.pushVertexValues(this.min.x, this.min.y, this.min.z);
+          out.pushVertexValues(this.max.x, this.min.y, this.min.z);
+          out.pushVertexValues(this.max.x, this.min.y, this.max.z);
+          out.pushVertexValues(this.min.x, this.min.y, this.max.z);
+          break;
+        }
+
+        case 2: {
+          out.pushVertexValues(this.min.x, this.min.y, this.min.z);
+          out.pushVertexValues(this.min.x, this.max.y, this.min.z);
+          out.pushVertexValues(this.max.x, this.max.y, this.min.z);
+          out.pushVertexValues(this.max.x, this.min.y, this.min.z);
+          break;
+        }
+      }
+    }
+  }
+
+  translate(translation: Vec3): void {
+    this.min.addVector(translation);
+    this.max.addVector(translation);
+    this.computeCentroid(this.centroid);
+  }
+
+  translateAabb(aabb: Aabb, translation: Vec3): Aabb {
+    this.min.addVectors(aabb.min, translation);
+    this.max.addVectors(aabb.max, translation);
+    this.computeCentroid(this.centroid);
+    return this;
+  }
+
+  transform(transform: Isometry) {
+    // start with the translation of the matrix
+    transform.matrix.getTranslation(newMin);
+    transform.matrix.getTranslation(newMax);
+
+    // mow find the extreme points by considering the product of the min and max with each column of inMatrix
+    for (let c = 0; c < 3; ++c) {
+      transform.matrix.getColumn3(col, c);
+
+      const minComponent = this.min.getComponentAtIndex(c);
+      const maxComponent = this.max.getComponentAtIndex(c);
+
+      a.scaleVector(col, minComponent);
+      b.scaleVector(col, maxComponent);
+
+      newMin.x += Math.min(a.x, b.x);
+      newMin.y += Math.min(a.y, b.y);
+      newMin.z += Math.min(a.z, b.z);
+
+      newMax.x += Math.max(a.x, b.x);
+      newMax.y += Math.max(a.y, b.y);
+      newMax.z += Math.max(a.z, b.z);
+    }
+
+    // set the new bounding box
+    this.min.copy(newMin);
+    this.max.copy(newMax);
+    this.computeCentroid(this.centroid);
+
+    return this;
+  }
+
+  transformAabb(aabb: Aabb, transform: Isometry) {
+    // start with the translation of the matrix
+    transform.matrix.getTranslation(newMin);
+    transform.matrix.getTranslation(newMax);
+
+    // now find the extreme points by considering the product of the min and max with each column of inMatrix
+    for (let c = 0; c < 3; ++c) {
+      transform.matrix.getColumn3(col, c);
+
+      const minComponent = aabb.min.getComponentAtIndex(c);
+      const maxComponent = aabb.max.getComponentAtIndex(c);
+
+      a.scaleVector(col, minComponent);
+      b.scaleVector(col, maxComponent);
+
+      newMin.x += Math.min(a.x, b.x);
+      newMin.y += Math.min(a.y, b.y);
+      newMin.z += Math.min(a.z, b.z);
+
+      newMax.x += Math.max(a.x, b.x);
+      newMax.y += Math.max(a.y, b.y);
+      newMax.z += Math.max(a.z, b.z);
+    }
+
+    // set the new bounding box
+    this.min.copy(newMin);
+    this.max.copy(newMax);
+    this.computeCentroid(this.centroid);
+
+    return this;
+  }
+
+  intersectsAabb(aabb: Aabb) {
+    return (
+      this.min.x <= aabb.max.x &&
+      this.max.x >= aabb.min.x &&
+      this.min.y <= aabb.max.y &&
+      this.max.y >= aabb.min.y &&
+      this.min.z <= aabb.max.z &&
+      this.max.z >= aabb.min.z
+    );
+  }
+
+  unionAabb(aabb: Aabb) {
+    this.min.minVectors(this.min, aabb.min);
+    this.max.maxVectors(this.max, aabb.max);
+    this.computeCentroid(this.centroid);
+    return this;
+  }
+
+  unionAabbs(boxA: Aabb, boxB: Aabb) {
+    this.min.minVectors(boxA.min, boxB.min);
+    this.max.maxVectors(boxA.max, boxB.max);
+    this.computeCentroid(this.centroid);
+  }
+
+  expand(value: number) {
+    this.min.x -= value;
+    this.min.y -= value;
+    this.min.z -= value;
+    this.max.x += value;
+    this.max.y += value;
+    this.max.z += value;
+    this.computeCentroid(this.centroid);
+  }
+
+  expandAabb(aabb: Aabb, value: number) {
+    this.min.x = aabb.min.x - value;
+    this.min.y = aabb.min.y - value;
+    this.min.z = aabb.min.z - value;
+    this.max.x = aabb.max.x + value;
+    this.max.y = aabb.max.y + value;
+    this.max.z = aabb.max.z + value;
+    this.computeCentroid(this.centroid);
+    return this;
+  }
+
+  setExtents(min: Vec3Like, max: Vec3Like) {
+    this.min.set(min);
+    this.max.set(max);
+    this.computeCentroid(this.centroid);
+    return this;
+  }
+
+  computeSurfaceArea() {
+    const dx = this.max.x - this.min.x;
+    const dy = this.max.y - this.min.y;
+    const dz = this.max.z - this.min.z;
+    return 2 * (dx * dy + dy * dz + dz * dx);
+  }
+
+  computeExtents(out: Vec3) {
+    out.x = this.max.x - this.min.x;
+    out.y = this.max.y - this.min.y;
+    out.z = this.max.z - this.min.z;
+  }
+
+  computeLargestAxis() {
+    const dx = this.max.x - this.min.x;
+    const dy = this.max.y - this.min.y;
+    const dz = this.max.z - this.min.z;
+
+    if (dx >= dy && dx >= dz) {
+      return 0;
+    }
+
+    if (dy >= dx && dy >= dz) {
+      return 1;
+    }
+
+    return 2;
+  }
+
+  computeLargestComponent() {
+    const dx = this.max.x - this.min.x;
+    const dy = this.max.y - this.min.y;
+    const dz = this.max.z - this.min.z;
+
+    if (dx >= dy && dx >= dz) {
+      return "x";
+    }
+
+    if (dy >= dx && dy >= dz) {
+      return "y";
+    }
+
+    return "z";
+  }
+
+  computeCentroid(out: Vec3) {
+    out.x = (this.min.x + this.max.x) * 0.5;
+    out.y = (this.min.y + this.max.y) * 0.5;
+    out.z = (this.min.z + this.max.z) * 0.5;
+    return out;
+  }
+
+  computeHalfExtents(out: Vec3) {
+    out.subtractVectors(this.max, this.min);
+    out.scaleVector(out, 0.5);
+  }
+
+  expandToPoint(point: Vec3) {
+    this.min.minVector(point);
+    this.max.maxVector(point);
+    return this;
+  }
+
+  enclosesAabb(aabb: Aabb) {
+    return (
+      this.min.x < aabb.min.x &&
+      this.max.x > aabb.max.x &&
+      this.min.y < aabb.min.y &&
+      this.max.y > aabb.max.y &&
+      this.min.z < aabb.min.z &&
+      this.max.z > aabb.max.z
+    );
+  }
+
+  expandByVector(vector: Vec3) {
+    this.min.x -= vector.x;
+    this.min.y -= vector.y;
+    this.min.z -= vector.z;
+    this.max.x += vector.x;
+    this.max.y += vector.y;
+    this.max.z += vector.z;
+  }
+
+  toString() {
+    return `Aabb(min: ${[this.min.x, this.min.y, this.min.z].join(", ")}, max: ${[
+      this.max.x,
+      this.max.y,
+      this.max.z,
+    ].join(", ")})`;
+  }
+
+  intersectsRay(ray: Ray) {
+    segment.setFromRay(ray);
+    return this.intersectsSegment(segment);
+  }
+
+  /**
+   * from Christer Ericson's book "Real-Time Collision Detection", "5.3.3 Intersecting Ray or Segment Against Box"
+   */
+  intersectsSegment(segment: Segment) {
+    this.computeCentroid(aabbCenter);
+    this.computeHalfExtents(aabbHalfExtents);
+
+    segment.computeCenter(segmentCenter);
+    segment.computeHalfExtents(segmentHalfExtents);
+
+    // translate the segment to the aabb space
+    segmentCenter.subtractVectors(segmentCenter, aabbCenter);
+
+    // test the 6 separating axes
+
+    // try the aabb axes first
+
+    // for any given axis, if the projection of the segment center onto the axis is greater than the sum of the half extents of the aabb and the segment, then the aabb and the segment do not intersect
+    let adx = Math.abs(segmentHalfExtents.x);
+    if (Math.abs(segmentCenter.x) > aabbHalfExtents.x + adx) {
+      return false;
+    }
+
+    let ady = Math.abs(segmentHalfExtents.y);
+    if (Math.abs(segmentCenter.y) > aabbHalfExtents.y + ady) {
+      return false;
+    }
+
+    let adz = Math.abs(segmentHalfExtents.z);
+    if (Math.abs(segmentCenter.z) > aabbHalfExtents.z + adz) {
+      return false;
+    }
+
+    // try the segment cross aabb axes next
+
+    // an epsilon is added to the half extents to counteract floating point errors when segment is near parallel to an axis
+    adx += epsilon;
+    ady += epsilon;
+    adz += epsilon;
+
+    if (
+      Math.abs(segmentCenter.y * segmentHalfExtents.z - segmentCenter.z * segmentHalfExtents.y) >
+      aabbHalfExtents.y * adz + aabbHalfExtents.z * ady
+    ) {
+      return false;
+    }
+
+    if (
+      Math.abs(segmentCenter.z * segmentHalfExtents.x - segmentCenter.x * segmentHalfExtents.z) >
+      aabbHalfExtents.x * adz + aabbHalfExtents.z * adx
+    ) {
+      return false;
+    }
+
+    if (
+      Math.abs(segmentCenter.x * segmentHalfExtents.y - segmentCenter.y * segmentHalfExtents.x) >
+      aabbHalfExtents.x * ady + aabbHalfExtents.y * adx
+    ) {
+      return false;
+    }
+
+    // if the segment passes all the tests, then it intersects the aabb
+
+    return true;
+  }
+
+  toObject() {
+    return {
+      min: this.min.toObject(),
+      max: this.max.toObject(),
+    };
+  }
+}
+
+const segment = /*@__PURE__*/ Segment.create();
+const aabbCenter = /*@__PURE__*/ Vec3.create();
+const aabbHalfExtents = /*@__PURE__*/ Vec3.create();
+const segmentCenter = /*@__PURE__*/ Vec3.create();
+const segmentHalfExtents = /*@__PURE__*/ Vec3.create();

package/src/shape/Box.ts

@@ -0,0 +1,231 @@
+import {
+  createClass,
+  LazyReferenceType,
+  MonomorphType,
+  NumberType,
+  PropertyDefinitionMap,
+  PropertyDefinitionReference,
+} from "monomorph";
+import { Vec3 } from "../math/vec3";
+import { ConvexShapeInterface, ShapeType } from "./Shape";
+import { Quat } from "../math/quat";
+import { Aabb } from "./Aabb";
+import { Face } from "../physics/manifold/Face";
+import { Mat4 } from "../math/mat4";
+import { Mat3 } from "../math/mat3";
+import { Isometry } from "../math/isometry";
+import { SupportMode, SupportShapeWithConvexRadius } from "./Convex";
+import type { World } from "../world";
+
+const scaledHalfExtent = /*@__PURE__*/ Vec3.create();
+const halfExtent = /*@__PURE__*/ Vec3.create();
+const convexRadiusVector = /*@__PURE__*/ Vec3.create();
+const reducedHalfExtent = /*@__PURE__*/ Vec3.create();
+const negatedScaledHalfExtent = /*@__PURE__*/ Vec3.create();
+const box = /*@__PURE__*/ Aabb.create();
+
+const isometry = /*@__PURE__*/ Isometry.create();
+
+const absLocalSurfacePosition = /*@__PURE__*/ Vec3.create();
+const tempVector = /*@__PURE__*/ Vec3.create();
+
+const defaultConvexRadius = 0.05; // Default convex radius for box shapes
+
+const boxSupportProps = {
+  convexRadius: NumberType(0.0),
+  // TODO: cannot used undefined default for this, possibly due to it being used as a deeply nested prop
+  computedAabb: MonomorphType(Aabb, {}, true),
+} as const satisfies PropertyDefinitionMap;
+
+export class BoxSupport extends createClass<BoxSupport, typeof boxSupportProps>(boxSupportProps) {
+  computeSupport(out: Vec3, direction: Vec3): void {
+    this.computedAabb.computeSupport(out, direction);
+  }
+
+  getConvexRadius(): number {
+    return this.convexRadius;
+  }
+}
+
+const boxProps = {
+  computedCenterOfMass: MonomorphType(Vec3, undefined, true),
+  computedVolume: NumberType(0.0, true),
+  computedAabb: MonomorphType(Aabb, undefined, true),
+  convexRadius: NumberType(0.0),
+  width: NumberType(0.0),
+  height: NumberType(0.0),
+  depth: NumberType(0.0),
+  boxSupport: MonomorphType(BoxSupport, undefined, true),
+  copyForDiff: LazyReferenceType((() => Box) as () => never) as PropertyDefinitionReference<Box | null, true>,
+} as const satisfies PropertyDefinitionMap;
+
+const afterConstructorCode = `
+  this.world = null;
+`;
+
+export class Box
+  extends createClass<Box, typeof boxProps>(boxProps, { afterConstructorCode })
+  implements ConvexShapeInterface
+{
+  type: ShapeType.box = ShapeType.box;
+
+  declare world: World | null;
+
+  computeSupportShape(mode: SupportMode, scale: number): SupportShapeWithConvexRadius {
+    // Scale our half extents
+    halfExtent.x = this.width * 0.5;
+    halfExtent.y = this.height * 0.5;
+    halfExtent.z = this.depth * 0.5;
+    scaledHalfExtent.scaleVector(halfExtent, scale);
+
+    switch (mode) {
+      case SupportMode.IncludeConvexRadius: {
+        // Make box out of our half extents
+        const out = this.boxSupport;
+        out.computedAabb.min.negateVector(scaledHalfExtent);
+        out.computedAabb.max.copy(scaledHalfExtent);
+        out.convexRadius = 0;
+        return out;
+      }
+
+      case SupportMode.ExcludeConvexRadius: {
+        // Reduce the box by our convex radius
+        // TODO: could this be a bug in their code? this never lets convex radius grow past the default
+        const convexRadius = Math.min(this.convexRadius * Math.abs(scale), defaultConvexRadius);
+        convexRadiusVector.replicate(convexRadius);
+        reducedHalfExtent.subtractVectors(scaledHalfExtent, convexRadiusVector);
+
+        const out = this.boxSupport;
+        out.computedAabb.min.negateVector(reducedHalfExtent);
+        out.computedAabb.max.copy(reducedHalfExtent);
+        out.convexRadius = convexRadius;
+        return out;
+      }
+
+      default: {
+        throw new Error(`Invalid support mode: ${mode}`);
+      }
+    }
+  }
+
+  computeSupportingFace(
+    out: Face,
+    subShapeID: number,
+    direction: Vec3,
+    scale: number,
+    centerOfMassTransform: Mat4
+  ): void {
+    scale = Math.abs(scale);
+
+    halfExtent.set({ x: this.width * 0.5, y: this.height * 0.5, z: this.depth * 0.5 });
+
+    scaledHalfExtent.scaleVector(halfExtent, scale);
+
+    negatedScaledHalfExtent.negateVector(scaledHalfExtent);
+
+    box.set({ min: negatedScaledHalfExtent, max: scaledHalfExtent });
+    box.computeSupportingFace(out, direction);
+
+    if (out.numVertices > 4) {
+      throw new Error("Box face has more than 4 vertices");
+    }
+
+    // transform to world space
+    out.transform(centerOfMassTransform);
+  }
+
+  computeInertiaTensor(out: Mat3, mass: number): void {
+    const widthSquared = this.width * this.width;
+    const heightSquared = this.height * this.height;
+    const depthSquared = this.depth * this.depth;
+
+    out.fromArray([
+      (mass * (heightSquared + depthSquared)) / 12,
+      0,
+      0,
+      0,
+      (mass * (widthSquared + depthSquared)) / 12,
+      0,
+      0,
+      0,
+      (mass * (widthSquared + heightSquared)) / 12,
+    ]);
+  }
+
+  computeInverseInertiaTensor(out: Mat3, mass: number): void {
+    this.computeInertiaTensor(out, mass);
+    out.invert();
+  }
+
+  computeWorldBounds(out: Aabb, translation: Vec3, rotation: Quat): void {
+    // TODO: apply rotation if shape's center of mass is not at the origin?
+    isometry.fromRotationAndTranslation(rotation, translation);
+    out.transformAabb(this.computedAabb, isometry);
+  }
+
+  hasChanged() {
+    return (
+      this.copyForDiff !== null &&
+      (this.width !== this.copyForDiff.width ||
+        this.height !== this.copyForDiff.height ||
+        this.depth !== this.copyForDiff.depth)
+    );
+  }
+
+  commitChanges() {
+    if (this.hasChanged()) {
+      updateShape(this);
+      // this.world?.updateBodyProperties();
+    }
+  }
+
+  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3): void {
+    // Get component that is closest to the surface of the box
+
+    absLocalSurfacePosition.absVector(inLocalSurfacePosition);
+    halfExtent.set({ x: this.width * 0.5, y: this.height * 0.5, z: this.depth * 0.5 });
+    tempVector.subtractVectors(absLocalSurfacePosition, halfExtent);
+    tempVector.absVector(tempVector);
+    const index = tempVector.computeLowestComponentIndex();
+
+    // Calculate normal
+    out.zero();
+    const component = inLocalSurfacePosition.getComponentAtIndex(index);
+    out.setComponentAtIndex(index, component > 0 ? 1 : -1);
+  }
+}
+
+const oldCreate = Box.create;
+Box.create = function () {
+  const shape = oldCreate.apply(this, arguments as any);
+  updateShape(shape);
+  return shape;
+};
+
+function updateCopyForDiff(shape: Box) {
+  if (shape.copyForDiff) {
+    shape.copyForDiff.copy(shape);
+    shape.copyForDiff.copyForDiff = null;
+  }
+}
+
+function updateCenterOfMass(shape: Box) {
+  shape.computedCenterOfMass.zero();
+}
+
+function updateVolume(shape: Box) {
+  shape.computedVolume = shape.width * shape.height * shape.depth;
+}
+
+function updateLocalBounds(shape: Box) {
+  halfExtent.set({ x: shape.width * 0.5, y: shape.height * 0.5, z: shape.depth * 0.5 });
+  shape.computedAabb.min.negateVector(halfExtent);
+  shape.computedAabb.max.copy(halfExtent);
+}
+
+function updateShape(shape: Box) {
+  updateCopyForDiff(shape);
+  updateCenterOfMass(shape);
+  updateVolume(shape);
+  updateLocalBounds(shape);
+}