three-stdlib 2.22.7 → 2.22.8

package/dist/math/Lut.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+var Lut = function(colormap, numberofcolors) {
+  this.lut = [];
+  this.setColorMap(colormap, numberofcolors);
+  return this;
+};
+Lut.prototype = {
+  constructor: Lut,
+  lut: [],
+  map: [],
+  n: 256,
+  minV: 0,
+  maxV: 1,
+  set: function(value) {
+    if (value instanceof Lut) {
+      this.copy(value);
+    }
+    return this;
+  },
+  setMin: function(min) {
+    this.minV = min;
+    return this;
+  },
+  setMax: function(max) {
+    this.maxV = max;
+    return this;
+  },
+  setColorMap: function(colormap, numberofcolors) {
+    this.map = ColorMapKeywords[colormap] || ColorMapKeywords.rainbow;
+    this.n = numberofcolors || 32;
+    var step = 1 / this.n;
+    this.lut.length = 0;
+    for (let i = 0; i <= 1; i += step) {
+      for (let j = 0; j < this.map.length - 1; j++) {
+        if (i >= this.map[j][0] && i < this.map[j + 1][0]) {
+          var min = this.map[j][0];
+          var max = this.map[j + 1][0];
+          var minColor = new THREE.Color(this.map[j][1]);
+          var maxColor = new THREE.Color(this.map[j + 1][1]);
+          var color = minColor.lerp(maxColor, (i - min) / (max - min));
+          this.lut.push(color);
+        }
+      }
+    }
+    return this;
+  },
+  copy: function(lut) {
+    this.lut = lut.lut;
+    this.map = lut.map;
+    this.n = lut.n;
+    this.minV = lut.minV;
+    this.maxV = lut.maxV;
+    return this;
+  },
+  getColor: function(alpha) {
+    if (alpha <= this.minV) {
+      alpha = this.minV;
+    } else if (alpha >= this.maxV) {
+      alpha = this.maxV;
+    }
+    alpha = (alpha - this.minV) / (this.maxV - this.minV);
+    var colorPosition = Math.round(alpha * this.n);
+    colorPosition == this.n ? colorPosition -= 1 : colorPosition;
+    return this.lut[colorPosition];
+  },
+  addColorMap: function(colormapName, arrayOfColors) {
+    ColorMapKeywords[colormapName] = arrayOfColors;
+  },
+  createCanvas: function() {
+    var canvas = document.createElement("canvas");
+    canvas.width = 1;
+    canvas.height = this.n;
+    this.updateCanvas(canvas);
+    return canvas;
+  },
+  updateCanvas: function(canvas) {
+    var ctx = canvas.getContext("2d", { alpha: false });
+    var imageData = ctx.getImageData(0, 0, 1, this.n);
+    var data = imageData.data;
+    var k = 0;
+    var step = 1 / this.n;
+    for (let i = 1; i >= 0; i -= step) {
+      for (let j = this.map.length - 1; j >= 0; j--) {
+        if (i < this.map[j][0] && i >= this.map[j - 1][0]) {
+          var min = this.map[j - 1][0];
+          var max = this.map[j][0];
+          var minColor = new THREE.Color(this.map[j - 1][1]);
+          var maxColor = new THREE.Color(this.map[j][1]);
+          var color = minColor.lerp(maxColor, (i - min) / (max - min));
+          data[k * 4] = Math.round(color.r * 255);
+          data[k * 4 + 1] = Math.round(color.g * 255);
+          data[k * 4 + 2] = Math.round(color.b * 255);
+          data[k * 4 + 3] = 255;
+          k += 1;
+        }
+      }
+    }
+    ctx.putImageData(imageData, 0, 0);
+    return canvas;
+  }
+};
+var ColorMapKeywords = {
+  rainbow: [
+    [0, 255],
+    [0.2, 65535],
+    [0.5, 65280],
+    [0.8, 16776960],
+    [1, 16711680]
+  ],
+  cooltowarm: [
+    [0, 3952322],
+    [0.2, 10206463],
+    [0.5, 14474460],
+    [0.8, 16163717],
+    [1, 11797542]
+  ],
+  blackbody: [
+    [0, 0],
+    [0.2, 7864320],
+    [0.5, 15086080],
+    [0.8, 16776960],
+    [1, 16777215]
+  ],
+  grayscale: [
+    [0, 0],
+    [0.2, 4210752],
+    [0.5, 8355712],
+    [0.8, 12566463],
+    [1, 16777215]
+  ]
+};
+exports.ColorMapKeywords = ColorMapKeywords;
+exports.Lut = Lut;

