Log depth buffer

CHANGES.md

@@ -1,6 +1,15 @@
 Change Log
 ==========
 
+### 1.46 - 2018-05-01
+
+##### Breaking Changes :mega:
+* `Camera.distanceToBoundingSphere` now returns the signed distance to the bounding sphere. Positive values indicate that the bounding sphere is in the positive half-plane of the camera position and view direction while a negative value indicates it is in the negative half-plane.
+
+##### Additions :tada:
+* Added option `logDepthBuffer` to `Viewer`. With this option there is typically a single frustum using logarithmic depth rendered. This increases performance by issuing less draw calls to the GPU and helps to avoid artifacts on the connection of two frustums. [#5851](https://github.com/AnalyticalGraphicsInc/cesium/pull/5851)
+* Added `Math.log2` to compute the base 2 logarithm of a number.
+
 ### 1.44 - 2018-04-02
 
 ##### Breaking Changes :mega:

CONTRIBUTORS.md

@@ -73,6 +73,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to Cesiu
    * [Dave Whipps](https://github.com/dwhipps)
 * [Geoscan](https://www.geoscan.aero)
    * [Andrey Orlov](https://github.com/AndreyOrlov)
+   * [George Vinokhodov](https://github.com/Vineg)
 * [The Imagineers](https://www.theimagineers.com/)
    * [Heerco Grond](https://github.com/HeercoGrond)
 * [Camptocamp SA](https://www.camptocamp.com/)

Source/Core/Math.js

@@ -849,6 +849,18 @@ define([
      */
     CesiumMath.cbrt = defined(Math.cbrt) ? Math.cbrt : cbrt;
 
+    function log2(x) {
+        return Math.log(x) * Math.LOG2E;
+    }
+
+    /**
+     * Finds the base 2 logarithm of a number.
+     *
+     * @param {Number} number The number.
+     * @returns {Number} The result.
+     */
+    CesiumMath.log2 = defined(Math.log2) ? Math.log2 : log2;
+
     /**
      * @private
      */

Source/Core/OrthographicFrustum.js

@@ -259,7 +259,7 @@ define([
      * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
      */
     OrthographicFrustum.prototype.equals = function(other) {
-        if (!defined(other)) {
+        if (!defined(other) || !(other instanceof OrthographicFrustum)) {
             return false;
         }
 

Source/Core/OrthographicOffCenterFrustum.js

@@ -361,7 +361,7 @@ define([
      * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
      */
     OrthographicOffCenterFrustum.prototype.equals = function(other) {
-        return (defined(other) &&
+        return (defined(other) && other instanceof OrthographicOffCenterFrustum &&
                 this.right === other.right &&
                 this.left === other.left &&
                 this.top === other.top &&

Source/Core/PerspectiveFrustum.js

@@ -354,7 +354,7 @@ define([
      * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
      */
     PerspectiveFrustum.prototype.equals = function(other) {
-        if (!defined(other)) {
+        if (!defined(other) || !(other instanceof PerspectiveFrustum)) {
             return false;
         }
 

Source/Core/PerspectiveOffCenterFrustum.js

@@ -412,7 +412,7 @@ define([
      * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
      */
     PerspectiveOffCenterFrustum.prototype.equals = function(other) {
-        return (defined(other) &&
+        return (defined(other) && other instanceof PerspectiveOffCenterFrustum &&
                 this.right === other.right &&
                 this.left === other.left &&
                 this.top === other.top &&

Source/Renderer/AutomaticUniforms.js

@@ -1135,6 +1135,22 @@ define([
             }
         }),
 
+        /**
+         * The log of the current frustums far plane. Used for computing the log depth.
+         *
+         * @alias czm_logFarDistance
+         * @glslUniform
+         *
+         * @private
+         */
+        czm_logFarDistance : new AutomaticUniform({
+            size : 1,
+            datatype : WebGLConstants.FLOAT,
+            getValue : function(uniformState) {
+                return uniformState.logFarDistance;
+            }
+        }),
+
         /**
          * An automatic GLSL uniform representing the sun position in world coordinates.
          *

Source/Renderer/UniformState.js

@@ -61,6 +61,7 @@ define([
         this._entireFrustum = new Cartesian2();
         this._currentFrustum = new Cartesian2();
         this._frustumPlanes = new Cartesian4();
+        this._logFarDistance = undefined;
 
         this._frameState = undefined;
         this._temeToPseudoFixed = Matrix3.clone(Matrix4.IDENTITY);
@@ -641,6 +642,17 @@ define([
             }
         },
 
+        /**
+         * The log of the current frustum's far distance. Used to compute the log depth.
+         * @memberof UniformState.prototype
+         * @type {Number}
+         */
+        logFarDistance : {
+            get : function() {
+                return this._logFarDistance;
+            }
+        },
+
         /**
          * The the height (<code>x</code>) and the height squared (<code>y</code>)
          * in meters of the camera above the 2D world plane. This uniform is only valid
@@ -987,6 +999,8 @@ define([
         this._currentFrustum.x = frustum.near;
         this._currentFrustum.y = frustum.far;
 
+        this._logFarDistance = 2.0 / CesiumMath.log2(frustum.far + 1.0);
+
         if (defined(frustum._offCenterFrustum)) {
             frustum = frustum._offCenterFrustum;
         }

Source/Scene/Camera.js

@@ -2574,10 +2574,13 @@ define([
     var scratchProj = new Cartesian3();
 
     /**
-     * Return the distance from the camera to the front of the bounding sphere.
+     * Return the signed distance from the camera to the front of the bounding sphere.
+     * <p>
+     * Positive values indicate that the bounding sphere is in the positive half-plane of the camera position and view direction while a negative value indicates it is in the negative half-plane.
+     * </p>
      *
      * @param {BoundingSphere} boundingSphere The bounding sphere in world coordinates.
-     * @returns {Number} The distance to the bounding sphere.
+     * @returns {Number} The signed distance to the bounding sphere.
      */
     Camera.prototype.distanceToBoundingSphere = function(boundingSphere) {
         //>>includeStart('debug', pragmas.debug);
@@ -2587,8 +2590,10 @@ define([
         //>>includeEnd('debug');
 
         var toCenter = Cartesian3.subtract(this.positionWC, boundingSphere.center, scratchToCenter);
-        var proj = Cartesian3.multiplyByScalar(this.directionWC, Cartesian3.dot(toCenter, this.directionWC), scratchProj);
-        return Math.max(0.0, Cartesian3.magnitude(proj) - boundingSphere.radius);
+        var distance = -Cartesian3.dot(toCenter, this.directionWC);
+        var proj = Cartesian3.multiplyByScalar(this.directionWC, distance, scratchProj);
+        var unsignedDistance = Math.max(0.0, Cartesian3.magnitude(proj) - boundingSphere.radius);
+        return distance < 0.0 ? -unsignedDistance : unsignedDistance;
     };
 
     var scratchPixelSize = new Cartesian2();
@@ -2615,6 +2620,9 @@ define([
         //>>includeEnd('debug');
 
         var distance = this.distanceToBoundingSphere(boundingSphere);
+        if (distance < 0.0) {
+            return 0.0;
+        }
         var pixelSize = this.frustum.getPixelDimensions(drawingBufferWidth, drawingBufferHeight, distance, scratchPixelSize);
         return Math.max(pixelSize.x, pixelSize.y);
     };
@@ -3229,6 +3237,7 @@ define([
         Cartesian3.clone(camera.right, result.right);
         Matrix4.clone(camera._transform, result.transform);
         result._transformChanged = true;
+        result.frustum = camera.frustum.clone();
 
         return result;
     };

Source/Scene/Cesium3DTileBatchTable.js

@@ -1351,7 +1351,7 @@ define([
             if (bivariateVisibilityTest) {
                 if (command.pass !== Pass.TRANSLUCENT && !finalResolution) {
                     if (!defined(derivedCommands.zback)) {
-                        derivedCommands.zback = deriveZBackfaceCommand(derivedCommands.originalCommand);
+                        derivedCommands.zback = deriveZBackfaceCommand(frameState.context, derivedCommands.originalCommand);
                     }
                     tileset._backfaceCommands.push(derivedCommands.zback);
                 }
@@ -1436,7 +1436,24 @@ define([
         return derivedCommand;
     }
 
-    function deriveZBackfaceCommand(command) {
+    function getDisableLogDepthFragmentShaderProgram(context, shaderProgram) {
+        var shader = context.shaderCache.getDerivedShaderProgram(shaderProgram, 'zBackfaceLogDepth');
+        if (!defined(shader)) {
+            var fs = shaderProgram.fragmentShaderSource.clone();
+            fs.defines = defined(fs.defines) ? fs.defines.slice(0) : [];
+            fs.defines.push('DISABLE_LOG_DEPTH_FRAGMENT_WRITE');
+
+            shader = context.shaderCache.createDerivedShaderProgram(shaderProgram, 'zBackfaceLogDepth', {
+                vertexShaderSource : shaderProgram.vertexShaderSource,
+                fragmentShaderSource : fs,
+                attributeLocations : shaderProgram._attributeLocations
+            });
+        }
+
+        return shader;
+    }
+
+    function deriveZBackfaceCommand(context, command) {
         // Write just backface depth of unresolved tiles so resolved stenciled tiles do not appear in front
         var derivedCommand = DrawCommand.shallowClone(command);
         var rs = clone(derivedCommand.renderState, true);
@@ -1459,6 +1476,9 @@ define([
         derivedCommand.renderState = RenderState.fromCache(rs);
         derivedCommand.castShadows = false;
         derivedCommand.receiveShadows = false;
+        // Disable the depth writes in the fragment shader. The back face commands were causing the higher resolution
+        // tiles to disappear.
+        derivedCommand.shaderProgram = getDisableLogDepthFragmentShaderProgram(context, command.shaderProgram);
         return derivedCommand;
     }
 

Source/Scene/ClassificationModel.js

@@ -663,34 +663,38 @@ define([
     }
 
     function createProgram(model) {
-        var positionName = ModelUtility.getAttributeOrUniformBySemantic(model.gltf, 'POSITION');
-        var batchIdName = ModelUtility.getAttributeOrUniformBySemantic(model.gltf, '_BATCHID');
+        var gltf = model.gltf;
+
+        var positionName = ModelUtility.getAttributeOrUniformBySemantic(gltf, 'POSITION');
+        var batchIdName = ModelUtility.getAttributeOrUniformBySemantic(gltf, '_BATCHID');
 
         var attributeLocations = {};
         attributeLocations[positionName] = 0;
         attributeLocations[batchIdName] = 1;
 
-        var modelViewProjectionName = ModelUtility.getAttributeOrUniformBySemantic(model.gltf, 'MODELVIEWPROJECTION');
+        var modelViewProjectionName = ModelUtility.getAttributeOrUniformBySemantic(gltf, 'MODELVIEWPROJECTION');
 
         var uniformDecl;
-        var computePosition;
+        var toClip;
 
         if (!defined(modelViewProjectionName)) {
-            var projectionName = ModelUtility.getAttributeOrUniformBySemantic(model.gltf, 'PROJECTION');
-            var modelViewName = ModelUtility.getAttributeOrUniformBySemantic(model.gltf, 'MODELVIEW');
+            var projectionName = ModelUtility.getAttributeOrUniformBySemantic(gltf, 'PROJECTION');
+            var modelViewName = ModelUtility.getAttributeOrUniformBySemantic(gltf, 'MODELVIEW');
             if (!defined(modelViewName)) {
-                modelViewName = ModelUtility.getAttributeOrUniformBySemantic(model.gltf, 'CESIUM_RTC_MODELVIEW');
+                modelViewName = ModelUtility.getAttributeOrUniformBySemantic(gltf, 'CESIUM_RTC_MODELVIEW');
             }
 
             uniformDecl =
                 'uniform mat4 ' + modelViewName + ';\n' +
                 'uniform mat4 ' + projectionName + ';\n';
-            computePosition = '    vec4 positionInClipCoords = ' + projectionName + ' * ' + modelViewName + ' * vec4(' + positionName + ', 1.0);\n';
+            toClip = projectionName + ' * ' + modelViewName + ' * vec4(' + positionName + ', 1.0)';
         } else {
             uniformDecl = 'uniform mat4 ' + modelViewProjectionName + ';\n';
-            computePosition = '    vec4 positionInClipCoords = ' + modelViewProjectionName + ' * vec4(' + positionName + ', 1.0);\n';
+            toClip = modelViewProjectionName + ' * vec4(' + positionName + ', 1.0)';
         }
 
+        var computePosition = '    vec4 positionInClipCoords = ' + toClip + ';\n';
+
         var vs =
             'attribute vec3 ' + positionName + ';\n' +
             'attribute float ' + batchIdName + ';\n' +
@@ -716,6 +720,9 @@ define([
         var drawVS = modifyShader(vs, model._vertexShaderLoaded);
         var drawFS = modifyShader(fs, model._classificationShaderLoaded);
 
+        drawVS = ModelUtility.modifyVertexShaderForLogDepth(drawVS, toClip);
+        drawFS = ModelUtility.modifyFragmentShaderForLogDepth(drawFS);
+
         model._shaderProgram = {
             vertexShaderSource : drawVS,
             fragmentShaderSource : drawFS,
@@ -726,6 +733,9 @@ define([
         var pickVS = modifyShader(vs, model._pickVertexShaderLoaded);
         var pickFS = modifyShader(fs, model._pickFragmentShaderLoaded);
 
+        pickVS = ModelUtility.modifyVertexShaderForLogDepth(pickVS, toClip);
+        pickFS = ModelUtility.modifyFragmentShaderForLogDepth(pickFS);
+
         model._pickShaderProgram = {
             vertexShaderSource : pickVS,
             fragmentShaderSource : pickFS,

Source/Scene/DepthPlane.js

@@ -12,6 +12,7 @@ define([
         '../Renderer/Pass',
         '../Renderer/RenderState',
         '../Renderer/ShaderProgram',
+        '../Renderer/ShaderSource',
         '../Renderer/VertexArray',
         '../Shaders/DepthPlaneFS',
         '../Shaders/DepthPlaneVS',
@@ -30,6 +31,7 @@ define([
         Pass,
         RenderState,
         ShaderProgram,
+        ShaderSource,
         VertexArray,
         DepthPlaneFS,
         DepthPlaneVS,
@@ -45,6 +47,7 @@ define([
         this._va = undefined;
         this._command = undefined;
         this._mode = undefined;
+        this._useLogDepth = false;
     }
 
     var depthQuadScratch = FeatureDetection.supportsTypedArrays() ? new Float32Array(12) : [];
@@ -100,7 +103,7 @@ define([
         return depthQuadScratch;
     }
 
-    DepthPlane.prototype.update = function(frameState) {
+    DepthPlane.prototype.update = function(frameState, useLogDepth) {
         this._mode = frameState.mode;
         if (frameState.mode !== SceneMode.SCENE3D) {
             return;
@@ -125,24 +128,48 @@ define([
                 }
             });
 
-            this._sp = ShaderProgram.fromCache({
-                context : context,
-                vertexShaderSource : DepthPlaneVS,
-                fragmentShaderSource : DepthPlaneFS,
-                attributeLocations : {
-                    position : 0
-                }
-            });
-
             this._command = new DrawCommand({
                 renderState : this._rs,
-                shaderProgram : this._sp,
                 boundingVolume : new BoundingSphere(Cartesian3.ZERO, ellipsoid.maximumRadius),
                 pass : Pass.OPAQUE,
                 owner : this
             });
         }
 
+        if (!defined(this._sp) || this._useLogDepth !== useLogDepth) {
+            this._useLogDepth = useLogDepth;
+
+            var vs = new ShaderSource({
+                sources : [DepthPlaneVS]
+            });
+            var fs = new ShaderSource({
+                sources : [DepthPlaneFS]
+            });
+            if (useLogDepth) {
+                var extension =
+                    '#ifdef GL_EXT_frag_depth \n' +
+                    '#extension GL_EXT_frag_depth : enable \n' +
+                    '#endif \n\n';
+
+                fs.sources.push(extension);
+                fs.defines.push('LOG_DEPTH');
+                vs.defines.push('LOG_DEPTH');
+                vs.defines.push('DISABLE_GL_POSITION_LOG_DEPTH');
+            }
+
+            this._sp = ShaderProgram.replaceCache({
+                shaderProgram : this._sp,
+                context : context,
+                vertexShaderSource : vs,
+                fragmentShaderSource : fs,
+                attributeLocations : {
+                    position : 0
+                }
+            });
+
+            this._command.shaderProgram = this._sp;
+        }
+
         // update depth plane
         var depthQuad = computeDepthQuad(ellipsoid, frameState);