@openglobus/og 0.17.2 → 0.18.1

package/lib/js/entity/Strip.js

@@ -0,0 +1,401 @@
+import * as utils from "../utils/shared";
+import { Line3 } from "../math/Line3";
+import { Vec3 } from "../math/Vec3";
+let _tempHigh = new Vec3(), _tempLow = new Vec3();
+/**
+ * Strip object.
+ * @class
+ * @param {*} [options] - Strip options:
+ * @param {boolean} [options.visibility] - Strip visibility.
+ * @example <caption>Stripe example</caption>
+ * new og.Entity({
+ *     strip: {
+ *         gridSize: 10,
+ *         path: [
+ *             [[],[]],
+ *             [[],[]]
+ *         ]
+ *     }
+ * });
+ */
+class Strip {
+    constructor(options = {}) {
+        this.__id = Strip.__counter__++;
+        this.visibility = options.visibility != undefined ? options.visibility : true;
+        this.color = new Float32Array([1.0, 1.0, 1.0, 0.5]);
+        if (options.color) {
+            let color = utils.createColorRGBA(options.color);
+            this.setColor(color.x, color.y, color.z, color.w);
+        }
+        if (options.opacity) {
+            this.setOpacity(options.opacity);
+        }
+        /**
+         * Parent collection render node.
+         * @protected
+         * @type {RenderNode}
+         */
+        this._renderNode = null;
+        /**
+         * Entity instance that holds this strip.
+         * @protected
+         * @type {Entity}
+         */
+        this._entity = null;
+        this._verticesHighBuffer = null;
+        this._verticesLowBuffer = null;
+        this._indexBuffer = null;
+        this._verticesHigh = [];
+        this._verticesLow = [];
+        this._indexes = [];
+        this._path = [];
+        this._pickingColor = new Float32Array(4);
+        this._gridSize = 1;
+        /**
+         * Handler that stores and renders this object.
+         * @protected
+         * @type {StripHandler}
+         */
+        this._handler = null;
+        this._handlerIndex = -1;
+        if (options.path) {
+            this.setPath(options.path);
+        }
+    }
+    /**
+     * Assign picking color.
+     * @public
+     * @param {Vec3} color - Picking RGB color.
+     */
+    setPickingColor3v(color) {
+        this._pickingColor[0] = color.x / 255.0;
+        this._pickingColor[1] = color.y / 255.0;
+        this._pickingColor[2] = color.z / 255.0;
+        this._pickingColor[3] = 1.0;
+    }
+    /**
+     * Clears object
+     * @public
+     */
+    clear() {
+        this._path.length = 0;
+        this._path = [];
+        this._verticesHigh.length = 0;
+        this._verticesHigh = [];
+        this._verticesLow.length = 0;
+        this._verticesLow = [];
+        this._indexes.length = 0;
+        this._indexes = [];
+        this._deleteBuffers();
+    }
+    setColor(r, g, b, a) {
+        a = a || this.color[3];
+        this.color[0] = r;
+        this.color[1] = g;
+        this.color[2] = b;
+        this.color[3] = a;
+    }
+    /**
+     * Set strip opacity.
+     * @public
+     * @param {number} opacity - opacity.
+     */
+    setOpacity(opacity) {
+        this.color[3] = opacity || 0;
+    }
+    /**
+     * Sets cloud visibility.
+     * @public
+     * @param {boolean} visibility - Visibility flag.
+     */
+    setVisibility(visibility) {
+        this.visibility = visibility;
+    }
+    /**
+     * @return {boolean} Strip visibility.
+     */
+    getVisibility() {
+        return this.visibility;
+    }
+    /**
+     * Assign rendering scene node.
+     * @public
+     * @param {RenderNode}  renderNode - Assigned render node.
+     */
+    setRenderNode(renderNode) {
+        this._renderNode = renderNode;
+        this._createBuffers();
+    }
+    /**
+     * Removes from entity.
+     * @public
+     */
+    remove() {
+        this._entity = null;
+        this._handler && this._handler.remove(this);
+    }
+    draw() {
+        if (this.visibility && this._verticesHigh.length) {
+            let r = this._renderNode.renderer;
+            let gl = r.handler.gl;
+            let sh = r.handler.programs.strip, p = sh._program, sha = p.attributes, shu = p.uniforms;
+            sh.activate();
+            gl.disable(gl.CULL_FACE);
+            gl.uniformMatrix4fv(shu.viewMatrix, false, r.activeCamera.getViewMatrix());
+            gl.uniformMatrix4fv(shu.projectionMatrix, false, r.activeCamera.getProjectionMatrix());
+            gl.uniform3fv(shu.eyePositionHigh, r.activeCamera.eyeHigh);
+            gl.uniform3fv(shu.eyePositionLow, r.activeCamera.eyeLow);
+            gl.uniform4fv(shu.uColor, this.color);
+            gl.uniform1f(shu.uOpacity, this._entity._entityCollection._fadingOpacity);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._verticesHighBuffer);
+            gl.vertexAttribPointer(sha.aVertexPositionHigh, this._verticesHighBuffer.itemSize, gl.FLOAT, false, 0, 0);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._verticesLowBuffer);
+            gl.vertexAttribPointer(sha.aVertexPositionLow, this._verticesLowBuffer.itemSize, gl.FLOAT, false, 0, 0);
+            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBuffer);
+            gl.drawElements(r.handler.gl.TRIANGLE_STRIP, this._indexBuffer.numItems, gl.UNSIGNED_INT, 0);
+            gl.enable(gl.CULL_FACE);
+        }
+    }
+    drawPicking() {
+        if (this.visibility && this._verticesHigh.length) {
+            let r = this._renderNode.renderer;
+            let gl = r.handler.gl;
+            let sh = r.handler.programs.strip, p = sh._program, sha = p.attributes, shu = p.uniforms;
+            sh.activate();
+            gl.disable(gl.CULL_FACE);
+            gl.uniformMatrix4fv(shu.viewMatrix, false, r.activeCamera.getViewMatrix());
+            gl.uniformMatrix4fv(shu.projectionMatrix, false, r.activeCamera.getProjectionMatrix());
+            gl.uniform3fv(shu.eyePositionHigh, r.activeCamera.eyeHigh);
+            gl.uniform3fv(shu.eyePositionLow, r.activeCamera.eyeLow);
+            gl.uniform1f(shu.uOpacity, this._entity._entityCollection._fadingOpacity != 0 ? 1 : 0);
+            gl.uniform4fv(shu.uColor, this._pickingColor);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._verticesHighBuffer);
+            gl.vertexAttribPointer(sha.aVertexPositionHigh, this._verticesHighBuffer.itemSize, gl.FLOAT, false, 0, 0);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._verticesLowBuffer);
+            gl.vertexAttribPointer(sha.aVertexPositionLow, this._verticesLowBuffer.itemSize, gl.FLOAT, false, 0, 0);
+            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBuffer);
+            gl.drawElements(r.handler.gl.TRIANGLE_STRIP, this._indexBuffer.numItems, gl.UNSIGNED_INT, 0);
+            gl.enable(gl.CULL_FACE);
+        }
+    }
+    /**
+     * Delete buffers
+     * @public
+     */
+    _deleteBuffers() {
+        if (this._renderNode && this._renderNode.renderer) {
+            let r = this._renderNode.renderer, gl = r.handler.gl;
+            gl.deleteBuffer(this._indexBuffer);
+            gl.deleteBuffer(this._verticesHighBuffer);
+            gl.deleteBuffer(this._verticesLowBuffer);
+        }
+        this._verticesHighBuffer = null;
+        this._verticesLowBuffer = null;
+        this._indexBuffer = null;
+    }
+    _createBuffers() {
+        if (this._renderNode && this._renderNode.renderer && this._renderNode.renderer.isInitialized()) {
+            let gl = this._renderNode.renderer.handler.gl;
+            gl.deleteBuffer(this._indexBuffer);
+            gl.deleteBuffer(this._verticesHighBuffer);
+            gl.deleteBuffer(this._verticesLowBuffer);
+            this._verticesHighBuffer = this._renderNode.renderer.handler.createArrayBuffer(new Float32Array(this._verticesHigh), 3, this._verticesHigh.length / 3);
+            this._verticesLowBuffer = this._renderNode.renderer.handler.createArrayBuffer(new Float32Array(this._verticesLow), 3, this._verticesLow.length / 3);
+            this._indexBuffer = this._renderNode.renderer.handler.createElementArrayBuffer(new Uint32Array(this._indexes), 1, this._indexes.length);
+        }
+    }
+    addEdge3v(p2, p3) {
+        let length = this._path.length;
+        if (length === 0) {
+            this._path.push([p2.clone(), p3.clone()]);
+        }
+        else {
+            let p0 = this._path[length - 1][0], p1 = this._path[length - 1][1];
+            this._path.push([p2.clone(), p3.clone()]);
+            let vHigh = this._verticesHigh, vLow = this._verticesLow;
+            let gs = this._gridSize, gs1 = gs + 1;
+            let p = new Vec3();
+            let last = this._verticesHigh.length / 3, ind = last;
+            let d = Math.abs(p0.sub(p1).normal().dot(p2.sub(p0).normal()));
+            for (let i = 0; i < gs1; i++) {
+                let di = i / gs;
+                let p02 = p0.lerp(p2, di), p13 = p1.lerp(p3, di);
+                for (let j = 0; j < gs1; j++) {
+                    let dj = j / gs;
+                    let p01 = p0.lerp(p1, dj), p23 = p2.lerp(p3, dj);
+                    if (d !== 1.0) {
+                        new Line3(p02, p13).intersects(new Line3(p01, p23), p);
+                    }
+                    else {
+                        p = p23;
+                    }
+                    ind = last + i * gs1 + j;
+                    Vec3.doubleToTwoFloats(p, _tempHigh, _tempLow);
+                    let ind3 = ind * 3;
+                    vHigh[ind3] = _tempHigh.x;
+                    vHigh[ind3 + 1] = _tempHigh.y;
+                    vHigh[ind3 + 2] = _tempHigh.z;
+                    vLow[ind3] = _tempLow.x;
+                    vLow[ind3 + 1] = _tempLow.y;
+                    vLow[ind3 + 2] = _tempLow.z;
+                    if (i < gs) {
+                        this._indexes.push(ind, ind + gs1);
+                    }
+                }
+                if (i < gs) {
+                    this._indexes.push(ind + gs1, ind + 1);
+                }
+            }
+            this._createBuffers();
+        }
+    }
+    setEdge3v(p2, p3, index) {
+        if (index === this._path.length) {
+            this.addEdge3v(p2, p3);
+            return;
+        }
+        if (this._path[index]) {
+            this._path[index][0] = p2;
+            this._path[index][1] = p3;
+            if (this._path.length > 1) {
+                let gs = this._gridSize, gs1 = gs + 1;
+                let vSize = gs1 * gs1;
+                let p = new Vec3();
+                let vHigh = this._verticesHigh, vLow = this._verticesLow;
+                if (index === this._path.length - 1) {
+                    let p0 = this._path[index - 1][0], p1 = this._path[index - 1][1];
+                    let prev = this._verticesHigh.length / 3 - vSize, ind = prev;
+                    let d = Math.abs(p0.sub(p1).normal().dot(p2.sub(p0).normal()));
+                    for (let i = 0; i < gs1; i++) {
+                        let di = i / gs;
+                        let p02 = p0.lerp(p2, di), p13 = p1.lerp(p3, di);
+                        for (let j = 0; j < gs1; j++) {
+                            let dj = j / gs;
+                            let p01 = p0.lerp(p1, dj), p23 = p2.lerp(p3, dj);
+                            if (d !== 1.0) {
+                                new Line3(p02, p13).intersects(new Line3(p01, p23), p);
+                            }
+                            else {
+                                p = p23;
+                            }
+                            ind = prev + i * gs1 + j;
+                            Vec3.doubleToTwoFloats(p, _tempHigh, _tempLow);
+                            let ind3 = ind * 3;
+                            vHigh[ind3] = _tempHigh.x;
+                            vHigh[ind3 + 1] = _tempHigh.y;
+                            vHigh[ind3 + 2] = _tempHigh.z;
+                            vLow[ind3] = _tempLow.x;
+                            vLow[ind3 + 1] = _tempLow.y;
+                            vLow[ind3 + 2] = _tempLow.z;
+                        }
+                    }
+                }
+                else if (index === 0) {
+                    let ind = 0;
+                    let p0 = p2, p1 = p3;
+                    p2 = this._path[1][0];
+                    p3 = this._path[1][1];
+                    for (let i = 0; i < gs1; i++) {
+                        let di = i / gs;
+                        let p02 = p0.lerp(p2, di), p13 = p1.lerp(p3, di);
+                        for (let j = 0; j < gs1; j++) {
+                            let dj = j / gs;
+                            let p01 = p0.lerp(p1, dj), p23 = p2.lerp(p3, dj);
+                            new Line3(p02, p13).intersects(new Line3(p01, p23), p);
+                            ind = i * gs1 + j;
+                            Vec3.doubleToTwoFloats(p, _tempHigh, _tempLow);
+                            let ind3 = ind * 3;
+                            vHigh[ind3] = _tempHigh.x;
+                            vHigh[ind3 + 1] = _tempHigh.y;
+                            vHigh[ind3 + 2] = _tempHigh.z;
+                            vLow[ind3] = _tempLow.x;
+                            vLow[ind3 + 1] = _tempLow.y;
+                            vLow[ind3 + 2] = _tempLow.z;
+                        }
+                    }
+                }
+                else if (index > 0 && index < this._path.length) {
+                    let p0 = this._path[index - 1][0], p1 = this._path[index - 1][1];
+                    let p4 = this._path[index + 1][0], p5 = this._path[index + 1][1];
+                    let next = index * vSize, prev = (index - 1) * vSize, ind = prev;
+                    for (let i = 0; i < gs1; i++) {
+                        let di = i / gs;
+                        let p02 = p0.lerp(p2, di), p35 = p3.lerp(p5, di), p24 = p2.lerp(p4, di), p13 = p1.lerp(p3, di);
+                        for (let j = 0; j < gs1; j++) {
+                            let dj = j / gs;
+                            let p01 = p0.lerp(p1, dj), p23 = p2.lerp(p3, dj);
+                            // prev
+                            new Line3(p02, p13).intersects(new Line3(p01, p23), p);
+                            let ij = i * gs1 + j;
+                            ind = prev + ij;
+                            Vec3.doubleToTwoFloats(p, _tempHigh, _tempLow);
+                            let ind3 = ind * 3;
+                            vHigh[ind3] = _tempHigh.x;
+                            vHigh[ind3 + 1] = _tempHigh.y;
+                            vHigh[ind3 + 2] = _tempHigh.z;
+                            vLow[ind3] = _tempLow.x;
+                            vLow[ind3 + 1] = _tempLow.y;
+                            vLow[ind3 + 2] = _tempLow.z;
+                            // next
+                            let p45 = p4.lerp(p5, dj);
+                            p23 = p2.lerp(p3, dj);
+                            new Line3(p24, p35).intersects(new Line3(p23, p45), p);
+                            ind = next + ij;
+                            Vec3.doubleToTwoFloats(p, _tempHigh, _tempLow);
+                            ind3 = ind * 3;
+                            vHigh[ind3] = _tempHigh.x;
+                            vHigh[ind3 + 1] = _tempHigh.y;
+                            vHigh[ind3 + 2] = _tempHigh.z;
+                            vLow[ind3] = _tempLow.x;
+                            vLow[ind3 + 1] = _tempLow.y;
+                            vLow[ind3 + 2] = _tempLow.z;
+                        }
+                    }
+                }
+                this._createBuffers();
+            }
+        }
+        else {
+            console.warn(`strip index ${index} is out of range`);
+        }
+    }
+    removeEdge(index) {
+        this._path.splice(index, 1);
+        this.setPath([].concat(this._path));
+    }
+    setGridSize(gridSize) {
+        this._gridSize = gridSize;
+        this.setPath([].concat(this._path));
+    }
+    getPath() {
+        return this._path;
+    }
+    setPath(path) {
+        this._verticesHigh = [];
+        this._verticesLow = [];
+        this._indexes = [];
+        this._path = [];
+        for (let i = 0; i < path.length; i++) {
+            let p0 = path[i][0], p1 = path[i][1];
+            if (p0 instanceof Array) {
+                p0 = new Vec3(p0[0], p0[1], p0[2]);
+            }
+            if (p1 instanceof Array) {
+                p1 = new Vec3(p1[0], p1[1], p1[2]);
+            }
+            this.addEdge3v(p0, p1);
+        }
+    }
+    insertEdge3v(p0, p1, index) {
+        if (index < this._path.length) {
+            let p = [].concat(this._path);
+            p.splice(index, 0, [p0, p1]);
+            this.setPath(p);
+        }
+        else if (index === this._path.length) {
+            this.addEdge3v(p0, p1);
+        }
+    }
+}
+Strip.__counter__ = 0;
+export { Strip };

