@perplexdotgg/bounce 1.0.0 → 1.0.2

package/src/shape/Convex.ts

@@ -1,130 +0,0 @@
-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

@@ -1,423 +0,0 @@
-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);
-}