three-gpu-pathtracer 0.0.5 → 0.0.7

package/src/utils/IESLoader.js

@@ -0,0 +1,325 @@
+import {
+	DataTexture,
+	FileLoader,
+	FloatType,
+	LinearFilter,
+	RedFormat,
+	MathUtils,
+	Loader,
+} from 'three';
+
+function IESLamp( text ) {
+
+	const _self = this;
+
+	const textArray = text.split( '\n' );
+
+	let lineNumber = 0;
+	let line;
+
+	_self.verAngles = [ ];
+	_self.horAngles = [ ];
+
+	_self.candelaValues = [ ];
+
+	_self.tiltData = { };
+	_self.tiltData.angles = [ ];
+	_self.tiltData.mulFactors = [ ];
+
+	function textToArray( text ) {
+
+		text = text.replace( /^\s+|\s+$/g, '' ); // remove leading or trailing spaces
+		text = text.replace( /,/g, ' ' ); // replace commas with spaces
+		text = text.replace( /\s\s+/g, ' ' ); // replace white space/tabs etc by single whitespace
+
+		const array = text.split( ' ' );
+
+		return array;
+
+	}
+
+	function readArray( count, array ) {
+
+		while ( true ) {
+
+			const line = textArray[ lineNumber ++ ];
+			const lineData = textToArray( line );
+
+			for ( let i = 0; i < lineData.length; ++ i ) {
+
+				array.push( Number( lineData[ i ] ) );
+
+			}
+
+			if ( array.length === count )
+				break;
+
+		}
+
+	}
+
+	function readTilt() {
+
+		let line = textArray[ lineNumber ++ ];
+		let lineData = textToArray( line );
+
+		_self.tiltData.lampToLumGeometry = Number( lineData[ 0 ] );
+
+		line = textArray[ lineNumber ++ ];
+		lineData = textToArray( line );
+
+		_self.tiltData.numAngles = Number( lineData[ 0 ] );
+
+		readArray( _self.tiltData.numAngles, _self.tiltData.angles );
+		readArray( _self.tiltData.numAngles, _self.tiltData.mulFactors );
+
+	}
+
+	function readLampValues() {
+
+		const values = [ ];
+		readArray( 10, values );
+
+		_self.count = Number( values[ 0 ] );
+		_self.lumens = Number( values[ 1 ] );
+		_self.multiplier = Number( values[ 2 ] );
+		_self.numVerAngles = Number( values[ 3 ] );
+		_self.numHorAngles = Number( values[ 4 ] );
+		_self.gonioType = Number( values[ 5 ] );
+		_self.units = Number( values[ 6 ] );
+		_self.width = Number( values[ 7 ] );
+		_self.length = Number( values[ 8 ] );
+		_self.height = Number( values[ 9 ] );
+
+	}
+
+	function readLampFactors() {
+
+		const values = [ ];
+		readArray( 3, values );
+
+		_self.ballFactor = Number( values[ 0 ] );
+		_self.blpFactor = Number( values[ 1 ] );
+		_self.inputWatts = Number( values[ 2 ] );
+
+	}
+
+	while ( true ) {
+
+		line = textArray[ lineNumber ++ ];
+
+		if ( line.includes( 'TILT' ) ) {
+
+			break;
+
+		}
+
+	}
+
+	if ( ! line.includes( 'NONE' ) ) {
+
+		if ( line.includes( 'INCLUDE' ) ) {
+
+			readTilt();
+
+		} else {
+
+			// TODO:: Read tilt data from a file
+
+		}
+
+	}
+
+	readLampValues();
+
+	readLampFactors();
+
+	// Initialize candela value array
+	for ( let i = 0; i < _self.numHorAngles; ++ i ) {
+
+		_self.candelaValues.push( [ ] );
+
+	}
+
+	// Parse Angles
+	readArray( _self.numVerAngles, _self.verAngles );
+	readArray( _self.numHorAngles, _self.horAngles );
+
+	// Parse Candela values
+	for ( let i = 0; i < _self.numHorAngles; ++ i ) {
+
+		readArray( _self.numVerAngles, _self.candelaValues[ i ] );
+
+	}
+
+	// Calculate actual candela values, and normalize.
+	for ( let i = 0; i < _self.numHorAngles; ++ i ) {
+
+		for ( let j = 0; j < _self.numVerAngles; ++ j ) {
+
+			_self.candelaValues[ i ][ j ] *= _self.candelaValues[ i ][ j ] * _self.multiplier
+				* _self.ballFactor * _self.blpFactor;
+
+		}
+
+	}
+
+	let maxVal = - 1;
+	for ( let i = 0; i < _self.numHorAngles; ++ i ) {
+
+		for ( let j = 0; j < _self.numVerAngles; ++ j ) {
+
+			const value = _self.candelaValues[ i ][ j ];
+			maxVal = maxVal < value ? value : maxVal;
+
+		}
+
+	}
+
+	const bNormalize = true;
+	if ( bNormalize && maxVal > 0 ) {
+
+		for ( let i = 0; i < _self.numHorAngles; ++ i ) {
+
+			for ( let j = 0; j < _self.numVerAngles; ++ j ) {
+
+				_self.candelaValues[ i ][ j ] /= maxVal;
+
+			}
+
+		}
+
+	}
+
+}
+
+export class IESLoader extends Loader {
+
+	_getIESValues( iesLamp ) {
+
+		const width = 360;
+		const height = 180;
+		const size = width * height;
+
+		const data = new Float32Array( size );
+
+		function interpolateCandelaValues( phi, theta ) {
+
+			let phiIndex = 0, thetaIndex = 0;
+			let startTheta = 0, endTheta = 0, startPhi = 0, endPhi = 0;
+
+			for ( let i = 0; i < iesLamp.numHorAngles - 1; ++ i ) { // numHorAngles = horAngles.length-1 because of extra padding, so this wont cause an out of bounds error
+
+				if ( theta < iesLamp.horAngles[ i + 1 ] || i == iesLamp.numHorAngles - 2 ) {
+
+					thetaIndex = i;
+					startTheta = iesLamp.horAngles[ i ];
+					endTheta = iesLamp.horAngles[ i + 1 ];
+
+					break;
+
+				}
+
+			}
+
+			for ( let i = 0; i < iesLamp.numVerAngles - 1; ++ i ) {
+
+				if ( phi < iesLamp.verAngles[ i + 1 ] || i == iesLamp.numVerAngles - 2 ) {
+
+					phiIndex = i;
+					startPhi = iesLamp.verAngles[ i ];
+					endPhi = iesLamp.verAngles[ i + 1 ];
+
+					break;
+
+				}
+
+			}
+
+			const deltaTheta = endTheta - startTheta;
+			const deltaPhi = endPhi - startPhi;
+
+			if ( deltaPhi === 0 ) // Outside range
+				return 0;
+
+			const t1 = deltaTheta === 0 ? 0 : ( theta - startTheta ) / deltaTheta;
+			const t2 = ( phi - startPhi ) / deltaPhi;
+
+			const nextThetaIndex = deltaTheta === 0 ? thetaIndex : thetaIndex + 1;
+
+			const v1 = MathUtils.lerp( iesLamp.candelaValues[ thetaIndex ][ phiIndex ], iesLamp.candelaValues[ nextThetaIndex ][ phiIndex ], t1 );
+			const v2 = MathUtils.lerp( iesLamp.candelaValues[ thetaIndex ][ phiIndex + 1 ], iesLamp.candelaValues[ nextThetaIndex ][ phiIndex + 1 ], t1 );
+			const v = MathUtils.lerp( v1, v2, t2 );
+
+			return v;
+
+		}
+
+		const startTheta = iesLamp.horAngles[ 0 ], endTheta = iesLamp.horAngles[ iesLamp.numHorAngles - 1 ];
+		for ( let i = 0; i < size; ++ i ) {
+
+			let theta = i % width;
+			const phi = Math.floor( i / width );
+
+			if ( endTheta - startTheta !== 0 && ( theta < startTheta || theta >= endTheta ) ) { // Handle symmetry for hor angles
+
+				theta %= endTheta * 2;
+				if ( theta > endTheta )
+					theta = endTheta * 2 - theta;
+
+			}
+
+			data[ i ] = interpolateCandelaValues( phi, theta );
+
+		}
+
+		return data;
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		const loader = new FileLoader( this.manager );
+		loader.setResponseType( 'text' );
+		loader.setCrossOrigin( this.crossOrigin );
+		loader.setWithCredentials( this.withCredentials );
+		loader.setPath( this.path );
+		loader.setRequestHeader( this.requestHeader );
+
+		const texture = new DataTexture( null, 360, 180, RedFormat, FloatType );
+		texture.minFilter = LinearFilter;
+		texture.magFilter = LinearFilter;
+
+		loader.load( url, text => {
+
+			const iesLamp = new IESLamp( text );
+
+			texture.image.data = this._getIESValues( iesLamp );
+			texture.needsUpdate = true;
+
+			if ( onLoad !== undefined ) {
+
+				onLoad( texture );
+
+			}
+
+		}, onProgress, onError );
+
+		return texture;
+
+	}
+
+	parse( text ) {
+
+		const iesLamp = new IESLamp( text );
+		const texture = new DataTexture( null, 360, 180, RedFormat, FloatType );
+		texture.minFilter = LinearFilter;
+		texture.magFilter = LinearFilter;
+		texture.image.data = this._getIESValues( iesLamp );
+		texture.needsUpdate = true;
+
+		return texture;
+
+	}
+
+}