package/lib/js/entity/StripHandler.d.ts

@@ -0,0 +1,42 @@
+import { EntityCollection } from "./EntityCollection";
+import { Renderer } from "../renderer/Renderer";
+import { RenderNode } from "../scene/RenderNode";
+import { Strip } from "./Strip";
+declare class StripHandler {
+    static __counter__: number;
+    protected __id: number;
+    /**
+     * Picking rendering option.
+     * @public
+     * @type {boolean}
+     */
+    pickingEnabled: boolean;
+    /**
+     * Parent collection
+     * @protected
+     * @type {EntityCollection}
+     */
+    protected _entityCollection: EntityCollection;
+    /**
+     * Renderer
+     * @protected
+     * @type {Renderer | null}
+     */
+    protected _renderer: Renderer | null;
+    /**
+     * Strip objects array
+     * @protected
+     * @type {Array.<Strip>}
+     */
+    protected _strips: Strip[];
+    constructor(entityCollection: EntityCollection);
+    protected _initProgram(): void;
+    setRenderNode(renderNode: RenderNode): void;
+    add(strip: Strip): void;
+    remove(strip: Strip): void;
+    reindexStripArray(startIndex: number): void;
+    draw(): void;
+    drawPicking(): void;
+    clear(): void;
+}
+export { StripHandler };

