From 5e458c8077dee0568539ab45164ba7b755dc11fc Mon Sep 17 00:00:00 2001
From: Sean Lilley <lilleyse@gmail.com>
Date: Fri, 21 Dec 2018 17:34:58 -0500
Subject: [PATCH 01/11] GroundPolylinePrimitive on 3D Tiles

---
 Source/Core/GroundPolylineGeometry.js   |   6 +-
 Source/Scene/ClassificationPrimitive.js |   2 -
 Source/Scene/GroundPolylinePrimitive.js | 153 ++++++++++++++++--------
 3 files changed, 103 insertions(+), 58 deletions(-)

diff --git a/Source/Core/GroundPolylineGeometry.js b/Source/Core/GroundPolylineGeometry.js
index 1c03744df648..c29e2748f5d7 100644
--- a/Source/Core/GroundPolylineGeometry.js
+++ b/Source/Core/GroundPolylineGeometry.js
@@ -70,7 +70,7 @@ define([
     var WALL_INITIAL_MAX_HEIGHT = 1000.0;
 
     /**
-     * A description of a polyline on terrain. Only to be used with {@link GroundPolylinePrimitive}.
+     * A description of a polyline on terrain or 3D Tiles. Only to be used with {@link GroundPolylinePrimitive}.
      *
      * @alias GroundPolylineGeometry
      * @constructor
@@ -159,7 +159,7 @@ define([
      * Set the GroundPolylineGeometry's projection and ellipsoid.
      * Used by GroundPolylinePrimitive to signal scene information to the geometry for generating 2D attributes.
      *
-     * @param {GroundPolylineGeometry} groundPolylineGeometry GroundPolylinGeometry describing a polyline on terrain.
+     * @param {GroundPolylineGeometry} groundPolylineGeometry GroundPolylinGeometry describing a polyline on terrain or 3D Tiles.
      * @param {Projection} mapProjection A MapProjection used for projecting cartographic coordinates to 2D.
      * @private
      */
@@ -386,7 +386,7 @@ define([
     var intersectionScratch = new Cartesian3();
     /**
      * Computes shadow volumes for the ground polyline, consisting of its vertices, indices, and a bounding sphere.
-     * Vertices are "fat," packing all the data needed in each volume to describe a line on terrain.
+     * Vertices are "fat," packing all the data needed in each volume to describe a line on terrain or 3D Tiles.
      * Should not be called independent of {@link GroundPolylinePrimitive}.
      *
      * @param {GroundPolylineGeometry} groundPolylineGeometry
diff --git a/Source/Scene/ClassificationPrimitive.js b/Source/Scene/ClassificationPrimitive.js
index d0dcc4695b7a..764ee174c20a 100644
--- a/Source/Scene/ClassificationPrimitive.js
+++ b/Source/Scene/ClassificationPrimitive.js
@@ -766,7 +766,6 @@ define([
                 // Then derive from the 3D Tiles command
                 derived2DCommand = DrawCommand.shallowClone(derivedCommand, derivedCommand.derivedCommands.appearance2D);
                 derived2DCommand.shaderProgram = classificationPrimitive._spColor2D;
-                derived2DCommand.pass = Pass.CESIUM_3D_TILE_CLASSIFICATION;
                 derivedCommand.derivedCommands.appearance2D = derived2DCommand;
             }
         }
@@ -908,7 +907,6 @@ define([
                 // Then derive from the 3D Tiles command
                 derived2DCommand = DrawCommand.shallowClone(derivedCommand, derivedCommand.derivedCommands.pick2D);
                 derived2DCommand.shaderProgram = classificationPrimitive._spPick2D;
-                derived2DCommand.pass = Pass.CESIUM_3D_TILE_CLASSIFICATION;
                 derivedCommand.derivedCommands.pick2D = derived2DCommand;
             }
         }
diff --git a/Source/Scene/GroundPolylinePrimitive.js b/Source/Scene/GroundPolylinePrimitive.js
index 7d052e567843..896aec902ed8 100644
--- a/Source/Scene/GroundPolylinePrimitive.js
+++ b/Source/Scene/GroundPolylinePrimitive.js
@@ -21,11 +21,15 @@ define([
         '../Renderer/ShaderSource',
         '../ThirdParty/when',
         './BlendingState',
+        './ClassificationType',
         './CullFace',
         './PolylineColorAppearance',
         './PolylineMaterialAppearance',
         './Primitive',
-        './SceneMode'
+        './SceneMode',
+        './StencilConstants',
+        './StencilFunction',
+        './StencilOperation'
     ], function(
         ApproximateTerrainHeights,
         ComponentDatatype,
@@ -49,18 +53,22 @@ define([
         ShaderSource,
         when,
         BlendingState,
+        ClassificationType,
         CullFace,
         PolylineColorAppearance,
         PolylineMaterialAppearance,
         Primitive,
-        SceneMode) {
+        SceneMode,
+        StencilConstants,
+        StencilFunction,
+        StencilOperation) {
     'use strict';
 
     /**
-     * A GroundPolylinePrimitive represents a polyline draped over the terrain in the {@link Scene}.
+     * A GroundPolylinePrimitive represents a polyline draped over the terrain or 3D Tiles in the {@link Scene}.
      * <p>
-     *
      * Only to be used with GeometryInstances containing {@link GroundPolylineGeometry}.
+     * </p>
      *
      * @alias GroundPolylinePrimitive
      * @constructor
@@ -73,6 +81,7 @@ define([
      * @param {Boolean} [options.releaseGeometryInstances=true] When <code>true</code>, the primitive does not keep a reference to the input <code>geometryInstances</code> to save memory.
      * @param {Boolean} [options.allowPicking=true] When <code>true</code>, each geometry instance will only be pickable with {@link Scene#pick}.  When <code>false</code>, GPU memory is saved.
      * @param {Boolean} [options.asynchronous=true] Determines if the primitive will be created asynchronously or block until ready. If false initializeTerrainHeights() must be called first.
+     * @param {ClassificationType} [options.classificationType=ClassificationType.BOTH] Determines whether terrain, 3D Tiles or both will be classified.
      * @param {Boolean} [options.debugShowBoundingVolume=false] For debugging only. Determines if this primitive's commands' bounding spheres are shown.
      * @param {Boolean} [options.debugShowShadowVolume=false] For debugging only. Determines if the shadow volume for each geometry in the primitive is drawn. Must be <code>true</code> on creation to have effect.
      *
@@ -168,6 +177,15 @@ define([
          */
         this.show = defaultValue(options.show, true);
 
+        /**
+         * Determines whether terrain, 3D Tiles or both will be classified.
+         *
+         * @type {ClassificationType}
+         *
+         * @default ClassificationType.BOTH
+         */
+        this.classificationType = defaultValue(options.classificationType, ClassificationType.BOTH);
+
         /**
          * This property is for debugging only; it is not for production use nor is it optimized.
          * <p>
@@ -209,13 +227,8 @@ define([
         this._sp2D = undefined;
         this._spMorph = undefined;
 
-        this._renderState = RenderState.fromCache({
-            cull : {
-                enabled : true // prevent double-draw. Geometry is "inverted" (reversed winding order) so we're drawing backfaces.
-            },
-            blending : BlendingState.ALPHA_BLEND,
-            depthMask : false
-        });
+        this._renderState = getRenderState(false);
+        this._renderState3DTiles = getRenderState(true);
 
         this._renderStateMorph = RenderState.fromCache({
             cull : {
@@ -454,6 +467,33 @@ define([
         groundPolylinePrimitive._spMorph = colorProgramMorph;
     }
 
+    function getRenderState(mask3DTiles) {
+        return RenderState.fromCache({
+            cull : {
+                enabled : true // prevent double-draw. Geometry is "inverted" (reversed winding order) so we're drawing backfaces.
+            },
+            blending : BlendingState.ALPHA_BLEND,
+            depthMask : false,
+            stencilTest : {
+                enabled : mask3DTiles,
+                frontFunction : StencilFunction.EQUAL,
+                frontOperation : {
+                    fail : StencilOperation.KEEP,
+                    zFail : StencilOperation.KEEP,
+                    zPass : StencilOperation.KEEP
+                },
+                backFunction : StencilFunction.EQUAL,
+                backOperation : {
+                    fail : StencilOperation.KEEP,
+                    zFail : StencilOperation.KEEP,
+                    zPass : StencilOperation.KEEP
+                },
+                reference : StencilConstants.CESIUM_3D_TILE_MASK,
+                mask : StencilConstants.CESIUM_3D_TILE_MASK
+            }
+        });
+    }
+
     function createCommands(groundPolylinePrimitive, appearance, material, translucent, colorCommands, pickCommands) {
         var primitive = groundPolylinePrimitive._primitive;
         var length = primitive._va.length;
@@ -462,16 +502,13 @@ define([
 
         var isPolylineColorAppearance = appearance instanceof PolylineColorAppearance;
 
-        var i;
-        var command;
         var materialUniforms = isPolylineColorAppearance ? {} : material._uniforms;
         var uniformMap = primitive._batchTable.getUniformMapCallback()(materialUniforms);
-        var pass = Pass.TERRAIN_CLASSIFICATION;
 
-        for (i = 0; i < length; i++) {
+        for (var i = 0; i < length; i++) {
             var vertexArray = primitive._va[i];
 
-            command = colorCommands[i];
+            var command = colorCommands[i];
             if (!defined(command)) {
                 command = colorCommands[i] = new DrawCommand({
                     owner : groundPolylinePrimitive,
@@ -483,37 +520,47 @@ define([
             command.renderState = groundPolylinePrimitive._renderState;
             command.shaderProgram = groundPolylinePrimitive._sp;
             command.uniformMap = uniformMap;
-            command.pass = pass;
+            command.pass = Pass.TERRAIN_CLASSIFICATION;
             command.pickId = 'czm_batchTable_pickColor(v_endPlaneNormalEcAndBatchId.w)';
 
+            var derivedTilesetCommand = DrawCommand.shallowClone(command, command.derivedCommands.tileset);
+            derivedTilesetCommand.renderState = groundPolylinePrimitive._renderState3DTiles;
+            derivedTilesetCommand.pass = Pass.CESIUM_3D_TILE_CLASSIFICATION;
+            command.derivedCommands.tileset = derivedTilesetCommand;
+
             // derive for 2D
-            var derivedColorCommand = command.derivedCommands.color2D;
-            if (!defined(derivedColorCommand)) {
-                derivedColorCommand = DrawCommand.shallowClone(command);
-                command.derivedCommands.color2D = derivedColorCommand;
-            }
-            derivedColorCommand.vertexArray = vertexArray;
-            derivedColorCommand.renderState = groundPolylinePrimitive._renderState;
-            derivedColorCommand.shaderProgram = groundPolylinePrimitive._sp2D;
-            derivedColorCommand.uniformMap = uniformMap;
-            derivedColorCommand.pass = pass;
-            derivedColorCommand.pickId = 'czm_batchTable_pickColor(v_endPlaneNormalEcAndBatchId.w)';
+            var derived2DCommand = DrawCommand.shallowClone(command, command.derivedCommands.color2D);
+            derived2DCommand.shaderProgram = groundPolylinePrimitive._sp2D;
+            command.derivedCommands.color2D = derived2DCommand;
+
+            var derived2DTilesetCommand = DrawCommand.shallowClone(command, derivedTilesetCommand.derivedCommands.color2D);
+            derived2DTilesetCommand.shaderProgram = groundPolylinePrimitive._sp2D;
+            derivedTilesetCommand.derivedCommands.color2D = derived2DTilesetCommand;
 
             // derive for Morph
-            derivedColorCommand = command.derivedCommands.colorMorph;
-            if (!defined(derivedColorCommand)) {
-                derivedColorCommand = DrawCommand.shallowClone(command);
-                command.derivedCommands.colorMorph = derivedColorCommand;
-            }
-            derivedColorCommand.vertexArray = vertexArray;
-            derivedColorCommand.renderState = groundPolylinePrimitive._renderStateMorph;
-            derivedColorCommand.shaderProgram = groundPolylinePrimitive._spMorph;
-            derivedColorCommand.uniformMap = uniformMap;
-            derivedColorCommand.pass = pass;
-            derivedColorCommand.pickId = 'czm_batchTable_pickColor(v_batchId)';
+            var derivedMorphCommand = DrawCommand.shallowClone(command, command.derivedCommands.colorMorph);
+            derivedMorphCommand.renderState = groundPolylinePrimitive._renderStateMorph;
+            derivedMorphCommand.shaderProgram = groundPolylinePrimitive._spMorph;
+            derivedMorphCommand.pickId = 'czm_batchTable_pickColor(v_batchId)';
+            command.derivedCommands.colorMorph = derivedMorphCommand;
         }
     }
 
+    function updateAndQueueCommand(groundPolylinePrimitive, command, frameState, modelMatrix, cull, boundingVolume, debugShowBoundingVolume) {
+        // Use derived appearance command for morph and 2D
+        if (frameState.mode === SceneMode.MORPHING && command.shaderProgram !== groundPolylinePrimitive._spMorph) {
+            command = command.derivedCommands.colorMorph;
+        } else if (frameState.mode !== SceneMode.SCENE3D && command.shaderProgram !== groundPolylinePrimitive._sp2D) {
+            command = command.derivedCommands.color2D;
+        }
+        command.modelMatrix = modelMatrix;
+        command.boundingVolume = boundingVolume;
+        command.cull = cull;
+        command.debugShowBoundingVolume = debugShowBoundingVolume;
+
+        frameState.commandList.push(command);
+    }
+
     function updateAndQueueCommands(groundPolylinePrimitive, frameState, colorCommands, pickCommands, modelMatrix, cull, debugShowBoundingVolume) {
         var primitive = groundPolylinePrimitive._primitive;
 
@@ -530,25 +577,25 @@ define([
             boundingSpheres = primitive._boundingSphereMorph;
         }
 
-        var commandList = frameState.commandList;
+        var morphing = frameState.mode === SceneMode.MORPHING;
+        var classificationType = groundPolylinePrimitive.classificationType;
+        var queueTerrainCommands = (classificationType !== ClassificationType.CESIUM_3D_TILE);
+        var queue3DTilesCommands = (classificationType !== ClassificationType.TERRAIN) && !morphing;
+
+        var command;
         var passes = frameState.passes;
         if (passes.render || (passes.pick && primitive.allowPicking)) {
             var colorLength = colorCommands.length;
-
             for (var j = 0; j < colorLength; ++j) {
-                var colorCommand = colorCommands[j];
-                // Use derived appearance command for morph and 2D
-                if (frameState.mode === SceneMode.MORPHING && colorCommand.shaderProgram !== groundPolylinePrimitive._spMorph) {
-                    colorCommand = colorCommand.derivedCommands.colorMorph;
-                } else if (frameState.mode !== SceneMode.SCENE3D && colorCommand.shaderProgram !== groundPolylinePrimitive._sp2D) {
-                    colorCommand = colorCommand.derivedCommands.color2D;
+                var boundingVolume = boundingSpheres[j];
+                if (queueTerrainCommands) {
+                    command = colorCommands[j];
+                    updateAndQueueCommand(groundPolylinePrimitive, command, frameState, modelMatrix, cull, boundingVolume, debugShowBoundingVolume);
+                }
+                if (queue3DTilesCommands) {
+                    command = colorCommands[j].derivedCommands.tileset;
+                    updateAndQueueCommand(groundPolylinePrimitive, command, frameState, modelMatrix, cull, boundingVolume, debugShowBoundingVolume);
                 }
-                colorCommand.modelMatrix = modelMatrix;
-                colorCommand.boundingVolume = boundingSpheres[j];
-                colorCommand.cull = cull;
-                colorCommand.debugShowBoundingVolume = debugShowBoundingVolume;
-
-                commandList.push(colorCommand);
             }
         }
     }

From b1e01ef9f601e1fffb2af25d435f354c231d24ab Mon Sep 17 00:00:00 2001
From: Sean Lilley <lilleyse@gmail.com>
Date: Sat, 22 Dec 2018 13:52:12 -0500
Subject: [PATCH 02/11] Add support in entity layer

---
 Source/DataSources/CorridorGraphics.js        |   3 +-
 Source/DataSources/EllipseGraphics.js         |   5 +-
 Source/DataSources/Entity.js                  |   2 +-
 Source/DataSources/PolygonGraphics.js         |   3 +-
 Source/DataSources/PolylineGeometryUpdater.js |  20 ++-
 Source/DataSources/PolylineGraphics.js        |  15 +-
 Source/DataSources/PolylineVisualizer.js      |  19 ++-
 Source/DataSources/RectangleGraphics.js       |   3 +-
 .../StaticGroundPolylinePerMaterialBatch.js   |  11 +-
 Specs/DataSources/PolylineGraphicsSpec.js     |  14 ++
 Specs/DataSources/PolylineVisualizerSpec.js   | 160 +++++++++++++++++-
 ...taticGroundPolylinePerMaterialBatchSpec.js |  20 ++-
 12 files changed, 247 insertions(+), 28 deletions(-)

diff --git a/Source/DataSources/CorridorGraphics.js b/Source/DataSources/CorridorGraphics.js
index 268f4e7da314..5de15e0b003c 100644
--- a/Source/DataSources/CorridorGraphics.js
+++ b/Source/DataSources/CorridorGraphics.js
@@ -41,6 +41,7 @@ define([
      * @param {Property} [options.granularity=Cesium.Math.RADIANS_PER_DEGREE] A numeric Property specifying the distance between each latitude and longitude.
      * @param {Property} [options.shadows=ShadowMode.DISABLED] An enum Property specifying whether the corridor casts or receives shadows from each light source.
      * @param {Property} [options.distanceDisplayCondition] A Property specifying at what distance from the camera that this corridor will be displayed.
+     * @param {Property} [options.classificationType=ClassificationType.BOTH] A Property specifying whether this corridor will classify terrain, 3D Tiles, or both when on the ground.
      * @param {ConstantProperty} [options.zIndex] A Property specifying the zIndex of the corridor, used for ordering.  Only has an effect if height and extrudedHeight are undefined, and if the corridor is static.
      *
      * @see Entity
@@ -232,7 +233,7 @@ define([
          * Gets or sets the {@link ClassificationType} Property specifying whether this corridor will classify terrain, 3D Tiles, or both when on the ground.
          * @memberof CorridorGraphics.prototype
          * @type {Property}
-         * @default ClassificationType.TERRAIN
+         * @default ClassificationType.BOTH
          */
         classificationType : createPropertyDescriptor('classificationType'),
 
diff --git a/Source/DataSources/EllipseGraphics.js b/Source/DataSources/EllipseGraphics.js
index c120ffc691c1..d909defbabb6 100644
--- a/Source/DataSources/EllipseGraphics.js
+++ b/Source/DataSources/EllipseGraphics.js
@@ -44,7 +44,8 @@ define([
      * @param {Property} [options.granularity=Cesium.Math.RADIANS_PER_DEGREE] A numeric Property specifying the angular distance between points on the ellipse.
      * @param {Property} [options.shadows=ShadowMode.DISABLED] An enum Property specifying whether the ellipse casts or receives shadows from each light source.
      * @param {Property} [options.distanceDisplayCondition] A Property specifying at what distance from the camera that this ellipse will be displayed.
-     * @param {ConstantProperty} [options.zIndex=0] A property specifying the zIndex of the Ellipse.  Used for ordering ground geometry.  Only has an effect if the ellipse is constant and neither height or exturdedHeight are specified.
+     * @param {Property} [options.classificationType=ClassificationType.BOTH] A Property specifying whether this ellipse will classify terrain, 3D Tiles, or both when on the ground.
+     @param {ConstantProperty} [options.zIndex=0] A property specifying the zIndex of the Ellipse.  Used for ordering ground geometry.  Only has an effect if the ellipse is constant and neither height or exturdedHeight are specified.
      *
      * @demo {@link https://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Circles and Ellipses.html|Cesium Sandcastle Circles and Ellipses Demo}
      */
@@ -254,7 +255,7 @@ define([
          * Gets or sets the {@link ClassificationType} Property specifying whether this ellipse will classify terrain, 3D Tiles, or both when on the ground.
          * @memberof EllipseGraphics.prototype
          * @type {Property}
-         * @default ClassificationType.TERRAIN
+         * @default ClassificationType.BOTH
          */
         classificationType : createPropertyDescriptor('classificationType'),
 
diff --git a/Source/DataSources/Entity.js b/Source/DataSources/Entity.js
index f3b8eb4411ca..12479c976706 100644
--- a/Source/DataSources/Entity.js
+++ b/Source/DataSources/Entity.js
@@ -676,7 +676,7 @@ define([
     };
 
     /**
-     * Checks if the given Scene supports polylines clamped to the ground..
+     * Checks if the given Scene supports polylines clamped to terrain or 3D Tiles.
      * If this feature is not supported, Entities with PolylineGraphics will be rendered with vertices at
      * the provided heights and using the `followSurface` parameter instead of clamped to the ground.
      *
diff --git a/Source/DataSources/PolygonGraphics.js b/Source/DataSources/PolygonGraphics.js
index 5eb968df4d59..c7ca77ad1258 100644
--- a/Source/DataSources/PolygonGraphics.js
+++ b/Source/DataSources/PolygonGraphics.js
@@ -43,6 +43,7 @@ define([
      * @param {Boolean} [options.closeBottom=true] When false, leaves off the bottom of an extruded polygon open.
      * @param {Property} [options.shadows=ShadowMode.DISABLED] An enum Property specifying whether the polygon casts or receives shadows from each light source.
      * @param {Property} [options.distanceDisplayCondition] A Property specifying at what distance from the camera that this polygon will be displayed.
+     * @param {Property} [options.classificationType=ClassificationType.BOTH] A Property specifying whether this ellipse will classify terrain, 3D Tiles, or both when on the ground.
      * @param {ConstantProperty} [options.zIndex=0] A property specifying the zIndex used for ordering ground geometry.  Only has an effect if the polygon is constant and neither height or extrudedHeight are specified.
      *
      * @see Entity
@@ -255,7 +256,7 @@ define([
          * Gets or sets the {@link ClassificationType} Property specifying whether this polygon will classify terrain, 3D Tiles, or both when on the ground.
          * @memberof PolygonGraphics.prototype
          * @type {Property}
-         * @default ClassificationType.TERRAIN
+         * @default ClassificationType.BOTH
          */
         classificationType : createPropertyDescriptor('classificationType'),
 
diff --git a/Source/DataSources/PolylineGeometryUpdater.js b/Source/DataSources/PolylineGeometryUpdater.js
index 87e1258e9005..8cc63def39b1 100644
--- a/Source/DataSources/PolylineGeometryUpdater.js
+++ b/Source/DataSources/PolylineGeometryUpdater.js
@@ -18,6 +18,7 @@ define([
         '../Core/PolylinePipeline',
         '../Core/ShowGeometryInstanceAttribute',
         '../DataSources/Entity',
+        '../Scene/ClassificationType',
         '../Scene/GroundPolylinePrimitive',
         '../Scene/PolylineCollection',
         '../Scene/PolylineColorAppearance',
@@ -48,6 +49,7 @@ define([
         PolylinePipeline,
         ShowGeometryInstanceAttribute,
         Entity,
+        ClassificationType,
         GroundPolylinePrimitive,
         PolylineCollection,
         PolylineColorAppearance,
@@ -70,6 +72,7 @@ define([
     var defaultShow = new ConstantProperty(true);
     var defaultShadows = new ConstantProperty(ShadowMode.DISABLED);
     var defaultDistanceDisplayCondition = new ConstantProperty(new DistanceDisplayCondition());
+    var defaultClassificationType = new ConstantProperty(ClassificationType.BOTH);
 
     function GeometryOptions() {
         this.vertexFormat = undefined;
@@ -113,6 +116,7 @@ define([
         this._materialProperty = undefined;
         this._shadowsProperty = undefined;
         this._distanceDisplayConditionProperty = undefined;
+        this._classificationTypeProperty = undefined;
         this._depthFailMaterialProperty = undefined;
         this._geometryOptions = new GeometryOptions();
         this._groundGeometryOptions = new GroundGeometryOptions();
@@ -252,6 +256,18 @@ define([
                 return this._distanceDisplayConditionProperty;
             }
         },
+        /**
+         * Gets or sets the {@link ClassificationType} Property specifying if this geometry will classify terrain, 3D Tiles, or both when on the ground.
+         * @memberof PolylineGeometryUpdater.prototype
+         *
+         * @type {Property}
+         * @readonly
+         */
+        classificationTypeProperty : {
+            get : function() {
+                return this._classificationTypeProperty;
+            }
+        },
         /**
          * Gets a value indicating if the geometry is time-varying.
          * If true, all visualization is delegated to the {@link DynamicGeometryUpdater}
@@ -473,6 +489,7 @@ define([
         this._showProperty = defaultValue(show, defaultShow);
         this._shadowsProperty = defaultValue(polyline.shadows, defaultShadows);
         this._distanceDisplayConditionProperty = defaultValue(polyline.distanceDisplayCondition, defaultDistanceDisplayCondition);
+        this._classificationTypeProperty = defaultValue(polyline.classificationType, defaultClassificationType);
         this._fillEnabled = true;
         this._zIndex = defaultValue(zIndex, defaultZIndex);
 
@@ -493,7 +510,7 @@ define([
             var positions = positionsProperty.getValue(Iso8601.MINIMUM_VALUE, geometryOptions.positions);
 
             //Because of the way we currently handle reference properties,
-            //we can't automatically assume the positions are  always valid.
+            //we can't automatically assume the positions are always valid.
             if (!defined(positions) || positions.length < 2) {
                 if (this._fillEnabled) {
                     this._fillEnabled = false;
@@ -635,6 +652,7 @@ define([
             this._groundPolylinePrimitive = groundPrimitives.add(new GroundPolylinePrimitive({
                 geometryInstances : geometryUpdater.createFillGeometryInstance(time),
                 appearance : appearance,
+                classificationType : geometryUpdater.classificationTypeProperty.getValue(time),
                 asynchronous : false
             }), Property.getValueOrUndefined(geometryUpdater.zIndex, time));
 
diff --git a/Source/DataSources/PolylineGraphics.js b/Source/DataSources/PolylineGraphics.js
index 3700d18ec149..9a79779ca4e5 100644
--- a/Source/DataSources/PolylineGraphics.js
+++ b/Source/DataSources/PolylineGraphics.js
@@ -31,10 +31,11 @@ define([
      * @param {Property} [options.width=1.0] A numeric Property specifying the width in pixels.
      * @param {Property} [options.show=true] A boolean Property specifying the visibility of the polyline.
      * @param {MaterialProperty} [options.material=Color.WHITE] A Property specifying the material used to draw the polyline.
-     * @param {MaterialProperty} [options.depthFailMaterial] A property specifiying the material used to draw the polyline when it is below the terrain.
+     * @param {MaterialProperty} [options.depthFailMaterial] A property specifying the material used to draw the polyline when it is below the terrain.
      * @param {Property} [options.granularity=Cesium.Math.RADIANS_PER_DEGREE] A numeric Property specifying the angular distance between each latitude and longitude if followSurface is true.
      * @param {Property} [options.shadows=ShadowMode.DISABLED] An enum Property specifying whether the polyline casts or receives shadows from each light source.
      * @param {Property} [options.distanceDisplayCondition] A Property specifying at what distance from the camera that this polyline will be displayed.
+     * @param {Property} [options.classificationType=ClassificationType.BOTH] A Property specifying whether this polyline will classify terrain, 3D Tiles, or both when on the ground.
      * @param {Property} [options.zIndex=0] A Property specifying the zIndex used for ordering ground geometry. Only has an effect if `clampToGround` is true and polylines on terrain is supported.
      *
      * @see Entity
@@ -62,6 +63,8 @@ define([
         this._shadowsSubscription = undefined;
         this._distanceDisplayCondition = undefined;
         this._distanceDisplayConditionSubscription = undefined;
+        this._classificationType = undefined;
+        this._classificationTypeSubscription = undefined;
         this._zIndex = undefined;
         this._zIndexSubscription = undefined;
 
@@ -170,6 +173,14 @@ define([
          */
         distanceDisplayCondition : createPropertyDescriptor('distanceDisplayCondition'),
 
+        /**
+         * Gets or sets the {@link ClassificationType} Property specifying whether this polyline will classify terrain, 3D Tiles, or both when on the ground.
+         * @memberof PolylineGraphics.prototype
+         * @type {Property}
+         * @default ClassificationType.BOTH
+         */
+        classificationType : createPropertyDescriptor('classificationType'),
+
         /**
          * Gets or sets the zIndex Property specifying the ordering of the polyline. Only has an effect if `clampToGround` is true and polylines on terrain is supported.
          * @memberof RectangleGraphics.prototype
@@ -199,6 +210,7 @@ define([
         result.granularity = this.granularity;
         result.shadows = this.shadows;
         result.distanceDisplayCondition = this.distanceDisplayCondition;
+        result.classificationType = this.classificationType;
         result.zIndex = this.zIndex;
 
         return result;
@@ -227,6 +239,7 @@ define([
         this.granularity = defaultValue(this.granularity, source.granularity);
         this.shadows = defaultValue(this.shadows, source.shadows);
         this.distanceDisplayCondition = defaultValue(this.distanceDisplayCondition, source.distanceDisplayCondition);
+        this.classificationType = defaultValue(this.classificationType, source.classificationType);
         this.zIndex = defaultValue(this.zIndex, source.zIndex);
     };
 
diff --git a/Source/DataSources/PolylineVisualizer.js b/Source/DataSources/PolylineVisualizer.js
index 7bf86fc489ae..a8c7b9d7925a 100644
--- a/Source/DataSources/PolylineVisualizer.js
+++ b/Source/DataSources/PolylineVisualizer.js
@@ -5,6 +5,7 @@ define([
         '../Core/defaultValue',
         '../Core/defined',
         '../Core/destroyObject',
+        '../Scene/ClassificationType',
         '../Scene/PolylineColorAppearance',
         '../Scene/PolylineMaterialAppearance',
         '../Scene/ShadowMode',
@@ -22,6 +23,7 @@ define([
         defaultValue,
         defined,
         destroyObject,
+        ClassificationType,
         PolylineColorAppearance,
         PolylineMaterialAppearance,
         ShadowMode,
@@ -52,7 +54,8 @@ define([
         }
 
         if (updater.clampToGround && updater.fillEnabled) { // Also checks for support
-            that._groundBatch.add(time, updater);
+            var classificationType = updater.classificationTypeProperty.getValue(time);
+            that._groundBatches[classificationType].add(time, updater);
             return;
         }
 
@@ -106,11 +109,12 @@ define([
         this._removedObjects = new AssociativeArray();
         this._changedObjects = new AssociativeArray();
 
+        var i;
         var numberOfShadowModes = ShadowMode.NUMBER_OF_SHADOW_MODES;
         this._colorBatches = new Array(numberOfShadowModes * 3);
         this._materialBatches = new Array(numberOfShadowModes * 3);
 
-        for (var i = 0; i < numberOfShadowModes; ++i) {
+        for (i = 0; i < numberOfShadowModes; ++i) {
             this._colorBatches[i] = new StaticGeometryColorBatch(primitives, PolylineColorAppearance, undefined, false, i); // no depth fail appearance
             this._materialBatches[i] = new StaticGeometryPerMaterialBatch(primitives, PolylineMaterialAppearance, undefined, false, i);
 
@@ -122,10 +126,15 @@ define([
         }
 
         this._dynamicBatch = new DynamicGeometryBatch(primitives, groundPrimitives);
-        // Only available for terrain classification
-        this._groundBatch = new StaticGroundPolylinePerMaterialBatch(groundPrimitives);
 
-        this._batches = this._colorBatches.concat(this._materialBatches, this._dynamicBatch, this._groundBatch);
+        var numberOfClassificationTypes = ClassificationType.NUMBER_OF_CLASSIFICATION_TYPES;
+        this._groundBatches = new Array(numberOfClassificationTypes);
+
+        for (i = 0; i < numberOfClassificationTypes; ++i) {
+            this._groundBatches[i] = new StaticGroundPolylinePerMaterialBatch(groundPrimitives, i);
+        }
+
+        this._batches = this._colorBatches.concat(this._materialBatches, this._dynamicBatch, this._groundBatches);
 
         this._subscriptions = new AssociativeArray();
         this._updaters = new AssociativeArray();
diff --git a/Source/DataSources/RectangleGraphics.js b/Source/DataSources/RectangleGraphics.js
index 9840679d75d0..0a7405c195a9 100644
--- a/Source/DataSources/RectangleGraphics.js
+++ b/Source/DataSources/RectangleGraphics.js
@@ -41,6 +41,7 @@ define([
      * @param {Property} [options.granularity=Cesium.Math.RADIANS_PER_DEGREE] A numeric Property specifying the angular distance between points on the rectangle.
      * @param {Property} [options.shadows=ShadowMode.DISABLED] An enum Property specifying whether the rectangle casts or receives shadows from each light source.
      * @param {Property} [options.distanceDisplayCondition] A Property specifying at what distance from the camera that this rectangle will be displayed.
+     * @param {Property} [options.classificationType=ClassificationType.BOTH] A Property specifying whether this rectangle will classify terrain, 3D Tiles, or both when on the ground.
      * @param {Property} [options.zIndex=0] A Property specifying the zIndex used for ordering ground geometry.  Only has an effect if the rectangle is constant and neither height or extrudedHeight are specified.
      *
      * @see Entity
@@ -234,7 +235,7 @@ define([
          * Gets or sets the {@link ClassificationType} Property specifying whether this rectangle will classify terrain, 3D Tiles, or both when on the ground.
          * @memberof RectangleGraphics.prototype
          * @type {Property}
-         * @default ClassificationType.TERRAIN
+         * @default ClassificationType.BOTH
          */
         classificationType : createPropertyDescriptor('classificationType'),
 
diff --git a/Source/DataSources/StaticGroundPolylinePerMaterialBatch.js b/Source/DataSources/StaticGroundPolylinePerMaterialBatch.js
index 5770e15b8183..399348c4c529 100644
--- a/Source/DataSources/StaticGroundPolylinePerMaterialBatch.js
+++ b/Source/DataSources/StaticGroundPolylinePerMaterialBatch.js
@@ -37,7 +37,7 @@ define([
     var defaultDistanceDisplayCondition = new DistanceDisplayCondition();
 
     // Encapsulates a Primitive and all the entities that it represents.
-    function Batch(orderedGroundPrimitives, materialProperty, zIndex, asynchronous) {
+    function Batch(orderedGroundPrimitives, classificationType, materialProperty, zIndex, asynchronous) {
         var appearanceType;
         if (materialProperty instanceof ColorMaterialProperty) {
             appearanceType = PolylineColorAppearance;
@@ -46,6 +46,7 @@ define([
         }
 
         this.orderedGroundPrimitives = orderedGroundPrimitives; // scene level primitive collection
+        this.classificationType = classificationType;
         this.appearanceType = appearanceType;
         this.materialProperty = materialProperty;
         this.updaters = new AssociativeArray();
@@ -139,7 +140,8 @@ define([
                     show : false,
                     asynchronous : this._asynchronous,
                     geometryInstances : geometries,
-                    appearance : new this.appearanceType()
+                    appearance : new this.appearanceType(),
+                    classificationType : this.classificationType
                 });
 
                 if (this.appearanceType === PolylineMaterialAppearance) {
@@ -278,9 +280,10 @@ define([
     /**
      * @private
      */
-    function StaticGroundPolylinePerMaterialBatch(orderedGroundPrimitives, asynchronous) {
+    function StaticGroundPolylinePerMaterialBatch(orderedGroundPrimitives, classificationType, asynchronous) {
         this._items = [];
         this._orderedGroundPrimitives = orderedGroundPrimitives;
+        this._classificationType = classificationType;
         this._asynchronous = defaultValue(asynchronous, true);
     }
 
@@ -299,7 +302,7 @@ define([
             }
         }
         // If a compatible batch wasn't found, create a new batch.
-        var batch = new Batch(this._orderedGroundPrimitives, updater.fillMaterialProperty, zIndex, this._asynchronous);
+        var batch = new Batch(this._orderedGroundPrimitives, this._classificationType, updater.fillMaterialProperty, zIndex, this._asynchronous);
         batch.add(time, updater, geometryInstance);
         items.push(batch);
     };
diff --git a/Specs/DataSources/PolylineGraphicsSpec.js b/Specs/DataSources/PolylineGraphicsSpec.js
index 97a69c5a8a19..b44bb4244dfe 100644
--- a/Specs/DataSources/PolylineGraphicsSpec.js
+++ b/Specs/DataSources/PolylineGraphicsSpec.js
@@ -4,6 +4,7 @@ defineSuite([
         'Core/DistanceDisplayCondition',
         'DataSources/ColorMaterialProperty',
         'DataSources/ConstantProperty',
+        'Scene/ClassificationType',
         'Scene/ShadowMode',
         'Specs/testDefinitionChanged',
         'Specs/testMaterialDefinitionChanged'
@@ -13,6 +14,7 @@ defineSuite([
         DistanceDisplayCondition,
         ColorMaterialProperty,
         ConstantProperty,
+        ClassificationType,
         ShadowMode,
         testDefinitionChanged,
     testMaterialDefinitionChanged) {
@@ -30,6 +32,7 @@ defineSuite([
             granularity : 2,
             shadows : ShadowMode.DISABLED,
             distanceDisplayCondition : new DistanceDisplayCondition(),
+            classificationType : ClassificationType.TERRAIN,
             zIndex : 0
         };
 
@@ -44,6 +47,7 @@ defineSuite([
         expect(polyline.granularity).toBeInstanceOf(ConstantProperty);
         expect(polyline.shadows).toBeInstanceOf(ConstantProperty);
         expect(polyline.distanceDisplayCondition).toBeInstanceOf(ConstantProperty);
+        expect(polyline.classificationType).toBeInstanceOf(ConstantProperty);
         expect(polyline.zIndex).toBeInstanceOf(ConstantProperty);
 
         expect(polyline.material.color.getValue()).toEqual(options.material);
@@ -56,6 +60,7 @@ defineSuite([
         expect(polyline.granularity.getValue()).toEqual(options.granularity);
         expect(polyline.shadows.getValue()).toEqual(options.shadows);
         expect(polyline.distanceDisplayCondition.getValue()).toEqual(options.distanceDisplayCondition);
+        expect(polyline.classificationType.getValue()).toEqual(options.classificationType);
         expect(polyline.zIndex.getValue()).toEqual(options.zIndex);
     });
 
@@ -71,6 +76,7 @@ defineSuite([
         source.granularity = new ConstantProperty();
         source.shadows = new ConstantProperty(ShadowMode.ENABLED);
         source.distanceDisplayCondition = new ConstantProperty(new DistanceDisplayCondition());
+        source.classificationType = new ConstantProperty(ClassificationType.TERRAIN);
         source.zIndex = new ConstantProperty();
 
         var target = new PolylineGraphics();
@@ -85,6 +91,7 @@ defineSuite([
         expect(target.granularity).toBe(source.granularity);
         expect(target.shadows).toBe(source.shadows);
         expect(target.distanceDisplayCondition).toBe(source.distanceDisplayCondition);
+        expect(target.classificationType).toBe(source.classificationType);
         expect(target.zIndex).toBe(source.zIndex);
     });
 
@@ -100,6 +107,7 @@ defineSuite([
         source.granularity = new ConstantProperty();
         source.shadows = new ConstantProperty();
         source.distanceDisplayCondition = new ConstantProperty();
+        source.classificationType = new ConstantProperty();
         source.zIndex = new ConstantProperty();
 
         var color = new ColorMaterialProperty();
@@ -112,6 +120,7 @@ defineSuite([
         var granularity = new ConstantProperty();
         var shadows = new ConstantProperty();
         var distanceDisplayCondition = new ConstantProperty();
+        var classificationType = new ConstantProperty();
         var zIndex = new ConstantProperty();
 
         var target = new PolylineGraphics();
@@ -125,6 +134,7 @@ defineSuite([
         target.granularity = granularity;
         target.shadows = shadows;
         target.distanceDisplayCondition = distanceDisplayCondition;
+        target.classificationType = classificationType;
         target.zIndex = zIndex;
 
         target.merge(source);
@@ -138,6 +148,7 @@ defineSuite([
         expect(target.granularity).toBe(granularity);
         expect(target.shadows).toBe(shadows);
         expect(target.distanceDisplayCondition).toBe(distanceDisplayCondition);
+        expect(target.classificationType).toBe(classificationType);
         expect(target.zIndex).toBe(zIndex);
     });
 
@@ -153,6 +164,7 @@ defineSuite([
         source.granularity = new ConstantProperty();
         source.shadows = new ConstantProperty();
         source.distanceDisplayCondition = new ConstantProperty();
+        source.classificationType = new ConstantProperty();
         source.zIndex = new ConstantProperty();
 
         var result = source.clone();
@@ -166,6 +178,7 @@ defineSuite([
         expect(result.granularity).toBe(source.granularity);
         expect(result.shadows).toBe(source.shadows);
         expect(result.distanceDisplayCondition).toBe(source.distanceDisplayCondition);
+        expect(result.classificationType).toBe(source.classificationType);
         expect(result.zIndex).toBe(source.zIndex);
     });
 
@@ -188,6 +201,7 @@ defineSuite([
         testDefinitionChanged(property, 'granularity', 2, 1);
         testDefinitionChanged(property, 'shadows', ShadowMode.ENABLED, ShadowMode.DISABLED);
         testDefinitionChanged(property, 'distanceDisplayCondition', new DistanceDisplayCondition(), new DistanceDisplayCondition(10.0, 20.0));
+        testDefinitionChanged(property, 'classificationType', ClassificationType.TERRAIN);
         testDefinitionChanged(property, 'zIndex', 20, 5);
     });
 });
diff --git a/Specs/DataSources/PolylineVisualizerSpec.js b/Specs/DataSources/PolylineVisualizerSpec.js
index 34722cf0a608..26dd30e51bcc 100644
--- a/Specs/DataSources/PolylineVisualizerSpec.js
+++ b/Specs/DataSources/PolylineVisualizerSpec.js
@@ -16,6 +16,7 @@ defineSuite([
         'DataSources/EntityCollection',
         'DataSources/PolylineArrowMaterialProperty',
         'DataSources/PolylineGraphics',
+        'Scene/ClassificationType',
         'Scene/PolylineColorAppearance',
         'Scene/PolylineMaterialAppearance',
         'Scene/ShadowMode',
@@ -40,6 +41,7 @@ defineSuite([
         EntityCollection,
         PolylineArrowMaterialProperty,
         PolylineGraphics,
+        ClassificationType,
         PolylineColorAppearance,
         PolylineMaterialAppearance,
         ShadowMode,
@@ -158,7 +160,7 @@ defineSuite([
         }
 
         var objects = new EntityCollection();
-        var visualizer = new PolylineVisualizer(scene, objects, scene.groundPrimitives);
+        var visualizer = new PolylineVisualizer(scene, objects);
 
         var polyline = new PolylineGraphics();
         polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
@@ -415,6 +417,54 @@ defineSuite([
         });
     });
 
+    function createAndRemoveGeometryWithClassificationType(classificationType) {
+        var objects = new EntityCollection();
+        var visualizer = new PolylineVisualizer(scene, objects);
+
+        var polyline = new PolylineGraphics();
+        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
+        polyline.material = new ColorMaterialProperty();
+        polyline.classificationType = new ConstantProperty(classificationType);
+        polyline.clampToGround = true;
+
+        var entity = new Entity();
+        entity.polyline = polyline;
+        objects.add(entity);
+
+        return pollToPromise(function() {
+            scene.initializeFrame();
+            var isUpdated = visualizer.update(time);
+            scene.render(time);
+            return isUpdated;
+        }).then(function() {
+            var primitive = scene.groundPrimitives.get(0);
+            expect(primitive.classificationType).toBe(classificationType);
+
+            objects.remove(entity);
+
+            return pollToPromise(function() {
+                scene.initializeFrame();
+                expect(visualizer.update(time)).toBe(true);
+                scene.render(time);
+                return scene.primitives.length === 0;
+            }).then(function(){
+                visualizer.destroy();
+            });
+        });
+    }
+
+    it('Creates and removes geometry classifying terrain', function() {
+        return createAndRemoveGeometryWithClassificationType(ClassificationType.TERRAIN);
+    });
+
+    it('Creates and removes geometry classifying 3D Tiles', function() {
+        return createAndRemoveGeometryWithClassificationType(ClassificationType.CESIUM_3D_TILE);
+    });
+
+    it('Creates and removes geometry classifying both terrain and 3D Tiles', function() {
+        return createAndRemoveGeometryWithClassificationType(ClassificationType.BOTH);
+    });
+
     it('Correctly handles geometry changing batches', function() {
         var objects = new EntityCollection();
         var visualizer = new PolylineVisualizer(scene, objects);
@@ -719,7 +769,7 @@ defineSuite([
         }
 
         var objects = new EntityCollection();
-        var visualizer = new PolylineVisualizer(scene, objects, scene.groundPrimitives);
+        var visualizer = new PolylineVisualizer(scene, objects);
 
         var polyline = new PolylineGraphics();
         polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
@@ -759,4 +809,110 @@ defineSuite([
             visualizer.destroy();
         });
     });
+
+    it('batches ground poylines by material if ground polylines are supported', function() {
+        if (!Entity.supportsPolylinesOnTerrain(scene)) {
+            return;
+        }
+
+        var entities = new EntityCollection();
+        var visualizer = new PolylineVisualizer(scene, entities);
+
+        var blueColor = Color.BLUE.withAlpha(0.5);
+        var redColor = Color.RED.withAlpha(0.5);
+        var positions = [Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)];
+        entities.add({
+            polyline : {
+                positions : positions,
+                material : blueColor,
+                classificationType : ClassificationType.TERRAIN,
+                clampToGround : true
+            }
+        });
+
+        return pollToPromise(function() {
+            scene.initializeFrame();
+            var isUpdated = visualizer.update(time);
+            scene.render(time);
+            return isUpdated;
+        }).then(function() {
+            expect(scene.groundPrimitives.length).toEqual(1);
+
+            entities.add({
+                polyline : {
+                    positions : positions,
+                    material : blueColor,
+                    classificationType : ClassificationType.TERRAIN,
+                    clampToGround : true
+                }
+            });
+
+            return pollToPromise(function() {
+                scene.initializeFrame();
+                var isUpdated = visualizer.update(time);
+                scene.render(time);
+                return isUpdated;
+            });
+        }).then(function() {
+            expect(scene.groundPrimitives.length).toEqual(1);
+
+            entities.add({
+                polyline : {
+                    positions : positions,
+                    material : redColor,
+                    classificationType : ClassificationType.TERRAIN,
+                    clampToGround : true
+                }
+            });
+
+            return pollToPromise(function() {
+                scene.initializeFrame();
+                var isUpdated = visualizer.update(time);
+                scene.render(time);
+                return isUpdated;
+            });
+        }).then(function() {
+            expect(scene.groundPrimitives.length).toEqual(1);
+
+            entities.add({
+                polyline : {
+                    positions : positions,
+                    material : new PolylineArrowMaterialProperty(),
+                    classificationType : ClassificationType.TERRAIN,
+                    clampToGround : true
+                }
+            });
+
+            return pollToPromise(function() {
+                scene.initializeFrame();
+                var isUpdated = visualizer.update(time);
+                scene.render(time);
+                return isUpdated;
+            });
+        }).then(function() {
+            expect(scene.groundPrimitives.length).toEqual(2);
+
+            entities.add({
+                polyline : {
+                    positions : positions,
+                    material : new PolylineArrowMaterialProperty(),
+                    classificationType : ClassificationType.CESIUM_3D_TILE,
+                    clampToGround : true
+                }
+            });
+
+            return pollToPromise(function() {
+                scene.initializeFrame();
+                var isUpdated = visualizer.update(time);
+                scene.render(time);
+                return isUpdated;
+            });
+        }).then(function() {
+            expect(scene.groundPrimitives.length).toEqual(3);
+
+            entities.removeAll();
+            visualizer.destroy();
+        });
+    });
+
 }, 'WebGL');
diff --git a/Specs/DataSources/StaticGroundPolylinePerMaterialBatchSpec.js b/Specs/DataSources/StaticGroundPolylinePerMaterialBatchSpec.js
index 6fbd74d96407..14bff2aae491 100644
--- a/Specs/DataSources/StaticGroundPolylinePerMaterialBatchSpec.js
+++ b/Specs/DataSources/StaticGroundPolylinePerMaterialBatchSpec.js
@@ -18,6 +18,7 @@ defineSuite([
         'DataSources/PolylineGeometryUpdater',
         'DataSources/PolylineGraphics',
         'DataSources/TimeIntervalCollectionProperty',
+        'Scene/ClassificationType',
         'Scene/GroundPolylinePrimitive',
         'Specs/createScene',
         'Specs/pollToPromise'
@@ -41,6 +42,7 @@ defineSuite([
         PolylineGeometryUpdater,
         PolylineGraphics,
         TimeIntervalCollectionProperty,
+        ClassificationType,
         GroundPolylinePrimitive,
         createScene,
         pollToPromise) {
@@ -90,7 +92,7 @@ defineSuite([
             return;
         }
 
-        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, false);
+        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, ClassificationType.BOTH, false);
 
         var polyline1 = createGroundPolyline();
         polyline1.material = new PolylineOutlineMaterialProperty();
@@ -151,7 +153,7 @@ defineSuite([
             polyline: polyline
         });
 
-        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, false);
+        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, ClassificationType.BOTH, false);
 
         var updater = new PolylineGeometryUpdater(entity, scene);
         batch.add(validTime, updater);
@@ -197,7 +199,7 @@ defineSuite([
             polyline: polyline
         });
 
-        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, false);
+        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, ClassificationType.BOTH, false);
 
         var updater = new PolylineGeometryUpdater(entity, scene);
         batch.add(validTime, updater);
@@ -230,7 +232,7 @@ defineSuite([
             return;
         }
 
-        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, false);
+        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, ClassificationType.BOTH, false);
 
         function buildEntity() {
             var polyline = createGroundPolyline();
@@ -299,7 +301,7 @@ defineSuite([
             return;
         }
 
-        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, false);
+        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, ClassificationType.BOTH, false);
         var polyline1 = createGroundPolyline();
         polyline1.material = Color.RED;
         var entity = new Entity({
@@ -335,7 +337,7 @@ defineSuite([
             return;
         }
 
-        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, false);
+        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, ClassificationType.BOTH, false);
 
         var polyline1 = createGroundPolyline();
         polyline1.material = new PolylineOutlineMaterialProperty();
@@ -376,7 +378,7 @@ defineSuite([
             return;
         }
 
-        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, false);
+        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, ClassificationType.BOTH, false);
 
         var polyline1 = createGroundPolyline();
         polyline1.material = new PolylineOutlineMaterialProperty();
@@ -417,7 +419,7 @@ defineSuite([
         }
 
         var resultSphere = new BoundingSphere();
-        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, false);
+        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, ClassificationType.BOTH, false);
 
         var polyline1 = createGroundPolyline();
         polyline1.material = new PolylineOutlineMaterialProperty();
@@ -457,7 +459,7 @@ defineSuite([
             // Don't fail if GroundPolylinePrimitive is not supported
             return;
         }
-        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, false);
+        batch = new StaticGroundPolylinePerMaterialBatch(scene.groundPrimitives, ClassificationType.BOTH, false);
 
         function buildEntity() {
             var polyline = createGroundPolyline();

From 35223886842533c8ece36c53a4f5d6c8f1921cd2 Mon Sep 17 00:00:00 2001
From: Sean Lilley <lilleyse@gmail.com>
Date: Sat, 22 Dec 2018 15:04:44 -0500
Subject: [PATCH 03/11] Add ground polyline to clamp to 3D Tiles demo

---
 Apps/SampleData/ClampToGround.czml            |  28 ++++++++++++++++++
 Apps/Sandcastle/gallery/Clamp to 3D Tiles.jpg | Bin 12402 -> 13200 bytes
 2 files changed, 28 insertions(+)

diff --git a/Apps/SampleData/ClampToGround.czml b/Apps/SampleData/ClampToGround.czml
index 04139df57883..9d5abaccd264 100644
--- a/Apps/SampleData/ClampToGround.czml
+++ b/Apps/SampleData/ClampToGround.czml
@@ -37,5 +37,33 @@
         0.7686388857813198
       ]
     }
+  },
+  {
+    "id": "Polyline",
+    "polyline": {
+      "positions": {
+        "cartesian": [
+          1216348.1632364073,
+          -4736348.958775471,
+          4081284.5528982095,
+          1216369.1229444197,
+          -4736377.467107148,
+          4081240.888485707
+        ]
+      },
+      "material": {
+        "polylineOutline": {
+          "color": {
+              "rgba": [255, 255, 0, 255]
+          },
+          "outlineColor": {
+              "rgba": [0, 0, 0, 255]
+          },
+          "outlineWidth": 2
+        }
+      },
+      "width": 10,
+      "clampToGround": true
+    }
   }
 ]
diff --git a/Apps/Sandcastle/gallery/Clamp to 3D Tiles.jpg b/Apps/Sandcastle/gallery/Clamp to 3D Tiles.jpg
index 711e53fc19dbb2fef7eaee9e1ddb85461407d5e2..8164f073a8e6ec1309fb11b1c4069d23ae966f58 100644
GIT binary patch
delta 13051
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
Vw#XTkhYW49nAgw^jEeo;_<#F7fX4s;

delta 12273
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
VPP%def}Z5TL6v%->D=G-{{svyEf@d*


From 2d7f4e0405c319eacc47320a001230a853f60f75 Mon Sep 17 00:00:00 2001
From: Sean Lilley <lilleyse@gmail.com>
Date: Sat, 22 Dec 2018 15:30:29 -0500
Subject: [PATCH 04/11] Doc fixes

---
 Source/DataSources/CorridorGraphics.js  | 2 +-
 Source/DataSources/EllipseGraphics.js   | 4 ++--
 Source/DataSources/Entity.js            | 2 +-
 Source/DataSources/PolygonGraphics.js   | 2 +-
 Source/DataSources/PolylineGraphics.js  | 2 +-
 Source/DataSources/RectangleGraphics.js | 2 +-
 6 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Source/DataSources/CorridorGraphics.js b/Source/DataSources/CorridorGraphics.js
index 5de15e0b003c..aef29581bf11 100644
--- a/Source/DataSources/CorridorGraphics.js
+++ b/Source/DataSources/CorridorGraphics.js
@@ -41,7 +41,7 @@ define([
      * @param {Property} [options.granularity=Cesium.Math.RADIANS_PER_DEGREE] A numeric Property specifying the distance between each latitude and longitude.
      * @param {Property} [options.shadows=ShadowMode.DISABLED] An enum Property specifying whether the corridor casts or receives shadows from each light source.
      * @param {Property} [options.distanceDisplayCondition] A Property specifying at what distance from the camera that this corridor will be displayed.
-     * @param {Property} [options.classificationType=ClassificationType.BOTH] A Property specifying whether this corridor will classify terrain, 3D Tiles, or both when on the ground.
+     * @param {Property} [options.classificationType=ClassificationType.BOTH] An enum Property specifying whether this corridor will classify terrain, 3D Tiles, or both when on the ground.
      * @param {ConstantProperty} [options.zIndex] A Property specifying the zIndex of the corridor, used for ordering.  Only has an effect if height and extrudedHeight are undefined, and if the corridor is static.
      *
      * @see Entity
diff --git a/Source/DataSources/EllipseGraphics.js b/Source/DataSources/EllipseGraphics.js
index d909defbabb6..acdf7b9e1d29 100644
--- a/Source/DataSources/EllipseGraphics.js
+++ b/Source/DataSources/EllipseGraphics.js
@@ -44,8 +44,8 @@ define([
      * @param {Property} [options.granularity=Cesium.Math.RADIANS_PER_DEGREE] A numeric Property specifying the angular distance between points on the ellipse.
      * @param {Property} [options.shadows=ShadowMode.DISABLED] An enum Property specifying whether the ellipse casts or receives shadows from each light source.
      * @param {Property} [options.distanceDisplayCondition] A Property specifying at what distance from the camera that this ellipse will be displayed.
-     * @param {Property} [options.classificationType=ClassificationType.BOTH] A Property specifying whether this ellipse will classify terrain, 3D Tiles, or both when on the ground.
-     @param {ConstantProperty} [options.zIndex=0] A property specifying the zIndex of the Ellipse.  Used for ordering ground geometry.  Only has an effect if the ellipse is constant and neither height or exturdedHeight are specified.
+     * @param {Property} [options.classificationType=ClassificationType.BOTH] An enum Property specifying whether this ellipse will classify terrain, 3D Tiles, or both when on the ground.
+     * @param {ConstantProperty} [options.zIndex=0] A property specifying the zIndex of the Ellipse.  Used for ordering ground geometry.  Only has an effect if the ellipse is constant and neither height or exturdedHeight are specified.
      *
      * @demo {@link https://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Circles and Ellipses.html|Cesium Sandcastle Circles and Ellipses Demo}
      */
diff --git a/Source/DataSources/Entity.js b/Source/DataSources/Entity.js
index 12479c976706..dae9820c5d4d 100644
--- a/Source/DataSources/Entity.js
+++ b/Source/DataSources/Entity.js
@@ -681,7 +681,7 @@ define([
      * the provided heights and using the `followSurface` parameter instead of clamped to the ground.
      *
      * @param {Scene} scene The current scene.
-     * @returns {Boolean} Whether or not the current scene supports Polylines on Terrain.
+     * @returns {Boolean} Whether or not the current scene supports polylines on terrain or 3D TIles.
      */
     Entity.supportsPolylinesOnTerrain = function(scene) {
         return GroundPolylinePrimitive.isSupported(scene);
diff --git a/Source/DataSources/PolygonGraphics.js b/Source/DataSources/PolygonGraphics.js
index c7ca77ad1258..fb65382cb61e 100644
--- a/Source/DataSources/PolygonGraphics.js
+++ b/Source/DataSources/PolygonGraphics.js
@@ -43,7 +43,7 @@ define([
      * @param {Boolean} [options.closeBottom=true] When false, leaves off the bottom of an extruded polygon open.
      * @param {Property} [options.shadows=ShadowMode.DISABLED] An enum Property specifying whether the polygon casts or receives shadows from each light source.
      * @param {Property} [options.distanceDisplayCondition] A Property specifying at what distance from the camera that this polygon will be displayed.
-     * @param {Property} [options.classificationType=ClassificationType.BOTH] A Property specifying whether this ellipse will classify terrain, 3D Tiles, or both when on the ground.
+     * @param {Property} [options.classificationType=ClassificationType.BOTH] An enum Property specifying whether this polygon will classify terrain, 3D Tiles, or both when on the ground.
      * @param {ConstantProperty} [options.zIndex=0] A property specifying the zIndex used for ordering ground geometry.  Only has an effect if the polygon is constant and neither height or extrudedHeight are specified.
      *
      * @see Entity
diff --git a/Source/DataSources/PolylineGraphics.js b/Source/DataSources/PolylineGraphics.js
index 9a79779ca4e5..8f1e912d3cfc 100644
--- a/Source/DataSources/PolylineGraphics.js
+++ b/Source/DataSources/PolylineGraphics.js
@@ -35,7 +35,7 @@ define([
      * @param {Property} [options.granularity=Cesium.Math.RADIANS_PER_DEGREE] A numeric Property specifying the angular distance between each latitude and longitude if followSurface is true.
      * @param {Property} [options.shadows=ShadowMode.DISABLED] An enum Property specifying whether the polyline casts or receives shadows from each light source.
      * @param {Property} [options.distanceDisplayCondition] A Property specifying at what distance from the camera that this polyline will be displayed.
-     * @param {Property} [options.classificationType=ClassificationType.BOTH] A Property specifying whether this polyline will classify terrain, 3D Tiles, or both when on the ground.
+     * @param {Property} [options.classificationType=ClassificationType.BOTH] An enum Property specifying whether this polyline will classify terrain, 3D Tiles, or both when on the ground.
      * @param {Property} [options.zIndex=0] A Property specifying the zIndex used for ordering ground geometry. Only has an effect if `clampToGround` is true and polylines on terrain is supported.
      *
      * @see Entity
diff --git a/Source/DataSources/RectangleGraphics.js b/Source/DataSources/RectangleGraphics.js
index 0a7405c195a9..69b251c1a684 100644
--- a/Source/DataSources/RectangleGraphics.js
+++ b/Source/DataSources/RectangleGraphics.js
@@ -41,7 +41,7 @@ define([
      * @param {Property} [options.granularity=Cesium.Math.RADIANS_PER_DEGREE] A numeric Property specifying the angular distance between points on the rectangle.
      * @param {Property} [options.shadows=ShadowMode.DISABLED] An enum Property specifying whether the rectangle casts or receives shadows from each light source.
      * @param {Property} [options.distanceDisplayCondition] A Property specifying at what distance from the camera that this rectangle will be displayed.
-     * @param {Property} [options.classificationType=ClassificationType.BOTH] A Property specifying whether this rectangle will classify terrain, 3D Tiles, or both when on the ground.
+     * @param {Property} [options.classificationType=ClassificationType.BOTH] An enum Property specifying whether this rectangle will classify terrain, 3D Tiles, or both when on the ground.
      * @param {Property} [options.zIndex=0] A Property specifying the zIndex used for ordering ground geometry.  Only has an effect if the rectangle is constant and neither height or extrudedHeight are specified.
      *
      * @see Entity

From 23a16ce0f1a555fbd94b08a81da624d2187cb753 Mon Sep 17 00:00:00 2001
From: Sean Lilley <lilleyse@gmail.com>
Date: Sat, 22 Dec 2018 15:42:48 -0500
Subject: [PATCH 05/11] Fix 2D/CV

---
 Source/Scene/GroundPolylinePrimitive.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/Scene/GroundPolylinePrimitive.js b/Source/Scene/GroundPolylinePrimitive.js
index 896aec902ed8..6dd35dda8dc2 100644
--- a/Source/Scene/GroundPolylinePrimitive.js
+++ b/Source/Scene/GroundPolylinePrimitive.js
@@ -533,7 +533,7 @@ define([
             derived2DCommand.shaderProgram = groundPolylinePrimitive._sp2D;
             command.derivedCommands.color2D = derived2DCommand;
 
-            var derived2DTilesetCommand = DrawCommand.shallowClone(command, derivedTilesetCommand.derivedCommands.color2D);
+            var derived2DTilesetCommand = DrawCommand.shallowClone(derivedTilesetCommand, derivedTilesetCommand.derivedCommands.color2D);
             derived2DTilesetCommand.shaderProgram = groundPolylinePrimitive._sp2D;
             derivedTilesetCommand.derivedCommands.color2D = derived2DTilesetCommand;
 

From 8e94c7c486b97fc71258cecc7cedf90d3caeb1b6 Mon Sep 17 00:00:00 2001
From: Sean Lilley <lilleyse@gmail.com>
Date: Sat, 22 Dec 2018 16:18:59 -0500
Subject: [PATCH 06/11] Update CHANGES.md

---
 CHANGES.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGES.md b/CHANGES.md
index 5d2532c5c69b..846b4194ec38 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -6,6 +6,8 @@ Change Log
 ##### Additions :tada:
 
 * Added support for textured ground entities (entities with unspecified `height`) and `GroundPrimitives` on 3D Tiles.
+* Added support for polylines on 3D Tiles.
+* Added `classificationType` property to `PolylineGraphics` and `GroundPolylinePrimitive` which specifies whether a polyline clamped to ground should be clamped to terrain, 3D Tiles, or both.
 
 ##### Fixes :wrench:
 * Fixed an issue where classification primitives with the `CESIUM_3D_TILE` classification type would render on terrain.

From 65821fe7b4c3d767c373fcb3a5f5dee0ad79065e Mon Sep 17 00:00:00 2001
From: Sean Lilley <lilleyse@gmail.com>
Date: Sat, 22 Dec 2018 16:27:04 -0500
Subject: [PATCH 07/11] Fix CI

---
 Specs/DataSources/PolylineVisualizerSpec.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Specs/DataSources/PolylineVisualizerSpec.js b/Specs/DataSources/PolylineVisualizerSpec.js
index 26dd30e51bcc..a3f91ebeeb99 100644
--- a/Specs/DataSources/PolylineVisualizerSpec.js
+++ b/Specs/DataSources/PolylineVisualizerSpec.js
@@ -418,6 +418,10 @@ defineSuite([
     });
 
     function createAndRemoveGeometryWithClassificationType(classificationType) {
+        if (!Entity.supportsPolylinesOnTerrain(scene)) {
+            return;
+        }
+
         var objects = new EntityCollection();
         var visualizer = new PolylineVisualizer(scene, objects);
 

From 13b82856110a35012e43f4947222c97aa6cf9b68 Mon Sep 17 00:00:00 2001
From: Sean Lilley <lilleyse@gmail.com>
Date: Wed, 2 Jan 2019 16:02:35 -0500
Subject: [PATCH 08/11] Smaller polylines to speed up tests

---
 Specs/DataSources/PolylineVisualizerSpec.js | 36 ++++++++++-----------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/Specs/DataSources/PolylineVisualizerSpec.js b/Specs/DataSources/PolylineVisualizerSpec.js
index a3f91ebeeb99..04b06751e870 100644
--- a/Specs/DataSources/PolylineVisualizerSpec.js
+++ b/Specs/DataSources/PolylineVisualizerSpec.js
@@ -81,7 +81,7 @@ defineSuite([
         var visualizer = new PolylineVisualizer(scene, objects);
 
         var polyline = new PolylineGraphics();
-        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
+        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)]);
         polyline.material = new ColorMaterialProperty();
 
         var entity = new Entity();
@@ -120,7 +120,7 @@ defineSuite([
         var visualizer = new PolylineVisualizer(scene, objects);
 
         var polyline = new PolylineGraphics();
-        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
+        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)]);
         polyline.material = new PolylineArrowMaterialProperty();
 
         var entity = new Entity();
@@ -163,7 +163,7 @@ defineSuite([
         var visualizer = new PolylineVisualizer(scene, objects);
 
         var polyline = new PolylineGraphics();
-        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
+        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)]);
         polyline.material = new ColorMaterialProperty();
         polyline.clampToGround = new ConstantProperty(true);
 
@@ -203,7 +203,7 @@ defineSuite([
         var visualizer = new PolylineVisualizer(scene, objects);
 
         var polyline = new PolylineGraphics();
-        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
+        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)]);
         polyline.material = new ColorMaterialProperty();
         polyline.shadows = new ConstantProperty(shadows);
 
@@ -254,7 +254,7 @@ defineSuite([
         var visualizer = new PolylineVisualizer(scene, objects);
 
         var polyline = new PolylineGraphics();
-        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
+        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)]);
         polyline.material = new ColorMaterialProperty();
         polyline.depthFailMaterial = new ColorMaterialProperty();
 
@@ -296,7 +296,7 @@ defineSuite([
         var visualizer = new PolylineVisualizer(scene, objects);
 
         var polyline = new PolylineGraphics();
-        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
+        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)]);
         polyline.material = new ColorMaterialProperty();
         polyline.depthFailMaterial = new PolylineArrowMaterialProperty();
 
@@ -338,7 +338,7 @@ defineSuite([
         var visualizer = new PolylineVisualizer(scene, objects);
 
         var polyline = new PolylineGraphics();
-        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
+        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)]);
         polyline.material = new PolylineArrowMaterialProperty();
         polyline.depthFailMaterial = new PolylineArrowMaterialProperty();
 
@@ -380,7 +380,7 @@ defineSuite([
         var visualizer = new PolylineVisualizer(scene, objects);
 
         var polyline = new PolylineGraphics();
-        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
+        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)]);
         polyline.material = new PolylineArrowMaterialProperty();
         polyline.depthFailMaterial = new ColorMaterialProperty();
 
@@ -426,7 +426,7 @@ defineSuite([
         var visualizer = new PolylineVisualizer(scene, objects);
 
         var polyline = new PolylineGraphics();
-        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
+        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)]);
         polyline.material = new ColorMaterialProperty();
         polyline.classificationType = new ConstantProperty(classificationType);
         polyline.clampToGround = true;
@@ -474,7 +474,7 @@ defineSuite([
         var visualizer = new PolylineVisualizer(scene, objects);
 
         var polyline = new PolylineGraphics();
-        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
+        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)]);
         polyline.material = new ColorMaterialProperty();
 
         var entity = new Entity();
@@ -527,7 +527,7 @@ defineSuite([
 
         var polyline = new PolylineGraphics();
         polyline.positions = new CallbackProperty(function() {
-            return [Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)];
+            return [Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)];
         }, false);
         polyline.material = new ColorMaterialProperty();
 
@@ -574,7 +574,7 @@ defineSuite([
         var visualizer = new PolylineVisualizer(scene, entityCollection);
 
         var polyline = new PolylineGraphics();
-        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
+        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)]);
         polyline.material = new PolylineArrowMaterialProperty();
 
         var entity = new Entity();
@@ -632,7 +632,7 @@ defineSuite([
         var entity = new Entity({
             id : 'test',
             polyline : {
-                positions: [Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)],
+                positions: [Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)],
                 material: Color.ORANGE
             }
         });
@@ -650,7 +650,7 @@ defineSuite([
                 id : 'test',
                 position : Cartesian3.fromDegrees(0, 0, 0),
                 polyline : {
-                    positions: [Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)],
+                    positions: [Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)],
                     material : Color.BLUE
                 }
             });
@@ -690,7 +690,7 @@ defineSuite([
 
         var entity = entities.add({
             polyline : {
-                positions: [Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)],
+                positions: [Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)],
                 material : new ColorMaterialProperty(createDynamicProperty(Color.BLUE))
             }
         });
@@ -732,7 +732,7 @@ defineSuite([
         var entity = entities.add({
             position : new Cartesian3(1234, 5678, 9101112),
             polyline : {
-                positions: [Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)],
+                positions: [Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)],
                 material : new PolylineArrowMaterialProperty(createDynamicProperty(Color.BLUE))
             }
         });
@@ -776,7 +776,7 @@ defineSuite([
         var visualizer = new PolylineVisualizer(scene, objects);
 
         var polyline = new PolylineGraphics();
-        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)]);
+        polyline.positions = new ConstantProperty([Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)]);
         polyline.material = new ColorMaterialProperty();
         polyline.clampToGround = new ConstantProperty(true);
 
@@ -824,7 +824,7 @@ defineSuite([
 
         var blueColor = Color.BLUE.withAlpha(0.5);
         var redColor = Color.RED.withAlpha(0.5);
-        var positions = [Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 1.0)];
+        var positions = [Cartesian3.fromDegrees(0.0, 0.0), Cartesian3.fromDegrees(0.0, 0.000001)];
         entities.add({
             polyline : {
                 positions : positions,

From 56b63d191ab9099d9f5996856a3ca1e60722339f Mon Sep 17 00:00:00 2001
From: Sean Lilley <lilleyse@gmail.com>
Date: Wed, 2 Jan 2019 16:34:33 -0500
Subject: [PATCH 09/11] Wrap pollToPromise blocks

---
 Specs/DataSources/GeometryVisualizerSpec.js | 264 ++++----------------
 Specs/DataSources/PolylineVisualizerSpec.js | 257 ++++---------------
 2 files changed, 105 insertions(+), 416 deletions(-)

diff --git a/Specs/DataSources/GeometryVisualizerSpec.js b/Specs/DataSources/GeometryVisualizerSpec.js
index 489d7694c243..f7f0ba49c965 100644
--- a/Specs/DataSources/GeometryVisualizerSpec.js
+++ b/Specs/DataSources/GeometryVisualizerSpec.js
@@ -82,6 +82,24 @@ defineSuite([
 
     });
 
+    function visualizerUpdated(visualizer) {
+        return pollToPromise(function() {
+            scene.initializeFrame();
+            var isUpdated = visualizer.update(time);
+            scene.render(time);
+            return isUpdated;
+        });
+    }
+
+    function visualizerEmpty(visualizer) {
+        return pollToPromise(function() {
+            scene.initializeFrame();
+            expect(visualizer.update(time)).toBe(true);
+            scene.render(time);
+            return scene.primitives.length === 0 && scene.groundPrimitives.length === 0;
+        });
+    }
+
     it('Can create and destroy', function() {
         var objects = new EntityCollection();
         var visualizer = new GeometryVisualizer(scene, objects, scene.primitives, scene.groundPrimitives);
@@ -107,12 +125,7 @@ defineSuite([
         entity.ellipse = ellipse;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -123,12 +136,7 @@ defineSuite([
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -149,12 +157,7 @@ defineSuite([
         entity.ellipse = ellipse;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -165,12 +168,7 @@ defineSuite([
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -191,12 +189,7 @@ defineSuite([
         entity.ellipse = ellipse;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -207,12 +200,7 @@ defineSuite([
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -233,12 +221,7 @@ defineSuite([
         entity.ellipse = ellipse;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -249,12 +232,7 @@ defineSuite([
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -276,12 +254,7 @@ defineSuite([
         entity.ellipse = ellipse;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -291,12 +264,7 @@ defineSuite([
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -318,23 +286,13 @@ defineSuite([
         entity.ellipse = ellipse;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             expect(primitive.shadows).toBe(shadows);
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -371,23 +329,13 @@ defineSuite([
         entity.ellipse = ellipse;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.groundPrimitives.get(0);
             expect(primitive.classificationType).toBe(type);
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -420,12 +368,7 @@ defineSuite([
         entity.ellipse = ellipse;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -435,12 +378,7 @@ defineSuite([
 
             ellipse.material = new GridMaterialProperty();
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            }).then(function() {
+            return visualizerUpdated(visualizer).then(function() {
                 primitive = scene.primitives.get(0);
                 attributes = primitive.getGeometryInstanceAttributes(entity);
                 expect(attributes).toBeDefined();
@@ -476,12 +414,7 @@ defineSuite([
             }
         });
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -490,12 +423,7 @@ defineSuite([
             color = Color.RED.withAlpha(0.5);
             entity.ellipse.outlineColor.setValue(color);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
@@ -662,12 +590,7 @@ defineSuite([
         });
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             objects.remove(entity);
 
             var entity2 = new Entity({
@@ -682,13 +605,7 @@ defineSuite([
             });
             objects.add(entity2);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            }).then(function() {
-
+            return visualizerUpdated(visualizer).then(function() {
                 var primitive = scene.primitives.get(0);
                 var attributes = primitive.getGeometryInstanceAttributes(entity2);
                 expect(attributes).toBeDefined();
@@ -698,12 +615,7 @@ defineSuite([
 
                 objects.remove(entity);
 
-                return pollToPromise(function() {
-                    scene.initializeFrame();
-                    expect(visualizer.update(time)).toBe(true);
-                    scene.render(time);
-                    return scene.primitives.length === 0;
-                }).then(function() {
+                return visualizerEmpty(visualizer).then(function() {
                     visualizer.destroy();
                 });
             });
@@ -724,12 +636,7 @@ defineSuite([
             }
         });
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -737,12 +644,7 @@ defineSuite([
 
             entity.show = false;
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
@@ -769,12 +671,7 @@ defineSuite([
             }
         });
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -782,12 +679,7 @@ defineSuite([
 
             entity.show = false;
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
@@ -815,12 +707,7 @@ defineSuite([
             }
         });
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -828,12 +715,7 @@ defineSuite([
 
             entity.show = false;
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
@@ -862,12 +744,7 @@ defineSuite([
             }
         });
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             expect(scene.groundPrimitives.length).toEqual(1);
 
             entities.add({
@@ -879,12 +756,7 @@ defineSuite([
                 }
             });
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             expect(scene.groundPrimitives.length).toEqual(1);
 
@@ -897,12 +769,7 @@ defineSuite([
                 }
             });
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             expect(scene.groundPrimitives.length).toEqual(2);
 
@@ -930,12 +797,7 @@ defineSuite([
             }
         });
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             expect(scene.groundPrimitives.length).toEqual(1);
 
             entities.add({
@@ -948,12 +810,7 @@ defineSuite([
                 }
             });
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             expect(scene.groundPrimitives.length).toEqual(1);
 
@@ -967,12 +824,7 @@ defineSuite([
                 }
             });
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             expect(scene.groundPrimitives.length).toEqual(1);
 
@@ -986,12 +838,7 @@ defineSuite([
                 }
             });
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             expect(scene.groundPrimitives.length).toEqual(2);
 
@@ -1005,12 +852,7 @@ defineSuite([
                 }
             });
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             expect(scene.groundPrimitives.length).toEqual(3);
 
diff --git a/Specs/DataSources/PolylineVisualizerSpec.js b/Specs/DataSources/PolylineVisualizerSpec.js
index 04b06751e870..e288753d9002 100644
--- a/Specs/DataSources/PolylineVisualizerSpec.js
+++ b/Specs/DataSources/PolylineVisualizerSpec.js
@@ -66,6 +66,24 @@ defineSuite([
         ApproximateTerrainHeights._terrainHeights = undefined;
     });
 
+    function visualizerUpdated(visualizer) {
+        return pollToPromise(function() {
+            scene.initializeFrame();
+            var isUpdated = visualizer.update(time);
+            scene.render(time);
+            return isUpdated;
+        });
+    }
+
+    function visualizerEmpty(visualizer) {
+        return pollToPromise(function() {
+            scene.initializeFrame();
+            expect(visualizer.update(time)).toBe(true);
+            scene.render(time);
+            return scene.primitives.length === 0 && scene.groundPrimitives.length === 0;
+        });
+    }
+
     it('Can create and destroy', function() {
         var objects = new EntityCollection();
         var visualizer = new PolylineVisualizer(scene, objects);
@@ -88,12 +106,7 @@ defineSuite([
         entity.polyline = polyline;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -104,12 +117,7 @@ defineSuite([
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -127,12 +135,7 @@ defineSuite([
         entity.polyline = polyline;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -143,12 +146,7 @@ defineSuite([
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -171,12 +169,7 @@ defineSuite([
         entity.polyline = polyline;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.groundPrimitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -187,12 +180,7 @@ defineSuite([
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.groundPrimitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -211,23 +199,13 @@ defineSuite([
         entity.polyline = polyline;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             expect(primitive.shadows).toBe(shadows);
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -263,12 +241,7 @@ defineSuite([
         entity.polyline = polyline;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -280,12 +253,7 @@ defineSuite([
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -305,12 +273,7 @@ defineSuite([
         entity.polyline = polyline;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -322,12 +285,7 @@ defineSuite([
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -347,12 +305,7 @@ defineSuite([
         entity.polyline = polyline;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -364,12 +317,7 @@ defineSuite([
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -389,12 +337,7 @@ defineSuite([
         entity.polyline = polyline;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -406,12 +349,7 @@ defineSuite([
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -435,23 +373,13 @@ defineSuite([
         entity.polyline = polyline;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.groundPrimitives.get(0);
             expect(primitive.classificationType).toBe(classificationType);
 
             objects.remove(entity);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                expect(visualizer.update(time)).toBe(true);
-                scene.render(time);
-                return scene.primitives.length === 0;
-            }).then(function(){
+            return visualizerEmpty(visualizer).then(function(){
                 visualizer.destroy();
             });
         });
@@ -481,12 +409,7 @@ defineSuite([
         entity.polyline = polyline;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -496,12 +419,7 @@ defineSuite([
 
             polyline.material = new PolylineArrowMaterialProperty();
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            }).then(function() {
+            return visualizerUpdated(visualizer).then(function() {
                 primitive = scene.primitives.get(0);
                 attributes = primitive.getGeometryInstanceAttributes(entity);
                 expect(attributes).toBeDefined();
@@ -638,12 +556,7 @@ defineSuite([
         });
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             objects.remove(entity);
 
             var entity2 = new Entity({
@@ -656,13 +569,7 @@ defineSuite([
             });
             objects.add(entity2);
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            }).then(function() {
-
+            return visualizerUpdated(visualizer).then(function() {
                 var primitive = scene.primitives.get(0);
                 var attributes = primitive.getGeometryInstanceAttributes(entity2);
                 expect(attributes).toBeDefined();
@@ -672,12 +579,7 @@ defineSuite([
 
                 objects.remove(entity);
 
-                return pollToPromise(function() {
-                    scene.initializeFrame();
-                    expect(visualizer.update(time)).toBe(true);
-                    scene.render(time);
-                    return scene.primitives.length === 0;
-                }).then(function() {
+                return visualizerEmpty(visualizer).then(function() {
                     visualizer.destroy();
                 });
             });
@@ -695,12 +597,7 @@ defineSuite([
             }
         });
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -708,12 +605,7 @@ defineSuite([
 
             entity.show = false;
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
@@ -737,12 +629,7 @@ defineSuite([
             }
         });
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -750,12 +637,7 @@ defineSuite([
 
             entity.show = false;
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             var primitive = scene.primitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
@@ -784,12 +666,7 @@ defineSuite([
         entity.polyline = polyline;
         objects.add(entity);
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             var primitive = scene.groundPrimitives.get(0);
             var attributes = primitive.getGeometryInstanceAttributes(entity);
             expect(attributes).toBeDefined();
@@ -800,12 +677,7 @@ defineSuite([
 
             entity.polyline.show = false;
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             expect(scene.primitives.length).toEqual(0);
 
@@ -834,12 +706,7 @@ defineSuite([
             }
         });
 
-        return pollToPromise(function() {
-            scene.initializeFrame();
-            var isUpdated = visualizer.update(time);
-            scene.render(time);
-            return isUpdated;
-        }).then(function() {
+        return visualizerUpdated(visualizer).then(function() {
             expect(scene.groundPrimitives.length).toEqual(1);
 
             entities.add({
@@ -851,12 +718,7 @@ defineSuite([
                 }
             });
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             expect(scene.groundPrimitives.length).toEqual(1);
 
@@ -869,12 +731,7 @@ defineSuite([
                 }
             });
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             expect(scene.groundPrimitives.length).toEqual(1);
 
@@ -887,12 +744,7 @@ defineSuite([
                 }
             });
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             expect(scene.groundPrimitives.length).toEqual(2);
 
@@ -905,12 +757,7 @@ defineSuite([
                 }
             });
 
-            return pollToPromise(function() {
-                scene.initializeFrame();
-                var isUpdated = visualizer.update(time);
-                scene.render(time);
-                return isUpdated;
-            });
+            return visualizerUpdated(visualizer);
         }).then(function() {
             expect(scene.groundPrimitives.length).toEqual(3);
 

From 2616eeed0fd8a3364818e27bee30c18ac0e02369 Mon Sep 17 00:00:00 2001
From: Sean Lilley <lilleyse@gmail.com>
Date: Wed, 2 Jan 2019 17:32:15 -0500
Subject: [PATCH 10/11] Remove unneeded shader checks

---
 Source/Scene/GroundPolylinePrimitive.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Source/Scene/GroundPolylinePrimitive.js b/Source/Scene/GroundPolylinePrimitive.js
index 6dd35dda8dc2..b8ebf53ea7a9 100644
--- a/Source/Scene/GroundPolylinePrimitive.js
+++ b/Source/Scene/GroundPolylinePrimitive.js
@@ -548,9 +548,9 @@ define([
 
     function updateAndQueueCommand(groundPolylinePrimitive, command, frameState, modelMatrix, cull, boundingVolume, debugShowBoundingVolume) {
         // Use derived appearance command for morph and 2D
-        if (frameState.mode === SceneMode.MORPHING && command.shaderProgram !== groundPolylinePrimitive._spMorph) {
+        if (frameState.mode === SceneMode.MORPHING) {
             command = command.derivedCommands.colorMorph;
-        } else if (frameState.mode !== SceneMode.SCENE3D && command.shaderProgram !== groundPolylinePrimitive._sp2D) {
+        } else if (frameState.mode !== SceneMode.SCENE3D) {
             command = command.derivedCommands.color2D;
         }
         command.modelMatrix = modelMatrix;

From 3729e7054994eb8861cb643212110cd324d90d77 Mon Sep 17 00:00:00 2001
From: Sean Lilley <lilleyse@gmail.com>
Date: Wed, 2 Jan 2019 17:47:53 -0500
Subject: [PATCH 11/11] Update Sandcastle demo

---
 .../gallery/Classification Types.html         | 40 ++++++++++++++++---
 1 file changed, 34 insertions(+), 6 deletions(-)

diff --git a/Apps/Sandcastle/gallery/Classification Types.html b/Apps/Sandcastle/gallery/Classification Types.html
index c1d6c8d3d4b4..59a8182ed9da 100644
--- a/Apps/Sandcastle/gallery/Classification Types.html	
+++ b/Apps/Sandcastle/gallery/Classification Types.html	
@@ -40,7 +40,7 @@
     viewer.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);
 });
 
-var entity = viewer.entities.add({
+var polygon = viewer.entities.add({
     polygon : {
         hierarchy : new Cesium.PolygonHierarchy(Cesium.Cartesian3.fromRadiansArray([-1.3194369277314022, 0.6988062530900625, -1.3193955980204217, 0.6988091578771254, -1.3193931220959367, 0.698743632490865, -1.3194358224045408, 0.6987471965556998])),
         material : Cesium.Color.RED.withAlpha(0.5),
@@ -48,32 +48,60 @@
     }
 });
 
+var polyline = viewer.entities.add({
+    polyline : {
+        positions : Cesium.Cartesian3.fromDegreesArray([
+            -75.60217330403601, 40.04102882709425,
+            -75.59968252414251, 40.04093615560871,
+            -75.59802015382800, 40.04079437042357,
+            -75.59674934074435, 40.040816173283304,
+            -75.59630042791713, 40.03986900370842,
+            -75.59563636849978, 40.03930996506271,
+            -75.59492397899098, 40.03873932846581,
+            -75.59457991226778, 40.038392701955786,
+            -75.59424838652453, 40.03775403572295,
+            -75.59387104290336, 40.03677022167725,
+            -75.59355000490342, 40.03588760913535
+        ]),
+        width : 8,
+        material : new Cesium.PolylineOutlineMaterialProperty({
+            color : Cesium.Color.YELLOW,
+            outlineWidth : 2,
+            outlineColor : Cesium.Color.BLACK
+        }),
+        clampToGround : true
+    }
+});
+
 var classificationOptions = [{
     text : 'Classify Both',
     onselect : function() {
-        entity.polygon.classificationType = Cesium.ClassificationType.BOTH;
+        polygon.polygon.classificationType = Cesium.ClassificationType.BOTH;
+        polyline.polyline.classificationType = Cesium.ClassificationType.BOTH;
     }
 }, {
     text : 'Classify Terrain',
     onselect : function() {
-        entity.polygon.classificationType = Cesium.ClassificationType.TERRAIN;
+        polygon.polygon.classificationType = Cesium.ClassificationType.TERRAIN;
+        polyline.polyline.classificationType = Cesium.ClassificationType.TERRAIN;
     }
 }, {
     text : 'Classify 3D Tiles',
     onselect : function() {
-        entity.polygon.classificationType = Cesium.ClassificationType.CESIUM_3D_TILE;
+        polygon.polygon.classificationType = Cesium.ClassificationType.CESIUM_3D_TILE;
+        polyline.polyline.classificationType = Cesium.ClassificationType.CESIUM_3D_TILE;
     }
 }];
 
 var materialOptions = [{
     text : 'Red Material',
     onselect : function() {
-        entity.polygon.material = Cesium.Color.RED.withAlpha(0.5);
+        polygon.polygon.material = Cesium.Color.RED.withAlpha(0.5);
     }
 }, {
     text : 'Textured Material',
     onselect : function() {
-        entity.polygon.material = '../images/Cesium_Logo_Color.jpg';
+        polygon.polygon.material = '../images/Cesium_Logo_Color.jpg';
     }
 }];