super-three 0.184.0 → 0.185.0

package/examples/jsm/misc/TileCreasedNormalsPlugin.js

@@ -0,0 +1,270 @@
+import { BufferAttribute } from 'three';
+
+/**
+ * A plugin for `3d-tiles-renderer` that computes creased vertex normals for the
+ * geometry of each loaded tile: smooth normals everywhere except where faces meet
+ * at an angle greater than the crease angle. Useful for photogrammetry tile sets
+ * like Google Photorealistic 3D Tiles which come without vertex normals.
+ *
+ * The normals are computed in a Web Worker so tile processing doesn't block the
+ * main thread. Tiles are displayed once their normals are ready.
+ *
+ * ```js
+ * tiles.registerPlugin( new TileCreasedNormalsPlugin( { creaseAngle: Math.PI / 6 } ) );
+ * ```
+ *
+ * @three_import import { TileCreasedNormalsPlugin } from 'three/addons/misc/TileCreasedNormalsPlugin.js';
+ */
+class TileCreasedNormalsPlugin {
+
+	/**
+	 * Constructs a new plugin.
+	 *
+	 * @param {Object} [options] - The configuration options.
+	 * @param {number} [options.creaseAngle=Math.PI/3] - The crease angle in radians.
+	 */
+	constructor( { creaseAngle = Math.PI / 3 } = {} ) {
+
+		/**
+		 * The crease angle in radians.
+		 *
+		 * @type {number}
+		 */
+		this.creaseAngle = creaseAngle;
+
+		this._requestId = 0;
+		this._pending = new Map();
+
+		const workerCode = `
+
+			${ computeCreasedNormals.toString() }
+
+			onmessage = ( { data } ) => {
+
+				const { id, positions, creaseAngle } = data;
+				const normals = computeCreasedNormals( positions, creaseAngle );
+				postMessage( { id, positions, normals }, [ positions.buffer, normals.buffer ] );
+
+			};
+
+		`;
+
+		this._worker = new Worker( URL.createObjectURL( new Blob( [ workerCode ] ) ) );
+		this._worker.onmessage = ( { data } ) => {
+
+			this._pending.get( data.id )( data );
+			this._pending.delete( data.id );
+
+		};
+
+	}
+
+	/**
+	 * Called by the tiles renderer for each loaded tile model. The tile is
+	 * displayed once the returned promise resolves.
+	 *
+	 * @param {Object3D} scene - The tile model.
+	 * @return {Promise} A promise that resolves when all geometries have creased normals.
+	 */
+	processTileModel( scene ) {
+
+		const promises = [];
+
+		scene.traverse( ( mesh ) => {
+
+			if ( mesh.geometry ) {
+
+				promises.push( this._processMesh( mesh ) );
+
+			}
+
+		} );
+
+		return Promise.all( promises );
+
+	}
+
+	_processMesh( mesh ) {
+
+		const geometry = mesh.geometry.index ? mesh.geometry.toNonIndexed() : mesh.geometry;
+		const positions = geometry.attributes.position.array;
+
+		const id = this._requestId ++;
+		this._worker.postMessage( { id, positions, creaseAngle: this.creaseAngle }, [ positions.buffer ] );
+
+		return new Promise( ( resolve ) => {
+
+			this._pending.set( id, ( { positions, normals } ) => {
+
+				geometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
+				geometry.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
+				mesh.geometry = geometry;
+				resolve();
+
+			} );
+
+		} );
+
+	}
+
+	/**
+	 * Called by the tiles renderer when the plugin is unregistered or the
+	 * tiles renderer is disposed.
+	 */
+	dispose() {
+
+		this._worker.terminate();
+
+	}
+
+}
+
+// Computes creased normals for non-indexed triangle positions. The function is
+// self-contained so it can be serialized into the worker.
+function computeCreasedNormals( positions, creaseAngle ) {
+
+	const creaseDot = Math.cos( creaseAngle );
+	const hashMultiplier = ( 1 + 1e-10 ) * 1e2;
+
+	const vertexCount = positions.length / 3;
+	const faceCount = vertexCount / 3;
+
+	// compute the normal of each face
+	const faceNormals = new Float64Array( faceCount * 3 );
+	for ( let f = 0; f < faceCount; f ++ ) {
+
+		const f9 = 9 * f;
+		const ax = positions[ f9 + 0 ], ay = positions[ f9 + 1 ], az = positions[ f9 + 2 ];
+		const bx = positions[ f9 + 3 ], by = positions[ f9 + 4 ], bz = positions[ f9 + 5 ];
+		const cx = positions[ f9 + 6 ], cy = positions[ f9 + 7 ], cz = positions[ f9 + 8 ];
+
+		const v1x = cx - bx, v1y = cy - by, v1z = cz - bz;
+		const v2x = ax - bx, v2y = ay - by, v2z = az - bz;
+
+		const nx = v1y * v2z - v1z * v2y;
+		const ny = v1z * v2x - v1x * v2z;
+		const nz = v1x * v2y - v1y * v2x;
+
+		const invLength = 1 / ( Math.sqrt( nx * nx + ny * ny + nz * nz ) || 1 );
+		faceNormals[ 3 * f + 0 ] = nx * invLength;
+		faceNormals[ 3 * f + 1 ] = ny * invLength;
+		faceNormals[ 3 * f + 2 ] = nz * invLength;
+
+	}
+
+	// assign an id to each vertex, sharing the id between vertices with the same
+	// quantized position via an open-addressed hash table (slots hold id + 1, 0 means empty)
+	const vertexIds = new Int32Array( vertexCount );
+	const quantized = new Int32Array( vertexCount * 3 );
+
+	let tableSize = 1;
+	while ( tableSize < vertexCount * 2 ) tableSize <<= 1;
+	const tableMask = tableSize - 1;
+	const table = new Int32Array( tableSize );
+
+	let uniqueCount = 0;
+	for ( let i = 0; i < vertexCount; i ++ ) {
+
+		const i3 = 3 * i;
+		const qx = ~ ~ ( positions[ i3 + 0 ] * hashMultiplier );
+		const qy = ~ ~ ( positions[ i3 + 1 ] * hashMultiplier );
+		const qz = ~ ~ ( positions[ i3 + 2 ] * hashMultiplier );
+
+		let slot = ( Math.imul( qx, 73856093 ) ^ Math.imul( qy, 19349663 ) ^ Math.imul( qz, 83492791 ) ) & tableMask;
+
+		while ( true ) {
+
+			const id = table[ slot ];
+
+			if ( id === 0 ) {
+
+				const q3 = 3 * uniqueCount;
+				quantized[ q3 + 0 ] = qx;
+				quantized[ q3 + 1 ] = qy;
+				quantized[ q3 + 2 ] = qz;
+
+				table[ slot ] = uniqueCount + 1;
+				vertexIds[ i ] = uniqueCount ++;
+				break;
+
+			}
+
+			const q3 = 3 * ( id - 1 );
+
+			if ( quantized[ q3 + 0 ] === qx && quantized[ q3 + 1 ] === qy && quantized[ q3 + 2 ] === qz ) {
+
+				vertexIds[ i ] = id - 1;
+				break;
+
+			}
+
+			slot = ( slot + 1 ) & tableMask;
+
+		}
+
+	}
+
+	// bucket the faces surrounding each unique vertex position
+	const bucketOffsets = new Int32Array( uniqueCount + 1 );
+	for ( let i = 0; i < vertexCount; i ++ ) bucketOffsets[ vertexIds[ i ] + 1 ] ++;
+	for ( let i = 0; i < uniqueCount; i ++ ) bucketOffsets[ i + 1 ] += bucketOffsets[ i ];
+
+	const bucketFaces = new Int32Array( vertexCount );
+	const bucketCursors = bucketOffsets.slice( 0, uniqueCount );
+	for ( let f = 0; f < faceCount; f ++ ) {
+
+		const f3 = 3 * f;
+		bucketFaces[ bucketCursors[ vertexIds[ f3 + 0 ] ] ++ ] = f;
+		bucketFaces[ bucketCursors[ vertexIds[ f3 + 1 ] ] ++ ] = f;
+		bucketFaces[ bucketCursors[ vertexIds[ f3 + 2 ] ] ++ ] = f;
+
+	}
+
+	// average the normals of the faces surrounding each vertex if they are within the
+	// provided crease threshold
+	const normalArray = new Float32Array( vertexCount * 3 );
+	for ( let f = 0; f < faceCount; f ++ ) {
+
+		const f3 = 3 * f;
+		const nx = faceNormals[ f3 + 0 ];
+		const ny = faceNormals[ f3 + 1 ];
+		const nz = faceNormals[ f3 + 2 ];
+
+		for ( let n = 0; n < 3; n ++ ) {
+
+			const i = f3 + n;
+			const id = vertexIds[ i ];
+
+			let sumX = 0, sumY = 0, sumZ = 0;
+
+			for ( let k = bucketOffsets[ id ], end = bucketOffsets[ id + 1 ]; k < end; k ++ ) {
+
+				const o3 = 3 * bucketFaces[ k ];
+				const ox = faceNormals[ o3 + 0 ];
+				const oy = faceNormals[ o3 + 1 ];
+				const oz = faceNormals[ o3 + 2 ];
+
+				if ( nx * ox + ny * oy + nz * oz > creaseDot ) {
+
+					sumX += ox;
+					sumY += oy;
+					sumZ += oz;
+
+				}
+
+			}
+
+			const invLength = 1 / ( Math.sqrt( sumX * sumX + sumY * sumY + sumZ * sumZ ) || 1 );
+			normalArray[ 3 * i + 0 ] = sumX * invLength;
+			normalArray[ 3 * i + 1 ] = sumY * invLength;
+			normalArray[ 3 * i + 2 ] = sumZ * invLength;
+
+		}
+
+	}
+
+	return normalArray;
+
+}
+
+export { TileCreasedNormalsPlugin };

