three-gpu-pathtracer 0.0.23 → 0.0.25

package/build/index.module.js

@@ -1,4 +1,4 @@
-import { BufferAttribute, BufferGeometry, Matrix4, Vector3, Vector4, Matrix3, MeshBasicMaterial, Mesh, ShaderMaterial, NoBlending, Vector2, WebGLRenderTarget, FloatType, RGBAFormat, NearestFilter, PerspectiveCamera, DataUtils, HalfFloatType, Source, DataTexture, LinearFilter, RepeatWrapping, RedFormat, ClampToEdgeWrapping, Quaternion, DataArrayTexture, DoubleSide, BackSide, FrontSide, Color, WebGLArrayRenderTarget, UnsignedByteType, NoToneMapping, RGFormat, NormalBlending, Spherical, EquirectangularReflectionMapping, LinearMipMapLinearFilter, Clock, Scene, AdditiveBlending, Camera, SpotLight, RectAreaLight, PMREMGenerator, MeshStandardMaterial } from 'three';
+import { BufferAttribute, BufferGeometry, Matrix4, Vector3, Vector4, Matrix3, MeshBasicMaterial, Mesh, ShaderMaterial, NoBlending, Vector2, WebGLRenderTarget, FloatType, RGBAFormat, NearestFilter, PerspectiveCamera, DataUtils, HalfFloatType, Source, DataTexture, LinearFilter, RepeatWrapping, RedFormat, ClampToEdgeWrapping, Quaternion, DataArrayTexture, DoubleSide, BackSide, FrontSide, Color, WebGLArrayRenderTarget, UnsignedByteType, NoToneMapping, RGFormat, NormalBlending, Spherical, EquirectangularReflectionMapping, LinearMipMapLinearFilter, Clock, Scene, AdditiveBlending, Camera, SpotLight, RectAreaLight, PMREMGenerator, MeshStandardMaterial, TangentSpaceNormalMap } from 'three';
 import { SAH, MeshBVH, FloatVertexAttributeTexture, MeshBVHUniformStruct, UIntVertexAttributeTexture, BVHShaderGLSL } from 'three-mesh-bvh';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 
@@ -277,7 +277,20 @@ function mergeGeometries( geometries, options = {}, targetGeometry = new BufferG
 			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 );
+
+				}
 
 			}
 
@@ -1315,6 +1328,7 @@ class PathTracingSceneGenerator {
 		this._bvhWorker = null;
 		this._pendingGenerate = null;
 		this._buildAsync = false;
+		this._materialUuids = null;
 
 	}
 
@@ -1396,12 +1410,29 @@ class PathTracingSceneGenerator {
 		// 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 );
 
 		}
 
