three-gpu-pathtracer 0.0.20 → 0.0.21

package/src/materials/fullscreen/ClampedInterpolationMaterial.js

@@ -0,0 +1,112 @@
+import { ShaderMaterial } from 'three';
+
+// Material that tone maps a texture before performing interpolation to prevent
+// unexpected high values during texture stretching interpolation.
+// Emulates browser image stretching
+export class ClampedInterpolationMaterial extends ShaderMaterial {
+
+	get map() {
+
+		return this.uniforms.map.value;
+
+	}
+
+	set map( v ) {
+
+		this.uniforms.map.value = v;
+
+	}
+
+	get opacity() {
+
+		return this.uniforms.opacity.value;
+
+	}
+
+	set opacity( v ) {
+
+		if ( this.uniforms ) {
+
+			this.uniforms.opacity.value = v;
+
+		}
+
+	}
+
+	constructor( params ) {
+
+		super( {
+			uniforms: {
+
+				map: { value: null },
+				opacity: { value: 1 },
+
+			},
+
+			vertexShader: /* glsl */`
+				varying vec2 vUv;
+				void main() {
+
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+				}
+			`,
+
+			fragmentShader: /* glsl */`
+				uniform sampler2D map;
+				uniform float opacity;
+				varying vec2 vUv;
+
+				vec4 clampedTexelFatch( sampler2D map, ivec2 px, int lod ) {
+
+					vec4 res = texelFetch( map, ivec2( px.x, px.y ), 0 );
+
+					#if defined( TONE_MAPPING )
+
+					res.xyz = toneMapping( res.xyz );
+
+					#endif
+
+			  		return linearToOutputTexel( res );
+
+				}
+
+				void main() {
+
+					vec2 size = vec2( textureSize( map, 0 ) );
+					vec2 pxUv = vUv * size;
+					vec2 pxCurr = floor( pxUv );
+					vec2 pxFrac = fract( pxUv ) - 0.5;
+					vec2 pxOffset;
+					pxOffset.x = pxFrac.x > 0.0 ? 1.0 : - 1.0;
+					pxOffset.y = pxFrac.y > 0.0 ? 1.0 : - 1.0;
+
+					vec2 pxNext = clamp( pxOffset + pxCurr, vec2( 0.0 ), size - 1.0 );
+					vec2 alpha = abs( pxFrac );
+
+					vec4 p1 = mix(
+						clampedTexelFatch( map, ivec2( pxCurr.x, pxCurr.y ), 0 ),
+						clampedTexelFatch( map, ivec2( pxNext.x, pxCurr.y ), 0 ),
+						alpha.x
+					);
+
+					vec4 p2 = mix(
+						clampedTexelFatch( map, ivec2( pxCurr.x, pxNext.y ), 0 ),
+						clampedTexelFatch( map, ivec2( pxNext.x, pxNext.y ), 0 ),
+						alpha.x
+					);
+
+					gl_FragColor = mix( p1, p2, alpha.y );
+					gl_FragColor.a *= opacity;
+					#include <premultiplied_alpha_fragment>
+
+				}
+			`
+		} );
+
+		this.setValues( params );
+
+	}
+
+}

package/src/materials/fullscreen/DenoiseMaterial.js

@@ -28,6 +28,7 @@ export class DenoiseMaterial extends MaterialBase {
 				kSigma: { value: 1.0 },
 
 				map: { value: null },
+				opacity: { value: 1 },
 
 			},
 
