text: /*global define*/
  define([
          '../Core/defaultValue',
          '../Core/defined',
          '../Core/defineProperties',
          '../Core/VertexFormat',
          '../Shaders/Appearances/EllipsoidSurfaceAppearanceFS',
          '../Shaders/Appearances/EllipsoidSurfaceAppearanceVS',
          './Appearance',
          './Material'
      ], function(
          defaultValue,
          defined,
          defineProperties,
          VertexFormat,
          EllipsoidSurfaceAppearanceFS,
          EllipsoidSurfaceAppearanceVS,
          Appearance,
          Material) {
      "use strict";
  
      /**
       * An appearance for geometry on the surface of the ellipsoid like {@link PolygonGeometry}
       * and {@link RectangleGeometry}, which supports all materials like {@link MaterialAppearance}
       * with {@link MaterialAppearance.MaterialSupport.ALL}.  However, this appearance requires
       * fewer vertex attributes since the fragment shader can procedurally compute <code>normal</code>,
       * <code>binormal</code>, and <code>tangent</code>.
       *
       * @alias EllipsoidSurfaceAppearance
       * @constructor
       *
       * @param {Object} [options] Object with the following properties:
       * @param {Boolean} [options.flat=false] When <code>true</code>, flat shading is used in the fragment shader, which means lighting is not taking into account.
       * @param {Boolean} [options.faceForward=options.aboveGround] When <code>true</code>, the fragment shader flips the surface normal as needed to ensure that the normal faces the viewer to avoid dark spots.  This is useful when both sides of a geometry should be shaded like {@link WallGeometry}.
       * @param {Boolean} [options.translucent=true] When <code>true</code>, the geometry is expected to appear translucent so {@link EllipsoidSurfaceAppearance#renderState} has alpha blending enabled.
       * @param {Boolean} [options.aboveGround=false] When <code>true</code>, the geometry is expected to be on the ellipsoid's surface - not at a constant height above it - so {@link EllipsoidSurfaceAppearance#renderState} has backface culling enabled.
       * @param {Material} [options.material=Material.ColorType] The material used to determine the fragment color.
       * @param {String} [options.vertexShaderSource] Optional GLSL vertex shader source to override the default vertex shader.
       * @param {String} [options.fragmentShaderSource] Optional GLSL fragment shader source to override the default fragment shader.
       * @param {RenderState} [options.renderState] Optional render state to override the default render state.
       *
       * @see {@link https://github.com/AnalyticalGraphicsInc/cesium/wiki/Fabric|Fabric}
       *
       * @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Ellipsoid%20Surface.html|Cesium Sandcastle Ellipsoid Surface Appearance Demo}
       *
       * @example
       * var primitive = new Cesium.Primitive({
       *   geometryInstances : new Cesium.GeometryInstance({
       *     geometry : new Cesium.PolygonGeometry({
       *       vertexFormat : Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT,
       *       // ...
       *     })
       *   }),
       *   appearance : new Cesium.EllipsoidSurfaceAppearance({
       *     material : Cesium.Material.fromType('Stripe')
       *   })
       * });
       */
      var EllipsoidSurfaceAppearance = function(options) {
          options = defaultValue(options, defaultValue.EMPTY_OBJECT);
  
          var translucent = defaultValue(options.translucent, true);
          var aboveGround = defaultValue(options.aboveGround, false);
  
          /**
           * The material used to determine the fragment color.  Unlike other {@link EllipsoidSurfaceAppearance}
           * properties, this is not read-only, so an appearance's material can change on the fly.
           *
           * @type Material
           *
           * @default {@link Material.ColorType}
           *
           * @see {@link https://github.com/AnalyticalGraphicsInc/cesium/wiki/Fabric|Fabric}
           */
          this.material = (defined(options.material)) ? options.material : Material.fromType(Material.ColorType);
  
          /**
           * When <code>true</code>, the geometry is expected to appear translucent.
           *
           * @type {Boolean}
           *
           * @default true
           */
          this.translucent = defaultValue(options.translucent, true);
  
          this._vertexShaderSource = defaultValue(options.vertexShaderSource, EllipsoidSurfaceAppearanceVS);
          this._fragmentShaderSource = defaultValue(options.fragmentShaderSource, EllipsoidSurfaceAppearanceFS);
          this._renderState = Appearance.getDefaultRenderState(translucent, !aboveGround, options.renderState);
          this._closed = false;
  
          // Non-derived members
  
          this._flat = defaultValue(options.flat, false);
          this._faceForward = defaultValue(options.faceForward, aboveGround);
          this._aboveGround = aboveGround;
      };
  
      defineProperties(EllipsoidSurfaceAppearance.prototype, {
          /**
           * The GLSL source code for the vertex shader.
           *
           * @memberof EllipsoidSurfaceAppearance.prototype
           *
           * @type {String}
           * @readonly
           */
          vertexShaderSource : {
              get : function() {
                  return this._vertexShaderSource;
              }
          },
  
          /**
           * The GLSL source code for the fragment shader.  The full fragment shader
           * source is built procedurally taking into account {@link EllipsoidSurfaceAppearance#material},
           * {@link EllipsoidSurfaceAppearance#flat}, and {@link EllipsoidSurfaceAppearance#faceForward}.
           * Use {@link EllipsoidSurfaceAppearance#getFragmentShaderSource} to get the full source.
           *
           * @memberof EllipsoidSurfaceAppearance.prototype
           *
           * @type {String}
           * @readonly
           */
          fragmentShaderSource : {
              get : function() {
                  return this._fragmentShaderSource;
              }
          },
  
          /**
           * The WebGL fixed-function state to use when rendering the geometry.
           * <p>
           * The render state can be explicitly defined when constructing a {@link EllipsoidSurfaceAppearance}
           * instance, or it is set implicitly via {@link EllipsoidSurfaceAppearance#translucent}
           * and {@link EllipsoidSurfaceAppearance#aboveGround}.
           * </p>
           *
           * @memberof EllipsoidSurfaceAppearance.prototype
           *
           * @type {Object}
           * @readonly
           */
          renderState : {
              get : function() {
                  return this._renderState;
              }
          },
  
          /**
           * When <code>true</code>, the geometry is expected to be closed so
           * {@link EllipsoidSurfaceAppearance#renderState} has backface culling enabled.
           * If the viewer enters the geometry, it will not be visible.
           *
           * @memberof EllipsoidSurfaceAppearance.prototype
           *
           * @type {Boolean}
           * @readonly
           *
           * @default false
           */
          closed : {
              get : function() {
                  return this._closed;
              }
          },
  
          /**
           * The {@link VertexFormat} that this appearance instance is compatible with.
           * A geometry can have more vertex attributes and still be compatible - at a
           * potential performance cost - but it can't have less.
           *
           * @memberof EllipsoidSurfaceAppearance.prototype
           *
           * @type VertexFormat
           * @readonly
           *
           * @default {@link EllipsoidSurfaceAppearance.VERTEX_FORMAT}
           */
          vertexFormat : {
              get : function() {
                  return EllipsoidSurfaceAppearance.VERTEX_FORMAT;
              }
          },
  
          /**
           * When <code>true</code>, flat shading is used in the fragment shader,
           * which means lighting is not taking into account.
           *
           * @memberof EllipsoidSurfaceAppearance.prototype
           *
           * @type {Boolean}
           * @readonly
           *
           * @default false
           */
          flat : {
              get : function() {
                  return this._flat;
              }
          },
  
          /**
           * When <code>true</code>, the fragment shader flips the surface normal
           * as needed to ensure that the normal faces the viewer to avoid
           * dark spots.  This is useful when both sides of a geometry should be
           * shaded like {@link WallGeometry}.
           *
           * @memberof EllipsoidSurfaceAppearance.prototype
           *
           * @type {Boolean}
           * @readonly
           *
           * @default true
           */
          faceForward : {
              get : function() {
                  return this._faceForward;
              }
          },
  
          /**
           * When <code>true</code>, the geometry is expected to be on the ellipsoid's
           * surface - not at a constant height above it - so {@link EllipsoidSurfaceAppearance#renderState}
           * has backface culling enabled.
           *
           *
           * @memberof EllipsoidSurfaceAppearance.prototype
           *
           * @type {Boolean}
           * @readonly
           *
           * @default false
           */
          aboveGround : {
              get : function() {
                  return this._aboveGround;
              }
          }
      });
  
      /**
       * The {@link VertexFormat} that all {@link EllipsoidSurfaceAppearance} instances
       * are compatible with, which requires only <code>position</code> and <code>st</code>
       * attributes.  Other attributes are procedurally computed in the fragment shader.
       *
       * @type VertexFormat
       *
       * @constant
       */
      EllipsoidSurfaceAppearance.VERTEX_FORMAT = VertexFormat.POSITION_AND_ST;
  
      /**
       * Procedurally creates the full GLSL fragment shader source.  For {@link EllipsoidSurfaceAppearance},
       * this is derived from {@link EllipsoidSurfaceAppearance#fragmentShaderSource}, {@link EllipsoidSurfaceAppearance#flat},
       * and {@link EllipsoidSurfaceAppearance#faceForward}.
       *
       * @function
       *
       * @returns String The full GLSL fragment shader source.
       */
      EllipsoidSurfaceAppearance.prototype.getFragmentShaderSource = Appearance.prototype.getFragmentShaderSource;
  
      /**
       * Determines if the geometry is translucent based on {@link EllipsoidSurfaceAppearance#translucent} and {@link Material#isTranslucent}.
       *
       * @function
       *
       * @returns {Boolean} <code>true</code> if the appearance is translucent.
       */
      EllipsoidSurfaceAppearance.prototype.isTranslucent = Appearance.prototype.isTranslucent;
  
      /**
       * Creates a render state.  This is not the final render state instance; instead,
       * it can contain a subset of render state properties identical to the render state
       * created in the context.
       *
       * @function
       *
       * @returns {Object} The render state.
       */
      EllipsoidSurfaceAppearance.prototype.getRenderState = Appearance.prototype.getRenderState;
  
      return EllipsoidSurfaceAppearance;
  });