@pirireis/webglobeplugins 0.16.0 → 0.16.2

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

@@ -1,99 +0,0 @@
-/**
- * # 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

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

@@ -1,74 +0,0 @@
-// 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

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

@@ -1,64 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

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

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

@@ -1,47 +0,0 @@
-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 }