@openglobus/og 0.24.2 → 0.25.0

package/lib/js/control/OldMouseNavigation.js

@@ -1,368 +0,0 @@
-import * as math from "../math";
-import { Control } from "./Control";
-import { input } from "../input/input";
-import { Key } from "../Lock";
-import { LonLat } from "../LonLat";
-import { Mat4 } from "../math/Mat4";
-import { Quat } from "../math/Quat";
-import { Ray } from "../math/Ray";
-import { Sphere } from "../bv/Sphere";
-import { Vec3 } from "../math/Vec3";
-import { Plane } from "../math/Plane";
-/**
- * Mouse planet camera dragging control.
- */
-export class OldMouseNavigation extends Control {
-    constructor(options = {}) {
-        super(options);
-        this._deactivate = false;
-        this._shiftBusy = false;
-        this._name = "mouseNavigation";
-        this.grabbedPoint = new Vec3();
-        this._eye0 = new Vec3();
-        this.pointOnEarth = new Vec3();
-        this.earthUp = new Vec3();
-        this.inertia = 0.007;
-        this.grabbedSpheroid = new Sphere();
-        this.qRot = new Quat();
-        this.scaleRot = 0.0;
-        this.distDiff = 0.3;
-        this.stepsCount = 8;
-        this.stepsForward = null;
-        this.stepIndex = 0;
-        this._lmbDoubleClickActive = true;
-        this.minSlope = options.minSlope || 0.1;
-        this._wheelDirection = +1;
-        this._keyLock = new Key();
-    }
-    static getMovePointsFromPixelTerrain(cam, planet, stepsCount, delta, point, forward, dir) {
-        const steps = [];
-        let eye = cam.eye.clone(), n = cam.getBackward(), u = cam.getRight(), v = cam.getUp();
-        let a = planet.getCartesianFromPixelTerrain(point);
-        if (!a) {
-            a = planet.getCartesianFromPixelTerrain(planet.renderer.handler.getCenter());
-        }
-        if (a) {
-            if (!dir) {
-                dir = Vec3.sub(a, cam.eye).normalize();
-            }
-            let d = (delta * cam.eye.distance(a)) / stepsCount;
-            if (forward) {
-                d = -1.25 * d;
-            }
-            else {
-                d *= 2;
-            }
-            const scaled_n = n.scaleTo(d);
-            const slope = dir.dot(cam.eye.normal().negate());
-            if (slope >= 0.1) {
-                const grabbedSpheroid = new Sphere();
-                grabbedSpheroid.radius = a.length();
-                let rotArr = [], eyeArr = [];
-                let breaked = false;
-                for (let i = 0; i < stepsCount; i++) {
-                    eye.addA(scaled_n);
-                    const b = new Ray(eye, dir).hitSphere(grabbedSpheroid);
-                    eyeArr[i] = eye.clone();
-                    if (b) {
-                        rotArr[i] = new Mat4().rotateBetweenVectors(a.normal(), b.normal());
-                    }
-                    else {
-                        breaked = true;
-                        break;
-                    }
-                }
-                if (!breaked) {
-                    for (let i = 0; i < stepsCount; i++) {
-                        let rot = rotArr[i];
-                        steps[i] = {
-                            eye: rot.mulVec3(eyeArr[i]),
-                            v: rot.mulVec3(v),
-                            u: rot.mulVec3(u),
-                            n: rot.mulVec3(n)
-                        };
-                    }
-                }
-                else {
-                    eye = cam.eye.clone();
-                    for (let i = 0; i < stepsCount; i++) {
-                        steps[i] = {
-                            eye: eye.addA(scaled_n).clone(),
-                            v: v,
-                            u: u,
-                            n: n,
-                        };
-                    }
-                }
-            }
-            else {
-                for (let i = 0; i < stepsCount; i++) {
-                    steps[i] = {
-                        eye: eye.addA(dir.scaleTo(-d)).clone(),
-                        v: v,
-                        u: u,
-                        n: n,
-                    };
-                }
-            }
-            return steps;
-        }
-    }
-    onactivate() {
-        if (this.renderer) {
-            this.renderer.events.on("mousewheel", this.onMouseWheel, this);
-            this.renderer.events.on("lhold", this.onMouseLeftButtonDown, this);
-            this.renderer.events.on("rhold", this.onMouseRightButtonDown, this);
-            this.renderer.events.on("ldown", this.onMouseLeftButtonClick, this);
-            this.renderer.events.on("lup", this.onMouseLeftButtonUp, this);
-            this.renderer.events.on("rdown", this.onMouseRightButtonClick, this);
-            this.renderer.events.on("draw", this.onDraw, this, -1000);
-            this.renderer.events.on("mousemove", this.onMouseMove, this);
-            this.renderer.events.on("mouseleave", this.onMouseLeave, this);
-            this.renderer.events.on("mouseenter", this.onMouseEnter, this);
-            if (this._lmbDoubleClickActive) {
-                this.renderer.events.on("ldblclick", this.onMouseLeftButtonDoubleClick, this);
-            }
-        }
-    }
-    ondeactivate() {
-        if (this.renderer) {
-            this.renderer.events.off("mousewheel", this.onMouseWheel);
-            this.renderer.events.off("lhold", this.onMouseLeftButtonDown);
-            this.renderer.events.off("rhold", this.onMouseRightButtonDown);
-            this.renderer.events.off("ldown", this.onMouseLeftButtonClick);
-            this.renderer.events.off("lup", this.onMouseLeftButtonUp);
-            this.renderer.events.off("rdown", this.onMouseRightButtonClick);
-            this.renderer.events.off("draw", this.onDraw);
-            this.renderer.events.off("ldblclick", this.onMouseLeftButtonDoubleClick);
-            this.renderer.events.off("mouseleave", this.onMouseLeave);
-            this.renderer.events.off("mouseenter", this.onMouseEnter);
-        }
-    }
-    activateDoubleClickZoom() {
-        if (!this._lmbDoubleClickActive) {
-            this._lmbDoubleClickActive = true;
-            this.renderer && this.renderer.events.on("ldblclick", this.onMouseLeftButtonDoubleClick, this);
-        }
-    }
-    deactivateDoubleClickZoom() {
-        if (this._lmbDoubleClickActive) {
-            this._lmbDoubleClickActive = false;
-            this.renderer && this.renderer.events.off("ldblclick", this.onMouseLeftButtonDoubleClick);
-        }
-    }
-    onMouseEnter(e) {
-        const renderEvents = this.renderer.events;
-        if (renderEvents.isKeyPressed(input.KEY_ALT)) {
-            renderEvents.releaseKeys();
-        }
-        renderEvents.updateButtonsStates(e.sys.buttons);
-        if (renderEvents.mouseState.leftButtonDown) {
-            this.renderer.handler.canvas.classList.add("ogGrabbingPoiner");
-        }
-        else {
-            this.renderer.handler.canvas.classList.remove("ogGrabbingPoiner");
-        }
-    }
-    onMouseLeave() {
-        if (this.renderer.events.mouseState.leftButtonDown) {
-            this.scaleRot = 0;
-        }
-        this.renderer.handler.canvas.classList.remove("ogGrabbingPoiner");
-    }
-    onMouseWheel(e) {
-        if (this.stepIndex) {
-            return;
-        }
-        this.planet.stopFlying();
-        this.stopRotation();
-        this._deactivate = true;
-        this.lockPlanet(true);
-        this.stepsForward = OldMouseNavigation.getMovePointsFromPixelTerrain(this.planet.camera, this.planet, this.stepsCount, this.distDiff, e.pos, e.wheelDelta > 0, e.direction) || null;
-        this._wheelDirection = e.wheelDelta;
-        if (this.stepsForward) {
-            this.stepIndex = this.stepsCount;
-        }
-    }
-    oninit() {
-        this.activate();
-        if (this.renderer) {
-            this.renderer.events.on("keyfree", input.KEY_ALT, this.onShiftFree, this);
-            this.renderer.events.on("keyfree", input.KEY_PRINTSCREEN, this.onShiftFree, this);
-        }
-    }
-    onMouseLeftButtonDoubleClick(e) {
-        this.planet.stopFlying();
-        this.stopRotation();
-        const p = this.planet.getCartesianFromPixelTerrain(e.pos);
-        if (p) {
-            const cam = this.planet.camera;
-            let maxAlt = cam.maxAltitude + this.planet.ellipsoid.polarSize;
-            let minAlt = cam.minAltitude + this.planet.ellipsoid.polarSize;
-            const camAlt = cam.eye.length();
-            const g = this.planet.ellipsoid.cartesianToLonLat(p);
-            if (camAlt > maxAlt || camAlt < minAlt) {
-                this.planet.flyLonLat(new LonLat(g.lon, g.lat));
-                return;
-            }
-            if (this.renderer.events.isKeyPressed(input.KEY_ALT)) {
-                this.planet.flyLonLat(new LonLat(g.lon, g.lat, cam.eye.distance(p) * 2.0));
-            }
-            else {
-                this.planet.flyLonLat(new LonLat(g.lon, g.lat, cam.eye.distance(p) * 0.57));
-            }
-        }
-    }
-    onMouseLeftButtonClick() {
-        if (this._active) {
-            this.renderer.handler.canvas.classList.add("ogGrabbingPoiner");
-            this.grabbedPoint = this.planet.getCartesianFromMouseTerrain();
-            if (this.grabbedPoint) {
-                this._eye0.copy(this.planet.camera.eye);
-                this.grabbedSpheroid.radius = this.grabbedPoint.length();
-                this.stopRotation();
-            }
-        }
-    }
-    stopRotation() {
-        this.qRot.clear();
-        this.freePlanet();
-    }
-    onMouseLeftButtonUp(e) {
-        this.renderer.handler.canvas.classList.remove("ogGrabbingPoiner");
-        if (e.x === e.prev_x && e.y === e.prev_y) {
-            this.scaleRot = 0.0;
-        }
-    }
-    onMouseLeftButtonDown(e) {
-        if (this._active) {
-            if (!this.grabbedPoint) {
-                return;
-            }
-            this.planet.stopFlying();
-            if (e.moving) {
-                let cam = this.planet.camera;
-                if (cam.slope > 0.2) {
-                    const targetPoint = new Ray(cam.eye, e.direction).hitSphere(this.grabbedSpheroid);
-                    if (targetPoint) {
-                        this.scaleRot = 1.0;
-                        this.qRot = Quat.getRotationBetweenVectors(targetPoint.normal(), this.grabbedPoint.normal());
-                        let rot = this.qRot;
-                        cam.eye = rot.mulVec3(cam.eye);
-                        cam.rotate(rot);
-                        // cam._u = rot.mulVec3(cam._u);
-                        // cam._r = rot.mulVec3(cam._r);
-                        // cam._b = rot.mulVec3(cam._b);
-                        // cam._f.set(-cam._b.x, -cam._b.y, -cam._b.z);
-                    }
-                }
-                else {
-                    let p0 = this.grabbedPoint, p1 = Vec3.add(p0, cam.getRight()), p2 = Vec3.add(p0, p0.normal());
-                    let px = new Vec3();
-                    if (new Ray(cam.eye, e.direction).hitPlaneRes(Plane.fromPoints(p0, p1, p2), px) === Ray.INSIDE) {
-                        cam.eye = this._eye0.addA(px.subA(p0).negate());
-                    }
-                }
-            }
-        }
-    }
-    onMouseRightButtonClick(e) {
-        this.stopRotation();
-        this.planet.stopFlying();
-        this.pointOnEarth = this.planet.getCartesianFromPixelTerrain(e.pos);
-        if (this.pointOnEarth) {
-            this.earthUp = this.pointOnEarth.normal();
-        }
-    }
-    onMouseRightButtonDown(e) {
-        const cam = this.planet.camera;
-        if (this.pointOnEarth && e.moving) {
-            this.renderer.controlsBag.scaleRot = 1.0;
-            let l = (0.5 / cam.eye.distance(this.pointOnEarth)) * cam._lonLat.height * math.RADIANS;
-            if (l > 0.007) {
-                l = 0.007;
-            }
-            else if (l < 0.003) {
-                l = 0.003;
-            }
-            cam.rotateHorizontal(l * (e.x - e.prev_x), false, this.pointOnEarth, this.earthUp);
-            cam.rotateVertical(l * (e.y - e.prev_y), this.pointOnEarth, this.minSlope);
-        }
-    }
-    onShiftFree() {
-        this._shiftBusy = false;
-    }
-    onMouseMove(e) {
-        if (this._active && this.renderer.events.isKeyPressed(input.KEY_ALT)) {
-            if (!this._shiftBusy) {
-                this._shiftBusy = true;
-                this.onMouseRightButtonClick(e);
-            }
-            this.onMouseRightButtonDown(e);
-        }
-    }
-    onDraw() {
-        if (this._active) {
-            const r = this.renderer;
-            const cam = this.planet.camera;
-            let prevEye = cam.eye.clone();
-            if (this.stepIndex) {
-                r.controlsBag.scaleRot = 1.0;
-                const sf = this.stepsForward[this.stepsCount - this.stepIndex--];
-                cam.eye = sf.eye;
-                //@ts-ignore
-                cam._u = sf.v;
-                //@ts-ignore
-                cam._r = sf.u;
-                //@ts-ignore
-                cam._b = sf.n;
-                //@ts-ignore
-                cam._f.set(-cam._b.x, -cam._b.y, -cam._b.z);
-            }
-            else {
-                if (this._deactivate) {
-                    this._deactivate = false;
-                    this.freePlanet();
-                }
-            }
-            if (r.events.mouseState.leftButtonDown || !this.scaleRot) {
-                return;
-            }
-            this.scaleRot -= this.inertia;
-            if (this.scaleRot <= 0.0) {
-                this.scaleRot = 0.0;
-            }
-            else {
-                r.controlsBag.scaleRot = this.scaleRot;
-                let rot = this.qRot
-                    .slerp(Quat.IDENTITY, 1.0 - this.scaleRot * this.scaleRot * this.scaleRot)
-                    .normalize();
-                if (!(rot.x || rot.y || rot.z)) {
-                    this.scaleRot = 0.0;
-                }
-                cam.eye = rot.mulVec3(cam.eye);
-                cam.rotate(rot);
-                // cam._u = rot.mulVec3(cam._u);
-                // cam._r = rot.mulVec3(cam._r);
-                // cam._b = rot.mulVec3(cam._b);
-                // cam._f.set(-cam._b.x, -cam._b.y, -cam._b.z);
-            }
-            if (cam.eye.distance(prevEye) / cam.getAltitude() > 0.01) {
-                this.lockPlanet();
-            }
-            else {
-                this.freePlanet();
-            }
-        }
-    }
-    lockPlanet(skipTerrain) {
-        this.planet.layerLock.lock(this._keyLock);
-        !skipTerrain && this.planet.terrainLock.lock(this._keyLock);
-        this.planet._normalMapCreator.lock(this._keyLock);
-    }
-    freePlanet() {
-        this.planet.layerLock.free(this._keyLock);
-        this.planet.terrainLock.free(this._keyLock);
-        this.planet._normalMapCreator.free(this._keyLock);
-    }
-}

