three-gpu-pathtracer 0.0.14 → 0.0.16

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

@@ -0,0 +1,50 @@
+export const renderStructsGLSL = /* glsl */`
+
+	struct Ray {
+
+		vec3 origin;
+		vec3 direction;
+
+	};
+
+	struct SurfaceHit {
+
+		uvec4 faceIndices;
+		vec3 barycoord;
+		vec3 faceNormal;
+		float side;
+		float dist;
+
+	};
+
+	struct RenderState {
+
+		bool firstRay;
+		bool transmissiveRay;
+		bool isShadowRay;
+		float accumulatedRoughness;
+		int transmissiveTraversals;
+		int traversals;
+		uint depth;
+		vec3 throughputColor;
+		Material fogMaterial;
+
+	};
+
+	RenderState initRenderState() {
+
+		RenderState result;
+		result.firstRay = true;
+		result.transmissiveRay = true;
+		result.isShadowRay = false;
+		result.accumulatedRoughness = 0.0;
+		result.transmissiveTraversals = 0;
+		result.traversals = 0;
+		result.throughputColor = vec3( 1.0 );
+		result.depth = 0u;
+		result.fogMaterial.fogVolume = false;
+		return result;
+
+	}
+
+`;

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

@@ -1,54 +1,52 @@
-export const traceSceneGLSL = /* glsl */`
-
-	#define NO_HIT 0
-	#define SURFACE_HIT 1
-	#define LIGHT_HIT 2
-	#define FOG_HIT 3
-
-	int traceScene(
-
-		vec3 rayOrigin, vec3 rayDirection,
-		BVH bvh, LightsInfo lights, Material fogMaterial,
-		out uvec4 faceIndices, out vec3 faceNormal, out vec3 barycoord, out float side, out float dist,
-		out LightSampleRecord lightSampleRec
-
-	) {
-
-		bool hit = bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist );
-		bool lightHit = lightsClosestHit( lights.tex, lights.count, rayOrigin, rayDirection, lightSampleRec );
-
-		#if FEATURE_FOG
-
-		if ( fogMaterial.fogVolume ) {
-
-			float particleDist = intersectFogVolume( fogMaterial, sobol( 1 ) );
-			if ( particleDist + 1e-4 < dist && ( particleDist + 1e-4 < lightSampleRec.dist || ! lightHit ) ) {
-
-				side = 1.0;
-				faceNormal = normalize( - rayDirection );
-				dist = particleDist;
-				return FOG_HIT;
-
-			}
-
-		}
-
-		#endif
-
-		if ( lightHit && ( lightSampleRec.dist < dist || ! hit ) ) {
-
-			return LIGHT_HIT;
-
-		}
-
-		if ( hit ) {
-
-			return SURFACE_HIT;
-
-		}
-
-		return NO_HIT;
-
-	}
-
-`;
+export const traceSceneGLSL = /* glsl */`
+
+	#define NO_HIT 0
+	#define SURFACE_HIT 1
+	#define LIGHT_HIT 2
+	#define FOG_HIT 3
+
+	int traceScene(
+
+		Ray ray, BVH bvh, LightsInfo lights, Material fogMaterial,
+		out SurfaceHit surfaceHit, out LightRecord lightRec
+
+	) {
+
+		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 ) {
+
+			float particleDist = intersectFogVolume( fogMaterial, sobol( 1 ) );
+			if ( particleDist + 1e-4 < surfaceHit.dist && ( particleDist + 1e-4 < lightRec.dist || ! lightHit ) ) {
+
+				surfaceHit.side = 1.0;
+				surfaceHit.faceNormal = normalize( - ray.direction );
+				surfaceHit.dist = particleDist;
+				return FOG_HIT;
+
+			}
+
+		}
+
+		#endif
+
+		if ( lightHit && ( lightRec.dist < surfaceHit.dist || ! hit ) ) {
+
+			return LIGHT_HIT;
+
+		}
+
+		if ( hit ) {
+
+			return SURFACE_HIT;
+
+		}
+
+		return NO_HIT;
+
+	}
+
+`;

package/src/materials/surface/AmbientOcclusionMaterial.js

