three-gpu-pathtracer 0.0.5 → 0.0.6

package/src/utils/GeometryPreparationUtils.js

@@ -1,194 +1,194 @@
-import { BufferAttribute } from 'three';
-import { mergeBufferGeometries, mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
-export function getGroupMaterialIndicesAttribute( geometry, materials, allMaterials ) {
-
-	const indexAttr = geometry.index;
-	const posAttr = geometry.attributes.position;
-	const vertCount = posAttr.count;
-	const materialArray = new Uint8Array( vertCount );
-	const totalCount = indexAttr ? indexAttr.count : vertCount;
-	let groups = geometry.groups;
-	if ( groups.length === 0 ) {
-
-		groups = [ { count: totalCount, start: 0, materialIndex: 0 } ];
-
-	}
-
-	for ( let i = 0; i < groups.length; i ++ ) {
-
-		const group = groups[ i ];
-		const start = group.start;
-		const count = group.count;
-		const endCount = Math.min( count, totalCount - start );
-
-		const mat = Array.isArray( materials ) ? materials[ group.materialIndex ] : materials;
-		const materialIndex = allMaterials.indexOf( mat );
-
-		for ( let j = 0; j < endCount; j ++ ) {
-
-			let index = start + j;
-			if ( indexAttr ) {
-
-				index = indexAttr.getX( index );
-
-			}
-
-			materialArray[ index ] = materialIndex;
-
-		}
-
-	}
-
-	return new BufferAttribute( materialArray, 1, false );
-
-}
-
-export function trimToAttributes( geometry, attributes ) {
-
-	// trim any unneeded attributes
-	if ( attributes ) {
-
-		for ( const key in geometry.attributes ) {
-
-			if ( ! attributes.includes( key ) ) {
-
-				geometry.deleteAttribute( key );
-
-			}
-
-		}
-
-	}
-
-}
-
-export function setCommonAttributes( geometry, options ) {
-
-	const { attributes = [], normalMapRequired = false } = options;
-
-	if ( ! geometry.attributes.normal && ( attributes && attributes.includes( 'normal' ) ) ) {
-
-		geometry.computeVertexNormals();
-
-	}
-
-	if ( ! geometry.attributes.uv && ( attributes && attributes.includes( 'uv' ) ) ) {
-
-		const vertCount = geometry.attributes.position.count;
-		geometry.setAttribute( 'uv', new BufferAttribute( new Float32Array( vertCount * 2 ), 2, false ) );
-
-	}
-
-	if ( ! geometry.attributes.tangent && ( attributes && attributes.includes( 'tangent' ) ) ) {
-
-		if ( normalMapRequired ) {
-
-			// computeTangents requires an index buffer
-			if ( geometry.index === null ) {
-
-				geometry = mergeVertices( geometry );
-
-			}
-
-			geometry.computeTangents();
-
-		} else {
-
-			const vertCount = geometry.attributes.position.count;
-			geometry.setAttribute( 'tangent', new BufferAttribute( new Float32Array( vertCount * 4 ), 4, false ) );
-
-		}
-
-	}
-
-	if ( ! geometry.index ) {
-
-		// TODO: compute a typed array
-		const indexCount = geometry.attributes.position.count;
-		const array = new Array( indexCount );
-		for ( let i = 0; i < indexCount; i ++ ) {
-
-			array[ i ] = i;
-
-		}
-
-		geometry.setIndex( array );
-
-	}
-
-}
-
-export function mergeMeshes( meshes, options = {} ) {
-
-	options = { attributes: null, cloneGeometry: true, ...options };
-
-	const transformedGeometry = [];
-	const materialSet = new Set();
-	for ( let i = 0, l = meshes.length; i < l; i ++ ) {
-
-		// save any materials
-		const mesh = meshes[ i ];
-		if ( mesh.visible === false ) continue;
-
-		if ( Array.isArray( mesh.material ) ) {
-
-			mesh.material.forEach( m => materialSet.add( m ) );
-
-		} else {
-
-			materialSet.add( mesh.material );
-
-		}
-
-	}
-
-	const materials = Array.from( materialSet );
-	for ( let i = 0, l = meshes.length; i < l; i ++ ) {
-
-		// ensure the matrix world is up to date
-		const mesh = meshes[ i ];
-		if ( mesh.visible === false ) continue;
-
-		mesh.updateMatrixWorld();
-
-		// apply the matrix world to the geometry
-		const originalGeometry = meshes[ i ].geometry;
-		const geometry = options.cloneGeometry ? originalGeometry.clone() : originalGeometry;
-		geometry.applyMatrix4( mesh.matrixWorld );
-
-		// ensure our geometry has common attributes
-		setCommonAttributes( geometry, {
-			attributes: options.attributes,
-			normalMapRequired: ! ! mesh.material.normalMap,
-		} );
-		trimToAttributes( geometry, options.attributes );
-
-		// create the material index attribute
-		const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, mesh.material, materials );
-		geometry.setAttribute( 'materialIndex', materialIndexAttribute );
-
-		transformedGeometry.push( geometry );
-
-	}
-
-	const textureSet = new Set();
-	materials.forEach( material => {
-
-		for ( const key in material ) {
-
-			const value = material[ key ];
-			if ( value && value.isTexture ) {
-
-				textureSet.add( value );
-
-			}
-
-		}
-
-	} );
-
-	const geometry = mergeBufferGeometries( transformedGeometry, false );
-	const textures = Array.from( textureSet );
-	return { geometry, materials, textures };
-
-}
+import { BufferAttribute } from 'three';
+import { mergeBufferGeometries, mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+export function getGroupMaterialIndicesAttribute( geometry, materials, allMaterials ) {
+
+	const indexAttr = geometry.index;
+	const posAttr = geometry.attributes.position;
+	const vertCount = posAttr.count;
+	const materialArray = new Uint8Array( vertCount );
+	const totalCount = indexAttr ? indexAttr.count : vertCount;
+	let groups = geometry.groups;
+	if ( groups.length === 0 ) {
+
+		groups = [ { count: totalCount, start: 0, materialIndex: 0 } ];
+
+	}
+
+	for ( let i = 0; i < groups.length; i ++ ) {
+
+		const group = groups[ i ];
+		const start = group.start;
+		const count = group.count;
+		const endCount = Math.min( count, totalCount - start );
+
+		const mat = Array.isArray( materials ) ? materials[ group.materialIndex ] : materials;
+		const materialIndex = allMaterials.indexOf( mat );
+
+		for ( let j = 0; j < endCount; j ++ ) {
+
+			let index = start + j;
+			if ( indexAttr ) {
+
+				index = indexAttr.getX( index );
+
+			}
+
+			materialArray[ index ] = materialIndex;
+
+		}
+
+	}
+
+	return new BufferAttribute( materialArray, 1, false );
+
+}
+
+export function trimToAttributes( geometry, attributes ) {
+
+	// trim any unneeded attributes
+	if ( attributes ) {
+
+		for ( const key in geometry.attributes ) {
+
+			if ( ! attributes.includes( key ) ) {
+
+				geometry.deleteAttribute( key );
+
+			}
+
+		}
+
+	}
+
+}
+
+export function setCommonAttributes( geometry, options ) {
+
+	const { attributes = [], normalMapRequired = false } = options;
+
+	if ( ! geometry.attributes.normal && ( attributes && attributes.includes( 'normal' ) ) ) {
+
+		geometry.computeVertexNormals();
+
+	}
+
+	if ( ! geometry.attributes.uv && ( attributes && attributes.includes( 'uv' ) ) ) {
+
+		const vertCount = geometry.attributes.position.count;
+		geometry.setAttribute( 'uv', new BufferAttribute( new Float32Array( vertCount * 2 ), 2, false ) );
+
+	}
+
+	if ( ! geometry.attributes.tangent && ( attributes && attributes.includes( 'tangent' ) ) ) {
+
+		if ( normalMapRequired ) {
+
+			// computeTangents requires an index buffer
+			if ( geometry.index === null ) {
+
+				geometry = mergeVertices( geometry );
+
+			}
+
+			geometry.computeTangents();
+
+		} else {
+
+			const vertCount = geometry.attributes.position.count;
+			geometry.setAttribute( 'tangent', new BufferAttribute( new Float32Array( vertCount * 4 ), 4, false ) );
+
+		}
+
+	}
+
+	if ( ! geometry.index ) {
+
+		// TODO: compute a typed array
+		const indexCount = geometry.attributes.position.count;
+		const array = new Array( indexCount );
+		for ( let i = 0; i < indexCount; i ++ ) {
+
+			array[ i ] = i;
+
+		}
+
+		geometry.setIndex( array );
+
+	}
+
+}
+
+export function mergeMeshes( meshes, options = {} ) {
+
+	options = { attributes: null, cloneGeometry: true, ...options };
+
+	const transformedGeometry = [];
+	const materialSet = new Set();
+	for ( let i = 0, l = meshes.length; i < l; i ++ ) {
+
+		// save any materials
+		const mesh = meshes[ i ];
+		if ( mesh.visible === false ) continue;
+
+		if ( Array.isArray( mesh.material ) ) {
+
+			mesh.material.forEach( m => materialSet.add( m ) );
+
+		} else {
+
+			materialSet.add( mesh.material );
+
+		}
+
+	}
+
+	const materials = Array.from( materialSet );
+	for ( let i = 0, l = meshes.length; i < l; i ++ ) {
+
+		// ensure the matrix world is up to date
+		const mesh = meshes[ i ];
+		if ( mesh.visible === false ) continue;
+
+		mesh.updateMatrixWorld();
+
+		// apply the matrix world to the geometry
+		const originalGeometry = meshes[ i ].geometry;
+		const geometry = options.cloneGeometry ? originalGeometry.clone() : originalGeometry;
+		geometry.applyMatrix4( mesh.matrixWorld );
+
+		// ensure our geometry has common attributes
+		setCommonAttributes( geometry, {
+			attributes: options.attributes,
+			normalMapRequired: ! ! mesh.material.normalMap,
+		} );
+		trimToAttributes( geometry, options.attributes );
+
+		// create the material index attribute
+		const materialIndexAttribute = getGroupMaterialIndicesAttribute( geometry, mesh.material, materials );
+		geometry.setAttribute( 'materialIndex', materialIndexAttribute );
+
+		transformedGeometry.push( geometry );
+
+	}
+
+	const textureSet = new Set();
+	materials.forEach( material => {
+
+		for ( const key in material ) {
+
+			const value = material[ key ];
+			if ( value && value.isTexture ) {
+
+				textureSet.add( value );
+
+			}
+
+		}
+
+	} );
+
+	const geometry = mergeBufferGeometries( transformedGeometry, false );
+	const textures = Array.from( textureSet );
+	return { geometry, materials, textures };
+
+}

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