deeptwins-engine-3d 0.1.49 → 0.1.50

package/dist/esm/drawCommand/viewShed/ViewShedMap.js

@@ -0,0 +1,1238 @@
+import * as Cesium from 'deeptwins-cesium';
+
+/**
+ *
+ * @alias ViewshedMap
+ * @param {Object} options An object containing the following properties:
+ * @param {Cesium.Camera} options.lightCamera A camera representing the light source.
+ * @param {Boolean} [options.enabled=true] Whether the shadow map is enabled.
+ * @param {Boolean} [options.isPointLight=false] Whether the light source is a point light. Point light shadows do not use cascades.
+ * @param {Boolean} [options.pointLightRadius=100.0] Radius of the point light.
+ * @param {Boolean} [options.cascadesEnabled=true] Use multiple shadow maps to cover different partitions of the view frustum.
+ * @param {Number} [options.numberOfCascades=4] The number of cascades to use for the shadow map. Supported values are one and four.
+ * @param {Number} [options.maximumDistance=5000.0] The maximum distance used for generating cascaded shadows. Lower values improve shadow quality.
+ * @param {Number} [options.size=2048] The width and height, in pixels, of each shadow map.
+ * @param {Boolean} [options.softShadows=false] Whether percentage-closer-filtering is enabled for producing softer shadows.
+ * @param {Number} [options.darkness=0.3] The shadow darkness.
+ * @param {Boolean} [options.normalOffset=true] Whether a normal bias is applied to shadows.
+ * @demo {@link https://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Shadows.html|Cesium Sandcastle Shadows Demo}
+ */
+function ViewshedMap(options) {
+  var _options, _options$enabled, _options$softShadows, _options$normalOffset, _options$fromLightSou, _options$maximumDista, _options$boundingSphe, _options$isPointLight, _options$pointLightRa, _options$numberOfCasc, _options$size;
+  options = (_options = options) !== null && _options !== void 0 ? _options : Cesium.defaultValue.EMPTY_OBJECT;
+  var context = options.context;
+  if (!Cesium.defined(context)) {
+    throw new Cesium.DeveloperError('context is required.');
+  }
+  if (!Cesium.defined(options.lightCamera)) {
+    throw new Cesium.DeveloperError('lightCamera is required.');
+  }
+  if (Cesium.defined(options.numberOfCascades) && options.numberOfCascades !== 1 && options.numberOfCascades !== 4) {
+    throw new Cesium.DeveloperError('Only one or four cascades are supported.');
+  }
+  this._enabled = (_options$enabled = options.enabled) !== null && _options$enabled !== void 0 ? _options$enabled : true;
+  this._softShadows = (_options$softShadows = options.softShadows) !== null && _options$softShadows !== void 0 ? _options$softShadows : false;
+  this._normalOffset = (_options$normalOffset = options.normalOffset) !== null && _options$normalOffset !== void 0 ? _options$normalOffset : true;
+  this.dirty = true;
+  this.fromLightSource = (_options$fromLightSou = options.fromLightSource) !== null && _options$fromLightSou !== void 0 ? _options$fromLightSou : true;
+  this.darkness = 0.0;
+  this._darkness = this.darkness;
+  this.maximumDistance = (_options$maximumDista = options.maximumDistance) !== null && _options$maximumDista !== void 0 ? _options$maximumDista : 5000.0;
+  this._outOfView = false;
+  this._outOfViewPrevious = false;
+  this._needsUpdate = true;
+  // Re-enable once https://github.com/AnalyticalGraphicsInc/cesium/issues/4560 is resolved.
+  var polygonOffsetSupported = true;
+  if (Cesium.FeatureDetection.isInternetExplorer() || Cesium.FeatureDetection.isEdge() || (Cesium.FeatureDetection.isChrome() || Cesium.FeatureDetection.isFirefox()) && Cesium.FeatureDetection.isWindows() && !context.depthTexture) {
+    polygonOffsetSupported = false;
+  }
+  this._polygonOffsetSupported = polygonOffsetSupported;
+  this._terrainBias = {
+    polygonOffset: polygonOffsetSupported,
+    polygonOffsetFactor: 1.1,
+    polygonOffsetUnits: 4.0,
+    normalOffset: this._normalOffset,
+    normalOffsetScale: 0.5,
+    normalShading: true,
+    normalShadingSmooth: 0.3,
+    depthBias: 0.0001
+  };
+  this._primitiveBias = {
+    polygonOffset: polygonOffsetSupported,
+    polygonOffsetFactor: 1.1,
+    polygonOffsetUnits: 4.0,
+    normalOffset: this._normalOffset,
+    normalOffsetScale: 0.1,
+    normalShading: true,
+    normalShadingSmooth: 0.05,
+    depthBias: 0.00002
+  };
+  this._pointBias = {
+    polygonOffset: false,
+    polygonOffsetFactor: 1.1,
+    polygonOffsetUnits: 4.0,
+    normalOffset: this._normalOffset,
+    normalOffsetScale: 0.0,
+    normalShading: true,
+    normalShadingSmooth: 0.1,
+    depthBias: 0.0005
+  };
+
+  // Cesium.Framebuffer resources
+  this._depthAttachment = undefined;
+  this._colorAttachment = undefined;
+
+  // Uniforms
+  this._shadowMapMatrix = new Cesium.Matrix4();
+  this._shadowMapTexture = undefined;
+  this._lightDirectionEC = new Cesium.Cartesian3();
+  this._lightPositionEC = new Cesium.Cartesian4();
+  this._distance = 0.0;
+  this._lightCamera = options.lightCamera;
+  this._shadowMapCamera = new ShadowMapCamera();
+  this._shadowMapCullingVolume = undefined;
+  this._sceneCamera = undefined;
+  // this._boundingSphere = new Cesium.BoundingSphere();
+  this._boundingSphere = (_options$boundingSphe = options.boundingSphere) !== null && _options$boundingSphe !== void 0 ? _options$boundingSphe : new Cesium.BoundingSphere();
+  this._isPointLight = (_options$isPointLight = options.isPointLight) !== null && _options$isPointLight !== void 0 ? _options$isPointLight : false;
+  this._pointLightRadius = (_options$pointLightRa = options.pointLightRadius) !== null && _options$pointLightRa !== void 0 ? _options$pointLightRa : 100.0;
+  this._cascadesEnabled = false;
+  this._numberOfCascades = !this._cascadesEnabled ? 0 : (_options$numberOfCasc = options.numberOfCascades) !== null && _options$numberOfCasc !== void 0 ? _options$numberOfCasc : 4;
+  this._fitNearFar = true;
+  this._maximumCascadeDistances = [25.0, 150.0, 700.0, Number.MAX_VALUE];
+  this._textureSize = new Cesium.Cartesian2();
+  this._isSpotLight = false;
+  if (this._cascadesEnabled) {
+    // Cascaded shadows are always orthographic. The frustum dimensions are calculated on the fly.
+    this._shadowMapCamera.frustum = new Cesium.OrthographicOffCenterFrustum();
+  } else if (Cesium.defined(this._lightCamera.frustum.fov)) {
+    // If the light camera uses a perspective frustum, then the light source is a spot light
+    this._isSpotLight = true;
+  }
+
+  // Uniforms
+  this._cascadeSplits = [new Cesium.Cartesian4(), new Cesium.Cartesian4()];
+  this._cascadeMatrices = [new Cesium.Matrix4(), new Cesium.Matrix4(), new Cesium.Matrix4(), new Cesium.Matrix4()];
+  this._cascadeDistances = new Cesium.Cartesian4();
+  var numberOfPasses;
+  if (this._isPointLight) {
+    numberOfPasses = 6; // One shadow map for each direction
+  } else if (!this._cascadesEnabled) {
+    numberOfPasses = 1;
+  } else {
+    numberOfPasses = this._numberOfCascades;
+  }
+  this._passes = new Array(numberOfPasses);
+  for (var i = 0; i < numberOfPasses; ++i) {
+    this._passes[i] = new ShadowPass(context);
+  }
+  this.debugShow = false;
+  this.debugFreezeFrame = false;
+  this._debugFreezeFrame = false;
+  this._debugCascadeColors = false;
+  this._debugLightFrustum = undefined;
+  this._debugCameraFrustum = undefined;
+  this._debugCascadeFrustums = new Array(this._numberOfCascades);
+  this._debugShadowViewCommand = undefined;
+  this._usesDepthTexture = context.depthTexture;
+  if (this._isPointLight) {
+    this._usesDepthTexture = false;
+  }
+
+  // Create render states for shadow casters
+  this._primitiveRenderState = undefined;
+  this._terrainRenderState = undefined;
+  this._pointRenderState = undefined;
+  createRenderStates(this);
+
+  // For clearing the shadow map texture every frame
+  this._clearCommand = new Cesium.ClearCommand({
+    depth: 1.0,
+    color: new Cesium.Color()
+  });
+  this._clearPassState = new Cesium.PassState(context);
+  this._size = (_options$size = options.size) !== null && _options$size !== void 0 ? _options$size : 2048;
+  this.size = this._size;
+}
+
+/**
+ * Global maximum shadow distance used to prevent far off receivers from extending
+ * the shadow far plane. This helps set a tighter near/far when viewing objects from space.
+ *
+ * @private
+ */
+ViewshedMap.MAXIMUM_DISTANCE = 20000.0;
+function ShadowPass(context) {
+  this.camera = new ShadowMapCamera();
+  this.passState = new Cesium.PassState(context);
+  this.framebuffer = undefined;
+  this.textureOffsets = undefined;
+  this.commandList = [];
+  this.cullingVolume = undefined;
+}
+function createRenderState(colorMask, bias) {
+  return Cesium.RenderState.fromCache({
+    cull: {
+      enabled: true,
+      face: Cesium.CullFace.BACK
+    },
+    depthTest: {
+      enabled: true
+    },
+    colorMask: {
+      red: colorMask,
+      green: colorMask,
+      blue: colorMask,
+      alpha: colorMask
+    },
+    depthMask: true,
+    polygonOffset: {
+      enabled: bias.polygonOffset,
+      factor: bias.polygonOffsetFactor,
+      units: bias.polygonOffsetUnits
+    }
+  });
+}
+function createRenderStates(shadowMap) {
+  // Enable the color mask if the shadow map is backed by a color texture, e.g. when depth textures aren't supported
+  var colorMask = !shadowMap._usesDepthTexture;
+  shadowMap._primitiveRenderState = createRenderState(colorMask, shadowMap._primitiveBias);
+  shadowMap._terrainRenderState = createRenderState(colorMask, shadowMap._terrainBias);
+  shadowMap._pointRenderState = createRenderState(colorMask, shadowMap._pointBias);
+}
+
+/**
+ * @private
+ */
+ViewshedMap.prototype.debugCreateRenderStates = function () {
+  createRenderStates(this);
+};
+Object.defineProperties(ViewshedMap.prototype, {
+  enabled: {
+    get: function get() {
+      return this._enabled;
+    },
+    set: function set(value) {
+      this.dirty = this._enabled !== value;
+      this._enabled = value;
+    }
+  },
+  isViewShed: {
+    get: function get() {
+      return true;
+    }
+  },
+  normalOffset: {
+    get: function get() {
+      return this._normalOffset;
+    },
+    set: function set(value) {
+      this.dirty = this._normalOffset !== value;
+      this._normalOffset = value;
+      this._terrainBias.normalOffset = value;
+      this._primitiveBias.normalOffset = value;
+      this._pointBias.normalOffset = value;
+    }
+  },
+  softShadows: {
+    get: function get() {
+      return this._softShadows;
+    },
+    set: function set(value) {
+      this.dirty = this._softShadows !== value;
+      this._softShadows = value;
+    }
+  },
+  size: {
+    get: function get() {
+      return this._size;
+    },
+    set: function set(value) {
+      resize(this, value);
+    }
+  },
+  outOfView: {
+    get: function get() {
+      return this._outOfView;
+    }
+  },
+  shadowMapCullingVolume: {
+    get: function get() {
+      return this._shadowMapCullingVolume;
+    }
+  },
+  passes: {
+    get: function get() {
+      return this._passes;
+    }
+  },
+  isPointLight: {
+    get: function get() {
+      return this._isPointLight;
+    }
+  },
+  debugCascadeColors: {
+    get: function get() {
+      return this._debugCascadeColors;
+    },
+    set: function set(value) {
+      this.dirty = this._debugCascadeColors !== value;
+      this._debugCascadeColors = value;
+    }
+  }
+});
+function destroyFramebuffer(shadowMap) {
+  var length = shadowMap._passes.length;
+  for (var i = 0; i < length; ++i) {
+    var pass = shadowMap._passes[i];
+    var framebuffer = pass.framebuffer;
+    if (Cesium.defined(framebuffer) && !framebuffer.isDestroyed()) {
+      framebuffer.destroy();
+    }
+    pass.framebuffer = undefined;
+  }
+
+  // Destroy the framebuffer attachments
+  shadowMap._depthAttachment = shadowMap._depthAttachment && shadowMap._depthAttachment.destroy();
+  shadowMap._colorAttachment = shadowMap._colorAttachment && shadowMap._colorAttachment.destroy();
+}
+function createSampler() {
+  return new Cesium.Sampler({
+    wrapS: Cesium.TextureWrap.CLAMP_TO_EDGE,
+    wrapT: Cesium.TextureWrap.CLAMP_TO_EDGE,
+    minificationFilter: Cesium.TextureMinificationFilter.NEAREST,
+    magnificationFilter: Cesium.TextureMagnificationFilter.NEAREST
+  });
+}
+function createFramebufferColor(shadowMap, context) {
+  var depthRenderbuffer = new Cesium.Renderbuffer({
+    context: context,
+    width: shadowMap._textureSize.x,
+    height: shadowMap._textureSize.y,
+    format: Cesium.RenderbufferFormat.DEPTH_COMPONENT16
+  });
+  var colorTexture = new Cesium.Texture({
+    context: context,
+    width: shadowMap._textureSize.x,
+    height: shadowMap._textureSize.y,
+    pixelFormat: Cesium.PixelFormat.RGBA,
+    pixelDatatype: Cesium.PixelDatatype.UNSIGNED_BYTE,
+    sampler: createSampler()
+  });
+  var framebuffer = new Cesium.Framebuffer({
+    context: context,
+    depthRenderbuffer: depthRenderbuffer,
+    colorTextures: [colorTexture],
+    destroyAttachments: false
+  });
+  var length = shadowMap._passes.length;
+  for (var i = 0; i < length; ++i) {
+    var pass = shadowMap._passes[i];
+    pass.framebuffer = framebuffer;
+    pass.passState.framebuffer = framebuffer;
+  }
+  shadowMap._shadowMapTexture = colorTexture;
+  shadowMap._depthAttachment = depthRenderbuffer;
+  shadowMap._colorAttachment = colorTexture;
+}
+function createFramebufferDepth(shadowMap, context) {
+  var depthStencilTexture = new Cesium.Texture({
+    context: context,
+    width: shadowMap._textureSize.x,
+    height: shadowMap._textureSize.y,
+    pixelFormat: Cesium.PixelFormat.DEPTH_STENCIL,
+    pixelDatatype: Cesium.PixelDatatype.UNSIGNED_INT_24_8,
+    sampler: createSampler()
+  });
+  var framebuffer = new Cesium.Framebuffer({
+    context: context,
+    depthStencilTexture: depthStencilTexture,
+    destroyAttachments: false
+  });
+  var length = shadowMap._passes.length;
+  for (var i = 0; i < length; ++i) {
+    var pass = shadowMap._passes[i];
+    pass.framebuffer = framebuffer;
+    pass.passState.framebuffer = framebuffer;
+  }
+  shadowMap._shadowMapTexture = depthStencilTexture;
+  shadowMap._depthAttachment = depthStencilTexture;
+}
+function createFramebufferCube(shadowMap, context) {
+  var depthRenderbuffer = new Cesium.Renderbuffer({
+    context: context,
+    width: shadowMap._textureSize.x,
+    height: shadowMap._textureSize.y,
+    format: Cesium.RenderbufferFormat.DEPTH_COMPONENT16
+  });
+  var cubeMap = new Cesium.CubeMap({
+    context: context,
+    width: shadowMap._textureSize.x,
+    height: shadowMap._textureSize.y,
+    pixelFormat: Cesium.PixelFormat.RGBA,
+    pixelDatatype: Cesium.PixelDatatype.UNSIGNED_BYTE,
+    sampler: createSampler()
+  });
+  var faces = [cubeMap.negativeX, cubeMap.negativeY, cubeMap.negativeZ, cubeMap.positiveX, cubeMap.positiveY, cubeMap.positiveZ];
+  for (var i = 0; i < 6; ++i) {
+    var framebuffer = new Cesium.Framebuffer({
+      context: context,
+      depthRenderbuffer: depthRenderbuffer,
+      colorTextures: [faces[i]],
+      destroyAttachments: false
+    });
+    var pass = shadowMap._passes[i];
+    pass.framebuffer = framebuffer;
+    pass.passState.framebuffer = framebuffer;
+  }
+  shadowMap._shadowMapTexture = cubeMap;
+  shadowMap._depthAttachment = depthRenderbuffer;
+  shadowMap._colorAttachment = cubeMap;
+}
+function createFramebuffer(shadowMap, context) {
+  if (shadowMap._isPointLight) {
+    createFramebufferCube(shadowMap, context);
+  } else if (shadowMap._usesDepthTexture) {
+    createFramebufferDepth(shadowMap, context);
+  } else {
+    createFramebufferColor(shadowMap, context);
+  }
+}
+function checkFramebuffer(shadowMap, context) {
+  // Attempt to make an FBO with only a depth texture. If it fails, fallback to a color texture.
+  if (shadowMap._usesDepthTexture && shadowMap._passes[0].framebuffer.status !== Cesium.WebGLConstants.FRAMEBUFFER_COMPLETE) {
+    shadowMap._usesDepthTexture = false;
+    createRenderStates(shadowMap);
+    destroyFramebuffer(shadowMap);
+    createFramebuffer(shadowMap, context);
+  }
+}
+function updateFramebuffer(shadowMap, context) {
+  if (!Cesium.defined(shadowMap._passes[0].framebuffer) || shadowMap._shadowMapTexture.width !== shadowMap._textureSize.x) {
+    destroyFramebuffer(shadowMap);
+    createFramebuffer(shadowMap, context);
+    checkFramebuffer(shadowMap, context);
+    clearFramebuffer(shadowMap, context);
+  }
+}
+function clearFramebuffer(shadowMap, context, shadowPass) {
+  var _shadowPass;
+  shadowPass = (_shadowPass = shadowPass) !== null && _shadowPass !== void 0 ? _shadowPass : 0;
+  if (shadowMap._isPointLight || shadowPass === 0) {
+    shadowMap._clearCommand.framebuffer = shadowMap._passes[shadowPass].framebuffer;
+    shadowMap._clearCommand.execute(context, shadowMap._clearPassState);
+  }
+}
+function resize(shadowMap, size) {
+  shadowMap._size = size;
+  var passes = shadowMap._passes;
+  var numberOfPasses = passes.length;
+  var textureSize = shadowMap._textureSize;
+  if (shadowMap._isPointLight) {
+    size = Cesium.ContextLimits.maximumCubeMapSize >= size ? size : Cesium.ContextLimits.maximumCubeMapSize;
+    textureSize.x = size;
+    textureSize.y = size;
+    var faceViewport = new Cesium.BoundingRectangle(0, 0, size, size);
+    passes[0].passState.viewport = faceViewport;
+    passes[1].passState.viewport = faceViewport;
+    passes[2].passState.viewport = faceViewport;
+    passes[3].passState.viewport = faceViewport;
+    passes[4].passState.viewport = faceViewport;
+    passes[5].passState.viewport = faceViewport;
+  } else if (numberOfPasses === 1) {
+    // +----+
+    // |  1 |
+    // +----+
+    size = Cesium.ContextLimits.maximumTextureSize >= size ? size : Cesium.ContextLimits.maximumTextureSize;
+    textureSize.x = size;
+    textureSize.y = size;
+    passes[0].passState.viewport = new Cesium.BoundingRectangle(0, 0, size, size);
+  } else if (numberOfPasses === 4) {
+    // +----+----+
+    // |  3 |  4 |
+    // +----+----+
+    // |  1 |  2 |
+    // +----+----+
+    size = Cesium.ContextLimits.maximumTextureSize >= size * 2 ? size : Cesium.ContextLimits.maximumTextureSize / 2;
+    textureSize.x = size * 2;
+    textureSize.y = size * 2;
+    passes[0].passState.viewport = new Cesium.BoundingRectangle(0, 0, size, size);
+    passes[1].passState.viewport = new Cesium.BoundingRectangle(size, 0, size, size);
+    passes[2].passState.viewport = new Cesium.BoundingRectangle(0, size, size, size);
+    passes[3].passState.viewport = new Cesium.BoundingRectangle(size, size, size, size);
+  }
+
+  // Update clear pass state
+  shadowMap._clearPassState.viewport = new Cesium.BoundingRectangle(0, 0, textureSize.x, textureSize.y);
+
+  // Transforms shadow coordinates [0, 1] into the pass's region of the texture
+  for (var i = 0; i < numberOfPasses; ++i) {
+    var pass = passes[i];
+    var viewport = pass.passState.viewport;
+    var biasX = viewport.x / textureSize.x;
+    var biasY = viewport.y / textureSize.y;
+    var scaleX = viewport.width / textureSize.x;
+    var scaleY = viewport.height / textureSize.y;
+    pass.textureOffsets = new Cesium.Matrix4(scaleX, 0.0, 0.0, biasX, 0.0, scaleY, 0.0, biasY, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
+  }
+}
+var scratchViewport = new Cesium.BoundingRectangle();
+function createDebugShadowViewCommand(shadowMap, context) {
+  var fs;
+  if (shadowMap._isPointLight) {
+    fs = 'uniform samplerCube shadowMap_textureCube; \n' + 'in vec2 v_textureCoordinates; \n' + 'void main() \n' + '{ \n' + '    vec2 uv = v_textureCoordinates; \n' + '    vec3 dir; \n' + ' \n' + '    if (uv.y < 0.5) \n' + '    { \n' + '        if (uv.x < 0.333) \n' + '        { \n' + '            dir.x = -1.0; \n' + '            dir.y = uv.x * 6.0 - 1.0; \n' + '            dir.z = uv.y * 4.0 - 1.0; \n' + '        } \n' + '        else if (uv.x < 0.666) \n' + '        { \n' + '            dir.y = -1.0; \n' + '            dir.x = uv.x * 6.0 - 3.0; \n' + '            dir.z = uv.y * 4.0 - 1.0; \n' + '        } \n' + '        else \n' + '        { \n' + '            dir.z = -1.0; \n' + '            dir.x = uv.x * 6.0 - 5.0; \n' + '            dir.y = uv.y * 4.0 - 1.0; \n' + '        } \n' + '    } \n' + '    else \n' + '    { \n' + '        if (uv.x < 0.333) \n' + '        { \n' + '            dir.x = 1.0; \n' + '            dir.y = uv.x * 6.0 - 1.0; \n' + '            dir.z = uv.y * 4.0 - 3.0; \n' + '        } \n' + '        else if (uv.x < 0.666) \n' + '        { \n' + '            dir.y = 1.0; \n' + '            dir.x = uv.x * 6.0 - 3.0; \n' + '            dir.z = uv.y * 4.0 - 3.0; \n' + '        } \n' + '        else \n' + '        { \n' + '            dir.z = 1.0; \n' + '            dir.x = uv.x * 6.0 - 5.0; \n' + '            dir.y = uv.y * 4.0 - 3.0; \n' + '        } \n' + '    } \n' + ' \n' + '    float shadow = czm_unpackDepth(textureCube(shadowMap_textureCube, dir)); \n' + '    out_FragColor = vec4(vec3(shadow), 1.0); \n' + '} \n';
+  } else {
+    fs = 'uniform sampler2D shadowMap_texture; \n' + 'in vec2 v_textureCoordinates; \n' + 'void main() \n' + '{ \n' + (shadowMap._usesDepthTexture ? '    float shadow = texture2D(shadowMap_texture, v_textureCoordinates).r; \n' : '    float shadow = czm_unpackDepth(texture2D(shadowMap_texture, v_textureCoordinates)); \n') + '    out_FragColor = vec4(vec3(shadow), 1.0); \n' + '} \n';
+  }
+  var drawCommand = context.createViewportQuadCommand(fs, {
+    uniformMap: {
+      shadowMap_texture: function shadowMap_texture() {
+        return shadowMap._shadowMapTexture;
+      },
+      shadowMap_textureCube: function shadowMap_textureCube() {
+        return shadowMap._shadowMapTexture;
+      }
+    }
+  });
+  drawCommand.pass = Cesium.Pass.OVERLAY;
+  return drawCommand;
+}
+function updateDebugShadowViewCommand(shadowMap, frameState) {
+  // Draws the shadow map on the bottom-right corner of the screen
+  var context = frameState.context;
+  var screenWidth = frameState.context.drawingBufferWidth;
+  var screenHeight = frameState.context.drawingBufferHeight;
+  var size = Math.min(screenWidth, screenHeight) * 0.3;
+  var viewport = scratchViewport;
+  viewport.x = screenWidth - size;
+  viewport.y = 0;
+  viewport.width = size;
+  viewport.height = size;
+  var debugCommand = shadowMap._debugShadowViewCommand;
+  if (!Cesium.defined(debugCommand)) {
+    debugCommand = createDebugShadowViewCommand(shadowMap, context);
+    shadowMap._debugShadowViewCommand = debugCommand;
+  }
+
+  // Get a new Cesium.RenderState for the updated viewport size
+  if (!Cesium.defined(debugCommand.renderState) || !Cesium.BoundingRectangle.equals(debugCommand.renderState.viewport, viewport)) {
+    debugCommand.renderState = Cesium.RenderState.fromCache({
+      viewport: Cesium.BoundingRectangle.clone(viewport)
+    });
+  }
+  frameState.commandList.push(shadowMap._debugShadowViewCommand);
+}
+var frustumCornersNDC = new Array(8);
+frustumCornersNDC[0] = new Cesium.Cartesian4(-1.0, -1.0, -1.0, 1.0);
+frustumCornersNDC[1] = new Cesium.Cartesian4(1.0, -1.0, -1.0, 1.0);
+frustumCornersNDC[2] = new Cesium.Cartesian4(1.0, 1.0, -1.0, 1.0);
+frustumCornersNDC[3] = new Cesium.Cartesian4(-1.0, 1.0, -1.0, 1.0);
+frustumCornersNDC[4] = new Cesium.Cartesian4(-1.0, -1.0, 1.0, 1.0);
+frustumCornersNDC[5] = new Cesium.Cartesian4(1.0, -1.0, 1.0, 1.0);
+frustumCornersNDC[6] = new Cesium.Cartesian4(1.0, 1.0, 1.0, 1.0);
+frustumCornersNDC[7] = new Cesium.Cartesian4(-1.0, 1.0, 1.0, 1.0);
+var scratchMatrix = new Cesium.Matrix4();
+var scratchFrustumCorners = new Array(8);
+for (var i = 0; i < 8; ++i) {
+  scratchFrustumCorners[i] = new Cesium.Cartesian4();
+}
+function createDebugPointLight(modelMatrix, color) {
+  var box = new Cesium.GeometryInstance({
+    geometry: new Cesium.BoxOutlineGeometry({
+      minimum: new Cesium.Cartesian3(-0.5, -0.5, -0.5),
+      maximum: new Cesium.Cartesian3(0.5, 0.5, 0.5)
+    }),
+    attributes: {
+      color: Cesium.ColorGeometryInstanceAttribute.fromColor(color)
+    }
+  });
+  var sphere = new Cesium.GeometryInstance({
+    geometry: new Cesium.SphereOutlineGeometry({
+      radius: 0.5
+    }),
+    attributes: {
+      color: Cesium.ColorGeometryInstanceAttribute.fromColor(color)
+    }
+  });
+  return new Cesium.Primitive({
+    geometryInstances: [box, sphere],
+    appearance: new Cesium.PerInstanceColorAppearance({
+      translucent: false,
+      flat: true
+    }),
+    asynchronous: false,
+    modelMatrix: modelMatrix
+  });
+}
+var debugOutlineColors = [Cesium.Color.RED, Cesium.Color.GREEN, Cesium.Color.BLUE, Cesium.Color.MAGENTA];
+var scratchScale = new Cesium.Cartesian3();
+function applyDebugSettings(shadowMap, frameState) {
+  updateDebugShadowViewCommand(shadowMap, frameState);
+  var enterFreezeFrame = shadowMap.debugFreezeFrame && !shadowMap._debugFreezeFrame;
+  shadowMap._debugFreezeFrame = shadowMap.debugFreezeFrame;
+
+  // Draw scene camera in freeze frame mode
+  if (shadowMap.debugFreezeFrame) {
+    if (enterFreezeFrame) {
+      // Recreate debug camera when entering freeze frame mode
+      shadowMap._debugCameraFrustum = shadowMap._debugCameraFrustum && shadowMap._debugCameraFrustum.destroy();
+      shadowMap._debugCameraFrustum = new Cesium.DebugCameraPrimitive({
+        camera: shadowMap._sceneCamera,
+        color: Cesium.Color.CYAN,
+        updateOnChange: false
+      });
+    }
+    shadowMap._debugCameraFrustum.update(frameState);
+  }
+  if (shadowMap._cascadesEnabled) {
+    // Draw cascades only in freeze frame mode
+    if (shadowMap.debugFreezeFrame) {
+      if (enterFreezeFrame) {
+        // Recreate debug frustum when entering freeze frame mode
+        shadowMap._debugLightFrustum = shadowMap._debugLightFrustum && shadowMap._debugLightFrustum.destroy();
+        shadowMap._debugLightFrustum = new Cesium.DebugCameraPrimitive({
+          camera: shadowMap._shadowMapCamera,
+          color: Cesium.Color.YELLOW,
+          updateOnChange: false
+        });
+      }
+      shadowMap._debugLightFrustum.update(frameState);
+      for (var _i = 0; _i < shadowMap._numberOfCascades; ++_i) {
+        if (enterFreezeFrame) {
+          // Recreate debug frustum when entering freeze frame mode
+          shadowMap._debugCascadeFrustums[_i] = shadowMap._debugCascadeFrustums[_i] && shadowMap._debugCascadeFrustums[_i].destroy();
+          shadowMap._debugCascadeFrustums[_i] = new Cesium.DebugCameraPrimitive({
+            camera: shadowMap._passes[_i].camera,
+            color: debugOutlineColors[_i],
+            updateOnChange: false
+          });
+        }
+        shadowMap._debugCascadeFrustums[_i].update(frameState);
+      }
+    }
+  } else if (shadowMap._isPointLight) {
+    if (!Cesium.defined(shadowMap._debugLightFrustum) || shadowMap._needsUpdate) {
+      var translation = shadowMap._shadowMapCamera.positionWC;
+      var rotation = Cesium.Quaternion.IDENTITY;
+      var uniformScale = shadowMap._pointLightRadius * 2.0;
+      var scale = Cesium.Cartesian3.fromElements(uniformScale, uniformScale, uniformScale, scratchScale);
+      var modelMatrix = Cesium.Matrix4.fromTranslationQuaternionRotationScale(translation, rotation, scale, scratchMatrix);
+      shadowMap._debugLightFrustum = shadowMap._debugLightFrustum && shadowMap._debugLightFrustum.destroy();
+      shadowMap._debugLightFrustum = createDebugPointLight(modelMatrix, Cesium.Color.YELLOW);
+    }
+    shadowMap._debugLightFrustum.update(frameState);
+  } else {
+    if (!Cesium.defined(shadowMap._debugLightFrustum) || shadowMap._needsUpdate) {
+      shadowMap._debugLightFrustum = new Cesium.DebugCameraPrimitive({
+        camera: shadowMap._shadowMapCamera,
+        color: Cesium.Color.YELLOW,
+        updateOnChange: false
+      });
+    }
+    shadowMap._debugLightFrustum.update(frameState);
+  }
+}
+function ShadowMapCamera() {
+  this.viewMatrix = new Cesium.Matrix4();
+  this.inverseViewMatrix = new Cesium.Matrix4();
+  this.frustum = undefined;
+  this.positionCartographic = new Cesium.Cartographic();
+  this.positionWC = new Cesium.Cartesian3();
+  this.directionWC = Cesium.Cartesian3.clone(Cesium.Cartesian3.UNIT_Z);
+  this.upWC = Cesium.Cartesian3.clone(Cesium.Cartesian3.UNIT_Y);
+  this.rightWC = Cesium.Cartesian3.clone(Cesium.Cartesian3.UNIT_X);
+  this.viewProjectionMatrix = new Cesium.Matrix4();
+}
+ShadowMapCamera.prototype.clone = function (camera) {
+  Cesium.Matrix4.clone(camera.viewMatrix, this.viewMatrix);
+  Cesium.Matrix4.clone(camera.inverseViewMatrix, this.inverseViewMatrix);
+  this.frustum = camera.frustum.clone(this.frustum);
+  Cesium.Cartographic.clone(camera.positionCartographic, this.positionCartographic);
+  Cesium.Cartesian3.clone(camera.positionWC, this.positionWC);
+  Cesium.Cartesian3.clone(camera.directionWC, this.directionWC);
+  Cesium.Cartesian3.clone(camera.upWC, this.upWC);
+  Cesium.Cartesian3.clone(camera.rightWC, this.rightWC);
+};
+
+// Converts from NDC space to texture space
+var scaleBiasMatrix = new Cesium.Matrix4(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0);
+ShadowMapCamera.prototype.getViewProjection = function () {
+  var view = this.viewMatrix;
+  var projection = this.frustum.projectionMatrix;
+  Cesium.Matrix4.multiply(projection, view, this.viewProjectionMatrix);
+  Cesium.Matrix4.multiply(scaleBiasMatrix, this.viewProjectionMatrix, this.viewProjectionMatrix);
+  return this.viewProjectionMatrix;
+};
+var scratchSplits = new Array(5);
+var scratchFrustum = new Cesium.PerspectiveFrustum();
+var scratchCascadeDistances = new Array(4);
+var scratchMin = new Cesium.Cartesian3();
+var scratchMax = new Cesium.Cartesian3();
+function computeCascades(shadowMap, frameState) {
+  var shadowMapCamera = shadowMap._shadowMapCamera;
+  var sceneCamera = shadowMap._sceneCamera;
+  var cameraNear = sceneCamera.frustum.near;
+  var cameraFar = sceneCamera.frustum.far;
+  var numberOfCascades = shadowMap._numberOfCascades;
+
+  // Split cascades. Use a mix of linear and log splits.
+  var i;
+  var range = cameraFar - cameraNear;
+  var ratio = cameraFar / cameraNear;
+  var lambda = 0.9;
+  var clampCascadeDistances = false;
+
+  // When the camera is close to a relatively small model, provide more detail in the closer cascades.
+  // If the camera is near or inside a large model, such as the root tile of a city, then use the default values.
+  // To get the most accurate cascade splits we would need to find the min and max values from the depth texture.
+  if (frameState.shadowState.closestObjectSize < 200.0) {
+    clampCascadeDistances = true;
+    lambda = 0.9;
+  }
+  var cascadeDistances = scratchCascadeDistances;
+  var splits = scratchSplits;
+  splits[0] = cameraNear;
+  splits[numberOfCascades] = cameraFar;
+
+  // Find initial splits
+  for (i = 0; i < numberOfCascades; ++i) {
+    var p = (i + 1) / numberOfCascades;
+    var logScale = cameraNear * Math.pow(ratio, p);
+    var uniformScale = cameraNear + range * p;
+    var split = Cesium.Math.lerp(uniformScale, logScale, lambda);
+    splits[i + 1] = split;
+    cascadeDistances[i] = split - splits[i];
+  }
+  if (clampCascadeDistances) {
+    // Clamp each cascade to its maximum distance
+    for (i = 0; i < numberOfCascades; ++i) {
+      cascadeDistances[i] = Math.min(cascadeDistances[i], shadowMap._maximumCascadeDistances[i]);
+    }
+
+    // Recompute splits
+    var distance = splits[0];
+    for (i = 0; i < numberOfCascades - 1; ++i) {
+      distance += cascadeDistances[i];
+      splits[i + 1] = distance;
+    }
+  }
+  Cesium.Cartesian4.unpack(splits, 0, shadowMap._cascadeSplits[0]);
+  Cesium.Cartesian4.unpack(splits, 1, shadowMap._cascadeSplits[1]);
+  Cesium.Cartesian4.unpack(cascadeDistances, 0, shadowMap._cascadeDistances);
+  var shadowFrustum = shadowMapCamera.frustum;
+  var left = shadowFrustum.left;
+  var right = shadowFrustum.right;
+  var bottom = shadowFrustum.bottom;
+  var top = shadowFrustum.top;
+  var near = shadowFrustum.near;
+  var far = shadowFrustum.far;
+  var position = shadowMapCamera.positionWC;
+  var direction = shadowMapCamera.directionWC;
+  var up = shadowMapCamera.upWC;
+  var cascadeSubFrustum = sceneCamera.frustum.clone(scratchFrustum);
+  var shadowViewProjection = shadowMapCamera.getViewProjection();
+  for (i = 0; i < numberOfCascades; ++i) {
+    // Find the bounding box of the camera sub-frustum in shadow map texture space
+    cascadeSubFrustum.near = splits[i];
+    cascadeSubFrustum.far = splits[i + 1];
+    var viewProjection = Cesium.Matrix4.multiply(cascadeSubFrustum.projectionMatrix, sceneCamera.viewMatrix, scratchMatrix);
+    var inverseViewProjection = Cesium.Matrix4.inverse(viewProjection, scratchMatrix);
+    var shadowMapMatrix = Cesium.Matrix4.multiply(shadowViewProjection, inverseViewProjection, scratchMatrix);
+
+    // Project each corner from camera NDC space to shadow map texture space. Min and max will be from 0 to 1.
+    var min = Cesium.Cartesian3.fromElements(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE, scratchMin);
+    var max = Cesium.Cartesian3.fromElements(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE, scratchMax);
+    for (var k = 0; k < 8; ++k) {
+      var corner = Cesium.Cartesian4.clone(frustumCornersNDC[k], scratchFrustumCorners[k]);
+      Cesium.Matrix4.multiplyByVector(shadowMapMatrix, corner, corner);
+      Cesium.Cartesian3.divideByScalar(corner, corner.w, corner); // Handle the perspective divide
+      Cesium.Cartesian3.minimumByComponent(corner, min, min);
+      Cesium.Cartesian3.maximumByComponent(corner, max, max);
+    }
+
+    // Limit light-space coordinates to the [0, 1] range
+    min.x = Math.max(min.x, 0.0);
+    min.y = Math.max(min.y, 0.0);
+    min.z = 0.0; // Always start cascade frustum at the top of the light frustum to capture objects in the light's path
+    max.x = Math.min(max.x, 1.0);
+    max.y = Math.min(max.y, 1.0);
+    max.z = Math.min(max.z, 1.0);
+    var pass = shadowMap._passes[i];
+    var cascadeCamera = pass.camera;
+    cascadeCamera.clone(shadowMapCamera); // PERFORMANCE_IDEA : could do a shallow clone for all properties except the frustum
+
+    var frustum = cascadeCamera.frustum;
+    frustum.left = left + min.x * (right - left);
+    frustum.right = left + max.x * (right - left);
+    frustum.bottom = bottom + min.y * (top - bottom);
+    frustum.top = bottom + max.y * (top - bottom);
+    frustum.near = near + min.z * (far - near);
+    frustum.far = near + max.z * (far - near);
+    pass.cullingVolume = cascadeCamera.frustum.computeCullingVolume(position, direction, up);
+
+    // Transforms from eye space to the cascade's texture space
+    var cascadeMatrix = shadowMap._cascadeMatrices[i];
+    Cesium.Matrix4.multiply(cascadeCamera.getViewProjection(), sceneCamera.inverseViewMatrix, cascadeMatrix);
+    Cesium.Matrix4.multiply(pass.textureOffsets, cascadeMatrix, cascadeMatrix);
+  }
+}
+var scratchLightView = new Cesium.Matrix4();
+var scratchRight = new Cesium.Cartesian3();
+var scratchUp = new Cesium.Cartesian3();
+var scratchTranslation = new Cesium.Cartesian3();
+function fitShadowMapToScene(shadowMap, frameState) {
+  var shadowMapCamera = shadowMap._shadowMapCamera;
+  var sceneCamera = shadowMap._sceneCamera;
+
+  // 1. First find a tight bounding box in light space that contains the entire camera frustum.
+  var viewProjection = Cesium.Matrix4.multiply(sceneCamera.frustum.projectionMatrix, sceneCamera.viewMatrix, scratchMatrix);
+  var inverseViewProjection = Cesium.Matrix4.inverse(viewProjection, scratchMatrix);
+
+  // Start to construct the light view matrix. Set translation later once the bounding box is found.
+  var lightDir = shadowMapCamera.directionWC;
+  var lightUp = sceneCamera.directionWC; // Align shadows to the camera view.
+  var lightRight = Cesium.Cartesian3.cross(lightDir, lightUp, scratchRight);
+  lightUp = Cesium.Cartesian3.cross(lightRight, lightDir, scratchUp); // Recalculate up now that right is derived
+  Cesium.Cartesian3.normalize(lightUp, lightUp);
+  Cesium.Cartesian3.normalize(lightRight, lightRight);
+  var lightPosition = Cesium.Cartesian3.fromElements(0.0, 0.0, 0.0, scratchTranslation);
+  var lightView = Cesium.Matrix4.computeView(lightPosition, lightDir, lightUp, lightRight, scratchLightView);
+  var cameraToLight = Cesium.Matrix4.multiply(lightView, inverseViewProjection, scratchMatrix);
+
+  // Project each corner from NDC space to light view space, and calculate a min and max in light view space
+  var min = Cesium.Cartesian3.fromElements(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE, scratchMin);
+  var max = Cesium.Cartesian3.fromElements(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE, scratchMax);
+  for (var _i2 = 0; _i2 < 8; ++_i2) {
+    var corner = Cesium.Cartesian4.clone(frustumCornersNDC[_i2], scratchFrustumCorners[_i2]);
+    Cesium.Matrix4.multiplyByVector(cameraToLight, corner, corner);
+    Cesium.Cartesian3.divideByScalar(corner, corner.w, corner); // Handle the perspective divide
+    Cesium.Cartesian3.minimumByComponent(corner, min, min);
+    Cesium.Cartesian3.maximumByComponent(corner, max, max);
+  }
+
+  // 2. Set bounding box back to include objects in the light's view
+  max.z += 1000.0; // Note: in light space, a positive number is behind the camera
+  min.z -= 10.0; // Extend the shadow volume forward slightly to avoid problems right at the edge
+
+  // 3. Adjust light view matrix so that it is centered on the bounding volume
+  var translation = scratchTranslation;
+  translation.x = -(0.5 * (min.x + max.x));
+  translation.y = -(0.5 * (min.y + max.y));
+  translation.z = -max.z;
+  var translationMatrix = Cesium.Matrix4.fromTranslation(translation, scratchMatrix);
+  lightView = Cesium.Matrix4.multiply(translationMatrix, lightView, lightView);
+
+  // 4. Create an orthographic frustum that covers the bounding box extents
+  var halfWidth = 0.5 * (max.x - min.x);
+  var halfHeight = 0.5 * (max.y - min.y);
+  var depth = max.z - min.z;
+  var frustum = shadowMapCamera.frustum;
+  frustum.left = -halfWidth;
+  frustum.right = halfWidth;
+  frustum.bottom = -halfHeight;
+  frustum.top = halfHeight;
+  frustum.near = 0.01;
+  frustum.far = depth;
+
+  // 5. Update the shadow map camera
+  Cesium.Matrix4.clone(lightView, shadowMapCamera.viewMatrix);
+  Cesium.Matrix4.inverse(lightView, shadowMapCamera.inverseViewMatrix);
+  Cesium.Matrix4.getTranslation(shadowMapCamera.inverseViewMatrix, shadowMapCamera.positionWC);
+  frameState.mapProjection.ellipsoid.cartesianToCartographic(shadowMapCamera.positionWC, shadowMapCamera.positionCartographic);
+  Cesium.Cartesian3.clone(lightDir, shadowMapCamera.directionWC);
+  Cesium.Cartesian3.clone(lightUp, shadowMapCamera.upWC);
+  Cesium.Cartesian3.clone(lightRight, shadowMapCamera.rightWC);
+}
+var directions = [new Cesium.Cartesian3(-1.0, 0.0, 0.0), new Cesium.Cartesian3(0.0, -1.0, 0.0), new Cesium.Cartesian3(0.0, 0.0, -1.0), new Cesium.Cartesian3(1.0, 0.0, 0.0), new Cesium.Cartesian3(0.0, 1.0, 0.0), new Cesium.Cartesian3(0.0, 0.0, 1.0)];
+var ups = [new Cesium.Cartesian3(0.0, -1.0, 0.0), new Cesium.Cartesian3(0.0, 0.0, -1.0), new Cesium.Cartesian3(0.0, -1.0, 0.0), new Cesium.Cartesian3(0.0, -1.0, 0.0), new Cesium.Cartesian3(0.0, 0.0, 1.0), new Cesium.Cartesian3(0.0, -1.0, 0.0)];
+var rights = [new Cesium.Cartesian3(0.0, 0.0, 1.0), new Cesium.Cartesian3(1.0, 0.0, 0.0), new Cesium.Cartesian3(-1.0, 0.0, 0.0), new Cesium.Cartesian3(0.0, 0.0, -1.0), new Cesium.Cartesian3(1.0, 0.0, 0.0), new Cesium.Cartesian3(1.0, 0.0, 0.0)];
+function computeOmnidirectional(shadowMap, frameState) {
+  // All sides share the same frustum
+  var frustum = new Cesium.PerspectiveFrustum();
+  frustum.fov = Cesium.Math.PI_OVER_TWO;
+  frustum.near = 1.0;
+  frustum.far = shadowMap._pointLightRadius;
+  frustum.aspectRatio = 1.0;
+  for (var _i3 = 0; _i3 < 6; ++_i3) {
+    var camera = shadowMap._passes[_i3].camera;
+    camera.positionWC = shadowMap._shadowMapCamera.positionWC;
+    camera.positionCartographic = frameState.mapProjection.ellipsoid.cartesianToCartographic(camera.positionWC, camera.positionCartographic);
+    camera.directionWC = directions[_i3];
+    camera.upWC = ups[_i3];
+    camera.rightWC = rights[_i3];
+    Cesium.Matrix4.computeView(camera.positionWC, camera.directionWC, camera.upWC, camera.rightWC, camera.viewMatrix);
+    Cesium.Matrix4.inverse(camera.viewMatrix, camera.inverseViewMatrix);
+    camera.frustum = frustum;
+  }
+}
+var scratchCartesian1 = new Cesium.Cartesian3();
+var scratchCartesian2 = new Cesium.Cartesian3();
+var scratchBoundingSphere = new Cesium.BoundingSphere();
+var scratchCenter = scratchBoundingSphere.center;
+function checkVisibility(shadowMap, frameState) {
+  var sceneCamera = shadowMap._sceneCamera;
+  var shadowMapCamera = shadowMap._shadowMapCamera;
+  var boundingSphere = scratchBoundingSphere;
+
+  // Check whether the shadow map is in view and needs to be updated
+  if (shadowMap._cascadesEnabled) {
+    // If the nearest shadow receiver is further than the shadow map's maximum distance then the shadow map is out of view.
+    if (sceneCamera.frustum.near >= shadowMap.maximumDistance) {
+      shadowMap._outOfView = true;
+      shadowMap._needsUpdate = false;
+      return;
+    }
+
+    // If the light source is below the horizon then the shadow map is out of view
+    var surfaceNormal = frameState.mapProjection.ellipsoid.geodeticSurfaceNormal(sceneCamera.positionWC, scratchCartesian1);
+    var lightDirection = Cesium.Cartesian3.negate(shadowMapCamera.directionWC, scratchCartesian2);
+    var dot = Cesium.Cartesian3.dot(surfaceNormal, lightDirection);
+
+    // Shadows start to fade out once the light gets closer to the horizon.
+    // At this point the globe uses vertex lighting alone to darken the surface.
+    var darknessAmount = Cesium.Math.clamp(dot / 0.1, 0.0, 1.0);
+    shadowMap._darkness = Cesium.Math.lerp(1.0, shadowMap.darkness, darknessAmount);
+    if (dot < 0.0) {
+      shadowMap._outOfView = true;
+      shadowMap._needsUpdate = false;
+      return;
+    }
+
+    // By default cascaded shadows need to update and are always in view
+    shadowMap._needsUpdate = true;
+    shadowMap._outOfView = false;
+  } else if (shadowMap._isPointLight) {
+    // Sphere-frustum intersection test
+    boundingSphere.center = shadowMapCamera.positionWC;
+    boundingSphere.radius = shadowMap._pointLightRadius;
+    shadowMap._outOfView = frameState.cullingVolume.computeVisibility(boundingSphere) === Cesium.Intersect.OUTSIDE;
+    shadowMap._needsUpdate = !shadowMap._outOfView && !shadowMap._boundingSphere.equals(boundingSphere);
+    Cesium.BoundingSphere.clone(boundingSphere, shadowMap._boundingSphere);
+  } else {
+    // Simplify frustum-frustum intersection test as a sphere-frustum test
+    var frustumRadius = shadowMapCamera.frustum.far / 2.0;
+    var frustumCenter = Cesium.Cartesian3.add(shadowMapCamera.positionWC, Cesium.Cartesian3.multiplyByScalar(shadowMapCamera.directionWC, frustumRadius, scratchCenter), scratchCenter);
+    boundingSphere.center = frustumCenter;
+    boundingSphere.radius = frustumRadius;
+    shadowMap._outOfView = frameState.cullingVolume.computeVisibility(boundingSphere) === Cesium.Intersect.OUTSIDE;
+    shadowMap._needsUpdate = !shadowMap._outOfView && !shadowMap._boundingSphere.equals(boundingSphere);
+    Cesium.BoundingSphere.clone(boundingSphere, shadowMap._boundingSphere);
+  }
+}
+function updateCameras(shadowMap, frameState) {
+  var camera = frameState.camera; // The actual camera in the scene
+  var lightCamera = shadowMap._lightCamera; // The external camera representing the light source
+  var sceneCamera = shadowMap._sceneCamera; // Clone of camera, with clamped near and far planes
+  var shadowMapCamera = shadowMap._shadowMapCamera; // Cesium.Camera representing the shadow volume, initially cloned from lightCamera
+
+  // Clone light camera into the shadow map camera
+  if (shadowMap._cascadesEnabled) {
+    Cesium.Cartesian3.clone(lightCamera.directionWC, shadowMapCamera.directionWC);
+  } else if (shadowMap._isPointLight) {
+    Cesium.Cartesian3.clone(lightCamera.positionWC, shadowMapCamera.positionWC);
+  } else {
+    shadowMapCamera.clone(lightCamera);
+  }
+
+  // Get the light direction in eye coordinates
+  var lightDirection = shadowMap._lightDirectionEC;
+  Cesium.Matrix4.multiplyByPointAsVector(camera.viewMatrix, shadowMapCamera.directionWC, lightDirection);
+  Cesium.Cartesian3.normalize(lightDirection, lightDirection);
+  Cesium.Cartesian3.negate(lightDirection, lightDirection);
+
+  // Get the light position in eye coordinates
+  Cesium.Matrix4.multiplyByPoint(camera.viewMatrix, shadowMapCamera.positionWC, shadowMap._lightPositionEC);
+  shadowMap._lightPositionEC.w = shadowMap._pointLightRadius;
+
+  // Get the near and far of the scene camera
+  var near;
+  var far;
+  if (shadowMap.isViewShed) {
+    near = lightCamera.frustum.near;
+    far = lightCamera.frustum.far;
+  } else if (shadowMap._fitNearFar) {
+    // shadowFar can be very large, so limit to shadowMap.maximumDistance
+    // Push the far plane slightly further than the near plane to avoid degenerate frustum
+    near = Math.min(frameState.shadowState.nearPlane, shadowMap.maximumDistance);
+    far = Math.min(frameState.shadowState.farPlane, shadowMap.maximumDistance + 1.0);
+  } else {
+    near = camera.frustum.near;
+    far = shadowMap.maximumDistance;
+  }
+  shadowMap._sceneCamera = Cesium.Camera.clone(camera, sceneCamera);
+  camera.frustum.clone(shadowMap._sceneCamera.frustum);
+  shadowMap._sceneCamera.frustum.near = near;
+  shadowMap._sceneCamera.frustum.far = far;
+  shadowMap._distance = far - near;
+  checkVisibility(shadowMap, frameState);
+  if (!shadowMap._outOfViewPrevious && shadowMap._outOfView) {
+    shadowMap._needsUpdate = true;
+  }
+  shadowMap._outOfViewPrevious = shadowMap._outOfView;
+}
+
+/**
+ * @private
+ */
+ViewshedMap.prototype.update = function (frameState) {
+  updateCameras(this, frameState);
+  if (this._needsUpdate) {
+    updateFramebuffer(this, frameState.context);
+    if (this._isPointLight) {
+      computeOmnidirectional(this, frameState);
+    }
+    if (this._cascadesEnabled) {
+      fitShadowMapToScene(this, frameState);
+      if (this._numberOfCascades > 1) {
+        computeCascades(this, frameState);
+      }
+    }
+    if (!this._isPointLight) {
+      // Compute the culling volume
+      var shadowMapCamera = this._shadowMapCamera;
+      var position = shadowMapCamera.positionWC;
+      var direction = shadowMapCamera.directionWC;
+      var up = shadowMapCamera.upWC;
+      this._shadowMapCullingVolume = shadowMapCamera.frustum.computeCullingVolume(position, direction, up);
+      if (this._passes.length === 1) {
+        // Since there is only one pass, use the shadow map camera as the pass camera.
+        this._passes[0].camera.clone(shadowMapCamera);
+      }
+    } else {
+      this._shadowMapCullingVolume = Cesium.CullingVolume.fromBoundingSphere(this._boundingSphere);
+    }
+  }
+  if (this._passes.length === 1) {
+    // Transforms from eye space to shadow texture space.
+    // Always requires an update since the scene camera constantly changes.
+    var inverseView = this._sceneCamera.inverseViewMatrix;
+    Cesium.Matrix4.multiply(this._shadowMapCamera.getViewProjection(), inverseView, this._shadowMapMatrix);
+  }
+  if (this.debugShow) {
+    applyDebugSettings(this, frameState);
+  }
+};
+
+/**
+ * @private
+ */
+ViewshedMap.prototype.updatePass = function (context, shadowPass) {
+  clearFramebuffer(this, context, shadowPass);
+};
+var scratchTexelStepSize = new Cesium.Cartesian2();
+function combineUniforms(shadowMap, uniforms, isTerrain) {
+  var bias = shadowMap._isPointLight ? shadowMap._pointBias : isTerrain ? shadowMap._terrainBias : shadowMap._primitiveBias;
+  var mapUniforms = {
+    shadowMap_texture: function shadowMap_texture() {
+      return shadowMap._shadowMapTexture;
+    },
+    shadowMap_textureCube: function shadowMap_textureCube() {
+      return shadowMap._shadowMapTexture;
+    },
+    shadowMap_matrix: function shadowMap_matrix() {
+      return shadowMap._shadowMapMatrix;
+    },
+    shadowMap_cascadeSplits: function shadowMap_cascadeSplits() {
+      return shadowMap._cascadeSplits;
+    },
+    shadowMap_cascadeMatrices: function shadowMap_cascadeMatrices() {
+      return shadowMap._cascadeMatrices;
+    },
+    shadowMap_lightDirectionEC: function shadowMap_lightDirectionEC() {
+      return shadowMap._lightDirectionEC;
+    },
+    shadowMap_lightPositionEC: function shadowMap_lightPositionEC() {
+      return shadowMap._lightPositionEC;
+    },
+    shadowMap_cascadeDistances: function shadowMap_cascadeDistances() {
+      return shadowMap._cascadeDistances;
+    },
+    shadowMap_texelSizeDepthBiasAndNormalShadingSmooth: function shadowMap_texelSizeDepthBiasAndNormalShadingSmooth() {
+      var texelStepSize = scratchTexelStepSize;
+      texelStepSize.x = 1.0 / shadowMap._textureSize.x;
+      texelStepSize.y = 1.0 / shadowMap._textureSize.y;
+      return Cesium.Cartesian4.fromElements(texelStepSize.x, texelStepSize.y, bias.depthBias, bias.normalShadingSmooth, this.combinedUniforms1);
+    },
+    shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness: function shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness() {
+      return Cesium.Cartesian4.fromElements(bias.normalOffsetScale, shadowMap._distance, shadowMap.maximumDistance, shadowMap._darkness, this.combinedUniforms2);
+    },
+    combinedUniforms1: new Cesium.Cartesian4(),
+    combinedUniforms2: new Cesium.Cartesian4()
+  };
+  return Cesium.combine(uniforms, mapUniforms, false);
+}
+function getShadowReceiveShaderKeyword(shadowMap, castShadows, isTerrain, hasTerrainNormal) {
+  var usesDepthTexture = shadowMap._usesDepthTexture;
+  var polygonOffsetSupported = shadowMap._polygonOffsetSupported;
+  var isPointLight = shadowMap._isPointLight;
+  var isSpotLight = shadowMap._isSpotLight;
+  var hasCascades = shadowMap._numberOfCascades > 1;
+  var debugCascadeColors = shadowMap.debugCascadeColors;
+  var softShadows = shadowMap.softShadows;
+  return 'view receiveShadow ' + usesDepthTexture + polygonOffsetSupported + isPointLight + isSpotLight + hasCascades + debugCascadeColors + softShadows + castShadows + isTerrain + hasTerrainNormal;
+}
+function createShadowReceiveFragmentShader(fs, shadowMap, castShadows, isTerrain, hasTerrainNormal) {
+  var normalVaryingName = Cesium.ShaderSource.findNormalVarying(fs);
+  var hasNormalVarying = !isTerrain && Cesium.defined(normalVaryingName) || isTerrain && hasTerrainNormal;
+  var positionVaryingName = Cesium.ShaderSource.findPositionVarying(fs);
+  var hasPositionVarying = Cesium.defined(positionVaryingName);
+  var usesDepthTexture = shadowMap._usesDepthTexture;
+  var polygonOffsetSupported = shadowMap._polygonOffsetSupported;
+  var isPointLight = shadowMap._isPointLight;
+  var isSpotLight = shadowMap._isSpotLight;
+  var hasCascades = shadowMap._numberOfCascades > 1;
+  var debugCascadeColors = shadowMap.debugCascadeColors;
+  var softShadows = shadowMap.softShadows;
+  var bias = isPointLight ? shadowMap._pointBias : isTerrain ? shadowMap._terrainBias : shadowMap._primitiveBias;
+  var defines = fs.defines.slice(0);
+  var sources = fs.sources.slice(0);
+  var length = sources.length;
+  for (var _i4 = 0; _i4 < length; ++_i4) {
+    sources[_i4] = Cesium.ShaderSource.replaceMain(sources[_i4], 'czm_shadow_receive_main');
+  }
+  if (isPointLight) {
+    defines.push('USE_CUBE_MAP_SHADOW');
+  } else if (usesDepthTexture) {
+    defines.push('USE_SHADOW_DEPTH_TEXTURE');
+  }
+  if (softShadows && !isPointLight) {
+    defines.push('USE_SOFT_SHADOWS');
+  }
+
+  // Enable day-night shading so that the globe is dark when the light is below the horizon
+  if (hasCascades && castShadows && isTerrain) {
+    if (hasNormalVarying) {
+      defines.push('ENABLE_VERTEX_LIGHTING');
+    } else {
+      defines.push('ENABLE_DAYNIGHT_SHADING');
+    }
+  }
+  if (castShadows && bias.normalShading && hasNormalVarying) {
+    defines.push('USE_NORMAL_SHADING');
+    if (bias.normalShadingSmooth > 0.0) {
+      defines.push('USE_NORMAL_SHADING_SMOOTH');
+    }
+  }
+  var fsSource = '';
+  if (isPointLight) {
+    fsSource += 'uniform samplerCube shadowMap_textureCube; \n';
+  } else {
+    fsSource += 'uniform sampler2D shadowMap_texture; \n';
+  }
+  var returnPositionEC;
+  if (hasPositionVarying) {
+    returnPositionEC = '    return vec4(' + positionVaryingName + ', 1.0); \n';
+  } else {
+    returnPositionEC = '#ifndef LOG_DEPTH \n' + '    return czm_windowToEyeCoordinates(gl_FragCoord); \n' + '#else \n' + '    return vec4(v_logPositionEC, 1.0); \n' + '#endif \n';
+  }
+  fsSource += 'uniform mat4 shadowMap_matrix; \n' + 'uniform vec3 shadowMap_lightDirectionEC; \n' + 'uniform vec4 shadowMap_lightPositionEC; \n' + 'uniform vec4 shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness; \n' + 'uniform vec4 shadowMap_texelSizeDepthBiasAndNormalShadingSmooth; \n' + '#ifdef LOG_DEPTH \n' + 'in vec3 v_logPositionEC; \n' + '#endif \n' + 'vec4 getPositionEC() \n' + '{ \n' + returnPositionEC + '} \n' + 'vec3 getNormalEC() \n' + '{ \n' + (hasNormalVarying ? '    return normalize(' + normalVaryingName + '); \n' : '    return vec3(1.0); \n') + '} \n' +
+  // Offset the shadow position in the direction of the normal for perpendicular and back faces
+  'void applyNormalOffset(inout vec4 positionEC, vec3 normalEC, float nDotL) \n' + '{ \n' + (bias.normalOffset && hasNormalVarying ? '    float normalOffset = shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.x; \n' + '    float normalOffsetScale = 1.0 - nDotL; \n' + '    vec3 offset = normalOffset * normalOffsetScale * normalEC; \n' + '    positionEC.xyz += offset; \n' : '') + '} \n';
+  fsSource += 'void main() \n' + '{ \n' + '    czm_shadow_receive_main(); \n' + '    vec4 positionEC = getPositionEC(); \n' + '    vec3 normalEC = getNormalEC(); \n' + '    float depth = -positionEC.z; \n';
+  fsSource += '    czm_shadowParameters shadowParameters; \n' + '    shadowParameters.texelStepSize = shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.xy; \n' + '    shadowParameters.depthBias = shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.z; \n' + '    shadowParameters.normalShadingSmooth = shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.w; \n' + '    shadowParameters.darkness = shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.w; \n';
+  if (isTerrain) {
+    // Scale depth bias based on view distance to reduce z-fighting in distant terrain
+    fsSource += '    shadowParameters.depthBias *= max(depth * 0.01, 1.0); \n';
+  } else if (!polygonOffsetSupported) {
+    // If polygon offset isn't supported push the depth back based on view, however this
+    // causes light leaking at further away views
+    fsSource += '    shadowParameters.depthBias *= mix(1.0, 100.0, depth * 0.0015); \n';
+  }
+  if (isPointLight) {
+    fsSource += '    vec3 directionEC = positionEC.xyz - shadowMap_lightPositionEC.xyz; \n' + '    float distance = length(directionEC); \n' + '    directionEC = normalize(directionEC); \n' + '    float radius = shadowMap_lightPositionEC.w; \n' + '    // Stop early if the fragment is beyond the point light radius \n' + '    if (distance > radius) \n' + '    { \n' + '        return; \n' + '    } \n' + '    vec3 directionWC  = czm_inverseViewRotation * directionEC; \n' + '    shadowParameters.depth = distance / radius; \n' + '    shadowParameters.nDotL = clamp(dot(normalEC, -directionEC), 0.0, 1.0); \n' + '    shadowParameters.texCoords = directionWC; \n' + '    float visibility = czm_shadowVisibility(shadowMap_textureCube, shadowParameters); \n';
+  } else if (isSpotLight) {
+    fsSource += '    vec3 directionEC1 = positionEC.xyz - shadowMap_lightPositionEC.xyz; \n' + '    float distance = length(directionEC1); \n' + '    if (distance > shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.y) \n' + '    { \n' + '        return; \n' + '    } \n' + '    vec3 directionEC = normalize(positionEC.xyz - shadowMap_lightPositionEC.xyz); \n' + '    float nDotL = clamp(dot(normalEC, -directionEC), 0.0, 1.0); \n' + '    applyNormalOffset(positionEC, normalEC, nDotL); \n' + '    vec4 shadowPosition = shadowMap_matrix * positionEC; \n' + '    // Spot light uses a perspective projection, so perform the perspective divide \n' + '    shadowPosition /= shadowPosition.w; \n' + '    // Stop early if the fragment is not in the shadow bounds \n' + '    if (any(lessThan(shadowPosition.xyz, vec3(0.0))) || any(greaterThan(shadowPosition.xyz, vec3(1.0)))) \n' + '    { \n' + '        return; \n' + '    } \n' + '    shadowParameters.texCoords = shadowPosition.xy; \n' + '    shadowParameters.depth = shadowPosition.z; \n' + '    shadowParameters.nDotL = nDotL; \n' + '    float visibility = czm_shadowVisibility(shadowMap_texture, shadowParameters); \n';
+  } else if (hasCascades) {
+    fsSource += '    float maxDepth = shadowMap_cascadeSplits[1].w; \n' + '    // Stop early if the eye depth exceeds the last cascade \n' + '    if (depth > maxDepth) \n' + '    { \n' + '        return; \n' + '    } \n' + '    // Get the cascade based on the eye-space depth \n' + '    vec4 weights = czm_cascadeWeights(depth); \n' + '    // Apply normal offset \n' + '    float nDotL = clamp(dot(normalEC, shadowMap_lightDirectionEC), 0.0, 1.0); \n' + '    applyNormalOffset(positionEC, normalEC, nDotL); \n' + '    // Transform position into the cascade \n' + '    vec4 shadowPosition = czm_cascadeMatrix(weights) * positionEC; \n' + '    // Get visibility \n' + '    shadowParameters.texCoords = shadowPosition.xy; \n' + '    shadowParameters.depth = shadowPosition.z; \n' + '    shadowParameters.nDotL = nDotL; \n' + '    float visibility = czm_shadowVisibility(shadowMap_texture, shadowParameters); \n' + '    // Fade out shadows that are far away \n' + '    float shadowMapMaximumDistance = shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.z; \n' + '    float fade = max((depth - shadowMapMaximumDistance * 0.8) / (shadowMapMaximumDistance * 0.2), 0.0); \n' + '    visibility = mix(visibility, 1.0, fade); \n' + (debugCascadeColors ? '    // Draw cascade colors for debugging \n' + '    out_FragColor *= czm_cascadeColor(weights); \n' : '');
+  } else {
+    fsSource += '    float nDotL = clamp(dot(normalEC, shadowMap_lightDirectionEC), 0.0, 1.0); \n' + '    applyNormalOffset(positionEC, normalEC, nDotL); \n' + '    vec4 shadowPosition = shadowMap_matrix * positionEC; \n' + '    // Stop early if the fragment is not in the shadow bounds \n' + '    if (any(lessThan(shadowPosition.xyz, vec3(0.0))) || any(greaterThan(shadowPosition.xyz, vec3(1.0)))) \n' + '    { \n' + '        return; \n' + '    } \n' + '    shadowParameters.texCoords = shadowPosition.xy; \n' + '    shadowParameters.depth = shadowPosition.z; \n' + '    shadowParameters.nDotL = nDotL; \n' + '    float visibility = czm_shadowVisibility(shadowMap_texture, shadowParameters); \n';
+  }
+  fsSource += '   if(visibility==0.0) \n' + '   {\n' + '        out_FragColor.rgb *= vec3(0.8,0.0,0.0);\n' + '   }else{\n' + '        out_FragColor.rgb *= vec3(0.0,0.8,0.0) * visibility;\n' + '   } \n ' + '} \n ';
+  sources.push(fsSource);
+  return new Cesium.ShaderSource({
+    defines: defines,
+    sources: sources
+  });
+}
+Cesium.ShadowMap.createReceiveDerivedCommand = function (lightShadowMaps, command, shadowsDirty, context, result) {
+  if (!Cesium.defined(result)) {
+    result = {};
+  }
+  var lightShadowMapsEnabled = lightShadowMaps.length > 0;
+  var shaderProgram = command.shaderProgram;
+  var vertexShaderSource = shaderProgram.vertexShaderSource;
+  var fragmentShaderSource = shaderProgram.fragmentShaderSource;
+  var isTerrain = command.pass === Cesium.Pass.GLOBE;
+  var hasTerrainNormal = false;
+  if (isTerrain) {
+    hasTerrainNormal = command.owner.data.renderedMesh.encoding.hasVertexNormals;
+  }
+  if (command.receiveShadows && lightShadowMapsEnabled) {
+    // Only generate a receiveCommand if there is a shadow map originating from a light source.
+    var receiveShader;
+    var receiveUniformMap;
+    if (Cesium.defined(result.receiveCommand)) {
+      receiveShader = result.receiveCommand.shaderProgram;
+      receiveUniformMap = result.receiveCommand.uniformMap;
+    }
+    result.receiveCommand = Cesium.DrawCommand.shallowClone(command, result.receiveCommand);
+    result.castShadows = false;
+    result.receiveShadows = true;
+
+    // If castShadows changed, recompile the receive shadows shader. The normal shading technique simulates
+    // self-shadowing so it should be turned off if castShadows is false.
+    var castShadowsDirty = result.receiveShaderCastShadows !== command.castShadows;
+    var shaderDirty = result.receiveShaderProgramId !== command.shaderProgram.id;
+    if (!Cesium.defined(receiveShader) || shaderDirty || shadowsDirty || castShadowsDirty) {
+      var keyword;
+      if (lightShadowMaps[0].isViewShed) {
+        keyword = getShadowReceiveShaderKeyword(lightShadowMaps[0], command.castShadows, isTerrain, hasTerrainNormal);
+      } else {
+        keyword = Cesium.ShadowMapShader.getShadowReceiveShaderKeyword(lightShadowMaps[0], command.castShadows, isTerrain, hasTerrainNormal);
+      }
+      receiveShader = context.shaderCache.getDerivedShaderProgram(shaderProgram, keyword);
+      if (!Cesium.defined(receiveShader)) {
+        var receiveVS = Cesium.ShadowMapShader.createShadowReceiveVertexShader(vertexShaderSource, isTerrain, hasTerrainNormal);
+        var receiveFS;
+        if (lightShadowMaps[0].isViewShed) {
+          receiveFS = createShadowReceiveFragmentShader(fragmentShaderSource, lightShadowMaps[0], command.castShadows, isTerrain, hasTerrainNormal);
+        } else {
+          receiveFS = Cesium.ShadowMapShader.createShadowReceiveFragmentShader(fragmentShaderSource, lightShadowMaps[0], command.castShadows, isTerrain, hasTerrainNormal);
+        }
+        receiveShader = context.shaderCache.createDerivedShaderProgram(shaderProgram, keyword, {
+          vertexShaderSource: receiveVS,
+          fragmentShaderSource: receiveFS,
+          attributeLocations: shaderProgram._attributeLocations
+        });
+      }
+      receiveUniformMap = combineUniforms(lightShadowMaps[0], command.uniformMap, isTerrain);
+    }
+    result.receiveCommand.shaderProgram = receiveShader;
+    result.receiveCommand.uniformMap = receiveUniformMap;
+    result.receiveShaderProgramId = command.shaderProgram.id;
+    result.receiveShaderCastShadows = command.castShadows;
+  }
+  return result;
+};
+
+/**
+ * @private
+ */
+ViewshedMap.prototype.isDestroyed = function () {
+  return false;
+};
+
+/**
+ * @private
+ */
+ViewshedMap.prototype.destroy = function () {
+  destroyFramebuffer(this);
+  this._debugLightFrustum = this._debugLightFrustum && this._debugLightFrustum.destroy();
+  this._debugCameraFrustum = this._debugCameraFrustum && this._debugCameraFrustum.destroy();
+  this._debugShadowViewCommand = this._debugShadowViewCommand && this._debugShadowViewCommand.shaderProgram && this._debugShadowViewCommand.shaderProgram.destroy();
+  for (var _i5 = 0; _i5 < this._numberOfCascades; ++_i5) {
+    this._debugCascadeFrustums[_i5] = this._debugCascadeFrustums[_i5] && this._debugCascadeFrustums[_i5].destroy();
+  }
+  return Cesium.destroyObject(this);
+};
+export default ViewshedMap;