@plastic-software/three 0.175.0 → 0.175.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plastic-software/three",
-  "version": "0.175.0",
+  "version": "0.175.1",
   "description": "JavaScript 3D library",
   "type": "module",
   "main": "./build/three.cjs",

package/src/constants.js

@@ -538,6 +538,9 @@ export const EquirectangularRefractionMapping = 304;
  */
 export const CubeUVReflectionMapping = 306;
 
+export const TriPlanarMapping = 307;
+export const CylindricalMapping = 308;
+
 /**
  * The texture will simply repeat to infinity.
  *

package/src/loaders/ObjectLoader.js

@@ -5,6 +5,8 @@ import {
 	EquirectangularReflectionMapping,
 	EquirectangularRefractionMapping,
 	CubeUVReflectionMapping,
+	TriPlanarMapping,
+	CylindricalMapping,
 
 	RepeatWrapping,
 	ClampToEdgeWrapping,
@@ -1215,7 +1217,9 @@ const TEXTURE_MAPPING = {
 	CubeRefractionMapping: CubeRefractionMapping,
 	EquirectangularReflectionMapping: EquirectangularReflectionMapping,
 	EquirectangularRefractionMapping: EquirectangularRefractionMapping,
-	CubeUVReflectionMapping: CubeUVReflectionMapping
+	CubeUVReflectionMapping: CubeUVReflectionMapping,
+	TriPlanarMapping: TriPlanarMapping,
+	CylindricalMapping: CylindricalMapping
 };
 
 const TEXTURE_WRAPPING = {

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

@@ -1,7 +1,16 @@
 export default /* glsl */`
 #ifdef USE_ALPHAMAP
+	#ifdef USE_ALPHAMAP_TRIPLANAR
 
-	diffuseColor.a *= texture2D( alphaMap, vAlphaMapUv ).g;
+		diffuseColor.a *= texture2DTriplanar( alphaMap, alphaMapTransform, triplanarCoords, triplanarWeights ).g;
 
+	#else
+    #if defined( USE_ALPHAMAP_CYLINDRICAL )
+      vec2 vAlphaMapUv = ( alphaMapTransform * vec3( positionBasedUv, 1 ) ).xy;
+    #endif
+
+		diffuseColor.a *= texture2D( alphaMap, vAlphaMapUv ).g;
+
+	#endif
 #endif
 `;

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

@@ -2,7 +2,14 @@ export default /* glsl */`
 #ifdef USE_AOMAP
 
 	// reads channel R, compatible with a combined OcclusionRoughnessMetallic (RGB) texture
-	float ambientOcclusion = ( texture2D( aoMap, vAoMapUv ).r - 1.0 ) * aoMapIntensity + 1.0;
+  #ifdef USE_AOMAP_TRIPLANAR
+		float ambientOcclusion = ( texture2DTriplanar( aoMap, aoMapTransform, triplanarCoords, triplanarWeights ).r - 1.0 ) * aoMapIntensity + 1.0;
+  #else
+    #if defined( USE_AOMAP_CYLINDRICAL )
+      vec2 vAoMapUv = ( aoMapTransform * vec3( positionBasedUv, 1 ) ).xy;
+    #endif
+		float ambientOcclusion = ( texture2D( aoMap, vAoMapUv ).r - 1.0 ) * aoMapIntensity + 1.0;
+  #endif
 
 	reflectedLight.indirectDiffuse *= ambientOcclusion;
 

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

@@ -1,5 +1,9 @@
 export default /* glsl */`
-#ifdef USE_CLEARCOAT_NORMALMAP
+#ifdef USE_CLEARCOAT_NORMALMAP_TRIPLANAR
+
+	normal = normalize(normalMatrix * transpose(mat3(texture3DMatrix)) * texture2DTriplanarNormal( clearcoatNormalMap, clearcoatNormalMapTransform, clearcoatNormalScale, normalize(mat3(texture3DMatrix) * vModelNormal.xyz), triplanarCoords, triplanarWeights ));
+
+#elif defined( USE_CLEARCOAT_NORMALMAP )
 
 	vec3 clearcoatMapN = texture2D( clearcoatNormalMap, vClearcoatNormalMapUv ).xyz * 2.0 - 1.0;
 	clearcoatMapN.xy *= clearcoatNormalScale;

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