package/examples/jsm/misc/Volume.js

@@ -122,7 +122,7 @@ class Volume {
 				case 'unsigned long long int' :
 				case 'uint64' :
 				case 'uint64_t' :
-					throw new Error( 'Error in Volume constructor : this type is not supported in JavaScript' );
+					throw new Error( 'THREE.Volume: type is not supported in JavaScript.' );
 				case 'Float32' :
 				case 'float32' :
 				case 'float' :
@@ -140,7 +140,7 @@ class Volume {
 
 			if ( this.data.length !== this.xLength * this.yLength * this.zLength ) {
 
-				throw new Error( 'Error in Volume constructor, lengths are not matching arrayBuffer size' );
+				throw new Error( 'THREE.Volume: lengths are not matching arrayBuffer size.' );
 
 			}
 

package/examples/jsm/objects/GroundedSkybox.js

@@ -32,7 +32,7 @@ class GroundedSkybox extends Mesh {
 
 		if ( height <= 0 || radius <= 0 || resolution <= 0 ) {
 
-			throw new Error( 'GroundedSkybox height, radius, and resolution must be positive.' );
+			throw new Error( 'THREE.GroundedSkybox: height, radius, and resolution must be positive.' );
 
 		}
 

package/examples/jsm/objects/Reflector.js

@@ -115,7 +115,7 @@ class Reflector extends Mesh {
 
 		this.onBeforeRender = function ( renderer, scene, camera ) {
 
-			const reflectionCamera = this._getReflectionCamera( camera );
+			const reflectionCamera = this.getReflectionCamera( camera );
 
 			reflectorWorldPosition.setFromMatrixPosition( scope.matrixWorld );
 			cameraWorldPosition.setFromMatrixPosition( camera.matrixWorld );
@@ -278,11 +278,10 @@ class Reflector extends Mesh {
 		 * Returns a reflection camera for the given camera. The reflection camera is used to
 		 * render the scene from the reflector's view so correct reflections can be produced.
 		 *
-		 * @private
 		 * @param {Camera} camera - The scene's camera.
 		 * @return {Camera} The corresponding reflection camera.
 		 */
-		this._getReflectionCamera = function ( camera ) {
+		this.getReflectionCamera = function ( camera ) {
 
 			let reflectionCamera = this._reflectionCameras.get( camera );
 

package/examples/jsm/objects/Water2Mesh.js

@@ -66,7 +66,7 @@ class WaterNode extends TempNode {
 
 		this.normalMap0 = texture( options.normalMap0 );
 		this.normalMap1 = texture( options.normalMap1 );
-		this.flowMap = texture( options.flowMap !== undefined ? options.flowMap : null );
+		this.flowMap = texture( options.flowMap );
 
 		this.color = uniform( options.color !== undefined ? new Color( options.color ) : new Color( 0xffffff ) );
 		this.flowDirection = uniform( options.flowDirection !== undefined ? options.flowDirection : new Vector2( 1, 0 ) );

package/examples/jsm/physics/AmmoPhysics.js

@@ -1,13 +1,13 @@
+const AMMO_PATH = 'https://cdn.jsdelivr.net/gh/kripken/ammo.js@79190a1f03845794b1bba1777f30037349967658/builds/ammo.wasm.js';
+
 /**
  * @classdesc Can be used to include Ammo.js as a Physics engine into
- * `three.js` apps. Make sure to include `ammo.wasm.js` first:
- * ```
- * <script src="jsm/libs/ammo.wasm.js"></script>
- * ```
- * It is then possible to initialize the API via:
+ * `three.js` apps. The API can be initialized via:
  * ```js
  * const physics = await AmmoPhysics();
  * ```
+ * The component automatically imports Ammo.js from a CDN so make sure
+ * to use the component with an active Internet connection.
  *
  * @name AmmoPhysics
  * @class
@@ -16,10 +16,17 @@
  */
 async function AmmoPhysics() {
 
-	if ( 'Ammo' in window === false ) {
+	if ( typeof Ammo === 'undefined' ) {
 
-		console.error( 'AmmoPhysics: Couldn\'t find Ammo.js' );
-		return;
+		await new Promise( ( resolve, reject ) => {
+
+			const script = document.createElement( 'script' );
+			script.src = AMMO_PATH;
+			script.onload = resolve;
+			script.onerror = reject;
+			document.head.appendChild( script );
+
+		} );
 
 	}
 

package/examples/jsm/physics/RapierPhysics.js

@@ -281,6 +281,20 @@ async function RapierPhysics() {
 
 	}
 
+	function applyImpulse( mesh, impulse, index = 0 ) {
+
+		let { body } = meshMap.get( mesh );
+
+		if ( mesh.isInstancedMesh ) {
+
+			body = body[ index ];
+
+		}
+
+		body.applyImpulse( impulse, true );
+
+	}
+
 	function addHeightfield( mesh, width, depth, heights, scale ) {
 
 		const shape = RAPIER.ColliderDesc.heightfield( width, depth, heights, scale );
@@ -414,7 +428,7 @@ async function RapierPhysics() {
 
 		/**
 		 * Adds a heightfield terrain to the physics simulation.
-		 * 
+		 *
 		 * @method
 		 * @name RapierPhysics#addHeightfield
 		 * @param {Mesh} mesh - The Three.js mesh representing the terrain.
@@ -427,7 +441,18 @@ async function RapierPhysics() {
 		 * @param {number} scale.z - Scale factor for depth.
 		 * @returns {RigidBody} The created Rapier rigid body for the heightfield.
 		 */
-		addHeightfield: addHeightfield
+		addHeightfield: addHeightfield,
+
+		/**
+		 * Applies an impulse to the given mesh which is part of the physics simulation.
+		 *
+		 * @method
+		 * @name RapierPhysics#applyImpulse
+		 * @param {Mesh} mesh - The mesh to apply the impulse to.
+		 * @param {Vector3} impulse - The impulse to apply.
+		 * @param {number} [index=0] - If the mesh is instanced, the index represents the instanced ID.
+		 */
+		applyImpulse: applyImpulse
 
 	};
 

package/examples/jsm/shaders/VolumeShader.js

@@ -31,34 +31,23 @@ const VolumeRenderShader1 = {
 
 	vertexShader: /* glsl */`
 
-		varying vec4 v_nearpos;
-		varying vec4 v_farpos;
 		varying vec3 v_position;
+		varying vec3 v_cameraInObj;
+		varying vec3 v_viewDirInObj;
 
 		void main() {
-				// Prepare transforms to map to "camera view". See also:
-				// https://threejs.org/docs/#api/renderers/webgl/WebGLProgram
-				mat4 viewtransformf = modelViewMatrix;
-				mat4 viewtransformi = inverse(modelViewMatrix);
-
-				// Project local vertex coordinate to camera position. Then do a step
-				// backward (in cam coords) to the near clipping plane, and project back. Do
-				// the same for the far clipping plane. This gives us all the information we
-				// need to calculate the ray and truncate it to the viewing cone.
 				vec4 position4 = vec4(position, 1.0);
-				vec4 pos_in_cam = viewtransformf * position4;
 
-				// Intersection of ray and near clipping plane (z = -1 in clip coords)
-				pos_in_cam.z = -pos_in_cam.w;
-				v_nearpos = viewtransformi * pos_in_cam;
+				v_position = position;
 
-				// Intersection of ray and far clipping plane (z = +1 in clip coords)
-				pos_in_cam.z = pos_in_cam.w;
-				v_farpos = viewtransformi * pos_in_cam;
+				// Express the camera position and view direction in the object's local
+				// space so the fragment shader can build the per-fragment view ray.
+				// For perspective cameras, rays converge at v_cameraInObj.
+				// For orthographic cameras, rays travel along v_viewDirInObj.
+				v_cameraInObj = (inverse(modelMatrix) * vec4(cameraPosition, 1.0)).xyz;
+				v_viewDirInObj = (inverse(modelViewMatrix) * vec4(0.0, 0.0, -1.0, 0.0)).xyz;
 
-				// Set varyings and output pos
-				v_position = position;
-				gl_Position = projectionMatrix * viewMatrix * modelMatrix * position4;
+				gl_Position = projectionMatrix * modelViewMatrix * position4;
 		}`,
 
 	fragmentShader: /* glsl */`
@@ -75,8 +64,8 @@ const VolumeRenderShader1 = {
 				uniform sampler2D u_cmdata;
 
 				varying vec3 v_position;
-				varying vec4 v_nearpos;
-				varying vec4 v_farpos;
+				varying vec3 v_cameraInObj;
+				varying vec3 v_viewDirInObj;
 
 				// The maximum distance through our rendering volume is sqrt(3).
 				const int MAX_STEPS = 887;	// 887 for 512^3, 1774 for 1024^3
@@ -96,33 +85,29 @@ const VolumeRenderShader1 = {
 
 
 				void main() {
-						// Normalize clipping plane info
-						vec3 farpos = v_farpos.xyz / v_farpos.w;
-						vec3 nearpos = v_nearpos.xyz / v_nearpos.w;
-
-						// Calculate unit vector pointing in the view direction through this fragment.
-						vec3 view_ray = normalize(nearpos.xyz - farpos.xyz);
-
-						// Compute the (negative) distance to the front surface or near clipping plane.
-						// v_position is the back face of the cuboid, so the initial distance calculated in the dot
-						// product below is the distance from near clip plane to the back of the cuboid
-						float distance = dot(nearpos - v_position, view_ray);
-						distance = max(distance, min((-0.5 - v_position.x) / view_ray.x,
-																				(u_size.x - 0.5 - v_position.x) / view_ray.x));
-						distance = max(distance, min((-0.5 - v_position.y) / view_ray.y,
-																				(u_size.y - 0.5 - v_position.y) / view_ray.y));
-						distance = max(distance, min((-0.5 - v_position.z) / view_ray.z,
-																				(u_size.z - 0.5 - v_position.z) / view_ray.z));
-
-						// Now we have the starting position on the front surface
-						vec3 front = v_position + view_ray * distance;
+						// Per-fragment ray direction in object space, pointing from the back
+						// face toward the camera. For perspective cameras the rays converge
+						// at the camera position; for orthographic cameras they are parallel
+						// to the view direction.
+						vec3 view_ray = isOrthographic
+								? normalize(-v_viewDirInObj)
+								: normalize(v_cameraInObj - v_position);
+
+						// Slab-based ray/AABB intersection: v_position lies on the back face
+						// of the cuboid, so stepping along view_ray traverses the volume and
+						// exits through the front face at t = distance.
+						vec3 t1 = (vec3(-0.5) - v_position) / view_ray;
+						vec3 t2 = (u_size - vec3(0.5) - v_position) / view_ray;
+						vec3 tmax = max(t1, t2);
+						float distance = min(min(tmax.x, tmax.y), tmax.z);
 
 						// Decide how many steps to take
-						int nsteps = int(-distance / relative_step_size + 0.5);
+						int nsteps = int(distance / relative_step_size + 0.5);
 						if ( nsteps < 1 )
 								discard;
 
 						// Get starting location and step vector in texture coordinates
+						vec3 front = v_position + view_ray * distance;
 						vec3 step = ((v_position - front) / u_size) / float(nsteps);
 						vec3 start_loc = front / u_size;
 
@@ -149,6 +134,8 @@ const VolumeRenderShader1 = {
 
 				vec4 apply_colormap(float val) {
 						val = (val - u_clim[0]) / (u_clim[1] - u_clim[0]);
+						float n = float(textureSize(u_cmdata, 0).x); // see #33842
+						val = (val * (n - 1.0) + 0.5) / n;
 						return texture2D(u_cmdata, vec2(val, 0.5));
 				}
 

package/examples/jsm/transpiler/GLSLDecoder.js

@@ -677,7 +677,7 @@ class GLSLDecoder {
 
 			params.push( new FunctionParameter( type, name, qualifier, immutable ) );
 
-			if ( tokens[ i ] && tokens[ i ].str !== ',' ) throw new Error( 'Expected ","' );
+			if ( tokens[ i ] && tokens[ i ].str !== ',' ) throw new Error( 'THREE.GLSLDecoder: Expected ","' );
 
 		}
 
@@ -789,7 +789,7 @@ class GLSLDecoder {
 
 		if ( tokens[ 2 ].str !== '{' ) {
 
-			throw new Error( 'Expected \'{\' after struct name ' );
+			throw new Error( 'THREE.GLSLDecoder: Expected \'{\' after struct name ' );
 
 		}
 
@@ -801,13 +801,13 @@ class GLSLDecoder {
 
 			if ( typeToken.type != 'literal' || nameToken.type != 'literal' ) {
 
-				throw new Error( 'Invalid struct declaration' );
+				throw new Error( 'THREE.GLSLDecoder: Invalid struct declaration' );
 
 			}
 
 			if ( tokens[ i + 2 ].str !== ';' ) {
 
-				throw new Error( 'Missing \';\' after struct member name' );
+				throw new Error( 'THREE.GLSLDecoder: Missing \';\' after struct member name' );
 
 			}
 
@@ -818,7 +818,7 @@ class GLSLDecoder {
 
 		if ( tokens[ tokens.length - 2 ].str !== '}' ) {
 
-			throw new Error( 'Missing closing \'}\' for struct ' + structName );
+			throw new Error( 'THREE.GLSLDecoder: Missing closing \'}\' for struct ' + structName );
 
 		}
 
@@ -921,7 +921,7 @@ class GLSLDecoder {
 		// Validate curly braces
 		if ( this.getToken().str !== '{' ) {
 
-			throw new Error( 'Expected \'{\' after switch(...) ' );
+			throw new Error( 'THREE.GLSLDecoder: Expected \'{\' after switch(...) ' );
 
 		}
 

package/examples/jsm/transpiler/Linker.js

@@ -49,7 +49,7 @@ class Linker {
 
 		if ( this.block === null || this.block.node !== node ) {
 
-			throw new Error( 'No block to remove or block mismatch.' );
+			throw new Error( 'THREE.Linker: No block to remove or block mismatch.' );
 
 		}