/**
 * Cesium Sensor Volumes - https://github.com/jlouns/cesium-sensor-volumes
 *
 * Copyright 2016 Jonathan Lounsbury
 * Copyright 2011-2014 Analytical Graphics Inc. and Cesium Contributors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Portions licensed separately.
 * See https://github.com/jlouns/cesium-sensor-volumes/blob/master/LICENSE.md for full licensing details.
 *
 * Derived from Cesium Sensors - https://github.com/AnalyticalGraphicsInc/cesium-sensors
 */

(function () {
  /**
   * @license almond 0.3.3 Copyright jQuery Foundation and other contributors.
   * Released under MIT license, http://github.com/requirejs/almond/LICENSE
   */
  //Going sloppy to avoid 'use strict' string cost, but strict practices should
  //be followed.
  /*global setTimeout: false */

  var requirejs, require, define;
  (function (undef) {
    var main,
      req,
      makeMap,
      handlers,
      defined = {},
      waiting = {},
      config = {},
      defining = {},
      hasOwn = Object.prototype.hasOwnProperty,
      aps = [].slice,
      jsSuffixRegExp = /\.js$/;

    function hasProp(obj, prop) {
      return hasOwn.call(obj, prop);
    }

    /**
     * Given a relative module name, like ./something, normalize it to
     * a real name that can be mapped to a path.
     * @param {String} name the relative name
     * @param {String} baseName a real name that the name arg is relative
     * to.
     * @returns {String} normalized name
     */
    function normalize(name, baseName) {
      var nameParts,
        nameSegment,
        mapValue,
        foundMap,
        lastIndex,
        foundI,
        foundStarMap,
        starI,
        i,
        j,
        part,
        normalizedBaseParts,
        baseParts = baseName && baseName.split("/"),
        map = config.map,
        starMap = (map && map["*"]) || {};

      //Adjust any relative paths.
      if (name) {
        name = name.split("/");
        lastIndex = name.length - 1;

        // If wanting node ID compatibility, strip .js from end
        // of IDs. Have to do this here, and not in nameToUrl
        // because node allows either .js or non .js to map
        // to same file.
        if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
          name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, "");
        }

        // Starts with a '.' so need the baseName
        if (name[0].charAt(0) === "." && baseParts) {
          //Convert baseName to array, and lop off the last part,
          //so that . matches that 'directory' and not name of the baseName's
          //module. For instance, baseName of 'one/two/three', maps to
          //'one/two/three.js', but we want the directory, 'one/two' for
          //this normalization.
          normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
          name = normalizedBaseParts.concat(name);
        }

        //start trimDots
        for (i = 0; i < name.length; i++) {
          part = name[i];
          if (part === ".") {
            name.splice(i, 1);
            i -= 1;
          } else if (part === "..") {
            // If at the start, or previous value is still ..,
            // keep them so that when converted to a path it may
            // still work when converted to a path, even though
            // as an ID it is less than ideal. In larger point
            // releases, may be better to just kick out an error.
            if (
              i === 0 ||
              (i === 1 && name[2] === "..") ||
              name[i - 1] === ".."
            ) {
              continue;
            } else if (i > 0) {
              name.splice(i - 1, 2);
              i -= 2;
            }
          }
        }
        //end trimDots

        name = name.join("/");
      }

      //Apply map config if available.
      if ((baseParts || starMap) && map) {
        nameParts = name.split("/");

        for (i = nameParts.length; i > 0; i -= 1) {
          nameSegment = nameParts.slice(0, i).join("/");

          if (baseParts) {
            //Find the longest baseName segment match in the config.
            //So, do joins on the biggest to smallest lengths of baseParts.
            for (j = baseParts.length; j > 0; j -= 1) {
              mapValue = map[baseParts.slice(0, j).join("/")];

              //baseName segment has  config, find if it has one for
              //this name.
              if (mapValue) {
                mapValue = mapValue[nameSegment];
                if (mapValue) {
                  //Match, update name to the new value.
                  foundMap = mapValue;
                  foundI = i;
                  break;
                }
              }
            }
          }

          if (foundMap) {
            break;
          }

          //Check for a star map match, but just hold on to it,
          //if there is a shorter segment match later in a matching
          //config, then favor over this star map.
          if (!foundStarMap && starMap && starMap[nameSegment]) {
            foundStarMap = starMap[nameSegment];
            starI = i;
          }
        }

        if (!foundMap && foundStarMap) {
          foundMap = foundStarMap;
          foundI = starI;
        }

        if (foundMap) {
          nameParts.splice(0, foundI, foundMap);
          name = nameParts.join("/");
        }
      }

      return name;
    }

    function makeRequire(relName, forceSync) {
      return function () {
        //A version of a require function that passes a moduleName
        //value for items that may need to
        //look up paths relative to the moduleName
        var args = aps.call(arguments, 0);

        //If first arg is not require('string'), and there is only
        //one arg, it is the array form without a callback. Insert
        //a null so that the following concat is correct.
        if (typeof args[0] !== "string" && args.length === 1) {
          args.push(null);
        }
        return req.apply(undef, args.concat([relName, forceSync]));
      };
    }

    function makeNormalize(relName) {
      return function (name) {
        return normalize(name, relName);
      };
    }

    function makeLoad(depName) {
      return function (value) {
        defined[depName] = value;
      };
    }

    function callDep(name) {
      if (hasProp(waiting, name)) {
        var args = waiting[name];
        delete waiting[name];
        defining[name] = true;
        main.apply(undef, args);
      }

      if (!hasProp(defined, name) && !hasProp(defining, name)) {
        throw new Error("No " + name);
      }
      return defined[name];
    }

    //Turns a plugin!resource to [plugin, resource]
    //with the plugin being undefined if the name
    //did not have a plugin prefix.
    function splitPrefix(name) {
      var prefix,
        index = name ? name.indexOf("!") : -1;
      if (index > -1) {
        prefix = name.substring(0, index);
        name = name.substring(index + 1, name.length);
      }
      return [prefix, name];
    }

    //Creates a parts array for a relName where first part is plugin ID,
    //second part is resource ID. Assumes relName has already been normalized.
    function makeRelParts(relName) {
      return relName ? splitPrefix(relName) : [];
    }

    /**
     * Makes a name map, normalizing the name, and using a plugin
     * for normalization if necessary. Grabs a ref to plugin
     * too, as an optimization.
     */
    makeMap = function (name, relParts) {
      var plugin,
        parts = splitPrefix(name),
        prefix = parts[0],
        relResourceName = relParts[1];

      name = parts[1];

      if (prefix) {
        prefix = normalize(prefix, relResourceName);
        plugin = callDep(prefix);
      }

      //Normalize according
      if (prefix) {
        if (plugin && plugin.normalize) {
          name = plugin.normalize(name, makeNormalize(relResourceName));
        } else {
          name = normalize(name, relResourceName);
        }
      } else {
        name = normalize(name, relResourceName);
        parts = splitPrefix(name);
        prefix = parts[0];
        name = parts[1];
        if (prefix) {
          plugin = callDep(prefix);
        }
      }

      //Using ridiculous property names for space reasons
      return {
        f: prefix ? prefix + "!" + name : name, //fullName
        n: name,
        pr: prefix,
        p: plugin,
      };
    };

    function makeConfig(name) {
      return function () {
        return (config && config.config && config.config[name]) || {};
      };
    }

    handlers = {
      require: function (name) {
        return makeRequire(name);
      },
      exports: function (name) {
        var e = defined[name];
        if (typeof e !== "undefined") {
          return e;
        } else {
          return (defined[name] = {});
        }
      },
      module: function (name) {
        return {
          id: name,
          uri: "",
          exports: defined[name],
          config: makeConfig(name),
        };
      },
    };

    main = function (name, deps, callback, relName) {
      var cjsModule,
        depName,
        ret,
        map,
        i,
        relParts,
        args = [],
        callbackType = typeof callback,
        usingExports;

      //Use name if no relName
      relName = relName || name;
      relParts = makeRelParts(relName);

      //Call the callback to define the module, if necessary.
      if (callbackType === "undefined" || callbackType === "function") {
        //Pull out the defined dependencies and pass the ordered
        //values to the callback.
        //Default to [require, exports, module] if no deps
        deps =
          !deps.length && callback.length
            ? ["require", "exports", "module"]
            : deps;
        for (i = 0; i < deps.length; i += 1) {
          map = makeMap(deps[i], relParts);
          depName = map.f;

          //Fast path CommonJS standard dependencies.
          if (depName === "require") {
            args[i] = handlers.require(name);
          } else if (depName === "exports") {
            //CommonJS module spec 1.1
            args[i] = handlers.exports(name);
            usingExports = true;
          } else if (depName === "module") {
            //CommonJS module spec 1.1
            cjsModule = args[i] = handlers.module(name);
          } else if (
            hasProp(defined, depName) ||
            hasProp(waiting, depName) ||
            hasProp(defining, depName)
          ) {
            args[i] = callDep(depName);
          } else if (map.p) {
            map.p.load(
              map.n,
              makeRequire(relName, true),
              makeLoad(depName),
              {}
            );
            args[i] = defined[depName];
          } else {
            throw new Error(name + " missing " + depName);
          }
        }

        ret = callback ? callback.apply(defined[name], args) : undefined;

        if (name) {
          //If setting exports via "module" is in play,
          //favor that over return value and exports. After that,
          //favor a non-undefined return value over exports use.
          if (
            cjsModule &&
            cjsModule.exports !== undef &&
            cjsModule.exports !== defined[name]
          ) {
            defined[name] = cjsModule.exports;
          } else if (ret !== undef || !usingExports) {
            //Use the return value from the function.
            defined[name] = ret;
          }
        }
      } else if (name) {
        //May just be an object definition for the module. Only
        //worry about defining if have a module name.
        defined[name] = callback;
      }
    };

    requirejs =
      require =
      req =
        function (deps, callback, relName, forceSync, alt) {
          if (typeof deps === "string") {
            if (handlers[deps]) {
              //callback in this case is really relName
              return handlers[deps](callback);
            }
            //Just return the module wanted. In this scenario, the
            //deps arg is the module name, and second arg (if passed)
            //is just the relName.
            //Normalize module name, if it contains . or ..
            return callDep(makeMap(deps, makeRelParts(callback)).f);
          } else if (!deps.splice) {
            //deps is a config object, not an array.
            config = deps;
            if (config.deps) {
              req(config.deps, config.callback);
            }
            if (!callback) {
              return;
            }

            if (callback.splice) {
              //callback is an array, which means it is a dependency list.
              //Adjust args if there are dependencies
              deps = callback;
              callback = relName;
              relName = null;
            } else {
              deps = undef;
            }
          }

          //Support require(['a'])
          callback = callback || function () {};

          //If relName is a function, it is an errback handler,
          //so remove it.
          if (typeof relName === "function") {
            relName = forceSync;
            forceSync = alt;
          }

          //Simulate async callback;
          if (forceSync) {
            main(undef, deps, callback, relName);
          } else {
            //Using a non-zero value because of concern for what old browsers
            //do, and latest browsers "upgrade" to 4 if lower value is used:
            //http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
            //If want a value immediately, use require('id') instead -- something
            //that works in almond on the global level, but not guaranteed and
            //unlikely to work in other AMD implementations.
            setTimeout(function () {
              main(undef, deps, callback, relName);
            }, 4);
          }

          return req;
        };

    /**
     * Just drops the config on the floor, but returns req in case
     * the config return value is used.
     */
    req.config = function (cfg) {
      return req(cfg);
    };

    /**
     * Expose module registry for debugging and tooling
     */
    requirejs._defined = defined;

    define = function (name, deps, callback) {
      if (typeof name !== "string") {
        throw new Error(
          "See almond README: incorrect module build, no module name"
        );
      }

      //This module may not have dependencies
      if (!deps.splice) {
        //deps is not an array, so probably means
        //an object literal or factory function for
        //the value. Adjust args.
        callback = deps;
        deps = [];
      }

      if (!hasProp(defined, name) && !hasProp(waiting, name)) {
        waiting[name] = [name, deps, callback];
      }
    };

    define.amd = {
      jQuery: true,
    };
  })();

  define("conic/conic-sensor-graphics", [
    "require",
    "Cesium/Core/defaultValue",
    "Cesium/Core/defined",
    "Cesium/Core/DeveloperError",
    "Cesium/Core/Event",
    "Cesium/DataSources/createMaterialPropertyDescriptor",
    "Cesium/DataSources/createPropertyDescriptor",
  ], function (require) {
    "use strict";

    var defaultValue = require("Cesium/Core/defaultValue");
    var defined = require("Cesium/Core/defined");
    var defineProperties = Object.defineProperties;
    var DeveloperError = require("Cesium/Core/DeveloperError");
    var Event = require("Cesium/Core/Event");

    var createMaterialPropertyDescriptor = require("Cesium/DataSources/createMaterialPropertyDescriptor");
    var createPropertyDescriptor = require("Cesium/DataSources/createPropertyDescriptor");

    /**
     * An optionally time-dynamic cone.
     *
     * @alias ConicSensorGraphics
     * @constructor
     */
    var ConicSensorGraphics = function (options) {
      this._minimumClockAngle = undefined;
      this._minimumClockAngleSubscription = undefined;
      this._maximumClockAngle = undefined;
      this._maximumClockAngleSubscription = undefined;
      this._innerHalfAngle = undefined;
      this._innerHalfAngleSubscription = undefined;
      this._outerHalfAngle = undefined;
      this._outerHalfAngleSubscription = undefined;
      this._lateralSurfaceMaterial = undefined;
      this._lateralSurfaceMaterialSubscription = undefined;
      this._intersectionColor = undefined;
      this._intersectionColorSubscription = undefined;
      this._intersectionWidth = undefined;
      this._intersectionWidthSubscription = undefined;
      this._showIntersection = undefined;
      this._showIntersectionSubscription = undefined;
      this._radius = undefined;
      this._radiusSubscription = undefined;
      this._show = undefined;
      this._showSubscription = undefined;
      this._definitionChanged = new Event();

      this.merge(defaultValue(options, defaultValue.EMPTY_OBJECT));
    };

    defineProperties(ConicSensorGraphics.prototype, {
      /**
       * Gets the event that is raised whenever a new property is assigned.
       * @memberof ConicSensorGraphics.prototype
       *
       * @type {Event}
       * @readonly
       */
      definitionChanged: {
        get: function () {
          return this._definitionChanged;
        },
      },

      /**
       * Gets or sets the numeric {@link Property} specifying the the cone's minimum clock angle.
       * @memberof ConicSensorGraphics.prototype
       * @type {Property}
       */
      minimumClockAngle: createPropertyDescriptor("minimumClockAngle"),

      /**
       * Gets or sets the numeric {@link Property} specifying the the cone's maximum clock angle.
       * @memberof ConicSensorGraphics.prototype
       * @type {Property}
       */
      maximumClockAngle: createPropertyDescriptor("maximumClockAngle"),

      /**
       * Gets or sets the numeric {@link Property} specifying the the cone's inner half-angle.
       * @memberof ConicSensorGraphics.prototype
       * @type {Property}
       */
      innerHalfAngle: createPropertyDescriptor("innerHalfAngle"),

      /**
       * Gets or sets the numeric {@link Property} specifying the the cone's outer half-angle.
       * @memberof ConicSensorGraphics.prototype
       * @type {Property}
       */
      outerHalfAngle: createPropertyDescriptor("outerHalfAngle"),

      /**
       * Gets or sets the {@link MaterialProperty} specifying the the cone's appearance.
       * @memberof ConicSensorGraphics.prototype
       * @type {MaterialProperty}
       */
      lateralSurfaceMaterial: createMaterialPropertyDescriptor(
        "lateralSurfaceMaterial"
      ),

      /**
       * Gets or sets the {@link Color} {@link Property} specifying the color of the line formed by the intersection of the cone and other central bodies.
       * @memberof ConicSensorGraphics.prototype
       * @type {Property}
       */
      intersectionColor: createPropertyDescriptor("intersectionColor"),

      /**
       * Gets or sets the numeric {@link Property} specifying the width of the line formed by the intersection of the cone and other central bodies.
       * @memberof ConicSensorGraphics.prototype
       * @type {Property}
       */
      intersectionWidth: createPropertyDescriptor("intersectionWidth"),

      /**
       * Gets or sets the boolean {@link Property} specifying the visibility of the line formed by the intersection of the cone and other central bodies.
       * @memberof ConicSensorGraphics.prototype
       * @type {Property}
       */
      showIntersection: createPropertyDescriptor("showIntersection"),

      /**
       * Gets or sets the numeric {@link Property} specifying the radius of the cone's projection.
       * @memberof ConicSensorGraphics.prototype
       * @type {Property}
       */
      radius: createPropertyDescriptor("radius"),

      /**
       * Gets or sets the boolean {@link Property} specifying the visibility of the cone.
       * @memberof ConicSensorGraphics.prototype
       * @type {Property}
       */
      show: createPropertyDescriptor("show"),
    });

    /**
     * Duplicates a ConicSensorGraphics instance.
     *
     * @param {ConicSensorGraphics} [result] The object onto which to store the result.
     * @returns {ConicSensorGraphics} The modified result parameter or a new instance if one was not provided.
     */
    ConicSensorGraphics.prototype.clone = function (result) {
      if (!defined(result)) {
        result = new ConicSensorGraphics();
      }
      result.show = this.show;
      result.innerHalfAngle = this.innerHalfAngle;
      result.outerHalfAngle = this.outerHalfAngle;
      result.minimumClockAngle = this.minimumClockAngle;
      result.maximumClockAngle = this.maximumClockAngle;
      result.radius = this.radius;
      result.showIntersection = this.showIntersection;
      result.intersectionColor = this.intersectionColor;
      result.intersectionWidth = this.intersectionWidth;
      result.lateralSurfaceMaterial = this.lateralSurfaceMaterial;
      return result;
    };

    /**
     * Assigns each unassigned property on this object to the value
     * of the same property on the provided source object.
     *
     * @param {ConicSensorGraphics} source The object to be merged into this object.
     */
    ConicSensorGraphics.prototype.merge = function (source) {
      // >>includeStart('debug', pragmas.debug);
      if (!defined(source)) {
        throw new DeveloperError("source is required.");
      }
      // >>includeEnd('debug');

      this.show = defaultValue(this.show, source.show);
      this.innerHalfAngle = defaultValue(
        this.innerHalfAngle,
        source.innerHalfAngle
      );
      this.outerHalfAngle = defaultValue(
        this.outerHalfAngle,
        source.outerHalfAngle
      );
      this.minimumClockAngle = defaultValue(
        this.minimumClockAngle,
        source.minimumClockAngle
      );
      this.maximumClockAngle = defaultValue(
        this.maximumClockAngle,
        source.maximumClockAngle
      );
      this.radius = defaultValue(this.radius, source.radius);
      this.showIntersection = defaultValue(
        this.showIntersection,
        source.showIntersection
      );
      this.intersectionColor = defaultValue(
        this.intersectionColor,
        source.intersectionColor
      );
      this.intersectionWidth = defaultValue(
        this.intersectionWidth,
        source.intersectionWidth
      );
      this.lateralSurfaceMaterial = defaultValue(
        this.lateralSurfaceMaterial,
        source.lateralSurfaceMaterial
      );
    };

    return ConicSensorGraphics;
  });

  define("text", {
    load: function (id) {
      throw new Error("Dynamic load not allowed: " + id);
    },
  });

  define("text!custom/custom-sensor-volume-fs.glsl", [], function () {
    return "#ifdef GL_OES_standard_derivatives\n#extension GL_OES_standard_derivatives : enable\n#endif\nuniform bool u_showIntersection;\nuniform bool u_showThroughEllipsoid;\nuniform float u_sensorRadius;\nuniform float u_normalDirection;\nvarying vec3 v_positionWC;\nvarying vec3 v_positionEC;\nvarying vec3 v_normalEC;\nvec4 getColor(float sensorRadius, vec3 pointEC)\n{\nczm_materialInput materialInput;\nvec3 pointMC = (czm_inverseModelView * vec4(pointEC, 1.0)).xyz;\nmaterialInput.st = sensor2dTextureCoordinates(sensorRadius, pointMC);\nmaterialInput.str = pointMC / sensorRadius;\nvec3 positionToEyeEC = -v_positionEC;\nmaterialInput.positionToEyeEC = positionToEyeEC;\nvec3 normalEC = normalize(v_normalEC);\nmaterialInput.normalEC = u_normalDirection * normalEC;\nczm_material material = czm_getMaterial(materialInput);\nreturn mix(czm_phong(normalize(positionToEyeEC), material, czm_lightDirectionEC), vec4(material.diffuse, material.alpha), 0.4);\n}\nbool isOnBoundary(float value, float epsilon)\n{\nfloat width = getIntersectionWidth();\nfloat tolerance = width * epsilon;\n#ifdef GL_OES_standard_derivatives\nfloat delta = max(abs(dFdx(value)), abs(dFdy(value)));\nfloat pixels = width * delta;\nfloat temp = abs(value);\nreturn temp < tolerance && temp < pixels || (delta < 10.0 * tolerance && temp - delta < tolerance && temp < pixels);\n#else\nreturn abs(value) < tolerance;\n#endif\n}\nvec4 shade(bool isOnBoundary)\n{\nif (u_showIntersection && isOnBoundary)\n{\nreturn getIntersectionColor();\n}\nreturn getColor(u_sensorRadius, v_positionEC);\n}\nfloat ellipsoidSurfaceFunction( vec3 point)\n{\nvec3 scaled = czm_ellipsoidInverseRadii * point;\nreturn dot(scaled, scaled) - 1.0;\n}\nvoid main()\n{\nvec3 sensorVertexWC = czm_model[3].xyz;\nvec3 sensorVertexEC = czm_modelView[3].xyz;\nfloat ellipsoidValue = ellipsoidSurfaceFunction( v_positionWC);\nif (!u_showThroughEllipsoid)\n{\nif (ellipsoidValue < 0.0)\n{\ndiscard;\n}\nif (inSensorShadow(sensorVertexWC, v_positionWC))\n{\ndiscard;\n}\n}\nif (distance(v_positionEC, sensorVertexEC) > u_sensorRadius)\n{\ndiscard;\n}\nbool isOnEllipsoid = isOnBoundary(ellipsoidValue, czm_epsilon3);\ngl_FragColor = shade(isOnEllipsoid);\n}";
  });

  define("text!custom/custom-sensor-volume-vs.glsl", [], function () {
    return "attribute vec4 position;\nattribute vec3 normal;\nvarying vec3 v_positionWC;\nvarying vec3 v_positionEC;\nvarying vec3 v_normalEC;\nvoid main()\n{\ngl_Position = czm_modelViewProjection * position;\nv_positionWC = (czm_model * position).xyz;\nv_positionEC = (czm_modelView * position).xyz;\nv_normalEC = czm_normal * normal;\n}";
  });

  define("text!sensor-volume.glsl", [], function () {
    return "uniform vec4 u_intersectionColor;\nuniform float u_intersectionWidth;\nbool inSensorShadow(vec3 coneVertexWC, vec3 pointWC)\n{\nvec3 D = czm_ellipsoidInverseRadii;\nvec3 q = D * coneVertexWC;\nfloat qMagnitudeSquared = dot(q, q);\nfloat test = qMagnitudeSquared - 1.0;\nvec3 temp = D * pointWC - q;\nfloat d = dot(temp, q);\nreturn (d < -test) && (d / length(temp) < -sqrt(test));\n}\nvec4 getIntersectionColor()\n{\nreturn u_intersectionColor;\n}\nfloat getIntersectionWidth()\n{\nreturn u_intersectionWidth;\n}\nvec2 sensor2dTextureCoordinates(float sensorRadius, vec3 pointMC)\n{\nfloat t = pointMC.z / sensorRadius;\nfloat s = 1.0 + (atan(pointMC.y, pointMC.x) / czm_twoPi);\ns = s - floor(s);\nreturn vec2(s, t);\n}";
  });

  define("custom/custom-sensor-volume", [
    "require",
    "Cesium/Core/BoundingSphere",
    "Cesium/Core/Cartesian3",
    "Cesium/Core/Color",
    "Cesium/Core/combine",
    "Cesium/Core/ComponentDatatype",
    "Cesium/Core/defaultValue",
    "Cesium/Core/defined",
    "Cesium/Core/destroyObject",
    "Cesium/Core/DeveloperError",
    "Cesium/Core/Matrix4",
    "Cesium/Core/PrimitiveType",
    "Cesium/Renderer/Buffer",
    "Cesium/Renderer/BufferUsage",
    "Cesium/Renderer/DrawCommand",
    "Cesium/Renderer/Pass",
    "Cesium/Renderer/RenderState",
    "Cesium/Renderer/ShaderProgram",
    "Cesium/Renderer/ShaderSource",
    "Cesium/Renderer/VertexArray",
    "Cesium/Scene/BlendingState",
    "Cesium/Scene/CullFace",
    "Cesium/Scene/Material",
    "Cesium/Scene/SceneMode",
    "text!./custom-sensor-volume-fs.glsl",
    "text!./custom-sensor-volume-vs.glsl",
    "text!../sensor-volume.glsl",
  ], function (require) {
    "use strict";

    var BoundingSphere = require("Cesium/Core/BoundingSphere");
    var Cartesian3 = require("Cesium/Core/Cartesian3");
    var Color = require("Cesium/Core/Color");
    var combine = require("Cesium/Core/combine");
    var ComponentDatatype = require("Cesium/Core/ComponentDatatype");
    var defaultValue = require("Cesium/Core/defaultValue");
    var defined = require("Cesium/Core/defined");
    var defineProperties = Object.defineProperties;
    var destroyObject = require("Cesium/Core/destroyObject");
    var DeveloperError = require("Cesium/Core/DeveloperError");
    var Matrix4 = require("Cesium/Core/Matrix4");
    var PrimitiveType = require("Cesium/Core/PrimitiveType");
    var Buffer = require("Cesium/Renderer/Buffer");
    var BufferUsage = require("Cesium/Renderer/BufferUsage");
    var DrawCommand = require("Cesium/Renderer/DrawCommand");
    var Pass = require("Cesium/Renderer/Pass");
    var RenderState = require("Cesium/Renderer/RenderState");
    var ShaderProgram = require("Cesium/Renderer/ShaderProgram");
    var ShaderSource = require("Cesium/Renderer/ShaderSource");
    var VertexArray = require("Cesium/Renderer/VertexArray");
    var BlendingState = require("Cesium/Scene/BlendingState");
    var CullFace = require("Cesium/Scene/CullFace");
    var Material = require("Cesium/Scene/Material");
    var SceneMode = require("Cesium/Scene/SceneMode");

    var CustomSensorVolumeFS = require("text!./custom-sensor-volume-fs.glsl");
    var CustomSensorVolumeVS = require("text!./custom-sensor-volume-vs.glsl");
    var SensorVolume = require("text!../sensor-volume.glsl");

    var attributeLocations = {
      position: 0,
      normal: 1,
    };

    var FAR = 5906376272000.0; // distance from the Sun to Pluto in meters.

    /**
     * DOC_TBA
     *
     * @alias CustomSensorVolume
     * @constructor
     */
    var CustomSensorVolume = function (options) {
      options = defaultValue(options, defaultValue.EMPTY_OBJECT);

      this._pickId = undefined;
      this._pickPrimitive = defaultValue(options._pickPrimitive, this);

      this._frontFaceColorCommand = new DrawCommand();
      this._backFaceColorCommand = new DrawCommand();
      this._pickCommand = new DrawCommand();

      this._boundingSphere = new BoundingSphere();
      this._boundingSphereWC = new BoundingSphere();

      this._frontFaceColorCommand.primitiveType = PrimitiveType.TRIANGLES;
      this._frontFaceColorCommand.boundingVolume = this._boundingSphereWC;
      this._frontFaceColorCommand.owner = this;

      this._backFaceColorCommand.primitiveType =
        this._frontFaceColorCommand.primitiveType;
      this._backFaceColorCommand.boundingVolume =
        this._frontFaceColorCommand.boundingVolume;
      this._backFaceColorCommand.owner = this;

      this._pickCommand.primitiveType =
        this._frontFaceColorCommand.primitiveType;
      this._pickCommand.boundingVolume =
        this._frontFaceColorCommand.boundingVolume;
      this._pickCommand.owner = this;

      /**
       * <code>true</code> if this sensor will be shown; otherwise, <code>false</code>
       *
       * @type {Boolean}
       * @default true
       */
      this.show = defaultValue(options.show, true);

      /**
       * When <code>true</code>, a polyline is shown where the sensor outline intersections the globe.
       *
       * @type {Boolean}
       *
       * @default true
       *
       * @see CustomSensorVolume#intersectionColor
       */
      this.showIntersection = defaultValue(options.showIntersection, true);

      /**
       * <p>
       * Determines if a sensor intersecting the ellipsoid is drawn through the ellipsoid and potentially out
       * to the other side, or if the part of the sensor intersecting the ellipsoid stops at the ellipsoid.
       * </p>
       *
       * @type {Boolean}
       * @default false
       */
      this.showThroughEllipsoid = defaultValue(
        options.showThroughEllipsoid,
        false
      );
      this._showThroughEllipsoid = this.showThroughEllipsoid;

      /**
       * The 4x4 transformation matrix that transforms this sensor from model to world coordinates.  In it's model
       * coordinates, the sensor's principal direction is along the positive z-axis.  The clock angle, sometimes
       * called azimuth, is the angle in the sensor's X-Y plane measured from the positive X-axis toward the positive
       * Y-axis.  The cone angle, sometimes called elevation, is the angle out of the X-Y plane along the positive Z-axis.
       * <br /><br />
       * <div align='center'>
       * <img src='images/CustomSensorVolume.setModelMatrix.png' /><br />
       * Model coordinate system for a custom sensor
       * </div>
       *
       * @type {Matrix4}
       * @default {@link Matrix4.IDENTITY}
       *
       * @example
       * // The sensor's vertex is located on the surface at -75.59777 degrees longitude and 40.03883 degrees latitude.
       * // The sensor's opens upward, along the surface normal.
       * var center = Cesium.Cartesian3.fromDegrees(-75.59777, 40.03883);
       * sensor.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(center);
       */
      this.modelMatrix = Matrix4.clone(
        defaultValue(options.modelMatrix, Matrix4.IDENTITY)
      );
      this._modelMatrix = new Matrix4();

      /**
       * DOC_TBA
       *
       * @type {Number}
       * @default {@link Number.POSITIVE_INFINITY}
       */
      this.radius = defaultValue(options.radius, Number.POSITIVE_INFINITY);

      this._directions = undefined;
      this._directionsDirty = false;
      this.directions = defined(options.directions) ? options.directions : [];

      /**
       * The surface appearance of the sensor.  This can be one of several built-in {@link Material} objects or a custom material, scripted with
       * {@link https://github.com/AnalyticalGraphicsInc/cesium/wiki/Fabric|Fabric}.
       * <p>
       * The default material is <code>Material.ColorType</code>.
       * </p>
       *
       * @type {Material}
       * @default Material.fromType(Material.ColorType)
       *
       * @see {@link https://github.com/AnalyticalGraphicsInc/cesium/wiki/Fabric|Fabric}
       *
       * @example
       * // 1. Change the color of the default material to yellow
       * sensor.lateralSurfaceMaterial.uniforms.color = new Cesium.Color(1.0, 1.0, 0.0, 1.0);
       *
       * // 2. Change material to horizontal stripes
       * sensor.lateralSurfaceMaterial = Cesium.Material.fromType(Material.StripeType);
       */
      this.lateralSurfaceMaterial = defined(options.lateralSurfaceMaterial)
        ? options.lateralSurfaceMaterial
        : Material.fromType(Material.ColorType);
      this._lateralSurfaceMaterial = undefined;
      this._translucent = undefined;

      /**
       * The color of the polyline where the sensor outline intersects the globe.  The default is {@link Color.WHITE}.
       *
       * @type {Color}
       * @default {@link Color.WHITE}
       *
       * @see CustomSensorVolume#showIntersection
       */
      this.intersectionColor = Color.clone(
        defaultValue(options.intersectionColor, Color.WHITE)
      );

      /**
       * The approximate pixel width of the polyline where the sensor outline intersects the globe.  The default is 5.0.
       *
       * @type {Number}
       * @default 5.0
       *
       * @see CustomSensorVolume#showIntersection
       */
      this.intersectionWidth = defaultValue(options.intersectionWidth, 5.0);

      /**
       * User-defined object returned when the sensors is picked.
       *
       * @type Object
       *
       * @default undefined
       *
       * @see Scene#pick
       */
      this.id = options.id;
      this._id = undefined;

      var that = this;

      /* eslint-disable camelcase */
      this._uniforms = {
        u_showThroughEllipsoid: function () {
          return that.showThroughEllipsoid;
        },
        u_showIntersection: function () {
          return that.showIntersection;
        },
        u_sensorRadius: function () {
          return isFinite(that.radius) ? that.radius : FAR;
        },
        u_intersectionColor: function () {
          return that.intersectionColor;
        },
        u_intersectionWidth: function () {
          return that.intersectionWidth;
        },
        u_normalDirection: function () {
          return 1.0;
        },
      };
      /* eslint-enable camelcase */

      this._mode = SceneMode.SCENE3D;
    };

    defineProperties(CustomSensorVolume.prototype, {
      directions: {
        get: function () {
          return this._directions;
        },
        set: function (value) {
          this._directions = value;
          this._directionsDirty = true;
        },
      },
    });

    var n0Scratch = new Cartesian3();
    var n1Scratch = new Cartesian3();
    var n2Scratch = new Cartesian3();
    function computePositions(customSensorVolume) {
      var directions = customSensorVolume._directions;
      var length = directions.length;
      var positions = new Float32Array(3 * length);
      var r = isFinite(customSensorVolume.radius)
        ? customSensorVolume.radius
        : FAR;

      var boundingVolumePositions = [Cartesian3.ZERO];

      for (
        var i = length - 2, j = length - 1, k = 0;
        k < length;
        i = j++, j = k++
      ) {
        // PERFORMANCE_IDEA:  We can avoid redundant operations for adjacent edges.
        var n0 = Cartesian3.fromSpherical(directions[i], n0Scratch);
        var n1 = Cartesian3.fromSpherical(directions[j], n1Scratch);
        var n2 = Cartesian3.fromSpherical(directions[k], n2Scratch);

        // Extend position so the volume encompasses the sensor's radius.
        var theta = Math.max(
          Cartesian3.angleBetween(n0, n1),
          Cartesian3.angleBetween(n1, n2)
        );
        var distance = r / Math.cos(theta * 0.5);
        var p = Cartesian3.multiplyByScalar(n1, distance, new Cartesian3());

        positions[j * 3] = p.x;
        positions[j * 3 + 1] = p.y;
        positions[j * 3 + 2] = p.z;

        boundingVolumePositions.push(p);
      }

      BoundingSphere.fromPoints(
        boundingVolumePositions,
        customSensorVolume._boundingSphere
      );

      return positions;
    }

    var nScratch = new Cartesian3();
    function createVertexArray(customSensorVolume, context) {
      var positions = computePositions(customSensorVolume);

      var length = customSensorVolume._directions.length;
      var vertices = new Float32Array(2 * 3 * 3 * length);

      var k = 0;
      for (var i = length - 1, j = 0; j < length; i = j++) {
        var p0 = new Cartesian3(
          positions[i * 3],
          positions[i * 3 + 1],
          positions[i * 3 + 2]
        );
        var p1 = new Cartesian3(
          positions[j * 3],
          positions[j * 3 + 1],
          positions[j * 3 + 2]
        );
        var n = Cartesian3.normalize(
          Cartesian3.cross(p1, p0, nScratch),
          nScratch
        ); // Per-face normals

        vertices[k++] = 0.0; // Sensor vertex
        vertices[k++] = 0.0;
        vertices[k++] = 0.0;
        vertices[k++] = n.x;
        vertices[k++] = n.y;
        vertices[k++] = n.z;

        vertices[k++] = p1.x;
        vertices[k++] = p1.y;
        vertices[k++] = p1.z;
        vertices[k++] = n.x;
        vertices[k++] = n.y;
        vertices[k++] = n.z;

        vertices[k++] = p0.x;
        vertices[k++] = p0.y;
        vertices[k++] = p0.z;
        vertices[k++] = n.x;
        vertices[k++] = n.y;
        vertices[k++] = n.z;
      }

      var vertexBuffer = Buffer.createVertexBuffer({
        context: context,
        typedArray: new Float32Array(vertices),
        usage: BufferUsage.STATIC_DRAW,
      });

      var stride = 2 * 3 * Float32Array.BYTES_PER_ELEMENT;

      var attributes = [
        {
          index: attributeLocations.position,
          vertexBuffer: vertexBuffer,
          componentsPerAttribute: 3,
          componentDatatype: ComponentDatatype.FLOAT,
          offsetInBytes: 0,
          strideInBytes: stride,
        },
        {
          index: attributeLocations.normal,
          vertexBuffer: vertexBuffer,
          componentsPerAttribute: 3,
          componentDatatype: ComponentDatatype.FLOAT,
          offsetInBytes: 3 * Float32Array.BYTES_PER_ELEMENT,
          strideInBytes: stride,
        },
      ];

      return new VertexArray({
        context: context,
        attributes: attributes,
      });
    }

    /**
     * Called when {@link Viewer} or {@link CesiumWidget} render the scene to
     * get the draw commands needed to render this primitive.
     * <p>
     * Do not call this function directly.  This is documented just to
     * list the exceptions that may be propagated when the scene is rendered:
     * </p>
     *
     * @exception {DeveloperError} this.radius must be greater than or equal to zero.
     * @exception {DeveloperError} this.lateralSurfaceMaterial must be defined.
     */
    CustomSensorVolume.prototype.update = function (frameState) {
      this._mode = frameState.mode;
      if (!this.show || this._mode !== SceneMode.SCENE3D) {
        return;
      }

      var context = frameState.context;
      var commandList = frameState.commandList;

      // >>includeStart('debug', pragmas.debug);
      if (this.radius < 0.0) {
        throw new DeveloperError(
          "this.radius must be greater than or equal to zero."
        );
      }
      if (!defined(this.lateralSurfaceMaterial)) {
        throw new DeveloperError(
          "this.lateralSurfaceMaterial must be defined."
        );
      }
      // >>includeEnd('debug');

      var translucent = this.lateralSurfaceMaterial.isTranslucent();

      // Initial render state creation
      if (
        this._showThroughEllipsoid !== this.showThroughEllipsoid ||
        !defined(this._frontFaceColorCommand.renderState) ||
        this._translucent !== translucent
      ) {
        this._showThroughEllipsoid = this.showThroughEllipsoid;
        this._translucent = translucent;

        var rs;

        if (translucent) {
          rs = RenderState.fromCache({
            depthTest: {
              // This would be better served by depth testing with a depth buffer that does not
              // include the ellipsoid depth - or a g-buffer containing an ellipsoid mask
              // so we can selectively depth test.
              enabled: !this.showThroughEllipsoid,
            },
            depthMask: false,
            blending: BlendingState.ALPHA_BLEND,
            cull: {
              enabled: true,
              face: CullFace.BACK,
            },
          });

          this._frontFaceColorCommand.renderState = rs;
          this._frontFaceColorCommand.pass = Pass.TRANSLUCENT;

          rs = RenderState.fromCache({
            depthTest: {
              enabled: !this.showThroughEllipsoid,
            },
            depthMask: false,
            blending: BlendingState.ALPHA_BLEND,
            cull: {
              enabled: true,
              face: CullFace.FRONT,
            },
          });

          this._backFaceColorCommand.renderState = rs;
          this._backFaceColorCommand.pass = Pass.TRANSLUCENT;

          rs = RenderState.fromCache({
            depthTest: {
              enabled: !this.showThroughEllipsoid,
            },
            depthMask: false,
            blending: BlendingState.ALPHA_BLEND,
          });
          this._pickCommand.renderState = rs;
        } else {
          rs = RenderState.fromCache({
            depthTest: {
              enabled: true,
            },
            depthMask: true,
          });
          this._frontFaceColorCommand.renderState = rs;
          this._frontFaceColorCommand.pass = Pass.OPAQUE;

          rs = RenderState.fromCache({
            depthTest: {
              enabled: true,
            },
            depthMask: true,
          });
          this._pickCommand.renderState = rs;
        }
      }

      // Recreate vertex buffer when directions change
      var directionsChanged = this._directionsDirty;
      if (directionsChanged) {
        this._directionsDirty = false;
        this._va = this._va && this._va.destroy();

        var directions = this._directions;
        if (directions && directions.length >= 3) {
          this._frontFaceColorCommand.vertexArray = createVertexArray(
            this,
            context
          );
          this._backFaceColorCommand.vertexArray =
            this._frontFaceColorCommand.vertexArray;
          this._pickCommand.vertexArray =
            this._frontFaceColorCommand.vertexArray;
        }
      }

      if (!defined(this._frontFaceColorCommand.vertexArray)) {
        return;
      }

      var pass = frameState.passes;

      var modelMatrixChanged = !Matrix4.equals(
        this.modelMatrix,
        this._modelMatrix
      );
      if (modelMatrixChanged) {
        Matrix4.clone(this.modelMatrix, this._modelMatrix);
      }

      if (directionsChanged || modelMatrixChanged) {
        BoundingSphere.transform(
          this._boundingSphere,
          this.modelMatrix,
          this._boundingSphereWC
        );
      }

      this._frontFaceColorCommand.modelMatrix = this.modelMatrix;
      this._backFaceColorCommand.modelMatrix =
        this._frontFaceColorCommand.modelMatrix;
      this._pickCommand.modelMatrix = this._frontFaceColorCommand.modelMatrix;

      var materialChanged =
        this._lateralSurfaceMaterial !== this.lateralSurfaceMaterial;
      this._lateralSurfaceMaterial = this.lateralSurfaceMaterial;
      this._lateralSurfaceMaterial.update(context);

      if (pass.render) {
        var frontFaceColorCommand = this._frontFaceColorCommand;
        var backFaceColorCommand = this._backFaceColorCommand;

        // Recompile shader when material changes
        if (materialChanged || !defined(frontFaceColorCommand.shaderProgram)) {
          var fsSource = new ShaderSource({
            sources: [
              SensorVolume,
              this._lateralSurfaceMaterial.shaderSource,
              CustomSensorVolumeFS,
            ],
          });

          frontFaceColorCommand.shaderProgram = ShaderProgram.replaceCache({
            context: context,
            shaderProgram: frontFaceColorCommand.shaderProgram,
            vertexShaderSource: CustomSensorVolumeVS,
            fragmentShaderSource: fsSource,
            attributeLocations: attributeLocations,
          });

          frontFaceColorCommand.uniformMap = combine(
            this._uniforms,
            this._lateralSurfaceMaterial._uniforms
          );

          backFaceColorCommand.shaderProgram =
            frontFaceColorCommand.shaderProgram;
          backFaceColorCommand.uniformMap = combine(
            this._uniforms,
            this._lateralSurfaceMaterial._uniforms
          );
          // eslint-disable-next-line camelcase
          backFaceColorCommand.uniformMap.u_normalDirection = function () {
            return -1.0;
          };
        }

        if (translucent) {
          commandList.push(
            this._backFaceColorCommand,
            this._frontFaceColorCommand
          );
        } else {
          commandList.push(this._frontFaceColorCommand);
        }
      }

      if (pass.pick) {
        var pickCommand = this._pickCommand;

        if (!defined(this._pickId) || this._id !== this.id) {
          this._id = this.id;
          this._pickId = this._pickId && this._pickId.destroy();
          this._pickId = context.createPickId({
            primitive: this._pickPrimitive,
            id: this.id,
          });
        }

        // Recompile shader when material changes
        if (materialChanged || !defined(pickCommand.shaderProgram)) {
          var pickFS = new ShaderSource({
            sources: [
              SensorVolume,
              this._lateralSurfaceMaterial.shaderSource,
              CustomSensorVolumeFS,
            ],
            pickColorQualifier: "uniform",
          });

          pickCommand.shaderProgram = ShaderProgram.replaceCache({
            context: context,
            shaderProgram: pickCommand.shaderProgram,
            vertexShaderSource: CustomSensorVolumeVS,
            fragmentShaderSource: pickFS,
            attributeLocations: attributeLocations,
          });

          var that = this;
          var uniforms = {
            // eslint-disable-next-line camelcase
            czm_pickColor: function () {
              return that._pickId.color;
            },
          };
          pickCommand.uniformMap = combine(
            combine(this._uniforms, this._lateralSurfaceMaterial._uniforms),
            uniforms
          );
        }

        pickCommand.pass = translucent ? Pass.TRANSLUCENT : Pass.OPAQUE;
        commandList.push(pickCommand);
      }
    };

    /**
     * DOC_TBA
     */
    CustomSensorVolume.prototype.isDestroyed = function () {
      return false;
    };

    /**
     * DOC_TBA
     */
    CustomSensorVolume.prototype.destroy = function () {
      this._frontFaceColorCommand.vertexArray =
        this._frontFaceColorCommand.vertexArray &&
        this._frontFaceColorCommand.vertexArray.destroy();
      this._frontFaceColorCommand.shaderProgram =
        this._frontFaceColorCommand.shaderProgram &&
        this._frontFaceColorCommand.shaderProgram.destroy();
      this._pickCommand.shaderProgram =
        this._pickCommand.shaderProgram &&
        this._pickCommand.shaderProgram.destroy();
      this._pickId = this._pickId && this._pickId.destroy();
      return destroyObject(this);
    };

    return CustomSensorVolume;
  });

  define("util/remove-primitive", ["require", "Cesium/Core/defined"], function (
    require
  ) {
    "use strict";

    var defined = require("Cesium/Core/defined");

    return function removePrimitive(entity, hash, primitives) {
      var data = hash[entity.id];
      if (defined(data)) {
        var primitive = data.primitive;
        primitives.remove(primitive);
        if (!primitive.isDestroyed()) {
          primitive.destroy();
        }
        delete hash[entity.id];
      }
    };
  });

  define("conic/conic-sensor-visualizer", [
    "require",
    "Cesium/Core/AssociativeArray",
    "Cesium/Core/Cartesian3",
    "Cesium/Core/Color",
    "Cesium/Core/defined",
    "Cesium/Core/destroyObject",
    "Cesium/Core/DeveloperError",
    "Cesium/Core/Math",
    "Cesium/Core/Matrix3",
    "Cesium/Core/Matrix4",
    "Cesium/Core/Quaternion",
    "Cesium/Core/Spherical",
    "Cesium/DataSources/MaterialProperty",
    "Cesium/DataSources/Property",
    "../custom/custom-sensor-volume",
    "../util/remove-primitive",
  ], function (require) {
    "use strict";

    var AssociativeArray = require("Cesium/Core/AssociativeArray");
    var Cartesian3 = require("Cesium/Core/Cartesian3");
    var Color = require("Cesium/Core/Color");
    var defined = require("Cesium/Core/defined");
    var destroyObject = require("Cesium/Core/destroyObject");
    var DeveloperError = require("Cesium/Core/DeveloperError");
    var CesiumMath = require("Cesium/Core/Math");
    var Matrix3 = require("Cesium/Core/Matrix3");
    var Matrix4 = require("Cesium/Core/Matrix4");
    var Quaternion = require("Cesium/Core/Quaternion");
    var Spherical = require("Cesium/Core/Spherical");
    var MaterialProperty = require("Cesium/DataSources/MaterialProperty");
    var Property = require("Cesium/DataSources/Property");

    var CustomSensorVolume = require("../custom/custom-sensor-volume");
    var removePrimitive = require("../util/remove-primitive");

    var defaultIntersectionColor = Color.WHITE;
    var defaultIntersectionWidth = 1.0;
    var defaultRadius = Number.POSITIVE_INFINITY;

    var matrix3Scratch = new Matrix3();
    var cachedPosition = new Cartesian3();
    var cachedOrientation = new Quaternion();

    function assignSpherical(index, array, clock, cone) {
      var spherical = array[index];
      if (!defined(spherical)) {
        spherical = new Spherical();
        array[index] = spherical;
      }
      spherical.clock = clock;
      spherical.cone = cone;
      spherical.magnitude = 1.0;
    }

    function computeDirections(
      primitive,
      minimumClockAngle,
      maximumClockAngle,
      innerHalfAngle,
      outerHalfAngle
    ) {
      var directions = primitive.directions;
      var angle;
      var i = 0;
      var angleStep = CesiumMath.toRadians(2.0);
      if (
        minimumClockAngle === 0.0 &&
        maximumClockAngle === CesiumMath.TWO_PI
      ) {
        // No clock angle limits, so this is just a circle.
        // There might be a hole but we're ignoring it for now.
        for (angle = 0.0; angle < CesiumMath.TWO_PI; angle += angleStep) {
          assignSpherical(i++, directions, angle, outerHalfAngle);
        }
      } else {
        // There are clock angle limits.
        for (
          angle = minimumClockAngle;
          angle < maximumClockAngle;
          angle += angleStep
        ) {
          assignSpherical(i++, directions, angle, outerHalfAngle);
        }
        assignSpherical(i++, directions, maximumClockAngle, outerHalfAngle);
        if (innerHalfAngle) {
          for (
            angle = maximumClockAngle;
            angle > minimumClockAngle;
            angle -= angleStep
          ) {
            assignSpherical(i++, directions, angle, innerHalfAngle);
          }
          assignSpherical(i++, directions, minimumClockAngle, innerHalfAngle);
        } else {
          assignSpherical(i++, directions, maximumClockAngle, 0.0);
        }
      }
      directions.length = i;
      primitive.directions = directions;
    }

    /**
     * A {@link Visualizer} which maps {@link Entity#conicSensor} to a {@link ConicSensor}.
     * @alias ConicSensorVisualizer
     * @constructor
     *
     * @param {Scene} scene The scene the primitives will be rendered in.
     * @param {EntityCollection} entityCollection The entityCollection to visualize.
     */
    var ConicSensorVisualizer = function (scene, entityCollection) {
      // >>includeStart('debug', pragmas.debug);
      if (!defined(scene)) {
        throw new DeveloperError("scene is required.");
      }
      if (!defined(entityCollection)) {
        throw new DeveloperError("entityCollection is required.");
      }
      // >>includeEnd('debug');

      entityCollection.collectionChanged.addEventListener(
        ConicSensorVisualizer.prototype._onCollectionChanged,
        this
      );

      this._scene = scene;
      this._primitives = scene.primitives;
      this._entityCollection = entityCollection;
      this._hash = {};
      this._entitiesToVisualize = new AssociativeArray();

      this._onCollectionChanged(
        entityCollection,
        entityCollection.values,
        [],
        []
      );
    };

    /**
     * Updates the primitives created by this visualizer to match their
     * Entity counterpart at the given time.
     *
     * @param {JulianDate} time The time to update to.
     * @returns {Boolean} This function always returns true.
     */
    ConicSensorVisualizer.prototype.update = function (time) {
      // >>includeStart('debug', pragmas.debug);
      if (!defined(time)) {
        throw new DeveloperError("time is required.");
      }
      // >>includeEnd('debug');

      var entities = this._entitiesToVisualize.values;
      var hash = this._hash;
      var primitives = this._primitives;

      for (var i = 0, len = entities.length; i < len; i++) {
        var entity = entities[i];
        var conicSensorGraphics = entity._conicSensor;

        var position;
        var orientation;
        var data = hash[entity.id];
        var show =
          entity.isShowing &&
          entity.isAvailable(time) &&
          Property.getValueOrDefault(conicSensorGraphics._show, time, true);

        if (show) {
          position = Property.getValueOrUndefined(
            entity._position,
            time,
            cachedPosition
          );
          orientation = Property.getValueOrUndefined(
            entity._orientation,
            time,
            cachedOrientation
          );
          show = defined(position) && defined(orientation);
        }

        if (!show) {
          // don't bother creating or updating anything else
          if (defined(data)) {
            data.primitive.show = false;
          }
          continue;
        }

        var primitive = defined(data) ? data.primitive : undefined;
        if (!defined(primitive)) {
          primitive = new CustomSensorVolume();
          primitive.id = entity;
          primitives.add(primitive);

          data = {
            primitive: primitive,
            position: undefined,
            orientation: undefined,
            minimumClockAngle: undefined,
            maximumClockAngle: undefined,
            innerHalfAngle: undefined,
            outerHalfAngle: undefined,
          };
          hash[entity.id] = data;
        }

        if (
          !Cartesian3.equals(position, data.position) ||
          !Quaternion.equals(orientation, data.orientation)
        ) {
          Matrix4.fromRotationTranslation(
            Matrix3.fromQuaternion(orientation, matrix3Scratch),
            position,
            primitive.modelMatrix
          );
          data.position = Cartesian3.clone(position, data.position);
          data.orientation = Quaternion.clone(orientation, data.orientation);
        }

        primitive.show = true;
        var minimumClockAngle = Property.getValueOrDefault(
          conicSensorGraphics._minimumClockAngle,
          time,
          0
        );
        var maximumClockAngle = Property.getValueOrDefault(
          conicSensorGraphics._maximumClockAngle,
          time,
          CesiumMath.TWO_PI
        );
        var innerHalfAngle = Property.getValueOrDefault(
          conicSensorGraphics._innerHalfAngle,
          time,
          0
        );
        var outerHalfAngle = Property.getValueOrDefault(
          conicSensorGraphics._outerHalfAngle,
          time,
          Math.PI
        );

        if (
          minimumClockAngle !== data.minimumClockAngle ||
          maximumClockAngle !== data.maximumClockAngle ||
          innerHalfAngle !== data.innerHalfAngle ||
          outerHalfAngle !== data.outerHalfAngle
        ) {
          computeDirections(
            primitive,
            minimumClockAngle,
            maximumClockAngle,
            innerHalfAngle,
            outerHalfAngle
          );
          data.innerHalfAngle = innerHalfAngle;
          data.maximumClockAngle = maximumClockAngle;
          data.outerHalfAngle = outerHalfAngle;
          data.minimumClockAngle = minimumClockAngle;
        }

        primitive.radius = Property.getValueOrDefault(
          conicSensorGraphics._radius,
          time,
          defaultRadius
        );
        primitive.lateralSurfaceMaterial = MaterialProperty.getValue(
          time,
          conicSensorGraphics._lateralSurfaceMaterial,
          primitive.lateralSurfaceMaterial
        );
        primitive.intersectionColor = Property.getValueOrClonedDefault(
          conicSensorGraphics._intersectionColor,
          time,
          defaultIntersectionColor,
          primitive.intersectionColor
        );
        primitive.intersectionWidth = Property.getValueOrDefault(
          conicSensorGraphics._intersectionWidth,
          time,
          defaultIntersectionWidth
        );
      }
      return true;
    };

    /**
     * Returns true if this object was destroyed; otherwise, false.
     *
     * @returns {Boolean} True if this object was destroyed; otherwise, false.
     */
    ConicSensorVisualizer.prototype.isDestroyed = function () {
      return false;
    };

    /**
     * Removes and destroys all primitives created by this instance.
     */
    ConicSensorVisualizer.prototype.destroy = function () {
      var entities = this._entitiesToVisualize.values;
      var hash = this._hash;
      var primitives = this._primitives;
      for (var i = entities.length - 1; i > -1; i--) {
        removePrimitive(entities[i], hash, primitives);
      }
      return destroyObject(this);
    };

    /**
     * @private
     */
    ConicSensorVisualizer.prototype._onCollectionChanged = function (
      entityCollection,
      added,
      removed,
      changed
    ) {
      var i;
      var entity;
      var entities = this._entitiesToVisualize;
      var hash = this._hash;
      var primitives = this._primitives;

      for (i = added.length - 1; i > -1; i--) {
        entity = added[i];
        if (
          defined(entity._conicSensor) &&
          defined(entity._position) &&
          defined(entity._orientation)
        ) {
          entities.set(entity.id, entity);
        }
      }

      for (i = changed.length - 1; i > -1; i--) {
        entity = changed[i];
        if (
          defined(entity._conicSensor) &&
          defined(entity._position) &&
          defined(entity._orientation)
        ) {
          entities.set(entity.id, entity);
        } else {
          removePrimitive(entity, hash, primitives);
          entities.remove(entity.id);
        }
      }

      for (i = removed.length - 1; i > -1; i--) {
        entity = removed[i];
        removePrimitive(entity, hash, primitives);
        entities.remove(entity.id);
      }
    };

    return ConicSensorVisualizer;
  });

  define("custom/custom-pattern-sensor-graphics", [
    "require",
    "Cesium/Core/defaultValue",
    "Cesium/Core/defined",
    "Cesium/Core/DeveloperError",
    "Cesium/Core/Event",
    "Cesium/DataSources/createMaterialPropertyDescriptor",
    "Cesium/DataSources/createPropertyDescriptor",
  ], function (require) {
    "use strict";

    var defaultValue = require("Cesium/Core/defaultValue");
    var defined = require("Cesium/Core/defined");
    var defineProperties = Object.defineProperties;
    var DeveloperError = require("Cesium/Core/DeveloperError");
    var Event = require("Cesium/Core/Event");

    var createMaterialPropertyDescriptor = require("Cesium/DataSources/createMaterialPropertyDescriptor");
    var createPropertyDescriptor = require("Cesium/DataSources/createPropertyDescriptor");

    /**
     * An optionally time-dynamic custom patterned sensor.
     *
     * @alias CustomPatternSensorGraphics
     * @constructor
     */
    var CustomPatternSensorGraphics = function (options) {
      this._directions = undefined;
      this._directionsSubscription = undefined;

      this._lateralSurfaceMaterial = undefined;
      this._lateralSurfaceMaterialSubscription = undefined;

      this._intersectionColor = undefined;
      this._intersectionColorSubscription = undefined;
      this._intersectionWidth = undefined;
      this._intersectionWidthSubscription = undefined;
      this._showIntersection = undefined;
      this._showIntersectionSubscription = undefined;
      this._radius = undefined;
      this._radiusSubscription = undefined;
      this._show = undefined;
      this._showSubscription = undefined;
      this._definitionChanged = new Event();

      this.merge(defaultValue(options, defaultValue.EMPTY_OBJECT));
    };

    defineProperties(CustomPatternSensorGraphics.prototype, {
      /**
       * Gets the event that is raised whenever a new property is assigned.
       * @memberof CustomPatternSensorGraphics.prototype
       *
       * @type {Event}
       * @readonly
       */
      definitionChanged: {
        get: function () {
          return this._definitionChanged;
        },
      },

      /**
       * A {@link Property} which returns an array of {@link Spherical} instances representing the sensor's projection.
       * @memberof CustomPatternSensorGraphics.prototype
       * @type {Property}
       */
      directions: createPropertyDescriptor("directions"),

      /**
       * Gets or sets the {@link MaterialProperty} specifying the the sensor's appearance.
       * @memberof CustomPatternSensorGraphics.prototype
       * @type {MaterialProperty}
       */
      lateralSurfaceMaterial: createMaterialPropertyDescriptor(
        "lateralSurfaceMaterial"
      ),

      /**
       * Gets or sets the {@link Color} {@link Property} specifying the color of the line formed by the intersection of the sensor and other central bodies.
       * @memberof CustomPatternSensorGraphics.prototype
       * @type {Property}
       */
      intersectionColor: createPropertyDescriptor("intersectionColor"),

      /**
       * Gets or sets the numeric {@link Property} specifying the width of the line formed by the intersection of the sensor and other central bodies.
       * @memberof CustomPatternSensorGraphics.prototype
       * @type {Property}
       */
      intersectionWidth: createPropertyDescriptor("intersectionWidth"),

      /**
       * Gets or sets the boolean {@link Property} specifying the visibility of the line formed by the intersection of the sensor and other central bodies.
       * @memberof CustomPatternSensorGraphics.prototype
       * @type {Property}
       */
      showIntersection: createPropertyDescriptor("showIntersection"),

      /**
       * Gets or sets the numeric {@link Property} specifying the radius of the sensor's projection.
       * @memberof CustomPatternSensorGraphics.prototype
       * @type {Property}
       */
      radius: createPropertyDescriptor("radius"),

      /**
       * Gets or sets the boolean {@link Property} specifying the visibility of the sensor.
       * @memberof CustomPatternSensorGraphics.prototype
       * @type {Property}
       */
      show: createPropertyDescriptor("show"),
    });

    /**
     * Duplicates a CustomPatternSensorGraphics instance.
     *
     * @param {CustomPatternSensorGraphics} [result] The object onto which to store the result.
     * @returns {CustomPatternSensorGraphics} The modified result parameter or a new instance if one was not provided.
     */
    CustomPatternSensorGraphics.prototype.clone = function (result) {
      if (!defined(result)) {
        result = new CustomPatternSensorGraphics();
      }
      result.directions = this.directions;
      result.radius = this.radius;
      result.show = this.show;
      result.showIntersection = this.showIntersection;
      result.intersectionColor = this.intersectionColor;
      result.intersectionWidth = this.intersectionWidth;
      result.lateralSurfaceMaterial = this.lateralSurfaceMaterial;
      return result;
    };

    /**
     * Assigns each unassigned property on this object to the value
     * of the same property on the provided source object.
     *
     * @param {CustomPatternSensorGraphics} source The object to be merged into this object.
     */
    CustomPatternSensorGraphics.prototype.merge = function (source) {
      // >>includeStart('debug', pragmas.debug);
      if (!defined(source)) {
        throw new DeveloperError("source is required.");
      }
      // >>includeEnd('debug');

      this.directions = defaultValue(this.directions, source.directions);
      this.radius = defaultValue(this.radius, source.radius);
      this.show = defaultValue(this.show, source.show);
      this.showIntersection = defaultValue(
        this.showIntersection,
        source.showIntersection
      );
      this.intersectionColor = defaultValue(
        this.intersectionColor,
        source.intersectionColor
      );
      this.intersectionWidth = defaultValue(
        this.intersectionWidth,
        source.intersectionWidth
      );
      this.lateralSurfaceMaterial = defaultValue(
        this.lateralSurfaceMaterial,
        source.lateralSurfaceMaterial
      );
    };

    return CustomPatternSensorGraphics;
  });

  define("custom/custom-pattern-sensor-visualizer", [
    "require",
    "Cesium/Core/AssociativeArray",
    "Cesium/Core/Cartesian3",
    "Cesium/Core/Color",
    "Cesium/Core/defined",
    "Cesium/Core/destroyObject",
    "Cesium/Core/DeveloperError",
    "Cesium/Core/Matrix3",
    "Cesium/Core/Matrix4",
    "Cesium/Core/Quaternion",
    "Cesium/DataSources/MaterialProperty",
    "Cesium/DataSources/Property",
    "../custom/custom-sensor-volume",
    "../util/remove-primitive",
  ], function (require) {
    "use strict";

    var AssociativeArray = require("Cesium/Core/AssociativeArray");
    var Cartesian3 = require("Cesium/Core/Cartesian3");
    var Color = require("Cesium/Core/Color");
    var defined = require("Cesium/Core/defined");
    var destroyObject = require("Cesium/Core/destroyObject");
    var DeveloperError = require("Cesium/Core/DeveloperError");
    var Matrix3 = require("Cesium/Core/Matrix3");
    var Matrix4 = require("Cesium/Core/Matrix4");
    var Quaternion = require("Cesium/Core/Quaternion");
    var MaterialProperty = require("Cesium/DataSources/MaterialProperty");
    var Property = require("Cesium/DataSources/Property");

    var CustomSensorVolume = require("../custom/custom-sensor-volume");
    var removePrimitive = require("../util/remove-primitive");

    var defaultIntersectionColor = Color.WHITE;
    var defaultIntersectionWidth = 1.0;
    var defaultRadius = Number.POSITIVE_INFINITY;

    var matrix3Scratch = new Matrix3();
    var cachedPosition = new Cartesian3();
    var cachedOrientation = new Quaternion();

    /**
     * A {@link Visualizer} which maps {@link Entity#customPatternSensor} to a {@link CustomPatternSensor}.
     * @alias CustomPatternSensorVisualizer
     * @constructor
     *
     * @param {Scene} scene The scene the primitives will be rendered in.
     * @param {EntityCollection} entityCollection The entityCollection to visualize.
     */
    var CustomPatternSensorVisualizer = function (scene, entityCollection) {
      // >>includeStart('debug', pragmas.debug);
      if (!defined(scene)) {
        throw new DeveloperError("scene is required.");
      }
      if (!defined(entityCollection)) {
        throw new DeveloperError("entityCollection is required.");
      }
      // >>includeEnd('debug');

      entityCollection.collectionChanged.addEventListener(
        CustomPatternSensorVisualizer.prototype._onCollectionChanged,
        this
      );

      this._scene = scene;
      this._primitives = scene.primitives;
      this._entityCollection = entityCollection;
      this._hash = {};
      this._entitiesToVisualize = new AssociativeArray();

      this._onCollectionChanged(
        entityCollection,
        entityCollection.values,
        [],
        []
      );
    };

    /**
     * Updates the primitives created by this visualizer to match their
     * Entity counterpart at the given time.
     *
     * @param {JulianDate} time The time to update to.
     * @returns {Boolean} This function always returns true.
     */
    CustomPatternSensorVisualizer.prototype.update = function (time) {
      // >>includeStart('debug', pragmas.debug);
      if (!defined(time)) {
        throw new DeveloperError("time is required.");
      }
      // >>includeEnd('debug');

      var entities = this._entitiesToVisualize.values;
      var hash = this._hash;
      var primitives = this._primitives;

      for (var i = 0, len = entities.length; i < len; i++) {
        var entity = entities[i];
        var customPatternSensorGraphics = entity._customPatternSensor;

        var position;
        var orientation;
        var directions;
        var data = hash[entity.id];
        var show =
          entity.isShowing &&
          entity.isAvailable(time) &&
          Property.getValueOrDefault(
            customPatternSensorGraphics._show,
            time,
            true
          );

        if (show) {
          position = Property.getValueOrUndefined(
            entity._position,
            time,
            cachedPosition
          );
          orientation = Property.getValueOrUndefined(
            entity._orientation,
            time,
            cachedOrientation
          );
          directions = Property.getValueOrUndefined(
            customPatternSensorGraphics._directions,
            time
          );
          show =
            defined(position) && defined(orientation) && defined(directions);
        }

        if (!show) {
          // don't bother creating or updating anything else
          if (defined(data)) {
            data.primitive.show = false;
          }
          continue;
        }

        var primitive = defined(data) ? data.primitive : undefined;
        if (!defined(primitive)) {
          primitive = new CustomSensorVolume();
          primitive.id = entity;
          primitives.add(primitive);

          data = {
            primitive: primitive,
            position: undefined,
            orientation: undefined,
          };
          hash[entity.id] = data;
        }

        if (
          !Cartesian3.equals(position, data.position) ||
          !Quaternion.equals(orientation, data.orientation)
        ) {
          Matrix4.fromRotationTranslation(
            Matrix3.fromQuaternion(orientation, matrix3Scratch),
            position,
            primitive.modelMatrix
          );
          data.position = Cartesian3.clone(position, data.position);
          data.orientation = Quaternion.clone(orientation, data.orientation);
        }

        primitive.show = true;
        primitive.directions = directions;
        primitive.radius = Property.getValueOrDefault(
          customPatternSensorGraphics._radius,
          time,
          defaultRadius
        );
        primitive.lateralSurfaceMaterial = MaterialProperty.getValue(
          time,
          customPatternSensorGraphics._lateralSurfaceMaterial,
          primitive.lateralSurfaceMaterial
        );
        primitive.intersectionColor = Property.getValueOrClonedDefault(
          customPatternSensorGraphics._intersectionColor,
          time,
          defaultIntersectionColor,
          primitive.intersectionColor
        );
        primitive.intersectionWidth = Property.getValueOrDefault(
          customPatternSensorGraphics._intersectionWidth,
          time,
          defaultIntersectionWidth
        );
      }
      return true;
    };

    /**
     * Returns true if this object was destroyed; otherwise, false.
     *
     * @returns {Boolean} True if this object was destroyed; otherwise, false.
     */
    CustomPatternSensorVisualizer.prototype.isDestroyed = function () {
      return false;
    };

    /**
     * Removes and destroys all primitives created by this instance.
     */
    CustomPatternSensorVisualizer.prototype.destroy = function () {
      var entities = this._entitiesToVisualize.values;
      var hash = this._hash;
      var primitives = this._primitives;
      for (var i = entities.length - 1; i > -1; i--) {
        removePrimitive(entities[i], hash, primitives);
      }
      return destroyObject(this);
    };

    /**
     * @private
     */
    CustomPatternSensorVisualizer.prototype._onCollectionChanged = function (
      entityCollection,
      added,
      removed,
      changed
    ) {
      var i;
      var entity;
      var entities = this._entitiesToVisualize;
      var hash = this._hash;
      var primitives = this._primitives;

      for (i = added.length - 1; i > -1; i--) {
        entity = added[i];
        if (
          defined(entity._customPatternSensor) &&
          defined(entity._position) &&
          defined(entity._orientation)
        ) {
          entities.set(entity.id, entity);
        }
      }

      for (i = changed.length - 1; i > -1; i--) {
        entity = changed[i];
        if (
          defined(entity._customPatternSensor) &&
          defined(entity._position) &&
          defined(entity._orientation)
        ) {
          entities.set(entity.id, entity);
        } else {
          removePrimitive(entity, hash, primitives);
          entities.remove(entity.id);
        }
      }

      for (i = removed.length - 1; i > -1; i--) {
        entity = removed[i];
        removePrimitive(entity, hash, primitives);
        entities.remove(entity.id);
      }
    };

    return CustomPatternSensorVisualizer;
  });

  define("rectangular/rectangular-sensor-graphics", [
    "require",
    "Cesium/Core/defaultValue",
    "Cesium/Core/defined",
    "Cesium/Core/DeveloperError",
    "Cesium/Core/Event",
    "Cesium/DataSources/createPropertyDescriptor",
  ], function (require) {
    "use strict";

    var defaultValue = require("Cesium/Core/defaultValue");
    var defined = require("Cesium/Core/defined");
    var defineProperties = Object.defineProperties;
    var DeveloperError = require("Cesium/Core/DeveloperError");
    var Event = require("Cesium/Core/Event");

    var createPropertyDescriptor = require("Cesium/DataSources/createPropertyDescriptor");

    /**
     * An optionally time-dynamic pyramid.
     *
     * @alias RectangularSensorGraphics
     * @constructor
     */
    var RectangularSensorGraphics = function () {
      this._xHalfAngle = undefined;
      this._xHalfAngleSubscription = undefined;
      this._yHalfAngle = undefined;
      this._yHalfAngleSubscription = undefined;

      this._lateralSurfaceMaterial = undefined;
      this._lateralSurfaceMaterialSubscription = undefined;

      this._intersectionColor = undefined;
      this._intersectionColorSubscription = undefined;
      this._intersectionWidth = undefined;
      this._intersectionWidthSubscription = undefined;
      this._showIntersection = undefined;
      this._showIntersectionSubscription = undefined;
      this._radius = undefined;
      this._radiusSubscription = undefined;
      this._show = undefined;
      this._showSubscription = undefined;
      this._definitionChanged = new Event();
    };

    defineProperties(RectangularSensorGraphics.prototype, {
      /**
       * Gets the event that is raised whenever a new property is assigned.
       * @memberof RectangularSensorGraphics.prototype
       *
       * @type {Event}
       * @readonly
       */
      definitionChanged: {
        get: function () {
          return this._definitionChanged;
        },
      },

      /**
       * A {@link Property} which returns an array of {@link Spherical} instances representing the pyramid's projection.
       * @memberof RectangularSensorGraphics.prototype
       * @type {Property}
       */
      xHalfAngle: createPropertyDescriptor("xHalfAngle"),

      /**
       * A {@link Property} which returns an array of {@link Spherical} instances representing the pyramid's projection.
       * @memberof RectangularSensorGraphics.prototype
       * @type {Property}
       */
      yHalfAngle: createPropertyDescriptor("yHalfAngle"),

      /**
       * Gets or sets the {@link MaterialProperty} specifying the the pyramid's appearance.
       * @memberof RectangularSensorGraphics.prototype
       * @type {MaterialProperty}
       */
      lateralSurfaceMaterial: createPropertyDescriptor(
        "lateralSurfaceMaterial"
      ),

      /**
       * Gets or sets the {@link Color} {@link Property} specifying the color of the line formed by the intersection of the pyramid and other central bodies.
       * @memberof RectangularSensorGraphics.prototype
       * @type {Property}
       */
      intersectionColor: createPropertyDescriptor("intersectionColor"),

      /**
       * Gets or sets the numeric {@link Property} specifying the width of the line formed by the intersection of the pyramid and other central bodies.
       * @memberof RectangularSensorGraphics.prototype
       * @type {Property}
       */
      intersectionWidth: createPropertyDescriptor("intersectionWidth"),

      /**
       * Gets or sets the boolean {@link Property} specifying the visibility of the line formed by the intersection of the pyramid and other central bodies.
       * @memberof RectangularSensorGraphics.prototype
       * @type {Property}
       */
      showIntersection: createPropertyDescriptor("showIntersection"),

      /**
       * Gets or sets the numeric {@link Property} specifying the radius of the pyramid's projection.
       * @memberof RectangularSensorGraphics.prototype
       * @type {Property}
       */
      radius: createPropertyDescriptor("radius"),

      /**
       * Gets or sets the boolean {@link Property} specifying the visibility of the pyramid.
       * @memberof RectangularSensorGraphics.prototype
       * @type {Property}
       */
      show: createPropertyDescriptor("show"),
    });

    /**
     * Duplicates a RectangularSensorGraphics instance.
     *
     * @param {RectangularSensorGraphics} [result] The object onto which to store the result.
     * @returns {RectangularSensorGraphics} The modified result parameter or a new instance if one was not provided.
     */
    RectangularSensorGraphics.prototype.clone = function (result) {
      if (!defined(result)) {
        result = new RectangularSensorGraphics();
      }
      result.xHalfAngle = this.xHalfAngle;
      result.yHalfAngle = this.yHalfAngle;
      result.radius = this.radius;
      result.show = this.show;
      result.showIntersection = this.showIntersection;
      result.intersectionColor = this.intersectionColor;
      result.intersectionWidth = this.intersectionWidth;
      result.lateralSurfaceMaterial = this.lateralSurfaceMaterial;
      return result;
    };

    /**
     * Assigns each unassigned property on this object to the value
     * of the same property on the provided source object.
     *
     * @param {RectangularSensorGraphics} source The object to be merged into this object.
     */
    RectangularSensorGraphics.prototype.merge = function (source) {
      // >>includeStart('debug', pragmas.debug);
      if (!defined(source)) {
        throw new DeveloperError("source is required.");
      }
      // >>includeEnd('debug');

      this.xHalfAngle = defaultValue(this.xHalfAngle, source.xHalfAngle);
      this.yHalfAngle = defaultValue(this.yHalfAngle, source.yHalfAngle);
      this.radius = defaultValue(this.radius, source.radius);
      this.show = defaultValue(this.show, source.show);
      this.showIntersection = defaultValue(
        this.showIntersection,
        source.showIntersection
      );
      this.intersectionColor = defaultValue(
        this.intersectionColor,
        source.intersectionColor
      );
      this.intersectionWidth = defaultValue(
        this.intersectionWidth,
        source.intersectionWidth
      );
      this.lateralSurfaceMaterial = defaultValue(
        this.lateralSurfaceMaterial,
        source.lateralSurfaceMaterial
      );
    };

    return RectangularSensorGraphics;
  });

  define("rectangular/rectangular-pyramid-sensor-volume", [
    "require",
    "Cesium/Core/clone",
    "Cesium/Core/defaultValue",
    "Cesium/Core/defined",
    "Cesium/Core/destroyObject",
    "Cesium/Core/DeveloperError",
    "Cesium/Core/Math",
    "Cesium/Core/Spherical",
    "../custom/custom-sensor-volume",
  ], function (require) {
    "use strict";

    var clone = require("Cesium/Core/clone");
    var defaultValue = require("Cesium/Core/defaultValue");
    var defined = require("Cesium/Core/defined");
    var defineProperties = Object.defineProperties;
    var destroyObject = require("Cesium/Core/destroyObject");
    var DeveloperError = require("Cesium/Core/DeveloperError");
    var CesiumMath = require("Cesium/Core/Math");
    var Spherical = require("Cesium/Core/Spherical");

    var CustomSensorVolume = require("../custom/custom-sensor-volume");

    function assignSpherical(index, array, clock, cone) {
      var spherical = array[index];
      if (!defined(spherical)) {
        spherical = new Spherical();
        array[index] = spherical;
      }
      spherical.clock = clock;
      spherical.cone = cone;
      spherical.magnitude = 1.0;
    }

    function updateDirections(rectangularSensor) {
      var directions = rectangularSensor._customSensor.directions;

      // At 90 degrees the sensor is completely open, and tan() goes to infinity.
      var tanX = Math.tan(
        Math.min(rectangularSensor._xHalfAngle, CesiumMath.toRadians(89.0))
      );
      var tanY = Math.tan(
        Math.min(rectangularSensor._yHalfAngle, CesiumMath.toRadians(89.0))
      );
      var theta = Math.atan(tanX / tanY);
      var cone = Math.atan(Math.sqrt(tanX * tanX + tanY * tanY));

      assignSpherical(0, directions, theta, cone);
      assignSpherical(1, directions, CesiumMath.toRadians(180.0) - theta, cone);
      assignSpherical(2, directions, CesiumMath.toRadians(180.0) + theta, cone);
      assignSpherical(3, directions, -theta, cone);

      directions.length = 4;
      rectangularSensor._customSensor.directions = directions;
    }

    var RectangularPyramidSensorVolume = function (options) {
      options = defaultValue(options, defaultValue.EMPTY_OBJECT);

      var customSensorOptions = clone(options);
      customSensorOptions._pickPrimitive = defaultValue(
        options._pickPrimitive,
        this
      );
      customSensorOptions.directions = undefined;
      this._customSensor = new CustomSensorVolume(customSensorOptions);

      this._xHalfAngle = defaultValue(
        options.xHalfAngle,
        CesiumMath.PI_OVER_TWO
      );
      this._yHalfAngle = defaultValue(
        options.yHalfAngle,
        CesiumMath.PI_OVER_TWO
      );

      updateDirections(this);
    };

    defineProperties(RectangularPyramidSensorVolume.prototype, {
      xHalfAngle: {
        get: function () {
          return this._xHalfAngle;
        },
        set: function (value) {
          // >>includeStart('debug', pragmas.debug)
          if (value > CesiumMath.PI_OVER_TWO) {
            throw new DeveloperError(
              "xHalfAngle must be less than or equal to 90 degrees."
            );
          }
          // >>includeEnd('debug');

          if (this._xHalfAngle !== value) {
            this._xHalfAngle = value;
            updateDirections(this);
          }
        },
      },
      yHalfAngle: {
        get: function () {
          return this._yHalfAngle;
        },
        set: function (value) {
          // >>includeStart('debug', pragmas.debug)
          if (value > CesiumMath.PI_OVER_TWO) {
            throw new DeveloperError(
              "yHalfAngle must be less than or equal to 90 degrees."
            );
          }
          // >>includeEnd('debug');

          if (this._yHalfAngle !== value) {
            this._yHalfAngle = value;
            updateDirections(this);
          }
        },
      },
      show: {
        get: function () {
          return this._customSensor.show;
        },
        set: function (value) {
          this._customSensor.show = value;
        },
      },
      showIntersection: {
        get: function () {
          return this._customSensor.showIntersection;
        },
        set: function (value) {
          this._customSensor.showIntersection = value;
        },
      },
      showThroughEllipsoid: {
        get: function () {
          return this._customSensor.showThroughEllipsoid;
        },
        set: function (value) {
          this._customSensor.showThroughEllipsoid = value;
        },
      },
      modelMatrix: {
        get: function () {
          return this._customSensor.modelMatrix;
        },
        set: function (value) {
          this._customSensor.modelMatrix = value;
        },
      },
      radius: {
        get: function () {
          return this._customSensor.radius;
        },
        set: function (value) {
          this._customSensor.radius = value;
        },
      },
      lateralSurfaceMaterial: {
        get: function () {
          return this._customSensor.lateralSurfaceMaterial;
        },
        set: function (value) {
          this._customSensor.lateralSurfaceMaterial = value;
        },
      },
      intersectionColor: {
        get: function () {
          return this._customSensor.intersectionColor;
        },
        set: function (value) {
          this._customSensor.intersectionColor = value;
        },
      },
      intersectionWidth: {
        get: function () {
          return this._customSensor.intersectionWidth;
        },
        set: function (value) {
          this._customSensor.intersectionWidth = value;
        },
      },
      id: {
        get: function () {
          return this._customSensor.id;
        },
        set: function (value) {
          this._customSensor.id = value;
        },
      },
    });

    RectangularPyramidSensorVolume.prototype.update = function (frameState) {
      this._customSensor.update(frameState);
    };

    RectangularPyramidSensorVolume.prototype.isDestroyed = function () {
      return false;
    };

    RectangularPyramidSensorVolume.prototype.destroy = function () {
      this._customSensor = this._customSensor && this._customSensor.destroy();
      return destroyObject(this);
    };

    return RectangularPyramidSensorVolume;
  });

  define("rectangular/rectangular-sensor-visualizer", [
    "require",
    "Cesium/Core/AssociativeArray",
    "Cesium/Core/Cartesian3",
    "Cesium/Core/Color",
    "Cesium/Core/defined",
    "Cesium/Core/destroyObject",
    "Cesium/Core/DeveloperError",
    "Cesium/Core/Math",
    "Cesium/Core/Matrix3",
    "Cesium/Core/Matrix4",
    "Cesium/Core/Quaternion",
    "Cesium/DataSources/MaterialProperty",
    "Cesium/DataSources/Property",
    "./rectangular-pyramid-sensor-volume",
    "../util/remove-primitive",
  ], function (require) {
    "use strict";

    var AssociativeArray = require("Cesium/Core/AssociativeArray");
    var Cartesian3 = require("Cesium/Core/Cartesian3");
    var Color = require("Cesium/Core/Color");
    var defined = require("Cesium/Core/defined");
    var destroyObject = require("Cesium/Core/destroyObject");
    var DeveloperError = require("Cesium/Core/DeveloperError");
    var CesiumMath = require("Cesium/Core/Math");
    var Matrix3 = require("Cesium/Core/Matrix3");
    var Matrix4 = require("Cesium/Core/Matrix4");
    var Quaternion = require("Cesium/Core/Quaternion");
    var MaterialProperty = require("Cesium/DataSources/MaterialProperty");
    var Property = require("Cesium/DataSources/Property");

    var RectangularPyramidSensorVolume = require("./rectangular-pyramid-sensor-volume");
    var removePrimitive = require("../util/remove-primitive");

    var defaultIntersectionColor = Color.WHITE;
    var defaultIntersectionWidth = 1.0;
    var defaultRadius = Number.POSITIVE_INFINITY;

    var matrix3Scratch = new Matrix3();
    var cachedPosition = new Cartesian3();
    var cachedOrientation = new Quaternion();

    /**
     * A {@link Visualizer} which maps {@link Entity#rectangularSensor} to a {@link RectangularSensor}.
     * @alias RectangularSensorVisualizer
     * @constructor
     *
     * @param {Scene} scene The scene the primitives will be rendered in.
     * @param {EntityCollection} entityCollection The entityCollection to visualize.
     */
    var RectangularSensorVisualizer = function (scene, entityCollection) {
      // >>includeStart('debug', pragmas.debug);
      if (!defined(scene)) {
        throw new DeveloperError("scene is required.");
      }
      if (!defined(entityCollection)) {
        throw new DeveloperError("entityCollection is required.");
      }
      // >>includeEnd('debug');

      entityCollection.collectionChanged.addEventListener(
        RectangularSensorVisualizer.prototype._onCollectionChanged,
        this
      );

      this._scene = scene;
      this._primitives = scene.primitives;
      this._entityCollection = entityCollection;
      this._hash = {};
      this._entitiesToVisualize = new AssociativeArray();

      this._onCollectionChanged(
        entityCollection,
        entityCollection.values,
        [],
        []
      );
    };

    /**
     * Updates the primitives created by this visualizer to match their
     * Entity counterpart at the given time.
     *
     * @param {JulianDate} time The time to update to.
     * @returns {Boolean} This function always returns true.
     */
    RectangularSensorVisualizer.prototype.update = function (time) {
      // >>includeStart('debug', pragmas.debug);
      if (!defined(time)) {
        throw new DeveloperError("time is required.");
      }
      // >>includeEnd('debug');

      var entities = this._entitiesToVisualize.values;
      var hash = this._hash;
      var primitives = this._primitives;

      for (var i = 0, len = entities.length; i < len; i++) {
        var entity = entities[i];
        var rectangularSensorGraphics = entity._rectangularSensorVoumes;

        var position;
        var orientation;
        var data = hash[entity.id];
        var show =
          entity.isShowing &&
          entity.isAvailable(time) &&
          Property.getValueOrDefault(
            rectangularSensorGraphics._show,
            time,
            true
          );

        if (show) {
          position = Property.getValueOrUndefined(
            entity._position,
            time,
            cachedPosition
          );
          orientation = Property.getValueOrUndefined(
            entity._orientation,
            time,
            cachedOrientation
          );
          show = defined(position) && defined(orientation);
        }

        if (!show) {
          // don't bother creating or updating anything else
          if (defined(data)) {
            data.primitive.show = false;
          }
          continue;
        }

        var primitive = defined(data) ? data.primitive : undefined;
        if (!defined(primitive)) {
          primitive = new RectangularPyramidSensorVolume();
          primitive.id = entity;
          primitives.add(primitive);

          data = {
            primitive: primitive,
            position: undefined,
            orientation: undefined,
          };
          hash[entity.id] = data;
        }

        if (
          !Cartesian3.equals(position, data.position) ||
          !Quaternion.equals(orientation, data.orientation)
        ) {
          Matrix4.fromRotationTranslation(
            Matrix3.fromQuaternion(orientation, matrix3Scratch),
            position,
            primitive.modelMatrix
          );
          data.position = Cartesian3.clone(position, data.position);
          data.orientation = Quaternion.clone(orientation, data.orientation);
        }

        primitive.show = true;
        primitive.xHalfAngle = Property.getValueOrDefault(
          rectangularSensorGraphics._xHalfAngle,
          time,
          CesiumMath.PI_OVER_TWO
        );
        primitive.yHalfAngle = Property.getValueOrDefault(
          rectangularSensorGraphics._yHalfAngle,
          time,
          CesiumMath.PI_OVER_TWO
        );
        primitive.radius = Property.getValueOrDefault(
          rectangularSensorGraphics._radius,
          time,
          defaultRadius
        );
        primitive.lateralSurfaceMaterial = MaterialProperty.getValue(
          time,
          rectangularSensorGraphics._lateralSurfaceMaterial,
          primitive.lateralSurfaceMaterial
        );
        primitive.intersectionColor = Property.getValueOrClonedDefault(
          rectangularSensorGraphics._intersectionColor,
          time,
          defaultIntersectionColor,
          primitive.intersectionColor
        );
        primitive.intersectionWidth = Property.getValueOrDefault(
          rectangularSensorGraphics._intersectionWidth,
          time,
          defaultIntersectionWidth
        );
      }
      return true;
    };

    /**
     * Returns true if this object was destroyed; otherwise, false.
     *
     * @returns {Boolean} True if this object was destroyed; otherwise, false.
     */
    RectangularSensorVisualizer.prototype.isDestroyed = function () {
      return false;
    };

    /**
     * Removes and destroys all primitives created by this instance.
     */
    RectangularSensorVisualizer.prototype.destroy = function () {
      var entities = this._entitiesToVisualize.values;
      var hash = this._hash;
      var primitives = this._primitives;
      for (var i = entities.length - 1; i > -1; i--) {
        removePrimitive(entities[i], hash, primitives);
      }
      return destroyObject(this);
    };

    /**
     * @private
     */
    RectangularSensorVisualizer.prototype._onCollectionChanged = function (
      entityCollection,
      added,
      removed,
      changed
    ) {
      var i;
      var entity;
      var entities = this._entitiesToVisualize;
      var hash = this._hash;
      var primitives = this._primitives;

      for (i = added.length - 1; i > -1; i--) {
        entity = added[i];
        if (
          defined(entity._rectangularSensorVoumes) &&
          defined(entity._position) &&
          defined(entity._orientation)
        ) {
          entities.set(entity.id, entity);
        }
      }

      for (i = changed.length - 1; i > -1; i--) {
        entity = changed[i];
        if (
          defined(entity._rectangularSensorVoumes) &&
          defined(entity._position) &&
          defined(entity._orientation)
        ) {
          entities.set(entity.id, entity);
        } else {
          removePrimitive(entity, hash, primitives);
          entities.remove(entity.id);
        }
      }

      for (i = removed.length - 1; i > -1; i--) {
        entity = removed[i];
        removePrimitive(entity, hash, primitives);
        entities.remove(entity.id);
      }
    };

    return RectangularSensorVisualizer;
  });

  define("initialize", [
    "require",
    "Cesium/Core/Cartesian3",
    "Cesium/Core/Color",
    "Cesium/Core/defined",
    "Cesium/Core/Spherical",
    "Cesium/Core/TimeInterval",
    "Cesium/DataSources/CzmlDataSource",
    "Cesium/DataSources/DataSourceDisplay",
    "./conic/conic-sensor-graphics",
    "./conic/conic-sensor-visualizer",
    "./custom/custom-pattern-sensor-graphics",
    "./custom/custom-pattern-sensor-visualizer",
    "./rectangular/rectangular-sensor-graphics",
    "./rectangular/rectangular-sensor-visualizer",
  ], function (require) {
    "use strict";

    var Cartesian3 = require("Cesium/Core/Cartesian3");
    var Color = require("Cesium/Core/Color");
    var defined = require("Cesium/Core/defined");
    var Spherical = require("Cesium/Core/Spherical");
    var TimeInterval = require("Cesium/Core/TimeInterval");

    var CzmlDataSource = require("Cesium/DataSources/CzmlDataSource");
    var DataSourceDisplay = require("Cesium/DataSources/DataSourceDisplay");

    var ConicSensorGraphics = require("./conic/conic-sensor-graphics");
    var ConicSensorVisualizer = require("./conic/conic-sensor-visualizer");
    var CustomPatternSensorGraphics = require("./custom/custom-pattern-sensor-graphics");
    var CustomPatternSensorVisualizer = require("./custom/custom-pattern-sensor-visualizer");
    var RectangularSensorGraphics = require("./rectangular/rectangular-sensor-graphics");
    var RectangularSensorVisualizer = require("./rectangular/rectangular-sensor-visualizer");

    var processPacketData = CzmlDataSource.processPacketData;
    var processMaterialPacketData = CzmlDataSource.processMaterialPacketData;

    function processDirectionData(
      customPatternSensor,
      directions,
      interval,
      sourceUri,
      entityCollection
    ) {
      var i;
      var len;
      var values = [];
      var unitSphericals = directions.unitSpherical;
      var sphericals = directions.spherical;
      var unitCartesians = directions.unitCartesian;
      var cartesians = directions.cartesian;

      if (defined(unitSphericals)) {
        for (i = 0, len = unitSphericals.length; i < len; i += 2) {
          values.push(new Spherical(unitSphericals[i], unitSphericals[i + 1]));
        }
        directions.array = values;
      } else if (defined(sphericals)) {
        for (i = 0, len = sphericals.length; i < len; i += 3) {
          values.push(
            new Spherical(sphericals[i], sphericals[i + 1], sphericals[i + 2])
          );
        }
        directions.array = values;
      } else if (defined(unitCartesians)) {
        for (i = 0, len = unitCartesians.length; i < len; i += 3) {
          var tmp = Spherical.fromCartesian3(
            new Cartesian3(
              unitCartesians[i],
              unitCartesians[i + 1],
              unitCartesians[i + 2]
            )
          );
          Spherical.normalize(tmp, tmp);
          values.push(tmp);
        }
        directions.array = values;
      } else if (defined(cartesians)) {
        for (i = 0, len = cartesians.length; i < len; i += 3) {
          values.push(
            Spherical.fromCartesian3(
              new Cartesian3(
                cartesians[i],
                cartesians[i + 1],
                cartesians[i + 2]
              )
            )
          );
        }
        directions.array = values;
      }
      processPacketData(
        Array,
        customPatternSensor,
        "directions",
        directions,
        interval,
        sourceUri,
        entityCollection
      );
    }

    function processCommonSensorProperties(
      sensor,
      sensorData,
      interval,
      sourceUri,
      entityCollection
    ) {
      processPacketData(
        Boolean,
        sensor,
        "show",
        sensorData.show,
        interval,
        sourceUri,
        entityCollection
      );
      processPacketData(
        Number,
        sensor,
        "radius",
        sensorData.radius,
        interval,
        sourceUri,
        entityCollection
      );
      processPacketData(
        Boolean,
        sensor,
        "showIntersection",
        sensorData.showIntersection,
        interval,
        sourceUri,
        entityCollection
      );
      processPacketData(
        Color,
        sensor,
        "intersectionColor",
        sensorData.intersectionColor,
        interval,
        sourceUri,
        entityCollection
      );
      processPacketData(
        Number,
        sensor,
        "intersectionWidth",
        sensorData.intersectionWidth,
        interval,
        sourceUri,
        entityCollection
      );
      processMaterialPacketData(
        sensor,
        "lateralSurfaceMaterial",
        sensorData.lateralSurfaceMaterial,
        interval,
        sourceUri,
        entityCollection
      );
    }

    var iso8601Scratch = {
      iso8601: undefined,
    };

    function processConicSensor(entity, packet, entityCollection, sourceUri) {
      var conicSensorData = packet.agi_conicSensor;
      if (!defined(conicSensorData)) {
        return;
      }

      var interval;
      var intervalString = conicSensorData.interval;
      if (defined(intervalString)) {
        iso8601Scratch.iso8601 = intervalString;
        interval = TimeInterval.fromIso8601(iso8601Scratch);
      }

      var conicSensor = entity.conicSensor;
      if (!defined(conicSensor)) {
        entity.addProperty("conicSensor");
        conicSensor = new ConicSensorGraphics();
        entity.conicSensor = conicSensor;
      }

      processCommonSensorProperties(
        conicSensor,
        conicSensorData,
        interval,
        sourceUri,
        entityCollection
      );
      processPacketData(
        Number,
        conicSensor,
        "innerHalfAngle",
        conicSensorData.innerHalfAngle,
        interval,
        sourceUri,
        entityCollection
      );
      processPacketData(
        Number,
        conicSensor,
        "outerHalfAngle",
        conicSensorData.outerHalfAngle,
        interval,
        sourceUri,
        entityCollection
      );
      processPacketData(
        Number,
        conicSensor,
        "minimumClockAngle",
        conicSensorData.minimumClockAngle,
        interval,
        sourceUri,
        entityCollection
      );
      processPacketData(
        Number,
        conicSensor,
        "maximumClockAngle",
        conicSensorData.maximumClockAngle,
        interval,
        sourceUri,
        entityCollection
      );
    }

    function processCustomPatternSensor(
      entity,
      packet,
      entityCollection,
      sourceUri
    ) {
      var customPatternSensorData = packet.agi_customPatternSensor;
      if (!defined(customPatternSensorData)) {
        return;
      }

      var interval;
      var intervalString = customPatternSensorData.interval;
      if (defined(intervalString)) {
        iso8601Scratch.iso8601 = intervalString;
        interval = TimeInterval.fromIso8601(iso8601Scratch);
      }

      var customPatternSensor = entity.customPatternSensor;
      if (!defined(customPatternSensor)) {
        entity.addProperty("customPatternSensor");
        customPatternSensor = new CustomPatternSensorGraphics();
        entity.customPatternSensor = customPatternSensor;
      }

      processCommonSensorProperties(
        customPatternSensor,
        customPatternSensorData,
        interval,
        sourceUri,
        entityCollection
      );

      // The directions property is a special case value that can be an array of unitSpherical or unit Cartesians.
      // We pre-process this into Spherical instances and then process it like any other array.
      var directions = customPatternSensorData.directions;
      if (defined(directions)) {
        if (Array.isArray(directions)) {
          var length = directions.length;
          for (var i = 0; i < length; i++) {
            processDirectionData(
              customPatternSensor,
              directions[i],
              interval,
              sourceUri,
              entityCollection
            );
          }
        } else {
          processDirectionData(
            customPatternSensor,
            directions,
            interval,
            sourceUri,
            entityCollection
          );
        }
      }
    }

    function processRectangularSensor(
      entity,
      packet,
      entityCollection,
      sourceUri
    ) {
      var rectangularSensorData = packet.agi_rectangularSensor;
      if (!defined(rectangularSensorData)) {
        return;
      }

      var interval;
      var intervalString = rectangularSensorData.interval;
      if (defined(intervalString)) {
        iso8601Scratch.iso8601 = intervalString;
        interval = TimeInterval.fromIso8601(iso8601Scratch);
      }

      var rectangularSensorVoumes = entity.rectangularSensorVoumes;
      if (!defined(rectangularSensorVoumes)) {
        entity.addProperty("rectangularSensorVoumes");
        rectangularSensorVoumes = new RectangularSensorGraphics();
        entity.rectangularSensorVoumes = rectangularSensorVoumes;
      }

      processCommonSensorProperties(
        rectangularSensorVoumes,
        rectangularSensorData,
        interval,
        sourceUri,
        entityCollection
      );
      processPacketData(
        Number,
        rectangularSensorVoumes,
        "xHalfAngle",
        rectangularSensorData.xHalfAngle,
        interval,
        sourceUri,
        entityCollection
      );
      processPacketData(
        Number,
        rectangularSensorVoumes,
        "yHalfAngle",
        rectangularSensorData.yHalfAngle,
        interval,
        sourceUri,
        entityCollection
      );
    }

    var initialized = false;
    return function initialize() {
      if (initialized) {
        return;
      }

      CzmlDataSource.updaters.push(
        processConicSensor,
        processCustomPatternSensor,
        processRectangularSensor
      );

      var originalDefaultVisualizersCallback =
        DataSourceDisplay.defaultVisualizersCallback;
      DataSourceDisplay.defaultVisualizersCallback = function (
        scene,
        entityCluster,
        dataSource
      ) {
        var entities = dataSource.entities;
        var array = originalDefaultVisualizersCallback(
          scene,
          entityCluster,
          dataSource
        );
        return array.concat([
          new ConicSensorVisualizer(scene, entities),
          new CustomPatternSensorVisualizer(scene, entities),
          new RectangularSensorVisualizer(scene, entities),
        ]);
      };

      initialized = true;
    };
  });

  define("cesium-sensor-volumes", [
    "require",
    "./initialize",
    "./conic/conic-sensor-graphics",
    "./conic/conic-sensor-visualizer",
    "./custom/custom-pattern-sensor-graphics",
    "./custom/custom-pattern-sensor-visualizer",
    "./custom/custom-sensor-volume",
    "./rectangular/rectangular-pyramid-sensor-volume",
    "./rectangular/rectangular-sensor-graphics",
    "./rectangular/rectangular-sensor-visualizer",
  ], function (require) {
    "use strict";

    var initialize = require("./initialize");
    var ConicSensorGraphics = require("./conic/conic-sensor-graphics");
    var ConicSensorVisualizer = require("./conic/conic-sensor-visualizer");
    var CustomPatternSensorGraphics = require("./custom/custom-pattern-sensor-graphics");
    var CustomPatternSensorVisualizer = require("./custom/custom-pattern-sensor-visualizer");
    var CustomSensorVolume = require("./custom/custom-sensor-volume");
    var RectangularPyramidSensorVolume = require("./rectangular/rectangular-pyramid-sensor-volume");
    var RectangularSensorGraphics = require("./rectangular/rectangular-sensor-graphics");
    var RectangularSensorVisualizer = require("./rectangular/rectangular-sensor-visualizer");

    initialize();

    return {
      ConicSensorGraphics: ConicSensorGraphics,
      ConicSensorVisualizer: ConicSensorVisualizer,
      CustomPatternSensorGraphics: CustomPatternSensorGraphics,
      CustomPatternSensorVisualizer: CustomPatternSensorVisualizer,
      CustomSensorVolume: CustomSensorVolume,
      RectangularPyramidSensorVolume: RectangularPyramidSensorVolume,
      RectangularSensorGraphics: RectangularSensorGraphics,
      RectangularSensorVisualizer: RectangularSensorVisualizer,
    };
  });

  ("use strict");
  /* global Cesium */
  define("Cesium/Core/Cartesian3", function () {
    return Cesium["Cartesian3"];
  });
  define("Cesium/Core/Color", function () {
    return Cesium["Color"];
  });
  define("Cesium/Core/defined", function () {
    return Cesium["defined"];
  });
  define("Cesium/Core/Spherical", function () {
    return Cesium["Spherical"];
  });
  define("Cesium/Core/TimeInterval", function () {
    return Cesium["TimeInterval"];
  });
  define("Cesium/DataSources/CzmlDataSource", function () {
    return Cesium["CzmlDataSource"];
  });
  define("Cesium/DataSources/DataSourceDisplay", function () {
    return Cesium["DataSourceDisplay"];
  });
  define("Cesium/Core/defaultValue", function () {
    return Cesium["defaultValue"];
  });
  define("Cesium/Core/DeveloperError", function () {
    return Cesium["DeveloperError"];
  });
  define("Cesium/Core/Event", function () {
    return Cesium["Event"];
  });
  define("Cesium/DataSources/createMaterialPropertyDescriptor", function () {
    return Cesium["createMaterialPropertyDescriptor"];
  });
  define("Cesium/DataSources/createPropertyDescriptor", function () {
    return Cesium["createPropertyDescriptor"];
  });
  define("Cesium/Core/AssociativeArray", function () {
    return Cesium["AssociativeArray"];
  });
  define("Cesium/Core/destroyObject", function () {
    return Cesium["destroyObject"];
  });
  define("Cesium/Core/Math", function () {
    return Cesium["Math"];
  });
  define("Cesium/Core/Matrix3", function () {
    return Cesium["Matrix3"];
  });
  define("Cesium/Core/Matrix4", function () {
    return Cesium["Matrix4"];
  });
  define("Cesium/Core/Quaternion", function () {
    return Cesium["Quaternion"];
  });
  define("Cesium/DataSources/MaterialProperty", function () {
    return Cesium["MaterialProperty"];
  });
  define("Cesium/DataSources/Property", function () {
    return Cesium["Property"];
  });
  define("Cesium/Core/BoundingSphere", function () {
    return Cesium["BoundingSphere"];
  });
  define("Cesium/Core/combine", function () {
    return Cesium["combine"];
  });
  define("Cesium/Core/ComponentDatatype", function () {
    return Cesium["ComponentDatatype"];
  });
  define("Cesium/Core/PrimitiveType", function () {
    return Cesium["PrimitiveType"];
  });
  define("Cesium/Renderer/Buffer", function () {
    return Cesium["Buffer"];
  });
  define("Cesium/Renderer/BufferUsage", function () {
    return Cesium["BufferUsage"];
  });
  define("Cesium/Renderer/DrawCommand", function () {
    return Cesium["DrawCommand"];
  });
  define("Cesium/Renderer/Pass", function () {
    return Cesium["Pass"];
  });
  define("Cesium/Renderer/RenderState", function () {
    return Cesium["RenderState"];
  });
  define("Cesium/Renderer/ShaderProgram", function () {
    return Cesium["ShaderProgram"];
  });
  define("Cesium/Renderer/ShaderSource", function () {
    return Cesium["ShaderSource"];
  });
  define("Cesium/Renderer/VertexArray", function () {
    return Cesium["VertexArray"];
  });
  define("Cesium/Scene/BlendingState", function () {
    return Cesium["BlendingState"];
  });
  define("Cesium/Scene/CullFace", function () {
    return Cesium["CullFace"];
  });
  define("Cesium/Scene/Material", function () {
    return Cesium["Material"];
  });
  define("Cesium/Scene/SceneMode", function () {
    return Cesium["SceneMode"];
  });
  define("Cesium/Core/clone", function () {
    return Cesium["clone"];
  });
  // eslint-disable-next-line import/no-dynamic-require
  require(["cesium-sensor-volumes"], function (CesiumSensorVolumes) {
    "use strict";
    /* global window, self */

    var scope;
    if (typeof window === "undefined") {
      if (typeof self === "undefined") {
        scope = {};
      } else {
        scope = self;
      }
    } else {
      scope = window;
    }

    scope.CesiumSensorVolumes = CesiumSensorVolumes;
  }, undefined, true);
})();