package/lib/js/control/RulerSwitcher.d.ts

@@ -1,18 +0,0 @@
-import { Control } from "./Control";
-import type { IControlParams } from "./Control";
-import { HeightRuler } from "./heightRuler/HeightRuler";
-interface IRulerSwitcherParams extends IControlParams {
-    ignoreTerrain?: boolean;
-}
-/**
- * Activate ruler
- */
-export declare class RulerSwitcher extends Control {
-    ruler: HeightRuler;
-    constructor(options?: IRulerSwitcherParams);
-    oninit(): void;
-    onactivate(): void;
-    ondeactivate(): void;
-    protected _createMenuBtn(): void;
-}
-export {};

package/lib/js/control/RulerSwitcher.js

@@ -1,57 +0,0 @@
-import { Control } from "./Control";
-import { ToggleButton } from "../ui/ToggleButton";
-import { HeightRuler } from "./heightRuler/HeightRuler";
-const ICON_BUTTON_SVG = `<?xml version="1.0" encoding="iso-8859-1"?>
-<!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
-<svg fill="#000000" height="800px" width="800px" version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" 
-\t viewBox="0 0 512 512" xml:space="preserve">
-<g>
-\t<g>
-\t\t<path d="M369.151,0L0.001,369.15L142.85,512l369.149-369.15L369.151,0z M47.286,369.15l10.908-10.908l47.782,47.782l23.642-23.642
-\t\t\tL81.837,334.6l10.909-10.909l23.711,23.711L140.1,323.76l-23.711-23.711l10.909-10.909l23.711,23.711l23.642-23.642
-\t\t\tl-23.711-23.711l10.909-10.909l47.782,47.782l23.642-23.642l-47.782-47.782l10.908-10.908l23.71,23.71l23.642-23.642l-23.71-23.71
-\t\t\tl10.908-10.908l23.711,23.711l23.642-23.642l-23.711-23.711l10.909-10.909l47.782,47.782l23.642-23.642l-47.782-47.782
-\t\t\tl10.908-10.908l23.71,23.711l23.642-23.642l-23.711-23.71L334.6,81.837l23.711,23.71l23.642-23.642l-23.711-23.712l10.908-10.908
-\t\t\tl95.564,95.564L142.85,464.714L47.286,369.15z"/>
-\t</g>
-</g>
-</svg>`;
-/**
- * Activate ruler
- */
-export class RulerSwitcher extends Control {
-    constructor(options = {}) {
-        super({
-            name: "RulerSwitcher",
-            ...options
-        });
-        this.ruler = new HeightRuler({
-            ignoreTerrain: options.ignoreTerrain
-        });
-    }
-    oninit() {
-        this.planet.addControl(this.ruler);
-        this._createMenuBtn();
-    }
-    onactivate() {
-        this.ruler.activate();
-    }
-    ondeactivate() {
-        this.ruler.deactivate();
-    }
-    _createMenuBtn() {
-        let btn = new ToggleButton({
-            classList: ["og-map-button", "og-ruler_button"],
-            icon: ICON_BUTTON_SVG
-        });
-        btn.appendTo(this.renderer.div);
-        btn.events.on("change", (isActive) => {
-            if (isActive) {
-                this.onactivate();
-            }
-            else {
-                this.ondeactivate();
-            }
-        });
-    }
-}

