cesium 0.13.0

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

@@ -0,0 +1,155 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/DeveloperError'
+       ], function(
+         defaultValue,
+         DeveloperError) {
+    "use strict";
+
+    function resolve(referenceProperty) {
+        var targetProperty = referenceProperty._targetProperty;
+        if (typeof targetProperty === 'undefined') {
+            var resolveBuffer = defaultValue(referenceProperty._dynamicObjectCollection.compositeCollection, referenceProperty._dynamicObjectCollection);
+            var targetObject = resolveBuffer.getObject(referenceProperty._targetObjectId);
+            if (typeof targetObject !== 'undefined') {
+                targetProperty = targetObject[referenceProperty._targetPropertyName];
+                referenceProperty._targetProperty = targetProperty;
+            }
+        }
+        return targetProperty;
+    }
+
+    /**
+     * A dynamic property which transparently links to another property, which may
+     * or may not exist yet.  It is up to the caller to know which kind of property
+     * is being linked to.
+     *
+     * @alias ReferenceProperty
+     * @constructor
+     *
+     * @param {DynamicObjectCollection} dynamicObjectCollection The object collection which will be used to resolve the reference.
+     * @param {String} targetObjectId The id of the object which is being referenced.
+     * @param {String} targetPropertyName The name of the property on the target object which we will use.
+     *
+     * @exception {DeveloperError} dynamicObjectCollection is required.
+     * @exception {DeveloperError} targetObjectId is required.
+     * @exception {DeveloperError} targetPropertyName is required.
+     *
+     * @see ReferenceProperty#fromString
+     * @see DynamicProperty
+     * @see DynamicPositionProperty
+     * @see DynamicDirectionsProperty
+     * @see DynamicVertexPositionsProperty
+     * @see DynamicObjectCollection
+     * @see CompositeDynamicObjectCollection
+     */
+    var ReferenceProperty = function(dynamicObjectCollection, targetObjectId, targetPropertyName) {
+        if (typeof dynamicObjectCollection === 'undefined') {
+            throw new DeveloperError('dynamicObjectCollection is required.');
+        }
+        if (typeof targetObjectId === 'undefined') {
+            throw new DeveloperError('targetObjectId is required.');
+        }
+        if (typeof targetPropertyName === 'undefined') {
+            throw new DeveloperError('targetPropertyName is required.');
+        }
+
+        this._targetProperty = undefined;
+        this._dynamicObjectCollection = dynamicObjectCollection;
+        this._targetObjectId = targetObjectId;
+        this._targetPropertyName = targetPropertyName;
+    };
+
+    /**
+     * Creates a new reference property given the dynamic object collection that will
+     * be used to resolve it and a string indicating the target object id and property,
+     * delineated by a period.
+     *
+     * @param {DynamicObject} dynamicObjectCollection
+     * @param referenceString
+     *
+     * @exception {DeveloperError} dynamicObjectCollection is required.
+     * @exception {DeveloperError} referenceString is required.
+     * @exception {DeveloperError} referenceString must contain a single . delineating the target object ID and property name.
+     *
+     * @see ReferenceProperty#fromString
+     * @see DynamicProperty
+     * @see DynamicPositionProperty
+     * @see DynamicDirectionsProperty
+     * @see DynamicVertexPositionsProperty
+     * @see DynamicObjectCollection
+     * @see CompositeDynamicObjectCollection
+     *
+     * @returns A new instance of ReferenceProperty.
+     */
+    ReferenceProperty.fromString = function(dynamicObjectCollection, referenceString) {
+        if (typeof dynamicObjectCollection === 'undefined') {
+            throw new DeveloperError('dynamicObjectCollection is required.');
+        }
+
+        if (typeof referenceString === 'undefined') {
+            throw new DeveloperError('referenceString is required.');
+        }
+
+        var parts = referenceString.split('.');
+        if (parts.length !== 2) {
+            throw new DeveloperError('referenceString must contain a single . delineating the target object ID and property name.');
+        }
+
+        return new ReferenceProperty(dynamicObjectCollection, parts[0], parts[1]);
+    };
+
+    /**
+     * Retrieves the value of the property at the specified time.
+     *
+     * @param time The time to evaluate the property.
+     * @param [result] The object to store the result in, if undefined a new instance will be created.
+     * @returns The result parameter or a new instance if the parameter was omitted.
+     */
+    ReferenceProperty.prototype.getValue = function(time, result) {
+        var targetProperty = resolve(this);
+        return typeof targetProperty !== 'undefined' ? targetProperty.getValue(time, result) : undefined;
+    };
+
+    /**
+     * Retrieves the Cartographic value or values of the property at the specified time if the linked property
+     * is a DynamicPositionProperty or DynamicVertexPositionsProperty.
+     *
+     * @param time The time to evaluate the property.
+     * @param [result] The object to store the result in, if undefined a new instance will be created.
+     * @returns The result parameter or a new instance if the parameter was omitted.
+     */
+    ReferenceProperty.prototype.getValueCartographic = function(time, result) {
+        var targetProperty = resolve(this);
+        return typeof targetProperty !== 'undefined' ? targetProperty.getValueCartographic(time, result) : undefined;
+    };
+
+    /**
+     * Retrieves the Cartesian value or values of the property at the specified time if the linked property
+     * is a DynamicPositionProperty, DynamicVertexPositionsProperty, or DynamicDirectionsProperty.
+     *
+     * @param time The time to evaluate the property.
+     * @param [result] The object to store the result in, if undefined a new instance will be created.
+     * @returns The result parameter or a new instance if the parameter was omitted.
+     */
+    ReferenceProperty.prototype.getValueCartesian = function(time, result) {
+        var targetProperty = resolve(this);
+        return typeof targetProperty !== 'undefined' ? targetProperty.getValueCartesian(time, result) : undefined;
+    };
+
+    /**
+     * Retrieves the Spherical value or values of the property at the specified time if the linked property
+     * is a DynamicDirectionsProperty.
+     *
+     * @param time The time to evaluate the property.
+     * @param [result] The object to store the result in, if undefined a new instance will be created.
+     * @returns The result parameter or a new instance if the parameter was omitted.
+     */
+    ReferenceProperty.prototype.getValueSpherical = function(time, result) {
+        var targetProperty = resolve(this);
+        return typeof targetProperty !== 'undefined' ? targetProperty.getValueSpherical(time, result) : undefined;
+    };
+
+    return ReferenceProperty;
+});

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

