rayzee 7.10.3 → 7.11.1

package/src/TSL/Struct.js

@@ -55,6 +55,33 @@ export const RayTracingMaterial = struct( {
 	subsurfaceRadius: 'vec3', // per-channel mean free path
 	subsurfaceRadiusScale: 'float', // scalar multiplier on radius
 	subsurfaceAnisotropy: 'float', // Henyey-Greenstein g (-1..1)
+	anisotropy: 'float', // surface specular anisotropy strength (0..1)
+	anisotropyRotation: 'float', // anisotropy tangent rotation (radians)
+	anisotropyMapIndex: 'int', // packed linear-bucket index, -1 if none
+	// Extension-texture map indices (packed bucket index, -1 if none). Fold applied in ShadeKernel.
+	transmissionMapIndex: 'int',
+	clearcoatMapIndex: 'int',
+	clearcoatRoughnessMapIndex: 'int',
+	sheenColorMapIndex: 'int',
+	sheenRoughnessMapIndex: 'int',
+	iridescenceMapIndex: 'int',
+	iridescenceThicknessMapIndex: 'int',
+	specularIntensityMapIndex: 'int',
+	specularColorMapIndex: 'int',
+} );
+
+// Result of folding the glTF extension textures into their scalar factors (applyExtensionMaps).
+// Each field is the material's scalar × the sampled map channel (or the scalar unchanged if no map).
+export const ExtMapResult = struct( {
+	transmission: 'float',
+	clearcoat: 'float',
+	clearcoatRoughness: 'float',
+	sheenColor: 'vec3',
+	sheenRoughness: 'float',
+	iridescence: 'float',
+	iridescenceThickness: 'float', // resolved thin-film thickness → written into iridescenceThicknessRange.y
+	specularIntensity: 'float',
+	specularColor: 'vec3',
 } );
 
 // Lightweight material for shadow ray evaluation — only the fields needed
@@ -142,12 +169,24 @@ export const ImportanceSamplingInfo = struct( {
 	clearcoatImportance: 'float',
 } );
 
+// Anisotropy tangent frame in world space (rotated ONB). Shared by the sampler and
+// the eval/PDF so both derive the identical frame — see anisoTangentFrame().
+export const AnisoFrame = struct( {
+	Ta: 'vec3', // anisotropy tangent
+	Ba: 'vec3', // anisotropy bitangent
+} );
+
 export const DotProducts = struct( {
 	NoL: 'float', // Normal • Light
 	NoV: 'float', // Normal • View
 	NoH: 'float', // Normal • Half
 	VoH: 'float', // View • Half
 	LoH: 'float', // Light • Half
+	// Anisotropy tangent-frame projections (0 unless computed via computeDotProductsAniso).
+	// T = anisotropy tangent, B = anisotropy bitangent.
+	ToH: 'float', BoH: 'float',
+	ToV: 'float', BoV: 'float',
+	ToL: 'float', BoL: 'float',
 } );
 
 // Kulla-Conty DFG approximation outputs (computed once, consumed by both

package/src/TSL/TextureSampling.js

@@ -1,9 +1,10 @@
-import { Fn, wgslFn, float, vec2, vec3, vec4, int, If, normalize, cross, abs, mix, clamp, texture, textureSize } from 'three/tsl';
+import { Fn, wgslFn, float, vec2, vec3, vec4, int, If, normalize, cross, abs, atan, mix, clamp, texture, textureSize } from 'three/tsl';
 import { DataArrayTexture, LinearFilter } from 'three';
 
 import {
 	UVCache,
 	MaterialSamples,
+	ExtMapResult,
 } from './Struct.js';
 import { TEXTURE_CONSTANTS } from '../EngineDefaults.js';
 
@@ -431,6 +432,107 @@ export const processBump = Fn( ( [ currentNormal, material, uvCache ] ) => {
 
 } );
 
