Pack Geometries before passing to a web worker

Source/Core/BoundingSphere.js

@@ -598,7 +598,7 @@ define([
      *
      * @param {Number[]} array The packed array.
      * @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
-     * @param {Cartesian3} [result] The object into which to store the result.
+     * @param {BoundingSphere} [result] The object into which to store the result.
      */
     BoundingSphere.unpack = function(array, startingIndex, result) {
         //>>includeStart('debug', pragmas.debug);

Source/Core/BoxGeometry.js

@@ -40,6 +40,7 @@ define([
      *
      * @see BoxGeometry.fromDimensions
      * @see BoxGeometry.createGeometry
+     * @see Packable
      *
      * @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Box.html|Cesium Sandcastle Box Demo}
      *
@@ -115,6 +116,72 @@ define([
         return new BoxGeometry(newOptions);
     };
 
+    /**
+     * The number of elements used to pack the object into an array.
+     * @type {Number}
+     */
+    BoxGeometry.packedLength = 2 * Cartesian3.packedLength + VertexFormat.packedLength;
+
+    /**
+     * Stores the provided instance into the provided array.
+     * @function
+     *
+     * @param {Object} 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.
+     */
+    BoxGeometry.pack = function(value, array, startingIndex) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(value)) {
+            throw new DeveloperError('value is required');
+        }
+        if (!defined(array)) {
+            throw new DeveloperError('array is required');
+        }
+        //>>includeEnd('debug');
+
+        startingIndex = defaultValue(startingIndex, 0);
+
+        Cartesian3.pack(value._minimumCorner, array, startingIndex);
+        Cartesian3.pack(value._maximumCorner, array, startingIndex + Cartesian3.packedLength);
+        VertexFormat.pack(value._vertexFormat, array, startingIndex + 2 * Cartesian3.packedLength);
+    };
+
+    /**
+     * 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 {BoxGeometry} [result] The object into which to store the result.
+     */
+    BoxGeometry.unpack = function(array, startingIndex, result) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(array)) {
+            throw new DeveloperError('array is required');
+        }
+        //>>includeEnd('debug');
+
+        startingIndex = defaultValue(startingIndex, 0);
+
+        var min = Cartesian3.unpack(array, startingIndex);
+        var max = Cartesian3.unpack(array, startingIndex + Cartesian3.packedLength);
+        var vertexFormat = VertexFormat.unpack(array, startingIndex + 2 * Cartesian3.packedLength);
+
+        if (!defined(result)) {
+            return new BoxGeometry({
+                minimumCorner : min,
+                maximumCorner : max,
+                vertexFormat : vertexFormat
+            });
+        }
+
+        result._minimumCorner = min;
+        result._maximumCorner = max;
+        result._vertexFormat = vertexFormat;
+
+        return result;
+    };
+
     /**
      * Computes the geometric representation of a box, including its vertices, indices, and a bounding sphere.
      *

Source/Core/BoxOutlineGeometry.js

@@ -36,6 +36,7 @@ define([
      *
      * @see BoxOutlineGeometry.fromDimensions
      * @see BoxOutlineGeometry.createGeometry
+     * @see Packable
      *
      * @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Box%20Outline.html|Cesium Sandcastle Box Outline Demo}
      *
@@ -105,6 +106,68 @@ define([
         return new BoxOutlineGeometry(newOptions);
     };
 
+    /**
+     * The number of elements used to pack the object into an array.
+     * @type {Number}
+     */
+    BoxOutlineGeometry.packedLength = 2 * Cartesian3.packedLength;
+
+    /**
+     * Stores the provided instance into the provided array.
+     * @function
+     *
+     * @param {Object} 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.
+     */
+    BoxOutlineGeometry.pack = function(value, array, startingIndex) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(value)) {
+            throw new DeveloperError('value is required');
+        }
+        if (!defined(array)) {
+            throw new DeveloperError('array is required');
+        }
+        //>>includeEnd('debug');
+
+        startingIndex = defaultValue(startingIndex, 0);
+
+        Cartesian3.pack(value._min, array, startingIndex);
+        Cartesian3.pack(value._max, array, startingIndex + Cartesian3.packedLength);
+    };
+
+    /**
+     * 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 {BoxOutlineGeometry} [result] The object into which to store the result.
+     */
+    BoxOutlineGeometry.unpack = function(array, startingIndex, result) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(array)) {
+            throw new DeveloperError('array is required');
+        }
+        //>>includeEnd('debug');
+
+        startingIndex = defaultValue(startingIndex, 0);
+
+        var min = Cartesian3.unpack(array, startingIndex);
+        var max = Cartesian3.unpack(array, startingIndex + Cartesian3.packedLength);
+
+        if (!defined(result)) {
+            return new BoxOutlineGeometry({
+                minimumCorner : min,
+                maximumCorner : max
+            });
+        }
+
+        result._min = min;
+        result._max = max;
+
+        return result;
+    };
+
     /**
      * Computes the geometric representation of an outline of a box, including its vertices, indices, and a bounding sphere.
      *

Source/Core/CircleGeometry.js

@@ -31,6 +31,7 @@ define([
      * @exception {DeveloperError} granularity must be greater than zero.
      *
      * @see CircleGeometry.createGeometry
+     * @see Packable
      *
      * @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Circle.html|Cesium Sandcastle Circle Demo}
      *
@@ -70,6 +71,56 @@ define([
         this._workerName = 'createCircleGeometry';
     };
 
+    /**
+     * The number of elements used to pack the object into an array.
+     * @type {Number}
+     */
+    CircleGeometry.packedLength = EllipseGeometry.packedLength;
+
+    /**
+     * Stores the provided instance into the provided array.
+     * @function
+     *
+     * @param {Object} 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.
+     */
+    CircleGeometry.pack = function(value, array, startingIndex) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(value)) {
+            throw new DeveloperError('value is required');
+        }
+        //>>includeEnd('debug');
+        EllipseGeometry.pack(value._ellipseGeometry, array, startingIndex);
+    };
+
+    /**
+     * 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 {CircleGeometry} [result] The object into which to store the result.
+     */
+    CircleGeometry.unpack = function(array, startingIndex, result) {
+        var ellipseGeometry = EllipseGeometry.unpack(array, startingIndex);
+
+        if (!defined(result)) {
+            return new CircleGeometry({
+                center : ellipseGeometry._center,
+                radius : ellipseGeometry._semiMajorAxis,
+                ellipsoid : ellipseGeometry._ellipsoid,
+                height : ellipseGeometry._height,
+                extrudedHeight : ellipseGeometry._extrudedHeight,
+                granularity : ellipseGeometry._granularity,
+                vertexFormat : ellipseGeometry._vertexFormat,
+                stRotation : ellipseGeometry._stRotation
+            });
+        }
+
+        result._ellipseGeometry = ellipseGeometry;
+        return result;
+    };
+
     /**
      * Computes the geometric representation of a circle on an ellipsoid, including its vertices, indices, and a bounding sphere.
      *

Source/Core/CircleOutlineGeometry.js

@@ -30,6 +30,7 @@ define([
      * @exception {DeveloperError} granularity must be greater than zero.
      *
      * @see CircleOutlineGeometry.createGeometry
+     * @see Packable
      *
      * @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Circle%20Outline.html|Cesium Sandcastle Circle Outline Demo}
      *
@@ -68,6 +69,55 @@ define([
         this._workerName = 'createCircleOutlineGeometry';
     };
 
+    /**
+     * The number of elements used to pack the object into an array.
+     * @type {Number}
+     */
+    CircleOutlineGeometry.packedLength = EllipseOutlineGeometry.packedLength;
+
+    /**
+     * Stores the provided instance into the provided array.
+     * @function
+     *
+     * @param {Object} 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.
+     */
+    CircleOutlineGeometry.pack = function(value, array, startingIndex) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(value)) {
+            throw new DeveloperError('value is required');
+        }
+        //>>includeEnd('debug');
+        EllipseOutlineGeometry.pack(value._ellipseGeometry, array, startingIndex);
+    };
+
+    /**
+     * 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 {CircleOutlineGeometry} [result] The object into which to store the result.
+     */
+    CircleOutlineGeometry.unpack = function(array, startingIndex, result) {
+        var ellipseGeometry = EllipseOutlineGeometry.unpack(array, startingIndex);
+
+        if (!defined(result)) {
+            return new CircleOutlineGeometry({
+                center : ellipseGeometry._center,
+                radius : ellipseGeometry._semiMajorAxis,
+                ellipsoid : ellipseGeometry._ellipsoid,
+                height : ellipseGeometry._height,
+                extrudedHeight : ellipseGeometry._extrudedHeight,
+                granularity : ellipseGeometry._granularity,
+                numberOfVerticalLines : ellipseGeometry._numberOfVerticalLines
+            });
+        }
+
+        result._ellipseGeometry = ellipseGeometry;
+        return result;
+    };
+
     /**
      * Computes the geometric representation of an outline of a circle on an ellipsoid, including its vertices, indices, and a bounding sphere.
      *