package/src/utils/UVUnwrapper.js

@@ -1,101 +1,101 @@
-// https://github.com/mozilla/Spoke/commit/9701d647020e09d584885bd457eb225e9995c12f
-import XAtlas from 'xatlas-web';
-import { BufferGeometry, Float32BufferAttribute, Uint32BufferAttribute } from 'three';
-
-export class UVUnwrapper {
-
-	constructor() {
-
-		this._module = null;
-
-	}
-
-	async load() {
-
-		const wasmurl = new URL( '../../node_modules/xatlas-web/dist/xatlas-web.wasm', import.meta.url );
-		this._module = XAtlas( {
-
-			locateFile( path ) {
-
-				if ( path.endsWith( '.wasm' ) ) {
-
-					return wasmurl.toString();
-
-				}
-
-				return path;
-
-			}
-
-		} );
-		return this._module.ready;
-
-	}
-
-	generate( geometry ) {
-
-		const xatlas = this._module;
-		const originalVertexCount = geometry.attributes.position.count;
-		const originalIndexCount = geometry.index.count;
-
-		xatlas.createAtlas();
-
-		const meshInfo = xatlas.createMesh( originalVertexCount, originalIndexCount, true, true );
-		xatlas.HEAPU16.set( geometry.index.array, meshInfo.indexOffset / Uint16Array.BYTES_PER_ELEMENT );
-		xatlas.HEAPF32.set( geometry.attributes.position.array, meshInfo.positionOffset / Float32Array.BYTES_PER_ELEMENT );
-		xatlas.HEAPF32.set( geometry.attributes.normal.array, meshInfo.normalOffset / Float32Array.BYTES_PER_ELEMENT );
-		xatlas.HEAPF32.set( geometry.attributes.uv.array, meshInfo.uvOffset / Float32Array.BYTES_PER_ELEMENT );
-
-		const statusCode = xatlas.addMesh();
-		if ( statusCode !== AddMeshStatus.Success ) {
-
-			throw new Error( `UVUnwrapper: Error adding mesh. Status code ${ statusCode }` );
-
-		}
-
-		xatlas.generateAtlas();
-
-		const meshData = xatlas.getMeshData( meshInfo.meshId );
-		const oldPositionArray = geometry.attributes.position.array;
-		const oldNormalArray = geometry.attributes.normal.array;
-		const oldUvArray = geometry.attributes.uv.array;
-
-		const newPositionArray = new Float32Array( meshData.newVertexCount * 3 );
-		const newNormalArray = new Float32Array( meshData.newVertexCount * 3 );
-		const newUvArray = new Float32Array( meshData.newVertexCount * 2 );
-		const newUv2Array = new Float32Array( xatlas.HEAPF32.buffer, meshData.uvOffset, meshData.newVertexCount * 2 );
-		const newIndexArray = new Uint32Array( xatlas.HEAPU32.buffer, meshData.indexOffset, meshData.newIndexCount );
-		const originalIndexArray = new Uint32Array(
-			xatlas.HEAPU32.buffer,
-			meshData.originalIndexOffset,
-			meshData.newVertexCount
-		);
-
-		for ( let i = 0; i < meshData.newVertexCount; i ++ ) {
-
-			const originalIndex = originalIndexArray[ i ];
-			newPositionArray[ i * 3 ] = oldPositionArray[ originalIndex * 3 ];
-			newPositionArray[ i * 3 + 1 ] = oldPositionArray[ originalIndex * 3 + 1 ];
-			newPositionArray[ i * 3 + 2 ] = oldPositionArray[ originalIndex * 3 + 2 ];
-			newNormalArray[ i * 3 ] = oldNormalArray[ originalIndex * 3 ];
-			newNormalArray[ i * 3 + 1 ] = oldNormalArray[ originalIndex * 3 + 1 ];
-			newNormalArray[ i * 3 + 2 ] = oldNormalArray[ originalIndex * 3 + 2 ];
-			newUvArray[ i * 2 ] = oldUvArray[ originalIndex * 2 ];
-			newUvArray[ i * 2 + 1 ] = oldUvArray[ originalIndex * 2 + 1 ];
-
-		}
-
-		const newGeometry = new BufferGeometry();
-		newGeometry.addAttribute( 'position', new Float32BufferAttribute( newPositionArray, 3 ) );
-		newGeometry.addAttribute( 'normal', new Float32BufferAttribute( newNormalArray, 3 ) );
-		newGeometry.addAttribute( 'uv', new Float32BufferAttribute( newUvArray, 2 ) );
-		newGeometry.addAttribute( 'uv2', new Float32BufferAttribute( newUv2Array, 2 ) );
-		newGeometry.setIndex( new Uint32BufferAttribute( newIndexArray, 1 ) );
-
-		mesh.geometry = newGeometry;
-
-		xatlas.destroyAtlas();
-
-	}
-
-}
+// https://github.com/mozilla/Spoke/commit/9701d647020e09d584885bd457eb225e9995c12f
+import XAtlas from 'xatlas-web';
+import { BufferGeometry, Float32BufferAttribute, Uint32BufferAttribute } from 'three';
+
+export class UVUnwrapper {
+
+	constructor() {
+
+		this._module = null;
+
+	}
+
+	async load() {
+
+		const wasmurl = new URL( '../../node_modules/xatlas-web/dist/xatlas-web.wasm', import.meta.url );
+		this._module = XAtlas( {
+
+			locateFile( path ) {
+
+				if ( path.endsWith( '.wasm' ) ) {
+
+					return wasmurl.toString();
+
+				}
+
+				return path;
+
+			}
+
+		} );
+		return this._module.ready;
+
+	}
+
+	generate( geometry ) {
+
+		const xatlas = this._module;
+		const originalVertexCount = geometry.attributes.position.count;
+		const originalIndexCount = geometry.index.count;
+
+		xatlas.createAtlas();
+
+		const meshInfo = xatlas.createMesh( originalVertexCount, originalIndexCount, true, true );
+		xatlas.HEAPU16.set( geometry.index.array, meshInfo.indexOffset / Uint16Array.BYTES_PER_ELEMENT );
+		xatlas.HEAPF32.set( geometry.attributes.position.array, meshInfo.positionOffset / Float32Array.BYTES_PER_ELEMENT );
+		xatlas.HEAPF32.set( geometry.attributes.normal.array, meshInfo.normalOffset / Float32Array.BYTES_PER_ELEMENT );
+		xatlas.HEAPF32.set( geometry.attributes.uv.array, meshInfo.uvOffset / Float32Array.BYTES_PER_ELEMENT );
+
+		const statusCode = xatlas.addMesh();
+		if ( statusCode !== AddMeshStatus.Success ) {
+
+			throw new Error( `UVUnwrapper: Error adding mesh. Status code ${ statusCode }` );
+
+		}
+
+		xatlas.generateAtlas();
+
+		const meshData = xatlas.getMeshData( meshInfo.meshId );
+		const oldPositionArray = geometry.attributes.position.array;
+		const oldNormalArray = geometry.attributes.normal.array;
+		const oldUvArray = geometry.attributes.uv.array;
+
+		const newPositionArray = new Float32Array( meshData.newVertexCount * 3 );
+		const newNormalArray = new Float32Array( meshData.newVertexCount * 3 );
+		const newUvArray = new Float32Array( meshData.newVertexCount * 2 );
+		const newUv2Array = new Float32Array( xatlas.HEAPF32.buffer, meshData.uvOffset, meshData.newVertexCount * 2 );
+		const newIndexArray = new Uint32Array( xatlas.HEAPU32.buffer, meshData.indexOffset, meshData.newIndexCount );
+		const originalIndexArray = new Uint32Array(
+			xatlas.HEAPU32.buffer,
+			meshData.originalIndexOffset,
+			meshData.newVertexCount
+		);
+
+		for ( let i = 0; i < meshData.newVertexCount; i ++ ) {
+
+			const originalIndex = originalIndexArray[ i ];
+			newPositionArray[ i * 3 ] = oldPositionArray[ originalIndex * 3 ];
+			newPositionArray[ i * 3 + 1 ] = oldPositionArray[ originalIndex * 3 + 1 ];
+			newPositionArray[ i * 3 + 2 ] = oldPositionArray[ originalIndex * 3 + 2 ];
+			newNormalArray[ i * 3 ] = oldNormalArray[ originalIndex * 3 ];
+			newNormalArray[ i * 3 + 1 ] = oldNormalArray[ originalIndex * 3 + 1 ];
+			newNormalArray[ i * 3 + 2 ] = oldNormalArray[ originalIndex * 3 + 2 ];
+			newUvArray[ i * 2 ] = oldUvArray[ originalIndex * 2 ];
+			newUvArray[ i * 2 + 1 ] = oldUvArray[ originalIndex * 2 + 1 ];
+
+		}
+
+		const newGeometry = new BufferGeometry();
+		newGeometry.addAttribute( 'position', new Float32BufferAttribute( newPositionArray, 3 ) );
+		newGeometry.addAttribute( 'normal', new Float32BufferAttribute( newNormalArray, 3 ) );
+		newGeometry.addAttribute( 'uv', new Float32BufferAttribute( newUvArray, 2 ) );
+		newGeometry.addAttribute( 'uv2', new Float32BufferAttribute( newUv2Array, 2 ) );
+		newGeometry.setIndex( new Uint32BufferAttribute( newIndexArray, 1 ) );
+
+		mesh.geometry = newGeometry;
+
+		xatlas.destroyAtlas();
+
+	}
+
+}

