add @dc-modules/effect

modules/effect/Effect.js

+/**
+ * @Author: Caven
+ * @Date: 2020-08-14 23:49:14
+ */
+
+import BlackAndWhite from './type/BlackAndWhite'
+import Bloom from './type/Bloom'
+import Brightness from './type/Brightness'
+import DepthOfField from './type/DepthOfField'
+import LensFlare from './type/LensFlare'
+import NightVision from './type/NightVision'
+import Silhouette from './type/Silhouette'
+
+class Effect {
+  constructor() {
+    this._comps = {
+      blackAndWhite: new BlackAndWhite(),
+      bloom: new Bloom(),
+      brightness: new Brightness(),
+      depthOfField: new DepthOfField(),
+      lensFlare: new LensFlare(),
+      night: new NightVision(),
+      silhouette: new Silhouette()
+    }
+  }
+
+  get blackAndWhite() {
+    return this._comps.blackAndWhite
+  }
+
+  get bloom() {
+    return this._comps.bloom
+  }
+
+  get brightness() {
+    return this._comps.brightness
+  }
+
+  get depthOfField() {
+    return this._comps.depthOfField
+  }
+
+  get lensFlare() {
+    return this._comps.lensFlare
+  }
+
+  get night() {
+    return this._comps.night
+  }
+
+  get silhouette() {
+    return this._comps.silhouette
+  }
+
+  /**
+   *
+   * @param viewer
+   */
+  install(viewer) {
+    Object.keys(this._comps).forEach(key => {
+      this._comps[key].addTo(viewer)
+    })
+    Object.defineProperty(viewer, 'effect', {
+      value: this,
+      writable: false
+    })
+  }
+}
+
+export default Effect

modules/effect/type/BlackAndWhite.js

+/**
+ * @Author: Caven
+ * @Date: 2020-08-14 23:51:47
+ */
+
+import State from '@dc-modules/state/State'
+
+const { Cesium } = DC.Namespace
+
+class BlackAndWhite {
+  constructor() {
+    this._viewer = undefined
+    this._delegate = undefined
+    this._enable = false
+    this._gradations = 1
+    this._selected = []
+    this.type = 'black_and_white'
+    this._state = State.INITIALIZED
+  }
+
+  set enable(enable) {
+    this._enable = enable
+    if (enable && this._viewer && !this._delegate) {
+      this._createPostProcessStage()
+    }
+    this._delegate && (this._delegate.enabled = enable)
+    return this
+  }
+
+  get enable() {
+    return this._enable
+  }
+
+  set gradations(gradations) {
+    this._gradations = gradations
+    this._delegate && (this._delegate.uniforms.gradations = gradations)
+    return this
+  }
+
+  get gradations() {
+    return this._gradations
+  }
+
+  set selected(selected) {
+    this._selected = selected
+    this._delegate && (this._delegate.selected = selected)
+    return this
+  }
+
+  get selected() {
+    return this._selected
+  }
+
+  /**
+   *
+   * @private
+   */
+  _createPostProcessStage() {
+    this._delegate = Cesium.PostProcessStageLibrary.createBlackAndWhiteStage()
+    if (this._delegate) {
+      this._delegate.uniforms.gradations = this._gradations
+      this._viewer.scene.postProcessStages.add(this._delegate)
+    }
+  }
+
+  /**
+   *
+   * @param viewer
+   * @returns {BlackAndWhite}
+   */
+  addTo(viewer) {
+    if (!viewer) {
+      return this
+    }
+    this._viewer = viewer
+    this._state = State.ADDED
+    return this
+  }
+}
+
+export default BlackAndWhite

modules/effect/type/Bloom.js

