@cesium/engine 24.0.0 → 25.0.0

package/Source/Scene/renderBufferPolylineCollection.js

@@ -21,13 +21,11 @@ import EncodedCartesian3 from "../Core/EncodedCartesian3.js";
 import AttributeCompression from "../Core/AttributeCompression.js";
 import IndexDatatype from "../Core/IndexDatatype.js";
 import PolylineCommon from "../Shaders/PolylineCommon.js";
-import Matrix4 from "../Core/Matrix4.js";
-import BoundingSphere from "../Core/BoundingSphere.js";
 import BufferPolylineMaterial from "./BufferPolylineMaterial.js";
 
 /** @import FrameState from "./FrameState.js"; */
 /** @import BufferPolylineCollection from "./BufferPolylineCollection.js"; */
-/** @import {Destroyable, TypedArray} from "../Core/globalTypes.js"; */
+/** @import {TypedArray} from "../Core/globalTypes.js"; */
 
 /**
  * TODO(PR#13211): Need 'keyof' syntax to avoid duplicating attribute names.
@@ -58,7 +56,6 @@ const BufferPolylineAttributeLocations = {
  * @property {RenderState} [renderState]
  * @property {ShaderProgram} [shaderProgram]
  * @property {DrawCommand} [command]
- * @property {Destroyable[]} [pickIds]
  * @property {Function} destroy
  * @ignore
  */
@@ -108,7 +105,7 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
       collection.vertexCountMax - collection.primitiveCount;
     const vertexCountMax = collection.vertexCountMax * 2;
 
-    // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
+    // @ts-expect-error https://github.com/CesiumGS/cesium/issues/13420
     renderContext.indexArray = IndexDatatype.createTypedArray(
       vertexCountMax,
       segmentCountMax * 6,
@@ -126,13 +123,9 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
     };
   }
 
-  if (!defined(renderContext.pickIds)) {
-    renderContext.pickIds = [];
-  }
-
   if (collection._dirtyCount > 0) {
     const { _dirtyOffset, _dirtyCount } = collection;
-    const { attributeArrays, pickIds } = renderContext;
+    const { attributeArrays } = renderContext;
 
     const indexArray = renderContext.indexArray;
     const positionHighArray = attributeArrays.positionHigh;
@@ -152,19 +145,6 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
         continue;
       }
 
-      if (collection._allowPicking && polyline._pickId === 0) {
-        const pickId = context.createPickId({
-          collection,
-          index: i,
-          get primitive() {
-            // Cannot reuse primitives; scene.drillPick() appends to a list.
-            return collection.get(i, new BufferPolyline());
-          },
-        });
-        polyline._pickId = pickId.key;
-        pickIds.push(pickId);
-      }
-
       const cartesianArray = polyline.getPositions();
       polyline.getMaterial(material);
       const encodedColor = AttributeCompression.encodeRGB8(material.color);
@@ -274,9 +254,8 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
       indexBuffer: Buffer.createIndexBuffer({
         context,
         typedArray: renderContext.indexArray,
-        // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
         usage: BufferUsage.STATIC_DRAW,
-        // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
+        // @ts-expect-error https://github.com/CesiumGS/cesium/issues/13420
         indexDatatype: IndexDatatype.fromTypedArray(renderContext.indexArray),
       }),
 
@@ -288,7 +267,6 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
           vertexBuffer: Buffer.createVertexBuffer({
             typedArray: attributeArrays.positionHigh,
             context,
-            // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
             usage: BufferUsage.STATIC_DRAW,
           }),
         },
@@ -299,7 +277,6 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
           vertexBuffer: Buffer.createVertexBuffer({
             typedArray: attributeArrays.positionLow,
             context,
-            // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
             usage: BufferUsage.STATIC_DRAW,
           }),
         },
@@ -311,7 +288,6 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
           vertexBuffer: Buffer.createVertexBuffer({
             typedArray: attributeArrays.prevPositionHigh,
             context,
-            // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
             usage: BufferUsage.STATIC_DRAW,
           }),
         },