package/src/workers/PathTracingSceneWorker.js

@@ -1,41 +1,42 @@
-import { PathTracingSceneGenerator } from '../core/PathTracingSceneGenerator.js';
-import { SAH } from 'three-mesh-bvh';
-import { GenerateMeshBVHWorker } from 'three-mesh-bvh/src/workers/GenerateMeshBVHWorker.js';
-
-export class PathTracingSceneWorker extends PathTracingSceneGenerator {
-
-	constructor() {
-
-		super();
-		this.bvhGenerator = new GenerateMeshBVHWorker();
-
-	}
-
-	generate( scene, options = {} ) {
-
-		const { bvhGenerator } = this;
-		const { geometry, materials, textures, lights } = this.prepScene( scene );
-
-		const bvhOptions = { strategy: SAH, ...options, maxLeafTris: 1 };
-		const bvhPromise = bvhGenerator.generate( geometry, bvhOptions );
-		return bvhPromise.then( bvh => {
-
-			return {
-				scene,
-				materials,
-				textures,
-				lights,
-				bvh,
-			};
-
-		} );
-
-	}
-
-	dispose() {
-
-		this.bvhGenerator.dispose();
-
-	}
-
-}
+import { PathTracingSceneGenerator } from '../core/PathTracingSceneGenerator.js';
+import { SAH } from 'three-mesh-bvh';
+import { GenerateMeshBVHWorker } from 'three-mesh-bvh/src/workers/GenerateMeshBVHWorker.js';
+
+export class PathTracingSceneWorker extends PathTracingSceneGenerator {
+
+	constructor() {
+
+		super();
+		this.bvhGenerator = new GenerateMeshBVHWorker();
+
+	}
+
+	generate( scene, options = {} ) {
+
+		const { bvhGenerator } = this;
+		const { geometry, materials, textures, lights, spotLights } = this.prepScene( scene );
+
+		const bvhOptions = { strategy: SAH, ...options, maxLeafTris: 1 };
+		const bvhPromise = bvhGenerator.generate( geometry, bvhOptions );
+		return bvhPromise.then( bvh => {
+
+			return {
+				scene,
+				materials,
+				textures,
+				lights,
+				spotLights,
+				bvh,
+			};
+
+		} );
+
+	}
+
+	dispose() {
+
+		this.bvhGenerator.dispose();
+
+	}
+
+}