package/dist/math/Lut.mjs

@@ -0,0 +1,135 @@
+import { Color } from "three";
+var Lut = function(colormap, numberofcolors) {
+  this.lut = [];
+  this.setColorMap(colormap, numberofcolors);
+  return this;
+};
+Lut.prototype = {
+  constructor: Lut,
+  lut: [],
+  map: [],
+  n: 256,
+  minV: 0,
+  maxV: 1,
+  set: function(value) {
+    if (value instanceof Lut) {
+      this.copy(value);
+    }
+    return this;
+  },
+  setMin: function(min) {
+    this.minV = min;
+    return this;
+  },
+  setMax: function(max) {
+    this.maxV = max;
+    return this;
+  },
+  setColorMap: function(colormap, numberofcolors) {
+    this.map = ColorMapKeywords[colormap] || ColorMapKeywords.rainbow;
+    this.n = numberofcolors || 32;
+    var step = 1 / this.n;
+    this.lut.length = 0;
+    for (let i = 0; i <= 1; i += step) {
+      for (let j = 0; j < this.map.length - 1; j++) {
+        if (i >= this.map[j][0] && i < this.map[j + 1][0]) {
+          var min = this.map[j][0];
+          var max = this.map[j + 1][0];
+          var minColor = new Color(this.map[j][1]);
+          var maxColor = new Color(this.map[j + 1][1]);
+          var color = minColor.lerp(maxColor, (i - min) / (max - min));
+          this.lut.push(color);
+        }
+      }
+    }
+    return this;
+  },
+  copy: function(lut) {
+    this.lut = lut.lut;
+    this.map = lut.map;
+    this.n = lut.n;
+    this.minV = lut.minV;
+    this.maxV = lut.maxV;
+    return this;
+  },
+  getColor: function(alpha) {
+    if (alpha <= this.minV) {
+      alpha = this.minV;
+    } else if (alpha >= this.maxV) {
+      alpha = this.maxV;
+    }
+    alpha = (alpha - this.minV) / (this.maxV - this.minV);
+    var colorPosition = Math.round(alpha * this.n);
+    colorPosition == this.n ? colorPosition -= 1 : colorPosition;
+    return this.lut[colorPosition];
+  },
+  addColorMap: function(colormapName, arrayOfColors) {
+    ColorMapKeywords[colormapName] = arrayOfColors;
+  },
+  createCanvas: function() {
+    var canvas = document.createElement("canvas");
+    canvas.width = 1;
+    canvas.height = this.n;
+    this.updateCanvas(canvas);
+    return canvas;
+  },
+  updateCanvas: function(canvas) {
+    var ctx = canvas.getContext("2d", { alpha: false });
+    var imageData = ctx.getImageData(0, 0, 1, this.n);
+    var data = imageData.data;
+    var k = 0;
+    var step = 1 / this.n;
+    for (let i = 1; i >= 0; i -= step) {
+      for (let j = this.map.length - 1; j >= 0; j--) {
+        if (i < this.map[j][0] && i >= this.map[j - 1][0]) {
+          var min = this.map[j - 1][0];
+          var max = this.map[j][0];
+          var minColor = new Color(this.map[j - 1][1]);
+          var maxColor = new Color(this.map[j][1]);
+          var color = minColor.lerp(maxColor, (i - min) / (max - min));
+          data[k * 4] = Math.round(color.r * 255);
+          data[k * 4 + 1] = Math.round(color.g * 255);
+          data[k * 4 + 2] = Math.round(color.b * 255);
+          data[k * 4 + 3] = 255;
+          k += 1;
+        }
+      }
+    }
+    ctx.putImageData(imageData, 0, 0);
+    return canvas;
+  }
+};
+var ColorMapKeywords = {
+  rainbow: [
+    [0, 255],
+    [0.2, 65535],
+    [0.5, 65280],
+    [0.8, 16776960],
+    [1, 16711680]
+  ],
+  cooltowarm: [
+    [0, 3952322],
+    [0.2, 10206463],
+    [0.5, 14474460],
+    [0.8, 16163717],
+    [1, 11797542]
+  ],
+  blackbody: [
+    [0, 0],
+    [0.2, 7864320],
+    [0.5, 15086080],
+    [0.8, 16776960],
+    [1, 16777215]
+  ],
+  grayscale: [
+    [0, 0],
+    [0.2, 4210752],
+    [0.5, 8355712],
+    [0.8, 12566463],
+    [1, 16777215]
+  ]
+};
+export {
+  ColorMapKeywords,
+  Lut
+};

