rayzee 7.10.3 → 7.11.1

package/src/TSL/FinalWriteKernel.js

@@ -4,7 +4,7 @@
 
 import {
 	Fn, wgslFn, float, vec2, vec4, int, uint, uvec2,
-	If, mix, select, texture, textureStore,
+	If, mix, select, texture, textureStore, length,
 	localId, workgroupId,
 } from 'three/tsl';
 
@@ -32,15 +32,19 @@ export function buildFinalWriteKernel( params ) {
 		resolution, frame,
 		enableAccumulation, hasPreviousAccumulated, accumulationAlpha, cameraIsMoving,
 		transparentBackground,
-		prevAccumTexture, prevAlbedoTexture,
+		prevAccumTexture, prevAlbedoTexture, prevNormalDepthTexture,
 		renderWidth, renderHeight,
 		visMode,
 		// Aux MRT (normalDepth + albedo) feeds only the denoiser/OIDN. Gated by a live uniform (1 = denoiser
 		// on): when off, skip the G-buffer decode, the prev-frame aux mix, and the two aux stores.
 		auxGBufferEnabled,
+		// Clean-aux normal (1 = temporally accumulate + renormalize the aux normal). On only for clean-aux
+		// OIDN models (calb_cnrm/high, alb_nrm/balanced); off for fast/ASVGF which want the bump normal.
+		cleanAuxNormalEnabled,
 	} = params;
 
 	const auxOn = auxGBufferEnabled.greaterThan( uint( 0 ) );
