three-gpu-pathtracer 0.0.23 → 0.0.25

package/build/index.umd.cjs

@@ -279,7 +279,20 @@
 				const attr = geometry.getAttribute( key );
 	 			if ( ! skip ) {
 
-					copyAttributeContents( attr, targetAttribute, offset );
+					if ( key === 'color' && targetAttribute.itemSize !== attr.itemSize ) {
+
+						// make sure the color attribute is aligned with itemSize 3 to 4
+						for ( let index = offset, l = attr.count; index < l; index ++ ) {
+
+							attr.setXYZW( index, targetAttribute.getX( index ), targetAttribute.getY( index ), targetAttribute.getZ( index ), 1.0 );
+
+						}
+
+					} else {
+
+						copyAttributeContents( attr, targetAttribute, offset );
+
+					}
 
 				}
 
@@ -1317,6 +1330,7 @@
 			this._bvhWorker = null;
 			this._pendingGenerate = null;
 			this._buildAsync = false;
+			this._materialUuids = null;
 
 		}
 
@@ -1398,12 +1412,29 @@
 			// generate the geometry
 			const result = staticGeometryGenerator.generate( geometry );
 			const materials = result.materials;
+			let needsMaterialIndexUpdate = result.changeType !== NO_CHANGE || this._materialUuids === null || this._materialUuids.length !== length;
+			if ( ! needsMaterialIndexUpdate ) {
+
+				for ( let i = 0, length = materials.length; i < length; i ++ ) {
+
+					const material = materials[ i ];
+					if ( material.uuid !== this._materialUuids[ i ] ) {
+
+						needsMaterialIndexUpdate = true;
+						break;
+
+					}
+
+				}
+
+			}
+
 			const textures = getTextures$1( materials );
 			const { lights, iesTextures } = getLights$1( objects );
