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

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.16",
   "description": "地球可视化实验室 (EarthSDK&CesiumLab) https://www.bjxbsj.cn",
   "type": "module",
   "main": "./dist/earthsdk3-cesium.umd.cjs",