@unikia/upe-renderer 0.186.110 → 0.187.11

package/src/renderers/common/nodes/NodeBuilderState.js

@@ -122,11 +122,13 @@ class NodeBuilderState {
 	 * on the existing bind groups of this state. Shared groups are
 	 * not cloned.
 	 *
+	 * @param {Bindings} bindings - Renderer component for managing bindings.
+	 * @param {RenderContext} renderContext - The render context.
 	 * @return {Array<BindGroup>} A array of bind groups.
 	 */
-	createBindings() {
+	createBindings( bindings, renderContext ) {
 
-		const bindings = [];
+		const bindGroups = [];
 
 		for ( const instanceGroup of this.bindings ) {
 
@@ -135,7 +137,7 @@ class NodeBuilderState {
 			if ( shared !== true ) {
 
 				const bindingsGroup = new BindGroup( instanceGroup.name, [] );
-				bindings.push( bindingsGroup );
+				bindGroups.push( bindingsGroup );
 
 				for ( const instanceBinding of instanceGroup.bindings ) {
 
@@ -145,13 +147,13 @@ class NodeBuilderState {
 
 			} else {
 
-				bindings.push( instanceGroup );
+				bindGroups.push( bindings.getSharedBindGroup( instanceGroup, renderContext ) );
 
 			}
 
 		}
 
-		return bindings;
+		return bindGroups;
 
 	}
 

package/src/renderers/common/nodes/NodeLibrary.js

@@ -1,4 +1,4 @@
-import { warn } from '../../../utils.js';
+import { warn, warnOnce } from '../../../utils.js';
 
 /**
  * The purpose of a node library is to assign node implementations
@@ -15,13 +15,6 @@ class NodeLibrary {
 	 */
 	constructor() {
 
-		/**
-		 * A weak map that maps lights to light nodes.
-		 *
-		 * @type {WeakMap<Light.constructor,AnalyticLightNode.constructor>}
-		 */
-		this.lightNodes = new WeakMap();
-
 		/**
 		 * A map that maps materials to node materials.
 		 *
@@ -124,24 +117,30 @@ class NodeLibrary {
 	/**
 	 * Returns a light node class definition for a light class definition.
 	 *
-	 * @param {Light.constructor} light - The light class definition.
+	 * @deprecated since r187. Use `Light.registerNode()` to assign light node classes instead.
+	 * @param {Light.constructor} lightClass - The light class definition.
 	 * @return {?AnalyticLightNode.constructor} The light node class definition. Returns `null` if no light node is found.
 	 */
-	getLightNodeClass( light ) {
+	getLightNodeClass( lightClass ) {
+
+		warnOnce( 'NodeLibrary: "getLightNodeClass()" has been deprecated. Use "Light.registerNode()" to assign light node classes instead.' ); // @deprecated r187
 
-		return this.lightNodes.get( light ) || null;
+		return lightClass.prototype._lightNode || null;
 
 	}
 
 	/**
 	 * Adds a light node class definition for a given light class definition.
 	 *
+	 * @deprecated since r187. Use `Light.registerNode()` instead.
 	 * @param {AnalyticLightNode.constructor} lightNodeClass - The light node class definition.
 	 * @param {Light.constructor} lightClass - The light class definition.
 	 */
 	addLight( lightNodeClass, lightClass ) {
 
-		this.addClass( lightNodeClass, lightClass, this.lightNodes );
+		warnOnce( 'NodeLibrary: "addLight()" has been deprecated. Use "Light.registerNode()" instead.' ); // @deprecated r187
+
+		lightClass.registerNode( lightNodeClass );
 
 	}
 
@@ -168,29 +167,6 @@ class NodeLibrary {
 
 	}
 
-	/**
-	 * Adds a node class definition for the given class definition to the provided type library.
-	 *
-	 * @param {Node.constructor} nodeClass - The node class definition.
-	 * @param {Node.constructor} baseClass - The class definition.
-	 * @param {WeakMap<Node.constructor, Node.constructor>} library - The type library.
-	 */
-	addClass( nodeClass, baseClass, library ) {
-
-		if ( library.has( baseClass ) ) {
-
-			warn( `Redefinition of node ${ baseClass.name }` );
-			return;
-
-		}
-
-		if ( typeof nodeClass !== 'function' ) throw new Error( `THREE.NodeLibrary: Node class ${ nodeClass.name } is not a class.` );
-		if ( typeof baseClass !== 'function' ) throw new Error( `THREE.NodeLibrary: Base class ${ baseClass.name } is not a class.` );
-
-		library.set( baseClass, nodeClass );
-
-	}
-
 }
 
 export default NodeLibrary;

package/src/renderers/common/nodes/NodeManager.js

@@ -7,9 +7,9 @@ import { NodeFrame, NodeUpdateType, StackTrace } from '../../../nodes/Nodes.js';
 import { renderGroup, cubeTexture, texture, fog, rangeFogFactor, densityFogFactor, reference, pmremTexture, screenUV, uniform } from '../../../nodes/TSL.js';
 import { builtin } from '../../../nodes/accessors/BuiltinNode.js';
 
-import { CubeUVReflectionMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping } from '../../../constants.js';
+import { EquirectangularReflectionMapping, EquirectangularRefractionMapping } from '../../../constants.js';
 import { hashArray } from '../../../nodes/core/NodeUtils.js';
-import { error } from '../../../utils.js';
+import { error, yieldToMain } from '../../../utils.js';
 
 const _chainKeys = [];
 const _cacheKeyValues = [];
@@ -188,14 +188,36 @@ class NodeManager extends DataMap {
 
 	}
 
+	/**
+	 * Logs an error thrown while building a node material.
+	 *
+	 * @private
+	 * @param {Error} e - The build error.
+	 */
+	_reportBuildError( e ) {
+
+		let stackTrace = e.stackTrace;
+
+		if ( ! stackTrace && e.stack ) {
+
+			// Capture stack trace for JavaScript errors
+
+			stackTrace = new StackTrace( e.stack );
+
+		}
+
+		error( 'TSL: ' + e, stackTrace );
+
+	}
+
 	/**
 	 * Returns a node builder state for the given render object.
 	 *
 	 * @param {RenderObject} renderObject - The render object.
-	 * @param {boolean} [useAsync=false] - Whether to use async build with yielding.
+	 * @param {?Function} [yieldFn=null] - If set, the build is async and yields to the main thread via this function.
 	 * @return {NodeBuilderState|Promise<NodeBuilderState>} The node builder state (or Promise if async).
 	 */
-	getForRender( renderObject, useAsync = false ) {
+	getForRender( renderObject, yieldFn = null ) {
 
 		const renderObjectData = this.get( renderObject );
 
@@ -217,9 +239,9 @@ class NodeManager extends DataMap {
 
 					try {
 
-						if ( useAsync ) {
+						if ( yieldFn !== null ) {
 
-							await nodeBuilder.buildAsync();
+							await nodeBuilder.buildAsync( yieldFn );
 
 						} else {
 
@@ -231,9 +253,9 @@ class NodeManager extends DataMap {
 
 						nodeBuilder = this._createNodeBuilder( renderObject, new NodeMaterial() );
 
-						if ( useAsync ) {
+						if ( yieldFn !== null ) {
 
-							await nodeBuilder.buildAsync();
+							await nodeBuilder.buildAsync( yieldFn );
 
 						} else {
 
@@ -241,7 +263,7 @@ class NodeManager extends DataMap {
 
 						}
 
-						error( 'TSL: ' + e );
+						this._reportBuildError( e );
 
 					}
 
@@ -249,12 +271,12 @@ class NodeManager extends DataMap {
 
 				};
 
-				if ( useAsync ) {
+				if ( yieldFn !== null ) {
 
 					return buildNodeBuilder().then( ( nodeBuilder ) => {
 
 						nodeBuilderState = this._createNodeBuilderState( nodeBuilder );
-						nodeBuilderCache.set( cacheKey, nodeBuilderState );
+						if ( nodeBuilder.objectSpecific === false ) nodeBuilderCache.set( cacheKey, nodeBuilderState );
 						nodeBuilderState.usedTimes ++;
 						renderObjectData.nodeBuilderState = nodeBuilderState;
 
@@ -276,23 +298,13 @@ class NodeManager extends DataMap {
 						nodeBuilder = this._createNodeBuilder( renderObject, new NodeMaterial() );
 						nodeBuilder.build();
 
-						let stackTrace = e.stackTrace;
-
-						if ( ! stackTrace && e.stack ) {
-
-							// Capture stack trace for JavaScript errors
-
-							stackTrace = new StackTrace( e.stack );
-
-						}
-
-						error( 'TSL: ' + e, stackTrace );
+						this._reportBuildError( e );
 
 					}
 
 					nodeBuilderState = this._createNodeBuilderState( nodeBuilder );
 
-					nodeBuilderCache.set( cacheKey, nodeBuilderState );
+					if ( nodeBuilder.objectSpecific === false ) nodeBuilderCache.set( cacheKey, nodeBuilderState );
 
 				}
 
@@ -313,11 +325,12 @@ class NodeManager extends DataMap {
 	 * Use this in compileAsync() to prevent blocking the main thread.
 	 *
 	 * @param {RenderObject} renderObject - The render object.
+	 * @param {Function} [yieldFn=yieldToMain] - The function used to yield to the main thread.
 	 * @return {Promise<NodeBuilderState>} A promise that resolves to the node builder state.
 	 */
-	getForRenderAsync( renderObject ) {
+	getForRenderAsync( renderObject, yieldFn = yieldToMain ) {
 
-		const result = this.getForRender( renderObject, true );
+		const result = this.getForRender( renderObject, yieldFn );
 
 		// Ensure we always return a Promise (cache hit returns nodeBuilderState directly)
 		if ( result.then ) {
@@ -451,9 +464,10 @@ class NodeManager extends DataMap {
 	 *
 	 * @param {Node} computeNode - The compute node.
 	 * @param {boolean} [useAsync=false] - Whether to use async build with yielding.
+	 * @param {Function} [yieldFn=yieldToMain] - The function used to yield to the main thread in an async build.
 	 * @return {NodeBuilderState|Promise<NodeBuilderState>} The node builder state (or Promise if async).
 	 */
-	getForCompute( computeNode, useAsync = false ) {
+	getForCompute( computeNode, useAsync = false, yieldFn = yieldToMain ) {
 
 		const computeData = this.get( computeNode );
 
@@ -470,7 +484,7 @@ class NodeManager extends DataMap {
 
 			if ( useAsync ) {
 
-				return nodeBuilder.buildAsync().then( () => {
+				return nodeBuilder.buildAsync( yieldFn ).then( () => {
 
 					nodeBuilderState = this._createNodeBuilderState( nodeBuilder );
 
@@ -501,11 +515,12 @@ class NodeManager extends DataMap {
 	 * Use this in compileComputeAsync() to prevent blocking the main thread.
 	 *
 	 * @param {Node} computeNode - The compute node.
+	 * @param {Function} [yieldFn=yieldToMain] - The function used to yield to the main thread.
 	 * @return {Promise<NodeBuilderState>} A promise that resolves to the node builder state.
 	 */
-	getForComputeAsync( computeNode ) {
+	getForComputeAsync( computeNode, yieldFn = yieldToMain ) {
 
-		const result = this.getForCompute( computeNode, true );
+		const result = this.getForCompute( computeNode, true, yieldFn );
 
 		if ( result.then ) {
 
@@ -624,6 +639,40 @@ class NodeManager extends DataMap {
 
 	}
 
+	/**
+	 * Returns the custom program cache key of the given material. Since
+	 * computing the key traverses the material's node graph, the result
+	 * is cached per material version if possible.
+	 *
+	 * @param {Material} material - The material.
+	 * @param {Scene} scene - The scene.
+	 * @return {string} The custom program cache key.
+	 */
+	getCustomProgramCacheKey( material, scene ) {
+
+		if ( material === scene.overrideMaterial ) {
+
+			// override materials can't be cached since they dynamically change node properties
+
+			return material.customProgramCacheKey();
+
+		} else {
+
+			const materialData = this.get( material );
+
+			if ( materialData.cacheKeyVersion !== material.version ) {
+
+				materialData.cacheKeyVersion = material.version;
+				materialData.cacheKey = material.customProgramCacheKey();
+
+			}
+
+			return materialData.cacheKey;
+
+		}
+
+	}
+
 	/**
 	 * Returns a cache key for the given scene and lights node.
 	 * This key is used by `RenderObject` as a part of the dynamic
@@ -710,9 +759,9 @@ class NodeManager extends DataMap {
 
 				const backgroundNode = this.getCacheNode( 'background', background, () => {
 
-					if ( background.isCubeTexture === true || ( background.mapping === EquirectangularReflectionMapping || background.mapping === EquirectangularRefractionMapping || background.mapping === CubeUVReflectionMapping ) ) {
+					if ( background.isCubeTexture === true || background.mapping === EquirectangularReflectionMapping || background.mapping === EquirectangularRefractionMapping ) {
 
-						if ( scene.backgroundBlurriness > 0 || background.mapping === CubeUVReflectionMapping ) {
+						if ( scene.backgroundBlurriness > 0 || background.isPMREMTexture === true ) {
 
 							return pmremTexture( background );
 

package/src/renderers/common/nodes/NodeSampledTexture.js

@@ -67,6 +67,20 @@ class NodeSampledTexture extends SampledTexture {
 
 	}
 
+	/**
+	 * Clones the binding.
+	 *
+	 * @return {NodeSampledTexture} The cloned binding.
+	 */
+	clone() {
+
+		const binding = super.clone();
+		binding.texture = this.textureNode.value; // copy current node value to avoid stale references
+
+		return binding;
+
+	}
+
 }
 
 /**

package/src/renderers/common/nodes/NodeSampler.js

@@ -57,6 +57,20 @@ class NodeSampler extends Sampler {
 
 	}
 
+	/**
+	 * Clones the binding.
+	 *
+	 * @return {NodeSampler} The cloned binding.
+	 */
+	clone() {
+
+		const binding = super.clone();
+		binding.texture = this.textureNode.value; // copy current node value to avoid stale references
+
+		return binding;
+
+	}
+
 }
 
 export default NodeSampler;

package/src/renderers/common/nodes/NodeStorageBuffer.js

@@ -22,7 +22,7 @@ class NodeStorageBuffer extends StorageBuffer {
 
 		const label = nodeUniform && nodeUniform.name ? nodeUniform.name : _id ++;
 
-		super( 'StorageBuffer_' + label, nodeUniform ? nodeUniform.value : null );
+		super( 'StorageBuffer_' + label );
 
 		/**
 		 * The node uniform.

package/src/renderers/common/nodes/NodeUniformBuffer.js

@@ -1,5 +1,4 @@
 import UniformBuffer from '../UniformBuffer.js';
-import { getFloatLength } from '../BufferUtils.js';
 
 let _id = 0;
 
@@ -22,7 +21,7 @@ class NodeUniformBuffer extends UniformBuffer {
 
 		const label = nodeUniform && nodeUniform.name ? nodeUniform.name : _id ++;
 
-		super( 'UniformBuffer_' + label, nodeUniform ? nodeUniform.value : null );
+		super( 'UniformBuffer_' + label );
 
 		/**
 		 * The uniform buffer node.
@@ -92,18 +91,6 @@ class NodeUniformBuffer extends UniformBuffer {
 
 	}
 
-	/**
-	 * The buffer's byte length.
-	 *
-	 * @type {number}
-	 * @readonly
-	 */
-	get byteLength() {
-
-		return getFloatLength( this.buffer.byteLength );
-
-	}
-
 	/**
 	 * The uniform buffer.
 	 *

package/src/renderers/shaders/ShaderChunk/envmap_common_pars_fragment.glsl.js

@@ -3,11 +3,20 @@ export default /* glsl */`
 
 	uniform float envMapIntensity;
 	uniform mat3 envMapRotation;
+	uniform samplerCube envMap;
+
+	#ifdef ENVMAP_TYPE_PMREM
+
+		// Invert PMREMGenerator.lodToRoughness(). Matches Filament's perceptualRoughnessToLod().
+		// https://github.com/google/filament/blob/main/shaders/src/surface_light_indirect.fs
+		float roughnessToMip( const in float roughness ) {
+
+			float r = clamp( roughness, 0.0, 1.0 );
+
+			return ENVMAP_MAX_LOD * r * ( 2.0 - r );
+
+		}
 
-	#ifdef ENVMAP_TYPE_CUBE
-		uniform samplerCube envMap;
-	#else
-		uniform sampler2D envMap;
 	#endif
 
 #endif

package/src/renderers/shaders/ShaderChunk/envmap_physical_pars_fragment.glsl.js

@@ -3,11 +3,11 @@ export default /* glsl */`
 
 	vec3 getIBLIrradiance( const in vec3 normal ) {
 
-		#ifdef ENVMAP_TYPE_CUBE_UV
+		#ifdef ENVMAP_TYPE_PMREM
 
 			vec3 worldNormal = transformNormalByInverseViewMatrix( normal, viewMatrix );
 
-			vec4 envMapColor = textureCubeUV( envMap, envMapRotation * worldNormal, 1.0 );
+			vec4 envMapColor = textureLod( envMap, envMapRotation * worldNormal, ENVMAP_MAX_LOD );
 
 			return PI * envMapColor.rgb * envMapIntensity;
 
@@ -21,7 +21,7 @@ export default /* glsl */`
 
 	vec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {
 
-		#ifdef ENVMAP_TYPE_CUBE_UV
+		#ifdef ENVMAP_TYPE_PMREM
 
 			vec3 reflectVec = reflect( - viewDir, normal );
 
@@ -30,7 +30,7 @@ export default /* glsl */`
 
 			reflectVec = transformDirectionByInverseViewMatrix( reflectVec, viewMatrix );
 
-			vec4 envMapColor = textureCubeUV( envMap, envMapRotation * reflectVec, roughness );
+			vec4 envMapColor = textureLod( envMap, envMapRotation * reflectVec, roughnessToMip( roughness ) );
 
 			return envMapColor.rgb * envMapIntensity;
 
@@ -46,14 +46,14 @@ export default /* glsl */`
 
 		vec3 getIBLRetroRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {
 
-			#ifdef ENVMAP_TYPE_CUBE_UV
+			#ifdef ENVMAP_TYPE_PMREM
 
 				// The retroreflective lobe returns light toward its source, so the environment is sampled along the view direction
 				vec3 retroVec = normalize( mix( viewDir, normal, pow4( roughness ) ) );
 
 				retroVec = transformDirectionByInverseViewMatrix( retroVec, viewMatrix );
 
-				vec4 envMapColor = textureCubeUV( envMap, envMapRotation * retroVec, roughness );
+				vec4 envMapColor = textureLod( envMap, envMapRotation * retroVec, roughnessToMip( roughness ) );
 
 				return envMapColor.rgb * envMapIntensity;
 
@@ -71,7 +71,7 @@ export default /* glsl */`
 
 		vec3 getIBLAnisotropyRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in vec3 bitangent, const in float anisotropy ) {
 
-			#ifdef ENVMAP_TYPE_CUBE_UV
+			#ifdef ENVMAP_TYPE_PMREM
 
 			  // https://google.github.io/filament/Filament.md.html#lighting/imagebasedlights/anisotropy
 				vec3 bentNormal = cross( bitangent, viewDir );
@@ -92,7 +92,7 @@ export default /* glsl */`
 
 			vec3 getIBLAnisotropyRetroRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in vec3 bitangent, const in float anisotropy ) {
 
-				#ifdef ENVMAP_TYPE_CUBE_UV
+				#ifdef ENVMAP_TYPE_PMREM
 
 				  // https://google.github.io/filament/Filament.md.html#lighting/imagebasedlights/anisotropy
 					vec3 bentNormal = cross( bitangent, viewDir );

package/src/renderers/shaders/ShaderChunk/lightprobes_pars_fragment.glsl.js

@@ -1,30 +1,42 @@
 export default /* glsl */`
-#ifdef USE_LIGHT_PROBES_GRID
+#if NUM_LIGHT_PROBE_GRIDS > 0
 
 // Single atlas 3D texture that stores all 7 SH sub-volumes stacked along Z.
 // Atlas depth = 7 * ( nz + 2 ) where nz = probesResolution.z.
 // Each sub-volume occupies ( nz + 2 ) slices: 1 padding + nz data + 1 padding.
 // Padding is a copy of the first / last data slice and prevents color bleeding
 // when the hardware linear filter reads across a sub-volume boundary.
-uniform highp sampler3D probesSH;
+uniform highp sampler3D probesSH[ NUM_LIGHT_PROBE_GRIDS ];
 
-uniform vec3 probesMin;
-uniform vec3 probesMax;
-uniform vec3 probesResolution;
+uniform vec3 probesMin[ NUM_LIGHT_PROBE_GRIDS ];
+uniform vec3 probesMax[ NUM_LIGHT_PROBE_GRIDS ];
+uniform vec3 probesResolution[ NUM_LIGHT_PROBE_GRIDS ];
 
-vec3 getLightProbeGridIrradiance( vec3 worldPos, vec3 worldNormal ) {
+bool isInsideLightProbeGrid( vec3 worldPos, vec3 worldNormal, vec3 probesMin, vec3 probesMax, vec3 probesResolution ) {
+
+	vec3 spacing = ( probesMax - probesMin ) / probesResolution;
+	vec3 samplePos = worldPos + worldNormal * spacing * 0.5;
+
+	// Grow the bounds by 1% of a cell, so fragments on the bounds aren't left out by
+	// precision errors or samples outside of the triangle.
+
+	vec3 margin = spacing * 0.01;
+	return all( greaterThanEqual( samplePos, probesMin - margin ) ) && all( lessThanEqual( samplePos, probesMax + margin ) );
+
+}
+
+vec3 getLightProbeGridIrradiance( highp sampler3D probesSH, vec3 probesMin, vec3 probesMax, vec3 probesResolution, vec3 worldPos, vec3 worldNormal ) {
 
 	vec3 res = probesResolution;
 	vec3 gridRange = probesMax - probesMin;
-	vec3 resMinusOne = res - 1.0;
-	vec3 probeSpacing = gridRange / resMinusOne;
+	vec3 probeSpacing = gridRange / res;
 
 	// Offset sample position along normal by half a probe spacing
 	vec3 samplePos = worldPos + worldNormal * probeSpacing * 0.5;
-	vec3 uvw = clamp( ( samplePos - probesMin ) / gridRange, 0.0, 1.0 );
 
-	// Remap to texel centers of the probe grid (XY and Z)
-	uvw = uvw * resMinusOne / res + 0.5 / res;
+	// The bounds hold one cell per probe, so they map directly to the probe grid.
+	// Clamp to the texel centers of the outermost probes (XY and Z).
+	vec3 uvw = clamp( ( samplePos - probesMin ) / gridRange, 0.5 / res, 1.0 - 0.5 / res );
 
 	// Atlas UV mapping along Z:
 	//   paddedSlices = nz + 2  (1 padding texel at each end of every sub-volume)

package/src/renderers/shaders/ShaderChunk/lights_fragment_begin.glsl.js

@@ -243,11 +243,30 @@ IncidentLight directLight;
 
 	#endif
 
-	#ifdef USE_LIGHT_PROBES_GRID
+	#if NUM_LIGHT_PROBE_GRIDS > 0
 
 		vec3 probeWorldPos = ( ( vec4( geometryPosition, 1.0 ) - viewMatrix[ 3 ] ) * viewMatrix ).xyz;
 		vec3 probeWorldNormal = transformNormalByInverseViewMatrix( geometryNormal, viewMatrix );
-		irradiance += getLightProbeGridIrradiance( probeWorldPos, probeWorldNormal );
+
+		// Sample the last grid whose cells contain the fragment.
+
+		int probeGrid = - 1;
+
+		#pragma unroll_loop_start
+		for ( int i = 0; i < NUM_LIGHT_PROBE_GRIDS; i ++ ) {
+
+			if ( isInsideLightProbeGrid( probeWorldPos, probeWorldNormal, probesMin[ i ], probesMax[ i ], probesResolution[ i ] ) ) probeGrid = UNROLLED_LOOP_INDEX;
+
+		}
+		#pragma unroll_loop_end
+
+		#pragma unroll_loop_start
+		for ( int i = 0; i < NUM_LIGHT_PROBE_GRIDS; i ++ ) {
+
+			if ( probeGrid == UNROLLED_LOOP_INDEX ) irradiance += getLightProbeGridIrradiance( probesSH[ i ], probesMin[ i ], probesMax[ i ], probesResolution[ i ], probeWorldPos, probeWorldNormal );
+
+		}
+		#pragma unroll_loop_end
 
 	#endif
 

package/src/renderers/shaders/ShaderChunk/lights_fragment_maps.glsl.js

@@ -10,7 +10,7 @@ export default /* glsl */`
 
 	#endif
 
-	#if defined( USE_ENVMAP ) && defined( ENVMAP_TYPE_CUBE_UV )
+	#if defined( USE_ENVMAP ) && defined( ENVMAP_TYPE_PMREM )
 
 		#if defined( STANDARD ) || defined( LAMBERT ) || defined( PHONG )
 

package/src/renderers/shaders/ShaderChunk/lights_physical_fragment.glsl.js

@@ -7,10 +7,26 @@ material.metalness = metalnessFactor;
 vec3 dxy = max( abs( dFdx( nonPerturbedNormal ) ), abs( dFdy( nonPerturbedNormal ) ) );
 float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
 
-material.roughness = max( roughnessFactor, 0.0525 );// 0.0525 corresponds to the base mip of a 256 cubemap.
+// Minimum roughness, so even a perfect mirror samples a prefiltered level of the environment map.
+// Matches Filament's desktop MIN_PERCEPTUAL_ROUGHNESS: https://github.com/google/filament/blob/main/shaders/src/surface_material.fs
+material.roughness = max( roughnessFactor, 0.045 );
 material.roughness += geometryRoughness;
 material.roughness = min( material.roughness, 1.0 );
 
+#ifdef USE_DIFFUSE_ROUGHNESS
+
+	float diffuseRoughnessFactor = diffuseRoughness;
+
+	#ifdef USE_DIFFUSE_ROUGHNESSMAP
+
+		diffuseRoughnessFactor *= texture2D( diffuseRoughnessMap, vDiffuseRoughnessMapUv ).r;
+
+	#endif
+
+	material.diffuseRoughness = saturate( diffuseRoughnessFactor );
+
+#endif
+
 #ifdef IOR
 
 	material.ior = ior;
@@ -73,7 +89,7 @@ material.roughness = min( material.roughness, 1.0 );
 	#endif
 
 	material.clearcoat = saturate( material.clearcoat ); // Burley clearcoat model
-	material.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );
+	material.clearcoatRoughness = max( material.clearcoatRoughness, 0.045 );
 	material.clearcoatRoughness += geometryRoughness;
 	material.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );