@pirireis/webglobeplugins 0.15.34 → 0.16.0

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

@@ -0,0 +1,332 @@
+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;
+    }
+
+
+    // ...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
+    // bufferManager.insertBulk([bigFloat32Array], [offsets[0]])
+    insertBulk(items: any[], bufferManagersMap: BufferManagersMap, bufferKeys: string[] | null = null) {
+        this.ensureSpace(items.length, bufferManagersMap);
+        const { offsetMap } = this;
+        let offsetStart = null;
+        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() as number;
+                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);
+                        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]);
+                    }
+                }
+            } 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 as number);
+                blockLoad.push(item);
+                if (offsetStart === null) {
+                    offsetStart = offset as number;
+                }
+            }
+        }
+        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.insertBlock(blockLoad, offsetStart, adaptor, Float32Array);
+            }
+        } else {
+            for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+                bufferManager.insertBlock(blockLoad, offsetStart, adaptor, Float32Array);
+            }
+        }
+    }
+
+
+
+
+    // 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, cannot update: ${item.key}`);
+            }
+        }
+        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);
+    }
+
+
+    nextTombstone(): number | undefined {
+        if (this.tombstoneOffsets.length > 0) {
+            const offset = this.tombstoneOffsets.pop() as number;
+            return offset;
+        }
+        return undefined
+    }
+
+
+
+    nextOffset(): number | undefined {
+        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/buffer-orchestrator1.ts

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

@@ -0,0 +1,11 @@
+import { BufferOrchestrator } from "./buffer-orchestrator";
+import { BufferManager } from "./buffer-manager";
+import { ObjectStore } from "./object-store";
+
+export { BufferOrchestrator, BufferManager, ObjectStore };
+
+// TODO: Duplucate. fix it while renaming adaptor to adapter
+export type BufferManagersMap = Map<string, {
+    bufferManager: BufferManager;
+    adaptor: (item: any) => Float32Array;
+}>;

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

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

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

@@ -0,0 +1,43 @@
+import { TypedArray } from "../../../types";
+
+type BufferManagersMap = Map<string, {
+    bufferManager: BufferManager;
+    adaptor: (item: any) => Float32Array;
+}>;
+
+interface BufferManager {
+    readonly gl: WebGL2RenderingContext;
+    readonly buffer: WebGLBuffer;
+    readonly itemSize: number;
+    readonly bufferType: string;
+    readonly isFreed: boolean;
+
+    insertBulk(blocks: any[], offsets: number[]): void;
+    insertBlock(items: any[], offset: number, adaptor: Function, dataConstructor?: { new(length: number): TypedArray }): void;
+    deleteBulk(offsets: number[]): void;
+    resetWithCapacity(capacity: number): void;
+    defrag(offsetValues: MapIterator<number> | number[], occupiedCapacity: number, newCapacity: number): void;
+    extendBuffer(occupiedCapacity: number, newCapacity: number): void;
+    free(): void;
+}
+
+interface BufferOrchestrator {
+    offsetMap: Map<string, number>;
+    tombstoneOffsets: number[];
+    _length: number;
+    _capacity: number;
+    getOffset(key: string): number | undefined;
+    nextOffset(): number | undefined;
+    //nextTombstone(): number | undefined;
+    ensureSpace(itemsLength: number, bufferManagersMap: BufferManagersMap): void;
+    updateBulk(items: any[], bufferManagersMap: BufferManagersMap, bufferKeys?: string[]): void;
+    deleteBulk(keys: string[], bufferManagersMap: BufferManagersMap): void;
+    resetWithCapacity(bufferManagersMap: BufferManagersMap, capacity: number | null): void;
+}
+
+
+export {
+    BufferManagersMap,
+    BufferManager,
+    BufferOrchestrator
+}

package/util/account/util.js

@@ -1,18 +1,22 @@
-export const vaoAttributeLoader = (gl, buffer, index, size, stride, offset, divisor = null, type = null) => {
-    if (!gl || !buffer) {
-        throw new Error("Invalid WebGL context or buffer");
-    }
-    if (index < 0) {
-        throw new Error("Attribute index must be non-negative");
-    }
-    if (stride < 0 || offset < 0) {
-        throw new Error("Stride and offset must be non-negative");
-    }
-    const attribType = type === null ? gl.FLOAT : type;
-    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-    gl.enableVertexAttribArray(index);
-    gl.vertexAttribPointer(index, size, attribType, false, stride, offset);
-    if (divisor !== null) {
-        gl.vertexAttribDivisor(index, divisor);
-    }
-};
+export const vaoAttributeLoader = (gl, buffer, index, size, stride, offset, divisor = null, type = null) => {
+    if (!gl || !buffer) {
+        throw new Error("Invalid WebGL context or buffer");
+    }
+    if (index < 0) {
+        throw new Error("Attribute index must be non-negative");
+    }
+    if (stride < 0 || offset < 0) {
+        throw new Error("Stride and offset must be non-negative");
+    }
+
+    const attribType = type === null ? gl.FLOAT : type;
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    gl.enableVertexAttribArray(index);
+    gl.vertexAttribPointer(index, size, attribType, false, stride, offset);
+    if (divisor !== null) {
+        gl.vertexAttribDivisor(index, divisor);
+    }
+
+}
+
+

package/util/algorithms/index.js

@@ -1 +0,0 @@
-"use strict";