opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/math/ImprovedNoise.js

@@ -0,0 +1,86 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.ImprovedNoise = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.ImprovedNoise = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  // http://mrl.nyu.edu/~perlin/noise/
+  var _p = [151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180];
+
+  for (var i = 0; i < 256; i++) {
+    _p[256 + i] = _p[i];
+  }
+
+  function fade(t) {
+    return t * t * t * (t * (t * 6 - 15) + 10);
+  }
+
+  function lerp(t, a, b) {
+    return a + t * (b - a);
+  }
+
+  function grad(hash, x, y, z) {
+    var h = hash & 15;
+    var u = h < 8 ? x : y,
+        v = h < 4 ? y : h == 12 || h == 14 ? x : z;
+    return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
+  }
+
+  var ImprovedNoise = /*#__PURE__*/function () {
+    function ImprovedNoise() {
+      _classCallCheck(this, ImprovedNoise);
+    }
+
+    _createClass(ImprovedNoise, [{
+      key: "noise",
+      value: function noise(x, y, z) {
+        var floorX = Math.floor(x),
+            floorY = Math.floor(y),
+            floorZ = Math.floor(z);
+        var X = floorX & 255,
+            Y = floorY & 255,
+            Z = floorZ & 255;
+        x -= floorX;
+        y -= floorY;
+        z -= floorZ;
+        var xMinus1 = x - 1,
+            yMinus1 = y - 1,
+            zMinus1 = z - 1;
+        var u = fade(x),
+            v = fade(y),
+            w = fade(z);
+        var A = _p[X] + Y,
+            AA = _p[A] + Z,
+            AB = _p[A + 1] + Z,
+            B = _p[X + 1] + Y,
+            BA = _p[B] + Z,
+            BB = _p[B + 1] + Z;
+        return lerp(w, lerp(v, lerp(u, grad(_p[AA], x, y, z), grad(_p[BA], xMinus1, y, z)), lerp(u, grad(_p[AB], x, yMinus1, z), grad(_p[BB], xMinus1, yMinus1, z))), lerp(v, lerp(u, grad(_p[AA + 1], x, y, zMinus1), grad(_p[BA + 1], xMinus1, y, zMinus1)), lerp(u, grad(_p[AB + 1], x, yMinus1, zMinus1), grad(_p[BB + 1], xMinus1, yMinus1, zMinus1))));
+      }
+    }]);
+
+    return ImprovedNoise;
+  }();
+
+  _exports.ImprovedNoise = ImprovedNoise;
+});

data/lib-opal/js_wrap/three/math/Lut.js