@@ -322,7 +298,6 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
           vertexBuffer: Buffer.createVertexBuffer({
             typedArray: attributeArrays.prevPositionLow,
             context,
-            // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
             usage: BufferUsage.STATIC_DRAW,
           }),
         },
@@ -334,7 +309,6 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
           vertexBuffer: Buffer.createVertexBuffer({
             typedArray: attributeArrays.nextPositionHigh,
             context,
-            // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
             usage: BufferUsage.STATIC_DRAW,
           }),
         },
@@ -345,7 +319,6 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
           vertexBuffer: Buffer.createVertexBuffer({
             typedArray: attributeArrays.nextPositionLow,
             context,
-            // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
             usage: BufferUsage.STATIC_DRAW,
           }),
         },
@@ -356,7 +329,6 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
           vertexBuffer: Buffer.createVertexBuffer({
             typedArray: attributeArrays.pickColor,
             context,
-            // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
             usage: BufferUsage.STATIC_DRAW,
           }),
         },
@@ -367,7 +339,6 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
           vertexBuffer: Buffer.createVertexBuffer({
             typedArray: attributeArrays.showColorWidthAndTexCoord,
             context,
-            // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
             usage: BufferUsage.STATIC_DRAW,
           }),
         },
@@ -416,26 +387,35 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
     });
   }
 
-  if (
-    !defined(renderContext.command) ||
-    isCommandDirty(collection, renderContext.command)
-  ) {
+  const drawCount = getDrawIndexCount(collection);
+
+  if (!defined(renderContext.command)) {
     renderContext.command = new DrawCommand({
       vertexArray: renderContext.vertexArray,
       renderState: renderContext.renderState,
       shaderProgram: renderContext.shaderProgram,
       primitiveType: PrimitiveType.TRIANGLES,
       pass: Pass.OPAQUE,
-      pickId: "v_pickColor",
+      pickId: collection._allowPicking ? "v_pickColor" : undefined,
       owner: collection,
-      count: getDrawIndexCount(collection),
-      modelMatrix: collection.modelMatrix,
-      boundingVolume: collection.boundingVolumeWC,
+      count: drawCount,
+      modelMatrix: collection.modelMatrix, // shared reference
+      boundingVolume: collection.boundingVolumeWC, // shared reference
       debugShowBoundingVolume: collection.debugShowBoundingVolume,
     });
   }
 
-  frameState.commandList.push(renderContext.command);
+  const command = renderContext.command;
+
+  if (command.count !== drawCount) {
+    command.count = drawCount;
+  }
+
+  if (command.debugShowBoundingVolume !== collection.debugShowBoundingVolume) {
+    command.debugShowBoundingVolume = collection.debugShowBoundingVolume;
+  }
+
+  frameState.commandList.push(command);
 
   collection._dirtyCount = 0;
   collection._dirtyOffset = 0;
@@ -443,31 +423,6 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
   return renderContext;
 }
 
