super-three 0.147.0 → 0.152.0

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

@@ -3,7 +3,7 @@ float specularStrength;
 
 #ifdef USE_SPECULARMAP
 
-	vec4 texelSpecular = texture2D( specularMap, vUv );
+	vec4 texelSpecular = texture2D( specularMap, vSpecularMapUv );
 	specularStrength = texelSpecular.r;
 
 #else

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

@@ -9,13 +9,13 @@ export default /* glsl */`
 
 	#ifdef USE_TRANSMISSIONMAP
 
-		material.transmission *= texture2D( transmissionMap, vUv ).r;
+		material.transmission *= texture2D( transmissionMap, vTransmissionMapUv ).r;
 
 	#endif
 
 	#ifdef USE_THICKNESSMAP
 
-		material.thickness *= texture2D( thicknessMap, vUv ).g;
+		material.thickness *= texture2D( thicknessMap, vThicknessMapUv ).g;
 
 	#endif
 

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

@@ -29,6 +29,95 @@ export default /* glsl */`
 
 	varying vec3 vWorldPosition;
 
+	// Mipped Bicubic Texture Filtering by N8
+	// https://www.shadertoy.com/view/Dl2SDW
+
+	float w0( float a ) {
+
+		return ( 1.0 / 6.0 ) * ( a * ( a * ( - a + 3.0 ) - 3.0 ) + 1.0 );
+
+	}
+
+	float w1( float a ) {
+
+		return ( 1.0 / 6.0 ) * ( a *  a * ( 3.0 * a - 6.0 ) + 4.0 );
+
+	}
+
+	float w2( float a ){
+
+		return ( 1.0 / 6.0 ) * ( a * ( a * ( - 3.0 * a + 3.0 ) + 3.0 ) + 1.0 );
+
+	}
+
+	float w3( float a ) {
+
+		return ( 1.0 / 6.0 ) * ( a * a * a );
+
+	}
+
+	// g0 and g1 are the two amplitude functions
+	float g0( float a ) {
+
+		return w0( a ) + w1( a );
+
+	}
+
+	float g1( float a ) {
+
+		return w2( a ) + w3( a );
+
+	}
+
+	// h0 and h1 are the two offset functions
+	float h0( float a ) {
+
+		return - 1.0 + w1( a ) / ( w0( a ) + w1( a ) );
+
+	}
+
+	float h1( float a ) {
+
+		return 1.0 + w3( a ) / ( w2( a ) + w3( a ) );
+
+	}
+
+	vec4 bicubic( sampler2D tex, vec2 uv, vec4 texelSize, float lod ) {
+
+		uv = uv * texelSize.zw + 0.5;
+
+		vec2 iuv = floor( uv );
+		vec2 fuv = fract( uv );
+
+		float g0x = g0( fuv.x );
+		float g1x = g1( fuv.x );
+		float h0x = h0( fuv.x );
+		float h1x = h1( fuv.x );
+		float h0y = h0( fuv.y );
+		float h1y = h1( fuv.y );
+
+		vec2 p0 = ( vec2( iuv.x + h0x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;
+		vec2 p1 = ( vec2( iuv.x + h1x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;
+		vec2 p2 = ( vec2( iuv.x + h0x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;
+		vec2 p3 = ( vec2( iuv.x + h1x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;
+
+		return g0( fuv.y ) * ( g0x * textureLod( tex, p0, lod ) + g1x * textureLod( tex, p1, lod ) ) +
+			g1( fuv.y ) * ( g0x * textureLod( tex, p2, lod ) + g1x * textureLod( tex, p3, lod ) );
+
+	}
+
+	vec4 textureBicubic( sampler2D sampler, vec2 uv, float lod ) {
+
+		vec2 fLodSize = vec2( textureSize( sampler, int( lod ) ) );
+		vec2 cLodSize = vec2( textureSize( sampler, int( lod + 1.0 ) ) );
+		vec2 fLodSizeInv = 1.0 / fLodSize;
+		vec2 cLodSizeInv = 1.0 / cLodSize;
+		vec4 fSample = bicubic( sampler, uv, vec4( fLodSizeInv, fLodSize ), floor( lod ) );
+		vec4 cSample = bicubic( sampler, uv, vec4( cLodSizeInv, cLodSize ), ceil( lod ) );
+		return mix( fSample, cSample, fract( lod ) );
+
+	}
+
 	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.
@@ -55,17 +144,8 @@ export default /* glsl */`
 
 	vec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {
 
-		float framebufferLod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
-
-		#ifdef texture2DLodEXT
-
-			return texture2DLodEXT( transmissionSamplerMap, fragCoord.xy, framebufferLod );
-
-		#else
-
-			return texture2D( transmissionSamplerMap, fragCoord.xy, framebufferLod );
-
-		#endif
+		float lod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );
+		return textureBicubic( transmissionSamplerMap, fragCoord.xy, lod );
 
 	}
 

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

@@ -1,7 +1,114 @@
 export default /* glsl */`
-#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )
+#ifdef USE_UV
 
 	varying vec2 vUv;
 
+#endif
+#ifdef USE_MAP
+
+	varying vec2 vMapUv;
+
+#endif
+#ifdef USE_ALPHAMAP
+
+	varying vec2 vAlphaMapUv;
+
+#endif
+#ifdef USE_LIGHTMAP
+
+	varying vec2 vLightMapUv;
+
+#endif
+#ifdef USE_AOMAP
+
+	varying vec2 vAoMapUv;
+
+#endif
+#ifdef USE_BUMPMAP
+
+	varying vec2 vBumpMapUv;
+
+#endif
+#ifdef USE_NORMALMAP
+
+	varying vec2 vNormalMapUv;
+
+#endif
+#ifdef USE_EMISSIVEMAP
+
+	varying vec2 vEmissiveMapUv;
+
+#endif
+#ifdef USE_METALNESSMAP
+
+	varying vec2 vMetalnessMapUv;
+
+#endif
+#ifdef USE_ROUGHNESSMAP
+
+	varying vec2 vRoughnessMapUv;
+
+#endif
+#ifdef USE_CLEARCOATMAP
+
+	varying vec2 vClearcoatMapUv;
+
+#endif
+#ifdef USE_CLEARCOAT_NORMALMAP
+
+	varying vec2 vClearcoatNormalMapUv;
+
+#endif
+#ifdef USE_CLEARCOAT_ROUGHNESSMAP
+
+	varying vec2 vClearcoatRoughnessMapUv;
+
+#endif
+#ifdef USE_IRIDESCENCEMAP
+
+	varying vec2 vIridescenceMapUv;
+
+#endif
+#ifdef USE_IRIDESCENCE_THICKNESSMAP
+
+	varying vec2 vIridescenceThicknessMapUv;
+
+#endif
+#ifdef USE_SHEEN_COLORMAP
+
+	varying vec2 vSheenColorMapUv;
+
+#endif
+#ifdef USE_SHEEN_ROUGHNESSMAP
+
+	varying vec2 vSheenRoughnessMapUv;
+
+#endif
+#ifdef USE_SPECULARMAP
+
+	varying vec2 vSpecularMapUv;
+
+#endif
+#ifdef USE_SPECULAR_COLORMAP
+
+	varying vec2 vSpecularColorMapUv;
+
+#endif
+#ifdef USE_SPECULAR_INTENSITYMAP
+
+	varying vec2 vSpecularIntensityMapUv;
+
+#endif
+#ifdef USE_TRANSMISSIONMAP
+
+	uniform mat3 transmissionMapTransform;
+	varying vec2 vTransmissionMapUv;
+
+#endif
+#ifdef USE_THICKNESSMAP
+
+	uniform mat3 thicknessMapTransform;
+	varying vec2 vThicknessMapUv;
+
 #endif
 `;

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

@@ -1,17 +1,139 @@
 export default /* glsl */`
 #ifdef USE_UV
 
-	#ifdef UVS_VERTEX_ONLY
+	varying vec2 vUv;
 
-		vec2 vUv;
+#endif
+#ifdef USE_MAP
+
+	uniform mat3 mapTransform;
+	varying vec2 vMapUv;
+
+#endif
+#ifdef USE_ALPHAMAP
+
+	uniform mat3 alphaMapTransform;
+	varying vec2 vAlphaMapUv;
+
+#endif
+#ifdef USE_LIGHTMAP
+
+	uniform mat3 lightMapTransform;
+	varying vec2 vLightMapUv;
 
-	#else
+#endif
+#ifdef USE_AOMAP
+
+	uniform mat3 aoMapTransform;
+	varying vec2 vAoMapUv;
+
+#endif
+#ifdef USE_BUMPMAP
 
-		varying vec2 vUv;
+	uniform mat3 bumpMapTransform;
+	varying vec2 vBumpMapUv;
 
-	#endif
+#endif
+#ifdef USE_NORMALMAP
+
+	uniform mat3 normalMapTransform;
+	varying vec2 vNormalMapUv;
+
+#endif
+#ifdef USE_DISPLACEMENTMAP
+
+	uniform mat3 displacementMapTransform;
+	varying vec2 vDisplacementMapUv;
+
+#endif
+#ifdef USE_EMISSIVEMAP
+
+	uniform mat3 emissiveMapTransform;
+	varying vec2 vEmissiveMapUv;
+
+#endif
+#ifdef USE_METALNESSMAP
+
+	uniform mat3 metalnessMapTransform;
+	varying vec2 vMetalnessMapUv;
+
+#endif
+#ifdef USE_ROUGHNESSMAP
+
+	uniform mat3 roughnessMapTransform;
+	varying vec2 vRoughnessMapUv;
+
+#endif
+#ifdef USE_CLEARCOATMAP
+
+	uniform mat3 clearcoatMapTransform;
+	varying vec2 vClearcoatMapUv;
+
+#endif
+#ifdef USE_CLEARCOAT_NORMALMAP
+
+	uniform mat3 clearcoatNormalMapTransform;
+	varying vec2 vClearcoatNormalMapUv;
+
+#endif
+#ifdef USE_CLEARCOAT_ROUGHNESSMAP
+
+	uniform mat3 clearcoatRoughnessMapTransform;
+	varying vec2 vClearcoatRoughnessMapUv;
+
+#endif
+#ifdef USE_SHEEN_COLORMAP
+
+	uniform mat3 sheenColorMapTransform;
+	varying vec2 vSheenColorMapUv;
+
+#endif
+#ifdef USE_SHEEN_ROUGHNESSMAP
+
+	uniform mat3 sheenRoughnessMapTransform;
+	varying vec2 vSheenRoughnessMapUv;
+
+#endif
+#ifdef USE_IRIDESCENCEMAP
+
+	uniform mat3 iridescenceMapTransform;
+	varying vec2 vIridescenceMapUv;
+
+#endif
+#ifdef USE_IRIDESCENCE_THICKNESSMAP
+
+	uniform mat3 iridescenceThicknessMapTransform;
+	varying vec2 vIridescenceThicknessMapUv;
+
+#endif
+#ifdef USE_SPECULARMAP
+
+	uniform mat3 specularMapTransform;
+	varying vec2 vSpecularMapUv;
+
+#endif
+#ifdef USE_SPECULAR_COLORMAP
+
+	uniform mat3 specularColorMapTransform;
+	varying vec2 vSpecularColorMapUv;
+
+#endif
+#ifdef USE_SPECULAR_INTENSITYMAP
+
+	uniform mat3 specularIntensityMapTransform;
+	varying vec2 vSpecularIntensityMapUv;
+
+#endif
+#ifdef USE_TRANSMISSIONMAP
+
+	uniform mat3 transmissionMapTransform;
+	varying vec2 vTransmissionMapUv;
+
+#endif
+#ifdef USE_THICKNESSMAP
 
-	uniform mat3 uvTransform;
+	uniform mat3 thicknessMapTransform;
+	varying vec2 vThicknessMapUv;
 
 #endif
 `;

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

@@ -1,7 +1,117 @@
 export default /* glsl */`
 #ifdef USE_UV
 
-	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
+	vUv = vec3( uv, 1 ).xy;
+
+#endif
+#ifdef USE_MAP
+
+	vMapUv = ( mapTransform * vec3( MAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_ALPHAMAP
+
+	vAlphaMapUv = ( alphaMapTransform * vec3( ALPHAMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_LIGHTMAP
+
+	vLightMapUv = ( lightMapTransform * vec3( LIGHTMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_AOMAP
+
+	vAoMapUv = ( aoMapTransform * vec3( AOMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_BUMPMAP
+
+	vBumpMapUv = ( bumpMapTransform * vec3( BUMPMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_NORMALMAP
+
+	vNormalMapUv = ( normalMapTransform * vec3( NORMALMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_DISPLACEMENTMAP
+
+	vDisplacementMapUv = ( displacementMapTransform * vec3( DISPLACEMENTMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_EMISSIVEMAP
+
+	vEmissiveMapUv = ( emissiveMapTransform * vec3( EMISSIVEMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_METALNESSMAP
+
+	vMetalnessMapUv = ( metalnessMapTransform * vec3( METALNESSMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_ROUGHNESSMAP
+
+	vRoughnessMapUv = ( roughnessMapTransform * vec3( ROUGHNESSMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_CLEARCOATMAP
+
+	vClearcoatMapUv = ( clearcoatMapTransform * vec3( CLEARCOATMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_CLEARCOAT_NORMALMAP
+
+	vClearcoatNormalMapUv = ( clearcoatNormalMapTransform * vec3( CLEARCOAT_NORMALMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_CLEARCOAT_ROUGHNESSMAP
+
+	vClearcoatRoughnessMapUv = ( clearcoatRoughnessMapTransform * vec3( CLEARCOAT_ROUGHNESSMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_IRIDESCENCEMAP
+
+	vIridescenceMapUv = ( iridescenceMapTransform * vec3( IRIDESCENCEMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_IRIDESCENCE_THICKNESSMAP
+
+	vIridescenceThicknessMapUv = ( iridescenceThicknessMapTransform * vec3( IRIDESCENCE_THICKNESSMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_SHEEN_COLORMAP
+
+	vSheenColorMapUv = ( sheenColorMapTransform * vec3( SHEEN_COLORMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_SHEEN_ROUGHNESSMAP
+
+	vSheenRoughnessMapUv = ( sheenRoughnessMapTransform * vec3( SHEEN_ROUGHNESSMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_SPECULARMAP
+
+	vSpecularMapUv = ( specularMapTransform * vec3( SPECULARMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_SPECULAR_COLORMAP
+
+	vSpecularColorMapUv = ( specularColorMapTransform * vec3( SPECULAR_COLORMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_SPECULAR_INTENSITYMAP
+
+	vSpecularIntensityMapUv = ( specularIntensityMapTransform * vec3( SPECULAR_INTENSITYMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_TRANSMISSIONMAP
+
+	vTransmissionMapUv = ( transmissionMapTransform * vec3( TRANSMISSIONMAP_UV, 1 ) ).xy;
+
+#endif
+#ifdef USE_THICKNESSMAP
+
+	vThicknessMapUv = ( thicknessMapTransform * vec3( THICKNESSMAP_UV, 1 ) ).xy;
 
 #endif
 `;

package/src/renderers/shaders/ShaderChunk.js

@@ -100,9 +100,6 @@ import transmission_pars_fragment from './ShaderChunk/transmission_pars_fragment
 import uv_pars_fragment from './ShaderChunk/uv_pars_fragment.glsl.js';
 import uv_pars_vertex from './ShaderChunk/uv_pars_vertex.glsl.js';
 import uv_vertex from './ShaderChunk/uv_vertex.glsl.js';
-import uv2_pars_fragment from './ShaderChunk/uv2_pars_fragment.glsl.js';
-import uv2_pars_vertex from './ShaderChunk/uv2_pars_vertex.glsl.js';
-import uv2_vertex from './ShaderChunk/uv2_vertex.glsl.js';
 import worldpos_vertex from './ShaderChunk/worldpos_vertex.glsl.js';
 
 import * as background from './ShaderLib/background.glsl.js';
@@ -226,9 +223,6 @@ export const ShaderChunk = {
 	uv_pars_fragment: uv_pars_fragment,
 	uv_pars_vertex: uv_pars_vertex,
 	uv_vertex: uv_vertex,
-	uv2_pars_fragment: uv2_pars_fragment,
-	uv2_pars_vertex: uv2_pars_vertex,
-	uv2_vertex: uv2_vertex,
 	worldpos_vertex: worldpos_vertex,
 
 	background_vert: background.vertex,

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

@@ -21,14 +21,6 @@ void main() {
 
 	vec4 texColor = texture2D( t2D, vUv );
 
-	#ifdef DECODE_VIDEO_TEXTURE
-
-		// inline sRGB decode (TODO: Remove this code when https://crbug.com/1256340 is solved)
-
-		texColor = vec4( mix( pow( texColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), texColor.rgb * 0.0773993808, vec3( lessThanEqual( texColor.rgb, vec3( 0.04045 ) ) ) ), texColor.w );
-
-	#endif
-
 	texColor.rgb *= backgroundIntensity;
 
 	gl_FragColor = texColor;

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

@@ -5,6 +5,7 @@ attribute float lineDistance;
 varying float vLineDistance;
 
 #include <common>
+#include <uv_pars_vertex>
 #include <color_pars_vertex>
 #include <fog_pars_vertex>
 #include <morphtarget_pars_vertex>
@@ -15,6 +16,7 @@ void main() {
 
 	vLineDistance = scale * lineDistance;
 
+	#include <uv_vertex>
 	#include <color_vertex>
 	#include <morphcolor_vertex>
 	#include <begin_vertex>
@@ -38,6 +40,8 @@ varying float vLineDistance;
 
 #include <common>
 #include <color_pars_fragment>
+#include <uv_pars_fragment>
+#include <map_pars_fragment>
 #include <fog_pars_fragment>
 #include <logdepthbuf_pars_fragment>
 #include <clipping_planes_pars_fragment>
@@ -56,6 +60,7 @@ void main() {
 	vec4 diffuseColor = vec4( diffuse, opacity );
 
 	#include <logdepthbuf_fragment>
+	#include <map_fragment>
 	#include <color_fragment>
 
 	outgoingLight = diffuseColor.rgb; // simple shader

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

@@ -1,7 +1,6 @@
 export const vertex = /* glsl */`
 #include <common>
 #include <uv_pars_vertex>
-#include <uv2_pars_vertex>
 #include <envmap_pars_vertex>
 #include <color_pars_vertex>
 #include <fog_pars_vertex>
@@ -13,7 +12,6 @@ export const vertex = /* glsl */`
 void main() {
 
 	#include <uv_vertex>
-	#include <uv2_vertex>
 	#include <color_vertex>
 	#include <morphcolor_vertex>
 
@@ -55,7 +53,6 @@ uniform float opacity;
 #include <dithering_pars_fragment>
 #include <color_pars_fragment>
 #include <uv_pars_fragment>
-#include <uv2_pars_fragment>
 #include <map_pars_fragment>
 #include <alphamap_pars_fragment>
 #include <alphatest_pars_fragment>
@@ -86,7 +83,7 @@ void main() {
 	// accumulation (baked indirect lighting only)
 	#ifdef USE_LIGHTMAP
 
-		vec4 lightMapTexel = texture2D( lightMap, vUv2 );
+		vec4 lightMapTexel = texture2D( lightMap, vLightMapUv );
 		reflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity * RECIPROCAL_PI;
 
 	#else

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

@@ -5,7 +5,6 @@ varying vec3 vViewPosition;
 
 #include <common>
 #include <uv_pars_vertex>
-#include <uv2_pars_vertex>
 #include <displacementmap_pars_vertex>
 #include <envmap_pars_vertex>
 #include <color_pars_vertex>
@@ -20,7 +19,6 @@ varying vec3 vViewPosition;
 void main() {
 
 	#include <uv_vertex>
-	#include <uv2_vertex>
 	#include <color_vertex>
 	#include <morphcolor_vertex>
 
@@ -61,7 +59,6 @@ uniform float opacity;
 #include <dithering_pars_fragment>
 #include <color_pars_fragment>
 #include <uv_pars_fragment>
-#include <uv2_pars_fragment>
 #include <map_pars_fragment>
 #include <alphamap_pars_fragment>
 #include <alphatest_pars_fragment>

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

@@ -1,7 +1,7 @@
 export const vertex = /* glsl */`
 #define NORMAL
 
-#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
+#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )
 
 	varying vec3 vViewPosition;
 
@@ -35,7 +35,7 @@ void main() {
 	#include <logdepthbuf_vertex>
 	#include <clipping_planes_vertex>
 
-#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
+#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )
 
 	vViewPosition = - mvPosition.xyz;
 
@@ -49,7 +49,7 @@ export const fragment = /* glsl */`
 
 uniform float opacity;
 
-#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )
+#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )
 
 	varying vec3 vViewPosition;
 

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

@@ -5,7 +5,6 @@ varying vec3 vViewPosition;
 
 #include <common>
 #include <uv_pars_vertex>
-#include <uv2_pars_vertex>
 #include <displacementmap_pars_vertex>
 #include <envmap_pars_vertex>
 #include <color_pars_vertex>
@@ -20,7 +19,6 @@ varying vec3 vViewPosition;
 void main() {
 
 	#include <uv_vertex>
-	#include <uv2_vertex>
 	#include <color_vertex>
 	#include <morphcolor_vertex>
 
@@ -63,7 +61,6 @@ uniform float opacity;
 #include <dithering_pars_fragment>
 #include <color_pars_fragment>
 #include <uv_pars_fragment>
-#include <uv2_pars_fragment>
 #include <map_pars_fragment>
 #include <alphamap_pars_fragment>
 #include <alphatest_pars_fragment>