rayzee 8.5.0 → 8.6.1

package/src/Processor/TextureCreator.js

@@ -1,8 +1,10 @@
-import { DataArrayTexture, RGBAFormat, LinearFilter, UnsignedByteType, SRGBColorSpace, LinearSRGBColorSpace, RepeatWrapping } from "three";
-import { alignBucketWidth, TEXTURE_CONSTANTS, MEMORY_CONSTANTS, DEFAULT_TEXTURE_MATRIX, MATERIAL_DATA_LAYOUT, normalizeAttenuationDistance, BVH_LEAF_MARKERS, assertBVHIndexFits, bvhIndexView } from '../EngineDefaults.js';
+import { DataArrayTexture, RGBAFormat, LinearFilter, UnsignedByteType, SRGBColorSpace, LinearSRGBColorSpace, RepeatWrapping, FloatType, HalfFloatType } from "three";
+import { alignBucketWidth, TEXTURE_CONSTANTS, MEMORY_CONSTANTS, MATERIAL_DATA_LAYOUT, BVH_LEAF_MARKERS, assertBVHIndexFits, bvhIndexView } from '../EngineDefaults.js';
+import { packMaterial } from './MaterialPacking.js';
 import TexturesWorker from './Workers/TexturesWorker.js?worker&inline';
 import { ISSUE_CODES } from '../EngineIssues.js';
 import { linearToSRGB } from './ToneMapCPU.js';
+import { getActiveColorManagement } from '../Color/ColorManagement.js';
 import { createLogger } from '../utils/Logger.js';
 
 const log = createLogger( 'textures' );
@@ -383,7 +385,11 @@ class TextureCache {
 				const height = texture.image.height || 0;
 				const src = texture.image.src || texture.uuid || '';
 				const flipFlag = texture.flipY === false ? 'n' : 'f';
-				hash += `${width}x${height}_${src.slice( - 8 )}_${flipFlag}_`;
+				// What the texture is read *as* is part of its identity: without these, changing a
+				// map's colour space handed back the array packed under the old one, and the change
+				// silently did nothing.
+				const space = `${texture.colorSpace ?? ''}|${texture.userData?.ocioColorSpace ?? ''}`;
+				hash += `${width}x${height}_${src.slice( - 8 )}_${flipFlag}_${space}_`;
 
 			}
 
@@ -572,6 +578,114 @@ export class TextureCreator {
 
 	}
 
