CesiumGS · lilleyse · Jan 8, 2018 · Jun 12, 2017 · Jun 12, 2017 · Jun 21, 2017
diff --git a/Apps/Sandcastle/gallery/3D Tiles Classification.html b/Apps/Sandcastle/gallery/3D Tiles Classification.html
@@ -0,0 +1,95 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no">
+    <meta name="description" content="A sample classification dataset rendered with 3D Tiles.">
+    <meta name="cesium-sandcastle-labels" content="Showcases, 3D Tiles">
+    <title>Cesium Demo</title>
+    <script type="text/javascript" src="../Sandcastle-header.js"></script>
+    <script type="text/javascript" src="../../../ThirdParty/requirejs-2.1.20/require.js"></script>
+    <script type="text/javascript">
+    require.config({
+        baseUrl : '../../../Source',
+        waitSeconds : 60
+    });
+    </script>
+</head>
+<body class="sandcastle-loading" data-sandcastle-bucket="bucket-requirejs.html">
+<style>
+    @import url(../templates/bucket.css);
+</style>
+<div id="cesiumContainer" class="fullSize"></div>
+<div id="loadingOverlay"><h1>Loading...</h1></div>
+<div id="toolbar"></div>
+<script id="cesium_sandcastle_script">
+function startup(Cesium) {
+    'use strict';
+//Sandcastle_Begin
+var viewer = new Cesium.Viewer('cesiumContainer');
+viewer.scene.globe.depthTestAgainstTerrain = true;
+
+var classification = viewer.scene.primitives.add(new Cesium.Cesium3DTileset({
+    url : '../../../Specs/Data/Cesium3DTiles/Vector/VectorTileCombined/',
+    classificationType : Cesium.ClassificationType.TERRAIN
+}));
+
+classification.readyPromise.then(function(tileset) {
+    viewer.camera.setView({ destination : Cesium.Rectangle.fromDegrees(-0.01, -0.01, 0.01, 0.01) });
+
+    tileset.style = new Cesium.Cesium3DTileStyle({
+        color : "rgba(255, 255, 0, 1.0)",
+        pointColor : "rgba(255, 255, 0, 1.0)",
+        pointSize : 20.0
+    });
+}).otherwise(function(error) {
+    throw(error);
+});
+
+var HIGHLIGHT_COLOR = new Cesium.Color(1.0, 1.0, 0.0, 0.4);
+var current = {
+    feature : undefined,
+    originalColor : new Cesium.Color()
+};
+
+var handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
+handler.setInputAction(function(movement) {
+    var pickedFeature = viewer.scene.pick(movement.endPosition);
+
+    if (Cesium.defined(current.feature) && (current.feature !== pickedFeature)) {
+        // Restore original color to feature that is no longer selected
+
+        // This assignment is necessary to work with the set property
+        if (Cesium.defined(current.feature.pointColor)) {
+            current.feature.pointColor = Cesium.Color.clone(current.originalColor, current.feature.pointColor);
+        } else {
+            current.feature.color = Cesium.Color.clone(current.originalColor, current.feature.color);
+        }
+        current.feature = undefined;
+    }
+
+    if (Cesium.defined(pickedFeature) && (pickedFeature !== current.feature)) {
+        current.feature = pickedFeature;
+        // Save original color and set to highlight color
+        if (Cesium.defined(pickedFeature.pointColor)) {
+            Cesium.Color.clone(pickedFeature.pointColor, current.originalColor);
+            pickedFeature.pointColor = Cesium.Color.clone(HIGHLIGHT_COLOR, pickedFeature.pointColor);
+        } else {
+            Cesium.Color.clone(pickedFeature.color, current.originalColor);
+            pickedFeature.color = Cesium.Color.clone(HIGHLIGHT_COLOR, pickedFeature.color);
+        }
+    }
+}, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+
+//Sandcastle_End
+    Sandcastle.finishedLoading();
+}
+if (typeof Cesium !== "undefined") {
+    startup(Cesium);
+} else if (typeof require === "function") {
+    require(["Cesium"], startup);
+}
+</script>
+</body>
+</html>
diff --git a/Source/Core/AttributeCompression.js b/Source/Core/AttributeCompression.js
@@ -277,5 +277,48 @@ define([
         return result;
     };
 
+    function zigZagDecode(value) {
+        return (value >> 1) ^ (-(value & 1));
+    }
+
+    /**
+     * Decodes delta and ZigZag encoded vertices. This modifies the buffers in place.
+     *
+     * @param {Uint16Array} uBuffer The buffer or buffer view of u values.
+     * @param {Uint16Array} vBuffer The buffer or buffer view of v values.
+     * @param {Uint16Array} [heightBuffer] The buffer or buffer view of height values.
+     *
+     * @see {@link http://cesiumjs.org/data-and-assets/terrain/formats/quantized-mesh-1.0.html|quantized-mesh-1.0 terrain format}
+     */
+    AttributeCompression.zigZagDeltaDecode = function(uBuffer, vBuffer, heightBuffer) {
+        //>>includeStart('debug', pragmas.debug);
+        Check.defined('uBuffer', uBuffer);
+        Check.defined('vBuffer', vBuffer);
+        Check.typeOf.number.equals('uBuffer.length', 'vBuffer.length', uBuffer.length, vBuffer.length);
+        if (defined(heightBuffer)) {
+            Check.typeOf.number.equals('uBuffer.length', 'heightBuffer.length', uBuffer.length, heightBuffer.length);
+        }
+        //>>includeEnd('debug');
+
+        var count = uBuffer.length;
+
+        var u = 0;
+        var v = 0;
+        var height = 0;
+
+        for (var i = 0; i < count; ++i) {
+            u += zigZagDecode(uBuffer[i]);
+            v += zigZagDecode(vBuffer[i]);
+
+            uBuffer[i] = u;
+            vBuffer[i] = v;
+
+            if (defined(heightBuffer)) {
+                height += zigZagDecode(heightBuffer[i]);
+                heightBuffer[i] = height;
+            }
+        }
+    };
+
     return AttributeCompression;
 });
