three-gpu-pathtracer 0.0.20 → 0.0.21

package/src/core/utils/mergeGeometries.js

@@ -0,0 +1,218 @@
+import { BufferAttribute, BufferGeometry } from 'three';
+import { copyAttributeContents, createAttributeClone } from './BufferAttributeUtils.js';
+
+function validateMergeability( geometries ) {
+
+	const isIndexed = geometries[ 0 ].index !== null;
+	const attributesUsed = new Set( Object.keys( geometries[ 0 ].attributes ) );
+	if ( ! geometries[ 0 ].getAttribute( 'position' ) ) {
+
+		throw new Error( 'StaticGeometryGenerator: position attribute is required.' );
+
+	}
+
+	for ( let i = 0; i < geometries.length; ++ i ) {
+
+		const geometry = geometries[ i ];
+		let attributesCount = 0;
+
+		// ensure that all geometries are indexed, or none
+		if ( isIndexed !== ( geometry.index !== null ) ) {
+
+			throw new Error( 'StaticGeometryGenerator: All geometries must have compatible attributes; make sure index attribute exists among all geometries, or in none of them.' );
+
+		}
+
+		// gather attributes, exit early if they're different
+		for ( const name in geometry.attributes ) {
+
+			if ( ! attributesUsed.has( name ) ) {
+
+				throw new Error( 'StaticGeometryGenerator: All geometries must have compatible attributes; make sure "' + name + '" attribute exists among all geometries, or in none of them.' );
+
+			}
+
+			attributesCount ++;
+
+		}
+
+		// ensure geometries have the same number of attributes
+		if ( attributesCount !== attributesUsed.size ) {
+
+			throw new Error( 'StaticGeometryGenerator: All geometries must have the same number of attributes.' );
+
+		}
+
+	}
+
+}
+
+function getTotalIndexCount( geometries ) {
+
+	let result = 0;
+	for ( let i = 0, l = geometries.length; i < l; i ++ ) {
+
+		result += geometries[ i ].getIndex().count;
+
+	}
+
+	return result;
+
+}
+
+function getTotalAttributeCount( geometries ) {
+
+	let result = 0;
+	for ( let i = 0, l = geometries.length; i < l; i ++ ) {
+
+		result += geometries[ i ].getAttribute( 'position' ).count;
+
+	}
+
+	return result;
+
+}
+
+function trimMismatchedAttributes( target, indexCount, attrCount ) {
+
+	if ( target.index && target.index.count !== indexCount ) {
+
+		target.setIndex( null );
+
+	}
+
+	const attributes = target.attributes;
+	for ( const key in attributes ) {
+
+		const attr = attributes[ key ];
+		if ( attr.count !== attrCount ) {
+
+			target.deleteAttribute( key );
+
+		}
+
+	}
+
+}
+
+// Modified version of BufferGeometryUtils.mergeBufferGeometries that ignores morph targets and updates a attributes in place
+export function mergeGeometries( geometries, options = {}, targetGeometry = new BufferGeometry() ) {
+
+	const {
+		useGroups = false,
+		forceUpdate = false,
+		skipAssigningAttributes = [],
+		overwriteIndex = true,
+	} = options;
+
+	// check if we can merge these geometries
+	validateMergeability( geometries );
+
+	const isIndexed = geometries[ 0 ].index !== null;
+	const totalIndexCount = isIndexed ? getTotalIndexCount( geometries ) : - 1;
+	const totalAttributeCount = getTotalAttributeCount( geometries );
+	trimMismatchedAttributes( targetGeometry, totalIndexCount, totalAttributeCount );
+
+	// set up groups
+	if ( useGroups ) {
+
+		let offset = 0;
+		for ( let i = 0, l = geometries.length; i < l; i ++ ) {
+
+			const geometry = geometries[ i ];
+
+			let primitiveCount;
+			if ( isIndexed ) {
+
+				primitiveCount = geometry.getIndex().count;
+
+			} else {
+
+				primitiveCount = geometry.getAttribute( 'position' ).count;
+
+			}
+
+			targetGeometry.addGroup( offset, primitiveCount, i );
+			offset += primitiveCount;
+
+		}
+
+	}
+
+	// generate the final geometry
+	// skip the assigning any attributes for items in the above array
+	if ( isIndexed ) {
+
+		// set up the index if it doesn't exist
+		let forceUpdateIndex = false;
+		if ( ! targetGeometry.index ) {
+
+			targetGeometry.setIndex( new BufferAttribute( new Uint32Array( totalIndexCount ), 1, false ) );
+			forceUpdateIndex = true;
+
+		}
+
+		if ( forceUpdateIndex || overwriteIndex ) {
+
+			// copy the index data to the target geometry
+			let targetOffset = 0;
+			let indexOffset = 0;
+			const targetIndex = targetGeometry.getIndex();
+			for ( let i = 0, l = geometries.length; i < l; i ++ ) {
+
+				const geometry = geometries[ i ];
+				const index = geometry.getIndex();
+				const skip = ! forceUpdate && ! forceUpdateIndex && skipAssigningAttributes[ i ];
+				if ( ! skip ) {
+
+					for ( let j = 0; j < index.count; ++ j ) {
+
+						targetIndex.setX( targetOffset + j, index.getX( j ) + indexOffset );
+
+					}
+
+				}
+
+				targetOffset += index.count;
+				indexOffset += geometry.getAttribute( 'position' ).count;
+
+			}
+
+		}
+
+	}
+
+	// copy all the attribute data over
+	const attributes = Object.keys( geometries[ 0 ].attributes );
+	for ( let i = 0, l = attributes.length; i < l; i ++ ) {
+
+		let forceUpdateAttr = false;
+		const key = attributes[ i ];
+		if ( ! targetGeometry.getAttribute( key ) ) {
+
+			const firstAttr = geometries[ 0 ].getAttribute( key );
+			targetGeometry.setAttribute( key, createAttributeClone( firstAttr, totalAttributeCount ) );
+			forceUpdateAttr = true;
+
+		}
+
+		let offset = 0;
+		const targetAttribute = targetGeometry.getAttribute( key );
+		for ( let g = 0, l = geometries.length; g < l; g ++ ) {
+
+			const geometry = geometries[ g ];
+			const skip = ! forceUpdate && ! forceUpdateAttr && skipAssigningAttributes[ g ];
+			const attr = geometry.getAttribute( key );
+ 			if ( ! skip ) {
+
+				copyAttributeContents( attr, targetAttribute, offset );
+
+			}
+
+			offset += attr.count;
+
+		}
+
+	}
+
+}

