three-gpu-pathtracer 0.0.2 → 0.0.5

package/src/core/PathTracingRenderer.js

@@ -1,22 +1,42 @@
-import { RGBAFormat, FloatType, Color, Vector2, WebGLRenderTarget } from 'three';
+import { RGBAFormat, FloatType, Color, Vector2, WebGLRenderTarget, NoBlending, NormalBlending } from 'three';
 import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
+import { BlendMaterial } from '../materials/BlendMaterial.js';
 
 function* renderTask() {
 
-	const { _fsQuad, _renderer, target, camera, material } = this;
+	const {
+		_renderer,
+		_fsQuad,
+		_blendQuad,
+		_primaryTarget,
+		_blendTargets,
+		alpha,
+		camera,
+		material,
+	} = this;
+
+	const blendMaterial = _blendQuad.material;
+	let [ blendTarget1, blendTarget2 ] = _blendTargets;
+
 	while ( true ) {
 
-		material.opacity = 1 / ( this.samples + 1 );
-		material.seed ++;
+		if ( alpha ) {
+
+			blendMaterial.opacity = 1 / ( this.samples + 1 );
+			material.blending = NoBlending;
+			material.opacity = 1;
+
+		} else {
+
+			material.opacity = 1 / ( this.samples + 1 );
+			material.blending = NormalBlending;
+
+		}
 
-		const w = target.width;
-		const h = target.height;
-		camera.setViewOffset(
-			w, h,
-			Math.random() - 0.5, Math.random() - 0.5,
-			w, h,
-		);
-		camera.updateProjectionMatrix();
+		const w = _primaryTarget.width;
+		const h = _primaryTarget.height;
+		material.resolution.set( w, h );
+		material.seed ++;
 
 		const tx = this.tiles.x || 1;
 		const ty = this.tiles.y || 1;
@@ -29,11 +49,32 @@ function* renderTask() {
 				material.cameraWorldMatrix.copy( camera.matrixWorld );
 				material.invProjectionMatrix.copy( camera.projectionMatrixInverse );
 
+				// Perspective camera (default)
+				let cameraType = 0;
+
+				// An orthographic projection matrix will always have the bottom right element == 1
+				// And a perspective projection matrix will always have the bottom right element == 0
+				if ( camera.projectionMatrix.elements[ 15 ] > 0 ) {
+
+					// Orthographic
+					cameraType = 1;
+
+				}
+
+				if ( camera.isEquirectCamera ) {
+
+					// Equirectangular
+					cameraType = 2;
+
+				}
+
+				material.setDefine( 'CAMERA_TYPE', cameraType );
+
 				const ogRenderTarget = _renderer.getRenderTarget();
 				const ogAutoClear = _renderer.autoClear;
 
 				// three.js renderer takes values relative to the current pixel ratio
-				_renderer.setRenderTarget( target );
+				_renderer.setRenderTarget( _primaryTarget );
 				_renderer.setScissorTest( true );
 				_renderer.setScissor(
 					dprInv * Math.ceil( x * w / tx ),
@@ -47,6 +88,17 @@ function* renderTask() {
 				_renderer.setRenderTarget( ogRenderTarget );
 				_renderer.autoClear = ogAutoClear;
 
+				if ( alpha ) {
+
+					blendMaterial.target1 = blendTarget1.texture;
+					blendMaterial.target2 = _primaryTarget.texture;
+
+					_renderer.setRenderTarget( blendTarget2 );
+					_blendQuad.render( _renderer );
+					_renderer.setRenderTarget( ogRenderTarget );
+
+				}
+
 				this.samples += ( 1 / totalTiles );
 
 				yield;
@@ -55,6 +107,8 @@ function* renderTask() {
 
 		}
 
+		[ blendTarget1, blendTarget2 ] = [ blendTarget2, blendTarget1 ];
+
 		this.samples = Math.round( this.samples );
 
 	}
@@ -76,43 +130,104 @@ export class PathTracingRenderer {
 
 	}
 
+	get target() {
+
+		return this._alpha ? this._blendTargets[ 1 ] : this._primaryTarget;
+
+	}
+
+	set alpha( v ) {
+
+		if ( ! v ) {
+
+			this._blendTargets[ 0 ].dispose();
+			this._blendTargets[ 1 ].dispose();
+
+		}
+
+		this._alpha = v;
+		this.reset();
+
+	}
+
+	get alpha() {
+
+		return this._alpha;
+
+	}
+
 	constructor( renderer ) {
 
 		this.camera = null;
 		this.tiles = new Vector2( 1, 1 );
-		this.target = new WebGLRenderTarget( 1, 1, {
-			format: RGBAFormat,
-			type: FloatType,
-		} );
+
 		this.samples = 0;
 		this.stableNoise = false;
 		this._renderer = renderer;
+		this._alpha = false;
 		this._fsQuad = new FullScreenQuad( null );
+		this._blendQuad = new FullScreenQuad( new BlendMaterial() );
 		this._task = null;
 
+		this._primaryTarget = new WebGLRenderTarget( 1, 1, {
+			format: RGBAFormat,
+			type: FloatType,
+		} );
+		this._blendTargets = [
+			new WebGLRenderTarget( 1, 1, {
+				format: RGBAFormat,
+				type: FloatType,
+			} ),
+			new WebGLRenderTarget( 1, 1, {
+				format: RGBAFormat,
+				type: FloatType,
+			} ),
+		];
+
 	}
 
 	setSize( w, h ) {
 
-		this.target.setSize( w, h );
+		this._primaryTarget.setSize( w, h );
+		this._blendTargets[ 0 ].setSize( w, h );
+		this._blendTargets[ 1 ].setSize( w, h );
 		this.reset();
 
 	}
 
+	dispose() {
+
+		this._primaryTarget.dispose();
+		this._blendTargets[ 0 ].dispose();
+		this._blendTargets[ 1 ].dispose();
+
+		this._fsQuad.dispose();
+		this._blendQuad.dispose();
+		this._task = null;
+
+	}
+
 	reset() {
 
-		const renderer = this._renderer;
-		const target = this.target;
-		const ogRenderTarget = renderer.getRenderTarget();
-		const ogClearAlpha = renderer.getClearAlpha();
-		renderer.getClearColor( ogClearColor );
+		const { _renderer, _primaryTarget, _blendTargets } = this;
+		const ogRenderTarget = _renderer.getRenderTarget();
+		const ogClearAlpha = _renderer.getClearAlpha();
+		_renderer.getClearColor( ogClearColor );
+
+		_renderer.setRenderTarget( _primaryTarget );
+		_renderer.setClearColor( 0, 0 );
+		_renderer.clearColor();
+
+		_renderer.setRenderTarget( _blendTargets[ 0 ] );
+		_renderer.setClearColor( 0, 0 );
+		_renderer.clearColor();
 
-		renderer.setRenderTarget( target );
-		renderer.setClearColor( 0, 0 );
-		renderer.clearColor();
+		_renderer.setRenderTarget( _blendTargets[ 1 ] );
+		_renderer.setClearColor( 0, 0 );
+		_renderer.clearColor();
 
-		renderer.setClearColor( ogClearColor, ogClearAlpha );
-		renderer.setRenderTarget( ogRenderTarget );
+		_renderer.setClearColor( ogClearColor, ogClearAlpha );
+		_renderer.setRenderTarget( ogRenderTarget );
 
 		this.samples = 0;
 		this._task = null;

package/src/core/PathTracingSceneGenerator.js

@@ -1,52 +1,68 @@
-import { Mesh } from 'three';
-import { SAH, MeshBVH, StaticGeometryGenerator } from 'three-mesh-bvh';
-import { mergeMeshes } from '../utils/GeometryPreparationUtils.js';
-
-export class PathTracingSceneGenerator {
-
-	prepScene( scene ) {
-
-		const meshes = [];
-		scene.traverse( c => {
-
-			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 );
-
-			}
-
-		} );
-
-		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: new MeshBVH( geometry, bvhOptions ),
-		};
-
-	}
-
-}
+import { Mesh } from 'three';
+import { SAH, MeshBVH, StaticGeometryGenerator } from 'three-mesh-bvh';
+import { mergeMeshes } from '../utils/GeometryPreparationUtils.js';
+
+export class PathTracingSceneGenerator {
+
+	prepScene( scene ) {
+
+		scene = Array.isArray( scene ) ? scene : [ scene ];
+
+		const meshes = [];
+		const lights = [];
+
+		for ( let i = 0, l = scene.length; i < l; i ++ ) {
+
+			scene[ i ].traverse( c => {
+
+				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 );
+
+				} else if ( c.isRectAreaLight ) {
+
+					lights.push( c );
+
+				}
+
+			} );
+
+		}
+
+		return {
+			...mergeMeshes( meshes, {
+				attributes: [ 'position', 'normal', 'tangent', 'uv' ],
+			} ),
+			lights
+		};
+
+	}
+
+	generate( scene, options = {} ) {
+
+		const { materials, textures, geometry, lights } = this.prepScene( scene );
+		const bvhOptions = { strategy: SAH, ...options, maxLeafTris: 1 };
+		return {
+			scene,
+			materials,
+			textures,
+			lights,
+			bvh: new MeshBVH( geometry, bvhOptions ),
+		};
+
+	}
+
+}

