three-gpu-pathtracer 0.0.6 → 0.0.7

package/src/materials/PhysicalPathTracingMaterial.js

@@ -52,6 +52,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				normalAttribute: { value: new FloatVertexAttributeTexture() },
 				tangentAttribute: { value: new FloatVertexAttributeTexture() },
 				uvAttribute: { value: new FloatVertexAttributeTexture() },
+				colorAttribute: { value: new FloatVertexAttributeTexture() },
 				materialIndexAttribute: { value: new UIntVertexAttributeTexture() },
 				materials: { value: new MaterialsTexture() },
 				textures: { value: new RenderTarget2DArray().texture },
@@ -130,6 +131,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				uniform sampler2D normalAttribute;
 				uniform sampler2D tangentAttribute;
 				uniform sampler2D uvAttribute;
+				uniform sampler2D colorAttribute;
 				uniform usampler2D materialIndexAttribute;
 				uniform BVH bvh;
 				uniform float environmentIntensity;
@@ -147,6 +149,18 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				uniform sampler2DArray textures;
 				varying vec2 vUv;
 
+				float applyFilteredGlossy( float roughness, float accumulatedRoughness ) {
+
+					return clamp(
+						max(
+							roughness,
+							accumulatedRoughness * filterGlossyFactor * 5.0 ),
+						0.0,
+						1.0
+					);
+
+				}
+
 				vec3 sampleBackground( vec3 direction ) {
 
 					#if FEATURE_GRADIENT_BG
@@ -188,6 +202,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 							// TODO: should we account for emissive surfaces here?
 
 							vec2 uv = textureSampleBarycoord( uvAttribute, barycoord, faceIndices.xyz ).xy;
+							vec4 vertexColor = textureSampleBarycoord( colorAttribute, barycoord, faceIndices.xyz );
 							uint materialIndex = uTexelFetch1D( materialIndexAttribute, faceIndices.x ).r;
 							Material material = readMaterialInfo( materials, materialIndex );
 
@@ -215,8 +230,14 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 							}
 
+							if ( material.vertexColors ) {
+
+								albedo *= vertexColor;
+
+							}
+
 							// alphaMap
-							if ( material.alphaMap != -1 ) {
+							if ( material.alphaMap != - 1 ) {
 
 								albedo.a *= texture2D( textures, vec3( uv, material.alphaMap ) ).x;
 
@@ -252,7 +273,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 									|| useAlphaTest && albedo.a < alphaTest
 
 									// opacity
-									|| ! useAlphaTest && albedo.a < rand()
+									|| material.transparent && ! useAlphaTest && albedo.a < rand()
 								)
 							) {
 
@@ -260,11 +281,16 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 							}
 
-							// only attenuate on the way in
-							if ( isBelowSurface ) {
+							if ( side == 1.0 && isBelowSurface ) {
 
+								// 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 );
+
 							}
 
 						} else {
@@ -329,7 +355,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 					#else
 
-						// get [-1, 1] normalized device coordinates
+						// get [- 1, 1] normalized device coordinates
 						vec2 ndc = 2.0 * jitteredUv - vec2( 1.0 );
 
 						rayOrigin = ndcToRayOrigin( ndc );
@@ -338,7 +364,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 							// Orthographic projection
 
-							rayDirection = ( cameraWorldMatrix * vec4( 0.0, 0.0, -1.0, 0.0 ) ).xyz;
+							rayDirection = ( cameraWorldMatrix * vec4( 0.0, 0.0, - 1.0, 0.0 ) ).xyz;
 							rayDirection = normalize( rayDirection );
 
 						#else
@@ -512,7 +538,10 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 						}
 
+						// uv coord for textures
 						vec2 uv = textureSampleBarycoord( uvAttribute, barycoord, faceIndices.xyz ).xy;
+						vec4 vertexColor = textureSampleBarycoord( colorAttribute, barycoord, faceIndices.xyz );
+
 						// albedo
 						vec4 albedo = vec4( material.color, material.opacity );
 						if ( material.map != - 1 ) {
@@ -521,8 +550,14 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 							albedo *= texture2D( textures, vec3( uvPrime.xy, material.map ) );
 						}
 