package/src/core/utils/sceneUpdateUtils.js

@@ -0,0 +1,96 @@
+function uuidSort( a, b ) {
+
+	if ( a.uuid < b.uuid ) return 1;
+	if ( a.uuid > b.uuid ) return - 1;
+	return 0;
+
+}
+
+// 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.colorSpace }`;
+
+}
+
+// reduce the set of textures to just those with a unique source while retaining
+// the order of the textures.
+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;
+
+}
+
+export function getIesTextures( lights ) {
+
+	const textures = lights.map( l => l.iesMap || null ).filter( t => t );
+	const textureSet = new Set( textures );
+	return Array.from( textureSet ).sort( uuidSort );
+
+}
+
+export function getTextures( materials ) {
+
+	const textureSet = new Set();
+	for ( let i = 0, l = materials.length; i < l; i ++ ) {
+
+		const material = materials[ i ];
+		for ( const key in material ) {
+
+			const value = material[ key ];
+			if ( value && value.isTexture ) {
+
+				textureSet.add( value );
+
+			}
+
+		}
+
+	}
+
+	const textureArray = Array.from( textureSet );
+	return reduceTexturesToUniqueSources( textureArray ).sort( uuidSort );
+
+}
+
+export function getLights( scene ) {
+
+	const lights = [];
+	scene.traverse( c => {
+
+		if ( c.visible ) {
+
+			if (
+				c.isRectAreaLight ||
+				c.isSpotLight ||
+				c.isPointLight ||
+				c.isDirectionalLight
+			) {
+
+				lights.push( c );
+
+			}
+
+		}
+
+	} );
+
+	return lights.sort( uuidSort );
+
+}

package/src/index.d.ts