@@ -134,4 +134,86 @@ float F_Schlick( const in float f0, const in float f90, const in float dotVH ) {
 	return f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );
 
 } // validated
+
+#if defined( USE_MAP_TRIPLANAR ) || \
+  defined( USE_ALPHAMAP_TRIPLANAR ) || \
+  defined( USE_NORMALMAP_TRIPLANAR ) || \
+  defined( USE_ROUGHNESSMAP_TRIPLANAR ) || \
+  defined( USE_AOMAP_TRIPLANAR ) || \
+  defined( USE_METALNESSMAP_TRIPLANAR ) || \
+  defined( USE_CLEARCOAT_NORMALMAP_TRIPLANAR )
+
+  #define USE_TRIPLANAR
+
+#endif
+
+#if defined( USE_MAP_TRIPLANAR ) || \
+  defined( USE_ALPHAMAP_TRIPLANAR ) || \
+  defined( USE_ROUGHNESSMAP_TRIPLANAR ) || \
+  defined( USE_AOMAP_TRIPLANAR ) || \
+  defined( USE_METALNESSMAP_TRIPLANAR )
+
+  vec4 texture2DTriplanar( sampler2D map, mat3 uvTransform, vec3 coords, vec3 weights ) {
+    return weights.x * texture2D( map, (uvTransform * vec3(coords.zy, 1)).xy ) +
+           weights.y * texture2D( map, (uvTransform * vec3(coords.xz, 1)).xy ) +
+           weights.z * texture2D( map, (uvTransform * vec3(coords.xy, 1)).xy );
+  
+  }
+
+#endif
+
+#if defined( USE_NORMALMAP_TRIPLANAR ) || defined( USE_CLEARCOAT_NORMALMAP_TRIPLANAR )
+
+  vec3 texture2DTriplanarNormal( sampler2D normalMap, mat3 uvTransform, vec2 normalMapScale, vec3 normal, vec3 coords, vec3 weights ) {
+    // Whiteout blend
+  
+    // Triplanar uvs
+    vec2 uvX = coords.zy; // x facing plane
+    vec2 uvY = coords.xz; // y facing plane
+    vec2 uvZ = coords.xy; // z facing plane
+  
+    // Tangent space normal maps
+    vec3 tnormalX = texture2D( normalMap, (uvTransform * vec3(uvX, 1)).xy ).xyz * 2.0 - 1.0;
+    vec3 tnormalY = texture2D( normalMap, (uvTransform * vec3(uvY, 1)).xy ).xyz * 2.0 - 1.0;
+    vec3 tnormalZ = texture2D( normalMap, (uvTransform * vec3(uvZ, 1)).xy ).xyz * 2.0 - 1.0;
+
+    tnormalX.xy *= normalMapScale;
+    tnormalY.xy *= normalMapScale;
+    tnormalZ.xy *= normalMapScale;
+  
+    // Swizzle world normals into tangent space and apply Whiteout blend
+    tnormalX = vec3(
+        tnormalX.xy + normal.zy,
+        abs(tnormalX.z) * normal.x
+        );
+    tnormalY = vec3(
+        tnormalY.xy + normal.xz,
+        abs(tnormalY.z) * normal.y
+        );
+    tnormalZ = vec3(
+        tnormalZ.xy + normal.xy,
+        abs(tnormalZ.z) * normal.z
+        );
+    
+    // Swizzle tangent normals to match world orientation and triblend
+    return normalize(
+        tnormalX.zyx * weights.x +
+        tnormalY.xzy * weights.y +
+        tnormalZ.xyz * weights.z
+        );
+  }
+
+#endif
+
+#if defined( USE_MAP_CYLINDRICAL ) || \
+  defined( USE_ALPHAMAP_CYLINDRICAL ) || \
+  defined( USE_NORMALMAP_CYLINDRICAL ) || \
+  defined( USE_ROUGHNESSMAP_CYLINDRICAL ) || \
+  defined( USE_AOMAP_CYLINDRICAL ) || \
+  defined( USE_METALNESSMAP_CYLINDRICAL ) || \
+  defined( USE_CLEARCOAT_NORMALMAP_CYLINDRICAL )
+
+  #define USE_CYLINDRICAL
+
+#endif
 `;

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

@@ -5,6 +5,11 @@ vec3 transformedNormal = objectNormal;
 
 	vec3 transformedTangent = objectTangent;
 
+#endif
+#if defined( USE_TANGENT_FROM_NORMAL ) || defined( USE_NORMALMAP_TRIPLANAR )
+
+  mat3 tangentMatrix = mat3(1.0);
+
 #endif
 
 #ifdef USE_BATCHING
@@ -20,7 +25,12 @@ vec3 transformedNormal = objectNormal;
 
 		transformedTangent = bm * transformedTangent;
 
-	#endif
+  #endif
+  #if defined( USE_TANGENT_FROM_NORMAL ) || defined( USE_NORMALMAP_TRIPLANAR )
+
+    tangentMatrix = bm * tangentMatrix;
+
+  #endif
 
 #endif
 
@@ -37,7 +47,12 @@ vec3 transformedNormal = objectNormal;
 
 		transformedTangent = im * transformedTangent;
 
-	#endif
+  #endif
+  #if defined( USE_TANGENT_FROM_NORMAL ) || defined( USE_NORMALMAP_TRIPLANAR )
+
+    tangentMatrix = im * tangentMatrix;
+
+  #endif
 
 #endif
 
@@ -59,5 +74,10 @@ transformedNormal = normalMatrix * transformedNormal;
 
 	#endif
 
+#endif
+#if defined( USE_TANGENT_FROM_NORMAL ) || defined( USE_NORMALMAP_TRIPLANAR )
+
+  tangentMatrix = mat3( modelViewMatrix ) * tangentMatrix;
+
 #endif
 `;

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

