three-gpu-pathtracer 0.0.14 → 0.0.16

package/src/core/PathTracingSceneGenerator.js

@@ -1,69 +1,69 @@
-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 ].traverseVisible( c => {
-
-				if ( c.isSkinnedMesh || c.isMesh && c.morphTargetInfluences ) {
-
-					const generator = new StaticGeometryGenerator( c );
-					generator.attributes = [ 'position', 'color', 'normal', 'tangent', 'uv', 'uv2' ];
-					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 || c.isSpotLight || c.isDirectionalLight || c.isPointLight ) {
-
-					lights.push( c );
-
-				}
-
-			} );
-
-		}
-
-		return {
-			...mergeMeshes( meshes, {
-				attributes: [ 'position', 'normal', 'tangent', 'uv', 'color' ],
-			} ),
-			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 ),
-		};
-
-	}
-
-}
+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 ].traverseVisible( c => {
+
+				if ( c.isSkinnedMesh || c.isMesh && c.morphTargetInfluences ) {
+
+					const generator = new StaticGeometryGenerator( c );
+					generator.attributes = [ 'position', 'color', 'normal', 'tangent', 'uv', 'uv2' ];
+					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 || c.isSpotLight || c.isDirectionalLight || c.isPointLight ) {
+
+					lights.push( c );
+
+				}
+
+			} );
+
+		}
+
+		return {
+			...mergeMeshes( meshes, {
+				attributes: [ 'position', 'normal', 'tangent', 'uv', 'color' ],
+			} ),
+			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/QuiltPathTracingRenderer.js

@@ -1,223 +1,223 @@
-import { PerspectiveCamera, Vector3, MathUtils, Vector2, Matrix4, Vector4 } from 'three';
-import { PathTracingRenderer } from './PathTracingRenderer.js';
-
-function* _task( cb ) {
-
-	const {
-		viewCount,
-		_camera,
-		_quiltUtility,
-		_subframe,
-	} = this;
-
-	const quiltViewInfo = {
-		subframe: _subframe,
-		projectionMatrix: _camera.projectionMatrix,
-		offsetDirection: new Vector3(),
-	};
-
-	while ( true ) {
-
-		for ( let i = 0; i < viewCount; i ++ ) {
-
-			// get the camera info for the current view index
-			_quiltUtility.near = this.camera.near;
-			_quiltUtility.far = this.camera.far;
-			_quiltUtility.getCameraViewInfo( i, quiltViewInfo );
-
-			// transform offset into world frame from camera frame
-			quiltViewInfo.offsetDirection.transformDirection( this.camera.matrixWorld );
-
-			// adjust the render camera with the view offset
-			this.camera.matrixWorld.decompose(
-				_camera.position,
-				_camera.quaternion,
-				_camera.scale,
-			);
-			_camera.position.addScaledVector( quiltViewInfo.offsetDirection, quiltViewInfo.offset );
-			_camera.updateMatrixWorld();
-
-			// get the inverse projection
-			_camera.projectionMatrixInverse
-				.copy( _camera.projectionMatrix )
-				.invert();
-
-			this._opacityFactor = Math.floor( this._samples + 1 ) / Math.floor( this._quiltSamples + 1 );
-
-			do {
-
-				const ogCamera = this.camera;
-				this.camera = _camera;
-				cb();
-				this.camera = ogCamera;
-				yield;
-
-			} while ( this._samples % 1 !== 0 );
-
-			this._quiltSamples += 1 / viewCount;
-
-		}
-
-		this._quiltSamples = Math.round( this._quiltSamples );
-
-	}
-
-}
-
-// Helper for extracting the camera projection, offset, and quilt subframe needed
-// for rendering a quilt with the provided parameters.
-class QuiltViewUtility {
-
-	constructor() {
-
-		this.viewCount = 48;
-		this.quiltDimensions = new Vector2( 8, 6 );
-		this.viewCone = 35 * MathUtils.DEG2RAD;
-		this.viewFoV = 14 * MathUtils.DEG2RAD;
-		this.displayDistance = 1;
-		this.displayAspect = 0.75;
-		this.near = 0.01;
-		this.far = 10;
-
-	}
-
-	getCameraViewInfo( i, target = {} ) {
-
-		const {
-			quiltDimensions,
-			viewCone,
-			displayDistance,
-			viewCount,
-			viewFoV,
-			displayAspect,
-			near,
-			far,
-		} = this;
-
-		// initialize defaults
-		target.subframe = target.subframe || new Vector4();
-		target.offsetDirection = target.offsetDirection || new Vector3();
-		target.projectionMatrix	= target.projectionMatrix || new Matrix4();
-
-		// set camera offset
-		const halfWidth = Math.tan( 0.5 * viewCone ) * displayDistance;
-		const totalWidth = halfWidth * 2.0;
-		const stride = totalWidth / ( viewCount - 1 );
-		const offset = viewCount === 1 ? 0 : - halfWidth + stride * i;
-		target.offsetDirection.set( 1.0, 0, 0 );
-		target.offset = offset;
-
-		// set the projection matrix
-		const displayHalfHeight = Math.tan( viewFoV * 0.5 ) * displayDistance;
-		const displayHalfWidth = displayAspect * displayHalfHeight;
-		const nearScale = near / displayDistance;
-
-		target.projectionMatrix.makePerspective(
-			nearScale * ( - displayHalfWidth - offset ), nearScale * ( displayHalfWidth - offset ),
-			nearScale * displayHalfHeight, nearScale * - displayHalfHeight,
-			near, far,
-		);
-
-		// set the quilt subframe
-		const x = i % quiltDimensions.x;
-		const y = Math.floor( i / quiltDimensions.x );
-
-		const qw = 1 / quiltDimensions.x;
-		const qh = 1 / quiltDimensions.y;
-		target.subframe.set( x * qw, y * qh, qw, qh );
-
-		return target;
-
-	}
-
-	setFromDisplayView( viewerDistance, displayWidth, displayHeight ) {
-
-		this.displayAspect = displayWidth / displayHeight;
-		this.displayDistance = viewerDistance;
-		this.viewFoV = 2.0 * Math.atan( 0.5 * displayHeight / viewerDistance );
-
-	}
-
-}
-
-export class QuiltPathTracingRenderer extends PathTracingRenderer {
-
-	get samples() {
-
-		return this._samples / this.viewCount;
-
-	}
-
-	constructor( ...args ) {
-
-		super( ...args );
-
-		[
-			'quiltDimensions',
-			'viewCount',
-			'viewCone',
-			'viewFoV',
-			'displayDistance',
-			'displayAspect',
-		].forEach( member => {
-
-			Object.defineProperty( this, member, {
-
-				enumerable: true,
-
-				set: v => {
-
-					this._quiltUtility[ member ] = v;
-
-				},
-
-				get: () => {
-
-					return this._quiltUtility[ member ];
-
-				}
-
-			} );
-
-		} );
-
-
-		this._quiltUtility = new QuiltViewUtility();
-		this._quiltSamples = 0;
-		this._camera = new PerspectiveCamera();
-		this._quiltTask = null;
-
-	}
-
-	setFromDisplayView( ...args ) {
-
-		this._quiltUtility.setFromDisplayView( ...args );
-
-	}
-
-	update() {
-
-		this.alpha = false;
-		if ( ! this._quiltTask ) {
-
-			this._quiltTask = _task.call( this, () => {
-
-				super.update();
-
-			} );
-
-		}
-
-		this._quiltTask.next();
-
-	}
-
-	reset() {
-
-		super.reset();
-		this._quiltTask = null;
-		this._quiltSamples = 0;
-
-	}
-
-}
+import { PerspectiveCamera, Vector3, MathUtils, Vector2, Matrix4, Vector4 } from 'three';
+import { PathTracingRenderer } from './PathTracingRenderer.js';
+
+function* _task( cb ) {
+
+	const {
+		viewCount,
+		_camera,
+		_quiltUtility,
+		_subframe,
+	} = this;
+
+	const quiltViewInfo = {
+		subframe: _subframe,
+		projectionMatrix: _camera.projectionMatrix,
+		offsetDirection: new Vector3(),
+	};
+
+	while ( true ) {
+
+		for ( let i = 0; i < viewCount; i ++ ) {
+
+			// get the camera info for the current view index
+			_quiltUtility.near = this.camera.near;
+			_quiltUtility.far = this.camera.far;
+			_quiltUtility.getCameraViewInfo( i, quiltViewInfo );
+
+			// transform offset into world frame from camera frame
+			quiltViewInfo.offsetDirection.transformDirection( this.camera.matrixWorld );
+
+			// adjust the render camera with the view offset
+			this.camera.matrixWorld.decompose(
+				_camera.position,
+				_camera.quaternion,
+				_camera.scale,
+			);
+			_camera.position.addScaledVector( quiltViewInfo.offsetDirection, quiltViewInfo.offset );
+			_camera.updateMatrixWorld();
+
+			// get the inverse projection
+			_camera.projectionMatrixInverse
+				.copy( _camera.projectionMatrix )
+				.invert();
+
+			this._opacityFactor = Math.floor( this._samples + 1 ) / Math.floor( this._quiltSamples + 1 );
+
+			do {
+
+				const ogCamera = this.camera;
+				this.camera = _camera;
+				cb();
+				this.camera = ogCamera;
+				yield;
+
+			} while ( this._samples % 1 !== 0 );
+
+			this._quiltSamples += 1 / viewCount;
+
+		}
+
+		this._quiltSamples = Math.round( this._quiltSamples );
+
+	}
+
+}
+
+// Helper for extracting the camera projection, offset, and quilt subframe needed
+// for rendering a quilt with the provided parameters.
+class QuiltViewUtility {
+
+	constructor() {
+
+		this.viewCount = 48;
+		this.quiltDimensions = new Vector2( 8, 6 );
+		this.viewCone = 35 * MathUtils.DEG2RAD;
+		this.viewFoV = 14 * MathUtils.DEG2RAD;
+		this.displayDistance = 1;
+		this.displayAspect = 0.75;
+		this.near = 0.01;
+		this.far = 10;
+
+	}
+
+	getCameraViewInfo( i, target = {} ) {
+
+		const {
+			quiltDimensions,
+			viewCone,
+			displayDistance,
+			viewCount,
+			viewFoV,
+			displayAspect,
+			near,
+			far,
+		} = this;
+
+		// initialize defaults
+		target.subframe = target.subframe || new Vector4();
+		target.offsetDirection = target.offsetDirection || new Vector3();
+		target.projectionMatrix	= target.projectionMatrix || new Matrix4();
+
+		// set camera offset
+		const halfWidth = Math.tan( 0.5 * viewCone ) * displayDistance;
+		const totalWidth = halfWidth * 2.0;
+		const stride = totalWidth / ( viewCount - 1 );
+		const offset = viewCount === 1 ? 0 : - halfWidth + stride * i;
+		target.offsetDirection.set( 1.0, 0, 0 );
+		target.offset = offset;
+
+		// set the projection matrix
+		const displayHalfHeight = Math.tan( viewFoV * 0.5 ) * displayDistance;
+		const displayHalfWidth = displayAspect * displayHalfHeight;
+		const nearScale = near / displayDistance;
+
+		target.projectionMatrix.makePerspective(
+			nearScale * ( - displayHalfWidth - offset ), nearScale * ( displayHalfWidth - offset ),
+			nearScale * displayHalfHeight, nearScale * - displayHalfHeight,
+			near, far,
+		);
+
+		// set the quilt subframe
+		const x = i % quiltDimensions.x;
+		const y = Math.floor( i / quiltDimensions.x );
+
+		const qw = 1 / quiltDimensions.x;
+		const qh = 1 / quiltDimensions.y;
+		target.subframe.set( x * qw, y * qh, qw, qh );
+
+		return target;
+
+	}
+
+	setFromDisplayView( viewerDistance, displayWidth, displayHeight ) {
+
+		this.displayAspect = displayWidth / displayHeight;
+		this.displayDistance = viewerDistance;
+		this.viewFoV = 2.0 * Math.atan( 0.5 * displayHeight / viewerDistance );
+
+	}
+
+}
+
+export class QuiltPathTracingRenderer extends PathTracingRenderer {
+
+	get samples() {
+
+		return this._samples / this.viewCount;
+
+	}
+
+	constructor( ...args ) {
+
+		super( ...args );
+
+		[
+			'quiltDimensions',
+			'viewCount',
+			'viewCone',
+			'viewFoV',
+			'displayDistance',
+			'displayAspect',
+		].forEach( member => {
+
+			Object.defineProperty( this, member, {
+
+				enumerable: true,
+
+				set: v => {
+
+					this._quiltUtility[ member ] = v;
+
+				},
+
+				get: () => {
+
+					return this._quiltUtility[ member ];
+
+				}
+
+			} );
+
+		} );
+
+
+		this._quiltUtility = new QuiltViewUtility();
+		this._quiltSamples = 0;
+		this._camera = new PerspectiveCamera();
+		this._quiltTask = null;
+
+	}
+
+	setFromDisplayView( ...args ) {
+
+		this._quiltUtility.setFromDisplayView( ...args );
+
+	}
+
+	update() {
+
+		this.alpha = false;
+		if ( ! this._quiltTask ) {
+
+			this._quiltTask = _task.call( this, () => {
+
+				super.update();
+
+			} );
+
+		}
+
+		this._quiltTask.next();
+
+	}
+
+	reset() {
+
+		super.reset();
+		this._quiltTask = null;
+		this._quiltSamples = 0;
+
+	}
+
+}

package/src/detectors/CompatibilityDetector.js

@@ -0,0 +1,38 @@
+import { PrecisionDetector } from './PrecisionDetector.js';
+import { MaterialCompileDetector } from './MaterialCompileDetector.js';
+export class CompatibilityDetector {
+
+	constructor( renderer, material ) {
+
+		this._renderer = renderer;
+		this._material = material;
+
+	}
+
+	detect() {
+
+		let detector = new PrecisionDetector( this._renderer );
+		let result = detector.detect();
+		if ( ! result.pass ) {
+
+			return result;
+
+		}
+
+		detector = new MaterialCompileDetector( this._renderer );
+		result = detector.detect( this._material );
+		if ( ! result.pass ) {
+
+			return result;
+
+		}
+
+		return {
+			detail: {},
+			pass: true,
+			message: '',
+		};
+
+	}
+
+}

package/src/detectors/MaterialCompileDetector.js

@@ -0,0 +1,50 @@
+import { Mesh, BoxGeometry, PerspectiveCamera } from 'three';
+
+// Returns whether a material can be compiled and run on the current device or not
+export class MaterialCompileDetector {
+
+	constructor( renderer ) {
+
+		this._renderer = renderer;
+
+	}
+
+	detect( material ) {
+
+		const renderer = this._renderer;
+		const mesh = new Mesh( new BoxGeometry(), material );
+		const camera = new PerspectiveCamera();
+		const ogShaderErrors = renderer.debug.checkShaderErrors;
+		renderer.debug.checkShaderErrors = true;
+
+		const programs = renderer.info.programs;
+		const progLength = programs.length;
+		renderer.compile( mesh, camera );
+
+		renderer.debug.checkShaderErrors = ogShaderErrors;
+		mesh.geometry.dispose();
+
+		if ( programs.length === progLength ) {
+
+			return {
+				detail: null,
+				pass: true,
+				message: 'Cannot determine shader compilation status if material has already been used.',
+			};
+
+		} else {
+
+			const program = programs[ programs.length - 1 ];
+			const pass = program.diagnostics ? program.diagnostics.runnable : true;
+			const message = pass ? '' : `Cannot render ${ material.type } on this device.`;
+			return {
+				detail: {},
+				pass,
+				message,
+			};
+
+		}
+
+	}
+
+}