@cesium/engine 17.0.0 → 18.0.1-splats.0

package/Source/Scene/VertexAttributeSemantic.js

@@ -73,6 +73,20 @@ const VertexAttributeSemantic = {
    * @constant
    */
   FEATURE_ID: "_FEATURE_ID",
+  /**
+   * Gaussian Splat Scale
+   *
+   * @type {string}
+   * @constant
+   */
+  SCALE: "_SCALE",
+  /**
+   * Gaussian Splat Rotation
+   *
+   * @type {string}
+   * @constant
+   */
+  ROTATION: "_ROTATION",
 };
 
 function semanticToVariableName(semantic) {
@@ -93,6 +107,10 @@ function semanticToVariableName(semantic) {
       return "weights";
     case VertexAttributeSemantic.FEATURE_ID:
       return "featureId";
+    case VertexAttributeSemantic.SCALE:
+      return "scale";
+    case VertexAttributeSemantic.ROTATION:
+      return "rotation";
     //>>includeStart('debug', pragmas.debug);
     default:
       throw new DeveloperError("semantic is not a valid value.");
@@ -124,6 +142,8 @@ VertexAttributeSemantic.hasSetIndex = function (semantic) {
     case VertexAttributeSemantic.JOINTS:
     case VertexAttributeSemantic.WEIGHTS:
     case VertexAttributeSemantic.FEATURE_ID:
+    case VertexAttributeSemantic.SCALE:
+    case VertexAttributeSemantic.ROTATION:
       return true;
     //>>includeStart('debug', pragmas.debug);
     default:
@@ -172,6 +192,10 @@ VertexAttributeSemantic.fromGltfSemantic = function (gltfSemantic) {
       return VertexAttributeSemantic.WEIGHTS;
     case "_FEATURE_ID":
       return VertexAttributeSemantic.FEATURE_ID;
+    case "_SCALE":
+      return VertexAttributeSemantic.SCALE;
+    case "_ROTATION":
+      return VertexAttributeSemantic.ROTATION;
   }
 
   return undefined;
@@ -241,6 +265,12 @@ VertexAttributeSemantic.getGlslType = function (semantic) {
       return "vec4";
     case VertexAttributeSemantic.FEATURE_ID:
       return "int";
+    case VertexAttributeSemantic.SCALE:
+      return "vec3";
+    case VertexAttributeSemantic.ROTATION:
+      return "vec4";
+    case VertexAttributeSemantic.OPACITY:
+      return "float";
     //>>includeStart('debug', pragmas.debug);
     default:
       throw new DeveloperError("semantic is not a valid value.");

package/Source/Scene/VoxelPrimitive.js

@@ -45,6 +45,7 @@ import VoxelMetadataOrder from "./VoxelMetadataOrder.js";
  * @see VoxelProvider
  * @see Cesium3DTilesVoxelProvider
  * @see VoxelShapeType
+ * @see {@link https://github.com/CesiumGS/cesium/tree/main/Documentation/CustomShaderGuide|Custom Shader Guide}
  *
  * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
  */
@@ -339,22 +340,22 @@ function VoxelPrimitive(options) {
   this._transformPositionWorldToUv = new Matrix4();
 
   /**
-   * @type {Matrix4}
+   * @type {Matrix3}
    * @private
    */
-  this._transformPositionUvToWorld = new Matrix4();
+  this._transformDirectionWorldToUv = new Matrix3();
 
   /**
-   * @type {Matrix3}
+   * @type {Matrix4}
    * @private
    */
-  this._transformDirectionWorldToLocal = new Matrix3();
+  this._transformPositionUvToWorld = new Matrix4();
 
   /**
    * @type {Matrix3}
    * @private
    */
-  this._transformNormalLocalToWorld = new Matrix3();
+  this._transformDirectionWorldToLocal = new Matrix3();
 
   // Rendering
   /**
@@ -442,8 +443,8 @@ function VoxelPrimitive(options) {
     transformPositionViewToUv: new Matrix4(),
     transformPositionUvToView: new Matrix4(),
     transformDirectionViewToLocal: new Matrix3(),
-    transformNormalLocalToWorld: new Matrix3(),
     cameraPositionUv: new Cartesian3(),
+    cameraDirectionUv: new Cartesian3(),
     ndcSpaceAxisAlignedBoundingBox: new Cartesian4(),
     clippingPlanesTexture: undefined,
     clippingPlanesMatrix: new Matrix4(),
@@ -1075,6 +1076,7 @@ Object.defineProperties(VoxelPrimitive.prototype, {
    *
    * @memberof VoxelPrimitive.prototype
    * @type {CustomShader}
+   * @see {@link https://github.com/CesiumGS/cesium/tree/main/Documentation/CustomShaderGuide|Custom Shader Guide}
    */
   customShader: {
     get: function () {
@@ -1135,10 +1137,6 @@ Object.defineProperties(VoxelPrimitive.prototype, {
 
 const scratchIntersect = new Cartesian4();
 const scratchNdcAabb = new Cartesian4();
-const scratchScale = new Cartesian3();
-const scratchLocalScale = new Cartesian3();
-const scratchRotation = new Matrix3();
-const scratchRotationAndLocalScale = new Matrix3();
 const scratchTransformPositionWorldToLocal = new Matrix4();
 const scratchTransformPositionLocalToWorld = new Matrix4();
 const scratchTransformPositionLocalToProjection = new Matrix4();
@@ -1306,16 +1304,20 @@ VoxelPrimitive.prototype.update = function (frameState) {
     transformDirectionViewToWorld,
     uniforms.transformDirectionViewToLocal,
   );
-  uniforms.transformNormalLocalToWorld = Matrix3.clone(
-    this._transformNormalLocalToWorld,
-    uniforms.transformNormalLocalToWorld,
-  );
-  const cameraPositionWorld = frameState.camera.positionWC;
   uniforms.cameraPositionUv = Matrix4.multiplyByPoint(
     this._transformPositionWorldToUv,
-    cameraPositionWorld,
+    frameState.camera.positionWC,
     uniforms.cameraPositionUv,
   );
+  uniforms.cameraDirectionUv = Matrix3.multiplyByVector(
+    this._transformDirectionWorldToUv,
+    frameState.camera.directionWC,
+    uniforms.cameraDirectionUv,
+  );
+  uniforms.cameraDirectionUv = Cartesian3.normalize(
+    uniforms.cameraDirectionUv,
+    uniforms.cameraDirectionUv,
+  );
   uniforms.stepSize = this._stepSizeMultiplier;
 
   // Render the primitive
@@ -1606,23 +1608,6 @@ function updateShapeAndTransforms(primitive, shape, provider) {
     transformPositionLocalToWorld,
     scratchTransformPositionWorldToLocal,
   );
-  const rotation = Matrix4.getRotation(
-    transformPositionLocalToWorld,
-    scratchRotation,
-  );
-  // Note that inverse(rotation) is the same as transpose(rotation)
-  const scale = Matrix4.getScale(transformPositionLocalToWorld, scratchScale);
-  const maximumScaleComponent = Cartesian3.maximumComponent(scale);
-  const localScale = Cartesian3.divideByScalar(
-    scale,
-    maximumScaleComponent,
-    scratchLocalScale,
-  );
-  const rotationAndLocalScale = Matrix3.multiplyByScale(
-    rotation,
-    localScale,
-    scratchRotationAndLocalScale,
-  );
 
   // Set member variables when the shape is dirty
   primitive._transformPositionWorldToUv = Matrix4.multiplyTransformation(
@@ -1630,6 +1615,10 @@ function updateShapeAndTransforms(primitive, shape, provider) {
     transformPositionWorldToLocal,
     primitive._transformPositionWorldToUv,
   );
+  primitive._transformDirectionWorldToUv = Matrix4.getMatrix3(
+    primitive._transformPositionWorldToUv,
+    primitive._transformDirectionWorldToUv,
+  );
   primitive._transformPositionUvToWorld = Matrix4.multiplyTransformation(
     transformPositionLocalToWorld,
     transformPositionUvToLocal,
@@ -1639,10 +1628,6 @@ function updateShapeAndTransforms(primitive, shape, provider) {
     transformPositionWorldToLocal,
     primitive._transformDirectionWorldToLocal,
   );
-  primitive._transformNormalLocalToWorld = Matrix3.inverseTranspose(
-    rotationAndLocalScale,
-    primitive._transformNormalLocalToWorld,
-  );
 
   return true;
 }

package/Source/Scene/VoxelRenderResources.js

@@ -140,13 +140,13 @@ function VoxelRenderResources(primitive) {
     }
     shaderBuilder.addFragmentLines([IntersectClippingPlanes]);
   }
+  shaderBuilder.addFragmentLines([IntersectDepth]);
   if (primitive._depthTest) {
     shaderBuilder.addDefine(
       "DEPTH_TEST",
       undefined,
       ShaderDestination.FRAGMENT,
     );
-    shaderBuilder.addFragmentLines([IntersectDepth]);
   }
 
   if (shapeType === "BOX") {

package/Source/Scene/processVoxelProperties.js

@@ -38,7 +38,7 @@ function processVoxelProperties(renderResources, primitive) {
   // PropertyStatistics structs
   for (let i = 0; i < attributeLength; i++) {
     const name = names[i];
-    const type = types[i];
+    const glslType = getGlslType(types[i]);
     const propertyStatisticsStructId = `PropertyStatistics_${name}`;
     const propertyStatisticsStructName = `PropertyStatistics_${name}`;
     shaderBuilder.addStruct(
@@ -46,18 +46,17 @@ function processVoxelProperties(renderResources, primitive) {
       propertyStatisticsStructName,
       ShaderDestination.FRAGMENT,
     );
-    const glslType = getGlslType(type);
     shaderBuilder.addStructField(propertyStatisticsStructId, glslType, "min");
     shaderBuilder.addStructField(propertyStatisticsStructId, glslType, "max");
   }
 
-  // Statistics struct
-  const statisticsStructId = "Statistics";
-  const statisticsStructName = "Statistics";
-  const statisticsFieldName = "statistics";
+  // MetadataStatistics struct
+  const metadataStatisticsStructId = "MetadataStatistics";
+  const metadataStatisticsStructName = "MetadataStatistics";
+  const metadataStatisticsFieldName = "metadataStatistics";
   shaderBuilder.addStruct(
-    statisticsStructId,
-    statisticsStructName,
+    metadataStatisticsStructId,
+    metadataStatisticsStructName,
     ShaderDestination.FRAGMENT,
   );
   for (let i = 0; i < attributeLength; i++) {
@@ -65,7 +64,7 @@ function processVoxelProperties(renderResources, primitive) {
     const propertyStructName = `PropertyStatistics_${name}`;
     const propertyFieldName = name;
     shaderBuilder.addStructField(
-      statisticsStructId,
+      metadataStatisticsStructId,
       propertyStructName,
       propertyFieldName,
     );
@@ -80,51 +79,22 @@ function processVoxelProperties(renderResources, primitive) {
     metadataStructName,
     ShaderDestination.FRAGMENT,
   );
-  shaderBuilder.addStructField(
-    metadataStructId,
-    statisticsStructName,
-    statisticsFieldName,
-  );
   for (let i = 0; i < attributeLength; i++) {
-    const name = names[i];
-    const type = types[i];
-    const glslType = getGlslType(type);
-    shaderBuilder.addStructField(metadataStructId, glslType, name);
+    const glslType = getGlslType(types[i]);
+    shaderBuilder.addStructField(metadataStructId, glslType, names[i]);
   }
 
-  // VoxelProperty structs
-  for (let i = 0; i < attributeLength; i++) {
-    const name = names[i];
-    const type = types[i];
-    const glslType = getGlslPartialDerivativeType(type);
-    const voxelPropertyStructId = `VoxelProperty_${name}`;
-    const voxelPropertyStructName = `VoxelProperty_${name}`;
-    shaderBuilder.addStruct(
-      voxelPropertyStructId,
-      voxelPropertyStructName,
-      ShaderDestination.FRAGMENT,
-    );
-    shaderBuilder.addStructField(
-      voxelPropertyStructId,
-      glslType,
-      "partialDerivativeLocal",
-    );
-    shaderBuilder.addStructField(
-      voxelPropertyStructId,
-      glslType,
-      "partialDerivativeWorld",
-    );
-    shaderBuilder.addStructField(
-      voxelPropertyStructId,
-      glslType,
-      "partialDerivativeView",
-    );
-    shaderBuilder.addStructField(
-      voxelPropertyStructId,
-      glslType,
-      "partialDerivativeValid",
-    );
-  }
+  // Attributes struct
+  const attributesStructId = "Attributes";
+  const attributesStructName = "Attributes";
+  const attributesFieldName = "attributes";
+  shaderBuilder.addStruct(
+    attributesStructId,
+    attributesStructName,
+    ShaderDestination.FRAGMENT,
+  );
+  shaderBuilder.addStructField(attributesStructId, "vec3", "positionEC");
+  shaderBuilder.addStructField(attributesStructId, "vec3", "normalEC");
 
   // Voxel struct
   const voxelStructId = "Voxel";
@@ -135,22 +105,12 @@ function processVoxelProperties(renderResources, primitive) {
     voxelStructName,
     ShaderDestination.FRAGMENT,
   );
-  for (let i = 0; i < attributeLength; i++) {
-    const name = names[i];
-    const voxelPropertyStructName = `VoxelProperty_${name}`;
-    shaderBuilder.addStructField(voxelStructId, voxelPropertyStructName, name);
-  }
-  shaderBuilder.addStructField(voxelStructId, "vec3", "positionEC");
-  shaderBuilder.addStructField(voxelStructId, "vec3", "positionUv");
-  shaderBuilder.addStructField(voxelStructId, "vec3", "positionShapeUv");
-  shaderBuilder.addStructField(voxelStructId, "vec3", "positionUvLocal");
   shaderBuilder.addStructField(voxelStructId, "vec3", "viewDirUv");
-  shaderBuilder.addStructField(voxelStructId, "vec3", "viewDirWorld");
-  shaderBuilder.addStructField(voxelStructId, "vec3", "surfaceNormal");
   shaderBuilder.addStructField(voxelStructId, "float", "travelDistance");
   shaderBuilder.addStructField(voxelStructId, "int", "stepCount");
   shaderBuilder.addStructField(voxelStructId, "int", "tileIndex");
   shaderBuilder.addStructField(voxelStructId, "int", "sampleIndex");
+  shaderBuilder.addStructField(voxelStructId, "float", "distanceToDepthBuffer");
 
   // FragmentInput struct
   const fragmentInputStructId = "FragmentInput";
@@ -160,11 +120,21 @@ function processVoxelProperties(renderResources, primitive) {
     fragmentInputStructName,
     ShaderDestination.FRAGMENT,
   );
+  shaderBuilder.addStructField(
+    fragmentInputStructId,
+    metadataStatisticsStructName,
+    metadataStatisticsFieldName,
+  );
   shaderBuilder.addStructField(
     fragmentInputStructId,
     metadataStructName,
     metadataFieldName,
   );
+  shaderBuilder.addStructField(
+    fragmentInputStructId,
+    attributesStructName,
+    attributesFieldName,
+  );
   shaderBuilder.addStructField(
     fragmentInputStructId,
     voxelStructName,
@@ -181,10 +151,8 @@ function processVoxelProperties(renderResources, primitive) {
     ShaderDestination.FRAGMENT,
   );
   for (let i = 0; i < attributeLength; i++) {
-    const name = names[i];
-    const type = types[i];
-    const glslType = getGlslType(type);
-    shaderBuilder.addStructField(propertiesStructId, glslType, name);
+    const glslType = getGlslType(types[i]);
+    shaderBuilder.addStructField(propertiesStructId, glslType, names[i]);
   }
 
   // Fragment shader functions
@@ -201,12 +169,9 @@ function processVoxelProperties(renderResources, primitive) {
       `${propertiesStructName} ${propertiesFieldName};`,
     ]);
     for (let i = 0; i < attributeLength; i++) {
-      const name = names[i];
-      const type = types[i];
-      const componentType = componentTypes[i];
-      const glslType = getGlslType(type, componentType);
+      const glslType = getGlslType(types[i], componentTypes[i]);
       shaderBuilder.addFunctionLines(functionId, [
-        `${propertiesFieldName}.${name} = ${glslType}(0.0);`,
+        `${propertiesFieldName}.${names[i]} = ${glslType}(0.0);`,
       ]);
     }
     shaderBuilder.addFunctionLines(functionId, [
@@ -248,9 +213,8 @@ function processVoxelProperties(renderResources, primitive) {
       `${propertiesStructName} scaledProperties = ${propertiesFieldName};`,
     ]);
     for (let i = 0; i < attributeLength; i++) {
-      const name = names[i];
       shaderBuilder.addFunctionLines(functionId, [
-        `scaledProperties.${name} *= scale;`,
+        `scaledProperties.${names[i]} *= scale;`,
       ]);
     }
     shaderBuilder.addFunctionLines(functionId, [`return scaledProperties;`]);
@@ -299,7 +263,7 @@ function processVoxelProperties(renderResources, primitive) {
     const functionId = "setStatistics";
     shaderBuilder.addFunction(
       functionId,
-      `void setStatistics(inout ${statisticsStructName} ${statisticsFieldName})`,
+      `void setStatistics(inout ${metadataStatisticsStructName} ${metadataStatisticsFieldName})`,
       ShaderDestination.FRAGMENT,
     );
     for (let i = 0; i < attributeLength; i++) {
@@ -314,10 +278,10 @@ function processVoxelProperties(renderResources, primitive) {
           continue;
         }
         shaderBuilder.addFunctionLines(functionId, [
-          `${statisticsFieldName}.${name}.min${glslField} = ${getGlslNumberAsFloat(
+          `${metadataStatisticsFieldName}.${name}.min${glslField} = ${getGlslNumberAsFloat(
             minimumValue,
           )};`,
-          `${statisticsFieldName}.${name}.max${glslField} = ${getGlslNumberAsFloat(
+          `${metadataStatisticsFieldName}.${name}.max${glslField} = ${getGlslNumberAsFloat(
             maximumValue,
           )};`,
         ]);
@@ -337,12 +301,11 @@ function processVoxelProperties(renderResources, primitive) {
       `${propertiesStructName} ${propertiesFieldName};`,
     ]);
     for (let i = 0; i < attributeLength; i++) {
-      const name = names[i];
       const type = types[i];
       const componentType = componentTypes[i];
       const glslTextureSwizzle = getGlslTextureSwizzle(type, componentType);
       shaderBuilder.addFunctionLines(functionId, [
-        `properties.${name} = texture(u_megatextureTextures[${i}], texcoord)${glslTextureSwizzle};`,
+        `properties.${names[i]} = texture(u_megatextureTextures[${i}], texcoord)${glslTextureSwizzle};`,
       ]);
     }
     shaderBuilder.addFunctionLines(functionId, [
@@ -395,28 +358,6 @@ function getGlslTextureSwizzle(type) {
   }
 }
 
-/**
- * Gets the GLSL type of the partial derivative of {@link MetadataType}.
- *
- * @function
- *
- * @param {MetadataType} type The {@link MetadataType}.
- * @returns {string} The GLSL type.
- *
- * @private
- */
-function getGlslPartialDerivativeType(type) {
-  if (type === MetadataType.SCALAR) {
-    return "vec3";
-  } else if (type === MetadataType.VEC2) {
-    return "mat2";
-  } else if (type === MetadataType.VEC3) {
-    return "mat3";
-  } else if (type === MetadataType.VEC4) {
-    return "mat4";
-  }
-}
-
 /**
  * GLSL needs to have `.0` at the end of whole number floats or else it's
  * treated like an integer.

package/Source/Shaders/Builtin/Constants/passGaussianSplats.glsl

@@ -0,0 +1,9 @@
+/**
+ * The automatic GLSL constant for {@link Pass#GAUSSIAN_SPLATS}
+ *
+ * @name czm_passGaussianSplats
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passGaussianSplats = 10.0;

package/Source/Shaders/Builtin/Constants/passGaussianSplats.js

@@ -0,0 +1,11 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * The automatic GLSL constant for {@link Pass#GAUSSIAN_SPLATS}\n\
+ *\n\
+ * @name czm_passGaussianSplats\n\
+ * @glslConstant\n\
+ *\n\
+ * @see czm_pass\n\
+ */\n\
+const float czm_passGaussianSplats = 10.0;\n\
+";

package/Source/Shaders/Builtin/Constants/passOverlay.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passOverlay = 10.0;
+const float czm_passOverlay = 11.0;

package/Source/Shaders/Builtin/Constants/passOverlay.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passOverlay = 10.0;\n\
+const float czm_passOverlay = 11.0;\n\
 ";

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -17,6 +17,7 @@ import czm_passCesium3DTileClassificationIgnoreShow from './Constants/passCesium
 import czm_passClassification from './Constants/passClassification.js'
 import czm_passCompute from './Constants/passCompute.js'
 import czm_passEnvironment from './Constants/passEnvironment.js'
+import czm_passGaussianSplats from './Constants/passGaussianSplats.js'
 import czm_passGlobe from './Constants/passGlobe.js'
 import czm_passOpaque from './Constants/passOpaque.js'
 import czm_passOverlay from './Constants/passOverlay.js'
@@ -155,6 +156,7 @@ export default {
     czm_passClassification : czm_passClassification,
     czm_passCompute : czm_passCompute,
     czm_passEnvironment : czm_passEnvironment,
+    czm_passGaussianSplats : czm_passGaussianSplats,
     czm_passGlobe : czm_passGlobe,
     czm_passOpaque : czm_passOpaque,
     czm_passOverlay : czm_passOverlay,

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

@@ -76,7 +76,6 @@ vec4 czm_screenToEyeCoordinates(vec2 screenCoordinateXY, float depthOrLogDepth)
     vec4 screenCoord = vec4(screenCoordinateXY, far * (1.0 - near / depthFromCamera) / (far - near), 1.0);
     vec4 eyeCoordinate = czm_screenToEyeCoordinates(screenCoord);
     eyeCoordinate.w = 1.0 / depthFromCamera; // Better precision
-    return eyeCoordinate;
 #else
     vec4 screenCoord = vec4(screenCoordinateXY, depthOrLogDepth, 1.0);
     vec4 eyeCoordinate = czm_screenToEyeCoordinates(screenCoord);

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

@@ -77,7 +77,6 @@ vec4 czm_screenToEyeCoordinates(vec2 screenCoordinateXY, float depthOrLogDepth)\
     vec4 screenCoord = vec4(screenCoordinateXY, far * (1.0 - near / depthFromCamera) / (far - near), 1.0);\n\
     vec4 eyeCoordinate = czm_screenToEyeCoordinates(screenCoord);\n\
     eyeCoordinate.w = 1.0 / depthFromCamera; // Better precision\n\
-    return eyeCoordinate;\n\
 #else\n\
     vec4 screenCoord = vec4(screenCoordinateXY, depthOrLogDepth, 1.0);\n\
     vec4 eyeCoordinate = czm_screenToEyeCoordinates(screenCoord);\n\

package/Source/Shaders/GlobeFS.glsl

@@ -87,25 +87,47 @@ flat in int v_regionIndex;
 uniform float u_minimumBrightness;
 #endif
 
+// Based on colorCorrect
+// The colorCorrect flag can only be true when tileProvider.hue/saturation/brightnessShift 
+// are nonzero AND when (applyFog || showGroundAtmosphere) in the tile provider
+// - The tileProvider.hue/saturation/brightnessShift are just passed through
+//   from the Globe hue/saturation/brightness, like atmosphereBrightnessShift
+// - The applyFog depends on enableFog, and some tile distance from the viewer
+// - The showGroundAtmosphere is a flag that is passed through from the Globe,
+//   and is true by default when the ellipsoid is WGS84
 #ifdef COLOR_CORRECT
 uniform vec3 u_hsbShift; // Hue, saturation, brightness
 #endif
 
+// Based on highlightFillTile
+// This is set for terrain tiles when they are "fill" tiles, and
+// the terrainProvider.fillHighlightColor was set to a value with
+// nonzero alpha
 #ifdef HIGHLIGHT_FILL_TILE
 uniform vec4 u_fillHighlightColor;
 #endif
 
+// Based on translucent
+// This is set depending on the GlobeTranslucencyState
 #ifdef TRANSLUCENT
 uniform vec4 u_frontFaceAlphaByDistance;
 uniform vec4 u_backFaceAlphaByDistance;
 uniform vec4 u_translucencyRectangle;
 #endif
 
+// Based on showUndergroundColor
+// This is set when GlobeSurfaceTileProvider.isUndergroundVisible 
+// returns true, AND the tileProvider.undergroundColor had a value with 
+// nonzero alpha, and the tileProvider.undergroundColorAlphaByDistance
+// was in the right range
 #ifdef UNDERGROUND_COLOR
 uniform vec4 u_undergroundColor;
 uniform vec4 u_undergroundColorAlphaByDistance;
 #endif
 
+// Based on enableLighting && hasVertexNormals
+// The enableLighting flag is passed in directly from the Globe.
+// The hasVertexNormals flag is from the tileProvider
 #ifdef ENABLE_VERTEX_LIGHTING
 uniform float u_lambertDiffuseMultiplier;
 uniform float u_vertexShadowDarkness;

package/Source/Shaders/GlobeFS.js

@@ -88,25 +88,47 @@ flat in int v_regionIndex;\n\
 uniform float u_minimumBrightness;\n\
 #endif\n\
 \n\
+// Based on colorCorrect\n\
+// The colorCorrect flag can only be true when tileProvider.hue/saturation/brightnessShift \n\
+// are nonzero AND when (applyFog || showGroundAtmosphere) in the tile provider\n\
+// - The tileProvider.hue/saturation/brightnessShift are just passed through\n\
+//   from the Globe hue/saturation/brightness, like atmosphereBrightnessShift\n\
+// - The applyFog depends on enableFog, and some tile distance from the viewer\n\
+// - The showGroundAtmosphere is a flag that is passed through from the Globe,\n\
+//   and is true by default when the ellipsoid is WGS84\n\
 #ifdef COLOR_CORRECT\n\
 uniform vec3 u_hsbShift; // Hue, saturation, brightness\n\
 #endif\n\
 \n\
+// Based on highlightFillTile\n\
+// This is set for terrain tiles when they are \"fill\" tiles, and\n\
+// the terrainProvider.fillHighlightColor was set to a value with\n\
+// nonzero alpha\n\
 #ifdef HIGHLIGHT_FILL_TILE\n\
 uniform vec4 u_fillHighlightColor;\n\
 #endif\n\
 \n\
+// Based on translucent\n\
+// This is set depending on the GlobeTranslucencyState\n\
 #ifdef TRANSLUCENT\n\
 uniform vec4 u_frontFaceAlphaByDistance;\n\
 uniform vec4 u_backFaceAlphaByDistance;\n\
 uniform vec4 u_translucencyRectangle;\n\
 #endif\n\
 \n\
+// Based on showUndergroundColor\n\
+// This is set when GlobeSurfaceTileProvider.isUndergroundVisible \n\
+// returns true, AND the tileProvider.undergroundColor had a value with \n\
+// nonzero alpha, and the tileProvider.undergroundColorAlphaByDistance\n\
+// was in the right range\n\
 #ifdef UNDERGROUND_COLOR\n\
 uniform vec4 u_undergroundColor;\n\
 uniform vec4 u_undergroundColorAlphaByDistance;\n\
 #endif\n\
 \n\
+// Based on enableLighting && hasVertexNormals\n\
+// The enableLighting flag is passed in directly from the Globe.\n\
+// The hasVertexNormals flag is from the tileProvider\n\
 #ifdef ENABLE_VERTEX_LIGHTING\n\
 uniform float u_lambertDiffuseMultiplier;\n\
 uniform float u_vertexShadowDarkness;\n\

package/Source/Shaders/Model/MaterialStageFS.glsl

@@ -444,6 +444,10 @@ void materialStage(inout czm_modelMaterial material, ProcessedAttributes attribu
         baseColorWithAlpha = u_baseColorFactor;
     #endif
 
+    #ifdef HAS_IMAGERY
+    baseColorWithAlpha = blendBaseColorWithImagery(baseColorWithAlpha);
+    #endif // HAS_IMAGERY
+
     #ifdef HAS_POINT_CLOUD_COLOR_STYLE
         baseColorWithAlpha = v_pointCloudColor;
     #elif defined(HAS_COLOR_0)

package/Source/Shaders/Model/MaterialStageFS.js

@@ -444,6 +444,10 @@ void materialStage(inout czm_modelMaterial material, ProcessedAttributes attribu
     #elif defined(HAS_BASE_COLOR_FACTOR)\n\
         baseColorWithAlpha = u_baseColorFactor;\n\
     #endif\n\
+\n\
+    #ifdef HAS_IMAGERY\n\
+    baseColorWithAlpha = blendBaseColorWithImagery(baseColorWithAlpha);\n\
+    #endif // HAS_IMAGERY\n\
 \n\
     #ifdef HAS_POINT_CLOUD_COLOR_STYLE\n\
         baseColorWithAlpha = v_pointCloudColor;\n\