three-stdlib 2.22.7 → 2.22.9

package/dist/math/Capsule.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+var Capsule = function() {
+  var _v1 = new THREE.Vector3();
+  var _v2 = new THREE.Vector3();
+  var _v3 = new THREE.Vector3();
+  var EPS = 1e-10;
+  function Capsule2(start, end, radius) {
+    this.start = start == void 0 ? new THREE.Vector3(0, 0, 0) : start;
+    this.end = end == void 0 ? new THREE.Vector3(0, 1, 0) : end;
+    this.radius = radius == void 0 ? 1 : radius;
+  }
+  Object.assign(Capsule2.prototype, {
+    clone: function() {
+      return new Capsule2(this.start.clone(), this.end.clone(), this.radius);
+    },
+    set: function(start, end, radius) {
+      this.start.copy(start);
+      this.end.copy(end);
+      this.radius = radius;
+    },
+    copy: function(capsule) {
+      this.start.copy(capsule.start);
+      this.end.copy(capsule.end);
+      this.radius = capsule.radius;
+    },
+    getCenter: function(target) {
+      return target.copy(this.end).add(this.start).multiplyScalar(0.5);
+    },
+    translate: function(v) {
+      this.start.add(v);
+      this.end.add(v);
+    },
+    checkAABBAxis: function(p1x, p1y, p2x, p2y, minx, maxx, miny, maxy, radius) {
+      return (minx - p1x < radius || minx - p2x < radius) && (p1x - maxx < radius || p2x - maxx < radius) && (miny - p1y < radius || miny - p2y < radius) && (p1y - maxy < radius || p2y - maxy < radius);
+    },
+    intersectsBox: function(box) {
+      return this.checkAABBAxis(
+        this.start.x,
+        this.start.y,
+        this.end.x,
+        this.end.y,
+        box.min.x,
+        box.max.x,
+        box.min.y,
+        box.max.y,
+        this.radius
+      ) && this.checkAABBAxis(
+        this.start.x,
+        this.start.z,
+        this.end.x,
+        this.end.z,
+        box.min.x,
+        box.max.x,
+        box.min.z,
+        box.max.z,
+        this.radius
+      ) && this.checkAABBAxis(
+        this.start.y,
+        this.start.z,
+        this.end.y,
+        this.end.z,
+        box.min.y,
+        box.max.y,
+        box.min.z,
+        box.max.z,
+        this.radius
+      );
+    },
+    lineLineMinimumPoints: function(line1, line2) {
+      var r = _v1.copy(line1.end).sub(line1.start);
+      var s = _v2.copy(line2.end).sub(line2.start);
+      var w = _v3.copy(line2.start).sub(line1.start);
+      var a = r.dot(s), b = r.dot(r), c = s.dot(s), d = s.dot(w), e = r.dot(w);
+      var t1, t2, divisor = b * c - a * a;
+      if (Math.abs(divisor) < EPS) {
+        var d1 = -d / c;
+        var d2 = (a - d) / c;
+        if (Math.abs(d1 - 0.5) < Math.abs(d2 - 0.5)) {
+          t1 = 0;
+          t2 = d1;
+        } else {
+          t1 = 1;
+          t2 = d2;
+        }
+      } else {
+        t1 = (d * a + e * c) / divisor;
+        t2 = (t1 * a - d) / c;
+      }
+      t2 = Math.max(0, Math.min(1, t2));
+      t1 = Math.max(0, Math.min(1, t1));
+      var point1 = r.multiplyScalar(t1).add(line1.start);
+      var point2 = s.multiplyScalar(t2).add(line2.start);
+      return [point1, point2];
+    }
+  });
+  return Capsule2;
+}();
+exports.Capsule = Capsule;

package/dist/math/Capsule.mjs

