three-gpu-pathtracer 0.0.7 → 0.0.9

package/src/uniforms/PhysicalCameraUniform.js

@@ -1,36 +1,36 @@
-import { PhysicalCamera } from '../objects/PhysicalCamera.js';
-export class PhysicalCameraUniform {
-
-	constructor() {
-
-		this.bokehSize = 0;
-		this.apertureBlades = 0;
-		this.apertureRotation = 0;
-		this.focusDistance = 10;
-		this.anamorphicRatio = 1;
-
-	}
-
-	updateFrom( camera ) {
-
-		if ( camera instanceof PhysicalCamera ) {
-
-			this.bokehSize = camera.bokehSize;
-			this.apertureBlades = camera.apertureBlades;
-			this.apertureRotation = camera.apertureRotation;
-			this.focusDistance = camera.focusDistance;
-			this.anamorphicRatio = camera.anamorphicRatio;
-
-		} else {
-
-			this.bokehSize = 0;
-			this.apertureRotation = 0;
-			this.apertureBlades = 0;
-			this.focusDistance = 10;
-			this.anamorphicRatio = 1;
-
-		}
-
-	}
-
-}
+import { PhysicalCamera } from '../objects/PhysicalCamera.js';
+export class PhysicalCameraUniform {
+
+	constructor() {
+
+		this.bokehSize = 0;
+		this.apertureBlades = 0;
+		this.apertureRotation = 0;
+		this.focusDistance = 10;
+		this.anamorphicRatio = 1;
+
+	}
+
+	updateFrom( camera ) {
+
+		if ( camera instanceof PhysicalCamera ) {
+
+			this.bokehSize = camera.bokehSize;
+			this.apertureBlades = camera.apertureBlades;
+			this.apertureRotation = camera.apertureRotation;
+			this.focusDistance = camera.focusDistance;
+			this.anamorphicRatio = camera.anamorphicRatio;
+
+		} else {
+
+			this.bokehSize = 0;
+			this.apertureRotation = 0;
+			this.apertureBlades = 0;
+			this.focusDistance = 10;
+			this.anamorphicRatio = 1;
+
+		}
+
+	}
+
+}

package/src/uniforms/RenderTarget2DArray.js

@@ -1,93 +1,97 @@
-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();
-
-	}
-
-}
+import {
+	WebGLArrayRenderTarget,
+	RGBAFormat,
+	UnsignedByteType,
+	MeshBasicMaterial,
+	Color,
+	RepeatWrapping,
+	LinearFilter,
+	NoToneMapping,
+} from 'three';
+import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass.js';
+import { reduceTexturesToUniqueSources } from './utils.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 ) {
+
+		// get the list of textures with unique sources
+		const uniqueTextures = reduceTexturesToUniqueSources( 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 = uniqueTextures.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 = uniqueTextures[ 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/uniforms/utils.js

@@ -0,0 +1,30 @@
+// we must hash the texture to determine uniqueness using the encoding, as well, because the
+// when rendering each texture to the texture array they must have a consistent color space.
+export function getTextureHash( t ) {
+
+	return `${ t.source.uuid }:${ t.encoding }`;
+
+}
+
+// reduce the set of textures to just those with a unique source while retaining
+// the order of the textures.
+export function reduceTexturesToUniqueSources( textures ) {
+
+	const sourceSet = new Set();
+	const result = [];
+	for ( let i = 0, l = textures.length; i < l; i ++ ) {
+
+		const tex = textures[ i ];
+		const hash = getTextureHash( tex );
+		if ( ! sourceSet.has( hash ) ) {
+
+			sourceSet.add( hash );
+			result.push( tex );
+
+		}
+
+	}
+
+	return result;
+
+}

package/src/utils/BlurredEnvMapGenerator.js

@@ -1,113 +1,116 @@
-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;
-
-	}
-
-}
+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;
+
+		// dispose of the now unneeded target
+		pmremTarget.dispose();
+
+		return result;
+
+	}
+
+}