+/**
+ * @Author: Caven
+ * @Date: 2020-08-14 23:50:27
+ */
+
+import State from '@dc-modules/state/State'
+
+class Bloom {
+  constructor() {
+    this._viewer = undefined
+    this._enable = false
+    this._contrast = 128
+    this._brightness = -0.3
+    this._glowOnly = false
+    this._delta = 1
+    this._sigma = 3.8
+    this._stepSize = 5
+    this._selected = []
+    this.type = 'bloom'
+    this._state = State.INITIALIZED
+  }
+
+  set enable(enable) {
+    this._enable = enable
+    if (enable && this._viewer && !this._delegate) {
+      this._createPostProcessStage()
+    }
+    this._delegate && (this._delegate.enabled = enable)
+    return this
+  }
+
+  get enable() {
+    return this._enable
+  }
+
+  set contrast(contrast) {
+    this._contrast = contrast
+    this._delegate && (this._delegate.uniforms.contrast = contrast)
+    return this
+  }
+
+  get contrast() {
+    return this._contrast
+  }
+
+  set brightness(brightness) {
+    this._brightness = brightness
+    this._delegate && (this._delegate.uniforms.brightness = brightness)
+    return this
+  }
+
+  get brightness() {
+    return this._brightness
+  }
+
+  set glowOnly(glowOnly) {
+    this._glowOnly = glowOnly
+    this._delegate && (this._delegate.uniforms.glowOnly = glowOnly)
+    return this
+  }
+
+  get glowOnly() {
+    return this._glowOnly
+  }
+
+  set delta(delta) {
+    this._delta = delta
+    this._delegate && (this._delegate.uniforms.delta = delta)
+    return this
+  }
+
+  get delta() {
+    return this._delta
+  }
+
+  set sigma(sigma) {
+    this._sigma = sigma
+    this._delegate && (this._delegate.uniforms.sigma = sigma)
+    return this
+  }
+
+  get sigma() {
+    return this._sigma
+  }
+
+  set stepSize(stepSize) {
+    this._stepSize = stepSize
+    this._delegate && (this._delegate.uniforms.stepSize = stepSize)
+    return this
+  }
+
+  get stepSize() {
+    return this._stepSize
+  }
+
+  set selected(selected) {
+    this._selected = selected
+    this._delegate && (this._delegate.selected = selected)
+    return this
+  }
+
+  get selected() {
+    return this._selected
+  }
+
+  /**
+   *
+   * @private
+   */
+  _createPostProcessStage() {
+    this._delegate = this._viewer.scene.postProcessStages.bloom
+    this._delegate.uniforms.contrast = this._contrast
+    this._delegate.uniforms.brightness = this._brightness
+    this._delegate.uniforms.glowOnly = this._glowOnly
+    this._delegate.uniforms.delta = this._delta
+    this._delegate.uniforms.sigma = this._sigma
+    this._delegate.uniforms.stepSize = this._stepSize
+  }
+
+  /**
+   *
+   * @param viewer
+   * @returns {Bloom}
+   */
+  addTo(viewer) {
+    if (!viewer) {
+      return this
+    }
+    this._viewer = viewer
+    this._state = State.ADDED
+    return this
+  }
+}
+
+export default Bloom

modules/effect/type/Brightness.js

+/**
+ * @Author: Caven
+ * @Date: 2020-08-14 23:51:47
+ */
+
+import State from '@dc-modules/state/State'
+
+const { Cesium } = DC.Namespace
+
+class Brightness {
+  constructor() {
+    this._viewer = undefined
+    this._delegate = undefined
+    this._enable = false
+    this._intensity = 1
+    this._selected = []
+    this.type = 'brightness'
+    this._state = State.INITIALIZED
+  }
+
+  set enable(enable) {
+    this._enable = enable
+    if (enable && this._viewer && !this._delegate) {
+      this._createPostProcessStage()
+    }
+    this._delegate && (this._delegate.enabled = enable)
+    return this
+  }
+
+  get enable() {
+    return this._enable
+  }
+
+  set intensity(intensity) {
+    this._intensity = intensity
+    this._delegate && (this._delegate.uniforms.brightness = intensity)
+    return this
+  }
+
+  get intensity() {
+    return this._intensity
+  }
+
+  set selected(selected) {
+    this._selected = selected
+    this._delegate && (this._delegate.selected = selected)
+    return this
+  }
+
+  get selected() {
+    return this._selected
+  }
+
+  /**
+   *
+   * @private
+   */
+  _createPostProcessStage() {
+    this._delegate = Cesium.PostProcessStageLibrary.createBrightnessStage()
+    if (this._delegate) {
+      this._delegate.uniforms.brightness = this._intensity
+      this._viewer.scene.postProcessStages.add(this._delegate)
+    }
+  }
+
+  /**
+   *
+   * @param viewer
+   * @returns {Brightness}
+   */
+  addTo(viewer) {
+    if (!viewer) {
+      return this
+    }
+    this._viewer = viewer
+    this._state = State.ADDED
+    return this
+  }
+}
+
+export default Brightness

modules/effect/type/DepthOfField.js

