cesium 0.16.0 → 0.17.0

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

@@ -0,0 +1,225 @@
+/*global define*/
+define(['./DataSourceCollection',
+        './DynamicBillboardVisualizer',
+        './DynamicEllipsoidVisualizer',
+        './DynamicConeVisualizerUsingCustomSensor',
+        './DynamicLabelVisualizer',
+        './DynamicPathVisualizer',
+        './DynamicPointVisualizer',
+        './DynamicPolygonVisualizer',
+        './DynamicPolylineVisualizer',
+        './DynamicPyramidVisualizer',
+        './VisualizerCollection',
+        '../Core/defaultValue',
+        '../Core/destroyObject',
+        '../Core/DeveloperError'
+    ], function(
+        DataSourceCollection,
+        DynamicBillboardVisualizer,
+        DynamicEllipsoidVisualizer,
+        DynamicConeVisualizerUsingCustomSensor,
+        DynamicLabelVisualizer,
+        DynamicPathVisualizer,
+        DynamicPointVisualizer,
+        DynamicPolygonVisualizer,
+        DynamicPolylineVisualizer,
+        DynamicPyramidVisualizer,
+        VisualizerCollection,
+        defaultValue,
+        destroyObject,
+        DeveloperError) {
+    "use strict";
+
+    var defaultVisualizerTypes = [DynamicBillboardVisualizer,
+                                  DynamicEllipsoidVisualizer,
+                                  DynamicConeVisualizerUsingCustomSensor,
+                                  DynamicLabelVisualizer,
+                                  DynamicPointVisualizer,
+                                  DynamicPolygonVisualizer,
+                                  DynamicPolylineVisualizer,
+                                  DynamicPyramidVisualizer,
+                                  DynamicPathVisualizer];
+
+    /**
+     * Visualizes a collection of {@link DataSource} instances.
+     * @alias DataSourceDisplay
+     * @constructor
+     *
+     * @param {Scene} scene The scene in which to display the data.
+     * @param {Array} [visualizerTypes] The array of visualizer constructor functions that will be created for each data source.  If undefined, All standard visualizers will be used.
+     *
+     * @exception {DeveloperError} scene is required.
+     */
+    var DataSourceDisplay = function(scene, visualizerTypes) {
+        if (typeof scene === 'undefined') {
+            throw new DeveloperError('scene is required.');
+        }
+
+        var dataSourceCollection = new DataSourceCollection();
+        dataSourceCollection.dataSourceAdded.addEventListener(this._onDataSourceAdded, this);
+        dataSourceCollection.dataSourceRemoved.addEventListener(this._onDataSourceRemoved, this);
+        this._dataSourceCollection = dataSourceCollection;
+        this._scene = scene;
+        this._timeVaryingSources = [];
+        this._staticSourcesToUpdate = [];
+        this._visualizersTypes = defaultValue(visualizerTypes, defaultVisualizerTypes).slice(0);
+    };
+
+    /**
+     * Gets the scene being used for display.
+     * @returns {Scene} The scene.
+     */
+    DataSourceDisplay.prototype.getScene = function() {
+        return this._scene;
+    };
+
+    /**
+     * Gets the types of visualizers being used for display.
+     * @returns {Array} A copy of the visualizer types being used for display.
+     */
+    DataSourceDisplay.prototype.getVisualizerTypes = function() {
+        return this._visualizersTypes.slice(0);
+    };
+
+    /**
+     * Gets the collection of data sources to be displayed.
+     * @returns {DataSourceCollection} The collection of data sources.
+     */
+    DataSourceDisplay.prototype.getDataSources = function() {
+        return this._dataSourceCollection;
+    };
+
+    /**
+     * 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.
+     *
+     * @return {Boolean} True if this object was destroyed; otherwise, false.
+     *
+     * @see DataSourceDisplay#destroy
+     */
+    DataSourceDisplay.prototype.isDestroyed = function() {
+        return false;
+    };
+
+    /**
+     * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
+     * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+     * <br /><br />
+     * Once an 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.
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see DataSourceDisplay#isDestroyed
+     *
+     * @example
+     * dataSourceDisplay = dataSourceDisplay.destroy();
+     */
+    DataSourceDisplay.prototype.destroy = function() {
+        var dataSources = this._dataSourceCollection;
+        dataSources.dataSourceAdded.removeEventListener(this._onDataSourceAdded, this);
+        dataSources.dataSourceRemoved.removeEventListener(this._onDataSourceRemoved, this);
+
+        var length = dataSources.getLength();
+        for ( var i = 0; i < length; i++) {
+            var dataSource = dataSources.get(i);
+            this._onDataSourceRemoved(this._dataSourceCollection, dataSource);
+            if (typeof dataSource.destroy === 'function') {
+                dataSource.destroy();
+            }
+        }
+        return destroyObject(this);
+    };
+
+    /**
+     * Updates time-varying data sources to the provided time and also
+     * updates static data sources that have changed since the last
+     * call to update.
+     *
+     * @param {JulianDate} time The simulation time.
+     *
+     * @exception {DeveloperError} time is required.
+     */
+    DataSourceDisplay.prototype.update = function(time) {
+        if (typeof time === 'undefined') {
+            throw new DeveloperError('time is required.');
+        }
+
+        var timeVaryingSources = this._timeVaryingSources;
+        var staticSourcesToUpdate = this._staticSourcesToUpdate;
+        var length;
+        var i;
+
+        length = timeVaryingSources.length;
+        for (i = 0; i < length; i++) {
+            timeVaryingSources[i]._visualizerCollection.update(time);
+        }
+
+        length = staticSourcesToUpdate.length;
+        if (length > 0) {
+            for (i = 0; i < length; i++) {
+                staticSourcesToUpdate[i]._visualizerCollection.update(time);
+            }
+            this._staticSourcesToUpdate = [];
+        }
+    };
+
+    DataSourceDisplay.prototype._onDataSourceAdded = function(dataSourceCollection, dataSource) {
+        var visualizerTypes = this._visualizersTypes;
+        var length = visualizerTypes.length;
+        var visualizers = new Array(length);
+        var scene = this._scene;
+        for ( var i = 0; i < length; i++) {
+            visualizers[i] = new visualizerTypes[i](scene);
+        }
+
+        var vCollection = new VisualizerCollection(visualizers, dataSource.getDynamicObjectCollection());
+        dataSource._visualizerCollection = vCollection;
+        dataSource.getChangedEvent().addEventListener(this._onDataSourceChanged, this);
+        this._onDataSourceChanged(dataSource);
+    };
+
+    DataSourceDisplay.prototype._onDataSourceRemoved = function(dataSourceCollection, dataSource) {
+        dataSource.getChangedEvent().removeEventListener(this._onDataSourceChanged, this);
+
+        var timeVaryingIndex = this._timeVaryingSources.indexOf(dataSource);
+        if (timeVaryingIndex !== -1) {
+            this._timeVaryingSources.splice(timeVaryingIndex, 1);
+        }
+
+        var staticIndex = this._staticSourcesToUpdate.indexOf(dataSource);
+        if (staticIndex !== -1) {
+            this._staticSourcesToUpdate.splice(staticIndex, 1);
+        }
+
+        dataSource._visualizerCollection.destroy();
+        dataSource._visualizerCollection = undefined;
+    };
+
+    DataSourceDisplay.prototype._onDataSourceChanged = function(dataSource) {
+        var timeVaryingIndex = this._timeVaryingSources.indexOf(dataSource);
+        var staticIndex = this._staticSourcesToUpdate.indexOf(dataSource);
+        if (dataSource.getIsTimeVarying()) {
+            if (timeVaryingIndex === -1) {
+                this._timeVaryingSources.push(dataSource);
+            }
+            if (staticIndex !== -1) {
+                this._staticSourcesToUpdate.splice(staticIndex, 1);
+            }
+        } else {
+            if (staticIndex === -1) {
+                this._staticSourcesToUpdate.push(dataSource);
+            }
+            if (timeVaryingIndex !== -1) {
+                this._timeVaryingSources.splice(staticIndex, 1);
+            }
+        }
+    };
+
+    return DataSourceDisplay;
+});

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

