three-gpu-pathtracer 0.0.3 → 0.0.4

package/src/core/PathTracingRenderer.js

@@ -1,233 +1,237 @@
-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 {
-		_renderer,
-		_fsQuad,
-		_blendQuad,
-		_primaryTarget,
-		_blendTargets,
-		alpha,
-		camera,
-		material,
-	} = this;
-
-	const blendMaterial = _blendQuad.material;
-	let [ blendTarget1, blendTarget2 ] = _blendTargets;
-
-	while ( true ) {
-
-		if ( alpha ) {
-
-			blendMaterial.opacity = 1 / ( this.samples + 1 );
-			material.blending = NoBlending;
-
-		} else {
-
-			material.opacity = 1 / ( this.samples + 1 );
-			material.blending = NormalBlending;
-
-		}
-
-		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;
-		const totalTiles = tx * ty;
-		const dprInv = ( 1 / _renderer.getPixelRatio() );
-		for ( let y = 0; y < ty; y ++ ) {
-
-			for ( let x = 0; x < tx; x ++ ) {
-
-				material.cameraWorldMatrix.copy( camera.matrixWorld );
-				material.invProjectionMatrix.copy( camera.projectionMatrixInverse );
-
-				const ogRenderTarget = _renderer.getRenderTarget();
-				const ogAutoClear = _renderer.autoClear;
-
-				// three.js renderer takes values relative to the current pixel ratio
-				_renderer.setRenderTarget( _primaryTarget );
-				_renderer.setScissorTest( true );
-				_renderer.setScissor(
-					dprInv * Math.ceil( x * w / tx ),
-					dprInv * Math.ceil( ( ty - y - 1 ) * h / ty ),
-					dprInv * Math.ceil( w / tx ),
-					dprInv * Math.ceil( h / ty ) );
-				_renderer.autoClear = false;
-				_fsQuad.render( _renderer );
-
-				_renderer.setScissorTest( false );
-				_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;
-
-			}
-
-		}
-
-		[ blendTarget1, blendTarget2 ] = [ blendTarget2, blendTarget1 ];
-
-		this.samples = Math.round( this.samples );
-
-	}
-
-}
-
-const ogClearColor = new Color();
-export class PathTracingRenderer {
-
-	get material() {
-
-		return this._fsQuad.material;
-
-	}
-
-	set material( v ) {
-
-		this._fsQuad.material = v;
-
-	}
-
-	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.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._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, _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( _blendTargets[ 1 ] );
-		_renderer.setClearColor( 0, 0 );
-		_renderer.clearColor();
-
-		_renderer.setClearColor( ogClearColor, ogClearAlpha );
-		_renderer.setRenderTarget( ogRenderTarget );
-
-		this.samples = 0;
-		this._task = null;
-
-		if ( this.stableNoise ) {
-
-			this.material.seed = 0;
-
-		}
-
-	}
-
-	update() {
-
-		if ( ! this._task ) {
-
-			this._task = renderTask.call( this );
-
-		}
-
-		this._task.next();
-
-	}
-
-}
+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 {
+		_renderer,
+		_fsQuad,
+		_blendQuad,
+		_primaryTarget,
+		_blendTargets,
+		alpha,
+		camera,
+		material,
+	} = this;
+
+	const blendMaterial = _blendQuad.material;
+	let [ blendTarget1, blendTarget2 ] = _blendTargets;
+
+	while ( true ) {
+
+		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 = _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;
+		const totalTiles = tx * ty;
+		const dprInv = ( 1 / _renderer.getPixelRatio() );
+		for ( let y = 0; y < ty; y ++ ) {
+
+			for ( let x = 0; x < tx; x ++ ) {
+
+				material.cameraWorldMatrix.copy( camera.matrixWorld );
+				material.invProjectionMatrix.copy( camera.projectionMatrixInverse );
+				// 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
+				material.isOrthographicCamera = camera.projectionMatrix.elements[ 15 ] > 0;
+
+				const ogRenderTarget = _renderer.getRenderTarget();
+				const ogAutoClear = _renderer.autoClear;
+
+				// three.js renderer takes values relative to the current pixel ratio
+				_renderer.setRenderTarget( _primaryTarget );
+				_renderer.setScissorTest( true );
+				_renderer.setScissor(
+					dprInv * Math.ceil( x * w / tx ),
+					dprInv * Math.ceil( ( ty - y - 1 ) * h / ty ),
+					dprInv * Math.ceil( w / tx ),
+					dprInv * Math.ceil( h / ty ) );
+				_renderer.autoClear = false;
+				_fsQuad.render( _renderer );
+
+				_renderer.setScissorTest( false );
+				_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;
+
+			}
+
+		}
+
+		[ blendTarget1, blendTarget2 ] = [ blendTarget2, blendTarget1 ];
+
+		this.samples = Math.round( this.samples );
+
+	}
+
+}
+
+const ogClearColor = new Color();
+export class PathTracingRenderer {
+
+	get material() {
+
+		return this._fsQuad.material;
+
+	}
+
+	set material( v ) {
+
+		this._fsQuad.material = v;
+
+	}
+
+	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.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._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, _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( _blendTargets[ 1 ] );
+		_renderer.setClearColor( 0, 0 );
+		_renderer.clearColor();
+
+		_renderer.setClearColor( ogClearColor, ogClearAlpha );
+		_renderer.setRenderTarget( ogRenderTarget );
+
+		this.samples = 0;
+		this._task = null;
+
+		if ( this.stableNoise ) {
+
+			this.material.seed = 0;
+
+		}
+
+	}
+
+	update() {
+
+		if ( ! this._task ) {
+
+			this._task = renderTask.call( this );
+
+		}
+
+		this._task.next();
+
+	}
+
+}

package/src/core/PathTracingSceneGenerator.js

@@ -1,52 +1,52 @@
-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 ) {
+
+		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 ),
+		};
+
+	}
+
+}

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;
+
+	}
+
+}