+// Fold the glTF anisotropyTexture (RG = tangent-space direction, B = strength) into scalar
+// (strength, rotationRadians) per three.js: anisotropy · R(rotation) · (normalize(rg·2−1)·b).
+// Caller guarantees anisotropyMapIndex >= 0. `uv` is pre-transformed by the caller (albedo transform).
+export const processAnisotropyMap = Fn( ( [ material, uv ] ) => {
+
+	const result = vec2( material.anisotropy, material.anisotropyRotation ).toVar();
+
+	const s = sampleBucket( _linearBuckets, material.anisotropyMapIndex, uv ).toVar();
+	const texDir = s.rg.mul( 2.0 ).sub( 1.0 ).toVar();
+	const dlen = texDir.length().toVar();
+
+	If( dlen.greaterThan( 1e-4 ), () => {
+
+		const u = texDir.div( dlen ).mul( s.b ).toVar(); // unit direction × texture strength
+		const c = material.anisotropyRotation.cos();
+		const sn = material.anisotropyRotation.sin();
+		const vx = material.anisotropy.mul( c.mul( u.x ).sub( sn.mul( u.y ) ) );
+		const vy = material.anisotropy.mul( sn.mul( u.x ).add( c.mul( u.y ) ) );
+		result.assign( vec2( clamp( vx.mul( vx ).add( vy.mul( vy ) ).sqrt(), 0.0, 1.0 ), atan( vy, vx ) ) );
+
+	} ).Else( () => {
+
+		result.assign( vec2( 0.0, material.anisotropyRotation ) );
+
+	} );
+
+	return result;
+
+} );
+
+// Fold the glTF extension textures into their scalar factors, per KHR_materials_* / three.js
+// channel conventions. Returns the modulated scalars (unchanged where a map is absent). `uv` is
+// pre-transformed by the caller with the material's albedo KHR_texture_transform (extension maps
+// share the base UV set/transform in practice). Color maps (sheenColor, specularColor) read the
+// sRGB pool; data maps read the linear pool.
+export const applyExtensionMaps = Fn( ( [ material, uv ] ) => {
+
+	const r = ExtMapResult( {
+		transmission: material.transmission,
+		clearcoat: material.clearcoat,
+		clearcoatRoughness: material.clearcoatRoughness,
+		sheenColor: material.sheenColor,
+		sheenRoughness: material.sheenRoughness,
+		iridescence: material.iridescence,
+		iridescenceThickness: material.iridescenceThicknessRange.y, // default = max (no-texture behavior)
+		specularIntensity: material.specularIntensity,
+		specularColor: material.specularColor,
+	} ).toVar();
+
+	If( material.transmissionMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		r.transmission.assign( r.transmission.mul( sampleBucket( _linearBuckets, material.transmissionMapIndex, uv ).r ) );
+
+	} );
+	If( material.clearcoatMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		r.clearcoat.assign( r.clearcoat.mul( sampleBucket( _linearBuckets, material.clearcoatMapIndex, uv ).r ) );
+
+	} );
+	If( material.clearcoatRoughnessMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		r.clearcoatRoughness.assign( r.clearcoatRoughness.mul( sampleBucket( _linearBuckets, material.clearcoatRoughnessMapIndex, uv ).g ) );
+
+	} );
+	If( material.sheenColorMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		r.sheenColor.assign( r.sheenColor.mul( sampleBucket( _srgbBuckets, material.sheenColorMapIndex, uv ).rgb ) );
+
+	} );
+	If( material.sheenRoughnessMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		// clamp to [0.05,1] to keep parity with the sample/PDF floor applied in ShadeKernel
+		r.sheenRoughness.assign( clamp( r.sheenRoughness.mul( sampleBucket( _linearBuckets, material.sheenRoughnessMapIndex, uv ).a ), 0.05, 1.0 ) );
+
+	} );
+	If( material.iridescenceMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		r.iridescence.assign( r.iridescence.mul( sampleBucket( _linearBuckets, material.iridescenceMapIndex, uv ).r ) );
+
+	} );
+	If( material.iridescenceThicknessMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		const g = sampleBucket( _linearBuckets, material.iridescenceThicknessMapIndex, uv ).g;
+		r.iridescenceThickness.assign( mix( material.iridescenceThicknessRange.x, material.iridescenceThicknessRange.y, g ) );
+
+	} );
+	If( material.specularIntensityMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		r.specularIntensity.assign( r.specularIntensity.mul( sampleBucket( _linearBuckets, material.specularIntensityMapIndex, uv ).a ) );
+
+	} );
+	If( material.specularColorMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+		r.specularColor.assign( r.specularColor.mul( sampleBucket( _srgbBuckets, material.specularColorMapIndex, uv ).rgb ) );
+
+	} );
+
+	return r;
+
+} );
+
 export const processEmissive = Fn( ( [ material, uvCache ] ) => {
 
 	const emissionBase = material.emissive.mul( material.emissiveIntensity ).toVar();

package/src/managers/DenoisingManager.js

@@ -368,6 +368,10 @@ export class DenoisingManager extends EventDispatcher {
 		// MRT read-targets directly). When none are active the wavefront skips those writes entirely.
 		s.pathTracer?.setAuxGBufferEnabled?.( normalNeeded || !! this.denoiser?.enabled );
 
+		// Clean-aux normal: temporally accumulate the aux normal only for OIDN clean-aux models
+		// (balanced/high). 'fast' and the real-time denoisers keep the point-sampled bump normal.
+		s.pathTracer?.setCleanAuxNormal?.( !! this.denoiser?.enabled && this.denoiser?.quality !== 'fast' );
+
 		// Reclaim VRAM: free the big 2048² StorageTextures of any denoiser/G-buffer stage that ended up
 		// disabled (lazily re-created on the next dispatch after re-enable). Every strategy/denoiser
 		// toggle funnels through here after the enabled flags above are settled, so this is the one
@@ -610,6 +614,8 @@ export class DenoisingManager extends EventDispatcher {
 	setOIDNQuality( quality ) {
 
 		this.denoiser?.updateQuality( quality );
+		// Clean-aux normal follows the model: balanced/high (clean-aux models) → accumulate; fast → keep bump.
+		this._stages.pathTracer?.setCleanAuxNormal?.( !! this.denoiser?.enabled && quality !== 'fast' );
 
 	}
 

package/src/managers/MaterialDataManager.js

@@ -329,6 +329,8 @@ export class MaterialDataManager {
 			case 'subsurface': data[ stride + M.SUBSURFACE ] = value; break;
 			case 'subsurfaceRadiusScale': data[ stride + M.SUBSURFACE_RADIUS_SCALE ] = value; break;
 			case 'subsurfaceAnisotropy': data[ stride + M.SUBSURFACE_ANISOTROPY ] = value; break;
+			case 'anisotropy': data[ stride + M.ANISOTROPY ] = value; break;
+			case 'anisotropyRotation': data[ stride + M.ANISOTROPY_ROTATION ] = value; break;
 			case 'subsurfaceColor':
 				if ( value.r !== undefined ) {
 
@@ -521,7 +523,25 @@ export class MaterialDataManager {
 		data[ stride + M.SUBSURFACE_RADIUS_SCALE ] = materialData.subsurfaceRadiusScale ?? 1;
 		data[ stride + M.SUBSURFACE_ANISOTROPY ] = materialData.subsurfaceAnisotropy ?? 0;
 
-		// Texture transformation matrices (9 floats each, identity if missing)
+		// Surface specular anisotropy (map index defaults to -1 = none)
+		data[ stride + M.ANISOTROPY ] = materialData.anisotropy ?? 0;
+		data[ stride + M.ANISOTROPY_ROTATION ] = materialData.anisotropyRotation ?? 0;
+		data[ stride + M.ANISOTROPY_MAP_INDEX ] = materialData.anisotropyMap ?? - 1;
+
+		// Extension-texture map indices (packed bucket index, -1 = none)
+		data[ stride + M.TRANSMISSION_MAP_INDEX ] = materialData.transmissionMap ?? - 1;
+		data[ stride + M.CLEARCOAT_MAP_INDEX ] = materialData.clearcoatMap ?? - 1;
+		data[ stride + M.CLEARCOAT_ROUGHNESS_MAP_INDEX ] = materialData.clearcoatRoughnessMap ?? - 1;
+		data[ stride + M.SHEEN_COLOR_MAP_INDEX ] = materialData.sheenColorMap ?? - 1;
+		data[ stride + M.SHEEN_ROUGHNESS_MAP_INDEX ] = materialData.sheenRoughnessMap ?? - 1;
+		data[ stride + M.IRIDESCENCE_MAP_INDEX ] = materialData.iridescenceMap ?? - 1;
+		data[ stride + M.IRIDESCENCE_THICKNESS_MAP_INDEX ] = materialData.iridescenceThicknessMap ?? - 1;
+		data[ stride + M.SPECULAR_INTENSITY_MAP_INDEX ] = materialData.specularIntensityMap ?? - 1;
+		data[ stride + M.SPECULAR_COLOR_MAP_INDEX ] = materialData.specularColorMap ?? - 1;
+
+		// Texture transformation matrices (8 floats per slot = matrix elements[0..7];
+		// element[8]=1 is reconstructed on the GPU by arrayToMat3, so it is NOT stored —
+		// writing a 9th float here would spill into the next slot / subsurfaceColor).
 		const identity = [ 1, 0, 0, 0, 1, 0, 0, 0, 1 ];
 		const transformEntries = [
 			{ key: 'mapMatrix', offset: M.ALBEDO_TRANSFORM },
@@ -536,7 +556,7 @@ export class MaterialDataManager {
 		for ( const { key, offset } of transformEntries ) {
 
 			const matrix = materialData[ key ] ?? identity;
-			for ( let i = 0; i < 9; i ++ ) {
+			for ( let i = 0; i < 8; i ++ ) {
 
 				if ( stride + offset + i < data.length ) {
 
@@ -582,6 +602,17 @@ export class MaterialDataManager {
 			completeMaterialData.roughnessMap = this.getPackedTextureIndex( material.roughnessMap, false );
 			completeMaterialData.metalnessMap = this.getPackedTextureIndex( material.metalnessMap, false );
 			completeMaterialData.displacementMap = this.getPackedTextureIndex( material.displacementMap, false );
+			completeMaterialData.anisotropyMap = this.getPackedTextureIndex( material.anisotropyMap, false );
+			// Extension maps — color maps (sheenColor, specularColor) are sRGB; the rest are data (linear)
+			completeMaterialData.transmissionMap = this.getPackedTextureIndex( material.transmissionMap, false );
+			completeMaterialData.clearcoatMap = this.getPackedTextureIndex( material.clearcoatMap, false );
+			completeMaterialData.clearcoatRoughnessMap = this.getPackedTextureIndex( material.clearcoatRoughnessMap, false );
+			completeMaterialData.sheenColorMap = this.getPackedTextureIndex( material.sheenColorMap, true );
+			completeMaterialData.sheenRoughnessMap = this.getPackedTextureIndex( material.sheenRoughnessMap, false );
+			completeMaterialData.iridescenceMap = this.getPackedTextureIndex( material.iridescenceMap, false );
+			completeMaterialData.iridescenceThicknessMap = this.getPackedTextureIndex( material.iridescenceThicknessMap, false );
+			completeMaterialData.specularIntensityMap = this.getPackedTextureIndex( material.specularIntensityMap, false );
+			completeMaterialData.specularColorMap = this.getPackedTextureIndex( material.specularColorMap, true );
 
 		}
 
@@ -625,7 +656,9 @@ export class MaterialDataManager {
 
 		}
 
-		for ( let i = 0; i < 9; i ++ ) {
+		// 8 floats per slot (matrix elements[0..7]); element[8]=1 is GPU-reconstructed.
+		// Writing 9 would clobber the next transform slot's first element.
+		for ( let i = 0; i < 8; i ++ ) {
 
 			if ( stride + offset + i < data.length ) {