cesium 1.18.0 → 1.23.0

data/app/assets/javascripts/Cesium/Core/CircleOutlineGeometry.js

@@ -13,7 +13,7 @@ define([
         DeveloperError,
         EllipseOutlineGeometry,
         Ellipsoid) {
-    "use strict";
+    'use strict';
 
     /**
      * A description of the outline of a circle on the ellipsoid.
@@ -52,9 +52,6 @@ define([
         if (!defined(radius)) {
             throw new DeveloperError('radius is required.');
         }
-        if (radius <= 0.0) {
-            throw new DeveloperError('radius must be greater than zero.');
-        }
         //>>includeEnd('debug');
 
         var ellipseGeometryOptions = {
@@ -142,7 +139,7 @@ define([
      * Computes the geometric representation of an outline of a circle on an ellipsoid, including its vertices, indices, and a bounding sphere.
      *
      * @param {CircleOutlineGeometry} circleGeometry A description of the circle.
-     * @returns {Geometry} The computed vertices and indices.
+     * @returns {Geometry|undefined} The computed vertices and indices.
      */
     CircleOutlineGeometry.createGeometry = function(circleGeometry) {
         return EllipseOutlineGeometry.createGeometry(circleGeometry._ellipseGeometry);

data/app/assets/javascripts/Cesium/Core/Clock.js

@@ -4,6 +4,7 @@ define([
         './ClockStep',
         './defaultValue',
         './defined',
+        './defineProperties',
         './DeveloperError',
         './Event',
         './getTimestamp',
@@ -13,11 +14,12 @@ define([
         ClockStep,
         defaultValue,
         defined,
+        defineProperties,
         DeveloperError,
         Event,
         getTimestamp,
         JulianDate) {
-    "use strict";
+    'use strict';
 
     /**
      * A simple clock for keeping track of simulated time.
@@ -29,11 +31,11 @@ define([
      * @param {JulianDate} [options.startTime] The start time of the clock.
      * @param {JulianDate} [options.stopTime] The stop time of the clock.
      * @param {JulianDate} [options.currentTime] The current time.
-     * @param {Number} [options.multiplier=1.0] Determines how much time advances when tick is called, negative values allow for advancing backwards.
-     * @param {ClockStep} [options.clockStep=ClockStep.SYSTEM_CLOCK_MULTIPLIER] Determines if calls to <code>tick</code> are frame dependent or system clock dependent.
-     * @param {ClockRange} [options.clockRange=ClockRange.UNBOUNDED] Determines how the clock should behave when <code>startTime</code> or <code>stopTime</code> is reached.
-     * @param {Boolean} [options.canAnimate=true] Indicates whether tick can advance time.  This could be false if data is being buffered, for example.  The clock will only tick when both <code>canAnimate</code> and <code>shouldAnimate</code> are true.
-     * @param {Boolean} [options.shouldAnimate=true] Indicates whether tick should attempt to advance time.  The clock will only tick when both <code>canAnimate</code> and <code>shouldAnimate</code> are true.
+     * @param {Number} [options.multiplier=1.0] Determines how much time advances when {@link Clock#tick} is called, negative values allow for advancing backwards.
+     * @param {ClockStep} [options.clockStep=ClockStep.SYSTEM_CLOCK_MULTIPLIER] Determines if calls to {@link Clock#tick} are frame dependent or system clock dependent.
+     * @param {ClockRange} [options.clockRange=ClockRange.UNBOUNDED] Determines how the clock should behave when {@link Clock#startTime} or {@link Clock#stopTime} is reached.
+     * @param {Boolean} [options.canAnimate=true] Indicates whether {@link Clock#tick} can advance time.  This could be false if data is being buffered, for example.  The clock will only tick when both {@link Clock#canAnimate} and {@link Clock#shouldAnimate} are true.
+     * @param {Boolean} [options.shouldAnimate=true] Indicates whether {@link Clock#tick} should attempt to advance time.  The clock will only tick when both {@link Clock#canAnimate} and {@link Clock#shouldAnimate} are true.
      *
      * @exception {DeveloperError} startTime must come before stopTime.
      *
@@ -47,7 +49,7 @@ define([
      *    clockRange : Cesium.ClockRange.LOOP_STOP,
      *    clockStep : Cesium.ClockStep.SYSTEM_CLOCK_MULTIPLIER
      * });
-     * 
+     *
      * @see ClockStep
      * @see ClockRange
      * @see JulianDate
@@ -55,34 +57,39 @@ define([
     function Clock(options) {
         options = defaultValue(options, defaultValue.EMPTY_OBJECT);
 
+        var currentTime = options.currentTime;
         var startTime = options.startTime;
-        var startTimeUndefined = !defined(startTime);
-
         var stopTime = options.stopTime;
-        var stopTimeUndefined = !defined(stopTime);
 
-        var currentTime = options.currentTime;
-        var currentTimeUndefined = !defined(currentTime);
+        if (!defined(currentTime)) {
+            // if not specified, current time is the start time,
+            // or if that is not specified, 1 day before the stop time,
+            // or if that is not specified, then now.
+            if (defined(startTime)) {
+                currentTime = JulianDate.clone(startTime);
+            } else if (defined(stopTime)) {
+                currentTime = JulianDate.addDays(stopTime, -1.0, new JulianDate());
+            } else {
+                currentTime = JulianDate.now();
+            }
+        } else {
+            currentTime = JulianDate.clone(currentTime);
+        }
 
-        if (startTimeUndefined && stopTimeUndefined && currentTimeUndefined) {
-            currentTime = JulianDate.now();
-            startTime = JulianDate.clone(currentTime);
-            stopTime = JulianDate.addDays(currentTime, 1.0, new JulianDate());
-        } else if (startTimeUndefined && stopTimeUndefined) {
+        if (!defined(startTime)) {
+            // if not specified, start time is the current time
+            // (as determined above)
             startTime = JulianDate.clone(currentTime);
-            stopTime = JulianDate.addDays(currentTime, 1.0, new JulianDate());
-        } else if (startTimeUndefined && currentTimeUndefined) {
-            startTime = JulianDate.addDays(stopTime, -1.0, new JulianDate());
-            currentTime = JulianDate.clone(startTime);
-        } else if (currentTimeUndefined && stopTimeUndefined) {
-            currentTime = JulianDate.clone(startTime);
+        } else {
+            startTime = JulianDate.clone(startTime);
+        }
+
+        if (!defined(stopTime)) {
+            // if not specified, stop time is 1 day after the start time
+            // (as determined above)
             stopTime = JulianDate.addDays(startTime, 1.0, new JulianDate());
-        } else if (currentTimeUndefined) {
-            currentTime = JulianDate.clone(startTime);
-        } else if (stopTimeUndefined) {
-            stopTime = JulianDate.addDays(currentTime, 1.0, new JulianDate());
-        } else if (startTimeUndefined) {
-            startTime = JulianDate.clone(currentTime);
+        } else {
+            stopTime = JulianDate.clone(stopTime);
         }
 
         //>>includeStart('debug', pragmas.debug);
@@ -103,93 +110,190 @@ define([
          */
         this.stopTime = stopTime;
 
+        /**
+         * Determines how the clock should behave when
+         * {@link Clock#startTime} or {@link Clock#stopTime}
+         * is reached.
+         * @type {ClockRange}
+         * @default {@link ClockRange.UNBOUNDED}
+         */
+        this.clockRange = defaultValue(options.clockRange, ClockRange.UNBOUNDED);
+
+        /**
+         * Indicates whether {@link Clock#tick} can advance time.  This could be false if data is being buffered,
+         * for example.  The clock will only advance time when both
+         * {@link Clock#canAnimate} and {@link Clock#shouldAnimate} are true.
+         * @type {Boolean}
+         * @default true
+         */
+        this.canAnimate = defaultValue(options.canAnimate, true);
+
+        /**
+         * An {@link Event} that is fired whenever {@link Clock#tick} is called.
+         * @type {Event}
+         */
+        this.onTick = new Event();
+
+        this._currentTime = undefined;
+        this._multiplier = undefined;
+        this._clockStep = undefined;
+        this._shouldAnimate = undefined;
+        this._lastSystemTime = getTimestamp();
+
+        // set values using the property setters to
+        // make values consistent.
+
+        this.currentTime = currentTime;
+        this.multiplier = defaultValue(options.multiplier, 1.0);
+        this.clockStep = defaultValue(options.clockStep, ClockStep.SYSTEM_CLOCK_MULTIPLIER);
+        this.shouldAnimate = defaultValue(options.shouldAnimate, true);
+    }
+
+    defineProperties(Clock.prototype, {
         /**
          * The current time.
+         * Changing this property will change
+         * {@link Clock#clockStep} from {@link ClockStep.SYSTEM_CLOCK} to
+         * {@link ClockStep.SYSTEM_CLOCK_MULTIPLIER}.
+         * @memberof Clock.prototype
          * @type {JulianDate}
          */
-        this.currentTime = currentTime;
+        currentTime : {
+            get : function() {
+                return this._currentTime;
+            },
+            set : function(value) {
+                if (JulianDate.equals(this._currentTime, value)) {
+                    return;
+                }
+
+                if (this._clockStep === ClockStep.SYSTEM_CLOCK) {
+                    this._clockStep = ClockStep.SYSTEM_CLOCK_MULTIPLIER;
+                }
+
+                this._currentTime = value;
+            }
+        },
 
         /**
-         * Determines how much time advances when tick is called, negative values allow for advancing backwards.
-         * If <code>clockStep</code> is set to ClockStep.TICK_DEPENDENT this is the number of seconds to advance.
-         * If <code>clockStep</code> is set to ClockStep.SYSTEM_CLOCK_MULTIPLIER this value is multiplied by the
-         * elapsed system time since the last call to tick.
+         * Gets or sets how much time advances when {@link Clock#tick} is called. Negative values allow for advancing backwards.
+         * If {@link Clock#clockStep} is set to {@link ClockStep.TICK_DEPENDENT}, this is the number of seconds to advance.
+         * If {@link Clock#clockStep} is set to {@link ClockStep.SYSTEM_CLOCK_MULTIPLIER}, this value is multiplied by the
+         * elapsed system time since the last call to {@link Clock#tick}.
+         * Changing this property will change
+         * {@link Clock#clockStep} from {@link ClockStep.SYSTEM_CLOCK} to
+         * {@link ClockStep.SYSTEM_CLOCK_MULTIPLIER}.
+         * @memberof Clock.prototype
          * @type {Number}
          * @default 1.0
          */
-        this.multiplier = defaultValue(options.multiplier, 1.0);
+        multiplier : {
+            get : function() {
+                return this._multiplier;
+            },
+            set : function(value) {
+                if (this._multiplier === value) {
+                    return;
+                }
+
+                if (this._clockStep === ClockStep.SYSTEM_CLOCK) {
+                    this._clockStep = ClockStep.SYSTEM_CLOCK_MULTIPLIER;
+                }
+
+                this._multiplier = value;
+            }
+        },
 
         /**
-         * Determines if calls to <code>tick</code> are frame dependent or system clock dependent.
+         * Determines if calls to {@link Clock#tick} are frame dependent or system clock dependent.
+         * Changing this property to {@link ClockStep.SYSTEM_CLOCK} will set
+         * {@link Clock#multiplier} to 1.0, {@link Clock#shouldAnimate} to true, and
+         * {@link Clock#currentTime} to the current system clock time.
+         * @memberof Clock.prototype
          * @type ClockStep
          * @default {@link ClockStep.SYSTEM_CLOCK_MULTIPLIER}
          */
-        this.clockStep = defaultValue(options.clockStep, ClockStep.SYSTEM_CLOCK_MULTIPLIER);
+        clockStep : {
+            get : function() {
+                return this._clockStep;
+            },
+            set : function(value) {
+                if (value === ClockStep.SYSTEM_CLOCK) {
+                    this._multiplier = 1.0;
+                    this._shouldAnimate = true;
+                    this._currentTime = JulianDate.now();
+                }
 
-        /**
-         * Determines how the clock should behave when <code>startTime</code> or <code>stopTime</code> is reached.
-         * @type {ClockRange}
-         * @default {@link ClockRange.UNBOUNDED}
-         */
-        this.clockRange = defaultValue(options.clockRange, ClockRange.UNBOUNDED);
+                this._clockStep = value;
+            }
+        },
 
-        /**
-         * Indicates whether tick can advance time.  This could be false if data is being buffered,
-         * for example.  The clock will only tick when both <code>canAnimate</code> and <code>shouldAnimate</code> are true.
-         * @type {Boolean}
-         * @default true
-         */
-        this.canAnimate = defaultValue(options.canAnimate, true);
 
         /**
-         * Indicates whether tick should attempt to advance time.
-         * The clock will only tick when both <code>canAnimate</code> and <code>shouldAnimate</code> are true.
+         * Indicates whether {@link Clock#tick} should attempt to advance time.
+         * The clock will only advance time when both
+         * {@link Clock#canAnimate} and {@link Clock#shouldAnimate} are true.
+         * Changing this property will change
+         * {@link Clock#clockStep} from {@link ClockStep.SYSTEM_CLOCK} to
+         * {@link ClockStep.SYSTEM_CLOCK_MULTIPLIER}.
+         * @memberof Clock.prototype
          * @type {Boolean}
          * @default true
          */
-        this.shouldAnimate = defaultValue(options.shouldAnimate, true);
+        shouldAnimate : {
+            get : function() {
+                return this._shouldAnimate;
+            },
+            set : function(value) {
+                if (this._shouldAnimate === value) {
+                    return;
+                }
 
-        /**
-         * An {@link Event} that is fired whenever <code>tick</code>.
-         * @type {Event}
-         */
-        this.onTick = new Event();
+                if (this._clockStep === ClockStep.SYSTEM_CLOCK) {
+                    this._clockStep = ClockStep.SYSTEM_CLOCK_MULTIPLIER;
+                }
 
-        this._lastSystemTime = getTimestamp();
-    }
+                this._shouldAnimate = value;
+            }
+        }
+    });
 
     /**
-     * Advances the clock from the currentTime based on the current configuration options.
+     * Advances the clock from the current time based on the current configuration options.
      * tick should be called every frame, regardless of whether animation is taking place
-     * or not.  To control animation, use the <code>shouldAnimate</code> property.
+     * or not.  To control animation, use the {@link Clock#shouldAnimate} property.
      *
-     * @returns {JulianDate} The new value of the <code>currentTime</code> property.
+     * @returns {JulianDate} The new value of the {@link Clock#currentTime} property.
      */
     Clock.prototype.tick = function() {
         var currentSystemTime = getTimestamp();
-        var currentTime = JulianDate.clone(this.currentTime);
-        var startTime = this.startTime;
-        var stopTime = this.stopTime;
-        var multiplier = this.multiplier;
+        var currentTime = JulianDate.clone(this._currentTime);
 
-        if (this.canAnimate && this.shouldAnimate) {
-            if (this.clockStep === ClockStep.SYSTEM_CLOCK) {
+        if (this.canAnimate && this._shouldAnimate) {
+            var clockStep = this._clockStep;
+            if (clockStep === ClockStep.SYSTEM_CLOCK) {
                 currentTime = JulianDate.now(currentTime);
             } else {
-                if (this.clockStep === ClockStep.TICK_DEPENDENT) {
+                var multiplier = this._multiplier;
+
+                if (clockStep === ClockStep.TICK_DEPENDENT) {
                     currentTime = JulianDate.addSeconds(currentTime, multiplier, currentTime);
                 } else {
                     var milliseconds = currentSystemTime - this._lastSystemTime;
                     currentTime = JulianDate.addSeconds(currentTime, multiplier * (milliseconds / 1000.0), currentTime);
                 }
 
-                if (this.clockRange === ClockRange.CLAMPED) {
+                var clockRange = this.clockRange;
+                var startTime = this.startTime;
+                var stopTime = this.stopTime;
+
+                if (clockRange === ClockRange.CLAMPED) {
                     if (JulianDate.lessThan(currentTime, startTime)) {
                         currentTime = JulianDate.clone(startTime, currentTime);
                     } else if (JulianDate.greaterThan(currentTime, stopTime)) {
                         currentTime = JulianDate.clone(stopTime, currentTime);
                     }
-                } else if (this.clockRange === ClockRange.LOOP_STOP) {
+                } else if (clockRange === ClockRange.LOOP_STOP) {
                     if (JulianDate.lessThan(currentTime, startTime)) {
                         currentTime = JulianDate.clone(startTime, currentTime);
                     }
@@ -200,7 +304,7 @@ define([
             }
         }
 
-        this.currentTime = currentTime;
+        this._currentTime = currentTime;
         this._lastSystemTime = currentSystemTime;
         this.onTick.raiseEvent(this);
         return currentTime;

data/app/assets/javascripts/Cesium/Core/ClockRange.js

@@ -3,7 +3,7 @@ define([
         './freezeObject'
     ], function(
         freezeObject) {
-    "use strict";
+    'use strict';
 
     /**
      * Constants used by {@link Clock#tick} to determine behavior

data/app/assets/javascripts/Cesium/Core/ClockStep.js

@@ -3,7 +3,7 @@ define([
         './freezeObject'
     ], function(
         freezeObject) {
-    "use strict";
+    'use strict';
 
     /**
      * Constants to determine how much time advances with each call

data/app/assets/javascripts/Cesium/Core/Color.js

@@ -13,7 +13,7 @@ define([
         FeatureDetection,
         freezeObject,
         CesiumMath) {
-    "use strict";
+    'use strict';
 
     function hue2rgb(m1, m2, h) {
         if (h < 0) {
@@ -174,17 +174,18 @@ define([
      * of the system.
      *
      * @param {Number} rgba A single numeric unsigned 32-bit RGBA value.
-     * @returns {Color} A new color instance.
+     * @param {Color} [result] The object to store the result in, if undefined a new instance will be created.
+     * @returns {Color} The color object.
      *
      * @example
      * var color = Cesium.Color.fromRgba(0x67ADDFFF);
      *
      * @see Color#toRgba
      */
-    Color.fromRgba = function(rgba) {
+    Color.fromRgba = function(rgba, result) {
         // scratchUint32Array and scratchUint8Array share an underlying array buffer
         scratchUint32Array[0] = rgba;
-        return Color.fromBytes(scratchUint8Array[0], scratchUint8Array[1], scratchUint8Array[2], scratchUint8Array[3]);
+        return Color.fromBytes(scratchUint8Array[0], scratchUint8Array[1], scratchUint8Array[2], scratchUint8Array[3], result);
     };
 
     /**
@@ -194,11 +195,12 @@ define([
      * @param {Number} [saturation=0] The saturation value 0...1
      * @param {Number} [lightness=0] The lightness value 0...1
      * @param {Number} [alpha=1.0] The alpha component 0...1
+     * @param {Color} [result] The object to store the result in, if undefined a new instance will be created.
      * @returns {Color} The color object.
      *
      * @see {@link http://www.w3.org/TR/css3-color/#hsl-color|CSS color values}
      */
-    Color.fromHsl = function(hue, saturation, lightness, alpha) {
+    Color.fromHsl = function(hue, saturation, lightness, alpha, result) {
         hue = defaultValue(hue, 0.0) % 1.0;
         saturation = defaultValue(saturation, 0.0);
         lightness = defaultValue(lightness, 0.0);
@@ -222,7 +224,15 @@ define([
             blue = hue2rgb(m1, m2, hue - 1 / 3);
         }
 
-        return new Color(red, green, blue, alpha);
+        if (!defined(result)) {
+            return new Color(red, green, blue, alpha);
+        }
+
+        result.red = red;
+        result.green = green;
+        result.blue = blue;
+        result.alpha = alpha;
+        return result;
     };
 
     /**
@@ -352,6 +362,7 @@ define([
      * Creates a Color instance from a CSS color value.
      *
      * @param {String} color The CSS color value in #rgb, #rrggbb, rgb(), rgba(), hsl(), or hsla() format.
+     * @param {Color} [result] The object to store the result in, if undefined a new instance will be created.
      * @returns {Color} The color object, or undefined if the string was not a valid CSS color.
      *
      *
@@ -361,38 +372,48 @@ define([
      * 
      * @see {@link http://www.w3.org/TR/css3-color|CSS color values}
      */
-    Color.fromCssColorString = function(color) {
+    Color.fromCssColorString = function(color, result) {
         //>>includeStart('debug', pragmas.debug);
         if (!defined(color)) {
             throw new DeveloperError('color is required');
         }
         //>>includeEnd('debug');
 
+        if (!defined(result)) {
+            result = new Color();
+        }
+
         var namedColor = Color[color.toUpperCase()];
         if (defined(namedColor)) {
-            return Color.clone(namedColor);
+            Color.clone(namedColor, result);
+            return result;
         }
 
         var matches = rgbMatcher.exec(color);
         if (matches !== null) {
-            return new Color(parseInt(matches[1], 16) / 15.0,
-                             parseInt(matches[2], 16) / 15.0,
-                             parseInt(matches[3], 16) / 15.0);
+            result.red = parseInt(matches[1], 16) / 15;
+            result.green = parseInt(matches[2], 16) / 15.0;
+            result.blue = parseInt(matches[3], 16) / 15.0;
+            result.alpha = 1.0;
+            return result;
         }
 
         matches = rrggbbMatcher.exec(color);
         if (matches !== null) {
-            return new Color(parseInt(matches[1], 16) / 255.0,
-                             parseInt(matches[2], 16) / 255.0,
-                             parseInt(matches[3], 16) / 255.0);
+            result.red = parseInt(matches[1], 16) / 255.0;
+            result.green = parseInt(matches[2], 16) / 255.0;
+            result.blue = parseInt(matches[3], 16) / 255.0;
+            result.alpha = 1.0;
+            return result;
         }
 
         matches = rgbParenthesesMatcher.exec(color);
         if (matches !== null) {
-            return new Color(parseFloat(matches[1]) / ('%' === matches[1].substr(-1) ? 100.0 : 255.0),
-                             parseFloat(matches[2]) / ('%' === matches[2].substr(-1) ? 100.0 : 255.0),
-                             parseFloat(matches[3]) / ('%' === matches[3].substr(-1) ? 100.0 : 255.0),
-                             parseFloat(defaultValue(matches[4], '1.0')));
+            result.red = parseFloat(matches[1]) / ('%' === matches[1].substr(-1) ? 100.0 : 255.0);
+            result.green = parseFloat(matches[2]) / ('%' === matches[2].substr(-1) ? 100.0 : 255.0);
+            result.blue = parseFloat(matches[3]) / ('%' === matches[3].substr(-1) ? 100.0 : 255.0);
+            result.alpha = parseFloat(defaultValue(matches[4], '1.0'));
+            return result;
         }
 
         matches = hslParenthesesMatcher.exec(color);
@@ -400,10 +421,11 @@ define([
             return Color.fromHsl(parseFloat(matches[1]) / 360.0,
                                  parseFloat(matches[2]) / 100.0,
                                  parseFloat(matches[3]) / 100.0,
-                                 parseFloat(defaultValue(matches[4], '1.0')));
+                                 parseFloat(defaultValue(matches[4], '1.0')), result);
         }
 
-        return undefined;
+        result = undefined;
+        return result;
     };
 
     /**
@@ -714,6 +736,202 @@ define([
         return Color.fromAlpha(this, alpha, result);
     };
 
+    /**
+     * Computes the componentwise sum of two Colors.
+     *
+     * @param {Color} left The first Color.
+     * @param {Color} right The second Color.
+     * @param {Color} result The object onto which to store the result.
+     * @returns {Color} The modified result parameter.
+     */
+    Color.add = function(left, right, result) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(left)) {
+            throw new DeveloperError('left is required');
+        }
+        if (!defined(right)) {
+            throw new DeveloperError('right is required');
+        }
+        if (!defined(result)) {
+            throw new DeveloperError('result is required');
+        }
+        //>>includeEnd('debug');
+
+        result.red = left.red + right.red;
+        result.green = left.green + right.green;
+        result.blue = left.blue + right.blue;
+        result.alpha = left.alpha + right.alpha;
+        return result;
+    };
+
+    /**
+     * Computes the componentwise difference of two Colors.
+     *
+     * @param {Color} left The first Color.
+     * @param {Color} right The second Color.
+     * @param {Color} result The object onto which to store the result.
+     * @returns {Color} The modified result parameter.
+     */
+    Color.subtract = function(left, right, result) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(left)) {
+            throw new DeveloperError('left is required');
+        }
+        if (!defined(right)) {
+            throw new DeveloperError('right is required');
+        }
+        if (!defined(result)) {
+            throw new DeveloperError('result is required');
+        }
+        //>>includeEnd('debug');
+
+        result.red = left.red - right.red;
+        result.green = left.green - right.green;
+        result.blue = left.blue - right.blue;
+        result.alpha = left.alpha - right.alpha;
+        return result;
+    };
+
+    /**
+     * Computes the componentwise product of two Colors.
+     *
+     * @param {Color} left The first Color.
+     * @param {Color} right The second Color.
+     * @param {Color} result The object onto which to store the result.
+     * @returns {Color} The modified result parameter.
+     */
+    Color.multiply = function(left, right, result) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(left)) {
+            throw new DeveloperError('left is required');
+        }
+        if (!defined(right)) {
+            throw new DeveloperError('right is required');
+        }
+        if (!defined(result)) {
+            throw new DeveloperError('result is required');
+        }
+        //>>includeEnd('debug');
+
+        result.red = left.red * right.red;
+        result.green = left.green * right.green;
+        result.blue = left.blue * right.blue;
+        result.alpha = left.alpha * right.alpha;
+        return result;
+    };
+
+    /**
+     * Computes the componentwise quotient of two Colors.
+     *
+     * @param {Color} left The first Color.
+     * @param {Color} right The second Color.
+     * @param {Color} result The object onto which to store the result.
+     * @returns {Color} The modified result parameter.
+     */
+    Color.divide = function(left, right, result) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(left)) {
+            throw new DeveloperError('left is required');
+        }
+        if (!defined(right)) {
+            throw new DeveloperError('right is required');
+        }
+        if (!defined(result)) {
+            throw new DeveloperError('result is required');
+        }
+        //>>includeEnd('debug');
+
+        result.red = left.red / right.red;
+        result.green = left.green / right.green;
+        result.blue = left.blue / right.blue;
+        result.alpha = left.alpha / right.alpha;
+        return result;
+    };
+
+    /**
+     * Computes the componentwise modulus of two Colors.
+     *
+     * @param {Color} left The first Color.
+     * @param {Color} right The second Color.
+     * @param {Color} result The object onto which to store the result.
+     * @returns {Color} The modified result parameter.
+     */
+    Color.mod = function(left, right, result) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(left)) {
+            throw new DeveloperError('left is required');
+        }
+        if (!defined(right)) {
+            throw new DeveloperError('right is required');
+        }
+        if (!defined(result)) {
+            throw new DeveloperError('result is required');
+        }
+        //>>includeEnd('debug');
+
+        result.red = left.red % right.red;
+        result.green = left.green % right.green;
+        result.blue = left.blue % right.blue;
+        result.alpha = left.alpha % right.alpha;
+        return result;
+    };
+
+    /**
+     * Multiplies the provided Color componentwise by the provided scalar.
+     *
+     * @param {Color} color The Color to be scaled.
+     * @param {Number} scalar The scalar to multiply with.
+     * @param {Color} result The object onto which to store the result.
+     * @returns {Color} The modified result parameter.
+     */
+    Color.multiplyByScalar = function(color, scalar, result) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(color)) {
+            throw new DeveloperError('cartesian is required');
+        }
+        if (typeof scalar !== 'number') {
+            throw new DeveloperError('scalar is required and must be a number.');
+        }
+        if (!defined(result)) {
+            throw new DeveloperError('result is required');
+        }
+        //>>includeEnd('debug');
+
+        result.red = color.red * scalar;
+        result.green = color.green * scalar;
+        result.blue = color.blue * scalar;
+        result.alpha = color.alpha * scalar;
+        return result;
+    };
+
+    /**
+     * Divides the provided Color componentwise by the provided scalar.
+     *
+     * @param {Color} color The Color to be divided.
+     * @param {Number} scalar The scalar to divide with.
+     * @param {Color} result The object onto which to store the result.
+     * @returns {Color} The modified result parameter.
+     */
+    Color.divideByScalar = function(color, scalar, result) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(color)) {
+            throw new DeveloperError('cartesian is required');
+        }
+        if (typeof scalar !== 'number') {
+            throw new DeveloperError('scalar is required and must be a number.');
+        }
+        if (!defined(result)) {
+            throw new DeveloperError('result is required');
+        }
+        //>>includeEnd('debug');
+
+        result.red = color.red / scalar;
+        result.green = color.green / scalar;
+        result.blue = color.blue / scalar;
+        result.alpha = color.alpha / scalar;
+        return result;
+    };
+
     /**
      * An immutable Color instance initialized to CSS color #F0F8FF
      * <span class="colorSwath" style="background: #F0F8FF;"></span>