@perplexdotgg/bounce 1.0.0

package/src/shape/Ray.ts

@@ -0,0 +1,81 @@
+import { createClass, MonomorphType, NumberType, PropertyDefinitionMap } from "monomorph";
+import { Vec3 } from "../math/vec3";
+import { Aabb } from "./Aabb";
+import { Isometry } from "../math/isometry";
+import { Triangle } from "./Triangle";
+
+const rayProps = {
+  origin: MonomorphType(Vec3),
+  direction: MonomorphType(Vec3),
+  length: NumberType(0.0),
+} as const satisfies PropertyDefinitionMap;
+
+export class Ray extends createClass<Ray, typeof rayProps>(rayProps) {
+  intersectsAabb(aabb: Aabb): boolean {
+    return aabb.intersectsRay(this);
+  }
+
+  transform(isometry: Isometry) {
+    this.origin.transformVectorFromMat4(this.origin, isometry.matrix);
+    isometry.matrix.multiply3x3(this.direction, this.direction);
+    return this;
+  }
+
+  transformRay(ray: Ray, isometry: Isometry) {
+    this.origin.transformVectorFromMat4(ray.origin, isometry.matrix);
+    isometry.matrix.multiply3x3(this.direction, ray.direction);
+    return this;
+  }
+
+  /**
+   * algorithm: https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
+   */
+  intersectsTriangle(outResult: { fraction: number; hit: boolean }, triangle: Triangle) {
+    ray_vector.copy(this.direction);
+
+    edge1.subtractVectors(triangle.b, triangle.a);
+    edge2.subtractVectors(triangle.c, triangle.a);
+    ray_cross_e2.crossVectors(ray_vector, edge2);
+    const det = edge1.dot(ray_cross_e2);
+
+    if (det > -epsilon && det < epsilon) {
+      outResult.hit = false; // parallel
+      return;
+    }
+
+    const inv_det = 1.0 / det;
+    s.subtractVectors(this.origin, triangle.a);
+    const u = inv_det * s.dot(ray_cross_e2);
+
+    if (u < -epsilon || u > 1 + epsilon) {
+      outResult.hit = false;
+      return;
+    }
+
+    s_cross_e1.crossVectors(s, edge1);
+    const v = inv_det * ray_vector.dot(s_cross_e1);
+
+    if (v < -epsilon || u + v > 1 + epsilon) {
+      outResult.hit = false;
+      return;
+    }
+
+    const t = inv_det * edge2.dot(s_cross_e1);
+
+    if (t > epsilon && t <= this.length + epsilon) {
+      outResult.fraction = t / this.length;
+      outResult.hit = true;
+    } else {
+      // line hit but outside the ray segment
+      outResult.hit = false;
+    }
+  }
+}
+
+const epsilon = 1e-6;
+const edge1 = /*@__PURE__*/ Vec3.create();
+const edge2 = /*@__PURE__*/ Vec3.create();
+const ray_cross_e2 = /*@__PURE__*/ Vec3.create();
+const s = /*@__PURE__*/ Vec3.create();
+const s_cross_e1 = /*@__PURE__*/ Vec3.create();
+const ray_vector = /*@__PURE__*/ Vec3.create();

package/src/shape/Segment.ts

@@ -0,0 +1,25 @@
+import { createClass, MonomorphType, PropertyDefinitionMap } from "monomorph";
+import { Vec3 } from "../math/vec3";
+import { Ray } from "./Ray";
+
+const segmentProps = {
+  pointA: MonomorphType(Vec3),
+  pointB: MonomorphType(Vec3),
+} as const satisfies PropertyDefinitionMap;
+
+export class Segment extends createClass<Segment, typeof segmentProps>(segmentProps) {
+  computeCenter(out: Vec3) {
+    out.addVectors(this.pointA, this.pointB);
+    out.scaleVector(out, 0.5);
+  }
+
+  computeHalfExtents(out: Vec3) {
+    out.subtractVectors(this.pointB, this.pointA);
+    out.scaleVector(out, 0.5);
+  }
+
+  setFromRay(ray: Ray) {
+    this.pointA.copy(ray.origin);
+    this.pointB.addScaledToVector(ray.origin, ray.direction, ray.length);
+  }
+}

