cesium 0.13.0

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

@@ -0,0 +1,347 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/destroyObject',
+        '../Core/Color',
+        '../Core/Cartesian2',
+        '../Core/Cartesian3',
+        '../Scene/BillboardCollection',
+        '../Scene/HorizontalOrigin',
+        '../Scene/VerticalOrigin',
+        '../Renderer/TextureAtlasBuilder'
+    ], function(
+        DeveloperError,
+        destroyObject,
+        Color,
+        Cartesian2,
+        Cartesian3,
+        BillboardCollection,
+        HorizontalOrigin,
+        VerticalOrigin,
+        TextureAtlasBuilder) {
+    "use strict";
+
+    //Callback to create a callback so that we close over all of the proper values.
+    function textureReady(dynamicObject, billboardCollection, textureValue) {
+        return function(imageIndex) {
+            //By the time the texture was loaded, the billboard might already be
+            //gone or have been assigned a different texture.  Look it up again
+            //and check.
+            var currentIndex = dynamicObject._billboardVisualizerIndex;
+            if (typeof currentIndex !== 'undefined') {
+                var cbBillboard = billboardCollection.get(currentIndex);
+                if (cbBillboard._visualizerUrl === textureValue) {
+                    cbBillboard._visualizerTextureAvailable = true;
+                    cbBillboard.setImageIndex(imageIndex);
+                }
+            }
+        };
+    }
+
+    /**
+     * A DynamicObject visualizer which maps the DynamicBillboard instance
+     * in DynamicObject.billboard to a Billboard primitive.
+     * @alias DynamicBillboardVisualizer
+     * @constructor
+     *
+     * @param {Scene} scene The scene the primitives will be rendered in.
+     * @param {DynamicObjectCollection} [dynamicObjectCollection] The dynamicObjectCollection to visualize.
+     *
+     * @exception {DeveloperError} scene is required.
+     *
+     * @see DynamicBillboard
+     * @see Scene
+     * @see DynamicObject
+     * @see DynamicObjectCollection
+     * @see CompositeDynamicObjectCollection
+     * @see VisualizerCollection
+     * @see DynamicConeVisualizer
+     * @see DynamicConeVisualizerUsingCustomSensor
+     * @see DynamicLabelVisualizer
+     * @see DynamicPointVisualizer
+     * @see DynamicPolygonVisualizer
+     * @see DynamicPolylineVisualizer
+     * @see DynamicPyramidVisualizer
+     *
+     */
+    var DynamicBillboardVisualizer = function(scene, dynamicObjectCollection) {
+        if (typeof scene === 'undefined') {
+            throw new DeveloperError('scene is required.');
+        }
+
+        this._scene = scene;
+        this._unusedIndexes = [];
+        this._dynamicObjectCollection = undefined;
+
+        var billboardCollection = this._billboardCollection = new BillboardCollection();
+        var atlas = this._textureAtlas = scene.getContext().createTextureAtlas();
+        this._textureAtlasBuilder = new TextureAtlasBuilder(atlas);
+        billboardCollection.setTextureAtlas(atlas);
+        scene.getPrimitives().add(billboardCollection);
+        this.setDynamicObjectCollection(dynamicObjectCollection);
+    };
+
+    /**
+     * Returns the scene being used by this visualizer.
+     *
+     * @returns {Scene} The scene being used by this visualizer.
+     */
+    DynamicBillboardVisualizer.prototype.getScene = function() {
+        return this._scene;
+    };
+
+    /**
+     * Gets the DynamicObjectCollection being visualized.
+     *
+     * @returns {DynamicObjectCollection} The DynamicObjectCollection being visualized.
+     */
+    DynamicBillboardVisualizer.prototype.getDynamicObjectCollection = function() {
+        return this._dynamicObjectCollection;
+    };
+
+    /**
+     * Sets the DynamicObjectCollection to visualize.
+     *
+     * @param dynamicObjectCollection The DynamicObjectCollection to visualizer.
+     */
+    DynamicBillboardVisualizer.prototype.setDynamicObjectCollection = function(dynamicObjectCollection) {
+        var oldCollection = this._dynamicObjectCollection;
+        if (oldCollection !== dynamicObjectCollection) {
+            if (typeof oldCollection !== 'undefined') {
+                oldCollection.objectsRemoved.removeEventListener(DynamicBillboardVisualizer.prototype._onObjectsRemoved);
+                this.removeAllPrimitives();
+            }
+            this._dynamicObjectCollection = dynamicObjectCollection;
+            if (typeof dynamicObjectCollection !== 'undefined') {
+                dynamicObjectCollection.objectsRemoved.addEventListener(DynamicBillboardVisualizer.prototype._onObjectsRemoved, this);
+            }
+        }
+    };
+
+    /**
+     * Updates all of the primitives created by this visualizer to match their
+     * DynamicObject counterpart at the given time.
+     *
+     * @param {JulianDate} time The time to update to.
+     *
+     * @exception {DeveloperError} time is required.
+     */
+    DynamicBillboardVisualizer.prototype.update = function(time) {
+        if (typeof time === 'undefined') {
+            throw new DeveloperError('time is requied.');
+        }
+        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]);
+            }
+        }
+    };
+
+    /**
+     * Removes all primitives from the scene.
+     */
+    DynamicBillboardVisualizer.prototype.removeAllPrimitives = function() {
+        if (typeof this._dynamicObjectCollection !== 'undefined') {
+            this._unusedIndexes = [];
+            this._billboardCollection.removeAll();
+            var dynamicObjects = this._dynamicObjectCollection.getObjects();
+            for ( var i = dynamicObjects.length - 1; i > -1; i--) {
+                dynamicObjects[i]._billboardVisualizerIndex = undefined;
+            }
+        }
+    };
+
+    /**
+     * 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 DynamicBillboardVisualizer
+     *
+     * @return {Boolean} True if this object was destroyed; otherwise, false.
+     *
+     * @see DynamicBillboardVisualizer#destroy
+     */
+    DynamicBillboardVisualizer.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.
+     *
+     * @memberof DynamicBillboardVisualizer
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see DynamicBillboardVisualizer#isDestroyed
+     *
+     * @example
+     * visualizer = visualizer && visualizer.destroy();
+     */
+    DynamicBillboardVisualizer.prototype.destroy = function() {
+        this.removeAllPrimitives();
+        this._scene.getPrimitives().remove(this._billboardCollection);
+        return destroyObject(this);
+    };
+
+    var position;
+    var color;
+    var eyeOffset;
+    var pixelOffset;
+    DynamicBillboardVisualizer.prototype._updateObject = function(time, dynamicObject) {
+        var dynamicBillboard = dynamicObject.billboard;
+        if (typeof dynamicBillboard === 'undefined') {
+            return;
+        }
+
+        var positionProperty = dynamicObject.position;
+        if (typeof positionProperty === 'undefined') {
+            return;
+        }
+
+        var textureProperty = dynamicBillboard.image;
+        if (typeof textureProperty === 'undefined') {
+            return;
+        }
+
+        var billboard;
+        var showProperty = dynamicBillboard.show;
+        var billboardVisualizerIndex = dynamicObject._billboardVisualizerIndex;
+        var show = dynamicObject.isAvailable(time) && (typeof showProperty === 'undefined' || showProperty.getValue(time));
+
+        if (!show) {
+            //don't bother creating or updating anything else
+            if (typeof billboardVisualizerIndex !== 'undefined') {
+                billboard = this._billboardCollection.get(billboardVisualizerIndex);
+                billboard.setShow(false);
+                billboard.setImageIndex(-1);
+                billboard._visualizerUrl = undefined;
+                billboard._visualizerTextureAvailable = false;
+                dynamicObject._billboardVisualizerIndex = undefined;
+                this._unusedIndexes.push(billboardVisualizerIndex);
+            }
+            return;
+        }
+
+        if (typeof billboardVisualizerIndex === 'undefined') {
+            var unusedIndexes = this._unusedIndexes;
+            var length = unusedIndexes.length;
+            if (length > 0) {
+                billboardVisualizerIndex = unusedIndexes.pop();
+                billboard = this._billboardCollection.get(billboardVisualizerIndex);
+            } else {
+                billboardVisualizerIndex = this._billboardCollection.getLength();
+                billboard = this._billboardCollection.add();
+            }
+            dynamicObject._billboardVisualizerIndex = billboardVisualizerIndex;
+            billboard.dynamicObject = dynamicObject;
+            billboard._visualizerUrl = undefined;
+            billboard._visualizerTextureAvailable = false;
+
+            // CZML_TODO Determine official defaults
+            billboard.setColor(Color.WHITE);
+            billboard.setEyeOffset(Cartesian3.ZERO);
+            billboard.setPixelOffset(Cartesian2.ZERO);
+            billboard.setScale(1.0);
+            billboard.setHorizontalOrigin(HorizontalOrigin.CENTER);
+            billboard.setVerticalOrigin(VerticalOrigin.CENTER);
+        } else {
+            billboard = this._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));
+        }
+
+        billboard.setShow(billboard._visualizerTextureAvailable);
+        if (!billboard._visualizerTextureAvailable) {
+            return;
+        }
+
+        position = positionProperty.getValueCartesian(time, position);
+        if (typeof position !== 'undefined') {
+            billboard.setPosition(position);
+        }
+
+        var property = dynamicBillboard.color;
+
+        if (typeof property !== 'undefined') {
+            color = property.getValue(time, color);
+            if (typeof color !== 'undefined') {
+                billboard.setColor(color);
+            }
+        }
+
+        property = dynamicBillboard.eyeOffset;
+        if (typeof property !== 'undefined') {
+            eyeOffset = property.getValue(time, eyeOffset);
+            if (typeof eyeOffset !== 'undefined') {
+                billboard.setEyeOffset(eyeOffset);
+            }
+        }
+
+        property = dynamicBillboard.pixelOffset;
+        if (typeof property !== 'undefined') {
+            pixelOffset = property.getValue(time, pixelOffset);
+            if (typeof pixelOffset !== 'undefined') {
+                billboard.setPixelOffset(pixelOffset);
+            }
+        }
+
+        property = dynamicBillboard.scale;
+        if (typeof property !== 'undefined') {
+            var scale = property.getValue(time);
+            if (typeof scale !== 'undefined') {
+                billboard.setScale(scale);
+            }
+        }
+
+        property = dynamicBillboard.horizontalOrigin;
+        if (typeof property !== 'undefined') {
+            var horizontalOrigin = property.getValue(time);
+            if (typeof horizontalOrigin !== 'undefined') {
+                billboard.setHorizontalOrigin(horizontalOrigin);
+            }
+        }
+
+        property = dynamicBillboard.verticalOrigin;
+        if (typeof property !== 'undefined') {
+            var verticalOrigin = property.getValue(time);
+            if (typeof verticalOrigin !== 'undefined') {
+                billboard.setVerticalOrigin(verticalOrigin);
+            }
+        }
+    };
+
+    DynamicBillboardVisualizer.prototype._onObjectsRemoved = function(dynamicObjectCollection, dynamicObjects) {
+        var thisBillboardCollection = this._billboardCollection;
+        var thisUnusedIndexes = this._unusedIndexes;
+        for ( var i = dynamicObjects.length - 1; i > -1; i--) {
+            var dynamicObject = dynamicObjects[i];
+            var billboardVisualizerIndex = dynamicObject._billboardVisualizerIndex;
+            if (typeof billboardVisualizerIndex !== 'undefined') {
+                var billboard = thisBillboardCollection.get(billboardVisualizerIndex);
+                billboard.setShow(false);
+                billboard.setImageIndex(-1);
+                billboard._visualizerUrl = undefined;
+                billboard._visualizerTextureAvailable = false;
+                dynamicObject._billboardVisualizerIndex = undefined;
+                thisUnusedIndexes.push(billboardVisualizerIndex);
+            }
+        }
+    };
+
+    return DynamicBillboardVisualizer;
+});

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