@@ -0,0 +1,181 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/destroyObject',
+        './CzmlDefaults'
+       ], function(
+         DeveloperError,
+         destroyObject,
+         CzmlDefaults) {
+    "use strict";
+
+    /**
+     * A collection of visualizers which makes it easy to manage and
+     * update them in unison.
+     * @alias VisualizerCollection
+     * @constructor
+     *
+     * @param {Object} The array of visualizers to use.
+     * @param {DynamicObjectCollection} The objects to be visualized.
+     *
+     * @see CzmlDefaults#createVisualizers
+     */
+    var VisualizerCollection = function(visualizers, dynamicObjectCollection) {
+        if (typeof visualizers === 'undefined') {
+            visualizers = [];
+        }
+        this._visualizers = visualizers;
+        this._dynamicObjectCollection = undefined;
+        this.setDynamicObjectCollection(dynamicObjectCollection);
+    };
+
+    /**
+     * Creates a new VisualizerCollection which includes all standard visualizers.
+     *
+     * @memberof VisualizerCollection
+     *
+     * @param {Scene} The scene where visualization will take place.
+     * @param {DynamicObjectCollection} The objects to be visualized.
+     *
+     * @exception {DeveloperError} scene is required.
+     *
+     * @see CzmlDefaults#createVisualizers
+     */
+    VisualizerCollection.createCzmlStandardCollection = function(scene, dynamicObjectCollection) {
+        if (typeof scene === 'undefined') {
+            throw new DeveloperError('scene is required.');
+        }
+        return new VisualizerCollection(CzmlDefaults.createVisualizers(scene), dynamicObjectCollection);
+    };
+
+    /**
+     * Gets a copy of the array of visualizers in the collection.
+     * @returns {Array} the array of visualizers in the collection.
+     */
+    VisualizerCollection.prototype.getVisualizers = function() {
+        return this._visualizers.slice(0);
+    };
+
+    /**
+     * Sets the array of visualizers in the collection.
+     *
+     * @param {Array} visualizers The new array of visualizers.  This array can partially overlap with visualizers currently in the collection.
+     * @param {Boolean} destroyOldVisualizers If true, visualizers no longer in the collection will be destroyed.
+     */
+    VisualizerCollection.prototype.setVisualizers = function(visualizers, destroyOldVisualizers) {
+        destroyOldVisualizers = (typeof destroyOldVisualizers !== 'undefined') ? destroyOldVisualizers : true;
+
+        var i;
+        var thisVisualizers = this._visualizers;
+        if (destroyOldVisualizers) {
+            for (i = thisVisualizers.length - 1; i > -1; i--) {
+                var visualizer = thisVisualizers[i];
+                if (visualizers.indexOf(visualizer) === -1) {
+                    visualizer.destroy();
+                }
+            }
+        }
+
+        if (typeof visualizers === 'undefined') {
+            visualizers = [];
+        }
+        this._visualizers = visualizers;
+        var dynamicObjectCollection = this._dynamicObjectCollection;
+        for (i = visualizers.length - 1; i > -1; i--) {
+            visualizers[i].setDynamicObjectCollection(dynamicObjectCollection);
+        }
+    };
+
+    /**
+     * Gets the DynamicObjectCollection being visualized.
+     * @returns the DynamicObjectCollection being visualized
+     */
+    VisualizerCollection.prototype.getDynamicObjectCollection = function() {
+        return this._dynamicObjectCollection;
+    };
+
+    /**
+     * Sets the DynamicObjectCollection being visualized.
+     * @param {DynamicObjectCollection} dynamicObjectCollection the DynamicObjectCollection being visualized.
+     */
+    VisualizerCollection.prototype.setDynamicObjectCollection = function(dynamicObjectCollection) {
+        var oldCollection = this._dynamicObjectCollection;
+        if (oldCollection !== dynamicObjectCollection) {
+            this._dynamicObjectCollection = dynamicObjectCollection;
+            var visualizers = this._visualizers;
+            for ( var i = visualizers.length - 1; i > -1; i--) {
+                visualizers[i].setDynamicObjectCollection(dynamicObjectCollection);
+            }
+        }
+    };
+
+    /**
+     * Updates all visualizers to the provided time.
+     * @param {JulianDate} time The time to updated to.
+     */
+    VisualizerCollection.prototype.update = function(time) {
+        var visualizers = this._visualizers;
+        for ( var i = visualizers.length - 1; i > -1; i--) {
+            visualizers[i].update(time);
+        }
+    };
+
+    /**
+     * Removes all primitives from visualization.
+     */
+    VisualizerCollection.prototype.removeAllPrimitives = function() {
+        var visualizers = this._visualizers;
+        for ( var i = visualizers.length - 1; i > -1; i--) {
+            visualizers[i].removeAllPrimitives();
+        }
+    };
+
+    /**
+     * 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 VisualizerCollection
+     *
+     * @return {Boolean} True if this object was destroyed; otherwise, false.
+     *
+     * @see VisualizerCollection#destroy
+     */
+    VisualizerCollection.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 VisualizerCollection
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see VisualizerCollection#isDestroyed
+     *
+     * @example
+     * visualizerCollection = visualizerCollection && visualizerCollection.destroy();
+     */
+    VisualizerCollection.prototype.destroy = function(destroyVisualizers) {
+        destroyVisualizers = (typeof destroyVisualizers !== 'undefined') ? destroyVisualizers : true;
+        this.removeAllPrimitives();
+        if (destroyVisualizers) {
+            var visualizers = this._visualizers;
+            for ( var i = visualizers.length - 1; i > -1; i--) {
+                visualizers[i].destroy();
+            }
+        }
+        return destroyObject(this);
+    };
+
+    return VisualizerCollection;
+});

