deeptwins-engine-3d 0.1.52 → 0.1.53

package/dist/esm/drawCommand/index.d.ts

@@ -1,2 +1,3 @@
 import ViewShedAnalyserLayer from './viewShed/ViewShedAnalyserLayer';
-export { ViewShedAnalyserLayer };
+import VolumeClouds from './volumeCloud/VolumeClouds';
+export { ViewShedAnalyserLayer, VolumeClouds };

package/dist/esm/drawCommand/index.js

@@ -1,2 +1,3 @@
 import ViewShedAnalyserLayer from "./viewShed/ViewShedAnalyserLayer";
-export { ViewShedAnalyserLayer };
+import VolumeClouds from "./volumeCloud/VolumeClouds";
+export { ViewShedAnalyserLayer, VolumeClouds };

package/dist/esm/drawCommand/volumeCloud/GeometryPrimitive.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Custom Primitive for Geometry
+ */
+declare class GeometryPrimitive {
+    /**
+     *
+     * @param {*} options
+     * @param {*} options.modelMatrix
+     * @param {*} options.vertexShaderSource
+     * @param {*} options.fragmentShaderSource
+     * @param {*} options.uniformMap
+     * @param {*} options.renderState
+     * @param {*} options.pass
+     */
+    private options;
+    private geometry;
+    private _drawCommand;
+    private _boundingSphereWC;
+    constructor(geometry: any, options: any);
+    /**
+     *
+     * @param {*} frameState
+     */
+    update(frameState: any): void;
+    destroy(): void;
+    isDestroyed(): boolean;
+}
+export default GeometryPrimitive;

package/dist/esm/drawCommand/volumeCloud/GeometryPrimitive.js

@@ -0,0 +1,89 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as Cesium from 'deeptwins-cesium';
+/**
+ * Custom Primitive for Geometry
+ */
+var GeometryPrimitive = /*#__PURE__*/function () {
+  function GeometryPrimitive(geometry, options) {
+    _classCallCheck(this, GeometryPrimitive);
+    /**
+     *
+     * @param {*} options
+     * @param {*} options.modelMatrix
+     * @param {*} options.vertexShaderSource
+     * @param {*} options.fragmentShaderSource
+     * @param {*} options.uniformMap
+     * @param {*} options.renderState
+     * @param {*} options.pass
+     */
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "geometry", void 0);
+    _defineProperty(this, "_drawCommand", void 0);
+    _defineProperty(this, "_boundingSphereWC", void 0);
+    this.options = options;
+    this.geometry = geometry;
+  }
+
+  /**
+   *
+   * @param {*} frameState
+   */
+  _createClass(GeometryPrimitive, [{
+    key: "update",
+    value: function update(frameState) {
+      if (Cesium.defined(this._drawCommand)) {
+        frameState.commandList.push(this._drawCommand);
+        return;
+      }
+      if (this.geometry.constructor.createGeometry) {
+        this.geometry = this.geometry.constructor.createGeometry(this.geometry);
+      }
+      var context = frameState.context;
+      var attributeLocations = Cesium.GeometryPipeline.createAttributeLocations(this.geometry);
+      var vertexArray = Cesium.VertexArray.fromGeometry({
+        context: context,
+        geometry: this.geometry,
+        attributeLocations: attributeLocations
+      });
+
+      // calculate boundingSphere
+      var boundingSphere = this.geometry.boundingSphere;
+      boundingSphere.center = Cesium.Matrix4.multiplyByPoint(this.options.modelMatrix, boundingSphere.center, new Cesium.Cartesian3());
+      boundingSphere.radius = 1000000;
+      this._boundingSphereWC = [boundingSphere];
+      var shaderProgram = Cesium.ShaderProgram.fromCache({
+        context: context,
+        attributeLocations: attributeLocations,
+        vertexShaderSource: this.options.vertexShaderSource,
+        fragmentShaderSource: this.options.fragmentShaderSource
+      });
+      this._drawCommand = new Cesium.DrawCommand(_objectSpread({
+        owner: this,
+        boundingVolume: boundingSphere,
+        primitiveType: this.geometry.primitiveType,
+        vertexArray: vertexArray,
+        shaderProgram: shaderProgram
+      }, this.options));
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      return Cesium.destroyObject(this);
+    }
+  }, {
+    key: "isDestroyed",
+    value: function isDestroyed() {
+      return false;
+    }
+  }]);
+  return GeometryPrimitive;
+}();
+export default GeometryPrimitive;

