@perplexdotgg/bounce 1.0.0 → 1.0.1

package/src/shape/HeightMap.ts

@@ -1,511 +0,0 @@
-import {
-  createClass,
-  LazyReferenceType,
-  MonomorphType,
-  NumberType,
-  PropertyDefinitionMap,
-  PropertyDefinitionReference,
-} from "monomorph";
-import { ShapeCollectionInterface, ShapeType } from "./Shape";
-import { Face } from "../physics/manifold/Face";
-import { Mat4 } from "../math/mat4";
-import { Mat3 } from "../math/mat3";
-import { Aabb } from "./Aabb";
-import { Vec3 } from "../math/vec3";
-import { Triangle } from "./Triangle";
-import { Isometry } from "../math/isometry";
-import { Quat } from "../math/quat";
-import { Tuple4 } from "../types";
-import type { World } from "../world";
-import { Ray } from "./Ray";
-
-export interface HeightMapVisitor {
-  shouldVisitBlock(block: Aabb): boolean;
-  visitTriangle(triangle: Triangle, activeEdges: number, triangleId: number): void;
-}
-
-class HeightMapRaycaster implements HeightMapVisitor {
-  declare ray: Ray;
-  declare onHit: (triangle: Triangle) => boolean;
-
-  init(onHit: (triangle: Triangle) => boolean, ray: Ray): void {
-    this.ray = ray;
-    this.onHit = onHit;
-  }
-
-  shouldVisitBlock(block: Aabb): boolean {
-    return this.ray.intersectsAabb(block);
-  }
-
-  visitTriangle(triangle: Triangle, activeEdges: number, triangleId: number): void {
-    this.onHit(triangle);
-  }
-}
-
-const heightMapRaycaster = /*@__PURE__*/ new HeightMapRaycaster();
-
-export function computeNumberOfLevels(numberOfSubdivisions: number): number {
-  return Math.log2(numberOfSubdivisions) + 1;
-}
-
-export function computeNumberOfCells(numberOfSubdivisions: number): number {
-  let numberOfCells = 0;
-  let currentNumberOfSubdivisions = numberOfSubdivisions;
-
-  while (currentNumberOfSubdivisions >= 1) {
-    numberOfCells += currentNumberOfSubdivisions ** 2;
-    currentNumberOfSubdivisions = currentNumberOfSubdivisions / 2;
-  }
-
-  return numberOfCells;
-}
-
-export function computeCornerIndicesInGrid(out: Tuple4<number>, x: number, z: number, stride: number): void {
-  const bottomLeft = x * stride + z;
-  const bottomRight = bottomLeft + 1;
-  const topLeft = bottomLeft + stride;
-  const topRight = topLeft + 1;
-
-  out[0] = bottomLeft;
-  out[1] = bottomRight;
-  out[2] = topLeft;
-  out[3] = topRight;
-}
-
-const triangle = /*@__PURE__*/ Triangle.create();
-const isometry = /*@__PURE__*/ Isometry.create();
-const interpolatedPoint = /*@__PURE__*/ Vec3.create();
-const a = /*@__PURE__*/ Vec3.create();
-const b = /*@__PURE__*/ Vec3.create();
-const c = /*@__PURE__*/ Vec3.create();
-const d = /*@__PURE__*/ Vec3.create();
-const scale = /*@__PURE__*/ Vec3.create();
-const blockAabb = /*@__PURE__*/ Aabb.create();
-const normal = /*@__PURE__*/ Vec3.create();
-
-const heightMapProps = {
-  computedCenterOfMass: MonomorphType(Vec3, undefined, true),
-  computedVolume: NumberType(0.0, true),
-  computedAabb: MonomorphType(Aabb, {}, true),
-  copyForDiff: LazyReferenceType((() => HeightMap) as () => never) as PropertyDefinitionReference<
-    HeightMap | null,
-    true
-  >,
-  subdivisionsCount: NumberType(0),
-  scale: MonomorphType(Vec3),
-  positionOffset: MonomorphType(Vec3),
-  // heights: PoolReferenceType(Vec1),
-  // minHeights: PoolReferenceType(Vec1),
-  // maxHeights: PoolReferenceType(Vec1),
-  // levels: PoolReferenceType(Vec1),
-  // activeEdges: PoolReferenceType(Vec1),
-} as const satisfies PropertyDefinitionMap;
-
-const afterConstructorCode = `
-  this.world = null;
-  this.heights = [];
-  this.minHeights = [];
-  this.maxHeights = [];
-  this.levels = [];
-  this.activeEdges = [];
-  this.stack = [];
-  this.children = [0, 0, 0, 0];
-`;
-
-export class HeightMap
-  extends createClass<HeightMap, typeof heightMapProps>(heightMapProps, { afterConstructorCode })
-  implements ShapeCollectionInterface
-{
-  type: ShapeType.heightMap = ShapeType.heightMap;
-
-  declare world: World | null;
-  declare heights: number[];
-  declare minHeights: number[];
-  declare maxHeights: number[];
-  declare levels: number[];
-  declare activeEdges: number[];
-
-  /**
-   * a stack to hold the indices of the blocks to visit during when walking the heightMap
-   */
-  declare stack: Array<number>;
-
-  /**
-   * a stack to hold the indices of the children of the current block when walking the heightMap
-   */
-  declare children: Tuple4<number>;
-
-  computeSupportingFace(
-    out: Face,
-    subShapeID: number,
-    direction: Vec3,
-    scale: number,
-    centerOfMassTransform: Mat4
-  ): void {
-    // get the triangle
-
-    this.computeTriangle(triangle, subShapeID);
-
-    // TODO: flip the triangle if scaled inside out
-
-    // TODO: prescale the transform
-
-    // transform to world space
-    triangle.transform(centerOfMassTransform);
-
-    // push world space triangle vertices to face
-    out.pushVertex(triangle.a);
-    out.pushVertex(triangle.b);
-    out.pushVertex(triangle.c);
-  }
-
-  computeInverseInertiaTensor(out: Mat3, mass: number): void {
-    out.zero();
-  }
-
-  computeWorldBounds(out: Aabb, translation: Vec3, rotation: Quat): void {
-    isometry.fromRotationAndTranslation(rotation, translation);
-    out.transformAabb(this.computedAabb, isometry);
-  }
-
-  computeInterpolatedHeight(localPosition: Vec3): number {
-    this.computeInterpolatedLocalPoint(interpolatedPoint, localPosition);
-    return interpolatedPoint.y;
-  }
-
-  computeInterpolatedLocalPoint(out: Vec3, localPosition: Vec3): void {
-    // TODO: clamp the local position?
-    const localPositionZ = localPosition.z;
-    const localPositionX = localPosition.x;
-
-    // get grid cell
-    let columnIndex = Math.floor((localPositionZ - this.positionOffset.z) / this.scale.z);
-    let rowIndex = Math.floor((localPositionX - this.positionOffset.x) / this.scale.x);
-
-    // if either of the indices are out of bounds (< 0, or > subdivisionsCount), we return the local position as is
-    if (
-      columnIndex < 0 ||
-      columnIndex >= this.subdivisionsCount ||
-      rowIndex < 0 ||
-      rowIndex >= this.subdivisionsCount
-    ) {
-      out.copy(localPosition);
-      return;
-    }
-
-    // get the local position within the cell
-    let normalizedZ = (localPositionZ - this.positionOffset.z) / this.scale.z - columnIndex;
-    let normalizedX = (localPositionX - this.positionOffset.x) / this.scale.x - rowIndex;
-
-    // get the quad vertices
-
-    this.computeVertex(a, columnIndex + 0, rowIndex + 0); // bottom left
-    this.computeVertex(b, columnIndex + 1, rowIndex + 0); // bottom right
-    this.computeVertex(c, columnIndex + 0, rowIndex + 1); // top left
-    this.computeVertex(d, columnIndex + 1, rowIndex + 1); // top right
-
-    // we will use barycentric coordinates to get the height of the point
-    let interpolatedHeight: number;
-
-    // case: we project onto triangle ABC
-    if (normalizedX + normalizedZ <= 1) {
-      const u = normalizedZ;
-      const v = normalizedX;
-      const w = 1 - u - v;
-      interpolatedHeight = a.y * w + b.y * u + c.y * v;
-    }
-    // case: we project onto triangle DCB
-    else {
-      const u = 1 - normalizedZ;
-      const v = 1 - normalizedX;
-      const w = 1 - u - v;
-      interpolatedHeight = d.y * w + c.y * u + b.y * v;
-    }
-
-    // set the out point
-    out.x = localPositionX;
-    out.y = interpolatedHeight;
-    out.z = localPositionZ;
-  }
-
-  castRay(onHit: (triangle: Triangle) => boolean, ray: Ray) {
-    heightMapRaycaster.init(onHit, ray);
-    this.walkHeightMap(heightMapRaycaster);
-  }
-
-  walkHeightMap(visitor: HeightMapVisitor): void {
-    // get a stack to hold the indices of the blocks to visit
-    const stack = this.stack;
-    stack.length = 0;
-    let stackCount = 0;
-    let triangleId: number;
-
-    const children = this.children;
-    children.fill(0);
-
-    // add the index of the root block
-    stack[stackCount] = 0;
-    stackCount++;
-
-    // TODO: this can be cached
-    const numberOfLevels = computeNumberOfLevels(this.subdivisionsCount);
-
-    // iterate until the stack is empty
-    while (stackCount > 0) {
-      // visit the block at the top of the stack
-      stackCount--;
-
-      const index = stack[stackCount];
-      const level = this.levels[index];
-      const minHeight = this.positionOffset.y + this.minHeights[index] * this.scale.y;
-      const maxHeight = this.positionOffset.y + this.maxHeights[index] * this.scale.y;
-      // const currentNumberOfSubDivisions = Math.pow(2, level);
-      const currentNumberOfSubDivisions = 1 << level;
-
-      // get the scale at this level, which would be doubled for each level underneath
-      const numberOfLevelsBelow = numberOfLevels - level - 1;
-      // vec3.scale(scale, this.scale, Math.pow(2, numberOfLevelsBelow));
-      scale.scaleVector(this.scale, 1 << numberOfLevelsBelow);
-
-      // if at base level, row and column index are zero
-      let rowIndex: number = 0;
-      let columnIndex: number = 0;
-      if (level > 0) {
-        // get the offset of the upper level
-        const offset = computeNumberOfCells(currentNumberOfSubDivisions / 2);
-
-        const indexWithoutOffset = index - offset;
-
-        // get the row and column index of the block
-        rowIndex = Math.floor(indexWithoutOffset / currentNumberOfSubDivisions);
-        // columnIndex = indexWithoutOffset % currentNumberOfSubDivisions;
-        columnIndex = indexWithoutOffset & (currentNumberOfSubDivisions - 1);
-      }
-
-      // get the min x and min z position of the block
-      const minX = this.positionOffset.x + rowIndex * scale.x;
-      const minZ = this.positionOffset.z + columnIndex * scale.z;
-
-      // get the max x and max z position of the block
-      const maxX = minX + scale.x;
-      const maxZ = minZ + scale.z;
-
-      // create the aabb for the block
-
-      blockAabb.min.fromArray([minX, minHeight, minZ]);
-      blockAabb.max.fromArray([maxX, maxHeight, maxZ]);
-      // expand the block aabb height by a small margin to account for flat planes
-      blockAabb.min.y -= 0.1;
-      blockAabb.max.y += 0.1;
-
-      // case: we should not visit the block, skip
-      if (visitor.shouldVisitBlock(blockAabb) === false) {
-        continue;
-      }
-      // case: we should visit the block, get this block's children (blocks if not on last level, triangles if on last level)
-      else {
-        // case: on last level
-        if (level === numberOfLevels - 1) {
-          // console.log("visiting block", index - getNumberOfCells(currentNumberOfSubDivisions / 2));
-
-          // get the 4 vertices of the quad
-          this.computeVertex(a, columnIndex + 0, rowIndex + 0); // bottom left
-          this.computeVertex(b, columnIndex + 1, rowIndex + 0); // bottom right
-          this.computeVertex(c, columnIndex + 0, rowIndex + 1); // top left
-          this.computeVertex(d, columnIndex + 1, rowIndex + 1); // top right
-
-          // get the activeEdges for each triangle
-          const firstTriangleIndex = index * 2 + 0;
-          const secondTriangleIndex = index * 2 + 1;
-
-          const activeEdges0 = this.activeEdges[firstTriangleIndex];
-          const activeEdges1 = this.activeEdges[secondTriangleIndex];
-
-          // visit the 2 triangles in the quad
-          triangle.set({ a: a, b: b, c: c });
-          triangleId = this.computeTriangleId(columnIndex, rowIndex, 0);
-          // if (this.world.debug) {
-          //   console.log("visiting triangle", { columnIndex, rowIndex, triangleIndex: 0, triangleId });
-          // }
-          visitor.visitTriangle(triangle, activeEdges0, triangleId);
-
-          triangle.set({ a: d, b: c, c: b });
-          triangleId = this.computeTriangleId(columnIndex, rowIndex, 1);
-          // if (this.world.debug) {
-          //   console.log("visiting triangle", { columnIndex, rowIndex, triangleIndex: 1, triangleId });
-          // }
-          visitor.visitTriangle(triangle, activeEdges1, triangleId);
-          continue;
-        }
-
-        // case: not on last level
-
-        // get the children of the block
-        computeCornerIndicesInGrid(children, rowIndex * 2, columnIndex * 2, currentNumberOfSubDivisions * 2);
-
-        // get the starting offset of the children
-        const offset = computeNumberOfCells(currentNumberOfSubDivisions);
-
-        // add the children to the stack
-        stack[stackCount] = children[3] + offset;
-        stackCount++;
-
-        stack[stackCount] = children[2] + offset;
-        stackCount++;
-
-        stack[stackCount] = children[1] + offset;
-        stackCount++;
-
-        stack[stackCount] = children[0] + offset;
-        stackCount++;
-      }
-    }
-  }
-
-  /**
-   * this function visits every block and triangle of the heightMap. take care when using it on high resolution heightMaps. it is intended to generate a debug visualization of the heightMap.
-   */
-  createTriangulatedVerticesAndNormalsArray(): [Float64Array, Float64Array] {
-    // performance is not a concern for this function, so we can make new allocations here
-
-    const vertices: number[] = [];
-    const normals: number[] = [];
-
-    class MyVisitor implements HeightMapVisitor {
-      shouldVisitBlock(block: Aabb): boolean {
-        return true;
-      }
-
-      visitTriangle(triangle: Triangle, activeEdges: number, triangleId: number): void {
-        triangle.computeNormal(normal);
-
-        vertices.push(triangle.a.x, triangle.a.y, triangle.a.z);
-        vertices.push(triangle.b.x, triangle.b.y, triangle.b.z);
-        vertices.push(triangle.c.x, triangle.c.y, triangle.c.z);
-
-        normals.push(normal.x, normal.y, normal.z);
-        normals.push(normal.x, normal.y, normal.z);
-        normals.push(normal.x, normal.y, normal.z);
-      }
-    }
-    const visitor = new MyVisitor();
-
-    this.walkHeightMap(visitor);
-    return [new Float64Array(vertices), new Float64Array(normals)];
-  }
-
-  computeSurfaceNormal(out: Vec3, inLocalSurfacePosition: Vec3, subShapeId?: number): void {
-    // #v-ifdef DEV
-    // assert that we have a sub shape id
-    if (subShapeId === undefined) {
-      throw new Error("subShapeId is required");
-    }
-    // #v-endif
-
-    this.computeTriangle(triangle, subShapeId);
-    triangle.computeSurfaceNormal(out, inLocalSurfacePosition);
-  }
-
-  computeColumnCount(): number {
-    return this.subdivisionsCount + 1;
-  }
-
-  computeRowCount(): number {
-    return this.subdivisionsCount + 1;
-  }
-
-  computeTriangleId(columnIndex: number, rowIndex: number, triangleIndex: 0 | 1): number {
-    return ((rowIndex * this.computeColumnCount() + columnIndex) << 1) | triangleIndex;
-  }
-
-  decodeTriangleId(triangleId: number): { columnIndex: number; rowIndex: number; triangleIndex: number } {
-    const triangleIndex = triangleId & 1;
-    const quadId = triangleId >> 1;
-    const columnIndex = quadId % this.computeColumnCount();
-    const rowIndex = Math.floor(quadId / this.computeColumnCount());
-    return { columnIndex, rowIndex, triangleIndex };
-  }
-
-  computeTriangle(out: Triangle, triangleId: number): void {
-    const { columnIndex, rowIndex, triangleIndex } = this.decodeTriangleId(triangleId);
-
-    this.computeVertex(a, columnIndex + 0, rowIndex + 0); // bottom left
-    this.computeVertex(b, columnIndex + 1, rowIndex + 0); // bottom right
-    this.computeVertex(c, columnIndex + 0, rowIndex + 1); // top left
-    this.computeVertex(d, columnIndex + 1, rowIndex + 1); // top right
-
-    if (triangleIndex === 0) {
-      out.set({ a: a, b: b, c: c });
-    } else {
-      out.set({ a: d, b: c, c: b });
-    }
-  }
-
-  computeVertex(out: Vec3, columnIndex: number, rowIndex: number): void {
-    out.z = this.positionOffset.z + columnIndex * this.scale.z;
-    out.x = this.positionOffset.x + rowIndex * this.scale.x;
-    out.y = this.positionOffset.y + this.heights[columnIndex + rowIndex * (this.subdivisionsCount + 1)] * this.scale.y;
-  }
-
-  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: HeightMap) {
-  shape.computedVolume = 0.0;
-}
-
-export function updateLocalBounds(shape: HeightMap) {
-  // find the min and max height
-  let minHeight = Number.POSITIVE_INFINITY;
-  let maxHeight = Number.NEGATIVE_INFINITY;
-  for (let i = 0; i < shape.heights.length; i++) {
-    const height = shape.heights[i] * shape.scale.y;
-    minHeight = Math.min(minHeight, height);
-    maxHeight = Math.max(maxHeight, height);
-  }
-
-  // set the local bounds
-  shape.computedAabb.min.x = 0;
-  // TODO: apply scale?
-  // out.min.y = shape.scale * minHeight;
-  shape.computedAabb.min.y = minHeight;
-  shape.computedAabb.min.z = 0;
-
-  shape.computedAabb.max.x = shape.subdivisionsCount * shape.scale.x;
-  // TODO: apply scale?
-  // out.max.y = shape.scale * maxHeight;
-  shape.computedAabb.max.y = maxHeight;
-  shape.computedAabb.max.z = shape.subdivisionsCount * shape.scale.z;
-
-  // account for the position offset
-  shape.computedAabb.min.addVector(shape.positionOffset);
-  shape.computedAabb.max.addVector(shape.positionOffset);
-}
-
-function updateCopyForDiff(shape: HeightMap) {
-  if (shape.copyForDiff) {
-    shape.copyForDiff.copy(shape);
-    shape.copyForDiff.copyForDiff = null;
-  }
-}
-
-function updateCenterOfMass(shape: HeightMap) {
-  shape.computedCenterOfMass.zero();
-}
-
-export function updateShape(shape: HeightMap) {
-  updateCopyForDiff(shape);
-  updateCenterOfMass(shape);
-  updateVolume(shape);
-  updateLocalBounds(shape);
-}

