@pirireis/webglobeplugins 0.15.17-alpha → 0.15.19-alpha

package/util/account/single-attribute-buffer-management/buffer-orchestrator copy.js

@@ -0,0 +1,161 @@
+const EXTRA_SIZE = 10;
+export class BufferOrchestrator {
+    _capacity;
+    offsetMap;
+    tombstoneOffsets;
+    _length;
+    constructor({ capacity = 10 } = {}) {
+        this._capacity = capacity;
+        this.offsetMap = new Map();
+        this.tombstoneOffsets = [];
+        this._length = 0;
+    }
+    resetWithCapacity(bufferManagersMap, capacity = 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, bufferManagersMap, bufferKeys = null) {
+        this.ensureSpace(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();
+            offsetMap.set(item.key, offset);
+            offsets.push(offset);
+        }
+        if (bufferKeys) {
+            for (const key of bufferKeys) {
+                const bufferManagerComp = bufferManagersMap.get(key);
+                if (bufferManagerComp === undefined)
+                    throw new Error("insertBulk 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);
+            }
+        }
+    }
+    // does not assign offset to the new items.
+    updateBulk(items, bufferManagersMap, bufferKeys = 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, 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) {
+        return this.offsetMap.get(key);
+    }
+    nextOffset() {
+        if (this.tombstoneOffsets.length > 0) {
+            const offset = this.tombstoneOffsets.pop();
+            return offset;
+        }
+        if (this._length < this._capacity) {
+            return this._length++;
+        }
+        return false;
+    }
+    ensureSpace(itemsLength, 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, bufferKeys) {
+        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/buffer-orchestrator.js

@@ -19,28 +19,114 @@ export class BufferOrchestrator {
         this.tombstoneOffsets = [];
         this._length = 0;
     }
+    // want to add stack load to this method
+    // if offsetMap.has(item.key) === false get next offset, add the item to stack
+    // create a single big float32array and fill it with the items
+    // bufferManager.insertBulk([bigFloat32Array], [offsets[0]])
     insertBulk(items, bufferManagersMap, bufferKeys = null) {
         this.ensureSpace(items.length, bufferManagersMap);
         const { offsetMap } = this;
-        const offsets = [];
+        let offsetStart = null;
+        const itemForConsecutiveLoad = [];
         for (const item of items) {
             let o = offsetMap.get(item.key);
-            const offset = o !== undefined ? o : this.nextOffset();
+            if (o !== undefined) {
+                if (bufferKeys) {
+                    for (const key of bufferKeys) {
+                        const bufferManagerComp = bufferManagersMap.get(key);
+                        if (bufferManagerComp === undefined)
+                            throw new Error("insertBulk bufferKey does not exist");
+                        const { bufferManager, adaptor } = bufferManagerComp;
+                        bufferManager.insertBulk([adaptor(item)], [o]);
+                    }
+                }
+                else {
+                    for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+                        bufferManager.insertBulk([adaptor(item)], [o]);
+                    }
+                }
+                continue;
+            }
+            const offset = this.nextOffset();
             offsetMap.set(item.key, offset);
-            offsets.push(offset);
+            itemForConsecutiveLoad.push(item);
+            if (offsetStart === null) {
+                offsetStart = offset;
+            }
         }
+        if (offsetStart === null)
+            return;
         if (bufferKeys) {
             for (const key of bufferKeys) {
                 const bufferManagerComp = bufferManagersMap.get(key);
                 if (bufferManagerComp === undefined)
                     throw new Error("insertBulk bufferKey does not exist");
                 const { bufferManager, adaptor } = bufferManagerComp;
-                bufferManager.insertBulk(items.map(adaptor), offsets);
+                bufferManager.insertConsecutiveBulk(itemForConsecutiveLoad, offsetStart, adaptor, Float32Array);
             }
         }
         else {
             for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
-                bufferManager.insertBulk(items.map(adaptor), offsets);
+                bufferManager.insertConsecutiveBulk(itemForConsecutiveLoad, offsetStart, adaptor, Float32Array);
+            }
+        }
+    }
+    insertBulk2(items, bufferManagersMap, bufferKeys = null) {
+        this.ensureSpace(items.length, bufferManagersMap);
+        const { offsetMap } = this;
+        // Pre-allocate arrays only if needed
+        const newItemsCount = items.reduce((acc, item) => acc + (offsetMap.has(item.key) ? 0 : 1), 0);
+        if (newItemsCount === 0)
+            return;
+        // Only allocate if there are new items
+        const newItems = new Array(newItemsCount);
+        const newOffsets = new Array(newItemsCount);
+        let idx = 0;
+        for (const item of items) {
+            let o = offsetMap.get(item.key);
+            if (o !== undefined) {
+                // Update existing
+                if (bufferKeys) {
+                    for (const key of bufferKeys) {
+                        const bufferManagerComp = bufferManagersMap.get(key);
+                        if (!bufferManagerComp)
+                            throw new Error("insertBulk bufferKey does not exist");
+                        const { bufferManager, adaptor } = bufferManagerComp;
+                        bufferManager.insertBulk([adaptor(item)], [o]);
+                    }
+                }
+                else {
+                    for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+                        bufferManager.insertBulk([adaptor(item)], [o]);
+                    }
+                }
+            }
+            else {
+                // New item
+                const offset = this.nextOffset();
+                offsetMap.set(item.key, offset);
+                newItems[idx] = item;
+                newOffsets[idx] = offset;
+                idx++;
+            }
+        }
+        if (idx > 0) {
+            // Only slice the arrays to the actual number of new items
+            const itemsToInsert = newItems.slice(0, idx);
+            const offsetsToInsert = newOffsets.slice(0, idx);
+            if (bufferKeys) {
+                for (const key of bufferKeys) {
+                    const bufferManagerComp = bufferManagersMap.get(key);
+                    if (!bufferManagerComp)
+                        throw new Error("insertBulk bufferKey does not exist");
+                    const { bufferManager, adaptor } = bufferManagerComp;
+                    bufferManager.insertConsecutiveBulk(itemsToInsert, offsetsToInsert[0], adaptor, Float32Array);
+                }
+            }
+            else {
+                for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+                    bufferManager.insertConsecutiveBulk(itemsToInsert, offsetsToInsert[0], adaptor, Float32Array);
+                }
             }
         }
     }