package/lib/js/entity/StripHandler.js

@@ -0,0 +1,110 @@
+import { Program } from "../webgl/Program";
+class StripHandler {
+    constructor(entityCollection) {
+        this.__id = StripHandler.__counter__++;
+        this.pickingEnabled = true;
+        this._entityCollection = entityCollection;
+        this._renderer = null;
+        this._strips = [];
+    }
+    _initProgram() {
+        if (this._renderer && this._renderer.handler) {
+            !this._renderer.handler.programs.strip &&
+                this._renderer.handler.addProgram(new Program("strip", {
+                    uniforms: {
+                        projectionMatrix: { type: "mat4" },
+                        viewMatrix: { type: "mat4" },
+                        eyePositionHigh: "vec3",
+                        eyePositionLow: "vec3",
+                        uColor: { type: "vec4" },
+                        uOpacity: { type: "float" }
+                    },
+                    attributes: {
+                        aVertexPositionHigh: { type: "vec3" },
+                        aVertexPositionLow: { type: "vec3" }
+                    },
+                    vertexShader: `attribute vec3 aVertexPositionHigh;
+                        attribute vec3 aVertexPositionLow;
+                        uniform mat4 projectionMatrix;
+                        uniform mat4 viewMatrix;
+                        uniform vec3 eyePositionHigh;
+                        uniform vec3 eyePositionLow;
+                        void main(void) {
+
+                            vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
+                            vec3 lowDiff = aVertexPositionLow - eyePositionLow;
+
+                            mat4 viewMatrixRTE = viewMatrix;
+                            viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+
+                            gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+                        }`,
+                    fragmentShader: `precision highp float;
+                        uniform vec4 uColor;
+                        uniform float uOpacity;
+                        void main(void) {
+                            gl_FragColor = vec4(uColor.rgb, uColor.a * uOpacity);
+                        }`
+                }));
+        }
+    }
+    setRenderNode(renderNode) {
+        this._renderer = renderNode.renderer;
+        this._initProgram();
+        for (let i = 0; i < this._strips.length; i++) {
+            this._strips[i].setRenderNode(renderNode);
+        }
+    }
+    add(strip) {
+        if (strip._handlerIndex === -1) {
+            strip._handler = this;
+            strip._handlerIndex = this._strips.length;
+            this._strips.push(strip);
+            this._entityCollection &&
+                this._entityCollection.renderNode &&
+                strip.setRenderNode(this._entityCollection.renderNode);
+        }
+    }
+    remove(strip) {
+        let index = strip._handlerIndex;
+        if (index !== -1) {
+            strip._deleteBuffers();
+            strip._handlerIndex = -1;
+            strip._handler = null;
+            this._strips.splice(index, 1);
+            this.reindexStripArray(index);
+        }
+    }
+    reindexStripArray(startIndex) {
+        let pc = this._strips;
+        for (let i = startIndex; i < pc.length; i++) {
+            pc[i]._handlerIndex = i;
+        }
+    }
+    draw() {
+        let i = this._strips.length;
+        while (i--) {
+            this._strips[i].draw();
+        }
+    }
+    drawPicking() {
+        if (this.pickingEnabled) {
+            let i = this._strips.length;
+            while (i--) {
+                this._strips[i].drawPicking();
+            }
+        }
+    }
+    clear() {
+        let i = this._strips.length;
+        while (i--) {
+            this._strips[i]._deleteBuffers();
+            this._strips[i]._handler = null;
+            this._strips[i]._handlerIndex = -1;
+        }
+        this._strips.length = 0;
+        this._strips = [];
+    }
+}
+StripHandler.__counter__ = 0;
+export { StripHandler };