+/**
+ * @Author: Caven
+ * @Date: 2020-08-14 23:51:47
+ */
+
+import State from '@dc-modules/state/State'
+
+const { Cesium } = DC.Namespace
+
+class DepthOfField {
+  constructor() {
+    this._viewer = undefined
+    this._delegate = undefined
+    this._enable = false
+    this._focalDistance = 87
+    this._delta = 1
+    this._sigma = 3.8
+    this._stepSize = 2.5
+    this._selected = []
+    this.type = 'depth_of_field'
+    this._state = State.INITIALIZED
+  }
+
+  set enable(enable) {
+    this._enable = enable
+    if (
+      enable &&
+      this._viewer &&
+      Cesium.PostProcessStageLibrary.isDepthOfFieldSupported(
+        this._viewer.scene
+      ) &&
+      !this._delegate
+    ) {
+      this._createPostProcessStage()
+    }
+    this._delegate && (this._delegate.enabled = enable)
+    return this
+  }
+
+  get enable() {
+    return this._enable
+  }
+
+  set focalDistance(focalDistance) {
+    this._focalDistance = focalDistance
+    this._delegate && (this._delegate.uniforms.focalDistance = focalDistance)
+    return this
+  }
+
+  get focalDistance() {
+    return this._focalDistance
+  }
+
+  set delta(delta) {
+    this._delta = delta
+    this._delegate && (this._delegate.uniforms.delta = delta)
+    return this
+  }
+
+  get delta() {
+    return this._delta
+  }
+
+  set sigma(sigma) {
+    this._sigma = sigma
+    this._delegate && (this._delegate.uniforms.sigma = sigma)
+    return this
+  }
+
+  get sigma() {
+    return this._sigma
+  }
+
+  set stepSize(stepSize) {
+    this._stepSize = stepSize
+    this._delegate && (this._delegate.uniforms.stepSize = stepSize)
+    return this
+  }
+
+  get stepSize() {
+    return this._stepSize
+  }
+
+  set selected(selected) {
+    this._selected = selected
+    this._delegate && (this._delegate.selected = selected)
+    return this
+  }
+
+  get selected() {
+    return this._selected
+  }
+
+  /**
+   *
+   * @private
+   */
+  _createPostProcessStage() {
+    this._delegate = Cesium.PostProcessStageLibrary.createDepthOfFieldStage()
+    if (this._delegate) {
+      this._delegate.uniforms.focalDistance = this._focalDistance
+      this._delegate.uniforms.delta = this._delta
+      this._delegate.uniforms.sigma = this._sigma
+      this._delegate.uniforms.stepSize = this._stepSize
+      this._viewer.scene.postProcessStages.add(this._delegate)
+    }
+  }
+
+  /**
+   *
+   * @param viewer
+   * @returns {DepthOfField}
+   */
+  addTo(viewer) {
+    if (!viewer) {
+      return this
+    }
+    this._viewer = viewer
+    this._state = State.ADDED
+    return this
+  }
+}
+
+export default DepthOfField

modules/effect/type/LensFlare.js

+/**
+ * @Author: Caven
+ * @Date: 2020-08-14 23:51:47
+ */
+
+import State from '@dc-modules/state/State'
+
+const { Cesium } = DC.Namespace
+
+class LensFlare {
+  constructor() {
+    this._viewer = undefined
+    this._delegate = undefined
+    this._enable = false
+    this._intensity = 6
+    this._distortion = 61
+    this._dirtAmount = 0.4
+    this._haloWidth = 0.4
+    this._selected = []
+    this.type = 'lens_flare'
+    this._state = State.INITIALIZED
+  }
+
+  set enable(enable) {
+    this._enable = enable
+    if (enable && this._viewer && !this._delegate) {
+      this._createPostProcessStage()
+    }
+    this._delegate && (this._delegate.enabled = enable)
+    return this
+  }
+
+  get enable() {
+    return this._enable
+  }
+
+  set intensity(intensity) {
+    this._intensity = intensity
+    this._delegate && (this._delegate.uniforms.intensity = intensity)
+    return this
+  }
+
+  get intensity() {
+    return this._intensity
+  }
+
+  set distortion(distortion) {
+    this._distortion = distortion
+    this._delegate && (this._delegate.uniforms.distortion = distortion)
+    return this
+  }
+
+  get distortion() {
+    return this._distortion
+  }
+
+  set dirtAmount(dirtAmount) {
+    this._dirtAmount = dirtAmount
+    this._delegate && (this._delegate.uniforms.dirtAmount = dirtAmount)
+    return this
+  }
+
+  get dirtAmount() {
+    return this._dirtAmount
+  }
+
+  set haloWidth(haloWidth) {
+    this._haloWidth = haloWidth
+    this._delegate && (this._delegate.uniforms.haloWidth = haloWidth)
+    return this
+  }
+
+  get haloWidth() {
+    return this._haloWidth
+  }
+
+  set selected(selected) {
+    this._selected = selected
+    this._delegate && (this._delegate.selected = selected)
+    return this
+  }
+
+  get selected() {
+    return this._selected
+  }
+
+  /**
+   *
+   * @private
+   */
+  _createPostProcessStage() {
+    this._delegate = Cesium.PostProcessStageLibrary.createLensFlareStage()
+    if (this._delegate) {
+      this._delegate.uniforms.intensity = this._intensity
+      this._delegate.uniforms.distortion = this._distortion
+      this._delegate.uniforms.dirtAmount = this._dirtAmount
+      this._delegate.uniforms.haloWidth = this._haloWidth
+      this._viewer.scene.postProcessStages.add(this._delegate)
+    }
+  }
+
+  /**
+   *
+   * @param viewer
+   * @returns {LensFlare}
+   */
+  addTo(viewer) {
+    if (!viewer) {
+      return this
+    }
+    this._viewer = viewer
+    this._state = State.ADDED
+    return this
+  }
+}
+
+export default LensFlare