package/dist/esm/drawCommand/volumeCloud/ImprovedNoise.d.ts

@@ -0,0 +1,15 @@
+declare class ImprovedNoise {
+    makeTexture3D(context: any): any;
+    /**
+     * Returns a noise value for the given parameters.
+     *
+     * @param {number} x - The x coordinate.
+     * @param {number} y - The y coordinate.
+     * @param {number} z - The z coordinate.
+     * @return {number} The noise value.
+     */
+    noise(x: number, y: number, z: number): number;
+    fade(t: number): number;
+    grad(hash: number, x: number, y: number, z: number): number;
+}
+export default ImprovedNoise;

package/dist/esm/drawCommand/volumeCloud/ImprovedNoise.js

@@ -0,0 +1,112 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as Cesium from 'deeptwins-cesium';
+var lerp = Cesium.Math.lerp;
+var _p = [151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180];
+for (var i = 0; i < 256; i++) {
+  _p[256 + i] = _p[i];
+}
+var ImprovedNoise = /*#__PURE__*/function () {
+  function ImprovedNoise() {
+    _classCallCheck(this, ImprovedNoise);
+  }
+  _createClass(ImprovedNoise, [{
+    key: "makeTexture3D",
+    value: function makeTexture3D(context) {
+      var size = 100;
+      var dataLength = size * size * size;
+      var data = new Uint8Array(dataLength);
+      var i = 0;
+      var scale = 0.05;
+      var perlin = new ImprovedNoise();
+      var vector = new Cesium.Cartesian3();
+      var halfSize = Cesium.Cartesian3.fromElements(size / 2, size / 2, size / 2, new Cesium.Cartesian3());
+      for (var z = 0; z < size; z++) {
+        for (var y = 0; y < size; y++) {
+          for (var x = 0; x < size; x++) {
+            vector = Cesium.Cartesian3.fromElements(x, y, z, vector);
+            vector = Cesium.Cartesian3.subtract(vector, halfSize, vector);
+            vector = Cesium.Cartesian3.divideByScalar(vector, size, vector);
+            var d = 1.0 - Cesium.Cartesian3.magnitude(vector);
+            var tv = (128 + 128 * perlin.noise(x * scale / 1.5, y * scale, z * scale / 1.5)) * d * d;
+            data[i] = tv;
+            i++;
+          }
+        }
+      }
+      return new Cesium.Texture3D({
+        context: context,
+        width: size,
+        height: size,
+        depth: size,
+        flipY: false,
+        pixelFormat: Cesium.PixelFormat.RED,
+        pixelDatatype: Cesium.PixelDatatype.UNSIGNED_BYTE,
+        source: {
+          arrayBufferView: data,
+          width: size,
+          height: size,
+          depth: size
+        },
+        sampler: new Cesium.Sampler({
+          minificationFilter: Cesium.TextureMinificationFilter.LINEAR,
+          magnificationFilter: Cesium.TextureMagnificationFilter.LINEAR
+        })
+      });
+    }
+
+    /**
+     * Returns a noise value for the given parameters.
+     *
+     * @param {number} x - The x coordinate.
+     * @param {number} y - The y coordinate.
+     * @param {number} z - The z coordinate.
+     * @return {number} The noise value.
+     */
+  }, {
+    key: "noise",
+    value: function noise(x, y, z) {
+      var floorX = Math.floor(x);
+      var floorY = Math.floor(y);
+      var floorZ = Math.floor(z);
+      var X = floorX & 255;
+      var Y = floorY & 255;
+      var Z = floorZ & 255;
+      x -= floorX;
+      y -= floorY;
+      z -= floorZ;
+      var xMinus1 = x - 1;
+      var yMinus1 = y - 1;
+      var zMinus1 = z - 1;
+      var u = this.fade(x);
+      var v = this.fade(y);
+      var w = this.fade(z);
+      var A = _p[X] + Y;
+      var AA = _p[A] + Z;
+      var AB = _p[A + 1] + Z;
+      var B = _p[X + 1] + Y;
+      var BA = _p[B] + Z;
+      var BB = _p[B + 1] + Z;
+      return lerp(lerp(lerp(this.grad(_p[AA], x, y, z), this.grad(_p[BA], xMinus1, y, z), u), lerp(this.grad(_p[AB], x, yMinus1, z), this.grad(_p[BB], xMinus1, yMinus1, z), u), v), lerp(lerp(this.grad(_p[AA + 1], x, y, zMinus1), this.grad(_p[BA + 1], xMinus1, y, zMinus1), u), lerp(this.grad(_p[AB + 1], x, yMinus1, zMinus1), this.grad(_p[BB + 1], xMinus1, yMinus1, zMinus1), u), v), w);
+    }
+  }, {
+    key: "fade",
+    value: function fade(t) {
+      return t * t * t * (t * (t * 6 - 15) + 10);
+    }
+  }, {
+    key: "grad",
+    value: function grad(hash, x, y, z) {
+      var h = hash & 15;
+      var u = h < 8 ? x : y;
+      var v = h < 4 ? y : h === 12 || h === 14 ? x : z;
+      return ((h & 1) === 0 ? u : -u) + ((h & 2) === 0 ? v : -v);
+    }
+  }]);
+  return ImprovedNoise;
+}();
+export default ImprovedNoise;