@@ -0,0 +1,78 @@
+/*global define*/
+define([
+        './DynamicProperty',
+        './CzmlColor',
+        '../Scene/Material'
+    ], function(
+         DynamicProperty,
+         CzmlColor,
+         Material) {
+    "use strict";
+
+    /**
+     * A utility class for processing CZML color materials.
+     * @alias DynamicColorMaterial
+     * @constructor
+     */
+    var DynamicColorMaterial = function() {
+        /**
+         * A DynamicProperty of type CzmlColor which determines the material's color.
+         * @type DynamicProperty
+         */
+        this.color = undefined;
+    };
+
+    /**
+     * Returns true if the provided CZML interval contains color material data.
+     * @param czmlInterval The CZML interval to check.
+     * @returns {Boolean} true if the interval contains CZML color material data, false otherwise.
+     */
+    DynamicColorMaterial.isMaterial = function(czmlInterval) {
+        return typeof czmlInterval !== 'undefined' && typeof czmlInterval.solidColor !== 'undefined';
+    };
+
+    /**
+     * Returns true if the provided CZML interval contains color material data.
+     * @param czmlInterval The CZML interval to check.
+     * @returns {Boolean} true if the interval contains CZML color material data, false otherwise.
+     */
+    DynamicColorMaterial.prototype.isMaterial = DynamicColorMaterial.isMaterial;
+
+    /**
+     * Provided a CZML interval containing color material data, processes the
+     * interval into a new or existing instance of this class.
+     *
+     * @param {Object} czmlInterval The interval to process.
+     * @param {DynamicColorMaterial} [existingMaterial] The DynamicColorMaterial to modify.
+     */
+    DynamicColorMaterial.prototype.processCzmlIntervals = function(czmlInterval) {
+        var materialData = czmlInterval.solidColor;
+        if (typeof materialData !== 'undefined') {
+            if (typeof materialData.color !== 'undefined') {
+                var color = this.color;
+                if (typeof color === 'undefined') {
+                    this.color = color = new DynamicProperty(CzmlColor);
+                }
+                color.processCzmlIntervals(materialData.color);
+            }
+        }
+    };
+
+    /**
+     * Gets a Color Material that represents this dynamic material at the provided time.
+     *
+     * @param {JulianDate} time The desired time.
+     * @param {Context} context The context in which this material exists.
+     * @param {Material} [existingMaterial] An existing material to be modified.  If the material is undefined or not a Color Material, a new instance is created.
+     * @returns The modified existingMaterial parameter or a new Color Material instance if existingMaterial was undefined or not a Color Material.
+     */
+    DynamicColorMaterial.prototype.getValue = function(time, context, existingMaterial) {
+        if (typeof existingMaterial === 'undefined' || (existingMaterial.type !== Material.ColorType)) {
+            existingMaterial = Material.fromType(context, Material.ColorType);
+        }
+        existingMaterial.uniforms.color = this.color.getValue(time, existingMaterial.uniforms.color);
+        return existingMaterial;
+    };
+
+    return DynamicColorMaterial;
+});

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