package/src/uniforms/LightsTexture.js

@@ -1,83 +0,0 @@
-import { DataTexture, RGBAFormat, ClampToEdgeWrapping, FloatType, Vector3, Quaternion } from 'three';
-
-const LIGHT_PIXELS = 4;
-
-export class LightsTexture extends DataTexture {
-
-	constructor() {
-
-		super( new Float32Array( 4 ), 1, 1 );
-
-		this.format = RGBAFormat;
-		this.type = FloatType;
-		this.wrapS = ClampToEdgeWrapping;
-		this.wrapT = ClampToEdgeWrapping;
-		this.generateMipmaps = false;
-
-	}
-
-	updateFrom( lights ) {
-
-		let index = 0;
-		const pixelCount = lights.length * LIGHT_PIXELS;
-		const dimension = Math.ceil( Math.sqrt( pixelCount ) );
-
-		if ( this.image.width !== dimension ) {
-
-			this.dispose();
-
-			this.image.data = new Float32Array( dimension * dimension * 4 );
-			this.image.width = dimension;
-			this.image.height = dimension;
-
-		}
-
-		const floatArray = this.image.data;
-
-		const u = new Vector3();
-		const v = new Vector3();
-		const worldQuaternion = new Quaternion();
-
-		for ( let i = 0, l = lights.length; i < l; i ++ ) {
-
-			const l = lights[ i ];
-
-			// position
-			l.getWorldPosition( v );
-			floatArray[ index ++ ] = v.x;
-			floatArray[ index ++ ] = v.y;
-			floatArray[ index ++ ] = v.z;
-			index ++;
-
-			// color
-			floatArray[ index ++ ] = l.color.r;
-			floatArray[ index ++ ] = l.color.g;
-			floatArray[ index ++ ] = l.color.b;
-
-			// intensity
-			floatArray[ index ++ ] = l.intensity;
-
-			// u vector
-			l.getWorldQuaternion( worldQuaternion );
-			u.set( l.width, 0, 0 ).applyQuaternion( worldQuaternion );
-			floatArray[ index ++ ] = u.x;
-			floatArray[ index ++ ] = u.y;
-			floatArray[ index ++ ] = u.z;
-			index ++;
-
-			// v vector
-			v.set( 0, l.height, 0 ).applyQuaternion( worldQuaternion );
-			floatArray[ index ++ ] = v.x;
-			floatArray[ index ++ ] = v.y;
-			floatArray[ index ++ ] = v.z;
-
-			// area
-			floatArray[ index ++ ] = u.cross( v ).length();
-
-		}
-
-		this.needsUpdate = true;
-
-	}
-
-}