@@ -65,6 +66,7 @@ export class DenoiseMaterial extends MaterialBase {
 				uniform float sigma;
 				uniform float threshold;
 				uniform float kSigma;
+				uniform float opacity;
 
 				varying vec2 vUv;
 
@@ -129,6 +131,8 @@ export class DenoiseMaterial extends MaterialBase {
 					#include <colorspace_fragment>
 					#include <premultiplied_alpha_fragment>
 
+					gl_FragColor.a *= opacity;
+
 				}
 
 			`

package/src/materials/pathtracing/PhysicalPathTracingMaterial.js

@@ -1,4 +1,4 @@
-import { Matrix4, Vector2 } from 'three';
+import { ClampToEdgeWrapping, HalfFloatType, Matrix4, Vector2 } from 'three';
 import { MaterialBase } from '../MaterialBase.js';
 import {
 	MeshBVHUniformStruct, UIntVertexAttributeTexture,
@@ -9,49 +9,23 @@ import {
 import { PhysicalCameraUniform } from '../../uniforms/PhysicalCameraUniform.js';
 import { EquirectHdrInfoUniform } from '../../uniforms/EquirectHdrInfoUniform.js';
 import { LightsInfoUniformStruct } from '../../uniforms/LightsInfoUniformStruct.js';
-import { IESProfilesTexture } from '../../uniforms/IESProfilesTexture.js';
 import { AttributesTextureArray } from '../../uniforms/AttributesTextureArray.js';
 import { MaterialsTexture } from '../../uniforms/MaterialsTexture.js';
 import { RenderTarget2DArray } from '../../uniforms/RenderTarget2DArray.js';
-
-// glsl
-import { cameraStructGLSL } from '../../shader/structs/cameraStruct.glsl.js';
-import { equirectStructGLSL } from '../../shader/structs/equirectStruct.glsl.js';
-import { lightsStructGLSL } from '../../shader/structs/lightsStruct.glsl.js';
-import { materialStructGLSL } from '../../shader/structs/materialStruct.glsl.js';
-import { fogMaterialBvhGLSL } from '../../shader/structs/fogMaterialBvh.glsl.js';
-
-// material sampling
-import { bsdfSamplingGLSL } from '../../shader/bsdf/bsdfSampling.glsl.js';
-import { fogGLSL } from '../../shader/bsdf/fog.glsl.js';
-
-// sampling
-import { equirectSamplingGLSL } from '../../shader/sampling/equirectSampling.glsl.js';
-import { lightSamplingGLSL } from '../../shader/sampling/lightSampling.glsl.js';
-import { shapeSamplingGLSL } from '../../shader/sampling/shapeSampling.glsl.js';
-
-// common glsl
-import { intersectShapesGLSL } from '../../shader/common/intersectShapes.glsl.js';
-import { mathGLSL } from '../../shader/common/math.glsl.js';
-import { utilsGLSL } from '../../shader/common/utils.glsl.js';
-import { fresnelGLSL } from '../../shader/common/fresnel.glsl.js';
-import { arraySamplerTexelFetchGLSL } from '../../shader/common/arraySamplerTexelFetch.glsl.js';
-
-// random glsl
-import { pcgGLSL } from '../../shader/rand/pcg.glsl.js';
-import { sobolCommonGLSL, sobolSamplingGLSL } from '../../shader/rand/sobol.glsl.js';
-
-// path tracer utils
-import { renderStructsGLSL } from './glsl/renderStructs.glsl.js';
-import { cameraUtilsGLSL } from './glsl/cameraUtils.glsl.js';
-import { attenuateHitGLSL } from './glsl/attenuateHit.glsl.js';
-import { traceSceneGLSL } from './glsl/traceScene.glsl.js';
-import { getSurfaceRecordGLSL } from './glsl/getSurfaceRecord.glsl.js';
-import { directLightContributionGLSL } from './glsl/directLightContribution.glsl.js';
-import { stratifiedTextureGLSL } from '../../shader/rand/stratifiedTexture.glsl.js';
 import { StratifiedSamplesTexture } from '../../uniforms/StratifiedSamplesTexture.js';
 import { BlueNoiseTexture } from '../../textures/BlueNoiseTexture.js';
 
+// general glsl
+import * as StructsGLSL from '../../shader/structs/index.js';
+import * as SamplingGLSL from '../../shader/sampling/index.js';
+import * as CommonGLSL from '../../shader/common/index.js';
+import * as RandomGLSL from '../../shader/rand/index.js';
+import * as BSDFGLSL from '../../shader/bsdf/index.js';
+import * as PTBVHGLSL from '../../shader/bvh/index.js';
+
+// path tracer glsl
+import * as RenderGLSL from './glsl/index.js';
+
 export class PhysicalPathTracingMaterial extends MaterialBase {
 
 	onBeforeRender() {
@@ -95,32 +69,46 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 			},
 
 			uniforms: {
-				resolution: { value: new Vector2() },
 
+				// path trace uniforms
+				resolution: { value: new Vector2() },
+				opacity: { value: 1 },
 				bounces: { value: 10 },
 				transmissiveBounces: { value: 10 },
+				filterGlossyFactor: { value: 0 },
+
+				// camera uniforms
 				physicalCamera: { value: new PhysicalCameraUniform() },
+				cameraWorldMatrix: { value: new Matrix4() },
+				invProjectionMatrix: { value: new Matrix4() },
 
+				// scene uniforms
 				bvh: { value: new MeshBVHUniformStruct() },
 				attributesArray: { value: new AttributesTextureArray() },
 				materialIndexAttribute: { value: new UIntVertexAttributeTexture() },
 				materials: { value: new MaterialsTexture() },
 				textures: { value: new RenderTarget2DArray().texture },
+
+				// light uniforms
 				lights: { value: new LightsInfoUniformStruct() },
-				iesProfiles: { value: new IESProfilesTexture().texture },
-				cameraWorldMatrix: { value: new Matrix4() },
-				invProjectionMatrix: { value: new Matrix4() },
-				backgroundBlur: { value: 0.0 },
+				iesProfiles: { value: new RenderTarget2DArray( 360, 180, {
+					type: HalfFloatType,
+					wrapS: ClampToEdgeWrapping,
+					wrapT: ClampToEdgeWrapping,
+				} ).texture },
 				environmentIntensity: { value: 1.0 },
 				environmentRotation: { value: new Matrix4() },
 				envMapInfo: { value: new EquirectHdrInfoUniform() },
+
+				// background uniforms
+				backgroundBlur: { value: 0.0 },
 				backgroundMap: { value: null },
+				backgroundAlpha: { value: 1.0 },
+				backgroundIntensity: { value: 1.0 },
+				backgroundRotation: { value: new Matrix4() },
 
+				// randomness uniforms
 				seed: { value: 0 },
-				opacity: { value: 1 },
-				filterGlossyFactor: { value: 0.0 },
-
-				backgroundAlpha: { value: 1.0 },
 				sobolTexture: { value: null },
 				stratifiedTexture: { value: new StratifiedSamplesTexture() },
 				stratifiedOffsetTexture: { value: new BlueNoiseTexture( 64, 1 ) },
@@ -157,21 +145,22 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				${ BVHShaderGLSL.bvh_ray_functions }
 
 				// uniform structs
-				${ cameraStructGLSL }
-				${ lightsStructGLSL }
-				${ equirectStructGLSL }
-				${ materialStructGLSL }
+				${ StructsGLSL.camera_struct }
+				${ StructsGLSL.lights_struct }
+				${ StructsGLSL.equirect_struct }
+				${ StructsGLSL.material_struct }
+				${ StructsGLSL.surface_record_struct }
 
 				// random
 				#if RANDOM_TYPE == 2 	// Stratified List
 
-					${ stratifiedTextureGLSL }
+					${ RandomGLSL.stratified_functions }
 
 				#elif RANDOM_TYPE == 1 	// Sobol
 
-					${ pcgGLSL }
-					${ sobolCommonGLSL }
-					${ sobolSamplingGLSL }
+					${ RandomGLSL.pcg_functions }
+					${ RandomGLSL.sobol_common }
+					${ RandomGLSL.sobol_functions }
 
 					#define rand(v) sobol(v)
 					#define rand2(v) sobol2(v)
@@ -180,7 +169,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 				#else 					// PCG
 
-					${ pcgGLSL }
+				${ RandomGLSL.pcg_functions }
 
 					// Using the sobol functions seems to break the the compiler on MacOS
 					// - specifically the "sobolReverseBits" function.
@@ -196,11 +185,11 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				#endif
 
 				// common
-				${ arraySamplerTexelFetchGLSL }
-				${ fresnelGLSL }
-				${ utilsGLSL }
-				${ mathGLSL }
-				${ intersectShapesGLSL }
+				${ CommonGLSL.texture_sample_functions }
+				${ CommonGLSL.fresnel_functions }
+				${ CommonGLSL.util_functions }
+				${ CommonGLSL.math_functions }
+				${ CommonGLSL.shape_intersection_functions }
 
 				// environment
 				uniform EquirectHdrInfo envMapInfo;
@@ -217,6 +206,8 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				#if FEATURE_BACKGROUND_MAP
 
 				uniform sampler2D backgroundMap;
+				uniform mat4 backgroundRotation;
+				uniform float backgroundIntensity;
 
 				#endif
 
@@ -254,12 +245,16 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 				float lightsDenom;
 
 				// sampling
-				${ fogMaterialBvhGLSL }
-				${ shapeSamplingGLSL }
-				${ bsdfSamplingGLSL }
-				${ equirectSamplingGLSL }
-				${ lightSamplingGLSL }
-				${ fogGLSL }
+				${ SamplingGLSL.shape_sampling_functions }
+				${ SamplingGLSL.equirect_functions }
+				${ SamplingGLSL.light_sampling_functions }
+
+				${ PTBVHGLSL.inside_fog_volume_function }
+				${ BSDFGLSL.ggx_functions }
+				${ BSDFGLSL.sheen_functions }
+				${ BSDFGLSL.iridescence_functions }
+				${ BSDFGLSL.fog_functions }
+				${ BSDFGLSL.bsdf_functions }
 
 				float applyFilteredGlossy( float roughness, float accumulatedRoughness ) {
 
@@ -275,26 +270,28 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 				vec3 sampleBackground( vec3 direction, vec2 uv ) {
 
-					vec3 sampleDir = normalize( direction + sampleHemisphere( direction, uv ) * 0.5 * backgroundBlur );
+					vec3 sampleDir = sampleHemisphere( direction, uv ) * 0.5 * backgroundBlur;
 
 					#if FEATURE_BACKGROUND_MAP
 
-					return sampleEquirectColor( backgroundMap, sampleDir );
+					sampleDir = normalize( mat3( backgroundRotation ) * direction + sampleDir );
+					return backgroundIntensity * sampleEquirectColor( backgroundMap, sampleDir );
 
 					#else
 
+					sampleDir = normalize( envRotation3x3 * direction + sampleDir );
 					return environmentIntensity * sampleEquirectColor( envMapInfo.map, sampleDir );
 
 					#endif
 
 				}
 
-				${ renderStructsGLSL }
-				${ cameraUtilsGLSL }
-				${ traceSceneGLSL }
-				${ attenuateHitGLSL }
-				${ directLightContributionGLSL }
-				${ getSurfaceRecordGLSL }
+				${ RenderGLSL.render_structs }
+				${ RenderGLSL.camera_util_functions }
+				${ RenderGLSL.trace_scene_function }
+				${ RenderGLSL.attenuate_hit_function }
+				${ RenderGLSL.direct_light_contribution_function }
+				${ RenderGLSL.get_surface_record_function }
 
 				void main() {
 
@@ -381,7 +378,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 							if ( state.firstRay || state.transmissiveRay ) {
 
-								gl_FragColor.rgb += sampleBackground( envRotation3x3 * ray.direction, rand2( 2 ) ) * state.throughputColor;
+								gl_FragColor.rgb += sampleBackground( ray.direction, rand2( 2 ) ) * state.throughputColor;
 								gl_FragColor.a = backgroundAlpha;
 
 							} else {

package/src/materials/pathtracing/glsl/{attenuateHit.glsl.js → attenuate_hit_function.glsl.js}

@@ -1,4 +1,4 @@
-export const attenuateHitGLSL = /* glsl */`
+export const attenuate_hit_function = /* glsl */`
 
 	// step through multiple surface hits and accumulate color attenuation based on transmissive surfaces
 	// returns true if a solid surface was hit

package/src/materials/pathtracing/glsl/{cameraUtils.glsl.js → camera_util_functions.glsl.js}

@@ -1,4 +1,4 @@
-export const cameraUtilsGLSL = /* glsl */`
+export const camera_util_functions = /* glsl */`
 
 	vec3 ndcToRayOrigin( vec2 coord ) {
 

package/src/materials/pathtracing/glsl/{directLightContribution.glsl.js → direct_light_contribution_function.glsl.js}

@@ -1,4 +1,4 @@
-export const directLightContributionGLSL = /*glsl*/`
+export const direct_light_contribution_function = /*glsl*/`
 
 	vec3 directLightContribution( vec3 worldWo, SurfaceRecord surf, RenderState state, vec3 rayOrigin ) {
 

package/src/materials/pathtracing/glsl/{getSurfaceRecord.glsl.js → get_surface_record_function.glsl.js}

@@ -1,5 +1,5 @@
 
-export const getSurfaceRecordGLSL = /* glsl */`
+export const get_surface_record_function = /* glsl */`
 
 	#define SKIP_SURFACE 0
 	#define HIT_SURFACE 1

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

@@ -0,0 +1,6 @@
+export * from './attenuate_hit_function.glsl.js';
+export * from './camera_util_functions.glsl.js';
+export * from './direct_light_contribution_function.glsl.js';
+export * from './get_surface_record_function.glsl.js';
+export * from './render_structs.glsl.js';
+export * from './trace_scene_function.glsl.js';

package/src/materials/pathtracing/glsl/{renderStructs.glsl.js → render_structs.glsl.js}

@@ -1,4 +1,4 @@
-export const renderStructsGLSL = /* glsl */`
+export const render_structs = /* glsl */`
 
 	struct Ray {
 

package/src/materials/pathtracing/glsl/{traceScene.glsl.js → trace_scene_function.glsl.js}

@@ -1,4 +1,4 @@
-export const traceSceneGLSL = /* glsl */`
+export const trace_scene_function = /* glsl */`
 
 	#define NO_HIT 0
 	#define SURFACE_HIT 1
@@ -9,9 +9,7 @@ export const traceSceneGLSL = /* glsl */`
 	// 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, Material fogMaterial, inout SurfaceHit surfaceHit
-
 	) {
 
 		int result = NO_HIT;

package/src/materials/surface/AmbientOcclusionMaterial.js

@@ -2,9 +2,9 @@ import { TangentSpaceNormalMap, Vector2 } from 'three';
 import { MaterialBase } from '../MaterialBase.js';
 import { MeshBVHUniformStruct, BVHShaderGLSL } from 'three-mesh-bvh';
 
-import { materialStructGLSL } from '../../shader/structs/materialStruct.glsl.js';
-import { shapeSamplingGLSL } from '../../shader/sampling/shapeSampling.glsl.js';
-import { pcgGLSL } from '../../shader/rand/pcg.glsl.js';
+import * as StructsGLSL from '../../shader/structs/index.js';
+import * as SamplingGLSL from '../../shader/sampling/index.js';
+import * as RandomGLSL from '../../shader/rand/index.js';
 
 export class AmbientOcclusionMaterial extends MaterialBase {
 
@@ -59,7 +59,7 @@ export class AmbientOcclusionMaterial extends MaterialBase {
 				varying vec3 vNorm;
 				varying vec3 vPos;
 
-				#if defined(USE_NORMALMAP) && defined(USE_TANGENT)
+				#if defined( USE_NORMALMAP ) && defined( USE_TANGENT )
 
 					varying vec2 vUv;
 					varying vec4 vTan;
@@ -102,13 +102,13 @@ export class AmbientOcclusionMaterial extends MaterialBase {
 				${ BVHShaderGLSL.bvh_ray_functions }
 
 				// uniform structs
-				${ materialStructGLSL }
+				${ StructsGLSL.material_struct }
 
 				// rand
-				${ pcgGLSL }
+				${ RandomGLSL.pcg_functions }
 
 				// common
-				${ shapeSamplingGLSL }
+				${ SamplingGLSL.shape_sampling_functions }
 
 				uniform BVH bvh;
 				uniform int seed;
@@ -167,7 +167,7 @@ export class AmbientOcclusionMaterial extends MaterialBase {
 
 						// sample the cosine weighted hemisphere and discard the sample if it's below
 						// the geometric surface
-						vec3 rayDirection = sampleHemisphere( normalize( normal ), rand4().xy );
+						vec3 rayDirection = sampleHemisphere( normalize( normal ), pcgRand4().xy );
 
 						// check if we hit the mesh and its within the specified radius
 						float side = 1.0;

package/src/objects/PhysicalSpotLight.js

@@ -6,7 +6,7 @@ export class PhysicalSpotLight extends SpotLight {
 
 		super( ...args );
 
-		this.iesTexture = null;
+		this.iesMap = null;
 		this.radius = 0;
 
 	}
@@ -15,7 +15,7 @@ export class PhysicalSpotLight extends SpotLight {
 
 		super.copy( source, recursive );
 
-		this.iesTexture = source.iesTexture;
+		this.iesMap = source.iesMap;
 		this.radius = source.radius;
 
 		return this;

package/src/shader/bsdf/{bsdfSampling.glsl.js → bsdf_functions.glsl.js}

@@ -1,7 +1,3 @@
-import { ggxGLSL } from './ggx.glsl.js';
-import { sheenGLSL } from './sheen.glsl.js';
-import { iridescenceGLSL } from './iridescence.glsl.js';
-
 /*
 wi     : incident vector or light vector (pointing toward the light)
 wo     : outgoing vector or view vector (pointing towards the camera)
@@ -13,71 +9,7 @@ f0     : Amount of light reflected when looking at a surface head on - "fresnel
 f90    : Amount of light reflected at grazing angles
 */
 
-export const bsdfSamplingGLSL = /* glsl */`
-
-	struct SurfaceRecord {
-
-		// surface type
-		bool volumeParticle;
-
-		// geometry
-		vec3 faceNormal;
-		bool frontFace;
-		vec3 normal;
-		mat3 normalBasis;
-		mat3 normalInvBasis;
-
-		// cached properties
-		float eta;
-		float f0;
-
-		// material
-		float roughness;
-		float filteredRoughness;
-		float metalness;
-		vec3 color;
-		vec3 emission;
-
-		// transmission
-		float ior;
-		float transmission;
-		bool thinFilm;
-		vec3 attenuationColor;
-		float attenuationDistance;
-
-		// clearcoat
-		vec3 clearcoatNormal;
-		mat3 clearcoatBasis;
-		mat3 clearcoatInvBasis;
-		float clearcoat;
-		float clearcoatRoughness;
-		float filteredClearcoatRoughness;
-
-		// sheen
-		float sheen;
-		vec3 sheenColor;
-		float sheenRoughness;
-
-		// iridescence
-		float iridescence;
-		float iridescenceIor;
-		float iridescenceThickness;
-
-		// specular
-		vec3 specularColor;
-		float specularIntensity;
-	};
-
-	struct ScatterRecord {
-		float specularPdf;
-		float pdf;
-		vec3 direction;
-		vec3 color;
-	};
-
-	${ ggxGLSL }
-	${ sheenGLSL }
-	${ iridescenceGLSL }
+export const bsdf_functions = /* glsl */`
 
 	// diffuse
 	float diffuseEval( vec3 wo, vec3 wi, vec3 wh, SurfaceRecord surf, inout vec3 color ) {
@@ -209,14 +141,29 @@ export const bsdfSamplingGLSL = /* glsl */`
 
 		// PDF
 		// float F = evaluateFresnelWeight( dot( wo, wh ), surf.eta, surf.f0 );
-		float F = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
-		if ( F >= 1.0 ) {
+		// float F = disneyFresnel( wo, wi, wh, surf.f0, surf.eta, surf.metalness );
+		// if ( F >= 1.0 ) {
+
+		// 	return 0.0;
+
+		// }
+
+		// return 1.0 / ( 1.0 - F );
+
+		// reverted to previous to transmission. The above was causing black pixels
+		float eta = surf.eta;
+		float f0 = surf.f0;
+		float cosTheta = min( wo.z, 1.0 );
+		float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+		float reflectance = schlickFresnel( cosTheta, f0 );
+		bool cannotRefract = eta * sinTheta > 1.0;
+		if ( cannotRefract ) {
 
 			return 0.0;
 
 		}
 
-		return 1.0 / ( 1.0 - F );
+		return 1.0 / ( 1.0 - reflectance );
 
 	}
 

package/src/shader/bsdf/{fog.glsl.js → fog_functions.glsl.js}

@@ -1,4 +1,4 @@
-export const fogGLSL = /* glsl */`
+export const fog_functions = /* glsl */`
 
 	// returns the hit distance given the material density
 	float intersectFogVolume( Material material, float u ) {

package/src/shader/bsdf/{ggx.glsl.js → ggx_functions.glsl.js}

@@ -1,4 +1,4 @@
-export const ggxGLSL = /* glsl */`
+export const ggx_functions = /* glsl */`
 
 	// The GGX functions provide sampling and distribution information for normals as output so
 	// in order to get probability of scatter direction the half vector must be computed and provided.

package/src/shader/bsdf/index.js

@@ -0,0 +1,5 @@
+export * from './bsdf_functions.glsl.js';
+export * from './fog_functions.glsl.js';
+export * from './ggx_functions.glsl.js';
+export * from './iridescence_functions.glsl.js';
+export * from './sheen_functions.glsl.js';

package/src/shader/bsdf/{iridescence.glsl.js → iridescence_functions.glsl.js}

@@ -1,4 +1,4 @@
-export const iridescenceGLSL = /* glsl */`
+export const iridescence_functions = /* glsl */`
 
 	// XYZ to sRGB color space
 	const mat3 XYZ_TO_REC709 = mat3(

package/src/shader/bsdf/{sheen.glsl.js → sheen_functions.glsl.js}

@@ -1,4 +1,4 @@
-export const sheenGLSL = /* glsl */`
+export const sheen_functions = /* glsl */`
 
 	// See equation (2) in http://www.aconty.com/pdf/s2017_pbs_imageworks_sheen.pdf
 	float velvetD( float cosThetaH, float roughness ) {

package/src/shader/bvh/index.js

@@ -0,0 +1,2 @@
+export * from './inside_fog_volume_function.glsl.js';
+export * from './ray_any_hit_function.glsl.js';

package/src/shader/{structs/fogMaterialBvh.glsl.js → bvh/inside_fog_volume_function.glsl.js}

@@ -1,4 +1,4 @@
-export const fogMaterialBvhGLSL = /* glsl */`
+export const inside_fog_volume_function = /* glsl */`
 
 #ifndef FOG_CHECK_ITERATIONS
 #define FOG_CHECK_ITERATIONS 30