package/src/shape/Shape.ts

@@ -0,0 +1,77 @@
+import { Aabb } from "./Aabb";
+import { Face } from "../physics/manifold/Face";
+import { Mat3 } from "../math/mat3";
+import { Mat4 } from "../math/mat4";
+import { Quat } from "../math/quat";
+import { Vec3 } from "../math/vec3";
+import { Sphere } from "./Sphere";
+import { Box } from "./Box";
+import { SupportMode, SupportShapeWithConvexRadius } from "./Convex";
+import { CompoundShape } from "./CompoundShape";
+import { HeightMap } from "./HeightMap";
+import ConvexHull from "./ConvexHull";
+import { Cylinder } from "./Cylinder";
+import { TriangleMesh } from "./TriangleMesh";
+import { Capsule } from "./Capsule";
+import { WithPool } from "monomorph";
+
+export const enum ShapeType {
+  box,
+  capsule,
+  compoundShape,
+  convexHull,
+  cylinder,
+  heightMap,
+  sphere,
+  triangleMesh,
+}
+
+export type ConvexShape = Box | Capsule | ConvexHull | Cylinder | Sphere;
+export type ShapeCollection = CompoundShape | HeightMap | TriangleMesh;
+export type Shape = ConvexShape | ShapeCollection;
+export type StaticShape = Shape;
+export type DynamicShape = Exclude<Shape, HeightMap>;
+export type KinematicShape = Exclude<Shape, HeightMap>;
+
+export type ConvexShapeInterface = {
+  type: ShapeType.box | ShapeType.capsule | ShapeType.convexHull | ShapeType.cylinder | ShapeType.sphere;
+
+  // for transform-dependent shape properties
+  computeSupportShape(mode: SupportMode, scale: number): SupportShapeWithConvexRadius;
+  computeSupportingFace(
+    out: Face,
+    subShapeID: number,
+    direction: Vec3,
+    scale: number,
+    centerOfMassTransform: Mat4
+  ): void;
+  computeInverseInertiaTensor(out: Mat3, mass: number): void;
+  computeWorldBounds(out: Aabb, translation: Vec3, rotation: Quat): void;
+  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3, subShapeId?: number): void;
+
+  // for "diffing"
+  copyForDiff: WithPool<ConvexShape> | ConvexShape | null;
+  commitChanges(): void;
+  hasChanged(): boolean;
+};
+
+export type ShapeCollectionInterface = {
+  type: ShapeType.compoundShape | ShapeType.heightMap | ShapeType.triangleMesh;
+
+  // for transform-dependent shape properties
+  computeSupportingFace(
+    out: Face,
+    subShapeID: number,
+    direction: Vec3,
+    scale: number,
+    centerOfMassTransform: Mat4
+  ): void;
+  computeInverseInertiaTensor(out: Mat3, mass: number): void;
+  computeWorldBounds(out: Aabb, translation: Vec3, rotation: Quat): void;
+  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3, subShapeId?: number): void;
+
+  // for "diffing"
+  copyForDiff: ShapeCollection | null;
+  commitChanges(): void;
+  hasChanged(): boolean;
+};

package/src/shape/Sphere.ts