package/src/shape/Line.ts

@@ -1,14 +0,0 @@
-import { createClass, MonomorphType, PropertyDefinitionMap } from "monomorph";
-import { Vec3 } from "../math/vec3";
-
-const lineProps = {
-  a: MonomorphType(Vec3),
-  b: MonomorphType(Vec3),
-} as const satisfies PropertyDefinitionMap;
-
-export class Line extends createClass<Line, typeof lineProps>(lineProps) {
-  setFromPointAndDirection(point: Vec3, direction: Vec3, length: number): void {
-    this.a.copy(point);
-    this.b.addScaledToVector(point, direction, length);
-  }
-}

package/src/shape/Plane.ts

@@ -1,116 +0,0 @@
-import { createClass, MonomorphType, NumberType, PropertyDefinitionMap } from "monomorph";
-import { Vec3 } from "../math/vec3";
-import { Ray } from "./Ray";
-
-const cross_bn_cn = /*@__PURE__*/ Vec3.create();
-
-const planeProps = {
-  normal: MonomorphType(Vec3),
-  constant: NumberType(0),
-} as const satisfies PropertyDefinitionMap;
-
-export class Plane extends createClass<Plane, typeof planeProps>(planeProps) {
-  toObject() {
-    return {
-      normal: this.normal.toObject(),
-      constant: this.constant,
-    };
-  }
-
-  fromPointAndNormal(point: Vec3, normal: Vec3): void {
-    this.normal.copy(normal);
-    this.constant = -normal.dot(point);
-  }
-
-  signedDistance(point: Vec3): number {
-    return point.dot(this.normal) + this.constant;
-  }
-
-  offsetAlongNormal(out: Plane, inDistance: number): void {
-    out.copy(this);
-    out.constant -= inDistance;
-  }
-
-  offsetPlaneAlongNormal(plane: Plane, inDistance: number) {
-    this.normal.copy(plane.normal);
-    this.constant = plane.constant - inDistance;
-  }
-
-  toString(): string {
-    return `Plane { normal: ${this.normal.toString()}, constant: ${this.constant} }`;
-  }
-
-  static intersectPlanes(planeA: Plane, planeB: Plane, planeC: Plane, outPoint: Vec3): boolean {
-    // We solve the equation:
-    // |ax, ay, az, aw|   | x |   | 0 |
-    // |bx, by, bz, bw| * | y | = | 0 |
-    // |cx, cy, cz, cw|   | z |   | 0 |
-    // | 0,	 0,	 0,	 1|   | 1 |   | 1 |
-    // Where normal of plane 1 = (ax, ay, az), plane constant of 1 = aw, normal of plane 2 = (bx, by, bz) etc.
-    // This involves inverting the matrix and multiplying it with [0, 0, 0, 1]
-
-    // Fetch the normals and plane constants for the three planes
-
-    cross_bn_cn.crossVectors(planeB.normal, planeC.normal);
-
-    const denominator = planeA.normal.dot(cross_bn_cn);
-    if (denominator === 0.0) {
-      return false;
-    }
-
-    // The numerator is:
-    // [aw*(bz*cy-by*cz)+ay*(bw*cz-bz*cw)+az*(by*cw-bw*cy)]
-    // [aw*(bx*cz-bz*cx)+ax*(bz*cw-bw*cz)+az*(bw*cx-bx*cw)]
-    // [aw*(by*cx-bx*cy)+ax*(bw*cy-by*cw)+ay*(bx*cw-bw*cx)]
-
-    const a = planeA.normal;
-    const b = planeB.normal;
-    const c = planeC.normal;
-
-    const ax = a.x;
-    const ay = a.y;
-    const az = a.z;
-
-    const bx = b.x;
-    const by = b.y;
-    const bz = b.z;
-
-    const cx = c.x;
-    const cy = c.y;
-    const cz = c.z;
-
-    const aw = planeA.constant;
-    const bw = planeB.constant;
-    const cw = planeC.constant;
-
-    outPoint.x = aw * (bz * cy - by * cz) + ay * (bw * cz - bz * cw) + az * (by * cw - bw * cy);
-    outPoint.y = aw * (bx * cz - bz * cx) + ax * (bz * cw - bw * cz) + az * (bw * cx - bx * cw);
-    outPoint.z = aw * (by * cx - bx * cy) + ax * (bw * cy - by * cw) + ay * (bx * cw - bw * cx);
-
-    outPoint.scale(1 / denominator);
-    return true;
-  }
-
-  /**
-   * return the normalized fraction of the ray that intersects the plane in the interval [0.0, 1.0]
-   */
-  castRay(ray: Ray): number {
-    const denominator = this.normal.dot(ray.direction);
-
-    // case: ray is nearly parallel to the plane
-    if (Math.abs(denominator) < 1e-6) {
-      return 1.0;
-    }
-
-    const t = (this.constant - this.normal.dot(ray.origin)) / denominator;
-    const fraction = t / ray.length;
-
-    // case: ray does not intersect the plane
-    if (fraction < 0.0 || fraction > 1.0) {
-      return 1.0;
-    }
-
-    // case: ray intersects the plane
-    return fraction;
-  }
-}