@unikia/upe-renderer 0.186.110 → 0.187.11

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

@@ -16,6 +16,10 @@ struct PhysicalMaterial {
 	vec2 dfg;
 	vec3 multiScatteringCompensation;
 
+	#ifdef USE_DIFFUSE_ROUGHNESS
+		float diffuseRoughness;
+	#endif
+
 	#ifdef USE_RETROREFLECTION
 		float retroreflectivity;
 	#endif
@@ -76,6 +80,66 @@ vec3 Schlick_to_F0( const in vec3 f, const in float f90, const in float dotVH )
     return ( f - vec3( f90 ) * x5 ) / ( 1.0 - x5 );
 }
 
+#ifdef USE_DIFFUSE_ROUGHNESS
+
+	// Portsmouth et al. 2025, "EON: A Practical Energy-Preserving Rough Diffuse BRDF"
+	// https://jcgt.org/published/0014/01/06/
+	const float EON_EPSILON = 1e-7;
+
+	float FON_DirectionalAlbedo( const in float mu, const in float roughness, const in float A ) {
+
+		float muComp = 1.0 - mu;
+		float gOverPi = muComp * ( 0.0571085289 + muComp * ( 0.491881867 + muComp * ( - 0.332181442 + muComp * 0.0714429953 ) ) );
+
+		return A * ( 1.0 + roughness * gOverPi );
+
+	}
+
+	vec3 BRDF_EON( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 diffuseColor, const in float roughness ) {
+
+		vec3 rho = saturate( diffuseColor );
+
+		if ( roughness <= EON_EPSILON ) return BRDF_Lambert( rho );
+
+		float dotNL = saturate( dot( normal, lightDir ) );
+		float dotNV = saturate( dot( normal, viewDir ) );
+		float s = dot( lightDir, viewDir ) - dotNL * dotNV;
+		float sOverT = ( s > 0.0 ) ? s / max( max( dotNL, dotNV ), EON_EPSILON ) : s;
+
+		float A = 1.0 / ( 1.0 + ( 0.5 - 2.0 / ( 3.0 * PI ) ) * roughness );
+		vec3 singleScatter = rho * RECIPROCAL_PI * A * ( 1.0 + roughness * sOverT );
+
+		float averageAlbedo = A * ( 1.0 + ( 2.0 / 3.0 - 28.0 / ( 15.0 * PI ) ) * roughness );
+		float albedoV = FON_DirectionalAlbedo( dotNV, roughness, A );
+		float albedoL = FON_DirectionalAlbedo( dotNL, roughness, A );
+
+		vec3 rhoMultiScatter = rho * rho * averageAlbedo / max( vec3( EON_EPSILON ), vec3( 1.0 ) - rho * ( 1.0 - averageAlbedo ) );
+		vec3 multiScatter = rhoMultiScatter * RECIPROCAL_PI
+			* max( EON_EPSILON, 1.0 - albedoV )
+			* max( EON_EPSILON, 1.0 - albedoL )
+			/ max( EON_EPSILON, 1.0 - averageAlbedo );
+
+		return singleScatter + multiScatter;
+
+	}
+
+	vec3 EON_DirectionalAlbedo( const in vec3 diffuseColor, const in float roughness, const in float dotNV ) {
+
+		vec3 rho = saturate( diffuseColor );
+
+		if ( roughness <= EON_EPSILON ) return rho;
+
+		float A = 1.0 / ( 1.0 + ( 0.5 - 2.0 / ( 3.0 * PI ) ) * roughness );
+		float directionalAlbedo = FON_DirectionalAlbedo( dotNV, roughness, A );
+		float averageAlbedo = A * ( 1.0 + ( 2.0 / 3.0 - 28.0 / ( 15.0 * PI ) ) * roughness );
+		vec3 rhoMultiScatter = rho * rho * averageAlbedo / max( vec3( EON_EPSILON ), vec3( 1.0 ) - rho * ( 1.0 - averageAlbedo ) );
+
+		return rho * directionalAlbedo + rhoMultiScatter * ( 1.0 - directionalAlbedo );
+
+	}
+
+#endif
+
 // Moving Frostbite to Physically Based Rendering 3.0 - page 12, listing 2
 // https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
 float V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {
@@ -132,7 +196,7 @@ float D_GGX( const in float alpha, const in float dotNH ) {
 
 		vec3 f0 = material.clearcoatF0;
 		float f90 = material.clearcoatF90;
-		float roughness = material.clearcoatRoughness;
+		float roughness = max( material.clearcoatRoughness, 0.045 ); // punctual lights need a minimum roughness to show a highlight
 
 		float alpha = pow2( roughness ); // UE4's roughness
 
@@ -159,7 +223,7 @@ vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 norm
 
 	vec3 f0 = material.specularColorBlended;
 	float f90 = material.specularF90;
-	float roughness = material.roughness;
+	float roughness = max( material.roughness, 0.045 ); // punctual lights need a minimum roughness to show a highlight
 
 	float alpha = pow2( roughness ); // UE4's roughness
 
@@ -187,9 +251,11 @@ vec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 norm
 		float dotBV = dot( material.anisotropyB, viewDir );
 		float dotBH = dot( material.anisotropyB, halfDir );
 
-		float V = V_GGX_SmithCorrelated_Anisotropic( material.alphaT, alpha, dotTV, dotBV, dotTL, dotBL, dotNV, dotNL );
+		float alphaT = max( material.alphaT, alpha );
+
+		float V = V_GGX_SmithCorrelated_Anisotropic( alphaT, alpha, dotTV, dotBV, dotTL, dotBL, dotNV, dotNL );
 
-		float D = D_GGX_Anisotropic( material.alphaT, alpha, dotNH, dotTH, dotBH );
+		float D = D_GGX_Anisotropic( alphaT, alpha, dotNH, dotTH, dotBH );
 
 	#else
 
@@ -543,7 +609,17 @@ void RE_Direct_Physical( const in IncidentLight directLight, const in vec3 geome
 
 	#endif
 
-	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseContribution ) * ( 1.0 - F );
+	#ifdef USE_DIFFUSE_ROUGHNESS
+
+		vec3 diffuseBRDF = BRDF_EON( directLight.direction, geometryViewDir, geometryNormal, material.diffuseColor, material.diffuseRoughness ) * ( 1.0 - material.metalness );
+
+	#else
+
+		vec3 diffuseBRDF = BRDF_Lambert( material.diffuseContribution );
+
+	#endif
+
+	reflectedLight.directDiffuse += irradiance * diffuseBRDF * ( 1.0 - F );
 }
 
 void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
@@ -562,7 +638,19 @@ void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in vec3 geomet
 
 	#endif
 
-	vec3 diffuse = irradiance * BRDF_Lambert( material.diffuseContribution ) * ( 1.0 - singleScattering - multiScattering );
+	#ifdef USE_DIFFUSE_ROUGHNESS
+
+		float dotNV = saturate( dot( geometryNormal, geometryViewDir ) );
+		// Irradiance has already integrated the cosine term, so use the directional
+		// albedo to approximate EON under locally uniform incident radiance.
+		vec3 diffuseAlbedo = EON_DirectionalAlbedo( material.diffuseColor, material.diffuseRoughness, dotNV ) * ( 1.0 - material.metalness );
+		vec3 diffuse = irradiance * RECIPROCAL_PI * diffuseAlbedo * ( 1.0 - singleScattering - multiScattering );
+
+	#else
+
+		vec3 diffuse = irradiance * BRDF_Lambert( material.diffuseContribution ) * ( 1.0 - singleScattering - multiScattering );
+
+	#endif
 
 	#ifdef USE_SHEEN
 
@@ -621,7 +709,16 @@ void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradia
 
 	// Diffuse energy conservation uses dielectric path
 	vec3 totalScatteringDielectric = singleScatteringDielectric + multiScatteringDielectric;
-	vec3 diffuse = material.diffuseContribution * ( 1.0 - totalScatteringDielectric );
+	#ifdef USE_DIFFUSE_ROUGHNESS
+
+		float dotNV = saturate( dot( geometryNormal, geometryViewDir ) );
+		vec3 diffuse = EON_DirectionalAlbedo( material.diffuseColor, material.diffuseRoughness, dotNV ) * ( 1.0 - material.metalness ) * ( 1.0 - totalScatteringDielectric );
+
+	#else
+
+		vec3 diffuse = material.diffuseContribution * ( 1.0 - totalScatteringDielectric );
+
+	#endif
 
 	vec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
 

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

@@ -4,7 +4,16 @@ export default /* glsl */`
 	// morphTargetBaseInfluence is set based on BufferGeometry.morphTargetsRelative value:
 	// When morphTargetsRelative is false, this is set to 1 - sum(influences); this results in normal = sum((target - base) * influence)
 	// When morphTargetsRelative is true, this is set to 1; as a result, all morph targets are simply added to the base after weighting
-	vColor *= morphTargetBaseInfluence;
+
+	#if defined( USE_COLOR_ALPHA )
+
+		vColor *= morphTargetBaseInfluence;
+
+	#elif defined( USE_COLOR )
+
+		vColor.rgb *= morphTargetBaseInfluence;
+
+	#endif
 
 	for ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {
 
@@ -14,7 +23,7 @@ export default /* glsl */`
 
 		#elif defined( USE_COLOR )
 
-			if ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ).rgb * morphTargetInfluences[ i ];
+			if ( morphTargetInfluences[ i ] != 0.0 ) vColor.rgb += getMorph( gl_VertexID, i, 2 ).rgb * morphTargetInfluences[ i ];
 
 		#endif
 

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