package/lib/js/entity/index.d.ts

@@ -0,0 +1,11 @@
+import { Billboard } from "./Billboard";
+import { Entity } from "./Entity";
+import { EntityCollection } from "./EntityCollection";
+import { Geometry } from "./Geometry";
+import { GeoObject } from "./GeoObject";
+import { Label } from "./Label";
+import { PointCloud } from "./PointCloud";
+import { Polyline } from "./Polyline";
+import { Ray } from "./Ray";
+import { Strip } from "./Strip";
+export { Billboard, Entity, EntityCollection, Geometry, GeoObject, Label, PointCloud, Polyline, Ray, Strip };

package/lib/js/entity/index.js

@@ -0,0 +1,11 @@
+import { Billboard } from "./Billboard";
+import { Entity } from "./Entity";
+import { EntityCollection } from "./EntityCollection";
+import { Geometry } from "./Geometry";
+import { GeoObject } from "./GeoObject";
+import { Label } from "./Label";
+import { PointCloud } from "./PointCloud";
+import { Polyline } from "./Polyline";
+import { Ray } from "./Ray";
+import { Strip } from "./Strip";
+export { Billboard, Entity, EntityCollection, Geometry, GeoObject, Label, PointCloud, Polyline, Ray, Strip };

package/lib/js/index.d.ts

