@perplexdotgg/bounce 1.0.0

package/src/shape/Convex.ts

@@ -0,0 +1,130 @@
+import { createClass, MonomorphType, NumberType, PropertyDefinitionMap } from "monomorph";
+import { Isometry } from "../math/isometry";
+import { Vec3 } from "../math/vec3";
+import { Face } from "../physics/manifold/Face";
+import { Mat4 } from "../math/mat4";
+
+export interface SupportShape {
+  computeSupport(out: Vec3, direction: Vec3): void;
+}
+
+export const enum SupportMode {
+  ExcludeConvexRadius,
+  IncludeConvexRadius,
+}
+
+export interface ConvexWithcomputeSupportShape {
+  computeSupportShape(mode: SupportMode, scale: number): SupportShapeWithConvexRadius;
+}
+
+export interface SupportShapeWithConvexRadius extends SupportShape {
+  getConvexRadius(): number;
+}
+
+const localDirection = /*@__PURE__*/ Vec3.create();
+
+export class TransformedConvexObject implements SupportShape {
+  transform: Isometry | null;
+  convexShape: SupportShape | null;
+
+  constructor() {
+    this.transform = null;
+    this.convexShape = null;
+  }
+
+  setData(transform: Isometry, convexShape: SupportShape): void {
+    this.transform = transform;
+    this.convexShape = convexShape;
+  }
+
+  computeSupport(out: Vec3, direction: Vec3): void {
+    this.transform!.matrix.multiply3x3Transposed(localDirection, direction);
+    this.convexShape!.computeSupport(out, localDirection);
+    out.transformFromMat4(this.transform!.matrix);
+  }
+}
+
+const transformedConvexShapeProps = {
+  transform: MonomorphType(Isometry),
+} as const satisfies PropertyDefinitionMap;
+
+const direction = /*@__PURE__*/ Vec3.create();
+
+export class TransformedConvexShape extends createClass<TransformedConvexShape, typeof transformedConvexShapeProps>(
+  transformedConvexShapeProps
+) {
+  object: SupportShape | null;
+
+  constructor() {
+    super();
+    this.object = null;
+  }
+
+  // Calculate the support vector for this convex shape.
+  computeSupport(out: Vec3, inDirection: Vec3): void {
+    this.transform.matrix.multiply3x3Transposed(direction, inDirection);
+    this.object!.computeSupport(out, direction);
+    out.transformByMat4(this.transform.matrix);
+  }
+}
+
+const convexRadiusObjectProps = {
+  radius: NumberType(0.0),
+} as const satisfies PropertyDefinitionMap;
+
+export class ConvexRadiusObject extends createClass<ConvexRadiusObject, typeof convexRadiusObjectProps>(
+  convexRadiusObjectProps
+) {
+  // TODO: this is an actual reference, should this be changed?
+  convexShape: SupportShape | null;
+
+  constructor() {
+    super();
+    this.convexShape = null;
+  }
+
+  setData(radius: number, convexShape: SupportShape): void {
+    this.radius = radius;
+    this.convexShape = convexShape;
+  }
+
+  // Calculate the support vector for this convex shape.
+  computeSupport(out: Vec3, inDirection: Vec3): void {
+    const length = inDirection.length();
+    this.convexShape!.computeSupport(out, inDirection);
+    if (length > 0.0) {
+      out.addScaled(inDirection, this.radius / length);
+    }
+  }
+}
+
+const vertex = /*@__PURE__*/ Vec3.create();
+
+export class PolygonConvexSupport implements SupportShape {
+  declare vertices: Face;
+
+  computeSupport(out: Vec3, direction: Vec3): void {
+    this.vertices.getVertex(out, 0);
+    let bestDot = out.dot(direction);
+
+    // iterate over the vertices of the face
+    for (let i = 0; i < this.vertices.numVertices; i++) {
+      this.vertices.getVertex(vertex, i);
+      const dot = vertex.dot(direction);
+      if (dot > bestDot) {
+        bestDot = dot;
+        out.copy(vertex);
+      }
+    }
+  }
+
+  computeSupportingFace(
+    out: Face,
+    subShapeID: number,
+    direction: Vec3,
+    scale: number,
+    centerOfMassTransform: Mat4
+  ): void {
+    throw new Error("Method not implemented.");
+  }
+}

