@cesium/engine 12.0.1 → 13.0.0

package/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.glsl

@@ -5,16 +5,21 @@ uniform sampler2D depthTexture;
 uniform float intensity;
 uniform float bias;
 uniform float lengthCap;
-uniform float stepSize;
-uniform float frustumLength;
+uniform int stepCount;
+uniform int directionCount;
 
-vec3 pixelToEye(vec2 screenCoordinate)
+vec4 pixelToEye(vec2 screenCoordinate)
 {
     vec2 uv = screenCoordinate / czm_viewport.zw;
     float depth = czm_readDepth(depthTexture, uv);
     vec2 xy = 2.0 * uv - vec2(1.0);
     vec4 posEC = czm_inverseProjection * vec4(xy, depth, 1.0);
-    return posEC.xyz / posEC.w;
+    posEC = posEC / posEC.w;
+    // Avoid numerical error at far plane
+    if (depth >= 1.0) {
+        posEC.z = czm_currentFrustum.y;
+    }
+    return posEC;
 }
 
 // Reconstruct surface normal in eye coordinates, avoiding edges
@@ -22,10 +27,10 @@ vec3 getNormalXEdge(vec3 positionEC)
 {
     // Find the 3D surface positions at adjacent screen pixels
     vec2 centerCoord = gl_FragCoord.xy;
-    vec3 positionLeft = pixelToEye(centerCoord + vec2(-1.0, 0.0));
-    vec3 positionRight = pixelToEye(centerCoord + vec2(1.0, 0.0));
-    vec3 positionUp = pixelToEye(centerCoord + vec2(0.0, 1.0));
-    vec3 positionDown = pixelToEye(centerCoord + vec2(0.0, -1.0));
+    vec3 positionLeft = pixelToEye(centerCoord + vec2(-1.0, 0.0)).xyz;
+    vec3 positionRight = pixelToEye(centerCoord + vec2(1.0, 0.0)).xyz;
+    vec3 positionUp = pixelToEye(centerCoord + vec2(0.0, 1.0)).xyz;
+    vec3 positionDown = pixelToEye(centerCoord + vec2(0.0, -1.0)).xyz;
 
     // Compute potential tangent vectors
     vec3 dx0 = positionEC - positionLeft;
@@ -40,22 +45,35 @@ vec3 getNormalXEdge(vec3 positionEC)
     return normalize(cross(dx, dy));
 }
 
