@pirireis/webglobeplugins 0.17.0 → 1.0.2

package/util/account/single-attribute-buffer-management/{buffer-orchestrator1.js → buffer-orchestrator1.ts}

@@ -1,159 +1,184 @@
-"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;
-//     }
-// }
+// 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.js → index.ts}

@@ -1,4 +1,11 @@
-import { BufferOrchestrator } from "./buffer-orchestrator";
-import { BufferManager } from "./buffer-manager";
-import { ObjectStore } from "./object-store";
-export { BufferOrchestrator, BufferManager, ObjectStore };
+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.js → object-store.ts}

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

package/util/algorithms/search-binary.js

@@ -1,25 +1,26 @@
-/**
- * @typedef {Array<number>} ListLike
- * @typedef {number || null} Index
- */
-/**
- * @param {ListLike} container
- * @param {number} value
- * @returns {Index}
- */
-const findFirstIndexInRange = (container, value) => {
-    let start = 0;
-    let end = container.length - 1;
-    let mid = 0;
-    while (start <= end) {
-        mid = Math.floor((start + end) / 2);
-        if (container[mid] <= value && value <= container[mid + 1])
-            return mid;
-        if (container[mid] < value)
-            start = mid + 1;
-        else
-            end = mid - 1;
-    }
-    return null;
-};
-export { findFirstIndexInRange };
+/**
+ * @typedef {Array<number>} ListLike
+ * @typedef {number || null} Index
+ */
+
+/**
+ * @param {ListLike} container
+ * @param {number} value
+ * @returns {Index}
+ */
+const findFirstIndexInRange = (container, value) => {
+    let start = 0;
+    let end = container.length - 1;
+    let mid = 0;
+    while (start <= end) {
+        mid = Math.floor((start + end) / 2);
+        if (container[mid] <= value && value <= container[mid + 1]) return mid;
+        if (container[mid] < value) start = mid + 1;
+        else end = mid - 1;
+    }
+    return null;
+}
+
+
+export { findFirstIndexInRange };
+