earthsdk3-cesium 3.7.0-beta.15 → 3.7.0-beta.17

package/dist/types/ESJTypesCzm/czmObject/CzmLabel.d.ts

@@ -1,6 +1,13 @@
 import * as Cesium from "cesium";
 export type CzmLabel = Partial<{
     position: Cesium.Cartesian3;
+    rotation: number;
+    positions: Cesium.Cartesian3[];
+    letterSpacing: number;
+    textJustify: string;
+    avoidancePadding: number;
+    ignorePlacement: boolean;
+    allowOverlap: boolean;
     id: any;
     text: string;
     show: boolean;

package/dist/types/__declares/cesium.d.ts

@@ -0,0 +1,434 @@
+// cesium声明文件补充
+// 注意此声明文件不全，用到哪儿写到哪儿
+// vtxf 20211215
+import * as Cesium from "cesium";
+declare module 'cesium' {
+    interface Destroyable {
+        isDestroyed(): boolean;
+        destroy(): undefined;
+    }
+
+    interface Context {
+        defaultTexture: Texture;
+    }
+
+    // @ts-ignore
+    type TextureOptions = {
+        context: Context;
+        pixelFormat?: number;
+        width: number;
+        height: number;
+        flipY?: boolean;
+    }
+
+    const enum MipmapHint {
+        DONT_CARE = WebGLConstants.DONT_CARE,
+        FASTEST = WebGLConstants.FASTEST,
+        NICEST = WebGLConstants.NICEST,
+    }
+
+    interface Texture extends Destroyable {
+        copyFrom(options: {
+            // arrayBufferView: ArrayBufferView,
+            // width: number;
+            // height: number;
+            source: {
+                width: number;
+                height: number;
+                arrayBufferView: ArrayBufferView;
+            } | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
+            xOffset?: number;
+            yOffset?: number;
+            skipColorSpaceConversion?: boolean; // false
+        }): void;
+
+        generateMipmap(hint: MipmapHint): void;
+    }
+
+    var Texture: {
+        prototype: Texture;
+        new(options: TextureOptions): Texture;
+    };
+
+    interface Scene {
+        context: Context;
+    }
+
+    interface AttributeLocations {
+        [k: string]: number;
+    }
+
+    const enum BufferUsage {
+        STREAM_DRAW = WebGLConstants.STREAM_DRAW,
+        STATIC_DRAW = WebGLConstants.STATIC_DRAW,
+        DYNAMIC_DRAW = WebGLConstants.DYNAMIC_DRAW,
+    }
+
+    interface VertexArrayOptions {
+        context: Context;
+        attributes: {
+            index: number,
+            vertexBuffer: Buffer,
+            componentsPerAttribute: number,
+            componentDatatype: ComponentDatatype,
+            normalize?: boolean, // false
+        }[];
+        attributeLocations: AttributeLocations;
+        bufferUsage: BufferUsage;
+        indexBuffer?: Buffer;
+    }
+
+    namespace ComponentDatatype {
+        function createTypedArray(componentDatatype: ComponentDatatype, valuesOrLength: number | number[]): Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+    }
+
+    interface VertexArray extends Destroyable {
+        isDestroyed(): boolean;
+        destroy(): undefined;
+    }
+
+    var VertexArray: {
+        prototype: VertexArray;
+        new(options: VertexArrayOptions): VertexArray;
+    }
+
+    // interface ShaderProgramOptions {
+    //     gl: WebGLRenderingContext | WebGL2RenderingContext;
+    //     // debugShaders: boolean; 
+    //     vertexShaderText: string;
+    //     fragmentShaderText: string;
+    //     attributeLocations: AttributeLocations;
+    // }
+
+    interface ShaderProgram extends Destroyable {
+
+    }
+
+    // var ShaderProgram:  {
+    //     prototype: ShaderProgram;
+    //     new(options: ShaderProgramOptions): ShaderProgram;
+    // }
+
+    interface ShaderSource {
+
+    }
+
+    var ShaderSource: {
+        prototype: ShaderSource;
+        new(options: {
+            defines?: string[];
+            sources: string[];
+            includeBuiltIns?: boolean;
+        }): ShaderSource;
+    };
+
+    namespace ShaderProgram {
+        function fromCache(options: {
+            context: Context,
+            vertexShaderSource: ShaderSource,
+            fragmentShaderSource: ShaderSource,
+            attributeLocations: AttributeLocations,
+        }): ShaderProgram;
+    }
+
+    interface UniformMap {
+        [k: string]: () => Texture | number | Cartesian2 | Cartesian3 | Cartesian4;
+    }
+
+    interface RenderState {
+
+    }
+
+    interface RenderStateOptions {
+        frontFace?: WindingOrder, // WindingOrder.COUNTER_CLOCKWISE,
+        cull?: {
+            enabled?: boolean, // false
+            face?: CullFace, // CullFace.BACK
+        },
+        lineWidth?: number, // 1
+        polygonOffset?: {
+            enabled?: boolean, // false
+            factor?: number, // 0,
+            units?: number, // 0
+        },
+        scissorTest?: {
+            enabled?: boolean, // false,
+            rectangle?: {
+                x?: number, // 0,
+                y?: number, // 0,
+                width?: number, // 0,
+                height?: number, // 0
+            }
+        },
+        depthRange?: {
+            near?: number, // 0,
+            far?: number, // 1
+        },
+        depthTest?: {
+            enabled?: boolean; // false,
+            func?: DepthFunction; //DepthFunction.LESS
+        },
+        colorMask?: {
+            red?: boolean, // true,
+            green?: boolean, // true,
+            blue?: boolean, // true,
+            alpha?: boolean, // true
+        },
+        depthMask?: boolean, // true,
+        stencilMask?: number, // ~0
+        blending?: {
+            enabled?: boolean, // false,
+            color?: {
+                red?: number, // 0.0,
+                green?: number, // 0.0,
+                blue?: number, // 0.0,
+                alpha?: number, // 0.0
+            },
+            equationRgb?: BlendEquation, // BlendEquation.ADD,
+            equationAlpha?: BlendEquation, // BlendEquation.ADD,
+            functionSourceRgb?: BlendFunction, // BlendFunction.ONE,
+            functionSourceAlpha?: BlendFunction, // BlendFunction.ONE,
+            functionDestinationRgb?: BlendFunction, // BlendFunction.ZERO,
+            functionDestinationAlpha?: BlendFunction, // BlendFunction.ZERO
+        },
+        stencilTest?: {
+            enabled?: boolean, // false,
+            frontFunction?: StencilFunction, // StencilFunction.ALWAYS,
+            backFunction?: StencilFunction, // StencilFunction.ALWAYS,
+            reference?: number; // 0,
+            mask?: number; // ~0,
+            frontOperation?: {
+                fail?: StencilOperation, // StencilOperation.KEEP,
+                zFail?: StencilOperation, // StencilOperation.KEEP,
+                zPass?: StencilOperation, // StencilOperation.KEEP
+            },
+            backOperation?: {
+                fail?: StencilOperation, // StencilOperation.KEEP,
+                zFail?: StencilOperation, // StencilOperation.KEEP,
+                zPass?: StencilOperation, // StencilOperation.KEEP
+            }
+        },
+        sampleCoverage?: {
+            enabled?: boolean, // false,
+            value?: number, // 1.0,
+            invert?: boolean, // false
+        }
+    }
+
+    namespace RenderState {
+        function fromCache(options: RenderStateOptions): RenderState;
+    }
+
+    namespace Appearance {
+        /**
+         * 
+         * @param translucent 是否是透明的？透明对象的depthMask设为false，blending设为ALPHA_BLEND
+         * @param closed 是否为封闭体，如果是封闭体，会开启背面裁剪 cull { enabled: true, face: CullFace.BACK }
+         * @param existing 是否和一个已存在的RenderState进行合并，已存在的RenderState不做修改
+         */
+        function getDefaultRenderState(translucent: boolean, closed: boolean, existing?: RenderStateOptions): RenderStateOptions;
+    }
+
+
+    const enum Pass {
+        ENVIRONMENT = 0,
+        COMPUTE = 1,
+        GLOBE = 2,
+        TERRAIN_CLASSIFICATION = 3,
+        CESIUM_3D_TILE = 4,
+        CESIUM_3D_TILE_CLASSIFICATION = 5,
+        CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW = 6,
+        OPAQUE = 7,
+        TRANSLUCENT = 8,
+        OVERLAY = 9,
+        NUMBER_OF_PASSES = 10,
+    }
+
+    // interface DrawCommandOptions 
+
+    interface PickId {
+        key: number;
+        color: Cesium.Color;
+    }
+
+    interface DrawCommand {
+        boundingVolume: BoundingRectangle | BoundingSphere | OrientedBoundingBox | undefined;
+        orientedBoundingBox: OrientedBoundingBox | undefined;
+        cull: boolean; // deafult true
+        occlude: boolean; // default true
+        modelMatrix: Cesium.Matrix4 | undefined; // default undefined
+        primitiveType: PrimitiveType; // default TRIANGLES
+        vertexArray: VertexArray | undefined; // default undefined
+        count: number | undefined;
+        offset: number; // default 0
+        instanceCount: number; // default 0
+        shaderProgram: ShaderProgram | undefined; // default undefined
+        castShadows: boolean; // default false
+        receiveShadows: boolean; // default false
+        uniformMap: UniformMap | undefined; // default undefine
+        renderState: RenderState | undefined; // default undefined
+        // framebuffer: FrameB
+        pass: Pass | undefined; // default undefined
+        executeInClosestFrustum: boolean;
+        owner: Object | undefined;
+        debugShowBoundingVolume: boolean;
+        debugOverlappingFrustums: number;
+        pickId: string | undefined;
+        pickOnly: boolean;
+        depthForTranslucentClassification: boolean;
+    }
+
+    var DrawCommand: {
+        prototype: DrawCommand;
+        new(options: {
+            // boundingVolume: BoundingVoluem;
+            cull?: boolean;
+            occlude?: boolean;
+            modelMatrix: Matrix4;
+            primitiveType?: PrimitiveType; // TRIANGLES
+            vertexArray: VertexArray;
+            count?: number;
+            offset?: number;
+            instanceCount?: number; // 0
+            shaderProgram: ShaderProgram;
+            uniformMap?: UniformMap;
+            renderState: RenderState;
+            // framebuffer: ;
+            pass: Pass;
+            executeInClosestFrustum: boolean;
+            owner?: any;
+            debugShowBoundingVolume?: boolean;
+            castShadows?: boolean; // false;
+            receiveShadows?: boolean; // false
+            pickId?: string;
+            pickOnly?: boolean; // false
+            depthForTranslucentClassification?: boolean; // false
+            boundingVolume?: BoundingRectangle | BoundingSphere | OrientedBoundingBox;
+            orientedBoundingBox?: OrientedBoundingBox;
+        }): DrawCommand;
+    };
+
+    interface ShadowMap {
+
+    }
+
+    interface FrameState {
+        context: Context;
+        commandList: DrawCommand[];
+        shadowMaps: ShadowMap[];
+        // brdfLutGenerator
+        // environmentMap
+        // sphericalHarmonicCoefficients
+        // specularEnvironmentMaps
+        mode: SceneMode;
+        morphTime: number;
+        frameNumber: number; // 0
+        newFrame: boolean;
+        time: JulianDate;
+        // jobScheduler
+        // mapProjection
+        camera: Camera;
+        cameraUnderground: boolean;
+        // globeTranslucencyState
+        // cullingVolume
+        // occluder
+        maximumScreenSpaceError: number; // 2
+        pixelRatio: number; // 1.0
+        passes: {
+            render: boolean;
+            pick: boolean;
+            depth: boolean;
+            postProcess: boolean;
+            offscreen: boolean;
+        };
+        // creditDisplay
+        afterRender: (() => void)[];
+        scene3DOnly: boolean;
+        // fog: FrameState.Fog
+        terrainExaggeration: number; // 1.0
+        imagerySplitPosition: number;
+        // frustumSplits
+        // light
+        // minimumDisableDepthTestDistance
+        // invertClassification
+        useLogDepth: boolean;
+        // tilesetPassState
+        minimumTerrainHeight: number; // 0.0
+    }
+
+    interface Buffer {
+        copyFromArrayView(arrayView: ArrayBufferView, offsetInBytes?: number): void;
+        readonly sizeInBytes: number;
+        readonly usage: BufferUsage;
+        isDestroyed(): boolean;
+        destroy(): undefined;
+    }
+
+    // const enum IndexDatatype {
+    //     /**
+    //      * 8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
+    //      * of an element in <code>Uint8Array</code>.
+    //      */
+    //     UNSIGNED_BYTE = WebGLConstants.UNSIGNED_BYTE,
+    //     /**
+    //      * 16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
+    //      * of an element in <code>Uint16Array</code>.
+    //      */
+    //     UNSIGNED_SHORT = WebGLConstants.UNSIGNED_SHORT,
+    //     /**
+    //      * 32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
+    //      * of an element in <code>Uint32Array</code>.
+    //      */
+    //     UNSIGNED_INT = WebGLConstants.UNSIGNED_INT
+    // }
+
+    interface IndexBuffer extends Buffer {
+        indexDatatype: IndexDatatype;
+        bytesPerIndex: number;
+        numberOfIndices: number;
+    }
+
+    namespace Buffer {
+        function createVertexBuffer(options: {
+            context: Context;
+            typedArray: ArrayBufferView;
+            usage: BufferUsage;
+        }): Buffer;
+
+        function createIndexBuffer(options: {
+            context: Context;
+            typedArray: Uint8Array | Uint16Array | Uint32Array;
+            usage: BufferUsage;
+            indexDatatype: IndexDatatype;
+        }): IndexBuffer;
+    }
+    interface RectangleCollisionChecker {
+        _tree: any;
+        insert(id: string, rectangle: Cesium.Rectangle): void;
+        remove(id: string, rectangle: Cesium.Rectangle): void;
+        collides(rectangle: Cesium.Rectangle): boolean;
+    }
+    var RectangleCollisionChecker: {
+        prototype: RectangleCollisionChecker;
+        new(): RectangleCollisionChecker;
+    };
+
+    interface MaterialCache {
+        _materials: Record<string, any>;
+        addMaterial(type: string, materialTemplate: any): void;
+        getMaterial(type: string): any | undefined;
+    }
+
+    // 或者扩展 Material 类型
+    namespace Material {
+        let XbsjPolylineArrow: string;
+        const _materialCache: MaterialCache
+    }
+
+    interface QuadtreeTile {
+        x: number,
+        y: number,
+        level: number,
+        rectangle: Cesium.Rectangle;
+    }
+}

package/dist/types/utils/czmUtils/todo/generateCartesianArc/czm/generateCartesianArc.d.ts

@@ -0,0 +1,8 @@
+import * as Cesium from 'cesium';
+
+export function generateCartesianArc(options: {
+    positions: Cesium.Cartesian3[],
+    arcType: Cesium.ArcType;
+    granularity: number;
+    ellipsoid: Cesium.Ellipsoid;
+}): Cesium.Cartesian3[] | undefined;

package/dist/types/utils/generalUtils/geoPolylineToBezierSpline/bezierSpline/index.d.ts

@@ -0,0 +1,37 @@
+import { Feature, LineString, Properties } from "@turf/helpers";
+/**
+ * Takes a {@link LineString|line} and returns a curved version
+ * by applying a [Bezier spline](http://en.wikipedia.org/wiki/B%C3%A9zier_spline)
+ * algorithm.
+ *
+ * The bezier spline implementation is by [Leszek Rybicki](http://leszek.rybicki.cc/).
+ *
+ * @name bezierSpline
+ * @param {Feature<LineString>} line input LineString
+ * @param {Object} [options={}] Optional parameters
+ * @param {Object} [options.properties={}] Translate properties to output
+ * @param {number} [options.resolution=10000] time in milliseconds between points
+ * @param {number} [options.sharpness=0.85] a measure of how curvy the path should be between splines
+ * @returns {Feature<LineString>} curved line
+ * @example
+ * var line = turf.lineString([
+ *   [-76.091308, 18.427501],
+ *   [-76.695556, 18.729501],
+ *   [-76.552734, 19.40443],
+ *   [-74.61914, 19.134789],
+ *   [-73.652343, 20.07657],
+ *   [-73.157958, 20.210656]
+ * ]);
+ *
+ * var curved = turf.bezierSpline(line);
+ *
+ * //addToMap
+ * var addToMap = [line, curved]
+ * curved.properties = { stroke: '#0F0' };
+ */
+declare function bezier<P = Properties>(line: Feature<LineString> | LineString, options?: {
+    properties?: P;
+    resolution?: number;
+    sharpness?: number;
+}): Feature<LineString, P>;
+export default bezier;

package/dist/types/utils/generalUtils/geoPolylineToBezierSpline/bezierSpline/lib/spline.d.ts

@@ -0,0 +1,62 @@
+export interface Point {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * BezierSpline
+ * https://github.com/leszekr/bezier-spline-js
+ *
+ * @private
+ * @copyright
+ * Copyright (c) 2013 Leszek Rybicki
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export default class Spline {
+    duration: number;
+    points: Point[];
+    sharpness: number;
+    centers: Point[];
+    controls: Array<[Point, Point]>;
+    stepLength: number;
+    length: number;
+    delay: number;
+    steps: number[];
+    constructor(options?: any);
+    /**
+     * Caches an array of equidistant (more or less) points on the curve.
+     */
+    cacheSteps(mindist: number): number[];
+    /**
+     * returns angle and speed in the given point in the curve
+     */
+    vector(t: number): {
+        angle: number;
+        speed: number;
+    };
+    /**
+     * Gets the position of the point, given time.
+     *
+     * WARNING: The speed is not constant. The time it takes between control points is constant.
+     *
+     * For constant speed, use Spline.steps[i];
+     */
+    pos(time: number): Point;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "earthsdk3-cesium",
-  "version": "3.7.0-beta.15",
+  "version": "3.7.0-beta.17",
   "description": "地球可视化实验室 (EarthSDK&CesiumLab) https://www.bjxbsj.cn",
   "type": "module",
   "main": "./dist/earthsdk3-cesium.umd.cjs",
@@ -38,7 +38,7 @@
   },
   "peerDependencies": {
     "cesium": "1.134.1",
-    "earthsdk3": "3.7.0-beta.14"
+    "earthsdk3": "3.7.0-beta.15"
   },
   "dependencies": {
     "@types/delaunator": "^5.0.2",

package/dist/types/ESCesiumViewer/initCesiumViewer/GaussianSplattingExtend/GaussianSplatFS.d.ts

@@ -1,2 +0,0 @@
-declare const _default: "void gaussianSplatStage(inout vec4 color, in ProcessedAttributes attributes) {\n    mediump float A = dot(v_vertPos, v_vertPos);\n    if(A > 1.0)\n        discard;\n    mediump float scale = 4.0;\n    mediump float B = exp(-A * scale) * (v_splatColor.a);\n    color = vec4(v_splatColor.rgb * B, B);\n}\n\n";
-export default _default;

package/dist/types/ESCesiumViewer/initCesiumViewer/GaussianSplattingExtend/GaussianSplatSorter.d.ts

@@ -1,10 +0,0 @@
-import { RuntimeError, TaskProcessor } from 'cesium';
-declare class GaussianSplatSorter {
-    static _maxSortingConcurrency: number;
-    static _sorterTaskProcessor: TaskProcessor | undefined;
-    static _taskProcessorReady: boolean;
-    static _error: RuntimeError | undefined;
-    static _getSorterTaskProcessor: () => TaskProcessor;
-    static radixSortIndexes: (parameters: any) => Promise<object> | undefined;
-}
-export default GaussianSplatSorter;

package/dist/types/ESCesiumViewer/initCesiumViewer/GaussianSplattingExtend/GaussianSplatTextureGenerator.d.ts

@@ -1,10 +0,0 @@
-import { RuntimeError, TaskProcessor } from 'cesium';
-declare class GaussianSplatTextureGenerator {
-    static _maxSortingConcurrency: number;
-    static _textureTaskProcessor: TaskProcessor | undefined;
-    static _taskProcessorReady: boolean;
-    static _error: RuntimeError | undefined;
-    static _getTextureTaskProcessor: () => TaskProcessor;
-    static generateFromAttrs: (parameters: any) => Promise<object> | undefined;
-}
-export default GaussianSplatTextureGenerator;

package/dist/types/ESCesiumViewer/initCesiumViewer/GaussianSplattingExtend/GaussianSplatVS.d.ts

@@ -1,2 +0,0 @@
-declare const _default: "#ifndef HAS_SPLAT_TEXTURE\n\nvoid calcCov3D(vec3 scale, vec4 rot, out float[6] cov3D)\n{\n    mat3 S = mat3(\n        u_splatScale * scale[0], 0, 0,\n        0, u_splatScale * scale[1], 0,\n        0, 0, u_splatScale * scale[2]\n    );\n\n    float r = rot.w;\n    float x = rot.x;\n    float y = rot.y;\n    float z = rot.z;\n\n    // Compute rotation matrix from quaternion\n    mat3 R = mat3(\n        1. - 2. * (y * y + z * z),\n        2. * (x * y - r * z),\n        2. * (x * z + r * y),\n        2. * (x * y + r * z),\n        1. - 2. * (x * x + z * z),\n        2. * (y * z - r * x),\n        2. * (x * z - r * y),\n        2. * (y * z + r * x),\n        1. - 2. * (x * x + y * y)\n    );\n\n    mat3 M = S * R;\n    mat3 Sigma = transpose(M) * M;\n\n    //we only need part of it, symmetric\n    cov3D = float[6](\n        Sigma[0][0], Sigma[0][1], Sigma[0][2],\n        Sigma[1][1], Sigma[1][2], Sigma[2][2]\n    );\n\n}\n\nvec3 calcCov2D(vec3 worldPos, float focal_x, float focal_y, float tan_fovx, float tan_fovy, float[6] cov3D, mat4 viewmatrix) {\n    vec4 t = viewmatrix * vec4(worldPos, 1.0);\n\n    float limx = 1.3 * tan_fovx;\n    float limy = 1.3 * tan_fovy;\n    float txtz = t.x / t.z;\n    float tytz = t.y / t.z;\n    t.x = min(limx, max(-limx, txtz)) * t.z;\n    t.y = min(limy, max(-limy, tytz)) * t.z;\n\n    mat3 J = mat3(\n        focal_x / t.z, 0, -(focal_x * t.x) / (t.z * t.z),\n        0, focal_y / t.z, -(focal_y * t.y) / (t.z * t.z),\n        0, 0, 0\n    );\n\n   mat3 W =  mat3(\n        viewmatrix[0][0], viewmatrix[1][0], viewmatrix[2][0],\n        viewmatrix[0][1], viewmatrix[1][1], viewmatrix[2][1],\n        viewmatrix[0][2], viewmatrix[1][2], viewmatrix[2][2]\n    );\n    mat3 T = W * J;\n    mat3 Vrk = mat3(\n        cov3D[0], cov3D[1], cov3D[2],\n        cov3D[1], cov3D[3], cov3D[4],\n        cov3D[2], cov3D[4], cov3D[5]\n    );\n\n    mat3 cov = transpose(T) * transpose(Vrk) * T;\n\n    cov[0][0] += .3;\n    cov[1][1] += .3;\n    return vec3(cov[0][0], cov[0][1], cov[1][1]);\n}\n\n\nvoid gaussianSplatStage(ProcessedAttributes attributes, inout vec4 positionClip) {\n    mat4 viewMatrix = czm_modelView;\n\n    vec4 clipPosition = czm_modelViewProjection * vec4(a_splatPosition,1.0);\n    positionClip = clipPosition;\n\n    //positionClip *= u_scalingMatrix;\n\n    float[6] cov3D;\n    calcCov3D(attributes.scale, attributes.rotation, cov3D);\n    vec3 cov = calcCov2D(a_splatPosition, u_focalX, u_focalY, u_tan_fovX, u_tan_fovY, cov3D, viewMatrix);\n\n    float mid = (cov.x + cov.z) / 2.0;\n    float radius = length(vec2((cov.x - cov.z) / 2.0, cov.y));\n    float lambda1 = mid + radius, lambda2 = mid - radius;\n\n    if(lambda2 < 0.0) return;\n    vec2 diagonalVector = normalize(vec2(cov.y, lambda1 - cov.x));\n    vec2 v1 = min(sqrt(2.0 * lambda1), 1024.0) * diagonalVector;\n    vec2 v2 = min(sqrt(2.0 * lambda2), 1024.0) * vec2(diagonalVector.y, -diagonalVector.x);\n\n    vec2 corner = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2) - 1.;\n    positionClip += vec4((corner.x * v1 + corner.y * v2) * 4.0 / czm_viewport.zw * positionClip.w, 0, 0);\n    positionClip.z = clamp(positionClip.z, -abs(positionClip.w), abs(positionClip.w));\n    v_vertPos = corner ;\n    v_splatColor = a_splatColor;\n}\n\n#else\n\nvec4 calcCovVectors(vec3 worldPos, mat3 Vrk, mat3 viewmatrix) {\n    vec4 t = vec4(worldPos, 1.0);\n    float focal = czm_viewport.z * czm_projection[0][0];\n\n    float J1 = focal / t.z;\n    vec2 J2 = -J1 / t.z * t.xy;\n    mat3 J = mat3(\n        J1, 0.0, J2.x,\n        0.0, J1, J2.y,\n        0.0, 0.0, 0.0\n    );\n\n    //assuming a uniform scale, should get us close enough\n    float scale = length(viewmatrix[0]);\n\n    mat3 T = viewmatrix * J;\n    mat3 cov = transpose(T) * Vrk * T / (scale*scale);\n\n    float diagonal1 = cov[0][0] + .3;\n    float offDiagonal = cov[0][1];\n    float diagonal2 = cov[1][1] + .3;\n\n    float mid = 0.5 * (diagonal1 + diagonal2);\n    float radius = length(vec2((diagonal1 - diagonal2) * 0.5, offDiagonal));\n    float lambda1 = mid + radius;\n    float lambda2 = max(mid - radius, 0.1);\n\n    vec2 diagonalVector = normalize(vec2(offDiagonal, lambda1 - diagonal1));\n\n    return vec4(\n        min(sqrt(2.0 * lambda1), 1024.0) * diagonalVector,\n        min(sqrt(2.0 * lambda2), 1024.0) * vec2(diagonalVector.y, -diagonalVector.x)\n    );\n}\n\nhighp vec4 discardVec = vec4(0.0, 0.0, 2.0, 1.0);\n\nvoid gaussianSplatStage(ProcessedAttributes attributes, inout vec4 positionClip) {\n    uint texIdx = uint(a_splatIndex);\n    ivec2 posCoord = ivec2((texIdx & 0x3ffu) << 1, texIdx >> 10);\n    vec4 splatPosition = vec4( uintBitsToFloat(uvec4(texelFetch(u_splatAttributeTexture, posCoord, 0))) );\n    \n    vec4 splatViewPos = czm_modelView * vec4(splatPosition.xyz, 1.0);\n    vec4 clipPosition = czm_projection * splatViewPos;\n\n    float clip = 1.2 * clipPosition.w;\n    if (clipPosition.z < -clip || clipPosition.x < -clip || clipPosition.x > clip ||\n        clipPosition.y < -clip || clipPosition.y > clip) {\n        positionClip = vec4(0.0, 0.0, 2.0, 1.0);\n        return;\n    }\n\n    ivec2 covCoord = ivec2(((texIdx & 0x3ffu) << 1) | 1u, texIdx >> 10);\n    uvec4 covariance = uvec4(texelFetch(u_splatAttributeTexture, covCoord, 0));\n\n    positionClip = clipPosition;\n\n    vec2 u1 = unpackHalf2x16(covariance.x) ;\n    vec2 u2 = unpackHalf2x16(covariance.y);\n    vec2 u3 = unpackHalf2x16(covariance.z);\n    mat3 Vrk = mat3(u1.x, u1.y, u2.x, u1.y, u2.y, u3.x, u2.x, u3.x, u3.y);\n\n    //we can still apply scale here even though cov3d is pre-computed\n    Vrk *= u_splatScale;\n\n    vec4 covVectors = calcCovVectors(\n        splatViewPos.xyz,\n        Vrk,\n        mat3(transpose(czm_modelView))\n    );\n\n    if (dot(covVectors.xy, covVectors.xy) < 4.0 && dot(covVectors.zw, covVectors.zw) < 4.0) {\n        gl_Position = discardVec;\n        return;\n    }\n\n    vec2 corner = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2) - 1.;\n\n    positionClip += vec4((corner.x * covVectors.xy + corner.y * covVectors.zw) / czm_viewport.zw * positionClip.w, 0, 0);\n    positionClip.z = clamp(positionClip.z, -abs(positionClip.w), abs(positionClip.w));\n\n    v_vertPos = corner ;\n    v_splatColor = vec4(covariance.w & 0xffu, (covariance.w >> 8) & 0xffu, (covariance.w >> 16) & 0xffu, (covariance.w >> 24) & 0xffu) / 255.0;\n\n    //if tile bounding volumes are shown, increase transparency so we can see the entire box\n    #ifdef DEBUG_BOUNDING_VOLUMES\n    v_splatColor.a *= 0.08;\n    #endif\n}\n\n\n#endif\n";
-export default _default;

package/dist/types/ESCesiumViewer/initCesiumViewer/GaussianSplattingExtend/GeometryStageFS.d.ts

@@ -1,2 +0,0 @@
-declare const _default: "void geometryStage(out ProcessedAttributes attributes)\n{\n  attributes.positionMC = v_positionMC;\n  attributes.positionEC = v_positionEC;\n\n  #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE)\n  attributes.positionWC = v_positionWC;\n  #endif\n\n  #ifdef HAS_NORMALS\n  // renormalize after interpolation\n  attributes.normalEC = normalize(v_normalEC);\n  #endif\n\n  #ifdef HAS_TANGENTS\n  attributes.tangentEC = normalize(v_tangentEC);\n  #endif\n\n  #ifdef HAS_BITANGENTS\n  attributes.bitangentEC = normalize(v_bitangentEC);\n  #endif\n\n  // Everything else is dynamically generated in GeometryPipelineStage\n  setDynamicVaryings(attributes);\n}\n";
-export default _default;

package/dist/types/ESCesiumViewer/initCesiumViewer/GaussianSplattingExtend/GeometryStageVS.d.ts

@@ -1,2 +0,0 @@
-declare const _default: "vec4 geometryStage(inout ProcessedAttributes attributes, mat4 modelView, mat3 normal)\n{\n    vec4 computedPosition;\n\n    // Compute positions in different coordinate systems\n    vec3 positionMC = attributes.positionMC;\n    v_positionMC = positionMC;\n    v_positionEC = (modelView * vec4(positionMC, 1.0)).xyz;\n\n    #if defined(USE_2D_POSITIONS) || defined(USE_2D_INSTANCING)\n    vec3 position2D = attributes.position2D;\n    vec3 positionEC = (u_modelView2D * vec4(position2D, 1.0)).xyz;\n    computedPosition = czm_projection * vec4(positionEC, 1.0);\n    #else\n    computedPosition = czm_projection * vec4(v_positionEC, 1.0);\n    #endif\n\n    // Sometimes the custom shader and/or style needs this\n    #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE) || defined(ENABLE_CLIPPING_POLYGONS)\n    // Note that this is a 32-bit position which may result in jitter on small\n    // scales.\n    v_positionWC = (czm_model * vec4(positionMC, 1.0)).xyz;\n    #endif\n\n    #ifdef HAS_NORMALS\n    v_normalEC = normalize(normal * attributes.normalMC);\n    #endif\n\n    #ifdef HAS_TANGENTS\n    v_tangentEC = normalize(normal * attributes.tangentMC);\n    #endif\n\n    #ifdef HAS_BITANGENTS\n    v_bitangentEC = normalize(normal * attributes.bitangentMC);\n    #endif\n\n    // All other varyings need to be dynamically generated in\n    // GeometryPipelineStage\n    setDynamicVaryings(attributes);\n\n    return computedPosition;\n}\n";
-export default _default;

package/dist/types/ESCesiumViewer/initCesiumViewer/GaussianSplattingExtend/ModelFS.d.ts

@@ -1,2 +0,0 @@
-declare const _default: "\nprecision highp float;\n\nczm_modelMaterial defaultModelMaterial()\n{\n    czm_modelMaterial material;\n    material.diffuse = vec3(0.0);\n    material.specular = vec3(1.0);\n    material.roughness = 1.0;\n    material.occlusion = 1.0;\n    material.normalEC = vec3(0.0, 0.0, 1.0);\n    material.emissive = vec3(0.0);\n    material.alpha = 1.0;\n    return material;\n}\n\nvec4 handleAlpha(vec3 color, float alpha)\n{\n    #ifdef ALPHA_MODE_MASK\n    if (alpha < u_alphaCutoff) {\n        discard;\n    }\n    #endif\n\n    return vec4(color, alpha);\n}\n\nSelectedFeature selectedFeature;\n\nvoid main()\n{\n    #ifdef HAS_POINT_CLOUD_SHOW_STYLE\n        if (v_pointCloudShow == 0.0)\n        {\n            discard;\n        }\n    #endif\n\n    #ifdef HAS_MODEL_SPLITTER\n    modelSplitterStage();\n    #endif\n\n    czm_modelMaterial material = defaultModelMaterial();\n\n    ProcessedAttributes attributes;\n    geometryStage(attributes);\n\n    FeatureIds featureIds;\n    featureIdStage(featureIds, attributes);\n\n    Metadata metadata;\n    MetadataClass metadataClass;\n    MetadataStatistics metadataStatistics;\n    metadataStage(metadata, metadataClass, metadataStatistics, attributes);\n\n    //========================================================================\n    // When not picking metadata START\n    #ifndef METADATA_PICKING_ENABLED\n\n    #ifdef HAS_SELECTED_FEATURE_ID\n    selectedFeatureIdStage(selectedFeature, featureIds);\n    #endif\n\n    #ifndef CUSTOM_SHADER_REPLACE_MATERIAL\n    materialStage(material, attributes, selectedFeature);\n    #endif\n\n    #ifdef HAS_CUSTOM_FRAGMENT_SHADER\n    customShaderStage(material, attributes, featureIds, metadata, metadataClass, metadataStatistics);\n    #endif\n\n    lightingStage(material, attributes);\n\n    #ifdef HAS_SELECTED_FEATURE_ID\n    cpuStylingStage(material, selectedFeature);\n    #endif\n\n    #ifdef HAS_MODEL_COLOR\n    modelColorStage(material);\n    #endif\n\n    #ifdef HAS_PRIMITIVE_OUTLINE\n    primitiveOutlineStage(material);\n    #endif\n\n    vec4 color = handleAlpha(material.diffuse, material.alpha);\n\n    // When not picking metadata END\n    //========================================================================\n    #else\n    //========================================================================\n    // When picking metadata START\n\n    vec4 metadataValues = vec4(0.0, 0.0, 0.0, 0.0);\n    metadataPickingStage(metadata, metadataClass, metadataValues);\n    vec4 color = metadataValues;\n\n    #endif\n    // When picking metadata END\n    //========================================================================\n\n    #ifdef HAS_CLIPPING_PLANES\n    modelClippingPlanesStage(color);\n    #endif\n\n    #ifdef ENABLE_CLIPPING_POLYGONS\n    modelClippingPolygonsStage();\n    #endif\n\n    //========================================================================\n    // When not picking metadata START\n    #ifndef METADATA_PICKING_ENABLED\n\n    #if defined(HAS_SILHOUETTE) && defined(HAS_NORMALS)\n    silhouetteStage(color);\n    #endif\n\n    #ifdef HAS_ATMOSPHERE\n    atmosphereStage(color, attributes);\n    #endif\n\n    #ifdef HAS_GAUSSIAN_SPLATS\n    gaussianSplatStage(color, attributes);\n    #endif\n\n    #endif\n    // When not picking metadata END\n    //========================================================================\n\n    out_FragColor = color;\n}\n\n";
-export default _default;

package/dist/types/ESCesiumViewer/initCesiumViewer/GaussianSplattingExtend/ModelVS.d.ts

@@ -1,2 +0,0 @@
-declare const _default: "precision highp float;\n\nczm_modelVertexOutput defaultVertexOutput(vec3 positionMC) {\n    czm_modelVertexOutput vsOutput;\n    vsOutput.positionMC = positionMC;\n    vsOutput.pointSize = 1.0;\n    return vsOutput;\n}\n\nvoid main()\n{\n    // Initialize the attributes struct with all\n    // attributes except quantized ones.\n    ProcessedAttributes attributes;\n    initializeAttributes(attributes);\n\n    // Dequantize the quantized ones and add them to the\n    // attributes struct.\n    #ifdef USE_DEQUANTIZATION\n    dequantizationStage(attributes);\n    #endif\n\n    #ifdef HAS_MORPH_TARGETS\n    morphTargetsStage(attributes);\n    #endif\n\n    #ifdef HAS_SKINNING\n    skinningStage(attributes);\n    #endif\n\n    #ifdef HAS_PRIMITIVE_OUTLINE\n    primitiveOutlineStage();\n    #endif\n\n    // Compute the bitangent according to the formula in the glTF spec.\n    // Normal and tangents can be affected by morphing and skinning, so\n    // the bitangent should not be computed until their values are finalized.\n    #ifdef HAS_BITANGENTS\n    attributes.bitangentMC = normalize(cross(attributes.normalMC, attributes.tangentMC) * attributes.tangentSignMC);\n    #endif\n\n    FeatureIds featureIds;\n    featureIdStage(featureIds, attributes);\n\n    #ifdef HAS_SELECTED_FEATURE_ID\n    SelectedFeature feature;\n    selectedFeatureIdStage(feature, featureIds);\n    // Handle any show properties that come from the style.\n    cpuStylingStage(attributes.positionMC, feature);\n    #endif\n\n    #if defined(USE_2D_POSITIONS) || defined(USE_2D_INSTANCING)\n    // The scene mode 2D pipeline stage and instancing stage add a different\n    // model view matrix to accurately project the model to 2D. However, the\n    // output positions and normals should be transformed by the 3D matrices\n    // to keep the data the same for the fragment shader.\n    mat4 modelView = czm_modelView3D;\n    mat3 normal = czm_normal3D;\n    #else\n    // These are used for individual model projection because they will\n    // automatically change based on the scene mode.\n    mat4 modelView = czm_modelView;\n    mat3 normal = czm_normal;\n    #endif\n\n    // Update the position for this instance in place\n    #ifdef HAS_INSTANCING\n\n        // The legacy instance stage is used when rendering i3dm models that\n        // encode instances transforms in world space, as opposed to glTF models\n        // that use EXT_mesh_gpu_instancing, where instance transforms are encoded\n        // in object space.\n        #ifdef USE_LEGACY_INSTANCING\n        mat4 instanceModelView;\n        mat3 instanceModelViewInverseTranspose;\n\n        legacyInstancingStage(attributes, instanceModelView, instanceModelViewInverseTranspose);\n\n        modelView = instanceModelView;\n        normal = instanceModelViewInverseTranspose;\n        #else\n        instancingStage(attributes);\n        #endif\n\n        #ifdef USE_PICKING\n        v_pickColor = a_pickColor;\n        #endif\n\n    #endif\n\n    Metadata metadata;\n    MetadataClass metadataClass;\n    MetadataStatistics metadataStatistics;\n    metadataStage(metadata, metadataClass, metadataStatistics, attributes);\n\n    #ifdef HAS_VERTICAL_EXAGGERATION\n    verticalExaggerationStage(attributes);\n    #endif\n\n    #ifdef HAS_CUSTOM_VERTEX_SHADER\n    czm_modelVertexOutput vsOutput = defaultVertexOutput(attributes.positionMC);\n    customShaderStage(vsOutput, attributes, featureIds, metadata, metadataClass, metadataStatistics);\n    #endif\n\n    // Compute the final position in each coordinate system needed.\n    // This returns the value that will be assigned to gl_Position.\n    vec4 positionClip = geometryStage(attributes, modelView, normal);\n\n    // This must go after the geometry stage as it needs v_positionWC\n    #ifdef HAS_ATMOSPHERE\n    atmosphereStage(attributes);\n    #endif\n\n    #ifdef ENABLE_CLIPPING_POLYGONS\n    modelClippingPolygonsStage(attributes);\n    #endif\n\n    #ifdef HAS_SILHOUETTE\n    silhouetteStage(attributes, positionClip);\n    #endif\n\n    #ifdef HAS_POINT_CLOUD_SHOW_STYLE\n    float show = pointCloudShowStylingStage(attributes, metadata);\n    #else\n    float show = 1.0;\n    #endif\n\n    #ifdef HAS_POINT_CLOUD_BACK_FACE_CULLING\n    show *= pointCloudBackFaceCullingStage();\n    #endif\n\n    #ifdef HAS_POINT_CLOUD_COLOR_STYLE\n    v_pointCloudColor = pointCloudColorStylingStage(attributes, metadata);\n    #endif\n\n    #ifdef PRIMITIVE_TYPE_POINTS\n        #ifdef HAS_CUSTOM_VERTEX_SHADER\n        gl_PointSize = vsOutput.pointSize;\n        #elif defined(HAS_POINT_CLOUD_POINT_SIZE_STYLE) || defined(HAS_POINT_CLOUD_ATTENUATION)\n        gl_PointSize = pointCloudPointSizeStylingStage(attributes, metadata);\n        #else\n        gl_PointSize = 1.0;\n        #endif\n        \n        gl_PointSize *= show;\n    #endif\n\n    #ifdef HAS_GAUSSIAN_SPLATS\n    gaussianSplatStage(attributes, positionClip);\n    #endif\n\n    // Important NOT to compute gl_Position = show * positionClip or we hit:\n    // https://github.com/CesiumGS/cesium/issues/11270\n    //\n    // We will discard points with v_pointCloudShow == 0 in the fragment shader.\n    gl_Position = positionClip;\n\n    #ifdef HAS_POINT_CLOUD_SHOW_STYLE\n    v_pointCloudShow = show;\n    #endif\n}\n";
-export default _default;

package/dist/types/ESCesiumViewer/initCesiumViewer/GaussianSplattingExtend/fixCesium3DTileStyle.d.ts

@@ -1 +0,0 @@
-export default function fixCesium3DTileStyle(): void;

package/dist/types/ESCesiumViewer/initCesiumViewer/GaussianSplattingExtend/fixCesium3DTileset.d.ts

@@ -1 +0,0 @@
-export default function fixCesium3DTileset(): void;

package/dist/types/ESCesiumViewer/initCesiumViewer/GaussianSplattingExtend/fixFrustuCommands.d.ts

@@ -1,4 +0,0 @@
-import * as Cesium from 'cesium';
-export declare class FrustumCommandsGaussianSplatting extends Cesium.FrustumCommands {
-    constructor(near: any, far: any);
-}

package/dist/types/ESCesiumViewer/initCesiumViewer/GaussianSplattingExtend/fixGeometryPipelineStage.d.ts

@@ -1 +0,0 @@
-export default function fixGeometryPipelineStage(): void;