super-three 0.157.0 → 0.158.0

package/examples/jsm/geometries/InstancedPointsGeometry.js

@@ -0,0 +1,174 @@
+import {
+	Box3,
+	Float32BufferAttribute,
+	InstancedBufferGeometry,
+	InstancedBufferAttribute,
+	Sphere,
+	Vector3
+} from 'three';
+
+const _vector = new Vector3();
+
+class InstancedPointsGeometry extends InstancedBufferGeometry {
+
+	constructor() {
+
+		super();
+
+		this.isInstancedPointsGeometry = true;
+
+		this.type = 'InstancedPointsGeometry';
+
+		const positions = [ - 1, 1, 0, 1, 1, 0, - 1, - 1, 0, 1, - 1, 0 ];
+		const uvs = [ - 1, 1, 1, 1, - 1, - 1, 1, - 1 ];
+		const index = [ 0, 2, 1, 2, 3, 1 ];
+
+		this.setIndex( index );
+		this.setAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+
+	}
+
+	applyMatrix4( matrix ) {
+
+		const pos = this.attributes.instancePosition;
+
+		if ( pos !== undefined ) {
+
+			pos.applyMatrix4( matrix );
+
+			pos.needsUpdate = true;
+
+		}
+
+		if ( this.boundingBox !== null ) {
+
+			this.computeBoundingBox();
+
+		}
+
+		if ( this.boundingSphere !== null ) {
+
+			this.computeBoundingSphere();
+
+		}
+
+		return this;
+
+	}
+
+	setPositions( array ) {
+
+		let points;
+
+		if ( array instanceof Float32Array ) {
+
+			points = array;
+
+		} else if ( Array.isArray( array ) ) {
+
+			points = new Float32Array( array );
+
+		}
+
+		this.setAttribute( 'instancePosition', new InstancedBufferAttribute( points, 3 ) ); // xyz
+
+		//
+
+		this.computeBoundingBox();
+		this.computeBoundingSphere();
+
+		return this;
+
+	}
+
+	setColors( array ) {
+
+		let colors;
+
+		if ( array instanceof Float32Array ) {
+
+			colors = array;
+
+		} else if ( Array.isArray( array ) ) {
+
+			colors = new Float32Array( array );
+
+		}
+
+		this.setAttribute( 'instanceColor', new InstancedBufferAttribute( colors, 3 ) ); // rgb
+
+		return this;
+
+	}
+
+	computeBoundingBox() {
+
+		if ( this.boundingBox === null ) {
+
+			this.boundingBox = new Box3();
+
+		}
+
+		const pos = this.attributes.instancePosition;
+
+		if ( pos !== undefined ) {
+
+			this.boundingBox.setFromBufferAttribute( pos );
+
+		}
+
+	}
+
+	computeBoundingSphere() {
+
+		if ( this.boundingSphere === null ) {
+
+			this.boundingSphere = new Sphere();
+
+		}
+
+		if ( this.boundingBox === null ) {
+
+			this.computeBoundingBox();
+
+		}
+
+		const pos = this.attributes.instancePosition;
+
+		if ( pos !== undefined ) {
+
+			const center = this.boundingSphere.center;
+
+			this.boundingBox.getCenter( center );
+
+			let maxRadiusSq = 0;
+
+			for ( let i = 0, il = pos.count; i < il; i ++ ) {
+
+				_vector.fromBufferAttribute( pos, i );
+				maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( _vector ) );
+
+			}
+
+			this.boundingSphere.radius = Math.sqrt( maxRadiusSq );
+
+			if ( isNaN( this.boundingSphere.radius ) ) {
+
+				console.error( 'THREE.InstancedPointsGeometry.computeBoundingSphere(): Computed radius is NaN. The instanced position data is likely to have NaN values.', this );
+
+			}
+
+		}
+
+	}
+
+	toJSON() {
+
+		// todo
+
+	}
+
+}
+
+export default InstancedPointsGeometry;

package/examples/jsm/geometries/SDFGeometryGenerator.js