package/dist/esm/drawCommand/volumeCloud/VolumeClouds.d.ts

@@ -0,0 +1,4 @@
+declare class VolumeClouds {
+    constructor(map: any);
+}
+export default VolumeClouds;

package/dist/esm/drawCommand/volumeCloud/VolumeClouds.js

@@ -0,0 +1,91 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+import * as Cesium from 'deeptwins-cesium';
+import GeometryPrimitive from "./GeometryPrimitive";
+import ImprovedNoise from "./ImprovedNoise";
+var vertexShader = /* glsl */"\nin vec3 position3DHigh;\nin vec3 position3DLow;\nin vec3 normal;\nin vec2 st;\nin float batchId;\n\nout vec3 vOrigin;\nout vec3 vDirection;\nout vec3 vPosition;\n\nvec4 translateRelativeToEye(vec3 high, vec3 low) {\n    vec3 highDifference = high - czm_encodedCameraPositionMCHigh;\n    if(length(highDifference) == 0.0f) {\n        highDifference = vec3(0);\n    }\n    vec3 lowDifference = low - czm_encodedCameraPositionMCLow;\n    return vec4(highDifference + lowDifference, 1.0f);\n}\n\nvoid main()\n{\n    vec4 p = translateRelativeToEye(position3DHigh, position3DLow);\n    \n    vOrigin = czm_encodedCameraPositionMCHigh + czm_encodedCameraPositionMCLow;\n\n    vec3 modelPosition = position3DHigh + position3DLow;\n    vPosition = modelPosition;\n\n    vDirection = modelPosition - vOrigin;\n\n    gl_Position = czm_modelViewProjectionRelativeToEye * p;\n}";
+var fragmentShader = /* glsl */"\nprecision highp float;\nprecision highp sampler3D;\n\nin vec3 vOrigin;\nin vec3 vDirection;\n\n// https://github.com/mrdoob/three.js/blob/dev/examples/webgl_volume_cloud.html\nuniform vec3 base;\nuniform sampler3D map;\n      uniform float threshold;\n      uniform float range;\n      uniform float opacity;\n      uniform float steps;\n      uniform float frame;\n\n      uint wang_hash(uint seed)\n      {\n              seed = (seed ^ 61u) ^ (seed >> 16u);\n              seed *= 9u;\n              seed = seed ^ (seed >> 4u);\n              seed *= 0x27d4eb2du;\n              seed = seed ^ (seed >> 15u);\n              return seed;\n      }\n\n      float randomFloat(inout uint seed)\n      {\n              return float(wang_hash(seed)) / 4294967296.;\n      }\n\n      vec2 hitBox( vec3 orig, vec3 dir ) {\n          const vec3 box_min = vec3( - 0.5 );\n          const vec3 box_max = vec3( 0.5 );\n          vec3 inv_dir = 1.0 / dir;\n          vec3 tmin_tmp = ( box_min - orig ) * inv_dir;\n          vec3 tmax_tmp = ( box_max - orig ) * inv_dir;\n          vec3 tmin = min( tmin_tmp, tmax_tmp );\n          vec3 tmax = max( tmin_tmp, tmax_tmp );\n          float t0 = max( tmin.x, max( tmin.y, tmin.z ) );\n          float t1 = min( tmax.x, min( tmax.y, tmax.z ) );\n          return vec2( t0, t1 );\n      }\n\n    float sample1( vec3 p ) {\n        return texture( map, p ).r;\n    }\n\n    float shading( vec3 coord ) {\n        float step = 0.01;\n        return sample1( coord + vec3( - step ) ) - sample1( coord + vec3( step ) );\n    }\n\n    vec4 linearToSRGB( in vec4 value ) {\n        return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n    }\n\nvoid main() {\n              vec3 rayDir = normalize( vDirection );\n              vec2 bounds = hitBox( vOrigin, rayDir );\n              if ( bounds.x > bounds.y ) discard;\n              bounds.x = max( bounds.x, 0.0 );\n              vec3 p = vOrigin + bounds.x * rayDir;\n              vec3 inc = 1.0 / abs( rayDir );\n              float delta = min( inc.x, min( inc.y, inc.z ) );\n              delta /= steps;\n\n              // Nice little seed from\n              // https://blog.demofox.org/2020/05/25/casual-shadertoy-path-tracing-1-basic-camera-diffuse-emissive/\n              uint seed = uint( gl_FragCoord.x ) * uint( 1973 ) + uint( gl_FragCoord.y ) * uint( 9277 ) + uint( frame ) * uint( 26699 );\n              vec3 size = vec3( textureSize( map, 0 ) );\n              float randNum = randomFloat( seed ) * 2.0 - 1.0;\n              p += rayDir * randNum * ( 1.0 / size );\n\n              vec4 ac = vec4( base, 0.0 );\n              for ( float t = bounds.x; t < bounds.y; t += delta ) {\n                  float d = sample1( p + 0.5 );\n                  d = smoothstep( threshold - range, threshold + range, d ) * opacity;\n                  float col = shading( p + 0.5 ) * 3.0 + ( ( p.x + p.y ) * 0.25 ) + 0.2;\n                  ac.rgb += ( 1.0 - ac.a ) * d * col;\n                  ac.a += ( 1.0 - ac.a ) * d;\n                  if ( ac.a >= 0.95 ) break;\n                  p += rayDir * delta;\n              }\n              vec4 color = linearToSRGB( ac );\n    color = czm_gammaCorrect( color );\n              if ( color.a == 0.0 ) discard;\n    out_FragColor = color;\n}\n";
+var VolumeClouds = /*#__PURE__*/_createClass(function VolumeClouds(map) {
+  _classCallCheck(this, VolumeClouds);
+  var texture3D = new ImprovedNoise().makeTexture3D(map.scene.context);
+  texture3D.generateMipmap();
+  var boxSideLength = 1.0;
+  var zoomScale = 10000;
+  var centerPoint = Cesium.Cartesian3.fromDegrees(113, 33, boxSideLength / 0.5 * zoomScale);
+  var modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(centerPoint);
+  var boxSize = new Cesium.Cartesian3(boxSideLength, boxSideLength, boxSideLength);
+  var renderState = Cesium.RenderState.fromCache({
+    depthMask: false,
+    blending: {
+      enabled: true,
+      color: {
+        red: 0.0,
+        green: 0.0,
+        blue: 0.0,
+        alpha: 0.0
+      }
+    },
+    depthTest: {
+      enabled: true,
+      func: Cesium.DepthFunction.LESS_OR_EQUAL
+    },
+    cull: {
+      enabled: true,
+      face: Cesium.CullFace.FRONT
+    }
+  });
+  var zoomMat = Cesium.Matrix4.fromScale(new Cesium.Cartesian3(zoomScale, zoomScale, zoomScale), new Cesium.Matrix4());
+  Cesium.Matrix4.multiply(modelMatrix, zoomMat, modelMatrix);
+  var halfBox = Cesium.Cartesian3.multiplyByScalar(boxSize, 0.5, new Cesium.Cartesian3());
+  var negHalfBox = Cesium.Cartesian3.negate(halfBox, new Cesium.Cartesian3());
+  var boxGeometry = new Cesium.BoxGeometry({
+    minimum: negHalfBox,
+    maximum: halfBox
+  });
+  var uniforms = {
+    base: new Cesium.Color(0.1912, 0.2542, 0.3515, 0),
+    map: texture3D,
+    opacity: 0.25,
+    range: 0.1,
+    steps: 100,
+    frame: 0,
+    threshold: 0.25
+  };
+  var cmdUniforms = {};
+  var _loop = function _loop(key) {
+    if (key) {
+      cmdUniforms[key] = function () {
+        return uniforms[key];
+      };
+    }
+  };
+  for (var key in uniforms) {
+    _loop(key);
+  }
+  var primitive = new GeometryPrimitive(boxGeometry, {
+    uniformMap: cmdUniforms,
+    vertexShaderSource: vertexShader,
+    fragmentShaderSource: fragmentShader,
+    renderState: renderState,
+    modelMatrix: modelMatrix,
+    pass: Cesium.Pass.TRANSLUCENT
+  });
+  map.scene.primitives.add(primitive);
+  var cameraState = {
+    destination: centerPoint,
+    orientation: {
+      heading: 4.159717744111784,
+      pitch: -0.4648127266675117,
+      roll: boxSideLength * zoomScale * 2
+    },
+    duration: 0
+  };
+  // viewer.camera.flyTo(camState);
+  var hpr = new Cesium.HeadingPitchRange(cameraState.orientation.heading, cameraState.orientation.pitch, boxSideLength * zoomScale * 2);
+  map.camera.lookAt(cameraState.destination, hpr);
+});
+export default VolumeClouds;