@@ -152,7 +152,16 @@ export default /* glsl */`
 			float shadow = 1.0;
 
 			shadowCoord.xyz /= shadowCoord.w;
-			shadowCoord.z += shadowBias;
+
+			#ifdef USE_REVERSED_DEPTH_BUFFER
+
+				shadowCoord.z -= shadowBias;
+
+			#else
+
+				shadowCoord.z += shadowBias;
+
+			#endif
 
 			bool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;
 			bool frustumTest = inFrustum && shadowCoord.z <= 1.0;
@@ -162,7 +171,7 @@ export default /* glsl */`
 				// Hardware PCF with LinearFilter gives us 4-tap filtering per sample
 				// 5 samples using Vogel disk + IGN = effectively 20 filtered taps with better distribution
 				vec2 texelSize = vec2( 1.0 ) / shadowMapSize;
-				float radius = shadowRadius * texelSize.x;
+				vec2 radius = shadowRadius * texelSize;
 
 				// Use IGN to rotate sampling pattern per pixel
 				float phi = interleavedGradientNoise( gl_FragCoord.xy ) * PI2;
@@ -362,17 +371,22 @@ export default /* glsl */`
 
 		if ( viewSpaceZ - shadowCameraFar <= 0.0 && viewSpaceZ - shadowCameraNear >= 0.0 ) {
 
-			// viewZ to perspective depth
+			// Each sample is compared against the depth of the point next to the fragment in its direction,
+			// on whichever face of the cube it falls, so the comparison is the same on every face. A face
+			// stores the depth along its own axis, which for the point at direction * lightDistance is
+			// lightDistance * max( |x|, |y|, |z| ) of the direction, and perspective depth is a + b / z.
+			float lightDistance = length( lightToPosition );
+			float depthRange = shadowCameraFar - shadowCameraNear;
 
 			#ifdef USE_REVERSED_DEPTH_BUFFER
 
-				float dp = ( shadowCameraNear * ( shadowCameraFar - viewSpaceZ ) ) / ( viewSpaceZ * ( shadowCameraFar - shadowCameraNear ) );
-				dp -= shadowBias;
+				float depthA = - shadowCameraNear / depthRange - shadowBias;
+				float depthB = shadowCameraNear * shadowCameraFar / ( depthRange * lightDistance );
 
 			#else
 
-				float dp = ( shadowCameraFar * ( viewSpaceZ - shadowCameraNear ) ) / ( viewSpaceZ * ( shadowCameraFar - shadowCameraNear ) );
-				dp += shadowBias;
+				float depthA = shadowCameraFar / depthRange + shadowBias;
+				float depthB = - shadowCameraNear * shadowCameraFar / ( depthRange * lightDistance );
 
 			#endif
 
@@ -389,19 +403,21 @@ export default /* glsl */`
 			// Use IGN to rotate sampling pattern per pixel
 			float phi = interleavedGradientNoise( gl_FragCoord.xy ) * PI2;
 
