three-stdlib 2.25.0 → 2.25.1

package/math/OBB.js

@@ -1,242 +0,0 @@
-import { Vector3, Matrix3, Box3, Matrix4, Ray, MathUtils } from "three";
-const a = {
-  c: null,
-  // center
-  u: [/* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3()],
-  // basis vectors
-  e: []
-  // half width
-};
-const b = {
-  c: null,
-  // center
-  u: [/* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3(), /* @__PURE__ */ new Vector3()],
-  // basis vectors
-  e: []
-  // half width
-};
-const R = [[], [], []];
-const AbsR = [[], [], []];
-const t = [];
-const xAxis = /* @__PURE__ */ new Vector3();
-const yAxis = /* @__PURE__ */ new Vector3();
-const zAxis = /* @__PURE__ */ new Vector3();
-const v1 = /* @__PURE__ */ new Vector3();
-const size = /* @__PURE__ */ new Vector3();
-const closestPoint = /* @__PURE__ */ new Vector3();
-const rotationMatrix = /* @__PURE__ */ new Matrix3();
-const aabb = /* @__PURE__ */ new Box3();
-const matrix = /* @__PURE__ */ new Matrix4();
-const inverse = /* @__PURE__ */ new Matrix4();
-const localRay = /* @__PURE__ */ new Ray();
-class OBB {
-  constructor(center = new Vector3(), halfSize = new Vector3(), rotation = new Matrix3()) {
-    this.center = center;
-    this.halfSize = halfSize;
-    this.rotation = rotation;
-  }
-  set(center, halfSize, rotation) {
-    this.center = center;
-    this.halfSize = halfSize;
-    this.rotation = rotation;
-    return this;
-  }
-  copy(obb2) {
-    this.center.copy(obb2.center);
-    this.halfSize.copy(obb2.halfSize);
-    this.rotation.copy(obb2.rotation);
-    return this;
-  }
-  clone() {
-    return new this.constructor().copy(this);
-  }
-  getSize(result) {
-    return result.copy(this.halfSize).multiplyScalar(2);
-  }
-  /**
-   * Reference: Closest Point on OBB to Point in Real-Time Collision Detection
-   * by Christer Ericson (chapter 5.1.4)
-   */
-  clampPoint(point, result) {
-    const halfSize = this.halfSize;
-    v1.subVectors(point, this.center);
-    this.rotation.extractBasis(xAxis, yAxis, zAxis);
-    result.copy(this.center);
-    const x = MathUtils.clamp(v1.dot(xAxis), -halfSize.x, halfSize.x);
-    result.add(xAxis.multiplyScalar(x));
-    const y = MathUtils.clamp(v1.dot(yAxis), -halfSize.y, halfSize.y);
-    result.add(yAxis.multiplyScalar(y));
-    const z = MathUtils.clamp(v1.dot(zAxis), -halfSize.z, halfSize.z);
-    result.add(zAxis.multiplyScalar(z));
-    return result;
-  }
-  containsPoint(point) {
-    v1.subVectors(point, this.center);
-    this.rotation.extractBasis(xAxis, yAxis, zAxis);
-    return Math.abs(v1.dot(xAxis)) <= this.halfSize.x && Math.abs(v1.dot(yAxis)) <= this.halfSize.y && Math.abs(v1.dot(zAxis)) <= this.halfSize.z;
-  }
-  intersectsBox3(box3) {
-    return this.intersectsOBB(obb.fromBox3(box3));
-  }
-  intersectsSphere(sphere) {
-    this.clampPoint(sphere.center, closestPoint);
-    return closestPoint.distanceToSquared(sphere.center) <= sphere.radius * sphere.radius;
-  }
-  /**
-   * Reference: OBB-OBB Intersection in Real-Time Collision Detection
-   * by Christer Ericson (chapter 4.4.1)
-   *
-   */
-  intersectsOBB(obb2, epsilon = Number.EPSILON) {
-    a.c = this.center;
-    a.e[0] = this.halfSize.x;
-    a.e[1] = this.halfSize.y;
-    a.e[2] = this.halfSize.z;
-    this.rotation.extractBasis(a.u[0], a.u[1], a.u[2]);
-    b.c = obb2.center;
-    b.e[0] = obb2.halfSize.x;
-    b.e[1] = obb2.halfSize.y;
-    b.e[2] = obb2.halfSize.z;
-    obb2.rotation.extractBasis(b.u[0], b.u[1], b.u[2]);
-    for (let i = 0; i < 3; i++) {
-      for (let j = 0; j < 3; j++) {
-        R[i][j] = a.u[i].dot(b.u[j]);
-      }
-    }
-    v1.subVectors(b.c, a.c);
-    t[0] = v1.dot(a.u[0]);
-    t[1] = v1.dot(a.u[1]);
-    t[2] = v1.dot(a.u[2]);
-    for (let i = 0; i < 3; i++) {
-      for (let j = 0; j < 3; j++) {
-        AbsR[i][j] = Math.abs(R[i][j]) + epsilon;
-      }
-    }
-    let ra, rb;
-    for (let i = 0; i < 3; i++) {
-      ra = a.e[i];
-      rb = b.e[0] * AbsR[i][0] + b.e[1] * AbsR[i][1] + b.e[2] * AbsR[i][2];
-      if (Math.abs(t[i]) > ra + rb)
-        return false;
-    }
-    for (let i = 0; i < 3; i++) {
-      ra = a.e[0] * AbsR[0][i] + a.e[1] * AbsR[1][i] + a.e[2] * AbsR[2][i];
-      rb = b.e[i];
-      if (Math.abs(t[0] * R[0][i] + t[1] * R[1][i] + t[2] * R[2][i]) > ra + rb)
-        return false;
-    }
-    ra = a.e[1] * AbsR[2][0] + a.e[2] * AbsR[1][0];
-    rb = b.e[1] * AbsR[0][2] + b.e[2] * AbsR[0][1];
-    if (Math.abs(t[2] * R[1][0] - t[1] * R[2][0]) > ra + rb)
-      return false;
-    ra = a.e[1] * AbsR[2][1] + a.e[2] * AbsR[1][1];
-    rb = b.e[0] * AbsR[0][2] + b.e[2] * AbsR[0][0];
-    if (Math.abs(t[2] * R[1][1] - t[1] * R[2][1]) > ra + rb)
-      return false;
-    ra = a.e[1] * AbsR[2][2] + a.e[2] * AbsR[1][2];
-    rb = b.e[0] * AbsR[0][1] + b.e[1] * AbsR[0][0];
-    if (Math.abs(t[2] * R[1][2] - t[1] * R[2][2]) > ra + rb)
-      return false;
-    ra = a.e[0] * AbsR[2][0] + a.e[2] * AbsR[0][0];
-    rb = b.e[1] * AbsR[1][2] + b.e[2] * AbsR[1][1];
-    if (Math.abs(t[0] * R[2][0] - t[2] * R[0][0]) > ra + rb)
-      return false;
-    ra = a.e[0] * AbsR[2][1] + a.e[2] * AbsR[0][1];
-    rb = b.e[0] * AbsR[1][2] + b.e[2] * AbsR[1][0];
-    if (Math.abs(t[0] * R[2][1] - t[2] * R[0][1]) > ra + rb)
-      return false;
-    ra = a.e[0] * AbsR[2][2] + a.e[2] * AbsR[0][2];
-    rb = b.e[0] * AbsR[1][1] + b.e[1] * AbsR[1][0];
-    if (Math.abs(t[0] * R[2][2] - t[2] * R[0][2]) > ra + rb)
-      return false;
-    ra = a.e[0] * AbsR[1][0] + a.e[1] * AbsR[0][0];
-    rb = b.e[1] * AbsR[2][2] + b.e[2] * AbsR[2][1];
-    if (Math.abs(t[1] * R[0][0] - t[0] * R[1][0]) > ra + rb)
-      return false;
-    ra = a.e[0] * AbsR[1][1] + a.e[1] * AbsR[0][1];
-    rb = b.e[0] * AbsR[2][2] + b.e[2] * AbsR[2][0];
-    if (Math.abs(t[1] * R[0][1] - t[0] * R[1][1]) > ra + rb)
-      return false;
-    ra = a.e[0] * AbsR[1][2] + a.e[1] * AbsR[0][2];
-    rb = b.e[0] * AbsR[2][1] + b.e[1] * AbsR[2][0];
-    if (Math.abs(t[1] * R[0][2] - t[0] * R[1][2]) > ra + rb)
-      return false;
-    return true;
-  }
-  /**
-   * Reference: Testing Box Against Plane in Real-Time Collision Detection
-   * by Christer Ericson (chapter 5.2.3)
-   */
-  intersectsPlane(plane) {
-    this.rotation.extractBasis(xAxis, yAxis, zAxis);
-    const r = this.halfSize.x * Math.abs(plane.normal.dot(xAxis)) + this.halfSize.y * Math.abs(plane.normal.dot(yAxis)) + this.halfSize.z * Math.abs(plane.normal.dot(zAxis));
-    const d = plane.normal.dot(this.center) - plane.constant;
-    return Math.abs(d) <= r;
-  }
-  /**
-   * Performs a ray/OBB intersection test and stores the intersection point
-   * to the given 3D vector. If no intersection is detected, *null* is returned.
-   */
-  intersectRay(ray, result) {
-    this.getSize(size);
-    aabb.setFromCenterAndSize(v1.set(0, 0, 0), size);
-    matrix.setFromMatrix3(this.rotation);
-    matrix.setPosition(this.center);
-    inverse.copy(matrix).invert();
-    localRay.copy(ray).applyMatrix4(inverse);
-    if (localRay.intersectBox(aabb, result)) {
-      return result.applyMatrix4(matrix);
-    } else {
-      return null;
-    }
-  }
-  /**
-   * Performs a ray/OBB intersection test. Returns either true or false if
-   * there is a intersection or not.
-   */
-  intersectsRay(ray) {
-    return this.intersectRay(ray, v1) !== null;
-  }
-  fromBox3(box3) {
-    box3.getCenter(this.center);
-    box3.getSize(this.halfSize).multiplyScalar(0.5);
-    this.rotation.identity();
-    return this;
-  }
-  equals(obb2) {
-    return obb2.center.equals(this.center) && obb2.halfSize.equals(this.halfSize) && obb2.rotation.equals(this.rotation);
-  }
-  applyMatrix4(matrix2) {
-    const e = matrix2.elements;
-    let sx = v1.set(e[0], e[1], e[2]).length();
-    const sy = v1.set(e[4], e[5], e[6]).length();
-    const sz = v1.set(e[8], e[9], e[10]).length();
-    const det = matrix2.determinant();
-    if (det < 0)
-      sx = -sx;
-    rotationMatrix.setFromMatrix4(matrix2);
-    const invSX = 1 / sx;
-    const invSY = 1 / sy;
-    const invSZ = 1 / sz;
-    rotationMatrix.elements[0] *= invSX;
-    rotationMatrix.elements[1] *= invSX;
-    rotationMatrix.elements[2] *= invSX;
-    rotationMatrix.elements[3] *= invSY;
-    rotationMatrix.elements[4] *= invSY;
-    rotationMatrix.elements[5] *= invSY;
-    rotationMatrix.elements[6] *= invSZ;
-    rotationMatrix.elements[7] *= invSZ;
-    rotationMatrix.elements[8] *= invSZ;
-    this.rotation.multiply(rotationMatrix);
-    this.halfSize.x *= sx;
-    this.halfSize.y *= sy;
-    this.halfSize.z *= sz;
-    v1.setFromMatrixPosition(matrix2);
-    this.center.add(v1);
-    return this;
-  }
-}
-const obb = /* @__PURE__ */ new OBB();
-export {
-  OBB
-};

