three-gpu-pathtracer 0.0.14 → 0.0.16

package/src/materials/pathtracing/glsl/attenuateHit.glsl.js

@@ -1,179 +1,177 @@
-export const attenuateHitGLSL = /* glsl */`
-
-	// step through multiple surface hits and accumulate color attenuation based on transmissive surfaces
-	// returns true if a solid surface was hit
-	bool attenuateHit(
-		BVH bvh, vec3 rayOrigin, vec3 rayDirection, float rayDist,
-		int traversals, int transmissiveTraversals, bool isShadowRay,
-		Material fogMaterial,
-		out vec3 color
-	) {
-
-		vec3 ogRayOrigin = rayOrigin;
-
-		// hit results
-		uvec4 faceIndices = uvec4( 0u );
-		vec3 faceNormal = vec3( 0.0, 0.0, 1.0 );
-		vec3 barycoord = vec3( 0.0 );
-		float side = 1.0;
-		float dist = 0.0;
-		LightSampleRecord lightSampleRec;
-
-		color = vec3( 1.0 );
-
-		// TODO: we should be using sobol sampling here instead of rand but the sobol bounce and path indices need to be incremented
-		// and then reset.
-		for ( int i = 0; i < traversals; i ++ ) {
-
-			int hitType = traceScene(
-				rayOrigin, rayDirection,
-				bvh, lights, fogMaterial,
-				faceIndices, faceNormal, barycoord, side, dist,
-				lightSampleRec
-			);
-
-			if ( hitType == FOG_HIT ) {
-
-				return true;
-
-			} else if ( hitType == LIGHT_HIT ) {
-
-				float totalDist = distance( ogRayOrigin, rayOrigin + rayDirection * lightSampleRec.dist );
-				return totalDist < rayDist - max( totalDist, rayDist ) * 1e-4;
-
-			} else if ( hitType == SURFACE_HIT ) {
-
-				float totalDist = distance( ogRayOrigin, rayOrigin + rayDirection * dist );
-				if ( totalDist > rayDist ) {
-
-					return false;
-
-				}
-
-				// TODO: attenuate the contribution based on the PDF of the resulting ray including refraction values
-				// Should be able to work using the material BSDF functions which will take into account specularity, etc.
-				// TODO: should we account for emissive surfaces here?
-
-				uint materialIndex = uTexelFetch1D( materialIndexAttribute, faceIndices.x ).r;
-				Material material = readMaterialInfo( materials, materialIndex );
-
-				// adjust the ray to the new surface
-				bool isEntering = side == 1.0;
-				rayOrigin = stepRayOrigin( rayOrigin, rayDirection, - faceNormal, dist );
-
-				#if FEATURE_FOG
-
-				if ( material.fogVolume ) {
-
-					fogMaterial = material;
-					fogMaterial.fogVolume = side == 1.0;
-					i -= sign( transmissiveTraversals );
-					transmissiveTraversals --;
-					continue;
-
-				}
-
-				#endif
-
-				if ( ! material.castShadow && isShadowRay ) {
-
-					continue;
-
-				}
-
-				vec2 uv = textureSampleBarycoord( attributesArray, ATTR_UV, barycoord, faceIndices.xyz ).xy;
-				vec4 vertexColor = textureSampleBarycoord( attributesArray, ATTR_COLOR, barycoord, faceIndices.xyz );
-
-				// albedo
-				vec4 albedo = vec4( material.color, material.opacity );
-				if ( material.map != - 1 ) {
-
-					vec3 uvPrime = material.mapTransform * vec3( uv, 1 );
-					albedo *= texture2D( textures, vec3( uvPrime.xy, material.map ) );
-
-				}
-
-				if ( material.vertexColors ) {
-
-					albedo *= vertexColor;
-
-				}
-
-				// alphaMap
-				if ( material.alphaMap != - 1 ) {
-
-					albedo.a *= texture2D( textures, vec3( uv, material.alphaMap ) ).x;
-
-				}
-
-				// transmission
-				float transmission = material.transmission;
-				if ( material.transmissionMap != - 1 ) {
-
-					vec3 uvPrime = material.transmissionMapTransform * vec3( uv, 1 );
-					transmission *= texture2D( textures, vec3( uvPrime.xy, material.transmissionMap ) ).r;
-
-				}
-
-				// metalness
-				float metalness = material.metalness;
-				if ( material.metalnessMap != - 1 ) {
-
-					vec3 uvPrime = material.metalnessMapTransform * vec3( uv, 1 );
-					metalness *= texture2D( textures, vec3( uvPrime.xy, material.metalnessMap ) ).b;
-
-				}
-
-				float alphaTest = material.alphaTest;
-				bool useAlphaTest = alphaTest != 0.0;
-				float transmissionFactor = ( 1.0 - metalness ) * transmission;
-				if (
-					transmissionFactor < rand() && ! (
-						// material sidedness
-						material.side != 0.0 && side == material.side
-
-						// alpha test
-						|| useAlphaTest && albedo.a < alphaTest
-
-						// opacity
-						|| material.transparent && ! useAlphaTest && albedo.a < rand()
-					)
-				) {
-
-					return true;
-
-				}
-
-				if ( side == 1.0 && isEntering ) {
-
-					// only attenuate by surface color on the way in
-					color *= mix( vec3( 1.0 ), albedo.rgb, transmissionFactor );
-
-				} else if ( side == - 1.0 ) {
-
-					// attenuate by medium once we hit the opposite side of the model
-					color *= transmissionAttenuation( dist, material.attenuationColor, material.attenuationDistance );
-
-				}
-
-				bool isTransmissiveRay = dot( rayDirection, faceNormal * side ) < 0.0;
-				if ( ( isTransmissiveRay || isEntering ) && transmissiveTraversals > 0 ) {
-
-					i -= sign( transmissiveTraversals );
-					transmissiveTraversals --;
-
-				}
-
-			} else {
-
-				return false;
-
-			}
-
-		}
-
-		return true;
-
-	}
-
-`;
+export const attenuateHitGLSL = /* glsl */`
+
+	// step through multiple surface hits and accumulate color attenuation based on transmissive surfaces
+	// returns true if a solid surface was hit
+	bool attenuateHit(
+		BVH bvh, RenderState state,
+		Ray ray, float rayDist,
+		out vec3 color
+	) {
+
+		int traversals = state.traversals;
+		int transmissiveTraversals = state.transmissiveTraversals;
+		bool isShadowRay = state.isShadowRay;
+		Material fogMaterial = state.fogMaterial;
+
+		vec3 startPoint = ray.origin;
+
+		// hit results
+		SurfaceHit surfaceHit;
+		LightRecord lightRec;
+
+		color = vec3( 1.0 );
+
+		// TODO: we should be using sobol sampling here instead of rand but the sobol bounce and path indices need to be incremented
+		// and then reset.
+		for ( int i = 0; i < traversals; i ++ ) {
+
+			int hitType = traceScene(
+				ray, bvh, lights, fogMaterial,
+				surfaceHit, lightRec
+			);
+
+			if ( hitType == FOG_HIT ) {
+
+				return true;
+
+			} else if ( hitType == LIGHT_HIT ) {
+
+				float totalDist = distance( startPoint, ray.origin + ray.direction * lightRec.dist );
+				return totalDist < rayDist - max( totalDist, rayDist ) * 1e-4;
+
+			} else if ( hitType == SURFACE_HIT ) {
+
+				float totalDist = distance( startPoint, ray.origin + ray.direction * surfaceHit.dist );
+				if ( totalDist > rayDist ) {
+
+					return false;
+
+				}
+
+				// TODO: attenuate the contribution based on the PDF of the resulting ray including refraction values
+				// Should be able to work using the material BSDF functions which will take into account specularity, etc.
+				// TODO: should we account for emissive surfaces here?
+
+				uint materialIndex = uTexelFetch1D( materialIndexAttribute, surfaceHit.faceIndices.x ).r;
+				Material material = readMaterialInfo( materials, materialIndex );
+
+				// adjust the ray to the new surface
+				bool isEntering = surfaceHit.side == 1.0;
+				ray.origin = stepRayOrigin( ray.origin, ray.direction, - surfaceHit.faceNormal, surfaceHit.dist );
+
+				#if FEATURE_FOG
+
+				if ( material.fogVolume ) {
+
+					fogMaterial = material;
+					fogMaterial.fogVolume = surfaceHit.side == 1.0;
+					i -= sign( transmissiveTraversals );
+					transmissiveTraversals --;
+					continue;
+
+				}
+
+				#endif
+
+				if ( ! material.castShadow && isShadowRay ) {
+
+					continue;
+
+				}
+
+				vec2 uv = textureSampleBarycoord( attributesArray, ATTR_UV, surfaceHit.barycoord, surfaceHit.faceIndices.xyz ).xy;
+				vec4 vertexColor = textureSampleBarycoord( attributesArray, ATTR_COLOR, surfaceHit.barycoord, surfaceHit.faceIndices.xyz );
+
+				// albedo
+				vec4 albedo = vec4( material.color, material.opacity );
+				if ( material.map != - 1 ) {
+
+					vec3 uvPrime = material.mapTransform * vec3( uv, 1 );
+					albedo *= texture2D( textures, vec3( uvPrime.xy, material.map ) );
+
+				}
+
+				if ( material.vertexColors ) {
+
+					albedo *= vertexColor;
+
+				}
+
+				// alphaMap
+				if ( material.alphaMap != - 1 ) {
+
+					albedo.a *= texture2D( textures, vec3( uv, material.alphaMap ) ).x;
+
+				}
+
+				// transmission
+				float transmission = material.transmission;
+				if ( material.transmissionMap != - 1 ) {
+
+					vec3 uvPrime = material.transmissionMapTransform * vec3( uv, 1 );
+					transmission *= texture2D( textures, vec3( uvPrime.xy, material.transmissionMap ) ).r;
+
+				}
+
+				// metalness
+				float metalness = material.metalness;
+				if ( material.metalnessMap != - 1 ) {
+
+					vec3 uvPrime = material.metalnessMapTransform * vec3( uv, 1 );
+					metalness *= texture2D( textures, vec3( uvPrime.xy, material.metalnessMap ) ).b;
+
+				}
+
+				float alphaTest = material.alphaTest;
+				bool useAlphaTest = alphaTest != 0.0;
+				float transmissionFactor = ( 1.0 - metalness ) * transmission;
+				if (
+					transmissionFactor < rand() && ! (
+						// material sidedness
+						material.side != 0.0 && surfaceHit.side == material.side
+
+						// alpha test
+						|| useAlphaTest && albedo.a < alphaTest
+
+						// opacity
+						|| material.transparent && ! useAlphaTest && albedo.a < rand()
+					)
+				) {
+
+					return true;
+
+				}
+
+				if ( surfaceHit.side == 1.0 && isEntering ) {
+
+					// only attenuate by surface color on the way in
+					color *= mix( vec3( 1.0 ), albedo.rgb, transmissionFactor );
+
+				} else if ( surfaceHit.side == - 1.0 ) {
+
+					// attenuate by medium once we hit the opposite side of the model
+					color *= transmissionAttenuation( surfaceHit.dist, material.attenuationColor, material.attenuationDistance );
+
+				}
+
+				bool isTransmissiveRay = dot( ray.direction, surfaceHit.faceNormal * surfaceHit.side ) < 0.0;
+				if ( ( isTransmissiveRay || isEntering ) && transmissiveTraversals > 0 ) {
+
+					i -= sign( transmissiveTraversals );
+					transmissiveTraversals --;
+
+				}
+
+			} else {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	}
+
+`;