modules/effect/type/NightVision.js

+/**
+ * @Author: Caven
+ * @Date: 2020-08-14 23:10:14
+ */
+
+import State from '@dc-modules/state/State'
+
+const { Cesium } = DC.Namespace
+
+class NightVision {
+  constructor() {
+    this._enable = false
+    this._selected = []
+    this.type = 'night'
+    this._state = State.INITIALIZED
+  }
+
+  set enable(enable) {
+    this._enable = enable
+    if (enable && this._viewer && !this._delegate) {
+      this._createPostProcessStage()
+    }
+    this._delegate && (this._delegate.enabled = enable)
+    return this
+  }
+
+  get enable() {
+    return this._enable
+  }
+
+  set selected(selected) {
+    this._selected = selected
+    this._delegate && (this._delegate.selected = selected)
+    return this
+  }
+
+  get selected() {
+    return this._selected
+  }
+
+  /**
+   *
+   * @private
+   */
+  _createPostProcessStage() {
+    this._delegate = Cesium.PostProcessStageLibrary.createNightVisionStage()
+    if (this._delegate) {
+      this._viewer.scene.postProcessStages.add(this._delegate)
+    }
+  }
+
+  /**
+   *
+   * @param viewer
+   * @returns {NightVision}
+   */
+  addTo(viewer) {
+    if (!viewer) {
+      return this
+    }
+    this._viewer = viewer
+    this._state = State.ADDED
+    return this
+  }
+}
+
+export default NightVision

modules/effect/type/Silhouette.js

+/**
+ * @Author: Caven
+ * @Date: 2020-08-14 23:51:47
+ */
+
+import State from '@dc-modules/state/State'
+
+const { Cesium } = DC.Namespace
+
+class Silhouette {
+  constructor() {
+    this._viewer = undefined
+    this._delegate = undefined
+    this._enable = false
+    this._color = Cesium.Color.GREEN
+    this._length = 0.5
+    this._selected = []
+    this.type = 'silhouette'
+    this._state = State.INITIALIZED
+  }
+
+  set enable(enable) {
+    this._enable = enable
+    if (
+      enable &&
+      this._viewer &&
+      Cesium.PostProcessStageLibrary.isSilhouetteSupported(
+        this._viewer.scene
+      ) &&
+      !this._delegate
+    ) {
+      this._createPostProcessStage()
+    }
+    this._delegate && (this._delegate.enabled = enable)
+    return this
+  }
+
+  get enable() {
+    return this._enable
+  }
+
+  set color(color) {
+    this._color = color
+    this._delegate && (this._delegate.uniforms.color = color)
+    return this
+  }
+
+  get color() {
+    return this._color
+  }
+
+  set length(length) {
+    this._length = length
+    this._delegate && (this._delegate.uniforms.length = length)
+    return this
+  }
+
+  get length() {
+    return this._length
+  }
+
+  set selected(selected) {
+    this._selected = selected
+    this._delegate && (this._delegate.selected = selected)
+    return this
+  }
+
+  get selected() {
+    return this._selected
+  }
+
+  /**
+   *
+   * @private
+   */
+  _createPostProcessStage() {
+    this._delegate = Cesium.PostProcessStageLibrary.createSilhouetteStage()
+    if (this._delegate) {
+      this._delegate.uniforms.color = this._color
+      this._delegate.uniforms.length = this._length
+      this._viewer.scene.postProcessStages.add(this._delegate)
+    }
+  }
+
+  /**
+   *
+   * @param viewer
+   * @returns {Silhouette}
+   */
+  addTo(viewer) {
+    if (!viewer) {
+      return this
+    }
+    this._viewer = viewer
+    this._state = State.ADDED
+    return this
+  }
+}
+
+export default Silhouette