@perplexdotgg/bounce 1.0.0 → 1.0.1

package/src/collision/epa/binaryHeap.ts

@@ -1,82 +0,0 @@
-/// Push a new element into a binary max-heap.
-/// [inBegin, inEnd - 1) must be a a valid heap. Element inEnd - 1 will be inserted into the heap. The heap will be [inBegin, inEnd) after this call.
-/// inPred is a function that returns true if the first element is less or equal than the second element.
-/// See: https://en.wikipedia.org/wiki/Binary_heap
-export function binaryHeapPush<T>(inArray: Array<T>, inBegin: number, inEnd: number, inPred: (a: T, b: T) => boolean) {
-  // new heap size
-  const count = inEnd - inBegin;
-
-  // start from the last element
-  let current = count - 1;
-  while (current > 0) {
-    // get current element
-    const currentElement = inArray[inBegin + current];
-
-    // get parent element
-    const parent = (current - 1) >> 1;
-    const parentElement = inArray[inBegin + parent];
-
-    // sort them so taht the parent is larger than the child
-    if (inPred(parentElement, currentElement)) {
-      const tempElement = parentElement;
-      inArray[inBegin + parent] = currentElement;
-      inArray[inBegin + current] = tempElement;
-      current = parent;
-    } else {
-      // When there's no change, we're done
-      break;
-    }
-  }
-}
-
-/// Pop an element from a binary max-heap.
-/// [inBegin, inEnd) must be a valid heap. The largest element will be removed from the heap. The heap will be [inBegin, inEnd - 1) after this call.
-/// inPred is a function that returns true if the first element is less or equal than the second element.
-/// See: https://en.wikipedia.org/wiki/Binary_heap
-export function binaryHeapPop<T>(inArray: Array<T>, inBegin: number, inEnd: number, inPred: (a: T, b: T) => boolean) {
-  // Begin by moving the highest element to the end, this is the popped element
-  const temp = inArray[inEnd - 1];
-  inArray[inEnd - 1] = inArray[inBegin];
-  inArray[inBegin] = temp;
-
-  // New heap size
-  const count = inEnd - inBegin - 1;
-
-  // Start from the root
-  let largest = 0;
-  while (true) {
-    // Get first child
-    let child = (largest << 1) + 1;
-
-    // Check if we're beyond the end of the heap, if so the 2nd child is also beyond the end
-    if (child >= count) {
-      break;
-    }
-
-    // Remember the largest element from the previous iteration
-    const prevLargest = largest;
-
-    // Check if first child is bigger, if so select it
-    if (inPred(inArray[inBegin + largest], inArray[inBegin + child])) {
-      largest = child;
-    }
-
-    // Switch to the second child
-    ++child;
-
-    // Check if second child is bigger, if so select it
-    if (child < count && inPred(inArray[inBegin + largest], inArray[inBegin + child])) {
-      largest = child;
-    }
-
-    // If there was no change, we're done
-    if (prevLargest === largest) {
-      break;
-    }
-
-    // Swap element
-    const tempElement = inArray[inBegin + prevLargest];
-    inArray[inBegin + prevLargest] = inArray[inBegin + largest];
-    inArray[inBegin + largest] = tempElement;
-  }
-}

package/src/collision/epa/structs.ts

