three-gpu-pathtracer 0.0.16 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-gpu-pathtracer",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "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",
@@ -28,9 +28,6 @@
     "path",
     "tracer"
   ],
-  "dependencies": {
-    "three-mesh-bvh": "^0.5.19"
-  },
   "devDependencies": {
     "@lookingglass/webxr": "^0.3.1",
     "canvas-capture": "^2.0.5",
@@ -44,11 +41,13 @@
     "puppeteer": "^15.4.0",
     "rollup": "^2.70.0",
     "simple-git": "^3.10.0",
-    "three": "^0.147.0",
+    "three": "^0.160.0",
+    "three-mesh-bvh": "0.7.0",
     "yargs": "^17.5.1"
   },
   "peerDependencies": {
-    "three": ">=0.139.2",
+    "three": ">=0.151.0",
+    "three-mesh-bvh": "0.7.0",
     "xatlas-web": "^0.1.0"
   },
   "scripts": {

package/src/core/DynamicPathTracingSceneGenerator.js

@@ -38,7 +38,7 @@ export class DynamicPathTracingSceneGenerator {
 
 	generate() {
 
-		const { objects, staticGeometryGenerator, geometry } = this;
+		const { objects, staticGeometryGenerator, geometry, lights } = this;
 		if ( this.bvh === null ) {
 
 			const attributes = [ 'position', 'normal', 'tangent', 'uv', 'color' ];
@@ -52,9 +52,14 @@ export class DynamicPathTracingSceneGenerator {
 						const normalMapRequired = ! ! c.material.normalMap;
 						setCommonAttributes( c.geometry, { attributes, normalMapRequired } );
 
-					} else if ( c.isRectAreaLight || c.isSpotLight ) {
+					} else if (
+						c.isRectAreaLight ||
+						c.isSpotLight ||
+						c.isPointLight ||
+						c.isDirectionalLight
+					) {
 
-						this.lights.push( c );
+						lights.push( c );
 
 					}
 

package/src/core/PathTracingRenderer.js

@@ -1,4 +1,4 @@
-import { RGBAFormat, FloatType, Color, Vector2, WebGLRenderTarget, NoBlending, NormalBlending, Vector4 } from 'three';
+import { RGBAFormat, FloatType, HalfFloatType, Color, Vector2, WebGLRenderTarget, NoBlending, NormalBlending, Vector4 } from 'three';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
 import { BlendMaterial } from '../materials/fullscreen/BlendMaterial.js';
 import { SobolNumberMapGenerator } from '../utils/SobolNumberMapGenerator.js';
@@ -250,18 +250,22 @@ export class PathTracingRenderer {
 		this._currentTile = 0;
 
 		this._sobolTarget = new SobolNumberMapGenerator().generate( renderer );
+
+		// will be null if extension not supported
+		const floatLinearExtensionSupported = renderer.extensions.get( 'OES_texture_float_linear' );
+
 		this._primaryTarget = new WebGLRenderTarget( 1, 1, {
 			format: RGBAFormat,
-			type: FloatType,
+			type: floatLinearExtensionSupported ? FloatType : HalfFloatType,
 		} );
 		this._blendTargets = [
 			new WebGLRenderTarget( 1, 1, {
 				format: RGBAFormat,
-				type: FloatType,
+				type: floatLinearExtensionSupported ? FloatType : HalfFloatType,
 			} ),
 			new WebGLRenderTarget( 1, 1, {
 				format: RGBAFormat,
-				type: FloatType,
+				type: floatLinearExtensionSupported ? FloatType : HalfFloatType,
 			} ),
 		];
 

package/src/core/PathTracingSceneGenerator.js

@@ -33,7 +33,12 @@ export class PathTracingSceneGenerator {
 
 					meshes.push( c );
 
-				} else if ( c.isRectAreaLight || c.isSpotLight || c.isDirectionalLight || c.isPointLight ) {
+				} else if (
+					c.isRectAreaLight ||
+					c.isSpotLight ||
+					c.isPointLight ||
+					c.isDirectionalLight
+				) {
 
 					lights.push( c );
 

package/src/materials/debug/GraphMaterial.js

@@ -198,7 +198,7 @@ export class GraphMaterial extends MaterialBase {
 
 					}
 
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 
 				}
 

package/src/materials/fullscreen/AlphaDisplayMaterial.js

@@ -37,7 +37,7 @@ export class AlphaDisplayMaterial extends MaterialBase {
 					gl_FragColor = vec4( texture( map, vUv ).a );
 					gl_FragColor.a = 1.0;
 
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 
 				}`
 

package/src/materials/fullscreen/DenoiseMaterial.js

@@ -126,7 +126,7 @@ export class DenoiseMaterial extends MaterialBase {
 
 					gl_FragColor = smartDeNoise( map, vec2( vUv.x, vUv.y ), sigma, kSigma, threshold );
 					#include <tonemapping_fragment>
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 					#include <premultiplied_alpha_fragment>
 
 				}

package/src/materials/fullscreen/GradientMapMaterial.js

@@ -69,7 +69,7 @@ export class GradientMapMaterial extends MaterialBase {
 					gl_FragColor.rgb = vec3( mix( minColor, maxColor, t ) );
 					gl_FragColor.a = 1.0;
 
-					#include <encodings_fragment>
+					#include <colorspace_fragment>
 
 				}`,
 

package/src/materials/pathtracing/LambertPathTracingMaterial.js

@@ -2,7 +2,7 @@ import { Matrix4, Color } from 'three';
 import { MaterialBase } from '../MaterialBase.js';
 import {
 	MeshBVHUniformStruct, FloatVertexAttributeTexture, UIntVertexAttributeTexture,
-	shaderStructs, shaderIntersectFunction,
+	BVHShaderGLSL,
 } from 'three-mesh-bvh';
 
 // uniforms
@@ -85,8 +85,9 @@ export class LambertPathTracingMaterial extends MaterialBase {
 				#include <common>
 				#include <cube_uv_reflection_fragment>
 
-				${ shaderStructs }
-				${ shaderIntersectFunction }
+				${ BVHShaderGLSL.common_functions }
+				${ BVHShaderGLSL.bvh_struct_definitions }
+				${ BVHShaderGLSL.bvh_ray_functions }
 
 				// uniform structs
 				${ materialStructGLSL }

package/src/materials/pathtracing/PhysicalPathTracingMaterial.js

@@ -2,7 +2,7 @@ import { Matrix4, Vector2 } from 'three';
 import { MaterialBase } from '../MaterialBase.js';
 import {
 	MeshBVHUniformStruct, UIntVertexAttributeTexture,
-	shaderStructs, shaderIntersectFunction,
+	BVHShaderGLSL,
 } from 'three-mesh-bvh';
 
 // uniforms
@@ -72,6 +72,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				FEATURE_DOF: 1,
 				FEATURE_BACKGROUND_MAP: 0,
 				FEATURE_FOG: 1,
+				FEATURE_SOBOL: 0,
 				// 0 = Perspective
 				// 1 = Orthographic
 				// 2 = Equirectangular
@@ -141,13 +142,36 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				#include <common>
 
 				// bvh intersection
-				${ shaderStructs }
-				${ shaderIntersectFunction }
+				${ BVHShaderGLSL.common_functions }
+				${ BVHShaderGLSL.bvh_struct_definitions }
+				${ BVHShaderGLSL.bvh_ray_functions }
+
+				// uniform structs
+				${ cameraStructGLSL }
+				${ lightsStructGLSL }
+				${ equirectStructGLSL }
+				${ materialStructGLSL }
 
 				// random
 				${ pcgGLSL }
-				${ sobolCommonGLSL }
-				${ sobolSamplingGLSL }
+				#if FEATURE_SOBOL
+
+					${ sobolCommonGLSL }
+					${ sobolSamplingGLSL }
+
+				#else
+
+					// Using the sobol functions seems to break the the compiler on MacOS
+					// - specifically the "sobolReverseBits" function.
+					uint sobolPixelIndex = 0u;
+					uint sobolPathIndex = 0u;
+					uint sobolBounceIndex = 0u;
+					float sobol( int v ) { return rand(); }
+					vec2 sobol2( int v ) { return rand2(); }
+					vec3 sobol3( int v ) { return rand3(); }
+					vec4 sobol4( int v ) { return rand4(); }
+
+				#endif
 
 				// common
 				${ arraySamplerTexelFetchGLSL }
@@ -156,20 +180,6 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				${ mathGLSL }
 				${ intersectShapesGLSL }
 
-				// uniform structs
-				${ cameraStructGLSL }
-				${ lightsStructGLSL }
-				${ equirectStructGLSL }
-				${ materialStructGLSL }
-				${ fogMaterialBvhGLSL }
-
-				// sampling
-				${ shapeSamplingGLSL }
-				${ bsdfSamplingGLSL }
-				${ equirectSamplingGLSL }
-				${ lightSamplingGLSL }
-				${ fogGLSL }
-
 				// environment
 				uniform EquirectHdrInfo envMapInfo;
 				uniform mat4 environmentRotation;
@@ -221,6 +231,14 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				mat3 invEnvRotation3x3;
 				float lightsDenom;
 
+				// sampling
+				${ fogMaterialBvhGLSL }
+				${ shapeSamplingGLSL }
+				${ bsdfSamplingGLSL }
+				${ equirectSamplingGLSL }
+				${ lightSamplingGLSL }
+				${ fogGLSL }
+
 				float applyFilteredGlossy( float roughness, float accumulatedRoughness ) {
 
 					return clamp(
@@ -260,7 +278,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 					// init
 					rng_initialize( gl_FragCoord.xy, seed );
-					sobolPixelIndex = ( uint( gl_FragCoord.x ) << 16 ) |  uint( gl_FragCoord.y );
+					sobolPixelIndex = ( uint( gl_FragCoord.x ) << 16 ) | uint( gl_FragCoord.y );
 					sobolPathIndex = uint( seed );
 
 					// get camera ray
@@ -276,7 +294,6 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 					// surface results
 					SurfaceHit surfaceHit;
-					LightRecord lightRec;
 					ScatterRecord scatterRec;
 
 					// path tracing state
@@ -285,7 +302,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 					#if FEATURE_FOG
 
 					state.fogMaterial.fogVolume = bvhIntersectFogVolumeHit(
-						bvh, ray.origin, - ray.direction,
+						ray.origin, - ray.direction,
 						materialIndexAttribute, materials,
 						state.fogMaterial
 					);
@@ -300,44 +317,42 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 						state.traversals = bounces - i;
 						state.firstRay = i == 0 && state.transmissiveTraversals == transmissiveBounces;
 
-						int hitType = traceScene(
-							ray, bvh, lights, state.fogMaterial,
-							surfaceHit, lightRec
-						);
-
-						if ( hitType == LIGHT_HIT ) {
-
-							if ( state.firstRay || state.transmissiveRay ) {
-
-								gl_FragColor.rgb += lightRec.emission * state.throughputColor;
+						int hitType = traceScene( ray, state.fogMaterial, surfaceHit );
 
-							} else {
-
-								#if FEATURE_MIS
+						// check if we intersect any lights and accumulate the light contribution
+						// TODO: we can add support for light surface rendering in the else condition if we
+						// add the ability to toggle visibility of the the light
+						if ( ! state.firstRay && ! state.transmissiveRay ) {
 
-								// NOTE: we skip MIS for punctual lights since they are not supported in forward PT case
-								if ( lightRec.type == SPOT_LIGHT_TYPE || lightRec.type == DIR_LIGHT_TYPE || lightRec.type == POINT_LIGHT_TYPE ) {
+							LightRecord lightRec;
+							float lightDist = hitType == NO_HIT ? INFINITY : surfaceHit.dist;
+							for ( uint i = 0u; i < lights.count; i ++ ) {
 
-									gl_FragColor.rgb += lightRec.emission * state.throughputColor;
+								if (
+									intersectLightAtIndex( lights.tex, ray.origin, ray.direction, i, lightRec ) &&
+									lightRec.dist < lightDist
+								) {
 
-								} else {
+									#if FEATURE_MIS
 
 									// weight the contribution
+									// NOTE: Only area lights are supported for forward sampling and can be hit
 									float misWeight = misHeuristic( scatterRec.pdf, lightRec.pdf / lightsDenom );
 									gl_FragColor.rgb += lightRec.emission * state.throughputColor * misWeight;
 
-								}
+									#else
 
-								#else
+									gl_FragColor.rgb += lightRec.emission * state.throughputColor;
 
-								gl_FragColor.rgb += lightRec.emission * state.throughputColor;
+									#endif
 
-								#endif
+								}
 
 							}
-							break;
 
-						} else if ( hitType == NO_HIT ) {
+						}
+
+						if ( hitType == NO_HIT ) {
 
 							if ( state.firstRay || state.transmissiveRay ) {
 
@@ -350,7 +365,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 								// get the PDF of the hit envmap point
 								vec3 envColor;
-								float envPdf = sampleEquirect( envMapInfo, envRotation3x3 * ray.direction, envColor );
+								float envPdf = sampleEquirect( envRotation3x3 * ray.direction, envColor );
 								envPdf /= lightsDenom;
 
 								// and weight the contribution

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

@@ -3,7 +3,7 @@ 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,
+		RenderState state,
 		Ray ray, float rayDist,
 		out vec3 color
 	) {
@@ -17,7 +17,6 @@ export const attenuateHitGLSL = /* glsl */`
 
 		// hit results
 		SurfaceHit surfaceHit;
-		LightRecord lightRec;
 
 		color = vec3( 1.0 );
 
@@ -25,20 +24,12 @@ export const attenuateHitGLSL = /* glsl */`
 		// and then reset.
 		for ( int i = 0; i < traversals; i ++ ) {
 
-			int hitType = traceScene(
-				ray, bvh, lights, fogMaterial,
-				surfaceHit, lightRec
-			);
+			int hitType = traceScene( ray, fogMaterial, surfaceHit );
 
 			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 );

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

@@ -2,6 +2,8 @@ export const directLightContributionGLSL = /*glsl*/`
 
 	vec3 directLightContribution( vec3 worldWo, SurfaceRecord surf, RenderState state, vec3 rayOrigin ) {
 
+		vec3 result = vec3( 0.0 );
+
 		// uniformly pick a light or environment map
 		if( lightsDenom != 0.0 && sobol( 5 ) < float( lights.count ) / lightsDenom ) {
 
@@ -23,7 +25,7 @@ export const directLightContributionGLSL = /*glsl*/`
 			if (
 				lightRec.pdf > 0.0 &&
 				isDirectionValid( lightRec.direction, surf.normal, surf.faceNormal ) &&
-				! attenuateHit( bvh, state, lightRay, lightRec.dist, attenuatedColor )
+				! attenuateHit( state, lightRay, lightRec.dist, attenuatedColor )
 			) {
 
 				// get the material pdf
@@ -35,7 +37,7 @@ export const directLightContributionGLSL = /*glsl*/`
 					// 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;
+					result = attenuatedColor * lightRec.emission * state.throughputColor * sampleColor * misWeight / lightPdf;
 
 				}
 
@@ -45,7 +47,7 @@ export const directLightContributionGLSL = /*glsl*/`
 
 			// find a sample in the environment map to include in the contribution
 			vec3 envColor, envDirection;
-			float envPdf = sampleEquirectProbability( envMapInfo, sobol2( 7 ), envColor, envDirection );
+			float envPdf = sampleEquirectProbability( sobol2( 7 ), envColor, envDirection );
 			envDirection = invEnvRotation3x3 * envDirection;
 
 			// this env sampling is not set up for transmissive sampling and yields overly bright
@@ -66,7 +68,7 @@ export const directLightContributionGLSL = /*glsl*/`
 			if (
 				envPdf > 0.0 &&
 				isDirectionValid( envDirection, surf.normal, surf.faceNormal ) &&
-				! attenuateHit( bvh, state, envRay, INFINITY, attenuatedColor )
+				! attenuateHit( state, envRay, INFINITY, attenuatedColor )
 			) {
 
 				// get the material pdf
@@ -78,7 +80,7 @@ export const directLightContributionGLSL = /*glsl*/`
 					// weight the direct light contribution
 					envPdf /= lightsDenom;
 					float misWeight = misHeuristic( envPdf, envMaterialPdf );
-					return attenuatedColor * environmentIntensity * envColor * state.throughputColor * sampleColor * misWeight / envPdf;
+					result = attenuatedColor * environmentIntensity * envColor * state.throughputColor * sampleColor * misWeight / envPdf;
 
 				}
 
@@ -86,7 +88,9 @@ export const directLightContributionGLSL = /*glsl*/`
 
 		}
 
-		return vec3( 0.0 );
+		// Function changed to have a single return statement to potentially help with crashes on Mac OS.
+		// See issue #470
+		return result;
 
 	}
 

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

@@ -6,7 +6,7 @@ export const getSurfaceRecordGLSL = /* glsl */`
 	int getSurfaceRecord(
 		Material material, SurfaceHit surfaceHit, sampler2DArray attributesArray,
 		float accumulatedRoughness,
-		out SurfaceRecord surf
+		inout SurfaceRecord surf
 	) {
 
 		if ( material.fogVolume ) {

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

@@ -5,22 +5,26 @@ export const traceSceneGLSL = /* glsl */`
 	#define LIGHT_HIT 2
 	#define FOG_HIT 3
 
+	// Passing the global variable 'lights' into this function caused shader program errors.
+	// So global variables like 'lights' and 'bvh' were moved out of the function parameters.
+	// For more information, refer to: https://github.com/gkjohnson/three-gpu-pathtracer/pull/457
 	int traceScene(
 
-		Ray ray, BVH bvh, LightsInfo lights, Material fogMaterial,
-		out SurfaceHit surfaceHit, out LightRecord lightRec
+		Ray ray, Material fogMaterial, inout SurfaceHit surfaceHit
 
 	) {
 
+		int result = NO_HIT;
 		bool hit = bvhIntersectFirstHit( bvh, ray.origin, ray.direction, surfaceHit.faceIndices, surfaceHit.faceNormal, surfaceHit.barycoord, surfaceHit.side, surfaceHit.dist );
-		bool lightHit = lightsClosestHit( lights.tex, lights.count, ray.origin, ray.direction, lightRec );
 
 		#if FEATURE_FOG
 
 		if ( fogMaterial.fogVolume ) {
 
+			// offset the distance so we don't run into issues with particles on the same surface
+			// as other objects
 			float particleDist = intersectFogVolume( fogMaterial, sobol( 1 ) );
-			if ( particleDist + 1e-4 < surfaceHit.dist && ( particleDist + 1e-4 < lightRec.dist || ! lightHit ) ) {
+			if ( particleDist + RAY_OFFSET < surfaceHit.dist ) {
 
 				surfaceHit.side = 1.0;
 				surfaceHit.faceNormal = normalize( - ray.direction );
@@ -33,19 +37,13 @@ export const traceSceneGLSL = /* glsl */`
 
 		#endif
 
-		if ( lightHit && ( lightRec.dist < surfaceHit.dist || ! hit ) ) {
-
-			return LIGHT_HIT;
-
-		}
-
 		if ( hit ) {
 
-			return SURFACE_HIT;
+			result = SURFACE_HIT;
 
 		}
 
-		return NO_HIT;
+		return result;
 
 	}
 

package/src/materials/surface/AmbientOcclusionMaterial.js

@@ -1,6 +1,6 @@
 import { TangentSpaceNormalMap, Vector2 } from 'three';
 import { MaterialBase } from '../MaterialBase.js';
-import { MeshBVHUniformStruct, shaderStructs, shaderIntersectFunction } from 'three-mesh-bvh';
+import { MeshBVHUniformStruct, BVHShaderGLSL } from 'three-mesh-bvh';
 
 import { materialStructGLSL } from '../../shader/structs/materialStruct.glsl.js';
 import { shapeSamplingGLSL } from '../../shader/sampling/shapeSampling.glsl.js';
@@ -97,8 +97,9 @@ export class AmbientOcclusionMaterial extends MaterialBase {
 				#include <cube_uv_reflection_fragment>
 
 				// bvh
-				${ shaderStructs }
-				${ shaderIntersectFunction }
+				${ BVHShaderGLSL.common_functions }
+				${ BVHShaderGLSL.bvh_struct_definitions }
+				${ BVHShaderGLSL.bvh_ray_functions }
 
 				// uniform structs
 				${ materialStructGLSL }

package/src/shader/bsdf/bsdfSampling.glsl.js

@@ -80,7 +80,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 	${ iridescenceGLSL }
 
 	// diffuse
-	float diffuseEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float diffuseEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		// https://schuttejoe.github.io/post/disneybsdf/
 		float fl = schlickFresnel( wi.z, 0.0 );
@@ -111,7 +111,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 	}
 
 	// specular
-	float specularEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float specularEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		// if roughness is set to 0 then D === NaN which results in black pixels
 		float metalness = surf.metalness;
@@ -158,7 +158,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 	// transmission
 	/*
-	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		// See section 4.2 in https://www.cs.cornell.edu/~srm/publications/EGSR07-btdf.pdf
 
@@ -201,7 +201,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 	// TODO: This is just using a basic cosine-weighted specular distribution with an
 	// incorrect PDF value at the moment. Update it to correctly use a GGX distribution
-	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, out vec3 color ) {
+	float transmissionEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
 
 		color = surf.transmission * surf.color;
 
@@ -292,7 +292,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 	// bsdf
 	void getLobeWeights(
 		vec3 wo, vec3 wi, vec3 wh, vec3 clearcoatWo, SurfaceRecord surf,
-		out float diffuseWeight, out float specularWeight, out float transmissionWeight, out float clearcoatWeight
+		inout float diffuseWeight, inout float specularWeight, inout float transmissionWeight, inout float clearcoatWeight
 	) {
 
 		float metalness = surf.metalness;
@@ -316,7 +316,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 	float bsdfEval(
 		vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRecord surf,
-		float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight, out float specularPdf, out vec3 color
+		float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight, inout float specularPdf, inout vec3 color
 	) {
 
 		float metalness = surf.metalness;
@@ -379,7 +379,7 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 	}
 
-	float bsdfResult( vec3 worldWo, vec3 worldWi, SurfaceRecord surf, out vec3 color ) {
+	float bsdfResult( vec3 worldWo, vec3 worldWi, SurfaceRecord surf, inout vec3 color ) {
 
 		if ( surf.volumeParticle ) {
 

package/src/shader/common/bvhAnyHit.glsl.js

@@ -1,10 +1,10 @@
 export const bvhAnyHitGLSL = /* glsl */`
 
 	bool bvhIntersectAnyHit(
-		BVH bvh, vec3 rayOrigin, vec3 rayDirection,
+		vec3 rayOrigin, vec3 rayDirection,
 
 		// output variables
-		out float side, out float dist
+		inout float side, inout float dist
 	) {
 
 		uvec4 faceIndices;

package/src/shader/common/intersectShapes.glsl.js

@@ -3,7 +3,7 @@ export const intersectShapesGLSL = /* glsl */`
 	// Finds the point where the ray intersects the plane defined by u and v and checks if this point
 	// falls in the bounds of the rectangle on that same plane.
 	// Plane intersection: https://lousodrome.net/blog/light/2020/07/03/intersection-of-a-ray-and-a-plane/
-	bool intersectsRectangle( vec3 center, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, out float dist ) {
+	bool intersectsRectangle( vec3 center, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, inout float dist ) {
 
 		float t = dot( center - rayOrigin, normal ) / dot( rayDirection, normal );
 
@@ -34,7 +34,7 @@ export const intersectShapesGLSL = /* glsl */`
 
 	// Finds the point where the ray intersects the plane defined by u and v and checks if this point
 	// falls in the bounds of the circle on that same plane. See above URL for a description of the plane intersection algorithm.
-	bool intersectsCircle( vec3 position, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, out float dist ) {
+	bool intersectsCircle( vec3 position, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, inout float dist ) {
 
 		float t = dot( position - rayOrigin, normal ) / dot( rayDirection, normal );
 

package/src/shader/rand/sobol.glsl.js

@@ -214,9 +214,9 @@ export const sobolSamplingGLSL = /* glsl */`
 
 	// Seeds
 	uniform sampler2D sobolTexture;
-	uint sobolPixelIndex;
-	uint sobolPathIndex;
-	uint sobolBounceIndex;
+	uint sobolPixelIndex = 0u;
+	uint sobolPathIndex = 0u;
+	uint sobolBounceIndex = 0u;
 
 	uint sobolGetSeed( uint bounce, uint effect ) {