@pirireis/webglobeplugins 0.15.35 → 0.16.0

package/util/algorithms/search-binary.js

@@ -1,25 +1,26 @@
-/**
- * @typedef {Array<number>} ListLike
- * @typedef {number || null} Index
- */
-/**
- * @param {ListLike} container
- * @param {number} value
- * @returns {Index}
- */
-const findFirstIndexInRange = (container, value) => {
-    let start = 0;
-    let end = container.length - 1;
-    let mid = 0;
-    while (start <= end) {
-        mid = Math.floor((start + end) / 2);
-        if (container[mid] <= value && value <= container[mid + 1])
-            return mid;
-        if (container[mid] < value)
-            start = mid + 1;
-        else
-            end = mid - 1;
-    }
-    return null;
-};
-export { findFirstIndexInRange };
+/**
+ * @typedef {Array<number>} ListLike
+ * @typedef {number || null} Index
+ */
+
+/**
+ * @param {ListLike} container
+ * @param {number} value
+ * @returns {Index}
+ */
+const findFirstIndexInRange = (container, value) => {
+    let start = 0;
+    let end = container.length - 1;
+    let mid = 0;
+    while (start <= end) {
+        mid = Math.floor((start + end) / 2);
+        if (container[mid] <= value && value <= container[mid + 1]) return mid;
+        if (container[mid] < value) start = mid + 1;
+        else end = mid - 1;
+    }
+    return null;
+}
+
+
+export { findFirstIndexInRange };
+

package/util/build-strategy/general-strategy.ts

@@ -0,0 +1,99 @@
+/**
+ * # Considerations ---
+ * - RABIT LOD change should trigger build immediately
+ * - CRUD operations should trigger build immediately
+ * - CameraAngle Change should trigger build immediately for Plugins employ DENSITY variation mechanism
+ * 
+ */
+
+import { Globe, GlobeLookInfo } from '../../types';
+
+
+enum State {
+    STATIC = "STATIC",
+    DYNAMIC = "DYNAMIC",
+    TRANSIENT = "TRANSIENT"
+}
+
+
+
+
+class GeneralStrategy {
+    globe: Globe;
+    private _state: State = State.DYNAMIC;
+    private _transitionLevel: number = 8; // Default transition level
+    private _lastLOD: number = 1000; // an extreme value to trigger initial build
+    private _lastCameraPosition: [number, number, number] = [0, 0, 0]; // Initial camera position
+    private _lastLookInfo: GlobeLookInfo = {
+        CenterLong: 0,
+        CenterLat: 0,
+        Distance: 0,
+        Tilt: 0,
+        NorthAng: 0
+    }
+    private _currentLOD: number = 1000; // an extreme value to trigger initial build
+    private _currentCameraPosition: [number, number, number] = [0, 0, 0]; // Initial camera position
+    private _currentLookInfo: GlobeLookInfo = {
+        CenterLong: 0,
+        CenterLat: 0,
+        Distance: 0,
+        Tilt: 0,
+        NorthAng: 0
+    }
+
+    // private _staticBuildThreshold: number = 8; // Default static build threshold
+    // private _triggerStaticBuild: boolean = false;
+
+
+    // private _isMovedParams: boolean = false
+    // private _isCameraChangedParams: boolean = false
+    // private _elevationChangedParams: boolean = false
+
+
+
+    constructor(
+
+        globe: Globe,
+        transitionLevel: number = 8
+    ) {
+        // Initialization logic if needed
+        this.globe = globe;
+        this._transitionLevel = transitionLevel;
+
+
+
+    }
+
+    calculateState() {
+
+
+    }
+
+    getState(): State {
+        return this._state;
+    }
+
+    // Additional methods and properties can be added here as needed
+
+
+    // @ts-ignore
+    _isMoved(): boolean {
+
+    }
+
+    // @ts-ignore
+    _isCameraChanged(): boolean {
+    }
+
+    // @ts-ignore
+    _elevationChanged(): boolean {
+
+    }
+
+    // @ts-ignore
+    // _triggerStaticBuild(): boolean {
+    //     if (this._lastLOD < this._staticBuildThreshold && this._currentLOD < this._staticBuildThreshold) {
+    //         this._triggerStaticBuild = true;
+    //     }
+    // }
+}

package/util/build-strategy/static-dynamic.ts

@@ -0,0 +1,50 @@
+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.ts

@@ -0,0 +1,99 @@
+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.ts

@@ -0,0 +1,64 @@
+import { Globe } from "../../types";
+
+
+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);
+}
+
+export { createBBoxMatrix, latLongToPixelXY, latLongBboxtoPixelXYBbox, sphereCoord, normalize };
+export type { PixelXY, Globe };

package/util/gl-util/buffer/attribute-loader.ts