package/util/account/single-attribute-buffer-management/chunked-buffer-manager.js

@@ -0,0 +1,75 @@
+import { BufferManager } from "./buffer-manager";
+export class ChunkedBufferManager extends BufferManager {
+    // Chunked insert that batches multiple items into fewer GPU calls
+    insertBulkChunked(blocks, offsets, chunkSize = 1000) {
+        const { gl, buffer, itemSize } = this;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        const offsetMultiplier = itemSize * 4;
+        // Process in chunks to reduce GPU call overhead
+        for (let i = 0; i < blocks.length; i += chunkSize) {
+            const chunkEnd = Math.min(i + chunkSize, blocks.length);
+            const chunkBlocks = blocks.slice(i, chunkEnd);
+            const chunkOffsets = offsets.slice(i, chunkEnd);
+            // Create a single large buffer for this chunk
+            const totalItems = chunkBlocks.length;
+            const chunkBuffer = new Float32Array(totalItems * itemSize);
+            // Copy all chunk data into one buffer
+            for (let j = 0; j < chunkBlocks.length; j++) {
+                chunkBuffer.set(chunkBlocks[j], j * itemSize);
+            }
+            // Find contiguous ranges for efficient uploads
+            const ranges = this.findContiguousRanges(chunkOffsets, offsetMultiplier);
+            for (const range of ranges) {
+                const startOffset = range.startOffset;
+                const dataStart = range.indices[0] * itemSize;
+                const dataLength = range.indices.length * itemSize;
+                const rangeData = chunkBuffer.subarray(dataStart, dataStart + dataLength);
+                gl.bufferSubData(gl.ARRAY_BUFFER, startOffset, rangeData);
+            }
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+    // Optimized delete that batches operations
+    deleteBulkChunked(offsets, chunkSize = 1000) {
+        const { gl, buffer, itemSize } = this;
+        const emptyBlock = new Float32Array(itemSize).fill(NaN);
+        const offsetMultiplier = itemSize * 4;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        // Sort offsets for better cache coherency
+        const sortedOffsets = [...offsets].sort((a, b) => a - b);
+        // Process in chunks
+        for (let i = 0; i < sortedOffsets.length; i += chunkSize) {
+            const chunkEnd = Math.min(i + chunkSize, sortedOffsets.length);
+            for (let j = i; j < chunkEnd; j++) {
+                const offset = sortedOffsets[j];
+                if (offset !== undefined) {
+                    gl.bufferSubData(gl.ARRAY_BUFFER, offset * offsetMultiplier, emptyBlock);
+                }
+            }
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+    // Find contiguous memory ranges for batch uploads
+    findContiguousRanges(offsets, offsetMultiplier) {
+        const ranges = [];
+        const sortedIndices = offsets
+            .map((offset, index) => ({ offset: offset * offsetMultiplier, index }))
+            .sort((a, b) => a.offset - b.offset);
+        let currentRange = null;
+        for (const { offset, index } of sortedIndices) {
+            if (!currentRange || offset !== currentRange.startOffset + currentRange.indices.length * offsetMultiplier) {
+                // Start new range
+                if (currentRange)
+                    ranges.push(currentRange);
+                currentRange = { startOffset: offset, indices: [index] };
+            }
+            else {
+                // Extend current range
+                currentRange.indices.push(index);
+            }
+        }
+        if (currentRange)
+            ranges.push(currentRange);
+        return ranges;
+    }
+}

package/util/account/single-attribute-buffer-management/chunked-buffer-orchestrator.js

@@ -0,0 +1,195 @@
+export class ChunkedBufferOrchestrator {
+    _capacity;
+    _length;
+    offsetMap;
+    tombstoneOffsets;
+    // Chunking configuration
+    chunkSize;
+    maxPendingOperations;
+    autoFlushInterval;
+    // Pending operations batching
+    pendingInserts;
+    pendingUpdates;
+    pendingDeletes;
+    operationCount;
+    flushTimer;
+    constructor({ capacity = 10, chunkSize = 1000, maxPendingOperations = 5000, autoFlushInterval = 16 // ~60fps
+     } = {}) {
+        this._capacity = capacity;
+        this._length = 0;
+        this.offsetMap = new Map();
+        this.tombstoneOffsets = [];
+        this.chunkSize = chunkSize;
+        this.maxPendingOperations = maxPendingOperations;
+        this.autoFlushInterval = autoFlushInterval;
+        this.pendingInserts = new Map();
+        this.pendingUpdates = new Map();
+        this.pendingDeletes = new Set();
+        this.operationCount = 0;
+        this.flushTimer = null;
+        this.startAutoFlush();
+    }
+    resetWithCapacity(bufferManagersMap, capacity = null) {
+        this.flushPendingOperations(bufferManagersMap);
+        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;
+    }
+    // Batch insert operations
+    insertBulk(items, bufferManagersMap, bufferKeys = null) {
+        const targetKeys = bufferKeys || Array.from(bufferManagersMap.keys());
+        // Process items in chunks
+        for (let i = 0; i < items.length; i += this.chunkSize) {
+            const chunk = items.slice(i, i + this.chunkSize);
+            this.queueInsertChunk(chunk, targetKeys);
+        }
+        this.operationCount += items.length;
+        this.checkAutoFlush(bufferManagersMap);
+    }
+    // Batch update operations
+    updateBulk(items, bufferManagersMap, bufferKeys = null) {
+        const targetKeys = bufferKeys || Array.from(bufferManagersMap.keys());
+        for (let i = 0; i < items.length; i += this.chunkSize) {
+            const chunk = items.slice(i, i + this.chunkSize);
+            this.queueUpdateChunk(chunk, targetKeys);
+        }
+        this.operationCount += items.length;
+        this.checkAutoFlush(bufferManagersMap);
+    }
+    // Batch delete operations
+    deleteBulk(keys, bufferManagersMap) {
+        for (const key of keys) {
+            const offset = this.offsetMap.get(key);
+            if (offset !== undefined) {
+                this.pendingDeletes.add(offset);
+                this.offsetMap.delete(key);
+                this.tombstoneOffsets.push(offset);
+            }
+        }
+        this.operationCount += keys.length;
+        this.checkAutoFlush(bufferManagersMap);
+    }
+    queueInsertChunk(items, bufferKeys) {
+        this.ensureSpaceForItems(items.length);
+        const offsets = [];
+        for (const item of items) {
+            let offset = this.offsetMap.get(item.key);
+            if (offset === undefined) {
+                offset = this.nextOffset();
+                this.offsetMap.set(item.key, offset);
+            }
+            offsets.push(offset);
+        }
+        for (const bufferKey of bufferKeys) {
+            if (!this.pendingInserts.has(bufferKey)) {
+                this.pendingInserts.set(bufferKey, { items: [], offsets: [] });
+            }
+            const pending = this.pendingInserts.get(bufferKey);
+            pending.items.push(...items);
+            pending.offsets.push(...offsets);
+        }
+    }
+    queueUpdateChunk(items, bufferKeys) {
+        const offsets = [];
+        for (const item of items) {
+            const offset = this.offsetMap.get(item.key);
+            if (offset === undefined) {
+                throw new Error(`Update item key '${item.key}' does not exist`);
+            }
+            offsets.push(offset);
+        }
+        for (const bufferKey of bufferKeys) {
+            if (!this.pendingUpdates.has(bufferKey)) {
+                this.pendingUpdates.set(bufferKey, { items: [], offsets: [] });
+            }
+            const pending = this.pendingUpdates.get(bufferKey);
+            pending.items.push(...items);
+            pending.offsets.push(...offsets);
+        }
+    }
+    checkAutoFlush(bufferManagersMap) {
+        if (this.operationCount >= this.maxPendingOperations) {
+            this.flushPendingOperations(bufferManagersMap);
+        }
+    }
+    // Force flush all pending operations to GPU
+    flushPendingOperations(bufferManagersMap) {
+        // Process deletes first
+        if (this.pendingDeletes.size > 0) {
+            const deleteOffsets = Array.from(this.pendingDeletes);
+            for (const [key, { bufferManager }] of bufferManagersMap) {
+                bufferManager.deleteBulk(deleteOffsets);
+            }
+            this.pendingDeletes.clear();
+        }
+        // Process inserts
+        for (const [bufferKey, { items, offsets }] of this.pendingInserts) {
+            const bufferManagerComp = bufferManagersMap.get(bufferKey);
+            if (bufferManagerComp) {
+                const { bufferManager, adaptor } = bufferManagerComp;
+                const adaptedData = items.map(adaptor);
+                bufferManager.insertBulkChunked(adaptedData, offsets, this.chunkSize);
+            }
+        }
+        this.pendingInserts.clear();
+        // Process updates
+        for (const [bufferKey, { items, offsets }] of this.pendingUpdates) {
+            const bufferManagerComp = bufferManagersMap.get(bufferKey);
+            if (bufferManagerComp) {
+                const { bufferManager, adaptor } = bufferManagerComp;
+                const adaptedData = items.map(adaptor);
+                bufferManager.insertBulkChunked(adaptedData, offsets, this.chunkSize);
+            }
+        }
+        this.pendingUpdates.clear();
+        this.operationCount = 0;
+    }
+    ensureSpaceForItems(itemCount) {
+        if (itemCount <= this.emptySpace)
+            return;
+        const newCapacity = Math.max(this._capacity * 2, this._length + itemCount + this.chunkSize);
+        this._capacity = newCapacity;
+    }
+    nextOffset() {
+        if (this.tombstoneOffsets.length > 0) {
+            return this.tombstoneOffsets.pop();
+        }
+        if (this._length < this._capacity) {
+            return this._length++;
+        }
+        return false;
+    }
+    startAutoFlush() {
+        if (this.autoFlushInterval > 0) {
+            this.flushTimer = setInterval(() => {
+                if (this.operationCount > 0) {
+                    // Note: You'll need to pass bufferManagersMap here
+                    // This requires restructuring to maintain reference
+                    console.log(`Auto-flush triggered with ${this.operationCount} pending operations`);
+                }
+            }, this.autoFlushInterval);
+        }
+    }
+    stopAutoFlush() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+    // Getters
+    get length() { return this._length; }
+    get emptySpace() { return this._capacity - this.offsetMap.size; }
+    get capacity() { return this._capacity; }
+    get pendingOperationCount() { return this.operationCount; }
+    // Manual control
+    forceMajorFlush(bufferManagersMap) {
+        this.flushPendingOperations(bufferManagersMap);
+    }
+    getOffset(key) {
+        return this.offsetMap.get(key);
+    }
+}

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

@@ -23,6 +23,13 @@ export class ObjectStore {
             }
         }
     }
+    insertConsecutiveBulk(objects, startOffset) {
+        for (let i = 0; i < objects.length; i++) {
+            const object = objects[i];
+            const offset = startOffset + i;
+            this._container[offset] = object;
+        }
+    }
     defrag(offsetValues, occupiedCapacity, newCapacity) {
         const hold = this._createEmptyList(newCapacity);
         for (let i = 0; i < offsetValues.length; i++) {

package/util/check/typecheck.js

@@ -9,6 +9,18 @@ const doesOwnProperties = (properties, errorMessage) => {
 };
 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");

package/util/geometry/index.js

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