/*global define*/ define([ '../Core/Cartesian3', '../Core/defaultValue', '../Core/defined', '../Core/defineProperties', '../Core/DeveloperError', '../Core/Event', '../Core/ReferenceFrame', './PositionProperty' ], function( Cartesian3, defaultValue, defined, defineProperties, DeveloperError, Event, ReferenceFrame, PositionProperty) { "use strict"; /** * A {@link PositionProperty} whose value does not change in respect to the * {@link ReferenceFrame} in which is it defined. * * @alias ConstantPositionProperty * @constructor * * @param {Cartesian3} [value] The property value. * @param {ReferenceFrame} [referenceFrame=ReferenceFrame.FIXED] The reference frame in which the position is defined. */ var ConstantPositionProperty = function(value, referenceFrame) { this._definitionChanged = new Event(); this._value = Cartesian3.clone(value); this._referenceFrame = defaultValue(referenceFrame, ReferenceFrame.FIXED); }; defineProperties(ConstantPositionProperty.prototype, { /** * Gets a value indicating if this property is constant. A property is considered * constant if getValue always returns the same result for the current definition. * @memberof ConstantPositionProperty.prototype * * @type {Boolean} * @readonly */ isConstant : { get : function() { return !defined(this._value) || this._referenceFrame === ReferenceFrame.FIXED; } }, /** * Gets the event that is raised whenever the definition of this property changes. * The definition is considered to have changed if a call to getValue would return * a different result for the same time. * @memberof ConstantPositionProperty.prototype * * @type {Event} * @readonly */ definitionChanged : { get : function() { return this._definitionChanged; } }, /** * Gets the reference frame in which the position is defined. * @memberof ConstantPositionProperty.prototype * @type {ReferenceFrame} * @default ReferenceFrame.FIXED; */ referenceFrame : { get : function() { return this._referenceFrame; } } }); /** * Gets the value of the property at the provided time in the fixed frame. * * @param {JulianDate} time The time for which to retrieve the value. * @param {Object} [result] The object to store the value into, if omitted, a new instance is created and returned. * @returns {Object} The modified result parameter or a new instance if the result parameter was not supplied. */ ConstantPositionProperty.prototype.getValue = function(time, result) { return this.getValueInReferenceFrame(time, ReferenceFrame.FIXED, result); }; /** * Sets the value of the property. * * @param {Cartesian3} value The property value. * @param {ReferenceFrame} [referenceFrame=this.referenceFrame] The reference frame in which the position is defined. */ ConstantPositionProperty.prototype.setValue = function(value, referenceFrame) { var definitionChanged = false; if (!Cartesian3.equals(this._value, value)) { definitionChanged = true; this._value = Cartesian3.clone(value); } if (defined(referenceFrame) && this._referenceFrame !== referenceFrame) { definitionChanged = true; this._referenceFrame = referenceFrame; } if (definitionChanged) { this._definitionChanged.raiseEvent(this); } }; /** * Gets the value of the property at the provided time and in the provided reference frame. * * @param {JulianDate} time The time for which to retrieve the value. * @param {ReferenceFrame} referenceFrame The desired referenceFrame of the result. * @param {Cartesian3} [result] The object to store the value into, if omitted, a new instance is created and returned. * @returns {Cartesian3} The modified result parameter or a new instance if the result parameter was not supplied. */ ConstantPositionProperty.prototype.getValueInReferenceFrame = function(time, referenceFrame, result) { //>>includeStart('debug', pragmas.debug); if (!defined(time)) { throw new DeveloperError('time is required.'); } if (!defined(referenceFrame)) { throw new DeveloperError('referenceFrame is required.'); } //>>includeEnd('debug'); return PositionProperty.convertToReferenceFrame(time, this._value, this._referenceFrame, referenceFrame, result); }; /** * Compares this property to the provided property and returns * true if they are equal, false otherwise. * * @param {Property} [other] The other property. * @returns {Boolean} true if left and right are equal, false otherwise. */ ConstantPositionProperty.prototype.equals = function(other) { return this === other || (other instanceof ConstantPositionProperty && Cartesian3.equals(this._value, other._value) && this._referenceFrame === other._referenceFrame); }; return ConstantPositionProperty; });