three-stdlib 2.22.9 → 2.23.0

package/dist/math/Lut.js

@@ -1,97 +1,99 @@
 "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) {
+class Lut {
+  constructor(colormap, count = 32) {
+    this.isLut = true;
+    this.lut = [];
+    this.map = [];
+    this.n = 0;
+    this.minV = 0;
+    this.maxV = 1;
+    this.setColorMap(colormap, count);
+  }
+  set(value) {
+    if (value.isLut === true) {
       this.copy(value);
     }
     return this;
-  },
-  setMin: function(min) {
+  }
+  setMin(min) {
     this.minV = min;
     return this;
-  },
-  setMax: function(max) {
+  }
+  setMax(max) {
     this.maxV = max;
     return this;
-  },
-  setColorMap: function(colormap, numberofcolors) {
+  }
+  setColorMap(colormap, count = 32) {
     this.map = ColorMapKeywords[colormap] || ColorMapKeywords.rainbow;
-    this.n = numberofcolors || 32;
-    var step = 1 / this.n;
+    this.n = count;
+    const step = 1 / this.n;
+    const minColor = new THREE.Color();
+    const maxColor = new THREE.Color();
     this.lut.length = 0;
-    for (let i = 0; i <= 1; i += step) {
+    this.lut.push(new THREE.Color(this.map[0][1]));
+    for (let i = 1; i < count; i++) {
+      const alpha = 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));
+        if (alpha > this.map[j][0] && alpha <= this.map[j + 1][0]) {
+          const min = this.map[j][0];
+          const max = this.map[j + 1][0];
+          minColor.setHex(this.map[j][1], "linear-srgb");
+          maxColor.setHex(this.map[j + 1][1], "linear-srgb");
+          const color = new THREE.Color().lerpColors(minColor, maxColor, (alpha - min) / (max - min));
           this.lut.push(color);
         }
       }
     }
+    this.lut.push(new THREE.Color(this.map[this.map.length - 1][1]));
     return this;
-  },
-  copy: function(lut) {
+  }
+  copy(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;
-    }
+  }
+  getColor(alpha) {
+    alpha = THREE.MathUtils.clamp(alpha, this.minV, this.maxV);
     alpha = (alpha - this.minV) / (this.maxV - this.minV);
-    var colorPosition = Math.round(alpha * this.n);
-    colorPosition == this.n ? colorPosition -= 1 : colorPosition;
+    const colorPosition = Math.round(alpha * this.n);
     return this.lut[colorPosition];
-  },
-  addColorMap: function(colormapName, arrayOfColors) {
-    ColorMapKeywords[colormapName] = arrayOfColors;
-  },
-  createCanvas: function() {
-    var canvas = document.createElement("canvas");
+  }
+  addColorMap(name, arrayOfColors) {
+    ColorMapKeywords[name] = arrayOfColors;
+    return this;
+  }
+  createCanvas() {
+    const 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;
+  }
+  updateCanvas(canvas) {
+    const ctx = canvas.getContext("2d", { alpha: false });
+    const imageData = ctx.getImageData(0, 0, 1, this.n);
+    const data = imageData.data;
+    let k = 0;
+    const step = 1 / this.n;
+    const minColor = new THREE.Color();
+    const maxColor = new THREE.Color();
+    const finalColor = new THREE.Color();
     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);
+          const min = this.map[j - 1][0];
+          const max = this.map[j][0];
+          minColor.setHex(this.map[j - 1][1], "linear-srgb");
+          maxColor.setHex(this.map[j][1], "linear-srgb");
+          finalColor.lerpColors(minColor, maxColor, (i - min) / (max - min));
+          data[k * 4] = Math.round(finalColor.r * 255);
+          data[k * 4 + 1] = Math.round(finalColor.g * 255);
+          data[k * 4 + 2] = Math.round(finalColor.b * 255);
           data[k * 4 + 3] = 255;
           k += 1;
         }
@@ -100,8 +102,8 @@ Lut.prototype = {
     ctx.putImageData(imageData, 0, 0);
     return canvas;
   }