@@ -0,0 +1,181 @@
+import {
+  createClass,
+  LazyReferenceType,
+  MonomorphType,
+  NumberType,
+  PropertyDefinitionMap,
+  PropertyDefinitionReference,
+} from "monomorph";
+import { Vec3 } from "../math/vec3";
+import { Quat } from "../math/quat";
+import { Face } from "../physics/manifold/Face";
+import { Mat4 } from "../math/mat4";
+import { Mat3 } from "../math/mat3";
+import { Aabb } from "./Aabb";
+import { SupportMode, SupportShapeWithConvexRadius } from "./Convex";
+import { ConvexShapeInterface, ShapeType } from "./Shape";
+import type { World } from "../world";
+
+const sphereNoConvexProps = {
+  radius: NumberType(0.0),
+} as const satisfies PropertyDefinitionMap;
+
+export class SphereNoConvex
+  extends createClass<SphereNoConvex, typeof sphereNoConvexProps>(sphereNoConvexProps)
+  implements SupportShapeWithConvexRadius
+{
+  getConvexRadius(): number {
+    return this.radius;
+  }
+
+  computeSupport(out: Vec3, direction: Vec3): void {
+    out.zero();
+  }
+}
+
+const sphereWithConvexProps = {
+  radius: NumberType(0.0),
+} as const satisfies PropertyDefinitionMap;
+
+export class SphereWithConvex
+  extends createClass<SphereWithConvex, typeof sphereWithConvexProps>(sphereWithConvexProps)
+  implements SupportShapeWithConvexRadius
+{
+  getConvexRadius(): number {
+    return 0;
+  }
+
+  computeSupport(out: Vec3, direction: Vec3): void {
+    const directionLength = direction.length();
+    if (directionLength > 0) {
+      out.scaleVector(direction, this.radius / directionLength);
+    } else {
+      out.zero();
+    }
+  }
+}
+
+const sphereProps = {
+  computedCenterOfMass: MonomorphType(Vec3, undefined, true),
+  computedVolume: NumberType(0.0, true),
+  computedAabb: MonomorphType(Aabb, undefined, true),
+  radius: NumberType(1.0),
+  copyForDiff: LazyReferenceType((() => Sphere) as () => never) as PropertyDefinitionReference<Sphere | null, true>,
+  sphereNoConvex: MonomorphType(SphereNoConvex, undefined, true),
+  sphereWithConvex: MonomorphType(SphereWithConvex, undefined, true),
+} as const satisfies PropertyDefinitionMap;
+
+const afterConstructorCode = `
+  this.world = null;
+`;
+
+export class Sphere
+  extends createClass<Sphere, typeof sphereProps>(sphereProps, { afterConstructorCode })
+  implements ConvexShapeInterface
+{
+  type: ShapeType.sphere = ShapeType.sphere;
+
+  declare world: World | null;
+
+  computeSupportShape(mode: SupportMode, scale: number): SupportShapeWithConvexRadius {
+    const scaled_radius = this.radius * scale;
+
+    switch (mode) {
+      case SupportMode.IncludeConvexRadius: {
+        this.sphereWithConvex.radius = scaled_radius;
+        return this.sphereWithConvex;
+      }
+
+      case SupportMode.ExcludeConvexRadius: {
+        this.sphereNoConvex.radius = scaled_radius;
+        return this.sphereNoConvex;
+      }
+
+      default: {
+        throw new Error(`Invalid support mode ${mode}`);
+      }
+    }
+  }
+
+  computeSupportingFace(
+    out: Face,
+    subShapeID: number,
+    direction: Vec3,
+    scale: number,
+    centerOfMassTransform: Mat4
+  ): void {
+    // no faces for a sphere
+    out.clear();
+  }
+
+  computeInertiaTensor(out: Mat3, mass: number) {
+    // assumptions:
+    // 1. sphere's center-of-mass is at origin
+    // 2. sphere is not transformed
+    // 3. sphere has uniform density = 1
+    const inertia = (2 / 5) * mass * this.radius * this.radius;
+    out.fromArray([inertia, 0, 0, 0, inertia, 0, 0, 0, inertia]);
+  }
+
+  computeInverseInertiaTensor(out: Mat3, mass: number) {
+    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?
+    out.translateAabb(this.computedAabb, translation);
+  }
+
+  hasChanged() {
+    return this.copyForDiff !== null && this.radius !== this.copyForDiff.radius;
+  }
+
+  commitChanges() {
+    if (this.hasChanged()) {
+      updateShape(this);
+      // this.world?.updateBodyProperties();
+    }
+  }
+
+  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3, subShapeId?: number): void {
+    // get the vector pointing from the center to the surface point
+    out.subtractVectors(inLocalSurfacePosition, this.computedCenterOfMass);
+    out.normalize();
+  }
+}
+
+const oldCreate = Sphere.create;
+Sphere.create = function () {
+  const shape = oldCreate.apply(this, arguments as any);
+  updateShape(shape);
+  return shape;
+};
+
+function updateVolume(shape: Sphere) {
+  shape.computedVolume = (4 / 3) * Math.PI * shape.radius * shape.radius * shape.radius;
+}
+
+function updateLocalBounds(shape: Sphere) {
+  // TODO: apply rotation if shape's center of mass is not at the origin?
+  shape.computedAabb.min.addScalarToVector(shape.computedCenterOfMass, -shape.radius);
+  shape.computedAabb.max.addScalarToVector(shape.computedCenterOfMass, +shape.radius);
+}
+
+function updateCopyForDiff(shape: Sphere) {
+  if (shape.copyForDiff) {
+    shape.copyForDiff.copy(shape);
+    shape.copyForDiff.copyForDiff = null;
+  }
+}
+
+function updateCenterOfMass(shape: Sphere) {
+  shape.computedCenterOfMass.zero();
+}
+
+function updateShape(shape: Sphere) {
+  updateCopyForDiff(shape);
+  updateCenterOfMass(shape);
+  updateVolume(shape);
+  updateLocalBounds(shape);
+}