package/src/core/PhysicalCamera.js

@@ -1,28 +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;
-
-	}
-
-}
+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,23 +1,26 @@
-// 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';
-export * from './uniforms/MaterialStructUniform.js';
-export * from './uniforms/RenderTarget2DArray.js';
-
-// utils
-export * from './utils/GeometryPreparationUtils.js';
-
-// materials
-export * from './materials/MaterialBase.js';
-export * from './materials/PhysicalPathTracingMaterial.js';
-
-// shaders
-export * from './shader/shaderMaterialSampling.js';
-export * from './shader/shaderUtils.js';
-export * from './shader/shaderStructs.js';
+// 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';
+export * from './core/EquirectCamera.js';
+
+// uniforms
+export * from './uniforms/MaterialsTexture.js';
+export * from './uniforms/RenderTarget2DArray.js';
+export * from './uniforms/EquirectHdrInfoUniform.js';
+export * from './uniforms/PhysicalCameraUniform.js';
+
+// utils
+export * from './utils/GeometryPreparationUtils.js';
+export * from './utils/BlurredEnvMapGenerator.js';
+
+// materials
+export * from './materials/MaterialBase.js';
+export * from './materials/PhysicalPathTracingMaterial.js';
+
+// shaders
+export * from './shader/shaderMaterialSampling.js';
+export * from './shader/shaderUtils.js';
+export * from './shader/shaderStructs.js';

package/src/materials/AlphaDisplayMaterial.js

@@ -0,0 +1,48 @@
+import { NoBlending } from 'three';
+import { MaterialBase } from './MaterialBase.js';
+
+export class AlphaDisplayMaterial extends MaterialBase {
+
+	constructor( parameters ) {
+
+		super( {
+
+			uniforms: {
+
+				map: { value: null },
+
+			},
+
+			blending: NoBlending,
+
+			vertexShader: /* glsl */`
+
+				varying vec2 vUv;
+
+				void main() {
+
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+				}`,
+
+			fragmentShader: /* glsl */`
+
+				uniform sampler2D map;
+
+				varying vec2 vUv;
+
+				void main() {
+
+					gl_FragColor = vec4( texture( map, vUv ).a );
+					gl_FragColor.a = 1.0;
+
+				}`
+
+		} );
+
+		this.setValues( parameters );
+
+	}
+
+}