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}
      *
@@ -51,7 +52,7 @@ define([
      * });
      * var geometry = Cesium.BoxGeometry.createGeometry(box);
      */
-    var BoxGeometry = function(options) {
+    function BoxGeometry(options) {
         options = defaultValue(options, defaultValue.EMPTY_OBJECT);
         var min = options.minimumCorner;
         var max = options.maximumCorner;
@@ -70,8 +71,7 @@ define([
         this._minimumCorner = Cartesian3.clone(min);
         this._maximumCorner = Cartesian3.clone(max);
         this._vertexFormat = vertexFormat;
-        this._workerName = 'createBoxGeometry';
-    };
+    }
 
     /**
      * Creates a cube centered at the origin given its dimensions.
@@ -115,6 +115,77 @@ 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);
+    };
+
+    var scratchMin = new Cartesian3();
+    var scratchMax = new Cartesian3();
+    var scratchVertexFormat = new VertexFormat();
+    var scratchOptions = {
+        minimumCorner : scratchMin,
+        maximumCorner : scratchMax,
+        vertexFormat : scratchVertexFormat
+    };
+
+    /**
+     * 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, scratchMin);
+        var max = Cartesian3.unpack(array, startingIndex + Cartesian3.packedLength, scratchMax);
+        var vertexFormat = VertexFormat.unpack(array, startingIndex + 2 * Cartesian3.packedLength, scratchVertexFormat);
+
+        if (!defined(result)) {
+            return new BoxGeometry(scratchOptions);
+        }
+
+        result._minimumCorner = Cartesian3.clone(min, result._minimumCorner);
+        result._maximumCorner = Cartesian3.clone(max, result._maximumCorner);
+        result._vertexFormat = VertexFormat.clone(vertexFormat, result._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}
      *
@@ -46,7 +47,7 @@ define([
      * });
      * var geometry = Cesium.BoxOutlineGeometry.createGeometry(box);
      */
-    var BoxOutlineGeometry = function(options) {
+    function BoxOutlineGeometry(options) {
         options = defaultValue(options, defaultValue.EMPTY_OBJECT);
 
         var min = options.minimumCorner;
@@ -63,8 +64,7 @@ define([
 
         this._min = Cartesian3.clone(min);
         this._max = Cartesian3.clone(max);
-        this._workerName = 'createBoxOutlineGeometry';
-    };
+    }
 
     /**
      * Creates an outline of a cube centered at the origin given its dimensions.
@@ -105,6 +105,72 @@ 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);
+    };
+
+    var scratchMin = new Cartesian3();
+    var scratchMax = new Cartesian3();
+    var scratchOptions = {
+        minimumCorner : scratchMin,
+        maximumCorner : scratchMax
+    };
+
+    /**
+     * 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, scratchMin);
+        var max = Cartesian3.unpack(array, startingIndex + Cartesian3.packedLength, scratchMax);
+
+        if (!defined(result)) {
+            return new BoxOutlineGeometry(scratchOptions);
+        }
+
+        result._min = Cartesian3.clone(min, result._min);
+        result._max = Cartesian3.clone(max, result._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

@@ -1,14 +1,20 @@
 /*global define*/
 define([
+        './Cartesian3',
         './defaultValue',
         './defined',
         './DeveloperError',
-        './EllipseGeometry'
+        './EllipseGeometry',
+        './Ellipsoid',
+        './VertexFormat'
     ], function(
+        Cartesian3,
         defaultValue,
         defined,
         DeveloperError,
-        EllipseGeometry) {
+        EllipseGeometry,
+        Ellipsoid,
+        VertexFormat) {
     "use strict";
 
     /**
@@ -31,6 +37,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}
      *
@@ -42,7 +49,7 @@ define([
      * });
      * var geometry = Cesium.CircleGeometry.createGeometry(circle);
      */
-    var CircleGeometry = function(options) {
+    function CircleGeometry(options) {
         options = defaultValue(options, defaultValue.EMPTY_OBJECT);
         var radius = options.radius;
 
@@ -67,7 +74,75 @@ define([
             stRotation : options.stRotation
         };
         this._ellipseGeometry = new EllipseGeometry(ellipseGeometryOptions);
-        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);
+    };
+
+    var scratchEllipseGeometry = new EllipseGeometry({
+        center : new Cartesian3(),
+        semiMajorAxis : 1.0,
+        semiMinorAxis : 1.0
+    });
+    var scratchOptions = {
+        center : new Cartesian3(),
+        radius : undefined,
+        ellipsoid : Ellipsoid.clone(Ellipsoid.UNIT_SPHERE),
+        height : undefined,
+        extrudedHeight : undefined,
+        granularity : undefined,
+        vertexFormat : new VertexFormat(),
+        stRotation : undefined,
+        semiMajorAxis : undefined,
+        semiMinorAxis : undefined
+    };
+
+    /**
+     * 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, scratchEllipseGeometry);
+        scratchOptions.center = Cartesian3.clone(ellipseGeometry._center, scratchOptions.center);
+        scratchOptions.ellipsoid = Ellipsoid.clone(ellipseGeometry._ellipsoid, scratchOptions.ellipsoid);
+        scratchOptions.height = ellipseGeometry._height;
+        scratchOptions.extrudedHeight = ellipseGeometry._extrudedHeight;
+        scratchOptions.granularity = ellipseGeometry._granularity;
+        scratchOptions.vertexFormat = VertexFormat.clone(ellipseGeometry._vertexFormat, scratchOptions.vertexFormat);
+        scratchOptions.stRotation = ellipseGeometry._stRotation;
+
+        if (!defined(result)) {
+            scratchOptions.radius = ellipseGeometry._semiMajorAxis;
+            return new CircleGeometry(scratchOptions);
+        }
+
+        scratchOptions.semiMajorAxis = ellipseGeometry._semiMajorAxis;
+        scratchOptions.semiMinorAxis = ellipseGeometry._semiMinorAxis;
+        result._ellipseGeometry = new EllipseGeometry(scratchOptions);
+        return result;
     };
 
     /**