package/src/shape/TransformedShape.ts

@@ -0,0 +1,51 @@
+import {
+  createClass,
+  MonomorphType,
+  NumberType,
+  PropertyDefinition,
+  PropertyDefinitionMap,
+  ReferenceType,
+} from "monomorph";
+import { Shape, ShapeType } from "./Shape";
+import { Sphere } from "./Sphere";
+import { Box } from "./Box";
+import { BasicTransform } from "../math/BasicTransform";
+import ConvexHull from "./ConvexHull";
+import { Cylinder } from "./Cylinder";
+import { Capsule } from "./Capsule";
+
+const transformedShapeProps = {
+  shapeType: NumberType(ShapeType.box) 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),
+  // compoundShape not supported
+  ['shape' + ShapeType.convexHull as 'shape3']: ReferenceType(ConvexHull, undefined, true),
+  ['shape' + ShapeType.cylinder as 'shape4']: ReferenceType(Cylinder, undefined, true),
+  // heightMap not supported
+  ['shape' + ShapeType.sphere as 'shape6']: ReferenceType(Sphere, undefined, true),
+  // triangleMesh not supported
+  transform: MonomorphType(BasicTransform),
+} as const satisfies PropertyDefinitionMap;
+
+const afterConstructorCode = `
+  this.world = null;
+`;
+
+export class TransformedShape extends createClass<TransformedShape, typeof transformedShapeProps>(
+  transformedShapeProps,
+  { afterConstructorCode }
+) {
+  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;
+    // this.computeMassProperties();
+    // computeCenterOfMassPosition(this.computedCenterOfMassPosition, this);
+    // this.computeWorldBounds(this.computedBounds);
+  }
+}

package/src/shape/Triangle.ts

