three-stdlib 2.15.1 → 2.16.0

package/utils/GeometryUtils.js

@@ -1,65 +1,38 @@
-import { Vector3 } from 'three';
-
-/**
- * Generates 2D-Coordinates in a very fast way.
- *
- * Based on work by:
- * @link http://www.openprocessing.org/sketch/15493
- *
- * @param center     Center of Hilbert curve.
- * @param size       Total width of Hilbert curve.
- * @param iterations Number of subdivisions.
- * @param v0         Corner index -X, -Z.
- * @param v1         Corner index -X, +Z.
- * @param v2         Corner index +X, +Z.
- * @param v3         Corner index +X, -Z.
- */
-
-const hilbert2D = (center = new Vector3(0, 0, 0), size = 10, iterations = 1, v0 = 0, v1 = 1, v2 = 2, v3 = 3) => {
-  // Default Vars
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+const hilbert2D = (center = new THREE.Vector3(0, 0, 0), size = 10, iterations = 1, v0 = 0, v1 = 1, v2 = 2, v3 = 3) => {
   const half = size / 2;
-  const vec_s = [new Vector3(center.x - half, center.y, center.z - half), new Vector3(center.x - half, center.y, center.z + half), new Vector3(center.x + half, center.y, center.z + half), new Vector3(center.x + half, center.y, center.z - half)];
-  const vec = [vec_s[v0], vec_s[v1], vec_s[v2], vec_s[v3]]; // Recurse iterations
-
+  const vec_s = [
+    new THREE.Vector3(center.x - half, center.y, center.z - half),
+    new THREE.Vector3(center.x - half, center.y, center.z + half),
+    new THREE.Vector3(center.x + half, center.y, center.z + half),
+    new THREE.Vector3(center.x + half, center.y, center.z - half)
+  ];
+  const vec = [vec_s[v0], vec_s[v1], vec_s[v2], vec_s[v3]];
   if (0 <= --iterations) {
     const tmp = [];
     Array.prototype.push.apply(tmp, hilbert2D(vec[0], half, iterations, v0, v3, v2, v1));
     Array.prototype.push.apply(tmp, hilbert2D(vec[1], half, iterations, v0, v1, v2, v3));
     Array.prototype.push.apply(tmp, hilbert2D(vec[2], half, iterations, v0, v1, v2, v3));
-    Array.prototype.push.apply(tmp, hilbert2D(vec[3], half, iterations, v2, v1, v0, v3)); // Return recursive call
-
+    Array.prototype.push.apply(tmp, hilbert2D(vec[3], half, iterations, v2, v1, v0, v3));
     return tmp;
-  } // Return complete Hilbert Curve.
-
-
+  }
   return vec;
 };