@@ -0,0 +1,84 @@
+import { BufferAndReadInfo, AttributeLoaderOptions } from "../../../types";
+
+
+/**
+ * @typedef BufferAndReadInfo Buffers can be intertwined or interleaved.
+ * This object forces user to adapt generic convention of buffer and read information.
+ * @type {Object}
+ * @property {WebGLBuffer} buffer
+ * @property {number} stride
+ * @property {number} offset
+ */
+
+/**
+ * 
+ * @param {WebGLBuffer} gl 
+ * @param {BufferAndReadInfo} bufferAndReadInfo
+ * @param {number} index 
+ * @param {number} size 
+ * @param {Object} options
+ * @param {*} options.type | default gl.FLOAT, gl.UNSIGNED_BYTE, gl.SHORT, gl.UNSIGNED_SHORT, gl.INT, gl.UNSIGNED_INT
+ * @param {number} options.divisor
+ * @param {Array<number>} options.escapeValues 
+ * @returns 
+ */
+
+
+
+const attributeLoader = (
+    gl: WebGL2RenderingContext,
+    bufferAndReadInfo: BufferAndReadInfo | null,
+    index: number,
+    size: number,
+    {
+        divisor = null,
+        type = null,
+        escapeValues = null,
+        normalized = false
+    }: AttributeLoaderOptions = {}) => {
+    if (bufferAndReadInfo == null || bufferAndReadInfo.buffer == null) {
+        if (escapeValues) constantFunction(gl, index, size, escapeValues);
+        return;
+    }
+
+    const { buffer, stride, offset } = bufferAndReadInfo;
+    if (!gl || !buffer) {
+        throw new Error("Invalid WebGL context or buffer");
+    }
+    if (index < 0) {
+        throw new Error("Attribute index must be non-negative");
+    }
+    if (stride < 0 || offset < 0) {
+        throw new Error("Stride and offset must be non-negative");
+    }
+    const attribType = type === null ? gl.FLOAT : type;
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    gl.enableVertexAttribArray(index);
+    gl.vertexAttribPointer(index, size, attribType, normalized, stride, offset);
+    if (divisor !== null) {
+        gl.vertexAttribDivisor(index, divisor);
+    }
+}
+
+/**
+ * 
+ * @param {WebGLBuffer} buffer 
+ * @param {number} stride 
+ * @param {number} offset 
+ * @returns {BufferAndReadInfo}
+ */
+const createBufferAndReadInfo = (buffer: WebGLBuffer | null, stride: number = 0, offset: number = 0): BufferAndReadInfo | null => {
+    if (buffer == null) return null;
+    return { buffer, stride, offset };
+}
+
+
+
+const constantFunction = (gl: WebGL2RenderingContext, index: number, size: number, escapeValues: Array<number>) => {
+    const func = `vertexAttrib${size}f`;
+    // @ts-ignore
+    gl[func](index, ...escapeValues);
+}
+
+
+export { attributeLoader, createBufferAndReadInfo };

package/util/gl-util/buffer/index.ts

@@ -0,0 +1,6 @@
+// import './types';
+
+import { attributeLoader } from './attribute-loader';
+
+
+export { attributeLoader };

package/util/gl-util/draw-options/methods.ts

@@ -0,0 +1,47 @@
+import { DrawRangeIndexParams, DrawRange } from "../../../types"
+/**
+ * Draws instanced geometry using WebGL2.
+ */
+const drawInstanced = (
+    gl: WebGL2RenderingContext,
+    mode: GLenum,
+    drawOptions: DrawRangeIndexParams,
+    vertexCount: number
+): void => {
+    const { drawRange, elementBufferIndexType = gl.UNSIGNED_INT } = drawOptions;
+    const { first = 0, count } = drawRange;
+    if (drawOptions.elementBuffer) {
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, drawOptions.elementBuffer ?? null);
+        gl.drawElementsInstanced(mode, vertexCount, elementBufferIndexType, first, count);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+    } else {
+        gl.drawArraysInstanced(mode, first, vertexCount, count);
+    }
+}
+
+/**
+ * Draws geometry using WebGL2.
+ */
+const drawArrays = (
+    gl: WebGL2RenderingContext,
+    defaultMode: GLenum,
+    drawOptions: DrawRangeIndexParams
+): void => {
+    const {
+        drawRange,
+        elementBuffer,
+        elementBufferIndexType = gl.UNSIGNED_INT,
+        drawMode = null
+    } = drawOptions;
+    const { first = 0, count } = drawRange;
+    const mode = drawMode ?? defaultMode;
+    if (elementBuffer) {
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementBuffer);
+        gl.drawElements(mode, count, elementBufferIndexType, first);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+    } else {
+        gl.drawArrays(mode, first, count);
+    }
+}
+
+export { drawArrays, drawInstanced }