package/src/materials/pathtracing/glsl/cameraUtils.glsl.js

@@ -1,81 +1,84 @@
-export const cameraUtilsGLSL = /* glsl */`
-
-	vec3 ndcToRayOrigin( vec2 coord ) {
-
-		vec4 rayOrigin4 = cameraWorldMatrix * invProjectionMatrix * vec4( coord, - 1.0, 1.0 );
-		return rayOrigin4.xyz / rayOrigin4.w;
-	}
-
-	void getCameraRay( out vec3 rayDirection, out vec3 rayOrigin ) {
-
-		vec2 ssd = vec2( 1.0 ) / resolution;
-
-		// Jitter the camera ray by finding a uv coordinate at a random sample
-		// around this pixel's UV coordinate for AA
-		vec2 ruv = sobol2( 0 );
-		vec2 jitteredUv = vUv + vec2( tentFilter( ruv.x ) * ssd.x, tentFilter( ruv.y ) * ssd.y );
-
-		#if CAMERA_TYPE == 2
-
-			// Equirectangular projection
-			vec4 rayDirection4 = vec4( equirectUvToDirection( jitteredUv ), 0.0 );
-			vec4 rayOrigin4 = vec4( 0.0, 0.0, 0.0, 1.0 );
-
-			rayDirection4 = cameraWorldMatrix * rayDirection4;
-			rayOrigin4 = cameraWorldMatrix * rayOrigin4;
-
-			rayDirection = normalize( rayDirection4.xyz );
-			rayOrigin = rayOrigin4.xyz / rayOrigin4.w;
-
-		#else
-
-			// get [- 1, 1] normalized device coordinates
-			vec2 ndc = 2.0 * jitteredUv - vec2( 1.0 );
-			rayOrigin = ndcToRayOrigin( ndc );
-
-			#if CAMERA_TYPE == 1
-
-				// Orthographic projection
-				rayDirection = ( cameraWorldMatrix * vec4( 0.0, 0.0, - 1.0, 0.0 ) ).xyz;
-				rayDirection = normalize( rayDirection );
-
-			#else
-
-				// Perspective projection
-				rayDirection = normalize( mat3(cameraWorldMatrix) * ( invProjectionMatrix * vec4( ndc, 0.0, 1.0 ) ).xyz );
-
-			#endif
-
-		#endif
-
-		#if FEATURE_DOF
-		{
-
-			// depth of field
-			vec3 focalPoint = rayOrigin + normalize( rayDirection ) * physicalCamera.focusDistance;
-
-			// get the aperture sample
-			// if blades === 0 then we assume a circle
-			vec3 shapeUVW= sobol3( 1 );
-			int blades = physicalCamera.apertureBlades;
-			float anamorphicRatio = physicalCamera.anamorphicRatio;
-			vec2 apertureSample = blades == 0 ? sampleCircle( shapeUVW.xy ) : sampleRegularPolygon( blades, shapeUVW );
-			apertureSample *= physicalCamera.bokehSize * 0.5 * 1e-3;
-
-			// rotate the aperture shape
-			apertureSample =
-				rotateVector( apertureSample, physicalCamera.apertureRotation ) *
-				saturate( vec2( anamorphicRatio, 1.0 / anamorphicRatio ) );
-
-			// create the new ray
-			rayOrigin += ( cameraWorldMatrix * vec4( apertureSample, 0.0, 0.0 ) ).xyz;
-			rayDirection = focalPoint - rayOrigin;
-
-		}
-		#endif
-
-		rayDirection = normalize( rayDirection );
-
-	}
-
-`;
+export const cameraUtilsGLSL = /* glsl */`
+
+	vec3 ndcToRayOrigin( vec2 coord ) {
+
+		vec4 rayOrigin4 = cameraWorldMatrix * invProjectionMatrix * vec4( coord, - 1.0, 1.0 );
+		return rayOrigin4.xyz / rayOrigin4.w;
+	}
+
+	Ray getCameraRay() {
+
+		vec2 ssd = vec2( 1.0 ) / resolution;
+
+		// Jitter the camera ray by finding a uv coordinate at a random sample
+		// around this pixel's UV coordinate for AA
+		vec2 ruv = sobol2( 0 );
+		vec2 jitteredUv = vUv + vec2( tentFilter( ruv.x ) * ssd.x, tentFilter( ruv.y ) * ssd.y );
+		Ray ray;
+
+		#if CAMERA_TYPE == 2
+
+			// Equirectangular projection
+			vec4 rayDirection4 = vec4( equirectUvToDirection( jitteredUv ), 0.0 );
+			vec4 rayOrigin4 = vec4( 0.0, 0.0, 0.0, 1.0 );
+
+			rayDirection4 = cameraWorldMatrix * rayDirection4;
+			rayOrigin4 = cameraWorldMatrix * rayOrigin4;
+
+			ray.direction = normalize( rayDirection4.xyz );
+			ray.origin = rayOrigin4.xyz / rayOrigin4.w;
+
+		#else
+
+			// get [- 1, 1] normalized device coordinates
+			vec2 ndc = 2.0 * jitteredUv - vec2( 1.0 );
+			ray.origin = ndcToRayOrigin( ndc );
+
+			#if CAMERA_TYPE == 1
+
+				// Orthographic projection
+				ray.direction = ( cameraWorldMatrix * vec4( 0.0, 0.0, - 1.0, 0.0 ) ).xyz;
+				ray.direction = normalize( ray.direction );
+
+			#else
+
+				// Perspective projection
+				ray.direction = normalize( mat3( cameraWorldMatrix ) * ( invProjectionMatrix * vec4( ndc, 0.0, 1.0 ) ).xyz );
+
+			#endif
+
+		#endif
+
+		#if FEATURE_DOF
+		{
+
+			// depth of field
+			vec3 focalPoint = ray.origin + normalize( ray.direction ) * physicalCamera.focusDistance;
+
+			// get the aperture sample
+			// if blades === 0 then we assume a circle
+			vec3 shapeUVW= sobol3( 1 );
+			int blades = physicalCamera.apertureBlades;
+			float anamorphicRatio = physicalCamera.anamorphicRatio;
+			vec2 apertureSample = blades == 0 ? sampleCircle( shapeUVW.xy ) : sampleRegularPolygon( blades, shapeUVW );
+			apertureSample *= physicalCamera.bokehSize * 0.5 * 1e-3;
+
+			// rotate the aperture shape
+			apertureSample =
+				rotateVector( apertureSample, physicalCamera.apertureRotation ) *
+				saturate( vec2( anamorphicRatio, 1.0 / anamorphicRatio ) );
+
+			// create the new ray
+			ray.origin += ( cameraWorldMatrix * vec4( apertureSample, 0.0, 0.0 ) ).xyz;
+			ray.direction = focalPoint - ray.origin;
+
+		}
+		#endif
+
+		ray.direction = normalize( ray.direction );
+
+		return ray;
+
+	}
+
+`;

