cesium 0.13.0

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

@@ -0,0 +1,163 @@
+/*global define*/
+define([
+        '../Core/JulianDate',
+        '../Core/TimeInterval',
+        '../Core/TimeIntervalCollection',
+        '../Core/Cartesian3',
+        '../Core/Spherical',
+        '../Core/Iso8601'
+    ], function(
+        JulianDate,
+        TimeInterval,
+        TimeIntervalCollection,
+        Cartesian3,
+        Spherical,
+        Iso8601) {
+    "use strict";
+
+    function ValueHolder(czmlInterval) {
+        var i;
+        var len;
+        var values = [];
+        var tmp = czmlInterval.unitSpherical;
+        if (typeof tmp !== 'undefined') {
+            for (i = 0, len = tmp.length; i < len; i += 2) {
+                values.push(new Spherical(tmp[i], tmp[i + 1]));
+            }
+            this.spherical = values;
+        }
+
+        tmp = czmlInterval.unitCartesian;
+        if (typeof tmp !== 'undefined') {
+            for (i = 0, len = tmp.length; i < len; i += 3) {
+                values.push(new Cartesian3(tmp[i], tmp[i + 1], tmp[i + 2], true));
+            }
+            this.cartesian = values;
+        }
+    }
+
+    ValueHolder.prototype.getValueSpherical = function() {
+        var sphericals = this.spherical;
+        if (typeof sphericals === 'undefined') {
+            sphericals = [];
+            this.spherical = sphericals;
+            var cartesians = this.cartesian;
+            for ( var i = 0, len = cartesians.length; i < len; i++) {
+                sphericals.push(Spherical.fromCartesian3(cartesians[i]));
+            }
+        }
+        return sphericals;
+    };
+
+    ValueHolder.prototype.getValueCartesian = function() {
+        var cartesians = this.cartesian;
+        if (typeof cartesians === 'undefined') {
+            cartesians = [];
+            this.cartesian = cartesians;
+            var sphericals = this.spherical;
+            for ( var i = 0, len = sphericals.length; i < len; i++) {
+                cartesians.push(Cartesian3.fromSpherical(sphericals[i]));
+            }
+        }
+        return cartesians;
+    };
+
+    /**
+     * A dynamic property which maintains an array of directions that can change over time.
+     * The directions can be represented as both Cartesian and Spherical coordinates.
+     * Rather than creating instances of this object directly, it's typically
+     * created and managed via loading CZML data into a DynamicObjectCollection.
+     * Instances of this type are exposed via DynamicObject and it's sub-objects
+     * and are responsible for interpreting and interpolating the data for visualization.
+     * </p>
+     *
+     * @alias DynamicDirectionsProperty
+     * @constructor
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see ReferenceProperty
+     * @see DynamicMaterialProperty
+     * @see DynamicPositionProperty
+     * @see DynamicVertexPositionsProperty
+     */
+    var DynamicDirectionsProperty = function() {
+        this._propertyIntervals = new TimeIntervalCollection();
+    };
+
+    /**
+     * Processes the provided CZML interval or intervals into this property.
+     *
+     * @memberof DynamicDirectionsProperty
+     *
+     * @param {Object} czmlIntervals The CZML data to process.
+     * @param {TimeInterval} [constrainedInterval] Constrains the processing so that any times outside of this interval are ignored.
+     * @param {DynamicObjectCollection} dynamicObjectCollection The DynamicObjectCollection to be used as a target for resolving links within this property.
+     */
+    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);
+            }
+        } else {
+            this._addCzmlInterval(czmlIntervals, constrainedInterval, dynamicObjectCollection);
+        }
+    };
+
+    /**
+     * Retrieves the values at the supplied time as Spherical coordinates.
+     * @memberof DynamicDirectionsProperty
+     *
+     * @param {JulianDate} time The time for which to retrieve the value.
+     * @returns An array of spherical coordinates for the provided time.
+     */
+    DynamicDirectionsProperty.prototype.getValueSpherical = function(time) {
+        var interval = this._propertyIntervals.findIntervalContainingDate(time);
+        if (typeof interval === 'undefined') {
+            return undefined;
+        }
+        return interval.data.getValueSpherical();
+    };
+
+    /**
+     * Retrieves the values at the supplied time as unit cartesian coordinates.
+     * @memberof DynamicDirectionsProperty
+     *
+     * @param {JulianDate} time The time for which to retrieve the value.
+     * @returns An array of unit cartesian coordinates for the provided time.
+     */
+    DynamicDirectionsProperty.prototype.getValueCartesian = function(time) {
+        var interval = this._propertyIntervals.findIntervalContainingDate(time);
+        if (typeof interval === 'undefined') {
+            return undefined;
+        }
+        return interval.data.getValueCartesian();
+    };
+
+    DynamicDirectionsProperty.prototype._addCzmlInterval = function(czmlInterval, constrainedInterval, dynamicObjectCollection) {
+        var iso8601Interval = czmlInterval.interval;
+        if (typeof iso8601Interval === 'undefined') {
+            iso8601Interval = Iso8601.MAXIMUM_INTERVAL.clone();
+        } else {
+            iso8601Interval = TimeInterval.fromIso8601(iso8601Interval);
+        }
+
+        if (typeof constrainedInterval !== 'undefined') {
+            iso8601Interval = iso8601Interval.intersect(constrainedInterval);
+        }
+
+        //See if we already have data at that interval.
+        var thisIntervals = this._propertyIntervals;
+        var existingInterval = thisIntervals.findInterval(iso8601Interval.start, iso8601Interval.stop);
+
+        //If not, create it.
+        if (typeof existingInterval === 'undefined') {
+            existingInterval = iso8601Interval;
+            thisIntervals.addInterval(existingInterval);
+        }
+
+        existingInterval.data = new ValueHolder(czmlInterval);
+    };
+
+    return DynamicDirectionsProperty;
+});

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