@@ -0,0 +1,33 @@
+import * as jd from './astro/jd';
+import * as math from './math';
+import * as mercator from './mercator';
+import * as utils from './utils/shared';
+import * as bv from './bv/index';
+import * as control from './control/index';
+import * as scene from './scene/index';
+import * as terrain from './terrain/index';
+import * as layer from './layer/index';
+import * as webgl from './webgl/index';
+import { Globe } from './Globe';
+import { Geoid } from './terrain/Geoid';
+import { input } from './input/input';
+import { Ellipsoid, wgs84 } from './ellipsoid/index';
+import { Camera, PlanetCamera } from './camera/index';
+import { Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4 } from './math/index';
+import { Renderer } from './renderer/Renderer';
+import { LightSource } from './light/LightSource';
+import { Clock } from './Clock';
+import { Events } from './Events';
+import { Extent } from './Extent';
+import { LonLat } from './LonLat';
+import { RenderNode } from './scene/RenderNode';
+import { Planet } from './scene/Planet';
+import { Popup } from './Popup';
+import { EarthQuadTreeStrategy, MarsQuadTreeStrategy, QuadTreeStrategy, quadTreeStrategyType, Wgs84QuadTreeStrategy } from './quadTree/index';
+import { Object3d } from './Object3d';
+import { Handler, Program, Framebuffer, Multisample } from './webgl/index';
+import { Control } from './control/Control';
+import { Entity, EntityCollection, Billboard, Geometry, Label, PointCloud, Polyline, GeoObject } from './entity/index';
+import { Layer, Vector, XYZ, CanvasTiles, WMS, GeoImage, GeoVideo, GeoTexture2d, KML, Material } from './layer/index';
+import { EmptyTerrain, GlobusTerrain, MapboxTerrain, BilTerrain } from './terrain/index';
+export { bv, jd, math, mercator, utils, input, control, scene, quadTreeStrategyType, wgs84, terrain, layer, webgl, Framebuffer, Material, KML, Layer, XYZ, Vector, CanvasTiles, WMS, GeoImage, GeoVideo, GeoTexture2d, EmptyTerrain, GlobusTerrain, MapboxTerrain, BilTerrain, Control, Camera, Ellipsoid, Planet, PlanetCamera, Globe, LightSource, Entity, EntityCollection, Billboard, Geometry, Label, PointCloud, Polyline, Program, GeoObject, Handler, Multisample, Renderer, Clock, Events, Extent, LonLat, RenderNode, Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4, Geoid, Popup, QuadTreeStrategy, MarsQuadTreeStrategy, EarthQuadTreeStrategy, Wgs84QuadTreeStrategy, Object3d };

