Merge branch 'master' into 5819_fix_for_empty_icon_tag

Author: Joshua Bernstein

Apps/Sandcastle/gallery/Classification.html

@@ -2,7 +2,10 @@ Change Log
 ==========
 ### 1.39 - 2017-11-01
 
+* Added function that inserts missing namespace declarations into KML files. [#5860](https://github.com/AnalyticalGraphicsInc/cesium/pull/5860)
 * Added support for the layer.json `parentUrl` property in `CesiumTerrainProvider` to allow for compositing of tilesets.
+* Fixed a bug that caused KML ground overlays to appear distorted when rotation was applied. [#5914](https://github.com/AnalyticalGraphicsInc/cesium/issues/5914)
+* Adds `invertClassification` and `invertClassificationColor` to `Scene`. When `invertClassification` is `true`, any 3D Tiles geometry that is not classified by a `ClassificationPrimitive` or `GroundPrimitive` will have its color multiplied by `invertClassificationColor`. [#5836](https://github.com/AnalyticalGraphicsInc/cesium/pull/5836)
 * Fixed bug with placemarks in imported KML: placemarks with no specified icon would be displayed with default icon. [#5819](https://github.com/AnalyticalGraphicsInc/cesium/issues/5819)
 
 ### 1.38 - 2017-10-02

CHANGES.md

@@ -94,6 +94,8 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to Cesiu
    * [Florent Cayré](https://github.com/fcayre/)
 * [Novetta](http://www.novetta.com/)
    * [Joshua Bernstein](https://github.com/jbernstein/)
+   * [Natanael Rivera](https://github.com/nrivera-Novetta/)
+   * [Justin Burr](https://github.com/jburr-nc/)
 
 ## [Individual CLA](Documentation/Contributors/CLAs/individual-cla-agi-v1.0.txt)
 * [Victor Berchet](https://github.com/vicb)

CONTRIBUTORS.md

@@ -255,6 +255,33 @@ define([
         return deferred.promise;
     }
 
+    function insertNamespaces(text) {
+        var namespaceMap = {
+            xsi : 'http://www.w3.org/2001/XMLSchema-instance'
+        };
+        var firstPart, lastPart, reg, declaration;
+
+        for (var key in namespaceMap) {
+            if (namespaceMap.hasOwnProperty(key)) {
+                reg = RegExp('[< ]' + key + ':');
+                declaration = 'xmlns:' + key + '=';
+                if (reg.test(text) && text.indexOf(declaration) === -1) {
+                    if (!defined(firstPart)) {
+                        firstPart = text.substr(0, text.indexOf('<kml') + 4);
+                        lastPart = text.substr(firstPart.length);
+                    }
+                    firstPart += ' ' + declaration + '"' + namespaceMap[key] + '"';
+                }
+            }
+        }
+
+        if (defined(firstPart)) {
+            text = firstPart + lastPart;
+        }
+
+        return text;
+    }
+
     function loadXmlFromZip(reader, entry, uriResolver, deferred) {
         entry.getData(new zip.TextWriter(), function(text) {
             uriResolver.kml = parser.parseFromString(text, 'application/xml');
@@ -1842,7 +1869,9 @@ define([
 
                 var rotation = queryNumericValue(latLonBox, 'rotation', namespaces.kml);
                 if (defined(rotation)) {
-                    geometry.rotation = CesiumMath.toRadians(rotation);
+                    var rotationRadians = CesiumMath.toRadians(rotation);
+                    geometry.rotation = rotationRadians;
+                    geometry.stRotation = rotationRadians;
                 }
             }
         }
@@ -2322,6 +2351,9 @@ define([
                             //There's no official way to validate if a parse was successful.
                             //The following check detects the error on various browsers.
 
+                            //Insert missing namespaces
+                            text = insertNamespaces(text);
+
                             //IE raises an exception
                             var kml;
                             var error;

Source/DataSources/KmlDataSource.js

@@ -1588,6 +1588,20 @@ define([
             getValue : function(uniformState) {
                 return uniformState.minimumDisableDepthTestDistance;
             }
+        }),
+
+        /**
+         * An automatic GLSL uniform that will be the highlight color of unclassified 3D Tiles.
+         *
+         * @alias czm_invertClassificationColor
+         * @glslUniform
+         */
+        czm_invertClassificationColor : new AutomaticUniform({
+            size : 1,
+            datatype : WebGLConstants.FLOAT_VEC4,
+            getValue : function(uniformState) {
+                return uniformState.invertClassificationColor;
+            }
         })
     };
 

Source/Renderer/AutomaticUniforms.js

@@ -23,10 +23,11 @@ define([
         TERRAIN_CLASSIFICATION : 3,
         CESIUM_3D_TILE : 4,
         CESIUM_3D_TILE_CLASSIFICATION : 5,
-        OPAQUE : 6,
-        TRANSLUCENT : 7,
-        OVERLAY : 8,
-        NUMBER_OF_PASSES : 9
+        CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW : 6,
+        OPAQUE : 7,
+        TRANSLUCENT : 8,
+        OVERLAY : 9,
+        NUMBER_OF_PASSES : 10
     };
 
     return freezeObject(Pass);

Source/Renderer/Pass.js

@@ -159,6 +159,8 @@ define([
 
         this._fogDensity = undefined;
 
+        this._invertClassificationColor = undefined;
+
         this._imagerySplitPosition = 0.0;
         this._pixelSizePerMeter = undefined;
         this._geometricToleranceOverMeter = undefined;
@@ -847,6 +849,18 @@ define([
             get : function() {
                 return this._minimumDisableDepthTestDistance;
             }
+        },
+
+        /**
+         * The highlight color of unclassified 3D Tiles.
+         *
+         * @memberof UniformState.prototype
+         * @type {Color}
+         */
+        invertClassificationColor : {
+            get : function() {
+                return this._invertClassificationColor;
+            }
         }
     });
 
@@ -1012,6 +1026,8 @@ define([
 
         this._fogDensity = frameState.fog.density;
 
+        this._invertClassificationColor = frameState.invertClassificationColor;
+
         this._frameState = frameState;
         this._temeToPseudoFixed = Transforms.computeTemeToPseudoFixedMatrix(frameState.time, this._temeToPseudoFixed);
 

Source/Renderer/UniformState.js

@@ -1342,8 +1342,12 @@ define([
             // selection depth to the stencil buffer to prevent ancestor tiles from drawing on top
             derivedCommand = DrawCommand.shallowClone(command);
             var rs = clone(derivedCommand.renderState, true);
+            // Stencil test is masked to the most significant 4 bits so the reference is shifted.
+            // This is to prevent clearing the stencil before classification which needs the least significant
+            // bits for increment/decrement operations.
             rs.stencilTest.enabled = true;
-            rs.stencilTest.reference = reference;
+            rs.stencilTest.mask = 0xF0;
+            rs.stencilTest.reference = reference << 4;
             rs.stencilTest.frontFunction = StencilFunction.GREATER_OR_EQUAL;
             rs.stencilTest.frontOperation.zPass = StencilOperation.REPLACE;
             derivedCommand.renderState = RenderState.fromCache(rs);

Source/Scene/Cesium3DTileBatchTable.js

@@ -1495,7 +1495,7 @@ define([
             var addedCommandsLength = (lengthAfterUpdate - lengthBeforeUpdate);
             var backfaceCommandsLength = backfaceCommands.length;
 
-            commandList.length += backfaceCommands.length;
+            commandList.length += backfaceCommandsLength;
 
             // copy commands to the back of the commandList
             for (i = addedCommandsLength - 1; i >= 0; --i) {

Source/Scene/Cesium3DTileset.js

@@ -167,6 +167,9 @@ define([
      * NOTE: this will no longer work when there is a chain of selected tiles that is longer than the size of the
      * stencil buffer (usually 8 bits). In other words, the subset of the tree containing only selected tiles must be
      * no deeper than 255. It is very, very unlikely this will cause a problem.
+     *
+     * NOTE: when the scene has inverted classification enabled, the stencil buffer will be masked to 4 bits. So, the
+     * selected tiles must be no deeper than 15. This is still very unlikely.
      */
     function traverseAndSelect(tileset, root, frameState) {
         var stack = scratchStack;