-};
-var ColorMapKeywords = {
+}
+const ColorMapKeywords = {
   rainbow: [
     [0, 255],
     [0.2, 65535],

package/dist/math/Lut.mjs

@@ -1,95 +1,97 @@
-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) {
+import { Color, MathUtils } from "three";
+class Lut {
+  constructor(colormap, count = 32) {
+    this.isLut = true;
+    this.lut = [];
+    this.map = [];
+    this.n = 0;
+    this.minV = 0;
+    this.maxV = 1;
+    this.setColorMap(colormap, count);
+  }
+  set(value) {
+    if (value.isLut === true) {
       this.copy(value);
     }
     return this;
-  },
-  setMin: function(min) {
+  }
+  setMin(min) {
     this.minV = min;
     return this;
-  },
-  setMax: function(max) {
+  }
+  setMax(max) {
     this.maxV = max;
     return this;
-  },
-  setColorMap: function(colormap, numberofcolors) {
+  }
+  setColorMap(colormap, count = 32) {
     this.map = ColorMapKeywords[colormap] || ColorMapKeywords.rainbow;
-    this.n = numberofcolors || 32;
-    var step = 1 / this.n;
+    this.n = count;
+    const step = 1 / this.n;
+    const minColor = new Color();
+    const maxColor = new Color();
     this.lut.length = 0;
-    for (let i = 0; i <= 1; i += step) {
+    this.lut.push(new Color(this.map[0][1]));
+    for (let i = 1; i < count; i++) {
+      const alpha = 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));
+        if (alpha > this.map[j][0] && alpha <= this.map[j + 1][0]) {
+          const min = this.map[j][0];
+          const max = this.map[j + 1][0];
+          minColor.setHex(this.map[j][1], "linear-srgb");
+          maxColor.setHex(this.map[j + 1][1], "linear-srgb");
+          const color = new Color().lerpColors(minColor, maxColor, (alpha - min) / (max - min));
           this.lut.push(color);
         }
       }
     }
+    this.lut.push(new Color(this.map[this.map.length - 1][1]));
     return this;
-  },
-  copy: function(lut) {
+  }
+  copy(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;
-    }
+  }
+  getColor(alpha) {
+    alpha = MathUtils.clamp(alpha, this.minV, this.maxV);
     alpha = (alpha - this.minV) / (this.maxV - this.minV);
-    var colorPosition = Math.round(alpha * this.n);
-    colorPosition == this.n ? colorPosition -= 1 : colorPosition;
+    const colorPosition = Math.round(alpha * this.n);
     return this.lut[colorPosition];
-  },
-  addColorMap: function(colormapName, arrayOfColors) {
-    ColorMapKeywords[colormapName] = arrayOfColors;
-  },
-  createCanvas: function() {
-    var canvas = document.createElement("canvas");
+  }
+  addColorMap(name, arrayOfColors) {
+    ColorMapKeywords[name] = arrayOfColors;
+    return this;
+  }
+  createCanvas() {
+    const 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;
+  }
+  updateCanvas(canvas) {
+    const ctx = canvas.getContext("2d", { alpha: false });
+    const imageData = ctx.getImageData(0, 0, 1, this.n);
+    const data = imageData.data;
+    let k = 0;
+    const step = 1 / this.n;
+    const minColor = new Color();
+    const maxColor = new Color();
+    const finalColor = new Color();
     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);
+          const min = this.map[j - 1][0];
+          const max = this.map[j][0];
+          minColor.setHex(this.map[j - 1][1], "linear-srgb");
+          maxColor.setHex(this.map[j][1], "linear-srgb");
+          finalColor.lerpColors(minColor, maxColor, (i - min) / (max - min));
+          data[k * 4] = Math.round(finalColor.r * 255);
+          data[k * 4 + 1] = Math.round(finalColor.g * 255);
+          data[k * 4 + 2] = Math.round(finalColor.b * 255);
           data[k * 4 + 3] = 255;
           k += 1;
         }
@@ -98,8 +100,8 @@ Lut.prototype = {
     ctx.putImageData(imageData, 0, 0);
     return canvas;
   }
-};
-var ColorMapKeywords = {
+}
+const ColorMapKeywords = {
   rainbow: [
     [0, 255],
     [0.2, 65535],

package/dist/math/MeshSurfaceSampler.d.ts

@@ -5,11 +5,14 @@ export class MeshSurfaceSampler {
   geometry: BufferGeometry
   positionAttribute: Float32Array
   weightAttribute: string | null
+  randomFunction: () => number
 
+  setRandomGenerator(randomFunction: () => number): this
   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
+  sampleFaceIndex(): number
   setWeightAttribute(name: string | null): this
 }

package/dist/math/MeshSurfaceSampler.js

@@ -1,14 +1,11 @@
 "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.");
-    }
+const _face = /* @__PURE__ */ new THREE.Triangle();
+const _color = /* @__PURE__ */ new THREE.Vector3();
+class MeshSurfaceSampler {
+  constructor(mesh) {
+    let geometry = mesh.geometry;
     if (geometry.index) {
       console.warn("THREE.MeshSurfaceSampler: Converting geometry to non-indexed BufferGeometry.");
       geometry = geometry.toNonIndexed();
@@ -20,88 +17,87 @@ var MeshSurfaceSampler = function() {
     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);
+  setWeightAttribute(name) {
+    this.weightAttribute = name ? this.geometry.getAttribute(name) : null;
+    return this;
+  }
+  build() {
+    const positionAttribute = this.positionAttribute;
+    const weightAttribute = this.weightAttribute;
+    const faceWeights = new Float32Array(positionAttribute.count / 3);
+    for (let i = 0; i < positionAttribute.count; i += 3) {
+      let faceWeight = 1;
+      if (weightAttribute) {
+        faceWeight = weightAttribute.getX(i) + weightAttribute.getX(i + 1) + weightAttribute.getX(i + 2);
       }
-      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;
+      _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);
+    let cumulativeTotal = 0;
+    for (let i = 0; i < faceWeights.length; i++) {
+      cumulativeTotal += faceWeights[i];
+      this.distribution[i] = cumulativeTotal;
+    }
+    return this;
+  }
+  setRandomGenerator(randomFunction) {
+    this.randomFunction = randomFunction;
+    return this;
+  }
+  sample(targetPosition, targetNormal, targetColor) {
+    const faceIndex = this.sampleFaceIndex();
+    return this.sampleFace(faceIndex, targetPosition, targetNormal, targetColor);
+  }
+  sampleFaceIndex() {
+    const cumulativeTotal = this.distribution[this.distribution.length - 1];
+    return this.binarySearch(this.randomFunction() * cumulativeTotal);
+  }
+  binarySearch(x) {
+    const dist = this.distribution;
+    let start = 0;
+    let end = dist.length - 1;
+    let index = -1;
+    while (start <= end) {
+      const 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 this;
     }
-  };
-  return MeshSurfaceSampler2;
-}();
+    return index;
+  }
+  sampleFace(faceIndex, targetPosition, targetNormal, targetColor) {
+    let u = this.randomFunction();
+    let 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;
+  }
+}
 exports.MeshSurfaceSampler = MeshSurfaceSampler;