@@ -1,207 +1,207 @@
-import { TangentSpaceNormalMap, Vector2 } from 'three';
-import { MaterialBase } from '../MaterialBase.js';
-import { MeshBVHUniformStruct, shaderStructs, shaderIntersectFunction } 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';
-
-export class AmbientOcclusionMaterial extends MaterialBase {
-
-	get normalMap() {
-
-		return this.uniforms.normalMap.value;
-
-	}
-
-	set normalMap( v ) {
-
-		this.uniforms.normalMap.value = v;
-		this.setDefine( 'USE_NORMALMAP', v ? null : '' );
-
-	}
-
-	get normalMapType() {
-
-		return TangentSpaceNormalMap;
-
-	}
-
-	set normalMapType( v ) {
-
-		if ( v !== TangentSpaceNormalMap ) {
-
-			throw new Error( 'AmbientOcclusionMaterial: Only tangent space normal map are supported' );
-
-		}
-
-	}
-
-	constructor( parameters ) {
-
-		super( {
-
-			defines: {
-				SAMPLES: 10,
-			},
-
-			uniforms: {
-				bvh: { value: new MeshBVHUniformStruct() },
-				radius: { value: 1.0 },
-				seed: { value: 0 },
-
-				normalMap: { value: null },
-				normalScale: { value: new Vector2( 1, 1 ) },
-			},
-
-			vertexShader: /* glsl */`
-
-				varying vec3 vNorm;
-				varying vec3 vPos;
-
-				#if defined(USE_NORMALMAP) && defined(USE_TANGENT)
-
-					varying vec2 vUv;
-					varying vec4 vTan;
-
-				#endif
-
-				void main() {
-
-					vec4 mvPosition = vec4( position, 1.0 );
-					mvPosition = modelViewMatrix * mvPosition;
-					gl_Position = projectionMatrix * mvPosition;
-
-					mat3 modelNormalMatrix = transpose( inverse( mat3( modelMatrix ) ) );
-					vNorm = normalize( modelNormalMatrix * normal );
-					vPos = ( modelMatrix * vec4( position, 1.0 ) ).xyz;
-
-					#if defined( USE_NORMALMAP ) && defined( USE_TANGENT )
-
-						vUv = uv;
-						vTan = tangent;
-
-					#endif
-
-				}
-
-			`,
-
-			fragmentShader: /* glsl */`
-				#define RAY_OFFSET 1e-4
-
-				precision highp isampler2D;
-				precision highp usampler2D;
-				precision highp sampler2DArray;
-				#include <common>
-				#include <cube_uv_reflection_fragment>
-
-				// bvh
-				${ shaderStructs }
-				${ shaderIntersectFunction }
-
-				// uniform structs
-				${ materialStructGLSL }
-
-				// rand
-				${ pcgGLSL }
-
-				// common
-				${ shapeSamplingGLSL }
-
-				uniform BVH bvh;
-				uniform int seed;
-				uniform float radius;
-
-				varying vec3 vNorm;
-				varying vec3 vPos;
-
-				#if defined(USE_NORMALMAP) && defined(USE_TANGENT)
-
-					uniform sampler2D normalMap;
-					uniform vec2 normalScale;
-					varying vec2 vUv;
-					varying vec4 vTan;
-
-				#endif
-
-				void main() {
-
-					rng_initialize( gl_FragCoord.xy, seed );
-
-					// compute the flat face surface normal
-					vec3 fdx = vec3( dFdx( vPos.x ), dFdx( vPos.y ), dFdx( vPos.z ) );
-					vec3 fdy = vec3( dFdy( vPos.x ), dFdy( vPos.y ), dFdy( vPos.z ) );
-					vec3 faceNormal = normalize( cross( fdx, fdy ) );
-
-					// find the max component to scale the offset to account for floating point error
-					vec3 absPoint = abs( vPos );
-					float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
-					vec3 normal = vNorm;
-
-					#if defined( USE_NORMALMAP ) && defined( USE_TANGENT )
-
-						// some provided tangents can be malformed (0, 0, 0) causing the normal to be degenerate
-						// resulting in NaNs and slow path tracing.
-						if ( length( vTan.xyz ) > 0.0 ) {
-
-							vec2 uv = vUv;
-							vec3 tangent = normalize( vTan.xyz );
-							vec3 bitangent = normalize( cross( normal, tangent ) * vTan.w );
-							mat3 vTBN = mat3( tangent, bitangent, normal );
-
-							vec3 texNormal = texture2D( normalMap, uv ).xyz * 2.0 - 1.0;
-							texNormal.xy *= normalScale;
-							normal = vTBN * texNormal;
-
-						}
-
-					#endif
-
-					normal *= gl_FrontFacing ? 1.0 : - 1.0;
-
-					vec3 rayOrigin = vPos + faceNormal * ( maxPoint + 1.0 ) * RAY_OFFSET;
-					float accumulated = 0.0;
-					for ( int i = 0; i < SAMPLES; i ++ ) {
-
-						// sample the cosine weighted hemisphere and discard the sample if it's below
-						// the geometric surface
-						vec3 rayDirection = sampleHemisphere( normalize( normal ), rand4().xy );
-
-						// check if we hit the mesh and its within the specified radius
-						float side = 1.0;
-						float dist = 0.0;
-						vec3 barycoord = vec3( 0.0 );
-						vec3 outNormal = vec3( 0.0 );
-						uvec4 faceIndices = uvec4( 0u );
-
-						// if the ray is above the geometry surface, and it doesn't hit another surface within the specified radius then
-						// we consider it lit
-						if (
-							dot( rayDirection, faceNormal ) > 0.0 &&
-							(
-								! bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, outNormal, barycoord, side, dist ) ||
-								dist > radius
-							)
-						) {
-
-							accumulated += 1.0;
-
-						}
-
-					}
-
-					gl_FragColor.rgb = vec3( accumulated / float( SAMPLES ) );
-					gl_FragColor.a = 1.0;
-
-				}
-
-			`
-
-		} );
-
-		this.setValues( parameters );
-
-	}
-
-}
+import { TangentSpaceNormalMap, Vector2 } from 'three';
+import { MaterialBase } from '../MaterialBase.js';
+import { MeshBVHUniformStruct, shaderStructs, shaderIntersectFunction } 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';
+
+export class AmbientOcclusionMaterial extends MaterialBase {
+
+	get normalMap() {
+
+		return this.uniforms.normalMap.value;
+
+	}
+
+	set normalMap( v ) {
+
+		this.uniforms.normalMap.value = v;
+		this.setDefine( 'USE_NORMALMAP', v ? null : '' );
+
+	}
+
+	get normalMapType() {
+
+		return TangentSpaceNormalMap;
+
+	}
+
+	set normalMapType( v ) {
+
+		if ( v !== TangentSpaceNormalMap ) {
+
+			throw new Error( 'AmbientOcclusionMaterial: Only tangent space normal map are supported' );
+
+		}
+
+	}
+
+	constructor( parameters ) {
+
+		super( {
+
+			defines: {
+				SAMPLES: 10,
+			},
+
+			uniforms: {
+				bvh: { value: new MeshBVHUniformStruct() },
+				radius: { value: 1.0 },
+				seed: { value: 0 },
+
+				normalMap: { value: null },
+				normalScale: { value: new Vector2( 1, 1 ) },
+			},
+
+			vertexShader: /* glsl */`
+
+				varying vec3 vNorm;
+				varying vec3 vPos;
+
+				#if defined(USE_NORMALMAP) && defined(USE_TANGENT)
+
+					varying vec2 vUv;
+					varying vec4 vTan;
+
+				#endif
+
+				void main() {
+
+					vec4 mvPosition = vec4( position, 1.0 );
+					mvPosition = modelViewMatrix * mvPosition;
+					gl_Position = projectionMatrix * mvPosition;
+
+					mat3 modelNormalMatrix = transpose( inverse( mat3( modelMatrix ) ) );
+					vNorm = normalize( modelNormalMatrix * normal );
+					vPos = ( modelMatrix * vec4( position, 1.0 ) ).xyz;
+
+					#if defined( USE_NORMALMAP ) && defined( USE_TANGENT )
+
+						vUv = uv;
+						vTan = tangent;
+
+					#endif
+
+				}
+
+			`,
+
+			fragmentShader: /* glsl */`
+				#define RAY_OFFSET 1e-4
+
+				precision highp isampler2D;
+				precision highp usampler2D;
+				precision highp sampler2DArray;
+				#include <common>
+				#include <cube_uv_reflection_fragment>
+
+				// bvh
+				${ shaderStructs }
+				${ shaderIntersectFunction }
+
+				// uniform structs
+				${ materialStructGLSL }
+
+				// rand
+				${ pcgGLSL }
+
+				// common
+				${ shapeSamplingGLSL }
+
+				uniform BVH bvh;
+				uniform int seed;
+				uniform float radius;
+
+				varying vec3 vNorm;
+				varying vec3 vPos;
+
+				#if defined(USE_NORMALMAP) && defined(USE_TANGENT)
+
+					uniform sampler2D normalMap;
+					uniform vec2 normalScale;
+					varying vec2 vUv;
+					varying vec4 vTan;
+
+				#endif
+
+				void main() {
+
+					rng_initialize( gl_FragCoord.xy, seed );
+
+					// compute the flat face surface normal
+					vec3 fdx = vec3( dFdx( vPos.x ), dFdx( vPos.y ), dFdx( vPos.z ) );
+					vec3 fdy = vec3( dFdy( vPos.x ), dFdy( vPos.y ), dFdy( vPos.z ) );
+					vec3 faceNormal = normalize( cross( fdx, fdy ) );
+
+					// find the max component to scale the offset to account for floating point error
+					vec3 absPoint = abs( vPos );
+					float maxPoint = max( absPoint.x, max( absPoint.y, absPoint.z ) );
+					vec3 normal = vNorm;
+
+					#if defined( USE_NORMALMAP ) && defined( USE_TANGENT )
+
+						// some provided tangents can be malformed (0, 0, 0) causing the normal to be degenerate
+						// resulting in NaNs and slow path tracing.
+						if ( length( vTan.xyz ) > 0.0 ) {
+
+							vec2 uv = vUv;
+							vec3 tangent = normalize( vTan.xyz );
+							vec3 bitangent = normalize( cross( normal, tangent ) * vTan.w );
+							mat3 vTBN = mat3( tangent, bitangent, normal );
+
+							vec3 texNormal = texture2D( normalMap, uv ).xyz * 2.0 - 1.0;
+							texNormal.xy *= normalScale;
+							normal = vTBN * texNormal;
+
+						}
+
+					#endif
+
+					normal *= gl_FrontFacing ? 1.0 : - 1.0;
+
+					vec3 rayOrigin = vPos + faceNormal * ( maxPoint + 1.0 ) * RAY_OFFSET;
+					float accumulated = 0.0;
+					for ( int i = 0; i < SAMPLES; i ++ ) {
+
+						// sample the cosine weighted hemisphere and discard the sample if it's below
+						// the geometric surface
+						vec3 rayDirection = sampleHemisphere( normalize( normal ), rand4().xy );
+
+						// check if we hit the mesh and its within the specified radius
+						float side = 1.0;
+						float dist = 0.0;
+						vec3 barycoord = vec3( 0.0 );
+						vec3 outNormal = vec3( 0.0 );
+						uvec4 faceIndices = uvec4( 0u );
+
+						// if the ray is above the geometry surface, and it doesn't hit another surface within the specified radius then
+						// we consider it lit
+						if (
+							dot( rayDirection, faceNormal ) > 0.0 &&
+							(
+								! bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, outNormal, barycoord, side, dist ) ||
+								dist >= radius
+							)
+						) {
+
+							accumulated += 1.0;
+
+						}
+
+					}
+
+					gl_FragColor.rgb = vec3( accumulated / float( SAMPLES ) );
+					gl_FragColor.a = 1.0;
+
+				}
+
+			`
+
+		} );
+
+		this.setValues( parameters );
+
+	}
+
+}