-
-			if ( result.changeType !== NO_CHANGE ) {
+			if ( needsMaterialIndexUpdate ) {
 
 				updateMaterialIndexAttribute( geometry, materials, materials );
+				this._materialUuids = materials.map( material => material.uuid );
 
 			}
 
@@ -1447,6 +1478,7 @@
 			return {
 				bvhChanged: result.changeType !== NO_CHANGE,
 				bvh: this.bvh,
+				needsMaterialIndexUpdate,
 				lights,
 				iesTextures,
 				geometry,
@@ -2216,6 +2248,12 @@
 
 		}
 
+		getPixelWeight( r, g, b ) {
+
+			return colorToLuminance( r, g, b );
+
+		}
+
 		dispose() {
 
 			this.marginalWeights.dispose();
@@ -2256,10 +2294,9 @@
 					const g = three.DataUtils.fromHalfFloat( data[ 4 * i + 1 ] );
 					const b = three.DataUtils.fromHalfFloat( data[ 4 * i + 2 ] );
 
-					// the probability of the pixel being selected in this row is the
-					// scale of the luminance relative to the rest of the pixels.
-					// TODO: this should also account for the solid angle of the pixel when sampling
-					const weight = colorToLuminance( r, g, b );
+					// the probability of the pixel being selected in its row is proportional
+					// to its luminance relative to the other pixels.
+					const weight = this.getPixelWeight( r, g, b, y, height );
 					cumulativeRowWeight += weight;
 					totalSumValue += weight;
 
@@ -2590,17 +2627,17 @@
 		let maxValue = 1.0;
 		switch ( fromArray.constructor ) {
 
-		case Uint8Array:
-		case Uint16Array:
-		case Uint32Array:
-			maxValue = 2 ** bpe - 1;
-			break;
+			case Uint8Array:
+			case Uint16Array:
+			case Uint32Array:
+				maxValue = 2 ** bpe - 1;
+				break;
 
-		case Int8Array:
-		case Int16Array:
-		case Int32Array:
-			maxValue = 2 ** ( bpe - 1 ) - 1;
-			break;
+			case Int8Array:
+			case Int16Array:
+			case Int32Array:
+				maxValue = 2 ** ( bpe - 1 ) - 1;
+				break;
 
 		}
 
@@ -2851,20 +2888,16 @@
 	function getLights( scene ) {
 
 		const lights = [];
-		scene.traverse( c => {
-
-			if ( c.visible ) {
+		scene.traverseVisible( c => {
 
-				if (
-					c.isRectAreaLight ||
-					c.isSpotLight ||
-					c.isPointLight ||
-					c.isDirectionalLight
-				) {
-
-					lights.push( c );
+			if (
+				c.isRectAreaLight ||
+				c.isSpotLight ||
+				c.isPointLight ||
+				c.isDirectionalLight
+			) {
 
-				}
+				lights.push( c );
 
 			}
 
@@ -2874,7 +2907,7 @@
 
 	}
 
-	const MATERIAL_PIXELS = 45;
+	const MATERIAL_PIXELS = 47;
 	const MATERIAL_STRIDE = MATERIAL_PIXELS * 4;
 
 	class MaterialFeatures {
@@ -3234,15 +3267,15 @@
 
 					switch ( m.side ) {
 
-					case three.FrontSide:
-						floatArray[ index ++ ] = 1;
-						break;
-					case three.BackSide:
-						floatArray[ index ++ ] = - 1;
-						break;
-					case three.DoubleSide:
-						floatArray[ index ++ ] = 0;
-						break;
+						case three.FrontSide:
+							floatArray[ index ++ ] = 1;
+							break;
+						case three.BackSide:
+							floatArray[ index ++ ] = - 1;
+							break;
+						case three.DoubleSide:
+							floatArray[ index ++ ] = 0;
+							break;
 
 					}
 
@@ -3299,6 +3332,9 @@
 				// specularIntensityMap transform 43
 				index += writeTextureMatrixToArray( m, 'specularIntensityMap', floatArray, index );
 
+				// alphaMap transform 45
+				index += writeTextureMatrixToArray( m, 'alphaMap', floatArray, index );
+
 			}
 
 			// check if the contents have changed
@@ -4112,12 +4148,12 @@
 
 		switch ( channels ) {
 
-		case 1:
-			return three.RedFormat;
-		case 2:
-			return three.RGFormat;
-		default:
-			return three.RGBAFormat;
+			case 1:
+				return three.RedFormat;
+			case 2:
+				return three.RGFormat;
+			default:
+				return three.RGBAFormat;
 
 		}
 
@@ -4378,6 +4414,7 @@
 		mat3 iridescenceThicknessMapTransform;
 		mat3 specularColorMapTransform;
 		mat3 specularIntensityMapTransform;
+		mat3 alphaMapTransform;
 
 	};
 
@@ -4398,7 +4435,7 @@
 
 	Material readMaterialInfo( sampler2D tex, uint index ) {
 
-		uint i = index * 45u;
+		uint i = index * uint( MATERIAL_PIXELS );
 
 		vec4 s0 = texelFetch1D( tex, i + 0u );
 		vec4 s1 = texelFetch1D( tex, i + 1u );
@@ -4497,6 +4534,7 @@
 		m.iridescenceThicknessMapTransform = m.iridescenceThicknessMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 24u );
 		m.specularColorMapTransform = m.specularColorMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 26u );
 		m.specularIntensityMapTransform = m.specularIntensityMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 28u );
+		m.alphaMapTransform = m.alphaMap == - 1 ? mat3( 1.0 ) : readTextureTransform( tex, firstTextureTransformIdx + 30u );
 
 		return m;
 
@@ -5677,7 +5715,6 @@
 		// See equation (1) in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
 		vec3 color = surf.sheenColor;
 		color *= D * G / ( 4.0 * abs( cosThetaO * cosThetaI ) );
-		color *= wi.z;
 
 		return color;
 
@@ -6263,7 +6300,7 @@
 // returns whether the given material is a fog material or not
 bool isMaterialFogVolume( sampler2D materials, uint materialIndex ) {
 
-	uint i = materialIndex * 45u;
+	uint i = materialIndex * uint( MATERIAL_PIXELS );
 	vec4 s14 = texelFetch1D( materials, i + 14u );
 	return bool( int( s14.b ) & 4 );
 
@@ -6493,7 +6530,8 @@ bool bvhIntersectFogVolumeHit(
 				// alphaMap
 				if ( material.alphaMap != - 1 ) {
 
-					albedo.a *= texture2D( textures, vec3( uv, material.alphaMap ) ).x;
+					vec3 uvPrime = material.alphaMapTransform * vec3( uv, 1 );
+					albedo.a *= texture2D( textures, vec3( uvPrime.xy, material.alphaMap ) ).x;
 
 				}
 
@@ -6635,7 +6673,7 @@ bool bvhIntersectFogVolumeHit(
 			vec3 shapeUVW= rand3( 1 );
 			int blades = physicalCamera.apertureBlades;
 			float anamorphicRatio = physicalCamera.anamorphicRatio;
-			vec2 apertureSample = blades == 0 ? sampleCircle( shapeUVW.xy ) : sampleRegularPolygon( blades, shapeUVW );
+			vec2 apertureSample = sampleAperture( blades, shapeUVW );
 			apertureSample *= physicalCamera.bokehSize * 0.5 * 1e-3;
 
 			// rotate the aperture shape
@@ -6805,7 +6843,8 @@ bool bvhIntersectFogVolumeHit(
 		// alphaMap
 		if ( material.alphaMap != - 1 ) {
 
-			albedo.a *= texture2D( textures, vec3( uv, material.alphaMap ) ).x;
+			vec3 uvPrime = material.alphaMapTransform * vec3( uv, 1 );
+			albedo.a *= texture2D( textures, vec3( uvPrime.xy, material.alphaMap ) ).x;
 
 		}
 
@@ -7220,6 +7259,7 @@ bool bvhIntersectFogVolumeHit(
 					ATTR_TANGENT: 1,
 					ATTR_UV: 2,
 					ATTR_COLOR: 3,
+					MATERIAL_PIXELS: MATERIAL_PIXELS,
 				},
 
 				uniforms: {
@@ -8155,8 +8195,8 @@ bool bvhIntersectFogVolumeHit(
 		constructor( width = 512, height = 512 ) {
 
 			super(
-				new Float32Array( width * height * 4 ),
-				width, height, three.RGBAFormat, three.FloatType, three.EquirectangularReflectionMapping,
+				new Uint16Array( width * height * 4 ),
+				width, height, three.RGBAFormat, three.HalfFloatType, three.EquirectangularReflectionMapping,
 				three.RepeatWrapping, three.ClampToEdgeWrapping, three.LinearFilter, three.LinearFilter,
 			);
 
@@ -8188,10 +8228,10 @@ bool bvhIntersectFogVolumeHit(
 
 					const i = y * width + x;
 					const i4 = 4 * i;
-					data[ i4 + 0 ] = ( _color.r );
-					data[ i4 + 1 ] = ( _color.g );
-					data[ i4 + 2 ] = ( _color.b );
-					data[ i4 + 3 ] = ( 1.0 );
+					data[ i4 + 0 ] = three.DataUtils.toHalfFloat( _color.r );
+					data[ i4 + 1 ] = three.DataUtils.toHalfFloat( _color.g );
+					data[ i4 + 2 ] = three.DataUtils.toHalfFloat( _color.b );
+					data[ i4 + 3 ] = three.DataUtils.toHalfFloat( 1.0 );
 
 				}
 
@@ -8592,6 +8632,8 @@ bool bvhIntersectFogVolumeHit(
 
 		constructor( renderer ) {
 
+			console.warn( 'WebGLPathTracer: This class has been deprecated and will be removed in a future release. Use "WebGPUPathTracer" instead.' );
+
 			// members
 			this._renderer = renderer;
 			this._generator = new PathTracingSceneGenerator();
@@ -8796,7 +8838,7 @@ bool bvhIntersectFogVolumeHit(
 			}
 
 			// update scene environment
-			material.environmentIntensity = scene.environmentIntensity ?? 1;
+			material.environmentIntensity = scene.environment !== null ? ( scene.environmentIntensity ?? 1 ) : 0;
 			material.environmentRotation.makeRotationFromEuler( scene.environmentRotation ).invert();
 			if ( this._previousEnvironment !== scene.environment ) {
 
@@ -8816,10 +8858,6 @@ bool bvhIntersectFogVolumeHit(
 
 					}
 
-				} else {
-
-					material.environmentIntensity = 0;
-
 				}
 
 			}
@@ -8837,6 +8875,7 @@ bool bvhIntersectFogVolumeHit(
 				geometry,
 				bvh,
 				bvhChanged,
+				needsMaterialIndexUpdate,
 			} = results;
 
 			this._materials = materials;
@@ -8854,6 +8893,10 @@ bool bvhIntersectFogVolumeHit(
 					geometry.attributes.color,
 				);
 
+			}
+
+			if ( needsMaterialIndexUpdate ) {
+
 				material.materialIndexAttribute.updateFrom( geometry.attributes.materialIndex );
 
 			}
@@ -8984,8 +9027,8 @@ bool bvhIntersectFogVolumeHit(
 
 		dispose() {
 
-			this._renderQuad.dispose();
-			this._renderQuad.material.dispose();
+			this._quad.dispose();
+			this._quad.material.dispose();
 			this._pathTracer.dispose();
 
 		}
@@ -9013,6 +9056,12 @@ bool bvhIntersectFogVolumeHit(
 
 		}
 
+		getRenderTime() {
+
+			return this._clock.getElapsedTime() * 1e3;
+
+		}
+
 	}
 
 	class EquirectCamera extends three.Camera {
@@ -9027,6 +9076,8 @@ bool bvhIntersectFogVolumeHit(
 
 	}
 
+	// TODO: this should extend IESSpotLight, but the class is only exported from "three/webgpu" and
+	// the node library resolves light nodes by exact constructor so a subclass would not rasterize
 	class PhysicalSpotLight extends three.SpotLight {
 
 		constructor( ...args ) {
@@ -9357,8 +9408,211 @@ bool bvhIntersectFogVolumeHit(
 
 	}
 
+	class AmbientOcclusionMaterial extends MaterialBase {
+
+		get normalMap() {
+
+			return this.uniforms.normalMap.value;
+
+		}
+
+		set normalMap( v ) {
+
+			this.uniforms.normalMap.value = v;
+			this.setDefine( 'USE_NORMALMAP', v ? null : '' );
+
+		}
+
+		get normalMapType() {
+
+			return three.TangentSpaceNormalMap;
+
+		}
+
+		set normalMapType( v ) {
+
+			if ( v !== three.TangentSpaceNormalMap ) {
+
+				throw new Error( 'AmbientOcclusionMaterial: Only tangent space normal map are supported' );
+
+			}
+
+		}
+
+		constructor( parameters ) {
+
+			super( {
+
+				defines: {
+					SAMPLES: 10,
+					MATERIAL_PIXELS: MATERIAL_PIXELS,
+				},
+
+				uniforms: {
+					bvh: { value: new threeMeshBvh.MeshBVHUniformStruct() },
+					radius: { value: 1.0 },
+					seed: { value: 0 },
+
+					normalMap: { value: null },
+					normalScale: { value: new three.Vector2( 1, 1 ) },
+				},
+
+				vertexShader: /* glsl */`
+
+				varying vec3 vNorm;
+				varying vec3 vPos;
+
+				#if defined( USE_NORMALMAP ) && defined( USE_TANGENT )
+
+					varying vec2 vUv;
+					varying vec4 vTan;
+
+				#endif
+
+				void main() {
+
+					vec4 mvPosition = vec4( position, 1.0 );
+					mvPosition = modelViewMatrix * mvPosition;
+					gl_Position = projectionMatrix * mvPosition;
+
+					mat3 modelNormalMatrix = transpose( inverse( mat3( modelMatrix ) ) );
+					vNorm = normalize( modelNormalMatrix * normal );
+					vPos = ( modelMatrix * vec4( position, 1.0 ) ).xyz;
+
+					#if defined( USE_NORMALMAP ) && defined( USE_TANGENT )
+
+						vUv = uv;
+						vTan = tangent;
+
+					#endif
+
+				}
+
+			`,
+
+				fragmentShader: /* glsl */`
+				#define RAY_OFFSET 1e-4
+
+				precision highp isampler2D;
+				precision highp usampler2D;
+				precision highp sampler2DArray;
+				#include <common>
+				#include <cube_uv_reflection_fragment>
+
+				// bvh
+				${ threeMeshBvh.BVHShaderGLSL.common_functions }
+				${ threeMeshBvh.BVHShaderGLSL.bvh_struct_definitions }
+				${ threeMeshBvh.BVHShaderGLSL.bvh_ray_functions }
+
+				// uniform structs
+				${ material_struct }
+
+				// rand
+				${ pcg_functions }
+
+				// common
+				${ shape_sampling_functions }
+
+				uniform BVH bvh;
+				uniform int seed;
+				uniform float radius;
+
+				varying vec3 vNorm;
+				varying vec3 vPos;
+
+				#if defined(USE_NORMALMAP) && defined(USE_TANGENT)
+
+					uniform sampler2D normalMap;
+					uniform vec2 normalScale;
+					varying vec2 vUv;
+					varying vec4 vTan;
+
+				#endif
+
+				void main() {
+
+					rng_initialize( gl_FragCoord.xy, seed );
+
+					// compute the flat face surface normal
+					vec3 fdx = vec3( dFdx( vPos.x ), dFdx( vPos.y ), dFdx( vPos.z ) );
+					vec3 fdy = vec3( dFdy( vPos.x ), dFdy( vPos.y ), dFdy( vPos.z ) );
+					vec3 faceNormal = normalize( cross( fdx, fdy ) );
+
+					// find the max component to scale the offset to account for floating point error
+					vec3 absPoint = abs( vPos );
+					float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
+					vec3 normal = vNorm;
+
+					#if defined( USE_NORMALMAP ) && defined( USE_TANGENT )
+
+						// some provided tangents can be malformed (0, 0, 0) causing the normal to be degenerate
+						// resulting in NaNs and slow path tracing.
+						if ( length( vTan.xyz ) > 0.0 ) {
+
+							vec2 uv = vUv;
+							vec3 tangent = normalize( vTan.xyz );
+							vec3 bitangent = normalize( cross( normal, tangent ) * vTan.w );
+							mat3 vTBN = mat3( tangent, bitangent, normal );
+
+							vec3 texNormal = texture2D( normalMap, uv ).xyz * 2.0 - 1.0;
+							texNormal.xy *= normalScale;
+							normal = vTBN * texNormal;
+
+						}
+
+					#endif
+
+					normal *= gl_FrontFacing ? 1.0 : - 1.0;
+
+					vec3 rayOrigin = vPos + faceNormal * ( maxPoint + 1.0 ) * RAY_OFFSET;
+					float accumulated = 0.0;
+					for ( int i = 0; i < SAMPLES; i ++ ) {
+
+						// sample the cosine weighted hemisphere and discard the sample if it's below
+						// the geometric surface
+						vec3 rayDirection = sampleHemisphere( normalize( normal ), pcgRand4().xy );
+
+						// check if we hit the mesh and its within the specified radius
+						float side = 1.0;
+						float dist = 0.0;
+						vec3 barycoord = vec3( 0.0 );
+						vec3 outNormal = vec3( 0.0 );
+						uvec4 faceIndices = uvec4( 0u );
+
+						// if the ray is above the geometry surface, and it doesn't hit another surface within the specified radius then
+						// we consider it lit
+						if (
+							dot( rayDirection, faceNormal ) > 0.0 &&
+							(
+								! bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, outNormal, barycoord, side, dist ) ||
+								dist >= radius
+							)
+						) {
+
+							accumulated += 1.0;
+
+						}
+
+					}
+
+					gl_FragColor.rgb = vec3( accumulated / float( SAMPLES ) );
+					gl_FragColor.a = 1.0;
+
+				}
+
+			`
+
+			} );
+
+			this.setValues( parameters );
+
+		}
+
+	}
+
 	// core
 
+	exports.AmbientOcclusionMaterial = AmbientOcclusionMaterial;
 	exports.BlurredEnvMapGenerator = BlurredEnvMapGenerator;
 	exports.DenoiseMaterial = DenoiseMaterial;
 	exports.DynamicPathTracingSceneGenerator = DynamicPathTracingSceneGenerator;