@pirireis/webglobeplugins 1.0.2 → 1.0.3

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

@@ -1,50 +1,41 @@
-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;
-    }
-
-}
+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;
+    }
+}

package/util/check/index.js

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

package/util/check/typecheck.js

@@ -0,0 +1,66 @@
+// Generic
+const doesOwnProperties = (properties, errorMessage) => {
+    return (object) => {
+        properties.forEach(element => {
+            if (!object.hasOwnProperty(element))
+                throw new TypeError(errorMessage + ':' + element);
+        });
+    };
+};
+export const isHexColor = (hexColor) => /^#[0-9A-F]{6}$/i.test(hexColor);
+export const isHexColorWithOpacity = (hexColor) => /^#[0-9A-F]{6}[0-9a-f]{0,2}$/i.test(hexColor);
+export const colorCheck = (color) => {
+    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) => {
+    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, hollowColor) => isHexColor(textColor) && isHexColor(hollowColor);
+export const isTextFont = (textFont) => {
+    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, lowerBound = null, upperBound = null) => {
+    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) => {
+    if (typeof x !== "boolean")
+        throw new TypeError("type must be boolean");
+};
+export const mapGetOrThrow = (errorNote) => {
+    return (mapInstance, ids) => {
+        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.ts → frame-counter-trigger.js}

@@ -1,99 +1,84 @@
-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);
-    }
-}
+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);
+    }
+}

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

@@ -1,155 +1,121 @@
-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 };
+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 };