rayzee 7.10.2 → 7.11.0

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

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,
@@ -549,6 +550,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 ) )

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