-/**
- * Generates 3D-Coordinates in a very fast way.
- *
- * Based on work by:
- * @link http://www.openprocessing.org/visuals/?visualID=15599
- *
- * @param center     Center of Hilbert curve.
- * @param size       Total width of Hilbert curve.
- * @param iterations Number of subdivisions.
- * @param v0         Corner index -X, +Y, -Z.
- * @param v1         Corner index -X, +Y, +Z.
- * @param v2         Corner index -X, -Y, +Z.
- * @param v3         Corner index -X, -Y, -Z.
- * @param v4         Corner index +X, -Y, -Z.
- * @param v5         Corner index +X, -Y, +Z.
- * @param v6         Corner index +X, +Y, +Z.
- * @param v7         Corner index +X, +Y, -Z.
- */
-
-
-const hilbert3D = (center = new Vector3(0, 0, 0), size = 10, iterations = 1, v0 = 0, v1 = 1, v2 = 2, v3 = 3, v4 = 4, v5 = 5, v6 = 6, v7 = 7) => {
-  // Default Vars
+const hilbert3D = (center = new THREE.Vector3(0, 0, 0), size = 10, iterations = 1, v0 = 0, v1 = 1, v2 = 2, v3 = 3, v4 = 4, v5 = 5, v6 = 6, v7 = 7) => {
   const half = size / 2;
-  const vec_s = [new Vector3(center.x - half, center.y + half, center.z - half), new Vector3(center.x - half, center.y + half, center.z + half), new Vector3(center.x - half, center.y - half, center.z + half), new Vector3(center.x - half, center.y - half, center.z - half), new Vector3(center.x + half, center.y - half, center.z - half), new Vector3(center.x + half, center.y - half, center.z + half), new Vector3(center.x + half, center.y + half, center.z + half), new Vector3(center.x + half, center.y + half, center.z - half)];
-  const vec = [vec_s[v0], vec_s[v1], vec_s[v2], vec_s[v3], vec_s[v4], vec_s[v5], vec_s[v6], vec_s[v7]]; // Recurse iterations
-
+  const vec_s = [
+    new THREE.Vector3(center.x - half, center.y + half, center.z - half),
+    new THREE.Vector3(center.x - half, center.y + half, center.z + half),
+    new THREE.Vector3(center.x - half, center.y - half, center.z + half),
+    new THREE.Vector3(center.x - half, center.y - half, center.z - half),
+    new THREE.Vector3(center.x + half, center.y - half, center.z - half),
+    new THREE.Vector3(center.x + half, center.y - half, center.z + half),
+    new THREE.Vector3(center.x + half, center.y + half, center.z + half),
+    new THREE.Vector3(center.x + half, center.y + half, center.z - half)
+  ];
+  const vec = [vec_s[v0], vec_s[v1], vec_s[v2], vec_s[v3], vec_s[v4], vec_s[v5], vec_s[v6], vec_s[v7]];
   if (--iterations >= 0) {
     const tmp = [];
     Array.prototype.push.apply(tmp, hilbert3D(vec[0], half, iterations, v0, v3, v4, v7, v6, v5, v2, v1));
@@ -69,93 +42,67 @@ const hilbert3D = (center = new Vector3(0, 0, 0), size = 10, iterations = 1, v0
     Array.prototype.push.apply(tmp, hilbert3D(vec[4], half, iterations, v2, v3, v0, v1, v6, v7, v4, v5));
     Array.prototype.push.apply(tmp, hilbert3D(vec[5], half, iterations, v4, v3, v2, v5, v6, v1, v0, v7));
     Array.prototype.push.apply(tmp, hilbert3D(vec[6], half, iterations, v4, v3, v2, v5, v6, v1, v0, v7));
-    Array.prototype.push.apply(tmp, hilbert3D(vec[7], half, iterations, v6, v5, v2, v1, v0, v3, v4, v7)); // Return recursive call
-
+    Array.prototype.push.apply(tmp, hilbert3D(vec[7], half, iterations, v6, v5, v2, v1, v0, v3, v4, v7));
     return tmp;
-  } // Return complete Hilbert Curve.
-
-
+  }
   return vec;
 };
-/**
- * Generates a Gosper curve (lying in the XY plane)
- *
- * https://gist.github.com/nitaku/6521802
- *
- * @param size The size of a single gosper island.
- */
-
-
 const gosper = (size = 1) => {
   function fractalize(config) {
-    let output = '';
+    let output = "";
     let input = config.axiom;
-
     for (let i = 0, il = config.steps; 0 <= il ? i < il : i > il; 0 <= il ? i++ : i--) {
-      output = '';
-
+      output = "";
       for (let j = 0, jl = input.length; j < jl; j++) {
         const char = input[j];
-
         if (char in config.rules) {
           output += config.rules[char];
         } else {
           output += char;
         }
       }
-
       input = output;
     }
-
     return output;
   }
-
   function toPoints(config) {
     let currX = 0;
     let currY = 0;
     let angle = 0;
     const path = [0, 0, 0];
     const fractal = config.fractal;
-
     for (let i = 0, l = fractal.length; i < l; i++) {
       const char = fractal[i];
-
-      if (char === '+') {
+      if (char === "+") {
         angle += config.angle;
-      } else if (char === '-') {
+      } else if (char === "-") {
         angle -= config.angle;
-      } else if (char === 'F') {
+      } else if (char === "F") {
         currX += config.size * Math.cos(angle);
         currY += -config.size * Math.sin(angle);
         path.push(currX, currY, 0);
       }
     }
-
     return path;
-  } //
-
-
-  const gosper = fractalize({
-    axiom: 'A',
+  }
+  const gosper2 = fractalize({
+    axiom: "A",
     steps: 4,
     rules: {
-      A: 'A+BF++BF-FA--FAFA-BF+',
-      B: '-FA+BFBF++BF+FA--FA-B'
+      A: "A+BF++BF-FA--FAFA-BF+",
+      B: "-FA+BFBF++BF+FA--FA-B"
     }
   });
   const points = toPoints({
-    fractal: gosper,
-    size: size,
-    angle: Math.PI / 3 // 60 degrees
-
+    fractal: gosper2,
+    size,
+    angle: Math.PI / 3
   });
   return points;
 };
-
 const GeometryUtils = {
   hilbert3D,
   gosper,
   hilbert2D
 };
-
-export { GeometryUtils };
+exports.GeometryUtils = GeometryUtils;

package/utils/GeometryUtils.mjs

@@ -0,0 +1,108 @@
+import { Vector3 } from "three";
+const hilbert2D = (center = new Vector3(0, 0, 0), size = 10, iterations = 1, v0 = 0, v1 = 1, v2 = 2, v3 = 3) => {
+  const half = size / 2;
+  const vec_s = [
+    new Vector3(center.x - half, center.y, center.z - half),
+    new Vector3(center.x - half, center.y, center.z + half),
+    new Vector3(center.x + half, center.y, center.z + half),
+    new Vector3(center.x + half, center.y, center.z - half)
+  ];
+  const vec = [vec_s[v0], vec_s[v1], vec_s[v2], vec_s[v3]];
+  if (0 <= --iterations) {
+    const tmp = [];
+    Array.prototype.push.apply(tmp, hilbert2D(vec[0], half, iterations, v0, v3, v2, v1));
+    Array.prototype.push.apply(tmp, hilbert2D(vec[1], half, iterations, v0, v1, v2, v3));
+    Array.prototype.push.apply(tmp, hilbert2D(vec[2], half, iterations, v0, v1, v2, v3));
+    Array.prototype.push.apply(tmp, hilbert2D(vec[3], half, iterations, v2, v1, v0, v3));
+    return tmp;
+  }
+  return vec;
+};
+const hilbert3D = (center = new Vector3(0, 0, 0), size = 10, iterations = 1, v0 = 0, v1 = 1, v2 = 2, v3 = 3, v4 = 4, v5 = 5, v6 = 6, v7 = 7) => {
+  const half = size / 2;
+  const vec_s = [
+    new Vector3(center.x - half, center.y + half, center.z - half),
+    new Vector3(center.x - half, center.y + half, center.z + half),
+    new Vector3(center.x - half, center.y - half, center.z + half),
+    new Vector3(center.x - half, center.y - half, center.z - half),
+    new Vector3(center.x + half, center.y - half, center.z - half),
+    new Vector3(center.x + half, center.y - half, center.z + half),
+    new Vector3(center.x + half, center.y + half, center.z + half),
+    new Vector3(center.x + half, center.y + half, center.z - half)
+  ];
+  const vec = [vec_s[v0], vec_s[v1], vec_s[v2], vec_s[v3], vec_s[v4], vec_s[v5], vec_s[v6], vec_s[v7]];
+  if (--iterations >= 0) {
+    const tmp = [];
+    Array.prototype.push.apply(tmp, hilbert3D(vec[0], half, iterations, v0, v3, v4, v7, v6, v5, v2, v1));
+    Array.prototype.push.apply(tmp, hilbert3D(vec[1], half, iterations, v0, v7, v6, v1, v2, v5, v4, v3));
+    Array.prototype.push.apply(tmp, hilbert3D(vec[2], half, iterations, v0, v7, v6, v1, v2, v5, v4, v3));
+    Array.prototype.push.apply(tmp, hilbert3D(vec[3], half, iterations, v2, v3, v0, v1, v6, v7, v4, v5));
+    Array.prototype.push.apply(tmp, hilbert3D(vec[4], half, iterations, v2, v3, v0, v1, v6, v7, v4, v5));
+    Array.prototype.push.apply(tmp, hilbert3D(vec[5], half, iterations, v4, v3, v2, v5, v6, v1, v0, v7));
+    Array.prototype.push.apply(tmp, hilbert3D(vec[6], half, iterations, v4, v3, v2, v5, v6, v1, v0, v7));
+    Array.prototype.push.apply(tmp, hilbert3D(vec[7], half, iterations, v6, v5, v2, v1, v0, v3, v4, v7));
+    return tmp;
+  }
+  return vec;
+};
+const gosper = (size = 1) => {
+  function fractalize(config) {
+    let output = "";
+    let input = config.axiom;
+    for (let i = 0, il = config.steps; 0 <= il ? i < il : i > il; 0 <= il ? i++ : i--) {
+      output = "";
+      for (let j = 0, jl = input.length; j < jl; j++) {
+        const char = input[j];
+        if (char in config.rules) {
+          output += config.rules[char];
+        } else {
+          output += char;
+        }
+      }
+      input = output;
+    }
+    return output;
+  }
+  function toPoints(config) {
+    let currX = 0;
+    let currY = 0;
+    let angle = 0;
+    const path = [0, 0, 0];
+    const fractal = config.fractal;
+    for (let i = 0, l = fractal.length; i < l; i++) {
+      const char = fractal[i];
+      if (char === "+") {
+        angle += config.angle;
+      } else if (char === "-") {
+        angle -= config.angle;
+      } else if (char === "F") {
+        currX += config.size * Math.cos(angle);
+        currY += -config.size * Math.sin(angle);
+        path.push(currX, currY, 0);
+      }
+    }
+    return path;
+  }
+  const gosper2 = fractalize({
+    axiom: "A",
+    steps: 4,
+    rules: {
+      A: "A+BF++BF-FA--FAFA-BF+",
+      B: "-FA+BFBF++BF+FA--FA-B"
+    }
+  });
+  const points = toPoints({
+    fractal: gosper2,
+    size,
+    angle: Math.PI / 3
+  });
+  return points;
+};
+const GeometryUtils = {
+  hilbert3D,
+  gosper,
+  hilbert2D
+};
+export {
+  GeometryUtils
+};

package/utils/RoughnessMipmapper.js

@@ -1,59 +1,40 @@
-import { Mesh, PlaneGeometry, OrthographicCamera, MathUtils, WebGLRenderTarget, Vector2, RawShaderMaterial, NoBlending } from 'three';
-
-/**
- * This class generates custom mipmaps for a roughness map by encoding the lost variation in the
- * normal map mip levels as increased roughness in the corresponding roughness mip levels. This
- * helps with rendering accuracy for MeshStandardMaterial, and also helps with anti-aliasing when
- * using PMREM. If the normal map is larger than the roughness map, the roughness map will be
- * enlarged to match the dimensions of the normal map.
- */
-
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
 var _mipmapMaterial = _getMipmapMaterial();
-
-var _mesh = new Mesh(new PlaneGeometry(2, 2), _mipmapMaterial);
-
-var _flatCamera = new OrthographicCamera(0, 1, 0, 1, 0, 1);
-
+var _mesh = new THREE.Mesh(new THREE.PlaneGeometry(2, 2), _mipmapMaterial);
+var _flatCamera = new THREE.OrthographicCamera(0, 1, 0, 1, 0, 1);
 var _tempTarget = null;
 var _renderer = null;
-
 function RoughnessMipmapper(renderer) {
   _renderer = renderer;
-
   _renderer.compile(_mesh, _flatCamera);
 }
-
 RoughnessMipmapper.prototype = {
   constructor: RoughnessMipmapper,
-  generateMipmaps: function (material) {
-    if ('roughnessMap' in material === false) return;
-    var {
-      roughnessMap,
-      normalMap
-    } = material;
-
+  generateMipmaps: function(material) {
+    if ("roughnessMap" in material === false)
+      return;
+    var { roughnessMap, normalMap } = material;
     if (roughnessMap === null || normalMap === null || !roughnessMap.generateMipmaps || material.userData.roughnessUpdated) {
       return;
     }
-
     material.userData.roughnessUpdated = true;
     var width = Math.max(roughnessMap.image.width, normalMap.image.width);
     var height = Math.max(roughnessMap.image.height, normalMap.image.height);
-    if (!MathUtils.isPowerOfTwo(width) || !MathUtils.isPowerOfTwo(height)) return;
-
+    if (!THREE.MathUtils.isPowerOfTwo(width) || !THREE.MathUtils.isPowerOfTwo(height))
+      return;
     var oldTarget = _renderer.getRenderTarget();
-
     var autoClear = _renderer.autoClear;
     _renderer.autoClear = false;
-
     if (_tempTarget === null || _tempTarget.width !== width || _tempTarget.height !== height) {
-      if (_tempTarget !== null) _tempTarget.dispose();
-      _tempTarget = new WebGLRenderTarget(width, height, {
+      if (_tempTarget !== null)
+        _tempTarget.dispose();
+      _tempTarget = new THREE.WebGLRenderTarget(width, height, {
         depthBuffer: false
       });
       _tempTarget.scissorTest = true;
     }
-
     if (width !== roughnessMap.image.width || height !== roughnessMap.image.height) {
       var params = {
         wrapS: roughnessMap.wrapS,
@@ -62,72 +43,50 @@ RoughnessMipmapper.prototype = {
         minFilter: roughnessMap.minFilter,
         depthBuffer: false
       };
-      var newRoughnessTarget = new WebGLRenderTarget(width, height, params);
-      newRoughnessTarget.texture.generateMipmaps = true; // Setting the render target causes the memory to be allocated.
-
+      var newRoughnessTarget = new THREE.WebGLRenderTarget(width, height, params);
+      newRoughnessTarget.texture.generateMipmaps = true;
       _renderer.setRenderTarget(newRoughnessTarget);
-
       material.roughnessMap = newRoughnessTarget.texture;
-      if (material.metalnessMap == roughnessMap) material.metalnessMap = material.roughnessMap;
-      if (material.aoMap == roughnessMap) material.aoMap = material.roughnessMap;
+      if (material.metalnessMap == roughnessMap)
+        material.metalnessMap = material.roughnessMap;
+      if (material.aoMap == roughnessMap)
+        material.aoMap = material.roughnessMap;
     }
-
     _mipmapMaterial.uniforms.roughnessMap.value = roughnessMap;
     _mipmapMaterial.uniforms.normalMap.value = normalMap;
-    var position = new Vector2(0, 0);
+    var position = new THREE.Vector2(0, 0);
     var texelSize = _mipmapMaterial.uniforms.texelSize.value;
-
     for (let mip = 0; width >= 1 && height >= 1; ++mip, width /= 2, height /= 2) {
-      // Rendering to a mip level is not allowed in webGL1. Instead we must set
-      // up a secondary texture to write the result to, then copy it back to the
-      // proper mipmap level.
-      texelSize.set(1.0 / width, 1.0 / height);
-      if (mip == 0) texelSize.set(0.0, 0.0);
-
+      texelSize.set(1 / width, 1 / height);
+      if (mip == 0)
+        texelSize.set(0, 0);
       _tempTarget.viewport.set(position.x, position.y, width, height);
-
       _tempTarget.scissor.set(position.x, position.y, width, height);
-
       _renderer.setRenderTarget(_tempTarget);
-
       _renderer.render(_mesh, _flatCamera);
-
       _renderer.copyFramebufferToTexture(position, material.roughnessMap, mip);
-
       _mipmapMaterial.uniforms.roughnessMap.value = material.roughnessMap;
     }
-
-    if (roughnessMap !== material.roughnessMap) roughnessMap.dispose();
-
+    if (roughnessMap !== material.roughnessMap)
+      roughnessMap.dispose();
     _renderer.setRenderTarget(oldTarget);
-
     _renderer.autoClear = autoClear;
   },
-  dispose: function () {
+  dispose: function() {
     _mipmapMaterial.dispose();
-
     _mesh.geometry.dispose();
-
-    if (_tempTarget != null) _tempTarget.dispose();
+    if (_tempTarget != null)
+      _tempTarget.dispose();
   }
 };
-
 function _getMipmapMaterial() {
-  var shaderMaterial = new RawShaderMaterial({
+  var shaderMaterial = new THREE.RawShaderMaterial({
     uniforms: {
-      roughnessMap: {
-        value: null
-      },
-      normalMap: {
-        value: null
-      },
-      texelSize: {
-        value: new Vector2(1, 1)
-      }
+      roughnessMap: { value: null },
+      normalMap: { value: null },
+      texelSize: { value: new THREE.Vector2(1, 1) }
     },
-    vertexShader:
-    /* glsl */
-    `
+    vertexShader: `
 			precision mediump float;
 			precision mediump int;
 
@@ -144,9 +103,7 @@ function _getMipmapMaterial() {
 
 			}
 		`,
-    fragmentShader:
-    /* glsl */
-    `
+    fragmentShader: `
 			precision mediump float;
 			precision mediump int;
 
@@ -246,12 +203,11 @@ function _getMipmapMaterial() {
 
 			}
 		`,
-    blending: NoBlending,
+    blending: THREE.NoBlending,
     depthTest: false,
     depthWrite: false
   });
-  shaderMaterial.type = 'RoughnessMipmapper';
+  shaderMaterial.type = "RoughnessMipmapper";
   return shaderMaterial;
 }
-
-export { RoughnessMipmapper };
+exports.RoughnessMipmapper = RoughnessMipmapper;