three-gpu-pathtracer 0.0.7 → 0.0.8

package/src/uniforms/FloatAttributeTextureArray.js

@@ -0,0 +1,169 @@
+import { DataArrayTexture, FloatType, RGBAFormat } from 'three';
+import { FloatVertexAttributeTexture } from 'three-mesh-bvh';
+
+function copyArrayToArray( fromArray, fromStride, toArray, toStride, offset ) {
+
+	if ( fromStride > toStride ) {
+
+		throw new Error();
+
+	}
+
+	// scale non-float values to their normalized range
+	const count = fromArray.length / fromStride;
+	const bpe = fromArray.constructor.BYTES_PER_ELEMENT * 8;
+	let maxValue = 1.0;
+	switch ( fromArray.constructor ) {
+
+	case Uint8Array:
+	case Uint16Array:
+	case Uint32Array:
+		maxValue = 2 ** bpe - 1;
+		break;
+
+	case Int8Array:
+	case Int16Array:
+	case Int32Array:
+		maxValue = 2 ** ( bpe - 1 ) - 1;
+		break;
+
+	}
+
+	for ( let i = 0; i < count; i ++ ) {
+
+		const i4 = 4 * i;
+		const is = fromStride * i;
+		for ( let j = 0; j < toStride; j ++ ) {
+
+			toArray[ offset + i4 + j ] = fromStride >= j + 1 ? fromArray[ is + j ] / maxValue : 0;
+
+		}
+
+	}
+
+}
+
+export class FloatAttributeTextureArray extends DataArrayTexture {
+
+	constructor() {
+
+		super();
+		this._textures = [];
+		this.type = FloatType;
+		this.format = RGBAFormat;
+		this.internalFormat = 'RGBA32F';
+
+	}
+
+	updateAttribute( index, attr ) {
+
+		// update the texture
+		const tex = this._textures[ index ];
+		tex.updateFrom( attr );
+
+		// ensure compatibility
+		const baseImage = tex.image;
+		const image = this.image;
+		if ( baseImage.width !== image.width || baseImage.height !== image.height ) {
+
+			throw new Error( 'FloatAttributeTextureArray: Attribute must be the same dimensions when updating single layer.' );
+
+		}
+
+		// update the image
+		const { width, height, data } = image;
+		const length = width * height * 4;
+		const offset = length * index;
+		let itemSize = attr.itemSize;
+		if ( itemSize === 3 ) {
+
+			itemSize = 4;
+
+		}
+
+		// copy the data
+		copyArrayToArray( tex.image.data, itemSize, data, 4, offset );
+
+		this.dispose();
+		this.needsUpdate = true;
+
+	}
+
+	setAttributes( attrs ) {
+
+		// ensure the attribute count
+		const itemCount = attrs[ 0 ].count;
+		const attrsLength = attrs.length;
+		for ( let i = 0, l = attrsLength; i < l; i ++ ) {
+
+			if ( attrs[ i ].count !== itemCount ) {
+
+				throw new Error( 'FloatAttributeTextureArray: All attributes must have the same item count.' );
+
+			}
+
+		}
+
+		// initialize all textures
+		const textures = this._textures;
+		while ( textures.length < attrsLength ) {
+
+			const tex = new FloatVertexAttributeTexture();
+			textures.push( tex );
+
+		}
+
+		while ( textures.length > attrsLength ) {
+
+			textures.pop();
+
+		}
+
+		// update all textures
+		for ( let i = 0, l = attrsLength; i < l; i ++ ) {
+
+			textures[ i ].updateFrom( attrs[ i ] );
+
+		}
+
+		// determine if we need to create a new array
+		const baseTexture = textures[ 0 ];
+		const baseImage = baseTexture.image;
+		const image = this.image;
+
+		if ( baseImage.width !== image.width || baseImage.height !== image.height || baseImage.depth !== attrsLength ) {
+
+			image.width = baseImage.width;
+			image.height = baseImage.height;
+			image.depth = attrsLength;
+			image.data = new Float32Array( image.width * image.height * image.depth * 4 );
+
+		}
+
+		// copy the other texture data into the data array texture
+		const { data, width, height } = image;
+		for ( let i = 0, l = attrsLength; i < l; i ++ ) {
+
+			const tex = textures[ i ];
+			const length = width * height * 4;
+			const offset = length * i;
+
+			let itemSize = attrs[ i ].itemSize;
+			if ( itemSize === 3 ) {
+
+				itemSize = 4;
+
+			}
+
+			copyArrayToArray( tex.image.data, itemSize, data, 4, offset );
+
+		}
+
+		// reset the texture
+		this.dispose();
+		this.needsUpdate = true;
+
+	}
+
+
+}