+	/**
+	 * Convert each colour layer into the working space, once a config is loaded.
+	 *
+	 * Runs after `_harmonizeTransfer`, so every layer is stored the way the colour pool expects:
+	 * sRGB-encoded. Two routes from there:
+	 *
+	 *   - **Named** — a tag, an override or one of the config's file rules says what the texture is
+	 *     (ACEScct, a camera log, sRGB). The full OCIO transform runs on the bytes as stored. Runs
+	 *     whether or not a working space is adopted: a log-encoded texture is wrong in linear
+	 *     Rec.709 too.
+	 *   - **Primaries** — nothing explicit, so the texture is what three.js assumed. Only the
+	 *     primaries change, and only once a working space is adopted.
+	 *
+	 * The named route reads the bytes as the author stored them, so it is refused for a layer
+	 * harmonization re-encoded, and for a float source the packer already quantized — in both the
+	 * bytes are no longer in the space the name describes, and converting them would be confidently
+	 * wrong. Those fall back to the primaries route and say so.
+	 *
+	 * @param {import('three').DataArrayTexture} arrayTex
+	 * @param {Array<import('three').Texture>} textures - pre-normalization list, in layer order
+	 * @param {boolean} srgbPool
+	 * @param {Set<number>} [reencoded] - layers `_harmonizeTransfer` changed
+	 */
+	_applyColorManagement( arrayTex, textures, srgbPool, reencoded = new Set() ) {
+
+		const cm = getActiveColorManagement();
+		if ( ! cm?.hasConfig ) return;
+
+		const data = arrayTex?.image?.data;
+		if ( ! data ) return;
+
+		// A data pool carries numbers, not colour — a primaries matrix would corrupt it.
+		if ( ! srgbPool ) return;
+
+		const kept = textures.filter( t => t?.image );
+		const layerSize = arrayTex.image.width * arrayTex.image.height * 4;
+		const encoding = 'srgb';
+		let named = 0, primaries = 0;
+		const refused = [];
+
+		for ( let layer = 0; layer < kept.length; layer ++ ) {
+
+			const start = layer * layerSize;
+			const end = Math.min( start + layerSize, data.length );
+			if ( start >= data.length ) break;
+
+			const texture = kept[ layer ];
+			const view = data.subarray( start, end );
+
+			let resolved = null;
+			try {
+
+				resolved = cm.resolveTexture( texture );
+
+			} catch ( error ) {
+
+				log.warn( `could not resolve the colour space of layer ${layer}: ${error.message}` );
+
+			}
+
+			let space = resolved && resolved.via !== 'three' ? resolved.colorSpace : null;
+			const floatSource = texture.type === FloatType || texture.type === HalfFloatType;
+			if ( space && ( reencoded.has( layer ) || floatSource ) ) {
+
+				refused.push( `${texture.name || `layer ${layer}`} (${space})` );
+				space = null;
+
+			}
+
+			try {
+
+				if ( cm.convertTextureBytes( view, { space, encoding } ) ) {
+
+					if ( space ) named ++;
+					else primaries ++;
+
+				}
+
+			} catch ( error ) {
+
+				this._issues?.warn(
+					ISSUE_CODES.TEXTURE_PROCESSING_FALLBACK,
+					`colour conversion failed for layer ${layer} — left in its original space`,
+					{ cause: String( error?.message ?? error ), space }
+				);
+
+			}
+
+		}
+
+		if ( refused.length ) {
+
+			this._issues?.warn(
+				ISSUE_CODES.TEXTURE_PROCESSING_FALLBACK,
+				`${refused.length} colour map(s) name a colour space their stored bytes are no longer in ` +
+				'(re-encoded or quantized on the way in); converted by primaries only',
+				{ textures: refused.slice( 0, 8 ) }
+			);
+
+		}
+
+		if ( named + primaries === 0 ) return;
+
+		arrayTex.needsUpdate = true;
+		log.info( `colour maps into ${cm.workingSpace}: ${named} by named space, ${primaries} by primaries, of ${kept.length}` );
+
+	}
+
 	/**
 	 * Re-encodes any layer whose declared colour space disagrees with its pool, so the GPU's
 	 * decode — or absence of one — lands on the values the author stored. An untagged texture
@@ -583,8 +697,9 @@ export class TextureCreator {
 	 */
 	_harmonizeTransfer( arrayTex, textures, srgbPool ) {
 
+		const touched = new Set();
 		const data = arrayTex?.image?.data;
-		if ( ! data ) return;
+		if ( ! data ) return touched;
 
 		// Mirrors _normalizeTexturesForProcessing's skip rule, which is what sets layer order.
 		const kept = textures.filter( t => t?.image );
@@ -612,10 +727,11 @@ export class TextureCreator {
 			}
 
 			converted.push( kept[ layer ].name || kept[ layer ].source?.uuid?.slice( 0, 8 ) || `layer ${layer}` );
+			touched.add( layer );
 
 		}
 
-		if ( converted.length === 0 ) return;
+		if ( converted.length === 0 ) return touched;
 
 		arrayTex.needsUpdate = true;
 		const names = converted.slice( 0, 4 ).join( ', ' ) + ( converted.length > 4 ? `, +${converted.length - 4} more` : '' );
@@ -632,6 +748,8 @@ export class TextureCreator {
 
 		}
 
+		return touched;
+
 	}
 
 	// Unified texture processing with strategy selection