-/**
- * Returns true if DrawCommand is out of date for given collection.
- * @param {BufferPolylineCollection} collection
- * @param {DrawCommand} command
- * @ignore
- */
-function isCommandDirty(collection, command) {
-  const isModelMatrixEqual = Matrix4.equals(
-    collection.modelMatrix,
-    command._modelMatrix,
-  );
-
-  const isBoundingVolumeEqual = BoundingSphere.equals(
-    collection.boundingVolumeWC,
-    command._boundingVolume,
-  );
-
-  return (
-    getDrawIndexCount(collection) !== command._count ||
-    collection.debugShowBoundingVolume !== command.debugShowBoundingVolume ||
-    !isModelMatrixEqual ||
-    !isBoundingVolumeEqual
-  );
-}
-
 /**
  * Returns number of drawn (not allocated) indices for given collection.
  * @param {BufferPolylineCollection} collection
@@ -518,12 +473,6 @@ function destroyRenderContext() {
   if (defined(context.renderState)) {
     RenderState.removeFromCache(context.renderState);
   }
-
-  if (defined(context.pickIds)) {
-    for (const pickId of context.pickIds) {
-      pickId.destroy();
-    }
-  }
 }
 
 export default renderBufferPolylineCollection;

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -71,6 +71,7 @@ import czm_computeAtmosphereColor from './Functions/computeAtmosphereColor.js'
 import czm_computeGroundAtmosphereScattering from './Functions/computeGroundAtmosphereScattering.js'
 import czm_computePosition from './Functions/computePosition.js'
 import czm_computeScattering from './Functions/computeScattering.js'
+import czm_computeTextureTransform from './Functions/computeTextureTransform.js'
 import czm_cosineAndSine from './Functions/cosineAndSine.js'
 import czm_decodeRGB8 from './Functions/decodeRGB8.js'
 import czm_decompressTextureCoordinates from './Functions/decompressTextureCoordinates.js'
@@ -213,6 +214,7 @@ export default {
     czm_computeGroundAtmosphereScattering : czm_computeGroundAtmosphereScattering,
     czm_computePosition : czm_computePosition,
     czm_computeScattering : czm_computeScattering,
+    czm_computeTextureTransform : czm_computeTextureTransform,
     czm_cosineAndSine : czm_cosineAndSine,
     czm_decodeRGB8 : czm_decodeRGB8,
     czm_decompressTextureCoordinates : czm_decompressTextureCoordinates,

package/Source/Shaders/Builtin/Functions/computeTextureTransform.glsl

@@ -0,0 +1,24 @@
+/**
+ * Applies a 2D texture transformation matrix to texture coordinates.
+ * This function applies translation, rotation, and scaling transformations
+ * as specified by the KHR_texture_transform glTF extension.
+ *
+ * @name czm_computeTextureTransform
+ * @glslFunction
+ *
+ * @param {vec2} texCoord The texture coordinates to transform.
+ * @param {mat3} textureTransform The 3x3 transformation matrix.
+ *
+ * @returns {vec2} The transformed texture coordinates.
+ *
+ * @example
+ * // GLSL declaration
+ * vec2 czm_computeTextureTransform(vec2 texCoord, mat3 textureTransform);
+ *
+ * // Apply texture transform to UV coordinates
+ * vec2 transformedUV = czm_computeTextureTransform(uv, u_textureTransform);
+ */
+vec2 czm_computeTextureTransform(vec2 texCoord, mat3 textureTransform)
+{
+    return vec2(textureTransform * vec3(texCoord, 1.0));
+}

package/Source/Shaders/Builtin/Functions/computeTextureTransform.js

@@ -0,0 +1,25 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Applies a 2D texture transformation matrix to texture coordinates.\n\
+ * This function applies translation, rotation, and scaling transformations\n\
+ * as specified by the KHR_texture_transform glTF extension.\n\
+ *\n\
+ * @name czm_computeTextureTransform\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {vec2} texCoord The texture coordinates to transform.\n\
+ * @param {mat3} textureTransform The 3x3 transformation matrix.\n\
+ *\n\
+ * @returns {vec2} The transformed texture coordinates.\n\
+ *\n\
+ * @example\n\
+ * // GLSL declaration\n\
+ * vec2 czm_computeTextureTransform(vec2 texCoord, mat3 textureTransform);\n\
+ *\n\
+ * // Apply texture transform to UV coordinates\n\
+ * vec2 transformedUV = czm_computeTextureTransform(uv, u_textureTransform);\n\
+ */\n\
+vec2 czm_computeTextureTransform(vec2 texCoord, mat3 textureTransform)\n\
+{\n\
+    return vec2(textureTransform * vec3(texCoord, 1.0));\n\
+}";

package/Source/Shaders/Model/ConstantLodStageFS.glsl

