@pirireis/webglobeplugins 0.17.0 → 1.0.2

package/util/build-strategy/{static-dynamic.js → static-dynamic.ts}

@@ -1,41 +1,50 @@
-export var StaticDynamicState;
-(function (StaticDynamicState) {
-    StaticDynamicState["STATIC"] = "STATIC";
-    StaticDynamicState["DYNAMIC"] = "DYNAMIC";
-    StaticDynamicState["TO_STATIC"] = "TO_STATIC"; // TODO: Change this not bidirectional, go to static
-})(StaticDynamicState || (StaticDynamicState = {}));
-export class StaticDynamicStrategy {
-    globe;
-    _staticDynamicState = StaticDynamicState.DYNAMIC;
-    _transitionLevel = 8; // Default transition level
-    _lastStaticDynamicState = StaticDynamicState.STATIC;
-    _lastGeometry = null;
-    _toStatic;
-    constructor(globe, transitionLevel = 8, toStatic) {
-        this.globe = globe;
-        this._transitionLevel = transitionLevel;
-        this._toStatic = toStatic;
-        this.updateState();
-    }
-    updateState() {
-        const currentLOD = this.globe.api_GetCurrentLODWithDecimal();
-        const state = currentLOD < this._transitionLevel ? StaticDynamicState.STATIC : StaticDynamicState.DYNAMIC;
-        const currentGeometry = this.globe.api_GetCurrentGeometry();
-        if (this._lastStaticDynamicState === StaticDynamicState.DYNAMIC && state === StaticDynamicState.STATIC) {
-            this._staticDynamicState = StaticDynamicState.TO_STATIC;
-            this._toStatic();
-        }
-        else if ((currentGeometry !== this._lastGeometry) && state === StaticDynamicState.STATIC) {
-            this._staticDynamicState = StaticDynamicState.TO_STATIC;
-            this._toStatic();
-        }
-        else {
-            this._staticDynamicState = state;
-        }
-        this._lastStaticDynamicState = this._staticDynamicState;
-        this._lastGeometry = currentGeometry;
-    }
-    getState() {
-        return this._staticDynamicState;
-    }
-}
+import { Globe } from '../../types';
+
+export enum StaticDynamicState {
+    STATIC = "STATIC",
+    DYNAMIC = "DYNAMIC",
+    TO_STATIC = "TO_STATIC" // TODO: Change this not bidirectional, go to static
+
+}
+
+
+export class StaticDynamicStrategy {
+    globe: Globe;
+    private _staticDynamicState: StaticDynamicState = StaticDynamicState.DYNAMIC;
+    private _transitionLevel: number = 8; // Default transition level
+    private _lastStaticDynamicState: StaticDynamicState = StaticDynamicState.STATIC;
+    private _lastGeometry: 0 | 1 = null!
+    private _toStatic: () => void;
+    constructor(globe: Globe, transitionLevel: number = 8, toStatic: () => void) {
+        this.globe = globe;
+        this._transitionLevel = transitionLevel;
+        this._toStatic = toStatic;
+
+        this.updateState();
+    }
+
+    updateState() {
+        const currentLOD = this.globe.api_GetCurrentLODWithDecimal();
+        const state = currentLOD < this._transitionLevel ? StaticDynamicState.STATIC : StaticDynamicState.DYNAMIC;
+        const currentGeometry = this.globe.api_GetCurrentGeometry();
+        if (this._lastStaticDynamicState === StaticDynamicState.DYNAMIC && state === StaticDynamicState.STATIC) {
+            this._staticDynamicState = StaticDynamicState.TO_STATIC;
+            this._toStatic();
+        } else if ((currentGeometry !== this._lastGeometry) && state === StaticDynamicState.STATIC) {
+            this._staticDynamicState = StaticDynamicState.TO_STATIC;
+            this._toStatic();
+        } else {
+            this._staticDynamicState = state;
+        }
+        this._lastStaticDynamicState = this._staticDynamicState;
+        this._lastGeometry = currentGeometry;
+    }
+
+
+
+
+    getState(): StaticDynamicState {
+        return this._staticDynamicState;
+    }
+
+}

