CesiumGS · pjcozzi · Nov 8, 2018 · Sep 18, 2018 · Sep 19, 2018 · Sep 21, 2018
diff --git a/Apps/Sandcastle/gallery/Clamp to 3D Tiles Offscreen.html b/Apps/Sandcastle/gallery/Clamp to 3D Tiles Offscreen.html
@@ -0,0 +1,104 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no">
+    <meta name="description" content="Sample the most detailed heights of a 3D Tileset.">
+    <meta name="cesium-sandcastle-labels" content="Showcases, 3D Tiles">
+    <title>Cesium Demo</title>
+    <script type="text/javascript" src="../Sandcastle-header.js"></script>
+    <script type="text/javascript" src="../../../ThirdParty/requirejs-2.1.20/require.js"></script>
+    <script type="text/javascript">
+        if(typeof require === 'function') {
+            require.config({
+                baseUrl : '../../../Source',
+                waitSeconds : 120
+            });
+        }
+    </script>
+</head>
+<body class="sandcastle-loading" data-sandcastle-bucket="bucket-requirejs.html">
+<style>
+    @import url(../templates/bucket.css);
+</style>
+<div id="cesiumContainer" class="fullSize"></div>
+<div id="loadingOverlay"><h1>Loading...</h1></div>
+<div id="toolbar"></div>
+<script id="cesium_sandcastle_script">
+function startup(Cesium) {
+    'use strict';
+//Sandcastle_Begin
+var viewer = new Cesium.Viewer('cesiumContainer');
+var scene = viewer.scene;
+
+var tileset = scene.primitives.add(
+    new Cesium.Cesium3DTileset({
+        url: Cesium.IonResource.fromAssetId(6074)
+    })
+);
+
+scene.camera.setView({
+    destination: new Cesium.Cartesian3(1216411.0748779264, -4736313.10747583, 4081359.5125561724),
+    orientation: new Cesium.HeadingPitchRoll(4.239925103568368, -0.4911293834802475, 6.279849292088564),
+    endTransform : Cesium.Matrix4.IDENTITY
+});
+
+Sandcastle.addToolbarButton('Sample heights', function() {
+    sampleHeights();
+});
+
+function sampleHeights() {
+    if (!scene.clampToHeightSupported) {
+        console.log('This browser does not support clampToHeightMostDetailed.');
+    }
+
+    viewer.entities.removeAll();
+
+    var cartesian1 = new Cesium.Cartesian3(1216390.063324395, -4736314.814479433, 4081341.9787972216);
+    var cartesian2 = new Cesium.Cartesian3(1216329.5413318684, -4736272.029009798, 4081407.9342479417);
+
+    var count = 30;
+    var cartesians = new Array(count);
+    for (var i = 0; i < count; ++i) {
+        var offset = i / (count - 1);
+        cartesians[i] = Cesium.Cartesian3.lerp(cartesian1, cartesian2, offset, new Cesium.Cartesian3());
+    }
+
+    scene.clampToHeightMostDetailed(cartesians).then(function(clampedCartesians) {
+        for (var i = 0; i < count; ++i) {
+            viewer.entities.add({
+                position: clampedCartesians[i],
+                ellipsoid : {
+                    radii : new Cesium.Cartesian3(0.2, 0.2, 0.2),
+                    material : Cesium.Color.RED
+                }
+            });
+        }
+
+        viewer.entities.add({
+            polyline : {
+                positions : clampedCartesians,
+                followSurface : false,
+                width : 2,
+                material : new Cesium.PolylineOutlineMaterialProperty({
+                    color : Cesium.Color.YELLOW
+                }),
+                depthFailMaterial : new Cesium.PolylineOutlineMaterialProperty({
+                    color : Cesium.Color.YELLOW
+                })
+            }
+        });
+    });
+}
+//Sandcastle_End
+    Sandcastle.finishedLoading();
+}
+if (typeof Cesium !== 'undefined') {
+    startup(Cesium);
+} else if (typeof require === 'function') {
+    require(['Cesium'], startup);
+}
+</script>
+</body>
+</html>
diff --git a/Apps/Sandcastle/gallery/Clamp to 3D Tiles Offscreen.jpg b/Apps/Sandcastle/gallery/Clamp to 3D Tiles Offscreen.jpg
diff --git a/CHANGES.md b/CHANGES.md
@@ -4,11 +4,13 @@ Change Log
 ### 1.51 - 2018-11-01
 
 ##### Additions :tada:
