@pirireis/webglobeplugins 0.15.19-alpha → 0.15.21-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.15.19-alpha",
+    "version": "0.15.21-alpha",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT",

package/point-tracks/plugin.js

@@ -224,12 +224,19 @@ class PointTracksPlugin {
             return;
         this._isFreed = true;
         this._pickerDisplayer.free();
+        this._tracksToPointMap.clear();
         PointOnGlobeProgramCache.release(this.globe);
         this.gl.deleteBuffer(this._focusParams.elementBuffer);
         this._bufferManagersMap.forEach(({ bufferManager, adaptor }) => bufferManager.free());
     }
     draw3D() {
         const { gl, _pointProgram, _pickerDisplayer, _bufferOrchestrator, _vao } = this;
+        if (!gl) {
+            throw new Error("GL is not loaded, PointTracks Plugin");
+        }
+        if (this._isFreed) {
+            throw new Error("Plugin is unregistered, PointTracks Plugin");
+        }
         this.resize();
         _pickerDisplayer.bindFBO();
         _pickerDisplayer.clearTextures();
@@ -270,13 +277,17 @@ class PointTracksPlugin {
             const trackID = track.trackID;
             const points = track.points;
             if (!this._tracksToPointsMap.has(trackID)) {
-                this._tracksToPointsMap.set(trackID, []); // TODO: alternative to Set?
-                // this._tracksToPointsMap.set(trackID, new Set()); // TODO: alternative to Set?
+                this._tracksToPointsMap.set(trackID, new Set());
             }
-            const pointList = this._tracksToPointsMap.get(trackID);
+            const pointSet = this._tracksToPointsMap.get(trackID);
             for (let p = 0; p < points.length; p++) {
                 const pointID = points[p].ID;
-                pointList.push(pointID);
+                if (!pointSet.has(pointID)) {
+                    pointSet.add(pointID);
+                }
+                else {
+                    console.warn(`Point with ID ${pointID} already exists in track ${trackID}. Skipping duplicate.`);
+                }
             }
         }
     }