package/lib/js/control/ScaleControl.d.ts

@@ -1,25 +0,0 @@
-import { Control } from "./Control";
-import type { IControlParams } from "./Control";
-import { Vec2 } from "../math/Vec2";
-interface IScaleControlParams extends IControlParams {
-    isCenter?: boolean;
-}
-/**
- * Planet zoom buttons control.
- */
-export declare class ScaleControl extends Control {
-    el: HTMLElement | null;
-    protected _template: string;
-    protected _minWidth: number;
-    protected _maxWidth: number;
-    protected _isCenter: boolean;
-    protected _scaleLabelEl: HTMLElement | null;
-    protected _mPx: number;
-    protected currWidth: number;
-    protected _metersInMinSize: number;
-    constructor(options?: IScaleControlParams);
-    protected _renderTemplate(): HTMLElement;
-    oninit(): void;
-    protected _drawScreen(px: Vec2): void;
-}
-export {};

package/lib/js/control/ScaleControl.js

@@ -1,97 +0,0 @@
-import { binarySearch, parseHTML } from "../utils/shared";
-import { Control } from "./Control";
-import { RADIANS } from "../math";
-import { Vec3 } from "../math/Vec3";
-const scale = [
-    0.001, 0.005, 0.01, 0.05, 0.1, 0.2, 0.5, 1, 2, 3, 5, 10, 20, 30, 50, 100, 200, 300, 500, 1e3, 2e3, 3e3, 5e3, 10e3, 20e3, 30e3, 50e3,
-    100e3, 200e3, 300e3, 500e3, 1000e3, 2000e3, 3000e3, 5000e3, 10000e3
-];
-const TEMPLATE = `<div class="og-scale-container">
-      <div class="og-scale-label"></div>
-      <div class="og-scale-ruler"></div>
-    </div>`;
-/**
- * Planet zoom buttons control.
- */
-export class ScaleControl extends Control {
-    constructor(options = {}) {
-        if (!options.name || options.name === "") {
-            options.name = "scaleControl";
-        }
-        super(options);
-        this._template = TEMPLATE;
-        this._minWidth = 100;
-        this._maxWidth = 150;
-        this._isCenter = options.isCenter != undefined ? options.isCenter : true;
-        this._mPx = 0;
-        this.currWidth = 0;
-        this._metersInMinSize = 0;
-        this.el = null;
-        this._scaleLabelEl = null;
-    }
-    _renderTemplate() {
-        return parseHTML(this._template)[0];
-    }
-    oninit() {
-        this.el = this._renderTemplate();
-        this._scaleLabelEl = this.el.querySelector(".og-scale-label");
-        this.renderer.div.appendChild(this.el);
-        if (this._isCenter) {
-            this.planet.camera.events.on("moveend", () => {
-                this._drawScreen(this.planet.renderer.handler.getCenter());
-            });
-            !this.planet.terrain.isEmpty && this.planet.terrain.events.on("loadend", () => {
-                this._drawScreen(this.planet.renderer.handler.getCenter());
-            });
-        }
-        else {
-            this.renderer.events.on("mousemove", (e) => {
-                if (!e.leftButtonHold && !e.rightButtonHold) {
-                    this._drawScreen(e.pos);
-                }
-            });
-            this.planet.camera.events.on("moveend", () => {
-                let ms = this.renderer.events.mouseState;
-                if (!ms.leftButtonHold && !ms.rightButtonHold) {
-                    this._drawScreen(ms.pos);
-                }
-            });
-        }
-    }
-    _drawScreen(px) {
-        let cam = this.planet.camera;
-        let s0 = px;
-        let dist = this.planet.getDistanceFromPixel(s0) || 0;
-        if (dist === 0) {
-            s0 = cam.project3v(Vec3.ZERO);
-            dist = this.planet.getDistanceFromPixel(s0) || 0;
-        }
-        let p0 = cam.getForward().scaleTo(dist).addA(cam.eye);
-        let tempSize = dist * Math.tan(cam.viewAngle * RADIANS);
-        let p1 = p0.add(cam.getRight().scaleTo(tempSize));
-        let s1 = cam.project3v(p1);
-        this._mPx = tempSize / s1.distance(s0);
-        let metersInMinSize = this._mPx * this._minWidth;
-        let index = binarySearch(scale, metersInMinSize, (a, b) => a - b);
-        if (index < 0) {
-            index = ~index;
-        }
-        let minMeters = scale[index], maxMeters = scale[index + 1];
-        let t = (minMeters - metersInMinSize) / (maxMeters - minMeters);
-        this.currWidth = this._minWidth + t * (this._maxWidth - this._minWidth);
-        if (minMeters >= 1000) {
-            this._scaleLabelEl.innerText = `${minMeters / 1000} km`;
-        }
-        else if (minMeters >= 1) {
-            this._scaleLabelEl.innerText = `${minMeters} m`;
-        }
-        else if (minMeters >= 0.01) {
-            this._scaleLabelEl.innerText = `${minMeters * 100} cm`;
-        }
-        else {
-            this._scaleLabelEl.innerText = `${minMeters * 1000} mm`;
-        }
-        this._metersInMinSize = metersInMinSize;
-        this.el.style.width = this.currWidth + "px";
-    }
-}