@@ -0,0 +1,158 @@
+/*global define*/
+define([
+        '../Core/TimeInterval',
+        '../Core/defaultValue',
+        './CzmlBoolean',
+        './CzmlCartesian3',
+        './CzmlColor',
+        './DynamicProperty',
+        './DynamicMaterialProperty'
+    ], function(
+        TimeInterval,
+        defaultValue,
+        CzmlBoolean,
+        CzmlCartesian3,
+        CzmlColor,
+        DynamicProperty,
+        DynamicMaterialProperty) {
+    "use strict";
+
+    /**
+     * Represents a time-dynamic ellipsoid, typically used in conjunction with DynamicEllipsoidVisualizer and
+     * DynamicObjectCollection to visualize CZML.
+     *
+     * @alias DynamicEllipsoid
+     * @constructor
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see DynamicObjectCollection
+     * @see DynamicEllipsoidVisualizer
+     * @see VisualizerCollection
+     * @see CustomSensor
+     * @see CzmlDefaults
+     */
+    var DynamicEllipsoid = function() {
+        /**
+         * A DynamicProperty of type CzmlBoolean which determines the ellipsoid's visibility.
+         * @type DynamicProperty
+         */
+        this.show = undefined;
+        /**
+         * A DynamicProperty of type CzmlCartesian3 which determines the ellipsoid's radii.
+         * @type DynamicProperty
+         */
+        this.radii = undefined;
+        /**
+         * A DynamicMaterialProperty which determines the material.
+         * @type DynamicMaterialProperty
+         */
+        this.material = undefined;
+    };
+
+    /**
+     * Processes a single CZML packet and merges its data into the provided DynamicObject's ellipsoid.
+     * If the DynamicObject does not have a ellipsoid, 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 ellipsoid data.
+     * @param {Object} packet The CZML packet to process.
+     * @param {DynamicObject} dynamicObjectCollection The DynamicObjectCollection to which the DynamicObject belongs.
+     *
+     * @returns {Boolean} true if any new properties were created while processing the packet, false otherwise.
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see DynamicObjectCollection
+     * @see CzmlDefaults#updaters
+     */
+    DynamicEllipsoid.processCzmlPacket = function(dynamicObject, packet, dynamicObjectCollection) {
+        var ellipsoidData = packet.ellipsoid;
+        if (typeof ellipsoidData === 'undefined') {
+            return false;
+        }
+
+        var ellipsoidUpdated = false;
+        var ellipsoid = dynamicObject.ellipsoid;
+        ellipsoidUpdated = typeof ellipsoid === 'undefined';
+        if (ellipsoidUpdated) {
+            dynamicObject.ellipsoid = ellipsoid = new DynamicEllipsoid();
+        }
+
+        var interval = ellipsoidData.interval;
+        if (typeof interval !== 'undefined') {
+            interval = TimeInterval.fromIso8601(interval);
+        }
+
+        if (typeof ellipsoidData.show !== 'undefined') {
+            var show = ellipsoid.show;
+            if (typeof show === 'undefined') {
+                ellipsoid.show = show = new DynamicProperty(CzmlBoolean);
+                ellipsoidUpdated = true;
+            }
+            show.processCzmlIntervals(ellipsoidData.show, interval);
+        }
+
+        if (typeof ellipsoidData.radii !== 'undefined') {
+            var radii = ellipsoid.radii;
+            if (typeof radii === 'undefined') {
+                ellipsoid.radii = radii = new DynamicProperty(CzmlCartesian3);
+                ellipsoidUpdated = true;
+            }
+            radii.processCzmlIntervals(ellipsoidData.radii, interval);
+        }
+
+        if (typeof ellipsoidData.material !== 'undefined') {
+            var material = ellipsoid.material;
+            if (typeof material === 'undefined') {
+                ellipsoid.material = material = new DynamicMaterialProperty();
+                ellipsoidUpdated = true;
+            }
+            material.processCzmlIntervals(ellipsoidData.material, interval);
+        }
+
+        return ellipsoidUpdated;
+    };
+
+    /**
+     * Given two DynamicObjects, takes the ellipsoid 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
+     */
+    DynamicEllipsoid.mergeProperties = function(targetObject, objectToMerge) {
+        var ellipsoidToMerge = objectToMerge.ellipsoid;
+        if (typeof ellipsoidToMerge !== 'undefined') {
+
+            var targetEllipsoid = targetObject.ellipsoid;
+            if (typeof targetEllipsoid === 'undefined') {
+                targetObject.ellipsoid = targetEllipsoid = new DynamicEllipsoid();
+            }
+
+            targetEllipsoid.show = defaultValue(targetEllipsoid.show, ellipsoidToMerge.show);
+            targetEllipsoid.radii = defaultValue(targetEllipsoid.radii, ellipsoidToMerge.radii);
+            targetEllipsoid.material = defaultValue(targetEllipsoid.material, ellipsoidToMerge.material);
+        }
+    };
+
+    /**
+     * Given a DynamicObject, undefines the ellipsoid 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 ellipsoid from.
+     *
+     * @see CzmlDefaults
+     */
+    DynamicEllipsoid.undefineProperties = function(dynamicObject) {
+        dynamicObject.ellipsoid = undefined;
+    };
+
+    return DynamicEllipsoid;
+});

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

