three-gpu-pathtracer 0.0.1 → 0.0.2

package/src/core/PathTracingSceneGenerator.js

@@ -1,23 +1,28 @@
-import { SAH } from 'three-mesh-bvh';
-import { GenerateMeshBVHWorker } from 'three-mesh-bvh/src/workers/GenerateMeshBVHWorker.js';
+import { Mesh } from 'three';
+import { SAH, MeshBVH, StaticGeometryGenerator } from 'three-mesh-bvh';
 import { mergeMeshes } from '../utils/GeometryPreparationUtils.js';
 
 export class PathTracingSceneGenerator {
 
-	constructor() {
+	prepScene( scene ) {
 
-		this.bvhGenerator = new GenerateMeshBVHWorker();
-
-	}
-
-	async generate( scene, options = {} ) {
-
-		const { bvhGenerator } = this;
 		const meshes = [];
-
 		scene.traverse( c => {
 
-			if ( c.isMesh ) {
+			if ( c.isSkinnedMesh || c.isMesh && c.morphTargetInfluences ) {
+
+				const generator = new StaticGeometryGenerator( c );
+				generator.applyWorldTransforms = false;
+				const mesh = new Mesh(
+					generator.generate(),
+					c.material,
+				);
+				mesh.matrixWorld.copy( c.matrixWorld );
+				mesh.matrix.copy( c.matrixWorld );
+				mesh.matrix.decompose( mesh.position, mesh.quaternion, mesh.scale );
+				meshes.push( mesh );
+
+			} else if ( c.isMesh ) {
 
 				meshes.push( c );
 
@@ -25,22 +30,23 @@ export class PathTracingSceneGenerator {
 
 		} );
 
-		const { geometry, materials, textures } = mergeMeshes( meshes, { attributes: [ 'position', 'normal', 'tangent', 'uv' ] } );
-		const bvhPromise = bvhGenerator.generate( geometry, { strategy: SAH, ...options, maxLeafTris: 1 } );
+		return mergeMeshes( meshes, {
+			attributes: [ 'position', 'normal', 'tangent', 'uv' ],
+		} );
 
+	}
+
+	generate( scene, options = {} ) {
+
+		const { materials, textures, geometry } = this.prepScene( scene );
+		const bvhOptions = { strategy: SAH, ...options, maxLeafTris: 1 };
 		return {
 			scene,
 			materials,
 			textures,
-			bvh: await bvhPromise,
+			bvh: new MeshBVH( geometry, bvhOptions ),
 		};
 
 	}
 
-	dispose() {
-
-		this.bvhGenerator.terminate();
-
-	}
-
 }

package/src/core/PhysicalCamera.js

@@ -0,0 +1,28 @@
+import { PerspectiveCamera } from 'three';
+
+export class PhysicalCamera extends PerspectiveCamera {
+
+	set bokehSize( size ) {
+
+		this.fStop = this.getFocalLength() / size;
+
+	}
+
+	get bokehSize() {
+
+		return this.getFocalLength() / this.fStop;
+
+	}
+
+	constructor( ...args ) {
+
+		super( ...args );
+		this.fStop = 1.4;
+		this.apertureBlades = 0;
+		this.apertureRotation = 0;
+		this.focusDistance = 25;
+		this.anamorphicRatio = 1;
+
+	}
+
+}

package/src/index.js

@@ -1,7 +1,9 @@
 // core
 export * from './core/PathTracingRenderer.js';
 export * from './core/PathTracingSceneGenerator.js';
+export * from './core/DynamicPathTracingSceneGenerator.js';
 export * from './core/MaterialReducer.js';
+export * from './core/PhysicalCamera.js';
 
 // uniforms
 export * from './uniforms/MaterialStructArrayUniform.js';

package/src/materials/PhysicalPathTracingMaterial.js

@@ -9,6 +9,7 @@ import { MaterialStructArrayUniform } from '../uniforms/MaterialStructArrayUnifo
 import { RenderTarget2DArray } from '../uniforms/RenderTarget2DArray.js';
 import { shaderMaterialSampling } from '../shader/shaderMaterialSampling.js';
 import { shaderUtils } from '../shader/shaderUtils.js';
+import { PhysicalCameraUniform } from '../uniforms/PhysicalCameraUniform.js';
 
 export class PhysicalPathTracingMaterial extends MaterialBase {
 
@@ -27,13 +28,16 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 			depthWrite: false,
 
 			defines: {
-				BOUNCES: 3,
+				DOF_SUPPORT: 1,
 				TRANSPARENT_TRAVERSALS: 5,
 				MATERIAL_LENGTH: 0,
 				GRADIENT_BG: 0,
 			},
 
 			uniforms: {
+				bounces: { value: 3 },
+				physicalCamera: { value: new PhysicalCameraUniform() },
+
 				bvh: { value: new MeshBVHUniformStruct() },
 				normalAttribute: { value: new FloatVertexAttributeTexture() },
 				tangentAttribute: { value: new FloatVertexAttributeTexture() },
@@ -110,6 +114,14 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 				#endif
 
+				#if DOF_SUPPORT
+
+				uniform PhysicalCamera physicalCamera;
+
+				#endif
+
+				uniform int bounces;
+
 				uniform mat4 cameraWorldMatrix;
 				uniform mat4 invProjectionMatrix;
 				uniform sampler2D normalAttribute;
@@ -134,6 +146,30 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 					vec3 rayOrigin, rayDirection;
 					ndcToCameraRay( ndc, cameraWorldMatrix, invProjectionMatrix, rayOrigin, rayDirection );
 
+					#if DOF_SUPPORT
+
+					// depth of field
+					vec3 focalPoint = rayOrigin + normalize( rayDirection ) * physicalCamera.focusDistance;
+
+					// get the aperture sample
+					vec2 apertureSample = sampleAperture( physicalCamera.apertureBlades ) * 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 );
+
+					#endif
+
+					// create the new ray
+					rayOrigin += ( cameraWorldMatrix * vec4( apertureSample, 0.0, 0.0 ) ).xyz;
+					rayDirection = focalPoint - rayOrigin;
+
 					// Lambertian render
 					gl_FragColor = vec4( 0.0 );
 
@@ -148,7 +184,7 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 					float accumulatedRoughness = 0.0;
 					int i;
 					int transparentTraversals = TRANSPARENT_TRAVERSALS;
-					for ( i = 0; i < BOUNCES; i ++ ) {
+					for ( i = 0; i < bounces; i ++ ) {
 
 						if ( ! bvhIntersectFirstHit( bvh, rayOrigin, rayDirection, faceIndices, faceNormal, barycoord, side, dist ) ) {
 
@@ -199,12 +235,23 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 
 						}
 
-						// possibly skip this sample if it's transparent or alpha test is enabled
-						// alpha test is disabled when it === 0
+						// possibly skip this sample if it's transparent, alpha test is enabled, or we hit the wrong material side
+						// and it's single sided.
+						// - alpha test is disabled when it === 0
+						// - the material sidedness test is complicated because we want light to pass through the back side but still
+						// be able to see the front side. This boolean checks if the side we hit is the front side on the first ray
+						// 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 (
-							useAlphaTest && albedo.a < alphaTest
+							// material sidedness
+							material.side != 0.0 && ( side != material.side ) == isFirstHit
+
+							// alpha test
+							|| useAlphaTest && albedo.a < alphaTest
+
+							// opacity
 							|| ! useAlphaTest && albedo.a < rand()
 						) {
 
@@ -288,7 +335,6 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 						SurfaceRec surfaceRec;
 						surfaceRec.normal = normal;
 						surfaceRec.faceNormal = faceNormal;
-						surfaceRec.frontFace = side == 1.0;
 						surfaceRec.transmission = transmission;
 						surfaceRec.ior = material.ior;
 						surfaceRec.emission = emission;
@@ -296,6 +342,10 @@ export class PhysicalPathTracingMaterial extends MaterialBase {
 						surfaceRec.color = albedo.rgb;
 						surfaceRec.roughness = roughness;
 
+						// 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;
+
 						// Compute the filtered roughness value to use during specular reflection computations. A minimum
 						// value of 1e-6 is needed because the GGX functions do not work with a roughness value of 0 and
 						// the accumulated roughness value is scaled by a user setting and a "magic value" of 5.0.

package/src/shader/shaderStructs.js

@@ -1,5 +1,15 @@
 export const shaderMaterialStructs = /* glsl */ `
 
+	struct PhysicalCamera {
+
+		float focusDistance;
+		float anamorphicRatio;
+		float bokehSize;
+		int apertureBlades;
+		float apertureRotation;
+
+	};
+
 	struct Material {
 
 		vec3 color;
@@ -25,6 +35,8 @@ export const shaderMaterialStructs = /* glsl */ `
 		float opacity;
 		float alphaTest;
 
+		float side;
+
 	};
 
 `;

package/src/shader/shaderUtils.js

@@ -98,6 +98,7 @@ export const shaderUtils = /* glsl */`
 
 	}
 
+	// returns [ 0, 1 ]
 	float rand() {
 
 		pcg4d(s0);
@@ -137,4 +138,54 @@ export const shaderUtils = /* glsl */`
 		return vec3( f * cos( t ), f * sin( t ), u );
 
 	}
+
+	vec2 triangleSample( vec2 a, vec2 b, vec2 c ) {
+
+		// get the edges of the triangle and the diagonal across the
+		// center of the parallelogram
+		vec2 e1 = a - b;
+		vec2 e2 = c - b;
+		vec2 diag = normalize( e1 + e2 );
+
+		// pick a random point in the parallelogram
+		vec2 r = rand2();
+		if ( r.x + r.y > 1.0 ) {
+
+			r = vec2( 1.0 ) - r;
+
+		}
+
+		return e1 * r.x + e2 * r.y;
+
+	}
+
+	// samples an aperture shape with the given number of sides. 0 means circle
+	vec2 sampleAperture( int blades ) {
+
+		if ( blades == 0 ) {
+
+			vec2 r = rand2();
+			float angle = 2.0 * PI * r.x;
+			float radius = sqrt( rand() );
+			return vec2( cos( angle ), sin( angle ) ) * radius;
+
+		} else {
+
+			blades = max( blades, 3 );
+
+			vec3 r = rand3();
+			float anglePerSegment = 2.0 * PI / float( blades );
+			float segment = floor( float( blades ) * r.x );
+
+			float angle1 = anglePerSegment * segment;
+			float angle2 = angle1 + anglePerSegment;
+			vec2 a = vec2( sin( angle1 ), cos( angle1 ) );
+			vec2 b = vec2( 0.0, 0.0 );
+			vec2 c = vec2( sin( angle2 ), cos( angle2 ) );
+
+			return triangleSample( a, b, c );
+
+		}
+
+	}
 `;

package/src/uniforms/MaterialStructUniform.js

@@ -1,4 +1,4 @@
-import { Color, Vector2 } from 'three';
+import { Color, Vector2, DoubleSide, FrontSide, BackSide } from 'three';
 export class MaterialStructUniform {
 
 	constructor() {
@@ -32,6 +32,8 @@ export class MaterialStructUniform {
 		this.opacity = 1.0;
 		this.alphaTest = 0.0;
 
+		this.side = 0;
+
 		// TODO: Clearcoat
 
 		// TODO: Sheen
@@ -91,4 +93,22 @@ export class MaterialStructUniform {
 
 	}
 
+	setSide( side ) {
+
+		switch ( side ) {
+
+			case DoubleSide:
+				this.side = 0;
+				break;
+			case FrontSide:
+				this.side = 1;
+				break;
+			case BackSide:
+				this.side = - 1;
+				break;
+
+		}
+
+	}
+
 }

package/src/uniforms/PhysicalCameraUniform.js

@@ -0,0 +1,36 @@
+import { PhysicalCamera } from '../core/PhysicalCamera.js';
+export class PhysicalCameraUniform {
+
+	constructor() {
+
+		this.bokehSize = 0;
+		this.apertureBlades = 0;
+		this.apertureRotation = 0;
+		this.focusDistance = 10;
+		this.anamorphicRatio = 1;
+
+	}
+
+	updateFrom( camera ) {
+
+		if ( camera instanceof PhysicalCamera ) {
+
+			this.bokehSize = camera.bokehSize;
+			this.apertureBlades = camera.apertureBlades;
+			this.apertureRotation = camera.apertureRotation;
+			this.focusDistance = camera.focusDistance;
+			this.anamorphicRatio = camera.anamorphicRatio;
+
+		} else {
+
+			this.bokehSize = 0;
+			this.apertureRotation = 0;
+			this.apertureBlades = 0;
+			this.focusDistance = 10;
+			this.anamorphicRatio = 1;
+
+		}
+
+	}
+
+}