@@ -133,7 +133,7 @@ define([
         if (typeof this._dynamicObjectCollection !== 'undefined') {
             var dynamicObjects = this._dynamicObjectCollection.getObjects();
             for ( var i = 0, len = dynamicObjects.length; i < len; i++) {
-                this._updateObject(time, dynamicObjects[i]);
+                updateObject(this, time, dynamicObjects[i]);
             }
         }
     };
@@ -197,7 +197,7 @@ define([
     var color;
     var eyeOffset;
     var pixelOffset;
-    DynamicBillboardVisualizer.prototype._updateObject = function(time, dynamicObject) {
+    function updateObject(dynamicBillboardVisualizer, time, dynamicObject) {
         var dynamicBillboard = dynamicObject.billboard;
         if (typeof dynamicBillboard === 'undefined') {
             return;
@@ -221,26 +221,26 @@ define([
         if (!show) {
             //don't bother creating or updating anything else
             if (typeof billboardVisualizerIndex !== 'undefined') {
-                billboard = this._billboardCollection.get(billboardVisualizerIndex);
+                billboard = dynamicBillboardVisualizer._billboardCollection.get(billboardVisualizerIndex);
                 billboard.setShow(false);
                 billboard.setImageIndex(-1);
                 billboard._visualizerUrl = undefined;
                 billboard._visualizerTextureAvailable = false;
                 dynamicObject._billboardVisualizerIndex = undefined;
-                this._unusedIndexes.push(billboardVisualizerIndex);
+                dynamicBillboardVisualizer._unusedIndexes.push(billboardVisualizerIndex);
             }
             return;
         }
 
         if (typeof billboardVisualizerIndex === 'undefined') {
-            var unusedIndexes = this._unusedIndexes;
+            var unusedIndexes = dynamicBillboardVisualizer._unusedIndexes;
             var length = unusedIndexes.length;
             if (length > 0) {
                 billboardVisualizerIndex = unusedIndexes.pop();
-                billboard = this._billboardCollection.get(billboardVisualizerIndex);
+                billboard = dynamicBillboardVisualizer._billboardCollection.get(billboardVisualizerIndex);
             } else {
-                billboardVisualizerIndex = this._billboardCollection.getLength();
-                billboard = this._billboardCollection.add();
+                billboardVisualizerIndex = dynamicBillboardVisualizer._billboardCollection.getLength();
+                billboard = dynamicBillboardVisualizer._billboardCollection.add();
             }
             dynamicObject._billboardVisualizerIndex = billboardVisualizerIndex;
             billboard.dynamicObject = dynamicObject;
@@ -255,14 +255,14 @@ define([
             billboard.setHorizontalOrigin(HorizontalOrigin.CENTER);
             billboard.setVerticalOrigin(VerticalOrigin.CENTER);
         } else {
-            billboard = this._billboardCollection.get(billboardVisualizerIndex);
+            billboard = dynamicBillboardVisualizer._billboardCollection.get(billboardVisualizerIndex);
         }
 
         var textureValue = textureProperty.getValue(time);
         if (textureValue !== billboard._visualizerUrl) {
             billboard._visualizerUrl = textureValue;
             billboard._visualizerTextureAvailable = false;
-            this._textureAtlasBuilder.addTextureFromUrl(textureValue, textureReady(dynamicObject, this._billboardCollection, textureValue));
+            dynamicBillboardVisualizer._textureAtlasBuilder.addTextureFromUrl(textureValue, textureReady(dynamicObject, dynamicBillboardVisualizer._billboardCollection, textureValue));
         }
 
         billboard.setShow(billboard._visualizerTextureAvailable);
@@ -323,7 +323,7 @@ define([
                 billboard.setVerticalOrigin(verticalOrigin);
             }
         }
-    };
+    }
 
     DynamicBillboardVisualizer.prototype._onObjectsRemoved = function(dynamicObjectCollection, dynamicObjects) {
         var thisBillboardCollection = this._billboardCollection;

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

@@ -2,16 +2,12 @@
 define([
         '../Core/TimeInterval',
         '../Core/Iso8601',
-        '../Core/defaultValue',
-        '../Core/Clock',
         '../Core/ClockRange',
         '../Core/ClockStep',
         '../Core/JulianDate'
     ], function(
         TimeInterval,
         Iso8601,
-        defaultValue,
-        Clock,
         ClockRange,
         ClockStep,
         JulianDate) {

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

@@ -160,7 +160,7 @@ define([
         if (typeof this._dynamicObjectCollection !== 'undefined') {
             var dynamicObjects = this._dynamicObjectCollection.getObjects();
             for ( var i = 0, len = dynamicObjects.length; i < len; i++) {
-                this._updateObject(time, dynamicObjects[i]);
+                updateObject(this, time, dynamicObjects[i]);
             }
         }
     };
@@ -228,8 +228,8 @@ define([
     var position;
     var orientation;
     var intersectionColor;
-    DynamicConeVisualizerUsingCustomSensor.prototype._updateObject = function(time, dynamicObject) {
-        var context = this._scene.getContext();
+    function updateObject(dynamicConeVisualizerUsingCustomSensor, time, dynamicObject) {
+        var context = dynamicConeVisualizerUsingCustomSensor._scene.getContext();
         var dynamicCone = dynamicObject.cone;
         if (typeof dynamicCone === 'undefined') {
             return;
@@ -253,26 +253,26 @@ define([
         if (!show) {
             //don't bother creating or updating anything else
             if (typeof coneVisualizerIndex !== 'undefined') {
-                cone = this._coneCollection[coneVisualizerIndex];
+                cone = dynamicConeVisualizerUsingCustomSensor._coneCollection[coneVisualizerIndex];
                 cone.show = false;
                 dynamicObject._coneVisualizerIndex = undefined;
-                this._unusedIndexes.push(coneVisualizerIndex);
+                dynamicConeVisualizerUsingCustomSensor._unusedIndexes.push(coneVisualizerIndex);
             }
             return;
         }
 
         if (typeof coneVisualizerIndex === 'undefined') {
-            var unusedIndexes = this._unusedIndexes;
+            var unusedIndexes = dynamicConeVisualizerUsingCustomSensor._unusedIndexes;
             var length = unusedIndexes.length;
             if (length > 0) {
                 coneVisualizerIndex = unusedIndexes.pop();
-                cone = this._coneCollection[coneVisualizerIndex];
+                cone = dynamicConeVisualizerUsingCustomSensor._coneCollection[coneVisualizerIndex];
             } else {
-                coneVisualizerIndex = this._coneCollection.length;
+                coneVisualizerIndex = dynamicConeVisualizerUsingCustomSensor._coneCollection.length;
                 cone = new CustomSensorVolume();
                 cone._directionsScratch = [];
-                this._coneCollection.push(cone);
-                this._primitives.add(cone);
+                dynamicConeVisualizerUsingCustomSensor._coneCollection.push(cone);
+                dynamicConeVisualizerUsingCustomSensor._primitives.add(cone);
             }
             dynamicObject._coneVisualizerIndex = coneVisualizerIndex;
             cone.dynamicObject = dynamicObject;
@@ -283,7 +283,7 @@ define([
             cone.radius = Number.POSITIVE_INFINITY;
             cone.showIntersection = true;
         } else {
-            cone = this._coneCollection[coneVisualizerIndex];
+            cone = dynamicConeVisualizerUsingCustomSensor._coneCollection[coneVisualizerIndex];
         }
 
         cone.show = true;
@@ -368,7 +368,7 @@ define([
                 cone.intersectionColor = intersectionColor;
             }
         }
-    };
+    }
 
     DynamicConeVisualizerUsingCustomSensor.prototype._onObjectsRemoved = function(dynamicObjectCollection, dynamicObjects) {
         var thisConeCollection = this._coneCollection;

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

@@ -1,13 +1,11 @@
 /*global define*/
 define([
-        '../Core/JulianDate',
         '../Core/TimeInterval',
         '../Core/TimeIntervalCollection',
         '../Core/Cartesian3',
         '../Core/Spherical',
         '../Core/Iso8601'
     ], function(
-        JulianDate,
         TimeInterval,
         TimeIntervalCollection,
         Cartesian3,
@@ -97,10 +95,10 @@ define([
     DynamicDirectionsProperty.prototype.processCzmlIntervals = function(czmlIntervals, constrainedInterval, dynamicObjectCollection) {
         if (Array.isArray(czmlIntervals)) {
             for ( var i = 0, len = czmlIntervals.length; i < len; i++) {
-                this._addCzmlInterval(czmlIntervals[i], constrainedInterval, dynamicObjectCollection);
+                addCzmlInterval(this, czmlIntervals[i], constrainedInterval, dynamicObjectCollection);
             }
         } else {
-            this._addCzmlInterval(czmlIntervals, constrainedInterval, dynamicObjectCollection);
+            addCzmlInterval(this, czmlIntervals, constrainedInterval, dynamicObjectCollection);
         }
     };
 
@@ -134,7 +132,7 @@ define([
         return interval.data.getValueCartesian();
     };
 
-    DynamicDirectionsProperty.prototype._addCzmlInterval = function(czmlInterval, constrainedInterval, dynamicObjectCollection) {
+    function addCzmlInterval(dynamicDirectionsProperty, czmlInterval, constrainedInterval, dynamicObjectCollection) {
         var iso8601Interval = czmlInterval.interval;
         if (typeof iso8601Interval === 'undefined') {
             iso8601Interval = Iso8601.MAXIMUM_INTERVAL.clone();
@@ -147,7 +145,7 @@ define([
         }
 
         //See if we already have data at that interval.
-        var thisIntervals = this._propertyIntervals;
+        var thisIntervals = dynamicDirectionsProperty._propertyIntervals;
         var existingInterval = thisIntervals.findInterval(iso8601Interval.start, iso8601Interval.stop);
 
         //If not, create it.
@@ -157,7 +155,7 @@ define([
         }
 
         existingInterval.data = new ValueHolder(czmlInterval);
-    };
+    }
 
     return DynamicDirectionsProperty;
 });

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

@@ -4,7 +4,6 @@ define([
         '../Core/defaultValue',
         './CzmlBoolean',
         './CzmlCartesian3',
-        './CzmlColor',
         './DynamicProperty',
         './DynamicMaterialProperty'
     ], function(
@@ -12,7 +11,6 @@ define([
         defaultValue,
         CzmlBoolean,
         CzmlCartesian3,
-        CzmlColor,
         DynamicProperty,
         DynamicMaterialProperty) {
     "use strict";