three-gpu-pathtracer 0.0.8 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-gpu-pathtracer",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Path tracing renderer and utilities for three.js built on top of three-mesh-bvh.",
   "module": "src/index.js",
   "main": "build/index.umd.cjs",
@@ -40,7 +40,7 @@
     "puppeteer": "^15.4.0",
     "rollup": "^2.70.0",
     "simple-git": "^3.10.0",
-    "three": "^0.145.0",
+    "three": "^0.147.0",
     "yargs": "^17.5.1"
   },
   "peerDependencies": {

package/src/core/PathTracingRenderer.js

@@ -1,6 +1,7 @@
 import { RGBAFormat, FloatType, Color, Vector2, WebGLRenderTarget, NoBlending, NormalBlending } from 'three';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 import { BlendMaterial } from '../materials/BlendMaterial.js';
+import { SobolNumberMapGenerator } from '../utils/SobolNumberMapGenerator.js';
 
 function* renderTask() {
 
@@ -10,6 +11,7 @@ function* renderTask() {
 		_blendQuad,
 		_primaryTarget,
 		_blendTargets,
+		_sobolTarget,
 		alpha,
 		camera,
 		material,
@@ -36,6 +38,7 @@ function* renderTask() {
 		const w = _primaryTarget.width;
 		const h = _primaryTarget.height;
 		material.resolution.set( w, h );
+		material.sobolTexture = _sobolTarget.texture;
 		material.seed ++;
 
 		const tilesX = this.tiles.x || 1;
@@ -184,6 +187,7 @@ export class PathTracingRenderer {
 		this._task = null;
 		this._currentTile = 0;
 
+		this._sobolTarget = new SobolNumberMapGenerator().generate( renderer );
 		this._primaryTarget = new WebGLRenderTarget( 1, 1, {
 			format: RGBAFormat,
 			type: FloatType,
@@ -215,6 +219,7 @@ export class PathTracingRenderer {
 		this._primaryTarget.dispose();
 		this._blendTargets[ 0 ].dispose();
 		this._blendTargets[ 1 ].dispose();
+		this._sobolTarget.dispose();
 
 		this._fsQuad.dispose();
 		this._blendQuad.dispose();

package/src/materials/AmbientOcclusionMaterial.js

@@ -3,6 +3,7 @@ import { MaterialBase } from './MaterialBase.js';
 import { MeshBVHUniformStruct, shaderStructs, shaderIntersectFunction } from 'three-mesh-bvh';
 import { shaderMaterialStructs } from '../shader/shaderStructs.js';
 import { shaderUtils } from '../shader/shaderUtils.js';
+import { shaderRandFunctions } from '../shader/shaderRandFunctions.js';
 
 export class AmbientOcclusionMaterial extends MaterialBase {
 
@@ -97,6 +98,7 @@ export class AmbientOcclusionMaterial extends MaterialBase {
 				${ shaderStructs }
 				${ shaderIntersectFunction }
 				${ shaderMaterialStructs }
+				${ shaderRandFunctions }
 				${ shaderUtils }
 
 				uniform BVH bvh;

package/src/materials/PhysicalPathTracingMaterial.js

@@ -10,8 +10,10 @@ import { RenderTarget2DArray } from '../uniforms/RenderTarget2DArray.js';
 import { shaderMaterialSampling } from '../shader/shaderMaterialSampling.js';
 import { shaderEnvMapSampling } from '../shader/shaderEnvMapSampling.js';
 import { shaderLightSampling } from '../shader/shaderLightSampling.js';
+import { shaderSobolCommon, shaderSobolSampling } from '../shader/shaderSobolSampling.js';
 import { shaderUtils } from '../shader/shaderUtils.js';
 import { shaderLayerTexelFetchFunctions } from '../shader/shaderLayerTexelFetchFunctions.js';
+import { shaderRandFunctions } from '../shader/shaderRandFunctions.js';
 import { PhysicalCameraUniform } from '../uniforms/PhysicalCameraUniform.js';
 import { EquirectHdrInfoUniform } from '../uniforms/EquirectHdrInfoUniform.js';
 import { LightsInfoUniformStruct } from '../uniforms/LightsInfoUniformStruct.js';
@@ -76,6 +78,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				filterGlossyFactor: { value: 0.0 },
 
 				backgroundAlpha: { value: 1.0 },
+				sobolTexture: { value: null },
 			},
 
 			vertexShader: /* glsl */`
@@ -102,6 +105,9 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				vec4 envMapTexelToLinear( vec4 a ) { return a; }
 				#include <common>
 
+				${ shaderRandFunctions }
+				${ shaderSobolCommon }
+				${ shaderSobolSampling }
 				${ shaderStructs }
 				${ shaderIntersectFunction }
 				${ shaderMaterialStructs }
@@ -162,9 +168,9 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 				}
 
-				vec3 sampleBackground( vec3 direction ) {
+				vec3 sampleBackground( vec3 direction, vec2 uv ) {
 
-					vec3 sampleDir = normalize( direction + getHemisphereSample( direction, rand2() ) * 0.5 * backgroundBlur );
+					vec3 sampleDir = normalize( direction + getHemisphereSample( direction, uv ) * 0.5 * backgroundBlur );
 
 					#if FEATURE_BACKGROUND_MAP
 
@@ -190,6 +196,8 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 					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 ++ ) {
 
 						if ( bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist ) ) {
@@ -316,14 +324,6 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 				}
 
-				// tentFilter from Peter Shirley's 'Realistic Ray Tracing (2nd Edition)' book, pg. 60
-				// erichlof/THREE.js-PathTracing-Renderer/
-				float tentFilter( float x ) {
-
-					return x < 0.5 ? sqrt( 2.0 * x ) - 1.0 : 1.0 - sqrt( 2.0 - ( 2.0 * x ) );
-
-				}
-
 				vec3 ndcToRayOrigin( vec2 coord ) {
 
 					vec4 rayOrigin4 = cameraWorldMatrix * invProjectionMatrix * vec4( coord, - 1.0, 1.0 );
@@ -335,13 +335,13 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 					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
-					vec2 jitteredUv = vUv + vec2( tentFilter( rand() ) * ssd.x, tentFilter( rand() ) * ssd.y );
+					// 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 );
 
@@ -355,20 +355,17 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 						// 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
@@ -382,17 +379,17 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 						vec3 focalPoint = rayOrigin + normalize( rayDirection ) * physicalCamera.focusDistance;
 
 						// get the aperture sample
-						vec2 apertureSample = sampleAperture( physicalCamera.apertureBlades ) * physicalCamera.bokehSize * 0.5 * 1e-3;
+						// 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 ) : sampleRegularNGon( blades, shapeUVW );
+						apertureSample *= physicalCamera.bokehSize * 0.5 * 1e-3;
 
 						// rotate the aperture shape
-						float ac = cos( physicalCamera.apertureRotation );
-						float as = sin( physicalCamera.apertureRotation );
-						apertureSample = vec2(
-							apertureSample.x * ac - apertureSample.y * as,
-							apertureSample.x * as + apertureSample.y * ac
-						);
-						apertureSample.x *= saturate( physicalCamera.anamorphicRatio );
-						apertureSample.y *= saturate( 1.0 / physicalCamera.anamorphicRatio );
+						apertureSample =
+							rotateVector( apertureSample, physicalCamera.apertureRotation ) *
+							saturate( vec2( anamorphicRatio, 1.0 / anamorphicRatio ) );
 
 						// create the new ray
 						rayOrigin += ( cameraWorldMatrix * vec4( apertureSample, 0.0, 0.0 ) ).xyz;
@@ -408,6 +405,8 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				void main() {
 
 					rng_initialize( gl_FragCoord.xy, seed );
+					sobolPixelIndex = ( uint( gl_FragCoord.x ) << 16 ) | ( uint( gl_FragCoord.y ) );
+					sobolPathIndex = uint( seed );
 
 					vec3 rayDirection;
 					vec3 rayOrigin;
@@ -441,6 +440,8 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 					for ( i = 0; i < bounces; i ++ ) {
 
+						sobolBounceIndex ++;
+
 						bool hit = bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist );
 
 						LightSampleRec lightHit = lightsClosestHit( lights.tex, lights.count, rayOrigin, rayDirection );
@@ -455,9 +456,8 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 								#if FEATURE_MIS
 
-								// NOTE: we skip MIS for spotlights since we haven't fixed the forward
-								// path tracing code path, yet
-								if ( lightHit.type == SPOT_LIGHT_TYPE ) {
+								// NOTE: we skip MIS for punctual lights since they are not supported in forward PT case
+								if ( lightHit.type == SPOT_LIGHT_TYPE || lightHit.type == DIR_LIGHT_TYPE || lightHit.type == POINT_LIGHT_TYPE ) {
 
 									gl_FragColor.rgb += lightHit.emission * throughputColor;
 
@@ -484,7 +484,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 							if ( i == 0 || transmissiveRay ) {
 
-								gl_FragColor.rgb += sampleBackground( envRotation3x3 * rayDirection ) * throughputColor;
+								gl_FragColor.rgb += sampleBackground( envRotation3x3 * rayDirection, sobol2( 2 ) ) * throughputColor;
 								gl_FragColor.a = backgroundAlpha;
 
 							} else {
@@ -493,7 +493,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 								// get the PDF of the hit envmap point
 								vec3 envColor;
-								float envPdf = envMapSample( envRotation3x3 * rayDirection, envMapInfo, envColor );
+								float envPdf = sampleEnvMap( envMapInfo, envRotation3x3 * rayDirection, envColor );
 								envPdf /= float( lights.count + 1u );
 
 								// and weight the contribution
@@ -578,7 +578,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 							|| useAlphaTest && albedo.a < alphaTest
 
 							// opacity
-							|| material.transparent && ! useAlphaTest && albedo.a < rand()
+							|| material.transparent && ! useAlphaTest && albedo.a < sobol( 3 )
 						) {
 
 							vec3 point = rayOrigin + rayDirection * dist;
@@ -639,6 +639,15 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 						}
 
 						// normal
+						if ( material.flatShading ) {
+
+							// if we're rendering a flat shaded object then use the face normals - the face normal
+							// is provided based on the side the ray hits the mesh so flip it to align with the
+							// interpolated vertex normals.
+							normal = faceNormal * side;
+
+						}
+
 						vec3 baseNormal = normal;
 						if ( material.normalMap != - 1 ) {
 
@@ -682,7 +691,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 						if ( material.clearcoatRoughnessMap != - 1 ) {
 
 							vec3 uvPrime = material.clearcoatRoughnessMapTransform * vec3( uv, 1 );
-							clearcoat *= texture2D( textures, vec3( uvPrime.xy, material.clearcoatRoughnessMap ) ).g;
+							clearcoatRoughness *= texture2D( textures, vec3( uvPrime.xy, material.clearcoatRoughnessMap ) ).g;
 
 						}
 
@@ -821,7 +830,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 						vec3 clearcoatOutgoing = - normalize( clearcoatInvBasis * rayDirection );
 						sampleRec = bsdfSample( outgoing, clearcoatOutgoing, normalBasis, invBasis, clearcoatNormalBasis, clearcoatInvBasis, surfaceRec );
 
-						isShadowRay = sampleRec.specularPdf < rand();
+						isShadowRay = sampleRec.specularPdf < sobol( 4 );
 
 						// adjust the hit point by the surface normal by a factor of some offset and the
 						// maximum component-wise value of the current point to accommodate floating point
@@ -838,10 +847,10 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 						#if FEATURE_MIS
 
 						// uniformly pick a light or environment map
-						if( rand() > 1.0 / float( lights.count + 1u ) ) {
+						if( sobol( 5 ) > 1.0 / float( lights.count + 1u ) ) {
 
 							// sample a light or environment
-							LightSampleRec lightSampleRec = randomLightSample( lights.tex, iesProfiles, lights.count, rayOrigin );
+							LightSampleRec lightSampleRec = randomLightSample( lights.tex, iesProfiles, lights.count, rayOrigin, sobol3( 6 ) );
 
 							bool isSampleBelowSurface = dot( faceNormal, lightSampleRec.direction ) < 0.0;
 							if ( isSampleBelowSurface ) {
@@ -865,7 +874,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 									// weight the direct light contribution
 									float lightPdf = lightSampleRec.pdf / float( lights.count + 1u );
-									float misWeight = misHeuristic( lightPdf, lightMaterialPdf );
+									float misWeight = lightSampleRec.type == SPOT_LIGHT_TYPE || lightSampleRec.type == DIR_LIGHT_TYPE || lightSampleRec.type == POINT_LIGHT_TYPE ? 1.0 : misHeuristic( lightPdf, lightMaterialPdf );
 									gl_FragColor.rgb += lightSampleRec.emission * throughputColor * sampleColor * misWeight / lightPdf;
 
 								}
@@ -876,7 +885,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 							// find a sample in the environment map to include in the contribution
 							vec3 envColor, envDirection;
-							float envPdf = randomEnvMapSample( envMapInfo, envColor, envDirection );
+							float envPdf = sampleEnvMapProbability( envMapInfo, sobol2( 7 ), envColor, envDirection );
 							envDirection = invEnvRotation3x3 * envDirection;
 
 							// this env sampling is not set up for transmissive sampling and yields overly bright

package/src/shader/shaderEnvMapSampling.js

@@ -21,13 +21,13 @@ float envMapDirectionPdf( vec3 direction ) {
 
 }
 
-float envMapSample( vec3 direction, EquirectHdrInfo info, out vec3 color ) {
+float sampleEnvMap( EquirectHdrInfo info, vec3 direction, out vec3 color ) {
 
 	vec2 uv = equirectDirectionToUv( direction );
 	color = texture2D( info.map, uv ).rgb;
 
 	float totalSum = info.totalSumWhole + info.totalSumDecimal;
-	float lum = colorToLuminance( color );
+	float lum = luminance( color );
 	ivec2 resolution = textureSize( info.map, 0 );
 	float pdf = lum / totalSum;
 
@@ -35,10 +35,9 @@ float envMapSample( vec3 direction, EquirectHdrInfo info, out vec3 color ) {
 
 }
 
-float randomEnvMapSample( EquirectHdrInfo info, out vec3 color, out vec3 direction ) {
+float sampleEnvMapProbability( EquirectHdrInfo info, vec2 r, out vec3 color, out vec3 direction ) {
 
 	// sample env map cdf
-	vec2 r = rand2();
 	float v = texture2D( info.marginalWeights, vec2( r.x, 0.0 ) ).x;
 	float u = texture2D( info.conditionalWeights, vec2( r.y, v ) ).x;
 	vec2 uv = vec2( u, v );
@@ -48,7 +47,7 @@ float randomEnvMapSample( EquirectHdrInfo info, out vec3 color, out vec3 directi
 	color = texture2D( info.map, uv ).rgb;
 
 	float totalSum = info.totalSumWhole + info.totalSumDecimal;
-	float lum = colorToLuminance( color );
+	float lum = luminance( color );
 	ivec2 resolution = textureSize( info.map, 0 );
 	float pdf = lum / totalSum;
 

package/src/shader/shaderGGXFunctions.js

@@ -8,14 +8,14 @@ export const shaderGGXFunctions = /* glsl */`
 
 // trowbridge-reitz === GGX === GTR
 
-vec3 ggxDirection( vec3 incidentDir, float roughnessX, float roughnessY, float random1, float random2 ) {
+vec3 ggxDirection( vec3 incidentDir, vec2 roughness, vec2 uv ) {
 
 	// TODO: try GGXVNDF implementation from reference [2], here. Needs to update ggxDistribution
 	// function below, as well
 
 	// Implementation from reference [1]
 	// stretch view
-	vec3 V = normalize( vec3( roughnessX * incidentDir.x, roughnessY * incidentDir.y, incidentDir.z ) );
+	vec3 V = normalize( vec3( roughness * incidentDir.xy, incidentDir.z ) );
 
 	// orthonormal basis
 	vec3 T1 = ( V.z < 0.9999 ) ? normalize( cross( V, vec3( 0.0, 0.0, 1.0 ) ) ) : vec3( 1.0, 0.0, 0.0 );
@@ -23,16 +23,16 @@ vec3 ggxDirection( vec3 incidentDir, float roughnessX, float roughnessY, float r
 
 	// sample point with polar coordinates (r, phi)
 	float a = 1.0 / ( 1.0 + V.z );
-	float r = sqrt( random1 );
-	float phi = ( random2 < a ) ? random2 / a * PI : PI + ( random2 - a ) / ( 1.0 - a ) * PI;
+	float r = sqrt( uv.x );
+	float phi = ( uv.y < a ) ? uv.y / a * PI : PI + ( uv.y - a ) / ( 1.0 - a ) * PI;
 	float P1 = r * cos( phi );
-	float P2 = r * sin( phi ) * ( ( random2 < a ) ? 1.0 : V.z );
+	float P2 = r * sin( phi ) * ( ( uv.y < a ) ? 1.0 : V.z );
 
 	// compute normal
 	vec3 N = P1 * T1 + P2 * T2 + V * sqrt( max( 0.0, 1.0 - P1 * P1 - P2 * P2 ) );
 
 	// unstretch
-	N = normalize( vec3( roughnessX * N.x, roughnessY * N.y, max( 0.0, N.z ) ) );
+	N = normalize( vec3( roughness * N.xy, max( 0.0, N.z ) ) );
 
 	return N;
 

package/src/shader/shaderLightSampling.js

@@ -67,6 +67,7 @@ LightSampleRec lightsClosestHit( sampler2D lights, uint lightCount, vec3 rayOrig
 
 		float dist;
 
+		// MIS / light intersection is not supported for punctual lights.
 		if(
 			( light.type == RECT_AREA_LIGHT_TYPE && intersectsRectangle( light.position, normal, u, v, rayOrigin, rayDirection, dist ) ) ||
 			( light.type == CIRC_AREA_LIGHT_TYPE && intersectsCircle( light.position, normal, u, v, rayOrigin, rayDirection, dist ) )
@@ -85,38 +86,6 @@ LightSampleRec lightsClosestHit( sampler2D lights, uint lightCount, vec3 rayOrig
 
 			}
 
-		} else if ( light.type == SPOT_LIGHT_TYPE ) {
-
-			// TODO: forward path tracing sampling needs to be made consistent with direct light sampling logic
-			// float radius = light.radius;
-			// vec3 lightNormal = normalize( cross( light.u, light.v ) );
-			// float angle = acos( light.coneCos );
-			// float angleTan = tan( angle );
-			// float startDistance = radius / max( angleTan, EPSILON );
-
-			// u = light.u / radius;
-			// v = light.v / radius;
-
-			// if (
-			// 	intersectsCircle( light.position - normal * startDistance, normal, u, v, rayOrigin, rayDirection, dist ) &&
-			// 	( dist < lightSampleRec.dist || ! lightSampleRec.hit )
-			// ) {
-
-			// 	float cosTheta = dot( rayDirection, normal );
-			// 	float spotAttenuation = light.iesProfile != - 1 ?
-			// 		getPhotometricAttenuation( iesProfiles, light.iesProfile, rayDirection, normal, u, v )
-			// 		: getSpotAttenuation( light.coneCos, light.penumbraCos, cosTheta );
-
-			// 	float distanceAttenuation = getDistanceAttenuation( dist, light.distance, light.decay );
-
-			// 	lightSampleRec.hit = true;
-			// 	lightSampleRec.dist = dist;
-			// 	lightSampleRec.direction = rayDirection;
-			// 	lightSampleRec.emission = light.color * light.intensity * distanceAttenuation * spotAttenuation;
-			// 	lightSampleRec.pdf = ( dist * dist ) / ( light.area * cosTheta );
-
-			// }
-
 		}
 
 	}
@@ -125,7 +94,7 @@ LightSampleRec lightsClosestHit( sampler2D lights, uint lightCount, vec3 rayOrig
 
 }
 
-LightSampleRec randomAreaLightSample( Light light, vec3 rayOrigin ) {
+LightSampleRec randomAreaLightSample( Light light, vec3 rayOrigin, vec2 ruv ) {
 
 	LightSampleRec lightSampleRec;
 	lightSampleRec.hit = true;
@@ -137,13 +106,13 @@ LightSampleRec randomAreaLightSample( Light light, vec3 rayOrigin ) {
 	if( light.type == RECT_AREA_LIGHT_TYPE ) {
 
 		// rectangular area light
-		randomPos = light.position + light.u * ( rand() - 0.5 ) + light.v * ( rand() - 0.5 );
+		randomPos = light.position + light.u * ( ruv.x - 0.5 ) + light.v * ( ruv.y - 0.5 );
 
-	} else if( light.type == 1 ) {
+	} else if( light.type == CIRC_AREA_LIGHT_TYPE ) {
 
 		// circular area light
-		float r = 0.5 * sqrt( rand() );
-		float theta = rand() * 2.0 * PI;
+		float r = 0.5 * sqrt( ruv.x );
+		float theta = ruv.y * 2.0 * PI;
 		float x = r * cos( theta );
 		float y = r * sin( theta );
 
@@ -165,10 +134,10 @@ LightSampleRec randomAreaLightSample( Light light, vec3 rayOrigin ) {
 
 }
 
-LightSampleRec randomSpotLightSample( Light light, sampler2DArray iesProfiles, vec3 rayOrigin ) {
+LightSampleRec randomSpotLightSample( Light light, sampler2DArray iesProfiles, vec3 rayOrigin, vec2 ruv ) {
 
-	float radius = light.radius * sqrt( rand() );
-	float theta = rand() * 2.0 * PI;
+	float radius = light.radius * sqrt( ruv.x );
+	float theta = ruv.y * 2.0 * PI;
 	float x = radius * cos( theta );
 	float y = radius * sin( theta );
 
@@ -189,8 +158,8 @@ LightSampleRec randomSpotLightSample( Light light, sampler2DArray iesProfiles, v
 	float cosTheta = dot( direction, normal );
 
 	float spotAttenuation = light.iesProfile != - 1 ?
-		  getPhotometricAttenuation( iesProfiles, light.iesProfile, direction, normal, u, v )
-		: getSpotAttenuation( light.coneCos, light.penumbraCos, cosTheta );
+		getPhotometricAttenuation( iesProfiles, light.iesProfile, direction, normal, u, v ) :
+		getSpotAttenuation( light.coneCos, light.penumbraCos, cosTheta );
 
 	float distanceAttenuation = getDistanceAttenuation( dist, light.distance, light.decay );
 	LightSampleRec lightSampleRec;
@@ -199,30 +168,59 @@ LightSampleRec randomSpotLightSample( Light light, sampler2DArray iesProfiles, v
 	lightSampleRec.dist = dist;
 	lightSampleRec.direction = direction;
 	lightSampleRec.emission = light.color * light.intensity * distanceAttenuation * spotAttenuation;
-
-	// TODO: this makes the result consistent between MIS and non MIS paths but at radius 0 the pdf is infinite
-	// and the intensity of the light is not correct
 	lightSampleRec.pdf = 1.0;
-	// lightSampleRec.pdf = lightDistSq / ( light.area * cosTheta );
 
 	return lightSampleRec;
 
 }
 
-LightSampleRec randomLightSample( sampler2D lights, sampler2DArray iesProfiles, uint lightCount, vec3 rayOrigin ) {
+LightSampleRec randomLightSample( sampler2D lights, sampler2DArray iesProfiles, uint lightCount, vec3 rayOrigin, vec3 ruv ) {
 
 	// pick a random light
-	uint l = uint( rand() * float( lightCount ) );
+	uint l = uint( ruv.x * float( lightCount ) );
 	Light light = readLightInfo( lights, l );
 
 	if ( light.type == SPOT_LIGHT_TYPE ) {
 
-		return randomSpotLightSample( light, iesProfiles, rayOrigin );
+		return randomSpotLightSample( light, iesProfiles, rayOrigin, ruv.yz );
+
+	} else if ( light.type == POINT_LIGHT_TYPE ) {
+
+		vec3 lightRay = light.u - rayOrigin;
+		float lightDist = length( lightRay );
+		float cutoffDistance = light.distance;
+		float distanceFalloff = 1.0 / max( pow( lightDist, light.decay ), 0.01 );
+		if ( cutoffDistance > 0.0 ) {
+
+			distanceFalloff *= pow2( saturate( 1.0 - pow4( lightDist / cutoffDistance ) ) );
+
+		}
+
+		LightSampleRec rec;
+		rec.hit = true;
+		rec.direction = normalize( lightRay );
+		rec.dist = length( lightRay );
+		rec.pdf = 1.0;
+		rec.emission = light.color * light.intensity * distanceFalloff;
+		rec.type = light.type;
+		return rec;
+
+	} else if ( light.type == DIR_LIGHT_TYPE ) {
+
+		LightSampleRec rec;
+		rec.hit = true;
+		rec.dist = 1e10;
+		rec.direction = light.u;
+		rec.pdf = 1.0;
+		rec.emission = light.color * light.intensity;
+		rec.type = light.type;
+
+		return rec;
 
 	} else {
 
 		// sample the light
-		return randomAreaLightSample( light, rayOrigin );
+		return randomAreaLightSample( light, rayOrigin, ruv.yz );
 
 	}
 

package/src/shader/shaderMaterialSampling.js

@@ -93,7 +93,7 @@ float diffuseEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRec surf, out vec3 color )
 
 vec3 diffuseDirection( vec3 wo, SurfaceRec surf ) {
 
-	vec3 lightDirection = randDirection();
+	vec3 lightDirection = sampleSphere( sobol2( 11 ) );
 	lightDirection.z += 1.0;
 	lightDirection = normalize( lightDirection );
 
@@ -147,10 +147,8 @@ vec3 specularDirection( vec3 wo, SurfaceRec surf ) {
 	float filteredRoughness = surf.filteredRoughness;
 	vec3 halfVector = ggxDirection(
 		wo,
-		filteredRoughness,
-		filteredRoughness,
-		rand(),
-		rand()
+		vec2( filteredRoughness ),
+		sobol2( 12 )
 	);
 
 	// apply to new ray by reflecting off the new normal
@@ -187,10 +185,8 @@ vec3 transmissionDirection( vec3 wo, SurfaceRec surf ) {
 	// sample ggx vndf distribution which gives a new normal
 	vec3 halfVector = ggxDirection(
 		wo,
-		filteredRoughness,
-		filteredRoughness,
-		rand(),
-		rand()
+		vec2( filteredRoughness ),
+		sobol2( 13 )
 	);
 
 
@@ -230,7 +226,7 @@ vec3 transmissionDirection( vec3 wo, SurfaceRec surf ) {
 
 	float roughness = surf.roughness;
 	float eta = surf.eta;
-	vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + randDirection() * roughness );
+	vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + sampleSphere( sobol2( 13 ) ) * roughness );
 	vec3 lightDirection = refract( normalize( - wo ), halfVector, eta );
 
 	if ( surf.thinFilm ) {
@@ -278,10 +274,8 @@ vec3 clearcoatDirection( vec3 wo, SurfaceRec surf ) {
 	float filteredClearcoatRoughness = surf.filteredClearcoatRoughness;
 	vec3 halfVector = ggxDirection(
 		wo,
-		filteredClearcoatRoughness,
-		filteredClearcoatRoughness,
-		rand(),
-		rand()
+		vec2( filteredClearcoatRoughness ),
+		sobol2( 14 )
 	);
 
 	// apply to new ray by reflecting off the new normal
@@ -470,7 +464,7 @@ SampleRec bsdfSample( vec3 wo, vec3 clearcoatWo, mat3 normalBasis, mat3 invBasis
 	vec3 wi;
 	vec3 clearcoatWi;
 
-	float r = rand();
+	float r = sobol( 15 );
 	if ( r <= cdf[0] ) { // diffuse
 
 		wi = diffuseDirection( wo, surf );

package/src/shader/shaderRandFunctions.js

@@ -0,0 +1,57 @@
+export const shaderRandFunctions = /* glsl */`
+
+	// https://www.shadertoy.com/view/wltcRS
+	uvec4 WHITE_NOISE_SEED;
+
+	void rng_initialize( vec2 p, int frame ) {
+
+		// white noise seed
+		WHITE_NOISE_SEED = uvec4( p, uint( frame ), uint( p.x ) + uint( p.y ) );
+
+	}
+
+	// https://www.pcg-random.org/
+	void pcg4d( inout uvec4 v ) {
+
+		v = v * 1664525u + 1013904223u;
+		v.x += v.y * v.w;
+		v.y += v.z * v.x;
+		v.z += v.x * v.y;
+		v.w += v.y * v.z;
+		v = v ^ ( v >> 16u );
+		v.x += v.y*v.w;
+		v.y += v.z*v.x;
+		v.z += v.x*v.y;
+		v.w += v.y*v.z;
+
+	}
+
+	// returns [ 0, 1 ]
+	float rand() {
+
+		pcg4d( WHITE_NOISE_SEED );
+		return float( WHITE_NOISE_SEED.x ) / float( 0xffffffffu );
+
+	}
+
+	vec2 rand2() {
+
+		pcg4d( WHITE_NOISE_SEED );
+		return vec2( WHITE_NOISE_SEED.xy ) / float(0xffffffffu);
+
+	}
+
+	vec3 rand3() {
+
+		pcg4d( WHITE_NOISE_SEED );
+		return vec3( WHITE_NOISE_SEED.xyz ) / float( 0xffffffffu );
+
+	}
+
+	vec4 rand4() {
+
+		pcg4d( WHITE_NOISE_SEED );
+		return vec4( WHITE_NOISE_SEED ) / float( 0xffffffffu );
+
+	}
+`;