@@ -1,227 +0,0 @@
-import {
-  BooleanType,
-  createClass,
-  LazyReferenceType,
-  MonomorphType,
-  NumberType,
-  PropertyDefinitionMap,
-  PropertyDefinitionReference,
-} from "monomorph";
-import { Vec3 } from "../../math/vec3";
-import { assert } from "../../helpers";
-
-const edgeProps = {
-  neighbourTriangle: LazyReferenceType((() => Triangle) as () => never) as PropertyDefinitionReference<
-    Triangle | null,
-    true
-  >,
-  neighbourEdge: NumberType(0),
-  startIndex: NumberType(0),
-} as const satisfies PropertyDefinitionMap;
-
-export class Edge extends createClass<Edge, typeof edgeProps>(edgeProps) {
-  //
-}
-
-const triangleProps = {
-  edge0: MonomorphType(Edge),
-  edge1: MonomorphType(Edge),
-  edge2: MonomorphType(Edge),
-  normal: MonomorphType(Vec3),
-  centroid: MonomorphType(Vec3),
-  closestLengthSq: NumberType(+Infinity),
-  lambda0: NumberType(0.0),
-  lambda1: NumberType(0.0),
-  lambdaRelativeTo0: BooleanType(false),
-  closestPointInterior: BooleanType(false),
-  removed: BooleanType(false),
-  inQueue: BooleanType(false),
-  iteration: NumberType(0),
-} as const satisfies PropertyDefinitionMap;
-
-const vectorAB = /*@__PURE__*/ Vec3.create();
-
-const y10 = /*@__PURE__*/ Vec3.create();
-const y20 = /*@__PURE__*/ Vec3.create();
-const y21 = /*@__PURE__*/ Vec3.create();
-
-export function initTriangle(
-  m: Triangle,
-  inIdx0: number,
-  inIdx1: number,
-  inIdx2: number,
-  inPositions: Vec3[],
-  minTriangleArea: number,
-  barycentricEpsilon: number
-) {
-  // reset defaults
-  m.closestLengthSq = +Infinity;
-  m.lambda[0] = 0.0;
-  m.lambda[1] = 0.0;
-  m.lambdaRelativeTo0 = false;
-  m.closestPointInterior = false;
-  m.removed = false;
-  m.inQueue = false;
-  m.iteration = 0;
-
-  // #v-ifdef DEV
-  // Fill in indexes
-  assert(inIdx0 !== inIdx1 && inIdx0 !== inIdx2 && inIdx1 !== inIdx2, "Triangle indices must be unique");
-  // #v-endif
-  m.edge[0].startIndex = inIdx0;
-  m.edge[1].startIndex = inIdx1;
-  m.edge[2].startIndex = inIdx2;
-
-  // Clear links
-  m.edge[0].neighbourTriangle = null;
-  m.edge[1].neighbourTriangle = null;
-  m.edge[2].neighbourTriangle = null;
-
-  // Get vertex positions
-  const y0 = inPositions[inIdx0];
-  const y1 = inPositions[inIdx1];
-  const y2 = inPositions[inIdx2];
-
-  // Calculate centroid
-  m.centroid.zero();
-  m.centroid.addVector(y0);
-  m.centroid.addVector(y1);
-  m.centroid.addVector(y2);
-  m.centroid.scale(1 / 3.0);
-
-  // Calculate edges
-  y10.subtractVectors(y1, y0);
-  y20.subtractVectors(y2, y0);
-  y21.subtractVectors(y2, y1);
-
-  // The most accurate normal is calculated by using the two shortest edges
-  // See: https://box2d.org/posts/2014/01/troublesome-triangle/
-  // The difference in normals is most pronounced when one edge is much smaller than the others (in which case the other 2 must have roughly the same length).
-  // Therefore we can suffice by just picking the shortest from 2 edges and use that with the 3rd edge to calculate the normal.
-  // We first check which of the edges is shorter.
-  const y20DotY20 = y20.dot(y20);
-  const y21DotY21 = y21.dot(y21);
-  if (y20DotY20 < y21DotY21) {
-    // We select the edges y10 and y20
-    m.normal.crossVectors(y10, y20);
-
-    // Check if triangle is degenerate
-    const normalLenSq = m.normal.squaredLength();
-    if (normalLenSq > minTriangleArea) {
-      // Determine distance between triangle and origin: distance = (centroid - origin) . normal / |normal|
-      // Note that this way of calculating the closest point is much more accurate than first calculating barycentric coordinates and then calculating the closest
-      // point based on those coordinates. Note that we preserve the sign of the distance to check on which side the origin is.
-      const cDotN = m.centroid.dot(m.normal);
-      m.closestLengthSq = (Math.abs(cDotN) * cDotN) / normalLenSq;
-
-      // Calculate closest point to origin using barycentric coordinates:
-      //
-      // v = y0 + l0 * (y1 - y0) + l1 * (y2 - y0)
-      // v . (y1 - y0) = 0
-      // v . (y2 - y0) = 0
-      //
-      // Written in matrix form:
-      //
-      // | y10.y10  y20.y10 | | l0 | = | -y0.y10 |
-      // | y10.y20  y20.y20 | | l1 |   | -y0.y20 |
-      //
-      // (y10 = y1 - y0 etc.)
-      //
-      // Cramers rule to invert matrix:
-      const y10DotY10 = y10.squaredLength();
-      const y10DotY20 = y10.dot(y20);
-      const determinant = y10DotY10 * y20DotY20 - y10DotY20 * y10DotY20;
-      if (determinant > 0.0) {
-        // If determinant == 0 then the system is linearly dependent and the triangle is degenerate, since y10.y10 * y20.y20 > y10.y20^2 it should also be > 0
-        const y0DotY10 = y0.dot(y10);
-        const y0DotY20 = y0.dot(y20);
-        const l0 = (y10DotY20 * y0DotY20 - y20DotY20 * y0DotY10) / determinant;
-        const l1 = (y10DotY20 * y0DotY10 - y10DotY10 * y0DotY20) / determinant;
-        m.lambda[0] = l0;
-        m.lambda[1] = l1;
-        m.lambdaRelativeTo0 = true;
-
-        // Check if closest point is interior to the triangle. For a convex hull which contains the origin each face must contain the origin, but because
-        // our faces are triangles, we can have multiple coplanar triangles and only 1 will have the origin as an interior point. We want to use this triangle
-        // to calculate the contact points because it gives the most accurate results, so we will only add these triangles to the priority queue.
-        if (l0 > -barycentricEpsilon && l1 > -barycentricEpsilon && l0 + l1 < 1.0 + barycentricEpsilon) {
-          m.closestPointInterior = true;
-        }
-      }
-    }
-  } else {
-    // We select the edges y10 and y21
-    m.normal.crossVectors(y10, y21);
-
-    // Check if triangle is degenerate
-    const normalLenSq = m.normal.squaredLength();
-    if (normalLenSq > minTriangleArea) {
-      // Again calculate distance between triangle and origin
-      const cDotN = m.centroid.dot(m.normal);
-      m.closestLengthSq = (Math.abs(cDotN) * cDotN) / normalLenSq;
-
-      // Calculate closest point to origin using barycentric coordinates but this time using y1 as the reference vertex
-      //
-      // v = y1 + l0 * (y0 - y1) + l1 * (y2 - y1)
-      // v . (y0 - y1) = 0
-      // v . (y2 - y1) = 0
-      //
-      // Written in matrix form:
-      //
-      // | y10.y10  -y21.y10 | | l0 | = | y1.y10 |
-      // | -y10.y21  y21.y21 | | l1 |   | -y1.y21 |
-      //
-      // Cramers rule to invert matrix:
-      const y10DotY10 = y10.squaredLength();
-      const y10DotY21 = y10.dot(y21);
-      const determinant = y10DotY10 * y21DotY21 - y10DotY21 * y10DotY21;
-      if (determinant > 0.0) {
-        const y1DotY10 = y1.dot(y10);
-        const y1DotY21 = y1.dot(y21);
-        const l0 = (y21DotY21 * y1DotY10 - y10DotY21 * y1DotY21) / determinant;
-        const l1 = (y10DotY21 * y1DotY10 - y10DotY10 * y1DotY21) / determinant;
-        m.lambda[0] = l0;
-        m.lambda[1] = l1;
-        m.lambdaRelativeTo0 = false;
-
-        // Again check if the closest point is inside the triangle
-        if (l0 > -barycentricEpsilon && l1 > -barycentricEpsilon && l0 + l1 < 1.0 + barycentricEpsilon) {
-          m.closestPointInterior = true;
-        }
-      }
-    }
-  }
-}
-
-// TODO: pass empty arrays into createClass
-export class Triangle extends createClass<Triangle, typeof triangleProps>(triangleProps) {
-  declare edge: [Edge, Edge, Edge];
-  declare lambda: [number, number];
-
-  isFacing(inPosition: Vec3) {
-    // #v-ifdef DEV
-    assert(!this.removed, "Triangle is removed, cannot check if facing");
-    // #v-endif
-    vectorAB.subtractVectors(inPosition, this.centroid);
-    return this.normal.dot(vectorAB) > 0.0;
-  }
-
-  isFacingOrigin() {
-    // #v-ifdef DEV
-    assert(!this.removed, "Triangle is removed, cannot check if facing origin");
-    // #v-endif
-    return this.normal.dot(this.centroid) < 0.0;
-  }
-
-  getNextEdge(inIndex: number) {
-    return this.edge[(inIndex + 1) % 3];
-  }
-}
-
-const oldTriangleCreate = Triangle.create;
-Triangle.create = function () {
-  const self = oldTriangleCreate.apply(this, arguments as any);
-  self.edge = [self.edge0, self.edge1, self.edge2];
-  self.lambda = [self.lambda0, self.lambda1];
-  return self;
-};