GLTF KHR_materials_anisotropy support

examples/jsm/exporters/GLTFExporter.js

@@ -120,6 +120,12 @@ class GLTFExporter {
 
 		} );
 
+		this.register( function ( writer ) {
+
+			return new GLTFMaterialsAnisotropyExtension( writer );
+
+		} );
+
 		this.register( function ( writer ) {
 
 			return new GLTFMaterialsEmissiveStrengthExtension( writer );
@@ -2804,6 +2810,48 @@ class GLTFMaterialsSheenExtension {
 
 }
 
+/**
+ * Anisotropy Materials Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_anisotropy
+ */
+class GLTFMaterialsAnisotropyExtension {
+
+	constructor( writer ) {
+
+		this.writer = writer;
+		this.name = 'KHR_materials_anisotropy';
+
+	}
+
+	writeMaterial( material, materialDef ) {
+
+		if ( ! material.isMeshPhysicalMaterial || material.anisotropy == 0.0 ) return;
+
+		const writer = this.writer;
+		const extensionsUsed = writer.extensionsUsed;
+
+		const extensionDef = {};
+
+		if ( material.anisotropyMap ) {
+
+			const anisotropyMapDef = { index: writer.processTexture( material.anisotropyMap ) };
+			writer.applyTextureTransform( anisotropyMapDef, material.anisotropyMap );
+			extensionDef.anisotropyTexture = anisotropyMapDef;
+
+		}
+
+		extensionDef.anisotropyStrength = material.anisotropyStrength;
+
+		materialDef.extensions = materialDef.extensions || {};
+		materialDef.extensions[ this.name ] = extensionDef;
+
+		extensionsUsed[ this.name ] = true;
+
+	}
+
+}
+
 /**
  * Materials Emissive Strength Extension
  *

examples/jsm/loaders/GLTFLoader.js

@@ -142,6 +142,12 @@ class GLTFLoader extends Loader {
 
 		} );
 
+		this.register( function ( parser ) {
+
+			return new GLTFMaterialsAnisotropyExtension( parser );
+
+		} );
+
 		this.register( function ( parser ) {
 
 			return new GLTFLightsExtension( parser );
@@ -472,6 +478,7 @@ const EXTENSIONS = {
 	KHR_MATERIALS_SPECULAR: 'KHR_materials_specular',
 	KHR_MATERIALS_TRANSMISSION: 'KHR_materials_transmission',
 	KHR_MATERIALS_IRIDESCENCE: 'KHR_materials_iridescence',
+	KHR_MATERIALS_ANISOTROPY: 'KHR_materials_anisotropy',
 	KHR_MATERIALS_UNLIT: 'KHR_materials_unlit',
 	KHR_MATERIALS_VOLUME: 'KHR_materials_volume',
 	KHR_TEXTURE_BASISU: 'KHR_texture_basisu',
@@ -1187,6 +1194,60 @@ class GLTFMaterialsSpecularExtension {
 
 }
 
+/**
+ * Materials anisotropy Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_anisotropy
+ */
+class GLTFMaterialsAnisotropyExtension {
+
+	constructor( parser ) {
+
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_MATERIALS_ANISOTROPY;
+
+	}
+
+	getMaterialType( materialIndex ) {
+
+		const parser = this.parser;
+		const materialDef = parser.json.materials[ materialIndex ];
+
+		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
+
+		return MeshPhysicalMaterial;
+
+	}
+
+	extendMaterialParams( materialIndex, materialParams ) {
+
+		const parser = this.parser;
+		const materialDef = parser.json.materials[ materialIndex ];
+
+		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
+
+			return Promise.resolve();
+
+		}
+
+		const pending = [];
+
+		const extension = materialDef.extensions[ this.name ];
+
+		materialParams.anisotropyStrength = extension.anisotropyStrength !== undefined ? extension.anisotropyStrength : 1.0;
+
+		if ( extension.anisotropyTexture !== undefined ) {
+
+			pending.push( parser.assignTexture( materialParams, 'anisotropyMap', extension.anisotropyTexture ) );
+
+		}
+
+		return Promise.all( pending );
+
+	}
+
+}
+
 /**
  * BasisU Texture Extension
  *

manual/resources/threejs-material-table.js

@@ -164,6 +164,8 @@ const materials = [
 			'transmissionMap',
 			'attenuationDistance',
 			'attenuationColor',
+			'anisotropy',
+			'anisotropyMap',
 			'specularIntensity',
 			'specularIntensityMap',
 			'specularColor',

src/loaders/MaterialLoader.js

@@ -110,6 +110,7 @@ class MaterialLoader extends Loader {
 		if ( json.thickness !== undefined ) material.thickness = json.thickness;
 		if ( json.attenuationDistance !== undefined ) material.attenuationDistance = json.attenuationDistance;
 		if ( json.attenuationColor !== undefined && material.attenuationColor !== undefined ) material.attenuationColor.setHex( json.attenuationColor );
+		if ( json.anisotropy !== undefined ) material.anisotropy = json.anisotropy;
 		if ( json.fog !== undefined ) material.fog = json.fog;
 		if ( json.flatShading !== undefined ) material.flatShading = json.flatShading;
 		if ( json.blending !== undefined ) material.blending = json.blending;
@@ -310,6 +311,8 @@ class MaterialLoader extends Loader {
 		if ( json.transmissionMap !== undefined ) material.transmissionMap = getTexture( json.transmissionMap );
 		if ( json.thicknessMap !== undefined ) material.thicknessMap = getTexture( json.thicknessMap );
 
+		if ( json.anisotropyMap !== undefined ) material.anisotropyMap = getTexture( json.anisotropyMap );
+
 		if ( json.sheenColorMap !== undefined ) material.sheenColorMap = getTexture( json.sheenColorMap );
 		if ( json.sheenRoughnessMap !== undefined ) material.sheenRoughnessMap = getTexture( json.sheenRoughnessMap );
 

src/materials/Material.js

@@ -230,6 +230,15 @@ class Material extends EventDispatcher {
 
 		}
 
+		if ( this.anisotropy !== undefined ) data.anisotropy = this.anisotropy;
+		if ( this.anisotropyStrength !== undefined ) data.anisotropyStrength = this.anisotropyStrength;
+
+		if ( this.anisotropyMap && this.anisotropyMap.isTexture ) {
+
+			data.anisotropyMap = this.anisotropyMap.toJSON( meta ).uuid;
+
+		}
+
 		if ( this.map && this.map.isTexture ) data.map = this.map.toJSON( meta ).uuid;
 		if ( this.matcap && this.matcap.isTexture ) data.matcap = this.matcap.toJSON( meta ).uuid;
 		if ( this.alphaMap && this.alphaMap.isTexture ) data.alphaMap = this.alphaMap.toJSON( meta ).uuid;

src/materials/MeshPhysicalMaterial.js

@@ -63,10 +63,14 @@ class MeshPhysicalMaterial extends MeshStandardMaterial {
 		this.specularColor = new Color( 1, 1, 1 );
 		this.specularColorMap = null;
 
+		this.anisotropyStrength = 1.0;
+		this.anisotropyMap = null;
+
 		this._sheen = 0.0;
 		this._clearcoat = 0;
 		this._iridescence = 0;
 		this._transmission = 0;
+		this._anisotropy = 0;
 
 		this.setValues( parameters );
 
@@ -144,6 +148,24 @@ class MeshPhysicalMaterial extends MeshStandardMaterial {
 
 	}
 
+	get anisotropy() {
+
+		return this._anisotropy;
+
+	}
+
+	set anisotropy( value ) {
+
+		if ( this._anisotropy > 0 !== value > 0 ) {
+
+			this.version ++;
+
+		}
+
+		this._anisotropy = value;
+
+	}
+
 	copy( source ) {
 
 		super.copy( source );
@@ -189,6 +211,10 @@ class MeshPhysicalMaterial extends MeshStandardMaterial {
 		this.specularColor.copy( source.specularColor );
 		this.specularColorMap = source.specularColorMap;
 
+		this.anisotropy = source.anisotropy;
+		this.anisotropyStrength = source.anisotropyStrength;
+		this.anisotropyMap = source.anisotropyMap;
+
 		return this;
 
 	}

src/renderers/shaders/ShaderChunk.js

@@ -77,6 +77,7 @@ import clearcoat_pars_fragment from './ShaderChunk/clearcoat_pars_fragment.glsl.
 import iridescence_pars_fragment from './ShaderChunk/iridescence_pars_fragment.glsl.js';
 import output_fragment from './ShaderChunk/output_fragment.glsl.js';
 import packing from './ShaderChunk/packing.glsl.js';
+import physical_pars_fragment from './ShaderChunk/physical_pars_fragment.glsl.js';
 import premultiplied_alpha_fragment from './ShaderChunk/premultiplied_alpha_fragment.glsl.js';
 import project_vertex from './ShaderChunk/project_vertex.glsl.js';
 import dithering_fragment from './ShaderChunk/dithering_fragment.glsl.js';
@@ -203,6 +204,7 @@ export const ShaderChunk = {
 	iridescence_pars_fragment: iridescence_pars_fragment,
 	output_fragment: output_fragment,
 	packing: packing,
+	physical_pars_fragment: physical_pars_fragment,
 	premultiplied_alpha_fragment: premultiplied_alpha_fragment,
 	project_vertex: project_vertex,
 	dithering_fragment: dithering_fragment,

src/renderers/shaders/ShaderChunk/bsdfs.glsl.js

@@ -66,8 +66,37 @@ float D_GGX( const in float alpha, const in float dotNH ) {
 
 }
 
+#ifdef USE_ANISOTROPY
+
+	float V_GGX_SmithCorrelated_Anisotropic( const in float alphaT, const in float alphaB, const in float dotTV, const in float dotBV, const in float dotTL, const in float dotBL, const in float dotNV, const in float dotNL ) {
+
+		float lambdaV = dotNL * length( vec3( alphaT * dotTV, alphaB * dotBV, dotNV ) );
+		float lambdaL = dotNV * length( vec3( alphaT * dotTL, alphaB * dotBL, dotNL ) );
+		float v = 0.5 / ( lambdaV + lambdaL );
+
+		return saturate(v);
+
+	}
+
+	float D_GGX_Anisotropic( const in float alphaT, const in float alphaB, const in float dotNH, const in float dotTH, const in float dotBH ) {
+
+		float a2 = alphaT * alphaB;
+		highp vec3 v = vec3( alphaB * dotTH, alphaT * dotBH, a2 * dotNH );
+		highp float v2 = dot( v, v );
+		float w2 = a2 / v2;
+
+		return a2 * w2 * w2 * ( 1.0 * RECIPROCAL_PI );
+
+	}
+
+#endif
+
 // GGX Distribution, Schlick Fresnel, GGX_SmithCorrelated Visibility
-vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float roughness ) {
+vec3 BRDF_GGX_Clearcoat( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material) {
+
+	vec3 f0 = material.clearcoatF0;
+	float f90 = material.clearcoatF90;
+	float roughness = material.clearcoatRoughness;
 
 	float alpha = pow2( roughness ); // UE4's roughness
 
@@ -88,28 +117,53 @@ vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 norm
 
 }
 
-#ifdef USE_IRIDESCENCE
+vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material ) {
 
-	vec3 BRDF_GGX_Iridescence( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 f0, const in float f90, const in float iridescence, const in vec3 iridescenceFresnel, const in float roughness ) {
+	vec3 f0 = material.specularColor;
+	float f90 = material.specularF90;
+	float roughness = material.roughness;
 
-		float alpha = pow2( roughness ); // UE4's roughness
+	float alpha = pow2( roughness ); // UE4's roughness
 
-		vec3 halfDir = normalize( lightDir + viewDir );
+	vec3 halfDir = normalize( lightDir + viewDir );
 
-		float dotNL = saturate( dot( normal, lightDir ) );
-		float dotNV = saturate( dot( normal, viewDir ) );
-		float dotNH = saturate( dot( normal, halfDir ) );
-		float dotVH = saturate( dot( viewDir, halfDir ) );
+	float dotNL = saturate( dot( normal, lightDir ) );
+	float dotNV = saturate( dot( normal, viewDir ) );
+	float dotNH = saturate( dot( normal, halfDir ) );
+	float dotVH = saturate( dot( viewDir, halfDir ) );
+
+	vec3 F = F_Schlick( f0, f90, dotVH );
+
+	#ifdef USE_IRIDESCENCE
+
+		F = mix( F, material.iridescenceFresnel, material.iridescence );
+
+	#endif
 
-		vec3 F = mix( F_Schlick( f0, f90, dotVH ), iridescenceFresnel, iridescence );
+	#ifdef USE_ANISOTROPY
+
+		float dotTL = saturate( dot( material.anisotropyT, lightDir ) );
+		float dotTV = saturate( dot( material.anisotropyT, viewDir ) );
+		float dotTH = saturate( dot( material.anisotropyT, halfDir ) );
+		float dotBL = saturate( dot( material.anisotropyB, lightDir ) );
+		float dotBV = saturate( dot( material.anisotropyB, viewDir ) );
+		float dotBH = saturate( dot( material.anisotropyB, halfDir ) );
+
+		float V = V_GGX_SmithCorrelated_Anisotropic( alpha, material.alphaB, dotTV, dotBV, dotTL, dotBL, dotNV, dotNL );
+
+		float D = D_GGX_Anisotropic( alpha, material.alphaB, dotNH, dotTH, dotBH );
+
+	#else
 
 		float V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );
 
 		float D = D_GGX( alpha, dotNH );
 
-		return F * ( V * D );
+	#endif
 
-	}
+	return F * ( V * D );
+
+}
 
 #endif
 

src/renderers/shaders/ShaderChunk/clearcoat_normal_fragment_maps.glsl.js

@@ -4,15 +4,7 @@ export default /* glsl */`
 	vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;
 	clearcoatMapN.xy *= clearcoatNormalScale;
 
-	#ifdef USE_TANGENT
-
-		clearcoatNormal = normalize( vTBN * clearcoatMapN );
-
-	#else
-
-		clearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN, faceDirection );
-
-	#endif
+	clearcoatNormal = normalize( vTBN * clearcoatMapN );
 
 #endif
 `;