three-stdlib 2.15.2 → 2.16.1

package/misc/VolumeSlice.js

@@ -1,62 +1,137 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-var VolumeSlice = function(volume, index, axis) {
+import { Texture, LinearFilter, ClampToEdgeWrapping, MeshBasicMaterial, DoubleSide, Mesh, PlaneGeometry } from 'three';
+
+/**
+ * This class has been made to hold a slice of a volume data
+ * @class
+ * @param   {Volume} volume    The associated volume
+ * @param   {number}       [index=0] The index of the slice
+ * @param   {string}       [axis='z']      For now only 'x', 'y' or 'z' but later it will change to a normal vector
+ * @see Volume
+ */
+
+var VolumeSlice = function (volume, index, axis) {
   var slice = this;
+  /**
+   * @member {Volume} volume The associated volume
+   */
+
   this.volume = volume;
+  /**
+   * @member {Number} index The index of the slice, if changed, will automatically call updateGeometry at the next repaint
+   */
+
   index = index || 0;
-  Object.defineProperty(this, "index", {
-    get: function() {
+  Object.defineProperty(this, 'index', {
+    get: function () {
       return index;
     },
-    set: function(value) {
+    set: function (value) {
       index = value;
       slice.geometryNeedsUpdate = true;
       return index;
     }
   });
-  this.axis = axis || "z";
-  this.canvas = document.createElement("canvas");
-  this.canvasBuffer = document.createElement("canvas");
+  /**
+   * @member {String} axis The normal axis
+   */
+
+  this.axis = axis || 'z';
+  /**
+   * @member {HTMLCanvasElement} canvas The final canvas used for the texture
+   */
+
+  /**
+   * @member {CanvasRenderingContext2D} ctx Context of the canvas
+   */
+
+  this.canvas = document.createElement('canvas');
+  /**
+   * @member {HTMLCanvasElement} canvasBuffer The intermediary canvas used to paint the data
+   */
+
+  /**
+   * @member {CanvasRenderingContext2D} ctxBuffer Context of the canvas buffer
+   */
+
+  this.canvasBuffer = document.createElement('canvas');
   this.updateGeometry();
-  var canvasMap = new THREE.Texture(this.canvas);
-  canvasMap.minFilter = THREE.LinearFilter;
-  canvasMap.wrapS = canvasMap.wrapT = THREE.ClampToEdgeWrapping;
-  var material = new THREE.MeshBasicMaterial({
+  var canvasMap = new Texture(this.canvas);
+  canvasMap.minFilter = LinearFilter;
+  canvasMap.wrapS = canvasMap.wrapT = ClampToEdgeWrapping;
+  var material = new MeshBasicMaterial({
     map: canvasMap,
-    side: THREE.DoubleSide,
+    side: DoubleSide,
     transparent: true
   });
-  this.mesh = new THREE.Mesh(this.geometry, material);
+  /**
+   * @member {Mesh} mesh The mesh ready to get used in the scene
+   */
+
+  this.mesh = new Mesh(this.geometry, material);
   this.mesh.matrixAutoUpdate = false;
+  /**
+   * @member {Boolean} geometryNeedsUpdate If set to true, updateGeometry will be triggered at the next repaint
+   */
+
   this.geometryNeedsUpdate = true;
   this.repaint();
+  /**
+   * @member {Number} iLength Width of slice in the original coordinate system, corresponds to the width of the buffer canvas
+   */
+
+  /**
+   * @member {Number} jLength Height of slice in the original coordinate system, corresponds to the height of the buffer canvas
+   */
+
+  /**
+   * @member {Function} sliceAccess Function that allow the slice to access right data
+   * @see Volume.extractPerpendicularPlane
+   * @param {Number} i The first coordinate
+   * @param {Number} j The second coordinate
+   * @returns {Number} the index corresponding to the voxel in volume.data of the given position in the slice
+   */
 };
+
 VolumeSlice.prototype = {
   constructor: VolumeSlice,
-  repaint: function() {
+
+  /**
+   * @member {Function} repaint Refresh the texture and the geometry if geometryNeedsUpdate is set to true
+   * @memberof VolumeSlice
+   */
+  repaint: function () {
     if (this.geometryNeedsUpdate) {
       this.updateGeometry();
     }
-    var iLength = this.iLength, jLength = this.jLength, sliceAccess = this.sliceAccess, volume = this.volume, canvas = this.canvasBuffer, ctx = this.ctxBuffer;
+
+    var iLength = this.iLength,
+        jLength = this.jLength,
+        sliceAccess = this.sliceAccess,
+        volume = this.volume,
+        canvas = this.canvasBuffer,
+        ctx = this.ctxBuffer; // get the imageData and pixel array from the canvas
+
     var imgData = ctx.getImageData(0, 0, iLength, jLength);
     var data = imgData.data;
     var volumeData = volume.data;
     var upperThreshold = volume.upperThreshold;
     var lowerThreshold = volume.lowerThreshold;
     var windowLow = volume.windowLow;
-    var windowHigh = volume.windowHigh;
+    var windowHigh = volume.windowHigh; // manipulate some pixel elements
+
     var pixelCount = 0;
-    if (volume.dataType === "label") {
+
+    if (volume.dataType === 'label') {
+      //this part is currently useless but will be used when colortables will be handled
       for (let j = 0; j < jLength; j++) {
         for (let i = 0; i < iLength; i++) {
           var label = volumeData[sliceAccess(i, j)];
           label = label >= this.colorMap.length ? label % this.colorMap.length + 1 : label;
           var color = this.colorMap[label];
-          data[4 * pixelCount] = color >> 24 & 255;
-          data[4 * pixelCount + 1] = color >> 16 & 255;
-          data[4 * pixelCount + 2] = color >> 8 & 255;
-          data[4 * pixelCount + 3] = color & 255;
+          data[4 * pixelCount] = color >> 24 & 0xff;
+          data[4 * pixelCount + 1] = color >> 16 & 0xff;
+          data[4 * pixelCount + 2] = color >> 8 & 0xff;
+          data[4 * pixelCount + 3] = color & 0xff;
           pixelCount++;
         }
       }
@@ -64,8 +139,10 @@ VolumeSlice.prototype = {
       for (let j = 0; j < jLength; j++) {
         for (let i = 0; i < iLength; i++) {
           var value = volumeData[sliceAccess(i, j)];
-          var alpha = 255;
-          alpha = upperThreshold >= value ? lowerThreshold <= value ? alpha : 0 : 0;
+          var alpha = 0xff; //apply threshold
+
+          alpha = upperThreshold >= value ? lowerThreshold <= value ? alpha : 0 : 0; //apply window level
+
           value = Math.floor(255 * (value - windowLow) / (windowHigh - windowLow));
           value = value > 255 ? 255 : value < 0 ? 0 : value | 0;
           data[4 * pixelCount] = value;
@@ -76,11 +153,18 @@ VolumeSlice.prototype = {
         }
       }
     }
+
     ctx.putImageData(imgData, 0, 0);
     this.ctx.drawImage(canvas, 0, 0, iLength, jLength, 0, 0, this.canvas.width, this.canvas.height);
     this.mesh.material.map.needsUpdate = true;
   },
-  updateGeometry: function() {
+
+  /**
+   * @member {Function} Refresh the geometry according to axis and index
+   * @see Volume.extractPerpendicularPlane
+   * @memberof VolumeSlice
+   */
+  updateGeometry: function () {
     var extracted = this.volume.extractPerpendicularPlane(this.axis, this.index);
     this.sliceAccess = extracted.sliceAccess;
     this.jLength = extracted.jLength;
@@ -90,17 +174,21 @@ VolumeSlice.prototype = {
     this.canvas.height = extracted.planeHeight;
     this.canvasBuffer.width = this.iLength;
     this.canvasBuffer.height = this.jLength;
-    this.ctx = this.canvas.getContext("2d");
-    this.ctxBuffer = this.canvasBuffer.getContext("2d");
-    if (this.geometry)
-      this.geometry.dispose();
-    this.geometry = new THREE.PlaneGeometry(extracted.planeWidth, extracted.planeHeight);
+    this.ctx = this.canvas.getContext('2d');
+    this.ctxBuffer = this.canvasBuffer.getContext('2d');
+    if (this.geometry) this.geometry.dispose(); // dispose existing geometry
+
+    this.geometry = new PlaneGeometry(extracted.planeWidth, extracted.planeHeight);
+
     if (this.mesh) {
-      this.mesh.geometry = this.geometry;
+      this.mesh.geometry = this.geometry; //reset mesh matrix
+
       this.mesh.matrix.identity();
       this.mesh.applyMatrix4(this.matrix);
     }
+
     this.geometryNeedsUpdate = false;
   }
 };
-exports.VolumeSlice = VolumeSlice;
+
+export { VolumeSlice };

package/misc/WebGL.cjs.js

@@ -0,0 +1 @@
+"use strict";let e,t;Object.defineProperty(exports,"__esModule",{value:!0}),exports.getErrorMessage=function(e){const t={1:window.WebGLRenderingContext,2:window.WebGL2RenderingContext},n=document.createElement("div");n.id="webglmessage",n.style.fontFamily="monospace",n.style.fontSize="13px",n.style.fontWeight="normal",n.style.textAlign="center",n.style.background="#fff",n.style.color="#000",n.style.padding="1.5em",n.style.width="400px",n.style.margin="5em auto 0";let r='Your $0 does not seem to support <a href="http://khronos.org/webgl/wiki/Getting_a_WebGL_Implementation" style="color:#000">$1</a>';return r=t[e]?r.replace("$0","graphics card"):r.replace("$0","browser"),r=r.replace("$1",{1:"WebGL",2:"WebGL 2"}[e]),n.innerHTML=r,n},exports.getWebGL2ErrorMessage=function(){return this.getErrorMessage(2)},exports.getWebGLErrorMessage=function(){return this.getErrorMessage(1)},exports.isWebGL2Available=function(){if(void 0!==t)return t;try{var e;let n;const r=document.createElement("canvas");return t=!(!window.WebGL2RenderingContext||!(n=r.getContext("webgl2"))),n&&(null===(e=n.getExtension("WEBGL_lose_context"))||void 0===e||e.loseContext()),t}catch(e){return t=!1}},exports.isWebGLAvailable=function(){if(void 0!==e)return e;try{var t;let n;const r=document.createElement("canvas");return e=!(!window.WebGLRenderingContext||!(n=r.getContext("webgl"))),n&&(null===(t=n.getExtension("WEBGL_lose_context"))||void 0===t||t.loseContext()),e}catch(t){return e=!1}};

package/misc/WebGL.js

@@ -1,31 +1,29 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 let webGLAvailable, webGL2Available;
 function isWebGLAvailable() {
-  var _a;
-  if (webGLAvailable !== void 0)
-    return webGLAvailable;
+  if (webGLAvailable !== undefined) return webGLAvailable;
+
   try {
+    var _gl$getExtension;
+
     let gl;
-    const canvas = document.createElement("canvas");
-    webGLAvailable = !!(window.WebGLRenderingContext && (gl = canvas.getContext("webgl")));
-    if (gl)
-      (_a = gl.getExtension("WEBGL_lose_context")) == null ? void 0 : _a.loseContext();
+    const canvas = document.createElement('canvas');
+    webGLAvailable = !!(window.WebGLRenderingContext && (gl = canvas.getContext('webgl')));
+    if (gl) (_gl$getExtension = gl.getExtension('WEBGL_lose_context')) === null || _gl$getExtension === void 0 ? void 0 : _gl$getExtension.loseContext();
     return webGLAvailable;
   } catch (e) {
     return webGLAvailable = false;
   }
 }
 function isWebGL2Available() {
-  var _a;
-  if (webGL2Available !== void 0)
-    return webGL2Available;
+  if (webGL2Available !== undefined) return webGL2Available;
+
   try {
+    var _gl$getExtension2;
+
     let gl;
-    const canvas = document.createElement("canvas");
-    webGL2Available = !!(window.WebGL2RenderingContext && (gl = canvas.getContext("webgl2")));
-    if (gl)
-      (_a = gl.getExtension("WEBGL_lose_context")) == null ? void 0 : _a.loseContext();
+    const canvas = document.createElement('canvas');
+    webGL2Available = !!(window.WebGL2RenderingContext && (gl = canvas.getContext('webgl2')));
+    if (gl) (_gl$getExtension2 = gl.getExtension('WEBGL_lose_context')) === null || _gl$getExtension2 === void 0 ? void 0 : _gl$getExtension2.loseContext();
     return webGL2Available;
   } catch (e) {
     return webGL2Available = false;
@@ -39,36 +37,35 @@ function getWebGL2ErrorMessage() {
 }
 function getErrorMessage(version) {
   const names = {
-    1: "WebGL",
-    2: "WebGL 2"
+    1: 'WebGL',
+    2: 'WebGL 2'
   };
   const contexts = {
     1: window.WebGLRenderingContext,
     2: window.WebGL2RenderingContext
   };
-  const element = document.createElement("div");
-  element.id = "webglmessage";
-  element.style.fontFamily = "monospace";
-  element.style.fontSize = "13px";
-  element.style.fontWeight = "normal";
-  element.style.textAlign = "center";
-  element.style.background = "#fff";
-  element.style.color = "#000";
-  element.style.padding = "1.5em";
-  element.style.width = "400px";
-  element.style.margin = "5em auto 0";
+  const element = document.createElement('div');
+  element.id = 'webglmessage';
+  element.style.fontFamily = 'monospace';
+  element.style.fontSize = '13px';
+  element.style.fontWeight = 'normal';
+  element.style.textAlign = 'center';
+  element.style.background = '#fff';
+  element.style.color = '#000';
+  element.style.padding = '1.5em';
+  element.style.width = '400px';
+  element.style.margin = '5em auto 0';
   let message = 'Your $0 does not seem to support <a href="http://khronos.org/webgl/wiki/Getting_a_WebGL_Implementation" style="color:#000">$1</a>';
+
   if (contexts[version]) {
-    message = message.replace("$0", "graphics card");
+    message = message.replace('$0', 'graphics card');
   } else {
-    message = message.replace("$0", "browser");
+    message = message.replace('$0', 'browser');
   }
-  message = message.replace("$1", names[version]);
+
+  message = message.replace('$1', names[version]);
   element.innerHTML = message;
   return element;
 }
-exports.getErrorMessage = getErrorMessage;
-exports.getWebGL2ErrorMessage = getWebGL2ErrorMessage;
-exports.getWebGLErrorMessage = getWebGLErrorMessage;
-exports.isWebGL2Available = isWebGL2Available;
-exports.isWebGLAvailable = isWebGLAvailable;
+
+export { getErrorMessage, getWebGL2ErrorMessage, getWebGLErrorMessage, isWebGL2Available, isWebGLAvailable };

package/modifiers/CurveModifier.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/defineProperty"),t=require("three");function n(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var r=n(e);const s=(e=1)=>{const n=new Float32Array(4096*e*4),r=new t.DataTexture(n,1024,4*e,t.RGBAFormat,t.FloatType);return r.wrapS=t.RepeatWrapping,r.wrapT=t.RepeatWrapping,r.magFilter=t.NearestFilter,r.needsUpdate=!0,r},i=(e,t,n=0)=>{const r=Math.floor(1024);t.arcLengthDivisions=r/2,t.updateArcLengths();const s=t.getSpacedPoints(r),i=t.computeFrenetFrames(r,!0);for(let t=0;t<r;t++){const r=Math.floor(t/1024),o=t%1024;let f=s[t];a(e,o,f.x,f.y,f.z,0+r+4*n),f=i.tangents[t],a(e,o,f.x,f.y,f.z,1+r+4*n),f=i.normals[t],a(e,o,f.x,f.y,f.z,2+r+4*n),f=i.binormals[t],a(e,o,f.x,f.y,f.z,3+r+4*n)}e.needsUpdate=!0},a=(e,t,n,r,s,i)=>{const a=e.image,{data:o}=a,f=4096*i;o[4*t+f+0]=n,o[4*t+f+1]=r,o[4*t+f+2]=s,o[4*t+f+3]=1},o=e=>({spineTexture:{value:e},pathOffset:{type:"f",value:0},pathSegment:{type:"f",value:1},spineOffset:{type:"f",value:161},spineLength:{type:"f",value:400},flow:{type:"i",value:1}});function f(e,t,n=1){e.__ok||(e.__ok=!0,e.onBeforeCompile=e=>{if(e.__modified)return;e.__modified=!0,Object.assign(e.uniforms,t);const r=`\n\t\tuniform sampler2D spineTexture;\n\t\tuniform float pathOffset;\n\t\tuniform float pathSegment;\n\t\tuniform float spineOffset;\n\t\tuniform float spineLength;\n\t\tuniform int flow;\n\n\t\tfloat textureLayers = ${4*n}.;\n\t\tfloat textureStacks = 1.;\n\n\t\t${e.vertexShader}\n\t\t`.replace("#include <beginnormal_vertex>","").replace("#include <defaultnormal_vertex>","").replace("#include <begin_vertex>","").replace(/void\s*main\s*\(\)\s*\{/,"\n        void main() {\n        #include <beginnormal_vertex>\n\n        vec4 worldPos = modelMatrix * vec4(position, 1.);\n\n        bool bend = flow > 0;\n        float xWeight = bend ? 0. : 1.;\n\n        #ifdef USE_INSTANCING\n        float pathOffsetFromInstanceMatrix = instanceMatrix[3][2];\n        float spineLengthFromInstanceMatrix = instanceMatrix[3][0];\n        float spinePortion = bend ? (worldPos.x + spineOffset) / spineLengthFromInstanceMatrix : 0.;\n        float mt = (spinePortion * pathSegment + pathOffset + pathOffsetFromInstanceMatrix)*textureStacks;\n        #else\n        float spinePortion = bend ? (worldPos.x + spineOffset) / spineLength : 0.;\n        float mt = (spinePortion * pathSegment + pathOffset)*textureStacks;\n        #endif\n\n        mt = mod(mt, textureStacks);\n        float rowOffset = floor(mt);\n\n        #ifdef USE_INSTANCING\n        rowOffset += instanceMatrix[3][1] * 4.;\n        #endif\n\n        vec3 spinePos = texture2D(spineTexture, vec2(mt, (0. + rowOffset + 0.5) / textureLayers)).xyz;\n        vec3 a =        texture2D(spineTexture, vec2(mt, (1. + rowOffset + 0.5) / textureLayers)).xyz;\n        vec3 b =        texture2D(spineTexture, vec2(mt, (2. + rowOffset + 0.5) / textureLayers)).xyz;\n        vec3 c =        texture2D(spineTexture, vec2(mt, (3. + rowOffset + 0.5) / textureLayers)).xyz;\n        mat3 basis = mat3(a, b, c);\n\n        vec3 transformed = basis\n          * vec3(worldPos.x * xWeight, worldPos.y * 1., worldPos.z * 1.)\n          + spinePos;\n\n        vec3 transformedNormal = normalMatrix * (basis * objectNormal);\n\t\t\t").replace("#include <project_vertex>","vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );\n\t\t\t\tgl_Position = projectionMatrix * mvPosition;");e.vertexShader=r})}class l{constructor(e,n=1){r.default(this,"curveArray",void 0),r.default(this,"curveLengthArray",void 0),r.default(this,"object3D",void 0),r.default(this,"splineTexure",void 0),r.default(this,"uniforms",void 0);const i=e.clone(),a=s(n),l=o(a);i.traverse((e=>{(e instanceof t.Mesh||e instanceof t.InstancedMesh)&&(e.material=e.material.clone(),f(e.material,l,n))})),this.curveArray=new Array(n),this.curveLengthArray=new Array(n),this.object3D=i,this.splineTexure=a,this.uniforms=l}updateCurve(e,t){if(e>=this.curveArray.length)throw Error("Index out of range for Flow");const n=t.getLength();this.uniforms.spineLength.value=n,this.curveLengthArray[e]=n,this.curveArray[e]=t,i(this.splineTexure,t,e)}moveAlongCurve(e){this.uniforms.pathOffset.value+=e}}const u=new t.Matrix4;exports.Flow=l,exports.InstancedFlow=class extends l{constructor(e,n,s,i){const a=new t.InstancedMesh(s,i,e);a.instanceMatrix.setUsage(t.DynamicDrawUsage),super(a,n),r.default(this,"offsets",void 0),r.default(this,"whichCurve",void 0),this.offsets=new Array(e).fill(0),this.whichCurve=new Array(e).fill(0)}writeChanges(e){u.makeTranslation(this.curveLengthArray[this.whichCurve[e]],this.whichCurve[e],this.offsets[e]),this.object3D.setMatrixAt(e,u),this.object3D.instanceMatrix.needsUpdate=!0}moveIndividualAlongCurve(e,t){this.offsets[e]+=t,this.writeChanges(e)}setCurve(e,t){if(isNaN(t))throw Error("curve index being set is Not a Number (NaN)");this.whichCurve[e]=t,this.writeChanges(e)}},exports.getUniforms=o,exports.initSplineTexture=s,exports.modifyShader=f,exports.updateSplineTexture=i;

package/modifiers/CurveModifier.js

@@ -1,24 +1,40 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import { DataTexture, RGBAFormat, FloatType, RepeatWrapping, NearestFilter, Mesh, InstancedMesh, Matrix4, DynamicDrawUsage } from 'three';
+
+// Original src: https://github.com/zz85/threejs-path-flow
 const CHANNELS = 4;
 const TEXTURE_WIDTH = 1024;
 const TEXTURE_HEIGHT = 4;
+
+/**
+ * Make a new DataTexture to store the descriptions of the curves.
+ *
+ * @param { number } numberOfCurves the number of curves needed to be described by this texture.
+ */
 const initSplineTexture = (numberOfCurves = 1) => {
   const dataArray = new Float32Array(TEXTURE_WIDTH * TEXTURE_HEIGHT * numberOfCurves * CHANNELS);
-  const dataTexture = new THREE.DataTexture(dataArray, TEXTURE_WIDTH, TEXTURE_HEIGHT * numberOfCurves, THREE.RGBAFormat, THREE.FloatType);
-  dataTexture.wrapS = THREE.RepeatWrapping;
-  dataTexture.wrapT = THREE.RepeatWrapping;
-  dataTexture.magFilter = THREE.NearestFilter;
+  const dataTexture = new DataTexture(dataArray, TEXTURE_WIDTH, TEXTURE_HEIGHT * numberOfCurves, RGBAFormat, FloatType);
+  dataTexture.wrapS = RepeatWrapping;
+  dataTexture.wrapT = RepeatWrapping;
+  dataTexture.magFilter = NearestFilter;
   dataTexture.needsUpdate = true;
   return dataTexture;
 };
+/**
+ * Write the curve description to the data texture
+ *
+ * @param { DataTexture } texture The DataTexture to write to
+ * @param { Curve } splineCurve The curve to describe
+ * @param { number } offset Which curve slot to write to
+ */
+
 const updateSplineTexture = (texture, splineCurve, offset = 0) => {
   const numberOfPoints = Math.floor(TEXTURE_WIDTH * (TEXTURE_HEIGHT / 4));
   splineCurve.arcLengthDivisions = numberOfPoints / 2;
   splineCurve.updateArcLengths();
   const points = splineCurve.getSpacedPoints(numberOfPoints);
   const frenetFrames = splineCurve.computeFrenetFrames(numberOfPoints, true);
+
   for (let i = 0; i < numberOfPoints; i++) {
     const rowOffset = Math.floor(i / TEXTURE_WIDTH);
     const rowIndex = i % TEXTURE_WIDTH;
@@ -31,35 +47,66 @@ const updateSplineTexture = (texture, splineCurve, offset = 0) => {
     pt = frenetFrames.binormals[i];
     setTextureValue(texture, rowIndex, pt.x, pt.y, pt.z, 3 + rowOffset + TEXTURE_HEIGHT * offset);
   }
+
   texture.needsUpdate = true;
 };
+
 const setTextureValue = (texture, index, x, y, z, o) => {
   const image = texture.image;
-  const { data } = image;
-  const i = CHANNELS * TEXTURE_WIDTH * o;
+  const {
+    data
+  } = image;
+  const i = CHANNELS * TEXTURE_WIDTH * o; // Row Offset
+
   data[index * CHANNELS + i + 0] = x;
   data[index * CHANNELS + i + 1] = y;
   data[index * CHANNELS + i + 2] = z;
   data[index * CHANNELS + i + 3] = 1;
 };
-const getUniforms = (splineTexture) => ({
-  spineTexture: { value: splineTexture },
-  pathOffset: { type: "f", value: 0 },
-  pathSegment: { type: "f", value: 1 },
-  spineOffset: { type: "f", value: 161 },
-  spineLength: { type: "f", value: 400 },
-  flow: { type: "i", value: 1 }
+
+/**
+ * Create a new set of uniforms for describing the curve modifier
+ *
+ * @param { DataTexture } Texture which holds the curve description
+ */
+const getUniforms = splineTexture => ({
+  spineTexture: {
+    value: splineTexture
+  },
+  pathOffset: {
+    type: 'f',
+    value: 0
+  },
+  // time of path curve
+  pathSegment: {
+    type: 'f',
+    value: 1
+  },
+  // fractional length of path
+  spineOffset: {
+    type: 'f',
+    value: 161
+  },
+  spineLength: {
+    type: 'f',
+    value: 400
+  },
+  flow: {
+    type: 'i',
+    value: 1
+  }
 });
 function modifyShader(material, uniforms, numberOfCurves = 1) {
-  if (material.__ok)
-    return;
+  if (material.__ok) return;
   material.__ok = true;
-  material.onBeforeCompile = (shader) => {
-    if (shader.__modified)
-      return;
+
+  material.onBeforeCompile = shader => {
+    if (shader.__modified) return;
     shader.__modified = true;
     Object.assign(shader.uniforms, uniforms);
-    const vertexShader = `
+    const vertexShader =
+    /* glsl */
+    `
 		uniform sampler2D spineTexture;
 		uniform float pathOffset;
 		uniform float pathSegment;
@@ -71,9 +118,13 @@ function modifyShader(material, uniforms, numberOfCurves = 1) {
 		float textureStacks = ${TEXTURE_HEIGHT / 4}.;
 
 		${shader.vertexShader}
-		`.replace("#include <beginnormal_vertex>", "").replace("#include <defaultnormal_vertex>", "").replace("#include <begin_vertex>", "").replace(
-      /void\s*main\s*\(\)\s*\{/,
-      `
+		` // chunk import moved in front of modified shader below
+    .replace('#include <beginnormal_vertex>', '') // vec3 transformedNormal declaration overriden below
+    .replace('#include <defaultnormal_vertex>', '') // vec3 transformed declaration overriden below
+    .replace('#include <begin_vertex>', '') // shader override
+    .replace(/void\s*main\s*\(\)\s*\{/,
+    /* glsl */
+    `
         void main() {
         #include <beginnormal_vertex>
 
@@ -110,22 +161,38 @@ function modifyShader(material, uniforms, numberOfCurves = 1) {
           + spinePos;
 
         vec3 transformedNormal = normalMatrix * (basis * objectNormal);
-			`
-    ).replace(
-      "#include <project_vertex>",
-      `vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );
-				gl_Position = projectionMatrix * mvPosition;`
-    );
+			`).replace('#include <project_vertex>',
+    /* glsl */
+    `vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );
+				gl_Position = projectionMatrix * mvPosition;`);
     shader.vertexShader = vertexShader;
   };
 }
+/**
+ * A helper class for making meshes bend aroudn curves
+ */
+
 class Flow {
+  /**
+   * @param {Mesh} mesh The mesh to clone and modify to bend around the curve
+   * @param {number} numberOfCurves The amount of space that should preallocated for additional curves
+   */
   constructor(mesh, numberOfCurves = 1) {
+    _defineProperty(this, "curveArray", void 0);
+
+    _defineProperty(this, "curveLengthArray", void 0);
+
+    _defineProperty(this, "object3D", void 0);
+
+    _defineProperty(this, "splineTexure", void 0);
+
+    _defineProperty(this, "uniforms", void 0);
+
     const obj3D = mesh.clone();
     const splineTexure = initSplineTexture(numberOfCurves);
     const uniforms = getUniforms(splineTexure);
-    obj3D.traverse((child) => {
-      if (child instanceof THREE.Mesh || child instanceof THREE.InstancedMesh) {
+    obj3D.traverse(child => {
+      if (child instanceof Mesh || child instanceof InstancedMesh) {
         child.material = child.material.clone();
         modifyShader(child.material, uniforms, numberOfCurves);
       }
@@ -136,47 +203,85 @@ class Flow {
     this.splineTexure = splineTexure;
     this.uniforms = uniforms;
   }
+
   updateCurve(index, curve) {
-    if (index >= this.curveArray.length)
-      throw Error("Index out of range for Flow");
+    if (index >= this.curveArray.length) throw Error('Index out of range for Flow');
     const curveLength = curve.getLength();
     this.uniforms.spineLength.value = curveLength;
     this.curveLengthArray[index] = curveLength;
     this.curveArray[index] = curve;
     updateSplineTexture(this.splineTexure, curve, index);
   }
+
   moveAlongCurve(amount) {
     this.uniforms.pathOffset.value += amount;
   }
+
 }
-const matrix = new THREE.Matrix4();
+const matrix = new Matrix4();
+/**
+ * A helper class for creating instanced versions of flow, where the instances are placed on the curve.
+ */
+
 class InstancedFlow extends Flow {
+  /**
+   *
+   * @param {number} count The number of instanced elements
+   * @param {number} curveCount The number of curves to preallocate for
+   * @param {Geometry} geometry The geometry to use for the instanced mesh
+   * @param {Material} material The material to use for the instanced mesh
+   */
   constructor(count, curveCount, geometry, material) {
-    const mesh = new THREE.InstancedMesh(geometry, material, count);
-    mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    const mesh = new InstancedMesh(geometry, material, count);
+    mesh.instanceMatrix.setUsage(DynamicDrawUsage);
     super(mesh, curveCount);
+
+    _defineProperty(this, "offsets", void 0);
+
+    _defineProperty(this, "whichCurve", void 0);
+
     this.offsets = new Array(count).fill(0);
     this.whichCurve = new Array(count).fill(0);
   }
+  /**
+   * The extra information about which curve and curve position is stored in the translation components of the matrix for the instanced objects
+   * This writes that information to the matrix and marks it as needing update.
+   *
+   * @param {number} index of the instanced element to update
+   */
+
+
   writeChanges(index) {
     matrix.makeTranslation(this.curveLengthArray[this.whichCurve[index]], this.whichCurve[index], this.offsets[index]);
     this.object3D.setMatrixAt(index, matrix);
     this.object3D.instanceMatrix.needsUpdate = true;
   }
+  /**
+   * Move an individual element along the curve by a specific amount
+   *
+   * @param {number} index Which element to update
+   * @param {number} offset Move by how much
+   */
+
+
   moveIndividualAlongCurve(index, offset) {
     this.offsets[index] += offset;
     this.writeChanges(index);
   }
+  /**
+   * Select which curve to use for an element
+   *
+   * @param {number} index the index of the instanced element to update
+   * @param {number} curveNo the index of the curve it should use
+   */
+
+
   setCurve(index, curveNo) {
-    if (isNaN(curveNo))
-      throw Error("curve index being set is Not a Number (NaN)");
+    if (isNaN(curveNo)) throw Error('curve index being set is Not a Number (NaN)');
     this.whichCurve[index] = curveNo;
     this.writeChanges(index);
   }
+
 }
-exports.Flow = Flow;
-exports.InstancedFlow = InstancedFlow;
-exports.getUniforms = getUniforms;
-exports.initSplineTexture = initSplineTexture;
-exports.modifyShader = modifyShader;
-exports.updateSplineTexture = updateSplineTexture;
+
+export { Flow, InstancedFlow, getUniforms, initSplineTexture, modifyShader, updateSplineTexture };

package/modifiers/EdgeSplitModifier.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("@babel/runtime/helpers/defineProperty"),e=require("three"),s=require("../BufferGeometryUtils-971dfde3.js");function i(t){return t&&"object"==typeof t&&"default"in t?t:{default:t}}require("../types/helpers.cjs.js");var o=i(t);exports.EdgeSplitModifier=class{constructor(){o.default(this,"A",new e.Vector3),o.default(this,"B",new e.Vector3),o.default(this,"C",new e.Vector3),o.default(this,"positions",[]),o.default(this,"normals",new Float32Array),o.default(this,"indexes",[]),o.default(this,"pointToIndexMap",[]),o.default(this,"splitIndexes",[]),o.default(this,"oldNormals",[]),o.default(this,"computeNormals",(()=>{this.normals=new Float32Array(3*this.indexes.length);for(let t=0;t<this.indexes.length;t+=3){let e=this.indexes[t];this.A.set(this.positions[3*e],this.positions[3*e+1],this.positions[3*e+2]),e=this.indexes[t+1],this.B.set(this.positions[3*e],this.positions[3*e+1],this.positions[3*e+2]),e=this.indexes[t+2],this.C.set(this.positions[3*e],this.positions[3*e+1],this.positions[3*e+2]),this.C.sub(this.B),this.A.sub(this.B);const s=this.C.cross(this.A).normalize();for(let e=0;e<3;e++)this.normals[3*(t+e)]=s.x,this.normals[3*(t+e)+1]=s.y,this.normals[3*(t+e)+2]=s.z}})),o.default(this,"mapPositionsToIndexes",(()=>{this.pointToIndexMap=Array(this.positions.length/3);for(let t=0;t<this.indexes.length;t++){const e=this.indexes[t];null==this.pointToIndexMap[e]&&(this.pointToIndexMap[e]=[]),this.pointToIndexMap[e].push(t)}})),o.default(this,"edgeSplitToGroups",((t,e,s)=>{this.A.set(this.normals[3*s],this.normals[3*s+1],this.normals[3*s+2]).normalize();const i={splitGroup:[],currentGroup:[s]};for(let o of t)o!==s&&(this.B.set(this.normals[3*o],this.normals[3*o+1],this.normals[3*o+2]).normalize(),this.B.dot(this.A)<e?i.splitGroup.push(o):i.currentGroup.push(o));return i})),o.default(this,"edgeSplit",((t,e,s=null)=>{if(0===t.length)return;const i=[];for(let s of t)i.push(this.edgeSplitToGroups(t,e,s));let o=i[0];for(let t of i)t.currentGroup.length>o.currentGroup.length&&(o=t);null!=s&&this.splitIndexes.push({original:s,indexes:o.currentGroup}),o.splitGroup.length&&this.edgeSplit(o.splitGroup,e,s||o.currentGroup[0])})),o.default(this,"modify",((t,i,o=!0)=>{let r=!1;if(t.attributes.normal&&(r=!0,t=t.clone(),!0===o&&null!==t.index&&(this.oldNormals=t.attributes.normal.array),t.deleteAttribute("normal")),null==t.index){if(void 0===s.BufferGeometryUtils)throw"THREE.EdgeSplitModifier relies on BufferGeometryUtils";t=s.mergeVertices(t)}this.indexes=t.index.array,this.positions=t.getAttribute("position").array,this.computeNormals(),this.mapPositionsToIndexes(),this.splitIndexes=[];for(let t of this.pointToIndexMap)this.edgeSplit(t,Math.cos(i)-.001);const n={};for(let s of Object.keys(t.attributes)){const i=t.attributes[s],o=new i.array.constructor((this.indexes.length+this.splitIndexes.length)*i.itemSize);o.set(i.array),n[s]=new e.BufferAttribute(o,i.itemSize,i.normalized)}const l=new Uint32Array(this.indexes.length);l.set(this.indexes);for(let t=0;t<this.splitIndexes.length;t++){const e=this.splitIndexes[t],s=this.indexes[e.original];for(let e of Object.values(n))for(let i=0;i<e.itemSize;i++)e.array[(this.indexes.length+t)*e.itemSize+i]=e.array[s*e.itemSize+i];for(let s of e.indexes)l[s]=this.indexes.length+t}(t=new e.BufferGeometry).setIndex(new e.BufferAttribute(l,1));for(let e of Object.keys(n))t.setAttribute(e,n[e]);if(r&&(t.computeVertexNormals(),null!==this.oldNormals)){const e=new Array(this.oldNormals.length/3).fill(!1);for(let t of this.splitIndexes)e[t.original]=!0;for(let s=0;s<e.length;s++)if(!1===e[s])for(let e=0;e<3;e++)t.attributes.normal.array[3*s+e]=this.oldNormals[3*s+e]}return t}))}};