package/dist/math/MeshSurfaceSampler.d.ts

@@ -0,0 +1,15 @@
+import { BufferGeometry, Color, Mesh, Vector3 } from 'three'
+
+export class MeshSurfaceSampler {
+  distribution: Float32Array | null
+  geometry: BufferGeometry
+  positionAttribute: Float32Array
+  weightAttribute: string | null
+
+  constructor(mesh: Mesh)
+  binarySearch(x: number): number
+  build(): this
+  sample(targetPosition: Vector3, targetNormal?: Vector3, targetColor?: Color): this
+  sampleFace(faceIndex: number, targetPosition: Vector3, targetNormal?: Vector3, targetColor?: Color): this
+  setWeightAttribute(name: string | null): this
+}

package/dist/math/MeshSurfaceSampler.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+var MeshSurfaceSampler = function() {
+  var _face = new THREE.Triangle();
+  var _color = new THREE.Vector3();
+  function MeshSurfaceSampler2(mesh) {
+    var geometry = mesh.geometry;
+    if (!geometry.isBufferGeometry || geometry.attributes.position.itemSize !== 3) {
+      throw new Error("THREE.MeshSurfaceSampler: Requires BufferGeometry triangle mesh.");
+    }
+    if (geometry.index) {
+      console.warn("THREE.MeshSurfaceSampler: Converting geometry to non-indexed BufferGeometry.");
+      geometry = geometry.toNonIndexed();
+    }
+    this.geometry = geometry;
+    this.randomFunction = Math.random;
+    this.positionAttribute = this.geometry.getAttribute("position");
+    this.colorAttribute = this.geometry.getAttribute("color");
+    this.weightAttribute = null;
+    this.distribution = null;
+  }
+  MeshSurfaceSampler2.prototype = {
+    constructor: MeshSurfaceSampler2,
+    setWeightAttribute: function(name) {
+      this.weightAttribute = name ? this.geometry.getAttribute(name) : null;
+      return this;
+    },
+    build: function() {
+      var positionAttribute = this.positionAttribute;
+      var weightAttribute = this.weightAttribute;
+      var faceWeights = new Float32Array(positionAttribute.count / 3);
+      for (let i = 0; i < positionAttribute.count; i += 3) {
+        var faceWeight = 1;
+        if (weightAttribute) {
+          faceWeight = weightAttribute.getX(i) + weightAttribute.getX(i + 1) + weightAttribute.getX(i + 2);
+        }
+        _face.a.fromBufferAttribute(positionAttribute, i);
+        _face.b.fromBufferAttribute(positionAttribute, i + 1);
+        _face.c.fromBufferAttribute(positionAttribute, i + 2);
+        faceWeight *= _face.getArea();
+        faceWeights[i / 3] = faceWeight;
+      }
+      this.distribution = new Float32Array(positionAttribute.count / 3);
+      var cumulativeTotal = 0;
+      for (let i = 0; i < faceWeights.length; i++) {
+        cumulativeTotal += faceWeights[i];
+        this.distribution[i] = cumulativeTotal;
+      }
+      return this;
+    },
+    setRandomGenerator: function(randomFunction) {
+      this.randomFunction = randomFunction;
+      return this;
+    },
+    sample: function(targetPosition, targetNormal, targetColor) {
+      var cumulativeTotal = this.distribution[this.distribution.length - 1];
+      var faceIndex = this.binarySearch(this.randomFunction() * cumulativeTotal);
+      return this.sampleFace(faceIndex, targetPosition, targetNormal, targetColor);
+    },
+    binarySearch: function(x) {
+      var dist = this.distribution;
+      var start = 0;
+      var end = dist.length - 1;
+      var index = -1;
+      while (start <= end) {
+        var mid = Math.ceil((start + end) / 2);
+        if (mid === 0 || dist[mid - 1] <= x && dist[mid] > x) {
+          index = mid;
+          break;
+        } else if (x < dist[mid]) {
+          end = mid - 1;
+        } else {
+          start = mid + 1;
+        }
+      }
+      return index;
+    },
+    sampleFace: function(faceIndex, targetPosition, targetNormal, targetColor) {
+      var u = this.randomFunction();
+      var v = this.randomFunction();
+      if (u + v > 1) {
+        u = 1 - u;
+        v = 1 - v;
+      }
+      _face.a.fromBufferAttribute(this.positionAttribute, faceIndex * 3);
+      _face.b.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 1);
+      _face.c.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 2);
+      targetPosition.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
+      if (targetNormal !== void 0) {
+        _face.getNormal(targetNormal);
+      }
+      if (targetColor !== void 0 && this.colorAttribute !== void 0) {
+        _face.a.fromBufferAttribute(this.colorAttribute, faceIndex * 3);
+        _face.b.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 1);
+        _face.c.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 2);
+        _color.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
+        targetColor.r = _color.x;
+        targetColor.g = _color.y;
+        targetColor.b = _color.z;
+      }
+      return this;
+    }
+  };
+  return MeshSurfaceSampler2;
+}();
+exports.MeshSurfaceSampler = MeshSurfaceSampler;

