@cesium/engine 17.0.0 → 18.0.0

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/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\

package/Source/Shaders/Model/ModelVS.glsl

@@ -14,6 +14,10 @@ void main()
     ProcessedAttributes attributes;
     initializeAttributes(attributes);
 
+    #ifdef HAS_IMAGERY
+    initializeImageryAttributes();
+    #endif
+
     // Dequantize the quantized ones and add them to the
     // attributes struct.
     #ifdef USE_DEQUANTIZATION

package/Source/Shaders/Model/ModelVS.js

@@ -14,6 +14,10 @@ void main()\n\
     // attributes except quantized ones.\n\
     ProcessedAttributes attributes;\n\
     initializeAttributes(attributes);\n\
+\n\
+    #ifdef HAS_IMAGERY\n\
+    initializeImageryAttributes();\n\
+    #endif\n\
 \n\
     // Dequantize the quantized ones and add them to the\n\
     // attributes struct.\n\

package/Source/Shaders/Voxels/IntersectDepth.glsl

@@ -9,15 +9,22 @@ uniform mat4 u_transformPositionViewToUv;
 
 void intersectDepth(in vec2 screenCoord, in Ray ray, inout Intersections ix) {
     float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, screenCoord));
+    float entry;
+    float exit;
     if (logDepthOrDepth != 0.0) {
         // Calculate how far the ray must travel before it hits the depth buffer.
         vec4 eyeCoordinateDepth = czm_screenToEyeCoordinates(screenCoord, logDepthOrDepth);
         eyeCoordinateDepth /= eyeCoordinateDepth.w;
         vec3 depthPositionUv = vec3(u_transformPositionViewToUv * eyeCoordinateDepth);
-        float t = dot(depthPositionUv - ray.pos, ray.dir);
-        setIntersectionPair(ix, DEPTH_INTERSECTION_INDEX, vec2(t, +INF_HIT));
+        entry = dot(depthPositionUv - ray.pos, ray.dir);
+        exit = +INF_HIT;
     } else {
         // There's no depth at this location.
-        setIntersectionPair(ix, DEPTH_INTERSECTION_INDEX, vec2(NO_HIT));
+        entry = NO_HIT;
+        exit = NO_HIT;
     }
+    ix.distanceToDepthBuffer = entry;
+#if defined(DEPTH_TEST)
+    setIntersectionPair(ix, DEPTH_INTERSECTION_INDEX, vec2(entry, exit));
+#endif
 }

package/Source/Shaders/Voxels/IntersectDepth.js

@@ -10,16 +10,23 @@ uniform mat4 u_transformPositionViewToUv;\n\
 \n\
 void intersectDepth(in vec2 screenCoord, in Ray ray, inout Intersections ix) {\n\
     float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, screenCoord));\n\
+    float entry;\n\
+    float exit;\n\
     if (logDepthOrDepth != 0.0) {\n\
         // Calculate how far the ray must travel before it hits the depth buffer.\n\
         vec4 eyeCoordinateDepth = czm_screenToEyeCoordinates(screenCoord, logDepthOrDepth);\n\
         eyeCoordinateDepth /= eyeCoordinateDepth.w;\n\
         vec3 depthPositionUv = vec3(u_transformPositionViewToUv * eyeCoordinateDepth);\n\
-        float t = dot(depthPositionUv - ray.pos, ray.dir);\n\
-        setIntersectionPair(ix, DEPTH_INTERSECTION_INDEX, vec2(t, +INF_HIT));\n\
+        entry = dot(depthPositionUv - ray.pos, ray.dir);\n\
+        exit = +INF_HIT;\n\
     } else {\n\
         // There's no depth at this location.\n\
-        setIntersectionPair(ix, DEPTH_INTERSECTION_INDEX, vec2(NO_HIT));\n\
+        entry = NO_HIT;\n\
+        exit = NO_HIT;\n\
     }\n\
+    ix.distanceToDepthBuffer = entry;\n\
+#if defined(DEPTH_TEST)\n\
+    setIntersectionPair(ix, DEPTH_INTERSECTION_INDEX, vec2(entry, exit));\n\
+#endif\n\
 }\n\
 ";

package/Source/Shaders/Voxels/Intersection.glsl

