@perplexdotgg/bounce 1.0.0

package/src/shape/TriangleMesh.ts

@@ -0,0 +1,186 @@
+import {
+  createClass,
+  LazyReferenceType,
+  MonomorphType,
+  NumberType,
+  PropertyDefinitionMap,
+  PropertyDefinitionReference,
+  ReferenceListType,
+} from "monomorph";
+import { Triangle } from "./Triangle";
+import { Aabb } from "./Aabb";
+import { Vec3 } from "../math/vec3";
+import { Mat3 } from "../math/mat3";
+import { ShapeCollectionInterface, ShapeType } from "./Shape";
+import type { World } from "../world";
+import { Isometry } from "../math/isometry";
+import { Face } from "../physics/manifold/Face";
+import { Mat4 } from "../math/mat4";
+import { Quat } from "../math/quat";
+import { TriangleMeshBvhTree } from "../physics/broadphase/TriangleMeshBvhTree";
+import { Ray } from "./Ray";
+
+const isometry = /*@__PURE__*/ Isometry.create();
+
+/**
+ * Callback function for walking over the triangles of a triangle mesh.
+ * @param triangle The triangle that is being visited.
+ * @param activeEdges The number of active edges.
+ * @param triangleId The id of the triangle.
+ * @returns returns a stopIteration flag. return true to stop iterating, false to continue.
+ */
+const triangleMeshProps = {
+  computedCenterOfMass: MonomorphType(Vec3, undefined, true),
+  computedVolume: NumberType(0.0, true),
+  computedAabb: MonomorphType(Aabb, undefined, true),
+  translation: MonomorphType(Vec3),
+  inertia: MonomorphType(Mat3, undefined, true),
+  vertexPositions: ReferenceListType(Vec3),
+  faceIndices: ReferenceListType(Vec3),
+  triangles: ReferenceListType(Triangle),
+  copyForDiff: LazyReferenceType((() => TriangleMesh) as () => never) as PropertyDefinitionReference<
+    TriangleMesh | null,
+    true
+  >,
+  bvh: LazyReferenceType((() => TriangleMeshBvhTree) as () => never) as PropertyDefinitionReference<
+    TriangleMeshBvhTree | null,
+    true
+  >,
+} as const satisfies PropertyDefinitionMap;
+
+const afterConstructorCode = `
+  this.world = null;
+`;
+
+export class TriangleMesh
+  extends createClass<TriangleMesh, typeof triangleMeshProps>(triangleMeshProps, { afterConstructorCode })
+  implements ShapeCollectionInterface
+{
+  type: ShapeType.triangleMesh = ShapeType.triangleMesh;
+
+  declare world: World | null;
+
+  // TODO: for direct broadphase queries
+  intersectsAabb(aabb: Aabb): boolean {
+    return false;
+  }
+
+  // TODO: for character controller
+  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3, subShapeId?: number): void {
+    //
+  }
+
+  // TODO: for physics. this currently just uses convex hull's method
+  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) {
+    // TODO: apply rotation if shape's center of mass is not at the origin?
+    isometry.fromRotationAndTranslation(rotation, translation);
+    out.transformAabb(this.computedAabb, isometry);
+  }
+
+  // TODO: for narrowphase
+  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");
+    }
+
+    const triangle = this.triangles!.getAtIndex(subShapeID)!;
+
+    out.pushVertex(triangle.a);
+    out.pushVertex(triangle.b);
+    out.pushVertex(triangle.c);
+    out.transform(centerOfMassTransform);
+  }
+
+  createTriangulatedVerticesAndNormalsArray(): [Float32Array, Float32Array, Float32Array] {
+    const positions: number[] = [];
+    const normals: number[] = [];
+    const indices: number[] = [];
+
+    for (const position of this.vertexPositions!) {
+      positions.push(position.x, position.y, position.z);
+    }
+
+    for (const index of this.faceIndices!) {
+      indices.push(index.x, index.y, index.z);
+    }
+
+    for (const triangle of this.triangles!) {
+      normals.push(triangle.normal.x, triangle.normal.y, triangle.normal.z);
+    }
+
+    return [new Float32Array(positions), new Float32Array(normals), new Float32Array(indices)];
+  }
+
+  iterateTriangles(onHit: (triangle: Triangle) => boolean): void {
+    for (const triangle of this.triangles) {
+      if (onHit(triangle)) {
+        break;
+      }
+    }
+  }
+
+  iterateNearbyTriangles(shapeBounds: Aabb, onHit: (triangle: Triangle) => boolean): void {
+    this.bvh!.intersectAabb(onHit, shapeBounds);
+  }
+
+  hasChanged() {
+    // TODO: we don't currently support changes for this shape
+    return false;
+  }
+
+  commitChanges() {
+    if (this.hasChanged()) {
+      updateShape(this);
+      // this.world?.updateBodyProperties();
+    }
+  }
+}
+
+function updateVolume(shape: TriangleMesh) {
+  // recomputing volume for this shape not supported yet
+}
+
+export function updateLocalBounds(shape: TriangleMesh) {
+  shape.computedAabb.min.fromArray([Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY]);
+  shape.computedAabb.max.fromArray([Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY]);
+  for (const vertex of shape.vertexPositions) {
+    shape.computedAabb.min.minVectors(shape.computedAabb.min, vertex);
+    shape.computedAabb.max.maxVectors(shape.computedAabb.max, vertex);
+  }
+}
+
+function updateCopyForDiff(shape: TriangleMesh) {
+  if (shape.copyForDiff) {
+    shape.copyForDiff.copy(shape);
+    shape.copyForDiff.copyForDiff = null;
+  }
+}
+
+function updateCenterOfMass(shape: TriangleMesh) {
+  // recomputing center of mass for this shape not supported yet
+}
+
+export function updateShape(shape: TriangleMesh) {
+  updateCopyForDiff(shape);
+  updateCenterOfMass(shape);
+  updateVolume(shape);
+  updateLocalBounds(shape);
+}

package/src/types.ts

@@ -0,0 +1 @@
+export type Tuple4<T> = [T, T, T, T];