super-three 0.147.1 → 0.152.0

package/examples/jsm/renderers/webgpu/nodes/WebGPUNodes.js

@@ -1,5 +1,6 @@
 import WebGPUNodeBuilder from './WebGPUNodeBuilder.js';
-import { NodeFrame } from 'three/nodes';
+import { NoToneMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping } from 'three';
+import { NodeFrame, cubeTexture, texture, rangeFog, densityFog, reference, toneMapping, positionWorld, modelWorldMatrix, transformDirection, equirectUV, viewportBottomLeft } from '../../../nodes/Nodes.js';
 
 class WebGPUNodes {
 
@@ -12,24 +13,42 @@ class WebGPUNodes {
 
 	}
 
-	get( object ) {
+	get( renderObject ) {
 
-		const objectProperties = this.properties.get( object );
+		const renderObjectProperties = this.properties.get( renderObject );
 
-		let nodeBuilder = objectProperties.nodeBuilder;
+		let nodeBuilder = renderObjectProperties.nodeBuilder;
 
 		if ( nodeBuilder === undefined ) {
 
-			const scene = objectProperties.scene;
-			const lightsNode = objectProperties.lightsNode;
+			nodeBuilder = new WebGPUNodeBuilder( renderObject.object, this.renderer );
+			nodeBuilder.material = renderObject.material;
+			nodeBuilder.lightsNode = renderObject.lightsNode;
+			nodeBuilder.environmentNode = this.getEnvironmentNode( renderObject.scene );
+			nodeBuilder.fogNode = this.getFogNode( renderObject.scene );
+			nodeBuilder.toneMappingNode = this.getToneMappingNode();
+			nodeBuilder.build();
+
+			renderObjectProperties.nodeBuilder = nodeBuilder;
+
+		}
+
+		return nodeBuilder;
+
+	}
 
-			nodeBuilder = new WebGPUNodeBuilder( object, this.renderer );
-			nodeBuilder.lightsNode = lightsNode;
-			nodeBuilder.fogNode = scene?.fogNode;
-			nodeBuilder.scene = scene;
+	getForCompute( computeNode ) {
+
+		const computeProperties = this.properties.get( computeNode );
+
+		let nodeBuilder = computeProperties.nodeBuilder;
+
+		if ( nodeBuilder === undefined ) {
+
+			nodeBuilder = new WebGPUNodeBuilder( computeNode, this.renderer );
 			nodeBuilder.build();
 
-			objectProperties.nodeBuilder = nodeBuilder;
+			computeProperties.nodeBuilder = nodeBuilder;
 
 		}
 
@@ -37,32 +56,232 @@ class WebGPUNodes {
 
 	}
 
-	remove( object ) {
+	remove( renderObject ) {
 
-		const objectProperties = this.properties.get( object );
+		const objectProperties = this.properties.get( renderObject );
 
 		delete objectProperties.nodeBuilder;
 
 	}
 
-	updateFrame() {
+	getEnvironmentNode( scene ) {
+
+		return scene.environmentNode || this.properties.get( scene ).environmentNode || null;
+
+	}
+
+	getFogNode( scene ) {
+
+		return scene.fogNode || this.properties.get( scene ).fogNode || null;
+
+	}
+
+	getToneMappingNode() {
 
-		this.nodeFrame.update();
+		return this.renderer.toneMappingNode || this.properties.get( this.renderer ).toneMappingNode || null;
 
 	}
 
-	update( object, camera ) {
+	getCacheKey( scene, lightsNode ) {
+
+		const environmentNode = this.getEnvironmentNode( scene );
+		const fogNode = this.getFogNode( scene );
+		const toneMappingNode = this.getToneMappingNode();
+
+		const cacheKey = [];
+
+		if ( lightsNode ) cacheKey.push( 'lightsNode:' + lightsNode.getCacheKey() );
+		if ( environmentNode ) cacheKey.push( 'environmentNode:' + environmentNode.getCacheKey() );
+		if ( fogNode ) cacheKey.push( 'fogNode:' + fogNode.getCacheKey() );
+		if ( toneMappingNode ) cacheKey.push( 'toneMappingNode:' + toneMappingNode.getCacheKey() );
+
+		return '{' + cacheKey.join( ',' ) + '}';
+
+	}
+
+	updateToneMapping() {
 
 		const renderer = this.renderer;
-		const material = object.material;
+		const rendererProperties = this.properties.get( renderer );
+		const rendererToneMapping = renderer.toneMapping;
+
+		if ( rendererToneMapping !== NoToneMapping ) {
+
+			if ( rendererProperties.toneMapping !== rendererToneMapping ) {
+
+				rendererProperties.toneMappingNode = toneMapping( rendererToneMapping, reference( 'toneMappingExposure', 'float', renderer ) );
+				rendererProperties.toneMapping = rendererToneMapping;
+
+			}
+
+		} else {
+
+			delete rendererProperties.toneMappingNode;
+			delete rendererProperties.toneMapping;
+
+		}
+
+	}
+
+	updateBackground( scene ) {
+
+		const sceneProperties = this.properties.get( scene );
+		const background = scene.background;
+
+		if ( background ) {
+
+			if ( sceneProperties.background !== background ) {
+
+				let backgroundNode = null;
+
+				if ( background.isCubeTexture === true ) {
+
+					backgroundNode = cubeTexture( background, transformDirection( positionWorld, modelWorldMatrix ) );
+
+				} else if ( background.isTexture === true ) {
+
+					let nodeUV = null;
+
+					if ( background.mapping === EquirectangularReflectionMapping || background.mapping === EquirectangularRefractionMapping ) {
+
+						nodeUV = equirectUV();
+
+					} else {
+
+						nodeUV = viewportBottomLeft;
+
+					}
+
+					backgroundNode = texture( background, nodeUV );
+
+				} else if ( background.isColor !== true ) {
+
+					console.error( 'WebGPUNodes: Unsupported background configuration.', background );
+
+				}
+
+				sceneProperties.backgroundNode = backgroundNode;
+				sceneProperties.background = background;
+
+			}
+
+		} else if ( sceneProperties.backgroundNode ) {
+
+			delete sceneProperties.backgroundNode;
+			delete sceneProperties.background;
+
+		}
+
+	}
+
+	updateFog( scene ) {
+
+		const sceneProperties = this.properties.get( scene );
+		const fog = scene.fog;
+
+		if ( fog ) {
+
+			if ( sceneProperties.fog !== fog ) {
+
+				let fogNode = null;
+
+				if ( fog.isFogExp2 ) {
+
+					fogNode = densityFog( reference( 'color', 'color', fog ), reference( 'density', 'float', fog ) );
+
+				} else if ( fog.isFog ) {
+
+					fogNode = rangeFog( reference( 'color', 'color', fog ), reference( 'near', 'float', fog ), reference( 'far', 'float', fog ) );
+
+				} else {
+
+					console.error( 'WebGPUNodes: Unsupported fog configuration.', fog );
+
+				}
+
+				sceneProperties.fogNode = fogNode;
+				sceneProperties.fog = fog;
+
+			}
+
+		} else {
+
+			delete sceneProperties.fogNode;
+			delete sceneProperties.fog;
+
+		}
+
+	}
+
+	updateEnvironment( scene ) {
+
+		const sceneProperties = this.properties.get( scene );
+		const environment = scene.environment;
+
+		if ( environment ) {
+
+			if ( sceneProperties.environment !== environment ) {
+
+				let environmentNode = null;
+
+				if ( environment.isCubeTexture === true ) {
+
+					environmentNode = cubeTexture( environment );
+
+				} else if ( environment.isTexture === true ) {
+
+					environmentNode = texture( environment );
+
+				} else {
+
+					console.error( 'WebGPUNodes: Unsupported environment configuration.', environment );
+
+				}
+
+				sceneProperties.environmentNode = environmentNode;
+				sceneProperties.environment = environment;
+
+			}
+
+		} else if ( sceneProperties.environmentNode ) {
+
+			delete sceneProperties.environmentNode;
+			delete sceneProperties.environment;
+
+		}
+
+	}
+
+	getNodeFrame( renderObject ) {
 
-		const nodeBuilder = this.get( object );
 		const nodeFrame = this.nodeFrame;
+		nodeFrame.scene = renderObject.scene;
+		nodeFrame.object = renderObject.object;
+		nodeFrame.camera = renderObject.camera;
+		nodeFrame.renderer = renderObject.renderer;
+		nodeFrame.material = renderObject.material;
+
+		return nodeFrame;
+
+	}
+
+	updateBefore( renderObject ) {
+
+		const nodeFrame = this.getNodeFrame( renderObject );
+		const nodeBuilder = this.get( renderObject );
+
+		for ( const node of nodeBuilder.updateBeforeNodes ) {
+
+			nodeFrame.updateBeforeNode( node );
+
+		}
+
+	}
+
+	update( renderObject ) {
 
-		nodeFrame.object = object;
-		nodeFrame.camera = camera;
-		nodeFrame.renderer = renderer;
-		nodeFrame.material = material;
+		const nodeFrame = this.getNodeFrame( renderObject );
+		const nodeBuilder = this.get( renderObject );
 
 		for ( const node of nodeBuilder.updateNodes ) {
 

package/examples/jsm/shaders/MMDToonShader.js

@@ -83,7 +83,16 @@ const MMDToonShader = {
 		ShaderLib.matcap.uniforms,
 	] ),
 
-	vertexShader: ShaderLib.phong.vertexShader,
+	vertexShader:
+		ShaderLib.phong.vertexShader
+			.replace(
+				'#include <envmap_pars_vertex>',
+				''
+			)
+			.replace(
+				'#include <envmap_vertex>',
+				''
+			),
 
 	fragmentShader:
 		ShaderLib.phong.fragmentShader
@@ -101,9 +110,12 @@ const MMDToonShader = {
 				'#include <envmap_common_pars_fragment>',
 				`
 					#include <gradientmap_pars_fragment>
-					#include <envmap_common_pars_fragment>
 				`
 			)
+			.replace(
+				'#include <envmap_pars_fragment>',
+				''
+			)
 			.replace(
 				'#include <lights_phong_pars_fragment>',
 				lights_mmd_toon_pars_fragment
@@ -111,10 +123,9 @@ const MMDToonShader = {
 			.replace(
 				'#include <envmap_fragment>',
 				`
-					#include <envmap_fragment>
 					${mmd_toon_matcap_fragment}
 				`
-			),
+			)
 
 };
 

package/examples/jsm/shaders/RGBShiftShader.js

@@ -1,8 +1,8 @@
 /**
  * RGB Shift Shader
  * Shifts red and blue channels from center in opposite directions
- * Ported from http://kriss.cx/tom/2009/05/rgb-shift/
- * by Tom Butterworth / http://kriss.cx/tom/
+ * Ported from https://web.archive.org/web/20090820185047/http://kriss.cx/tom/2009/05/rgb-shift/
+ * by Tom Butterworth / https://web.archive.org/web/20090810054752/http://kriss.cx/tom/
  *
  * amount: shift distance (1 is width of input)
  * angle: shift angle in radians

package/examples/jsm/shaders/VelocityShader.js

@@ -23,7 +23,7 @@ const VelocityShader = {
 	vertexShader: /* glsl */`
 #define NORMAL
 
-#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
+#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )
 
 	varying vec3 vViewPosition;
 

package/examples/jsm/utils/BufferGeometryUtils.js

@@ -11,12 +11,6 @@ import {
 	Vector3,
 } from 'three';
 
-function computeTangents() {
-
-	throw new Error( 'BufferGeometryUtils: computeTangents renamed to computeMikkTSpaceTangents.' );
-
-}
-
 function computeMikkTSpaceTangents( geometry, MikkTSpace, negateSign = true ) {
 
 	if ( ! MikkTSpace || ! MikkTSpace.isReady ) {
@@ -35,9 +29,9 @@ function computeMikkTSpaceTangents( geometry, MikkTSpace, negateSign = true ) {
 
 		if ( attribute.normalized || attribute.isInterleavedBufferAttribute ) {
 
-			const dstArray = new Float32Array( attribute.getCount() * attribute.itemSize );
+			const dstArray = new Float32Array( attribute.count * attribute.itemSize );
 
-			for ( let i = 0, j = 0; i < attribute.getCount(); i ++ ) {
+			for ( let i = 0, j = 0; i < attribute.count; i ++ ) {
 
 				dstArray[ j ++ ] = attribute.getX( i );
 				dstArray[ j ++ ] = attribute.getY( i );
@@ -110,7 +104,7 @@ function computeMikkTSpaceTangents( geometry, MikkTSpace, negateSign = true ) {
  * @param  {Boolean} useGroups
  * @return {BufferGeometry}
  */
-function mergeBufferGeometries( geometries, useGroups = false ) {
+function mergeGeometries( geometries, useGroups = false ) {
 
 	const isIndexed = geometries[ 0 ].index !== null;
 
@@ -135,7 +129,7 @@ function mergeBufferGeometries( geometries, useGroups = false ) {
 
 		if ( isIndexed !== ( geometry.index !== null ) ) {
 
-			console.error( 'THREE.BufferGeometryUtils: .mergeBufferGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure index attribute exists among all geometries, or in none of them.' );
+			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure index attribute exists among all geometries, or in none of them.' );
 			return null;
 
 		}
@@ -146,7 +140,7 @@ function mergeBufferGeometries( geometries, useGroups = false ) {
 
 			if ( ! attributesUsed.has( name ) ) {
 
-				console.error( 'THREE.BufferGeometryUtils: .mergeBufferGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure "' + name + '" attribute exists among all geometries, or in none of them.' );
+				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure "' + name + '" attribute exists among all geometries, or in none of them.' );
 				return null;
 
 			}
@@ -163,7 +157,7 @@ function mergeBufferGeometries( geometries, useGroups = false ) {
 
 		if ( attributesCount !== attributesUsed.size ) {
 
-			console.error( 'THREE.BufferGeometryUtils: .mergeBufferGeometries() failed with geometry at index ' + i + '. Make sure all geometries have the same number of attributes.' );
+			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. Make sure all geometries have the same number of attributes.' );
 			return null;
 
 		}
@@ -172,7 +166,7 @@ function mergeBufferGeometries( geometries, useGroups = false ) {
 
 		if ( morphTargetsRelative !== geometry.morphTargetsRelative ) {
 
-			console.error( 'THREE.BufferGeometryUtils: .mergeBufferGeometries() failed with geometry at index ' + i + '. .morphTargetsRelative must be consistent throughout all geometries.' );
+			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. .morphTargetsRelative must be consistent throughout all geometries.' );
 			return null;
 
 		}
@@ -181,7 +175,7 @@ function mergeBufferGeometries( geometries, useGroups = false ) {
 
 			if ( ! morphAttributesUsed.has( name ) ) {
 
-				console.error( 'THREE.BufferGeometryUtils: .mergeBufferGeometries() failed with geometry at index ' + i + '.  .morphAttributes must be consistent throughout all geometries.' );
+				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '.  .morphAttributes must be consistent throughout all geometries.' );
 				return null;
 
 			}
@@ -206,7 +200,7 @@ function mergeBufferGeometries( geometries, useGroups = false ) {
 
 			} else {
 
-				console.error( 'THREE.BufferGeometryUtils: .mergeBufferGeometries() failed with geometry at index ' + i + '. The geometry must have either an index or a position attribute' );
+				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. The geometry must have either an index or a position attribute' );
 				return null;
 
 			}
@@ -248,11 +242,11 @@ function mergeBufferGeometries( geometries, useGroups = false ) {
 
 	for ( const name in attributes ) {
 
-		const mergedAttribute = mergeBufferAttributes( attributes[ name ] );
+		const mergedAttribute = mergeAttributes( attributes[ name ] );
 
 		if ( ! mergedAttribute ) {
 
-			console.error( 'THREE.BufferGeometryUtils: .mergeBufferGeometries() failed while trying to merge the ' + name + ' attribute.' );
+			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' attribute.' );
 			return null;
 
 		}
@@ -282,11 +276,11 @@ function mergeBufferGeometries( geometries, useGroups = false ) {
 
 			}
 
-			const mergedMorphAttribute = mergeBufferAttributes( morphAttributesToMerge );
+			const mergedMorphAttribute = mergeAttributes( morphAttributesToMerge );
 
 			if ( ! mergedMorphAttribute ) {
 
-				console.error( 'THREE.BufferGeometryUtils: .mergeBufferGeometries() failed while trying to merge the ' + name + ' morphAttribute.' );
+				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' morphAttribute.' );
 				return null;
 
 			}
@@ -305,7 +299,7 @@ function mergeBufferGeometries( geometries, useGroups = false ) {
  * @param {Array<BufferAttribute>} attributes
  * @return {BufferAttribute}
  */
-function mergeBufferAttributes( attributes ) {
+function mergeAttributes( attributes ) {
 
 	let TypedArray;
 	let itemSize;
@@ -318,7 +312,7 @@ function mergeBufferAttributes( attributes ) {
 
 		if ( attribute.isInterleavedBufferAttribute ) {
 
-			console.error( 'THREE.BufferGeometryUtils: .mergeBufferAttributes() failed. InterleavedBufferAttributes are not supported.' );
+			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. InterleavedBufferAttributes are not supported.' );
 			return null;
 
 		}
@@ -326,7 +320,7 @@ function mergeBufferAttributes( attributes ) {
 		if ( TypedArray === undefined ) TypedArray = attribute.array.constructor;
 		if ( TypedArray !== attribute.array.constructor ) {
 
-			console.error( 'THREE.BufferGeometryUtils: .mergeBufferAttributes() failed. BufferAttribute.array must be of consistent array types across matching attributes.' );
+			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.array must be of consistent array types across matching attributes.' );
 			return null;
 
 		}
@@ -334,7 +328,7 @@ function mergeBufferAttributes( attributes ) {
 		if ( itemSize === undefined ) itemSize = attribute.itemSize;
 		if ( itemSize !== attribute.itemSize ) {
 
-			console.error( 'THREE.BufferGeometryUtils: .mergeBufferAttributes() failed. BufferAttribute.itemSize must be consistent across matching attributes.' );
+			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.itemSize must be consistent across matching attributes.' );
 			return null;
 
 		}
@@ -342,7 +336,7 @@ function mergeBufferAttributes( attributes ) {
 		if ( normalized === undefined ) normalized = attribute.normalized;
 		if ( normalized !== attribute.normalized ) {
 
-			console.error( 'THREE.BufferGeometryUtils: .mergeBufferAttributes() failed. BufferAttribute.normalized must be consistent across matching attributes.' );
+			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.normalized must be consistent across matching attributes.' );
 			return null;
 
 		}
@@ -844,13 +838,6 @@ function toTrianglesDrawMode( geometry, drawMode ) {
  */
 function computeMorphedAttributes( object ) {
 
-	if ( object.geometry.isBufferGeometry !== true ) {
-
-		console.error( 'THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.' );
-		return null;
-
-	}
-
 	const _vA = new Vector3();
 	const _vB = new Vector3();
 	const _vC = new Vector3();
@@ -921,9 +908,9 @@ function computeMorphedAttributes( object ) {
 
 		if ( object.isSkinnedMesh ) {
 
-			object.boneTransform( a, _vA );
-			object.boneTransform( b, _vB );
-			object.boneTransform( c, _vC );
+			object.applyBoneTransform( a, _vA );
+			object.applyBoneTransform( b, _vB );
+			object.applyBoneTransform( c, _vC );
 
 		}
 
@@ -1331,10 +1318,25 @@ function toCreasedNormals( geometry, creaseAngle = Math.PI / 3 /* 60 degrees */
 
 }
 
+function mergeBufferGeometries( geometries, useGroups = false ) {
+
+	console.warn( 'THREE.BufferGeometryUtils: mergeBufferGeometries() has been renamed to mergeGeometries().' ); // @deprecated, r151
+	return mergeGeometries( geometries, useGroups );
+
+}
+
+function mergeBufferAttributes( attributes ) {
+
+	console.warn( 'THREE.BufferGeometryUtils: mergeBufferAttributes() has been renamed to mergeAttributes().' ); // @deprecated, r151
+	return mergeAttributes( attributes );
+
+}
+
 export {
-	computeTangents,
 	computeMikkTSpaceTangents,
+	mergeGeometries,
 	mergeBufferGeometries,
+	mergeAttributes,
 	mergeBufferAttributes,
 	interleaveAttributes,
 	estimateBytesUsed,

package/examples/jsm/utils/LDrawUtils.js

@@ -7,7 +7,7 @@ import {
 	Mesh
 } from 'three';
 
-import { mergeBufferGeometries } from './BufferGeometryUtils.js';
+import { mergeGeometries } from './BufferGeometryUtils.js';
 
 class LDrawUtils {
 
@@ -165,7 +165,7 @@ class LDrawUtils {
 		for ( const meshMaterialsId of meshMaterialsIds ) {
 
 			const meshGeometry = meshGeometries[ meshMaterialsId ];
-			const mergedGeometry = mergeBufferGeometries( meshGeometry.arr );
+			const mergedGeometry = mergeGeometries( meshGeometry.arr );
 			mergedObject.add( new Mesh( mergedGeometry, meshGeometry.mat ) );
 
 		}
@@ -174,7 +174,7 @@ class LDrawUtils {
 		for ( const linesMaterialsId of linesMaterialsIds ) {
 
 			const lineGeometry = linesGeometries[ linesMaterialsId ];
-			const mergedGeometry = mergeBufferGeometries( lineGeometry.arr );
+			const mergedGeometry = mergeGeometries( lineGeometry.arr );
 			mergedObject.add( new LineSegments( mergedGeometry, lineGeometry.mat ) );
 
 		}
@@ -183,7 +183,7 @@ class LDrawUtils {
 		for ( const condLinesMaterialsId of condLinesMaterialsIds ) {
 
 			const condLineGeometry = condLinesGeometries[ condLinesMaterialsId ];
-			const mergedGeometry = mergeBufferGeometries( condLineGeometry.arr );
+			const mergedGeometry = mergeGeometries( condLineGeometry.arr );
 			const condLines = new LineSegments( mergedGeometry, condLineGeometry.mat );
 			condLines.isConditionalLine = true;
 			mergedObject.add( condLines );