package/src/uniforms/IESProfilesTexture.js

@@ -1,100 +1,100 @@
-import {
-	ClampToEdgeWrapping,
-	Color,
-	FloatType,
-	LinearFilter,
-	MeshBasicMaterial,
-	NoToneMapping,
-	RGBAFormat,
-	WebGLArrayRenderTarget,
-} from 'three';
-import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
-import { IESLoader } from '../utils/IESLoader.js';
-
-const prevColor = new Color();
-export class IESProfilesTexture extends WebGLArrayRenderTarget {
-
-	constructor( ...args ) {
-
-		super( ...args );
-
-		const tex = this.texture;
-		tex.format = RGBAFormat;
-		tex.type = FloatType;
-		tex.minFilter = LinearFilter;
-		tex.magFilter = LinearFilter;
-		tex.wrapS = ClampToEdgeWrapping;
-		tex.wrapT = ClampToEdgeWrapping;
-		tex.generateMipmaps = false;
-
-		tex.updateFrom = ( ...args ) => {
-
-			this.updateFrom( ...args );
-
-		};
-
-		const fsQuad = new FullScreenQuad( new MeshBasicMaterial() );
-		this.fsQuad = fsQuad;
-
-		this.iesLoader = new IESLoader();
-
-	}
-
-	async updateFrom( renderer, textures ) {
-
-		// save previous renderer state
-		const prevRenderTarget = renderer.getRenderTarget();
-		const prevToneMapping = renderer.toneMapping;
-		const prevAlpha = renderer.getClearAlpha();
-		renderer.getClearColor( prevColor );
-
-		// resize the render target and ensure we don't have an empty texture
-		// render target depth must be >= 1 to avoid unbound texture error on android devices
-		const depth = textures.length || 1;
-		this.setSize( 360, 180, depth );
-		renderer.setClearColor( 0, 0 );
-		renderer.toneMapping = NoToneMapping;
-
-		// render each texture into each layer of the target
-		const fsQuad = this.fsQuad;
-		for ( let i = 0, l = depth; i < l; i ++ ) {
-
-			const texture = textures[ i ];
-			if ( texture ) {
-
-				// revert to default texture transform before rendering
-				texture.matrixAutoUpdate = false;
-				texture.matrix.identity();
-
-				fsQuad.material.map = texture;
-				fsQuad.material.transparent = true;
-
-				renderer.setRenderTarget( this, i );
-				fsQuad.render( renderer );
-
-				// restore custom texture transform
-				texture.updateMatrix();
-				texture.matrixAutoUpdate = true;
-
-			}
-
-		}
-
-		// reset the renderer
-		fsQuad.material.map = null;
-		renderer.setClearColor( prevColor, prevAlpha );
-		renderer.setRenderTarget( prevRenderTarget );
-		renderer.toneMapping = prevToneMapping;
-
-		fsQuad.dispose();
-
-	}
-
-	dispose() {
-
-		super.dispose();
-		this.fsQuad.dispose();
-
-	}
-
-}
+import {
+	ClampToEdgeWrapping,
+	Color,
+	FloatType,
+	LinearFilter,
+	MeshBasicMaterial,
+	NoToneMapping,
+	RGBAFormat,
+	WebGLArrayRenderTarget,
+} from 'three';
+import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
+import { IESLoader } from '../utils/IESLoader.js';
+
+const prevColor = new Color();
+export class IESProfilesTexture extends WebGLArrayRenderTarget {
+
+	constructor( ...args ) {
+
+		super( ...args );
+
+		const tex = this.texture;
+		tex.format = RGBAFormat;
+		tex.type = FloatType;
+		tex.minFilter = LinearFilter;
+		tex.magFilter = LinearFilter;
+		tex.wrapS = ClampToEdgeWrapping;
+		tex.wrapT = ClampToEdgeWrapping;
+		tex.generateMipmaps = false;
+
+		tex.updateFrom = ( ...args ) => {
+
+			this.updateFrom( ...args );
+
+		};
+
+		const fsQuad = new FullScreenQuad( new MeshBasicMaterial() );
+		this.fsQuad = fsQuad;
+
+		this.iesLoader = new IESLoader();
+
+	}
+
+	async updateFrom( renderer, textures ) {
+
+		// save previous renderer state
+		const prevRenderTarget = renderer.getRenderTarget();
+		const prevToneMapping = renderer.toneMapping;
+		const prevAlpha = renderer.getClearAlpha();
+		renderer.getClearColor( prevColor );
+
+		// resize the render target and ensure we don't have an empty texture
+		// render target depth must be >= 1 to avoid unbound texture error on android devices
+		const depth = textures.length || 1;
+		this.setSize( 360, 180, depth );
+		renderer.setClearColor( 0, 0 );
+		renderer.toneMapping = NoToneMapping;
+
+		// render each texture into each layer of the target
+		const fsQuad = this.fsQuad;
+		for ( let i = 0, l = depth; i < l; i ++ ) {
+
+			const texture = textures[ i ];
+			if ( texture ) {
+
+				// revert to default texture transform before rendering
+				texture.matrixAutoUpdate = false;
+				texture.matrix.identity();
+
+				fsQuad.material.map = texture;
+				fsQuad.material.transparent = true;
+
+				renderer.setRenderTarget( this, i );
+				fsQuad.render( renderer );
+
+				// restore custom texture transform
+				texture.updateMatrix();
+				texture.matrixAutoUpdate = true;
+
+			}
+
+		}
+
+		// reset the renderer
+		fsQuad.material.map = null;
+		renderer.setClearColor( prevColor, prevAlpha );
+		renderer.setRenderTarget( prevRenderTarget );
+		renderer.toneMapping = prevToneMapping;
+
+		fsQuad.dispose();
+
+	}
+
+	dispose() {
+
+		super.dispose();
+		this.fsQuad.dispose();
+
+	}
+
+}