package/util/check/index.js

@@ -1 +0,0 @@
-"use strict";

package/util/check/typecheck.ts

@@ -0,0 +1,74 @@
+// Generic
+
+import { Color } from "../../types";
+
+interface TextFont {
+    name: string;
+    textColor: string;
+    hollowColor: string;
+    size: number;
+    bold: boolean;
+    italic: boolean;
+}
+
+const doesOwnProperties = (properties: string[], errorMessage: string) => {
+    return (object: Record<string, any>): void => {
+        properties.forEach(element => {
+            if (!object.hasOwnProperty(element)) throw new TypeError(errorMessage + ':' + element);
+        });
+    }
+}
+
+export const isHexColor = (hexColor: string): boolean => /^#[0-9A-F]{6}$/i.test(hexColor);
+export const isHexColorWithOpacity = (hexColor: string): boolean => /^#[0-9A-F]{6}[0-9a-f]{0,2}$/i.test(hexColor);
+
+export const colorCheck = (color: Color): void => {
+    if (Array.isArray(color)) {
+        if (color.length !== 4) throw new TypeError("Color must be an array 4 numbers RGBA");
+        color.forEach(c => {
+            if (typeof c !== "number") throw new TypeError("Color array must contain only numbers");
+            if (c < 0 || c > 1) throw new RangeError("Color values must be between 0 and 1");
+        });
+    }
+}
+
+export const opacityCheck = (opacity: number | any): void => {
+    if (typeof opacity !== "number") throw new TypeError("style.opacity must a number");
+    if (opacity < 0 || 1 < opacity) throw new RangeError("Opacity Range Must be 0-1");
+}
+
+// Text Related 
+
+const fontCheckTypes = doesOwnProperties(["name", "textColor", "hollowColor", "size", "bold", "italic"], "font does not have");
+const fontCheckColors = (textColor: string, hollowColor: string): boolean => isHexColor(textColor) && isHexColor(hollowColor);
+
+export const isTextFont = (textFont: TextFont): void => {
+    fontCheckTypes(textFont);
+    fontCheckColors(textFont.textColor, textFont.hollowColor);
+    if (typeof textFont.size !== "number") throw new TypeError("textFont size is not a number");
+}
+
+export const constraintFloat = (x: number, lowerBound: number | null = null, upperBound: number | null = null): void => {
+    if (typeof x !== "number") throw new Error("type must be numberic");
+    if (lowerBound === null && upperBound === null) return;
+    if (lowerBound !== null && lowerBound > x) throw new Error(`input must be greater than ${lowerBound}`);
+    if (upperBound !== null && x > upperBound) throw new Error(`input must be less than ${upperBound}`);
+}
+
+export const isBoolean = (x: any): void => {
+    if (typeof x !== "boolean") throw new TypeError("type must be boolean");
+}
+
+
+export const mapGetOrThrow = (errorNote: string) => {
+    return (mapInstance: Map<string, any>, ids: string[]) => {
+        if (!ids) throw new Error("There is no map keys to get");
+        const result = [];
+        for (let i = 0; i < ids.length; i++) {
+            const e = mapInstance.get(ids[i]);
+            if (e === undefined) throw new Error(errorNote + " " + ids[i]);
+            result.push(e);
+        }
+        return result;
+    }
+}

package/util/{frame-counter-trigger.js → frame-counter-trigger.ts}