package/src/materials/surface/FogVolumeMaterial.js

@@ -1,23 +1,23 @@
-import { Color, MeshStandardMaterial } from 'three';
-
-export class FogVolumeMaterial extends MeshStandardMaterial {
-
-	constructor( params ) {
-
-		super( params );
-
-		this.isFogVolumeMaterial = true;
-
-		this.density = 0.015;
-		this.emissive = new Color();
-		this.emissiveIntensity = 0.0;
-		this.opacity = 0.15;
-		this.transparent = true;
-		this.roughness = 1.0;
-		this.metalness = 0.0;
-
-		this.setValues( params );
-
-	}
-
-}
+import { Color, MeshStandardMaterial } from 'three';
+
+export class FogVolumeMaterial extends MeshStandardMaterial {
+
+	constructor( params ) {
+
+		super( params );
+
+		this.isFogVolumeMaterial = true;
+
+		this.density = 0.015;
+		this.emissive = new Color();
+		this.emissiveIntensity = 0.0;
+		this.opacity = 0.15;
+		this.transparent = true;
+		this.roughness = 1.0;
+		this.metalness = 0.0;
+
+		this.setValues( params );
+
+	}
+
+}

package/src/objects/EquirectCamera.js

@@ -1,13 +1,13 @@
-import { Camera } from 'three';
-
-export class EquirectCamera extends Camera {
-
-	constructor() {
-
-		super();
-
-		this.isEquirectCamera = true;
-
-	}
-
-}
+import { Camera } from 'three';
+
+export class EquirectCamera extends Camera {
+
+	constructor() {
+
+		super();
+
+		this.isEquirectCamera = true;
+
+	}
+
+}