@pirireis/webglobeplugins 0.15.20-alpha → 0.15.22-alpha

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

@@ -1,161 +0,0 @@
-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/chunked-buffer-manager.js

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

@@ -1,195 +0,0 @@
-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);
-    }
-}