@@ -0,0 +1,291 @@
+/*global define*/
+define([
+        '../Core/TimeInterval',
+        '../Core/defaultValue',
+        './CzmlBoolean',
+        './CzmlNumber',
+        './CzmlColor',
+        './DynamicProperty',
+        './DynamicMaterialProperty'
+       ], function(
+         TimeInterval,
+         defaultValue,
+         CzmlBoolean,
+         CzmlNumber,
+         CzmlColor,
+         DynamicProperty,
+         DynamicMaterialProperty) {
+    "use strict";
+
+    /**
+     * Represents a time-dynamic cone, typically used in conjunction with DynamicConeVisualizer and
+     * DynamicObjectCollection to visualize CZML.
+     *
+     * @alias DynamicCone
+     * @constructor
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see DynamicObjectCollection
+     * @see DynamicConeVisualizer
+     * @see VisualizerCollection
+     * @see ComplexConicSensor
+     * @see CzmlDefaults
+     */
+    var DynamicCone = function() {
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the cone's minimum clock-angle.
+         * @type DynamicProperty
+         */
+        this.minimumClockAngle = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the cone's maximum clock-angle.
+         * @type DynamicProperty
+         */
+        this.maximumClockAngle = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the cone's inner half-angle.
+         * @type DynamicProperty
+         */
+        this.innerHalfAngle = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the cone's outer half-angle.
+         * @type DynamicProperty
+         */
+        this.outerHalfAngle = undefined;
+        /**
+         * A DynamicMaterialProperty which determines the cone's cap material.
+         * @type DynamicMaterialProperty
+         */
+        this.capMaterial = undefined;
+        /**
+         * A DynamicMaterialProperty which determines the cone's inner material.
+         * @type DynamicMaterialProperty
+         */
+        this.innerMaterial = undefined;
+        /**
+         * A DynamicMaterialProperty which determines the cone's outer material.
+         * @type DynamicMaterialProperty
+         */
+        this.outerMaterial = undefined;
+        /**
+         * A DynamicMaterialProperty which determines the cone's silhouette material.
+         * @type DynamicMaterialProperty
+         */
+        this.silhouetteMaterial = undefined;
+        /**
+         * A DynamicProperty of type CzmlColor which determines the color of the line formed by the intersection of the cone and other central bodies.
+         * @type DynamicProperty
+         */
+        this.intersectionColor = undefined;
+        /**
+         * A DynamicProperty of type CzmlBoolean which determines the cone's intersection visibility
+         * @type DynamicProperty
+         */
+        this.showIntersection = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the cone's radius.
+         * @type DynamicProperty
+         */
+        this.radius = undefined;
+        /**
+         * A DynamicProperty of type CzmlBoolean which determines the cone's visibility
+         * @type DynamicProperty
+         */
+        this.show = undefined;
+    };
+
+    /**
+     * Processes a single CZML packet and merges its data into the provided DynamicObject's cone.
+     * If the DynamicObject does not have a cone, one is created.  This method is not
+     * normally called directly, but is part of the array of CZML processing functions that is
+     * passed into the DynamicObjectCollection constructor.
+     *
+     * @param {DynamicObject} dynamicObject The DynamicObject which will contain the cone data.
+     * @param {Object} packet The CZML packet to process.
+     * @returns {Boolean} true if any new properties were created while processing the packet, false otherwise.
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see DynamicObjectCollection
+     * @see CzmlDefaults#updaters
+     */
+    DynamicCone.processCzmlPacket = function(dynamicObject, packet) {
+        var coneData = packet.cone;
+        if (typeof coneData === 'undefined') {
+            return false;
+        }
+
+        var coneUpdated = false;
+        var cone = dynamicObject.cone;
+        coneUpdated = typeof cone === 'undefined';
+        if (coneUpdated) {
+            dynamicObject.cone = cone = new DynamicCone();
+        }
+
+        var interval = coneData.interval;
+        if (typeof interval !== 'undefined') {
+            interval = TimeInterval.fromIso8601(interval);
+        }
+
+        if (typeof coneData.show !== 'undefined') {
+            var show = cone.show;
+            if (typeof show === 'undefined') {
+                cone.show = show = new DynamicProperty(CzmlBoolean);
+                coneUpdated = true;
+            }
+            show.processCzmlIntervals(coneData.show, interval);
+        }
+
+        if (typeof coneData.innerHalfAngle !== 'undefined') {
+            var innerHalfAngle = cone.innerHalfAngle;
+            if (typeof innerHalfAngle === 'undefined') {
+                cone.innerHalfAngle = innerHalfAngle = new DynamicProperty(CzmlNumber);
+                coneUpdated = true;
+            }
+            innerHalfAngle.processCzmlIntervals(coneData.innerHalfAngle, interval);
+        }
+
+        if (typeof coneData.outerHalfAngle !== 'undefined') {
+            var outerHalfAngle = cone.outerHalfAngle;
+            if (typeof outerHalfAngle === 'undefined') {
+                cone.outerHalfAngle = outerHalfAngle = new DynamicProperty(CzmlNumber);
+                coneUpdated = true;
+            }
+            outerHalfAngle.processCzmlIntervals(coneData.outerHalfAngle, interval);
+        }
+
+        if (typeof coneData.minimumClockAngle !== 'undefined') {
+            var minimumClockAngle = cone.minimumClockAngle;
+            if (typeof minimumClockAngle === 'undefined') {
+                cone.minimumClockAngle = minimumClockAngle = new DynamicProperty(CzmlNumber);
+                coneUpdated = true;
+            }
+            minimumClockAngle.processCzmlIntervals(coneData.minimumClockAngle, interval);
+        }
+
+        if (typeof coneData.maximumClockAngle !== 'undefined') {
+            var maximumClockAngle = cone.maximumClockAngle;
+            if (typeof maximumClockAngle === 'undefined') {
+                cone.maximumClockAngle = maximumClockAngle = new DynamicProperty(CzmlNumber);
+                coneUpdated = true;
+            }
+            maximumClockAngle.processCzmlIntervals(coneData.maximumClockAngle, interval);
+        }
+
+        if (typeof coneData.radius !== 'undefined') {
+            var radius = cone.radius;
+            if (typeof radius === 'undefined') {
+                cone.radius = radius = new DynamicProperty(CzmlNumber);
+                coneUpdated = true;
+            }
+            radius.processCzmlIntervals(coneData.radius, interval);
+        }
+
+        if (typeof coneData.showIntersection !== 'undefined') {
+            var showIntersection = cone.showIntersection;
+            if (typeof showIntersection === 'undefined') {
+                cone.showIntersection = showIntersection = new DynamicProperty(CzmlBoolean);
+                coneUpdated = true;
+            }
+            showIntersection.processCzmlIntervals(coneData.showIntersection, interval);
+        }
+
+        if (typeof coneData.intersectionColor !== 'undefined') {
+            var intersectionColor = cone.intersectionColor;
+            if (typeof intersectionColor === 'undefined') {
+                cone.intersectionColor = intersectionColor = new DynamicProperty(CzmlColor);
+                coneUpdated = true;
+            }
+            intersectionColor.processCzmlIntervals(coneData.intersectionColor, interval);
+        }
+
+        if (typeof coneData.capMaterial !== 'undefined') {
+            var capMaterial = cone.capMaterial;
+            if (typeof capMaterial === 'undefined') {
+                cone.capMaterial = capMaterial = new DynamicMaterialProperty();
+                coneUpdated = true;
+            }
+            capMaterial.processCzmlIntervals(coneData.capMaterial, interval);
+        }
+
+        if (typeof coneData.innerMaterial !== 'undefined') {
+            var innerMaterial = cone.innerMaterial;
+            if (typeof innerMaterial === 'undefined') {
+                cone.innerMaterial = innerMaterial = new DynamicMaterialProperty();
+                coneUpdated = true;
+            }
+            innerMaterial.processCzmlIntervals(coneData.innerMaterial, interval);
+        }
+
+        if (typeof coneData.outerMaterial !== 'undefined') {
+            var outerMaterial = cone.outerMaterial;
+            if (typeof outerMaterial === 'undefined') {
+                cone.outerMaterial = outerMaterial = new DynamicMaterialProperty();
+                coneUpdated = true;
+            }
+            outerMaterial.processCzmlIntervals(coneData.outerMaterial, interval);
+        }
+
+        if (typeof coneData.silhouetteMaterial !== 'undefined') {
+            var silhouetteMaterial = cone.silhouetteMaterial;
+            if (typeof silhouetteMaterial === 'undefined') {
+                cone.silhouetteMaterial = silhouetteMaterial = new DynamicMaterialProperty();
+                coneUpdated = true;
+            }
+            silhouetteMaterial.processCzmlIntervals(coneData.silhouetteMaterial, interval);
+        }
+
+        return coneUpdated;
+    };
+
+    /**
+     * Given two DynamicObjects, takes the cone properties from the second
+     * and assigns them to the first, assuming such a property did not already exist.
+     * This method is not normally called directly, but is part of the array of CZML processing
+     * functions that is passed into the CompositeDynamicObjectCollection constructor.
+     *
+     * @param {DynamicObject} targetObject The DynamicObject which will have properties merged onto it.
+     * @param {DynamicObject} objectToMerge The DynamicObject containing properties to be merged.
+     *
+     * @see CzmlDefaults
+     */
+    DynamicCone.mergeProperties = function(targetObject, objectToMerge) {
+        var coneToMerge = objectToMerge.cone;
+        if (typeof coneToMerge !== 'undefined') {
+
+            var targetCone = targetObject.cone;
+            if (typeof targetCone === 'undefined') {
+                targetObject.cone = targetCone = new DynamicCone();
+            }
+
+            targetCone.show = defaultValue(targetCone.show, coneToMerge.show);
+            targetCone.innerHalfAngle = defaultValue(targetCone.innerHalfAngle, coneToMerge.innerHalfAngle);
+            targetCone.outerHalfAngle = defaultValue(targetCone.outerHalfAngle, coneToMerge.outerHalfAngle);
+            targetCone.minimumClockAngle = defaultValue(targetCone.minimumClockAngle, coneToMerge.minimumClockAngle);
+            targetCone.maximumClockAngle = defaultValue(targetCone.maximumClockAngle, coneToMerge.maximumClockAngle);
+            targetCone.radius = defaultValue(targetCone.radius, coneToMerge.radius);
+            targetCone.showIntersection = defaultValue(targetCone.showIntersection, coneToMerge.showIntersection);
+            targetCone.intersectionColor = defaultValue(targetCone.intersectionColor, coneToMerge.intersectionColor);
+            targetCone.capMaterial = defaultValue(targetCone.capMaterial, coneToMerge.capMaterial);
+            targetCone.innerMaterial = defaultValue(targetCone.innerMaterial, coneToMerge.innerMaterial);
+            targetCone.outerMaterial = defaultValue(targetCone.outerMaterial, coneToMerge.outerMaterial);
+            targetCone.silhouetteMaterial = defaultValue(targetCone.silhouetteMaterial, coneToMerge.silhouetteMaterial);
+        }
+    };
+
+    /**
+     * Given a DynamicObject, undefines the cone associated with it.
+     * This method is not normally called directly, but is part of the array of CZML processing
+     * functions that is passed into the CompositeDynamicObjectCollection constructor.
+     *
+     * @param {DynamicObject} dynamicObject The DynamicObject to remove the cone from.
+     *
+     * @see CzmlDefaults
+     */
+    DynamicCone.undefineProperties = function(dynamicObject) {
+        dynamicObject.cone = undefined;
+    };
+
+    return DynamicCone;
+});