@@ -1,84 +1,99 @@
-import { CameraUniformBlockTotemCache } from "../programs/totems/camerauniformblock";
-export class FrameCounterTrigger {
-    globe;
-    count = 0;
-    threshold;
-    timeoutMs;
-    timeoutId = null;
-    accumulatedChanges = {
-        geometry: false,
-        look: false,
-        lod: false,
-        lod2DWheel: false,
-        elevationScale: false,
-        screenMoved: false
-    };
-    cameraBlockTotem;
-    updateCallback;
-    constructor(globe, threshold, timeoutMs, updateCallback) {
-        this.threshold = threshold;
-        this.timeoutMs = timeoutMs;
-        this.updateCallback = updateCallback;
-        this.globe = globe;
-        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
-    }
-    trigger(level = null) {
-        const globeChanges = this.cameraBlockTotem.getGlobeChanges();
-        if (!globeChanges.screenMoved)
-            return;
-        this.setChanges(globeChanges);
-        if (globeChanges.geometry || globeChanges.elevationScale || globeChanges.lod2DWheel) {
-            this.triggerUpdate();
-            return;
-        }
-        this.count++;
-        if (this.count === 1) {
-            this.startTimeout();
-        }
-        if (this.count >= this.threshold) {
-            this.triggerUpdate();
-        }
-    }
-    startTimeout() {
-        this.clearTimeout();
-        this.timeoutId = setTimeout(() => {
-            this.triggerUpdate();
-        }, this.timeoutMs);
-    }
-    triggerUpdate() {
-        this.clearTimeout();
-        this.updateCallback(this.accumulatedChanges);
-        this.reset();
-    }
-    clearTimeout() {
-        if (this.timeoutId) {
-            clearTimeout(this.timeoutId);
-            this.timeoutId = null;
-        }
-    }
-    setChanges(changes) {
-        // accumulate true states until reset
-        this.accumulatedChanges.geometry = this.accumulatedChanges.geometry || changes.geometry;
-        this.accumulatedChanges.look = this.accumulatedChanges.look || changes.look;
-        this.accumulatedChanges.lod = this.accumulatedChanges.lod || changes.lod;
-        this.accumulatedChanges.elevationScale = this.accumulatedChanges.elevationScale || changes.elevationScale;
-        this.accumulatedChanges.screenMoved = this.accumulatedChanges.screenMoved || changes.screenMoved;
-        this.accumulatedChanges.lod2DWheel = this.accumulatedChanges.lod2DWheel || changes.lod2DWheel;
-    }
-    getLevel() {
-        return this.accumulatedChanges;
-    }
-    reset() {
-        this.count = 0;
-        this.accumulatedChanges.geometry = false;
-        this.accumulatedChanges.look = false;
-        this.accumulatedChanges.lod = false;
-        this.accumulatedChanges.lod2DWheel = false;
-        this.accumulatedChanges.elevationScale = false;
-        this.accumulatedChanges.screenMoved = false;
-        this.clearTimeout();
-    }
-    free() {
-        CameraUniformBlockTotemCache.release(this.globe);
-    }
-}
+import { CameraUniformBlockTotemCache, CameraUniformBlockTotem } from "../programs/totems/camerauniformblock";
+import { Globe, GlobeChanges } from "../types";
+
+type UpdateCallback = (globeChanges: GlobeChanges) => void;
+
+export class FrameCounterTrigger {
+    private globe: Globe;
+    private count: number = 0;
+    private threshold: number;
+    private timeoutMs: number;
+    private timeoutId: ReturnType<typeof setTimeout> | null = null;
+    readonly accumulatedChanges: GlobeChanges = {
+        geometry: false,
+        look: false,
+        lod: false,
+        lod2DWheel: false,
+        elevationScale: false,
+        screenMoved: false
+    };
+    private cameraBlockTotem: CameraUniformBlockTotem;
+    private updateCallback: UpdateCallback;
+
+    constructor(globe: Globe, threshold: number, timeoutMs: number, updateCallback: UpdateCallback) {
+        this.threshold = threshold;
+        this.timeoutMs = timeoutMs;
+        this.updateCallback = updateCallback;
+        this.globe = globe;
+        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+
+    }
+
+    trigger(level: number | null = null) {
+        const globeChanges = this.cameraBlockTotem.getGlobeChanges();
+        if (!globeChanges.screenMoved) return;
+        this.setChanges(globeChanges);
+        if (globeChanges.geometry || globeChanges.elevationScale || globeChanges.lod2DWheel) {
+            this.triggerUpdate();
+            return;
+        }
+
+        this.count++;
+        if (this.count === 1) {
+            this.startTimeout();
+        }
+        if (this.count >= this.threshold) {
+            this.triggerUpdate();
+        }
+    }
+
+    private startTimeout() {
+        this.clearTimeout();
+        this.timeoutId = setTimeout(() => {
+            this.triggerUpdate();
+        }, this.timeoutMs);
+    }
+
+    private triggerUpdate() {
+        this.clearTimeout();
+        this.updateCallback(this.accumulatedChanges);
+        this.reset();
+    }
+
+    private clearTimeout() {
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+    }
+
+    private setChanges(changes: GlobeChanges) {
+        // accumulate true states until reset
+        this.accumulatedChanges.geometry = this.accumulatedChanges.geometry || changes.geometry;
+        this.accumulatedChanges.look = this.accumulatedChanges.look || changes.look;
+        this.accumulatedChanges.lod = this.accumulatedChanges.lod || changes.lod;
+        this.accumulatedChanges.elevationScale = this.accumulatedChanges.elevationScale || changes.elevationScale;
+        this.accumulatedChanges.screenMoved = this.accumulatedChanges.screenMoved || changes.screenMoved;
+        this.accumulatedChanges.lod2DWheel = this.accumulatedChanges.lod2DWheel || changes.lod2DWheel;
+    }
+
+
+    getLevel() {
+        return this.accumulatedChanges;
+    }
+
+    reset() {
+        this.count = 0;
+        this.accumulatedChanges.geometry = false;
+        this.accumulatedChanges.look = false;
+        this.accumulatedChanges.lod = false;
+        this.accumulatedChanges.lod2DWheel = false;
+        this.accumulatedChanges.elevationScale = false;
+        this.accumulatedChanges.screenMoved = false;
+        this.clearTimeout();
+    }
+
+    free() {
+        CameraUniformBlockTotemCache.release(this.globe);
+    }
+}