@@ -1445,6 +1476,7 @@ class PathTracingSceneGenerator {
 		return {
 			bvhChanged: result.changeType !== NO_CHANGE,
 			bvh: this.bvh,
+			needsMaterialIndexUpdate,
 			lights,
 			iesTextures,
 			geometry,
@@ -2214,6 +2246,12 @@ class EquirectHdrInfoUniform {
 
 	}
 
+	getPixelWeight( r, g, b ) {
+
+		return colorToLuminance( r, g, b );
+
+	}
+
 	dispose() {
 
 		this.marginalWeights.dispose();
@@ -2254,10 +2292,9 @@ class EquirectHdrInfoUniform {
 				const g = DataUtils.fromHalfFloat( data[ 4 * i + 1 ] );
 				const b = 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;
 
@@ -2588,17 +2625,17 @@ function copyArrayToArray( fromArray, fromStride, toArray, toStride, offset ) {
 	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;
 
 	}
 
@@ -2849,20 +2886,16 @@ function getTextures( materials ) {
 function getLights( scene ) {
 
 	const lights = [];
-	scene.traverse( c => {
+	scene.traverseVisible( c => {
 
-		if ( c.visible ) {
-
-			if (
-				c.isRectAreaLight ||
-				c.isSpotLight ||
-				c.isPointLight ||
-				c.isDirectionalLight
-			) {
+		if (
+			c.isRectAreaLight ||
+			c.isSpotLight ||
+			c.isPointLight ||
+			c.isDirectionalLight
+		) {
 
-				lights.push( c );
-
-			}
+			lights.push( c );
 
 		}
 
@@ -2872,7 +2905,7 @@ function getLights( scene ) {
 
 }
 
-const MATERIAL_PIXELS = 45;
+const MATERIAL_PIXELS = 47;
 const MATERIAL_STRIDE = MATERIAL_PIXELS * 4;
 
 class MaterialFeatures {
@@ -3232,15 +3265,15 @@ class MaterialsTexture extends DataTexture {
 
 				switch ( m.side ) {
 
-				case FrontSide:
-					floatArray[ index ++ ] = 1;
-					break;
-				case BackSide:
-					floatArray[ index ++ ] = - 1;
-					break;
-				case DoubleSide:
-					floatArray[ index ++ ] = 0;
-					break;
+					case FrontSide:
+						floatArray[ index ++ ] = 1;
+						break;
+					case BackSide:
+						floatArray[ index ++ ] = - 1;
+						break;
+					case DoubleSide:
+						floatArray[ index ++ ] = 0;
+						break;
 
 				}
 
@@ -3297,6 +3330,9 @@ class MaterialsTexture extends DataTexture {
 			// specularIntensityMap transform 43
 			index += writeTextureMatrixToArray( m, 'specularIntensityMap', floatArray, index );
 
+			// alphaMap transform 45
+			index += writeTextureMatrixToArray( m, 'alphaMap', floatArray, index );
+
 		}
 
 		// check if the contents have changed
@@ -4110,12 +4146,12 @@ function getFormat( channels ) {
 
 	switch ( channels ) {
 
-	case 1:
-		return RedFormat;
-	case 2:
-		return RGFormat;
-	default:
-		return RGBAFormat;
+		case 1:
+			return RedFormat;
+		case 2:
+			return RGFormat;
+		default:
+			return RGBAFormat;
 
 	}
 
@@ -4376,6 +4412,7 @@ const material_struct = /* glsl */ `
 		mat3 iridescenceThicknessMapTransform;
 		mat3 specularColorMapTransform;
 		mat3 specularIntensityMapTransform;
+		mat3 alphaMapTransform;
 
 	};
 
@@ -4396,7 +4433,7 @@ const material_struct = /* glsl */ `
 
 	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 );
@@ -4495,6 +4532,7 @@ const material_struct = /* glsl */ `
 		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;
 
@@ -5675,7 +5713,6 @@ const bsdf_functions = /* glsl */`
 		// 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;
 
@@ -6261,7 +6298,7 @@ const inside_fog_volume_function = /* glsl */`
 // 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 );
 
@@ -6491,7 +6528,8 @@ const attenuate_hit_function = /* glsl */`
 				// 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;
 
 				}
 
@@ -6633,7 +6671,7 @@ const camera_util_functions = /* glsl */`
 			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
@@ -6803,7 +6841,8 @@ const get_surface_record_function = /* glsl */`
 		// 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;
 
 		}
 
@@ -7218,6 +7257,7 @@ class PhysicalPathTracingMaterial extends MaterialBase {
 				ATTR_TANGENT: 1,
 				ATTR_UV: 2,
 				ATTR_COLOR: 3,
+				MATERIAL_PIXELS: MATERIAL_PIXELS,
 			},
 
 			uniforms: {
@@ -8153,8 +8193,8 @@ class ProceduralEquirectTexture extends DataTexture {
 	constructor( width = 512, height = 512 ) {
 
 		super(
-			new Float32Array( width * height * 4 ),
-			width, height, RGBAFormat, FloatType, EquirectangularReflectionMapping,
+			new Uint16Array( width * height * 4 ),
+			width, height, RGBAFormat, HalfFloatType, EquirectangularReflectionMapping,
 			RepeatWrapping, ClampToEdgeWrapping, LinearFilter, LinearFilter,
 		);
 
@@ -8186,10 +8226,10 @@ class ProceduralEquirectTexture extends DataTexture {
 
 				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 ] = DataUtils.toHalfFloat( _color.r );
+				data[ i4 + 1 ] = DataUtils.toHalfFloat( _color.g );
+				data[ i4 + 2 ] = DataUtils.toHalfFloat( _color.b );
+				data[ i4 + 3 ] = DataUtils.toHalfFloat( 1.0 );
 
 			}
 
@@ -8590,6 +8630,8 @@ class WebGLPathTracer {
 
 	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();
@@ -8794,7 +8836,7 @@ class WebGLPathTracer {
 		}
 
 		// 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 ) {
 
@@ -8814,10 +8856,6 @@ class WebGLPathTracer {
 
 				}
 
-			} else {
-
-				material.environmentIntensity = 0;
-
 			}
 
 		}
@@ -8835,6 +8873,7 @@ class WebGLPathTracer {
 			geometry,
 			bvh,
 			bvhChanged,
+			needsMaterialIndexUpdate,
 		} = results;
 
 		this._materials = materials;
@@ -8852,6 +8891,10 @@ class WebGLPathTracer {
 				geometry.attributes.color,
 			);
 
+		}
+
+		if ( needsMaterialIndexUpdate ) {
+
 			material.materialIndexAttribute.updateFrom( geometry.attributes.materialIndex );
 
 		}
@@ -8982,8 +9025,8 @@ class WebGLPathTracer {
 
 	dispose() {
 
-		this._renderQuad.dispose();
-		this._renderQuad.material.dispose();
+		this._quad.dispose();
+		this._quad.material.dispose();
 		this._pathTracer.dispose();
 
 	}
@@ -9011,6 +9054,12 @@ class WebGLPathTracer {
 
 	}
 
+	getRenderTime() {
+
+		return this._clock.getElapsedTime() * 1e3;
+
+	}
+
 }
 
 class EquirectCamera extends Camera {
@@ -9025,6 +9074,8 @@ class EquirectCamera extends Camera {
 
 }
 
+// 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 SpotLight {
 
 	constructor( ...args ) {
@@ -9355,7 +9406,209 @@ class FogVolumeMaterial extends MeshStandardMaterial {
 
 }
 
+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 TangentSpaceNormalMap;
+
+	}
+
+	set normalMapType( v ) {
+
+		if ( v !== 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 MeshBVHUniformStruct() },
+				radius: { value: 1.0 },
+				seed: { value: 0 },
+
+				normalMap: { value: null },
+				normalScale: { value: new 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
+				${ BVHShaderGLSL.common_functions }
+				${ BVHShaderGLSL.bvh_struct_definitions }
+				${ 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
 
-export { BlurredEnvMapGenerator, DenoiseMaterial, DynamicPathTracingSceneGenerator, EquirectCamera, FogVolumeMaterial, GradientEquirectTexture, PathTracingRenderer, PathTracingSceneGenerator, PathTracingSceneWorker, PhysicalCamera, PhysicalPathTracingMaterial, PhysicalSpotLight, ProceduralEquirectTexture, ShapedAreaLight, WebGLPathTracer };
+export { AmbientOcclusionMaterial, BlurredEnvMapGenerator, DenoiseMaterial, DynamicPathTracingSceneGenerator, EquirectCamera, FogVolumeMaterial, GradientEquirectTexture, PathTracingRenderer, PathTracingSceneGenerator, PathTracingSceneWorker, PhysicalCamera, PhysicalPathTracingMaterial, PhysicalSpotLight, ProceduralEquirectTexture, ShapedAreaLight, WebGLPathTracer };
 //# sourceMappingURL=index.module.js.map