cesium 0.16.0 → 0.17.0

data/app/assets/javascripts/DynamicScene/CzmlDefaults.js

@@ -12,6 +12,7 @@ define([
         './DynamicPolygon',
         './DynamicPolyline',
         './DynamicPyramid',
+        './DynamicVector',
         './DynamicBillboardVisualizer',
         './DynamicEllipsoidVisualizer',
         './DynamicConeVisualizerUsingCustomSensor', //CZML_TODO Replace with './DynamicConeVisualizer', once ComplexConicSensor works.
@@ -20,7 +21,8 @@ define([
         './DynamicPointVisualizer',
         './DynamicPolygonVisualizer',
         './DynamicPolylineVisualizer',
-        './DynamicPyramidVisualizer'
+        './DynamicPyramidVisualizer',
+        './DynamicVectorVisualizer'
     ], function(
         DynamicObject,
         DynamicBillboard,
@@ -34,6 +36,7 @@ define([
         DynamicPolygon,
         DynamicPolyline,
         DynamicPyramid,
+        DynamicVector,
         DynamicBillboardVisualizer,
         DynamicEllipsoidVisualizer,
         DynamicConeVisualizer,
@@ -42,7 +45,8 @@ define([
         DynamicPointVisualizer,
         DynamicPolygonVisualizer,
         DynamicPolylineVisualizer,
-        DynamicPyramidVisualizer) {
+        DynamicPyramidVisualizer,
+        DynamicVectorVisualizer) {
     "use strict";
 
     /**
@@ -76,6 +80,7 @@ define([
                     DynamicPolygon.processCzmlPacket,
                     DynamicPolyline.processCzmlPacket,
                     DynamicPyramid.processCzmlPacket,
+                    DynamicVector.processCzmlPacket,
                     DynamicObject.processCzmlPacketPosition,
                     DynamicObject.processCzmlPacketViewFrom,
                     DynamicObject.processCzmlPacketOrientation,
@@ -99,6 +104,7 @@ define([
                    DynamicPolygon.mergeProperties,
                    DynamicPolyline.mergeProperties,
                    DynamicPyramid.mergeProperties,
+                   DynamicVector.mergeProperties,
                    DynamicObject.mergeProperties],
 
         /**
@@ -117,6 +123,7 @@ define([
                     DynamicPolygon.undefineProperties,
                     DynamicPolyline.undefineProperties,
                     DynamicPyramid.undefineProperties,
+                    DynamicVector.undefineProperties,
                     DynamicObject.undefineProperties,
                     DynamicClock.undefineProperties],
 
@@ -137,6 +144,7 @@ define([
                     new DynamicPolygonVisualizer(scene),
                     new DynamicPolylineVisualizer(scene),
                     new DynamicPyramidVisualizer(scene),
+                    new DynamicVectorVisualizer(scene),
                     new DynamicPathVisualizer(scene)];
         }
     };

data/app/assets/javascripts/DynamicScene/CzmlDirection.js

@@ -0,0 +1,136 @@
+/*global define*/
+define([
+        '../Core/Cartesian3',
+        '../Core/Spherical',
+        '../Core/Math',
+        '../Core/Ellipsoid'
+       ], function(
+         Cartesian3,
+         Spherical,
+         CesiumMath,
+         Ellipsoid) {
+    "use strict";
+
+    var doublesPerValue = 3;
+    var scratchCartesian = new Cartesian3();
+    var scratchSpherical = new Spherical();
+
+    /**
+     * Provides methods for working with a direction defined in CZML.
+     *
+     * @exports CzmlDirection
+     *
+     * @see Cartesian3
+     * @see Spherical
+     * @see DynamicProperty
+     * @see DynamicDirectionProperty
+     * @see CzmlBoolean
+     * @see CzmlCartesian2
+     * @see CzmlColor
+     * @see CzmlHorizontalOrigin
+     * @see CzmlLabelStyle
+     * @see CzmlNumber
+     * @see CzmlString
+     * @see CzmlUnitCartesian3
+     * @see CzmlUnitQuaternion
+     * @see CzmlUnitSpherical
+     * @see CzmlVerticalOrigin
+     */
+    var CzmlDirection = {
+         /**
+         * The number of doubles per packed Cartesian3 value.
+         */
+        doublesPerValue : doublesPerValue,
+
+        /**
+         * The number of doubles per packed value used for interpolation.
+         */
+        doublesPerInterpolationValue : doublesPerValue,
+
+        /**
+         * Returns the packed Cartesian3 representation contained within the provided CZML interval
+         * or undefined if the interval does not contain Cartesian3 data.
+         *
+         * @param {Object} czmlInterval The CZML interval to unwrap.
+         */
+        unwrapInterval : function(czmlInterval) {
+            var unitCartesian = czmlInterval.unitCartesian;
+            if (typeof unitCartesian !== 'undefined') {
+                return unitCartesian;
+            }
+
+            var unitSpherical = czmlInterval.unitSpherical;
+            if (typeof unitSpherical !== 'undefined') {
+                var len = unitSpherical.length;
+                if (len === 2) {
+                    scratchSpherical.clock = unitSpherical[0];
+                    scratchSpherical.cone = unitSpherical[1];
+                    Cartesian3.fromSpherical(scratchSpherical, scratchCartesian);
+                    unitCartesian = [scratchCartesian.x, scratchCartesian.y, scratchCartesian.z];
+                } else {
+                    var sphericalIt = 0;
+                    unitCartesian = new Array((len / 3) * 4);
+                    for ( var i = 0; i < len; i += 4) {
+                        unitCartesian[i] = unitSpherical[sphericalIt++];
+
+                        scratchSpherical.clock = unitSpherical[sphericalIt++];
+                        scratchSpherical.cone = unitSpherical[sphericalIt++];
+                        Cartesian3.fromSpherical(scratchSpherical, scratchCartesian);
+
+                        unitCartesian[i + 1] = scratchCartesian.x;
+                        unitCartesian[i + 2] = scratchCartesian.y;
+                        unitCartesian[i + 3] = scratchCartesian.z;
+                    }
+                }
+            }
+            return unitCartesian;
+        },
+
+        /**
+         * Returns true if this interval represents data that should be interpolated by the client
+         * or false if it's a single value.
+         *
+         * @param {Object} unwrappedInterval The result of CzmlDirection.unwrapInterval.
+         */
+        isSampled : function(unwrappedInterval) {
+            return Array.isArray(unwrappedInterval) && unwrappedInterval.length > doublesPerValue;
+        },
+
+        /**
+         * Given a non-sampled unwrapped interval, returns a Cartesian3 instance of the data.
+         *
+         * @param {Object} unwrappedInterval The result of CzmlDirection.unwrapInterval.
+         * @param {Cartesian3} result The object to store the result in, if undefined a new instance will be created.
+         * @returns The modified result parameter or a new Cartesian3 instance if result was not defined.
+         */
+        getValue : function(unwrappedInterval, result) {
+            if (typeof result === 'undefined') {
+                result = new Cartesian3();
+            }
+            result.x = unwrappedInterval[0];
+            result.y = unwrappedInterval[1];
+            result.z = unwrappedInterval[2];
+            return result;
+        },
+
+        /**
+         * Given a packed array of x, y, and z values, extracts a Cartesian3 instance.
+         *
+         * @param {Array} array A packed array of Cartesian3 values, where every three elements represents a Cartesian3.
+         * @param {Number} startingIndex The index into the array that contains the x value of the Cartesian3 you would like.
+         * @param {Cartesian3} result The object to store the result in, if undefined a new instance will be created.
+         * @returns The modified result parameter or a new Cartesian3 instance if result was not defined.
+         */
+        getValueFromArray : function(array, startingIndex, result) {
+            if (typeof result === 'undefined') {
+                result = new Cartesian3();
+            }
+            result.x = array[startingIndex];
+            result.y = array[startingIndex + 1];
+            result.z = array[startingIndex + 2];
+            return result;
+        }
+    };
+
+    return CzmlDirection;
+});

data/app/assets/javascripts/DynamicScene/DataSource.js

@@ -0,0 +1,63 @@
+/*global define*/
+define(['../Core/DeveloperError'
+        ], function(
+                DeveloperError) {
+    "use strict";
+
+    function throwInstantiationError() {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    }
+
+    /**
+     * Defines the interface for data sources, which turn arbitrary data into a
+     * {@link DynamicObjectCollection} for generic consumption. This object is an interface
+     * for documentation purposes and is not intended to be instantiated directly.
+     * @alias DataSource
+     * @constructor
+     */
+    var DataSource = throwInstantiationError;
+
+    /**
+     * Gets an event that will be raised when non-time-Varying data changes
+     * or if the return value of getIsTimeVarying changes.
+     * @memberof DataSource
+     *
+     * @returns {Event} The event.
+     */
+    DataSource.prototype.getChangedEvent = throwInstantiationError;
+
+    /**
+     * Gets an event that will be raised if an error is encountered during processing.
+     * @memberof DataSource
+     *
+     * @returns {Event} The event.
+     */
+    DataSource.prototype.getErrorEvent = throwInstantiationError;
+
+    /**
+     * Gets the top level clock associated with this data source, or undefined if no clock exists.
+     * @memberof DataSource
+     *
+     * @returns {DynamicClock} The clock associated with this data source, or undefined if none exists.
+     */
+    DataSource.prototype.getClock = throwInstantiationError;
+
+    /**
+     * Gets the DynamicObjectCollection generated by this data source.
+     * @memberof DataSource
+     *
+     * @returns {DynamicObjectCollection} The collection of objects generated by this data source.
+     */
+    DataSource.prototype.getDynamicObjectCollection = throwInstantiationError;
+
+    /**
+     * Gets a value indicating if the data varies with simulation time.  If the return value of
+     * this function changes, the changed event will be raised.
+     * @memberof DataSource
+     *
+     * @returns {Boolean} True if the data is varies with simulation time, false otherwise.
+     */
+    DataSource.prototype.getIsTimeVarying = throwInstantiationError;
+
+    return DataSource;
+});

data/app/assets/javascripts/DynamicScene/DataSourceCollection.js

@@ -0,0 +1,189 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/destroyObject',
+        '../Core/Event'
+    ], function(
+        DeveloperError,
+        destroyObject,
+        Event) {
+    "use strict";
+
+    /**
+     * A collection of {@link DataSource} instances.
+     * @alias DataSourceCollection
+     * @constructor
+     */
+    var DataSourceCollection = function() {
+        this._dataSources = [];
+
+        /**
+         * An event that is raised when a data source is added to the collection.  Event handlers are passed the data source that
+         * was added.
+         * @type {Event}
+         */
+        this.dataSourceAdded = new Event();
+
+        /**
+         * An event that is raised when a data source is removed from the collection.  Event handlers are passed the data source that
+         * was removed.
+         * @type {Event}
+         */
+        this.dataSourceRemoved = new Event();
+    };
+
+    /**
+     * Adds a data source to the collection.
+     * @memberof DataSourceCollection
+     *
+     * @param {DataSource} dataSource The data source to add.
+     *
+     * @exception {DeveloperError} dataSource is required.
+     */
+    DataSourceCollection.prototype.add = function(dataSource) {
+        if (typeof dataSource === 'undefined') {
+            throw new DeveloperError('dataSource is required.');
+        }
+        this._dataSources.push(dataSource);
+        this.dataSourceAdded.raiseEvent(this, dataSource);
+    };
+
+    /**
+     * Removes a data source from this collection, if present.
+     *
+     * @memberof DataSourceCollection
+     *
+     * @param {DataSource} dataSource The data source to remove.
+     * @param {Boolean} [destroy=true] whether to destroy the data sources in addition to removing them.
+     *
+     * @returns {Boolean} true if the data source was in the collection and was removed,
+     *                    false if the data source was not in the collection.
+     */
+    DataSourceCollection.prototype.remove = function(dataSource, destroy) {
+        var index = this._dataSources.indexOf(dataSource);
+        if (index !== -1) {
+            this._dataSources.splice(index, 1);
+            this.dataSourceRemoved.raiseEvent(this, dataSource);
+
+            if (typeof dataSource.destroy === 'function' && destroy) {
+                dataSource.destroy();
+            }
+
+            return true;
+        }
+
+        return false;
+    };
+
+    /**
+     * Removes all data sources from this collection.
+     *
+     * @memberof DataSourceCollection
+     *
+     * @param {Boolean} [destroy=true] whether to destroy the data sources in addition to removing them.
+     */
+    DataSourceCollection.prototype.removeAll = function(destroy) {
+        var dataSources = this._dataSources;
+        for ( var i = dataSources.length - 1; i >= 0; i--) {
+            this.remove(dataSources[i], destroy);
+        }
+    };
+
+    /**
+     * Checks to see if the collection contains a given data source.
+     *
+     * @memberof DataSourceCollection
+     *
+     * @param {DataSource} dataSource The data source to check for.
+     *
+     * @returns {Boolean} true if the collection contains the data source, false otherwise.
+     */
+    DataSourceCollection.prototype.contains = function(dataSource) {
+        return this.indexOf(dataSource) !== -1;
+    };
+
+    /**
+     * Determines the index of a given data source in the collection.
+     *
+     * @memberof DataSourceCollection
+     *
+     * @param {DataSource} dataSource The data source to find the index of.
+     *
+     * @returns {Number} The index of the data source in the collection, or -1 if the data source does not exist in the collection.
+     */
+    DataSourceCollection.prototype.indexOf = function(dataSource) {
+        return this._dataSources.indexOf(dataSource);
+    };
+
+    /**
+     * Gets a data source by index from the collection.
+     *
+     * @memberof DataSourceCollection
+     *
+     * @param {Number} index the index to retrieve.
+     *
+     * @exception {DeveloperError} index is required.
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     */
+    DataSourceCollection.prototype.get = function(index) {
+        if (typeof index === 'undefined') {
+            throw new DeveloperError('index is required.');
+        }
+
+        return this._dataSources[index];
+    };
+
+    /**
+     * Gets the number of data sources in this collection.
+     *
+     * @memberof DataSourceCollection
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     */
+    DataSourceCollection.prototype.getLength = function() {
+        return this._dataSources.length;
+    };
+
+    /**
+     * Returns true if this object was destroyed; otherwise, false.
+     * <br /><br />
+     * If this object was destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+     *
+     * @memberof DataSourceCollection
+     *
+     * @return {Boolean} true if this object was destroyed; otherwise, false.
+     *
+     * @see DataSourceCollection#destroy
+     */
+    DataSourceCollection.prototype.isDestroyed = function() {
+        return false;
+    };
+
+    /**
+     * Destroys the WebGL resources held by all data sources in this collection.  Explicitly destroying this
+     * object allows for deterministic release of WebGL resources, instead of relying on the garbage
+     * collector.
+     * <br /><br />
+     * Once this object is destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+     * assign the return value (<code>undefined</code>) to the object as done in the example.
+     *
+     * @memberof DataSourceCollection
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see DataSourceCollection#isDestroyed
+     *
+     * @example
+     * dataSourceCollection = dataSourceCollection && dataSourceCollection.destroy();
+     */
+    DataSourceCollection.prototype.destroy = function() {
+        this.removeAll(true);
+        return destroyObject(this);
+    };
+
+    return DataSourceCollection;
+});