@perplexdotgg/bounce 1.6.0 → 1.7.0

package/build/bounce.js

@@ -798,9 +798,9 @@ class Vec3 extends createClass()(vec3Props) {
     return Math.abs(this.x - other.x) <= tolerance && Math.abs(this.y - other.y) <= tolerance && Math.abs(this.z - other.z) <= tolerance;
   }
   minVector(a3) {
-    this.x = Math.min(this.x, a3.x);
-    this.y = Math.min(this.y, a3.y);
-    this.z = Math.min(this.z, a3.z);
+    if (a3.x < this.x) this.x = a3.x;
+    if (a3.y < this.y) this.y = a3.y;
+    if (a3.z < this.z) this.z = a3.z;
     return this;
   }
   minVectors(a3, b3) {
@@ -810,9 +810,9 @@ class Vec3 extends createClass()(vec3Props) {
     return this;
   }
   maxVector(a3) {
-    this.x = Math.max(this.x, a3.x);
-    this.y = Math.max(this.y, a3.y);
-    this.z = Math.max(this.z, a3.z);
+    if (a3.x > this.x) this.x = a3.x;
+    if (a3.y > this.y) this.y = a3.y;
+    if (a3.z > this.z) this.z = a3.z;
     return this;
   }
   maxVectors(a3, b3) {
@@ -923,1365 +923,1287 @@ const rb = /* @__PURE__ */ Vec3.create();
 const temp = /* @__PURE__ */ Vec3.create();
 const rotatedVector = /* @__PURE__ */ Vec3.create();
 const rotationMatrix$3 = /* @__PURE__ */ Mat3.create();
-const lineProps = props({
-  a: Vec3,
-  b: Vec3
+const segmentProps = props({
+  pointA: Vec3,
+  pointB: Vec3
 });
-class Line extends createClass()(lineProps) {
-  setFromPointAndDirection(point2, direction2, length) {
-    this.a.copy(point2);
-    this.b.addScaledToVector(point2, direction2, length);
+class Segment extends createClass()(segmentProps) {
+  computeCenter(out) {
+    out.addVectors(this.pointA, this.pointB);
+    out.scaleVector(out, 0.5);
+  }
+  computeHalfExtents(out) {
+    out.subtractVectors(this.pointB, this.pointA);
+    out.scaleVector(out, 0.5);
+  }
+  setFromRay(ray2) {
+    this.pointA.copy(ray2.origin);
+    this.pointB.addScaledToVector(ray2.origin, ray2.direction, ray2.length);
   }
 }
-const quatKeys = ["x", "y", "z", "w"];
-const quatProps = props({
-  x: 0,
-  y: 0,
-  z: 0,
-  w: 1
+const epsilon$2 = 1e-7;
+const newMin = /* @__PURE__ */ Vec3.create();
+const newMax = /* @__PURE__ */ Vec3.create();
+const col = /* @__PURE__ */ Vec3.create();
+const a$2 = /* @__PURE__ */ Vec3.create();
+const b$1 = /* @__PURE__ */ Vec3.create();
+const aabbProps = props({
+  min: Vec3,
+  max: Vec3,
+  centroid: ChildType(Vec3, void 0, true)
 });
-class Quat extends createClass()(quatProps) {
-  constructor(data, index, pool) {
-    if (Array.isArray(data)) {
-      if (data.length && data.length < 4) {
-        tempQuat.setFromEulerRadians(data[0], data[1] ?? 0, data[2] ?? 0);
-      } else {
-        tempQuat.x = data[0] ?? 0;
-        tempQuat.y = data[1] ?? 0;
-        tempQuat.z = data[2] ?? 0;
-        tempQuat.w = data[3] ?? 1;
-      }
-      super(tempQuat, index, pool);
-      return;
-    }
-    super(data, index, pool);
+class Aabb extends createClass()(aabbProps) {
+  computeSupport(out, direction2) {
+    out.x = direction2.x < 0 ? this.min.x : this.max.x;
+    out.y = direction2.y < 0 ? this.min.y : this.max.y;
+    out.z = direction2.z < 0 ? this.min.z : this.max.z;
   }
-  reset(data) {
-    if (Array.isArray(data)) {
-      if (data.length && data.length < 4) {
-        return this.setFromEulerRadians(data[0], data[1] ?? 0, data[2] ?? 0);
+  computeSupportingFace(out, inDirection) {
+    const absX = Math.abs(inDirection.x);
+    const absY = Math.abs(inDirection.y);
+    const absZ = Math.abs(inDirection.z);
+    const axis2 = absX > absY ? absX > absZ ? 0 : 2 : absY > absZ ? 1 : 2;
+    const component = inDirection.getComponentAtIndex(axis2);
+    if (component < 0) {
+      switch (axis2) {
+        case 0: {
+          out.pushVertexValues(this.max.x, this.min.y, this.min.z);
+          out.pushVertexValues(this.max.x, this.max.y, this.min.z);
+          out.pushVertexValues(this.max.x, this.max.y, this.max.z);
+          out.pushVertexValues(this.max.x, this.min.y, this.max.z);
+          break;
+        }
+        case 1: {
+          out.pushVertexValues(this.min.x, this.max.y, this.min.z);
+          out.pushVertexValues(this.min.x, this.max.y, this.max.z);
+          out.pushVertexValues(this.max.x, this.max.y, this.max.z);
+          out.pushVertexValues(this.max.x, this.max.y, this.min.z);
+          break;
+        }
+        case 2: {
+          out.pushVertexValues(this.min.x, this.min.y, this.max.z);
+          out.pushVertexValues(this.max.x, this.min.y, this.max.z);
+          out.pushVertexValues(this.max.x, this.max.y, this.max.z);
+          out.pushVertexValues(this.min.x, this.max.y, this.max.z);
+          break;
+        }
       }
-      this.x = data[0] ?? 0;
-      this.y = data[1] ?? 0;
-      this.z = data[2] ?? 0;
-      this.w = data[3] ?? 1;
     } else {
-      if (data && data.w === void 0 && (data.x || data.y || data.z)) {
-        return this.setFromEulerRadians(data.x ?? 0, data.y ?? 0, data.z ?? 0);
+      switch (axis2) {
+        case 0: {
+          out.pushVertexValues(this.min.x, this.min.y, this.min.z);
+          out.pushVertexValues(this.min.x, this.min.y, this.max.z);
+          out.pushVertexValues(this.min.x, this.max.y, this.max.z);
+          out.pushVertexValues(this.min.x, this.max.y, this.min.z);
+          break;
+        }
+        case 1: {
+          out.pushVertexValues(this.min.x, this.min.y, this.min.z);
+          out.pushVertexValues(this.max.x, this.min.y, this.min.z);
+          out.pushVertexValues(this.max.x, this.min.y, this.max.z);
+          out.pushVertexValues(this.min.x, this.min.y, this.max.z);
+          break;
+        }
+        case 2: {
+          out.pushVertexValues(this.min.x, this.min.y, this.min.z);
+          out.pushVertexValues(this.min.x, this.max.y, this.min.z);
+          out.pushVertexValues(this.max.x, this.max.y, this.min.z);
+          out.pushVertexValues(this.max.x, this.min.y, this.min.z);
+          break;
+        }
       }
-      this.x = data?.x ?? 0;
-      this.y = data?.y ?? 0;
-      this.z = data?.z ?? 0;
-      this.w = data?.w ?? 1;
     }
+  }
+  translate(translation) {
+    this.min.addVector(translation);
+    this.max.addVector(translation);
+    this.computeCentroid(this.centroid);
+  }
+  translateAabb(aabb, translation) {
+    this.min.addVectors(aabb.min, translation);
+    this.max.addVectors(aabb.max, translation);
+    this.computeCentroid(this.centroid);
     return this;
   }
-  set(data) {
-    if (Array.isArray(data)) {
-      if (data.length && data.length < 4) {
-        return this.setFromEulerRadians(data[0], data[1] ?? 0, data[2] ?? 0);
-      }
-      this.x = data[0] ?? 0;
-      this.y = data[1] ?? 0;
-      this.z = data[2] ?? 0;
-      this.w = data[3] ?? 1;
-    } else if (data) {
-      if (data.x !== void 0) {
-        this.x = data.x;
-      }
-      if (data.y !== void 0) {
-        this.y = data.y;
-      }
-      if (data.z !== void 0) {
-        this.z = data.z;
-      }
-      if (data.w !== void 0) {
-        this.w = data.w;
-      }
+  transform(transform2) {
+    transform2.matrix.getTranslation(newMin);
+    transform2.matrix.getTranslation(newMax);
+    for (let c3 = 0; c3 < 3; ++c3) {
+      transform2.matrix.getColumn3(col, c3);
+      const minComponent = this.min.getComponentAtIndex(c3);
+      const maxComponent = this.max.getComponentAtIndex(c3);
+      a$2.scaleVector(col, minComponent);
+      b$1.scaleVector(col, maxComponent);
+      newMin.x += Math.min(a$2.x, b$1.x);
+      newMin.y += Math.min(a$2.y, b$1.y);
+      newMin.z += Math.min(a$2.z, b$1.z);
+      newMax.x += Math.max(a$2.x, b$1.x);
+      newMax.y += Math.max(a$2.y, b$1.y);
+      newMax.z += Math.max(a$2.z, b$1.z);
     }
+    this.min.copy(newMin);
+    this.max.copy(newMax);
+    this.computeCentroid(this.centroid);
     return this;
   }
-  length() {
-    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
-  }
-  normalize() {
-    const length = this.length();
-    if (length > 0) {
-      this.x /= length;
-      this.y /= length;
-      this.z /= length;
-      this.w /= length;
+  transformAabb(aabb, transform2) {
+    transform2.matrix.getTranslation(newMin);
+    transform2.matrix.getTranslation(newMax);
+    for (let c3 = 0; c3 < 3; ++c3) {
+      transform2.matrix.getColumn3(col, c3);
+      const minComponent = aabb.min.getComponentAtIndex(c3);
+      const maxComponent = aabb.max.getComponentAtIndex(c3);
+      a$2.scaleVector(col, minComponent);
+      b$1.scaleVector(col, maxComponent);
+      newMin.x += Math.min(a$2.x, b$1.x);
+      newMin.y += Math.min(a$2.y, b$1.y);
+      newMin.z += Math.min(a$2.z, b$1.z);
+      newMax.x += Math.max(a$2.x, b$1.x);
+      newMax.y += Math.max(a$2.y, b$1.y);
+      newMax.z += Math.max(a$2.z, b$1.z);
     }
+    this.min.copy(newMin);
+    this.max.copy(newMax);
+    this.computeCentroid(this.centroid);
     return this;
   }
-  identity() {
-    this.x = 0;
-    this.y = 0;
-    this.z = 0;
-    this.w = 1;
+  intersectsAabb(aabb) {
+    return this.min.x <= aabb.max.x && this.max.x >= aabb.min.x && this.min.y <= aabb.max.y && this.max.y >= aabb.min.y && this.min.z <= aabb.max.z && this.max.z >= aabb.min.z;
+  }
+  unionAabb(aabb) {
+    this.min.minVectors(this.min, aabb.min);
+    this.max.maxVectors(this.max, aabb.max);
+    this.computeCentroid(this.centroid);
     return this;
   }
-  conjugateQuat(a3) {
-    this.x = -a3.x;
-    this.y = -a3.y;
-    this.z = -a3.z;
-    this.w = a3.w;
+  unionAabbs(boxA, boxB) {
+    this.min.minVectors(boxA.min, boxB.min);
+    this.max.maxVectors(boxA.max, boxB.max);
+    this.computeCentroid(this.centroid);
     return this;
   }
-  multiplyQuats(a3, b3) {
-    const ax = a3.x;
-    const ay = a3.y;
-    const az = a3.z;
-    const aw = a3.w;
-    const bx = b3.x;
-    const by = b3.y;
-    const bz = b3.z;
-    const bw = b3.w;
-    this.x = ax * bw + aw * bx + ay * bz - az * by;
-    this.y = ay * bw + aw * by + az * bx - ax * bz;
-    this.z = az * bw + aw * bz + ax * by - ay * bx;
-    this.w = aw * bw - ax * bx - ay * by - az * bz;
+  expand(value) {
+    this.min.x -= value;
+    this.min.y -= value;
+    this.min.z -= value;
+    this.max.x += value;
+    this.max.y += value;
+    this.max.z += value;
+    this.computeCentroid(this.centroid);
+  }
+  expandAabb(aabb, value) {
+    this.min.x = aabb.min.x - value;
+    this.min.y = aabb.min.y - value;
+    this.min.z = aabb.min.z - value;
+    this.max.x = aabb.max.x + value;
+    this.max.y = aabb.max.y + value;
+    this.max.z = aabb.max.z + value;
+    this.computeCentroid(this.centroid);
     return this;
   }
-  normalizeQuat(a3) {
-    const x2 = a3.x;
-    const y4 = a3.y;
-    const z = a3.z;
-    const w3 = a3.w;
-    let len = x2 * x2 + y4 * y4 + z * z + w3 * w3;
-    if (len > 0) {
-      len = 1 / Math.sqrt(len);
-    }
-    this.x = x2 * len;
-    this.y = y4 * len;
-    this.z = z * len;
-    this.w = w3 * len;
-    return this;
-  }
-  setAxisAngle(axis2, angle) {
-    angle = angle * 0.5;
-    let s2 = Math.sin(angle);
-    this.x = s2 * axis2.x;
-    this.y = s2 * axis2.y;
-    this.z = s2 * axis2.z;
-    this.w = Math.cos(angle);
+  setExtents(min, max) {
+    this.min.set(min);
+    this.max.set(max);
+    this.computeCentroid(this.centroid);
     return this;
   }
-  dot(b3) {
-    return this.x * b3.x + this.y * b3.y + this.z * b3.z + this.w * b3.w;
-  }
-  notEquals(other, tolerance = 1e-6) {
-    return Math.abs(this.x - other.x) >= tolerance || Math.abs(this.y - other.y) >= tolerance || Math.abs(this.z - other.z) >= tolerance || Math.abs(this.w - other.w) >= tolerance;
+  computeSurfaceArea() {
+    const dx = this.max.x - this.min.x;
+    const dy = this.max.y - this.min.y;
+    const dz = this.max.z - this.min.z;
+    return 2 * (dx * dy + dy * dz + dz * dx);
   }
-  equals(other, tolerance = 1e-6) {
-    return Math.abs(this.x - other.x) < tolerance && Math.abs(this.y - other.y) < tolerance && Math.abs(this.z - other.z) < tolerance && Math.abs(this.w - other.w) < tolerance;
+  computeExtents(out) {
+    out.x = this.max.x - this.min.x;
+    out.y = this.max.y - this.min.y;
+    out.z = this.max.z - this.min.z;
   }
-  intoEuler(out) {
-    if (this.w < 0) {
-      out.x = -this.x * 2;
-      out.y = -this.y * 2;
-      out.z = -this.z * 2;
-    } else {
-      out.x = this.x * 2;
-      out.y = this.y * 2;
-      out.z = this.z * 2;
+  computeLargestAxis() {
+    const dx = this.max.x - this.min.x;
+    const dy = this.max.y - this.min.y;
+    const dz = this.max.z - this.min.z;
+    if (dx >= dy && dx >= dz) {
+      return 0;
     }
-    return this;
+    if (dy >= dx && dy >= dz) {
+      return 1;
+    }
+    return 2;
   }
-  fromMat3(m) {
-    let fTrace = m.e0 + m.e4 + m.e8;
-    let fRoot;
-    if (fTrace > 0) {
-      fRoot = Math.sqrt(fTrace + 1);
-      this.w = 0.5 * fRoot;
-      fRoot = 0.5 / fRoot;
-      this.x = (m.e5 - m.e7) * fRoot;
-      this.y = (m.e6 - m.e2) * fRoot;
-      this.z = (m.e1 - m.e3) * fRoot;
-    } else {
-      let i = 0;
-      if (m.e4 > m.e0) i = 1;
-      if (m.e8 > m[mat3Keys[i * 3 + i]]) i = 2;
-      let j = (i + 1) % 3;
-      let k = (i + 2) % 3;
-      fRoot = Math.sqrt(m[mat3Keys[i * 3 + i]] - m[mat3Keys[j * 3 + j]] - m[mat3Keys[k * 3 + k]] + 1);
-      this[quatKeys[i]] = 0.5 * fRoot;
-      fRoot = 0.5 / fRoot;
-      this.w = (m[mat3Keys[j * 3 + k]] - m[mat3Keys[k * 3 + j]]) * fRoot;
-      this[quatKeys[j]] = (m[mat3Keys[j * 3 + i]] + m[mat3Keys[i * 3 + j]]) * fRoot;
-      this[quatKeys[k]] = (m[mat3Keys[k * 3 + i]] + m[mat3Keys[i * 3 + k]]) * fRoot;
+  computeLargestComponent() {
+    const dx = this.max.x - this.min.x;
+    const dy = this.max.y - this.min.y;
+    const dz = this.max.z - this.min.z;
+    if (dx >= dy && dx >= dz) {
+      return "x";
     }
-    return this;
+    if (dy >= dx && dy >= dz) {
+      return "y";
+    }
+    return "z";
   }
-  fromMat4(m) {
-    tempMat3.fromMat4(m);
-    this.fromMat3(tempMat3);
-    return this;
+  computeCentroid(out) {
+    out.x = (this.min.x + this.max.x) * 0.5;
+    out.y = (this.min.y + this.max.y) * 0.5;
+    out.z = (this.min.z + this.max.z) * 0.5;
+    return out;
   }
-  computeRotationAngle(axis2) {
-    if (this.w === 0) {
-      return Math.PI;
-    } else {
-      vector.x = this.x;
-      vector.y = this.y;
-      vector.z = this.z;
-      return 2 * Math.atan(vector.dot(axis2) / this.w);
-    }
+  computeHalfExtents(out) {
+    out.subtractVectors(this.max, this.min);
+    out.scaleVector(out, 0.5);
   }
-  setFromEulerRadians(x2, y4, z) {
-    const halfX = x2 * 0.5;
-    const halfY = y4 * 0.5;
-    const halfZ = z * 0.5;
-    const c12 = Math.cos(halfX);
-    const c22 = Math.cos(halfY);
-    const c3 = Math.cos(halfZ);
-    const s1 = Math.sin(halfX);
-    const s2 = Math.sin(halfY);
-    const s3 = Math.sin(halfZ);
-    this.x = s1 * c22 * c3 + c12 * s2 * s3;
-    this.y = c12 * s2 * c3 - s1 * c22 * s3;
-    this.z = c12 * c22 * s3 + s1 * s2 * c3;
-    this.w = c12 * c22 * c3 - s1 * s2 * s3;
+  /**
+   * expand this aabb to include the given point
+   * @param point the vec3 to expand to. meaning if the point is outside the aabb, it will expand to include the point
+   * @returns
+   */
+  expandToPoint(point2) {
+    this.min.minVector(point2);
+    this.max.maxVector(point2);
     return this;
   }
+  enclosesAabb(aabb) {
+    return this.min.x < aabb.min.x && this.max.x > aabb.max.x && this.min.y < aabb.min.y && this.max.y > aabb.max.y && this.min.z < aabb.min.z && this.max.z > aabb.max.z;
+  }
+  expandByVector(vector2) {
+    this.min.x -= vector2.x;
+    this.min.y -= vector2.y;
+    this.min.z -= vector2.z;
+    this.max.x += vector2.x;
+    this.max.y += vector2.y;
+    this.max.z += vector2.z;
+  }
+  toString() {
+    return `Aabb(min: ${[this.min.x, this.min.y, this.min.z].join(", ")}, max: ${[
+      this.max.x,
+      this.max.y,
+      this.max.z
+    ].join(", ")})`;
+  }
+  intersectsRay(ray2) {
+    segment.setFromRay(ray2);
+    return this.intersectsSegment(segment);
+  }
+  /**
+   * from Christer Ericson's book "Real-Time Collision Detection", "5.3.3 Intersecting Ray or Segment Against Box"
+   */
+  intersectsSegment(segment2) {
+    this.computeCentroid(aabbCenter);
+    this.computeHalfExtents(aabbHalfExtents);
+    segment2.computeCenter(segmentCenter);
+    segment2.computeHalfExtents(segmentHalfExtents);
+    segmentCenter.subtractVectors(segmentCenter, aabbCenter);
+    let adx = Math.abs(segmentHalfExtents.x);
+    if (Math.abs(segmentCenter.x) > aabbHalfExtents.x + adx) {
+      return false;
+    }
+    let ady = Math.abs(segmentHalfExtents.y);
+    if (Math.abs(segmentCenter.y) > aabbHalfExtents.y + ady) {
+      return false;
+    }
+    let adz = Math.abs(segmentHalfExtents.z);
+    if (Math.abs(segmentCenter.z) > aabbHalfExtents.z + adz) {
+      return false;
+    }
+    adx += epsilon$2;
+    ady += epsilon$2;
+    adz += epsilon$2;
+    if (Math.abs(segmentCenter.y * segmentHalfExtents.z - segmentCenter.z * segmentHalfExtents.y) > aabbHalfExtents.y * adz + aabbHalfExtents.z * ady) {
+      return false;
+    }
+    if (Math.abs(segmentCenter.z * segmentHalfExtents.x - segmentCenter.x * segmentHalfExtents.z) > aabbHalfExtents.x * adz + aabbHalfExtents.z * adx) {
+      return false;
+    }
+    if (Math.abs(segmentCenter.x * segmentHalfExtents.y - segmentCenter.y * segmentHalfExtents.x) > aabbHalfExtents.x * ady + aabbHalfExtents.y * adx) {
+      return false;
+    }
+    return true;
+  }
   toObject() {
     return {
-      x: this.x,
-      y: this.y,
-      z: this.z,
-      w: this.w
+      min: this.min.toObject(),
+      max: this.max.toObject()
     };
   }
 }
-const vector = /* @__PURE__ */ Vec3.create();
-const tempMat3 = /* @__PURE__ */ Mat3.create();
-const tempQuat = /* @__PURE__ */ Quat.create();
-const rotationMatrix$2 = /* @__PURE__ */ Mat3.create();
-const scaling = /* @__PURE__ */ Vec3.create();
-const conjugatedRotation = /* @__PURE__ */ Quat.create();
-const rotatedTranslation = /* @__PURE__ */ Vec3.create();
-const mat4Props = props({
-  e0: 0,
-  e1: 0,
-  e2: 0,
-  e3: 0,
-  e4: 0,
-  e5: 0,
-  e6: 0,
-  e7: 0,
-  e8: 0,
-  e9: 0,
-  e10: 0,
-  e11: 0,
-  e12: 0,
-  e13: 0,
-  e14: 0,
-  e15: 0
+const segment = /* @__PURE__ */ Segment.create();
+const aabbCenter = /* @__PURE__ */ Vec3.create();
+const aabbHalfExtents = /* @__PURE__ */ Vec3.create();
+const segmentCenter = /* @__PURE__ */ Vec3.create();
+const segmentHalfExtents = /* @__PURE__ */ Vec3.create();
+const triangleProps$1 = props({
+  computedBounds: ChildType(Aabb, void 0, true),
+  normal: ChildType(Vec3, void 0, true),
+  a: Vec3,
+  b: Vec3,
+  c: Vec3,
+  subShapeId: NumberType(0, true),
+  activeEdges: NumberType(0, true)
+  // aabb: { struct: Aabb, readOnly: true },
+  // activeEdges: { struct: Uint32, optional: true },
+  // translation: { struct: Vec3, optional: true },
 });
-class Mat4 extends createClass()(mat4Props) {
-  multiply3x3(out, a3) {
-    const x2 = a3.x;
-    const y4 = a3.y;
-    const z = a3.z;
-    out.x = this.e0 * x2 + this.e4 * y4 + this.e8 * z;
-    out.y = this.e1 * x2 + this.e5 * y4 + this.e9 * z;
-    out.z = this.e2 * x2 + this.e6 * y4 + this.e10 * z;
-    return out;
+const ab$5 = /* @__PURE__ */ Vec3.create();
+const ac$3 = /* @__PURE__ */ Vec3.create();
+let Triangle$1 = class Triangle extends createClass()(triangleProps$1) {
+  // type: ShapeType.triangle = ShapeType.triangle;
+  computeNormal(out) {
+    ab$5.subtractVectors(this.b, this.a);
+    ac$3.subtractVectors(this.c, this.a);
+    out.crossVectors(ab$5, ac$3);
+    out.normalize();
   }
-  multiply3x3Transposed(out, a3) {
-    rotationMatrix$2.fromMat4(this);
-    rotationMatrix$2.transpose();
-    out.transformVectorFromMat3(a3, rotationMatrix$2);
+  computeCentroid(out) {
+    out.addVectors(this.a, this.b).addVector(this.c).scale(1 / 3);
   }
-  computeScaling(out) {
-    let m11 = this.e0;
-    let m12 = this.e1;
-    let m13 = this.e2;
-    let m21 = this.e4;
-    let m22 = this.e5;
-    let m23 = this.e6;
-    let m31 = this.e8;
-    let m32 = this.e9;
-    let m33 = this.e10;
-    out.x = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
-    out.y = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
-    out.z = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
-    return out;
+  computeUnnormalizedNormal(out) {
+    ab$5.subtractVectors(this.b, this.a);
+    ac$3.subtractVectors(this.c, this.a);
+    out.crossVectors(ab$5, ac$3);
   }
-  computeRotation(out) {
-    this.computeScaling(scaling);
-    let is1 = 1 / scaling.x;
-    let is2 = 1 / scaling.y;
-    let is3 = 1 / scaling.z;
-    let sm11 = this.e0 * is1;
-    let sm12 = this.e1 * is2;
-    let sm13 = this.e2 * is3;
-    let sm21 = this.e4 * is1;
-    let sm22 = this.e5 * is2;
-    let sm23 = this.e6 * is3;
-    let sm31 = this.e8 * is1;
-    let sm32 = this.e9 * is2;
-    let sm33 = this.e10 * is3;
-    let trace = sm11 + sm22 + sm33;
-    let S = 0;
-    if (trace > 0) {
-      S = Math.sqrt(trace + 1) * 2;
-      out.w = 0.25 * S;
-      out.x = (sm23 - sm32) / S;
-      out.y = (sm31 - sm13) / S;
-      out.z = (sm12 - sm21) / S;
-    } else if (sm11 > sm22 && sm11 > sm33) {
-      S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2;
-      out.w = (sm23 - sm32) / S;
-      out.x = 0.25 * S;
-      out.y = (sm12 + sm21) / S;
-      out.z = (sm31 + sm13) / S;
-    } else if (sm22 > sm33) {
-      S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2;
-      out.w = (sm31 - sm13) / S;
-      out.x = (sm12 + sm21) / S;
-      out.y = 0.25 * S;
-      out.z = (sm23 + sm32) / S;
+  computeSurfaceNormal(out, inLocalSurfacePosition2, subShapeId) {
+    this.computeNormal(out);
+  }
+  transform(isometry2) {
+    this.a.transformByMat4(isometry2);
+    this.b.transformByMat4(isometry2);
+    this.c.transformByMat4(isometry2);
+  }
+  computeLocalBounds(out) {
+    out.min.x = Math.min(this.a.x, this.b.x, this.c.x);
+    out.min.y = Math.min(this.a.y, this.b.y, this.c.y);
+    out.min.z = Math.min(this.a.z, this.b.z, this.c.z);
+    out.max.x = Math.max(this.a.x, this.b.x, this.c.x);
+    out.max.y = Math.max(this.a.y, this.b.y, this.c.y);
+    out.max.z = Math.max(this.a.z, this.b.z, this.c.z);
+    out.computeCentroid(out.centroid);
+  }
+  computeSupport(out, direction2) {
+    const dotA = this.a.dot(direction2);
+    const dotB = this.b.dot(direction2);
+    const dotC = this.c.dot(direction2);
+    if (dotA > dotB) {
+      if (dotA > dotC) {
+        out.copy(this.a);
+      } else {
+        out.copy(this.c);
+      }
     } else {
-      S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2;
-      out.w = (sm12 - sm21) / S;
-      out.x = (sm31 + sm13) / S;
-      out.y = (sm23 + sm32) / S;
-      out.z = 0.25 * S;
+      if (dotB > dotC) {
+        out.copy(this.b);
+      } else {
+        out.copy(this.c);
+      }
     }
-    return out;
-  }
-  getTranslation(out) {
-    out.x = this.e12;
-    out.y = this.e13;
-    out.z = this.e14;
   }
-  setTranslation(v4) {
-    this.e12 = v4.x;
-    this.e13 = v4.y;
-    this.e14 = v4.z;
-    this.e15 = 1;
+  getConvexRadius() {
+    return 0;
   }
-  preTranslated(translation) {
-    this.e12 += this.e0 * translation.x + this.e4 * translation.y + this.e8 * translation.z;
-    this.e13 += this.e1 * translation.x + this.e5 * translation.y + this.e9 * translation.z;
-    this.e14 += this.e2 * translation.x + this.e6 * translation.y + this.e10 * translation.z;
-    this.e15 = 1;
+  computeSupportShape(mode, scale2) {
     return this;
   }
-  postTranslated(translation) {
-    this.e12 += translation.x;
-    this.e13 += translation.y;
-    this.e14 += translation.z;
-    this.e15 = 1;
-    return this;
+  toObject() {
+    return {
+      a: this.a.toObject(),
+      b: this.b.toObject(),
+      c: this.c.toObject(),
+      normal: this.normal.toObject()
+    };
   }
-  postTranslatedMatrix(mat, translation) {
-    this.e0 = mat.e0;
-    this.e1 = mat.e1;
-    this.e2 = mat.e2;
-    this.e3 = mat.e3;
-    this.e4 = mat.e4;
-    this.e5 = mat.e5;
-    this.e6 = mat.e6;
-    this.e7 = mat.e7;
-    this.e8 = mat.e8;
-    this.e9 = mat.e9;
-    this.e10 = mat.e10;
-    this.e11 = mat.e11;
-    this.e12 = mat.e12 + translation.x;
-    this.e13 = mat.e13 + translation.y;
-    this.e14 = mat.e14 + translation.z;
-    this.e15 = 1;
-    return this;
+  computeSupportingFace(out, subShapeID, direction2, scale2, centerOfMassTransform2) {
+    out.clear();
+    out.pushVertex(this.a);
+    out.pushVertex(this.b);
+    out.pushVertex(this.c);
+    out.transform(centerOfMassTransform2);
   }
-  fromRotationTranslation(q4, v4) {
-    const x2 = q4.x;
-    const y4 = q4.y;
-    const z = q4.z;
-    const w3 = q4.w;
-    const x22 = x2 + x2;
-    const y22 = y4 + y4;
-    const z2 = z + z;
-    const xx = x2 * x22;
-    const xy = x2 * y22;
-    const xz = x2 * z2;
-    const yy = y4 * y22;
-    const yz = y4 * z2;
-    const zz = z * z2;
-    const wx = w3 * x22;
-    const wy = w3 * y22;
-    const wz = w3 * z2;
-    this.e0 = 1 - (yy + zz);
-    this.e1 = xy + wz;
-    this.e2 = xz - wy;
-    this.e3 = 0;
-    this.e4 = xy - wz;
-    this.e5 = 1 - (xx + zz);
-    this.e6 = yz + wx;
-    this.e7 = 0;
-    this.e8 = xz + wy;
-    this.e9 = yz - wx;
-    this.e10 = 1 - (xx + yy);
-    this.e11 = 0;
-    this.e12 = v4.x;
-    this.e13 = v4.y;
-    this.e14 = v4.z;
-    this.e15 = 1;
-    return this;
+};
+const faceProps = props({
+  numVertices: 0,
+  buffer: LazyReferenceListType(() => Vec3)
+});
+const triangle$1 = /* @__PURE__ */ Triangle$1.create();
+const tempVertex = /* @__PURE__ */ Vec3.create();
+class Face extends createClass()(faceProps) {
+  clear() {
+    this.numVertices = 0;
   }
-  fromAxisAngle(axis2, angle) {
-    rotation$3.setAxisAngle(axis2, angle);
-    this.fromQuat(rotation$3);
-    this.e12 = 0;
-    this.e13 = 0;
-    this.e14 = 0;
-    this.e15 = 1;
-    return this;
+  isEmpty() {
+    return this.numVertices === 0;
   }
-  fromQuat(q4) {
-    let x2 = q4.x, y4 = q4.y, z = q4.z, w3 = q4.w;
-    let x22 = x2 + x2;
-    let y22 = y4 + y4;
-    let z2 = z + z;
-    let xx = x2 * x22;
-    let yx = y4 * x22;
-    let yy = y4 * y22;
-    let zx = z * x22;
-    let zy = z * y22;
-    let zz = z * z2;
-    let wx = w3 * x22;
-    let wy = w3 * y22;
-    let wz = w3 * z2;
-    this.e0 = 1 - yy - zz;
-    this.e1 = yx + wz;
-    this.e2 = zx - wy;
-    this.e3 = 0;
-    this.e4 = yx - wz;
-    this.e5 = 1 - xx - zz;
-    this.e6 = zy + wx;
-    this.e7 = 0;
-    this.e8 = zx + wy;
-    this.e9 = zy - wx;
-    this.e10 = 1 - xx - yy;
-    this.e11 = 0;
-    this.e12 = 0;
-    this.e13 = 0;
-    this.e14 = 0;
-    this.e15 = 1;
-    return this;
+  isFull() {
+    return this.numVertices === this.buffer.maxLength;
   }
-  fromInverseRotationAndTranslation(rotation2, translation) {
-    conjugatedRotation.conjugateQuat(rotation2);
-    this.fromQuat(conjugatedRotation);
-    this.multiply3x3(rotatedTranslation, translation);
-    rotatedTranslation.negate();
-    this.setTranslation(rotatedTranslation);
-    return this;
+  getVertex(out, index) {
+    out.copy(this.buffer.getAtIndex(index));
   }
-  invert() {
-    const a00 = this.e0;
-    const a01 = this.e1;
-    const a02 = this.e2;
-    const a03 = this.e3;
-    const a10 = this.e4;
-    const a11 = this.e5;
-    const a12 = this.e6;
-    const a13 = this.e7;
-    const a20 = this.e8;
-    const a21 = this.e9;
-    const a22 = this.e10;
-    const a23 = this.e11;
-    const a30 = this.e12;
-    const a31 = this.e13;
-    const a32 = this.e14;
-    const a33 = this.e15;
-    const b00 = a00 * a11 - a01 * a10;
-    const b01 = a00 * a12 - a02 * a10;
-    const b02 = a00 * a13 - a03 * a10;
-    const b03 = a01 * a12 - a02 * a11;
-    const b04 = a01 * a13 - a03 * a11;
-    const b05 = a02 * a13 - a03 * a12;
-    const b06 = a20 * a31 - a21 * a30;
-    const b07 = a20 * a32 - a22 * a30;
-    const b08 = a20 * a33 - a23 * a30;
-    const b09 = a21 * a32 - a22 * a31;
-    const b10 = a21 * a33 - a23 * a31;
-    const b11 = a22 * a33 - a23 * a32;
-    let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
-    if (!det) {
-      return null;
+  pushVertex(value) {
+    if (this.numVertices >= this.buffer.maxLength) {
+      throw new Error("Face is full");
     }
-    det = 1 / det;
-    this.e0 = (a11 * b11 - a12 * b10 + a13 * b09) * det;
-    this.e1 = (a02 * b10 - a01 * b11 - a03 * b09) * det;
-    this.e2 = (a31 * b05 - a32 * b04 + a33 * b03) * det;
-    this.e3 = (a22 * b04 - a21 * b05 - a23 * b03) * det;
-    this.e4 = (a12 * b08 - a10 * b11 - a13 * b07) * det;
-    this.e5 = (a00 * b11 - a02 * b08 + a03 * b07) * det;
-    this.e6 = (a32 * b02 - a30 * b05 - a33 * b01) * det;
-    this.e7 = (a20 * b05 - a22 * b02 + a23 * b01) * det;
-    this.e8 = (a10 * b10 - a11 * b08 + a13 * b06) * det;
-    this.e9 = (a01 * b08 - a00 * b10 - a03 * b06) * det;
-    this.e10 = (a30 * b04 - a31 * b02 + a33 * b00) * det;
-    this.e11 = (a21 * b02 - a20 * b04 - a23 * b00) * det;
-    this.e12 = (a11 * b07 - a10 * b09 - a12 * b06) * det;
-    this.e13 = (a00 * b09 - a01 * b07 + a02 * b06) * det;
-    this.e14 = (a31 * b01 - a30 * b03 - a32 * b00) * det;
-    this.e15 = (a20 * b03 - a21 * b01 + a22 * b00) * det;
-    return this;
+    this.buffer.getAtIndex(this.numVertices).copy(value);
+    this.numVertices++;
   }
-  invertMatrix(a3) {
-    const a00 = a3.e0;
-    const a01 = a3.e1;
-    const a02 = a3.e2;
-    const a03 = a3.e3;
-    const a10 = a3.e4;
-    const a11 = a3.e5;
-    const a12 = a3.e6;
-    const a13 = a3.e7;
-    const a20 = a3.e8;
-    const a21 = a3.e9;
-    const a22 = a3.e10;
-    const a23 = a3.e11;
-    const a30 = a3.e12;
-    const a31 = a3.e13;
-    const a32 = a3.e14;
-    const a33 = a3.e15;
-    const b00 = a00 * a11 - a01 * a10;
-    const b01 = a00 * a12 - a02 * a10;
-    const b02 = a00 * a13 - a03 * a10;
-    const b03 = a01 * a12 - a02 * a11;
-    const b04 = a01 * a13 - a03 * a11;
-    const b05 = a02 * a13 - a03 * a12;
-    const b06 = a20 * a31 - a21 * a30;
-    const b07 = a20 * a32 - a22 * a30;
-    const b08 = a20 * a33 - a23 * a30;
-    const b09 = a21 * a32 - a22 * a31;
-    const b10 = a21 * a33 - a23 * a31;
-    const b11 = a22 * a33 - a23 * a32;
-    let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
-    if (!det) {
-      return null;
+  pushVertexValues(x2, y4, z) {
+    if (this.numVertices >= this.buffer.maxLength) {
+      throw new Error("Face is full");
     }
-    det = 1 / det;
-    this.e0 = (a11 * b11 - a12 * b10 + a13 * b09) * det;
-    this.e1 = (a02 * b10 - a01 * b11 - a03 * b09) * det;
-    this.e2 = (a31 * b05 - a32 * b04 + a33 * b03) * det;
-    this.e3 = (a22 * b04 - a21 * b05 - a23 * b03) * det;
-    this.e4 = (a12 * b08 - a10 * b11 - a13 * b07) * det;
-    this.e5 = (a00 * b11 - a02 * b08 + a03 * b07) * det;
-    this.e6 = (a32 * b02 - a30 * b05 - a33 * b01) * det;
-    this.e7 = (a20 * b05 - a22 * b02 + a23 * b01) * det;
-    this.e8 = (a10 * b10 - a11 * b08 + a13 * b06) * det;
-    this.e9 = (a01 * b08 - a00 * b10 - a03 * b06) * det;
-    this.e10 = (a30 * b04 - a31 * b02 + a33 * b00) * det;
-    this.e11 = (a21 * b02 - a20 * b04 - a23 * b00) * det;
-    this.e12 = (a11 * b07 - a10 * b09 - a12 * b06) * det;
-    this.e13 = (a00 * b09 - a01 * b07 + a02 * b06) * det;
-    this.e14 = (a31 * b01 - a30 * b03 - a32 * b00) * det;
-    this.e15 = (a20 * b03 - a21 * b01 + a22 * b00) * det;
-    return this;
+    const vertex3 = this.buffer.getAtIndex(this.numVertices);
+    vertex3.x = x2;
+    vertex3.y = y4;
+    vertex3.z = z;
+    this.numVertices++;
   }
-  getColumn3(out, index) {
-    switch (index) {
-      case 0: {
-        out.x = this.e0;
-        out.y = this.e1;
-        out.z = this.e2;
-        break;
-      }
-      case 1: {
-        out.x = this.e4;
-        out.y = this.e5;
-        out.z = this.e6;
-        break;
-      }
+  transform(isometry2) {
+    for (let i = 0; i < this.numVertices; i++) {
+      this.buffer.getAtIndex(i).transformByMat4(isometry2);
+    }
+  }
+  getCentroid(out) {
+    out.zero();
+    for (let i = 0; i < this.numVertices; i++) {
+      out.addVector(this.buffer.getAtIndex(i));
+    }
+    out.scale(1 / this.numVertices);
+  }
+  getNormal(out) {
+    switch (this.numVertices) {
+      case 0:
+      case 1:
       case 2: {
-        out.x = this.e8;
-        out.y = this.e9;
-        out.z = this.e10;
+        out.zero();
         break;
       }
+      default: {
+        triangle$1.a.copy(this.buffer.getAtIndex(0));
+        triangle$1.b.copy(this.buffer.getAtIndex(1));
+        triangle$1.c.copy(this.buffer.getAtIndex(2));
+        triangle$1.computeNormal(out);
+      }
     }
   }
-  multiplyMatrix(b3) {
-    let a00 = this.e0, a01 = this.e1, a02 = this.e2, a03 = this.e3;
-    let a10 = this.e4, a11 = this.e5, a12 = this.e6, a13 = this.e7;
-    let a20 = this.e8, a21 = this.e9, a22 = this.e10, a23 = this.e11;
-    let a30 = this.e12, a31 = this.e13, a32 = this.e14, a33 = this.e15;
-    let b0 = b3.e0, b12 = b3.e1, b22 = b3.e2, b32 = b3.e3;
-    this.e0 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
-    this.e1 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
-    this.e2 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
-    this.e3 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
-    b0 = b3.e4;
-    b12 = b3.e5;
-    b22 = b3.e6;
-    b32 = b3.e7;
-    this.e4 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
-    this.e5 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
-    this.e6 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
-    this.e7 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
-    b0 = b3.e8;
-    b12 = b3.e9;
-    b22 = b3.e10;
-    b32 = b3.e11;
-    this.e8 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
-    this.e9 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
-    this.e10 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
-    this.e11 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
-    b0 = b3.e12;
-    b12 = b3.e13;
-    b22 = b3.e14;
-    b32 = b3.e15;
-    this.e12 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
-    this.e13 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
-    this.e14 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
-    this.e15 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
-    return this;
+  translate(translation) {
+    for (let i = 0; i < this.numVertices; i++) {
+      this.buffer.getAtIndex(i).addVector(translation);
+    }
   }
-  multiplyMatrices(a3, b3) {
-    let a00 = a3.e0, a01 = a3.e1, a02 = a3.e2, a03 = a3.e3;
-    let a10 = a3.e4, a11 = a3.e5, a12 = a3.e6, a13 = a3.e7;
-    let a20 = a3.e8, a21 = a3.e9, a22 = a3.e10, a23 = a3.e11;
-    let a30 = a3.e12, a31 = a3.e13, a32 = a3.e14, a33 = a3.e15;
-    let b0 = b3.e0, b12 = b3.e1, b22 = b3.e2, b32 = b3.e3;
-    this.e0 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
-    this.e1 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
-    this.e2 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
-    this.e3 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
-    b0 = b3.e4;
-    b12 = b3.e5;
-    b22 = b3.e6;
-    b32 = b3.e7;
-    this.e4 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
-    this.e5 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
-    this.e6 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
-    this.e7 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
-    b0 = b3.e8;
-    b12 = b3.e9;
-    b22 = b3.e10;
-    b32 = b3.e11;
-    this.e8 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
-    this.e9 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
-    this.e10 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
-    this.e11 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
-    b0 = b3.e12;
-    b12 = b3.e13;
-    b22 = b3.e14;
-    b32 = b3.e15;
-    this.e12 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
-    this.e13 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
-    this.e14 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
-    this.e15 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
-    return this;
+  swap(other) {
+    if (this.numVertices !== other.numVertices) {
+      throw new Error("Cannot swap faces of different sizes");
+    }
+    for (let i = 0; i < this.numVertices; i++) {
+      tempVertex.copy(this.buffer.getAtIndex(i));
+      this.buffer.getAtIndex(i).copy(other.buffer.getAtIndex(i));
+      other.buffer.getAtIndex(i).copy(tempVertex);
+    }
   }
-  preScaled(scale2) {
-    this.e0 *= scale2.x;
-    this.e1 *= scale2.x;
-    this.e2 *= scale2.x;
-    this.e4 *= scale2.y;
-    this.e5 *= scale2.y;
-    this.e6 *= scale2.y;
-    this.e8 *= scale2.z;
-    this.e9 *= scale2.z;
-    this.e10 *= scale2.z;
-    return this;
+}
+const oldCreate$b = Face.create;
+Face.create = function() {
+  const face = oldCreate$b.apply(this, arguments);
+  if (isFinite(face.buffer.maxLength)) {
+    for (let i = 0; i < face.buffer.maxLength; i++) {
+      face.buffer.create();
+    }
   }
-  toObject() {
-    return {
-      e0: this.e0,
-      e1: this.e1,
-      e2: this.e2,
-      e3: this.e3,
-      e4: this.e4,
-      e5: this.e5,
-      e6: this.e6,
-      e7: this.e7,
-      e8: this.e8,
-      e9: this.e9,
-      e10: this.e10,
-      e11: this.e11,
-      e12: this.e12,
-      e13: this.e13,
-      e14: this.e14,
-      e15: this.e15
-    };
-  }
-  identity() {
-    this.e0 = 1;
-    this.e1 = 0;
-    this.e2 = 0;
-    this.e3 = 0;
-    this.e4 = 0;
-    this.e5 = 1;
-    this.e6 = 0;
-    this.e7 = 0;
-    this.e8 = 0;
-    this.e9 = 0;
-    this.e10 = 1;
-    this.e11 = 0;
-    this.e12 = 0;
-    this.e13 = 0;
-    this.e14 = 0;
-    this.e15 = 1;
-    return this;
-  }
-  getRotationMatrix4(out) {
-    out.copy(this);
-    out.e12 = 0;
-    out.e13 = 0;
-    out.e14 = 0;
-    out.e15 = 1;
+  return face;
+};
+const quatKeys = ["x", "y", "z", "w"];
+const quatProps = props({
+  x: 0,
+  y: 0,
+  z: 0,
+  w: 1
+});
+class Quat extends createClass()(quatProps) {
+  constructor(data, index, pool) {
+    if (Array.isArray(data)) {
+      if (data.length && data.length < 4) {
+        tempQuat.setFromEulerRadians(data[0], data[1] ?? 0, data[2] ?? 0);
+      } else {
+        tempQuat.x = data[0] ?? 0;
+        tempQuat.y = data[1] ?? 0;
+        tempQuat.z = data[2] ?? 0;
+        tempQuat.w = data[3] ?? 1;
+      }
+      super(tempQuat, index, pool);
+      return;
+    }
+    super(data, index, pool);
   }
-  decompose(outTranslation, outOrientation, outScale) {
-    outTranslation.x = this.e12;
-    outTranslation.y = this.e13;
-    outTranslation.z = this.e14;
-    let m11 = this.e0;
-    let m12 = this.e1;
-    let m13 = this.e2;
-    let m21 = this.e4;
-    let m22 = this.e5;
-    let m23 = this.e6;
-    let m31 = this.e8;
-    let m32 = this.e9;
-    let m33 = this.e10;
-    outScale.x = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
-    outScale.y = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
-    outScale.z = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
-    let is1 = 1 / outScale.x;
-    let is2 = 1 / outScale.y;
-    let is3 = 1 / outScale.z;
-    let sm11 = m11 * is1;
-    let sm12 = m12 * is2;
-    let sm13 = m13 * is3;
-    let sm21 = m21 * is1;
-    let sm22 = m22 * is2;
-    let sm23 = m23 * is3;
-    let sm31 = m31 * is1;
-    let sm32 = m32 * is2;
-    let sm33 = m33 * is3;
-    let trace = sm11 + sm22 + sm33;
-    let S = 0;
-    if (trace > 0) {
-      S = Math.sqrt(trace + 1) * 2;
-      outOrientation.w = 0.25 * S;
-      outOrientation.x = (sm23 - sm32) / S;
-      outOrientation.y = (sm31 - sm13) / S;
-      outOrientation.z = (sm12 - sm21) / S;
-    } else if (sm11 > sm22 && sm11 > sm33) {
-      S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2;
-      outOrientation.w = (sm23 - sm32) / S;
-      outOrientation.x = 0.25 * S;
-      outOrientation.y = (sm12 + sm21) / S;
-      outOrientation.z = (sm31 + sm13) / S;
-    } else if (sm22 > sm33) {
-      S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2;
-      outOrientation.w = (sm31 - sm13) / S;
-      outOrientation.x = (sm12 + sm21) / S;
-      outOrientation.y = 0.25 * S;
-      outOrientation.z = (sm23 + sm32) / S;
+  reset(data) {
+    if (Array.isArray(data)) {
+      if (data.length && data.length < 4) {
+        return this.setFromEulerRadians(data[0], data[1] ?? 0, data[2] ?? 0);
+      }
+      this.x = data[0] ?? 0;
+      this.y = data[1] ?? 0;
+      this.z = data[2] ?? 0;
+      this.w = data[3] ?? 1;
     } else {
-      S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2;
-      outOrientation.w = (sm12 - sm21) / S;
-      outOrientation.x = (sm31 + sm13) / S;
-      outOrientation.y = (sm23 + sm32) / S;
-      outOrientation.z = 0.25 * S;
+      if (data && data.w === void 0 && (data.x || data.y || data.z)) {
+        return this.setFromEulerRadians(data.x ?? 0, data.y ?? 0, data.z ?? 0);
+      }
+      this.x = data?.x ?? 0;
+      this.y = data?.y ?? 0;
+      this.z = data?.z ?? 0;
+      this.w = data?.w ?? 1;
     }
     return this;
   }
-  compose(translation, orientation, scale2) {
-    let x2 = orientation.x, y4 = orientation.y, z = orientation.z, w3 = orientation.w;
-    let x22 = x2 + x2;
-    let y22 = y4 + y4;
-    let z2 = z + z;
-    let xx = x2 * x22;
-    let xy = x2 * y22;
-    let xz = x2 * z2;
-    let yy = y4 * y22;
-    let yz = y4 * z2;
-    let zz = z * z2;
-    let wx = w3 * x22;
-    let wy = w3 * y22;
-    let wz = w3 * z2;
-    let sx = scale2.x;
-    let sy = scale2.y;
-    let sz = scale2.z;
-    this.e0 = (1 - (yy + zz)) * sx;
-    this.e1 = (xy + wz) * sx;
-    this.e2 = (xz - wy) * sx;
-    this.e3 = 0;
-    this.e4 = (xy - wz) * sy;
-    this.e5 = (1 - (xx + zz)) * sy;
-    this.e6 = (yz + wx) * sy;
-    this.e7 = 0;
-    this.e8 = (xz + wy) * sz;
-    this.e9 = (yz - wx) * sz;
-    this.e10 = (1 - (xx + yy)) * sz;
-    this.e11 = 0;
-    this.e12 = translation.x;
-    this.e13 = translation.y;
-    this.e14 = translation.z;
-    this.e15 = 1;
+  set(data) {
+    if (Array.isArray(data)) {
+      if (data.length && data.length < 4) {
+        return this.setFromEulerRadians(data[0], data[1] ?? 0, data[2] ?? 0);
+      }
+      this.x = data[0] ?? 0;
+      this.y = data[1] ?? 0;
+      this.z = data[2] ?? 0;
+      this.w = data[3] ?? 1;
+    } else if (data) {
+      if (data.x !== void 0) {
+        this.x = data.x;
+      }
+      if (data.y !== void 0) {
+        this.y = data.y;
+      }
+      if (data.z !== void 0) {
+        this.z = data.z;
+      }
+      if (data.w !== void 0) {
+        this.w = data.w;
+      }
+    }
     return this;
   }
-}
-const rotation$3 = /* @__PURE__ */ Quat.create();
-const cross_bn_cn = /* @__PURE__ */ Vec3.create();
-const planeProps = props({
-  normal: Vec3,
-  constant: 0
-});
-class Plane extends createClass()(planeProps) {
-  toObject() {
-    return {
-      normal: this.normal.toObject(),
-      constant: this.constant
-    };
-  }
-  fromPointAndNormal(point2, normal4) {
-    this.normal.copy(normal4);
-    this.constant = -normal4.dot(point2);
-  }
-  signedDistance(point2) {
-    return point2.dot(this.normal) + this.constant;
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
   }
-  offsetAlongNormal(out, inDistance) {
-    out.copy(this);
-    out.constant -= inDistance;
+  normalize() {
+    const length = this.length();
+    if (length > 0) {
+      this.x /= length;
+      this.y /= length;
+      this.z /= length;
+      this.w /= length;
+    }
+    return this;
   }
-  offsetPlaneAlongNormal(plane, inDistance) {
-    this.normal.copy(plane.normal);
-    this.constant = plane.constant - inDistance;
+  identity() {
+    this.x = 0;
+    this.y = 0;
+    this.z = 0;
+    this.w = 1;
+    return this;
   }
-  toString() {
-    return `Plane { normal: ${this.normal.toString()}, constant: ${this.constant} }`;
+  conjugateQuat(a3) {
+    this.x = -a3.x;
+    this.y = -a3.y;
+    this.z = -a3.z;
+    this.w = a3.w;
+    return this;
   }
-  static intersectPlanes(planeA, planeB, planeC, outPoint) {
-    cross_bn_cn.crossVectors(planeB.normal, planeC.normal);
-    const denominator = planeA.normal.dot(cross_bn_cn);
-    if (denominator === 0) {
-      return false;
-    }
-    const a3 = planeA.normal;
-    const b3 = planeB.normal;
-    const c3 = planeC.normal;
+  multiplyQuats(a3, b3) {
     const ax = a3.x;
     const ay = a3.y;
     const az = a3.z;
+    const aw = a3.w;
     const bx = b3.x;
     const by = b3.y;
     const bz = b3.z;
-    const cx = c3.x;
-    const cy = c3.y;
-    const cz = c3.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(ray2) {
-    const denominator = this.normal.dot(ray2.direction);
-    if (Math.abs(denominator) < 1e-6) {
-      return 1;
-    }
-    const t = (this.constant - this.normal.dot(ray2.origin)) / denominator;
-    const fraction = t / ray2.length;
-    if (fraction < 0 || fraction > 1) {
-      return 1;
+    const bw = b3.w;
+    this.x = ax * bw + aw * bx + ay * bz - az * by;
+    this.y = ay * bw + aw * by + az * bx - ax * bz;
+    this.z = az * bw + aw * bz + ax * by - ay * bx;
+    this.w = aw * bw - ax * bx - ay * by - az * bz;
+    return this;
+  }
+  normalizeQuat(a3) {
+    const x2 = a3.x;
+    const y4 = a3.y;
+    const z = a3.z;
+    const w3 = a3.w;
+    let len = x2 * x2 + y4 * y4 + z * z + w3 * w3;
+    if (len > 0) {
+      len = 1 / Math.sqrt(len);
     }
-    return fraction;
+    this.x = x2 * len;
+    this.y = y4 * len;
+    this.z = z * len;
+    this.w = w3 * len;
+    return this;
   }
-}
-const segmentProps = props({
-  pointA: Vec3,
-  pointB: Vec3
-});
-class Segment extends createClass()(segmentProps) {
-  computeCenter(out) {
-    out.addVectors(this.pointA, this.pointB);
-    out.scaleVector(out, 0.5);
+  setAxisAngle(axis2, angle) {
+    angle = angle * 0.5;
+    let s2 = Math.sin(angle);
+    this.x = s2 * axis2.x;
+    this.y = s2 * axis2.y;
+    this.z = s2 * axis2.z;
+    this.w = Math.cos(angle);
+    return this;
   }
-  computeHalfExtents(out) {
-    out.subtractVectors(this.pointB, this.pointA);
-    out.scaleVector(out, 0.5);
+  dot(b3) {
+    return this.x * b3.x + this.y * b3.y + this.z * b3.z + this.w * b3.w;
   }
-  setFromRay(ray2) {
-    this.pointA.copy(ray2.origin);
-    this.pointB.addScaledToVector(ray2.origin, ray2.direction, ray2.length);
+  notEquals(other, tolerance = 1e-6) {
+    return Math.abs(this.x - other.x) >= tolerance || Math.abs(this.y - other.y) >= tolerance || Math.abs(this.z - other.z) >= tolerance || Math.abs(this.w - other.w) >= tolerance;
   }
-}
-const epsilon$2 = 1e-7;
-const newMin = /* @__PURE__ */ Vec3.create();
-const newMax = /* @__PURE__ */ Vec3.create();
-const col = /* @__PURE__ */ Vec3.create();
-const a$2 = /* @__PURE__ */ Vec3.create();
-const b$1 = /* @__PURE__ */ Vec3.create();
-const aabbProps = props({
-  min: Vec3,
-  max: Vec3,
-  centroid: ChildType(Vec3, void 0, true)
-});
-class Aabb extends createClass()(aabbProps) {
-  computeSupport(out, direction2) {
-    out.x = direction2.x < 0 ? this.min.x : this.max.x;
-    out.y = direction2.y < 0 ? this.min.y : this.max.y;
-    out.z = direction2.z < 0 ? this.min.z : this.max.z;
+  equals(other, tolerance = 1e-6) {
+    return Math.abs(this.x - other.x) < tolerance && Math.abs(this.y - other.y) < tolerance && Math.abs(this.z - other.z) < tolerance && Math.abs(this.w - other.w) < tolerance;
   }
-  computeSupportingFace(out, inDirection) {
-    const absX = Math.abs(inDirection.x);
-    const absY = Math.abs(inDirection.y);
-    const absZ = Math.abs(inDirection.z);
-    const axis2 = absX > absY ? absX > absZ ? 0 : 2 : absY > absZ ? 1 : 2;
-    const component = inDirection.getComponentAtIndex(axis2);
-    if (component < 0) {
-      switch (axis2) {
-        case 0: {
-          out.pushVertexValues(this.max.x, this.min.y, this.min.z);
-          out.pushVertexValues(this.max.x, this.max.y, this.min.z);
-          out.pushVertexValues(this.max.x, this.max.y, this.max.z);
-          out.pushVertexValues(this.max.x, this.min.y, this.max.z);
-          break;
-        }
-        case 1: {
-          out.pushVertexValues(this.min.x, this.max.y, this.min.z);
-          out.pushVertexValues(this.min.x, this.max.y, this.max.z);
-          out.pushVertexValues(this.max.x, this.max.y, this.max.z);
-          out.pushVertexValues(this.max.x, this.max.y, this.min.z);
-          break;
-        }
-        case 2: {
-          out.pushVertexValues(this.min.x, this.min.y, this.max.z);
-          out.pushVertexValues(this.max.x, this.min.y, this.max.z);
-          out.pushVertexValues(this.max.x, this.max.y, this.max.z);
-          out.pushVertexValues(this.min.x, this.max.y, this.max.z);
-          break;
-        }
-      }
+  intoEuler(out) {
+    if (this.w < 0) {
+      out.x = -this.x * 2;
+      out.y = -this.y * 2;
+      out.z = -this.z * 2;
     } else {
-      switch (axis2) {
-        case 0: {
-          out.pushVertexValues(this.min.x, this.min.y, this.min.z);
-          out.pushVertexValues(this.min.x, this.min.y, this.max.z);
-          out.pushVertexValues(this.min.x, this.max.y, this.max.z);
-          out.pushVertexValues(this.min.x, this.max.y, this.min.z);
-          break;
-        }
-        case 1: {
-          out.pushVertexValues(this.min.x, this.min.y, this.min.z);
-          out.pushVertexValues(this.max.x, this.min.y, this.min.z);
-          out.pushVertexValues(this.max.x, this.min.y, this.max.z);
-          out.pushVertexValues(this.min.x, this.min.y, this.max.z);
-          break;
-        }
-        case 2: {
-          out.pushVertexValues(this.min.x, this.min.y, this.min.z);
-          out.pushVertexValues(this.min.x, this.max.y, this.min.z);
-          out.pushVertexValues(this.max.x, this.max.y, this.min.z);
-          out.pushVertexValues(this.max.x, this.min.y, this.min.z);
-          break;
-        }
-      }
+      out.x = this.x * 2;
+      out.y = this.y * 2;
+      out.z = this.z * 2;
     }
-  }
-  translate(translation) {
-    this.min.addVector(translation);
-    this.max.addVector(translation);
-    this.computeCentroid(this.centroid);
-  }
-  translateAabb(aabb, translation) {
-    this.min.addVectors(aabb.min, translation);
-    this.max.addVectors(aabb.max, translation);
-    this.computeCentroid(this.centroid);
     return this;
   }
-  transform(transform2) {
-    transform2.matrix.getTranslation(newMin);
-    transform2.matrix.getTranslation(newMax);
-    for (let c3 = 0; c3 < 3; ++c3) {
-      transform2.matrix.getColumn3(col, c3);
-      const minComponent = this.min.getComponentAtIndex(c3);
-      const maxComponent = this.max.getComponentAtIndex(c3);
-      a$2.scaleVector(col, minComponent);
-      b$1.scaleVector(col, maxComponent);
-      newMin.x += Math.min(a$2.x, b$1.x);
-      newMin.y += Math.min(a$2.y, b$1.y);
-      newMin.z += Math.min(a$2.z, b$1.z);
-      newMax.x += Math.max(a$2.x, b$1.x);
-      newMax.y += Math.max(a$2.y, b$1.y);
-      newMax.z += Math.max(a$2.z, b$1.z);
+  fromMat3(m) {
+    let fTrace = m.e0 + m.e4 + m.e8;
+    let fRoot;
+    if (fTrace > 0) {
+      fRoot = Math.sqrt(fTrace + 1);
+      this.w = 0.5 * fRoot;
+      fRoot = 0.5 / fRoot;
+      this.x = (m.e5 - m.e7) * fRoot;
+      this.y = (m.e6 - m.e2) * fRoot;
+      this.z = (m.e1 - m.e3) * fRoot;
+    } else {
+      let i = 0;
+      if (m.e4 > m.e0) i = 1;
+      if (m.e8 > m[mat3Keys[i * 3 + i]]) i = 2;
+      let j = (i + 1) % 3;
+      let k = (i + 2) % 3;
+      fRoot = Math.sqrt(m[mat3Keys[i * 3 + i]] - m[mat3Keys[j * 3 + j]] - m[mat3Keys[k * 3 + k]] + 1);
+      this[quatKeys[i]] = 0.5 * fRoot;
+      fRoot = 0.5 / fRoot;
+      this.w = (m[mat3Keys[j * 3 + k]] - m[mat3Keys[k * 3 + j]]) * fRoot;
+      this[quatKeys[j]] = (m[mat3Keys[j * 3 + i]] + m[mat3Keys[i * 3 + j]]) * fRoot;
+      this[quatKeys[k]] = (m[mat3Keys[k * 3 + i]] + m[mat3Keys[i * 3 + k]]) * fRoot;
     }
-    this.min.copy(newMin);
-    this.max.copy(newMax);
-    this.computeCentroid(this.centroid);
     return this;
   }
-  transformAabb(aabb, transform2) {
-    transform2.matrix.getTranslation(newMin);
-    transform2.matrix.getTranslation(newMax);
-    for (let c3 = 0; c3 < 3; ++c3) {
-      transform2.matrix.getColumn3(col, c3);
-      const minComponent = aabb.min.getComponentAtIndex(c3);
-      const maxComponent = aabb.max.getComponentAtIndex(c3);
-      a$2.scaleVector(col, minComponent);
-      b$1.scaleVector(col, maxComponent);
-      newMin.x += Math.min(a$2.x, b$1.x);
-      newMin.y += Math.min(a$2.y, b$1.y);
-      newMin.z += Math.min(a$2.z, b$1.z);
-      newMax.x += Math.max(a$2.x, b$1.x);
-      newMax.y += Math.max(a$2.y, b$1.y);
-      newMax.z += Math.max(a$2.z, b$1.z);
-    }
-    this.min.copy(newMin);
-    this.max.copy(newMax);
-    this.computeCentroid(this.centroid);
+  fromMat4(m) {
+    tempMat3.fromMat4(m);
+    this.fromMat3(tempMat3);
     return this;
   }
-  intersectsAabb(aabb) {
-    return this.min.x <= aabb.max.x && this.max.x >= aabb.min.x && this.min.y <= aabb.max.y && this.max.y >= aabb.min.y && this.min.z <= aabb.max.z && this.max.z >= aabb.min.z;
+  computeRotationAngle(axis2) {
+    if (this.w === 0) {
+      return Math.PI;
+    } else {
+      vector.x = this.x;
+      vector.y = this.y;
+      vector.z = this.z;
+      return 2 * Math.atan(vector.dot(axis2) / this.w);
+    }
   }
-  unionAabb(aabb) {
-    this.min.minVectors(this.min, aabb.min);
-    this.max.maxVectors(this.max, aabb.max);
-    this.computeCentroid(this.centroid);
+  setFromEulerRadians(x2, y4, z) {
+    const halfX = x2 * 0.5;
+    const halfY = y4 * 0.5;
+    const halfZ = z * 0.5;
+    const c12 = Math.cos(halfX);
+    const c22 = Math.cos(halfY);
+    const c3 = Math.cos(halfZ);
+    const s1 = Math.sin(halfX);
+    const s2 = Math.sin(halfY);
+    const s3 = Math.sin(halfZ);
+    this.x = s1 * c22 * c3 + c12 * s2 * s3;
+    this.y = c12 * s2 * c3 - s1 * c22 * s3;
+    this.z = c12 * c22 * s3 + s1 * s2 * c3;
+    this.w = c12 * c22 * c3 - s1 * s2 * s3;
     return this;
   }
-  unionAabbs(boxA, boxB) {
-    this.min.minVectors(boxA.min, boxB.min);
-    this.max.maxVectors(boxA.max, boxB.max);
-    this.computeCentroid(this.centroid);
-    return this;
+  toObject() {
+    return {
+      x: this.x,
+      y: this.y,
+      z: this.z,
+      w: this.w
+    };
   }
-  expand(value) {
-    this.min.x -= value;
-    this.min.y -= value;
-    this.min.z -= value;
-    this.max.x += value;
-    this.max.y += value;
-    this.max.z += value;
-    this.computeCentroid(this.centroid);
-  }
-  expandAabb(aabb, value) {
-    this.min.x = aabb.min.x - value;
-    this.min.y = aabb.min.y - value;
-    this.min.z = aabb.min.z - value;
-    this.max.x = aabb.max.x + value;
-    this.max.y = aabb.max.y + value;
-    this.max.z = aabb.max.z + value;
-    this.computeCentroid(this.centroid);
-    return this;
-  }
-  setExtents(min, max) {
-    this.min.set(min);
-    this.max.set(max);
-    this.computeCentroid(this.centroid);
-    return this;
-  }
-  computeSurfaceArea() {
-    const dx = this.max.x - this.min.x;
-    const dy = this.max.y - this.min.y;
-    const dz = this.max.z - this.min.z;
-    return 2 * (dx * dy + dy * dz + dz * dx);
+}
+const vector = /* @__PURE__ */ Vec3.create();
+const tempMat3 = /* @__PURE__ */ Mat3.create();
+const tempQuat = /* @__PURE__ */ Quat.create();
+const rotationMatrix$2 = /* @__PURE__ */ Mat3.create();
+const scaling = /* @__PURE__ */ Vec3.create();
+const conjugatedRotation = /* @__PURE__ */ Quat.create();
+const rotatedTranslation = /* @__PURE__ */ Vec3.create();
+const mat4Props = props({
+  e0: 0,
+  e1: 0,
+  e2: 0,
+  e3: 0,
+  e4: 0,
+  e5: 0,
+  e6: 0,
+  e7: 0,
+  e8: 0,
+  e9: 0,
+  e10: 0,
+  e11: 0,
+  e12: 0,
+  e13: 0,
+  e14: 0,
+  e15: 0
+});
+class Mat4 extends createClass()(mat4Props) {
+  multiply3x3(out, a3) {
+    const x2 = a3.x;
+    const y4 = a3.y;
+    const z = a3.z;
+    out.x = this.e0 * x2 + this.e4 * y4 + this.e8 * z;
+    out.y = this.e1 * x2 + this.e5 * y4 + this.e9 * z;
+    out.z = this.e2 * x2 + this.e6 * y4 + this.e10 * z;
+    return out;
   }
-  computeExtents(out) {
-    out.x = this.max.x - this.min.x;
-    out.y = this.max.y - this.min.y;
-    out.z = this.max.z - this.min.z;
+  multiply3x3Transposed(out, a3) {
+    rotationMatrix$2.fromMat4(this);
+    rotationMatrix$2.transpose();
+    out.transformVectorFromMat3(a3, rotationMatrix$2);
   }
-  computeLargestAxis() {
-    const dx = this.max.x - this.min.x;
-    const dy = this.max.y - this.min.y;
-    const dz = this.max.z - this.min.z;
-    if (dx >= dy && dx >= dz) {
-      return 0;
-    }
-    if (dy >= dx && dy >= dz) {
-      return 1;
-    }
-    return 2;
+  computeScaling(out) {
+    let m11 = this.e0;
+    let m12 = this.e1;
+    let m13 = this.e2;
+    let m21 = this.e4;
+    let m22 = this.e5;
+    let m23 = this.e6;
+    let m31 = this.e8;
+    let m32 = this.e9;
+    let m33 = this.e10;
+    out.x = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
+    out.y = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
+    out.z = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
+    return out;
   }
-  computeLargestComponent() {
-    const dx = this.max.x - this.min.x;
-    const dy = this.max.y - this.min.y;
-    const dz = this.max.z - this.min.z;
-    if (dx >= dy && dx >= dz) {
-      return "x";
-    }
-    if (dy >= dx && dy >= dz) {
-      return "y";
+  computeRotation(out) {
+    this.computeScaling(scaling);
+    let is1 = 1 / scaling.x;
+    let is2 = 1 / scaling.y;
+    let is3 = 1 / scaling.z;
+    let sm11 = this.e0 * is1;
+    let sm12 = this.e1 * is2;
+    let sm13 = this.e2 * is3;
+    let sm21 = this.e4 * is1;
+    let sm22 = this.e5 * is2;
+    let sm23 = this.e6 * is3;
+    let sm31 = this.e8 * is1;
+    let sm32 = this.e9 * is2;
+    let sm33 = this.e10 * is3;
+    let trace = sm11 + sm22 + sm33;
+    let S = 0;
+    if (trace > 0) {
+      S = Math.sqrt(trace + 1) * 2;
+      out.w = 0.25 * S;
+      out.x = (sm23 - sm32) / S;
+      out.y = (sm31 - sm13) / S;
+      out.z = (sm12 - sm21) / S;
+    } else if (sm11 > sm22 && sm11 > sm33) {
+      S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2;
+      out.w = (sm23 - sm32) / S;
+      out.x = 0.25 * S;
+      out.y = (sm12 + sm21) / S;
+      out.z = (sm31 + sm13) / S;
+    } else if (sm22 > sm33) {
+      S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2;
+      out.w = (sm31 - sm13) / S;
+      out.x = (sm12 + sm21) / S;
+      out.y = 0.25 * S;
+      out.z = (sm23 + sm32) / S;
+    } else {
+      S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2;
+      out.w = (sm12 - sm21) / S;
+      out.x = (sm31 + sm13) / S;
+      out.y = (sm23 + sm32) / S;
+      out.z = 0.25 * S;
     }
-    return "z";
-  }
-  computeCentroid(out) {
-    out.x = (this.min.x + this.max.x) * 0.5;
-    out.y = (this.min.y + this.max.y) * 0.5;
-    out.z = (this.min.z + this.max.z) * 0.5;
     return out;
   }
-  computeHalfExtents(out) {
-    out.subtractVectors(this.max, this.min);
-    out.scaleVector(out, 0.5);
-  }
-  expandToPoint(point2) {
-    this.min.minVector(point2);
-    this.max.maxVector(point2);
-    return this;
-  }
-  enclosesAabb(aabb) {
-    return this.min.x < aabb.min.x && this.max.x > aabb.max.x && this.min.y < aabb.min.y && this.max.y > aabb.max.y && this.min.z < aabb.min.z && this.max.z > aabb.max.z;
-  }
-  expandByVector(vector2) {
-    this.min.x -= vector2.x;
-    this.min.y -= vector2.y;
-    this.min.z -= vector2.z;
-    this.max.x += vector2.x;
-    this.max.y += vector2.y;
-    this.max.z += vector2.z;
+  getTranslation(out) {
+    out.x = this.e12;
+    out.y = this.e13;
+    out.z = this.e14;
   }
-  toString() {
-    return `Aabb(min: ${[this.min.x, this.min.y, this.min.z].join(", ")}, max: ${[
-      this.max.x,
-      this.max.y,
-      this.max.z
-    ].join(", ")})`;
+  setTranslation(v4) {
+    this.e12 = v4.x;
+    this.e13 = v4.y;
+    this.e14 = v4.z;
+    this.e15 = 1;
   }
-  intersectsRay(ray2) {
-    segment.setFromRay(ray2);
-    return this.intersectsSegment(segment);
+  preTranslated(translation) {
+    this.e12 += this.e0 * translation.x + this.e4 * translation.y + this.e8 * translation.z;
+    this.e13 += this.e1 * translation.x + this.e5 * translation.y + this.e9 * translation.z;
+    this.e14 += this.e2 * translation.x + this.e6 * translation.y + this.e10 * translation.z;
+    this.e15 = 1;
+    return this;
   }
-  /**
-   * from Christer Ericson's book "Real-Time Collision Detection", "5.3.3 Intersecting Ray or Segment Against Box"
-   */
-  intersectsSegment(segment2) {
-    this.computeCentroid(aabbCenter);
-    this.computeHalfExtents(aabbHalfExtents);
-    segment2.computeCenter(segmentCenter);
-    segment2.computeHalfExtents(segmentHalfExtents);
-    segmentCenter.subtractVectors(segmentCenter, aabbCenter);
-    let adx = Math.abs(segmentHalfExtents.x);
-    if (Math.abs(segmentCenter.x) > aabbHalfExtents.x + adx) {
-      return false;
-    }
-    let ady = Math.abs(segmentHalfExtents.y);
-    if (Math.abs(segmentCenter.y) > aabbHalfExtents.y + ady) {
-      return false;
-    }
-    let adz = Math.abs(segmentHalfExtents.z);
-    if (Math.abs(segmentCenter.z) > aabbHalfExtents.z + adz) {
-      return false;
-    }
-    adx += epsilon$2;
-    ady += epsilon$2;
-    adz += epsilon$2;
-    if (Math.abs(segmentCenter.y * segmentHalfExtents.z - segmentCenter.z * segmentHalfExtents.y) > aabbHalfExtents.y * adz + aabbHalfExtents.z * ady) {
-      return false;
-    }
-    if (Math.abs(segmentCenter.z * segmentHalfExtents.x - segmentCenter.x * segmentHalfExtents.z) > aabbHalfExtents.x * adz + aabbHalfExtents.z * adx) {
-      return false;
-    }
-    if (Math.abs(segmentCenter.x * segmentHalfExtents.y - segmentCenter.y * segmentHalfExtents.x) > aabbHalfExtents.x * ady + aabbHalfExtents.y * adx) {
-      return false;
-    }
-    return true;
+  postTranslated(translation) {
+    this.e12 += translation.x;
+    this.e13 += translation.y;
+    this.e14 += translation.z;
+    this.e15 = 1;
+    return this;
   }
-  toObject() {
-    return {
-      min: this.min.toObject(),
-      max: this.max.toObject()
-    };
+  postTranslatedMatrix(mat, translation) {
+    this.e0 = mat.e0;
+    this.e1 = mat.e1;
+    this.e2 = mat.e2;
+    this.e3 = mat.e3;
+    this.e4 = mat.e4;
+    this.e5 = mat.e5;
+    this.e6 = mat.e6;
+    this.e7 = mat.e7;
+    this.e8 = mat.e8;
+    this.e9 = mat.e9;
+    this.e10 = mat.e10;
+    this.e11 = mat.e11;
+    this.e12 = mat.e12 + translation.x;
+    this.e13 = mat.e13 + translation.y;
+    this.e14 = mat.e14 + translation.z;
+    this.e15 = 1;
+    return this;
   }
-}
-const segment = /* @__PURE__ */ Segment.create();
-const aabbCenter = /* @__PURE__ */ Vec3.create();
-const aabbHalfExtents = /* @__PURE__ */ Vec3.create();
-const segmentCenter = /* @__PURE__ */ Vec3.create();
-const segmentHalfExtents = /* @__PURE__ */ Vec3.create();
-const triangleProps$1 = props({
-  computedBounds: ChildType(Aabb, void 0, true),
-  normal: ChildType(Vec3, void 0, true),
-  a: Vec3,
-  b: Vec3,
-  c: Vec3,
-  subShapeId: NumberType(0, true),
-  activeEdges: NumberType(0, true)
-  // aabb: { struct: Aabb, readOnly: true },
-  // activeEdges: { struct: Uint32, optional: true },
-  // translation: { struct: Vec3, optional: true },
-});
-const ab$5 = /* @__PURE__ */ Vec3.create();
-const ac$3 = /* @__PURE__ */ Vec3.create();
-let Triangle$1 = class Triangle extends createClass()(triangleProps$1) {
-  // type: ShapeType.triangle = ShapeType.triangle;
-  computeNormal(out) {
-    ab$5.subtractVectors(this.b, this.a);
-    ac$3.subtractVectors(this.c, this.a);
-    out.crossVectors(ab$5, ac$3);
-    out.normalize();
+  fromRotationTranslation(q4, v4) {
+    const x2 = q4.x;
+    const y4 = q4.y;
+    const z = q4.z;
+    const w3 = q4.w;
+    const x22 = x2 + x2;
+    const y22 = y4 + y4;
+    const z2 = z + z;
+    const xx = x2 * x22;
+    const xy = x2 * y22;
+    const xz = x2 * z2;
+    const yy = y4 * y22;
+    const yz = y4 * z2;
+    const zz = z * z2;
+    const wx = w3 * x22;
+    const wy = w3 * y22;
+    const wz = w3 * z2;
+    this.e0 = 1 - (yy + zz);
+    this.e1 = xy + wz;
+    this.e2 = xz - wy;
+    this.e3 = 0;
+    this.e4 = xy - wz;
+    this.e5 = 1 - (xx + zz);
+    this.e6 = yz + wx;
+    this.e7 = 0;
+    this.e8 = xz + wy;
+    this.e9 = yz - wx;
+    this.e10 = 1 - (xx + yy);
+    this.e11 = 0;
+    this.e12 = v4.x;
+    this.e13 = v4.y;
+    this.e14 = v4.z;
+    this.e15 = 1;
+    return this;
   }
-  computeCentroid(out) {
-    out.addVectors(this.a, this.b).addVector(this.c).scale(1 / 3);
+  fromAxisAngle(axis2, angle) {
+    rotation$3.setAxisAngle(axis2, angle);
+    this.fromQuat(rotation$3);
+    this.e12 = 0;
+    this.e13 = 0;
+    this.e14 = 0;
+    this.e15 = 1;
+    return this;
   }
-  computeUnnormalizedNormal(out) {
-    ab$5.subtractVectors(this.b, this.a);
-    ac$3.subtractVectors(this.c, this.a);
-    out.crossVectors(ab$5, ac$3);
+  fromQuat(q4) {
+    let x2 = q4.x, y4 = q4.y, z = q4.z, w3 = q4.w;
+    let x22 = x2 + x2;
+    let y22 = y4 + y4;
+    let z2 = z + z;
+    let xx = x2 * x22;
+    let yx = y4 * x22;
+    let yy = y4 * y22;
+    let zx = z * x22;
+    let zy = z * y22;
+    let zz = z * z2;
+    let wx = w3 * x22;
+    let wy = w3 * y22;
+    let wz = w3 * z2;
+    this.e0 = 1 - yy - zz;
+    this.e1 = yx + wz;
+    this.e2 = zx - wy;
+    this.e3 = 0;
+    this.e4 = yx - wz;
+    this.e5 = 1 - xx - zz;
+    this.e6 = zy + wx;
+    this.e7 = 0;
+    this.e8 = zx + wy;
+    this.e9 = zy - wx;
+    this.e10 = 1 - xx - yy;
+    this.e11 = 0;
+    this.e12 = 0;
+    this.e13 = 0;
+    this.e14 = 0;
+    this.e15 = 1;
+    return this;
   }
-  computeSurfaceNormal(out, inLocalSurfacePosition2, subShapeId) {
-    this.computeNormal(out);
+  fromInverseRotationAndTranslation(rotation2, translation) {
+    conjugatedRotation.conjugateQuat(rotation2);
+    this.fromQuat(conjugatedRotation);
+    this.multiply3x3(rotatedTranslation, translation);
+    rotatedTranslation.negate();
+    this.setTranslation(rotatedTranslation);
+    return this;
   }
-  transform(isometry2) {
-    this.a.transformByMat4(isometry2);
-    this.b.transformByMat4(isometry2);
-    this.c.transformByMat4(isometry2);
+  invert() {
+    const a00 = this.e0;
+    const a01 = this.e1;
+    const a02 = this.e2;
+    const a03 = this.e3;
+    const a10 = this.e4;
+    const a11 = this.e5;
+    const a12 = this.e6;
+    const a13 = this.e7;
+    const a20 = this.e8;
+    const a21 = this.e9;
+    const a22 = this.e10;
+    const a23 = this.e11;
+    const a30 = this.e12;
+    const a31 = this.e13;
+    const a32 = this.e14;
+    const a33 = this.e15;
+    const b00 = a00 * a11 - a01 * a10;
+    const b01 = a00 * a12 - a02 * a10;
+    const b02 = a00 * a13 - a03 * a10;
+    const b03 = a01 * a12 - a02 * a11;
+    const b04 = a01 * a13 - a03 * a11;
+    const b05 = a02 * a13 - a03 * a12;
+    const b06 = a20 * a31 - a21 * a30;
+    const b07 = a20 * a32 - a22 * a30;
+    const b08 = a20 * a33 - a23 * a30;
+    const b09 = a21 * a32 - a22 * a31;
+    const b10 = a21 * a33 - a23 * a31;
+    const b11 = a22 * a33 - a23 * a32;
+    let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    if (!det) {
+      return null;
+    }
+    det = 1 / det;
+    this.e0 = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+    this.e1 = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+    this.e2 = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+    this.e3 = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+    this.e4 = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+    this.e5 = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+    this.e6 = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+    this.e7 = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+    this.e8 = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+    this.e9 = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+    this.e10 = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+    this.e11 = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+    this.e12 = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+    this.e13 = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+    this.e14 = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+    this.e15 = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+    return this;
   }
-  computeLocalBounds(out) {
-    out.min.x = Math.min(this.a.x, this.b.x, this.c.x);
-    out.min.y = Math.min(this.a.y, this.b.y, this.c.y);
-    out.min.z = Math.min(this.a.z, this.b.z, this.c.z);
-    out.max.x = Math.max(this.a.x, this.b.x, this.c.x);
-    out.max.y = Math.max(this.a.y, this.b.y, this.c.y);
-    out.max.z = Math.max(this.a.z, this.b.z, this.c.z);
-    out.computeCentroid(out.centroid);
+  invertMatrix(a3) {
+    const a00 = a3.e0;
+    const a01 = a3.e1;
+    const a02 = a3.e2;
+    const a03 = a3.e3;
+    const a10 = a3.e4;
+    const a11 = a3.e5;
+    const a12 = a3.e6;
+    const a13 = a3.e7;
+    const a20 = a3.e8;
+    const a21 = a3.e9;
+    const a22 = a3.e10;
+    const a23 = a3.e11;
+    const a30 = a3.e12;
+    const a31 = a3.e13;
+    const a32 = a3.e14;
+    const a33 = a3.e15;
+    const b00 = a00 * a11 - a01 * a10;
+    const b01 = a00 * a12 - a02 * a10;
+    const b02 = a00 * a13 - a03 * a10;
+    const b03 = a01 * a12 - a02 * a11;
+    const b04 = a01 * a13 - a03 * a11;
+    const b05 = a02 * a13 - a03 * a12;
+    const b06 = a20 * a31 - a21 * a30;
+    const b07 = a20 * a32 - a22 * a30;
+    const b08 = a20 * a33 - a23 * a30;
+    const b09 = a21 * a32 - a22 * a31;
+    const b10 = a21 * a33 - a23 * a31;
+    const b11 = a22 * a33 - a23 * a32;
+    let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    if (!det) {
+      return null;
+    }
+    det = 1 / det;
+    this.e0 = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+    this.e1 = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+    this.e2 = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+    this.e3 = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+    this.e4 = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+    this.e5 = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+    this.e6 = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+    this.e7 = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+    this.e8 = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+    this.e9 = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+    this.e10 = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+    this.e11 = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+    this.e12 = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+    this.e13 = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+    this.e14 = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+    this.e15 = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+    return this;
   }
-  computeSupport(out, direction2) {
-    const dotA = this.a.dot(direction2);
-    const dotB = this.b.dot(direction2);
-    const dotC = this.c.dot(direction2);
-    if (dotA > dotB) {
-      if (dotA > dotC) {
-        out.copy(this.a);
-      } else {
-        out.copy(this.c);
+  getColumn3(out, index) {
+    switch (index) {
+      case 0: {
+        out.x = this.e0;
+        out.y = this.e1;
+        out.z = this.e2;
+        break;
       }
-    } else {
-      if (dotB > dotC) {
-        out.copy(this.b);
-      } else {
-        out.copy(this.c);
+      case 1: {
+        out.x = this.e4;
+        out.y = this.e5;
+        out.z = this.e6;
+        break;
+      }
+      case 2: {
+        out.x = this.e8;
+        out.y = this.e9;
+        out.z = this.e10;
+        break;
       }
     }
   }
-  getConvexRadius() {
-    return 0;
+  multiplyMatrix(b3) {
+    let a00 = this.e0, a01 = this.e1, a02 = this.e2, a03 = this.e3;
+    let a10 = this.e4, a11 = this.e5, a12 = this.e6, a13 = this.e7;
+    let a20 = this.e8, a21 = this.e9, a22 = this.e10, a23 = this.e11;
+    let a30 = this.e12, a31 = this.e13, a32 = this.e14, a33 = this.e15;
+    let b0 = b3.e0, b12 = b3.e1, b22 = b3.e2, b32 = b3.e3;
+    this.e0 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
+    this.e1 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
+    this.e2 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
+    this.e3 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
+    b0 = b3.e4;
+    b12 = b3.e5;
+    b22 = b3.e6;
+    b32 = b3.e7;
+    this.e4 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
+    this.e5 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
+    this.e6 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
+    this.e7 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
+    b0 = b3.e8;
+    b12 = b3.e9;
+    b22 = b3.e10;
+    b32 = b3.e11;
+    this.e8 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
+    this.e9 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
+    this.e10 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
+    this.e11 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
+    b0 = b3.e12;
+    b12 = b3.e13;
+    b22 = b3.e14;
+    b32 = b3.e15;
+    this.e12 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
+    this.e13 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
+    this.e14 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
+    this.e15 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
+    return this;
   }
-  computeSupportShape(mode, scale2) {
+  multiplyMatrices(a3, b3) {
+    let a00 = a3.e0, a01 = a3.e1, a02 = a3.e2, a03 = a3.e3;
+    let a10 = a3.e4, a11 = a3.e5, a12 = a3.e6, a13 = a3.e7;
+    let a20 = a3.e8, a21 = a3.e9, a22 = a3.e10, a23 = a3.e11;
+    let a30 = a3.e12, a31 = a3.e13, a32 = a3.e14, a33 = a3.e15;
+    let b0 = b3.e0, b12 = b3.e1, b22 = b3.e2, b32 = b3.e3;
+    this.e0 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
+    this.e1 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
+    this.e2 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
+    this.e3 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
+    b0 = b3.e4;
+    b12 = b3.e5;
+    b22 = b3.e6;
+    b32 = b3.e7;
+    this.e4 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
+    this.e5 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
+    this.e6 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
+    this.e7 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
+    b0 = b3.e8;
+    b12 = b3.e9;
+    b22 = b3.e10;
+    b32 = b3.e11;
+    this.e8 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
+    this.e9 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
+    this.e10 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
+    this.e11 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
+    b0 = b3.e12;
+    b12 = b3.e13;
+    b22 = b3.e14;
+    b32 = b3.e15;
+    this.e12 = b0 * a00 + b12 * a10 + b22 * a20 + b32 * a30;
+    this.e13 = b0 * a01 + b12 * a11 + b22 * a21 + b32 * a31;
+    this.e14 = b0 * a02 + b12 * a12 + b22 * a22 + b32 * a32;
+    this.e15 = b0 * a03 + b12 * a13 + b22 * a23 + b32 * a33;
+    return this;
+  }
+  preScaled(scale2) {
+    this.e0 *= scale2.x;
+    this.e1 *= scale2.x;
+    this.e2 *= scale2.x;
+    this.e4 *= scale2.y;
+    this.e5 *= scale2.y;
+    this.e6 *= scale2.y;
+    this.e8 *= scale2.z;
+    this.e9 *= scale2.z;
+    this.e10 *= scale2.z;
     return this;
   }
   toObject() {
     return {
-      a: this.a.toObject(),
-      b: this.b.toObject(),
-      c: this.c.toObject(),
-      normal: this.normal.toObject()
+      e0: this.e0,
+      e1: this.e1,
+      e2: this.e2,
+      e3: this.e3,
+      e4: this.e4,
+      e5: this.e5,
+      e6: this.e6,
+      e7: this.e7,
+      e8: this.e8,
+      e9: this.e9,
+      e10: this.e10,
+      e11: this.e11,
+      e12: this.e12,
+      e13: this.e13,
+      e14: this.e14,
+      e15: this.e15
     };
   }
-  computeSupportingFace(out, subShapeID, direction2, scale2, centerOfMassTransform2) {
-    out.clear();
-    out.pushVertex(this.a);
-    out.pushVertex(this.b);
-    out.pushVertex(this.c);
-    out.transform(centerOfMassTransform2);
-  }
-};
-const faceProps = props({
-  numVertices: 0,
-  buffer: LazyReferenceListType(() => Vec3)
-});
-const triangle$1 = /* @__PURE__ */ Triangle$1.create();
-const tempVertex = /* @__PURE__ */ Vec3.create();
-class Face extends createClass()(faceProps) {
-  clear() {
-    this.numVertices = 0;
-  }
-  isEmpty() {
-    return this.numVertices === 0;
-  }
-  isFull() {
-    return this.numVertices === this.buffer.maxLength;
-  }
-  getVertex(out, index) {
-    out.copy(this.buffer.getAtIndex(index));
-  }
-  pushVertex(value) {
-    if (this.numVertices >= this.buffer.maxLength) {
-      throw new Error("Face is full");
-    }
-    this.buffer.getAtIndex(this.numVertices).copy(value);
-    this.numVertices++;
-  }
-  pushVertexValues(x2, y4, z) {
-    if (this.numVertices >= this.buffer.maxLength) {
-      throw new Error("Face is full");
-    }
-    const vertex3 = this.buffer.getAtIndex(this.numVertices);
-    vertex3.x = x2;
-    vertex3.y = y4;
-    vertex3.z = z;
-    this.numVertices++;
-  }
-  transform(isometry2) {
-    for (let i = 0; i < this.numVertices; i++) {
-      this.buffer.getAtIndex(i).transformByMat4(isometry2);
-    }
-  }
-  getCentroid(out) {
-    out.zero();
-    for (let i = 0; i < this.numVertices; i++) {
-      out.addVector(this.buffer.getAtIndex(i));
-    }
-    out.scale(1 / this.numVertices);
+  identity() {
+    this.e0 = 1;
+    this.e1 = 0;
+    this.e2 = 0;
+    this.e3 = 0;
+    this.e4 = 0;
+    this.e5 = 1;
+    this.e6 = 0;
+    this.e7 = 0;
+    this.e8 = 0;
+    this.e9 = 0;
+    this.e10 = 1;
+    this.e11 = 0;
+    this.e12 = 0;
+    this.e13 = 0;
+    this.e14 = 0;
+    this.e15 = 1;
+    return this;
   }
-  getNormal(out) {
-    switch (this.numVertices) {
-      case 0:
-      case 1:
-      case 2: {
-        out.zero();
-        break;
-      }
-      default: {
-        triangle$1.a.copy(this.buffer.getAtIndex(0));
-        triangle$1.b.copy(this.buffer.getAtIndex(1));
-        triangle$1.c.copy(this.buffer.getAtIndex(2));
-        triangle$1.computeNormal(out);
-      }
-    }
+  getRotationMatrix4(out) {
+    out.copy(this);
+    out.e12 = 0;
+    out.e13 = 0;
+    out.e14 = 0;
+    out.e15 = 1;
   }
-  translate(translation) {
-    for (let i = 0; i < this.numVertices; i++) {
-      this.buffer.getAtIndex(i).addVector(translation);
+  decompose(outTranslation, outOrientation, outScale) {
+    outTranslation.x = this.e12;
+    outTranslation.y = this.e13;
+    outTranslation.z = this.e14;
+    let m11 = this.e0;
+    let m12 = this.e1;
+    let m13 = this.e2;
+    let m21 = this.e4;
+    let m22 = this.e5;
+    let m23 = this.e6;
+    let m31 = this.e8;
+    let m32 = this.e9;
+    let m33 = this.e10;
+    outScale.x = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
+    outScale.y = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
+    outScale.z = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
+    let is1 = 1 / outScale.x;
+    let is2 = 1 / outScale.y;
+    let is3 = 1 / outScale.z;
+    let sm11 = m11 * is1;
+    let sm12 = m12 * is2;
+    let sm13 = m13 * is3;
+    let sm21 = m21 * is1;
+    let sm22 = m22 * is2;
+    let sm23 = m23 * is3;
+    let sm31 = m31 * is1;
+    let sm32 = m32 * is2;
+    let sm33 = m33 * is3;
+    let trace = sm11 + sm22 + sm33;
+    let S = 0;
+    if (trace > 0) {
+      S = Math.sqrt(trace + 1) * 2;
+      outOrientation.w = 0.25 * S;
+      outOrientation.x = (sm23 - sm32) / S;
+      outOrientation.y = (sm31 - sm13) / S;
+      outOrientation.z = (sm12 - sm21) / S;
+    } else if (sm11 > sm22 && sm11 > sm33) {
+      S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2;
+      outOrientation.w = (sm23 - sm32) / S;
+      outOrientation.x = 0.25 * S;
+      outOrientation.y = (sm12 + sm21) / S;
+      outOrientation.z = (sm31 + sm13) / S;
+    } else if (sm22 > sm33) {
+      S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2;
+      outOrientation.w = (sm31 - sm13) / S;
+      outOrientation.x = (sm12 + sm21) / S;
+      outOrientation.y = 0.25 * S;
+      outOrientation.z = (sm23 + sm32) / S;
+    } else {
+      S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2;
+      outOrientation.w = (sm12 - sm21) / S;
+      outOrientation.x = (sm31 + sm13) / S;
+      outOrientation.y = (sm23 + sm32) / S;
+      outOrientation.z = 0.25 * S;
     }
+    return this;
   }
-  swap(other) {
-    if (this.numVertices !== other.numVertices) {
-      throw new Error("Cannot swap faces of different sizes");
-    }
-    for (let i = 0; i < this.numVertices; i++) {
-      tempVertex.copy(this.buffer.getAtIndex(i));
-      this.buffer.getAtIndex(i).copy(other.buffer.getAtIndex(i));
-      other.buffer.getAtIndex(i).copy(tempVertex);
-    }
+  compose(translation, orientation, scale2) {
+    let x2 = orientation.x, y4 = orientation.y, z = orientation.z, w3 = orientation.w;
+    let x22 = x2 + x2;
+    let y22 = y4 + y4;
+    let z2 = z + z;
+    let xx = x2 * x22;
+    let xy = x2 * y22;
+    let xz = x2 * z2;
+    let yy = y4 * y22;
+    let yz = y4 * z2;
+    let zz = z * z2;
+    let wx = w3 * x22;
+    let wy = w3 * y22;
+    let wz = w3 * z2;
+    let sx = scale2.x;
+    let sy = scale2.y;
+    let sz = scale2.z;
+    this.e0 = (1 - (yy + zz)) * sx;
+    this.e1 = (xy + wz) * sx;
+    this.e2 = (xz - wy) * sx;
+    this.e3 = 0;
+    this.e4 = (xy - wz) * sy;
+    this.e5 = (1 - (xx + zz)) * sy;
+    this.e6 = (yz + wx) * sy;
+    this.e7 = 0;
+    this.e8 = (xz + wy) * sz;
+    this.e9 = (yz - wx) * sz;
+    this.e10 = (1 - (xx + yy)) * sz;
+    this.e11 = 0;
+    this.e12 = translation.x;
+    this.e13 = translation.y;
+    this.e14 = translation.z;
+    this.e15 = 1;
+    return this;
   }
 }
-const oldCreate$b = Face.create;
-Face.create = function() {
-  const face = oldCreate$b.apply(this, arguments);
-  if (isFinite(face.buffer.maxLength)) {
-    for (let i = 0; i < face.buffer.maxLength; i++) {
-      face.buffer.create();
-    }
-  }
-  return face;
-};
+const rotation$3 = /* @__PURE__ */ Quat.create();
 var ReferenceFrame = /* @__PURE__ */ ((ReferenceFrame2) => {
   ReferenceFrame2[ReferenceFrame2["local"] = 0] = "local";
   ReferenceFrame2[ReferenceFrame2["world"] = 1] = "world";
@@ -3985,41 +3907,6 @@ function createBitFlags(keys) {
 function shouldPairCollide(groupA, maskA, groupB, maskB) {
   return (groupA & maskB) !== 0 && (groupB & maskA) !== 0;
 }
-function shouldCollide(maskA, groupB) {
-  return (groupB & maskA) !== 0;
-}
-function addFlag(flag, value) {
-  return flag | value;
-}
-function removeFlag(flag, value) {
-  return flag & ~value;
-}
-function toggleFlag(flag, value) {
-  return flag ^ value;
-}
-function hasFlag(flag, value) {
-  return (flag & value) !== 0;
-}
-function doesNotHaveFlag(flag, value) {
-  return (flag & value) === 0;
-}
-function setFlags(...values) {
-  return values.reduce((acc, value) => acc | value, 0);
-}
-const CollisionFilter = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  AllFlag,
-  NoneFlag,
-  addFlag,
-  createBitFlags,
-  doesNotHaveFlag,
-  hasFlag,
-  removeFlag,
-  setFlags,
-  shouldCollide,
-  shouldPairCollide,
-  toggleFlag
-}, Symbol.toStringTag, { value: "Module" }));
 const leftAabb = /* @__PURE__ */ Aabb.create();
 const rightAabb = /* @__PURE__ */ Aabb.create();
 const centroidBounds$1 = /* @__PURE__ */ Aabb.create();
@@ -4570,6 +4457,79 @@ class BasicTransform extends createClass()(basicTransformProps) {
     return this.position.equals(other.position, tolerance) && this.rotation.equals(other.rotation, tolerance) && Math.abs(this.scale - other.scale) < tolerance;
   }
 }
+const cross_bn_cn = /* @__PURE__ */ Vec3.create();
+const planeProps = props({
+  normal: Vec3,
+  constant: 0
+});
+class Plane extends createClass()(planeProps) {
+  toObject() {
+    return {
+      normal: this.normal.toObject(),
+      constant: this.constant
+    };
+  }
+  fromPointAndNormal(point2, normal4) {
+    this.normal.copy(normal4);
+    this.constant = -normal4.dot(point2);
+  }
+  signedDistance(point2) {
+    return point2.dot(this.normal) + this.constant;
+  }
+  offsetAlongNormal(out, inDistance) {
+    out.copy(this);
+    out.constant -= inDistance;
+  }
+  offsetPlaneAlongNormal(plane, inDistance) {
+    this.normal.copy(plane.normal);
+    this.constant = plane.constant - inDistance;
+  }
+  toString() {
+    return `Plane { normal: ${this.normal.toString()}, constant: ${this.constant} }`;
+  }
+  static intersectPlanes(planeA, planeB, planeC, outPoint) {
+    cross_bn_cn.crossVectors(planeB.normal, planeC.normal);
+    const denominator = planeA.normal.dot(cross_bn_cn);
+    if (denominator === 0) {
+      return false;
+    }
+    const a3 = planeA.normal;
+    const b3 = planeB.normal;
+    const c3 = planeC.normal;
+    const ax = a3.x;
+    const ay = a3.y;
+    const az = a3.z;
+    const bx = b3.x;
+    const by = b3.y;
+    const bz = b3.z;
+    const cx = c3.x;
+    const cy = c3.y;
+    const cz = c3.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(ray2) {
+    const denominator = this.normal.dot(ray2.direction);
+    if (Math.abs(denominator) < 1e-6) {
+      return 1;
+    }
+    const t = (this.constant - this.normal.dot(ray2.origin)) / denominator;
+    const fraction = t / ray2.length;
+    if (fraction < 0 || fraction > 1) {
+      return 1;
+    }
+    return fraction;
+  }
+}
 const numberValueProps = props({
   value: 0
 });
@@ -8030,29 +7990,31 @@ class Body extends createClass({ afterConstructorCode })(bodyProps) {
     return this["shape" + this.shapeType];
   }
   set shape(newShape) {
-    this.setShape(newShape);
+    this.setShape(newShape, Boolean(newShape));
   }
   setShape(newShape, updateBroadphase = true) {
     this["shape" + this.shapeType] = null;
-    this["shape" + newShape.type] = newShape;
-    this.shapeType = newShape.type;
-    if (newShape.type === ShapeType.triangleMesh && this.type === 0 && !newShape.computedVolume) {
-      const float32Array = new Float32Array(newShape.vertexPositions.length * 3);
-      let index = 0;
-      for (const vertexPosition of newShape.vertexPositions) {
-        float32Array[index++] = vertexPosition.x;
-        float32Array[index++] = vertexPosition.y;
-        float32Array[index++] = vertexPosition.z;
-      }
-      const hull = this.world.triangleMeshBuilder.convexHullBuilder.buildFromPoints(
-        float32Array,
-        0.02,
-        1e-3,
-        Infinity,
-        Infinity
-      );
-      newShape.computedVolume = hull.computedVolume;
-      newShape.inertia.copy(hull.inertia);
+    if (newShape) {
+      this["shape" + newShape.type] = newShape;
+      this.shapeType = newShape.type;
+      if (newShape.type === ShapeType.triangleMesh && this.type === 0 && !newShape.computedVolume) {
+        const float32Array = new Float32Array(newShape.vertexPositions.length * 3);
+        let index = 0;
+        for (const vertexPosition of newShape.vertexPositions) {
+          float32Array[index++] = vertexPosition.x;
+          float32Array[index++] = vertexPosition.y;
+          float32Array[index++] = vertexPosition.z;
+        }
+        const hull = this.world.triangleMeshBuilder.convexHullBuilder.buildFromPoints(
+          float32Array,
+          0.02,
+          1e-3,
+          Infinity,
+          Infinity
+        );
+        newShape.computedVolume = hull.computedVolume;
+        newShape.inertia.copy(hull.inertia);
+      }
     }
     if (updateBroadphase) {
       updateBody(this);
@@ -8305,6 +8267,10 @@ class Body extends createClass({ afterConstructorCode })(bodyProps) {
     this.world.sleepModule.wakeBodyUp(this);
   }
   markBodyAsDirty() {
+    if (this.type === 2) {
+      this.world.broadphase.markStaticBodyAsDirty(this);
+      return;
+    }
     this.world.broadphase.markDynamicBodyAsDirty(this);
   }
 }
@@ -8379,8 +8345,95 @@ function updateBody(body2, updateBroadphase = true) {
   if (updateBroadphase) {
     body2.markBodyAsDirty();
   }
-}
-const castResultProps = props({
+}
+const castResultProps = props({
+  status: NumberType(
+    2
+    /* Indeterminate */
+  ),
+  hasContact: BooleanType(false),
+  penetration: 0,
+  contactPointA: Vec3,
+  contactPointB: Vec3,
+  normalA: Vec3,
+  normalB: Vec3,
+  momentArmA: Vec3,
+  momentArmB: Vec3,
+  surfaceNormalA: Vec3,
+  surfaceNormalB: Vec3,
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
+  subShapeIdA: 0,
+  subShapeIdB: 0,
+  isBackFace: BooleanType(false),
+  faceA: Face,
+  faceB: Face,
+  fraction: 0,
+  isBackFaceHit: BooleanType(false)
+});
+class CastResult extends createClass()(castResultProps) {
+  /**
+   * swaps the A and B data
+   */
+  swap() {
+    this.contactPointA.swap(this.contactPointB);
+    this.normalA.swap(this.normalB);
+    this.momentArmA.swap(this.momentArmB);
+    this.surfaceNormalA.swap(this.surfaceNormalB);
+    const tempBody = this.bodyA;
+    this.bodyA = this.bodyB;
+    this.bodyB = tempBody;
+    const tempSubShapeId = this.subShapeIdA;
+    this.subShapeIdA = this.subShapeIdB;
+    this.subShapeIdB = tempSubShapeId;
+    this.faceA.swap(this.faceB);
+  }
+  getEarlyOutFraction() {
+    return this.fraction > 0 ? this.fraction : -this.penetration;
+  }
+}
+const _CastCollector = class _CastCollector {
+  constructor() {
+    this.earlyOutFraction = _CastCollector.initialEarlyOutFraction;
+    this.body2 = null;
+  }
+  getEarlyOutFraction() {
+    return this.earlyOutFraction;
+  }
+  getPositiveEarlyOutFraction() {
+    return Math.max(Number.MIN_VALUE, this.earlyOutFraction);
+  }
+  reset() {
+    this.earlyOutFraction = _CastCollector.initialEarlyOutFraction;
+    this.body2 = null;
+    return this;
+  }
+  updateEarlyOutFraction(inFraction) {
+    if (inFraction <= this.earlyOutFraction) {
+      this.earlyOutFraction = inFraction;
+    }
+  }
+  addHit(result2) {
+  }
+  addMiss() {
+  }
+};
+_CastCollector.initialEarlyOutFraction = 1 + 1e-4;
+_CastCollector.shouldEarlyOutFraction = -Infinity;
+let CastCollector = _CastCollector;
+var QueryPrecision = /* @__PURE__ */ ((QueryPrecision2) => {
+  QueryPrecision2[QueryPrecision2["approximate"] = 0] = "approximate";
+  QueryPrecision2[QueryPrecision2["precise"] = 1] = "precise";
+  QueryPrecision2[QueryPrecision2["preciseWithContacts"] = 2] = "preciseWithContacts";
+  return QueryPrecision2;
+})(QueryPrecision || {});
+var CollisionStatus = /* @__PURE__ */ ((CollisionStatus2) => {
+  CollisionStatus2[CollisionStatus2["NotColliding"] = 0] = "NotColliding";
+  CollisionStatus2[CollisionStatus2["Colliding"] = 1] = "Colliding";
+  CollisionStatus2[CollisionStatus2["Indeterminate"] = 2] = "Indeterminate";
+  return CollisionStatus2;
+})(CollisionStatus || {});
+const collisionResultProps = props({
   status: NumberType(
     2
     /* Indeterminate */
@@ -8401,11 +8454,9 @@ const castResultProps = props({
   subShapeIdB: 0,
   isBackFace: BooleanType(false),
   faceA: Face,
-  faceB: Face,
-  fraction: 0,
-  isBackFaceHit: BooleanType(false)
+  faceB: Face
 });
-class CastResult extends createClass()(castResultProps) {
+class CollisionResult extends createClass()(collisionResultProps) {
   /**
    * swaps the A and B data
    */
@@ -8420,51 +8471,95 @@ class CastResult extends createClass()(castResultProps) {
     const tempSubShapeId = this.subShapeIdA;
     this.subShapeIdA = this.subShapeIdB;
     this.subShapeIdB = tempSubShapeId;
-    this.faceA.swap(this.faceB);
-  }
-  getEarlyOutFraction() {
-    return this.fraction > 0 ? this.fraction : -this.penetration;
+    const tempFace = this.faceA;
+    this.faceA = this.faceB;
+    this.faceB = tempFace;
   }
 }
-const _CastCollector = class _CastCollector {
+const _CollisionCollector = class _CollisionCollector {
   constructor() {
-    this.earlyOutFraction = _CastCollector.initialEarlyOutFraction;
+    this.earlyOutFraction = _CollisionCollector.initialEarlyOutFraction;
     this.body2 = null;
   }
   getEarlyOutFraction() {
-    return this.earlyOutFraction;
+    return _CollisionCollector.initialEarlyOutFraction;
   }
   getPositiveEarlyOutFraction() {
     return Math.max(Number.MIN_VALUE, this.earlyOutFraction);
   }
   reset() {
-    this.earlyOutFraction = _CastCollector.initialEarlyOutFraction;
+    this.earlyOutFraction = _CollisionCollector.initialEarlyOutFraction;
     this.body2 = null;
     return this;
   }
-  updateEarlyOutFraction(inFraction) {
-    if (inFraction <= this.earlyOutFraction) {
-      this.earlyOutFraction = inFraction;
-    }
-  }
   addHit(result2) {
   }
   addMiss() {
   }
 };
-_CastCollector.initialEarlyOutFraction = 1 + 1e-4;
-_CastCollector.shouldEarlyOutFraction = -Infinity;
-let CastCollector = _CastCollector;
-var QueryPrecision = /* @__PURE__ */ ((QueryPrecision2) => {
-  QueryPrecision2[QueryPrecision2["approximate"] = 0] = "approximate";
-  QueryPrecision2[QueryPrecision2["precise"] = 1] = "precise";
-  QueryPrecision2[QueryPrecision2["preciseWithContacts"] = 2] = "preciseWithContacts";
-  return QueryPrecision2;
-})(QueryPrecision || {});
+_CollisionCollector.initialEarlyOutFraction = Infinity;
+_CollisionCollector.shouldEarlyOutFraction = -Infinity;
+let CollisionCollector = _CollisionCollector;
+var CollectFacesMode = /* @__PURE__ */ ((CollectFacesMode2) => {
+  CollectFacesMode2[CollectFacesMode2["CollectFaces"] = 0] = "CollectFaces";
+  CollectFacesMode2[CollectFacesMode2["NoFaces"] = 1] = "NoFaces";
+  return CollectFacesMode2;
+})(CollectFacesMode || {});
+var ActiveEdgeMode = /* @__PURE__ */ ((ActiveEdgeMode2) => {
+  ActiveEdgeMode2[ActiveEdgeMode2["CollideOnlyWithActive"] = 0] = "CollideOnlyWithActive";
+  ActiveEdgeMode2[ActiveEdgeMode2["CollideWithAll"] = 1] = "CollideWithAll";
+  return ActiveEdgeMode2;
+})(ActiveEdgeMode || {});
+var BackFaceMode = /* @__PURE__ */ ((BackFaceMode2) => {
+  BackFaceMode2[BackFaceMode2["IgnoreBackFaces"] = 0] = "IgnoreBackFaces";
+  BackFaceMode2[BackFaceMode2["CollideWithBackFaces"] = 1] = "CollideWithBackFaces";
+  return BackFaceMode2;
+})(BackFaceMode || {});
+const result$9 = CollisionResult.create({
+  faceA: {
+    numVertices: 0,
+    buffer: { pool: new Vec3.Pool(32), maxLength: 32 }
+  },
+  faceB: {
+    numVertices: 0,
+    buffer: { pool: new Vec3.Pool(32), maxLength: 32 }
+  }
+});
+const positionA$3 = /* @__PURE__ */ Vec3.create();
+const positionB$3 = /* @__PURE__ */ Vec3.create();
 const ab$4 = /* @__PURE__ */ Vec3.create();
+function collideSphereVsSphere(penetrationDepthModule2, collector2, shapeA, shapeB2, isometryA2, isometryB2, settings, bodyA, bodyB, initialDirection, subShapeIdA = 0, subShapeIdB = 0) {
+  result$9.reset();
+  result$9.bodyA = bodyA;
+  result$9.bodyB = bodyB;
+  isometryA2.matrix.getTranslation(positionA$3);
+  isometryB2.matrix.getTranslation(positionB$3);
+  ab$4.subtractVectors(positionB$3, positionA$3);
+  if (ab$4.squaredLength() > squared(shapeA.radius + shapeB2.radius)) {
+    result$9.hasContact = false;
+    collector2.addMiss();
+    return;
+  }
+  result$9.hasContact = true;
+  result$9.bodyA = bodyA;
+  result$9.bodyB = bodyB;
+  result$9.subShapeIdA = subShapeIdA;
+  result$9.subShapeIdB = subShapeIdB;
+  result$9.normalA.normalizeVector(ab$4);
+  result$9.normalB.negateVector(result$9.normalA);
+  result$9.contactPointA.addScaledToVector(positionA$3, result$9.normalA, shapeA.radius);
+  result$9.contactPointB.addScaledToVector(positionB$3, result$9.normalB, shapeB2.radius);
+  result$9.momentArmA.subtractVectors(result$9.contactPointA, positionA$3);
+  result$9.momentArmB.subtractVectors(result$9.contactPointB, positionB$3);
+  result$9.penetration = shapeA.radius + shapeB2.radius - ab$4.length();
+  result$9.normalA.normalizeVector(result$9.normalA);
+  result$9.normalB.normalizeVector(result$9.normalB);
+  collector2.addHit(result$9);
+}
+const ab$3 = /* @__PURE__ */ Vec3.create();
 function computeBarycentricCoordinates2d(outBarycentric, a3, b3, squaredTolerance = 1e-10) {
-  ab$4.subtractVectors(b3, a3);
-  const denominator = ab$4.squaredLength();
+  ab$3.subtractVectors(b3, a3);
+  const denominator = ab$3.squaredLength();
   if (denominator < squaredTolerance) {
     if (a3.squaredLength() < b3.squaredLength()) {
       outBarycentric.u = 1;
@@ -8476,7 +8571,7 @@ function computeBarycentricCoordinates2d(outBarycentric, a3, b3, squaredToleranc
     outBarycentric.isValid = false;
     return;
   } else {
-    outBarycentric.v = -a3.dot(ab$4) / denominator;
+    outBarycentric.v = -a3.dot(ab$3) / denominator;
     outBarycentric.u = 1 - outBarycentric.v;
   }
   outBarycentric.isValid = true;
@@ -8497,19 +8592,19 @@ class BarycentricCoordinatesResult extends createClass()(
   barycentricCoordinatesResultProps
 ) {
 }
-const ab$3 = /* @__PURE__ */ Vec3.create();
+const ab$2 = /* @__PURE__ */ Vec3.create();
 const ac$2 = /* @__PURE__ */ Vec3.create();
 const bc$2 = /* @__PURE__ */ Vec3.create();
 const otherBarycentric = /* @__PURE__ */ BarycentricCoordinatesResult.create();
 function computeBarycentricCoordinates3d(outBarycentric, a3, b3, c3, squaredTolerance = 1e-10) {
-  ab$3.subtractVectors(b3, a3);
+  ab$2.subtractVectors(b3, a3);
   ac$2.subtractVectors(c3, a3);
   bc$2.subtractVectors(c3, b3);
-  const d00 = ab$3.dot(ab$3);
+  const d00 = ab$2.dot(ab$2);
   const d11 = ac$2.dot(ac$2);
   const d22 = bc$2.dot(bc$2);
   if (d00 <= d22) {
-    const d01 = ab$3.dot(ac$2);
+    const d01 = ab$2.dot(ac$2);
     const denominator = d00 * d11 - d01 * d01;
     if (Math.abs(denominator) < 1e-12) {
       if (d00 > d11) {
@@ -8526,7 +8621,7 @@ function computeBarycentricCoordinates3d(outBarycentric, a3, b3, c3, squaredTole
       outBarycentric.isValid = false;
       return;
     } else {
-      const a0 = a3.dot(ab$3);
+      const a0 = a3.dot(ab$2);
       const a12 = a3.dot(ac$2);
       outBarycentric.v = (d01 * a12 - d11 * a0) / denominator;
       outBarycentric.w = (d01 * a0 - d00 * a12) / denominator;
@@ -8576,7 +8671,7 @@ function computeClosestPointOnLine(outClosestPoints, a3, b3, squaredTolerance =
   }
 }
 const ac$1 = /* @__PURE__ */ Vec3.create();
-const ab$2 = /* @__PURE__ */ Vec3.create();
+const ab$1 = /* @__PURE__ */ Vec3.create();
 const bc$1 = /* @__PURE__ */ Vec3.create();
 const a = /* @__PURE__ */ Vec3.create();
 const c = /* @__PURE__ */ Vec3.create();
@@ -8593,9 +8688,9 @@ function computeClosestPointOnTriangle(outClosestPoint, inA, inB, inC, mustInclu
   const swapAC = bc$1.dot(bc$1) < ac$1.dot(ac$1);
   a.copy(swapAC ? inC : inA);
   c.copy(swapAC ? inA : inC);
-  ab$2.subtractVectors(inB, a);
+  ab$1.subtractVectors(inB, a);
   ac$1.subtractVectors(c, a);
-  n$1.crossVectors(ab$2, ac$1);
+  n$1.crossVectors(ab$1, ac$1);
   const normalLengthSquared = n$1.squaredLength();
   if (normalLengthSquared < 1e-11) {
     let closestSet = 4;
@@ -8639,11 +8734,11 @@ function computeClosestPointOnTriangle(outClosestPoint, inA, inB, inC, mustInclu
       }
     }
     if (!mustIncludeC) {
-      ab$2.subtractVectors(inB, inA);
-      const abLengthSquared = ab$2.squaredLength();
+      ab$1.subtractVectors(inB, inA);
+      const abLengthSquared = ab$1.squaredLength();
       if (abLengthSquared > squaredTolerance) {
-        const v4 = clamp(-inA.dot(ab$2) / abLengthSquared, 0, 1);
-        q$2.addScaledToVector(inA, ab$2, v4);
+        const v4 = clamp(-inA.dot(ab$1) / abLengthSquared, 0, 1);
+        q$2.addScaledToVector(inA, ab$1, v4);
         const distanceSquared = q$2.squaredLength();
         if (distanceSquared < bestDistanceSquared) {
           closestSet = 3;
@@ -8657,7 +8752,7 @@ function computeClosestPointOnTriangle(outClosestPoint, inA, inB, inC, mustInclu
     return;
   }
   ap.negateVector(a);
-  const d12 = ab$2.dot(ap);
+  const d12 = ab$1.dot(ap);
   const d22 = ac$1.dot(ap);
   if (d12 <= 0 && d22 <= 0) {
     outClosestPoint.pointSet = swapAC ? 4 : 1;
@@ -8665,7 +8760,7 @@ function computeClosestPointOnTriangle(outClosestPoint, inA, inB, inC, mustInclu
     return;
   }
   bp.negateVector(inB);
-  const d32 = ab$2.dot(bp);
+  const d32 = ab$1.dot(bp);
   const d42 = ac$1.dot(bp);
   if (d32 >= 0 && d42 <= d32) {
     outClosestPoint.pointSet = 2;
@@ -8675,11 +8770,11 @@ function computeClosestPointOnTriangle(outClosestPoint, inA, inB, inC, mustInclu
   if (d12 * d42 <= d32 * d22 && d12 >= 0 && d32 <= 0) {
     const v4 = d12 / (d12 - d32);
     outClosestPoint.pointSet = swapAC ? 6 : 3;
-    outClosestPoint.point.addScaledToVector(a, ab$2, v4);
+    outClosestPoint.point.addScaledToVector(a, ab$1, v4);
     return;
   }
   cp.negateVector(c);
-  const d5 = ab$2.dot(cp);
+  const d5 = ab$1.dot(cp);
   const d6 = ac$1.dot(cp);
   if (d6 >= 0 && d5 <= d6) {
     outClosestPoint.pointSet = swapAC ? 1 : 4;
@@ -8714,7 +8809,7 @@ const vec4Props = props({
 });
 class Vec4 extends createClass()(vec4Props) {
 }
-const ab$1 = /* @__PURE__ */ Vec3.create();
+const ab = /* @__PURE__ */ Vec3.create();
 const ac = /* @__PURE__ */ Vec3.create();
 const ad = /* @__PURE__ */ Vec3.create();
 const bd = /* @__PURE__ */ Vec3.create();
@@ -8726,23 +8821,23 @@ const bd_cross_bc = /* @__PURE__ */ Vec3.create();
 const signP = /* @__PURE__ */ Vec4.create();
 const signD = /* @__PURE__ */ Vec4.create();
 function isOriginOutsideOfTrianglePlanes(outResult, a3, b3, c3, d5, tolerance = 1e-5) {
-  ab$1.subtractVectors(b3, a3);
+  ab.subtractVectors(b3, a3);
   ac.subtractVectors(c3, a3);
   ad.subtractVectors(d5, a3);
   bd.subtractVectors(d5, b3);
   bc.subtractVectors(c3, b3);
-  ab_cross_ac.crossVectors(ab$1, ac);
+  ab_cross_ac.crossVectors(ab, ac);
   ac_cross_ad.crossVectors(ac, ad);
-  ad_cross_ab.crossVectors(ad, ab$1);
+  ad_cross_ab.crossVectors(ad, ab);
   bd_cross_bc.crossVectors(bd, bc);
   signP.x = a3.dot(ab_cross_ac);
   signP.y = a3.dot(ac_cross_ad);
   signP.z = a3.dot(ad_cross_ab);
   signP.w = b3.dot(bd_cross_bc);
   signD.x = ad.dot(ab_cross_ac);
-  signD.y = ab$1.dot(ac_cross_ad);
+  signD.y = ab.dot(ac_cross_ad);
   signD.z = ac.dot(ad_cross_ab);
-  signD.w = -ab$1.dot(bd_cross_bc);
+  signD.w = -ab.dot(bd_cross_bc);
   const allPositive = signD.x > 0 && signD.y > 0 && signD.z > 0 && signD.w > 0;
   if (allPositive) {
     outResult.x = signP.x >= -tolerance ? 1 : 0;
@@ -9320,94 +9415,6 @@ class GjkModule {
   }
 }
 const v = /* @__PURE__ */ Vec3.create();
-var CollisionStatus = /* @__PURE__ */ ((CollisionStatus2) => {
-  CollisionStatus2[CollisionStatus2["NotColliding"] = 0] = "NotColliding";
-  CollisionStatus2[CollisionStatus2["Colliding"] = 1] = "Colliding";
-  CollisionStatus2[CollisionStatus2["Indeterminate"] = 2] = "Indeterminate";
-  return CollisionStatus2;
-})(CollisionStatus || {});
-const collisionResultProps = props({
-  status: NumberType(
-    2
-    /* Indeterminate */
-  ),
-  hasContact: BooleanType(false),
-  penetration: 0,
-  contactPointA: Vec3,
-  contactPointB: Vec3,
-  normalA: Vec3,
-  normalB: Vec3,
-  momentArmA: Vec3,
-  momentArmB: Vec3,
-  surfaceNormalA: Vec3,
-  surfaceNormalB: Vec3,
-  bodyA: LazyReferenceType((() => Body)),
-  bodyB: LazyReferenceType((() => Body)),
-  subShapeIdA: 0,
-  subShapeIdB: 0,
-  isBackFace: BooleanType(false),
-  faceA: Face,
-  faceB: Face
-});
-class CollisionResult extends createClass()(collisionResultProps) {
-  /**
-   * swaps the A and B data
-   */
-  swap() {
-    this.contactPointA.swap(this.contactPointB);
-    this.normalA.swap(this.normalB);
-    this.momentArmA.swap(this.momentArmB);
-    this.surfaceNormalA.swap(this.surfaceNormalB);
-    const tempBody = this.bodyA;
-    this.bodyA = this.bodyB;
-    this.bodyB = tempBody;
-    const tempSubShapeId = this.subShapeIdA;
-    this.subShapeIdA = this.subShapeIdB;
-    this.subShapeIdB = tempSubShapeId;
-    const tempFace = this.faceA;
-    this.faceA = this.faceB;
-    this.faceB = tempFace;
-  }
-}
-const _CollisionCollector = class _CollisionCollector {
-  constructor() {
-    this.earlyOutFraction = _CollisionCollector.initialEarlyOutFraction;
-    this.body2 = null;
-  }
-  getEarlyOutFraction() {
-    return _CollisionCollector.initialEarlyOutFraction;
-  }
-  getPositiveEarlyOutFraction() {
-    return Math.max(Number.MIN_VALUE, this.earlyOutFraction);
-  }
-  reset() {
-    this.earlyOutFraction = _CollisionCollector.initialEarlyOutFraction;
-    this.body2 = null;
-    return this;
-  }
-  addHit(result2) {
-  }
-  addMiss() {
-  }
-};
-_CollisionCollector.initialEarlyOutFraction = Infinity;
-_CollisionCollector.shouldEarlyOutFraction = -Infinity;
-let CollisionCollector = _CollisionCollector;
-var CollectFacesMode = /* @__PURE__ */ ((CollectFacesMode2) => {
-  CollectFacesMode2[CollectFacesMode2["CollectFaces"] = 0] = "CollectFaces";
-  CollectFacesMode2[CollectFacesMode2["NoFaces"] = 1] = "NoFaces";
-  return CollectFacesMode2;
-})(CollectFacesMode || {});
-var ActiveEdgeMode = /* @__PURE__ */ ((ActiveEdgeMode2) => {
-  ActiveEdgeMode2[ActiveEdgeMode2["CollideOnlyWithActive"] = 0] = "CollideOnlyWithActive";
-  ActiveEdgeMode2[ActiveEdgeMode2["CollideWithAll"] = 1] = "CollideWithAll";
-  return ActiveEdgeMode2;
-})(ActiveEdgeMode || {});
-var BackFaceMode = /* @__PURE__ */ ((BackFaceMode2) => {
-  BackFaceMode2[BackFaceMode2["IgnoreBackFaces"] = 0] = "IgnoreBackFaces";
-  BackFaceMode2[BackFaceMode2["CollideWithBackFaces"] = 1] = "CollideWithBackFaces";
-  return BackFaceMode2;
-})(BackFaceMode || {});
 const edgeProps = props({
   neighbourTriangle: LazyReferenceType((() => Triangle2)),
   neighbourEdge: 0,
@@ -10249,47 +10256,6 @@ class PenetrationDepthModule {
     return true;
   }
 }
-const result$9 = CollisionResult.create({
-  faceA: {
-    numVertices: 0,
-    buffer: { pool: new Vec3.Pool(32), maxLength: 32 }
-  },
-  faceB: {
-    numVertices: 0,
-    buffer: { pool: new Vec3.Pool(32), maxLength: 32 }
-  }
-});
-const positionA$3 = /* @__PURE__ */ Vec3.create();
-const positionB$3 = /* @__PURE__ */ Vec3.create();
-const ab = /* @__PURE__ */ Vec3.create();
-function collideSphereVsSphere(penetrationDepthModule2, collector2, shapeA, shapeB2, isometryA2, isometryB2, settings, bodyA, bodyB, initialDirection, subShapeIdA = 0, subShapeIdB = 0) {
-  result$9.reset();
-  result$9.bodyA = bodyA;
-  result$9.bodyB = bodyB;
-  isometryA2.matrix.getTranslation(positionA$3);
-  isometryB2.matrix.getTranslation(positionB$3);
-  ab.subtractVectors(positionB$3, positionA$3);
-  if (ab.squaredLength() > squared(shapeA.radius + shapeB2.radius)) {
-    result$9.hasContact = false;
-    collector2.addMiss();
-    return;
-  }
-  result$9.hasContact = true;
-  result$9.bodyA = bodyA;
-  result$9.bodyB = bodyB;
-  result$9.subShapeIdA = subShapeIdA;
-  result$9.subShapeIdB = subShapeIdB;
-  result$9.normalA.normalizeVector(ab);
-  result$9.normalB.negateVector(result$9.normalA);
-  result$9.contactPointA.addScaledToVector(positionA$3, result$9.normalA, shapeA.radius);
-  result$9.contactPointB.addScaledToVector(positionB$3, result$9.normalB, shapeB2.radius);
-  result$9.momentArmA.subtractVectors(result$9.contactPointA, positionA$3);
-  result$9.momentArmB.subtractVectors(result$9.contactPointB, positionB$3);
-  result$9.penetration = shapeA.radius + shapeB2.radius - ab.length();
-  result$9.normalA.normalizeVector(result$9.normalA);
-  result$9.normalB.normalizeVector(result$9.normalB);
-  collector2.addHit(result$9);
-}
 const result$8 = CollisionResult.create({
   faceA: {
     numVertices: 0,
@@ -11290,6 +11256,16 @@ class CollideShapesModule {
     );
   }
 }
+const lineProps = props({
+  a: Vec3,
+  b: Vec3
+});
+class Line extends createClass()(lineProps) {
+  setFromPointAndDirection(point2, direction2, length) {
+    this.a.copy(point2);
+    this.b.addScaledToVector(point2, direction2, length);
+  }
+}
 const estimateCollisionResponseResultProps = props({
   deltaLinearVelocityA: Vec3,
   deltaAngularVelocityA: Vec3,
@@ -12525,10 +12501,16 @@ class BvhModule {
     }
     return startOffset;
   }
+  markStaticBodyAsDirty(body2) {
+    this.staticTree.markObjectAsDirty(body2);
+  }
   markDynamicBodyAsDirty(body2) {
     this.dynamicTree.markObjectAsDirty(body2);
   }
   updateDirtyBodies() {
+    for (const body2 of this.staticTree.dirtyObjects) {
+      this.staticTree.update(body2, false);
+    }
     for (const body2 of this.dynamicTree.dirtyObjects) {
       this.dynamicTree.update(body2, false);
     }
@@ -16039,17 +16021,18 @@ export {
   CollideShapesModule,
   ColliderType,
   CollisionCollector,
-  CollisionFilter,
   CollisionResult,
   CompoundShape,
   ContactManifold,
   ConvexHull,
   ConvexRadiusObject,
+  Cylinder,
   DistanceConstraint,
   Face,
   FixedConstraint,
   GjkCastShapeResult,
   GjkModule,
+  HeightMap,
   HingeConstraint,
   Isometry,
   Line,
@@ -16074,6 +16057,7 @@ export {
   World,
   baseConstraintProps,
   clamp,
+  createBitFlags,
   degreesToRadians,
   destroyAllInstancesInPool,
   squared