+						if ( material.vertexColors ) {
+
+							albedo *= vertexColor;
+
+						}
+
 						// alphaMap
-						if ( material.alphaMap != -1 ) {
+						if ( material.alphaMap != - 1 ) {
 
 							albedo.a *= texture2D( textures, vec3( uv, material.alphaMap ) ).x;
 
@@ -536,16 +571,15 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 						// and we're rendering the other then we skip it. Do the opposite on subsequent bounces to get incoming light.
 						float alphaTest = material.alphaTest;
 						bool useAlphaTest = alphaTest != 0.0;
-						bool isFirstHit = i == 0;
 						if (
 							// material sidedness
-							material.side != 0.0 && ( side != material.side ) == isFirstHit
+							material.side != 0.0 && side != material.side
 
 							// alpha test
 							|| useAlphaTest && albedo.a < alphaTest
 
 							// opacity
-							|| ! useAlphaTest && albedo.a < rand()
+							|| material.transparent && ! useAlphaTest && albedo.a < rand()
 						) {
 
 							vec3 point = rayOrigin + rayDirection * dist;
@@ -745,27 +779,34 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 						surfaceRec.emission = emission;
 						surfaceRec.metalness = metalness;
 						surfaceRec.color = albedo.rgb;
-						surfaceRec.roughness = roughness;
 						surfaceRec.clearcoat = clearcoat;
-						surfaceRec.clearcoatRoughness = clearcoatRoughness;
 						surfaceRec.sheenColor = sheenColor;
-						surfaceRec.sheenRoughness = sheenRoughness;
 						surfaceRec.iridescence = iridescence;
 						surfaceRec.iridescenceIor = material.iridescenceIor;
 						surfaceRec.iridescenceThickness = iridescenceThickness;
 						surfaceRec.specularColor = specularColor;
 						surfaceRec.specularIntensity = specularIntensity;
+						surfaceRec.attenuationColor = material.attenuationColor;
+						surfaceRec.attenuationDistance = material.attenuationDistance;
+
+						// apply perceptual roughness factor from gltf
+						// https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#microfacet-surfaces
+						surfaceRec.roughness = roughness * roughness;
+						surfaceRec.clearcoatRoughness = clearcoatRoughness * clearcoatRoughness;
+						surfaceRec.sheenRoughness = sheenRoughness * sheenRoughness;
 
 						// frontFace is used to determine transmissive properties and PDF. If no transmission is used
 						// then we can just always assume this is a front face.
 						surfaceRec.frontFace = side == 1.0 || transmission == 0.0;
+						surfaceRec.iorRatio = material.thinFilm || surfaceRec.frontFace ? 1.0 / material.ior : material.ior;
+						surfaceRec.thinFilm = material.thinFilm;
 
 						// Compute the filtered roughness value to use during specular reflection computations.
 						// The accumulated roughness value is scaled by a user setting and a "magic value" of 5.0.
 						// If we're exiting something transmissive then scale the factor down significantly so we can retain
 						// sharp internal reflections
-						surfaceRec.filteredRoughness = clamp( max( surfaceRec.roughness, accumulatedRoughness * filterGlossyFactor * 5.0 ), 0.0, 1.0 );
-						surfaceRec.filteredClearcoatRoughness = clamp( max( surfaceRec.clearcoatRoughness, accumulatedClearcoatRoughness * filterGlossyFactor * 5.0 ), 0.0, 1.0 );
+						surfaceRec.filteredRoughness = applyFilteredGlossy( surfaceRec.roughness, accumulatedRoughness );
+						surfaceRec.filteredClearcoatRoughness = applyFilteredGlossy( surfaceRec.clearcoatRoughness, accumulatedClearcoatRoughness );
 
 						mat3 normalBasis = getBasisFromNormal( surfaceRec.normal );
 						mat3 invBasis = inverse( normalBasis );
@@ -898,6 +939,13 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 						throughputColor *= sampleRec.color / sampleRec.pdf;
 
+						// attenuate the throughput color by the medium color
+						if ( side == - 1.0 ) {
+
+							throughputColor *= transmissionAttenuation( dist, surfaceRec.attenuationColor, surfaceRec.attenuationDistance );
+
+						}
+
 						// discard the sample if there are any NaNs
 						if ( any( isnan( throughputColor ) ) || any( isinf( throughputColor ) ) ) {
 

package/src/shader/shaderGGXFunctions.js

@@ -40,7 +40,7 @@ vec3 ggxDirection( vec3 incidentDir, float roughnessX, float roughnessY, float r
 
 // Below are PDF and related functions for use in a Monte Carlo path tracer
 // as specified in Appendix B of the following paper
-// See equation (2) from reference [2]
+// See equation (34) from reference [0]
 float ggxLamda( float theta, float roughness ) {
 
 	float tanTheta = tan( theta );
@@ -52,7 +52,7 @@ float ggxLamda( float theta, float roughness ) {
 
 }
 
-// See equation (2) from reference [2]
+// See equation (34) from reference [0]
 float ggxShadowMaskG1( float theta, float roughness ) {
 
 	return 1.0 / ( 1.0 + ggxLamda( theta, roughness ) );
@@ -68,9 +68,9 @@ float ggxShadowMaskG2( vec3 wi, vec3 wo, float roughness ) {
 
 }
 
+// See equation (33) from reference [0]
 float ggxDistribution( vec3 halfVector, float roughness ) {
 
-	// See equation (33) from reference [0]
 	float a2 = roughness * roughness;
 	a2 = max( EPSILON, a2 );
 	float cosTheta = halfVector.z;
@@ -85,14 +85,6 @@ float ggxDistribution( vec3 halfVector, float roughness ) {
 	float denom = PI * cosTheta4 * pow( a2 + tanTheta2, 2.0 );
 	return ( a2 / denom );
 
-	// See equation (1) from reference [2]
-	// const { x, y, z } = halfVector;
-	// const a2 = roughness * roughness;
-	// const mult = x * x / a2 + y * y / a2 + z * z;
-	// const mult2 = mult * mult;
-
-	// return 1.0 / Math.PI * a2 * mult2;
-
 }
 
 // See equation (3) from reference [2]

package/src/shader/shaderMaterialSampling.js

@@ -14,7 +14,9 @@ struct SurfaceRec {
 	vec3 color;
 	vec3 emission;
 	float transmission;
+	bool thinFilm;
 	float ior;
+	float iorRatio;
 	float clearcoat;
 	float clearcoatRoughness;
 	float filteredClearcoatRoughness;
@@ -25,6 +27,8 @@ struct SurfaceRec {
 	float iridescenceThickness;
 	vec3 specularColor;
 	float specularIntensity;
+	vec3 attenuationColor;
+	float attenuationDistance;
 };
 
 struct SampleRec {
@@ -63,9 +67,8 @@ vec3 diffuseColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 	// TODO: scale by 1 - F here
 	// note on division by PI
 	// https://seblagarde.wordpress.com/2012/01/08/pi-or-not-to-pi-in-game-lighting-equation/
-	float metalFactor = ( 1.0 - surf.metalness ) * wi.z / ( PI * PI );
-	float transmissionFactor = 1.0 - surf.transmission;
-	return surf.color * metalFactor * transmissionFactor;
+	float metalFactor = ( 1.0 - surf.metalness );
+	return surf.color * metalFactor * wi.z / PI;
 
 }
 
@@ -105,15 +108,15 @@ vec3 specularColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 
 	// if roughness is set to 0 then D === NaN which results in black pixels
 	float metalness = surf.metalness;
-	float ior = surf.ior;
-	bool frontFace = surf.frontFace;
 	float filteredRoughness = surf.filteredRoughness;
 
 	vec3 halfVector = getHalfVector( wo, wi );
-	float iorRatio = frontFace ? 1.0 / ior : ior;
+	float iorRatio = surf.iorRatio;
 	float G = ggxShadowMaskG2( wi, wo, filteredRoughness );
 	float D = ggxDistribution( halfVector, filteredRoughness );
-	vec3 F = vec3( schlickFresnelFromIor( dot( wi, halfVector ), iorRatio ) ) * surf.specularColor * surf.specularIntensity;
+
+	float f0 = iorRatioToF0( iorRatio );
+	vec3 F = vec3( schlickFresnel( dot( wi, halfVector ), f0 ) );
 
 	float cosTheta = min( wo.z, 1.0 );
 	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
@@ -124,11 +127,12 @@ vec3 specularColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 
 	}
 
-	float f0 = pow( ( iorRatio - 1.0 ) / ( iorRatio + 1.0 ), 2.0 );
 	vec3 iridescenceFresnel = evalIridescence( 1.0, surf.iridescenceIor, dot( wi, halfVector ), surf.iridescenceThickness, vec3( f0 ) );
-	F = mix( F, iridescenceFresnel, surf.iridescence );
+	vec3 metalF = mix( F, iridescenceFresnel, surf.iridescence );
+	vec3 dialectricF = F * surf.specularIntensity;
+	F = mix( dialectricF, metalF, metalness );
 
-	vec3 color = mix( vec3( 1.0 ), surf.color, metalness );
+	vec3 color = mix( surf.specularColor, surf.color, metalness );
 	color = mix( color, vec3( 1.0 ), F );
 	color *= G * D / ( 4.0 * abs( wi.z * wo.z ) );
 	color *= mix( F, vec3( 1.0 ), metalness );
@@ -194,14 +198,11 @@ function transmissionColor( wo, wi, material, hit, colorTarget ) {
 // incorrect PDF value at the moment. Update it to correctly use a GGX distribution
 float transmissionPDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
 
-	float ior = surf.ior;
-	bool frontFace = surf.frontFace;
-
-	float ratio = frontFace ? 1.0 / ior : ior;
+	float iorRatio = surf.iorRatio;
 	float cosTheta = min( wo.z, 1.0 );
 	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
-	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
-	bool cannotRefract = ratio * sinTheta > 1.0;
+	float reflectance = schlickFresnelFromIor( cosTheta, iorRatio );
+	bool cannotRefract = iorRatio * sinTheta > 1.0;
 	if ( cannotRefract ) {
 
 		return 0.0;
@@ -215,26 +216,25 @@ float transmissionPDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
 vec3 transmissionDirection( vec3 wo, SurfaceRec surf ) {
 
 	float roughness = surf.roughness;
-	float ior = surf.ior;
-	bool frontFace = surf.frontFace;
-	float ratio = frontFace ? 1.0 / ior : ior;
+	float iorRatio = surf.iorRatio;
+
+	vec3 halfVector = normalize( vec3( 0.0, 0.0, 1.0 ) + randDirection() * roughness );
+	vec3 lightDirection = refract( normalize( - wo ), halfVector, iorRatio );
+
+	if ( surf.thinFilm ) {
 
-	vec3 lightDirection = refract( - wo, vec3( 0.0, 0.0, 1.0 ), ratio );
-	lightDirection += randDirection() * roughness;
+		lightDirection = - refract( normalize( - lightDirection ), - vec3( 0.0, 0.0, 1.0 ), 1.0 / iorRatio );
+
+	}
 	return normalize( lightDirection );
 
 }
 
 vec3 transmissionColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 
-	float metalness = surf.metalness;
-	float transmission = surf.transmission;
-
-	vec3 color = surf.color;
-	color *= ( 1.0 - metalness );
-	color *= transmission;
-
-	return color;
+	// only attenuate the color if it's on the way in
+	vec3 col = surf.thinFilm || surf.frontFace ? surf.color : vec3( 1.0 );
+	return surf.transmission * col;
 
 }
 
@@ -316,16 +316,16 @@ vec3 sheenColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 // bsdf
 void getLobeWeights( vec3 wo, vec3 clearcoatWo, SurfaceRec surf, out float diffuseWeight, out float specularWeight, out float transmissionWeight, out float clearcoatWeight ) {
 
-	float ior = surf.ior;
 	float metalness = surf.metalness;
 	float transmission = surf.transmission;
-	bool frontFace = surf.frontFace;
 
-	float ratio = frontFace ? 1.0 / ior : ior;
+	// TODO: we should compute a half vector ahead of time and pass it into the sampling functions
+	// so all functions will use the same half vector
+	float iorRatio = surf.iorRatio;
 	float cosTheta = min( wo.z, 1.0 );
 	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
-	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
-	bool cannotRefract = ratio * sinTheta > 1.0;
+	float reflectance = schlickFresnelFromIor( cosTheta, iorRatio );
+	bool cannotRefract = iorRatio * sinTheta > 1.0;
 	if ( cannotRefract ) {
 
 		reflectance = 1.0;
@@ -341,27 +341,23 @@ void getLobeWeights( vec3 wo, vec3 clearcoatWo, SurfaceRec surf, out float diffu
 	transmissionWeight = transmission * ( 1.0 - transSpecularProb ) * ( 1.0 - clearcoatWeight );
 
 	float totalWeight = diffuseWeight + specularWeight + transmissionWeight + clearcoatWeight;
-	float invTotalWeight = 1.0 / totalWeight;
-
-	diffuseWeight *= invTotalWeight;
-	specularWeight *= invTotalWeight;
-	transmissionWeight *= invTotalWeight;
-	clearcoatWeight *= invTotalWeight;
+	diffuseWeight /= totalWeight;
+	specularWeight /= totalWeight;
+	transmissionWeight /= totalWeight;
+	clearcoatWeight /= totalWeight;
 
 }
 
 float bsdfPdf( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec surf, out float specularPdf, float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight ) {
 
-	float ior = surf.ior;
 	float metalness = surf.metalness;
 	float transmission = surf.transmission;
-	bool frontFace = surf.frontFace;
 
-	float ratio = frontFace ? 1.0 / ior : ior;
+	float iorRatio = surf.iorRatio;
 	float cosTheta = min( wo.z, 1.0 );
 	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
-	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
-	bool cannotRefract = ratio * sinTheta > 1.0;
+	float reflectance = schlickFresnelFromIor( cosTheta, iorRatio );
+	bool cannotRefract = iorRatio * sinTheta > 1.0;
 	if ( cannotRefract ) {
 
 		reflectance = 1.0;
@@ -512,22 +508,22 @@ SampleRec bsdfSample( vec3 wo, vec3 clearcoatWo, mat3 normalBasis, mat3 invBasis
 	vec3 clearcoatWi;
 
 	float r = rand();
-	if ( r <= cdf[0] ) {
+	if ( r <= cdf[0] ) { // diffuse
 
 		wi = diffuseDirection( wo, surf );
 		clearcoatWi = normalize( clearcoatInvBasis * normalize( normalBasis * wi ) );
 
-	} else if ( r <= cdf[1] ) {
+	} else if ( r <= cdf[1] ) { // specular
 
 		wi = specularDirection( wo, surf );
 		clearcoatWi = normalize( clearcoatInvBasis * normalize( normalBasis * wi ) );
 
-	} else if ( r <= cdf[2] ) {
+	} else if ( r <= cdf[2] ) { // transmission / refraction
 
 		wi = transmissionDirection( wo, surf );
 		clearcoatWi = normalize( clearcoatInvBasis * normalize( normalBasis * wi ) );
 
-	} else if ( r <= cdf[3] ) {
+	} else if ( r <= cdf[3] ) { // clearcoat
 
 		clearcoatWi = clearcoatDirection( clearcoatWo, surf );
 		wi = normalize( invBasis * normalize( clearcoatNormalBasis * clearcoatWi ) );

package/src/shader/shaderStructs.js

@@ -62,6 +62,10 @@ export const shaderMaterialStructs = /* glsl */ `
 
 		float specularIntensity;
 		int specularIntensityMap;
+		bool thinFilm;
+
+		vec3 attenuationColor;
+		float attenuationDistance;
 
 		int alphaMap;
 
@@ -77,6 +81,9 @@ export const shaderMaterialStructs = /* glsl */ `
 		float sheenRoughness;
 		int sheenRoughnessMap;
 
+		bool vertexColors;
+		bool transparent;
+
 		mat3 mapTransform;
 		mat3 metalnessMapTransform;
 		mat3 roughnessMapTransform;
@@ -112,7 +119,7 @@ export const shaderMaterialStructs = /* glsl */ `
 
 	Material readMaterialInfo( sampler2D tex, uint index ) {
 
-		uint i = index * 44u;
+		uint i = index * 45u;
 
 		vec4 s0 = texelFetch1D( tex, i + 0u );
 		vec4 s1 = texelFetch1D( tex, i + 1u );
@@ -128,6 +135,7 @@ export const shaderMaterialStructs = /* glsl */ `
 		vec4 s11 = texelFetch1D( tex, i + 11u );
 		vec4 s12 = texelFetch1D( tex, i + 12u );
 		vec4 s13 = texelFetch1D( tex, i + 13u );
+		vec4 s14 = texelFetch1D( tex, i + 14u );
 
 		Material m;
 		m.color = s0.rgb;
@@ -173,17 +181,23 @@ export const shaderMaterialStructs = /* glsl */ `
 
 		m.specularIntensity = s11.r;
 		m.specularIntensityMap = int( round( s11.g ) );
+		m.thinFilm = bool( s11.b );
+
+		m.attenuationColor = s12.rgb;
+		m.attenuationDistance = s12.a;
 
-		m.alphaMap = int( round( s12.r ) );
+		m.alphaMap = int( round( s13.r ) );
 
-		m.opacity = s12.g;
-		m.alphaTest = s12.b;
-		m.side = s12.a;
+		m.opacity = s13.g;
+		m.alphaTest = s13.b;
+		m.side = s13.a;
 
-		m.matte = bool( s13.r );
-		m.castShadow = ! bool( s13.g );
+		m.matte = bool( s14.r );
+		m.castShadow = ! bool( s14.g );
+		m.vertexColors = bool( s14.b );
+		m.transparent = bool( s14.a );
 
-		uint firstTextureTransformIdx = i + 14u;
+		uint firstTextureTransformIdx = i + 15u;
 
 		m.mapTransform = m.map == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx );
 		m.metalnessMapTransform = m.metalnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 2u );

package/src/shader/shaderUtils.js

@@ -1,5 +1,13 @@
 export const shaderUtils = /* glsl */`
 
+	// https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_volume/README.md#attenuation
+	vec3 transmissionAttenuation( float dist, vec3 attColor, float attDist ) {
+
+		vec3 ot = - log( attColor ) / attDist;
+		return exp( - ot * dist );
+
+	}
+
 	// https://google.github.io/filament/Filament.md.html#materialsystem/diffusebrdf
 	float schlickFresnel( float cosine, float f0 ) {
 
@@ -14,10 +22,16 @@ export const shaderUtils = /* glsl */`
 	}
 
 	// https://raytracing.github.io/books/RayTracingInOneWeekend.html#dielectrics/schlickapproximation
+	float iorRatioToF0( float iorRatio ) {
+
+		return pow( ( 1.0 - iorRatio ) / ( 1.0 + iorRatio ), 2.0 );
+
+	}
+
 	float schlickFresnelFromIor( float cosine, float iorRatio ) {
 
 		// Schlick approximation
-		float r_0 = pow( ( 1.0 - iorRatio ) / ( 1.0 + iorRatio ), 2.0 );
+		float r_0 = iorRatioToF0( iorRatio );
 		return schlickFresnel( cosine, r_0 );
 
 	}
@@ -261,7 +275,7 @@ export const shaderUtils = /* glsl */`
 
 	}
 
-	vec2 square( vec2 t) {
+	vec2 square( vec2 t ) {
 
 		return t * t;