data/app/assets/javascripts/DynamicScene/package.json

@@ -0,0 +1,6 @@
+{
+	"name": "DynamicScene",
+	"description": "Cesium DynamicScene",
+	"version": "0.6.0",
+	"dojoBuild": "DynamicScene.profile.js"
+}

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

@@ -0,0 +1,77 @@
+/*global define*/
+define([
+        '../Core/createGuid',
+        '../Core/DeveloperError',
+        './CzmlDefaults'
+       ], function(
+        createGuid,
+        DeveloperError,
+        CzmlDefaults) {
+    "use strict";
+
+    function processCzmlPacket(packet, dynamicObjectCollection, updatedObjects, updatedObjectsHash, updaterFunctions, sourceUri) {
+        var objectId = packet.id;
+        if (typeof objectId === 'undefined') {
+            objectId = createGuid();
+        }
+
+        var object = dynamicObjectCollection.getOrCreateObject(objectId);
+        for ( var i = updaterFunctions.length - 1; i > -1; i--) {
+            if (updaterFunctions[i](object, packet, dynamicObjectCollection, sourceUri) && typeof updatedObjectsHash[objectId] === 'undefined') {
+                updatedObjectsHash[objectId] = true;
+                updatedObjects.push(object);
+            }
+        }
+    }
+
+    /**
+     * Processes the provided CZML, creating or updating DynamicObject instances for each
+     * corresponding CZML identifier.
+     * @exports processCzml
+     *
+     * @param {Object} czml The parsed CZML object to be processed.
+     * @param {DynamicObjectCollection} dynamicObjectCollection The collection to create or updated objects within.
+     * @param {String} [sourceUri] The uri of the file where the CZML originated from.  If provided, relative uri look-ups will use this as their base.
+     * @param {Array} [updaterFunctions=CzmlDefaults.updaters] The array of updated functions to use for processing.  If left undefined, all standard CZML data is processed.
+     *
+     * @exception {DeveloperError} czml is required.
+     * @exception {DeveloperError} dynamicObjectCollection is required.
+     *
+     * @returns An array containing all DynamicObject instances that were created or updated.
+     *
+     * @example
+     * var url = 'http://someUrl.com/myCzmlFile.czml';
+     * var dynamicObjectCollection = new DynamicObjectCollection();
+     * loadJson(url).then(function(czml) {
+     *     processCzml(czml, dynamicObjectCollection, url);
+     * });
+     */
+    var processCzml = function(czml, dynamicObjectCollection, sourceUri, updaterFunctions) {
+        if (typeof czml === 'undefined') {
+            throw new DeveloperError('czml is required.');
+        }
+        if (typeof dynamicObjectCollection === 'undefined') {
+            throw new DeveloperError('dynamicObjectCollection is required.');
+        }
+
+        var updatedObjects = [];
+        var updatedObjectsHash = {};
+        updaterFunctions = typeof updaterFunctions !== 'undefined' ? updaterFunctions : CzmlDefaults.updaters;
+
+        if (Array.isArray(czml)) {
+            for ( var i = 0, len = czml.length; i < len; i++) {
+                processCzmlPacket(czml[i], dynamicObjectCollection, updatedObjects, updatedObjectsHash, updaterFunctions, sourceUri);
+            }
+        } else {
+            processCzmlPacket(czml, dynamicObjectCollection, updatedObjects, updatedObjectsHash, updaterFunctions, sourceUri);
+        }
+
+        if (updatedObjects.length > 0) {
+            dynamicObjectCollection.objectPropertiesChanged.raiseEvent(dynamicObjectCollection, updatedObjects);
+        }
+
+        return updatedObjects;
+    };
+
+    return processCzml;
+});

data/app/assets/javascripts/Renderer/BlendEquation.js

@@ -0,0 +1,52 @@
+/*global define*/
+define(['../Core/Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @exports BlendEquation
+     */
+    var BlendEquation = {
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        ADD : new Enumeration(0x8006, 'ADD'), // WebGL: FUNC_ADD
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        SUBTRACT : new Enumeration(0x800A, 'SUBTRACT'), // WebGL: FUNC_SUBTRACT
+
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        REVERSE_SUBTRACT : new Enumeration(0x800B, 'REVERSE_SUBTRACT'), // WebGL: FUNC_REVERSE_SUBTRACT
+
+        // No min and max like in ColladaFX GLES2 profile
+
+        /**
+         * DOC_TBA
+         *
+         * @param blendEquation
+         *
+         * @returns {Boolean}
+         */
+        validate : function(blendEquation) {
+            return ((blendEquation === BlendEquation.ADD) ||
+                    (blendEquation === BlendEquation.SUBTRACT) ||
+                    (blendEquation === BlendEquation.REVERSE_SUBTRACT));
+        }
+    };
+
+    return BlendEquation;
+});