@cesium/engine 17.0.0 → 18.0.1-splats.0

package/Source/Shaders/Model/ModelFS.glsl

@@ -1,5 +1,6 @@
 
 precision highp float;
+
 czm_modelMaterial defaultModelMaterial()
 {
     czm_modelMaterial material;
@@ -86,7 +87,7 @@ void main()
 
     // When not picking metadata END
     //========================================================================
-    #else 
+    #else
     //========================================================================
     // When picking metadata START
 
@@ -124,3 +125,4 @@ void main()
 
     out_FragColor = color;
 }
+

package/Source/Shaders/Model/ModelFS.js

@@ -1,6 +1,7 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "\n\
 precision highp float;\n\
+\n\
 czm_modelMaterial defaultModelMaterial()\n\
 {\n\
     czm_modelMaterial material;\n\
@@ -87,7 +88,7 @@ void main()\n\
 \n\
     // When not picking metadata END\n\
     //========================================================================\n\
-    #else \n\
+    #else\n\
     //========================================================================\n\
     // When picking metadata START\n\
 \n\
@@ -125,4 +126,5 @@ void main()\n\
 \n\
     out_FragColor = color;\n\
 }\n\
+\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
@@ -141,7 +145,7 @@ void main()
         #else
         gl_PointSize = 1.0;
         #endif
-
+        
         gl_PointSize *= show;
     #endif
 

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\
@@ -142,7 +146,7 @@ void main()\n\
         #else\n\
         gl_PointSize = 1.0;\n\
         #endif\n\
-\n\
+        \n\
         gl_PointSize *= show;\n\
     #endif\n\
 \n\

package/Source/Shaders/Model/PointCloudStylingStageVS.glsl

@@ -42,4 +42,4 @@ float pointCloudBackFaceCullingStage() {
   return 1.0;
   #endif
 }
-#endif
+#endif

package/Source/Shaders/Model/PointCloudStylingStageVS.js

@@ -43,4 +43,5 @@ float pointCloudBackFaceCullingStage() {\n\
   return 1.0;\n\
   #endif\n\
 }\n\
-#endif";
+#endif\n\
+";

package/Source/Shaders/PrimitiveGaussianSplatFS.glsl

@@ -0,0 +1,18 @@
+//
+// Fragment shader for Gaussian splats.
+// Renders a Gaussian splat within a quad, discarding fragments outside the unit circle.
+// Applies an approximate Gaussian falloff based on distance from the center and outputs
+// a color modulated by the alpha and Gaussian weight.
+//
+void main() {
+    if (v_splitDirection < 0.0 && gl_FragCoord.x > czm_splitPosition) discard;
+    if (v_splitDirection > 0.0 && gl_FragCoord.x < czm_splitPosition) discard;
+
+    mediump float A = dot(v_vertPos, v_vertPos);
+    if(A > 1.0) {
+        discard;
+    }
+    mediump float scale = 4.0;
+    mediump float B = exp(-A * scale) * (v_splatColor.a);
+    out_FragColor = vec4(v_splatColor.rgb * B, B);
+}

package/Source/Shaders/PrimitiveGaussianSplatFS.js

@@ -0,0 +1,20 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "//\n\
+// Fragment shader for Gaussian splats.\n\
+// Renders a Gaussian splat within a quad, discarding fragments outside the unit circle.\n\
+// Applies an approximate Gaussian falloff based on distance from the center and outputs\n\
+// a color modulated by the alpha and Gaussian weight.\n\
+//\n\
+void main() {\n\
+    if (v_splitDirection < 0.0 && gl_FragCoord.x > czm_splitPosition) discard;\n\
+    if (v_splitDirection > 0.0 && gl_FragCoord.x < czm_splitPosition) discard;\n\
+\n\
+    mediump float A = dot(v_vertPos, v_vertPos);\n\
+    if(A > 1.0) {\n\
+        discard;\n\
+    }\n\
+    mediump float scale = 4.0;\n\
+    mediump float B = exp(-A * scale) * (v_splatColor.a);\n\
+    out_FragColor = vec4(v_splatColor.rgb * B, B);\n\
+}\n\
+";

package/Source/Shaders/PrimitiveGaussianSplatVS.glsl