package/dist/math/MeshSurfaceSampler.mjs

@@ -0,0 +1,107 @@
+import { Triangle, Vector3 } from "three";
+var MeshSurfaceSampler = function() {
+  var _face = new Triangle();
+  var _color = new Vector3();
+  function MeshSurfaceSampler2(mesh) {
+    var geometry = mesh.geometry;
+    if (!geometry.isBufferGeometry || geometry.attributes.position.itemSize !== 3) {
+      throw new Error("THREE.MeshSurfaceSampler: Requires BufferGeometry triangle mesh.");
+    }
+    if (geometry.index) {
+      console.warn("THREE.MeshSurfaceSampler: Converting geometry to non-indexed BufferGeometry.");
+      geometry = geometry.toNonIndexed();
+    }
+    this.geometry = geometry;
+    this.randomFunction = Math.random;
+    this.positionAttribute = this.geometry.getAttribute("position");
+    this.colorAttribute = this.geometry.getAttribute("color");
+    this.weightAttribute = null;
+    this.distribution = null;
+  }
+  MeshSurfaceSampler2.prototype = {
+    constructor: MeshSurfaceSampler2,
+    setWeightAttribute: function(name) {
+      this.weightAttribute = name ? this.geometry.getAttribute(name) : null;
+      return this;
+    },
+    build: function() {
+      var positionAttribute = this.positionAttribute;
+      var weightAttribute = this.weightAttribute;
+      var faceWeights = new Float32Array(positionAttribute.count / 3);
+      for (let i = 0; i < positionAttribute.count; i += 3) {
+        var faceWeight = 1;
+        if (weightAttribute) {
+          faceWeight = weightAttribute.getX(i) + weightAttribute.getX(i + 1) + weightAttribute.getX(i + 2);
+        }
+        _face.a.fromBufferAttribute(positionAttribute, i);
+        _face.b.fromBufferAttribute(positionAttribute, i + 1);
+        _face.c.fromBufferAttribute(positionAttribute, i + 2);
+        faceWeight *= _face.getArea();
+        faceWeights[i / 3] = faceWeight;
+      }
+      this.distribution = new Float32Array(positionAttribute.count / 3);
+      var cumulativeTotal = 0;
+      for (let i = 0; i < faceWeights.length; i++) {
+        cumulativeTotal += faceWeights[i];
+        this.distribution[i] = cumulativeTotal;
+      }
+      return this;
+    },
+    setRandomGenerator: function(randomFunction) {
+      this.randomFunction = randomFunction;
+      return this;
+    },
+    sample: function(targetPosition, targetNormal, targetColor) {
+      var cumulativeTotal = this.distribution[this.distribution.length - 1];
+      var faceIndex = this.binarySearch(this.randomFunction() * cumulativeTotal);
+      return this.sampleFace(faceIndex, targetPosition, targetNormal, targetColor);
+    },
+    binarySearch: function(x) {
+      var dist = this.distribution;
+      var start = 0;
+      var end = dist.length - 1;
+      var index = -1;
+      while (start <= end) {
+        var mid = Math.ceil((start + end) / 2);
+        if (mid === 0 || dist[mid - 1] <= x && dist[mid] > x) {
+          index = mid;
+          break;
+        } else if (x < dist[mid]) {
+          end = mid - 1;
+        } else {
+          start = mid + 1;
+        }
+      }
+      return index;
+    },
+    sampleFace: function(faceIndex, targetPosition, targetNormal, targetColor) {
+      var u = this.randomFunction();
+      var v = this.randomFunction();
+      if (u + v > 1) {
+        u = 1 - u;
+        v = 1 - v;
+      }
+      _face.a.fromBufferAttribute(this.positionAttribute, faceIndex * 3);
+      _face.b.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 1);
+      _face.c.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 2);
+      targetPosition.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
+      if (targetNormal !== void 0) {
+        _face.getNormal(targetNormal);
+      }
+      if (targetColor !== void 0 && this.colorAttribute !== void 0) {
+        _face.a.fromBufferAttribute(this.colorAttribute, faceIndex * 3);
+        _face.b.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 1);
+        _face.c.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 2);
+        _color.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
+        targetColor.r = _color.x;
+        targetColor.g = _color.y;
+        targetColor.b = _color.z;
+      }
+      return this;
+    }
+  };
+  return MeshSurfaceSampler2;
+}();
+export {
+  MeshSurfaceSampler
+};

package/dist/math/OBB.d.ts

@@ -0,0 +1,24 @@
+import { Box3, Matrix3, Matrix4, Plane, Ray, Sphere, Vector3 } from 'three'
+
+export class OBB {
+  center: Vector3
+  halfSize: Vector3
+  rotation: Matrix3
+
+  constructor(center?: Vector3, halfSize?: Vector3, rotation?: Matrix3)
+  set(center: Vector3, halfSize: Vector3, rotation: Matrix3): this
+  copy(obb: OBB): this
+  clone(): this
+  getSize(result: Vector3): Vector3
+  clampPoint(point: Vector3, result: Vector3): Vector3
+  containsPoint(point: Vector3): boolean
+  intersectsBox3(box3: Box3): boolean
+  intersectsSphere(sphere: Sphere): boolean
+  intersectsOBB(obb: OBB, epsilon?: number): boolean
+  intersectsPlane(plane: Plane): boolean
+  intersectRay(ray: Ray, result: Vector3): Vector3 | null
+  intersectsRay(ray: Ray): boolean
+  fromBox3(box3: Box3): this
+  equals(obb: OBB): boolean
+  applyMatrix4(matrix: Matrix4): this
+}