@@ -0,0 +1,144 @@
+/**
+ * @author santiago / @glitch_life
+ * wrapper of https://www.npmjs.com/package/isosurface by https://github.com/mikolalysenko
+ *
+ * Returns BufferGeometry from SDF
+ */
+
+import {
+	BufferAttribute,
+	BufferGeometry,
+	FloatType,
+	Mesh,
+	OrthographicCamera,
+	PlaneGeometry,
+	Scene,
+	ShaderMaterial,
+	Vector2,
+	WebGLRenderTarget
+} from 'three';
+
+import { surfaceNet } from './../libs/surfaceNet.js';
+
+class SDFGeometryGenerator {
+
+	constructor( renderer ) {
+
+		this.renderer = renderer;
+
+	}
+
+	generate( res = 64, distFunc = 'float dist( vec3 p ){ return length(p) - 0.5; }', bounds = 1 ) {
+
+		let w, h;
+		if ( res == 8 ) [ w, h ] = [ 32, 16 ];
+		else if ( res == 16 ) [ w, h ] = [ 64, 64 ];
+		else if ( res == 32 ) [ w, h ] = [ 256, 128 ];
+		else if ( res == 64 ) [ w, h ] = [ 512, 512 ];
+		else if ( res == 128 ) [ w, h ] = [ 2048, 1024 ];
+		else if ( res == 256 ) [ w, h ] = [ 4096, 4096 ];
+		else if ( res == 512 ) [ w, h ] = [ 16384, 8096 ];
+		else if ( res == 1024 ) [ w, h ] = [ 32768, 32768 ];
+		else throw new Error( 'THREE.SDFGeometryGenerator: Resolution must be in range 8 < res < 1024 and must be ^2' );
+
+		const maxTexSize = this.renderer.capabilities.maxTextureSize;
+
+		if ( w > maxTexSize || h > maxTexSize ) throw new Error( 'THREE.SDFGeometryGenerator: Your device does not support this resolution ( ' + res + ' ), decrease [res] param.' );
+
+		const [ tilesX, tilesY ] = [ ( w / res ), ( h / res ) ];
+
+		const sdfCompute = `
+			varying vec2 vUv;
+			uniform float tileNum;
+			uniform float bounds;
+			[#dist#]
+			void main()	{ gl_FragColor=vec4( ( dist( vec3( vUv, tileNum ) * 2.0 * bounds - vec3( bounds ) ) < 0.00001 ) ? 1.0 : 0.0 ); }
+		`;
+
+		const sdfRT = this.computeSDF( w, h, tilesX, tilesY, bounds, sdfCompute.replace( '[#dist#]', distFunc ) );
+
+		const read = new Float32Array( w * h * 4 );
+		this.renderer.readRenderTargetPixels( sdfRT, 0, 0, w, h, read );
+		sdfRT.dispose();
+
+		//
+
+		const mesh = surfaceNet( [ res, res, res ], ( x, y, z ) => {
+
+			x = ( x + bounds ) * ( res / ( bounds * 2 ) );
+			y = ( y + bounds ) * ( res / ( bounds * 2 ) );
+			z = ( z + bounds ) * ( res / ( bounds * 2 ) );
+			let p = ( x + ( z % tilesX ) * res ) + y * w + ( Math.floor( z / tilesX ) * res * w );
+			p *= 4;
+			return ( read[ p + 3 ] > 0 ) ? - 0.000000001 : 1;
+
+		}, [[ - bounds, - bounds, - bounds ], [ bounds, bounds, bounds ]] );
+
+		const ps = [], ids = [];
+		const geometry = new BufferGeometry();
+		mesh.positions.forEach( p => {
+
+			ps.push( p[ 0 ], p[ 1 ], p[ 2 ] );
+
+		} );
+		mesh.cells.forEach( p => ids.push( p[ 0 ], p[ 1 ], p[ 2 ] ) );
+		geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( ps ), 3 ) );
+		geometry.setIndex( ids );
+
+		return geometry;
+
+	}
+
+	computeSDF( width, height, tilesX, tilesY, bounds, shader ) {
+
+		const rt = new WebGLRenderTarget( width, height, { type: FloatType } );
+		const scn = new Scene();
+		const cam = new OrthographicCamera();
+		const tiles = tilesX * tilesY;
+		let currentTile = 0;
+
+		Object.assign( cam, { left: width / - 2, right: width / 2, top: height / 2, bottom: height / - 2 } ).updateProjectionMatrix();
+		cam.position.z = 2;
+
+		const tileSize = width / tilesX;
+		const geometry = new PlaneGeometry( tileSize, tileSize );
+
+		while ( currentTile ++ < tiles ) {
+
+			const c = currentTile - 1;
+			const [ px, py ] = [ ( tileSize ) / 2 + ( c % tilesX ) * ( tileSize ) - width / 2, ( tileSize ) / 2 + Math.floor( c / tilesX ) * ( tileSize ) - height / 2 ];
+			const compPlane = new Mesh( geometry, new ShaderMaterial( {
+				uniforms: {
+					res: { value: new Vector2( width, height ) },
+					tileNum: { value: c / ( tilesX * tilesY - 1 ) },
+					bounds: { value: bounds }
+				},
+				vertexShader: 'varying vec2 vUv;void main(){vUv=uv;gl_Position=projectionMatrix*modelViewMatrix*vec4(position,1.0);}',
+				fragmentShader: shader
+			} ) );
+			compPlane.position.set( px, py, 0 );
+			scn.add( compPlane );
+
+		}
+
+		this.renderer.setRenderTarget( rt );
+		this.renderer.render( scn, cam );
+		this.renderer.setRenderTarget( null );
+
+		//
+
+		geometry.dispose();
+
+		scn.traverse( function ( object ) {
+
+			if ( object.material !== undefined ) object.material.dispose();
+
+		} );
+
+		return rt;
+
+	}
+
+}
+
+export { SDFGeometryGenerator };