diff --git a/Source/Core/CesiumTerrainProvider.js b/Source/Core/CesiumTerrainProvider.js
@@ -1,6 +1,7 @@
 define([
         '../ThirdParty/Uri',
         '../ThirdParty/when',
+        './AttributeCompression',
         './BoundingSphere',
         './Cartesian3',
         './Credit',
@@ -27,6 +28,7 @@ define([
     ], function(
         Uri,
         when,
+        AttributeCompression,
         BoundingSphere,
         Cartesian3,
         Credit,
@@ -449,24 +451,7 @@ define([
         var vBuffer = encodedVertexBuffer.subarray(vertexCount, 2 * vertexCount);
         var heightBuffer = encodedVertexBuffer.subarray(vertexCount * 2, 3 * vertexCount);
 
-        var i;
-        var u = 0;
-        var v = 0;
-        var height = 0;
-
-        function zigZagDecode(value) {
-            return (value >> 1) ^ (-(value & 1));
-        }
-
-        for (i = 0; i < vertexCount; ++i) {
-            u += zigZagDecode(uBuffer[i]);
-            v += zigZagDecode(vBuffer[i]);
-            height += zigZagDecode(heightBuffer[i]);
-
-            uBuffer[i] = u;
-            vBuffer[i] = v;
-            heightBuffer[i] = height;
-        }
+        AttributeCompression.zigZagDeltaDecode(uBuffer, vBuffer, heightBuffer);
 
         // skip over any additional padding that was added for 2/4 byte alignment
         if (pos % bytesPerIndex !== 0) {
@@ -482,7 +467,8 @@ define([
         // https://code.google.com/p/webgl-loader/source/browse/trunk/samples/loader.js?r=99#55
         // Copyright 2012 Google Inc., Apache 2.0 license.
         var highest = 0;
-        for (i = 0; i < indices.length; ++i) {
+        var length = indices.length;
+        for (var i = 0; i < length; ++i) {
             var code = indices[i];
             indices[i] = highest - code;
             if (code === 0) {

diff --git a/Source/Core/OrientedBoundingBox.js b/Source/Core/OrientedBoundingBox.js
@@ -3,6 +3,7 @@ define([
         './Cartesian2',
         './Cartesian3',
         './Cartographic',
+        './Check',
         './defaultValue',
         './defined',
         './DeveloperError',
@@ -19,6 +20,7 @@ define([
         Cartesian2,
         Cartesian3,
         Cartographic,
+        Check,
         defaultValue,
         defined,
         DeveloperError,
@@ -69,6 +71,59 @@ define([
         this.halfAxes = Matrix3.clone(defaultValue(halfAxes, Matrix3.ZERO));
     }
 
+    /**
+     * The number of elements used to pack the object into an array.
+     * @type {Number}
+     */
+    OrientedBoundingBox.packedLength = Cartesian3.packedLength + Matrix3.packedLength;
+
+    /**
+     * Stores the provided instance into the provided array.
+     *
+     * @param {OrientedBoundingBox} value The value to pack.
+     * @param {Number[]} array The array to pack into.
+     * @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.
+     *
+     * @returns {Number[]} The array that was packed into
+     */
+    OrientedBoundingBox.pack = function(value, array, startingIndex) {
+        //>>includeStart('debug', pragmas.debug);
+        Check.typeOf.object('value', value);
+        Check.defined('array', array);
+        //>>includeEnd('debug');
+
+        startingIndex = defaultValue(startingIndex, 0);
+
+        Cartesian3.pack(value.center, array, startingIndex);
+        Matrix3.pack(value.halfAxes, array, startingIndex + Cartesian3.packedLength);
+
+        return array;
+    };
+
+    /**
+     * Retrieves an instance from a packed array.
+     *
+     * @param {Number[]} array The packed array.
+     * @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
+     * @param {OrientedBoundingBox} [result] The object into which to store the result.
+     * @returns {OrientedBoundingBox} The modified result parameter or a new OrientedBoundingBox instance if one was not provided.
+     */
+    OrientedBoundingBox.unpack = function(array, startingIndex, result) {
+        //>>includeStart('debug', pragmas.debug);
+        Check.defined('array', array);
+        //>>includeEnd('debug');
+
+        startingIndex = defaultValue(startingIndex, 0);
+
+        if (!defined(result)) {
+            result = new OrientedBoundingBox();
+        }
+
+        Cartesian3.unpack(array, startingIndex, result.center);
+        Matrix3.unpack(array, startingIndex + Cartesian3.packedLength, result.halfAxes);
+        return result;
+    };
+
     var scratchCartesian1 = new Cartesian3();
     var scratchCartesian2 = new Cartesian3();
     var scratchCartesian3 = new Cartesian3();
@@ -86,7 +141,7 @@ define([
      * This is an implementation of Stefan Gottschalk's Collision Queries using Oriented Bounding Boxes solution (PHD thesis).
      * Reference: http://gamma.cs.unc.edu/users/gottschalk/main.pdf
      *
-     * @param {Cartesian3[]} positions List of {@link Cartesian3} points that the bounding box will enclose.
+     * @param {Cartesian3[]} [positions] List of {@link Cartesian3} points that the bounding box will enclose.
      * @param {OrientedBoundingBox} [result] The object onto which to store the result.
      * @returns {OrientedBoundingBox} The modified result parameter or a new OrientedBoundingBox instance if one was not provided.
      *

diff --git a/Source/Core/arraySlice.js b/Source/Core/arraySlice.js
@@ -0,0 +1,59 @@
+define([
+        './Check',
+        './defaultValue',
+        './defined',
+        './FeatureDetection'
+    ], function(
+        Check,
+        defaultValue,
+        defined,
+        FeatureDetection) {
+    'use strict';
+
+    var typedArrayTypes;
+
+    if (FeatureDetection.supportsTypedArrays()) {
+        typedArrayTypes = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
+    }
+
+    /**
+     * Create a shallow copy of an array from begin to end.
+     *
+     * @param {Array} array The array to fill.
+     * @param {Number} [begin=0] The index to start at.
+     * @param {Number} [end=array.length] The index to end at.
+     *
+     * @returns {Array} The resulting array.
+     * @private
+     */
+    function arraySlice(array, begin, end) {
+        //>>includeStart('debug', pragmas.debug);
+        Check.defined('array', array);
+        if (defined(begin)) {
+            Check.typeOf.number('begin', begin);
+        }
+        if (defined(end)) {
+            Check.typeOf.number('end', end);
+        }
+        //>>includeEnd('debug');
+
+        if (typeof array.slice === 'function') {
+            return array.slice(begin, end);
+        }
+
+        var copy = Array.prototype.slice.call(array, begin, end);
+        if (FeatureDetection.supportsTypedArrays()) {
+            var length = typedArrayTypes.length;
+            for (var i = 0; i < length; ++i) {
+                if (array instanceof typedArrayTypes[i]) {
+                    copy = new typedArrayTypes[i](copy);
+                    break;
+                }
+            }
+        }
+
+        return copy;
+    }
+
+    return arraySlice;
+});
diff --git a/Source/Scene/Batched3DModel3DTileContent.js b/Source/Scene/Batched3DModel3DTileContent.js
@@ -382,12 +382,11 @@ define([
     }
 
     function createFeatures(content) {
-        var tileset = content._tileset;
         var featuresLength = content.featuresLength;
         if (!defined(content._features) && (featuresLength > 0)) {
             var features = new Array(featuresLength);
             for (var i = 0; i < featuresLength; ++i) {
-                features[i] = new Cesium3DTileFeature(tileset, content, i);
+                features[i] = new Cesium3DTileFeature(content, i);
             }
             content._features = features;
         }

diff --git a/Source/Scene/Billboard.js b/Source/Scene/Billboard.js
@@ -147,6 +147,7 @@ define([
         this._billboardCollection = billboardCollection;
         this._dirty = false;
         this._index = -1; //Used only by BillboardCollection
+        this._batchIndex = undefined; // Used only by Vector3DTilePoints and BillboardCollection
 
         this._imageIndex = -1;
         this._imageIndexPromise = undefined;