package/src/materials/pathtracing/glsl/directLightContribution.glsl.js

@@ -0,0 +1,93 @@
+export const directLightContributionGLSL = /*glsl*/`
+
+	vec3 directLightContribution( vec3 worldWo, SurfaceRecord surf, RenderState state, vec3 rayOrigin ) {
+
+		// uniformly pick a light or environment map
+		if( lightsDenom != 0.0 && sobol( 5 ) < float( lights.count ) / lightsDenom ) {
+
+			// sample a light or environment
+			LightRecord lightRec = randomLightSample( lights.tex, iesProfiles, lights.count, rayOrigin, sobol3( 6 ) );
+
+			bool isSampleBelowSurface = ! surf.volumeParticle && dot( surf.faceNormal, lightRec.direction ) < 0.0;
+			if ( isSampleBelowSurface ) {
+
+				lightRec.pdf = 0.0;
+
+			}
+
+			// check if a ray could even reach the light area
+			Ray lightRay;
+			lightRay.origin = rayOrigin;
+			lightRay.direction = lightRec.direction;
+			vec3 attenuatedColor;
+			if (
+				lightRec.pdf > 0.0 &&
+				isDirectionValid( lightRec.direction, surf.normal, surf.faceNormal ) &&
+				! attenuateHit( bvh, state, lightRay, lightRec.dist, attenuatedColor )
+			) {
+
+				// get the material pdf
+				vec3 sampleColor;
+				float lightMaterialPdf = bsdfResult( worldWo, lightRec.direction, surf, sampleColor );
+				bool isValidSampleColor = all( greaterThanEqual( sampleColor, vec3( 0.0 ) ) );
+				if ( lightMaterialPdf > 0.0 && isValidSampleColor ) {
+
+					// weight the direct light contribution
+					float lightPdf = lightRec.pdf / lightsDenom;
+					float misWeight = lightRec.type == SPOT_LIGHT_TYPE || lightRec.type == DIR_LIGHT_TYPE || lightRec.type == POINT_LIGHT_TYPE ? 1.0 : misHeuristic( lightPdf, lightMaterialPdf );
+					return attenuatedColor * lightRec.emission * state.throughputColor * sampleColor * misWeight / lightPdf;
+
+				}
+
+			}
+
+		} else {
+
+			// find a sample in the environment map to include in the contribution
+			vec3 envColor, envDirection;
+			float envPdf = sampleEquirectProbability( envMapInfo, sobol2( 7 ), envColor, envDirection );
+			envDirection = invEnvRotation3x3 * envDirection;
+
+			// this env sampling is not set up for transmissive sampling and yields overly bright
+			// results so we ignore the sample in this case.
+			// TODO: this should be improved but how? The env samples could traverse a few layers?
+			bool isSampleBelowSurface = ! surf.volumeParticle && dot( surf.faceNormal, envDirection ) < 0.0;
+			if ( isSampleBelowSurface ) {
+
+				envPdf = 0.0;
+
+			}
+
+			// check if a ray could even reach the surface
+			Ray envRay;
+			envRay.origin = rayOrigin;
+			envRay.direction = envDirection;
+			vec3 attenuatedColor;
+			if (
+				envPdf > 0.0 &&
+				isDirectionValid( envDirection, surf.normal, surf.faceNormal ) &&
+				! attenuateHit( bvh, state, envRay, INFINITY, attenuatedColor )
+			) {
+
+				// get the material pdf
+				vec3 sampleColor;
+				float envMaterialPdf = bsdfResult( worldWo, envDirection, surf, sampleColor );
+				bool isValidSampleColor = all( greaterThanEqual( sampleColor, vec3( 0.0 ) ) );
+				if ( envMaterialPdf > 0.0 && isValidSampleColor ) {
+
+					// weight the direct light contribution
+					envPdf /= lightsDenom;
+					float misWeight = misHeuristic( envPdf, envMaterialPdf );
+					return attenuatedColor * environmentIntensity * envColor * state.throughputColor * sampleColor * misWeight / envPdf;
+
+				}
+
+			}
+
+		}
+
+		return vec3( 0.0 );
+
+	}
+
+`;