rayzee 7.10.2 → 7.11.0

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

@@ -248,6 +248,9 @@ export class DenoisingManager extends EventDispatcher {
 				break;
 
 			case 'edgeaware':
+				// EdgeAware is a spatial-only SVGF à-trous — it consumes the Variance
+				// stage's per-pixel variance to drive its luminance edge-stop.
+				if ( s.variance ) s.variance.enabled = true;
 				if ( s.edgeFilter ) s.edgeFilter.setFilteringEnabled( true );
 				break;
 

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 ) {