@@ -0,0 +1,60 @@
+#ifdef HAS_CONSTANT_LOD
+
+vec4 constantLodTextureLookup(sampler2D textureSampler, vec3 constantLodParams) {
+    bool atMaxClamp = v_constantLodUvCustom.z >= constantLodParams.y;
+    bool atMinClamp = v_constantLodUvCustom.z <= constantLodParams.x;
+    bool atClampBoundary = atMaxClamp || atMinClamp;
+    
+    float effectiveDistance = atMaxClamp ? constantLodParams.y : 
+                              (atMinClamp ? constantLodParams.x : v_constantLodUvCustom.z);
+    
+    float logDepth = log2(effectiveDistance);
+    logDepth = clamp(logDepth, -10.0, 20.0);
+    
+    float f = fract(logDepth);
+    float p = floor(logDepth);
+    
+    if (atClampBoundary) {
+        float clampedP = ceil(logDepth);
+        vec2 tc = v_constantLodUvCustom.xy / pow(2.0, clampedP) * constantLodParams.z;
+        return texture(textureSampler, tc);
+    }
+
+    vec2 tc1 = v_constantLodUvCustom.xy / pow(2.0, p) * constantLodParams.z;
+    vec2 tc2 = v_constantLodUvCustom.xy / pow(2.0, p + 1.0) * constantLodParams.z;
+    return mix(texture(textureSampler, tc1), texture(textureSampler, tc2), f);
+}
+
+vec4 constantLodTextureLookup(sampler2D textureSampler, vec3 constantLodParams, mat3 textureTransform) {
+    bool atMaxClamp = v_constantLodUvCustom.z >= constantLodParams.y;
+    bool atMinClamp = v_constantLodUvCustom.z <= constantLodParams.x;
+    bool atClampBoundary = atMaxClamp || atMinClamp;
+    
+    float effectiveDistance = atMaxClamp ? constantLodParams.y : 
+                              (atMinClamp ? constantLodParams.x : v_constantLodUvCustom.z);
+    
+    float logDepth = log2(effectiveDistance);
+    logDepth = clamp(logDepth, -10.0, 20.0);
+    
+    float f = fract(logDepth);
+    float p = floor(logDepth);
+    
+    if (atClampBoundary) {
+        float clampedP = ceil(logDepth);
+        vec2 tc = v_constantLodUvCustom.xy / pow(2.0, clampedP) * constantLodParams.z;
+        // Apply texture transform to the final texture coordinates
+        tc = czm_computeTextureTransform(tc, textureTransform);
+        return texture(textureSampler, tc);
+    }
+
+    vec2 tc1 = v_constantLodUvCustom.xy / pow(2.0, p) * constantLodParams.z;
+    vec2 tc2 = v_constantLodUvCustom.xy / pow(2.0, p + 1.0) * constantLodParams.z;
+    
+    // Apply texture transform to both LOD texture coordinates before mixing
+    tc1 = czm_computeTextureTransform(tc1, textureTransform);
+    tc2 = czm_computeTextureTransform(tc2, textureTransform);
+    
+    return mix(texture(textureSampler, tc1), texture(textureSampler, tc2), f);
+}
+
+#endif

package/Source/Shaders/Model/ConstantLodStageFS.js