@@ -0,0 +1,122 @@
+import { createClass, MonomorphType, NumberType, PropertyDefinitionMap } from "monomorph";
+import { Vec3 } from "../math/vec3";
+import { Mat4 } from "../math/mat4";
+import { Aabb } from "./Aabb";
+import { SupportMode, SupportShapeWithConvexRadius } from "./Convex";
+import { Face } from "../physics/manifold/Face";
+import { Ray } from "./Ray";
+
+const triangleProps = {
+  computedBounds: MonomorphType(Aabb, undefined, true),
+  normal: MonomorphType(Vec3, undefined, true),
+  a: MonomorphType(Vec3),
+  b: MonomorphType(Vec3),
+  c: MonomorphType(Vec3),
+  subShapeId: NumberType(0, true),
+  activeEdges: NumberType(0, true),
+  // aabb: { struct: Aabb, readOnly: true },
+  // activeEdges: { struct: Uint32, optional: true },
+  // translation: { struct: Vec3, optional: true },
+} as const satisfies PropertyDefinitionMap;
+
+const ab = /*@__PURE__*/ Vec3.create();
+const ac = /*@__PURE__*/ Vec3.create();
+
+export class Triangle extends createClass<Triangle, typeof triangleProps>(triangleProps) {
+  // type: ShapeType.triangle = ShapeType.triangle;
+
+  computeNormal(out: Vec3): void {
+    ab.subtractVectors(this.b, this.a);
+    ac.subtractVectors(this.c, this.a);
+    out.crossVectors(ab, ac);
+    out.normalize();
+  }
+
+  computeCentroid(out: Vec3): void {
+    out
+      .addVectors(this.a, this.b)
+      .addVector(this.c)
+      .scale(1 / 3);
+  }
+
+  computeUnnormalizedNormal(out: Vec3): void {
+    ab.subtractVectors(this.b, this.a);
+    ac.subtractVectors(this.c, this.a);
+    out.crossVectors(ab, ac);
+  }
+
+  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3, subShapeId?: number): void {
+    // TODO: take into account surface position for backfaces?
+    this.computeNormal(out);
+  }
+
+  transform(isometry: Mat4) {
+    this.a.transformByMat4(isometry);
+    this.b.transformByMat4(isometry);
+    this.c.transformByMat4(isometry);
+  }
+
+  computeLocalBounds(out: Aabb) {
+    out.min.x = Math.min(this.a.x, this.b.x, this.c.x);
+    out.min.y = Math.min(this.a.y, this.b.y, this.c.y);
+    out.min.z = Math.min(this.a.z, this.b.z, this.c.z);
+
+    out.max.x = Math.max(this.a.x, this.b.x, this.c.x);
+    out.max.y = Math.max(this.a.y, this.b.y, this.c.y);
+    out.max.z = Math.max(this.a.z, this.b.z, this.c.z);
+
+    out.computeCentroid(out.centroid);
+  }
+
+  computeSupport(out: Vec3, direction: Vec3): void {
+    const dotA = this.a.dot(direction);
+    const dotB = this.b.dot(direction);
+    const dotC = this.c.dot(direction);
+
+    if (dotA > dotB) {
+      if (dotA > dotC) {
+        out.copy(this.a);
+      } else {
+        out.copy(this.c);
+      }
+    } else {
+      if (dotB > dotC) {
+        out.copy(this.b);
+      } else {
+        out.copy(this.c);
+      }
+    }
+  }
+
+  getConvexRadius(): number {
+    return 0;
+  }
+
+  computeSupportShape(mode: SupportMode, scale: number): SupportShapeWithConvexRadius {
+    // TODO: account for mode and scale not being supported like the other shapes
+    // 1. either adjust the method signature to make mode and scale optional
+    // 2. or add support for mode and scale
+    return this;
+  }
+
+  toObject() {
+    return {
+      a: this.a.toObject(),
+      b: this.b.toObject(),
+      c: this.c.toObject(),
+      normal: this.normal.toObject(),
+    };
+  }
+
+  computeSupportingFace(out: Face, subShapeID: number, direction: Vec3, scale: number, centerOfMassTransform: Mat4) {
+    // TODO: prescale transform
+
+    // TODO: flip triangle if scaled inside out
+
+    out.clear();
+    out.pushVertex(this.a);
+    out.pushVertex(this.b);
+    out.pushVertex(this.c);
+    out.transform(centerOfMassTransform);
+  }
+}