@@ -0,0 +1,274 @@
+import {
+	DataTexture,
+	RectAreaLight,
+	ShaderMaterial,
+	SpotLight,
+	Camera,
+	PerspectiveCamera,
+	MeshStandardMaterial,
+	Light,
+	Material,
+	Object3D,
+	Texture,
+	Vector2,
+	WebGLRenderer,
+	WebGLRenderTarget,
+	BufferGeometry,
+	Color,
+	ShaderMaterialParameters,
+	MeshStandardMaterialParameters,
+	Spherical,
+	Scene,
+	PMREMGenerator
+} from 'three';
+import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass';
+import { MeshBVH, MeshBVHOptions } from 'three-mesh-bvh';
+
+// three.js type augmentation
+
+declare module 'three/src/materials/MeshStandardMaterial' {
+
+	export interface MeshStandardMaterial {
+
+		/**
+		 * Whether to render the object as completely transparent against the rest of the environment
+		 * so other objects can be composited later.
+		 *
+		 * Used by `WebGLPathTracer` from `three-gpu-pathtracer`.
+		 */
+		matte: boolean;
+		/**
+		 * Whether the object should cast a shadow.
+		 *
+		 * Used by `WebGLPathTracer` from `three-gpu-pathtracer`.
+		 */
+		castShadow: boolean;
+
+	}
+
+}
+
+// core
+
+export interface PathTracingSceneGeneratorResult {
+
+	bvhChanged: boolean;
+	bvh: MeshBVH;
+	lights: Array<Light>;
+	iesTextures: Array<DataTexture>;
+	geometry: BufferGeometry;
+	materials: Array<Material>;
+	textures: Array<Texture>;
+	objects: Array<Object3D>;
+
+}
+
+export interface BVHWorker {
+
+	generate( geometry : BufferGeometry, options?: MeshBVHOptions ) : Promise<MeshBVH>
+
+}
+
+/**
+ * @deprecated `PathTracingSceneGenerator` has been deprecated and will be removed in a future release.
+ * Use `WebGLPathTracer` instead, as it handles scene generation internally.
+ */
+export class PathTracingSceneGenerator {
+
+	constructor( objects?: Object3D | Array<Object3D> );
+
+	readonly initialized: boolean;
+
+	bvhOptions: MeshBVHOptions;
+	attributes: Array<string>;
+	generateBVH: boolean;
+
+	bvh: MeshBVH | null;
+	geometry: BufferGeometry;
+
+	setObjects( objects: Object3D | Array<Object3D> ): void;
+	setBVHWorker( bvhWorker: BVHWorker ): void;
+
+	generateAsync( onProgress?: ( progress: number ) => void ): Promise<PathTracingSceneGeneratorResult>;
+	generate( onProgress?: ( progress: number ) => void ): PathTracingSceneGeneratorResult;
+
+}
+
+/**
+ * @deprecated `DynamicPathTracingSceneGenerator` has been deprecated and will be removed in a future release.
+ * Use `WebGLPathTracer` instead, as it handles scene generation internally.
+ */
+export class DynamicPathTracingSceneGenerator extends PathTracingSceneGenerator {}
+
+/**
+ * @deprecated `PathTracingSceneWorker` has been deprecated and will be removed in a future release.
+ * Use `WebGLPathTracer` instead, as it handles scene generation internally.
+ */
+export class PathTracingSceneWorker extends PathTracingSceneGenerator {}
+
+export class WebGLPathTracer {
+
+	constructor( renderer: WebGLRenderer );
+
+	readonly samples: number;
+	readonly target: WebGLRenderTarget;
+	readonly tiles: Vector2;
+	readonly camera: Camera | null;
+	readonly scene: Scene | null;
+
+	multipleImportanceSampling: boolean;
+	bounces: number;
+	transmissiveBounces: number;
+	filterGlossyFactor: number;
+	renderDelay: number;
+	minSamples: number;
+	fadeDuration: number;
+	enablePathTracing: boolean;
+	pausePathTracing: boolean;
+	dynamicLowRes: boolean;
+	lowResScale: number;
+	renderScale: number;
+	synchronizeRenderSize: boolean;
+	rasterizeScene: boolean;
+	renderToCanvas: boolean;
+	textureSize: Vector2;
+
+	rasterizeSceneCallback: ( scene: Scene, camera: Camera ) => void;
+	renderToCanvasCallback: ( target: WebGLRenderTarget, renderer: WebGLRenderer, quad: FullScreenQuad ) => void;
+
+	setBVHWorker( bvhWorker: BVHWorker ): void;
+	setScene(
+		scene: Scene,
+		camera: Camera,
+		options?: { onProgress?: ( progress: number ) => void }
+	): void;
+	setSceneAsync(
+		scene: Scene,
+		camera: Camera,
+		options?: { onProgress?: ( progress: number ) => void }
+	): Promise<void>;
+	setCamera( camera: Camera ): void;
+
+	updateCamera(): void;
+	updateMaterials(): void;
+	updateLights(): void;
+	updateEnvironment(): void;
+	renderSample(): void;
+	reset(): void;
+	dispose(): void;
+
+}
+
+// objects
+
+export class PhysicalCamera extends PerspectiveCamera {
+
+	focusDistance: number;
+	fStop: number;
+	bokehSize: number;
+	apertureBlades: number;
+	apertureRotation: number;
+	anamorphicRatio: number;
+
+}
+
+export class EquirectCamera extends Camera {
+
+	readonly isEquirectCamera: true;
+
+}
+
+export class PhysicalSpotLight extends SpotLight {
+
+	radius: number;
+	iesTexture: DataTexture | null;
+
+}
+
+export class ShapedAreaLight extends RectAreaLight {
+
+	isCircular: boolean;
+
+}
+
+// textures
+
+export class ProceduralEquirectTexture extends DataTexture {
+
+	constructor( width?: number, height?: number );
+
+	generationCallback( polar: Spherical, uv: Vector2, coord: Vector2, color: Color ): void;
+
+	update(): void;
+
+}
+
+export class GradientEquirectTexture extends ProceduralEquirectTexture {
+
+	constructor( resolution?: number );
+
+	exponent: number;
+	topColor: Color;
+	bottomColor: Color;
+
+}
+
+// utils
+
+export class BlurredEnvMapGenerator {
+
+	constructor( renderer: WebGLRenderer );
+
+	renderer: WebGLRenderer;
+	pmremGenerator: PMREMGenerator;
+	copyQuad: FullScreenQuad;
+	renderTarget: WebGLRenderTarget;
+
+	generate( texture: Texture, blur: number ): DataTexture;
+	dispose(): void;
+
+}
+
+// materials
+
+declare class MaterialBase extends ShaderMaterial {
+
+	setDefine( name: string, value: any ): boolean;
+
+}
+
+export interface DenoiseMaterialParameters extends ShaderMaterialParameters {
+
+	sigma?: number;
+	kSigma?: number;
+	threshold?: number;
+	map?: Texture;
+
+}
+
+export class DenoiseMaterial extends MaterialBase {
+
+	constructor( parameters?: DenoiseMaterialParameters );
+
+	sigma: number;
+	kSigma: number;
+	threshold: number;
+	map: Texture | null;
+
+}
+
+export interface FogVolumeMaterialParameters extends MeshStandardMaterialParameters {
+
+	density?: number;
+
+}
+
+export class FogVolumeMaterial extends MeshStandardMaterial {
+
+	constructor( parameters?: FogVolumeMaterialParameters );
+
+	readonly isFogVolumeMaterial: true;
+
+	density: number;
+
+}