@@ -0,0 +1,277 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/DeveloperError',
+        '../Core/destroyObject',
+        '../Core/Color',
+        '../Core/Matrix3',
+        '../Core/Matrix4',
+        '../Scene/EllipsoidPrimitive',
+        '../Scene/Material'
+       ], function(
+         defaultValue,
+         DeveloperError,
+         destroyObject,
+         Color,
+         Matrix3,
+         Matrix4,
+         EllipsoidPrimitive,
+         Material) {
+    "use strict";
+
+    var matrix3Scratch = new Matrix3();
+
+    /**
+     * A DynamicObject visualizer which maps the DynamicEllipsoid instance
+     * in DynamicObject.ellipsoid to a Ellipsoid primitive.
+     * @alias DynamicEllipsoidVisualizer
+     * @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 DynamicEllipsoid
+     * @see Scene
+     * @see DynamicObject
+     * @see DynamicObjectCollection
+     * @see CompositeDynamicObjectCollection
+     * @see VisualizerCollection
+     * @see DynamicBillboardVisualizer
+     * @see DynamicConeVisualizer
+     * @see DynamicConeVisualizerUsingCustomSensorr
+     * @see DynamicLabelVisualizer
+     * @see DynamicPointVisualizer
+     * @see DynamicPolygonVisualizer
+     * @see DynamicPolylineVisualizer
+     */
+    var DynamicEllipsoidVisualizer = function(scene, dynamicObjectCollection) {
+        if (typeof scene === 'undefined') {
+            throw new DeveloperError('scene is required.');
+        }
+        this._scene = scene;
+        this._unusedIndexes = [];
+        this._primitives = scene.getPrimitives();
+        this._ellipsoidCollection = [];
+        this._dynamicObjectCollection = undefined;
+        this.setDynamicObjectCollection(dynamicObjectCollection);
+    };
+
+    /**
+     * Returns the scene being used by this visualizer.
+     *
+     * @returns {Scene} The scene being used by this visualizer.
+     */
+    DynamicEllipsoidVisualizer.prototype.getScene = function() {
+        return this._scene;
+    };
+
+    /**
+     * Gets the DynamicObjectCollection being visualized.
+     *
+     * @returns {DynamicObjectCollection} The DynamicObjectCollection being visualized.
+     */
+    DynamicEllipsoidVisualizer.prototype.getDynamicObjectCollection = function() {
+        return this._dynamicObjectCollection;
+    };
+
+    /**
+     * Sets the DynamicObjectCollection to visualize.
+     *
+     * @param dynamicObjectCollection The DynamicObjectCollection to visualizer.
+     */
+    DynamicEllipsoidVisualizer.prototype.setDynamicObjectCollection = function(dynamicObjectCollection) {
+        var oldCollection = this._dynamicObjectCollection;
+        if (oldCollection !== dynamicObjectCollection) {
+            if (typeof oldCollection !== 'undefined') {
+                oldCollection.objectsRemoved.removeEventListener(DynamicEllipsoidVisualizer.prototype._onObjectsRemoved);
+                this.removeAllPrimitives();
+            }
+            this._dynamicObjectCollection = dynamicObjectCollection;
+            if (typeof dynamicObjectCollection !== 'undefined') {
+                dynamicObjectCollection.objectsRemoved.addEventListener(DynamicEllipsoidVisualizer.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.
+     */
+    DynamicEllipsoidVisualizer.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.
+     */
+    DynamicEllipsoidVisualizer.prototype.removeAllPrimitives = function() {
+        var i, len;
+        for (i = 0, len = this._ellipsoidCollection.length; i < len; i++) {
+            this._primitives.remove(this._ellipsoidCollection[i]);
+        }
+
+        if (typeof this._dynamicObjectCollection !== 'undefined') {
+            var dynamicObjects = this._dynamicObjectCollection.getObjects();
+            for (i = dynamicObjects.length - 1; i > -1; i--) {
+                dynamicObjects[i]._ellipsoidVisualizerIndex = undefined;
+            }
+        }
+
+        this._unusedIndexes = [];
+        this._ellipsoidCollection = [];
+    };
+
+    /**
+     * 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 DynamicEllipsoidVisualizer
+     *
+     * @return {Boolean} True if this object was destroyed; otherwise, false.
+     *
+     * @see DynamicEllipsoidVisualizer#destroy
+     */
+    DynamicEllipsoidVisualizer.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 DynamicEllipsoidVisualizer
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see DynamicEllipsoidVisualizer#isDestroyed
+     *
+     * @example
+     * visualizer = visualizer && visualizer.destroy();
+     */
+    DynamicEllipsoidVisualizer.prototype.destroy = function() {
+        this.removeAllPrimitives();
+        return destroyObject(this);
+    };
+
+    var position;
+    var orientation;
+    DynamicEllipsoidVisualizer.prototype._updateObject = function(time, dynamicObject) {
+        var context = this._scene.getContext();
+        var dynamicEllipsoid = dynamicObject.ellipsoid;
+        if (typeof dynamicEllipsoid === 'undefined') {
+            return;
+        }
+
+        var radiiProperty = dynamicEllipsoid.radii;
+        if (typeof radiiProperty === 'undefined') {
+            return;
+        }
+
+        var positionProperty = dynamicObject.position;
+        if (typeof positionProperty === 'undefined') {
+            return;
+        }
+
+        var orientationProperty = dynamicObject.orientation;
+        if (typeof orientationProperty === 'undefined') {
+            return;
+        }
+
+        var ellipsoid;
+        var showProperty = dynamicEllipsoid.show;
+        var ellipsoidVisualizerIndex = dynamicObject._ellipsoidVisualizerIndex;
+        var show = dynamicObject.isAvailable(time) && (typeof showProperty === 'undefined' || showProperty.getValue(time));
+
+        if (!show) {
+            //don't bother creating or updating anything else
+            if (typeof ellipsoidVisualizerIndex !== 'undefined') {
+                ellipsoid = this._ellipsoidCollection[ellipsoidVisualizerIndex];
+                ellipsoid.show = false;
+                dynamicObject._ellipsoidVisualizerIndex = undefined;
+                this._unusedIndexes.push(ellipsoidVisualizerIndex);
+            }
+            return;
+        }
+
+        if (typeof ellipsoidVisualizerIndex === 'undefined') {
+            var unusedIndexes = this._unusedIndexes;
+            var length = unusedIndexes.length;
+            if (length > 0) {
+                ellipsoidVisualizerIndex = unusedIndexes.pop();
+                ellipsoid = this._ellipsoidCollection[ellipsoidVisualizerIndex];
+            } else {
+                ellipsoidVisualizerIndex = this._ellipsoidCollection.length;
+                ellipsoid = new EllipsoidPrimitive();
+
+                this._ellipsoidCollection.push(ellipsoid);
+                this._primitives.add(ellipsoid);
+            }
+            dynamicObject._ellipsoidVisualizerIndex = ellipsoidVisualizerIndex;
+            ellipsoid.dynamicObject = dynamicObject;
+
+            ellipsoid.material = Material.fromType(context, Material.ColorType);
+        } else {
+            ellipsoid = this._ellipsoidCollection[ellipsoidVisualizerIndex];
+        }
+
+        ellipsoid.show = true;
+
+        ellipsoid.radii = radiiProperty.getValue(time, ellipsoid.radii);
+
+        position = defaultValue(positionProperty.getValueCartesian(time, position), ellipsoid._visualizerPosition);
+        orientation = defaultValue(orientationProperty.getValue(time, orientation), ellipsoid._visualizerOrientation);
+
+        if (typeof position !== 'undefined' &&
+            typeof orientation !== 'undefined' &&
+            (!position.equals(ellipsoid._visualizerPosition) ||
+             !orientation.equals(ellipsoid._visualizerOrientation))) {
+            Matrix4.fromRotationTranslation(Matrix3.fromQuaternion(orientation, matrix3Scratch), position, ellipsoid.modelMatrix);
+            ellipsoid._visualizerPosition = position.clone(ellipsoid._visualizerPosition);
+            ellipsoid._visualizerOrientation = orientation.clone(ellipsoid._visualizerOrientation);
+        }
+
+        var material = dynamicEllipsoid.material;
+        if (typeof material !== 'undefined') {
+            ellipsoid.material = material.getValue(time, context, ellipsoid.material);
+        }
+    };
+
+    DynamicEllipsoidVisualizer.prototype._onObjectsRemoved = function(dynamicObjectCollection, dynamicObjects) {
+        var thisEllipsoidCollection = this._ellipsoidCollection;
+        var thisUnusedIndexes = this._unusedIndexes;
+        for ( var i = dynamicObjects.length - 1; i > -1; i--) {
+            var dynamicObject = dynamicObjects[i];
+            var ellipsoidVisualizerIndex = dynamicObject._ellipsoidVisualizerIndex;
+            if (typeof ellipsoidVisualizerIndex !== 'undefined') {
+                var ellipsoid = thisEllipsoidCollection[ellipsoidVisualizerIndex];
+                ellipsoid.show = false;
+                thisUnusedIndexes.push(ellipsoidVisualizerIndex);
+                dynamicObject._ellipsoidVisualizerIndex = undefined;
+            }
+        }
+    };
+
+    return DynamicEllipsoidVisualizer;
+});