@@ -640,8 +758,13 @@ export class TextureCreator {
 		if ( ! textures || textures.length === 0 ) return null;
 
 		// Pool is part of the identity: the same list packed for the colour pool and the data pool
-		// gets different pixels (see _harmonizeTransfer), so one key must not serve both.
-		const cacheKey = `${srgbPool ? 's' : 'l'}:${this.textureCache.generateHash( textures )}`;
+		// gets different pixels (see _harmonizeTransfer), so one key must not serve both. The
+		// working space is part of it for the same reason — adopting one rewrites every colour
+		// map, and a key that ignored it would hand back pixels converted for the previous space.
+		// So is the config and any override, which change what a texture is read *as*.
+		const cm = getActiveColorManagement();
+		const colour = cm?.inputKey ?? '-';
+		const cacheKey = `${srgbPool ? 's' : 'l'}:${colour}:${this.textureCache.generateHash( textures )}`;
 		const cached = this.textureCache.get( cacheKey );
 		if ( cached ) return cached;
 
@@ -673,7 +796,8 @@ export class TextureCreator {
 			// Cache successful result
 			if ( result ) {
 
-				this._harmonizeTransfer( result, textures, srgbPool );
+				const reencoded = this._harmonizeTransfer( result, textures, srgbPool );
+				this._applyColorManagement( result, textures, srgbPool, reencoded );
 				this.textureCache.set( cacheKey, result );
 
 			}
@@ -688,7 +812,8 @@ export class TextureCreator {
 				{ cause: String( error?.message ?? error ) }
 			);
 			const fallback = await this.processOnMainThreadSync( normalized );
-			this._harmonizeTransfer( fallback, textures, srgbPool );
+			const reencoded = this._harmonizeTransfer( fallback, textures, srgbPool );
+			this._applyColorManagement( fallback, textures, srgbPool, reencoded );
 			return fallback;
 
 		} finally {
@@ -1036,88 +1161,9 @@ export class TextureCreator {
 	 */
 	createMaterialRawData( materials ) {
 
-		// Layout is defined by MATERIAL_DATA_LAYOUT in EngineDefaults.js.
-		// The inline array below must match that layout exactly (positional order = canonical layout).
-		const dataLengthPerMaterial = MATERIAL_DATA_LAYOUT.FLOATS_PER_MATERIAL;
-		const totalMaterials = materials.length;
-
-		const size = totalMaterials * dataLengthPerMaterial;
-		const data = new Float32Array( size );
-
-		for ( let i = 0; i < totalMaterials; i ++ ) {
-
-			const mat = materials[ i ];
-			const stride = i * dataLengthPerMaterial;
-
-			const mapMatrix = mat.mapMatrix ?? DEFAULT_TEXTURE_MATRIX;
-			const normalMapMatrices = mat.normalMapMatrices ?? DEFAULT_TEXTURE_MATRIX;
-			const roughnessMapMatrices = mat.roughnessMapMatrices ?? DEFAULT_TEXTURE_MATRIX;
-			const metalnessMapMatrices = mat.metalnessMapMatrices ?? DEFAULT_TEXTURE_MATRIX;
-			const emissiveMapMatrices = mat.emissiveMapMatrices ?? DEFAULT_TEXTURE_MATRIX;
-			const bumpMapMatrices = mat.bumpMapMatrices ?? DEFAULT_TEXTURE_MATRIX;
-			const displacementMapMatrices = mat.displacementMapMatrices ?? DEFAULT_TEXTURE_MATRIX;
-
-			// Slot order: shadow/culling → BxDF core → maps → extended → displacement → transforms
-			// Must match MATERIAL_DATA_LAYOUT in EngineDefaults.js exactly.
-			const materialData = [
-				// Slot 0: shadow core (ior, transmission, thickness, emissiveIntensity)
-				mat.ior, 					mat.transmission, 			mat.thickness, 				mat.emissiveIntensity,
-				// Slot 1: shadow (attenuationColor, attenuationDistance)
-				mat.attenuationColor.r, 	mat.attenuationColor.g, 	mat.attenuationColor.b, 	normalizeAttenuationDistance( mat.attenuationDistance ),
-				// Slot 2: shadow + culling (opacity, side, transparent, alphaTest)
-				mat.opacity, 				mat.side, 					mat.transparent, 			mat.alphaTest,
-				// Slot 3: shadow (alphaMode, depthWrite, normalScale)
-				mat.alphaMode, 				mat.depthWrite, 			mat.normalScale?.x ?? 1, 	mat.normalScale?.y ?? 1,
-				// Slot 4: BxDF core (color, metalness)
-				mat.color.r, 				mat.color.g, 				mat.color.b, 				mat.metalness,
-				// Slot 5: BxDF core (emissive, roughness)
-				mat.emissive.r, 			mat.emissive.g, 			mat.emissive.b, 			mat.roughness,
-				// Slot 6: map indices A (albedo, normal, roughness, metalness)
-				mat.map, 					mat.normalMap, 				mat.roughnessMap, 			mat.metalnessMap,
-				// Slot 7: map indices B (emissive, bump, clearcoat, clearcoatRoughness)
-				mat.emissiveMap, 			mat.bumpMap, 				mat.clearcoat, 				mat.clearcoatRoughness,
-				// Slot 8: extended BxDF (dispersion, visible, sheen, sheenRoughness)
-				mat.dispersion, 			mat.visible, 				mat.sheen, 					mat.sheenRoughness,
-				// Slot 9: extended BxDF (sheenColor, reserved)
-				mat.sheenColor.r, 			mat.sheenColor.g, 			mat.sheenColor.b, 			1,
-				// Slot 10: extended BxDF (specularIntensity, specularColor)
-				mat.specularIntensity, 		mat.specularColor.r, 		mat.specularColor.g, 		mat.specularColor.b,
-				// Slot 11: extended BxDF (iridescence)
-				mat.iridescence, 			mat.iridescenceIOR, 		mat.iridescenceThicknessRange[ 0 ], mat.iridescenceThicknessRange[ 1 ],
-				// Slot 12: displacement
-				mat.bumpScale,				mat.displacementScale,		mat.displacementMap,		0,
-				mapMatrix[ 0 ], 			mapMatrix[ 1 ], 			mapMatrix[ 2 ], 			mapMatrix[ 3 ],
-				mapMatrix[ 4 ], 			mapMatrix[ 5 ], 			mapMatrix[ 6 ], 			mapMatrix[ 7 ],
-				normalMapMatrices[ 0 ], 	normalMapMatrices[ 1 ], 	normalMapMatrices[ 2 ], 	normalMapMatrices[ 3 ],
-				normalMapMatrices[ 4 ], 	normalMapMatrices[ 5 ], 	normalMapMatrices[ 6 ], 	normalMapMatrices[ 7 ],
-				roughnessMapMatrices[ 0 ], 	roughnessMapMatrices[ 1 ], 	roughnessMapMatrices[ 2 ], 	roughnessMapMatrices[ 3 ],
-				roughnessMapMatrices[ 4 ], 	roughnessMapMatrices[ 5 ], 	roughnessMapMatrices[ 6 ], 	roughnessMapMatrices[ 7 ],
-				metalnessMapMatrices[ 0 ], 	metalnessMapMatrices[ 1 ], 	metalnessMapMatrices[ 2 ], 	metalnessMapMatrices[ 3 ],
-				metalnessMapMatrices[ 4 ], 	metalnessMapMatrices[ 5 ], 	metalnessMapMatrices[ 6 ], 	metalnessMapMatrices[ 7 ],
-				emissiveMapMatrices[ 0 ], 	emissiveMapMatrices[ 1 ], 	emissiveMapMatrices[ 2 ], 	emissiveMapMatrices[ 3 ],
-				emissiveMapMatrices[ 4 ], 	emissiveMapMatrices[ 5 ], 	emissiveMapMatrices[ 6 ], 	emissiveMapMatrices[ 7 ],
-				bumpMapMatrices[ 0 ], 		bumpMapMatrices[ 1 ], 		bumpMapMatrices[ 2 ], 		bumpMapMatrices[ 3 ],
-				bumpMapMatrices[ 4 ], 		bumpMapMatrices[ 5 ],	 	bumpMapMatrices[ 6 ], 		bumpMapMatrices[ 7 ],
-				displacementMapMatrices[ 0 ], displacementMapMatrices[ 1 ], displacementMapMatrices[ 2 ], displacementMapMatrices[ 3 ],
-				displacementMapMatrices[ 4 ], displacementMapMatrices[ 5 ], displacementMapMatrices[ 6 ], displacementMapMatrices[ 7 ],
-				// Slot 27: subsurface (subsurfaceColor.rgb, subsurface weight)
-				mat.subsurfaceColor?.r ?? 1,	mat.subsurfaceColor?.g ?? 1,	mat.subsurfaceColor?.b ?? 1,	mat.subsurface ?? 0,
-				// Slot 28: subsurface (subsurfaceRadius.rgb, subsurfaceRadiusScale)
-				mat.subsurfaceRadius?.[ 0 ] ?? 1, mat.subsurfaceRadius?.[ 1 ] ?? 0.2, mat.subsurfaceRadius?.[ 2 ] ?? 0.1, mat.subsurfaceRadiusScale ?? 1,
-				// Slot 29: subsurfaceAnisotropy g + surface anisotropy (strength, rotation, map index)
-				mat.subsurfaceAnisotropy ?? 0,	mat.anisotropy ?? 0,	mat.anisotropyRotation ?? 0,	mat.anisotropyMap ?? - 1,
-				// Slot 30: extension map indices A (transmission, clearcoat, clearcoatRoughness, sheenColor)
-				mat.transmissionMap ?? - 1,	mat.clearcoatMap ?? - 1,	mat.clearcoatRoughnessMap ?? - 1,	mat.sheenColorMap ?? - 1,
-				// Slot 31: extension map indices B (sheenRoughness, iridescence, iridescenceThickness, specularIntensity)
-				mat.sheenRoughnessMap ?? - 1,	mat.iridescenceMap ?? - 1,	mat.iridescenceThicknessMap ?? - 1,	mat.specularIntensityMap ?? - 1,
-				// Slot 32: extension map indices C (specularColor + 3 reserved)
-				mat.specularColorMap ?? - 1,	0,	0,	0,
-			];
-
-			data.set( materialData, stride );
-
-		}
-
+		const stride = MATERIAL_DATA_LAYOUT.FLOATS_PER_MATERIAL;
+		const data = new Float32Array( materials.length * stride );
+		for ( let i = 0; i < materials.length; i ++ ) packMaterial( data, i * stride, materials[ i ] );
 		return data;
 
 	}

package/src/Processor/TextureReadback.js

@@ -0,0 +1,92 @@
+/**
+ * Any texture the pipeline publishes, read back as linear float RGBA.
+ *
+ * The denoisers publish their output as whatever they happen to own — a render target's texture,
+ * or, for OIDN, an ExternalTexture wrapping a raw GPUTexture that no render target owns — and only a
+ * render target can be read back. So this draws the texture into one float target of its own and
+ * reads that.
+ *
+ * ⚠️ Drawn through `outputNode`, not `colorNode`: a colour node gets the renderer's tone mapping,
+ * output transfer and a forced alpha of 1, and this has to return the light itself.
+ */
+
+import { RenderTarget, FloatType, RGBAFormat, NearestFilter } from 'three';
+import { QuadMesh, NodeMaterial } from 'three/webgpu';
+import { texture as tslTexture, screenCoordinate, ivec2 } from 'three/tsl';
+
+export class TextureReadback {
+
+	constructor( renderer ) {
+
+		this.renderer = renderer;
+		this.target = null;
+		this.material = new NodeMaterial();
+		this.material.name = 'rayzee:texture-readback';
+		this.quad = new QuadMesh( this.material );
+		this._node = null;
+		this._source = null;
+
+	}
+
+	_ensureTarget( width, height ) {
+
+		if ( this.target && this.target.width === width && this.target.height === height ) return;
+
+		this.target?.dispose();
+		this.target = new RenderTarget( width, height, {
+			type: FloatType, format: RGBAFormat, depthBuffer: false,
+			minFilter: NearestFilter, magFilter: NearestFilter,
+		} );
+
+	}
+
+	/**
+	 * @param {import('three').Texture} source
+	 * @returns {Promise<Float32Array>} `width * height * 4`, top row first
+	 */
+	async read( source, width, height ) {
+
+		this._ensureTarget( width, height );
+
+		if ( this._source !== source ) {
+
+			// Fetched by pixel, not sampled over 0..1: the pools are allocated larger than the frame,
+			// and sampling would squash the whole allocation into it.
+			this._node = tslTexture( source ).load( ivec2( screenCoordinate.xy ) );
+			this.material.outputNode = this._node;
+			this.material.needsUpdate = true;
+			this._source = source;
+
+		}
+
+		const previous = this.renderer.getRenderTarget();
+		this.renderer.setRenderTarget( this.target );
+		this.quad.render( this.renderer );
+		this.renderer.setRenderTarget( previous );
+
+		try {
+
+			return await this.renderer.readRenderTargetPixelsAsync( this.target, 0, 0, width, height );
+
+		} finally {
+
+			// A float target the size of the frame — 132 MB at 4K — for something done once per
+			// saved file. Not worth keeping between saves.
+			this.target.dispose();
+			this.target = null;
+
+		}
+
+	}
+
+	dispose() {
+
+		this.target?.dispose();
+		this.material.dispose();
+		this.target = null;
+		this._source = null;
+		this._node = null;
+
+	}
+
+}