-			vec2 sample0 = vogelDiskSample( 0, 5, phi );
-			vec2 sample1 = vogelDiskSample( 1, 5, phi );
-			vec2 sample2 = vogelDiskSample( 2, 5, phi );
-			vec2 sample3 = vogelDiskSample( 3, 5, phi );
-			vec2 sample4 = vogelDiskSample( 4, 5, phi );
-
-			shadow = (
-				texture( shadowMap, vec4( bd3D + ( tangent * sample0.x + bitangent * sample0.y ) * texelSize, dp ) ) +
-				texture( shadowMap, vec4( bd3D + ( tangent * sample1.x + bitangent * sample1.y ) * texelSize, dp ) ) +
-				texture( shadowMap, vec4( bd3D + ( tangent * sample2.x + bitangent * sample2.y ) * texelSize, dp ) ) +
-				texture( shadowMap, vec4( bd3D + ( tangent * sample3.x + bitangent * sample3.y ) * texelSize, dp ) ) +
-				texture( shadowMap, vec4( bd3D + ( tangent * sample4.x + bitangent * sample4.y ) * texelSize, dp ) )
-			) * 0.2;
+			shadow = 0.0;
+
+			for ( int i = 0; i < 5; i ++ ) {
+
+				vec2 offset = vogelDiskSample( i, 5, phi );
+				vec3 direction = bd3D + ( tangent * offset.x + bitangent * offset.y ) * texelSize;
+				vec3 absDirection = abs( direction );
+
+				float dp = depthA + depthB / max( max( absDirection.x, absDirection.y ), absDirection.z );
+
+				shadow += texture( shadowMap, vec4( direction, dp ) );
+
+			}
+
+			shadow *= 0.2;
 
 		}
 

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

