Source: DataSources/EllipsoidGeometryUpdater.js

  1. /*global define*/
  2. define([
  3.         '../Core/Cartesian3',
  4.         '../Core/Color',
  5.         '../Core/ColorGeometryInstanceAttribute',
  6.         '../Core/defaultValue',
  7.         '../Core/defined',
  8.         '../Core/defineProperties',
  9.         '../Core/destroyObject',
  10.         '../Core/DeveloperError',
  11.         '../Core/DistanceDisplayCondition',
  12.         '../Core/DistanceDisplayConditionGeometryInstanceAttribute',
  13.         '../Core/EllipsoidGeometry',
  14.         '../Core/EllipsoidOutlineGeometry',
  15.         '../Core/Event',
  16.         '../Core/GeometryInstance',
  17.         '../Core/Iso8601',
  18.         '../Core/Matrix4',
  19.         '../Core/ShowGeometryInstanceAttribute',
  20.         '../Scene/MaterialAppearance',
  21.         '../Scene/PerInstanceColorAppearance',
  22.         '../Scene/Primitive',
  23.         '../Scene/SceneMode',
  24.         '../Scene/ShadowMode',
  25.         './ColorMaterialProperty',
  26.         './ConstantProperty',
  27.         './dynamicGeometryGetBoundingSphere',
  28.         './MaterialProperty',
  29.         './Property'
  30.     ], function(
  31.         Cartesian3,
  32.         Color,
  33.         ColorGeometryInstanceAttribute,
  34.         defaultValue,
  35.         defined,
  36.         defineProperties,
  37.         destroyObject,
  38.         DeveloperError,
  39.         DistanceDisplayCondition,
  40.         DistanceDisplayConditionGeometryInstanceAttribute,
  41.         EllipsoidGeometry,
  42.         EllipsoidOutlineGeometry,
  43.         Event,
  44.         GeometryInstance,
  45.         Iso8601,
  46.         Matrix4,
  47.         ShowGeometryInstanceAttribute,
  48.         MaterialAppearance,
  49.         PerInstanceColorAppearance,
  50.         Primitive,
  51.         SceneMode,
  52.         ShadowMode,
  53.         ColorMaterialProperty,
  54.         ConstantProperty,
  55.         dynamicGeometryGetBoundingSphere,
  56.         MaterialProperty,
  57.         Property) {
  58.     'use strict';
  60.     var defaultMaterial = new ColorMaterialProperty(Color.WHITE);
  61.     var defaultShow = new ConstantProperty(true);
  62.     var defaultFill = new ConstantProperty(true);
  63.     var defaultOutline = new ConstantProperty(false);
  64.     var defaultOutlineColor = new ConstantProperty(Color.BLACK);
  65.     var defaultShadows = new ConstantProperty(ShadowMode.DISABLED);
  66.     var defaultDistanceDisplayCondition = new ConstantProperty(new DistanceDisplayCondition());
  68.     var radiiScratch = new Cartesian3();
  69.     var scratchColor = new Color();
  70.     var unitSphere = new Cartesian3(1, 1, 1);
  72.     function GeometryOptions(entity) {
  73.         this.id = entity;
  74.         this.vertexFormat = undefined;
  75.         this.radii = undefined;
  76.         this.stackPartitions = undefined;
  77.         this.slicePartitions = undefined;
  78.         this.subdivisions = undefined;
  79.     }
  81.     /**
  82.      * A {@link GeometryUpdater} for ellipsoids.
  83.      * Clients do not normally create this class directly, but instead rely on {@link DataSourceDisplay}.
  84.      * @alias EllipsoidGeometryUpdater
  85.      * @constructor
  86.      *
  87.      * @param {Entity} entity The entity containing the geometry to be visualized.
  88.      * @param {Scene} scene The scene where visualization is taking place.
  89.      */
  90.     function EllipsoidGeometryUpdater(entity, scene) {
  91.         //>>includeStart('debug', pragmas.debug);
  92.         if (!defined(entity)) {
  93.             throw new DeveloperError('entity is required');
  94.         }
  95.         if (!defined(scene)) {
  96.             throw new DeveloperError('scene is required');
  97.         }
  98.         //>>includeEnd('debug');
  100.         this._scene = scene;
  101.         this._entity = entity;
  102.         this._entitySubscription = entity.definitionChanged.addEventListener(EllipsoidGeometryUpdater.prototype._onEntityPropertyChanged, this);
  103.         this._fillEnabled = false;
  104.         this._dynamic = false;
  105.         this._outlineEnabled = false;
  106.         this._geometryChanged = new Event();
  107.         this._showProperty = undefined;
  108.         this._materialProperty = undefined;
  109.         this._hasConstantOutline = true;
  110.         this._showOutlineProperty = undefined;
  111.         this._outlineColorProperty = undefined;
  112.         this._outlineWidth = 1.0;
  113.         this._shadowsProperty = undefined;
  114.         this._distanceDisplayConditionProperty = undefined;
  115.         this._options = new GeometryOptions(entity);
  116.         this._onEntityPropertyChanged(entity, 'ellipsoid', entity.ellipsoid, undefined);
  117.     }
  119.     defineProperties(EllipsoidGeometryUpdater, {
  120.         /**
  121.          * Gets the type of Appearance to use for simple color-based geometry.
  122.          * @memberof EllipsoidGeometryUpdater
  123.          * @type {Appearance}
  124.          */
  125.         perInstanceColorAppearanceType : {
  126.             value : PerInstanceColorAppearance
  127.         },
  128.         /**
  129.          * Gets the type of Appearance to use for material-based geometry.
  130.          * @memberof EllipsoidGeometryUpdater
  131.          * @type {Appearance}
  132.          */
  133.         materialAppearanceType : {
  134.             value : MaterialAppearance
  135.         }
  136.     });
  138.     defineProperties(EllipsoidGeometryUpdater.prototype, {
  139.         /**
  140.          * Gets the entity associated with this geometry.
  141.          * @memberof EllipsoidGeometryUpdater.prototype
  142.          *
  143.          * @type {Entity}
  144.          * @readonly
  145.          */
  146.         entity : {
  147.             get : function() {
  148.                 return this._entity;
  149.             }
  150.         },
  151.         /**
  152.          * Gets a value indicating if the geometry has a fill component.
  153.          * @memberof EllipsoidGeometryUpdater.prototype
  154.          *
  155.          * @type {Boolean}
  156.          * @readonly
  157.          */
  158.         fillEnabled : {
  159.             get : function() {
  160.                 return this._fillEnabled;
  161.             }
  162.         },
  163.         /**
  164.          * Gets a value indicating if fill visibility varies with simulation time.
  165.          * @memberof EllipsoidGeometryUpdater.prototype
  166.          *
  167.          * @type {Boolean}
  168.          * @readonly
  169.          */
  170.         hasConstantFill : {
  171.             get : function() {
  172.                 return !this._fillEnabled ||
  173.                        (!defined(this._entity.availability) &&
  174.                         Property.isConstant(this._showProperty) &&
  175.                         Property.isConstant(this._fillProperty));
  176.             }
  177.         },
  178.         /**
  179.          * Gets the material property used to fill the geometry.
  180.          * @memberof EllipsoidGeometryUpdater.prototype
  181.          *
  182.          * @type {MaterialProperty}
  183.          * @readonly
  184.          */
  185.         fillMaterialProperty : {
  186.             get : function() {
  187.                 return this._materialProperty;
  188.             }
  189.         },
  190.         /**
  191.          * Gets a value indicating if the geometry has an outline component.
  192.          * @memberof EllipsoidGeometryUpdater.prototype
  193.          *
  194.          * @type {Boolean}
  195.          * @readonly
  196.          */
  197.         outlineEnabled : {
  198.             get : function() {
  199.                 return this._outlineEnabled;
  200.             }
  201.         },
  202.         /**
  203.          * Gets a value indicating if outline visibility varies with simulation time.
  204.          * @memberof EllipsoidGeometryUpdater.prototype
  205.          *
  206.          * @type {Boolean}
  207.          * @readonly
  208.          */
  209.         hasConstantOutline : {
  210.             get : function() {
  211.                 return !this._outlineEnabled ||
  212.                        (!defined(this._entity.availability) &&
  213.                         Property.isConstant(this._showProperty) &&
  214.                         Property.isConstant(this._showOutlineProperty));
  215.             }
  216.         },
  217.         /**
  218.          * Gets the {@link Color} property for the geometry outline.
  219.          * @memberof EllipsoidGeometryUpdater.prototype
  220.          *
  221.          * @type {Property}
  222.          * @readonly
  223.          */
  224.         outlineColorProperty : {
  225.             get : function() {
  226.                 return this._outlineColorProperty;
  227.             }
  228.         },
  229.         /**
  230.          * Gets the constant with of the geometry outline, in pixels.
  231.          * This value is only valid if isDynamic is false.
  232.          * @memberof EllipsoidGeometryUpdater.prototype
  233.          *
  234.          * @type {Number}
  235.          * @readonly
  236.          */
  237.         outlineWidth : {
  238.             get : function() {
  239.                 return this._outlineWidth;
  240.             }
  241.         },
  242.         /**
  243.          * Gets the property specifying whether the geometry
  244.          * casts or receives shadows from each light source.
  245.          * @memberof EllipsoidGeometryUpdater.prototype
  246.          * 
  247.          * @type {Property}
  248.          * @readonly
  249.          */
  250.         shadowsProperty : {
  251.             get : function() {
  252.                 return this._shadowsProperty;
  253.             }
  254.         },
  255.         /**
  256.          * Gets or sets the {@link DistanceDisplayCondition} Property specifying at what distance from the camera that this geometry will be displayed.
  257.          * @memberof EllipsoidGeometryUpdater.prototype
  258.          *
  259.          * @type {Property}
  260.          * @readonly
  261.          */
  262.         distanceDisplayConditionProperty : {
  263.             get : function() {
  264.                 return this._distanceDisplayConditionProperty;
  265.             }
  266.         },
  267.         /**
  268.          * Gets a value indicating if the geometry is time-varying.
  269.          * If true, all visualization is delegated to the {@link DynamicGeometryUpdater}
  270.          * returned by GeometryUpdater#createDynamicUpdater.
  271.          * @memberof EllipsoidGeometryUpdater.prototype
  272.          *
  273.          * @type {Boolean}
  274.          * @readonly
  275.          */
  276.         isDynamic : {
  277.             get : function() {
  278.                 return this._dynamic;
  279.             }
  280.         },
  281.         /**
  282.          * Gets a value indicating if the geometry is closed.
  283.          * This property is only valid for static geometry.
  284.          * @memberof EllipsoidGeometryUpdater.prototype
  285.          *
  286.          * @type {Boolean}
  287.          * @readonly
  288.          */
  289.         isClosed : {
  290.             value : true
  291.         },
  292.         /**
  293.          * Gets an event that is raised whenever the public properties
  294.          * of this updater change.
  295.          * @memberof EllipsoidGeometryUpdater.prototype
  296.          *
  297.          * @type {Boolean}
  298.          * @readonly
  299.          */
  300.         geometryChanged : {
  301.             get : function() {
  302.                 return this._geometryChanged;
  303.             }
  304.         }
  305.     });
  307.     /**
  308.      * Checks if the geometry is outlined at the provided time.
  309.      *
  310.      * @param {JulianDate} time The time for which to retrieve visibility.
  311.      * @returns {Boolean} true if geometry is outlined at the provided time, false otherwise.
  312.      */
  313.     EllipsoidGeometryUpdater.prototype.isOutlineVisible = function(time) {
  314.         var entity = this._entity;
  315.         return this._outlineEnabled && entity.isAvailable(time) && this._showProperty.getValue(time) && this._showOutlineProperty.getValue(time);
  316.     };
  318.     /**
  319.      * Checks if the geometry is filled at the provided time.
  320.      *
  321.      * @param {JulianDate} time The time for which to retrieve visibility.
  322.      * @returns {Boolean} true if geometry is filled at the provided time, false otherwise.
  323.      */
  324.     EllipsoidGeometryUpdater.prototype.isFilled = function(time) {
  325.         var entity = this._entity;
  326.         return this._fillEnabled && entity.isAvailable(time) && this._showProperty.getValue(time) && this._fillProperty.getValue(time);
  327.     };
  329.     /**
  330.      * Creates the geometry instance which represents the fill of the geometry.
  331.      *
  332.      * @param {JulianDate} time The time to use when retrieving initial attribute values.
  333.      * @returns {GeometryInstance} The geometry instance representing the filled portion of the geometry.
  334.      *
  335.      * @exception {DeveloperError} This instance does not represent a filled geometry.
  336.      */
  337.     EllipsoidGeometryUpdater.prototype.createFillGeometryInstance = function(time) {
  338.         //>>includeStart('debug', pragmas.debug);
  339.         if (!defined(time)) {
  340.             throw new DeveloperError('time is required.');
  341.         }
  343.         if (!this._fillEnabled) {
  344.             throw new DeveloperError('This instance does not represent a filled geometry.');
  345.         }
  346.         //>>includeEnd('debug');
  348.         var entity = this._entity;
  349.         var isAvailable = entity.isAvailable(time);
  351.         var attributes;
  353.         var color;
  354.         var show = new ShowGeometryInstanceAttribute(isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._fillProperty.getValue(time));
  355.         var distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(time);
  356.         var distanceDisplayConditionAttribute = DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition(distanceDisplayCondition);
  357.         if (this._materialProperty instanceof ColorMaterialProperty) {
  358.             var currentColor = Color.WHITE;
  359.             if (defined(this._materialProperty.color) && (this._materialProperty.color.isConstant || isAvailable)) {
  360.                 currentColor = this._materialProperty.color.getValue(time);
  361.             }
  362.             color = ColorGeometryInstanceAttribute.fromColor(currentColor);
  363.             attributes = {
  364.                 show : show,
  365.                 distanceDisplayCondition : distanceDisplayConditionAttribute,
  366.                 color : color
  367.             };
  368.         } else {
  369.             attributes = {
  370.                 show : show,
  371.                 distanceDisplayCondition : distanceDisplayConditionAttribute
  372.             };
  373.         }
  375.         return new GeometryInstance({
  376.             id : entity,
  377.             geometry : new EllipsoidGeometry(this._options),
  378.             modelMatrix : entity._getModelMatrix(Iso8601.MINIMUM_VALUE),
  379.             attributes : attributes
  380.         });
  381.     };
  383.     /**
  384.      * Creates the geometry instance which represents the outline of the geometry.
  385.      *
  386.      * @param {JulianDate} time The time to use when retrieving initial attribute values.
  387.      * @returns {GeometryInstance} The geometry instance representing the outline portion of the geometry.
  388.      *
  389.      * @exception {DeveloperError} This instance does not represent an outlined geometry.
  390.      */
  391.     EllipsoidGeometryUpdater.prototype.createOutlineGeometryInstance = function(time) {
  392.         //>>includeStart('debug', pragmas.debug);
  393.         if (!defined(time)) {
  394.             throw new DeveloperError('time is required.');
  395.         }
  397.         if (!this._outlineEnabled) {
  398.             throw new DeveloperError('This instance does not represent an outlined geometry.');
  399.         }
  400.         //>>includeEnd('debug');
  402.         var entity = this._entity;
  403.         var isAvailable = entity.isAvailable(time);
  405.         var outlineColor = Property.getValueOrDefault(this._outlineColorProperty, time, Color.BLACK);
  406.         var distanceDisplayCondition = this._distanceDisplayConditionProperty.getValue(time);
  408.         return new GeometryInstance({
  409.             id : entity,
  410.             geometry : new EllipsoidOutlineGeometry(this._options),
  411.             modelMatrix : entity._getModelMatrix(Iso8601.MINIMUM_VALUE),
  412.             attributes : {
  413.                 show : new ShowGeometryInstanceAttribute(isAvailable && entity.isShowing && this._showProperty.getValue(time) && this._showOutlineProperty.getValue(time)),
  414.                 color : ColorGeometryInstanceAttribute.fromColor(outlineColor),
  415.                 distanceDisplayCondition : DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition(distanceDisplayCondition)
  416.             }
  417.         });
  418.     };
  420.     /**
  421.      * Returns true if this object was destroyed; otherwise, false.
  422.      *
  423.      * @returns {Boolean} True if this object was destroyed; otherwise, false.
  424.      */
  425.     EllipsoidGeometryUpdater.prototype.isDestroyed = function() {
  426.         return false;
  427.     };
  429.     /**
  430.      * Destroys and resources used by the object.  Once an object is destroyed, it should not be used.
  431.      *
  432.      * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
  433.      */
  434.     EllipsoidGeometryUpdater.prototype.destroy = function() {
  435.         this._entitySubscription();
  436.         destroyObject(this);
  437.     };
  439.     EllipsoidGeometryUpdater.prototype._onEntityPropertyChanged = function(entity, propertyName, newValue, oldValue) {
  440.         if (!(propertyName === 'availability' || propertyName === 'position' || propertyName === 'orientation' || propertyName === 'ellipsoid')) {
  441.             return;
  442.         }
  444.         var ellipsoid = entity.ellipsoid;
  446.         if (!defined(ellipsoid)) {
  447.             if (this._fillEnabled || this._outlineEnabled) {
  448.                 this._fillEnabled = false;
  449.                 this._outlineEnabled = false;
  450.                 this._geometryChanged.raiseEvent(this);
  451.             }
  452.             return;
  453.         }
  455.         var fillProperty = ellipsoid.fill;
  456.         var fillEnabled = defined(fillProperty) && fillProperty.isConstant ? fillProperty.getValue(Iso8601.MINIMUM_VALUE) : true;
  458.         var outlineProperty = ellipsoid.outline;
  459.         var outlineEnabled = defined(outlineProperty);
  460.         if (outlineEnabled && outlineProperty.isConstant) {
  461.             outlineEnabled = outlineProperty.getValue(Iso8601.MINIMUM_VALUE);
  462.         }
  464.         if (!fillEnabled && !outlineEnabled) {
  465.             if (this._fillEnabled || this._outlineEnabled) {
  466.                 this._fillEnabled = false;
  467.                 this._outlineEnabled = false;
  468.                 this._geometryChanged.raiseEvent(this);
  469.             }
  470.             return;
  471.         }
  473.         var position = entity.position;
  474.         var radii = ellipsoid.radii;
  476.         var show = ellipsoid.show;
  477.         if ((defined(show) && show.isConstant && !show.getValue(Iso8601.MINIMUM_VALUE)) || //
  478.             (!defined(position) || !defined(radii))) {
  479.             if (this._fillEnabled || this._outlineEnabled) {
  480.                 this._fillEnabled = false;
  481.                 this._outlineEnabled = false;
  482.                 this._geometryChanged.raiseEvent(this);
  483.             }
  484.             return;
  485.         }
  487.         var material = defaultValue(ellipsoid.material, defaultMaterial);
  488.         var isColorMaterial = material instanceof ColorMaterialProperty;
  489.         this._materialProperty = material;
  490.         this._fillProperty = defaultValue(fillProperty, defaultFill);
  491.         this._showProperty = defaultValue(show, defaultShow);
  492.         this._showOutlineProperty = defaultValue(ellipsoid.outline, defaultOutline);
  493.         this._outlineColorProperty = outlineEnabled ? defaultValue(ellipsoid.outlineColor, defaultOutlineColor) : undefined;
  494.         this._shadowsProperty = defaultValue(ellipsoid.shadows, defaultShadows);
  495.         this._distanceDisplayConditionProperty = defaultValue(ellipsoid.distanceDisplayCondition, defaultDistanceDisplayCondition);
  496.         
  497.         this._fillEnabled = fillEnabled;
  498.         this._outlineEnabled = outlineEnabled;
  500.         var stackPartitions = ellipsoid.stackPartitions;
  501.         var slicePartitions = ellipsoid.slicePartitions;
  502.         var outlineWidth = ellipsoid.outlineWidth;
  503.         var subdivisions = ellipsoid.subdivisions;
  505.         if (!position.isConstant || //
  506.             !Property.isConstant(entity.orientation) || //
  507.             !radii.isConstant || //
  508.             !Property.isConstant(stackPartitions) || //
  509.             !Property.isConstant(slicePartitions) || //
  510.             !Property.isConstant(outlineWidth) || //
  511.             !Property.isConstant(subdivisions)) {
  512.             if (!this._dynamic) {
  513.                 this._dynamic = true;
  514.                 this._geometryChanged.raiseEvent(this);
  515.             }
  516.         } else {
  517.             var options = this._options;
  518.             options.vertexFormat = isColorMaterial ? PerInstanceColorAppearance.VERTEX_FORMAT : MaterialAppearance.MaterialSupport.TEXTURED.vertexFormat;
  519.             options.radii = radii.getValue(Iso8601.MINIMUM_VALUE, options.radii);
  520.             options.stackPartitions = defined(stackPartitions) ? stackPartitions.getValue(Iso8601.MINIMUM_VALUE) : undefined;
  521.             options.slicePartitions = defined(slicePartitions) ? slicePartitions.getValue(Iso8601.MINIMUM_VALUE) : undefined;
  522.             options.subdivisions = defined(subdivisions) ? subdivisions.getValue(Iso8601.MINIMUM_VALUE) : undefined;
  523.             this._outlineWidth = defined(outlineWidth) ? outlineWidth.getValue(Iso8601.MINIMUM_VALUE) : 1.0;
  524.             this._dynamic = false;
  525.             this._geometryChanged.raiseEvent(this);
  526.         }
  527.     };
  529.     /**
  530.      * Creates the dynamic updater to be used when GeometryUpdater#isDynamic is true.
  531.      *
  532.      * @param {PrimitiveCollection} primitives The primitive collection to use.
  533.      * @returns {DynamicGeometryUpdater} The dynamic updater used to update the geometry each frame.
  534.      *
  535.      * @exception {DeveloperError} This instance does not represent dynamic geometry.
  536.      */
  537.     EllipsoidGeometryUpdater.prototype.createDynamicUpdater = function(primitives) {
  538.         //>>includeStart('debug', pragmas.debug);
  539.         if (!this._dynamic) {
  540.             throw new DeveloperError('This instance does not represent dynamic geometry.');
  541.         }
  543.         if (!defined(primitives)) {
  544.             throw new DeveloperError('primitives is required.');
  545.         }
  546.         //>>includeEnd('debug');
  548.         return new DynamicGeometryUpdater(primitives, this);
  549.     };
  551.     /**
  552.      * @private
  553.      */
  554.     function DynamicGeometryUpdater(primitives, geometryUpdater) {
  555.         this._entity = geometryUpdater._entity;
  556.         this._scene = geometryUpdater._scene;
  557.         this._primitives = primitives;
  558.         this._primitive = undefined;
  559.         this._outlinePrimitive = undefined;
  560.         this._geometryUpdater = geometryUpdater;
  561.         this._options = new GeometryOptions(geometryUpdater._entity);
  562.         this._modelMatrix = new Matrix4();
  563.         this._material = undefined;
  564.         this._attributes = undefined;
  565.         this._outlineAttributes = undefined;
  566.         this._lastSceneMode = undefined;
  567.         this._lastShow = undefined;
  568.         this._lastOutlineShow = undefined;
  569.         this._lastOutlineWidth = undefined;
  570.         this._lastOutlineColor = undefined;
  571.     }
  572.     DynamicGeometryUpdater.prototype.update = function(time) {
  573.         //>>includeStart('debug', pragmas.debug);
  574.         if (!defined(time)) {
  575.             throw new DeveloperError('time is required.');
  576.         }
  577.         //>>includeEnd('debug');
  579.         var entity = this._entity;
  580.         var ellipsoid = entity.ellipsoid;
  581.         if (!entity.isShowing || !entity.isAvailable(time) || !Property.getValueOrDefault(ellipsoid.show, time, true)) {
  582.             if (defined(this._primitive)) {
  583.                 this._primitive.show = false;
  584.             }
  586.             if (defined(this._outlinePrimitive)) {
  587.                 this._outlinePrimitive.show = false;
  588.             }
  589.             return;
  590.         }
  592.         var radii = Property.getValueOrUndefined(ellipsoid.radii, time, radiiScratch);
  593.         var modelMatrix = entity._getModelMatrix(time, this._modelMatrix);
  594.         if (!defined(modelMatrix) || !defined(radii)) {
  595.             if (defined(this._primitive)) {
  596.                 this._primitive.show = false;
  597.             }
  599.             if (defined(this._outlinePrimitive)) {
  600.                 this._outlinePrimitive.show = false;
  601.             }
  602.             return;
  603.         }
  605.         //Compute attributes and material.
  606.         var appearance;
  607.         var showFill = Property.getValueOrDefault(ellipsoid.fill, time, true);
  608.         var showOutline = Property.getValueOrDefault(ellipsoid.outline, time, false);
  609.         var outlineColor = Property.getValueOrClonedDefault(ellipsoid.outlineColor, time, Color.BLACK, scratchColor);
  610.         var material = MaterialProperty.getValue(time, defaultValue(ellipsoid.material, defaultMaterial), this._material);
  611.         this._material = material;
  613.         // Check properties that could trigger a primitive rebuild.
  614.         var stackPartitions = Property.getValueOrUndefined(ellipsoid.stackPartitions, time);
  615.         var slicePartitions = Property.getValueOrUndefined(ellipsoid.slicePartitions, time);
  616.         var subdivisions = Property.getValueOrUndefined(ellipsoid.subdivisions, time);
  617.         var outlineWidth = Property.getValueOrDefault(ellipsoid.outlineWidth, time, 1.0);
  619.         //In 3D we use a fast path by modifying Primitive.modelMatrix instead of regenerating the primitive every frame.
  620.         var sceneMode = this._scene.mode;
  621.         var in3D = sceneMode === SceneMode.SCENE3D;
  623.         var options = this._options;
  624.         
  625.         var shadows = this._geometryUpdater.shadowsProperty.getValue(time);
  627.         var distanceDisplayConditionProperty = this._geometryUpdater.distanceDisplayConditionProperty;
  628.         var distanceDisplayCondition = distanceDisplayConditionProperty.getValue(time);
  629.         var distanceDisplayConditionAttribute = DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition(distanceDisplayCondition);
  630.         
  631.         //We only rebuild the primitive if something other than the radii has changed
  632.         //For the radii, we use unit sphere and then deform it with a scale matrix.
  633.         var rebuildPrimitives = !in3D || this._lastSceneMode !== sceneMode || !defined(this._primitive) || //
  634.                                 options.stackPartitions !== stackPartitions || options.slicePartitions !== slicePartitions || //
  635.                                 options.subdivisions !== subdivisions || this._lastOutlineWidth !== outlineWidth;
  637.         if (rebuildPrimitives) {
  638.             var primitives = this._primitives;
  639.             primitives.removeAndDestroy(this._primitive);
  640.             primitives.removeAndDestroy(this._outlinePrimitive);
  641.             this._primitive = undefined;
  642.             this._outlinePrimitive = undefined;
  643.             this._lastSceneMode = sceneMode;
  644.             this._lastOutlineWidth = outlineWidth;
  646.             options.stackPartitions = stackPartitions;
  647.             options.slicePartitions = slicePartitions;
  648.             options.subdivisions = subdivisions;
  649.             options.radii = in3D ? unitSphere : radii;
  651.             appearance = new MaterialAppearance({
  652.                 material : material,
  653.                 translucent : material.isTranslucent(),
  654.                 closed : true
  655.             });
  656.             options.vertexFormat = appearance.vertexFormat;
  658.             this._primitive = primitives.add(new Primitive({
  659.                 geometryInstances : new GeometryInstance({
  660.                     id : entity,
  661.                     geometry : new EllipsoidGeometry(options),
  662.                     modelMatrix : !in3D ? modelMatrix : undefined,
  663.                     attributes : {
  664.                         show : new ShowGeometryInstanceAttribute(showFill),
  665.                         distanceDisplayCondition : distanceDisplayConditionAttribute
  666.                     }
  667.                 }),
  668.                 appearance : appearance,
  669.                 asynchronous : false,
  670.                 shadows : shadows
  671.             }));
  673.             options.vertexFormat = PerInstanceColorAppearance.VERTEX_FORMAT;
  675.             this._outlinePrimitive = primitives.add(new Primitive({
  676.                 geometryInstances : new GeometryInstance({
  677.                     id : entity,
  678.                     geometry : new EllipsoidOutlineGeometry(options),
  679.                     modelMatrix : !in3D ? modelMatrix : undefined,
  680.                     attributes : {
  681.                         show : new ShowGeometryInstanceAttribute(showOutline),
  682.                         color : ColorGeometryInstanceAttribute.fromColor(outlineColor),
  683.                         distanceDisplayCondition : distanceDisplayConditionAttribute
  684.                     }
  685.                 }),
  686.                 appearance : new PerInstanceColorAppearance({
  687.                     flat : true,
  688.                     translucent : outlineColor.alpha !== 1.0,
  689.                     renderState : {
  690.                         lineWidth : this._geometryUpdater._scene.clampLineWidth(outlineWidth)
  691.                     }
  692.                 }),
  693.                 asynchronous : false,
  694.                 shadows : shadows
  695.             }));
  697.             this._lastShow = showFill;
  698.             this._lastOutlineShow = showOutline;
  699.             this._lastOutlineColor = Color.clone(outlineColor, this._lastOutlineColor);
  700.             this._lastDistanceDisplayCondition = distanceDisplayCondition;
  701.         } else if (this._primitive.ready) {
  702.             //Update attributes only.
  703.             var primitive = this._primitive;
  704.             var outlinePrimitive = this._outlinePrimitive;
  706.             primitive.show = true;
  707.             outlinePrimitive.show = true;
  709.             appearance = primitive.appearance;
  710.             appearance.material = material;
  712.             var attributes = this._attributes;
  713.             if (!defined(attributes)) {
  714.                 attributes = primitive.getGeometryInstanceAttributes(entity);
  715.                 this._attributes = attributes;
  716.             }
  717.             if (showFill !== this._lastShow) {
  718.                 attributes.show = ShowGeometryInstanceAttribute.toValue(showFill, attributes.show);
  719.                 this._lastShow = showFill;
  720.             }
  722.             var outlineAttributes = this._outlineAttributes;
  724.             if (!defined(outlineAttributes)) {
  725.                 outlineAttributes = outlinePrimitive.getGeometryInstanceAttributes(entity);
  726.                 this._outlineAttributes = outlineAttributes;
  727.             }
  729.             if (showOutline !== this._lastOutlineShow) {
  730.                 outlineAttributes.show = ShowGeometryInstanceAttribute.toValue(showOutline, outlineAttributes.show);
  731.                 this._lastOutlineShow = showOutline;
  732.             }
  734.             if (!Color.equals(outlineColor, this._lastOutlineColor)) {
  735.                 outlineAttributes.color = ColorGeometryInstanceAttribute.toValue(outlineColor, outlineAttributes.color);
  736.                 Color.clone(outlineColor, this._lastOutlineColor);
  737.             }
  739.             if (!DistanceDisplayCondition.equals(distanceDisplayCondition, this._lastDistanceDisplayCondition)) {
  740.                 attributes.distanceDisplayCondition = DistanceDisplayConditionGeometryInstanceAttribute.toValue(distanceDisplayCondition, attributes.distanceDisplayCondition);
  741.                 outlineAttributes.distanceDisplayCondition = DistanceDisplayConditionGeometryInstanceAttribute.toValue(distanceDisplayCondition, outlineAttributes.distanceDisplayCondition);
  742.                 DistanceDisplayCondition.clone(distanceDisplayCondition, this._lastDistanceDisplayCondition);
  743.             }
  744.         }
  746.         if (in3D) {
  747.             //Since we are scaling a unit sphere, we can't let any of the values go to zero.
  748.             //Instead we clamp them to a small value.  To the naked eye, this produces the same results
  749.             //that you get passing EllipsoidGeometry a radii with a zero component.
  750.             radii.x = Math.max(radii.x, 0.001);
  751.             radii.y = Math.max(radii.y, 0.001);
  752.             radii.z = Math.max(radii.z, 0.001);
  754.             modelMatrix = Matrix4.multiplyByScale(modelMatrix, radii, modelMatrix);
  755.             this._primitive.modelMatrix = modelMatrix;
  756.             this._outlinePrimitive.modelMatrix = modelMatrix;
  757.         }
  758.     };
  760.     DynamicGeometryUpdater.prototype.getBoundingSphere = function(entity, result) {
  761.         return dynamicGeometryGetBoundingSphere(entity, this._primitive, this._outlinePrimitive, result);
  762.     };
  764.     DynamicGeometryUpdater.prototype.isDestroyed = function() {
  765.         return false;
  766.     };
  768.     DynamicGeometryUpdater.prototype.destroy = function() {
  769.         var primitives = this._primitives;
  770.         primitives.removeAndDestroy(this._primitive);
  771.         primitives.removeAndDestroy(this._outlinePrimitive);
  772.         destroyObject(this);
  773.     };
  775.     return EllipsoidGeometryUpdater;
  776. });