+* Added `Ray.clone`. [#7115](https://github.com/AnalyticalGraphicsInc/cesium/pull/7115)
 * Added WMS-T (time) support in WebMapServiceImageryProvider [#2581](https://github.com/AnalyticalGraphicsInc/cesium/issues/2581)
 * Added `cutoutRectangle` to `ImageryLayer`, which allows cutting out rectangular areas in imagery layers to reveal underlying imagery. [#7056](https://github.com/AnalyticalGraphicsInc/cesium/pull/7056)
 
 ##### Fixes :wrench:
 * Fixed an issue where `pickPosition` would return incorrect results when called after `sampleHeight` or `clampToHeight`. [#7113](https://github.com/AnalyticalGraphicsInc/cesium/pull/7113)
+* Fixed an issue where `sampleHeight` and `clampToHeight` would crash if picking a primitive that doesn't write depth. [#7120](https://github.com/AnalyticalGraphicsInc/cesium/issues/7120)
 
 ### 1.50 - 2018-10-01
 

diff --git a/Source/Core/Ray.js b/Source/Core/Ray.js
@@ -1,13 +1,13 @@
 define([
         './Cartesian3',
+        './Check',
         './defaultValue',
-        './defined',
-        './DeveloperError'
+        './defined'
     ], function(
         Cartesian3,
+        Check,
         defaultValue,
-        defined,
-        DeveloperError) {
+        defined) {
     'use strict';
 
     /**
@@ -38,6 +38,27 @@ define([
         this.direction = direction;
     }
 
+    /**
+     * Duplicates a Ray instance.
+     *
+     * @param {Ray} ray The ray to duplicate.
+     * @param {Ray} [result] The object onto which to store the result.
+     * @returns {Ray} The modified result parameter or a new Ray instance if one was not provided.
+     */
+    Ray.clone = function(ray, result) {
+        //>>includeStart('debug', pragmas.debug);
+        Check.typeOf.object('ray', ray);
+        //>>includeEnd('debug');
+
+        if (!defined(result)) {
+            return new Ray(ray.origin, ray.direction);
+        }
+
+        result.origin = ray.origin;
+        result.direction = ray.direction;
+        return result;
+    };
+
     /**
      * Computes the point along the ray given by r(t) = o + t*d,
      * where o is the origin of the ray and d is the direction.
@@ -54,12 +75,8 @@ define([
      */
     Ray.getPoint = function(ray, t, result) {
         //>>includeStart('debug', pragmas.debug);
-        if (!defined(ray)){
-            throw new DeveloperError('ray is requred');
-        }
-        if (typeof t !== 'number') {
-            throw new DeveloperError('t is a required number');
-        }
+        Check.typeOf.object('ray', ray);
+        Check.typeOf.number('t', t);
         //>>includeEnd('debug');
 
         if (!defined(result)) {

diff --git a/Source/Scene/Cesium3DTile.js b/Source/Scene/Cesium3DTile.js
@@ -17,6 +17,7 @@ define([
         '../Core/Matrix3',
         '../Core/Matrix4',
         '../Core/OrientedBoundingBox',
+        '../Core/OrthographicFrustum',
         '../Core/Rectangle',
         '../Core/Request',
         '../Core/RequestScheduler',
@@ -54,6 +55,7 @@ define([
         Matrix3,
         Matrix4,
         OrientedBoundingBox,
+        OrthographicFrustum,
         Rectangle,
         Request,
         RequestScheduler,
@@ -607,6 +609,69 @@ define([
 
     var scratchJulianDate = new JulianDate();
 
+    /**
+     * Get the tile's screen space error.
+     *
+     * @private
+     */
+    Cesium3DTile.prototype.getScreenSpaceError = function(frameState, useParentGeometricError) {
+        var tileset = this._tileset;
+        var parentGeometricError = defined(this.parent) ? this.parent.geometricError : tileset._geometricError;
+        var geometricError = useParentGeometricError ? parentGeometricError : this.geometricError;
+        if (geometricError === 0.0) {
+            // Leaf tiles do not have any error so save the computation
+            return 0.0;
+        }
+
+        var camera = frameState.camera;
+        var frustum = camera.frustum;
+        var context = frameState.context;
+        var width = context.drawingBufferWidth;
+        var height = context.drawingBufferHeight;
+
+        var error;
+        if (frameState.mode === SceneMode.SCENE2D || frustum instanceof OrthographicFrustum) {
+            if (defined(frustum._offCenterFrustum)) {
+                frustum = frustum._offCenterFrustum;
+            }
+            var pixelSize = Math.max(frustum.top - frustum.bottom, frustum.right - frustum.left) / Math.max(width, height);
+            error = geometricError / pixelSize;
+        } else {
+            // Avoid divide by zero when viewer is inside the tile
+            var distance = Math.max(this._distanceToCamera, CesiumMath.EPSILON7);
+            var sseDenominator = camera.frustum.sseDenominator;
+            error = (geometricError * height) / (distance * sseDenominator);
+
+            if (tileset.dynamicScreenSpaceError) {
+                var density = tileset._dynamicScreenSpaceErrorComputedDensity;
+                var factor = tileset.dynamicScreenSpaceErrorFactor;
+                var dynamicError = CesiumMath.fog(distance, density) * factor;
+                error -= dynamicError;
+            }
+        }
+
+        return error;
+    };
+
+    /**
+     * Update the tile's visibility.
+     *
+     * @private
+     */
+    Cesium3DTile.prototype.updateVisibility = function(frameState) {
+        var parent = this.parent;
+        var parentTransform = defined(parent) ? parent.computedTransform : this._tileset.modelMatrix;
+        var parentVisibilityPlaneMask = defined(parent) ? parent._visibilityPlaneMask : CullingVolume.MASK_INDETERMINATE;
+
+        this.updateTransform(parentTransform);
+        this._distanceToCamera = this.distanceToTile(frameState);
+        this._centerZDepth = this.distanceToTileCenter(frameState);
+        this._screenSpaceError = this.getScreenSpaceError(frameState);
+        this._visibilityPlaneMask = this.visibility(frameState, parentVisibilityPlaneMask); // Use parent's plane mask to speed up visibility test
+        this._visible = this._visibilityPlaneMask !== CullingVolume.MASK_OUTSIDE;
+        this._inRequestVolume = this.insideViewerRequestVolume(frameState);
+    };
+
     /**
      * Update whether the tile has expired.
      *
@@ -846,6 +911,12 @@ define([
             return Intersect.INSIDE;
         }
 
+        if (this._visibilityPlaneMask === CullingVolume.MASK_INSIDE) {
+            // The tile's bounding volume is completely inside the culling volume so
+            // the content bounding volume must also be inside.
+            return Intersect.INSIDE;
+        }
+
         // PERFORMANCE_IDEA: is it possible to burn less CPU on this test since we know the
         // tile's (not the content's) bounding volume intersects the culling volume?
         var cullingVolume = frameState.cullingVolume;
@@ -1055,6 +1126,10 @@ define([
     };
 
     function applyDebugSettings(tile, tileset, frameState) {
+        if (!frameState.passes.render) {
+            return;
+        }
+
         var hasContentBoundingVolume = defined(tile._header.content) && defined(tile._header.content.boundingVolume);
         var empty = tile.hasEmptyContent || tile.hasTilesetContent;