package/lib/js/index.js

@@ -0,0 +1,33 @@
+import * as jd from './astro/jd';
+import * as math from './math';
+import * as mercator from './mercator';
+import * as utils from './utils/shared';
+import * as bv from './bv/index';
+import * as control from './control/index';
+import * as scene from './scene/index';
+import * as terrain from './terrain/index';
+import * as layer from './layer/index';
+import * as webgl from './webgl/index';
+import { Globe } from './Globe';
+import { Geoid } from './terrain/Geoid';
+import { input } from './input/input';
+import { Ellipsoid, wgs84 } from './ellipsoid/index';
+import { Camera, PlanetCamera } from './camera/index';
+import { Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4 } from './math/index';
+import { Renderer } from './renderer/Renderer';
+import { LightSource } from './light/LightSource';
+import { Clock } from './Clock';
+import { Events } from './Events';
+import { Extent } from './Extent';
+import { LonLat } from './LonLat';
+import { RenderNode } from './scene/RenderNode';
+import { Planet } from './scene/Planet';
+import { Popup } from './Popup';
+import { EarthQuadTreeStrategy, MarsQuadTreeStrategy, QuadTreeStrategy, quadTreeStrategyType, Wgs84QuadTreeStrategy } from './quadTree/index';
+import { Object3d } from './Object3d';
+import { Handler, Program, Framebuffer, Multisample } from './webgl/index';
+import { Control } from './control/Control';
+import { Entity, EntityCollection, Billboard, Geometry, Label, PointCloud, Polyline, GeoObject } from './entity/index';
+import { Layer, Vector, XYZ, CanvasTiles, WMS, GeoImage, GeoVideo, GeoTexture2d, KML, Material } from './layer/index';
+import { EmptyTerrain, GlobusTerrain, MapboxTerrain, BilTerrain } from './terrain/index';
+export { bv, jd, math, mercator, utils, input, control, scene, quadTreeStrategyType, wgs84, terrain, layer, webgl, Framebuffer, Material, KML, Layer, XYZ, Vector, CanvasTiles, WMS, GeoImage, GeoVideo, GeoTexture2d, EmptyTerrain, GlobusTerrain, MapboxTerrain, BilTerrain, Control, Camera, Ellipsoid, Planet, PlanetCamera, Globe, LightSource, Entity, EntityCollection, Billboard, Geometry, Label, PointCloud, Polyline, Program, GeoObject, Handler, Multisample, Renderer, Clock, Events, Extent, LonLat, RenderNode, Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4, Geoid, Popup, QuadTreeStrategy, MarsQuadTreeStrategy, EarthQuadTreeStrategy, Wgs84QuadTreeStrategy, Object3d };