package/src/shape/ConvexHull.ts

@@ -0,0 +1,423 @@
+import {
+  createClass,
+  LazyReferenceType,
+  MonomorphType,
+  NumberType,
+  PropertyDefinitionMap,
+  PropertyDefinitionReference,
+  ReferenceListType,
+} from "monomorph";
+import { Vec3 } from "../math/vec3";
+import { ConvexShapeInterface, ShapeType } from "./Shape";
+import { Aabb } from "./Aabb";
+import { Mat3 } from "../math/mat3";
+import { Plane } from "./Plane";
+import { NumberValue } from "../math/NumberValue";
+import { SupportMode, SupportShapeWithConvexRadius } from "./Convex";
+import { Face } from "../physics/manifold/Face";
+import { Mat4 } from "../math/mat4";
+import { Isometry } from "../math/isometry";
+import { Quat } from "../math/quat";
+import type { World } from "../world";
+
+const maxPointsInHull = 1000;
+const isometry = /*@__PURE__*/ Isometry.create();
+const cross_n1_n2 = /*@__PURE__*/ Vec3.create();
+let newPoint = /*@__PURE__*/ Vec3.create();
+
+const p1 = /*@__PURE__*/ Plane.create();
+const p2 = /*@__PURE__*/ Plane.create();
+const p3 = /*@__PURE__*/ Plane.create();
+
+export class ConvexHullNoConvex implements SupportShapeWithConvexRadius {
+  shape: ConvexHull;
+  points: typeof ConvexHull.prototype.shapeNoConvexPoints;
+
+  constructor(shape: ConvexHull, points: typeof ConvexHull.prototype.shapeNoConvexPoints) {
+    this.shape = shape;
+    this.points = points;
+  }
+
+  getConvexRadius() {
+    return this.shape.convexRadius;
+  }
+
+  computeSupport(out: Vec3, direction: Vec3) {
+    // Find the point with the highest projection on inDirection
+    let bestDot = -Infinity;
+    let bestPointIndex = -1;
+
+    for (let i = 0; i < this.points!.length; i++) {
+      const point = this.points!.getAtIndex(i)!;
+
+      // Check if its support is bigger than the current max
+      const dot = point.dot(direction);
+      if (dot > bestDot) {
+        bestDot = dot;
+        bestPointIndex = i;
+      }
+    }
+
+    out.copy(this.points!.getAtIndex(bestPointIndex)!);
+  }
+
+  computeSupportingFace(out: Face, subShapeID: number, direction: Vec3, scale: number, centerOfMassTransform: Mat4) {
+    throw new Error("Method not implemented.");
+  }
+}
+
+export class ConvexHullWithConvex implements SupportShapeWithConvexRadius {
+  shape: ConvexHull;
+
+  constructor(shape: ConvexHull) {
+    this.shape = shape;
+  }
+
+  getConvexRadius() {
+    return 0.0;
+  }
+
+  computeSupport(out: Vec3, direction: Vec3) {
+    // Find the point with the highest projection on inDirection
+    let bestDot = -Infinity;
+    let bestPointIndex = -1;
+
+    for (let i = 0; i < this.shape.points!.length; i++) {
+      const point = this.shape.points!.getAtIndex(i)!;
+
+      // Check if its support is bigger than the current max
+      const dot = point.position.dot(direction);
+      if (dot > bestDot) {
+        bestDot = dot;
+        bestPointIndex = i;
+      }
+    }
+
+    out.copy(this.shape.points!.getAtIndex(bestPointIndex)!.position);
+  }
+
+  computeSupportingFace(out: Face, subShapeID: number, direction: Vec3, scale: number, centerOfMassTransform: Mat4) {
+    throw new Error("Method not implemented.");
+  }
+}
+
+const convexHullPointProps = {
+  position: MonomorphType(Vec3),
+  numFaces: NumberType(0),
+  faces: MonomorphType(Vec3),
+} as const satisfies PropertyDefinitionMap;
+
+export class ConvexHullPoint extends createClass<ConvexHullPoint, typeof convexHullPointProps>(convexHullPointProps) {
+  toObject() {
+    return {
+      position: this.position.toObject(),
+      numFaces: this.numFaces,
+      faces: this.faces.toObject(),
+    };
+  }
+}
+
+const convexHullFaceProps = {
+  firstVertex: NumberType(0),
+  numVertices: NumberType(0),
+} as const satisfies PropertyDefinitionMap;
+
+export class ConvexHullFace extends createClass<ConvexHullFace, typeof convexHullFaceProps>(convexHullFaceProps) {
+  toObject() {
+    return {
+      firstVertex: this.firstVertex,
+      numVertices: this.numVertices,
+    };
+  }
+}
+
+const convexHullProps = {
+  computedCenterOfMass: MonomorphType(Vec3, undefined, true),
+  computedVolume: NumberType(0.0, true),
+  computedAabb: MonomorphType(Aabb, undefined, true),
+  convexRadius: NumberType(0.0),
+  innerRadius: NumberType(0.0, true),
+  inertia: MonomorphType(Mat3, undefined, true),
+  points: ReferenceListType(ConvexHullPoint), // { array: Float64Array(b), itemMaxCount: b / 7, itemSize: 7 } [ConvexHullPoint], points on the convex hull surface
+  faces: ReferenceListType(ConvexHullFace), // { array: Float64Array(c), itemMaxCount: c / 2, itemSize: 2 } [ConvexHullFace], faces of the convex hull surface
+  planes: ReferenceListType(Plane), // { array: Float64Array(d), itemMaxCount: d / 4, itemSize: 4 } [Plane], planes of the convex hull surface
+  vertexIdx: ReferenceListType(NumberValue), // { array: Float64Array(e), itemMaxCount: e, itemSize: 1 } [Uint32], vertex indices for each of the faces
+  shapeNoConvexPoints: ReferenceListType(Vec3), // { array: Float64Array(f), itemMaxCount: f / 3, itemSize: 3 } [Vec3], transformed points used by ConvexHullNoConvex
+  translation: MonomorphType(Vec3, { x: 0, y: 0, z: 0 }),
+  copyForDiff: LazyReferenceType((() => ConvexHull) as () => never) as PropertyDefinitionReference<
+    ConvexHull | null,
+    true
+  >,
+} as const satisfies PropertyDefinitionMap;
+
+const afterConstructorCode = `
+  this.world = null;
+  this.shapeNoConvex = null;
+  this.shapeWithConvex = null;
+  this.type = ${ShapeType.convexHull};
+`;
+
+export default class ConvexHull
+  extends createClass<ConvexHull, typeof convexHullProps>(convexHullProps, { afterConstructorCode })
+  implements ConvexShapeInterface
+{
+  declare world: World | null;
+  declare shapeNoConvex: ConvexHullNoConvex;
+  declare shapeWithConvex: ConvexHullWithConvex;
+  declare type: ShapeType.convexHull;
+
+  computeSupportShape(inMode: SupportMode, inScale: number): SupportShapeWithConvexRadius {
+    // If there's no convex radius, we don't need to shrink the hull
+    if (this.convexRadius === 0.0) {
+      // TODO: implement scale helpers logic
+      this.shapeWithConvex.shape = this;
+      return this.shapeWithConvex;
+    }
+
+    switch (inMode) {
+      case SupportMode.IncludeConvexRadius: {
+        if (inScale === 1.0) {
+          this.shapeWithConvex.shape = this;
+          return this.shapeWithConvex;
+        } else {
+          throw new Error("Not implemented");
+        }
+      }
+      case SupportMode.ExcludeConvexRadius: {
+        if (inScale === 1.0) {
+          // Create support function
+          const hull = this.shapeNoConvex;
+
+          // #v-ifdef DEV
+          // assert
+          if (this.points!.length > maxPointsInHull) {
+            throw new Error(
+              `Not enough space, this should have been caught during shape creation!, points: ${
+                this.points!.length
+              }, max: ${maxPointsInHull}`
+            );
+          }
+          // #v-endif
+
+          let numPoints = 0;
+
+          for (let i = 0; i < this.points!.length; i++) {
+            const point = this.points!.getAtIndex(i)!;
+            newPoint.zero();
+
+            if (point.numFaces === 1) {
+              // Simply shift back by the convex radius using our 1 plane
+              // plane.copyFromList(this.planes, point.faces.x);
+              newPoint.addScaledToVector(point.position, this.planes!.getAtIndex(point.faces.x)!.normal, -this.convexRadius);
+            } else {
+              // Get first two planes and offset inwards by convex radius
+              p1.offsetPlaneAlongNormal(this.planes!.getAtIndex(point.faces.x)!, -this.convexRadius);
+              p2.offsetPlaneAlongNormal(this.planes!.getAtIndex(point.faces.y)!, -this.convexRadius);
+
+              if (point.numFaces === 3) {
+                // Get third plane and offset inwards by convex radius
+                p3.offsetPlaneAlongNormal(this.planes!.getAtIndex(point.faces.z)!, -this.convexRadius);
+              } else {
+                // Third plane has normal perpendicular to the other two planes and goes through the vertex position
+                // #v-ifdef DEV
+                // assert
+                if (point.numFaces !== 2) {
+                  throw new Error(`Invalid number of faces: ${point.numFaces}`);
+                }
+                // #v-endif
+                cross_n1_n2.crossVectors(p1.normal, p2.normal);
+                p3.fromPointAndNormal(point.position, cross_n1_n2);
+              }
+
+              // Find intersection point between the three planes
+              const intersection = Plane.intersectPlanes(p1, p2, p3, newPoint);
+              if (!intersection) {
+                // Fallback: Just push point back using the first plane
+                newPoint.addScaledToVector(point.position, p1.normal, -this.convexRadius);
+              }
+            }
+
+            // Add point
+            // new_point.pushToList(hull.points);
+            hull.points!.getAtIndex(numPoints)!.copy(newPoint);
+            numPoints++;
+          }
+
+          hull.points!.length = numPoints;
+
+          return hull;
+        } else {
+          throw new Error("Not implemented");
+        }
+      }
+      default: {
+        throw new Error(`Invalid support mode: ${inMode}`);
+      }
+    }
+  }
+
+  computeSupportingFace(
+    out: Face,
+    subShapeID: number,
+    direction: Vec3,
+    scale: number,
+    centerOfMassTransform: Mat4
+  ): void {
+    out.clear();
+
+    // scaling is not implemented yet
+    if (scale !== 1.0) {
+      throw new Error("scaling is not implemented yet");
+    }
+
+    // find the plane that has a normal as similar as possible to the search direction vector
+    let bestDot = +Infinity;
+    let bestFaceIndex = -1;
+    for (let i = 0; i < this.planes!.length; i++) {
+      const plane = this.planes!.getAtIndex(i)!;
+      const dot = plane.normal.dot(direction);
+      if (dot < bestDot) {
+        bestDot = dot;
+        bestFaceIndex = i;
+      }
+    }
+
+    // get the best face
+    const face = this.faces!.getAtIndex(bestFaceIndex)!;
+
+    // TODO: handle inverse scale
+    const maxVerticesToReturn = out.buffer!.maxLength / 2;
+    const deltaVtx = Math.floor((face.numVertices + maxVerticesToReturn) / maxVerticesToReturn);
+
+    // TODO: Calculate transform with scale
+    for (let i = 0; i < face.numVertices; i += deltaVtx) {
+      const index = this.vertexIdx!.getAtIndex(face.firstVertex + i)!;
+      const point = this.points!.getAtIndex(index.value)!;
+      out.pushVertex(point.position);
+    }
+
+    // transform the out face to world space
+    out.transform(centerOfMassTransform);
+  }
+
+  computeInertiaTensor(out: Mat3, mass: number): void {
+    out.multiplyMatrixByScalar(this.inertia, mass / this.computedVolume);
+  }
+
+  computeInverseInertiaTensor(out: Mat3, mass: number): void {
+    this.computeInertiaTensor(out, mass);
+    out.invert();
+  }
+
+  computeWorldBounds(out: Aabb, translation: Vec3, rotation: Quat) {
+    isometry.fromRotationAndTranslation(rotation, translation);
+    out.transformAabb(this.computedAabb, isometry);
+  }
+
+  createTriangulatedVerticesAndNormalsArray(): [Float32Array, Float32Array] {
+    const vertices = [];
+    const normals = [];
+    // loop over faces
+    for (let i = 0; i < this.faces!.length; i++) {
+      const face = this.faces!.getAtIndex(i)!;
+      const plane = this.planes!.getAtIndex(i)!;
+
+      for (let j = 1; j < face.numVertices - 1; j++) {
+        // Triangle made up of the first vertex, and every subsequent pair
+        const indices = [0, j, j + 1];
+        for (let k of indices) {
+          // Adjusted to use the first vertex and the current pair to form triangles
+          const index = this.vertexIdx!.getAtIndex(face.firstVertex + k)!;
+          const point = this.points!.getAtIndex(index.value)!;
+
+          // Add vertex
+          vertices.push(point.position.x + this.computedCenterOfMass.x);
+          vertices.push(point.position.y + this.computedCenterOfMass.y);
+          vertices.push(point.position.z + this.computedCenterOfMass.z);
+
+          // Add normal (same for all vertices of the face)
+          normals.push(plane.normal.x);
+          normals.push(plane.normal.y);
+          normals.push(plane.normal.z);
+        }
+      }
+    }
+
+    return [new Float32Array(vertices), new Float32Array(normals)];
+  }
+
+  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3, subShapeId?: number): void {
+    const first_plane = this.planes!.getAtIndex(0)!;
+    best_normal.set(first_plane.normal);
+    let best_dist = Math.abs(first_plane.signedDistance(inLocalSurfacePosition));
+
+    // Find the face that has the shortest distance to the surface point
+    for (let i = 1; i < this.faces!.length; ++i) {
+      const plane = this.planes!.getAtIndex(i)!;
+      const dist = Math.abs(plane.signedDistance(inLocalSurfacePosition));
+      if (dist < best_dist) {
+        best_dist = dist;
+        best_normal.copy(plane.normal);
+      }
+    }
+
+    out.copy(best_normal);
+  }
+
+  hasChanged() {
+    // TODO: we don't currently support changes for this shape
+    return false;
+  }
+
+  commitChanges() {
+    if (this.hasChanged()) {
+      updateShape(this);
+      // this.world?.updateBodyProperties();
+    }
+  }
+}
+
+const best_normal = /*@__PURE__*/ Vec3.create();
+
+function updateVolume(shape: ConvexHull) {
+  // recomputing volume for this shape not supported yet
+}
+
+function updateLocalBounds(shape: ConvexHull) {
+  const min = shape.computedAabb.min;
+  const max = shape.computedAabb.max;
+
+  // Set the min and max to the first point
+  min.set({ x: +Infinity, y: +Infinity, z: +Infinity });
+  max.set({ x: -Infinity, y: -Infinity, z: -Infinity });
+
+  // Loop over the rest of the points
+  for (let i = 0; i < shape.points!.length; i++) {
+    const point = shape.points!.getAtIndex(i)!;
+    min.x = Math.min(min.x, point.position.x);
+    min.y = Math.min(min.y, point.position.y);
+    min.z = Math.min(min.z, point.position.z);
+
+    max.x = Math.max(max.x, point.position.x);
+    max.y = Math.max(max.y, point.position.y);
+    max.z = Math.max(max.z, point.position.z);
+  }
+}
+
+function updateCenterOfMass(shape: ConvexHull) {
+  // recomputing center of mass for this shape not supported yet
+}
+
+function updateCopyForDiff(shape: ConvexHull) {
+  if (shape.copyForDiff) {
+    shape.copyForDiff.copy(shape);
+    shape.copyForDiff.copyForDiff = null;
+  }
+}
+
+export function updateShape(shape: ConvexHull) {
+  updateCopyForDiff(shape);
+  updateCenterOfMass(shape);
+  updateVolume(shape);
+  updateLocalBounds(shape);
+}