three-gpu-pathtracer 0.0.1 → 0.0.4

package/src/uniforms/RenderTarget2DArray.js

@@ -1,80 +1,93 @@
-import {
-	WebGLArrayRenderTarget,
-	RGBAFormat,
-	UnsignedByteType,
-	MeshBasicMaterial,
-	Color,
-	RepeatWrapping,
-	LinearFilter,
-	NoToneMapping,
-} from 'three';
-import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
-
-const prevColor = new Color();
-export class RenderTarget2DArray extends WebGLArrayRenderTarget {
-
-	constructor( ...args ) {
-
-		super( ...args );
-
-		const tex = this.texture;
-		tex.format = RGBAFormat;
-		tex.type = UnsignedByteType;
-		tex.minFilter = LinearFilter;
-		tex.magFilter = LinearFilter;
-		tex.wrapS = RepeatWrapping;
-		tex.wrapT = RepeatWrapping;
-		tex.setTextures = ( ...args ) => {
-
-			this.setTextures( ...args );
-
-		};
-
-		const fsQuad = new FullScreenQuad( new MeshBasicMaterial() );
-		this.fsQuad = fsQuad;
-
-	}
-
-	setTextures( renderer, width, height, textures ) {
-
-		// save previous renderer state
-		const prevRenderTarget = renderer.getRenderTarget();
-		const prevToneMapping = renderer.toneMapping;
-		const prevAlpha = renderer.getClearAlpha();
-		renderer.getClearColor( prevColor );
-
-		// resize the render target
-		const depth = textures.length;
-		this.setSize( width, height, 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 ];
-			fsQuad.material.map = texture;
-			fsQuad.material.transparent = true;
-
-			renderer.setRenderTarget( this, i );
-			fsQuad.render( renderer );
-
-		}
-
-		// reset the renderer
-		fsQuad.material.map = null;
-		renderer.setClearColor( prevColor, prevAlpha );
-		renderer.setRenderTarget( prevRenderTarget );
-		renderer.toneMapping = prevToneMapping;
-
-	}
-
-	dispose() {
-
-		super.dispose();
-		this.fsQuad.dispose();
-
-	}
-
-}
+import {
+	WebGLArrayRenderTarget,
+	RGBAFormat,
+	UnsignedByteType,
+	MeshBasicMaterial,
+	Color,
+	RepeatWrapping,
+	LinearFilter,
+	NoToneMapping,
+} from 'three';
+import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
+
+const prevColor = new Color();
+export class RenderTarget2DArray extends WebGLArrayRenderTarget {
+
+	constructor( ...args ) {
+
+		super( ...args );
+
+		const tex = this.texture;
+		tex.format = RGBAFormat;
+		tex.type = UnsignedByteType;
+		tex.minFilter = LinearFilter;
+		tex.magFilter = LinearFilter;
+		tex.wrapS = RepeatWrapping;
+		tex.wrapT = RepeatWrapping;
+		tex.setTextures = ( ...args ) => {
+
+			this.setTextures( ...args );
+
+		};
+
+		const fsQuad = new FullScreenQuad( new MeshBasicMaterial() );
+		this.fsQuad = fsQuad;
+
+	}
+
+	setTextures( renderer, width, height, 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( width, height, 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;
+
+	}
+
+	dispose() {
+
+		super.dispose();
+		this.fsQuad.dispose();
+
+	}
+
+}

package/src/utils/BlurredEnvMapGenerator.js

@@ -0,0 +1,113 @@
+import { WebGLRenderTarget, RGBAFormat, FloatType, PMREMGenerator, DataTexture, EquirectangularReflectionMapping } from 'three';
+import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
+import { MaterialBase } from '../materials/MaterialBase.js';
+import { shaderUtils } from '../shader/shaderUtils.js';
+
+class PMREMCopyMaterial extends MaterialBase {
+
+	constructor() {
+
+		super( {
+
+			uniforms: {
+
+				envMap: { value: null },
+				blur: { value: 0 },
+
+			},
+
+			vertexShader: /* glsl */`
+
+				varying vec2 vUv;
+				void main() {
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+				}
+
+			`,
+
+			fragmentShader: /* glsl */`
+
+				#include <common>
+				#include <cube_uv_reflection_fragment>
+
+				${ shaderUtils }
+
+				uniform sampler2D envMap;
+				uniform float blur;
+				varying vec2 vUv;
+				void main() {
+
+					vec3 rayDirection = equirectUvToDirection( vUv );
+					gl_FragColor = textureCubeUV( envMap, rayDirection, blur );
+
+				}
+
+			`,
+
+		} );
+
+	}
+
+}
+
+export class BlurredEnvMapGenerator {
+
+	constructor( renderer ) {
+
+		this.renderer = renderer;
+		this.pmremGenerator = new PMREMGenerator( renderer );
+		this.copyQuad = new FullScreenQuad( new PMREMCopyMaterial() );
+		this.renderTarget = new WebGLRenderTarget( 1, 1, { type: FloatType, format: RGBAFormat } );
+
+	}
+
+	dispose() {
+
+		this.pmremGenerator.dispose();
+		this.copyQuad.dispose();
+		this.renderTarget.dispose();
+
+	}
+
+	generate( texture, blur ) {
+
+		const { pmremGenerator, renderTarget, copyQuad, renderer } = this;
+
+		// get the pmrem target
+		const pmremTarget = pmremGenerator.fromEquirectangular( texture );
+
+		// set up the material
+		const { width, height } = texture.image;
+		renderTarget.setSize( width, height );
+		copyQuad.material.envMap = pmremTarget.texture;
+		copyQuad.material.blur = blur;
+
+		// render
+		const prevRenderTarget = renderer.getRenderTarget();
+		const prevClear = renderer.autoClear;
+
+		renderer.setRenderTarget( renderTarget );
+		renderer.autoClear = true;
+		copyQuad.render( renderer );
+
+		renderer.setRenderTarget( prevRenderTarget );
+		renderer.autoClear = prevClear;
+
+		// read the data back
+		const buffer = new Float32Array( width * height * 4 );
+		renderer.readRenderTargetPixels( renderTarget, 0, 0, width, height, buffer );
+
+		const result = new DataTexture( buffer, width, height, RGBAFormat, FloatType );
+		result.minFilter = texture.minFilter;
+		result.magFilter = texture.magFilter;
+		result.wrapS = texture.wrapS;
+		result.wrapT = texture.wrapT;
+		result.mapping = EquirectangularReflectionMapping;
+		result.needsUpdate = true;
+
+		return result;
+
+	}
+
+}

package/src/utils/GeometryPreparationUtils.js

@@ -1,172 +1,194 @@
-import { BufferAttribute } from 'three';
-import { mergeBufferGeometries, mergeVertices } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
-function getGroupMaterialIndicesAttribute( geometry, materials, allMaterials ) {
-
-	if ( ! Array.isArray( materials ) ) {
-
-		materials = [ materials ];
-
-	}
-
-	const vertCount = geometry.attributes.position.count;
-	const materialArray = new Uint8Array( vertCount );
-	let groups = geometry.groups;
-	if ( groups.length === 0 ) {
-
-		groups = [ { count: vertCount, start: 0, materialIndex: 0 } ];
-
-	}
-
-	for ( let i = 0; i < groups.length; i ++ ) {
-
-		const group = groups[ i ];
-		const { count, start } = group;
-		const endCount = Math.min( count, vertCount - start );
-		const mat = materials[ group.materialIndex ];
-		const materialIndex = allMaterials.indexOf( mat );
-
-		for ( let j = 0; j < endCount; j ++ ) {
-
-			materialArray[ start + j ] = materialIndex;
-
-		}
-
-	}
-
-	return new BufferAttribute( materialArray, 1, false );
-
-}
-
-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;
-		let geometry = options.cloneGeometry ? originalGeometry.clone() : originalGeometry;
-		geometry.applyMatrix4( mesh.matrixWorld );
-
-		const attrs = options.attributes;
-		if ( ! geometry.attributes.normal && ( attrs && attrs.includes( 'normal' ) ) ) {
-
-			geometry.computeVertexNormals();
-
-		}
-
-		if ( ! geometry.attributes.uv && ( attrs && attrs.includes( 'uv' ) ) ) {
-
-			const vertCount = geometry.attributes.position.count;
-			geometry.setAttribute( 'uv', new BufferAttribute( new Float32Array( vertCount * 2 ), 2, false ) );
-
-		}
-
-		if ( ! geometry.attributes.tangent && ( attrs && attrs.includes( 'tangent' ) ) ) {
-
-			if ( mesh.material.normalMap ) {
-
-				// 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 );
-
-		}
-
-		// trim any unneeded attributes
-		if ( options.attributes ) {
-
-			for ( const key in geometry.attributes ) {
-
-				if ( ! options.attributes.includes( key ) ) {
-
-					geometry.deleteAttribute( key );
-
-				}
-
-			}
-
-		}
-
-		// 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 };
+
+}