rayzee 7.10.3 → 7.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rayzee",
-  "version": "7.10.3",
+  "version": "7.11.1",
   "type": "module",
   "description": "Real-time WebGPU path tracing engine built on Three.js",
   "main": "dist/rayzee.umd.js",

package/src/EngineDefaults.js

@@ -390,8 +390,8 @@ export const TRIANGLE_DATA_LAYOUT = {
 // Shared between CPU writers (TextureCreator, MaterialDataManager) and GPU readers (Common.js getMaterial).
 export const MATERIAL_DATA_LAYOUT = {
 
-	SLOTS_PER_MATERIAL: 30, // vec4 slots per material
-	FLOATS_PER_MATERIAL: 120, // total floats per material (30 × 4)
+	SLOTS_PER_MATERIAL: 33, // vec4 slots per material
+	FLOATS_PER_MATERIAL: 132, // total floats per material (33 × 4)
 
 	// ── Flat float offsets (CPU side) ────────────────────────────────
 	// Used as: data[ materialIndex * FLOATS_PER_MATERIAL + offset ]
@@ -438,8 +438,14 @@ export const MATERIAL_DATA_LAYOUT = {
 	SUBSURFACE_COLOR: 108, SUBSURFACE: 111,
 	// Slot 28: subsurfaceRadius.rgb (mean free path) + radius scale
 	SUBSURFACE_RADIUS: 112, SUBSURFACE_RADIUS_SCALE: 115,
-	// Slot 29: anisotropy g (floats 117-119 reserved for future SSS)
-	SUBSURFACE_ANISOTROPY: 116,
+	// Slot 29: subsurfaceAnisotropy g (116) + surface anisotropy (strength 117, rotation 118, map index 119)
+	SUBSURFACE_ANISOTROPY: 116, ANISOTROPY: 117, ANISOTROPY_ROTATION: 118, ANISOTROPY_MAP_INDEX: 119,
+	// Slot 30: extension-texture map indices A (transmission, clearcoat, clearcoatRoughness, sheenColor)
+	TRANSMISSION_MAP_INDEX: 120, CLEARCOAT_MAP_INDEX: 121, CLEARCOAT_ROUGHNESS_MAP_INDEX: 122, SHEEN_COLOR_MAP_INDEX: 123,
+	// Slot 31: extension-texture map indices B (sheenRoughness, iridescence, iridescenceThickness, specularIntensity)
+	SHEEN_ROUGHNESS_MAP_INDEX: 124, IRIDESCENCE_MAP_INDEX: 125, IRIDESCENCE_THICKNESS_MAP_INDEX: 126, SPECULAR_INTENSITY_MAP_INDEX: 127,
+	// Slot 32: extension-texture map indices C (specularColor + 3 reserved)
+	SPECULAR_COLOR_MAP_INDEX: 128,
 
 	// ── Vec4 slot indices (GPU/TSL side) ─────────────────────────────
 	// Used with getDatafromStorageBuffer( buf, matIdx, int(slot), int(SLOTS_PER_MATERIAL) )
@@ -466,7 +472,10 @@ export const MATERIAL_DATA_LAYOUT = {
 		DISPLACEMENT_TRANSFORM_A: 25, DISPLACEMENT_TRANSFORM_B: 26,
 		SUBSURFACE_A: 27, // subsurfaceColor.rgb, subsurface weight
 		SUBSURFACE_B: 28, // subsurfaceRadius.rgb, subsurfaceRadiusScale
-		SUBSURFACE_C: 29, // subsurfaceAnisotropy, reserved
+		SUBSURFACE_C: 29, // subsurfaceAnisotropy g, anisotropy, anisotropyRotation, anisotropyMapIndex
+		EXT_MAP_INDICES_A: 30, // transmission, clearcoat, clearcoatRoughness, sheenColor map indices
+		EXT_MAP_INDICES_B: 31, // sheenRoughness, iridescence, iridescenceThickness, specularIntensity map indices
+		EXT_MAP_INDICES_C: 32, // specularColor map index + 3 reserved
 	},
 
 };

package/src/Processor/AssetLoader.js

@@ -1590,6 +1590,17 @@ export class AssetLoader extends EventDispatcher {
 
 			}
 
+			// glTF punctual point/spot intensity is candela (W/sr); the engine's light
+			// model is Blender-style Power (W) that LightSerializer divides by 4π. Convert
+			// glTF candela → Power once at import (×4π) so it nets to the correct I/d².
+			// Directional (lux ≈ irradiance) is used directly and needs no conversion.
+			if ( ( object.isPointLight || object.isSpotLight ) && ! userData.__candelaConverted ) {
+
+				object.intensity *= 4 * Math.PI;
+				userData.__candelaConverted = true;
+
+			}
+
 			// Process ceiling lights
 			if ( object.name.startsWith( 'RectAreaLightPlaceholder' ) &&
 				userData.name

package/src/Processor/GeometryExtractor.js

@@ -292,7 +292,10 @@ export class GeometryExtractor {
 			subsurfaceColor: new Color( 0xffffff ),
 			subsurfaceRadius: [ 1.0, 0.2, 0.1 ], // skin-like: red travels furthest
 			subsurfaceRadiusScale: 1.0,
-			subsurfaceAnisotropy: 0.0
+			subsurfaceAnisotropy: 0.0,
+			// Surface specular anisotropy (native MeshPhysicalMaterial / KHR_materials_anisotropy)
+			anisotropy: 0.0,
+			anisotropyRotation: 0.0
 		};
 
 	}
@@ -399,7 +402,9 @@ export class GeometryExtractor {
 			emissiveIntensity: legacyMapping.emissiveIntensity ?? material.emissiveIntensity ?? defaults.emissiveIntensity,
 
 			// Surface properties
-			roughness: Math.max( 0.05, legacyMapping.roughness ?? material.roughness ?? defaults.roughness ),
+			// Floor at 0.02 (the sampler's own VNDF-PDF clamp, MaterialProperties.js) rather than
+			// 0.05, so near-mirror metals stay sharp without entering a new firefly regime.
+			roughness: Math.max( 0.02, legacyMapping.roughness ?? material.roughness ?? defaults.roughness ),
 			metalness: legacyMapping.metalness ?? material.metalness ?? defaults.metalness,
 
 			// Optical properties
@@ -430,6 +435,10 @@ export class GeometryExtractor {
 			subsurfaceRadiusScale: material.subsurfaceRadiusScale ?? defaults.subsurfaceRadiusScale,
 			subsurfaceAnisotropy: material.subsurfaceAnisotropy ?? defaults.subsurfaceAnisotropy,
 
+			// Surface specular anisotropy (native MeshPhysicalMaterial / KHR_materials_anisotropy)
+			anisotropy: material.anisotropy ?? defaults.anisotropy,
+			anisotropyRotation: material.anisotropyRotation ?? defaults.anisotropyRotation,
+
 			// Specular properties (for compatibility)
 			specularIntensity: legacyMapping.specularIntensity ?? material.specularIntensity ?? defaults.specularIntensity,
 			specularColor: legacyMapping.specularColor ?? material.specularColor ?? defaults.specularColor,
@@ -456,18 +465,21 @@ export class GeometryExtractor {
 			metalnessMap: this.processTexture( material.metalnessMap, this.metalnessMaps ),
 			emissiveMap: this.processTexture( material.emissiveMap, this.emissiveMaps ),
 			displacementMap: this.processTexture( material.displacementMap, this.displacementMaps ),
-
-			// Advanced texture maps (MeshPhysicalMaterial only)
-			clearcoatMap: this.processTexture( material.clearcoatMap, [] ),
-			clearcoatRoughnessMap: this.processTexture( material.clearcoatRoughnessMap, [] ),
-			transmissionMap: this.processTexture( material.transmissionMap, [] ),
+			anisotropyMap: this.processTexture( material.anisotropyMap, this.anisotropyMaps ),
+
+			// Advanced texture maps (MeshPhysicalMaterial only). Folded into their scalar factors
+			// in ShadeKernel (applyExtensionMaps). thicknessMap stays dropped — thickness has no
+			// render effect yet (see gap-plan Phase 4.4).
+			clearcoatMap: this.processTexture( material.clearcoatMap, this.clearcoatMaps ),
+			clearcoatRoughnessMap: this.processTexture( material.clearcoatRoughnessMap, this.clearcoatRoughnessMaps ),
+			transmissionMap: this.processTexture( material.transmissionMap, this.transmissionMaps ),
 			thicknessMap: this.processTexture( material.thicknessMap, [] ),
-			sheenColorMap: this.processTexture( material.sheenColorMap, [] ),
-			sheenRoughnessMap: this.processTexture( material.sheenRoughnessMap, [] ),
-			specularIntensityMap: this.processTexture( material.specularIntensityMap, [] ),
-			specularColorMap: this.processTexture( material.specularColorMap, [] ),
-			iridescenceMap: this.processTexture( material.iridescenceMap, [] ),
-			iridescenceThicknessMap: this.processTexture( material.iridescenceThicknessMap, [] ),
+			sheenColorMap: this.processTexture( material.sheenColorMap, this.sheenColorMaps ),
+			sheenRoughnessMap: this.processTexture( material.sheenRoughnessMap, this.sheenRoughnessMaps ),
+			specularIntensityMap: this.processTexture( material.specularIntensityMap, this.specularIntensityMaps ),
+			specularColorMap: this.processTexture( material.specularColorMap, this.specularColorMaps ),
+			iridescenceMap: this.processTexture( material.iridescenceMap, this.iridescenceMaps ),
+			iridescenceThicknessMap: this.processTexture( material.iridescenceThicknessMap, this.iridescenceThicknessMaps ),
 
 			// Texture transformation matrices
 			mapMatrix: this.getTextureMatrix( material.map ),
@@ -819,6 +831,16 @@ export class GeometryExtractor {
 		this.emissiveMaps = [];
 		this.roughnessMaps = [];
 		this.displacementMaps = [];
+		this.anisotropyMaps = [];
+		this.transmissionMaps = [];
+		this.clearcoatMaps = [];
+		this.clearcoatRoughnessMaps = [];
+		this.sheenColorMaps = [];
+		this.sheenRoughnessMaps = [];
+		this.iridescenceMaps = [];
+		this.iridescenceThicknessMaps = [];
+		this.specularIntensityMaps = [];
+		this.specularColorMaps = [];
 		this.directionalLights = [];
 		this.cameras = [];
 
@@ -857,6 +879,16 @@ export class GeometryExtractor {
 			emissiveMaps: this.emissiveMaps,
 			roughnessMaps: this.roughnessMaps,
 			displacementMaps: this.displacementMaps,
+			anisotropyMaps: this.anisotropyMaps,
+			transmissionMaps: this.transmissionMaps,
+			clearcoatMaps: this.clearcoatMaps,
+			clearcoatRoughnessMaps: this.clearcoatRoughnessMaps,
+			sheenColorMaps: this.sheenColorMaps,
+			sheenRoughnessMaps: this.sheenRoughnessMaps,
+			iridescenceMaps: this.iridescenceMaps,
+			iridescenceThicknessMaps: this.iridescenceThicknessMaps,
+			specularIntensityMaps: this.specularIntensityMaps,
+			specularColorMaps: this.specularColorMaps,
 			directionalLights: this.directionalLights,
 			cameras: this.cameras,
 			sceneFeatures: this.sceneFeatures // Scene-wide material feature flags

package/src/Processor/SceneProcessor.js

@@ -63,6 +63,16 @@ export class SceneProcessor {
 		this.metalnessMaps = [];
 		this.emissiveMaps = [];
 		this.displacementMaps = [];
+		this.anisotropyMaps = [];
+		this.transmissionMaps = [];
+		this.clearcoatMaps = [];
+		this.clearcoatRoughnessMaps = [];
+		this.sheenColorMaps = [];
+		this.sheenRoughnessMaps = [];
+		this.iridescenceMaps = [];
+		this.iridescenceThicknessMaps = [];
+		this.specularIntensityMaps = [];
+		this.specularColorMaps = [];
 		this.directionalLights = [];
 		this.cameras = [];
 		this.spheres = [];
@@ -320,6 +330,16 @@ export class SceneProcessor {
 			this.metalnessMaps = extractedData.metalnessMaps;
 			this.emissiveMaps = extractedData.emissiveMaps;
 			this.displacementMaps = extractedData.displacementMaps;
+			this.anisotropyMaps = extractedData.anisotropyMaps;
+			this.transmissionMaps = extractedData.transmissionMaps;
+			this.clearcoatMaps = extractedData.clearcoatMaps;
+			this.clearcoatRoughnessMaps = extractedData.clearcoatRoughnessMaps;
+			this.sheenColorMaps = extractedData.sheenColorMaps;
+			this.sheenRoughnessMaps = extractedData.sheenRoughnessMaps;
+			this.iridescenceMaps = extractedData.iridescenceMaps;
+			this.iridescenceThicknessMaps = extractedData.iridescenceThicknessMaps;
+			this.specularIntensityMaps = extractedData.specularIntensityMaps;
+			this.specularColorMaps = extractedData.specularColorMaps;
 			this.directionalLights = extractedData.directionalLights;
 			this.cameras = extractedData.cameras;
 			this.sceneFeatures = extractedData.sceneFeatures; // Store material feature flags for shader optimization
@@ -883,6 +903,17 @@ export class SceneProcessor {
 			roughness: remapType( this.roughnessMaps, linearLists, linearDedup, this._linearTexPacked ),
 			metalness: remapType( this.metalnessMaps, linearLists, linearDedup, this._linearTexPacked ),
 			displacement: remapType( this.displacementMaps, linearLists, linearDedup, this._linearTexPacked ),
+			anisotropy: remapType( this.anisotropyMaps, linearLists, linearDedup, this._linearTexPacked ),
+			// Extension maps — data maps → linear pool; color maps (sheenColor, specularColor) → sRGB pool.
+			transmission: remapType( this.transmissionMaps, linearLists, linearDedup, this._linearTexPacked ),
+			clearcoat: remapType( this.clearcoatMaps, linearLists, linearDedup, this._linearTexPacked ),
+			clearcoatRoughness: remapType( this.clearcoatRoughnessMaps, linearLists, linearDedup, this._linearTexPacked ),
+			sheenColor: remapType( this.sheenColorMaps, srgbLists, srgbDedup, this._srgbTexPacked ),
+			sheenRoughness: remapType( this.sheenRoughnessMaps, linearLists, linearDedup, this._linearTexPacked ),
+			iridescence: remapType( this.iridescenceMaps, linearLists, linearDedup, this._linearTexPacked ),
+			iridescenceThickness: remapType( this.iridescenceThicknessMaps, linearLists, linearDedup, this._linearTexPacked ),
+			specularIntensity: remapType( this.specularIntensityMaps, linearLists, linearDedup, this._linearTexPacked ),
+			specularColor: remapType( this.specularColorMaps, srgbLists, srgbDedup, this._srgbTexPacked ),
 		};
 
 		return { srgbLists, linearLists, remap };
@@ -907,6 +938,16 @@ export class SceneProcessor {
 			mat.roughnessMap = fix( mat.roughnessMap, remap.roughness );
 			mat.metalnessMap = fix( mat.metalnessMap, remap.metalness );
 			mat.displacementMap = fix( mat.displacementMap, remap.displacement );
+			mat.anisotropyMap = fix( mat.anisotropyMap, remap.anisotropy );
+			mat.transmissionMap = fix( mat.transmissionMap, remap.transmission );
+			mat.clearcoatMap = fix( mat.clearcoatMap, remap.clearcoat );
+			mat.clearcoatRoughnessMap = fix( mat.clearcoatRoughnessMap, remap.clearcoatRoughness );
+			mat.sheenColorMap = fix( mat.sheenColorMap, remap.sheenColor );
+			mat.sheenRoughnessMap = fix( mat.sheenRoughnessMap, remap.sheenRoughness );
+			mat.iridescenceMap = fix( mat.iridescenceMap, remap.iridescence );
+			mat.iridescenceThicknessMap = fix( mat.iridescenceThicknessMap, remap.iridescenceThickness );
+			mat.specularIntensityMap = fix( mat.specularIntensityMap, remap.specularIntensity );
+			mat.specularColorMap = fix( mat.specularColorMap, remap.specularColor );
 
 		}
 
@@ -984,6 +1025,16 @@ export class SceneProcessor {
 		this.metalnessMaps = [];
 		this.emissiveMaps = [];
 		this.displacementMaps = [];
+		this.anisotropyMaps = [];
+		this.transmissionMaps = [];
+		this.clearcoatMaps = [];
+		this.clearcoatRoughnessMaps = [];
+		this.sheenColorMaps = [];
+		this.sheenRoughnessMaps = [];
+		this.iridescenceMaps = [];
+		this.iridescenceThicknessMaps = [];
+		this.specularIntensityMaps = [];
+		this.specularColorMaps = [];
 		this.directionalLights = [];
 		this.cameras = [];
 		this.spheres = [];

package/src/Processor/ShaderBuilder.js

@@ -19,6 +19,7 @@ export class ShaderBuilder {
 		// Previous-frame texture nodes (sample from MRT RenderTarget)
 		this.prevColorTexNode = null;
 		this.prevAlbedoTexNode = null;
+		this.prevNormalDepthTexNode = null;
 
 		// Scene texture nodes cache (for in-place updates on model change)
 		this._sceneTextureNodes = null;
@@ -98,6 +99,7 @@ export class ShaderBuilder {
 		const readTextures = storageTextures.getReadTextures();
 		this.prevColorTexNode = texture( readTextures.color );
 		this.prevAlbedoTexNode = texture( readTextures.albedo );
+		this.prevNormalDepthTexNode = texture( readTextures.normalDepth );
 
 		const createArrayPlaceholder = () => {
 
@@ -137,6 +139,7 @@ export class ShaderBuilder {
 
 		this.prevColorTexNode = null;
 		this.prevAlbedoTexNode = null;
+		this.prevNormalDepthTexNode = null;
 		this._sceneTextureNodes = null;
 
 	}

package/src/Processor/TextureCreator.js

@@ -1,4 +1,4 @@
-import { DataArrayTexture, RGBAFormat, LinearFilter, UnsignedByteType, SRGBColorSpace } from "three";
+import { DataArrayTexture, RGBAFormat, LinearFilter, UnsignedByteType, SRGBColorSpace, RepeatWrapping } from "three";
 import { TEXTURE_CONSTANTS, MEMORY_CONSTANTS, DEFAULT_TEXTURE_MATRIX, MATERIAL_DATA_LAYOUT } from '../EngineDefaults.js';
 import { fetchAsWorker } from './Workers/fetchAsWorker.js';
 import TEXTURES_WORKER_URL from './Workers/TexturesWorker.js?worker&url';
@@ -983,25 +983,31 @@ export class TextureCreator {
 				// Slot 12: displacement
 				mat.bumpScale,				mat.displacementScale,		mat.displacementMap,		0,
 				mapMatrix[ 0 ], 			mapMatrix[ 1 ], 			mapMatrix[ 2 ], 			mapMatrix[ 3 ],
-				mapMatrix[ 4 ], 			mapMatrix[ 5 ], 			mapMatrix[ 6 ], 			1,
+				mapMatrix[ 4 ], 			mapMatrix[ 5 ], 			mapMatrix[ 6 ], 			mapMatrix[ 7 ],
 				normalMapMatrices[ 0 ], 	normalMapMatrices[ 1 ], 	normalMapMatrices[ 2 ], 	normalMapMatrices[ 3 ],
-				normalMapMatrices[ 4 ], 	normalMapMatrices[ 5 ], 	normalMapMatrices[ 6 ], 	1,
+				normalMapMatrices[ 4 ], 	normalMapMatrices[ 5 ], 	normalMapMatrices[ 6 ], 	normalMapMatrices[ 7 ],
 				roughnessMapMatrices[ 0 ], 	roughnessMapMatrices[ 1 ], 	roughnessMapMatrices[ 2 ], 	roughnessMapMatrices[ 3 ],
-				roughnessMapMatrices[ 4 ], 	roughnessMapMatrices[ 5 ], 	roughnessMapMatrices[ 6 ], 	1,
+				roughnessMapMatrices[ 4 ], 	roughnessMapMatrices[ 5 ], 	roughnessMapMatrices[ 6 ], 	roughnessMapMatrices[ 7 ],
 				metalnessMapMatrices[ 0 ], 	metalnessMapMatrices[ 1 ], 	metalnessMapMatrices[ 2 ], 	metalnessMapMatrices[ 3 ],
-				metalnessMapMatrices[ 4 ], 	metalnessMapMatrices[ 5 ], 	metalnessMapMatrices[ 6 ], 	1,
+				metalnessMapMatrices[ 4 ], 	metalnessMapMatrices[ 5 ], 	metalnessMapMatrices[ 6 ], 	metalnessMapMatrices[ 7 ],
 				emissiveMapMatrices[ 0 ], 	emissiveMapMatrices[ 1 ], 	emissiveMapMatrices[ 2 ], 	emissiveMapMatrices[ 3 ],
-				emissiveMapMatrices[ 4 ], 	emissiveMapMatrices[ 5 ], 	emissiveMapMatrices[ 6 ], 	1,
+				emissiveMapMatrices[ 4 ], 	emissiveMapMatrices[ 5 ], 	emissiveMapMatrices[ 6 ], 	emissiveMapMatrices[ 7 ],
 				bumpMapMatrices[ 0 ], 		bumpMapMatrices[ 1 ], 		bumpMapMatrices[ 2 ], 		bumpMapMatrices[ 3 ],
-				bumpMapMatrices[ 4 ], 		bumpMapMatrices[ 5 ],	 	bumpMapMatrices[ 6 ], 		1,
+				bumpMapMatrices[ 4 ], 		bumpMapMatrices[ 5 ],	 	bumpMapMatrices[ 6 ], 		bumpMapMatrices[ 7 ],
 				displacementMapMatrices[ 0 ], displacementMapMatrices[ 1 ], displacementMapMatrices[ 2 ], displacementMapMatrices[ 3 ],
-				displacementMapMatrices[ 4 ], displacementMapMatrices[ 5 ], displacementMapMatrices[ 6 ], 1,
+				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: subsurface (anisotropy g, reserved)
-				mat.subsurfaceAnisotropy ?? 0,	0,	0,	0,
+				// 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 );
@@ -1314,6 +1320,11 @@ export class TextureCreator {
 
 		texture.minFilter = LinearFilter;
 		texture.magFilter = LinearFilter;
+		// glTF's default sampler wrap is REPEAT; array layers are independent (not an atlas),
+		// so per-layer repeat is safe and lets tiling UVs (outside [0,1]) tile instead of
+		// clamping. MIRRORED_REPEAT / per-texture wrap is a follow-up (not stored per-slot yet).
+		texture.wrapS = RepeatWrapping;
+		texture.wrapT = RepeatWrapping;
 		texture.format = RGBAFormat;
 		texture.type = UnsignedByteType;
 		texture.needsUpdate = true;

package/src/Stages/PathTracer.js

@@ -46,6 +46,11 @@ export class PathTracer extends PathTracerStage {
 		// uniform — NOT baked — so DenoisingManager can toggle it without a (UI-freezing) kernel rebuild.
 		this._auxGBufferEnabled = false;
 		this._auxGBufferUniform = uniform( 0, 'uint' );
+		// Clean-aux mode: temporally accumulate + renormalize the aux NORMAL (like albedo) so a clean-aux
+		// OIDN model (calb_cnrm/high, alb_nrm/balanced) gets the prefiltered-ish normal it expects instead
+		// of the point-sampled per-frame value that leaks noise. Off for fast/ASVGF (they want the bump normal).
+		this._cleanAuxNormalEnabled = false;
+		this._cleanAuxNormalUniform = uniform( 0, 'uint' );
 
 		// CPU sizes per-bounce kernels from last frame's survivor curve; kernels bound on ENTERING_COUNT so over-sizing is safe. (indirect dispatch not viable — three.js doesn't sync compute-written indirect buffers across submissions)
 		this._useDynamicDispatch = true;
@@ -220,6 +225,7 @@ export class PathTracer extends PathTracerStage {
 
 			this.shaderBuilder.prevColorTexNode.value = readTextures.color;
 			this.shaderBuilder.prevAlbedoTexNode.value = readTextures.albedo;
+			this.shaderBuilder.prevNormalDepthTexNode.value = readTextures.normalDepth;
 
 		}
 
@@ -410,6 +416,19 @@ export class PathTracer extends PathTracerStage {
 
 	}
 
+	// Clean-aux normal: when a clean-aux OIDN model is active (calb_cnrm/high, alb_nrm/balanced), FinalWrite
+	// temporally accumulates + renormalizes the aux normal so the model isn't fed per-frame point-sampled
+	// noise. DenoisingManager calls this on OIDN enable + quality change. Live uniform → value flip + reset.
+	setCleanAuxNormal( enabled ) {
+
+		enabled = !! enabled;
+		if ( this._cleanAuxNormalEnabled === enabled ) return;
+		this._cleanAuxNormalEnabled = enabled;
+		this._cleanAuxNormalUniform.value = enabled ? 1 : 0;
+		this.reset();
+
+	}
+
 	// UI-driven resize (Resolution dropdown) — parent bypasses _handleResize(), so hook here too.
 	setSize( width, height ) {
 
@@ -605,6 +624,7 @@ export class PathTracer extends PathTracerStage {
 
 		const prevColor = this.shaderBuilder.prevColorTexNode;
 		const prevAlbedo = this.shaderBuilder.prevAlbedoTexNode;
+		const prevNormalDepth = this.shaderBuilder.prevNormalDepthTexNode;
 		const writeTex = this.storageTextures.getWriteTextures();
 
 		const counters = qm.getCounters();
@@ -907,10 +927,12 @@ export class PathTracer extends PathTracerStage {
 			transparentBackground: this.transparentBackground,
 			prevAccumTexture: prevColor,
 			prevAlbedoTexture: prevAlbedo,
+			prevNormalDepthTexture: prevNormalDepth,
 			renderWidth: this._wfRenderWidth,
 			renderHeight: this._wfRenderHeight,
 			visMode: this.visMode,
 			auxGBufferEnabled: this._auxGBufferUniform,
+			cleanAuxNormalEnabled: this._cleanAuxNormalUniform,
 		} );
 		this._kernelManager.register( 'finalWrite',
 			// Per-pixel (w×h) — kernel averages the S sample-slots internally.

package/src/TSL/Clearcoat.js

@@ -2,6 +2,7 @@ import {
 	Fn,
 	vec3,
 	float,
+	dot,
 	normalize,
 	reflect,
 	max,
@@ -10,10 +11,10 @@ import {
 
 import { struct } from './patches.js';
 
-import { DotProducts } from './Struct.js';
-import { PI, MIN_CLEARCOAT_ROUGHNESS, computeDotProducts } from './Common.js';
-import { DistributionGGX } from './MaterialProperties.js';
-import { ImportanceSampleGGX, ImportanceSampleCosine } from './MaterialSampling.js';
+import { AnisoFrame, DotProducts } from './Struct.js';
+import { PI, MIN_CLEARCOAT_ROUGHNESS, computeDotProductsAniso, anisoTangentFrame } from './Common.js';
+import { DistributionGGX, computeAnisoAlphas, calculateVNDFPDFAniso } from './MaterialProperties.js';
+import { ImportanceSampleGGX, ImportanceSampleCosine, sampleGGXVNDFAniso } from './MaterialSampling.js';
 import { evaluateLayeredBRDF } from './MaterialEvaluation.js';
 import { RandomValue } from './Random.js';
 
@@ -62,8 +63,20 @@ export const sampleClearcoat = Fn( ( [
 
 	} ).ElseIf( rand.lessThan( clearcoatWeight.add( specularWeight ) ), () => {
 
-		// Sample base specular
-		H.assign( ImportanceSampleGGX( { N, roughness: baseRoughness, Xi: randomSample } ) );
+		// Sample base specular (anisotropic VNDF when anisotropy > 0)
+		If( material.anisotropy.greaterThan( 0.0 ), () => {
+
+			const f = AnisoFrame.wrap( anisoTangentFrame( N, material.anisotropyRotation ) );
+			const localV = vec3( dot( V, f.Ta ), dot( V, f.Ba ), dot( V, N ) );
+			const a = computeAnisoAlphas( material.roughness, material.anisotropy );
+			const localH = sampleGGXVNDFAniso( { V: localV, alphaX: a.x, alphaY: a.y, Xi: randomSample } );
+			H.assign( f.Ta.mul( localH.x ).add( f.Ba.mul( localH.y ) ).add( N.mul( localH.z ) ) );
+
+		} ).Else( () => {
+
+			H.assign( ImportanceSampleGGX( { N, roughness: baseRoughness, Xi: randomSample } ) );
+
+		} );
 		L.assign( reflect( V.negate(), H ) );
 
 	} ).Else( () => {
@@ -74,12 +87,23 @@ export const sampleClearcoat = Fn( ( [
 
 	} );
 
-	// Calculate dot products
-	const dots = DotProducts.wrap( computeDotProducts( N, V, L ) );
+	// Calculate dot products (aniso-aware: also projects onto the anisotropy frame)
+	const dots = DotProducts.wrap( computeDotProductsAniso( N, V, L, material ) );
 
-	// Calculate individual PDFs
+	// Calculate individual PDFs. Clearcoat layer is always isotropic; the base specular
+	// matches its sampler — VNDF-aniso when anisotropy>0, else the half-vector GGX pdf.
 	const clearcoatPDF = DistributionGGX( dots.NoH, clearcoatRoughness ).mul( dots.NoH ).div( float( 4.0 ).mul( dots.VoH ) ).mul( clearcoatWeight );
-	const specularPDF = DistributionGGX( dots.NoH, baseRoughness ).mul( dots.NoH ).div( float( 4.0 ).mul( dots.VoH ) ).mul( specularWeight );
+	const specularPDF = float( 0.0 ).toVar();
+	If( material.anisotropy.greaterThan( 0.0 ), () => {
+
+		const a = computeAnisoAlphas( material.roughness, material.anisotropy );
+		specularPDF.assign( calculateVNDFPDFAniso( a.x, a.y, dots.NoH, dots.ToH, dots.BoH, dots.NoV, dots.ToV, dots.BoV ).mul( specularWeight ) );
+
+	} ).Else( () => {
+
+		specularPDF.assign( DistributionGGX( dots.NoH, baseRoughness ).mul( dots.NoH ).div( float( 4.0 ).mul( dots.VoH ) ).mul( specularWeight ) );
+
+	} );
 	const diffusePDF = dots.NoL.div( PI ).mul( diffuseWeight );
 
 	// Combined PDF using MIS

package/src/TSL/Common.js

@@ -1,6 +1,7 @@
 import { Fn, wgslFn, float, vec2, vec3, vec4, int, mat3, If, max, dot, clamp, bool as tslBool } from 'three/tsl';
 
 import {
+	AnisoFrame,
 	DotProducts,
 	MaterialClassification,
 	MISStrategy,
@@ -155,6 +156,58 @@ export const computeDotProducts = Fn( ( [ N, V, L ] ) => {
 		NoH: max( dot( N, H ), 0.001 ),
 		VoH: max( dot( V, H ), 0.001 ),
 		LoH: max( dot( L, H ), 0.001 ),
+		ToH: float( 0.0 ), BoH: float( 0.0 ),
+		ToV: float( 0.0 ), BoV: float( 0.0 ),
+		ToL: float( 0.0 ), BoL: float( 0.0 ),
+	} );
+
+} );
+
+// Anisotropy tangent frame: arbitrary ONB from N (matching constructTBN + normal mapping),
+// rotated by anisotropyRotation. Single source of truth for sampler AND eval/PDF so their
+// frames are bit-identical (required for MIS consistency).
+export const anisoTangentFrame = Fn( ( [ N, rotation ] ) => {
+
+	const majorAxis = N.x.abs().lessThan( 0.999 ).select( vec3( 1.0, 0.0, 0.0 ), vec3( 0.0, 1.0, 0.0 ) );
+	const T0 = N.cross( majorAxis ).normalize();
+	const B0 = N.cross( T0 ).normalize();
+	const c = rotation.cos();
+	const s = rotation.sin();
+	return AnisoFrame( { Ta: T0.mul( c ).add( B0.mul( s ) ), Ba: B0.mul( c ).sub( T0.mul( s ) ) } );
+
+} );
+
+// Anisotropy-aware dot products: computeDotProducts + tangent-frame projections of H/V/L
+// (0 for isotropic materials, so aniso branches gated on anisotropy>0 are a no-op).
+export const computeDotProductsAniso = Fn( ( [ N, V, L, material ] ) => {
+
+	const H = V.add( L ).toVar();
+	const lenSq = dot( H, H ).toVar();
+	H.assign( lenSq.greaterThan( EPSILON ).select( H.div( lenSq.sqrt() ), vec3( 0.0, 0.0, 1.0 ) ) );
+
+	const ToH = float( 0.0 ).toVar();
+	const BoH = float( 0.0 ).toVar();
+	const ToV = float( 0.0 ).toVar();
+	const BoV = float( 0.0 ).toVar();
+	const ToL = float( 0.0 ).toVar();
+	const BoL = float( 0.0 ).toVar();
+
+	If( material.anisotropy.greaterThan( 0.0 ), () => {
+
+		const f = AnisoFrame.wrap( anisoTangentFrame( N, material.anisotropyRotation ) );
+		ToH.assign( dot( f.Ta, H ) ); BoH.assign( dot( f.Ba, H ) );
+		ToV.assign( dot( f.Ta, V ) ); BoV.assign( dot( f.Ba, V ) );
+		ToL.assign( dot( f.Ta, L ) ); BoL.assign( dot( f.Ba, L ) );
+
+	} );
+
+	return DotProducts( {
+		NoL: max( dot( N, L ), 0.001 ),
+		NoV: max( dot( N, V ), 0.001 ),
+		NoH: max( dot( N, H ), 0.001 ),
+		VoH: max( dot( V, H ), 0.001 ),
+		LoH: max( dot( L, H ), 0.001 ),
+		ToH, BoH, ToV, BoV, ToL, BoL,
 	} );
 
 } );
@@ -345,6 +398,9 @@ export const getMaterial = Fn( ( [ materialIndex, materialBuffer ] ) => {
 	const data27 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.SUBSURFACE_A ), int( MATERIAL_SLOTS ) ).toVar();
 	const data28 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.SUBSURFACE_B ), int( MATERIAL_SLOTS ) ).toVar();
 	const data29 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.SUBSURFACE_C ), int( MATERIAL_SLOTS ) ).toVar();
+	const data30 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.EXT_MAP_INDICES_A ), int( MATERIAL_SLOTS ) ).toVar();
+	const data31 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.EXT_MAP_INDICES_B ), int( MATERIAL_SLOTS ) ).toVar();
+	const data32 = getDatafromStorageBuffer( materialBuffer, materialIndex, int( S.EXT_MAP_INDICES_C ), int( MATERIAL_SLOTS ) ).toVar();
 
 	return RayTracingMaterial( {
 		color: vec4( data0.rgb, 1.0 ),
@@ -371,6 +427,18 @@ export const getMaterial = Fn( ( [ materialIndex, materialBuffer ] ) => {
 		subsurfaceRadius: data28.rgb,
 		subsurfaceRadiusScale: data28.a,
 		subsurfaceAnisotropy: data29.r,
+		anisotropy: data29.g,
+		anisotropyRotation: data29.b,
+		anisotropyMapIndex: int( data29.a ),
+		transmissionMapIndex: int( data30.r ),
+		clearcoatMapIndex: int( data30.g ),
+		clearcoatRoughnessMapIndex: int( data30.b ),
+		sheenColorMapIndex: int( data30.a ),
+		sheenRoughnessMapIndex: int( data31.r ),
+		iridescenceMapIndex: int( data31.g ),
+		iridescenceThicknessMapIndex: int( data31.b ),
+		specularIntensityMapIndex: int( data31.a ),
+		specularColorMapIndex: int( data32.r ),
 		albedoMapIndex: int( data8.r ),
 		normalMapIndex: int( data8.g ),
 		roughnessMapIndex: int( data8.b ),
@@ -458,6 +526,18 @@ export const diffuseGroundMaterial = Fn( () => {
 		subsurfaceRadius: vec3( 1.0, 0.2, 0.1 ),
 		subsurfaceRadiusScale: float( 1.0 ),
 		subsurfaceAnisotropy: float( 0.0 ),
+		anisotropy: float( 0.0 ),
+		anisotropyRotation: float( 0.0 ),
+		anisotropyMapIndex: int( - 1 ),
+		transmissionMapIndex: int( - 1 ),
+		clearcoatMapIndex: int( - 1 ),
+		clearcoatRoughnessMapIndex: int( - 1 ),
+		sheenColorMapIndex: int( - 1 ),
+		sheenRoughnessMapIndex: int( - 1 ),
+		iridescenceMapIndex: int( - 1 ),
+		iridescenceThicknessMapIndex: int( - 1 ),
+		specularIntensityMapIndex: int( - 1 ),
+		specularColorMapIndex: int( - 1 ),
 	} );
 
 } );

package/src/TSL/EmissiveSampling.js

@@ -26,7 +26,7 @@ import {
 } from 'three/tsl';
 
 import { struct } from './patches.js';
-import { MIN_PDF, getDatafromStorageBuffer, powerHeuristic, MATERIAL_SLOTS, MATERIAL_SLOT, computeDotProducts } from './Common.js';
+import { MIN_PDF, getDatafromStorageBuffer, powerHeuristic, MATERIAL_SLOTS, MATERIAL_SLOT, computeDotProductsAniso } from './Common.js';
 import { RandomValue } from './Random.js';
 import { calculateMaterialPDFFromDots } from './LightsSampling.js';
 import { evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
@@ -573,7 +573,7 @@ export const calculateEmissiveTriangleContributionDebug = Fn( ( [
 
 					// Share H + dot products between BRDF eval and PDF (computeDotProducts
 					// would otherwise run twice with identical inputs).
-					const dots = DotProducts.wrap( computeDotProducts( normal, viewDir, emissiveSample.direction ) );
+					const dots = DotProducts.wrap( computeDotProductsAniso( normal, viewDir, emissiveSample.direction, material ) );
 					const brdfValue = evaluateMaterialResponseFromDots( material, dots );
 					const brdfPdf = calculateMaterialPDFFromDots( material, dots );