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

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

@@ -1,434 +0,0 @@
-// 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

@@ -1,8 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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;
-}