@@ -28,9 +28,7 @@ RayShapeIntersection intersectScene(in vec2 screenCoord, in Ray ray, out Interse
     #endif
 
     // Depth
-    #if defined(DEPTH_TEST)
-        intersectDepth(screenCoord, ray, ix);
-    #endif
+    intersectDepth(screenCoord, ray, ix);
 
     // Find the first intersection that's in front of the ray
     #if (INTERSECTION_COUNT > 1)

package/Source/Shaders/Voxels/Intersection.js

@@ -29,9 +29,7 @@ RayShapeIntersection intersectScene(in vec2 screenCoord, in Ray ray, out Interse
     #endif\n\
 \n\
     // Depth\n\
-    #if defined(DEPTH_TEST)\n\
-        intersectDepth(screenCoord, ray, ix);\n\
-    #endif\n\
+    intersectDepth(screenCoord, ray, ix);\n\
 \n\
     // Find the first intersection that's in front of the ray\n\
     #if (INTERSECTION_COUNT > 1)\n\

package/Source/Shaders/Voxels/IntersectionUtils.glsl

@@ -56,6 +56,7 @@ struct Intersections {
     // INTERSECTION_COUNT is the number of ray-*shape* (volume) intersections,
     // so we need twice as many to track ray-*surface* intersections
     vec4 intersections[INTERSECTION_COUNT * 2];
+    float distanceToDepthBuffer;
 
     #if (INTERSECTION_COUNT > 1)
         // Maintain state for future nextIntersection calls

package/Source/Shaders/Voxels/IntersectionUtils.js

@@ -57,6 +57,7 @@ struct Intersections {\n\
     // INTERSECTION_COUNT is the number of ray-*shape* (volume) intersections,\n\
     // so we need twice as many to track ray-*surface* intersections\n\
     vec4 intersections[INTERSECTION_COUNT * 2];\n\
+    float distanceToDepthBuffer;\n\
 \n\
     #if (INTERSECTION_COUNT > 1)\n\
         // Maintain state for future nextIntersection calls\n\

package/Source/Shaders/Voxels/VoxelFS.glsl

@@ -15,8 +15,10 @@
     #define ALPHA_ACCUM_MAX 0.98 // Must be > 0.0 and <= 1.0
 #endif
 
+uniform mat4 u_transformPositionUvToView;
 uniform mat3 u_transformDirectionViewToLocal;
 uniform vec3 u_cameraPositionUv;
+uniform vec3 u_cameraDirectionUv;
 uniform float u_stepSize;
 
 #if defined(PICKING)
@@ -111,26 +113,38 @@ int getSampleIndex(in SampleData sampleData) {
     return sampleIndex.x + u_inputDimensions.x * (sampleIndex.y + u_inputDimensions.y * sampleIndex.z);
 }
 
-void main()
-{
-    vec4 fragCoord = gl_FragCoord;
-    vec2 screenCoord = (fragCoord.xy - czm_viewport.xy) / czm_viewport.zw; // [0,1]
-    vec3 eyeDirection = normalize(czm_windowToEyeCoordinates(fragCoord).xyz);
-    vec3 viewDirWorld = normalize(czm_inverseViewRotation * eyeDirection); // normalize again just in case
-    vec3 viewDirUv = normalize(u_transformDirectionViewToLocal * eyeDirection); // normalize again just in case
-    vec3 viewPosUv = u_cameraPositionUv;
+/**
+ * Compute the view ray at the current fragment, in the local UV coordinates of the shape.
+ */
+Ray getViewRayUv() {
+    vec4 eyeCoordinates = czm_windowToEyeCoordinates(gl_FragCoord);
+    vec3 viewDirUv;
+    vec3 viewPosUv;
+    if (czm_orthographicIn3D == 1.0) {
+        eyeCoordinates.z = 0.0;
+        viewPosUv = (u_transformPositionViewToUv * eyeCoordinates).xyz;
+        viewDirUv = normalize(u_cameraDirectionUv);
+    } else {
+        viewPosUv = u_cameraPositionUv;
+        viewDirUv = normalize(u_transformDirectionViewToLocal * eyeCoordinates.xyz);
+    }
     #if defined(SHAPE_ELLIPSOID)
         // viewDirUv has been scaled to a space where the ellipsoid is a sphere.
         // Undo this scaling to get the raw direction.
         vec3 rawDir = viewDirUv * u_ellipsoidRadiiUv;
-        Ray viewRayUv = Ray(viewPosUv, viewDirUv, rawDir);
+        return Ray(viewPosUv, viewDirUv, rawDir);
     #else
-        Ray viewRayUv = Ray(viewPosUv, viewDirUv, viewDirUv);
+        return Ray(viewPosUv, viewDirUv, viewDirUv);
     #endif
+}
+
+void main()
+{
+    Ray viewRayUv = getViewRayUv();
 
     Intersections ix;
+    vec2 screenCoord = (gl_FragCoord.xy - czm_viewport.xy) / czm_viewport.zw; // [0,1]
     RayShapeIntersection shapeIntersection = intersectScene(screenCoord, viewRayUv, ix);
-
     // Exit early if the scene was completely missed.
     if (shapeIntersection.entry.w == NO_HIT) {
         discard;
@@ -138,7 +152,7 @@ void main()
 
     float currentT = shapeIntersection.entry.w;
     float endT = shapeIntersection.exit.w;
-    vec3 positionUv = viewPosUv + currentT * viewDirUv;
+    vec3 positionUv = viewRayUv.pos + currentT * viewRayUv.dir;
     PointJacobianT pointJacobian = convertUvToShapeUvSpaceDerivative(positionUv);
 
     // Traverse the tree from the start position
@@ -150,14 +164,15 @@ void main()
     #if defined(JITTER)
         float noise = hash(screenCoord); // [0,1]
         currentT += noise * step.w;
-        positionUv += noise * step.w * viewDirUv;
+        positionUv += noise * step.w * viewRayUv.dir;
     #endif
 
     FragmentInput fragmentInput;
     #if defined(STATISTICS)
-        setStatistics(fragmentInput.metadata.statistics);
+        setStatistics(fragmentInput.metadataStatistics);
     #endif
 
+    czm_modelMaterial materialOutput;
     vec4 colorAccum = vec4(0.0);
 
     for (int stepCount = 0; stepCount < STEP_COUNT_MAX; ++stepCount) {
@@ -166,19 +181,19 @@ void main()
 
         // Prepare the custom shader inputs
         copyPropertiesToMetadata(properties, fragmentInput.metadata);
-        fragmentInput.voxel.positionUv = positionUv;
-        fragmentInput.voxel.positionShapeUv = pointJacobian.point;
-        fragmentInput.voxel.positionUvLocal = sampleDatas[0].tileUv;
-        fragmentInput.voxel.viewDirUv = viewDirUv;
-        fragmentInput.voxel.viewDirWorld = viewDirWorld;
-        fragmentInput.voxel.surfaceNormal = step.xyz;
+
+        fragmentInput.attributes.positionEC = vec3(u_transformPositionUvToView * vec4(positionUv, 1.0));
+        fragmentInput.attributes.normalEC = normalize(czm_normal * step.xyz);
+
+        fragmentInput.voxel.viewDirUv = viewRayUv.dir;
+
         fragmentInput.voxel.travelDistance = step.w;
         fragmentInput.voxel.stepCount = stepCount;
         fragmentInput.voxel.tileIndex = sampleDatas[0].megatextureIndex;
         fragmentInput.voxel.sampleIndex = getSampleIndex(sampleDatas[0]);
+        fragmentInput.voxel.distanceToDepthBuffer = ix.distanceToDepthBuffer - currentT;
 
         // Run the custom shader
-        czm_modelMaterial materialOutput;
         fragmentMain(fragmentInput, materialOutput);
 
         // Sanitize the custom shader output
@@ -203,8 +218,6 @@ void main()
 
         // Keep raymarching
         currentT += step.w;
-        positionUv = viewPosUv + currentT * viewDirUv;
-
         // Check if there's more intersections.
         if (currentT > endT) {
             #if (INTERSECTION_COUNT == 1)
@@ -217,10 +230,10 @@ void main()
                     // Found another intersection. Resume raymarching there
                     currentT = shapeIntersection.entry.w;
                     endT = shapeIntersection.exit.w;
-                    positionUv = viewPosUv + currentT * viewDirUv;
                 }
             #endif
         }
+        positionUv = viewRayUv.pos + currentT * viewRayUv.dir;
 
         // Traverse the tree from the current ray position.
         // This is similar to traverseOctreeFromBeginning but is faster when the ray is in the same tile as the previous step.