package/src/uniforms/LightsInfoUniformStruct.js

@@ -1,162 +1,162 @@
-import { DataTexture, RGBAFormat, ClampToEdgeWrapping, FloatType, Vector3, Quaternion, Matrix4 } from 'three';
-
-const LIGHT_PIXELS = 6;
-const RECT_AREA_LIGHT = 0;
-const CIRC_AREA_LIGHT = 1;
-const SPOT_LIGHT = 2;
-export class LightsInfoUniformStruct {
-
-	constructor() {
-
-		const tex = new DataTexture( new Float32Array( 4 ), 1, 1 );
-		tex.format = RGBAFormat;
-		tex.type = FloatType;
-		tex.wrapS = ClampToEdgeWrapping;
-		tex.wrapT = ClampToEdgeWrapping;
-		tex.generateMipmaps = false;
-
-		this.tex = tex;
-		this.count = 0;
-
-	}
-
-	updateFrom( lights, iesTextures = [] ) {
-
-		const tex = this.tex;
-		const pixelCount = Math.max( lights.length * LIGHT_PIXELS, 1 );
-		const dimension = Math.ceil( Math.sqrt( pixelCount ) );
-
-		if ( tex.image.width !== dimension ) {
-
-			tex.dispose();
-
-			tex.image.data = new Float32Array( dimension * dimension * 4 );
-			tex.image.width = dimension;
-			tex.image.height = dimension;
-
-		}
-
-		const floatArray = tex.image.data;
-
-		const u = new Vector3();
-		const v = new Vector3();
-		const m = new Matrix4();
-		const worldQuaternion = new Quaternion();
-		const eye = new Vector3();
-		const target = new Vector3();
-		const up = new Vector3();
-
-		for ( let i = 0, l = lights.length; i < l; i ++ ) {
-
-			const l = lights[ i ];
-
-			const baseIndex = i * LIGHT_PIXELS * 4;
-			let index = 0;
-
-			// sample 1
-		    // position
-			l.getWorldPosition( v );
-			floatArray[ baseIndex + ( index ++ ) ] = v.x;
-			floatArray[ baseIndex + ( index ++ ) ] = v.y;
-			floatArray[ baseIndex + ( index ++ ) ] = v.z;
-
-			// type
-			let type = RECT_AREA_LIGHT;
-			if ( l.isRectAreaLight && l.isCircular ) type = CIRC_AREA_LIGHT;
-			else if ( l.isSpotLight ) type = SPOT_LIGHT;
-			floatArray[ baseIndex + ( index ++ ) ] = type;
-
-			// sample 2
-			// color
-			floatArray[ baseIndex + ( index ++ ) ] = l.color.r;
-			floatArray[ baseIndex + ( index ++ ) ] = l.color.g;
-			floatArray[ baseIndex + ( index ++ ) ] = l.color.b;
-
-			// intensity
-			floatArray[ baseIndex + ( index ++ ) ] = l.intensity;
-
-			l.getWorldQuaternion( worldQuaternion );
-
-			if ( l.isRectAreaLight ) {
-
-				// sample 3
-				// u vector
-				u.set( l.width, 0, 0 ).applyQuaternion( worldQuaternion );
-
-				floatArray[ baseIndex + ( index ++ ) ] = u.x;
-				floatArray[ baseIndex + ( index ++ ) ] = u.y;
-				floatArray[ baseIndex + ( index ++ ) ] = u.z;
-				index ++;
-
-				// sample 4
-				// v vector
-				v.set( 0, l.height, 0 ).applyQuaternion( worldQuaternion );
-
-				floatArray[ baseIndex + ( index ++ ) ] = v.x;
-				floatArray[ baseIndex + ( index ++ ) ] = v.y;
-				floatArray[ baseIndex + ( index ++ ) ] = v.z;
-
-				// area
-				floatArray[ baseIndex + ( index ++ ) ] = u.cross( v ).length() * ( l.isCircular ? ( Math.PI / 4.0 ) : 1.0 );
-
-			} else if ( l.isSpotLight ) {
-
-				const radius = l.radius;
-				eye.setFromMatrixPosition( l.matrixWorld );
-				target.setFromMatrixPosition( l.target.matrixWorld );
-				m.lookAt( eye, target, up );
-				worldQuaternion.setFromRotationMatrix( m );
-
-				// sample 3
-				// u vector
-				u.set( 1, 0, 0 ).applyQuaternion( worldQuaternion );
-
-				floatArray[ baseIndex + ( index ++ ) ] = u.x;
-				floatArray[ baseIndex + ( index ++ ) ] = u.y;
-				floatArray[ baseIndex + ( index ++ ) ] = u.z;
-				index ++;
-
-				// sample 4
-				// v vector
-				v.set( 0, 1, 0 ).applyQuaternion( worldQuaternion );
-
-				floatArray[ baseIndex + ( index ++ ) ] = v.x;
-				floatArray[ baseIndex + ( index ++ ) ] = v.y;
-				floatArray[ baseIndex + ( index ++ ) ] = v.z;
-
-				// area
-				floatArray[ baseIndex + ( index ++ ) ] = Math.PI * radius * radius;
-
-				// sample 5
-				// radius
-				floatArray[ baseIndex + ( index ++ ) ] = radius;
-
-				// near
-				floatArray[ baseIndex + ( index ++ ) ] = l.shadow.camera.near;
-
-				// decay
-				floatArray[ baseIndex + ( index ++ ) ] = l.decay;
-
-				// distance
-				floatArray[ baseIndex + ( index ++ ) ] = l.distance;
-
-				// sample 6
-				// coneCos
-				floatArray[ baseIndex + ( index ++ ) ] = Math.cos( l.angle );
-
-				// penumbraCos
-				floatArray[ baseIndex + ( index ++ ) ] = Math.cos( l.angle * ( 1 - l.penumbra ) );
-
-				// iesProfile
-				floatArray[ baseIndex + ( index ++ ) ] = iesTextures.indexOf( l.iesTexture );
-
-			}
-
-		}
-
-		tex.needsUpdate = true;
-		this.count = lights.length;
-
-	}
-
-}
+import { DataTexture, RGBAFormat, ClampToEdgeWrapping, FloatType, Vector3, Quaternion, Matrix4 } from 'three';
+
+const LIGHT_PIXELS = 6;
+const RECT_AREA_LIGHT = 0;
+const CIRC_AREA_LIGHT = 1;
+const SPOT_LIGHT = 2;
+export class LightsInfoUniformStruct {
+
+	constructor() {
+
+		const tex = new DataTexture( new Float32Array( 4 ), 1, 1 );
+		tex.format = RGBAFormat;
+		tex.type = FloatType;
+		tex.wrapS = ClampToEdgeWrapping;
+		tex.wrapT = ClampToEdgeWrapping;
+		tex.generateMipmaps = false;
+
+		this.tex = tex;
+		this.count = 0;
+
+	}
+
+	updateFrom( lights, iesTextures = [] ) {
+
+		const tex = this.tex;
+		const pixelCount = Math.max( lights.length * LIGHT_PIXELS, 1 );
+		const dimension = Math.ceil( Math.sqrt( pixelCount ) );
+
+		if ( tex.image.width !== dimension ) {
+
+			tex.dispose();
+
+			tex.image.data = new Float32Array( dimension * dimension * 4 );
+			tex.image.width = dimension;
+			tex.image.height = dimension;
+
+		}
+
+		const floatArray = tex.image.data;
+
+		const u = new Vector3();
+		const v = new Vector3();
+		const m = new Matrix4();
+		const worldQuaternion = new Quaternion();
+		const eye = new Vector3();
+		const target = new Vector3();
+		const up = new Vector3();
+
+		for ( let i = 0, l = lights.length; i < l; i ++ ) {
+
+			const l = lights[ i ];
+
+			const baseIndex = i * LIGHT_PIXELS * 4;
+			let index = 0;
+
+			// sample 1
+		    // position
+			l.getWorldPosition( v );
+			floatArray[ baseIndex + ( index ++ ) ] = v.x;
+			floatArray[ baseIndex + ( index ++ ) ] = v.y;
+			floatArray[ baseIndex + ( index ++ ) ] = v.z;
+
+			// type
+			let type = RECT_AREA_LIGHT;
+			if ( l.isRectAreaLight && l.isCircular ) type = CIRC_AREA_LIGHT;
+			else if ( l.isSpotLight ) type = SPOT_LIGHT;
+			floatArray[ baseIndex + ( index ++ ) ] = type;
+
+			// sample 2
+			// color
+			floatArray[ baseIndex + ( index ++ ) ] = l.color.r;
+			floatArray[ baseIndex + ( index ++ ) ] = l.color.g;
+			floatArray[ baseIndex + ( index ++ ) ] = l.color.b;
+
+			// intensity
+			floatArray[ baseIndex + ( index ++ ) ] = l.intensity;
+
+			l.getWorldQuaternion( worldQuaternion );
+
+			if ( l.isRectAreaLight ) {
+
+				// sample 3
+				// u vector
+				u.set( l.width, 0, 0 ).applyQuaternion( worldQuaternion );
+
+				floatArray[ baseIndex + ( index ++ ) ] = u.x;
+				floatArray[ baseIndex + ( index ++ ) ] = u.y;
+				floatArray[ baseIndex + ( index ++ ) ] = u.z;
+				index ++;
+
+				// sample 4
+				// v vector
+				v.set( 0, l.height, 0 ).applyQuaternion( worldQuaternion );
+
+				floatArray[ baseIndex + ( index ++ ) ] = v.x;
+				floatArray[ baseIndex + ( index ++ ) ] = v.y;
+				floatArray[ baseIndex + ( index ++ ) ] = v.z;
+
+				// area
+				floatArray[ baseIndex + ( index ++ ) ] = u.cross( v ).length() * ( l.isCircular ? ( Math.PI / 4.0 ) : 1.0 );
+
+			} else if ( l.isSpotLight ) {
+
+				const radius = l.radius;
+				eye.setFromMatrixPosition( l.matrixWorld );
+				target.setFromMatrixPosition( l.target.matrixWorld );
+				m.lookAt( eye, target, up );
+				worldQuaternion.setFromRotationMatrix( m );
+
+				// sample 3
+				// u vector
+				u.set( 1, 0, 0 ).applyQuaternion( worldQuaternion );
+
+				floatArray[ baseIndex + ( index ++ ) ] = u.x;
+				floatArray[ baseIndex + ( index ++ ) ] = u.y;
+				floatArray[ baseIndex + ( index ++ ) ] = u.z;
+				index ++;
+
+				// sample 4
+				// v vector
+				v.set( 0, 1, 0 ).applyQuaternion( worldQuaternion );
+
+				floatArray[ baseIndex + ( index ++ ) ] = v.x;
+				floatArray[ baseIndex + ( index ++ ) ] = v.y;
+				floatArray[ baseIndex + ( index ++ ) ] = v.z;
+
+				// area
+				floatArray[ baseIndex + ( index ++ ) ] = Math.PI * radius * radius;
+
+				// sample 5
+				// radius
+				floatArray[ baseIndex + ( index ++ ) ] = radius;
+
+				// near
+				floatArray[ baseIndex + ( index ++ ) ] = l.shadow.camera.near;
+
+				// decay
+				floatArray[ baseIndex + ( index ++ ) ] = l.decay;
+
+				// distance
+				floatArray[ baseIndex + ( index ++ ) ] = l.distance;
+
+				// sample 6
+				// coneCos
+				floatArray[ baseIndex + ( index ++ ) ] = Math.cos( l.angle );
+
+				// penumbraCos
+				floatArray[ baseIndex + ( index ++ ) ] = Math.cos( l.angle * ( 1 - l.penumbra ) );
+
+				// iesProfile
+				floatArray[ baseIndex + ( index ++ ) ] = iesTextures.indexOf( l.iesTexture );
+
+			}
+
+		}
+
+		tex.needsUpdate = true;
+		this.count = lights.length;
+
+	}
+
+}