@@ -48,6 +48,11 @@ export default /* glsl */`
 
 	varying vec2 vRoughnessMapUv;
 
+#endif
+#ifdef USE_DIFFUSE_ROUGHNESSMAP
+
+	varying vec2 vDiffuseRoughnessMapUv;
+
 #endif
 #ifdef USE_ANISOTROPYMAP
 

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

@@ -63,6 +63,12 @@ export default /* glsl */`
 	uniform mat3 roughnessMapTransform;
 	varying vec2 vRoughnessMapUv;
 
+#endif
+#ifdef USE_DIFFUSE_ROUGHNESSMAP
+
+	uniform mat3 diffuseRoughnessMapTransform;
+	varying vec2 vDiffuseRoughnessMapUv;
+
 #endif
 #ifdef USE_ANISOTROPYMAP
 

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

@@ -53,6 +53,11 @@ export default /* glsl */`
 
 	vRoughnessMapUv = ( roughnessMapTransform * vec3( ROUGHNESSMAP_UV, 1 ) ).xy;
 
+#endif
+#ifdef USE_DIFFUSE_ROUGHNESSMAP
+
+	vDiffuseRoughnessMapUv = ( diffuseRoughnessMapTransform * vec3( DIFFUSE_ROUGHNESSMAP_UV, 1 ) ).xy;
+
 #endif
 #ifdef USE_ANISOTROPYMAP
 

package/src/renderers/shaders/ShaderChunk.js

@@ -22,7 +22,6 @@ import color_pars_fragment from './ShaderChunk/color_pars_fragment.glsl.js';
 import color_pars_vertex from './ShaderChunk/color_pars_vertex.glsl.js';
 import color_vertex from './ShaderChunk/color_vertex.glsl.js';
 import common from './ShaderChunk/common.glsl.js';
-import cube_uv_reflection_fragment from './ShaderChunk/cube_uv_reflection_fragment.glsl.js';
 import defaultnormal_vertex from './ShaderChunk/defaultnormal_vertex.glsl.js';
 import displacementmap_pars_vertex from './ShaderChunk/displacementmap_pars_vertex.glsl.js';
 import displacementmap_vertex from './ShaderChunk/displacementmap_vertex.glsl.js';
@@ -150,7 +149,6 @@ export const ShaderChunk = {
 	color_pars_vertex: color_pars_vertex,
 	color_vertex: color_vertex,
 	common: common,
-	cube_uv_reflection_fragment: cube_uv_reflection_fragment,
 	defaultnormal_vertex: defaultnormal_vertex,
 	displacementmap_pars_vertex: displacementmap_pars_vertex,
 	displacementmap_vertex: displacementmap_vertex,

package/src/renderers/shaders/ShaderLib/backgroundCube.glsl.js

@@ -17,37 +17,23 @@ void main() {
 
 export const fragment = /* glsl */`
 
