rayzee 7.10.3 → 7.11.0

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

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