package/util/geometry/{index.js → index.ts}

@@ -1,121 +1,155 @@
-import { GLOBE_DEFAULT_MIN_LOD, GLOBE_DEFAULT_MAX_LOD, POLE2 } from "../../constants";
-function latLongToPixelXY(latitude, longitude) {
-    return {
-        x: (longitude + 180) / 360,
-        y: (90 - latitude) / 180
-    };
-}
-/**
- * createBBoxMatrix( minX, maxX, minY, maxY)
- * use this matrix to transform a point from 0 to 1 range to the bounding box
- * for example: Transform image coordinates to map coordinates
- * glsl`vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, v_particle_pos.y, 1.0);`
- */
-function createBBoxMatrix(minX, maxX, minY, maxY) {
-    return new Float32Array([
-        maxX - minX, 0, 0,
-        0, maxY - minY, 0,
-        minX, minY, 1
-    ]);
-}
-function latLongBboxtoPixelXYBbox(minX, minY, maxX, maxY) {
-    const minXY = latLongToPixelXY(minY, minX);
-    const maxXY = latLongToPixelXY(maxY, maxX);
-    return createBBoxMatrix(minXY.x, maxXY.x, minXY.y, maxXY.y);
-}
-/**
- *
- * @param array - The array to normalize
- * @param newLength - The target length for the normalized array
- * @returns Normalized Float32Array
- */
-function normalize(array, newLength = 1) {
-    let total = 0;
-    for (let i = 0; i < array.length; i++) {
-        total += array[i] * array[i];
-    }
-    const len = newLength / Math.sqrt(total);
-    const result = new Float32Array(array.length);
-    for (let i = 0; i < array.length; i++) {
-        result[i] = array[i] * len;
-    }
-    return result;
-}
-// TODO carry the usefull content to math module. 
-function sphereCoord(long, lat, globe, height = 0) {
-    return normalize(globe.api_GetCartesian3DPoint(long, lat, 0, false), 6378.137 + height);
-}
-function clamp(value, min, max) {
-    return Math.min(Math.max(value, min), max);
-}
-function _flatZoomLevel(globe) {
-    const { width, height } = globe.api_GetCurrentWorldWH();
-    const curLod = Math.log(POLE2 / Math.min(width, height)) / Math.LN2 + GLOBE_DEFAULT_MIN_LOD;
-    return curLod;
-}
-function _sphereZoomLevel(globe) {
-    // Sorted array of [lod, altitude]
-    const altitudesAsMeterByLod = [
-        [25, 39.97],
-        [24, 39.97],
-        [23, 39.97],
-        [22, 39.97],
-        [21, 84.84],
-        [20, 169.95],
-        [19, 335.87],
-        [18, 672.80],
-        [17, 1352.01],
-        [16, 2688.90],
-        [15, 5386.31],
-        [14, 10611.02],
-        [13, 21526.80],
-        [12, 43121.77],
-        [11, 86927.14],
-        [10, 171201.96],
-        [9, 336039.90],
-        [8, 678769.05],
-        [7, 1379009.96],
-        [6, 2770920.56],
-        [5, 5837640.93],
-        [4, 12408290.88],
-        [3, 25512546.06],
-        [2, 25512546.06],
-        [1, 25512546.06],
-        [0, 25512546.06]
-    ];
-    const { Distance: altitude } = globe.api_GetCurrentLookInfo();
-    const defMinLod = GLOBE_DEFAULT_MIN_LOD;
-    const defMaxLod = GLOBE_DEFAULT_MAX_LOD;
-    // Binary search for correct LOD
-    let left = 0, right = altitudesAsMeterByLod.length - 1;
-    if (altitude > altitudesAsMeterByLod[right][1]) {
-        return clamp(0, defMinLod, defMaxLod);
-    }
-    if (altitude < altitudesAsMeterByLod[0][1]) {
-        return clamp(25, defMinLod, defMaxLod);
-    }
-    while (left < right) {
-        let mid = Math.floor((left + right) / 2);
-        let currAlt = altitudesAsMeterByLod[mid][1];
-        let nextAlt = altitudesAsMeterByLod[mid + 1][1];
-        if (altitude >= currAlt && altitude <= nextAlt) {
-            let lod = altitudesAsMeterByLod[mid][0];
-            if (currAlt === nextAlt) {
-                return clamp(lod, defMinLod, defMaxLod);
-            }
-            return clamp(lod + (-currAlt + altitude) / (-currAlt + nextAlt), defMinLod, defMaxLod);
-        }
-        if (altitude > nextAlt) {
-            left = mid + 1;
-        }
-        else {
-            right = mid;
-        }
-    }
-    return GLOBE_DEFAULT_MIN_LOD;
-}
-function approximatedZoomLevel(globe) {
-    const is3D = globe.api_GetCurrentGeometry() === 0;
-    return is3D ? _sphereZoomLevel(globe) : _flatZoomLevel(globe);
-}
-export { createBBoxMatrix, latLongToPixelXY, latLongBboxtoPixelXYBbox, sphereCoord, normalize, approximatedZoomLevel };
+import { Globe } from "../../types";
+import {GLOBE_DEFAULT_MIN_LOD,GLOBE_DEFAULT_MAX_LOD, POLE2} from "../../constants";
+
+
+
+interface PixelXY {
+    x: number;
+    y: number;
+}
+
+
+
+function latLongToPixelXY(latitude: number, longitude: number): PixelXY {
+    return {
+        x: (longitude + 180) / 360,
+        y: (90 - latitude) / 180
+    };
+}
+
+/**
+ * createBBoxMatrix( minX, maxX, minY, maxY)
+ * use this matrix to transform a point from 0 to 1 range to the bounding box
+ * for example: Transform image coordinates to map coordinates
+ * glsl`vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, v_particle_pos.y, 1.0);`
+ */
+function createBBoxMatrix(minX: number, maxX: number, minY: number, maxY: number): Float32Array {
+    return new Float32Array([
+        maxX - minX, 0, 0,
+        0, maxY - minY, 0,
+        minX, minY, 1
+    ])
+}
+
+function latLongBboxtoPixelXYBbox(minX: number, minY: number, maxX: number, maxY: number): Float32Array {
+    const minXY = latLongToPixelXY(minY, minX);
+    const maxXY = latLongToPixelXY(maxY, maxX);
+    return createBBoxMatrix(minXY.x, maxXY.x, minXY.y, maxXY.y);
+}
+
+/**
+ * 
+ * @param array - The array to normalize
+ * @param newLength - The target length for the normalized array
+ * @returns Normalized Float32Array
+ */
+function normalize(array: ArrayLike<number>, newLength: number = 1): Float32Array {
+    let total = 0;
+    for (let i = 0; i < array.length; i++) {
+        total += array[i] * array[i];
+    }
+    const len = newLength / Math.sqrt(total);
+    const result = new Float32Array(array.length);
+    for (let i = 0; i < array.length; i++) {
+        result[i] = array[i] * len;
+    }
+    return result;
+}
+
+
+// TODO carry the usefull content to math module. 
+function sphereCoord(long: number, lat: number, globe: Globe, height: number = 0): Float32Array {
+    return normalize(globe.api_GetCartesian3DPoint(long, lat, 0, false), 6378.137 + height);
+}
+
+
+
+
+function clamp(value: number, min: number, max: number): number {
+    return Math.min(Math.max(value, min), max);
+}
+
+function _flatZoomLevel(globe: Globe): number {
+    const {width, height} = globe.api_GetCurrentWorldWH();
+    const curLod = Math.log(POLE2 / Math.min(width, height)) / Math.LN2 + GLOBE_DEFAULT_MIN_LOD
+    return curLod
+}
+
+
+function _sphereZoomLevel(globe: Globe): number {
+    // Sorted array of [lod, altitude]
+    const altitudesAsMeterByLod = [
+        [25, 39.97],
+        [24, 39.97],
+        [23, 39.97],
+        [22, 39.97],
+        [21, 84.84],
+        [20, 169.95],
+        [19, 335.87],
+        [18, 672.80],
+        [17, 1352.01],
+        [16, 2688.90],
+        [15, 5386.31],
+        [14, 10611.02],
+        [13, 21526.80],
+        [12, 43121.77],
+        [11, 86927.14],
+        [10, 171201.96],
+        [9, 336039.90],
+        [8, 678769.05],
+        [7, 1379009.96],
+        [6, 2770920.56],
+        [5, 5837640.93],
+        [4, 12408290.88],
+        [3, 25512546.06],
+        [2, 25512546.06],
+        [1, 25512546.06],
+        [0, 25512546.06]
+    ];
+
+    const { Distance: altitude } = globe.api_GetCurrentLookInfo();
+    const defMinLod = GLOBE_DEFAULT_MIN_LOD;
+    const defMaxLod = GLOBE_DEFAULT_MAX_LOD;
+
+    // Binary search for correct LOD
+    let left = 0, right = altitudesAsMeterByLod.length - 1;
+    if (altitude > altitudesAsMeterByLod[right][1]) {
+        return clamp(0, defMinLod, defMaxLod);
+    }
+    if (altitude < altitudesAsMeterByLod[0][1]) {
+        return clamp(25, defMinLod, defMaxLod);
+    }
+    while (left < right) {
+        let mid = Math.floor((left + right) / 2);
+        let currAlt = altitudesAsMeterByLod[mid][1];
+        let nextAlt = altitudesAsMeterByLod[mid + 1][1];
+        if (altitude >= currAlt && altitude <= nextAlt) {
+            let lod = altitudesAsMeterByLod[mid][0];
+            if (currAlt === nextAlt) {
+                return clamp(lod, defMinLod, defMaxLod);
+            }
+            return clamp(
+                lod + ( - currAlt + altitude) / ( -currAlt + nextAlt),
+                defMinLod, defMaxLod
+            );
+        }
+        if (altitude > nextAlt) {
+            left = mid + 1;
+        } else {
+            right = mid;
+        }
+    }
+    return GLOBE_DEFAULT_MIN_LOD;
+}
+
+
+
+function approximatedZoomLevel(globe: Globe): number {
+    const is3D = globe.api_GetCurrentGeometry() === 0;
+    return is3D ? _sphereZoomLevel(globe) : _flatZoomLevel(globe);
+}
+
+
+
+export { createBBoxMatrix, latLongToPixelXY, latLongBboxtoPixelXYBbox, sphereCoord, normalize, approximatedZoomLevel };
+export type { PixelXY, Globe };