super-three 0.164.0 → 0.167.0

package/{examples/jsm → src}/renderers/webgpu/utils/WebGPUUtils.js

@@ -76,15 +76,36 @@ class WebGPUUtils {
 
 	}
 
-	getSampleCount( renderContext ) {
+	getSampleCount( sampleCount ) {
+
+		let count = 1;
+
+		if ( sampleCount > 1 ) {
+
+			// WebGPU only supports power-of-two sample counts and 2 is not a valid value
+			count = Math.pow( 2, Math.floor( Math.log2( sampleCount ) ) );
+
+			if ( count === 2 ) {
+
+				count = 4;
+
+			}
+
+		}
+
+		return count;
+
+	}
+
+	getSampleCountRenderContext( renderContext ) {
 
 		if ( renderContext.textures !== null ) {
 
-			return renderContext.sampleCount;
+			return this.getSampleCount( renderContext.sampleCount );
 
 		}
 
-		return this.backend.parameters.sampleCount;
+		return this.getSampleCount( this.backend.renderer.samples );
 
 	}
 

package/src/renderers/webxr/WebXRDepthSensing.js

@@ -65,7 +65,7 @@ class WebXRDepthSensing {
 
 	}
 
-	render( renderer, cameraXR ) {
+	getMesh( cameraXR ) {
 
 		if ( this.texture !== null ) {
 
@@ -86,10 +86,10 @@ class WebXRDepthSensing {
 
 			}
 
-			renderer.render( this.mesh, cameraXR );
-
 		}
 
+		return this.mesh;
+
 	}
 
 	reset() {
@@ -99,6 +99,12 @@ class WebXRDepthSensing {
 
 	}
 
+	getDepthTexture() {
+
+		return this.texture;
+
+	}
+
 }
 
 export { WebXRDepthSensing };

package/src/renderers/webxr/WebXRManager.js

@@ -433,6 +433,12 @@ class WebXRManager extends EventDispatcher {
 			session.updateRenderState( { layers: layersCopy } );
 		}
 
+		this.getDepthTexture = function () {
+
+			return depthSensing.getDepthTexture();
+
+		};
+
 		function onInputSourcesChange( event ) {
 
 			// Notify disconnected
@@ -725,6 +731,12 @@ class WebXRManager extends EventDispatcher {
 
 		};
 
+		this.getDepthSensingMesh = function () {
+
+			return depthSensing.getMesh( cameraXR );
+
+		};
+
 		// Animation Loop
 
 		let onAnimationFrameCallback = null;
@@ -850,8 +862,6 @@ class WebXRManager extends EventDispatcher {
 
 			}
 
-			depthSensing.render( renderer, cameraXR );
-
 			if ( onAnimationFrameCallback ) onAnimationFrameCallback( time, frame );
 
 			if ( frame.detectedPlanes ) {

package/src/textures/CompressedArrayTexture.js

@@ -11,6 +11,20 @@ class CompressedArrayTexture extends CompressedTexture {
 		this.image.depth = depth;
 		this.wrapR = ClampToEdgeWrapping;
 
+		this.layerUpdates = new Set();
+
+	}
+
+	addLayerUpdate( layerIndex ) {
+
+		this.layerUpdates.add( layerIndex );
+
+	}
+
+	clearLayerUpdates() {
+
+		this.layerUpdates.clear();
+
 	}
 
 }

package/src/textures/DataArrayTexture.js

@@ -20,6 +20,20 @@ class DataArrayTexture extends Texture {
 		this.flipY = false;
 		this.unpackAlignment = 1;
 
+		this.layerUpdates = new Set();
+
+	}
+
+	addLayerUpdate( layerIndex ) {
+
+		this.layerUpdates.add( layerIndex );
+
+	}
+
+	clearLayerUpdates() {
+
+		this.layerUpdates.clear();
+
 	}
 
 }

package/src/textures/DepthTexture.js

@@ -3,9 +3,7 @@ import { NearestFilter, UnsignedIntType, UnsignedInt248Type, DepthFormat, DepthS
 
 class DepthTexture extends Texture {
 
-	constructor( width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format ) {
-
-		format = format !== undefined ? format : DepthFormat;
+	constructor( width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format = DepthFormat ) {
 
 		if ( format !== DepthFormat && format !== DepthStencilFormat ) {
 

package/src/utils.js

@@ -88,4 +88,33 @@ function warnOnce( message ) {
 
 }
 
-export { arrayMin, arrayMax, arrayNeedsUint32, getTypedArray, createElementNS, createCanvasElement, warnOnce };
+function probeAsync( gl, sync, interval ) {
+
+	return new Promise( function ( resolve, reject ) {
+
+		function probe() {
+
+			switch ( gl.clientWaitSync( sync, gl.SYNC_FLUSH_COMMANDS_BIT, 0 ) ) {
+
+				case gl.WAIT_FAILED:
+					reject();
+					break;
+
+				case gl.TIMEOUT_EXPIRED:
+					setTimeout( probe, interval );
+					break;
+
+				default:
+					resolve();
+
+			}
+
+		}
+
+		setTimeout( probe, interval );
+
+	} );
+
+}
+
+export { arrayMin, arrayMax, arrayNeedsUint32, getTypedArray, createElementNS, createCanvasElement, warnOnce, probeAsync };

package/examples/jsm/nodes/accessors/BitangentNode.js

@@ -1,89 +0,0 @@
-import Node, { addNodeClass } from '../core/Node.js';
-import { varying } from '../core/VaryingNode.js';
-import { normalize } from '../math/MathNode.js';
-import { cameraViewMatrix } from './CameraNode.js';
-import { normalGeometry, normalLocal, normalView, normalWorld, transformedNormalView } from './NormalNode.js';
-import { tangentGeometry, tangentLocal, tangentView, tangentWorld, transformedTangentView } from './TangentNode.js';
-import { nodeImmutable } from '../shadernode/ShaderNode.js';
-
-class BitangentNode extends Node {
-
-	constructor( scope = BitangentNode.LOCAL ) {
-
-		super( 'vec3' );
-
-		this.scope = scope;
-
-	}
-
-	getHash( /*builder*/ ) {
-
-		return `bitangent-${this.scope}`;
-
-	}
-
-	generate( builder ) {
-
-		const scope = this.scope;
-
-		let crossNormalTangent;
-
-		if ( scope === BitangentNode.GEOMETRY ) {
-
-			crossNormalTangent = normalGeometry.cross( tangentGeometry );
-
-		} else if ( scope === BitangentNode.LOCAL ) {
-
-			crossNormalTangent = normalLocal.cross( tangentLocal );
-
-		} else if ( scope === BitangentNode.VIEW ) {
-
-			crossNormalTangent = normalView.cross( tangentView );
-
-		} else if ( scope === BitangentNode.WORLD ) {
-
-			crossNormalTangent = normalWorld.cross( tangentWorld );
-
-		}
-
-		const vertexNode = crossNormalTangent.mul( tangentGeometry.w ).xyz;
-
-		const outputNode = normalize( varying( vertexNode ) );
-
-		return outputNode.build( builder, this.getNodeType( builder ) );
-
-	}
-
-	serialize( data ) {
-
-		super.serialize( data );
-
-		data.scope = this.scope;
-
-	}
-
-	deserialize( data ) {
-
-		super.deserialize( data );
-
-		this.scope = data.scope;
-
-	}
-
-}
-
-BitangentNode.GEOMETRY = 'geometry';
-BitangentNode.LOCAL = 'local';
-BitangentNode.VIEW = 'view';
-BitangentNode.WORLD = 'world';
-
-export default BitangentNode;
-
-export const bitangentGeometry = nodeImmutable( BitangentNode, BitangentNode.GEOMETRY );
-export const bitangentLocal = nodeImmutable( BitangentNode, BitangentNode.LOCAL );
-export const bitangentView = nodeImmutable( BitangentNode, BitangentNode.VIEW );
-export const bitangentWorld = nodeImmutable( BitangentNode, BitangentNode.WORLD );
-export const transformedBitangentView = normalize( transformedNormalView.cross( transformedTangentView ).mul( tangentGeometry.w ) );
-export const transformedBitangentWorld = normalize( transformedBitangentView.transformDirection( cameraViewMatrix ) );
-
-addNodeClass( 'BitangentNode', BitangentNode );

package/examples/jsm/nodes/accessors/CameraNode.js

@@ -1,119 +0,0 @@
-import Object3DNode from './Object3DNode.js';
-import { addNodeClass } from '../core/Node.js';
-import { NodeUpdateType } from '../core/constants.js';
-//import { sharedUniformGroup } from '../core/UniformGroupNode.js';
-import { nodeImmutable } from '../shadernode/ShaderNode.js';
-
-//const cameraGroup = sharedUniformGroup( 'camera' );
-
-class CameraNode extends Object3DNode {
-
-	constructor( scope = CameraNode.POSITION ) {
-
-		super( scope );
-
-		this.updateType = NodeUpdateType.RENDER;
-
-		//this._uniformNode.groupNode = cameraGroup;
-
-	}
-
-	getNodeType( builder ) {
-
-		const scope = this.scope;
-
-		if ( scope === CameraNode.PROJECTION_MATRIX || scope === CameraNode.PROJECTION_MATRIX_INVERSE ) {
-
-			return 'mat4';
-
-		} else if ( scope === CameraNode.NEAR || scope === CameraNode.FAR || scope === CameraNode.LOG_DEPTH ) {
-
-			return 'float';
-
-		}
-
-		return super.getNodeType( builder );
-
-	}
-
-	update( frame ) {
-
-		const camera = frame.camera;
-		const uniformNode = this._uniformNode;
-		const scope = this.scope;
-
-		//cameraGroup.needsUpdate = true;
-
-		if ( scope === CameraNode.VIEW_MATRIX ) {
-
-			uniformNode.value = camera.matrixWorldInverse;
-
-		} else if ( scope === CameraNode.PROJECTION_MATRIX ) {
-
-			uniformNode.value = camera.projectionMatrix;
-
-		} else if ( scope === CameraNode.PROJECTION_MATRIX_INVERSE ) {
-
-			uniformNode.value = camera.projectionMatrixInverse;
-
-		} else if ( scope === CameraNode.NEAR ) {
-
-			uniformNode.value = camera.near;
-
-		} else if ( scope === CameraNode.FAR ) {
-
-			uniformNode.value = camera.far;
-
-		} else if ( scope === CameraNode.LOG_DEPTH ) {
-
-			uniformNode.value = 2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 );
-
-		} else {
-
-			this.object3d = camera;
-
-			super.update( frame );
-
-		}
-
-	}
-
-	generate( builder ) {
-
-		const scope = this.scope;
-
-		if ( scope === CameraNode.PROJECTION_MATRIX || scope === CameraNode.PROJECTION_MATRIX_INVERSE ) {
-
-			this._uniformNode.nodeType = 'mat4';
-
-		} else if ( scope === CameraNode.NEAR || scope === CameraNode.FAR || scope === CameraNode.LOG_DEPTH ) {
-
-			this._uniformNode.nodeType = 'float';
-
-		}
-
-		return super.generate( builder );
-
-	}
-
-}
-
-CameraNode.PROJECTION_MATRIX = 'projectionMatrix';
-CameraNode.PROJECTION_MATRIX_INVERSE = 'projectionMatrixInverse';
-CameraNode.NEAR = 'near';
-CameraNode.FAR = 'far';
-CameraNode.LOG_DEPTH = 'logDepth';
-
-export default CameraNode;
-
-export const cameraProjectionMatrix = nodeImmutable( CameraNode, CameraNode.PROJECTION_MATRIX );
-export const cameraProjectionMatrixInverse = nodeImmutable( CameraNode, CameraNode.PROJECTION_MATRIX_INVERSE );
-export const cameraNear = nodeImmutable( CameraNode, CameraNode.NEAR );
-export const cameraFar = nodeImmutable( CameraNode, CameraNode.FAR );
-export const cameraLogDepth = nodeImmutable( CameraNode, CameraNode.LOG_DEPTH );
-export const cameraViewMatrix = nodeImmutable( CameraNode, CameraNode.VIEW_MATRIX );
-export const cameraNormalMatrix = nodeImmutable( CameraNode, CameraNode.NORMAL_MATRIX );
-export const cameraWorldMatrix = nodeImmutable( CameraNode, CameraNode.WORLD_MATRIX );
-export const cameraPosition = nodeImmutable( CameraNode, CameraNode.POSITION );
-
-addNodeClass( 'CameraNode', CameraNode );

package/examples/jsm/nodes/accessors/InstanceNode.js

@@ -1,94 +0,0 @@
-import Node, { addNodeClass } from '../core/Node.js';
-import { varyingProperty } from '../core/PropertyNode.js';
-import { instancedBufferAttribute, instancedDynamicBufferAttribute } from './BufferAttributeNode.js';
-import { normalLocal } from './NormalNode.js';
-import { positionLocal } from './PositionNode.js';
-import { nodeProxy, vec3, mat3, mat4 } from '../shadernode/ShaderNode.js';
-import { DynamicDrawUsage, InstancedInterleavedBuffer, InstancedBufferAttribute } from 'three';
-
-class InstanceNode extends Node {
-
-	constructor( instanceMesh ) {
-
-		super( 'void' );
-
-		this.instanceMesh = instanceMesh;
-
-		this.instanceMatrixNode = null;
-
-		this.instanceColorNode = null;
-
-	}
-
-	setup( /*builder*/ ) {
-
-		let instanceMatrixNode = this.instanceMatrixNode;
-
-		const instanceMesh = this.instanceMesh;
-
-		if ( instanceMatrixNode === null ) {
-
-			const instanceAttribute = instanceMesh.instanceMatrix;
-			const buffer = new InstancedInterleavedBuffer( instanceAttribute.array, 16, 1 );
-
-			const bufferFn = instanceAttribute.usage === DynamicDrawUsage ? instancedDynamicBufferAttribute : instancedBufferAttribute;
-
-			const instanceBuffers = [
-				// F.Signature -> bufferAttribute( array, type, stride, offset )
-				bufferFn( buffer, 'vec4', 16, 0 ),
-				bufferFn( buffer, 'vec4', 16, 4 ),
-				bufferFn( buffer, 'vec4', 16, 8 ),
-				bufferFn( buffer, 'vec4', 16, 12 )
-			];
-
-			instanceMatrixNode = mat4( ...instanceBuffers );
-
-			this.instanceMatrixNode = instanceMatrixNode;
-
-		}
-
-		const instanceColorAttribute = instanceMesh.instanceColor;
-
-		if ( instanceColorAttribute && this.instanceColorNode === null ) {
-
-			const buffer = new InstancedBufferAttribute( instanceColorAttribute.array, 3 );
-			const bufferFn = instanceColorAttribute.usage === DynamicDrawUsage ? instancedDynamicBufferAttribute : instancedBufferAttribute;
-
-			this.instanceColorNode = vec3( bufferFn( buffer, 'vec3', 3, 0 ) );
-
-		}
-
-		// POSITION
-
-		const instancePosition = instanceMatrixNode.mul( positionLocal ).xyz;
-
-		// NORMAL
-
-		const m = mat3( instanceMatrixNode[ 0 ].xyz, instanceMatrixNode[ 1 ].xyz, instanceMatrixNode[ 2 ].xyz );
-
-		const transformedNormal = normalLocal.div( vec3( m[ 0 ].dot( m[ 0 ] ), m[ 1 ].dot( m[ 1 ] ), m[ 2 ].dot( m[ 2 ] ) ) );
-
-		const instanceNormal = m.mul( transformedNormal ).xyz;
-
-		// ASSIGNS
-
-		positionLocal.assign( instancePosition );
-		normalLocal.assign( instanceNormal );
-
-		// COLOR
-
-		if ( this.instanceColorNode !== null ) {
-
-			varyingProperty( 'vec3', 'vInstanceColor' ).assign( this.instanceColorNode );
-
-		}
-
-	}
-
-}
-
-export default InstanceNode;
-
-export const instance = nodeProxy( InstanceNode );
-
-addNodeClass( 'InstanceNode', InstanceNode );

package/examples/jsm/nodes/accessors/NormalNode.js

@@ -1,106 +0,0 @@
-import Node, { addNodeClass } from '../core/Node.js';
-import { attribute } from '../core/AttributeNode.js';
-import { varying } from '../core/VaryingNode.js';
-import { property } from '../core/PropertyNode.js';
-import { normalize } from '../math/MathNode.js';
-import { cameraViewMatrix } from './CameraNode.js';
-import { modelNormalMatrix } from './ModelNode.js';
-import { nodeImmutable, vec3 } from '../shadernode/ShaderNode.js';
-
-class NormalNode extends Node {
-
-	constructor( scope = NormalNode.LOCAL ) {
-
-		super( 'vec3' );
-
-		this.scope = scope;
-
-	}
-
-	isGlobal() {
-
-		return true;
-
-	}
-
-	getHash( /*builder*/ ) {
-
-		return `normal-${this.scope}`;
-
-	}
-
-	generate( builder ) {
-
-		const scope = this.scope;
-
-		let outputNode = null;
-
-		if ( scope === NormalNode.GEOMETRY ) {
-
-			const geometryAttribute = builder.hasGeometryAttribute( 'normal' );
-
-			if ( geometryAttribute === false ) {
-
-				outputNode = vec3( 0, 1, 0 );
-
-			} else {
-
-				outputNode = attribute( 'normal', 'vec3' );
-
-			}
-
-		} else if ( scope === NormalNode.LOCAL ) {
-
-			outputNode = varying( normalGeometry );
-
-		} else if ( scope === NormalNode.VIEW ) {
-
-			const vertexNode = modelNormalMatrix.mul( normalLocal );
-			outputNode = normalize( varying( vertexNode ) );
-
-		} else if ( scope === NormalNode.WORLD ) {
-
-			// To use inverseTransformDirection only inverse the param order like this: cameraViewMatrix.transformDirection( normalView )
-			const vertexNode = normalView.transformDirection( cameraViewMatrix );
-			outputNode = normalize( varying( vertexNode ) );
-
-		}
-
-		return outputNode.build( builder, this.getNodeType( builder ) );
-
-	}
-
-	serialize( data ) {
-
-		super.serialize( data );
-
-		data.scope = this.scope;
-
-	}
-
-	deserialize( data ) {
-
-		super.deserialize( data );
-
-		this.scope = data.scope;
-
-	}
-
-}
-
-NormalNode.GEOMETRY = 'geometry';
-NormalNode.LOCAL = 'local';
-NormalNode.VIEW = 'view';
-NormalNode.WORLD = 'world';
-
-export default NormalNode;
-
-export const normalGeometry = nodeImmutable( NormalNode, NormalNode.GEOMETRY );
-export const normalLocal = nodeImmutable( NormalNode, NormalNode.LOCAL ).temp( 'Normal' );
-export const normalView = nodeImmutable( NormalNode, NormalNode.VIEW );
-export const normalWorld = nodeImmutable( NormalNode, NormalNode.WORLD );
-export const transformedNormalView = property( 'vec3', 'TransformedNormalView' );
-export const transformedNormalWorld = transformedNormalView.transformDirection( cameraViewMatrix ).normalize();
-export const transformedClearcoatNormalView = property( 'vec3', 'TransformedClearcoatNormalView' );
-
-addNodeClass( 'NormalNode', NormalNode );