+	const cleanAuxNormalOn = cleanAuxNormalEnabled.greaterThan( uint( 0 ) );
 
 	const computeFn = Fn( () => {
 
@@ -80,12 +84,27 @@ export function buildFinalWriteKernel( params ) {
 				finalColor.assign( mix( prevAccumSample.xyz, sampleColor.xyz, accumulationAlpha ) );
 				If( auxOn, () => {
 
-					// Albedo averages cleanly (it's a colour). The NORMAL must NOT: averaging jittered
-					// unit normals collapses toward the flat geometric mean (worse at distance), which made
-					// OIDN smooth bump detail away. Keep this frame's point-sampled normal — it varies with
-					// the bump, which is exactly what OIDN's edge-stop needs to preserve it.
+					// Albedo averages cleanly (it's a colour).
 					finalAlbedo.assign( mix( texture( prevAlbedoTexture, prevUV, 0 ).xyz, finalAlbedo, accumulationAlpha ) );
 
+					// NORMAL: by default keep this frame's POINT-SAMPLED normal — it varies with the bump,
+					// which fast/ASVGF want to preserve edge detail. But a CLEAN-AUX OIDN model (calb_cnrm/high,
+					// alb_nrm/balanced) trusts the aux and is fed per-frame point-sampled NOISE → leaked noise
+					// (high) / over-smoothing (balanced). When cleanAuxNormalOn, temporally accumulate it like
+					// the colour. Average the RAW unit normals (decode 0.5+0.5 → [-1,1]) and RENORMALIZE — a
+					// plain encoded-space mix would bias toward the flat (0.5,0.5,1) mean and collapse detail.
+					// Depth (.w) stays this frame's value; guard the degenerate near-zero mean (opposing normals).
+					If( cleanAuxNormalOn, () => {
+
+						const prevN = texture( prevNormalDepthTexture, prevUV, 0 ).xyz.mul( 2.0 ).sub( 1.0 );
+						const curN = finalNormalDepth.xyz.mul( 2.0 ).sub( 1.0 ).toVar();
+						const mixedN = mix( prevN, curN, accumulationAlpha ).toVar();
+						const len = length( mixedN );
+						const avgN = select( len.greaterThan( 1e-4 ), mixedN.div( len ), curN );
+						finalNormalDepth.assign( vec4( avgN.mul( 0.5 ).add( 0.5 ), finalNormalDepth.w ) );
+
+					} );
+
 				} );
 
 				If( transparentBackground, () => {

package/src/TSL/LightsDirect.js

@@ -144,8 +144,9 @@ export const traceShadowRay = Fn( ( [
 
 			If( shadowMaterial.alphaMode.equal( int( 1 ) ), () => {
 
-				// MASK mode: binary alpha cutout
-				const effectiveAlpha = shadowMaterial.color.a.mul( texAlpha );
+				// MASK mode: binary alpha cutout. Include opacity (=baseColorFactor.a) so
+				// factor-only MASK cuts out; mirrors the BLEND branch and the camera path.
+				const effectiveAlpha = shadowMaterial.color.a.mul( texAlpha ).mul( shadowMaterial.opacity );
 				const cutoff = select( shadowMaterial.alphaTest.greaterThan( 0.0 ), shadowMaterial.alphaTest, float( 0.5 ) );
 				If( effectiveAlpha.lessThan( cutoff ), () => {
 

package/src/TSL/LightsIndirect.js

@@ -25,7 +25,6 @@ import {
 	abs,
 	sqrt,
 	dot,
-	normalize,
 	If,
 	select,
 } from 'three/tsl';
@@ -41,7 +40,7 @@ import {
 	EPSILON,
 	MIN_PDF,
 } from './Common.js';
-import { DistributionGGX, calculateVNDFPDF } from './MaterialProperties.js';
+import { DistributionGGX, calculateVNDFPDF, specularVNDFPDFForDir } from './MaterialProperties.js';
 import { evaluateMaterialResponse } from './MaterialEvaluation.js';
 import { RandomValue } from './Random.js';
 import { sampleMicrofacetTransmission, MicrofacetTransmissionResult } from './MaterialTransmission.js';
@@ -342,11 +341,9 @@ export const calculateIndirectLighting = Fn( ( [
 
 		If( weights.useSpecular, () => {
 
-			// Evaluate specular PDF at sampleDir (not brdfSampleDirection which may differ)
-			const H_spec = normalize( V.add( sampleDir ) );
-			const NoH_spec = max( dot( N, H_spec ), 0.001 );
-			const NoV_spec = max( dot( N, V ), 0.001 );
-			const specPdfAtSampleDir = calculateVNDFPDF( NoH_spec, NoV_spec, material.roughness );
+			// Evaluate specular PDF at sampleDir (not brdfSampleDirection which may differ);
+			// auto-selects iso/aniso to stay consistent with the BRDF sampler.
+			const specPdfAtSampleDir = specularVNDFPDFForDir( material, N, V, sampleDir );
 			combinedPdf.addAssign( weights.specularWeight.mul( specPdfAtSampleDir ) );
 
 		} );

package/src/TSL/LightsSampling.js

@@ -72,7 +72,7 @@ import {
 
 import { traverseBVHShadow } from './BVHTraversal.js';
 import { evaluateMaterialResponseFromDots } from './MaterialEvaluation.js';
-import { calculateVNDFPDF } from './MaterialProperties.js';
+import { calculateVNDFPDF, calculateVNDFPDFAniso, computeAnisoAlphas } from './MaterialProperties.js';
 import { RandomValue } from './Random.js';
 import {
 	selectOptimalMISStrategy,
@@ -81,7 +81,7 @@ import {
 	EPSILON,
 	powerHeuristic,
 	balanceHeuristic,
-	computeDotProducts,
+	computeDotProductsAniso,
 } from './Common.js';
 import {
 	sampleEquirectProbability,
@@ -737,7 +737,18 @@ export const calculateMaterialPDFFromDots = Fn( ( [ material, dots ] ) => {
 		If( specularWeight.greaterThan( 0.0 ).and( NoL.greaterThan( 0.0 ) ), () => {
 
 			const roughness = max( material.roughness, 0.02 );
-			pdf.addAssign( specularWeight.mul( calculateVNDFPDF( NoH, NoV, roughness ) ) );
+			const specPdf = float( 0.0 ).toVar();
+			If( material.anisotropy.greaterThan( 0.0 ), () => {
+
+				const a = computeAnisoAlphas( material.roughness, material.anisotropy );
+				specPdf.assign( calculateVNDFPDFAniso( a.x, a.y, dots.NoH, dots.ToH, dots.BoH, dots.NoV, dots.ToV, dots.BoV ) );
+
+			} ).Else( () => {
+
+				specPdf.assign( calculateVNDFPDF( NoH, NoV, roughness ) );
+
+			} );
+			pdf.addAssign( specularWeight.mul( specPdf ) );
 
 		} );
 
@@ -751,7 +762,7 @@ export const calculateMaterialPDFFromDots = Fn( ( [ material, dots ] ) => {
 // already have dots; otherwise prefer calculateMaterialPDFFromDots.
 export const calculateMaterialPDF = Fn( ( [ viewDir, lightDir, normal, material ] ) => {
 
-	const dots = DotProducts.wrap( computeDotProducts( normal, viewDir, lightDir ) );
+	const dots = DotProducts.wrap( computeDotProductsAniso( normal, viewDir, lightDir, material ) );
 	return calculateMaterialPDFFromDots( material, dots );
 
 } );
@@ -985,7 +996,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 						// Share H + dot products between BRDF eval and PDF — otherwise each
 						// would recompute normalize(V+L) + 5 dot products independently.
-						const sharedDots = DotProducts.wrap( computeDotProducts( hitNormal, viewDir, lightSample.direction ) );
+						const sharedDots = DotProducts.wrap( computeDotProductsAniso( hitNormal, viewDir, lightSample.direction, material ) );
 						const brdfValue = evaluateMaterialResponseFromDots( material, sharedDots );
 						const bPdf = calculateMaterialPDFFromDots( material, sharedDots ).toVar();
 
@@ -1187,7 +1198,7 @@ export const calculateDirectLightingUnified = Fn( ( [
 
 						// Share H + dots between env BRDF/PDF — same redundancy fix as the
 						// discrete-light path above.
-						const envDots = DotProducts.wrap( computeDotProducts( hitNormal, viewDir, envDirection ) );
+						const envDots = DotProducts.wrap( computeDotProductsAniso( hitNormal, viewDir, envDirection, material ) );
 						const brdfValue = evaluateMaterialResponseFromDots( material, envDots );
 						const bPdf = calculateMaterialPDFFromDots( material, envDots ).toVar();
 

package/src/TSL/MaterialEvaluation.js

@@ -6,11 +6,12 @@ import {
 import { DotProducts, DFGResult } from './Struct.js';
 import {
 	PI, PI_INV, EPSILON, MIN_CLEARCOAT_ROUGHNESS,
-	computeDotProducts,
+	computeDotProductsAniso,
 } from './Common.js';
 import { fresnelSchlick, fresnelSchlickFloat, dielectricF0 } from './Fresnel.js';
 import {
 	DistributionGGX, SheenDistribution, GeometrySmith, evaluateDFG,
+	computeAnisoAlphas, DistributionGGXAniso, VisibilityGGXAniso,
 } from './MaterialProperties.js';
 import { evalIridescence } from './MaterialProperties.js';
 
@@ -75,12 +76,25 @@ export const evaluateMaterialResponseFromDots = Fn( ( [ material, dots ] ) => {
 		} );
 
 		// Precalculate shared terms
-		const D = DistributionGGX( dots.NoH, material.roughness );
-		const G = GeometrySmith( dots.NoV, dots.NoL, material.roughness );
 		const F = fresnelSchlick( dots.VoH, F0 );
 
-		// Single-scatter specular BRDF
-		const specularSS = D.mul( G ).mul( F ).div( max( float( 4.0 ).mul( dots.NoV ).mul( dots.NoL ), EPSILON ) );
+		// Single-scatter specular BRDF (anisotropic when material.anisotropy > 0; the aniso
+		// visibility term already carries the 1/(4·NoV·NoL) denominator)
+		const specularSS = vec3( 0.0 ).toVar();
+		If( material.anisotropy.greaterThan( 0.0 ), () => {
+
+			const a = computeAnisoAlphas( material.roughness, material.anisotropy );
+			const Da = DistributionGGXAniso( a.x, a.y, dots.NoH, dots.ToH, dots.BoH );
+			const Va = VisibilityGGXAniso( a.x, a.y, dots.ToV, dots.BoV, dots.ToL, dots.BoL, dots.NoV, dots.NoL );
+			specularSS.assign( F.mul( Da.mul( Va ) ) );
+
+		} ).Else( () => {
+
+			const D = DistributionGGX( dots.NoH, material.roughness );
+			const G = GeometrySmith( dots.NoV, dots.NoL, material.roughness );
+			specularSS.assign( D.mul( G ).mul( F ).div( max( float( 4.0 ).mul( dots.NoV ).mul( dots.NoL ), EPSILON ) ) );
+
+		} );
 
 		// Shared DFG evaluation — compensation factor and total directional albedo
 		// come from the same polynomial.
@@ -123,7 +137,7 @@ export const evaluateMaterialResponseFromDots = Fn( ( [ material, dots ] ) => {
 // have dots; otherwise prefer evaluateMaterialResponseFromDots to share the work.
 export const evaluateMaterialResponse = Fn( ( [ V, L, N, material ] ) => {
 
-	const dots = DotProducts.wrap( computeDotProducts( N, V, L ) );
+	const dots = DotProducts.wrap( computeDotProductsAniso( N, V, L, material ) );
 	return evaluateMaterialResponseFromDots( material, dots );
 
 } );
@@ -143,10 +157,24 @@ export const evaluateLayeredBRDF = Fn( ( [ dots, material ] ) => {
 		vec3( 0.0 ), vec3( 1.0 )
 	).toVar();
 
-	const D = DistributionGGX( dots.NoH, material.roughness );
-	const G = GeometrySmith( dots.NoV, dots.NoL, material.roughness );
 	const F = fresnelSchlick( dots.VoH, F0 );
-	const baseBRDFSS = D.mul( G ).mul( F ).div( max( float( 4.0 ).mul( dots.NoV ).mul( dots.NoL ), EPSILON ) );
+
+	// Base specular (anisotropic when anisotropy > 0; aniso V term carries 1/(4·NoV·NoL))
+	const baseBRDFSS = vec3( 0.0 ).toVar();
+	If( material.anisotropy.greaterThan( 0.0 ), () => {
+
+		const a = computeAnisoAlphas( material.roughness, material.anisotropy );
+		const Da = DistributionGGXAniso( a.x, a.y, dots.NoH, dots.ToH, dots.BoH );
+		const Va = VisibilityGGXAniso( a.x, a.y, dots.ToV, dots.BoV, dots.ToL, dots.BoL, dots.NoV, dots.NoL );
+		baseBRDFSS.assign( F.mul( Da.mul( Va ) ) );
+
+	} ).Else( () => {
+
+		const D = DistributionGGX( dots.NoH, material.roughness );
+		const G = GeometrySmith( dots.NoV, dots.NoL, material.roughness );
+		baseBRDFSS.assign( D.mul( G ).mul( F ).div( max( float( 4.0 ).mul( dots.NoV ).mul( dots.NoL ), EPSILON ) ) );
+
+	} );
 
 	// Shared DFG evaluation — compensation factor and total directional albedo
 	// come from the same polynomial.

package/src/TSL/MaterialProperties.js

@@ -1,16 +1,17 @@
-import { Fn, float, vec3, int, If, dot, max, min, sqrt, cos, exp, mix, clamp, smoothstep } from 'three/tsl';
+import { Fn, float, vec2, vec3, int, If, dot, max, min, sqrt, cos, exp, mix, clamp, smoothstep } from 'three/tsl';
 
 import {
 	BRDFWeights,
 	MaterialCache,
 	ImportanceSamplingInfo,
 	DFGResult,
+	DotProducts,
 
 } from './Struct.js';
 
 import {
 	PI, TWO_PI, EPSILON, MIN_ROUGHNESS,
-	XYZ_TO_REC709, square,
+	XYZ_TO_REC709, square, computeDotProductsAniso,
 } from './Common.js';
 
 import {
@@ -124,6 +125,81 @@ export const calculateVNDFPDF = Fn( ( [ NoH, NoV, roughness ] ) => {
 
 } );
 
+// -----------------------------------------------------------------------------
+// Anisotropic GGX (Filament / three.js convention — matches WebGLRenderer/glTF)
+// -----------------------------------------------------------------------------
+// alphaB = roughness² (bitangent axis), alphaT = mix(roughness², 1, anisotropy²) (tangent axis).
+// Returns vec2( alphaT, alphaB ). Both floored so smooth anisotropic surfaces stay stable.
+export const computeAnisoAlphas = Fn( ( [ roughness, anisotropy ] ) => {
+
+	const alphaB = max( roughness.mul( roughness ), 1e-4 ).toVar();
+	const alphaT = max( mix( alphaB, float( 1.0 ), anisotropy.mul( anisotropy ) ), 1e-4 );
+	return vec2( alphaT, alphaB );
+
+} );
+
+// Anisotropic GGX normal distribution (Filament D_GGX_Anisotropic). Reduces exactly to
+// DistributionGGX when alphaT == alphaB.
+export const DistributionGGXAniso = Fn( ( [ alphaT, alphaB, NoH, ToH, BoH ] ) => {
+
+	const a2 = alphaT.mul( alphaB );
+	const v = vec3( alphaB.mul( ToH ), alphaT.mul( BoH ), a2.mul( NoH ) );
+	const v2 = max( dot( v, v ), EPSILON );
+	const w2 = a2.div( v2 );
+	return a2.mul( w2.mul( w2 ) ).div( PI );
+
+} );
+
+// Anisotropic Smith height-correlated visibility (three.js V_GGX_SmithCorrelated_Anisotropic).
+// Already includes the 1/(4·NoV·NoL) denominator — multiply directly by D and F.
+export const VisibilityGGXAniso = Fn( ( [ alphaT, alphaB, ToV, BoV, ToL, BoL, NoV, NoL ] ) => {
+
+	const gv = NoL.mul( vec3( alphaT.mul( ToV ), alphaB.mul( BoV ), NoV ).length() );
+	const gl = NoV.mul( vec3( alphaT.mul( ToL ), alphaB.mul( BoL ), NoL ).length() );
+	return float( 0.5 ).div( max( gv.add( gl ), EPSILON ) );
+
+} );
+
+// Anisotropic Smith masking G1 (for the VNDF pdf). G1 = 1 / (1 + Λ).
+export const smithG1Aniso = Fn( ( [ alphaT, alphaB, ToV, BoV, NoV ] ) => {
+
+	const t = alphaT.mul( ToV );
+	const b = alphaB.mul( BoV );
+	const num = t.mul( t ).add( b.mul( b ) );
+	const nov2 = max( NoV.mul( NoV ), EPSILON );
+	const lambda = sqrt( float( 1.0 ).add( num.div( nov2 ) ) ).sub( 1.0 ).mul( 0.5 );
+	return float( 1.0 ).div( lambda.add( 1.0 ) );
+
+} );
+
+// Anisotropic VNDF pdf over the reflected direction: G1(V)·D(H) / (4·NoV).
+export const calculateVNDFPDFAniso = Fn( ( [ alphaT, alphaB, NoH, ToH, BoH, NoV, ToV, BoV ] ) => {
+
+	const D = DistributionGGXAniso( alphaT, alphaB, NoH, ToH, BoH );
+	const G1 = smithG1Aniso( alphaT, alphaB, ToV, BoV, NoV );
+	return D.mul( G1 ).div( max( NoV.mul( 4.0 ), EPSILON ) );
+
+} );
+
+// Specular VNDF pdf (iso/aniso auto-select) for MIS sites that only have (N, V, L).
+export const specularVNDFPDFForDir = Fn( ( [ material, N, V, L ] ) => {
+
+	const dots = DotProducts.wrap( computeDotProductsAniso( N, V, L, material ) );
+	const pdf = float( 0.0 ).toVar();
+	If( material.anisotropy.greaterThan( 0.0 ), () => {
+
+		const a = computeAnisoAlphas( material.roughness, material.anisotropy );
+		pdf.assign( calculateVNDFPDFAniso( a.x, a.y, dots.NoH, dots.ToH, dots.BoH, dots.NoV, dots.ToV, dots.BoV ) );
+
+	} ).Else( () => {
+
+		pdf.assign( calculateVNDFPDF( dots.NoH, dots.NoV, max( material.roughness, 0.02 ) ) );
+
+	} );
+	return pdf;
+
+} );
+
 // -----------------------------------------------------------------------------
 // Iridescence Evaluation
 // -----------------------------------------------------------------------------

package/src/TSL/MaterialSampling.js

@@ -74,3 +74,22 @@ export const sampleGGXVNDF = /*@__PURE__*/ wgslFn( `
 		return normalize( vec3f( alpha * Nh.x, alpha * Nh.y, max( 0.0f, Nh.z ) ) );
 	}
 ` );
+
+// Anisotropic VNDF: identical to sampleGGXVNDF but stretches x/y by separate alphas.
+// V is in the anisotropy tangent frame (x=tangent, y=bitangent, z=normal); returns local H.
+export const sampleGGXVNDFAniso = /*@__PURE__*/ wgslFn( `
+	fn sampleGGXVNDFAniso( V: vec3f, alphaX: f32, alphaY: f32, Xi: vec2f ) -> vec3f {
+		let Vh = normalize( vec3f( alphaX * V.x, alphaY * V.y, V.z ) );
+		let lensq = Vh.x * Vh.x + Vh.y * Vh.y;
+		let T1 = select( vec3f( 1.0f, 0.0f, 0.0f ), vec3f( -Vh.y, Vh.x, 0.0f ) / sqrt( lensq ), lensq > 1e-8f );
+		let T2 = cross( Vh, T1 );
+		let r = sqrt( Xi.x );
+		let phi = 6.28318530717958647692f * Xi.y;
+		let t1 = r * cos( phi );
+		let t2tmp = r * sin( phi );
+		let s = 0.5f * ( 1.0f + Vh.z );
+		let t2 = ( 1.0f - s ) * sqrt( 1.0f - t1 * t1 ) + s * t2tmp;
+		let Nh = T1 * t1 + T2 * t2 + Vh * sqrt( max( 0.0f, 1.0f - t1 * t1 - t2 * t2 ) );
+		return normalize( vec3f( alphaX * Nh.x, alphaY * Nh.y, max( 0.0f, Nh.z ) ) );
+	}
+` );

package/src/TSL/MaterialTransmission.js

@@ -546,7 +546,9 @@ export const handleMaterialTransparency = Fn( ( [
 
 			const cutoff = select( material.alphaTest.greaterThan( 0.0 ), material.alphaTest, float( 0.5 ) );
 
-			If( material.color.a.lessThan( cutoff ), () => {
+			// Effective alpha = textureAlpha (in color.a) × baseColorFactor.a (opacity).
+			// color.a base is 1.0, so factor-only MASK (no albedo map) relies on opacity.
+			If( material.color.a.mul( material.opacity ).lessThan( cutoff ), () => {
 
 				result.continueRay.assign( true );
 				result.direction.assign( ray.direction );

package/src/TSL/PathTracerCore.js

@@ -33,15 +33,18 @@ import {
 	MIN_CLEARCOAT_ROUGHNESS,
 	MIN_PDF,
 	constructTBN,
+	anisoTangentFrame,
 	calculateFireflyThreshold,
 	applySoftSuppressionRGB,
 } from './Common.js';
-import { DirectionSample, MaterialCache } from './Struct.js';
+import { AnisoFrame, DirectionSample, MaterialCache } from './Struct.js';
 import { RandomValue } from './Random.js';
 import { sampleMicrofacetTransmission, MicrofacetTransmissionResult } from './MaterialTransmission.js';
 import {
 	SheenDistribution,
 	calculateVNDFPDF,
+	calculateVNDFPDFAniso,
+	computeAnisoAlphas,
 	calculateBRDFWeights,
 } from './MaterialProperties.js';
 import { evaluateMaterialResponse } from './MaterialEvaluation.js';
@@ -50,6 +53,7 @@ import {
 	ImportanceSampleCosine,
 	ImportanceSampleGGX,
 	sampleGGXVNDF,
+	sampleGGXVNDFAniso,
 } from './MaterialSampling.js';
 
 // =============================================================================
@@ -125,18 +129,39 @@ export const generateSampledDirection = Fn( ( [
 
 	} ).ElseIf( rand.lessThan( cumulativeSpecular ), () => {
 
-		const TBN = constructTBN( { N } );
-		const localV = TBN.transpose().mul( V );
+		If( material.anisotropy.greaterThan( 0.0 ), () => {
 
-		// VNDF sampling
-		const localH = sampleGGXVNDF( { V: localV, roughness: material.roughness, Xi: xi } );
-		H.assign( TBN.mul( localH ) );
+			// Shared frame → sampler and eval/PDF stay bit-identical (MIS consistency)
+			const f = AnisoFrame.wrap( anisoTangentFrame( N, material.anisotropyRotation ) );
+			const Ta = f.Ta;
+			const Ba = f.Ba;
 
-		const NoH = clamp( dot( N, H ), 0.001, 1.0 );
+			const localV = vec3( dot( V, Ta ), dot( V, Ba ), dot( V, N ) );
+			const a = computeAnisoAlphas( material.roughness, material.anisotropy );
+			const localH = sampleGGXVNDFAniso( { V: localV, alphaX: a.x, alphaY: a.y, Xi: xi } );
+			H.assign( Ta.mul( localH.x ).add( Ba.mul( localH.y ) ).add( N.mul( localH.z ) ) );
 
-		resultDirection.assign( reflect( V.negate(), H ) );
-		resultPdf.assign( calculateVNDFPDF( NoH, NoV, material.roughness ) );
-		resultValue.assign( evaluateMaterialResponse( V, resultDirection, N, material ) );
+			const NoH = clamp( dot( N, H ), 0.001, 1.0 );
+			resultDirection.assign( reflect( V.negate(), H ) );
+			resultPdf.assign( calculateVNDFPDFAniso( a.x, a.y, NoH, dot( Ta, H ), dot( Ba, H ), NoV, dot( Ta, V ), dot( Ba, V ) ) );
+			resultValue.assign( evaluateMaterialResponse( V, resultDirection, N, material ) );
+
+		} ).Else( () => {
+
+			const TBN = constructTBN( { N } );
+			const localV = TBN.transpose().mul( V );
+
+			// VNDF sampling
+			const localH = sampleGGXVNDF( { V: localV, roughness: material.roughness, Xi: xi } );
+			H.assign( TBN.mul( localH ) );
+
+			const NoH = clamp( dot( N, H ), 0.001, 1.0 );
+
+			resultDirection.assign( reflect( V.negate(), H ) );
+			resultPdf.assign( calculateVNDFPDF( NoH, NoV, material.roughness ) );
+			resultValue.assign( evaluateMaterialResponse( V, resultDirection, N, material ) );
+
+		} );
 
 	} ).ElseIf( rand.lessThan( cumulativeSheen ), () => {
 

package/src/TSL/ShadeKernel.js

@@ -17,7 +17,7 @@ import {
 import { sampleEnvironment, sampleEquirectProbability, sampleEquirect, groundProjectedEnvDir } from './Environment.js';
 import { getMaterial, powerHeuristic, balanceHeuristic, classifyMaterial, REC709_LUMINANCE_COEFFICIENTS, PI_INV, EPSILON, diffuseGroundMaterial } from './Common.js';
 import { cosineWeightedSample } from './MaterialSampling.js';
-import { sampleAllMaterialTextures } from './TextureSampling.js';
+import { sampleAllMaterialTextures, processAnisotropyMap, applyExtensionMaps, getTransformedUV } from './TextureSampling.js';
 import { evaluateMaterialResponse } from './MaterialEvaluation.js';
 import { calculateDirectLightingUnified, calculateMaterialPDF } from './LightsSampling.js';
 import { traceShadowRay, calculateRayOffset } from './LightsDirect.js';
@@ -37,6 +37,7 @@ import {
 	HitInfo,
 	RayTracingMaterial,
 	MaterialSamples,
+	ExtMapResult,
 	DirectionSample,
 	ImportanceSamplingInfo,
 	MaterialClassification,
@@ -53,7 +54,7 @@ import {
 	readHitDistance, readHitBarycentrics, readHitNormal,
 	readHitMaterialIndex, readHitTriangleIndex,
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf, writeRayRadiance,
-	writeGBuffer, readGBuffer, gbDecodeNormalDepth,
+	writeGBuffer, readGBuffer, gbDecodeNormalDepth, gbDecodeAlbedo,
 	readRayRadiance,
 } from '../Processor/PackedRayBuffer.js';
 
@@ -319,6 +320,11 @@ export function buildShadeKernel( params ) {
 			const wantBackdrop = isBackdropView.and( showBackground ); // draw env image as backdrop
 			const wantEnvLight = isBackdropView.not().and( enableEnvironmentLight ); // env as light on redirected bounces
 
+			// Fix ①: OIDN clean-aux for a redirected ray that escapes to the environment (e.g. smooth
+			// glass over sky). Holds the clamped env colour this ray sees; written into the aux G-buffer
+			// before the miss Return below, but only when the pixel still carries the black bounce-0 default.
+			const escapedAuxAlbedo = vec3( 0.0 ).toVar();
+
 			If( wantBackdrop.or( wantEnvLight ), () => {
 
 				// Ground projection bends the backdrop-view env lookup onto a projected sphere+disk so the lower
@@ -357,6 +363,10 @@ export function buildShadeKernel( params ) {
 
 				} );
 
+				// Fix ①: remember the (clamped) env colour this escaped ray sees, so a redirected ray
+				// that never captured a surface aux can feed OIDN a meaningful albedo below.
+				escapedAuxAlbedo.assign( clamp( envColor, vec3( 0.0 ), vec3( 1.0 ) ) );
+
 				// MIS weight for implicit env hit — prevents double-counting with NEE
 				const envMisWeight = float( 1.0 ).toVar();
 				If( isBackdropView.not().and( useEnvMapIS ), () => {
@@ -424,6 +434,25 @@ export function buildShadeKernel( params ) {
 
 			} );
 
+			// Fix ①: fill the black bounce-0 default aux for a redirected ray that reached the
+			// environment without ever locking a surface guide (smooth glass / specular transmission
+			// over sky). Only when the stored albedo is still the black default (dot < 1e-4), so a real
+			// specular-surface aux written upstream is never clobbered. Normal = the escaped ray
+			// direction (varies per pixel → OIDN sees structure that tracks the refracted view);
+			// albedo = the clamped env colour it sees; depth kept at the primary hit.
+			If( auxOn
+				.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) )
+				.and( flags.bitAnd( uint( RAY_FLAG.REDIRECTED ) ).notEqual( uint( 0 ) ) ), () => {
+
+				const gPrev = readGBuffer( gBufferRW, pixelIndex );
+				If( dot( gbDecodeAlbedo( gPrev ), vec3( 1.0 ) ).lessThan( float( 1e-4 ) ), () => {
+
+					writeGBuffer( gBufferRW, pixelIndex, normalize( direction ), gbDecodeNormalDepth( gPrev ).w, escapedAuxAlbedo );
+
+				} );
+
+			} );
+
 			writeRayRadiance( rayBufferRW, rayID, currentRadiance );
 			writeRayDirFlags( rayBufferRW, rayID, direction, flags.bitAnd( uint( ~ RAY_FLAG.ACTIVE ) ) );
 			Return();
@@ -549,6 +578,35 @@ export function buildShadeKernel( params ) {
 		material.roughness.assign( matSamples.roughness.clamp( 0.05, 1.0 ) );
 		material.sheenRoughness.assign( material.sheenRoughness.clamp( 0.05, 1.0 ) ); // megakernel parity (PathTracerCore.js:1060): sample/PDF mismatch at sheenRoughness~0
 
+		// Anisotropy + extension maps carry no per-slot transform of their own, so reuse the material's
+		// albedo UV-transform (KHR_texture_transform). Extension/aniso textures nearly always share the
+		// base UV set + transform, so this aligns tiled/offset maps (e.g. SheenCloth's 30× sheen weave)
+		// instead of sampling at raw 1× UV. Identity albedo transform → same as raw UV (safe no-op).
+		const extUV = getTransformedUV( { uv: samplingUV, transform: material.albedoTransform } ).toVar();
+
+		// Fold the anisotropy texture (if any) into the scalar anisotropy/rotation used by the BRDF
+		If( material.anisotropyMapIndex.greaterThanEqual( int( 0 ) ), () => {
+
+			const aniso = processAnisotropyMap( material, extUV ).toVar();
+			material.anisotropy.assign( aniso.x );
+			material.anisotropyRotation.assign( aniso.y );
+
+		} );
+
+		// Fold the glTF extension textures (transmission/clearcoat/sheen/iridescence/specular) into
+		// their scalar factors. `material` is the shared mutable struct that flows into BOTH the
+		// BRDF-sample path and the NEE evaluator, so modulating here covers every consumer at once.
+		const extMaps = ExtMapResult.wrap( applyExtensionMaps( material, extUV ) ).toVar();
+		material.transmission.assign( extMaps.transmission );
+		material.clearcoat.assign( extMaps.clearcoat );
+		material.clearcoatRoughness.assign( extMaps.clearcoatRoughness );
+		material.sheenColor.assign( extMaps.sheenColor );
+		material.sheenRoughness.assign( extMaps.sheenRoughness );
+		material.iridescence.assign( extMaps.iridescence );
+		material.iridescenceThicknessRange.assign( vec2( material.iridescenceThicknessRange.x, extMaps.iridescenceThickness ) );
+		material.specularIntensity.assign( extMaps.specularIntensity );
+		material.specularColor.assign( extMaps.specularColor );
+
 		const albedo = matSamples.albedo.toVar();
 		If(
 			material.displacementMapIndex.greaterThanEqual( int( 0 ) )
@@ -577,7 +635,23 @@ export function buildShadeKernel( params ) {
 			// (aux-extend) and may extend through specular surfaces (gap #9). Glass rays Return at the transparency
 			// block before that capture, so a glass-then-escape pixel keeps this default aux — megakernel parity
 			// (objectNormal/objectColor stay at their init for transmissive-then-miss).
-			writeGBuffer( gBufferRW, pixelIndex, vec3( 0.0, 0.0, 1.0 ), linearDepth, vec3( 0.0 ) );
+			//
+			// Fix ③: BLEND (semi-transparent) glass instead LOCKS its OWN normal + albedo here. Its per-frame
+			// stochastic alpha-skip-vs-opaque-shade outcome (MaterialTransmission.js:522-540) otherwise writes a
+			// DIFFERENT surface into the aux each frame (wall-behind on skip vs glass on opaque); with the normal
+			// not temporally averaged that becomes the speckle OIDN smears on — the visible artefact on
+			// alpha-transparent glass. A deterministic glass-surface guide every frame removes it. MASK / opaque
+			// materials keep the default + rely on the downstream aux-extend.
+			If( material.alphaMode.equal( int( 2 ) ), () => {
+
+				writeGBuffer( gBufferRW, pixelIndex, N, linearDepth, albedo.xyz );
+				flags.assign( flags.bitOr( uint( RAY_FLAG.AUX_LOCKED ) ) );
+
+			} ).Else( () => {
+
+				writeGBuffer( gBufferRW, pixelIndex, vec3( 0.0, 0.0, 1.0 ), linearDepth, vec3( 0.0 ) );
+
+			} );
 
 		} );
 
@@ -714,6 +788,26 @@ export function buildShadeKernel( params ) {
 
 			throughput.mulAssign( interaction.throughput );
 
+			// Fix ②: OIDN clean-aux for STOCHASTIC glass (rough / frosted / dispersive), whose refracted
+			// ray hits a different behind-surface every frame. Extending aux through it (the aux-extend on
+			// the opaque-hit path) captures that per-frame surface — albedo then temporally averaged, normal
+			// point-sampled — an inconsistent guide OIDN smears on. Instead lock the glass surface's OWN
+			// normal + tint here (deterministic, spatially coherent). Smooth non-dispersive glass is left
+			// alone: its refraction is a per-pixel delta, so the behind-surface aux captured downstream is
+			// already stable. Gated to a genuine dielectric event (not alpha-cutout passthrough or SSS).
+			If( auxOn
+				.and( flags.bitAnd( uint( RAY_FLAG.AUX_LOCKED ) ).equal( uint( 0 ) ) )
+				.and( interaction.isTransmissive )
+				.and( interaction.isAlphaSkip.not() )
+				.and( interaction.isSubsurface.not() )
+				.and( material.roughness.greaterThan( 0.05 ).or( material.dispersion.greaterThan( 0.0 ) ) ), () => {
+
+				const primaryDepth = gbDecodeNormalDepth( readGBuffer( gBufferRW, pixelIndex ) ).w;
+				writeGBuffer( gBufferRW, pixelIndex, N, primaryDepth, albedo.xyz );
+				flags.assign( flags.bitOr( uint( RAY_FLAG.AUX_LOCKED ) ) );
+
+			} );
+
 			// reflection stays on same side, transmission pushes through
 			const reflectOffsetDir = select( interaction.entering, N, N.negate() );
 			const offsetDir = select( interaction.didReflect, reflectOffsetDir, direction );