@@ -1,7 +1,18 @@
 export default /* glsl */`
 #ifdef USE_MAP
 
-	vec4 sampledDiffuseColor = texture2D( map, vMapUv );
+	#ifdef USE_MAP_TRIPLANAR
+
+		vec4 sampledDiffuseColor = texture2DTriplanar( map, mapTransform, triplanarCoords, triplanarWeights );
+
+	#else
+    #if defined( USE_MAP_CYLINDRICAL )
+      vec2 vMapUv = ( mapTransform * vec3( positionBasedUv, 1 ) ).xy;
+    #endif
+
+		vec4 sampledDiffuseColor = texture2D( map, vMapUv );
+
+	#endif
 
 	#ifdef DECODE_VIDEO_TEXTURE
 

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

@@ -2,8 +2,14 @@ export default /* glsl */`
 float metalnessFactor = metalness;
 
 #ifdef USE_METALNESSMAP
-
-	vec4 texelMetalness = texture2D( metalnessMap, vMetalnessMapUv );
+  #ifdef USE_METALNESSMAP_TRIPLANAR
+		vec4 texelMetalness = texture2DTriplanar( metalnessMap, metalnessMapTransform, triplanarCoords, triplanarWeights );
+  #else
+    #if defined( USE_METALNESSMAP_CYLINDRICAL )
+      vec2 vMetalnessMapUv = ( metalnessMapTransform * vec3( positionBasedUv, 1 ) ).xy;
+    #endif
+		vec4 texelMetalness = texture2D( metalnessMap, vMetalnessMapUv );
+  #endif
 
 	// reads channel B, compatible with a combined OcclusionRoughnessMetallic (RGB) texture
 	metalnessFactor *= texelMetalness.b;

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

@@ -21,21 +21,35 @@ float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
 
 #if defined( USE_NORMALMAP_TANGENTSPACE ) || defined( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY )
 
-	#ifdef USE_TANGENT
+	#if defined( USE_TANGENT )
 
 		mat3 tbn = mat3( normalize( vTangent ), normalize( vBitangent ), normal );
 