package/lib/js/control/SegmentBoundVisualization.d.ts

@@ -1,13 +0,0 @@
-import { EntityCollection } from "../entity/EntityCollection";
-import { Control } from "./Control";
-import type { IControlParams } from "./Control";
-/**
- * Frame per second(FPS) display control.
- */
-export declare class SegmentBoundVisualization extends Control {
-    protected _boundingSphereCollection: EntityCollection;
-    constructor(options: IControlParams);
-    oninit(): void;
-    protected _predraw(): void;
-    protected _draw(): void;
-}

package/lib/js/control/SegmentBoundVisualization.js

@@ -1,37 +0,0 @@
-import { Entity } from "../entity/Entity";
-import { EntityCollection } from "../entity/EntityCollection";
-import { Control } from "./Control";
-/**
- * Frame per second(FPS) display control.
- */
-export class SegmentBoundVisualization extends Control {
-    constructor(options) {
-        super(options);
-        this._boundingSphereCollection = new EntityCollection();
-    }
-    oninit() {
-        this.planet.addEntityCollection(this._boundingSphereCollection);
-        this.renderer.events.on("draw", this._predraw, this);
-        this.planet.events.on("draw", this._draw, this);
-    }
-    _predraw() {
-        this._boundingSphereCollection.clear();
-    }
-    _draw() {
-        const planet = this.planet;
-        for (let i = 0; i < planet._renderedNodes.length; i++) {
-            let si = planet._renderedNodes[i].segment;
-            if (!si._sphereEntity) {
-                si._sphereEntity = new Entity({
-                    billboard: {
-                    //todo: replace with sphere geoObject
-                    }
-                });
-            }
-            //@todo: geoObject
-            //si._sphereEntity.shape.setScale(si.bsphere.radius / 2);
-            //si._sphereEntity.shape.setPosition3v(si.bsphere.center);
-            this._boundingSphereCollection.add(si._sphereEntity);
-        }
-    }
-}

package/lib/js/control/ShowFps.d.ts

@@ -1,10 +0,0 @@
-import { Control } from "./Control";
-import type { IControlParams } from "./Control";
-/**
- * Frame per second(FPS) display control.
- */
-export declare class ShowFps extends Control {
-    constructor(options: IControlParams);
-    oninit(): void;
-    protected _draw(): void;
-}

package/lib/js/control/ShowFps.js

@@ -1,20 +0,0 @@
-import { print2d } from "../utils/shared";
-import { Control } from "./Control";
-/**
- * Frame per second(FPS) display control.
- */
-export class ShowFps extends Control {
-    constructor(options) {
-        super(options);
-    }
-    oninit() {
-        let d = document.createElement("div");
-        d.className = "defaultText ";
-        d.id = "ogShowFpsControl";
-        document.body.appendChild(d);
-        this.renderer.events.on("draw", this._draw, this);
-    }
-    _draw() {
-        print2d("ogShowFpsControl", (1000.0 / this.renderer.handler.deltaTime).toFixed(1), this.renderer.handler.canvas.clientWidth - 60, 0);
-    }
-}