-#ifdef ENVMAP_TYPE_CUBE
-
-	uniform samplerCube envMap;
-
-#elif defined( ENVMAP_TYPE_CUBE_UV )
-
-	uniform sampler2D envMap;
-
-#endif
-
 uniform float backgroundBlurriness;
 uniform float backgroundIntensity;
 uniform mat3 backgroundRotation;
 
 varying vec3 vWorldDirection;
 
-#include <cube_uv_reflection_fragment>
+#include <envmap_common_pars_fragment>
 
 void main() {
 
-	#ifdef ENVMAP_TYPE_CUBE
+	#ifdef ENVMAP_TYPE_PMREM
 
-		vec4 texColor = textureCube( envMap, backgroundRotation * vWorldDirection );
-
-	#elif defined( ENVMAP_TYPE_CUBE_UV )
-
-		vec4 texColor = textureCubeUV( envMap, backgroundRotation * vWorldDirection, backgroundBlurriness );
+		vec4 texColor = textureLod( envMap, backgroundRotation * vWorldDirection, roughnessToMip( backgroundBlurriness ) );
 
 	#else
 
-		vec4 texColor = vec4( 0.0, 0.0, 0.0, 1.0 );
+		vec4 texColor = textureCube( envMap, backgroundRotation * vWorldDirection );
 
 	#endif
 

package/src/renderers/shaders/ShaderLib/meshlambert.glsl.js

@@ -68,7 +68,6 @@ uniform float opacity;
 #include <aomap_pars_fragment>
 #include <lightmap_pars_fragment>
 #include <emissivemap_pars_fragment>
-#include <cube_uv_reflection_fragment>
 #include <envmap_common_pars_fragment>
 #include <envmap_pars_fragment>
 #include <envmap_physical_pars_fragment>

package/src/renderers/shaders/ShaderLib/meshphong.glsl.js

@@ -70,7 +70,6 @@ uniform float opacity;
 #include <aomap_pars_fragment>
 #include <lightmap_pars_fragment>
 #include <emissivemap_pars_fragment>
-#include <cube_uv_reflection_fragment>
 #include <envmap_common_pars_fragment>
 #include <envmap_pars_fragment>
 #include <envmap_physical_pars_fragment>

package/src/renderers/shaders/ShaderLib/meshphysical.glsl.js

@@ -95,6 +95,14 @@ uniform float opacity;
 	uniform float clearcoatRoughness;
 #endif
 
+#ifdef USE_DIFFUSE_ROUGHNESS
+	uniform float diffuseRoughness;
+
+	#ifdef USE_DIFFUSE_ROUGHNESSMAP
+		uniform sampler2D diffuseRoughnessMap;
+	#endif
+#endif
+
 #ifdef USE_DISPERSION
 	uniform float dispersion;
 #endif
@@ -145,7 +153,6 @@ varying vec3 vViewPosition;
 #include <lightmap_pars_fragment>
 #include <emissivemap_pars_fragment>
 #include <iridescence_fragment>
-#include <cube_uv_reflection_fragment>
 #include <envmap_common_pars_fragment>
 #include <envmap_physical_pars_fragment>
 #include <fog_pars_fragment>

package/src/renderers/shaders/ShaderLib.js

@@ -315,6 +315,9 @@ ShaderLib.physical = {
 			clearcoatRoughness: { value: 0 },
 			clearcoatRoughnessMap: { value: null },
 			clearcoatRoughnessMapTransform: { value: /*@__PURE__*/ new Matrix3() },
+			diffuseRoughness: { value: 0 },
+			diffuseRoughnessMap: { value: null },
+			diffuseRoughnessMapTransform: { value: /*@__PURE__*/ new Matrix3() },
 			dispersion: { value: 0 },
 			retroreflectivity: { value: 0 },
 			iridescence: { value: 0 },

package/src/renderers/shaders/UniformsLib.js

@@ -1,6 +1,5 @@
 import { Color } from '../../math/Color.js';
 import { Vector2 } from '../../math/Vector2.js';
-import { Vector3 } from '../../math/Vector3.js';
 import { Matrix3 } from '../../math/Matrix3.js';
 
 // Uniforms library for shared webgl shaders
@@ -210,10 +209,10 @@ const UniformsLib = {
 		ltc_1: { value: null },
 		ltc_2: { value: null },
 
-		probesSH: { value: null },
-		probesMin: { value: /*@__PURE__*/ new Vector3() },
-		probesMax: { value: /*@__PURE__*/ new Vector3() },
-		probesResolution: { value: /*@__PURE__*/ new Vector3() }
+		probesSH: { value: [] },
+		probesMin: { value: [] },
+		probesMax: { value: [] },
+		probesResolution: { value: [] }
 
 	},
 

package/src/renderers/webgl/WebGLBackground.js

@@ -1,4 +1,4 @@
-import { BackSide, FrontSide, CubeUVReflectionMapping, SRGBTransfer } from '../../constants.js';
+import { BackSide, FrontSide, SRGBTransfer } from '../../constants.js';
 import { BoxGeometry } from '../../geometries/BoxGeometry.js';
 import { PlaneGeometry } from '../../geometries/PlaneGeometry.js';
 import { ShaderMaterial } from '../../materials/ShaderMaterial.js';
@@ -89,7 +89,7 @@ function WebGLBackground( renderer, environments, state, objects, alpha, premult
 
 		const background = getBackground( scene );
 
-		if ( background && ( background.isCubeTexture || background.mapping === CubeUVReflectionMapping ) ) {
+		if ( background && background.isCubeTexture ) {
 
 			if ( boxMesh === undefined ) {
 
@@ -141,7 +141,7 @@ function WebGLBackground( renderer, environments, state, objects, alpha, premult
 			// note: since the matrix is orthonormal, we can use the more-efficient transpose() in lieu of invert()
 			boxMesh.material.uniforms.backgroundRotation.value.setFromMatrix4( _m1.makeRotationFromEuler( scene.backgroundRotation ) ).transpose();
 
-			if ( background.isCubeTexture && background.isRenderTargetTexture === false ) {
+			if ( background.isRenderTargetTexture === false ) {
 
 				boxMesh.material.uniforms.backgroundRotation.value.premultiply( _m );
 

package/src/renderers/webgl/WebGLBindingStates.js

@@ -358,11 +358,13 @@ function WebGLBindingStates( gl, attributes ) {
 
 					if ( geometryAttribute.isInterleavedBufferAttribute ) {
 
+						// interleaved attributes can also view a buffer attribute, e.g. the columns of instance matrices
+
 						const data = geometryAttribute.data;
-						const stride = data.stride;
+						const stride = data.isInterleavedBuffer === true ? data.stride : data.itemSize;
 						const offset = geometryAttribute.offset;
 
-						if ( data.isInstancedInterleavedBuffer ) {
+						if ( data.isInstancedInterleavedBuffer || data.isInstancedBufferAttribute ) {
 
 							for ( let i = 0; i < programAttribute.locationSize; i ++ ) {
 

package/src/renderers/webgl/WebGLCapabilities.js

@@ -92,8 +92,8 @@ function WebGLCapabilities( gl, extensions, parameters, utils ) {
 
 	}
 
-	const logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true;
 	const reversedDepthBuffer = parameters.reversedDepthBuffer === true && extensions.has( 'EXT_clip_control' );
+	const logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true && reversedDepthBuffer === false;
 
 	if ( parameters.reversedDepthBuffer === true && reversedDepthBuffer === false ) {
 
@@ -101,6 +101,12 @@ function WebGLCapabilities( gl, extensions, parameters, utils ) {
 
 	}
 
+	if ( parameters.logarithmicDepthBuffer === true && reversedDepthBuffer === true ) {
+
+		warn( 'WebGLRenderer: Logarithmic depth buffer is ignored when reversed depth buffer is enabled.' );
+
+	}
+
 	const maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS );
 	const maxVertexTextures = gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS );
 	const maxTextureSize = gl.getParameter( gl.MAX_TEXTURE_SIZE );

package/src/renderers/webgl/WebGLEnvironments.js

@@ -70,14 +70,14 @@ function WebGLEnvironments( renderer ) {
 
 	function getPMREM( texture ) {
 
-		if ( texture && texture.isTexture ) {
+		if ( texture && texture.isTexture && texture.isPMREMTexture !== true ) {
 
 			const mapping = texture.mapping;
 
 			const isEquirectMap = ( mapping === EquirectangularReflectionMapping || mapping === EquirectangularRefractionMapping );
 			const isCubeMap = ( mapping === CubeReflectionMapping || mapping === CubeRefractionMapping );
 
-			// equirect/cube map to cubeUV conversion
+			// equirect/cube map to PMREM conversion
 
 			if ( isEquirectMap || isCubeMap ) {