@@ -286,15 +297,22 @@ class PointTracksPlugin {
         }
     }
     _deletePointsFromTracksMap(trackID, pointIDs) {
-        const trackSet = this._tracksToPointsMap.get(trackID);
-        const pointList = new Set(pointIDs);
-        const newList = [];
-        for (const pointID of trackSet) {
-            if (!pointList.has(pointID)) {
-                newList.push(pointID);
+        const trackIDs = this._tracksToPointsMap.get(trackID);
+        if (trackIDs === undefined) {
+            console.warn(`Track with ID ${trackID} not found.`);
+            return;
+        }
+        for (const pointID of pointIDs) {
+            if (!trackIDs.has(pointID)) {
+                console.warn(`Point with ID ${pointID} not found in track ${trackID}.`);
+            }
+            else {
+                trackIDs.delete(pointID);
             }
         }
-        this._tracksToPointsMap.set(trackID, newList);
+        if (trackIDs.size === 0) {
+            this._tracksToPointsMap.delete(trackID);
+        }
     }
     _selfSelect() {
         const { globe } = this;
@@ -324,6 +342,9 @@ class PointTracksPlugin {
             for (const pointID of pointList) {
                 const key = keyMethod(trackID, pointID);
                 const index = this._bufferOrchestrator.offsetMap.get(key);
+                if (index === undefined) {
+                    throw new Error;
+                }
                 indexes.push(index);
                 length++;
             }

package/range-tools-on-terrain/circle-line-chain/plugin.js

@@ -47,7 +47,7 @@ export class CircleLineChainPlugin {
             dashedLineOpacityVariativeOn: false,
             dashedLineRatioVariativeOn: false,
             bufferType: "DYNAMIC_DRAW",
-            opacity: 1.0
+            opacity: 1.0,
         }
     };
     constructor(id, { drawCircleOn, textWritersMap, textDataPreAdaptor, opacities, lineAdaptor, arcAdaptor, circleAdaptor, arcOnTerrainOptions, circleOnTerrainOptions, lineOptions } = {}) {

package/semiplugins/lightweight/line-plugin.js

@@ -1,5 +1,6 @@
 import { LineOnGlobeCache } from "../../programs/line-on-globe/naive-accurate-flexible";
-import { BufferMapOrchestrator } from "../../util/account/create-buffermap-orchastration";
+import { BufferOrchestrator } from "../../util/account/single-attribute-buffer-management/buffer-orchestrator";
+import { BufferManager } from "../../util/account/single-attribute-buffer-management/buffer-manager";
 import { sphereCoord } from "../../util/geometry/index";
 import { constraintFloat } from "../../util/check/typecheck";
 export class LinePlugin {
@@ -10,20 +11,23 @@ export class LinePlugin {
     vao = null;
     _options;
     _uboHandler = null;
-    _bufferOrchestrator = null;
+    _bufferOrchestrator;
+    _bufferManagersMap = new Map();
     _freed = false;
-    constructor(id, { flatViewOn = true, globeViewOn = true, variativeColorsOn = false, defaultColor = [1, 1, 1, 1], dashedLineOpacityVariativeOn = false, dashedLineRatioVariativeOn = false, bufferType = "DYNAMIC_DRAW", opacity = 1.0 } = {}) {
+    constructor(id, { flatViewOn = true, globeViewOn = true, variativeColorsOn = false, defaultColor = [1, 1, 1, 1], dashedLineOpacityVariativeOn = false, dashedLineRatioVariativeOn = false, bufferType = "DYNAMIC_DRAW", opacity = 1.0, initialCapacity = 10 } = {}) {
         this.id = id;
         this._options = {
-            flatViewOn,
-            globeViewOn,
-            variativeColorsOn,
-            defaultColor,
-            dashedLineOpacityVariativeOn,
-            dashedLineRatioVariativeOn,
-            bufferType,
-            opacity
+            flatViewOn: flatViewOn ?? true,
+            globeViewOn: globeViewOn ?? true,
+            variativeColorsOn: variativeColorsOn ?? false,
+            defaultColor: defaultColor ?? [1, 1, 1, 1],
+            dashedLineOpacityVariativeOn: dashedLineOpacityVariativeOn ?? false,
+            dashedLineRatioVariativeOn: dashedLineRatioVariativeOn ?? false,
+            bufferType: bufferType ?? "DYNAMIC_DRAW",
+            opacity: opacity ?? 1.0,
+            initialCapacity: initialCapacity ?? 10
         };
+        this._bufferOrchestrator = new BufferOrchestrator({ capacity: initialCapacity ?? 10 });
     }
     init(globe, gl) {
         this.globe = globe;
@@ -31,13 +35,12 @@ export class LinePlugin {
         this.program = LineOnGlobeCache.get(globe);
         this._uboHandler = this.program.createUBO();
         this.setDefaultColor(this._options.defaultColor);
-        this._bufferOrchestrator = new BufferMapOrchestrator(gl, this._createBufferDetailsMap(), 10 // initial capacity
-        );
+        this._fillManagerMap();
         this.vao = this.program.createVAO(...this._createSelectBufferNames().map((key) => {
             if (key === null) {
                 return null;
             }
-            const bufferManagerComp = this._bufferOrchestrator?.bufferManagersMap.get(key);
+            const bufferManagerComp = this._bufferManagersMap.get(key);
             if (bufferManagerComp === undefined) {
                 throw new Error(`Buffer key ${key} does not exist in bufferManagersMap`);
             }
@@ -51,19 +54,19 @@ export class LinePlugin {
     }
     // PLUGIN INTERFACE METHODS
     insertBulk(items) {
-        const { _bufferOrchestrator, globe } = this;
+        const { _bufferOrchestrator, _bufferManagersMap, globe } = this;
         if (!_bufferOrchestrator || !globe) {
             throw new Error("Buffer orchestrator or globe is not initialized.");
         }
-        _bufferOrchestrator.insertBulk(items);
+        _bufferOrchestrator.insertBulk(items, _bufferManagersMap);
         this.globe?.DrawRender();
     }
     deleteBulk(keys) {
-        const { _bufferOrchestrator, globe } = this;
+        const { _bufferOrchestrator, _bufferManagersMap, globe } = this;
         if (!_bufferOrchestrator || !globe) {
             throw new Error("Buffer orchestrator or globe is not initialized.");
         }
-        _bufferOrchestrator.deleteBulk(keys);
+        _bufferOrchestrator.deleteBulk(keys, _bufferManagersMap);
         this.globe?.DrawRender();
     }
     setPluginOpacity(opacity, drawRender = false) {
@@ -108,12 +111,11 @@ export class LinePlugin {
         if (!_bufferOrchestrator || !_bufferOrchestrator || !_uboHandler) {
             throw new Error("Buffer orchestrator is not initialized.");
         }
-        const { bufferOrchestrator } = _bufferOrchestrator;
         const { flatViewOn, globeViewOn, opacity } = _options;
         const drawOptions = {
             drawRange: {
                 first: 0,
-                count: bufferOrchestrator.length
+                count: _bufferOrchestrator.length
             }
         };
         this.gl.disable(this.gl.DEPTH_TEST); // Disable depth test for lines
@@ -132,67 +134,60 @@ export class LinePlugin {
         if (this._freed)
             return;
         // TODO: FILL
-        this._bufferOrchestrator?.free();
+        this._bufferManagersMap.forEach((manager) => {
+            manager.bufferManager.free();
+        });
         this._uboHandler?.free();
         LineOnGlobeCache.release(this.globe);
         this._freed = true;
     }
     // IMPLICIT INTERFACE METHODS
-    _createBufferDetailsMap() {
+    _fillManagerMap() {
         const globe = this.globe;
         const { flatViewOn, globeViewOn, variativeColorsOn, dashedLineOpacityVariativeOn, dashedLineRatioVariativeOn, bufferType = "DYNAMIC_DRAW" } = this._options;
-        const m = new Map();
+        const m = this._bufferManagersMap;
+        const initialCapacity = this._options.initialCapacity;
         if (flatViewOn) {
             m.set("start_position", {
-                itemSize: 2,
-                bufferType: bufferType, // TODO: Ask User? 
-                buffer: null,
+                bufferManager: new BufferManager(globe.gl, 2, { bufferType, initialCapacity: this._options.initialCapacity }),
                 adaptor: (item) => {
                     const result = new Float32Array(globe.api_GetMercator2DPoint(item.start[0], item.start[1]));
                     return result;
                 }
             });
             m.set("end_position", {
-                itemSize: 2,
-                bufferType: bufferType,
-                buffer: null,
+                bufferManager: new BufferManager(globe.gl, 2, { bufferType, initialCapacity: this._options.initialCapacity }),
                 adaptor: (item) => new Float32Array(globe.api_GetMercator2DPoint(item.end[0], item.end[1]))
             });
         }
         if (globeViewOn) {
             m.set("start_position_3d", {
-                itemSize: 3,
-                bufferType: bufferType,
+                bufferManager: new BufferManager(globe.gl, 3, { bufferType, initialCapacity: this._options.initialCapacity }),
                 adaptor: (item) => sphereCoord(item.start[0], item.start[1], globe, item.start_altitude || 0)
             });
             m.set("end_position_3d", {
-                itemSize: 3,
-                bufferType: bufferType,
+                bufferManager: new BufferManager(globe.gl, 3, { bufferType, initialCapacity: this._options.initialCapacity }),
                 adaptor: (item) => sphereCoord(item.end[0], item.end[1], globe, item.end_altitude || 0)
             });
         }
         if (variativeColorsOn) {
             m.set("color", {
-                itemSize: 4,
-                bufferType: bufferType,
+                bufferManager: new BufferManager(globe.gl, 4, { bufferType, initialCapacity: this._options.initialCapacity }),
                 adaptor: (item) => new Float32Array(item.color !== undefined ? item.color : [-1, -1, -1, -1])
             });
         }
         if (dashedLineOpacityVariativeOn) {
             m.set("dashed_line_opacity", {
-                itemSize: 1,
-                bufferType: bufferType,
+                bufferManager: new BufferManager(globe.gl, 1, { bufferType, initialCapacity: this._options.initialCapacity }),
                 adaptor: (item) => new Float32Array(item.dashed_line_opacity !== undefined ? [item.dashed_line_opacity] : [-1])
             });
         }
         if (dashedLineRatioVariativeOn) {
             m.set("dashed_line_ratio", {
-                itemSize: 1,
-                bufferType: bufferType,
+                bufferManager: new BufferManager(globe.gl, 1, { bufferType, initialCapacity: this._options.initialCapacity }),
                 adaptor: (item) => new Float32Array(item.dashed_line_ratio !== undefined ? [item.dashed_line_ratio] : [-1])
             });
         }
-        return m;
     }
     _createSelectBufferNames() {
         const { flatViewOn, globeViewOn, variativeColorsOn, dashedLineOpacityVariativeOn, dashedLineRatioVariativeOn } = this._options;

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

@@ -60,7 +60,7 @@ export class BufferManager {
         }
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
     }
-    insertConsecutiveBulk(items, offset, adapter, Constructor = Float32Array) {
+    insertBlock(items, offset, adapter, Constructor = Float32Array) {
         const { gl, buffer, itemSize } = this;
         const cpuBuffer = new Constructor(itemSize * items.length);
         for (let i = 0; i < items.length; i++) {

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

@@ -19,6 +19,92 @@ export class BufferOrchestrator {
         this.tombstoneOffsets = [];
         this._length = 0;
     }
+    // ...existing code...
+    // TODO: CLEAN THIS
+    // insertBulk2(items: any[], bufferManagersMap: BufferManagersMap, bufferKeys: string[] | null = null) {
+    //     this.ensureSpace(items.length, bufferManagersMap);
+    //     const { offsetMap } = this;
+    //     // For block insert (truly new, consecutive offsets)
+    //     const blockItems: any[] = [];
+    //     let blockStart: number | null = null;
+    //     let lastBlockOffset: number | null = null;
+    //     // For single insert (existing or tombstone-assigned)
+    //     const singleItems: any[] = [];
+    //     const singleOffsets: number[] = [];
+    //     for (const item of items) {
+    //         let offset = offsetMap.get(item.key);
+    //         if (offset !== undefined) {
+    //             // Already present, update in place
+    //             singleItems.push(item);
+    //             singleOffsets.push(offset);
+    //         } else {
+    //             // Assign offset (tombstone or new)
+    //             if (this.tombstoneOffsets.length > 0) {
+    //                 offset = this.tombstoneOffsets.pop() as number;
+    //                 offsetMap.set(item.key, offset);
+    //                 singleItems.push(item);
+    //                 singleOffsets.push(offset);
+    //             } else {
+    //                 offset = this._length++;
+    //                 if (offset >= this._capacity) throw new Error("The Size Should Be Increased!!");
+    //                 offsetMap.set(item.key, offset);
+    //                 // Check for consecutive block
+    //                 if (blockStart === null) {
+    //                     blockStart = offset;
+    //                     lastBlockOffset = offset;
+    //                     blockItems.push(item);
+    //                 } else if (lastBlockOffset !== null && offset === lastBlockOffset + 1) {
+    //                     lastBlockOffset = offset;
+    //                     blockItems.push(item);
+    //                 } else {
+    //                     // Not consecutive, flush current block
+    //                     if (blockItems.length > 0) {
+    //                         this._insertBlock(blockItems, blockStart, bufferManagersMap, bufferKeys);
+    //                         blockItems.length = 0;
+    //                     }
+    //                     blockStart = offset;
+    //                     lastBlockOffset = offset;
+    //                     blockItems.push(item);
+    //                 }
+    //             }
+    //         }
+    //     }
+    //     // Flush any remaining block
+    //     if (blockItems.length > 0 && blockStart !== null) {
+    //         this._insertBlock(blockItems, blockStart, bufferManagersMap, bufferKeys);
+    //     }
+    //     // Insert singles
+    //     if (singleItems.length > 0) {
+    //         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(singleItems.map(adaptor), singleOffsets);
+    //             }
+    //         } else {
+    //             for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+    //                 bufferManager.insertBulk(singleItems.map(adaptor), singleOffsets);
+    //             }
+    //         }
+    //     }
+    // }
+    // // Helper for block insert
+    // private _insertBlock(blockItems: any[], blockStart: number, bufferManagersMap: BufferManagersMap, bufferKeys: string[] | null) {
+    //     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.insertBlock(blockItems, blockStart, adaptor, Float32Array);
+    //         }
+    //     } else {
+    //         for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+    //             bufferManager.insertBlock(blockItems, blockStart, adaptor, Float32Array);
+    //         }
+    //     }
+    // }
+    // ...existing code...
     // 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
@@ -27,10 +113,18 @@ export class BufferOrchestrator {
         this.ensureSpace(items.length, bufferManagersMap);
         const { offsetMap } = this;
         let offsetStart = null;
-        const itemForConsecutiveLoad = [];
+        const offsets = [];
+        const blockLoad = [];
         for (const item of items) {
             let o = offsetMap.get(item.key);
+            if (o === undefined && this.tombstoneOffsets.length > 0) {
+                // If there is a tombstone, use it
+                o = this.tombstoneOffsets.pop();
+                offsetMap.set(item.key, o);
+            }
             if (o !== undefined) {
+                // Already exist or there is a random empty space in earlear part of memory.
+                // insert for single slots 
                 if (bufferKeys) {
                     for (const key of bufferKeys) {
                         const bufferManagerComp = bufferManagersMap.get(key);
@@ -45,88 +139,42 @@ export class BufferOrchestrator {
                         bufferManager.insertBulk([adaptor(item)], [o]);
                     }
                 }
-                continue;
             }
-            const offset = this.nextOffset();
-            offsetMap.set(item.key, offset);
-            itemForConsecutiveLoad.push(item);
-            if (offsetStart === null) {
-                offsetStart = offset;
+            else {
+                // offset comes from increment function
+                // this part stacks data to be load a a single big block.
+                const offset = this.nextOffset();
+                if (offset === undefined) {
+                    throw new Error("The Size Should Be Increased!!");
+                }
+                offsets.push(offset);
+                offsetMap.set(item.key, offset);
+                blockLoad.push(item);
+                if (offsetStart === null) {
+                    offsetStart = offset;
+                }
             }
         }
         if (offsetStart === null)
             return;
+        for (let i = 0; i < offsets.length - 1; i++) {
+            if (offsets[i] - offsets[i + 1] !== -1) {
+                // TODO: DELETE THIS
+                throw new Error("consecutive is not consecutive");
+            }
+        }
         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.insertConsecutiveBulk(itemForConsecutiveLoad, offsetStart, adaptor, Float32Array);
+                bufferManager.insertBlock(blockLoad, offsetStart, adaptor, Float32Array);
             }
         }
         else {
             for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
-                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);
-                }
+                bufferManager.insertBlock(blockLoad, offsetStart, adaptor, Float32Array);
             }
         }
     }
@@ -175,15 +223,18 @@ export class BufferOrchestrator {
     getOffset(key) {
         return this.offsetMap.get(key);
     }
-    nextOffset() {
+    nextTombstone() {
         if (this.tombstoneOffsets.length > 0) {
             const offset = this.tombstoneOffsets.pop();
             return offset;
         }
+        return undefined;
+    }
+    nextOffset() {
         if (this._length < this._capacity) {
             return this._length++;
         }
-        return false;
+        return undefined;
     }
     ensureSpace(itemsLength, bufferManagersMap) {
         if (itemsLength <= this.emptySpace)

package/util/account/single-attribute-buffer-management/buffer-orchestrator1.js

@@ -0,0 +1,159 @@
+"use strict";
+// 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, bufferKeys: string[] | null = 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() as number;
+//             if (offset === undefined) {
+//                 throw new Error("The Size Should Be Increased!!")
+//             }
+//             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: 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 | undefined {
+//         if (this.tombstoneOffsets.length > 0) {
+//             const offset = this.tombstoneOffsets.pop() as number;
+//             return offset;
+//         }
+//         if (this._length < this._capacity) {
+//             return this._length++;
+//         }
+//         return undefined;
+//     }
+//     ensureSpace(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/object-store.js

@@ -23,7 +23,7 @@ export class ObjectStore {
             }
         }
     }
-    insertConsecutiveBulk(objects, startOffset) {
+    insertBlock(objects, startOffset) {
         for (let i = 0; i < objects.length; i++) {
             const object = objects[i];
             const offset = startOffset + i;

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);
-    }
-}