@@ -0,0 +1,108 @@
+//
+// Vertex shader for Gaussian splats.
+
+// The splats are rendered as quads in view space. Splat attributes are loaded from a texture with precomputed 3D covariance.
+
+// Passes local quad coordinates and color to the fragment shader for Gaussian evaluation. 
+//
+// Discards splats outside the view frustum or with negligible screen size.
+//
+
+// Transforms and projects splat covariance into screen space and extracts the major and minor axes of the Gaussian ellipsoid
+// which is used to calculate the vertex position in clip space.
+vec4 calcCovVectors(vec3 viewPos, mat3 Vrk) {
+    vec4 t = vec4(viewPos, 1.0);
+    float focal = czm_viewport.z * czm_projection[0][0];
+
+    float J1 = focal / t.z;
+    vec2 J2 = -J1 / t.z * t.xy;
+    mat3 J = mat3(
+        J1, 0.0, J2.x,
+        0.0, J1, J2.y,
+        0.0, 0.0, 0.0
+    );
+
+    //We need to take our view and remove the scale component
+    //quantized models can have a scaled matrix which will throw our splat size off
+    mat3 R = mat3(czm_modelView);
+    vec3 scale;
+    scale.x = length(R[0].xyz);
+    scale.y = length(R[1].xyz);
+    scale.z = length(R[2].xyz);
+
+    mat3 Rs = mat3(
+    R[0].xyz / scale.x,
+    R[1].xyz / scale.y,
+    R[2].xyz / scale.z
+    );
+
+    //transform our covariance into view space
+    //ensures orientation is correct
+    mat3 Vrk_view = Rs * Vrk * transpose(Rs);
+
+    mat3 cov = transpose(J) * Vrk_view * J;
+
+    float diagonal1 = cov[0][0] + .3;
+    float offDiagonal = cov[0][1];
+    float diagonal2 = cov[1][1] + .3;
+
+    float mid = 0.5 * (diagonal1 + diagonal2);
+    float radius = length(vec2((diagonal1 - diagonal2) * 0.5, offDiagonal));
+    float lambda1 = mid + radius;
+    float lambda2 = max(mid - radius, 0.1);
+
+    vec2 diagonalVector = normalize(vec2(offDiagonal, lambda1 - diagonal1));
+
+    return vec4(
+        min(sqrt(2.0 * lambda1), 1024.0) * diagonalVector,
+        min(sqrt(2.0 * lambda2), 1024.0) * vec2(diagonalVector.y, -diagonalVector.x)
+    );
+}
+
+highp vec4 discardVec = vec4(0.0, 0.0, 2.0, 1.0);
+
+void main() {
+    uint texIdx = uint(a_splatIndex);
+    ivec2 posCoord = ivec2((texIdx & 0x3ffu) << 1, texIdx >> 10);
+    vec4 splatPosition = vec4( uintBitsToFloat(uvec4(texelFetch(u_splatAttributeTexture, posCoord, 0))) );
+
+    vec4 splatViewPos = czm_modelView * vec4(splatPosition.xyz, 1.0);
+    vec4 clipPosition = czm_projection * splatViewPos;
+
+    float clip = 1.2 * clipPosition.w;
+    if (clipPosition.z < -clip || clipPosition.x < -clip || clipPosition.x > clip ||
+        clipPosition.y < -clip || clipPosition.y > clip) {
+        gl_Position = vec4(0.0, 0.0, 2.0, 1.0);
+        return;
+    }
+
+    ivec2 covCoord = ivec2(((texIdx & 0x3ffu) << 1) | 1u, texIdx >> 10);
+    uvec4 covariance = uvec4(texelFetch(u_splatAttributeTexture, covCoord, 0));
+
+    gl_Position = clipPosition;
+
+    vec2 u1 = unpackHalf2x16(covariance.x) ;
+    vec2 u2 = unpackHalf2x16(covariance.y);
+    vec2 u3 = unpackHalf2x16(covariance.z);
+    mat3 Vrk = mat3(u1.x, u1.y, u2.x, u1.y, u2.y, u3.x, u2.x, u3.x, u3.y);
+
+    //we can still apply scale here even though cov3d is pre-computed
+    Vrk *= u_splatScale;
+
+    vec4 covVectors = calcCovVectors(splatViewPos.xyz, Vrk);
+
+    if (dot(covVectors.xy, covVectors.xy) < 4.0 && dot(covVectors.zw, covVectors.zw) < 4.0) {
+        gl_Position = discardVec;
+        return;
+    }
+
+    vec2 corner = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2) - 1.;
+
+    gl_Position += vec4((corner.x * covVectors.xy + corner.y * covVectors.zw) / czm_viewport.zw * gl_Position.w, 0, 0);
+    gl_Position.z = clamp(gl_Position.z, -abs(gl_Position.w), abs(gl_Position.w));
+
+    v_vertPos = corner ;
+    v_splatColor = vec4(covariance.w & 0xffu, (covariance.w >> 8) & 0xffu, (covariance.w >> 16) & 0xffu, (covariance.w >> 24) & 0xffu) / 255.0;
+
+    v_splitDirection = u_splitDirection;
+}

package/Source/Shaders/PrimitiveGaussianSplatVS.js

