Refactor DynamicScene to use Geometry & Appearances

CHANGES.md

@@ -36,6 +36,13 @@ Beta Releases
       * `getEllipsoid` -> `ellipsoid`
       * `getCameraPosition`, `setCameraPosition` -> `cameraPosition`
   * Removed `Scene.getUniformState()`.  Use `scene.context.getUniformState()`
+  * Visualizers no longer create a `dynamicObject` property on the primitives they create.  Instead, they set the `id` property that is standard for all primitives.
+  * The `propertyChanged` on DynamicScene objects has been renamed to `definitionChanged`.  Also, the event is now raised in the case of an existing property being modified as well as having a new property assigned (previously only property assignment would raise the event).
+  * The `visualizerTypes` parameter to the `DataSouceDisplay` has been changed to a callback function that creates an array of visualizer instances.
+  * `DynamicDirectionsProperty` and `DynamicVertexPositionsProperty` were both removed, they have been superseded by `PropertyArray` and `PropertyPositionArray`, which make it easy for DataSource implementations to create time-dynamic arrays.
+  * `VisualizerCollection` has been removed.  It is superseded by `DataSourceDisplay`.
+  * `DynamicEllipsoidVisualizer`, `DynamicPolygonVisualizer`, and `DynamicPolylineVisualizer` have been removed.  They are superseded by `GeometryVisualizer` and corresponding `GeometryUpdater` implementations; `EllipsoidGeometryUpdater`, `PolygonGeometryUpdater`, `PolylineGeometryUpdater`.
+* DynamicScene now makes use of Geometry and Appearances, which provides a tremendous improvements to DataSource visualization (CZML, GeoJSON, etc..).  Extruded geometries are now supported and in many use cases performance is now GPU bound.
 * Added new `SelectionIndicator` and `InfoBox` widgets to `Viewer`, activated by `viewerDynamicObjectMixin`.
 * Fix developer error when zooming in 2D. If the zoom would create an invalid frustum, nothing is done. [#1432](https://github.com/AnalyticalGraphicsInc/cesium/issues/1432)
 * `OpenStreetMapImageryProvider` now supports imagery with a minimum level.
@@ -50,6 +57,12 @@ Beta Releases
 * `RequestErrorEvent` now includes the headers that were returned with the error response.
 * Added `CesiumInspector` widget for graphics debugging.  In Cesium Viewer, it is enabled by using the query parameter `inspector=true`. 
 * Fixed `WallGeometry` bug that failed by removing positions that were less close together by less than 6 decimal places. [#1483](https://github.com/AnalyticalGraphicsInc/cesium/pull/1483)
+* `DynamicEllipse`, `DynamicPolygon`, and `DynamicEllipsoid` now have properties matching their geometry counterpart, i.e. `EllipseGeometry`, `EllipseOutlineGeometry`, etc. These properties are also available in CZML.
+* Added a `definitionChanged` event to the `Property` interface as well as most `DynamicScene` objects.  This makes it easy for a client to observe when new data is loaded into a property or object.
+* Added an `isConstant` property to the `Property` interface.  Constant properties do not change in regards to simulation time, i.e. `Property.getValue` will always return the same result for all times.
+* `ConstantProperty` is now mutable; it's value can be updated via `ConstantProperty.setValue`.
+* Added AssociativeArray, which is a helper class for maintaining a hash of objects that also needs to be iterated often.
+* Added `TimeIntervalCollection.getChangedEvent` which returns an event that will be raised whenever intervals are updated.
 
 ### b25 - 2014-02-03
 

Source/DynamicScene/ColorMaterialProperty.js

@@ -1,29 +1,86 @@
 /*global define*/
-define([
-        '../Core/Color',
+define(['../Core/Color',
+        '../Core/defaultValue',
         '../Core/defined',
+        '../Core/defineProperties',
+        '../Core/DeveloperError',
+        '../Core/Event',
+        './createDynamicPropertyDescriptor',
         './ConstantProperty',
         './Property'
     ], function(
         Color,
+        defaultValue,
         defined,
+        defineProperties,
+        DeveloperError,
+        Event,
+        createDynamicPropertyDescriptor,
         ConstantProperty,
         Property) {
     "use strict";
 
     /**
      * A {@link MaterialProperty} that maps to solid color {@link Material} uniforms.
+     *
+     * @param {Property} [color] The {@link Color} property to be used.
+     *
      * @alias ColorMaterialProperty
      * @constructor
      */
-    var ColorMaterialProperty = function() {
+    var ColorMaterialProperty = function(colorProperty) {
+        this._definitionChanged = new Event();
+        this._color = undefined;
+        this._colorSubscription = undefined;
+        this.color = defaultValue(colorProperty, new ConstantProperty(Color.WHITE));
+    };
+
+    /**
+     * Creates a new instance that represents a constant color.
+     *
+     * @param {Color} color The color.
+     * @returns {ColorMaterialProperty} A new instance configured to represent the provided color.
+     */
+    ColorMaterialProperty.fromColor = function(color) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(color)) {
+            throw new DeveloperError('color is required');
+        }
+        //>>includeEnd('debug');
+        return new ColorMaterialProperty(new ConstantProperty(color));
+    };
+
+    defineProperties(ColorMaterialProperty.prototype, {
+        /**
+         * Gets a value indicating if this property is constant.  A property is considered
+         * constant if getValue always returns the same result for the current definition.
+         * @memberof ColorMaterialProperty.prototype
+         * @type {Boolean}
+         */
+        isConstant : {
+            get : function() {
+                return Property.isConstant(this._color);
+            }
+        },
+        /**
+         * Gets the event that is raised whenever the definition of this property changes.
+         * The definition is considered to have changed if a call to getValue would return
+         * a different result for the same time.
+         * @memberof ColorMaterialProperty.prototype
+         * @type {Event}
+         */
+        definitionChanged : {
+            get : function() {
+                return this._definitionChanged;
+            }
+        },
         /**
          * A {@link Color} {@link Property} which determines the material's color.
+         * @memberof ColorMaterialProperty.prototype
          * @type {Property}
-         * @default new ConstantProperty(Color.WHITE)
          */
-        this.color = new ConstantProperty(Color.WHITE);
-    };
+        color : createDynamicPropertyDescriptor('color')
+    });
 
     /**
      * Gets the {@link Material} type at the provided time.
@@ -48,7 +105,7 @@ define([
         if (!defined(result)) {
             result = {};
         }
-        result.color = defined(this.color) ? this.color.getValue(time, result.color) : undefined;
+        result.color = defined(this._color) ? this._color.getValue(time, result.color) : undefined;
         return result;
     };
 
@@ -63,7 +120,14 @@ define([
     ColorMaterialProperty.prototype.equals = function(other) {
         return this === other || //
                (other instanceof ColorMaterialProperty && //
-                Property.equals(this.color, other.color));
+                Property.equals(this._color, other._color));
+    };
+
+    /**
+     * @private
+     */
+    ColorMaterialProperty.prototype._raiseDefinitionChanged = function() {
+        this._definitionChanged.raiseEvent(this);
     };
 
     return ColorMaterialProperty;

Source/DynamicScene/CompositeDynamicObjectCollection.js

@@ -92,12 +92,12 @@ define(['../Core/createGuid',
     }
 
     function subscribeToProperty(that, eventHash, collectionId, dynamicObject, propertyName, property) {
-        if (defined(property) && defined(property.propertyChanged)) {
-            var subpropertyChanged = createSubPropertyChangedCallback(that, dynamicObject, propertyName);
+        if (defined(property) && defined(property.definitionChanged)) {
+            var subdefinitionChanged = createSubPropertyChangedCallback(that, dynamicObject, propertyName);
             propertyIdScratch[0] = collectionId;
             propertyIdScratch[1] = dynamicObject.id;
             propertyIdScratch[2] = propertyName;
-            eventHash[JSON.stringify(propertyIdScratch)] = property.propertyChanged.addEventListener(subpropertyChanged);
+            eventHash[JSON.stringify(propertyIdScratch)] = property.definitionChanged.addEventListener(subdefinitionChanged);
         }
     }
 
@@ -116,7 +116,7 @@ define(['../Core/createGuid',
     function subscribeToDynamicObject(that, eventHash, collectionId, dynamicObject) {
         dynamicObjectIdScratch[0] = collectionId;
         dynamicObjectIdScratch[1] = dynamicObject.id;
-        eventHash[JSON.stringify(dynamicObjectIdScratch)] = dynamicObject.propertyChanged.addEventListener(createPropertyChangedCallback(that, collectionId));
+        eventHash[JSON.stringify(dynamicObjectIdScratch)] = dynamicObject.definitionChanged.addEventListener(createPropertyChangedCallback(that, collectionId));
 
         var properties = dynamicObject.propertyNames;
         var length = properties.length;

Source/DynamicScene/CompositeMaterialProperty.js

@@ -1,15 +1,16 @@
 /*global define*/
-define([
-        '../Core/defined',
+define(['../Core/defined',
         '../Core/defineProperties',
         '../Core/DeveloperError',
-        '../Core/TimeIntervalCollection',
+        '../Core/Event',
+        './CompositeProperty',
         './Property'
     ], function(
         defined,
         defineProperties,
         DeveloperError,
-        TimeIntervalCollection,
+        Event,
+        CompositeProperty,
         Property) {
     "use strict";
 
@@ -20,10 +21,35 @@ define([
      * @constructor
      */
     var CompositeMaterialProperty = function() {
-        this._intervals = new TimeIntervalCollection();
+        this._definitionChanged = new Event();
+        this._composite = new CompositeProperty();
+        this._composite.definitionChanged.addEventListener(CompositeMaterialProperty.prototype._raiseDefinitionChanged, this);
     };
 
     defineProperties(CompositeMaterialProperty.prototype, {
+        /**
+         * Gets a value indicating if this property is constant.  A property is considered
+         * constant if getValue always returns the same result for the current definition.
+         * @memberof CompositeMaterialProperty.prototype
+         * @type {Boolean}
+         */
+        isConstant : {
+            get : function() {
+                return this._composite.isConstant;
+            }
+        },
+        /**
+         * Gets the event that is raised whenever the definition of this property changes.
+         * The definition is changed whenever setValue is called with data different
+         * than the current value.
+         * @memberof CompositeMaterialProperty.prototype
+         * @type {Event}
+         */
+        definitionChanged : {
+            get : function() {
+                return this._definitionChanged;
+            }
+        },
         /**
          * Gets the interval collection.
          * @memberof CompositeMaterialProperty.prototype
@@ -32,7 +58,7 @@ define([
          */
         intervals : {
             get : function() {
-                return this._intervals;
+                return this._composite._intervals;
             }
         }
     });
@@ -51,7 +77,7 @@ define([
         }
         //>>includeEnd('debug');
 
-        var innerProperty = this._intervals.findDataForIntervalContainingDate(time);
+        var innerProperty = this._composite._intervals.findDataForIntervalContainingDate(time);
         if (defined(innerProperty)) {
             return innerProperty.getType(time);
         }
@@ -73,7 +99,7 @@ define([
         }
         //>>includeEnd('debug');
 
-        var innerProperty = this._intervals.findDataForIntervalContainingDate(time);
+        var innerProperty = this._composite._intervals.findDataForIntervalContainingDate(time);
         if (defined(innerProperty)) {
             return innerProperty.getValue(time, result);
         }
@@ -91,7 +117,14 @@ define([
     CompositeMaterialProperty.prototype.equals = function(other) {
         return this === other || //
                (other instanceof CompositeMaterialProperty && //
-                this._intervals.equals(other._intervals, Property.equals));
+                this._composite.equals(other._composite, Property.equals));
+    };
+
+    /**
+     * @private
+     */
+    CompositeMaterialProperty.prototype._raiseDefinitionChanged = function() {
+        this._definitionChanged.raiseEvent(this);
     };
 
     return CompositeMaterialProperty;

Source/DynamicScene/CompositePositionProperty.js

@@ -1,19 +1,20 @@
 /*global define*/
-define([
-        '../Core/defaultValue',
+define(['../Core/defaultValue',
         '../Core/defined',
         '../Core/defineProperties',
         '../Core/DeveloperError',
-        '../Core/TimeIntervalCollection',
+        '../Core/Event',
         '../Core/ReferenceFrame',
+        './CompositeProperty',
         './Property'
     ], function(
         defaultValue,
         defined,
         defineProperties,
         DeveloperError,
-        TimeIntervalCollection,
+        Event,
         ReferenceFrame,
+        CompositeProperty,
         Property) {
     "use strict";
 
@@ -24,11 +25,36 @@ define([
      * @constructor
      */
     var CompositePositionProperty = function(referenceFrame) {
-        this._intervals = new TimeIntervalCollection();
         this._referenceFrame = defaultValue(referenceFrame, ReferenceFrame.FIXED);
+        this._definitionChanged = new Event();
+        this._composite = new CompositeProperty();
+        this._composite.definitionChanged.addEventListener(CompositePositionProperty.prototype._raiseDefinitionChanged, this);
     };
 
     defineProperties(CompositePositionProperty.prototype, {
+        /**
+         * Gets a value indicating if this property is constant.  A property is considered
+         * constant if getValue always returns the same result for the current definition.
+         * @memberof CompositePositionProperty.prototype
+         * @type {Boolean}
+         */
+        isConstant : {
+            get : function() {
+                return this._composite.isConstant;
+            }
+        },
+        /**
+         * Gets the event that is raised whenever the definition of this property changes.
+         * The definition is changed whenever setValue is called with data different
+         * than the current value.
+         * @memberof CompositePositionProperty.prototype
+         * @type {Event}
+         */
+        definitionChanged : {
+            get : function() {
+                return this._definitionChanged;
+            }
+        },
         /**
          * Gets the interval collection.
          * @memberof CompositePositionProperty.prototype
@@ -37,7 +63,7 @@ define([
          */
         intervals : {
             get : function() {
-                return this._intervals;
+                return this._composite.intervals;
             }
         },
         /**
@@ -90,7 +116,7 @@ define([
         }
         //>>includeEnd('debug');
 
-        var innerProperty = this._intervals.findDataForIntervalContainingDate(time);
+        var innerProperty = this._composite._intervals.findDataForIntervalContainingDate(time);
         if (defined(innerProperty)) {
             return innerProperty.getValueInReferenceFrame(time, referenceFrame, result);
         }
@@ -109,7 +135,14 @@ define([
         return this === other || //
                (other instanceof CompositePositionProperty && //
                 this._referenceFrame === other._referenceFrame && //
-                this._intervals.equals(other._intervals, Property.equals));
+                this._composite.equals(other._composite, Property.equals));
+    };
+
+    /**
+     * @private
+     */
+    CompositePositionProperty.prototype._raiseDefinitionChanged = function() {
+        this._definitionChanged.raiseEvent(this);
     };
 
     return CompositePositionProperty;