@pirireis/webglobeplugins 0.9.5 → 0.9.7

package/util/account/single-attribute-buffer-management/buffer-manager.ts

@@ -1,119 +0,0 @@
-/**
- * BufferOffsetManager
- * Purpose: To manage the offset of the buffer. Plus extend and defrag the buffer. 
- * ------------------------------------------------------------------------------------------------------------------------------------------- * Functions:
- * 1. getOffet(key) : return the offset of the key if not found return false.
- * 2. setOffset(key, offset) : set the offset of the key.
- * 3. nextOffset() : return the next available offset if not return false.
- * 4. delete(key) : delete the key and return true if not found return false.
- * 5. defragBuffer(gl, buffer, bufferType, newCapacity = null) : defrag the buffer. if newCapacity is not provided the buffer is vacumed.
- * 6. extendBuffer(gl, buffer, bufferType, newCapacity) : extend the buffer.
- * -------------------------------------------------------------------------------------------------------------------------------------------
- * What this class does NOT do:
- * ADD, DELETE, READ
- * ADD, inputs needs to be turn into a block and put into buffer. Bulk will be more performant.
- * DELETE, might be a set to single byte to indicate the tombstone.
- * READ, most of the time is not needed to be read, unless for defraging.
- * This unpredicatable behavior is not handled by this class.
- */
-
-export class BufferManager {
-    gl: WebGL2RenderingContext;
-    buffer: WebGLBuffer;
-    itemSize: number;
-    bufferType: string;
-    isFreed: boolean = false;
-
-    constructor(gl: WebGL2RenderingContext, itemSize: number, { bufferType = "STATIC_DRAW", buffer = null, initialCapacity = null } = {}) {
-        this.gl = gl;
-        this.itemSize = itemSize;
-        this.bufferType = bufferType;
-        this.buffer = buffer === null ? gl.createBuffer() : buffer;
-        if (initialCapacity !== null) this.resetWithCapacity(initialCapacity);
-    }
-
-    resetWithCapacity(capacity: number) {
-        const { gl, buffer, bufferType, itemSize } = this;
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        // @ts-ignore
-        gl.bufferData(gl.ARRAY_BUFFER, capacity * itemSize * 4, gl[bufferType]);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-
-    deleteBulk(offsets: number[]) {
-        const { gl, buffer, itemSize } = this;
-        const emptyBlock = new Float32Array(this.itemSize).fill(NaN)
-        const offsetMultiplier = itemSize * 4;
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        for (let offset of offsets) {
-            if (offset !== undefined) {
-                gl.bufferSubData(gl.ARRAY_BUFFER, offset * offsetMultiplier, emptyBlock);
-            }
-        }
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-
-
-    insertBulk(blocks: any[], offsets: number[]) {
-        const { gl, buffer, itemSize } = this;
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        const offsetMultiplier = itemSize * 4;
-        for (let i = 0; i < blocks.length; i++) {
-            const block = blocks[i];
-            const offset = offsets[i] * offsetMultiplier;
-            if (offset !== undefined) gl.bufferSubData(gl.ARRAY_BUFFER, offset, block);
-        }
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-
-
-    // TODO: this is broken
-    defrag(offsetValues: MapIterator<number> | number[], occupiedCapacity: number, newCapacity: number) {
-        const { gl, buffer, bufferType, itemSize } = this;
-
-        const newArray = new Float32Array(newCapacity * itemSize);
-        const bufferData = this._getBufferData(occupiedCapacity);
-        let newOffset = 0;
-        for (const offset of offsetValues) {
-            const itemOffset = offset * itemSize;
-            newArray.set(bufferData.slice(itemOffset, itemOffset + itemSize), newOffset);
-            newOffset += itemSize;
-        }
-
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        // @ts-ignore
-        gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
-        gl.bufferSubData(gl.ARRAY_BUFFER, 0, newArray);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-
-    }
-
-    extendBuffer(occupiedCapacity: number, newCapacity: number) {
-        const { gl, buffer, bufferType } = this;
-        const itemSize = this.itemSize;
-        const bufferData = this._getBufferData(occupiedCapacity);
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        // @ts-ignore
-        gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
-        gl.bufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-
-    _getBufferData(occupiedCapacity: number): Float32Array {
-        const { gl, buffer } = this;
-        const size = occupiedCapacity * this.itemSize;
-        const bufferData = new Float32Array(size);
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        gl.getBufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        return bufferData;
-    }
-
-    free() {
-        if (this.isFreed) return;
-        this.gl.deleteBuffer(this.buffer);
-        // this.buffer = null;
-        // this.gl = null;
-        this.isFreed = true;
-    }
-}

package/util/account/single-attribute-buffer-management/buffer-orchestrator.ts

@@ -1,173 +0,0 @@
-import { BufferOrchestrator as BufferOrchestratorI, BufferManagersMap, BufferManager } from "./types";
-
-const EXTRA_SIZE = 10;
-
-export class BufferOrchestrator implements BufferOrchestratorI {
-    _capacity: number;
-    offsetMap: Map<string, number>;
-    tombstoneOffsets: number[];
-    _length: number;
-
-    constructor({ capacity = 10 } = {}) {
-        this._capacity = capacity;
-        this.offsetMap = new Map();
-        this.tombstoneOffsets = [];
-        this._length = 0;
-    }
-
-
-    resetWithCapacity(bufferManagersMap: BufferManagersMap, capacity: number | null = null) {
-        this._capacity = capacity !== null ? capacity : this._capacity;
-        for (const [key, { bufferManager }] of bufferManagersMap) {
-            bufferManager.resetWithCapacity(this._capacity);
-        }
-        this.offsetMap.clear();
-        this.tombstoneOffsets = [];
-        this._length = 0;
-    }
-
-    insertBulk(items: any[], bufferManagersMap: BufferManagersMap) {
-        this.autoExtendBuffers(items.length, bufferManagersMap);
-        const { offsetMap } = this;
-        const offsets = [];
-        for (const item of items) {
-            let o = offsetMap.get(item.key);
-            const offset = o !== undefined ? o : this.nextOffset() as number;
-            offsetMap.set(item.key, offset);
-            offsets.push(offset);
-        }
-        for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
-            bufferManager.insertBulk(items.map(adaptor), offsets);
-        }
-    }
-
-
-    // does not assign offset to the new items.
-    updateBulk(items: any[], bufferManagersMap: BufferManagersMap, bufferKeys: string[] | null = null) {
-        const { offsetMap } = this;
-        const offsets = [];
-        for (const item of items) {
-            const offset = offsetMap.get(item.key);
-            if (offset !== undefined) {
-                offsets.push(offset);
-            } else {
-                throw new Error("updateBulk item Key does not exist");
-            }
-        }
-        if (bufferKeys) {
-            for (const key of bufferKeys) {
-                const bufferManagerComp = bufferManagersMap.get(key);
-                if (bufferManagerComp === undefined) throw new Error("updateBulk bufferKey does not exist");
-                const { bufferManager, adaptor } = bufferManagerComp;
-                bufferManager.insertBulk(items.map(adaptor), offsets);
-            }
-        } else {
-            for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
-                bufferManager.insertBulk(items.map(adaptor), offsets);
-            }
-        }
-
-    }
-
-
-    deleteBulk(keys: string[], bufferManagersMap: BufferManagersMap) {
-        const offsets = [];
-        for (const key of keys) {
-            const offset = this.getOffset(key);
-            if (offset !== undefined) {
-                offsets.push(offset);
-                this.offsetMap.delete(key);
-                this.tombstoneOffsets.push(offset);
-            }
-        }
-        for (const [key, { bufferManager }] of bufferManagersMap) {
-            bufferManager.deleteBulk(offsets);
-        }
-    }
-
-
-    getOffset(key: string) {
-        return this.offsetMap.get(key);
-    }
-
-    nextOffset(): number | boolean {
-        if (this.tombstoneOffsets.length > 0) {
-            const offset = this.tombstoneOffsets.pop() as number;
-            return offset;
-        }
-        if (this._length < this._capacity) {
-            return this._length++;
-        }
-        return false;
-    }
-
-
-    autoExtendBuffers(itemsLength: number, bufferManagersMap: BufferManagersMap) {
-        if (itemsLength <= this.emptySpace) return;
-        const newCapacity = this.length + itemsLength;
-        for (const [key, { bufferManager }] of bufferManagersMap) {
-            bufferManager.extendBuffer(this.length, newCapacity);
-        }
-        this._capacity = newCapacity;
-    }
-
-
-    defrag(bufferManagers: BufferManagersMap, bufferKeys: string[]) { // TODO defrag and leave some empty space
-        const offsetMap = this.offsetMap;
-        const newCapacity = offsetMap.size + EXTRA_SIZE;
-        if (bufferKeys) {
-            for (const key of bufferKeys) {
-                const offset = offsetMap.get(key);
-                if (offset !== undefined) {
-                    for (const [key, { bufferManager }] of bufferManagers) {
-                        bufferManager.defrag([offset], this.length, newCapacity);
-                    }
-                }
-            }
-        } else {
-            for (const [key, { bufferManager }] of bufferManagers) {
-                bufferManager.defrag(offsetMap.values(), this.length, newCapacity);
-            }
-        }
-        this._defrag();
-        this._length = offsetMap.size;
-        this._capacity = newCapacity;
-        this.tombstoneOffsets = [];
-    }
-
-
-    /**
-     * Flushes metadata and sets length to 0 without actualize change on buffers
-     * This method created for cases in which data is loaded on each frame
-     */
-    flush({ capacity = 10 } = {}) {
-        this._length = 0;
-        this._capacity = capacity;
-        this.tombstoneOffsets = []
-        this.offsetMap.clear();
-    }
-
-    _defrag() {
-        const newOffsetMap = new Map();
-        let newOffset = 0;
-        for (const [key, offset] of this.offsetMap) {
-            newOffsetMap.set(key, newOffset++);
-        }
-        this.offsetMap = newOffsetMap
-    }
-
-    get length() {
-        return this._length;
-    }
-
-    get emptySpace() {
-        return this._capacity - this.offsetMap.size;
-    }
-
-    get capacity() {
-        return this._capacity;
-    }
-}
-
-
-

package/util/account/single-attribute-buffer-management/index.ts

@@ -1,13 +0,0 @@
-import { BufferOrchestrator } from "./buffer-orchestrator";
-import { BufferManager } from "./buffer-manager";
-import { ObjectStore } from "./object-store";
-
-type BufferManagement = Map<string, {
-    bufferManager: BufferManager,
-    adaptor: (item: any) => Float32Array,
-}>;
-
-
-export { BufferOrchestrator, BufferManager, ObjectStore, BufferManagement };
-
-

package/util/account/single-attribute-buffer-management/object-store.ts

@@ -1,65 +0,0 @@
-
-export class ObjectStore {
-    _container;
-
-
-    constructor({ initialCapcity = 10 } = {}) {
-        this._container = this._createEmptyList(initialCapcity);
-    }
-
-
-    resetWithCapacity(capacity: number) {
-        this._container = this._createEmptyList(capacity);
-    }
-
-
-    deleteBulk(offsets: number[]) {
-        for (let i = 0; i < offsets.length; i++) {
-            const offset = offsets[i];
-            if (offset !== undefined) {
-                this._container[offset] = null;
-            }
-        }
-    }
-
-
-    insertBulk(objects: any[], offsets: number[]) {
-        for (let i = 0; i < objects.length; i++) {
-            const object = objects[i];
-            const offset = offsets[i];
-            if (offset !== undefined) {
-                this._container[offset] = object;
-            }
-        }
-    }
-
-    defrag(offsetValues: number[], occupiedCapacity: number, newCapacity: number) {
-
-        const hold = this._createEmptyList(newCapacity);
-        for (let i = 0; i < offsetValues.length; i++) {
-            const offset = offsetValues[i];
-            if (offset !== undefined) {
-                hold[i] = this._container[offset];
-            }
-        }
-        this._container = hold;
-    }
-
-    extendBuffer(occupiedCapacity: number, newCapacity: number) {
-        const oldCapacity = this._container.length;
-        this._container = this._container.concat(this._createEmptyList(newCapacity - oldCapacity));
-    }
-
-    _createEmptyList(size: number) {
-        return new Array(size).fill(null);
-    }
-
-    get(index: number) {
-        return this._container[index];
-    }
-
-
-    free() {
-
-    }
-}

package/util/account/single-attribute-buffer-management/types.ts

@@ -1,39 +0,0 @@
-type BufferManagersMap = Map<string, {
-    bufferManager: BufferManager;
-    adaptor: (item: any) => Float32Array;
-}>;
-
-interface BufferManager {
-    gl: WebGL2RenderingContext;
-    buffer: WebGLBuffer;
-    itemSize: number;
-    bufferType: string;
-    isFreed: boolean;
-
-    insertBulk(blocks: any[], offsets: number[]): void;
-    deleteBulk(offsets: number[]): void;
-    resetWithCapacity(capacity: number): void;
-    defrag(offsetValues: MapIterator<number> | number[], occupiedCapacity: number, newCapacity: number): void;
-    extendBuffer(occupiedCapacity: number, newCapacity: number): void;
-    free(): void;
-}
-
-interface BufferOrchestrator {
-    offsetMap: Map<string, number>;
-    tombstoneOffsets: number[];
-    _length: number;
-    _capacity: number;
-    getOffset(key: string): number | undefined;
-    nextOffset(): number | boolean;
-    autoExtendBuffers(itemsLength: number, bufferManagersMap: BufferManagersMap): void;
-    updateBulk(items: any[], bufferManagersMap: BufferManagersMap, bufferKeys?: string[]): void;
-    deleteBulk(keys: string[], bufferManagersMap: BufferManagersMap): void;
-    resetWithCapacity(bufferManagersMap: BufferManagersMap, capacity: number | null): void;
-}
-
-
-export {
-    BufferManagersMap,
-    BufferManager,
-    BufferOrchestrator
-}

package/util/account/util.js

@@ -1,22 +0,0 @@
-export const vaoAttributeLoader = (gl, buffer, index, size, stride, offset, divisor = null, type = null) => {
-    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, false, stride, offset);
-    if (divisor !== null) {
-        gl.vertexAttribDivisor(index, divisor);
-    }
-
-}
-
-

package/util/algorithms/search-binary.js

@@ -1,26 +0,0 @@
-/**
- * @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/check/get.js

@@ -1,13 +0,0 @@
-
-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/check/typecheck.js

@@ -1,39 +0,0 @@
-// Generic
-
-const doesOwnProperties = (properties, errorMessage) => {
-    return (object) => {
-        properties.forEach(element => {
-            if (!Object.hasOwn(object, 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 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");
-}

package/util/geometry/index.js

@@ -1,53 +0,0 @@
-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 {Float32List} array 
- * @returns {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;
-}
-
-
-function sphereCoord(long, lat, globe, height = 0) {
-    return normalize(globe.api_GetCartesian3DPoint(long, lat, 0, 0), 6378.137 + height);
-}
-
-
-export { createBBoxMatrix, latLongToPixelXY, latLongBboxtoPixelXYBbox, sphereCoord, normalize };

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

@@ -1,85 +0,0 @@
-import './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 (size < 1 || size > 4) throw new Error("Size must be between 1 and 4");
-    if (bufferAndReadInfo == null) {
-        if (escapeValues !== null) 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, 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/buffer/types.ts

@@ -1,13 +0,0 @@
-
-type BufferAndReadInfo = {
-    buffer: WebGLBuffer;
-    stride: number;
-    offset: number;
-}
-
-type AttributeLoaderOptions = {
-    divisor?: number | null;
-    type?: number | null;
-    escapeValues?: Array<number> | null;
-    normalized?: boolean;
-}