@@ -0,0 +1,170 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.Lut = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.Lut = _exports.ColorMapKeywords = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  var Lut = /*#__PURE__*/function () {
+    function Lut(colormap) {
+      var count = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 32;
+
+      _classCallCheck(this, Lut);
+
+      this.lut = [];
+      this.map = [];
+      this.n = 0;
+      this.minV = 0;
+      this.maxV = 1;
+      this.setColorMap(colormap, count);
+    }
+
+    _createClass(Lut, [{
+      key: "set",
+      value: function set(value) {
+        if (value.isLut === true) {
+          this.copy(value);
+        }
+
+        return this;
+      }
+    }, {
+      key: "setMin",
+      value: function setMin(min) {
+        this.minV = min;
+        return this;
+      }
+    }, {
+      key: "setMax",
+      value: function setMax(max) {
+        this.maxV = max;
+        return this;
+      }
+    }, {
+      key: "setColorMap",
+      value: function setColorMap(colormap) {
+        var count = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 32;
+        this.map = ColorMapKeywords[colormap] || ColorMapKeywords.rainbow;
+        this.n = count;
+        var step = 1.0 / this.n;
+        this.lut.length = 0;
+
+        for (var i = 0; i <= 1; i += step) {
+          for (var 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;
+      }
+    }, {
+      key: "copy",
+      value: function copy(lut) {
+        this.lut = lut.lut;
+        this.map = lut.map;
+        this.n = lut.n;
+        this.minV = lut.minV;
+        this.maxV = lut.maxV;
+        return this;
+      }
+    }, {
+      key: "getColor",
+      value: function getColor(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];
+      }
+    }, {
+      key: "addColorMap",
+      value: function addColorMap(name, arrayOfColors) {
+        ColorMapKeywords[name] = arrayOfColors;
+        return this;
+      }
+    }, {
+      key: "createCanvas",
+      value: function createCanvas() {
+        var canvas = document.createElement('canvas');
+        canvas.width = 1;
+        canvas.height = this.n;
+        this.updateCanvas(canvas);
+        return canvas;
+      }
+    }, {
+      key: "updateCanvas",
+      value: function updateCanvas(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.0 / this.n;
+
+        for (var i = 1; i >= 0; i -= step) {
+          for (var 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;
+      }
+    }]);
+
+    return Lut;
+  }();
+
+  _exports.Lut = Lut;
+  Lut.prototype.isLut = true;
+  var ColorMapKeywords = {
+    'rainbow': [[0.0, 0x0000FF], [0.2, 0x00FFFF], [0.5, 0x00FF00], [0.8, 0xFFFF00], [1.0, 0xFF0000]],
+    'cooltowarm': [[0.0, 0x3C4EC2], [0.2, 0x9BBCFF], [0.5, 0xDCDCDC], [0.8, 0xF6A385], [1.0, 0xB40426]],
+    'blackbody': [[0.0, 0x000000], [0.2, 0x780000], [0.5, 0xE63200], [0.8, 0xFFFF00], [1.0, 0xFFFFFF]],
+    'grayscale': [[0.0, 0x000000], [0.2, 0x404040], [0.5, 0x7F7F80], [0.8, 0xBFBFBF], [1.0, 0xFFFFFF]]
+  };
+  _exports.ColorMapKeywords = ColorMapKeywords;
+});

data/lib-opal/js_wrap/three/math/MeshSurfaceSampler.js

@@ -0,0 +1,187 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.MeshSurfaceSampler = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.MeshSurfaceSampler = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  /**
+   * Utility class for sampling weighted random points on the surface of a mesh.
+   *
+   * Building the sampler is a one-time O(n) operation. Once built, any number of
+   * random samples may be selected in O(logn) time. Memory usage is O(n).
+   *
+   * References:
+   * - http://www.joesfer.com/?p=84
+   * - https://stackoverflow.com/a/4322940/1314762
+   */
+  var _face = new _three.Triangle();
+
+  var _color = new _three.Vector3();
+
+  var MeshSurfaceSampler = /*#__PURE__*/function () {
+    function MeshSurfaceSampler(mesh) {
+      _classCallCheck(this, MeshSurfaceSampler);
+
+      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;
+    }
+
+    _createClass(MeshSurfaceSampler, [{
+      key: "setWeightAttribute",
+      value: function setWeightAttribute(name) {
+        this.weightAttribute = name ? this.geometry.getAttribute(name) : null;
+        return this;
+      }
+    }, {
+      key: "build",
+      value: function build() {
+        var positionAttribute = this.positionAttribute;
+        var weightAttribute = this.weightAttribute;
+        var faceWeights = new Float32Array(positionAttribute.count / 3); // Accumulate weights for each mesh face.
+
+        for (var 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;
+        } // Store cumulative total face weights in an array, where weight index
+        // corresponds to face index.
+
+
+        this.distribution = new Float32Array(positionAttribute.count / 3);
+        var cumulativeTotal = 0;
+
+        for (var _i = 0; _i < faceWeights.length; _i++) {
+          cumulativeTotal += faceWeights[_i];
+          this.distribution[_i] = cumulativeTotal;
+        }
+
+        return this;
+      }
+    }, {
+      key: "setRandomGenerator",
+      value: function setRandomGenerator(randomFunction) {
+        this.randomFunction = randomFunction;
+        return this;
+      }
+    }, {
+      key: "sample",
+      value: function sample(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);
+      }
+    }, {
+      key: "binarySearch",
+      value: function binarySearch(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;
+      }
+    }, {
+      key: "sampleFace",
+      value: function sampleFace(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 !== undefined) {
+          _face.getNormal(targetNormal);
+        }
+
+        if (targetColor !== undefined && this.colorAttribute !== undefined) {
+          _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 MeshSurfaceSampler;
+  }();
+
+  _exports.MeshSurfaceSampler = MeshSurfaceSampler;
+});