three-gpu-pathtracer 0.0.24 → 0.0.25

package/build/index.umd.cjs

@@ -2248,6 +2248,12 @@
 
 		}
 
+		getPixelWeight( r, g, b ) {
+
+			return colorToLuminance( r, g, b );
+
+		}
+
 		dispose() {
 
 			this.marginalWeights.dispose();
@@ -2288,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;
 
@@ -2622,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;
 
 		}
 
@@ -2883,20 +2888,16 @@
 	function getLights( scene ) {
 
 		const lights = [];
-		scene.traverse( c => {
-
-			if ( c.visible ) {
-
-				if (
-					c.isRectAreaLight ||
-					c.isSpotLight ||
-					c.isPointLight ||
-					c.isDirectionalLight
-				) {
+		scene.traverseVisible( c => {
 
-					lights.push( c );
+			if (
+				c.isRectAreaLight ||
+				c.isSpotLight ||
+				c.isPointLight ||
+				c.isDirectionalLight
+			) {
 
-				}
+				lights.push( c );
 
 			}
 
@@ -3266,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;
 
 					}
 
@@ -4147,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;
 
 		}
 
@@ -5714,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;
 
@@ -8195,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,
 			);
 
@@ -8228,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 );
 
 				}
 
@@ -8632,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();
@@ -9054,6 +9056,12 @@ bool bvhIntersectFogVolumeHit(
 
 		}
 
+		getRenderTime() {
+
+			return this._clock.getElapsedTime() * 1e3;
+
+		}
+
 	}
 
 	class EquirectCamera extends three.Camera {
@@ -9068,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 ) {
@@ -9398,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;