package/lib/js/input/KeyboardHandler.d.ts

@@ -0,0 +1,33 @@
+import { EventCallback, EventCallbackStamp } from "../Events";
+interface ICallbackHandler {
+    callback: EventCallbackStamp;
+    sender: any;
+    priority: number;
+}
+declare class KeyboardHandler {
+    protected _currentlyPressedKeys: Record<number, boolean>;
+    protected _pressedKeysCallbacks: Record<number, ICallbackHandler[]>;
+    protected _unpressedKeysCallbacks: Record<number, ICallbackHandler[]>;
+    protected _charkeysCallbacks: Record<number, ICallbackHandler[]>;
+    protected _anykeyCallback: any;
+    protected _event: KeyboardEvent | null;
+    protected _active: boolean;
+    protected _stampCache: Record<string, number>;
+    constructor();
+    getcurrentlyPressedKeys(): Record<number, boolean>;
+    getPressedKeysCallbacks(): Record<number, ICallbackHandler[]>;
+    getUnpressedKeysCallbacks(): Record<number, ICallbackHandler[]>;
+    getCharkeysCallbacks(): Record<number, ICallbackHandler[]>;
+    removeEvent(event: string, keyCode: number, callback: EventCallback): void;
+    protected _removeCallback(handlers: ICallbackHandler[], callback: EventCallbackStamp): void;
+    protected _getStamp(name: string, keyCode: number, ogid: number): string;
+    protected _stamp(name: string, keyCode: number, obj: any): boolean;
+    setActivity(activity: boolean): void;
+    releaseKeys(): void;
+    addEvent(event: string, keyCode: number, callback: EventCallback, sender?: any, priority?: number): void;
+    isKeyPressed(keyCode: number): boolean;
+    handleKeyDown(): void;
+    handleKeyUp(): void;
+    handleEvents(): void;
+}
+export { KeyboardHandler };