@@ -0,0 +1,62 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "#ifdef HAS_CONSTANT_LOD\n\
+\n\
+vec4 constantLodTextureLookup(sampler2D textureSampler, vec3 constantLodParams) {\n\
+    bool atMaxClamp = v_constantLodUvCustom.z >= constantLodParams.y;\n\
+    bool atMinClamp = v_constantLodUvCustom.z <= constantLodParams.x;\n\
+    bool atClampBoundary = atMaxClamp || atMinClamp;\n\
+    \n\
+    float effectiveDistance = atMaxClamp ? constantLodParams.y : \n\
+                              (atMinClamp ? constantLodParams.x : v_constantLodUvCustom.z);\n\
+    \n\
+    float logDepth = log2(effectiveDistance);\n\
+    logDepth = clamp(logDepth, -10.0, 20.0);\n\
+    \n\
+    float f = fract(logDepth);\n\
+    float p = floor(logDepth);\n\
+    \n\
+    if (atClampBoundary) {\n\
+        float clampedP = ceil(logDepth);\n\
+        vec2 tc = v_constantLodUvCustom.xy / pow(2.0, clampedP) * constantLodParams.z;\n\
+        return texture(textureSampler, tc);\n\
+    }\n\
+\n\
+    vec2 tc1 = v_constantLodUvCustom.xy / pow(2.0, p) * constantLodParams.z;\n\
+    vec2 tc2 = v_constantLodUvCustom.xy / pow(2.0, p + 1.0) * constantLodParams.z;\n\
+    return mix(texture(textureSampler, tc1), texture(textureSampler, tc2), f);\n\
+}\n\
+\n\
+vec4 constantLodTextureLookup(sampler2D textureSampler, vec3 constantLodParams, mat3 textureTransform) {\n\
+    bool atMaxClamp = v_constantLodUvCustom.z >= constantLodParams.y;\n\
+    bool atMinClamp = v_constantLodUvCustom.z <= constantLodParams.x;\n\
+    bool atClampBoundary = atMaxClamp || atMinClamp;\n\
+    \n\
+    float effectiveDistance = atMaxClamp ? constantLodParams.y : \n\
+                              (atMinClamp ? constantLodParams.x : v_constantLodUvCustom.z);\n\
+    \n\
+    float logDepth = log2(effectiveDistance);\n\
+    logDepth = clamp(logDepth, -10.0, 20.0);\n\
+    \n\
+    float f = fract(logDepth);\n\
+    float p = floor(logDepth);\n\
+    \n\
+    if (atClampBoundary) {\n\
+        float clampedP = ceil(logDepth);\n\
+        vec2 tc = v_constantLodUvCustom.xy / pow(2.0, clampedP) * constantLodParams.z;\n\
+        // Apply texture transform to the final texture coordinates\n\
+        tc = czm_computeTextureTransform(tc, textureTransform);\n\
+        return texture(textureSampler, tc);\n\
+    }\n\
+\n\
+    vec2 tc1 = v_constantLodUvCustom.xy / pow(2.0, p) * constantLodParams.z;\n\
+    vec2 tc2 = v_constantLodUvCustom.xy / pow(2.0, p + 1.0) * constantLodParams.z;\n\
+    \n\
+    // Apply texture transform to both LOD texture coordinates before mixing\n\
+    tc1 = czm_computeTextureTransform(tc1, textureTransform);\n\
+    tc2 = czm_computeTextureTransform(tc2, textureTransform);\n\
+    \n\
+    return mix(texture(textureSampler, tc1), texture(textureSampler, tc2), f);\n\
+}\n\
+\n\
+#endif\n\
+";

package/Source/Shaders/Model/ConstantLodStageVS.glsl

@@ -0,0 +1,12 @@
+#ifdef HAS_CONSTANT_LOD
+// Extract model scale to compensate for minimumPixelSize scaling
+float modelScaleX = length(czm_model[0].xyz);
+float modelScaleY = length(czm_model[1].xyz);
+float modelScaleZ = length(czm_model[2].xyz);
+float modelScale = (modelScaleX + modelScaleY + modelScaleZ) / 3.0;
+
+// Transform model position through ENU but as direction only (w=0) to avoid position-dependent rotation
+vec3 enuDir = (u_constantLodWorldToEnu * czm_model * vec4(v_positionMC, 0.0)).xyz;
+v_constantLodUvCustom.xy = (enuDir.yx + u_constantLodOffset) / modelScale;
+v_constantLodUvCustom.z = u_constantLodDistance / modelScale;
+#endif

package/Source/Shaders/Model/ConstantLodStageVS.js

@@ -0,0 +1,13 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "#ifdef HAS_CONSTANT_LOD\n\
+// Extract model scale to compensate for minimumPixelSize scaling\n\
+float modelScaleX = length(czm_model[0].xyz);\n\
+float modelScaleY = length(czm_model[1].xyz);\n\
+float modelScaleZ = length(czm_model[2].xyz);\n\
+float modelScale = (modelScaleX + modelScaleY + modelScaleZ) / 3.0;\n\
+\n\
+// Transform model position through ENU but as direction only (w=0) to avoid position-dependent rotation\n\
+vec3 enuDir = (u_constantLodWorldToEnu * czm_model * vec4(v_positionMC, 0.0)).xyz;\n\
+v_constantLodUvCustom.xy = (enuDir.yx + u_constantLodOffset) / modelScale;\n\
+v_constantLodUvCustom.z = u_constantLodDistance / modelScale;\n\
+#endif";

package/Source/Shaders/Model/MaterialStageFS.glsl

