super-three 0.133.4 → 0.136.1

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

@@ -14,7 +14,7 @@ material.roughness = min( material.roughness, 1.0 );
 	#ifdef SPECULAR
 
 		float specularIntensityFactor = specularIntensity;
-		vec3 specularTintFactor = specularTint;
+		vec3 specularColorFactor = specularColor;
 
 		#ifdef USE_SPECULARINTENSITYMAP
 
@@ -22,9 +22,9 @@ material.roughness = min( material.roughness, 1.0 );
 
 		#endif
 
-		#ifdef USE_SPECULARTINTMAP
+		#ifdef USE_SPECULARCOLORMAP
 
-			specularTintFactor *= specularTintMapTexelToLinear( texture2D( specularTintMap, vUv ) ).rgb;
+			specularColorFactor *= texture2D( specularColorMap, vUv ).rgb;
 
 		#endif
 
@@ -33,12 +33,12 @@ material.roughness = min( material.roughness, 1.0 );
 	#else
 
 		float specularIntensityFactor = 1.0;
-		vec3 specularTintFactor = vec3( 1.0 );
+		vec3 specularColorFactor = vec3( 1.0 );
 		material.specularF90 = 1.0;
 
 	#endif
 
-	material.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularTintFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );
+	material.specularColor = mix( min( pow2( ( ior - 1.0 ) / ( ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );
 
 #else
 
@@ -75,8 +75,21 @@ material.roughness = min( material.roughness, 1.0 );
 
 #ifdef USE_SHEEN
 
-	material.sheenTint = sheenTint;
+	material.sheenColor = sheenColor;
+
+	#ifdef USE_SHEENCOLORMAP
+
+		material.sheenColor *= texture2D( sheenColorMap, vUv ).rgb;
+
+	#endif
+
 	material.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );
 
+	#ifdef USE_SHEENROUGHNESSMAP
+
+		material.sheenRoughness *= texture2D( sheenRoughnessMap, vUv ).a;
+
+	#endif
+
 #endif
 `;

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

@@ -14,7 +14,7 @@ struct PhysicalMaterial {
 	#endif
 
 	#ifdef USE_SHEEN
-		vec3 sheenTint;
+		vec3 sheenColor;
 		float sheenRoughness;
 	#endif
 
@@ -22,6 +22,26 @@ struct PhysicalMaterial {
 
 // temporary
 vec3 clearcoatSpecular = vec3( 0.0 );
+vec3 sheenSpecular = vec3( 0.0 );
+
+// This is a curve-fit approxmation to the "Charlie sheen" BRDF integrated over the hemisphere from 
+// Estevez and Kulla 2017, "Production Friendly Microfacet Sheen BRDF". The analysis can be found
+// in the Sheen section of https://drive.google.com/file/d/1T0D1VSyR4AllqIJTQAraEIzjlb5h4FKH/view?usp=sharing
+float IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness) {
+
+	float dotNV = saturate( dot( normal, viewDir ) );
+
+	float r2 = roughness * roughness;
+
+	float a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;
+
+	float b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;
+
+	float DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );
+
+	return saturate( DG * RECIPROCAL_PI );
+
+}
 
 // Analytical approximation of the DFG LUT, one half of the
 // split-sum approximation used in indirect specular lighting.
@@ -133,7 +153,7 @@ void RE_Direct_Physical( const in IncidentLight directLight, const in GeometricC
 
 	#ifdef USE_SHEEN
 
-		reflectedLight.directSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenTint, material.sheenRoughness );
+		sheenSpecular += irradiance * BRDF_Sheen( directLight.direction, geometry.viewDir, geometry.normal, material.sheenColor, material.sheenRoughness );
 
 	#endif
 
@@ -157,6 +177,12 @@ void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradia
 
 	#endif
 
+	#ifdef USE_SHEEN
+
+		sheenSpecular += irradiance * material.sheenColor * IBLSheenBRDF( geometry.normal, geometry.viewDir, material.sheenRoughness );
+
+	#endif
+
 	// Both indirect specular and indirect diffuse light accumulate here
 
 	vec3 singleScattering = vec3( 0.0 );

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

@@ -1,10 +1,17 @@
 export default /* glsl */`
 #ifdef USE_MAP
 
-	vec4 texelColor = texture2D( map, vUv );
+	vec4 sampledDiffuseColor = texture2D( map, vUv );
 
-	texelColor = mapTexelToLinear( texelColor );
-	diffuseColor *= texelColor;
+	#ifdef DECODE_VIDEO_TEXTURE
+
+		// inline sRGB decode (TODO: Remove this code when https://crbug.com/1256340 is solved)
+
+		sampledDiffuseColor = vec4( mix( pow( sampledDiffuseColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), sampledDiffuseColor.rgb * 0.0773993808, vec3( lessThanEqual( sampledDiffuseColor.rgb, vec3( 0.04045 ) ) ) ), sampledDiffuseColor.w );
+
+	#endif
+
+	diffuseColor *= sampledDiffuseColor;
 
 #endif
 `;

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

@@ -7,8 +7,7 @@ export default /* glsl */`
 
 #ifdef USE_MAP
 
-	vec4 mapTexel = texture2D( map, uv );
-	diffuseColor *= mapTexelToLinear( mapTexel );
+	diffuseColor *= texture2D( map, uv );
 
 #endif
 

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

@@ -13,7 +13,7 @@ vec3 LinearToneMapping( vec3 color ) {
 
 }
 
-// source: https://www.cs.utah.edu/~reinhard/cdrom/
+// source: https://www.cs.utah.edu/docs/techreports/2002/pdf/UUCS-02-001.pdf
 vec3 ReinhardToneMapping( vec3 color ) {
 
 	color *= toneMappingExposure;

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

@@ -24,7 +24,7 @@ export default /* glsl */`
 	vec4 transmission = getIBLVolumeRefraction(
 		n, v, roughnessFactor, material.diffuseColor, material.specularColor, material.specularF90,
 		pos, modelMatrix, viewMatrix, projectionMatrix, ior, thicknessFactor,
-		attenuationTint, attenuationDistance );
+		attenuationColor, attenuationDistance );
 
 	totalDiffuse = mix( totalDiffuse, transmission.rgb, transmissionFactor );
 	transmissionAlpha = mix( transmissionAlpha, transmission.a, transmissionFactor );

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

@@ -7,7 +7,7 @@ export default /* glsl */`
 	uniform float transmission;
 	uniform float thickness;
 	uniform float attenuationDistance;
-	uniform vec3 attenuationTint;
+	uniform vec3 attenuationColor;
 
 	#ifdef USE_TRANSMISSIONMAP
 
@@ -29,7 +29,7 @@ export default /* glsl */`
 
 	varying vec3 vWorldPosition;
 
-	vec3 getVolumeTransmissionRay( vec3 n, vec3 v, float thickness, float ior, mat4 modelMatrix ) {
+	vec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {
 
 		// Direction of refracted light.
 		vec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );
@@ -45,7 +45,7 @@ export default /* glsl */`
 
 	}
 
-	float applyIorToRoughness( float roughness, float ior ) {
+	float applyIorToRoughness( const in float roughness, const in float ior ) {
 
 		// Scale roughness with IOR so that an IOR of 1.0 results in no microfacet refraction and
 		// an IOR of 1.5 results in the default amount of microfacet refraction.
@@ -53,7 +53,7 @@ export default /* glsl */`
 
 	}
 
-	vec4 getTransmissionSample( vec2 fragCoord, float roughness, float ior ) {
+	vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
 
 		float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
 
@@ -69,7 +69,7 @@ export default /* glsl */`
 
 	}
 
-	vec3 applyVolumeAttenuation( vec3 radiance, float transmissionDistance, vec3 attenuationColor, float attenuationDistance ) {
+	vec3 applyVolumeAttenuation( const in vec3 radiance, const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {
 
 		if ( attenuationDistance == 0.0 ) {
 
@@ -87,9 +87,10 @@ export default /* glsl */`
 
 	}
 
-	vec4 getIBLVolumeRefraction( vec3 n, vec3 v, float roughness, vec3 diffuseColor, vec3 specularColor, float specularF90,
-		vec3 position, mat4 modelMatrix, mat4 viewMatrix, mat4 projMatrix, float ior, float thickness,
-		vec3 attenuationColor, float attenuationDistance ) {
+	vec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,
+		const in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,
+		const in mat4 viewMatrix, const in mat4 projMatrix, const in float ior, const in float thickness,
+		const in vec3 attenuationColor, const in float attenuationDistance ) {
 
 		vec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );
 		vec3 refractedRayExit = position + transmissionRay;

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

@@ -18,9 +18,7 @@ varying vec2 vUv;
 
 void main() {
 
-	vec4 texColor = texture2D( t2D, vUv );
-
-	gl_FragColor = mapTexelToLinear( texColor );
+	gl_FragColor = texture2D( t2D, vUv );
 
 	#include <tonemapping_fragment>
 	#include <encodings_fragment>

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

@@ -26,9 +26,7 @@ void main() {
 
 	vec2 sampleUV = equirectUv( direction );
 
-	vec4 texColor = texture2D( tEquirect, sampleUV );
-
-	gl_FragColor = mapTexelToLinear( texColor );
+	gl_FragColor = texture2D( tEquirect, sampleUV );
 
 	#include <tonemapping_fragment>
 	#include <encodings_fragment>

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

@@ -87,7 +87,7 @@ void main() {
 	#ifdef USE_LIGHTMAP
 
 		vec4 lightMapTexel= texture2D( lightMap, vUv2 );
-		reflectedLight.indirectDiffuse += lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;
+		reflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity;
 
 	#else
 

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

@@ -86,11 +86,10 @@ void main() {
 	#ifdef USE_MATCAP
 
 		vec4 matcapColor = texture2D( matcap, uv );
-		matcapColor = matcapTexelToLinear( matcapColor );
 
 	#else
 
-		vec4 matcapColor = vec4( 1.0 );
+		vec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 ); // default if matcap is missing
 
 	#endif
 

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

@@ -77,14 +77,14 @@ uniform float opacity;
 
 #ifdef SPECULAR
 	uniform float specularIntensity;
-	uniform vec3 specularTint;
+	uniform vec3 specularColor;
 
 	#ifdef USE_SPECULARINTENSITYMAP
 		uniform sampler2D specularIntensityMap;
 	#endif
 
-	#ifdef USE_SPECULARTINTMAP
-		uniform sampler2D specularTintMap;
+	#ifdef USE_SPECULARCOLORMAP
+		uniform sampler2D specularColorMap;
 	#endif
 #endif
 
@@ -94,8 +94,16 @@ uniform float opacity;
 #endif
 
 #ifdef USE_SHEEN
-	uniform vec3 sheenTint;
+	uniform vec3 sheenColor;
 	uniform float sheenRoughness;
+
+	#ifdef USE_SHEENCOLORMAP
+		uniform sampler2D sheenColorMap;
+	#endif
+
+	#ifdef USE_SHEENROUGHNESSMAP
+		uniform sampler2D sheenRoughnessMap;
+	#endif
 #endif
 
 varying vec3 vViewPosition;
@@ -167,13 +175,23 @@ void main() {
 
 	vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
 
+	#ifdef USE_SHEEN
+
+		// Sheen energy compensation approximation calculation can be found at the end of
+		// https://drive.google.com/file/d/1T0D1VSyR4AllqIJTQAraEIzjlb5h4FKH/view?usp=sharing
+		float sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );
+
+		outgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;
+
+	#endif
+
 	#ifdef USE_CLEARCOAT
 
 		float dotNVcc = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );
 
 		vec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );
 
-		outgoingLight = outgoingLight * ( 1.0 - clearcoat * Fcc ) + clearcoatSpecular * clearcoat;
+		outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + clearcoatSpecular * material.clearcoat;
 
 	#endif
 

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

@@ -10,12 +10,13 @@ export const fragment = /* glsl */`
 uniform sampler2D shadow_pass;
 uniform vec2 resolution;
 uniform float radius;
-uniform float samples;
 
 #include <packing>
 
 void main() {
 
+	const float samples = float( VSM_SAMPLES );
+
 	float mean = 0.0;
 	float squared_mean = 0.0;
 

package/src/renderers/shaders/ShaderLib.js

@@ -297,8 +297,10 @@ ShaderLib.physical = {
 			clearcoatNormalScale: { value: new Vector2( 1, 1 ) },
 			clearcoatNormalMap: { value: null },
 			sheen: { value: 0 },
-			sheenTint: { value: new Color( 0x000000 ) },
-			sheenRoughness: { value: 0 },
+			sheenColor: { value: new Color( 0x000000 ) },
+			sheenColorMap: { value: null },
+			sheenRoughness: { value: 1 },
+			sheenRoughnessMap: { value: null },
 			transmission: { value: 0 },
 			transmissionMap: { value: null },
 			transmissionSamplerSize: { value: new Vector2() },
@@ -306,11 +308,11 @@ ShaderLib.physical = {
 			thickness: { value: 0 },
 			thicknessMap: { value: null },
 			attenuationDistance: { value: 0 },
-			attenuationTint: { value: new Color( 0x000000 ) },
-			specularIntensity: { value: 0 },
+			attenuationColor: { value: new Color( 0x000000 ) },
+			specularIntensity: { value: 1 },
 			specularIntensityMap: { value: null },
-			specularTint: { value: new Color( 1, 1, 1 ) },
-			specularTintMap: { value: null },
+			specularColor: { value: new Color( 1, 1, 1 ) },
+			specularColorMap: { value: null },
 		}
 	] ),
 

package/src/renderers/shaders/UniformsLib.js

@@ -34,8 +34,7 @@ const UniformsLib = {
 		flipEnvMap: { value: - 1 },
 		reflectivity: { value: 1.0 }, // basic, lambert, phong
 		ior: { value: 1.5 }, // standard, physical
-		refractionRatio: { value: 0.98 },
-		maxMipLevel: { value: 0 }
+		refractionRatio: { value: 0.98 }
 
 	},
 

package/src/renderers/webgl/WebGLCapabilities.js

@@ -52,10 +52,8 @@ function WebGLCapabilities( gl, extensions, parameters ) {
 
 	}
 
-	/* eslint-disable no-undef */
 	const isWebGL2 = ( typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext ) ||
 		( typeof WebGL2ComputeRenderingContext !== 'undefined' && gl instanceof WebGL2ComputeRenderingContext );
-	/* eslint-enable no-undef */
 
 	let precision = parameters.precision !== undefined ? parameters.precision : 'highp';
 	const maxPrecision = getMaxPrecision( precision );

package/src/renderers/webgl/WebGLCubeMaps.js

@@ -40,14 +40,10 @@ function WebGLCubeMaps( renderer ) {
 
 					if ( image && image.height > 0 ) {
 
-						const currentRenderTarget = renderer.getRenderTarget();
-
 						const renderTarget = new WebGLCubeRenderTarget( image.height / 2 );
 						renderTarget.fromEquirectangularTexture( renderer, texture );
 						cubemaps.set( texture, renderTarget );
 
-						renderer.setRenderTarget( currentRenderTarget );
-
 						texture.addEventListener( 'dispose', onTextureDispose );
 
 						return mapTextureMapping( renderTarget.texture, texture.mapping );

package/src/renderers/webgl/WebGLCubeUVMaps.js

@@ -9,45 +9,58 @@ function WebGLCubeUVMaps( renderer ) {
 
 	function get( texture ) {
 
-		if ( texture && texture.isTexture && texture.isRenderTargetTexture === false ) {
+		if ( texture && texture.isTexture ) {
 
 			const mapping = texture.mapping;
 
 			const isEquirectMap = ( mapping === EquirectangularReflectionMapping || mapping === EquirectangularRefractionMapping );
 			const isCubeMap = ( mapping === CubeReflectionMapping || mapping === CubeRefractionMapping );
 
+			// equirect/cube map to cubeUV conversion
+
 			if ( isEquirectMap || isCubeMap ) {
 
-				// equirect/cube map to cubeUV conversion
+				if ( texture.isRenderTargetTexture && texture.needsPMREMUpdate === true ) {
+
+					texture.needsPMREMUpdate = false;
+
+					let renderTarget = cubeUVmaps.get( texture );
+
+					if ( pmremGenerator === null ) pmremGenerator = new PMREMGenerator( renderer );
 
-				if ( cubeUVmaps.has( texture ) ) {
+					renderTarget = isEquirectMap ? pmremGenerator.fromEquirectangular( texture, renderTarget ) : pmremGenerator.fromCubemap( texture, renderTarget );
+					cubeUVmaps.set( texture, renderTarget );
 
-					return cubeUVmaps.get( texture ).texture;
+					return renderTarget.texture;
 
 				} else {
 
-					const image = texture.image;
+					if ( cubeUVmaps.has( texture ) ) {
 
-					if ( ( isEquirectMap && image && image.height > 0 ) || ( isCubeMap && image && isCubeTextureComplete( image ) ) ) {
+						return cubeUVmaps.get( texture ).texture;
 
-						const currentRenderTarget = renderer.getRenderTarget();
+					} else {
 
-						if ( pmremGenerator === null ) pmremGenerator = new PMREMGenerator( renderer );
+						const image = texture.image;
 
-						const renderTarget = isEquirectMap ? pmremGenerator.fromEquirectangular( texture ) : pmremGenerator.fromCubemap( texture );
-						cubeUVmaps.set( texture, renderTarget );
+						if ( ( isEquirectMap && image && image.height > 0 ) || ( isCubeMap && image && isCubeTextureComplete( image ) ) ) {
 
-						renderer.setRenderTarget( currentRenderTarget );
+							if ( pmremGenerator === null ) pmremGenerator = new PMREMGenerator( renderer );
 
-						texture.addEventListener( 'dispose', onTextureDispose );
+							const renderTarget = isEquirectMap ? pmremGenerator.fromEquirectangular( texture ) : pmremGenerator.fromCubemap( texture );
+							cubeUVmaps.set( texture, renderTarget );
 
-						return renderTarget.texture;
+							texture.addEventListener( 'dispose', onTextureDispose );
 
-					} else {
+							return renderTarget.texture;
+
+						} else {
+
+							// image not yet ready. try the conversion next frame
 
-						// image not yet ready. try the conversion next frame
+							return null;
 
-						return null;
+						}
 
 					}
 

package/src/renderers/webgl/WebGLExtensions.js

@@ -70,6 +70,7 @@ function WebGLExtensions( gl ) {
 
 			getExtension( 'OES_texture_float_linear' );
 			getExtension( 'EXT_color_buffer_half_float' );
+			getExtension( 'WEBGL_multisampled_render_to_texture' );
 
 		},
 

package/src/renderers/webgl/WebGLMaterials.js

@@ -157,14 +157,6 @@ function WebGLMaterials( properties ) {
 			uniforms.ior.value = material.ior;
 			uniforms.refractionRatio.value = material.refractionRatio;
 
-			const maxMipLevel = properties.get( envMap ).__maxMipLevel;
-
-			if ( maxMipLevel !== undefined ) {
-
-				uniforms.maxMipLevel.value = maxMipLevel;
-
-			}
-
 		}
 
 		if ( material.lightMap ) {
@@ -253,9 +245,9 @@ function WebGLMaterials( properties ) {
 
 			uvScaleMap = material.specularIntensityMap;
 
-		} else if ( material.specularTintMap ) {
+		} else if ( material.specularColorMap ) {
 
-			uvScaleMap = material.specularTintMap;
+			uvScaleMap = material.specularColorMap;
 
 		} else if ( material.transmissionMap ) {
 
@@ -265,6 +257,14 @@ function WebGLMaterials( properties ) {
 
 			uvScaleMap = material.thicknessMap;
 
+		} else if ( material.sheenColorMap ) {
+
+			uvScaleMap = material.sheenColorMap;
+
+		} else if ( material.sheenRoughnessMap ) {
+
+			uvScaleMap = material.sheenRoughnessMap;
+
 		}
 
 		if ( uvScaleMap !== undefined ) {
@@ -600,10 +600,22 @@ function WebGLMaterials( properties ) {
 
 		if ( material.sheen > 0 ) {
 
-			uniforms.sheenTint.value.copy( material.sheenTint ).multiplyScalar( material.sheen );
+			uniforms.sheenColor.value.copy( material.sheenColor ).multiplyScalar( material.sheen );
 
 			uniforms.sheenRoughness.value = material.sheenRoughness;
 
+			if ( material.sheenColorMap ) {
+
+				uniforms.sheenColorMap.value = material.sheenColorMap;
+
+			}
+
+			if ( material.sheenRoughnessMap ) {
+
+				uniforms.sheenRoughnessMap.value = material.sheenRoughnessMap;
+
+			}
+
 		}
 
 		if ( material.clearcoat > 0 ) {
@@ -659,12 +671,12 @@ function WebGLMaterials( properties ) {
 			}
 
 			uniforms.attenuationDistance.value = material.attenuationDistance;
-			uniforms.attenuationTint.value.copy( material.attenuationTint );
+			uniforms.attenuationColor.value.copy( material.attenuationColor );
 
 		}
 
 		uniforms.specularIntensity.value = material.specularIntensity;
-		uniforms.specularTint.value.copy( material.specularTint );
+		uniforms.specularColor.value.copy( material.specularColor );
 
 		if ( material.specularIntensityMap ) {
 
@@ -672,9 +684,9 @@ function WebGLMaterials( properties ) {
 
 		}
 
-		if ( material.specularTintMap ) {
+		if ( material.specularColorMap ) {
 
-			uniforms.specularTintMap.value = material.specularTintMap;
+			uniforms.specularColorMap.value = material.specularColorMap;
 
 		}
 

package/src/renderers/webgl/WebGLMorphtargets.js

@@ -84,6 +84,7 @@ function WebGLMorphtargets( gl, capabilities, textures ) {
 				const texture = new DataTexture2DArray( buffer, width, height, numberOfMorphTargets );
 				texture.format = RGBAFormat; // using RGBA since RGB might be emulated (and is thus slower)
 				texture.type = FloatType;
+				texture.needsUpdate = true;
 
 				// fill buffer
 
@@ -134,6 +135,18 @@ function WebGLMorphtargets( gl, capabilities, textures ) {
 
 				morphTextures.set( geometry, entry );
 
+				function disposeTexture() {
+
+					texture.dispose();
+
+					morphTextures.delete( geometry );
+
+					geometry.removeEventListener( 'dispose', disposeTexture );
+
+				}
+
+				geometry.addEventListener( 'dispose', disposeTexture );
+
 			}
 
 			//