@@ -0,0 +1,100 @@
+import { Vector3 } from "three";
+var Capsule = function() {
+  var _v1 = new Vector3();
+  var _v2 = new Vector3();
+  var _v3 = new Vector3();
+  var EPS = 1e-10;
+  function Capsule2(start, end, radius) {
+    this.start = start == void 0 ? new Vector3(0, 0, 0) : start;
+    this.end = end == void 0 ? new Vector3(0, 1, 0) : end;
+    this.radius = radius == void 0 ? 1 : radius;
+  }
+  Object.assign(Capsule2.prototype, {
+    clone: function() {
+      return new Capsule2(this.start.clone(), this.end.clone(), this.radius);
+    },
+    set: function(start, end, radius) {
+      this.start.copy(start);
+      this.end.copy(end);
+      this.radius = radius;
+    },
+    copy: function(capsule) {
+      this.start.copy(capsule.start);
+      this.end.copy(capsule.end);
+      this.radius = capsule.radius;
+    },
+    getCenter: function(target) {
+      return target.copy(this.end).add(this.start).multiplyScalar(0.5);
+    },
+    translate: function(v) {
+      this.start.add(v);
+      this.end.add(v);
+    },
+    checkAABBAxis: function(p1x, p1y, p2x, p2y, minx, maxx, miny, maxy, radius) {
+      return (minx - p1x < radius || minx - p2x < radius) && (p1x - maxx < radius || p2x - maxx < radius) && (miny - p1y < radius || miny - p2y < radius) && (p1y - maxy < radius || p2y - maxy < radius);
+    },
+    intersectsBox: function(box) {
+      return this.checkAABBAxis(
+        this.start.x,
+        this.start.y,
+        this.end.x,
+        this.end.y,
+        box.min.x,
+        box.max.x,
+        box.min.y,
+        box.max.y,
+        this.radius
+      ) && this.checkAABBAxis(
+        this.start.x,
+        this.start.z,
+        this.end.x,
+        this.end.z,
+        box.min.x,
+        box.max.x,
+        box.min.z,
+        box.max.z,
+        this.radius
+      ) && this.checkAABBAxis(
+        this.start.y,
+        this.start.z,
+        this.end.y,
+        this.end.z,
+        box.min.y,
+        box.max.y,
+        box.min.z,
+        box.max.z,
+        this.radius
+      );
+    },
+    lineLineMinimumPoints: function(line1, line2) {
+      var r = _v1.copy(line1.end).sub(line1.start);
+      var s = _v2.copy(line2.end).sub(line2.start);
+      var w = _v3.copy(line2.start).sub(line1.start);
+      var a = r.dot(s), b = r.dot(r), c = s.dot(s), d = s.dot(w), e = r.dot(w);
+      var t1, t2, divisor = b * c - a * a;
+      if (Math.abs(divisor) < EPS) {
+        var d1 = -d / c;
+        var d2 = (a - d) / c;
+        if (Math.abs(d1 - 0.5) < Math.abs(d2 - 0.5)) {
+          t1 = 0;
+          t2 = d1;
+        } else {
+          t1 = 1;
+          t2 = d2;
+        }
+      } else {
+        t1 = (d * a + e * c) / divisor;
+        t2 = (t1 * a - d) / c;
+      }
+      t2 = Math.max(0, Math.min(1, t2));
+      t1 = Math.max(0, Math.min(1, t1));
+      var point1 = r.multiplyScalar(t1).add(line1.start);
+      var point2 = s.multiplyScalar(t2).add(line2.start);
+      return [point1, point2];
+    }
+  });
+  return Capsule2;
+}();
+export {
+  Capsule
+};

package/dist/math/ColorConverter.d.ts

@@ -0,0 +1,21 @@
+import { Color } from 'three'
+
+export interface HSL {
+  h: number
+  s: number
+  l: number
+}
+
+export interface CMYK {
+  c: number
+  m: number
+  y: number
+  k: number
+}
+
+export namespace ColorConverter {
+  function setHSV(color: Color, h: number, s: number, v: number): Color
+  function getHSV(color: Color, target: HSL): HSL
+  function setCMYK(color: Color, c: number, m: number, y: number, k: number): Color
+  function getCMYK(color: Color, target: CMYK): CMYK
+}

package/dist/math/ColorConverter.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+var ColorConverter = {
+  setHSV: function(color, h, s, v) {
+    h = THREE.MathUtils.euclideanModulo(h, 1);
+    s = THREE.MathUtils.clamp(s, 0, 1);
+    v = THREE.MathUtils.clamp(v, 0, 1);
+    return color.setHSL(h, s * v / ((h = (2 - s) * v) < 1 ? h : 2 - h), h * 0.5);
+  },
+  getHSV: function() {
+    var hsl = {};
+    return function getHSV(color, target) {
+      if (target === void 0) {
+        console.warn("THREE.ColorConverter: .getHSV() target is now required");
+        target = { h: 0, s: 0, l: 0 };
+      }
+      color.getHSL(hsl);
+      hsl.s *= hsl.l < 0.5 ? hsl.l : 1 - hsl.l;
+      target.h = hsl.h;
+      target.s = 2 * hsl.s / (hsl.l + hsl.s);
+      target.v = hsl.l + hsl.s;
+      return target;
+    };
+  }(),
+  // where c, m, y, k is between 0 and 1
+  setCMYK: function(color, c, m, y, k) {
+    var r = (1 - c) * (1 - k);
+    var g = (1 - m) * (1 - k);
+    var b = (1 - y) * (1 - k);
+    return color.setRGB(r, g, b);
+  },
+  getCMYK: function(color, target) {
+    if (target === void 0) {
+      console.warn("THREE.ColorConverter: .getCMYK() target is now required");
+      target = { c: 0, m: 0, y: 0, k: 0 };
+    }
+    var r = color.r;
+    var g = color.g;
+    var b = color.b;
+    var k = 1 - Math.max(r, g, b);
+    var c = (1 - r - k) / (1 - k);
+    var m = (1 - g - k) / (1 - k);
+    var y = (1 - b - k) / (1 - k);
+    target.c = c;
+    target.m = m;
+    target.y = y;
+    target.k = k;
+    return target;
+  }
+};
+exports.ColorConverter = ColorConverter;

package/dist/math/ColorConverter.mjs