package/examples/jsm/libs/lottie_canvas.module.js

@@ -1,3 +1,7 @@
+const lottie = {};
+
+if (typeof document !== 'undefined') {
+
 const svgNS = 'http://www.w3.org/2000/svg';
 
 let locationHref = '';
@@ -4547,7 +4551,6 @@ const Matrix = (function () {
   };
 }());
 
-const lottie = {};
 var standalone = '__[STANDALONE]__';
 var animationData = '__[ANIMATIONDATA]__';
 var renderer = '';
@@ -14841,4 +14844,6 @@ setExpressionsPlugin(Expressions);
 initialize$1();
 initialize();
 
+}
+
 export { lottie as default };

package/examples/jsm/libs/opentype.module.js

@@ -8115,30 +8115,6 @@ Substitution.prototype.add = function(feature, sub, script, language) {
     return undefined;
 };
 
-function isBrowser() {
-    return typeof window !== 'undefined';
-}
-
-function nodeBufferToArrayBuffer(buffer) {
-    var ab = new ArrayBuffer(buffer.length);
-    var view = new Uint8Array(ab);
-    for (var i = 0; i < buffer.length; ++i) {
-        view[i] = buffer[i];
-    }
-
-    return ab;
-}
-
-function arrayBufferToNodeBuffer(ab) {
-    var buffer = new Buffer(ab.byteLength);
-    var view = new Uint8Array(ab);
-    for (var i = 0; i < buffer.length; ++i) {
-        buffer[i] = view[i];
-    }
-
-    return buffer;
-}
-
 function checkArgument(expression, message) {
     if (!expression) {
         throw message;
@@ -13671,27 +13647,21 @@ Font.prototype.download = function(fileName) {
     fileName = fileName || familyName.replace(/\s/g, '') + '-' + styleName + '.otf';
     var arrayBuffer = this.toArrayBuffer();
 
-    if (isBrowser()) {
-        window.URL = window.URL || window.webkitURL;
+    window.URL = window.URL || window.webkitURL;
 
-        if (window.URL) {
-            var dataView = new DataView(arrayBuffer);
-            var blob = new Blob([dataView], {type: 'font/opentype'});
+    if (window.URL) {
+        var dataView = new DataView(arrayBuffer);
+        var blob = new Blob([dataView], {type: 'font/opentype'});
 
-            var link = document.createElement('a');
-            link.href = window.URL.createObjectURL(blob);
-            link.download = fileName;
+        var link = document.createElement('a');
+        link.href = window.URL.createObjectURL(blob);
+        link.download = fileName;
 
-            var event = document.createEvent('MouseEvents');
-            event.initEvent('click', true, false);
-            link.dispatchEvent(event);
-        } else {
-            console.warn('Font file could not be downloaded. Try using a different browser.');
-        }
+        var event = document.createEvent('MouseEvents');
+        event.initEvent('click', true, false);
+        link.dispatchEvent(event);
     } else {
-        var fs = require('fs');
-        var buffer = arrayBufferToNodeBuffer(arrayBuffer);
-        fs.writeFileSync(fileName, buffer);
+        console.warn('Font file could not be downloaded. Try using a different browser.');
     }
 };
 /**
@@ -14155,22 +14125,7 @@ var loca = { parse: parseLocaTable };
  */
 
 // File loaders /////////////////////////////////////////////////////////
-/**
- * Loads a font from a file. The callback throws an error message as the first parameter if it fails
- * and the font as an ArrayBuffer in the second parameter if it succeeds.
- * @param  {string} path - The path of the file
- * @param  {Function} callback - The function to call when the font load completes
- */
-function loadFromFile(path, callback) {
-    var fs = require('fs');
-    fs.readFile(path, function(err, buffer) {
-        if (err) {
-            return callback(err.message);
-        }
 
-        callback(null, nodeBufferToArrayBuffer(buffer));
-    });
-}
 /**
  * Loads a font from a URL. The callback throws an error message as the first parameter if it fails
  * and the font as an ArrayBuffer in the second parameter if it succeeds.
@@ -14507,11 +14462,9 @@ function parseBuffer(buffer, opt) {
  */
 function load(url, callback, opt) {
     opt = (opt === undefined || opt === null) ?  {} : opt;
-    var isNode = typeof window === 'undefined';
-    var loadFn = isNode && !opt.isUrl ? loadFromFile : loadFromUrl;
 
     return new Promise(function (resolve, reject) {
-        loadFn(url, function(err, arrayBuffer) {
+        loadFromUrl(url, function(err, arrayBuffer) {
             if (err) {
                 if (callback) {
                     return callback(err);
@@ -14538,20 +14491,6 @@ function load(url, callback, opt) {
     });
 }
 
-/**
- * Synchronously load the font from a URL or file.
- * When done, returns the font object or throws an error.
- * @alias opentype.loadSync
- * @param  {string} url - The URL of the font to load.
- * @param  {Object} opt - opt.lowMemory
- * @return {opentype.Font}
- */
-function loadSync(url, opt) {
-    var fs = require('fs');
-    var buffer = fs.readFileSync(url);
-    return parseBuffer(nodeBufferToArrayBuffer(buffer), opt);
-}
-
 var opentype = /*#__PURE__*/Object.freeze({
 	__proto__: null,
 	Font: Font,
@@ -14561,8 +14500,7 @@ var opentype = /*#__PURE__*/Object.freeze({
 	_parse: parse,
 	parse: parseBuffer,
 	load: load,
-	loadSync: loadSync
 });
 
 export default opentype;
-export { BoundingBox, Font, Glyph, Path, parse as _parse, load, loadSync, parseBuffer as parse };
+export { BoundingBox, Font, Glyph, Path, parse as _parse, load, parseBuffer as parse };

package/examples/jsm/libs/surfaceNet.js

@@ -0,0 +1,201 @@
+/**
+ * SurfaceNets in JavaScript
+ *
+ * Written by Mikola Lysenko (C) 2012
+ *
+ * MIT License
+ *
+ * Based on: S.F. Gibson, 'Constrained Elastic Surface Nets'. (1998) MERL Tech Report.
+ * from https://github.com/mikolalysenko/isosurface/tree/master
+ * 
+ */
+
+let surfaceNet = ( dims, potential, bounds ) => {
+		
+	
+	//Precompute edge table, like Paul Bourke does.
+	// This saves a bit of time when computing the centroid of each boundary cell
+	var cube_edges = new Int32Array(24) , edge_table = new Int32Array(256);
+	(function() {
+
+		//Initialize the cube_edges table
+		// This is just the vertex number of each cube
+		var k = 0;
+		for(var i=0; i<8; ++i) {
+			for(var j=1; j<=4; j<<=1) {
+				var p = i^j;
+				if(i <= p) {
+					cube_edges[k++] = i;
+					cube_edges[k++] = p;
+				}
+			}
+		}
+
+		//Initialize the intersection table.
+		//  This is a 2^(cube configuration) ->  2^(edge configuration) map
+		//  There is one entry for each possible cube configuration, and the output is a 12-bit vector enumerating all edges crossing the 0-level.
+		for(var i=0; i<256; ++i) {
+			var em = 0;
+			for(var j=0; j<24; j+=2) {
+				var a = !!(i & (1<<cube_edges[j]))
+					, b = !!(i & (1<<cube_edges[j+1]));
+				em |= a !== b ? (1 << (j >> 1)) : 0;
+			}
+			edge_table[i] = em;
+		}
+	})();
+
+	//Internal buffer, this may get resized at run time
+	var buffer = new Array(4096);
+	(function() {
+		for(var i=0; i<buffer.length; ++i) {
+			buffer[i] = 0;
+		}
+	})();
+
+	if(!bounds) {
+		bounds = [[0,0,0],dims];
+	}
+	
+	var scale     = [0,0,0];
+	var shift     = [0,0,0];
+	for(var i=0; i<3; ++i) {
+		scale[i] = (bounds[1][i] - bounds[0][i]) / dims[i];
+		shift[i] = bounds[0][i];
+	}
+	
+	var vertices = []
+		, faces = []
+		, n = 0
+		, x = [0, 0, 0]
+		, R = [1, (dims[0]+1), (dims[0]+1)*(dims[1]+1)]
+		, grid = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+		, buf_no = 1;
+	
+		
+	//Resize buffer if necessary 
+	if(R[2] * 2 > buffer.length) {
+		var ol = buffer.length;
+		buffer.length = R[2] * 2;
+		while(ol < buffer.length) {
+			buffer[ol++] = 0;
+		}
+	}
+	
+	//March over the voxel grid
+	for(x[2]=0; x[2]<dims[2]-1; ++x[2], n+=dims[0], buf_no ^= 1, R[2]=-R[2]) {
+	
+		//m is the pointer into the buffer we are going to use.  
+		//This is slightly obtuse because javascript does not have good support for packed data structures, so we must use typed arrays :(
+		//The contents of the buffer will be the indices of the vertices on the previous x/y slice of the volume
+		var m = 1 + (dims[0]+1) * (1 + buf_no * (dims[1]+1));
+		
+		for(x[1]=0; x[1]<dims[1]-1; ++x[1], ++n, m+=2)
+		for(x[0]=0; x[0]<dims[0]-1; ++x[0], ++n, ++m) {
+		
+			//Read in 8 field values around this vertex and store them in an array
+			//Also calculate 8-bit mask, like in marching cubes, so we can speed up sign checks later
+			var mask = 0, g = 0;
+			for(var k=0; k<2; ++k)
+			for(var j=0; j<2; ++j)      
+			for(var i=0; i<2; ++i, ++g) {
+				var p = potential(
+					scale[0]*(x[0]+i)+shift[0],
+					scale[1]*(x[1]+j)+shift[1],
+					scale[2]*(x[2]+k)+shift[2]);
+				grid[g] = p;
+				mask |= (p < 0) ? (1<<g) : 0;
+			}
+			
+			//Check for early termination if cell does not intersect boundary
+			if(mask === 0 || mask === 0xff) {
+				continue;
+			}
+			
+			//Sum up edge intersections
+			var edge_mask = edge_table[mask]
+				, v = [0.0,0.0,0.0]
+				, e_count = 0;
+				
+			//For every edge of the cube...
+			for(var i=0; i<12; ++i) {
+			
+				//Use edge mask to check if it is crossed
+				if(!(edge_mask & (1<<i))) {
+					continue;
+				}
+				
+				//If it did, increment number of edge crossings
+				++e_count;
+				
+				//Now find the point of intersection
+				var e0 = cube_edges[ i<<1 ]       //Unpack vertices
+					, e1 = cube_edges[(i<<1)+1]
+					, g0 = grid[e0]                 //Unpack grid values
+					, g1 = grid[e1]
+					, t  = g0 - g1;                 //Compute point of intersection
+				if(Math.abs(t) > 1e-6) {
+					t = g0 / t;
+				} else {
+					continue;
+				}
+				
+				//Interpolate vertices and add up intersections (this can be done without multiplying)
+				for(var j=0, k=1; j<3; ++j, k<<=1) {
+					var a = e0 & k
+						, b = e1 & k;
+					if(a !== b) {
+						v[j] += a ? 1.0 - t : t;
+					} else {
+						v[j] += a ? 1.0 : 0;
+					}
+				}
+			}
+			
+			//Now we just average the edge intersections and add them to coordinate
+			var s = 1.0 / e_count;
+			for(var i=0; i<3; ++i) {
+				v[i] = scale[i] * (x[i] + s * v[i]) + shift[i];
+			}
+			
+			//Add vertex to buffer, store pointer to vertex index in buffer
+			buffer[m] = vertices.length;
+			vertices.push(v);
+			
+			//Now we need to add faces together, to do this we just loop over 3 basis components
+			for(var i=0; i<3; ++i) {
+				//The first three entries of the edge_mask count the crossings along the edge
+				if(!(edge_mask & (1<<i)) ) {
+					continue;
+				}
+				
+				// i = axes we are point along.  iu, iv = orthogonal axes
+				var iu = (i+1)%3
+					, iv = (i+2)%3;
+					
+				//If we are on a boundary, skip it
+				if(x[iu] === 0 || x[iv] === 0) {
+					continue;
+				}
+				
+				//Otherwise, look up adjacent edges in buffer
+				var du = R[iu]
+					, dv = R[iv];
+				
+				//Remember to flip orientation depending on the sign of the corner.
+				if(mask & 1) {
+					faces.push([buffer[m],    buffer[m-du],    buffer[m-dv]]);
+					faces.push([buffer[m-dv], buffer[m-du],    buffer[m-du-dv]]);
+				} else {
+					faces.push([buffer[m],    buffer[m-dv],    buffer[m-du]]);
+					faces.push([buffer[m-du], buffer[m-dv],    buffer[m-du-dv]]);
+				}
+			}
+		}
+	}
+	
+	//All done!  Return the result
+	return { positions: vertices, cells: faces };
+}
+
+export { surfaceNet }