+  #elif defined( USE_NORMALMAP_UV )
+
+	  mat3 tbn = getTangentFrame( - vViewPosition, normal, vNormalMapUv );
+
+  #elif defined( USE_NORMALMAP_CYLINDRICAL ) || defined( USE_CLEARCOAT_NORMALMAP_CYLINDRICAL ) || (defined( USE_ANISOTROPY ) && !defined( USE_UV1 ) || !defined( USE_UV2 ) && !defined( USE_UV3 ))
+  
+    #if defined( USE_NORMALMAP_CYLINDRICAL )
+      vec2 vNormalMapUv = ( normalMapTransform * vec3( positionBasedUv, 1 ) ).xy;
+    #endif
+
+    #if defined( USE_CLEARCOAT_NORMALMAP_CYLINDRICAL )
+      vec2 vClearcoatNormalMapUv = ( clearcoatNormalMapTransform * vec3( positionBasedUv, 1 ) ).xy;
+    #endif
+
+    vec3 tangent = normalize(cross(normal, mat3(modelViewMatrix) * transpose(mat3(texture3DMatrix)) * vec3(0, 1, 0)));
+    vec3 bitangent = cross(tangent, normal);
+  	mat3 tbn = mat3(tangent, bitangent, normal);
+  
+	#elif defined( USE_CLEARCOAT_NORMALMAP_UV )
+
+	  mat3 tbn = getTangentFrame( - vViewPosition, normal, vClearcoatNormalMapUv );
+
 	#else
 
-		mat3 tbn = getTangentFrame( - vViewPosition, normal,
-		#if defined( USE_NORMALMAP )
-			vNormalMapUv
-		#elif defined( USE_CLEARCOAT_NORMALMAP )
-			vClearcoatNormalMapUv
-		#else
-			vUv
-		#endif
-		);
+	  mat3 tbn = getTangentFrame( - vViewPosition, normal, vUv );
 
 	#endif
 
@@ -54,7 +68,13 @@ float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;
 
 		mat3 tbn2 = mat3( normalize( vTangent ), normalize( vBitangent ), normal );
 
-	#else
+  #elif defined( USE_CLEARCOAT_NORMALMAP_CYLINDRICAL )
+
+    vec3 tangent2 = normalize(cross(normal, mat3(modelViewMatrix) * transpose(mat3(texture3DMatrix)) * vec3(0, 1, 0)));
+    vec3 bitangent2 = cross(tangent2, normal);
+  	mat3 tbn2 = mat3(tangent2, bitangent2, normal);
+
+	#elif defined( USE_CLEARCOAT_NORMALMAP_UV )
 
 		mat3 tbn2 = getTangentFrame( - vViewPosition, normal, vClearcoatNormalMapUv );
 

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

@@ -1,6 +1,10 @@
 export default /* glsl */`
 
-#ifdef USE_NORMALMAP_OBJECTSPACE
+#ifdef USE_NORMALMAP_TRIPLANAR
+
+	normal = normalize(normalMatrix * transpose(mat3(texture3DMatrix)) * texture2DTriplanarNormal( normalMap, normalMapTransform, normalScale, normalize(mat3(texture3DMatrix) * vModelNormal.xyz), triplanarCoords, triplanarWeights ));
+
+#elif defined( USE_NORMALMAP_OBJECTSPACE )
 
 	normal = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0; // overrides both flatShading and attribute normals
 

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

@@ -3,7 +3,7 @@ export default /* glsl */`
 
 	varying vec3 vNormal;
 
-	#ifdef USE_TANGENT
+	#if defined( USE_TANGENT )
 
 		varying vec3 vTangent;
 		varying vec3 vBitangent;

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

@@ -3,7 +3,7 @@ export default /* glsl */`
 
 	varying vec3 vNormal;
 
-	#ifdef USE_TANGENT
+	#if defined( USE_TANGENT )
 
 		varying vec3 vTangent;
 		varying vec3 vBitangent;

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

@@ -16,7 +16,7 @@ export default /* glsl */`
 
 	// Normal Mapping Without Precomputed Tangents
 	// http://www.thetenthplanet.de/archives/1180