@@ -0,0 +1,52 @@
+import { MathUtils } from "three";
+var ColorConverter = {
+  setHSV: function(color, h, s, v) {
+    h = MathUtils.euclideanModulo(h, 1);
+    s = MathUtils.clamp(s, 0, 1);
+    v = MathUtils.clamp(v, 0, 1);
+    return color.setHSL(h, s * v / ((h = (2 - s) * v) < 1 ? h : 2 - h), h * 0.5);
+  },
+  getHSV: function() {
+    var hsl = {};
+    return function getHSV(color, target) {
+      if (target === void 0) {
+        console.warn("THREE.ColorConverter: .getHSV() target is now required");
+        target = { h: 0, s: 0, l: 0 };
+      }
+      color.getHSL(hsl);
+      hsl.s *= hsl.l < 0.5 ? hsl.l : 1 - hsl.l;
+      target.h = hsl.h;
+      target.s = 2 * hsl.s / (hsl.l + hsl.s);
+      target.v = hsl.l + hsl.s;
+      return target;
+    };
+  }(),
+  // where c, m, y, k is between 0 and 1
+  setCMYK: function(color, c, m, y, k) {
+    var r = (1 - c) * (1 - k);
+    var g = (1 - m) * (1 - k);
+    var b = (1 - y) * (1 - k);
+    return color.setRGB(r, g, b);
+  },
+  getCMYK: function(color, target) {
+    if (target === void 0) {
+      console.warn("THREE.ColorConverter: .getCMYK() target is now required");
+      target = { c: 0, m: 0, y: 0, k: 0 };
+    }
+    var r = color.r;
+    var g = color.g;
+    var b = color.b;
+    var k = 1 - Math.max(r, g, b);
+    var c = (1 - r - k) / (1 - k);
+    var m = (1 - g - k) / (1 - k);
+    var y = (1 - b - k) / (1 - k);
+    target.c = c;
+    target.m = m;
+    target.y = y;
+    target.k = k;
+    return target;
+  }
+};
+export {
+  ColorConverter
+};

package/dist/math/ConvexHull.d.ts

@@ -0,0 +1,89 @@
+import { Object3D, Ray, Vector3 } from 'three'
+
+export class Face {
+  constructor()
+  normal: Vector3
+  midpoint: Vector3
+  area: number
+  constant: number
+  outside: VertexNode
+  mark: number
+  edge: HalfEdge
+
+  static create(a: VertexNode, b: VertexNode, c: VertexNode): Face
+
+  compute(): this
+  getEdge(i: number): HalfEdge
+}
+
+export class HalfEdge {
+  constructor(vertex: VertexNode, face: Face)
+  vertex: VertexNode
+  prev: HalfEdge
+  next: HalfEdge
+  twin: HalfEdge
+  face: Face
+
+  head(): VertexNode
+  length(): number
+  lengthSquared(): number
+  setTwin(edge: HalfEdge): this
+  tail(): VertexNode
+}
+
+export class VertexNode {
+  constructor(point: Vector3)
+  point: Vector3
+  prev: VertexNode
+  next: VertexNode
+  face: Face
+}
+
+export class VertexList {
+  constructor()
+  head: VertexNode
+  tail: VertexNode
+
+  append(vertex: VertexNode): this
+  appendChain(vertex: VertexNode): this
+  clear(): this
+  first(): VertexNode
+  insertAfter(target: VertexNode, vertex: VertexNode): this
+  insertBefore(target: VertexNode, vertex: VertexNode): this
+  isEmpty(): boolean
+  last(): VertexNode
+  remove(vertex: VertexNode): this
+  removeSubList(a: VertexNode, b: VertexNode): this
+}
+
+export class ConvexHull {
+  constructor()
+  tolerance: number
+  faces: Face[]
+  newFaces: Face[]
+  assigned: VertexList
+  unassigned: VertexList
+  vertices: VertexNode[]
+
+  addAdjoiningFace(eyeVertex: VertexNode, horizonEdge: HalfEdge): HalfEdge
+  addNewFaces(eyeVertex: VertexNode, horizon: HalfEdge[]): this
+  addVertexToFace(vertex: VertexNode, face: Face): this
+  addVertexToHull(eyeVertex: VertexNode): this
+  cleanup(): this
+  compute(): this
+  computeExtremes(): object
+  computeHorizon(eyePoint: Vector3, crossEdge: HalfEdge, face: Face, horizon: HalfEdge[]): this
+  computeInitialHull(): this
+  containsPoint(point: Vector3): boolean
+  deleteFaceVertices(face: Face, absorbingFace: Face): this
+  intersectRay(ray: Ray, target: Vector3): Vector3 | null
+  intersectsRay(ray: Ray): boolean
+  makeEmpty(): this
+  nextVertexToAdd(): VertexNode | undefined
+  reindexFaces(): this
+  removeAllVerticesFromFace(face: Face): VertexNode | undefined
+  removeVertexFromFace(vertex: VertexNode, face: Face): this
+  resolveUnassignedPoints(newFaces: Face[]): this
+  setFromPoints(points: Vector3[]): this
+  setFromObject(object: Object3D): this
+}