package/dist/esm/graphicLayer/BaseSource.d.ts

@@ -15,7 +15,7 @@ export default class BaseSource {
     remove(): void;
     setData(data: any): this | undefined;
     _toDestroy(): void;
-    static analysisSourceType(data: any): "wkt" | "sourceId" | "sourceInstance" | "geoJson" | "clampedPolygonGrid" | "other";
+    static analysisSourceType(data: any): "other" | "wkt" | "sourceId" | "sourceInstance" | "geoJson" | "clampedPolygonGrid";
     static wktToGeoJon(wkt: string): any;
     static geoJsonToGeoCartesian3Array(geoJson: any): any[];
     static handleFeaturePoint(feature: any): any;

package/dist/esm/index.d.ts

@@ -72,5 +72,6 @@ export declare class DeepTwinsEngine3D {
     static FlightRiskEvaluation: any;
     static BuildClampedPolygonGridUnified: any;
     static ViewShedAnalyserLayer: any;
+    static VolumeClouds: any;
 }
 export default DeepTwinsEngine3D;

package/dist/esm/index.js

@@ -54,18 +54,18 @@ import Heatmap2d from "./visualization/Heatmap2d";
 import Heatmap3d from "./visualization/Heatmap3d";
 import PointCluster from "./visualization/PointCluster";
 // drawCommand
-import { ViewShedAnalyserLayer } from "./drawCommand";
+import { ViewShedAnalyserLayer, VolumeClouds } from "./drawCommand";
 window.Cesium = Cesium;
 // 将DEEP_TWINS_BASE_URL赋值给CESIUM_BASE_URL
 DEEP_TWINS_BASE_URL && (window.CESIUM_BASE_URL = DEEP_TWINS_BASE_URL);
 // 全局加载css
 loadCss(Cesium.buildModuleUrl('Widgets/widgets.css'));
 // 打印版本信息
-console.log('DeepTwinsEngine3D Version:', "0.1.52");
+console.log('DeepTwinsEngine3D Version:', "0.1.53");
 export var DeepTwinsEngine3D = /*#__PURE__*/_createClass(function DeepTwinsEngine3D() {
   _classCallCheck(this, DeepTwinsEngine3D);
 });
-_defineProperty(DeepTwinsEngine3D, "Version", "0.1.52");
+_defineProperty(DeepTwinsEngine3D, "Version", "0.1.53");
 _defineProperty(DeepTwinsEngine3D, "Map", Map);
 _defineProperty(DeepTwinsEngine3D, "GroundSkyBox", GroundSkyBox);
 _defineProperty(DeepTwinsEngine3D, "RasterLayer", RasterLayer);
@@ -137,4 +137,5 @@ _defineProperty(DeepTwinsEngine3D, "FlightPlanning", FlightPlanning);
 _defineProperty(DeepTwinsEngine3D, "FlightRiskEvaluation", FlightRiskEvaluation);
 _defineProperty(DeepTwinsEngine3D, "BuildClampedPolygonGridUnified", BuildClampedPolygonGridUnified);
 _defineProperty(DeepTwinsEngine3D, "ViewShedAnalyserLayer", ViewShedAnalyserLayer);
+_defineProperty(DeepTwinsEngine3D, "VolumeClouds", VolumeClouds);
 export default DeepTwinsEngine3D;