-
+	
 	mat3 getTangentFrame( vec3 eye_pos, vec3 surf_norm, vec2 uv ) {
 
 		vec3 q0 = dFdx( eye_pos.xyz );
@@ -40,4 +40,5 @@ export default /* glsl */`
 	}
 
 #endif
+
 `;

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

@@ -1,7 +1,18 @@
 export default /* glsl */`
 float roughnessFactor = roughness;
 
-#ifdef USE_ROUGHNESSMAP
+#ifdef USE_ROUGHNESSMAP_TRIPLANAR
+
+	vec4 texelRoughness = texture2DTriplanar( roughnessMap, roughnessMapTransform, triplanarCoords, triplanarWeights );
+
+	// reads channel G, compatible with a combined OcclusionRoughnessMetallic (RGB) texture
+	roughnessFactor *= texelRoughness.g;
+
+#elif defined( USE_ROUGHNESSMAP )
+
+  #if defined( USE_ROUGHNESSMAP_CYLINDRICAL )
+    vec2 vRoughnessMapUv = ( roughnessMapTransform * vec3( positionBasedUv, 1 ) ).xy;
+  #endif
 
 	vec4 texelRoughness = texture2D( roughnessMap, vRoughnessMapUv );
 

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

@@ -0,0 +1,20 @@
+export default /* glsl */`
+#ifdef USE_TRIPLANAR
+
+	vec3 triplanarWeights = pow(abs(mat3(texture3DMatrix) * vModelNormal), vec3(triplanarHardness, triplanarHardness, triplanarHardness));
+	triplanarWeights /= dot(triplanarWeights, vec3(1.0, 1.0, 1.0));
+	vec3 triplanarCoords = vModelPosition.xyz;
+
+#endif
+
+#ifdef USE_CYLINDRICAL
+
+  // Cylindrical and toroidal parameterizations without vertex seams
+  // DOI:10.1080/2151237X.2012.654054
+	float positionBasedU1 = fract(atan(vModelPosition.z, vModelPosition.x) * RECIPROCAL_PI2);
+	float positionBasedU2 = fract(positionBasedU1 + 0.5) - 0.5;
+  vec2 positionBasedUv = vec2(fwidth(positionBasedU1) < fwidth(positionBasedU2) - 1e-3 ? positionBasedU1 : positionBasedU2, vModelPosition.y);
+
+#endif
+
+`;

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

@@ -4,12 +4,37 @@ export default /* glsl */`
 	varying vec2 vUv;
 
 #endif
-#ifdef USE_MAP
+#if defined( USE_TRIPLANAR )
+
+uniform float triplanarHardness;
+
+#endif
+#if defined( USE_TRIPLANAR ) || defined( USE_CYLINDRICAL )
+
+	varying vec3 vModelPosition;
+
+#endif
+#if defined( USE_TRIPLANAR ) || defined( USE_CYLINDRICAL ) || (defined(USE_ANISOTROPY) && !defined(USE_UV1) && !defined(USE_UV2) && !defined(USE_UV3))
+
+	varying vec3 vModelNormal;
+  uniform mat4 texture3DMatrix;
+  uniform mat4 invTexture3DMatrix;
+
+#endif
+#if defined( USE_MAP_CYLINDRICAL ) || defined( USE_MAP_TRIPLANAR )
+
+	uniform mat3 mapTransform;
+
+#elif defined( USE_MAP_UV )
 
 	varying vec2 vMapUv;
 
 #endif
-#ifdef USE_ALPHAMAP
+#if defined( USE_ALPHAMAP_CYLINDRICAL ) || defined( USE_ALPHAMAP_TRIPLANAR )
+
+	uniform mat3 alphaMapTransform;
+
+#elif defined( USE_ALPHAMAP_UV )
 
 	varying vec2 vAlphaMapUv;
 
@@ -19,7 +44,11 @@ export default /* glsl */`
 	varying vec2 vLightMapUv;
 
 #endif
-#ifdef USE_AOMAP
+#if defined( USE_AOMAP_CYLINDRICAL ) || defined( USE_AOMAP_TRIPLANAR )
+
+	uniform mat3 aoMapTransform;
+
+#elif defined( USE_AOMAP_UV )
 
 	varying vec2 vAoMapUv;
 
@@ -29,7 +58,11 @@ export default /* glsl */`
 	varying vec2 vBumpMapUv;
 
 #endif
-#ifdef USE_NORMALMAP
+#if defined( USE_NORMALMAP_CYLINDRICAL ) || defined( USE_NORMALMAP_TRIPLANAR )
+
+	uniform mat3 normalMapTransform;
+
+#elif defined( USE_NORMALMAP_UV )
 
 	varying vec2 vNormalMapUv;
 
@@ -39,12 +72,20 @@ export default /* glsl */`
 	varying vec2 vEmissiveMapUv;
 
 #endif
-#ifdef USE_METALNESSMAP
+#if defined( USE_METALNESSMAP_CYLINDRICAL ) || defined( USE_METALNESSMAP_TRIPLANAR )
+
+	uniform mat3 metalnessMapTransform;
+
+#elif defined( USE_METALNESSMAP_UV )
 
 	varying vec2 vMetalnessMapUv;
 
 #endif
-#ifdef USE_ROUGHNESSMAP
+#if defined( USE_ROUGHNESSMAP_CYLINDRICAL ) || defined( USE_ROUGHNESSMAP_TRIPLANAR )
+
+	uniform mat3 roughnessMapTransform;
+
+#elif defined( USE_ROUGHNESSMAP_UV )
 
 	varying vec2 vRoughnessMapUv;
 
@@ -59,7 +100,11 @@ export default /* glsl */`
 	varying vec2 vClearcoatMapUv;
 
 #endif
-#ifdef USE_CLEARCOAT_NORMALMAP
+#if defined( USE_CLEARCOAT_NORMALMAP_CYLINDRICAL ) || defined( USE_CLEARCOAT_NORMALMAP_TRIPLANAR )
+
+	uniform mat3 clearcoatNormalMapTransform;
+
+#elif defined( USE_CLEARCOAT_NORMALMAP_UV )
 
 	varying vec2 vClearcoatNormalMapUv;
 

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

@@ -4,13 +4,31 @@ export default /* glsl */`
 	varying vec2 vUv;
 
 #endif
-#ifdef USE_MAP
+#if defined( USE_TRIPLANAR ) || defined( USE_CYLINDRICAL ) || ( defined(USE_ANISOTROPY) && !defined(USE_UV1) && !defined(USE_UV2) && !defined(USE_UV3) )
+
+	uniform mat4 texture3DMatrix;
+
+#endif
+#if defined( USE_TRIPLANAR ) || defined( USE_CYLINDRICAL )
+
+	varying vec3 vModelPosition;
+
+#endif
+#if defined( USE_TRIPLANAR ) || ( defined(USE_ANISOTROPY) && !defined(USE_UV1) && !defined(USE_UV2) && !defined(USE_UV3) )
+
+	varying vec3 vModelNormal;
+
+#endif
+#if defined( USE_CYLINDRICAL )
+
+#endif
+#if defined( USE_MAP_UV )
 
 	uniform mat3 mapTransform;
 	varying vec2 vMapUv;
 
 #endif
-#ifdef USE_ALPHAMAP
+#if defined( USE_ALPHAMAP_UV )
 
 	uniform mat3 alphaMapTransform;
 	varying vec2 vAlphaMapUv;
@@ -22,7 +40,7 @@ export default /* glsl */`
 	varying vec2 vLightMapUv;
 
 #endif
-#ifdef USE_AOMAP
+#if defined( USE_AOMAP_UV )
 
 	uniform mat3 aoMapTransform;
 	varying vec2 vAoMapUv;
@@ -34,7 +52,7 @@ export default /* glsl */`
 	varying vec2 vBumpMapUv;
 
 #endif
-#ifdef USE_NORMALMAP
+#if defined( USE_NORMALMAP_UV )
 
 	uniform mat3 normalMapTransform;
 	varying vec2 vNormalMapUv;
@@ -52,13 +70,13 @@ export default /* glsl */`
 	varying vec2 vEmissiveMapUv;
 
 #endif
-#ifdef USE_METALNESSMAP
+#if defined( USE_METALNESSMAP_UV )
 
 	uniform mat3 metalnessMapTransform;
 	varying vec2 vMetalnessMapUv;
 
 #endif
-#ifdef USE_ROUGHNESSMAP
+#if defined( USE_ROUGHNESSMAP_UV )
 
 	uniform mat3 roughnessMapTransform;
 	varying vec2 vRoughnessMapUv;
@@ -142,4 +160,5 @@ export default /* glsl */`
 	varying vec2 vThicknessMapUv;
 
 #endif
+
 `;

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

@@ -1,15 +1,27 @@
 export default /* glsl */`
 #if defined( USE_UV ) || defined( USE_ANISOTROPY )
 
-	vUv = vec3( uv, 1 ).xy;
+  #if defined( USE_UV1 ) || defined( USE_UV2 ) || defined( USE_UV3 )
+	  vUv = vec3( uv, 1 ).xy;
+  #endif
 
 #endif
-#ifdef USE_MAP
+#if defined( USE_TRIPLANAR ) || defined( USE_CYLINDRICAL )
+
+	vModelPosition = (texture3DMatrix * vec4(position.xyz, 1)).xyz;
+
+#endif
+#if defined( USE_TRIPLANAR )
+
+	vModelNormal = normal.xyz;
+
+#endif
+#if defined( USE_MAP_UV )
 
 	vMapUv = ( mapTransform * vec3( MAP_UV, 1 ) ).xy;
 
 #endif
-#ifdef USE_ALPHAMAP
+#if defined( USE_ALPHAMAP_UV )
 
 	vAlphaMapUv = ( alphaMapTransform * vec3( ALPHAMAP_UV, 1 ) ).xy;
 
@@ -19,7 +31,7 @@ export default /* glsl */`
 	vLightMapUv = ( lightMapTransform * vec3( LIGHTMAP_UV, 1 ) ).xy;
 
 #endif
-#ifdef USE_AOMAP
+#if defined( USE_AOMAP_UV )
 
 	vAoMapUv = ( aoMapTransform * vec3( AOMAP_UV, 1 ) ).xy;
 
@@ -29,7 +41,7 @@ export default /* glsl */`
 	vBumpMapUv = ( bumpMapTransform * vec3( BUMPMAP_UV, 1 ) ).xy;
 
 #endif
-#ifdef USE_NORMALMAP
+#if defined( USE_NORMALMAP_UV )
 
 	vNormalMapUv = ( normalMapTransform * vec3( NORMALMAP_UV, 1 ) ).xy;
 
@@ -44,12 +56,12 @@ export default /* glsl */`
 	vEmissiveMapUv = ( emissiveMapTransform * vec3( EMISSIVEMAP_UV, 1 ) ).xy;
 
 #endif
-#ifdef USE_METALNESSMAP
+#if defined( USE_METALNESSMAP_UV )
 
 	vMetalnessMapUv = ( metalnessMapTransform * vec3( METALNESSMAP_UV, 1 ) ).xy;
 
 #endif
-#ifdef USE_ROUGHNESSMAP
+#if defined( USE_ROUGHNESSMAP_UV )
 
 	vRoughnessMapUv = ( roughnessMapTransform * vec3( ROUGHNESSMAP_UV, 1 ) ).xy;
 

package/src/renderers/shaders/ShaderChunk.js

@@ -59,6 +59,7 @@ import logdepthbuf_pars_fragment from './ShaderChunk/logdepthbuf_pars_fragment.g
 import logdepthbuf_pars_vertex from './ShaderChunk/logdepthbuf_pars_vertex.glsl.js';
 import logdepthbuf_vertex from './ShaderChunk/logdepthbuf_vertex.glsl.js';
 import map_fragment from './ShaderChunk/map_fragment.glsl.js';
+import triplanar_fragment from './ShaderChunk/triplanar_fragment.glsl.js';
 import map_pars_fragment from './ShaderChunk/map_pars_fragment.glsl.js';
 import map_particle_fragment from './ShaderChunk/map_particle_fragment.glsl.js';
 import map_particle_pars_fragment from './ShaderChunk/map_particle_pars_fragment.glsl.js';
@@ -186,6 +187,7 @@ export const ShaderChunk = {
 	logdepthbuf_pars_vertex: logdepthbuf_pars_vertex,
 	logdepthbuf_vertex: logdepthbuf_vertex,
 	map_fragment: map_fragment,
+	triplanar_fragment: triplanar_fragment,
 	map_pars_fragment: map_pars_fragment,
 	map_particle_fragment: map_particle_fragment,
 	map_particle_pars_fragment: map_particle_pars_fragment,