@@ -11,17 +11,12 @@ vec3 blend(vec3 sourceColor, vec3 styleColor, float styleColorBlend)
     return color;
 }
 
-vec2 computeTextureTransform(vec2 texCoord, mat3 textureTransform)
-{
-    return vec2(textureTransform * vec3(texCoord, 1.0));
-}
-
 #ifdef HAS_NORMAL_TEXTURE
 vec2 getNormalTexCoords()
 {
     vec2 texCoord = TEXCOORD_NORMAL;
     #ifdef HAS_NORMAL_TEXTURE_TRANSFORM
-        texCoord = vec2(u_normalTextureTransform * vec3(texCoord, 1.0));
+        texCoord = czm_computeTextureTransform(texCoord, u_normalTextureTransform);
     #endif
     return texCoord;
 }
@@ -64,7 +59,18 @@ NormalInfo getNormalInfo(ProcessedAttributes attributes)
 
     #ifdef HAS_NORMAL_TEXTURE
         mat3 tbn = mat3(tangent, bitangent, geometryNormal);
-        vec3 normalSample = texture(u_normalTexture, normalTexCoords).rgb;
+        
+        vec3 normalSample;
+        #if defined(HAS_NORMAL_CONSTANT_LOD) && defined(HAS_CONSTANT_LOD)
+            #ifdef HAS_NORMAL_TEXTURE_TRANSFORM
+                normalSample = constantLodTextureLookup(u_normalTexture, u_normalTextureConstantLodParams, u_normalTextureTransform).rgb;
+            #else
+                normalSample = constantLodTextureLookup(u_normalTexture, u_normalTextureConstantLodParams).rgb;
+            #endif
+        #else
+            normalSample = texture(u_normalTexture, normalTexCoords).rgb;
+        #endif
+        
         normalSample = 2.0 * normalSample - 1.0;
         #ifdef HAS_NORMAL_TEXTURE_SCALE
             normalSample.xy *= u_normalTextureScale;
@@ -109,7 +115,18 @@ vec3 getNormalFromTexture(ProcessedAttributes attributes, vec3 geometryNormal)
     #endif
 
     mat3 tbn = mat3(t, b, geometryNormal);
-    vec3 normalSample = texture(u_normalTexture, normalTexCoords).rgb;
+    
+    vec3 normalSample;
+    #if defined(HAS_NORMAL_CONSTANT_LOD) && defined(HAS_CONSTANT_LOD)
+        #ifdef HAS_NORMAL_TEXTURE_TRANSFORM
+            normalSample = constantLodTextureLookup(u_normalTexture, u_normalTextureConstantLodParams, u_normalTextureTransform).rgb;
+        #else
+            normalSample = constantLodTextureLookup(u_normalTexture, u_normalTextureConstantLodParams).rgb;
+        #endif
+    #else
+        normalSample = texture(u_normalTexture, normalTexCoords).rgb;
+    #endif
+    
     normalSample = 2.0 * normalSample - 1.0;
     #ifdef HAS_NORMAL_TEXTURE_SCALE
         normalSample.xy *= u_normalTextureScale;