package/src/index.js

@@ -1,9 +1,6 @@
 // core
-export * from './core/PathTracingRenderer.js';
-export * from './core/QuiltPathTracingRenderer.js';
 export * from './core/PathTracingSceneGenerator.js';
-export * from './core/DynamicPathTracingSceneGenerator.js';
-export * from './core/MaterialReducer.js';
+export * from './core/WebGLPathTracer.js';
 
 // objects
 export * from './objects/PhysicalCamera.js';
@@ -15,26 +12,13 @@ export * from './objects/ShapedAreaLight.js';
 export * from './textures/ProceduralEquirectTexture.js';
 export * from './textures/GradientEquirectTexture.js';
 
-// uniforms
-export * from './uniforms/MaterialsTexture.js';
-export * from './uniforms/RenderTarget2DArray.js';
-export * from './uniforms/EquirectHdrInfoUniform.js';
-export * from './uniforms/PhysicalCameraUniform.js';
-export * from './uniforms/LightsInfoUniformStruct.js';
-export * from './uniforms/IESProfilesTexture.js';
-
 // utils
-export * from './utils/GeometryPreparationUtils.js';
 export * from './utils/BlurredEnvMapGenerator.js';
-export * from './utils/IESLoader.js';
 
 // materials
 export * from './materials/fullscreen/DenoiseMaterial.js';
-export * from './materials/fullscreen/GradientMapMaterial.js';
-export * from './materials/debug/GraphMaterial.js';
-export * from './materials/MaterialBase.js';
-export * from './materials/pathtracing/PhysicalPathTracingMaterial.js';
 export * from './materials/surface/FogVolumeMaterial.js';
 
-// detectors
-export * from './detectors/CompatibilityDetector.js';
+// deprecated
+export * from './materials/pathtracing/PhysicalPathTracingMaterial.js';
+export * from './core/PathTracingRenderer.js';

package/src/materials/MaterialBase.js

@@ -37,6 +37,7 @@ export class MaterialBase extends ShaderMaterial {
 
 				delete this.defines[ name ];
 				this.needsUpdate = true;
+				return true;
 
 			}
 
@@ -46,11 +47,14 @@ export class MaterialBase extends ShaderMaterial {
 
 				this.defines[ name ] = value;
 				this.needsUpdate = true;
+				return true;
 
 			}
 
 		}
 
+		return false;
+
 	}
 
 }