+const float sqrtTwoPi = sqrt(czm_twoPi);
+
+float gaussian(float x, float standardDeviation) {
+    float argument = x / standardDeviation;
+    return exp(-0.5 * argument * argument) / (sqrtTwoPi * standardDeviation);
+}
+
 void main(void)
 {
-    vec3 positionEC = pixelToEye(gl_FragCoord.xy);
+    vec4 positionEC = pixelToEye(gl_FragCoord.xy);
 
-    if (positionEC.z > frustumLength)
+    // Exit if we are too close to the back of the frustum, where the depth value is invalid.
+    float maxValidDepth = czm_currentFrustum.y - lengthCap;
+    if (-positionEC.z > maxValidDepth)
     {
         out_FragColor = vec4(1.0);
         return;
     }
 
-    vec3 normalEC = getNormalXEdge(positionEC);
+    vec3 normalEC = getNormalXEdge(positionEC.xyz);
+    float gaussianVariance = lengthCap * sqrt(-positionEC.z);
+    // Choose a step length such that the marching stops just before 3 * variance.
+    float stepLength = 3.0 * gaussianVariance / (float(stepCount) + 1.0);
+    float metersPerPixel = czm_metersPerPixel(positionEC, 1.0);
+    // Minimum step is 1 pixel to avoid double sampling
+    float pixelsPerStep = max(stepLength / metersPerPixel, 1.0);
+    stepLength = pixelsPerStep * metersPerPixel;
 
-    float ao = 0.0;
-
-    const int ANGLE_STEPS = 4;
-    float angleStepScale = 1.0 / float(ANGLE_STEPS);
+    float angleStepScale = 1.0 / float(directionCount);
     float angleStep = angleStepScale * czm_twoPi;
     float cosStep = cos(angleStep);
     float sinStep = sin(angleStep);
@@ -67,48 +85,59 @@ void main(void)
     float randomVal = texture(randomTexture, randomTexCoord).x;
     vec2 sampleDirection = vec2(cos(angleStep * randomVal), sin(angleStep * randomVal));
 
+    float ao = 0.0;
     // Loop over sampling directions
-    for (int i = 0; i < ANGLE_STEPS; i++)
+#if __VERSION__ == 300
+    for (int i = 0; i < directionCount; i++)
+    {
+#else
+    for (int i = 0; i < 16; i++)
     {
+        if (i >= directionCount) {
+            break;
+        }
+#endif
         sampleDirection = rotateStep * sampleDirection;
 
         float localAO = 0.0;
-        vec2 radialStep = stepSize * sampleDirection;
+        vec2 radialStep = pixelsPerStep * sampleDirection;
 
-        for (int j = 0; j < 6; j++)
+#if __VERSION__ == 300
+        for (int j = 0; j < stepCount; j++)
+        {
+#else
+        for (int j = 0; j < 64; j++)
         {
+            if (j >= stepCount) {
+                break;
+            }
+#endif
             // Step along sampling direction, away from output pixel
-            vec2 newCoords = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);
+            vec2 samplePixel = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);
 
             // Exit if we stepped off the screen
-            if (clamp(newCoords, vec2(0.0), czm_viewport.zw) != newCoords)
-            {
+            if (clamp(samplePixel, vec2(0.0), czm_viewport.zw) != samplePixel) {
                 break;
             }
 
-            vec3 stepPositionEC = pixelToEye(newCoords);
-            vec3 stepVector = stepPositionEC - positionEC;
-            float stepLength = length(stepVector);
-
-            if (stepLength > lengthCap)
-            {
-                break;
-            }
+            // Compute step vector from output point to sampled point
+            vec4 samplePositionEC = pixelToEye(samplePixel);
+            vec3 stepVector = samplePositionEC.xyz - positionEC.xyz;
 
+            // Estimate the angle from the surface normal.
             float dotVal = clamp(dot(normalEC, normalize(stepVector)), 0.0, 1.0);
-            if (dotVal < bias)
-            {
-                dotVal = 0.0;
-            }
+            dotVal = czm_branchFreeTernary(dotVal > bias, dotVal, 0.0);
+            dotVal = czm_branchFreeTernary(-samplePositionEC.z <= maxValidDepth, dotVal, 0.0);
 
-            float weight = stepLength / lengthCap;
-            weight = 1.0 - weight * weight;
-            localAO = max(localAO, dotVal * weight);
+            // Weight contribution based on the distance from the output point
+            float sampleDistance = length(stepVector);
+            float weight = gaussian(sampleDistance, gaussianVariance);
+            localAO += weight * dotVal;
         }
         ao += localAO;
     }
 
-    ao *= angleStepScale;
+    ao *= angleStepScale * stepLength;
     ao = 1.0 - clamp(ao, 0.0, 1.0);
     ao = pow(ao, intensity);
     out_FragColor = vec4(vec3(ao), 1.0);

package/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.js

@@ -6,16 +6,21 @@ uniform sampler2D depthTexture;\n\
 uniform float intensity;\n\
 uniform float bias;\n\
 uniform float lengthCap;\n\
-uniform float stepSize;\n\
-uniform float frustumLength;\n\
+uniform int stepCount;\n\
+uniform int directionCount;\n\
 \n\
-vec3 pixelToEye(vec2 screenCoordinate)\n\
+vec4 pixelToEye(vec2 screenCoordinate)\n\
 {\n\
     vec2 uv = screenCoordinate / czm_viewport.zw;\n\
     float depth = czm_readDepth(depthTexture, uv);\n\
     vec2 xy = 2.0 * uv - vec2(1.0);\n\
     vec4 posEC = czm_inverseProjection * vec4(xy, depth, 1.0);\n\
-    return posEC.xyz / posEC.w;\n\
+    posEC = posEC / posEC.w;\n\
+    // Avoid numerical error at far plane\n\
+    if (depth >= 1.0) {\n\
+        posEC.z = czm_currentFrustum.y;\n\
+    }\n\
+    return posEC;\n\
 }\n\
 \n\
 // Reconstruct surface normal in eye coordinates, avoiding edges\n\
@@ -23,10 +28,10 @@ vec3 getNormalXEdge(vec3 positionEC)\n\
 {\n\
     // Find the 3D surface positions at adjacent screen pixels\n\
     vec2 centerCoord = gl_FragCoord.xy;\n\
-    vec3 positionLeft = pixelToEye(centerCoord + vec2(-1.0, 0.0));\n\
-    vec3 positionRight = pixelToEye(centerCoord + vec2(1.0, 0.0));\n\
-    vec3 positionUp = pixelToEye(centerCoord + vec2(0.0, 1.0));\n\
-    vec3 positionDown = pixelToEye(centerCoord + vec2(0.0, -1.0));\n\
+    vec3 positionLeft = pixelToEye(centerCoord + vec2(-1.0, 0.0)).xyz;\n\
+    vec3 positionRight = pixelToEye(centerCoord + vec2(1.0, 0.0)).xyz;\n\
+    vec3 positionUp = pixelToEye(centerCoord + vec2(0.0, 1.0)).xyz;\n\
+    vec3 positionDown = pixelToEye(centerCoord + vec2(0.0, -1.0)).xyz;\n\
 \n\
     // Compute potential tangent vectors\n\
     vec3 dx0 = positionEC - positionLeft;\n\
@@ -41,22 +46,35 @@ vec3 getNormalXEdge(vec3 positionEC)\n\
     return normalize(cross(dx, dy));\n\
 }\n\
 \n\
+const float sqrtTwoPi = sqrt(czm_twoPi);\n\
+\n\
+float gaussian(float x, float standardDeviation) {\n\
+    float argument = x / standardDeviation;\n\
+    return exp(-0.5 * argument * argument) / (sqrtTwoPi * standardDeviation);\n\
+}\n\
+\n\
 void main(void)\n\
 {\n\
-    vec3 positionEC = pixelToEye(gl_FragCoord.xy);\n\
+    vec4 positionEC = pixelToEye(gl_FragCoord.xy);\n\
 \n\
-    if (positionEC.z > frustumLength)\n\
+    // Exit if we are too close to the back of the frustum, where the depth value is invalid.\n\
+    float maxValidDepth = czm_currentFrustum.y - lengthCap;\n\
+    if (-positionEC.z > maxValidDepth)\n\
     {\n\
         out_FragColor = vec4(1.0);\n\
         return;\n\
     }\n\
 \n\
-    vec3 normalEC = getNormalXEdge(positionEC);\n\
+    vec3 normalEC = getNormalXEdge(positionEC.xyz);\n\
+    float gaussianVariance = lengthCap * sqrt(-positionEC.z);\n\
+    // Choose a step length such that the marching stops just before 3 * variance.\n\
+    float stepLength = 3.0 * gaussianVariance / (float(stepCount) + 1.0);\n\
+    float metersPerPixel = czm_metersPerPixel(positionEC, 1.0);\n\
+    // Minimum step is 1 pixel to avoid double sampling\n\
+    float pixelsPerStep = max(stepLength / metersPerPixel, 1.0);\n\
+    stepLength = pixelsPerStep * metersPerPixel;\n\
 \n\
-    float ao = 0.0;\n\
-\n\
-    const int ANGLE_STEPS = 4;\n\
-    float angleStepScale = 1.0 / float(ANGLE_STEPS);\n\
+    float angleStepScale = 1.0 / float(directionCount);\n\
     float angleStep = angleStepScale * czm_twoPi;\n\
     float cosStep = cos(angleStep);\n\
     float sinStep = sin(angleStep);\n\
@@ -68,48 +86,59 @@ void main(void)\n\
     float randomVal = texture(randomTexture, randomTexCoord).x;\n\
     vec2 sampleDirection = vec2(cos(angleStep * randomVal), sin(angleStep * randomVal));\n\
 \n\
+    float ao = 0.0;\n\
     // Loop over sampling directions\n\
-    for (int i = 0; i < ANGLE_STEPS; i++)\n\
+#if __VERSION__ == 300\n\
+    for (int i = 0; i < directionCount; i++)\n\
+    {\n\
+#else\n\
+    for (int i = 0; i < 16; i++)\n\
     {\n\
+        if (i >= directionCount) {\n\
+            break;\n\
+        }\n\
+#endif\n\
         sampleDirection = rotateStep * sampleDirection;\n\
 \n\
         float localAO = 0.0;\n\
-        vec2 radialStep = stepSize * sampleDirection;\n\
+        vec2 radialStep = pixelsPerStep * sampleDirection;\n\
 \n\
-        for (int j = 0; j < 6; j++)\n\
+#if __VERSION__ == 300\n\
+        for (int j = 0; j < stepCount; j++)\n\
+        {\n\
+#else\n\
+        for (int j = 0; j < 64; j++)\n\
         {\n\
+            if (j >= stepCount) {\n\
+                break;\n\
+            }\n\
+#endif\n\
             // Step along sampling direction, away from output pixel\n\
-            vec2 newCoords = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);\n\
+            vec2 samplePixel = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);\n\
 \n\
             // Exit if we stepped off the screen\n\
-            if (clamp(newCoords, vec2(0.0), czm_viewport.zw) != newCoords)\n\
-            {\n\
+            if (clamp(samplePixel, vec2(0.0), czm_viewport.zw) != samplePixel) {\n\
                 break;\n\
             }\n\
 \n\
-            vec3 stepPositionEC = pixelToEye(newCoords);\n\
-            vec3 stepVector = stepPositionEC - positionEC;\n\
-            float stepLength = length(stepVector);\n\
-\n\
-            if (stepLength > lengthCap)\n\
-            {\n\
-                break;\n\
-            }\n\
+            // Compute step vector from output point to sampled point\n\
+            vec4 samplePositionEC = pixelToEye(samplePixel);\n\
+            vec3 stepVector = samplePositionEC.xyz - positionEC.xyz;\n\
 \n\
+            // Estimate the angle from the surface normal.\n\
             float dotVal = clamp(dot(normalEC, normalize(stepVector)), 0.0, 1.0);\n\
-            if (dotVal < bias)\n\
-            {\n\
-                dotVal = 0.0;\n\
-            }\n\
+            dotVal = czm_branchFreeTernary(dotVal > bias, dotVal, 0.0);\n\
+            dotVal = czm_branchFreeTernary(-samplePositionEC.z <= maxValidDepth, dotVal, 0.0);\n\
 \n\
-            float weight = stepLength / lengthCap;\n\
-            weight = 1.0 - weight * weight;\n\
-            localAO = max(localAO, dotVal * weight);\n\
+            // Weight contribution based on the distance from the output point\n\
+            float sampleDistance = length(stepVector);\n\
+            float weight = gaussian(sampleDistance, gaussianVariance);\n\
+            localAO += weight * dotVal;\n\
         }\n\
         ao += localAO;\n\
     }\n\
 \n\
-    ao *= angleStepScale;\n\
+    ao *= angleStepScale * stepLength;\n\
     ao = 1.0 - clamp(ao, 0.0, 1.0);\n\
     ao = pow(ao, intensity);\n\
     out_FragColor = vec4(vec3(ao), 1.0);\n\