@@ -171,10 +188,19 @@ vec4 getBaseColorFromTexture()
 {
     vec2 baseColorTexCoords = TEXCOORD_BASE_COLOR;
     #ifdef HAS_BASE_COLOR_TEXTURE_TRANSFORM
-        baseColorTexCoords = computeTextureTransform(baseColorTexCoords, u_baseColorTextureTransform);
+        baseColorTexCoords = czm_computeTextureTransform(baseColorTexCoords, u_baseColorTextureTransform);
     #endif
 
-    vec4 baseColorWithAlpha = czm_srgbToLinear(texture(u_baseColorTexture, baseColorTexCoords));
+    vec4 baseColorWithAlpha;
+    #if defined(HAS_BASE_COLOR_CONSTANT_LOD) && defined(HAS_CONSTANT_LOD)
+        #ifdef HAS_BASE_COLOR_TEXTURE_TRANSFORM
+            baseColorWithAlpha = czm_srgbToLinear(constantLodTextureLookup(u_baseColorTexture, u_baseColorTextureConstantLodParams, u_baseColorTextureTransform));
+        #else
+            baseColorWithAlpha = czm_srgbToLinear(constantLodTextureLookup(u_baseColorTexture, u_baseColorTextureConstantLodParams));
+        #endif
+    #else
+        baseColorWithAlpha = czm_srgbToLinear(texture(u_baseColorTexture, baseColorTexCoords));
+    #endif
 
     #ifdef HAS_BASE_COLOR_FACTOR
         baseColorWithAlpha *= u_baseColorFactor;
@@ -189,7 +215,7 @@ vec3 getEmissiveFromTexture()
 {
     vec2 emissiveTexCoords = TEXCOORD_EMISSIVE;
     #ifdef HAS_EMISSIVE_TEXTURE_TRANSFORM
-        emissiveTexCoords = computeTextureTransform(emissiveTexCoords, u_emissiveTextureTransform);
+        emissiveTexCoords = czm_computeTextureTransform(emissiveTexCoords, u_emissiveTextureTransform);
     #endif
 
     vec3 emissive = czm_srgbToLinear(texture(u_emissiveTexture, emissiveTexCoords).rgb);
@@ -207,7 +233,7 @@ void setSpecularGlossiness(inout czm_modelMaterial material)
     #ifdef HAS_SPECULAR_GLOSSINESS_TEXTURE
         vec2 specularGlossinessTexCoords = TEXCOORD_SPECULAR_GLOSSINESS;
         #ifdef HAS_SPECULAR_GLOSSINESS_TEXTURE_TRANSFORM
-            specularGlossinessTexCoords = computeTextureTransform(specularGlossinessTexCoords, u_specularGlossinessTextureTransform);
+            specularGlossinessTexCoords = czm_computeTextureTransform(specularGlossinessTexCoords, u_specularGlossinessTextureTransform);
         #endif
 
         vec4 specularGlossiness = czm_srgbToLinear(texture(u_specularGlossinessTexture, specularGlossinessTexCoords));
@@ -237,7 +263,7 @@ void setSpecularGlossiness(inout czm_modelMaterial material)
     #ifdef HAS_DIFFUSE_TEXTURE
         vec2 diffuseTexCoords = TEXCOORD_DIFFUSE;
         #ifdef HAS_DIFFUSE_TEXTURE_TRANSFORM
-            diffuseTexCoords = computeTextureTransform(diffuseTexCoords, u_diffuseTextureTransform);
+            diffuseTexCoords = czm_computeTextureTransform(diffuseTexCoords, u_diffuseTextureTransform);
         #endif
 
         vec4 diffuse = czm_srgbToLinear(texture(u_diffuseTexture, diffuseTexCoords));
@@ -266,7 +292,7 @@ float setMetallicRoughness(inout czm_modelMaterial material)
     #ifdef HAS_METALLIC_ROUGHNESS_TEXTURE
         vec2 metallicRoughnessTexCoords = TEXCOORD_METALLIC_ROUGHNESS;
         #ifdef HAS_METALLIC_ROUGHNESS_TEXTURE_TRANSFORM
-            metallicRoughnessTexCoords = computeTextureTransform(metallicRoughnessTexCoords, u_metallicRoughnessTextureTransform);
+            metallicRoughnessTexCoords = czm_computeTextureTransform(metallicRoughnessTexCoords, u_metallicRoughnessTextureTransform);
         #endif
 
         vec3 metallicRoughness = texture(u_metallicRoughnessTexture, metallicRoughnessTexCoords).rgb;
@@ -313,7 +339,7 @@ void setSpecular(inout czm_modelMaterial material, in float metalness)
     #ifdef HAS_SPECULAR_TEXTURE
         vec2 specularTexCoords = TEXCOORD_SPECULAR;
         #ifdef HAS_SPECULAR_TEXTURE_TRANSFORM
-            specularTexCoords = computeTextureTransform(specularTexCoords, u_specularTextureTransform);
+            specularTexCoords = czm_computeTextureTransform(specularTexCoords, u_specularTextureTransform);
         #endif
         float specularWeight = texture(u_specularTexture, specularTexCoords).a;
         #ifdef HAS_SPECULAR_FACTOR
@@ -330,7 +356,7 @@ void setSpecular(inout czm_modelMaterial material, in float metalness)
     #ifdef HAS_SPECULAR_COLOR_TEXTURE
         vec2 specularColorTexCoords = TEXCOORD_SPECULAR_COLOR;
         #ifdef HAS_SPECULAR_COLOR_TEXTURE_TRANSFORM
-            specularColorTexCoords = computeTextureTransform(specularColorTexCoords, u_specularColorTextureTransform);
+            specularColorTexCoords = czm_computeTextureTransform(specularColorTexCoords, u_specularColorTextureTransform);
         #endif
         vec3 specularColorSample = texture(u_specularColorTexture, specularColorTexCoords).rgb;
         vec3 specularColorFactor = czm_srgbToLinear(specularColorSample);
@@ -360,7 +386,7 @@ void setAnisotropy(inout czm_modelMaterial material, in NormalInfo normalInfo)
     #ifdef HAS_ANISOTROPY_TEXTURE
         vec2 anisotropyTexCoords = TEXCOORD_ANISOTROPY;
         #ifdef HAS_ANISOTROPY_TEXTURE_TRANSFORM
-            anisotropyTexCoords = computeTextureTransform(anisotropyTexCoords, u_anisotropyTextureTransform);
+            anisotropyTexCoords = czm_computeTextureTransform(anisotropyTexCoords, u_anisotropyTextureTransform);
         #endif
         vec3 anisotropySample = texture(u_anisotropyTexture, anisotropyTexCoords).rgb;
         direction = anisotropySample.rg * 2.0 - vec2(1.0);
@@ -383,7 +409,7 @@ void setClearcoat(inout czm_modelMaterial material, in ProcessedAttributes attri
     #ifdef HAS_CLEARCOAT_TEXTURE
         vec2 clearcoatTexCoords = TEXCOORD_CLEARCOAT;
         #ifdef HAS_CLEARCOAT_TEXTURE_TRANSFORM
-            clearcoatTexCoords = computeTextureTransform(clearcoatTexCoords, u_clearcoatTextureTransform);
+            clearcoatTexCoords = czm_computeTextureTransform(clearcoatTexCoords, u_clearcoatTextureTransform);
         #endif
         float clearcoatFactor = texture(u_clearcoatTexture, clearcoatTexCoords).r;
         #ifdef HAS_CLEARCOAT_FACTOR
@@ -401,7 +427,7 @@ void setClearcoat(inout czm_modelMaterial material, in ProcessedAttributes attri
     #ifdef HAS_CLEARCOAT_ROUGHNESS_TEXTURE
         vec2 clearcoatRoughnessTexCoords = TEXCOORD_CLEARCOAT_ROUGHNESS;
         #ifdef HAS_CLEARCOAT_ROUGHNESS_TEXTURE_TRANSFORM
-            clearcoatRoughnessTexCoords = computeTextureTransform(clearcoatRoughnessTexCoords, u_clearcoatRoughnessTextureTransform);
+            clearcoatRoughnessTexCoords = czm_computeTextureTransform(clearcoatRoughnessTexCoords, u_clearcoatRoughnessTextureTransform);
         #endif
         float clearcoatRoughness = texture(u_clearcoatRoughnessTexture, clearcoatRoughnessTexCoords).g;
         #ifdef HAS_CLEARCOAT_ROUGHNESS_FACTOR
@@ -469,7 +495,7 @@ void materialStage(inout czm_modelMaterial material, ProcessedAttributes attribu
     #ifdef HAS_OCCLUSION_TEXTURE
         vec2 occlusionTexCoords = TEXCOORD_OCCLUSION;
         #ifdef HAS_OCCLUSION_TEXTURE_TRANSFORM
-            occlusionTexCoords = computeTextureTransform(occlusionTexCoords, u_occlusionTextureTransform);
+            occlusionTexCoords = czm_computeTextureTransform(occlusionTexCoords, u_occlusionTextureTransform);
         #endif
         material.occlusion = texture(u_occlusionTexture, occlusionTexCoords).r;
     #endif