package/math/Octree.cjs

@@ -1,273 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
-const Capsule = require("./Capsule.cjs");
-const _v1 = /* @__PURE__ */ new THREE.Vector3();
-const _v2 = /* @__PURE__ */ new THREE.Vector3();
-const _plane = /* @__PURE__ */ new THREE.Plane();
-const _line1 = /* @__PURE__ */ new THREE.Line3();
-const _line2 = /* @__PURE__ */ new THREE.Line3();
-const _sphere = /* @__PURE__ */ new THREE.Sphere();
-const _capsule = /* @__PURE__ */ new Capsule.Capsule();
-class Octree {
-  constructor(box) {
-    this.triangles = [];
-    this.box = box;
-    this.subTrees = [];
-  }
-  addTriangle(triangle) {
-    if (!this.bounds)
-      this.bounds = new THREE.Box3();
-    this.bounds.min.x = Math.min(this.bounds.min.x, triangle.a.x, triangle.b.x, triangle.c.x);
-    this.bounds.min.y = Math.min(this.bounds.min.y, triangle.a.y, triangle.b.y, triangle.c.y);
-    this.bounds.min.z = Math.min(this.bounds.min.z, triangle.a.z, triangle.b.z, triangle.c.z);
-    this.bounds.max.x = Math.max(this.bounds.max.x, triangle.a.x, triangle.b.x, triangle.c.x);
-    this.bounds.max.y = Math.max(this.bounds.max.y, triangle.a.y, triangle.b.y, triangle.c.y);
-    this.bounds.max.z = Math.max(this.bounds.max.z, triangle.a.z, triangle.b.z, triangle.c.z);
-    this.triangles.push(triangle);
-    return this;
-  }
-  calcBox() {
-    this.box = this.bounds.clone();
-    this.box.min.x -= 0.01;
-    this.box.min.y -= 0.01;
-    this.box.min.z -= 0.01;
-    return this;
-  }
-  split(level) {
-    if (!this.box)
-      return;
-    const subTrees = [];
-    const halfsize = _v2.copy(this.box.max).sub(this.box.min).multiplyScalar(0.5);
-    for (let x = 0; x < 2; x++) {
-      for (let y = 0; y < 2; y++) {
-        for (let z = 0; z < 2; z++) {
-          const box = new THREE.Box3();
-          const v = _v1.set(x, y, z);
-          box.min.copy(this.box.min).add(v.multiply(halfsize));
-          box.max.copy(box.min).add(halfsize);
-          subTrees.push(new Octree(box));
-        }
-      }
-    }
-    let triangle;
-    while (triangle = this.triangles.pop()) {
-      for (let i = 0; i < subTrees.length; i++) {
-        if (subTrees[i].box.intersectsTriangle(triangle)) {
-          subTrees[i].triangles.push(triangle);
-        }
-      }
-    }
-    for (let i = 0; i < subTrees.length; i++) {
-      const len = subTrees[i].triangles.length;
-      if (len > 8 && level < 16) {
-        subTrees[i].split(level + 1);
-      }
-      if (len !== 0) {
-        this.subTrees.push(subTrees[i]);
-      }
-    }
-    return this;
-  }
-  build() {
-    this.calcBox();
-    this.split(0);
-    return this;
-  }
-  getRayTriangles(ray, triangles) {
-    for (let i = 0; i < this.subTrees.length; i++) {
-      const subTree = this.subTrees[i];
-      if (!ray.intersectsBox(subTree.box))
-        continue;
-      if (subTree.triangles.length > 0) {
-        for (let j = 0; j < subTree.triangles.length; j++) {
-          if (triangles.indexOf(subTree.triangles[j]) === -1)
-            triangles.push(subTree.triangles[j]);
-        }
-      } else {
-        subTree.getRayTriangles(ray, triangles);
-      }
-    }
-    return triangles;
-  }
-  triangleCapsuleIntersect(capsule, triangle) {
-    triangle.getPlane(_plane);
-    const d1 = _plane.distanceToPoint(capsule.start) - capsule.radius;
-    const d2 = _plane.distanceToPoint(capsule.end) - capsule.radius;
-    if (d1 > 0 && d2 > 0 || d1 < -capsule.radius && d2 < -capsule.radius) {
-      return false;
-    }
-    const delta = Math.abs(d1 / (Math.abs(d1) + Math.abs(d2)));
-    const intersectPoint = _v1.copy(capsule.start).lerp(capsule.end, delta);
-    if (triangle.containsPoint(intersectPoint)) {
-      return { normal: _plane.normal.clone(), point: intersectPoint.clone(), depth: Math.abs(Math.min(d1, d2)) };
-    }
-    const r2 = capsule.radius * capsule.radius;
-    const line1 = _line1.set(capsule.start, capsule.end);
-    const lines = [
-      [triangle.a, triangle.b],
-      [triangle.b, triangle.c],
-      [triangle.c, triangle.a]
-    ];
-    for (let i = 0; i < lines.length; i++) {
-      const line2 = _line2.set(lines[i][0], lines[i][1]);
-      const [point1, point2] = capsule.lineLineMinimumPoints(line1, line2);
-      if (point1.distanceToSquared(point2) < r2) {
-        return {
-          normal: point1.clone().sub(point2).normalize(),
-          point: point2.clone(),
-          depth: capsule.radius - point1.distanceTo(point2)
-        };
-      }
-    }
-    return false;
-  }
-  triangleSphereIntersect(sphere, triangle) {
-    triangle.getPlane(_plane);
-    if (!sphere.intersectsPlane(_plane))
-      return false;
-    const depth = Math.abs(_plane.distanceToSphere(sphere));
-    const r2 = sphere.radius * sphere.radius - depth * depth;
-    const plainPoint = _plane.projectPoint(sphere.center, _v1);
-    if (triangle.containsPoint(sphere.center)) {
-      return {
-        normal: _plane.normal.clone(),
-        point: plainPoint.clone(),
-        depth: Math.abs(_plane.distanceToSphere(sphere))
-      };
-    }
-    const lines = [
-      [triangle.a, triangle.b],
-      [triangle.b, triangle.c],
-      [triangle.c, triangle.a]
-    ];
-    for (let i = 0; i < lines.length; i++) {
-      _line1.set(lines[i][0], lines[i][1]);
-      _line1.closestPointToPoint(plainPoint, true, _v2);
-      const d = _v2.distanceToSquared(sphere.center);
-      if (d < r2) {
-        return {
-          normal: sphere.center.clone().sub(_v2).normalize(),
-          point: _v2.clone(),
-          depth: sphere.radius - Math.sqrt(d)
-        };
-      }
-    }
-    return false;
-  }
-  getSphereTriangles(sphere, triangles) {
-    for (let i = 0; i < this.subTrees.length; i++) {
-      const subTree = this.subTrees[i];
-      if (!sphere.intersectsBox(subTree.box))
-        continue;
-      if (subTree.triangles.length > 0) {
-        for (let j = 0; j < subTree.triangles.length; j++) {
-          if (triangles.indexOf(subTree.triangles[j]) === -1)
-            triangles.push(subTree.triangles[j]);
-        }
-      } else {
-        subTree.getSphereTriangles(sphere, triangles);
-      }
-    }
-  }
-  getCapsuleTriangles(capsule, triangles) {
-    for (let i = 0; i < this.subTrees.length; i++) {
-      const subTree = this.subTrees[i];
-      if (!capsule.intersectsBox(subTree.box))
-        continue;
-      if (subTree.triangles.length > 0) {
-        for (let j = 0; j < subTree.triangles.length; j++) {
-          if (triangles.indexOf(subTree.triangles[j]) === -1)
-            triangles.push(subTree.triangles[j]);
-        }
-      } else {
-        subTree.getCapsuleTriangles(capsule, triangles);
-      }
-    }
-  }
-  sphereIntersect(sphere) {
-    _sphere.copy(sphere);
-    const triangles = [];
-    let result, hit = false;
-    this.getSphereTriangles(sphere, triangles);
-    for (let i = 0; i < triangles.length; i++) {
-      if (result = this.triangleSphereIntersect(_sphere, triangles[i])) {
-        hit = true;
-        _sphere.center.add(result.normal.multiplyScalar(result.depth));
-      }
-    }
-    if (hit) {
-      const collisionVector = _sphere.center.clone().sub(sphere.center);
-      const depth = collisionVector.length();
-      return { normal: collisionVector.normalize(), depth };
-    }
-    return false;
-  }
-  capsuleIntersect(capsule) {
-    _capsule.copy(capsule);
-    const triangles = [];
-    let result, hit = false;
-    this.getCapsuleTriangles(_capsule, triangles);
-    for (let i = 0; i < triangles.length; i++) {
-      if (result = this.triangleCapsuleIntersect(_capsule, triangles[i])) {
-        hit = true;
-        _capsule.translate(result.normal.multiplyScalar(result.depth));
-      }
-    }
-    if (hit) {
-      const collisionVector = _capsule.getCenter(new THREE.Vector3()).sub(capsule.getCenter(_v1));
-      const depth = collisionVector.length();
-      return { normal: collisionVector.normalize(), depth };
-    }
-    return false;
-  }
-  rayIntersect(ray) {
-    if (ray.direction.length() === 0)
-      return;
-    const triangles = [];
-    let triangle, position, distance = 1e100;
-    this.getRayTriangles(ray, triangles);
-    for (let i = 0; i < triangles.length; i++) {
-      const result = ray.intersectTriangle(triangles[i].a, triangles[i].b, triangles[i].c, true, _v1);
-      if (result) {
-        const newdistance = result.sub(ray.origin).length();
-        if (distance > newdistance) {
-          position = result.clone().add(ray.origin);
-          distance = newdistance;
-          triangle = triangles[i];
-        }
-      }
-    }
-    return distance < 1e100 ? { distance, triangle, position } : false;
-  }
-  fromGraphNode(group) {
-    group.updateWorldMatrix(true, true);
-    group.traverse((obj) => {
-      if (obj.isMesh === true) {
-        let geometry, isTemp = false;
-        if (obj.geometry.index !== null) {
-          isTemp = true;
-          geometry = obj.geometry.toNonIndexed();
-        } else {
-          geometry = obj.geometry;
-        }
-        const positionAttribute = geometry.getAttribute("position");
-        for (let i = 0; i < positionAttribute.count; i += 3) {
-          const v1 = new THREE.Vector3().fromBufferAttribute(positionAttribute, i);
-          const v2 = new THREE.Vector3().fromBufferAttribute(positionAttribute, i + 1);
-          const v3 = new THREE.Vector3().fromBufferAttribute(positionAttribute, i + 2);
-          v1.applyMatrix4(obj.matrixWorld);
-          v2.applyMatrix4(obj.matrixWorld);
-          v3.applyMatrix4(obj.matrixWorld);
-          this.addTriangle(new THREE.Triangle(v1, v2, v3));
-        }
-        if (isTemp) {
-          geometry.dispose();
-        }
-      }
-    });
-    this.build();
-    return this;
-  }
-}
-exports.Octree = Octree;