@@ -0,0 +1,109 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "//\n\
+// Vertex shader for Gaussian splats.\n\
+\n\
+// The splats are rendered as quads in view space. Splat attributes are loaded from a texture with precomputed 3D covariance.\n\
+\n\
+// Passes local quad coordinates and color to the fragment shader for Gaussian evaluation. \n\
+//\n\
+// Discards splats outside the view frustum or with negligible screen size.\n\
+//\n\
+\n\
+// Transforms and projects splat covariance into screen space and extracts the major and minor axes of the Gaussian ellipsoid\n\
+// which is used to calculate the vertex position in clip space.\n\
+vec4 calcCovVectors(vec3 viewPos, mat3 Vrk) {\n\
+    vec4 t = vec4(viewPos, 1.0);\n\
+    float focal = czm_viewport.z * czm_projection[0][0];\n\
+\n\
+    float J1 = focal / t.z;\n\
+    vec2 J2 = -J1 / t.z * t.xy;\n\
+    mat3 J = mat3(\n\
+        J1, 0.0, J2.x,\n\
+        0.0, J1, J2.y,\n\
+        0.0, 0.0, 0.0\n\
+    );\n\
+\n\
+    //We need to take our view and remove the scale component\n\
+    //quantized models can have a scaled matrix which will throw our splat size off\n\
+    mat3 R = mat3(czm_modelView);\n\
+    vec3 scale;\n\
+    scale.x = length(R[0].xyz);\n\
+    scale.y = length(R[1].xyz);\n\
+    scale.z = length(R[2].xyz);\n\
+\n\
+    mat3 Rs = mat3(\n\
+    R[0].xyz / scale.x,\n\
+    R[1].xyz / scale.y,\n\
+    R[2].xyz / scale.z\n\
+    );\n\
+\n\
+    //transform our covariance into view space\n\
+    //ensures orientation is correct\n\
+    mat3 Vrk_view = Rs * Vrk * transpose(Rs);\n\
+\n\
+    mat3 cov = transpose(J) * Vrk_view * J;\n\
+\n\
+    float diagonal1 = cov[0][0] + .3;\n\
+    float offDiagonal = cov[0][1];\n\
+    float diagonal2 = cov[1][1] + .3;\n\
+\n\
+    float mid = 0.5 * (diagonal1 + diagonal2);\n\
+    float radius = length(vec2((diagonal1 - diagonal2) * 0.5, offDiagonal));\n\
+    float lambda1 = mid + radius;\n\
+    float lambda2 = max(mid - radius, 0.1);\n\
+\n\
+    vec2 diagonalVector = normalize(vec2(offDiagonal, lambda1 - diagonal1));\n\
+\n\
+    return vec4(\n\
+        min(sqrt(2.0 * lambda1), 1024.0) * diagonalVector,\n\
+        min(sqrt(2.0 * lambda2), 1024.0) * vec2(diagonalVector.y, -diagonalVector.x)\n\
+    );\n\
+}\n\
+\n\
+highp vec4 discardVec = vec4(0.0, 0.0, 2.0, 1.0);\n\
+\n\
+void main() {\n\
+    uint texIdx = uint(a_splatIndex);\n\
+    ivec2 posCoord = ivec2((texIdx & 0x3ffu) << 1, texIdx >> 10);\n\
+    vec4 splatPosition = vec4( uintBitsToFloat(uvec4(texelFetch(u_splatAttributeTexture, posCoord, 0))) );\n\
+\n\
+    vec4 splatViewPos = czm_modelView * vec4(splatPosition.xyz, 1.0);\n\
+    vec4 clipPosition = czm_projection * splatViewPos;\n\
+\n\
+    float clip = 1.2 * clipPosition.w;\n\
+    if (clipPosition.z < -clip || clipPosition.x < -clip || clipPosition.x > clip ||\n\
+        clipPosition.y < -clip || clipPosition.y > clip) {\n\
+        gl_Position = vec4(0.0, 0.0, 2.0, 1.0);\n\
+        return;\n\
+    }\n\
+\n\
+    ivec2 covCoord = ivec2(((texIdx & 0x3ffu) << 1) | 1u, texIdx >> 10);\n\
+    uvec4 covariance = uvec4(texelFetch(u_splatAttributeTexture, covCoord, 0));\n\
+\n\
+    gl_Position = clipPosition;\n\
+\n\
+    vec2 u1 = unpackHalf2x16(covariance.x) ;\n\
+    vec2 u2 = unpackHalf2x16(covariance.y);\n\
+    vec2 u3 = unpackHalf2x16(covariance.z);\n\
+    mat3 Vrk = mat3(u1.x, u1.y, u2.x, u1.y, u2.y, u3.x, u2.x, u3.x, u3.y);\n\
+\n\
+    //we can still apply scale here even though cov3d is pre-computed\n\
+    Vrk *= u_splatScale;\n\
+\n\
+    vec4 covVectors = calcCovVectors(splatViewPos.xyz, Vrk);\n\
+\n\
+    if (dot(covVectors.xy, covVectors.xy) < 4.0 && dot(covVectors.zw, covVectors.zw) < 4.0) {\n\
+        gl_Position = discardVec;\n\
+        return;\n\
+    }\n\
+\n\
+    vec2 corner = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2) - 1.;\n\
+\n\
+    gl_Position += vec4((corner.x * covVectors.xy + corner.y * covVectors.zw) / czm_viewport.zw * gl_Position.w, 0, 0);\n\
+    gl_Position.z = clamp(gl_Position.z, -abs(gl_Position.w), abs(gl_Position.w));\n\
+\n\
+    v_vertPos = corner ;\n\
+    v_splatColor = vec4(covariance.w & 0xffu, (covariance.w >> 8) & 0xffu, (covariance.w >> 16) & 0xffu, (covariance.w >> 24) & 0xffu) / 255.0;\n\
+\n\
+    v_splitDirection = u_splitDirection;\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.