@pirireis/webglobeplugins 0.9.6 → 0.9.8

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

@@ -1,119 +1,108 @@
-/**
- * BufferOffsetManager
- * Purpose: To manage the offset of the buffer. Plus extend and defrag the buffer. 
- * ------------------------------------------------------------------------------------------------------------------------------------------- * Functions:
- * 1. getOffet(key) : return the offset of the key if not found return false.
- * 2. setOffset(key, offset) : set the offset of the key.
- * 3. nextOffset() : return the next available offset if not return false.
- * 4. delete(key) : delete the key and return true if not found return false.
- * 5. defragBuffer(gl, buffer, bufferType, newCapacity = null) : defrag the buffer. if newCapacity is not provided the buffer is vacumed.
- * 6. extendBuffer(gl, buffer, bufferType, newCapacity) : extend the buffer.
- * -------------------------------------------------------------------------------------------------------------------------------------------
- * What this class does NOT do:
- * ADD, DELETE, READ
- * ADD, inputs needs to be turn into a block and put into buffer. Bulk will be more performant.
- * DELETE, might be a set to single byte to indicate the tombstone.
- * READ, most of the time is not needed to be read, unless for defraging.
- * This unpredicatable behavior is not handled by this class.
- */
-
-export class BufferManager {
-    gl: WebGL2RenderingContext;
-    buffer: WebGLBuffer;
-    itemSize: number;
-    bufferType: string;
-    isFreed: boolean = false;
-
-    constructor(gl: WebGL2RenderingContext, itemSize: number, { bufferType = "STATIC_DRAW", buffer = null, initialCapacity = null } = {}) {
-        this.gl = gl;
-        this.itemSize = itemSize;
-        this.bufferType = bufferType;
-        this.buffer = buffer === null ? gl.createBuffer() : buffer;
-        if (initialCapacity !== null) this.resetWithCapacity(initialCapacity);
-    }
-
-    resetWithCapacity(capacity: number) {
-        const { gl, buffer, bufferType, itemSize } = this;
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        // @ts-ignore
-        gl.bufferData(gl.ARRAY_BUFFER, capacity * itemSize * 4, gl[bufferType]);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-
-    deleteBulk(offsets: number[]) {
-        const { gl, buffer, itemSize } = this;
-        const emptyBlock = new Float32Array(this.itemSize).fill(NaN)
-        const offsetMultiplier = itemSize * 4;
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        for (let offset of offsets) {
-            if (offset !== undefined) {
-                gl.bufferSubData(gl.ARRAY_BUFFER, offset * offsetMultiplier, emptyBlock);
-            }
-        }
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-
-
-    insertBulk(blocks: any[], offsets: number[]) {
-        const { gl, buffer, itemSize } = this;
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        const offsetMultiplier = itemSize * 4;
-        for (let i = 0; i < blocks.length; i++) {
-            const block = blocks[i];
-            const offset = offsets[i] * offsetMultiplier;
-            if (offset !== undefined) gl.bufferSubData(gl.ARRAY_BUFFER, offset, block);
-        }
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-
-
-    // TODO: this is broken
-    defrag(offsetValues: MapIterator<number> | number[], occupiedCapacity: number, newCapacity: number) {
-        const { gl, buffer, bufferType, itemSize } = this;
-
-        const newArray = new Float32Array(newCapacity * itemSize);
-        const bufferData = this._getBufferData(occupiedCapacity);
-        let newOffset = 0;
-        for (const offset of offsetValues) {
-            const itemOffset = offset * itemSize;
-            newArray.set(bufferData.slice(itemOffset, itemOffset + itemSize), newOffset);
-            newOffset += itemSize;
-        }
-
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        // @ts-ignore
-        gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
-        gl.bufferSubData(gl.ARRAY_BUFFER, 0, newArray);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-
-    }
-
-    extendBuffer(occupiedCapacity: number, newCapacity: number) {
-        const { gl, buffer, bufferType } = this;
-        const itemSize = this.itemSize;
-        const bufferData = this._getBufferData(occupiedCapacity);
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        // @ts-ignore
-        gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
-        gl.bufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-
-    _getBufferData(occupiedCapacity: number): Float32Array {
-        const { gl, buffer } = this;
-        const size = occupiedCapacity * this.itemSize;
-        const bufferData = new Float32Array(size);
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        gl.getBufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        return bufferData;
-    }
-
-    free() {
-        if (this.isFreed) return;
-        this.gl.deleteBuffer(this.buffer);
-        // this.buffer = null;
-        // this.gl = null;
-        this.isFreed = true;
-    }
-}
+"use strict";
+/**
+ * BufferOffsetManager
+ * Purpose: To manage the offset of the buffer. Plus extend and defrag the buffer.
+ * ------------------------------------------------------------------------------------------------------------------------------------------- * Functions:
+ * 1. getOffet(key) : return the offset of the key if not found return false.
+ * 2. setOffset(key, offset) : set the offset of the key.
+ * 3. nextOffset() : return the next available offset if not return false.
+ * 4. delete(key) : delete the key and return true if not found return false.
+ * 5. defragBuffer(gl, buffer, bufferType, newCapacity = null) : defrag the buffer. if newCapacity is not provided the buffer is vacumed.
+ * 6. extendBuffer(gl, buffer, bufferType, newCapacity) : extend the buffer.
+ * -------------------------------------------------------------------------------------------------------------------------------------------
+ * What this class does NOT do:
+ * ADD, DELETE, READ
+ * ADD, inputs needs to be turn into a block and put into buffer. Bulk will be more performant.
+ * DELETE, might be a set to single byte to indicate the tombstone.
+ * READ, most of the time is not needed to be read, unless for defraging.
+ * This unpredicatable behavior is not handled by this class.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferManager = void 0;
+class BufferManager {
+    constructor(gl, itemSize, { bufferType = "STATIC_DRAW", buffer = null, initialCapacity = null } = {}) {
+        this.isFreed = false;
+        this.gl = gl;
+        this.itemSize = itemSize;
+        this.bufferType = bufferType;
+        this.buffer = buffer === null ? gl.createBuffer() : buffer;
+        if (initialCapacity !== null)
+            this.resetWithCapacity(initialCapacity);
+    }
+    resetWithCapacity(capacity) {
+        const { gl, buffer, bufferType, itemSize } = this;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        // @ts-ignore
+        gl.bufferData(gl.ARRAY_BUFFER, capacity * itemSize * 4, gl[bufferType]);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+    deleteBulk(offsets) {
+        const { gl, buffer, itemSize } = this;
+        const emptyBlock = new Float32Array(this.itemSize).fill(NaN);
+        const offsetMultiplier = itemSize * 4;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        for (let offset of offsets) {
+            if (offset !== undefined) {
+                gl.bufferSubData(gl.ARRAY_BUFFER, offset * offsetMultiplier, emptyBlock);
+            }
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+    insertBulk(blocks, offsets) {
+        const { gl, buffer, itemSize } = this;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        const offsetMultiplier = itemSize * 4;
+        for (let i = 0; i < blocks.length; i++) {
+            const block = blocks[i];
+            const offset = offsets[i] * offsetMultiplier;
+            if (offset !== undefined)
+                gl.bufferSubData(gl.ARRAY_BUFFER, offset, block);
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+    // TODO: this is broken
+    defrag(offsetValues, occupiedCapacity, newCapacity) {
+        const { gl, buffer, bufferType, itemSize } = this;
+        const newArray = new Float32Array(newCapacity * itemSize);
+        const bufferData = this._getBufferData(occupiedCapacity);
+        let newOffset = 0;
+        for (const offset of offsetValues) {
+            const itemOffset = offset * itemSize;
+            newArray.set(bufferData.slice(itemOffset, itemOffset + itemSize), newOffset);
+            newOffset += itemSize;
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        // @ts-ignore
+        gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
+        gl.bufferSubData(gl.ARRAY_BUFFER, 0, newArray);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+    extendBuffer(occupiedCapacity, newCapacity) {
+        const { gl, buffer, bufferType } = this;
+        const itemSize = this.itemSize;
+        const bufferData = this._getBufferData(occupiedCapacity);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        // @ts-ignore
+        gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
+        gl.bufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+    _getBufferData(occupiedCapacity) {
+        const { gl, buffer } = this;
+        const size = occupiedCapacity * this.itemSize;
+        const bufferData = new Float32Array(size);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.getBufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return bufferData;
+    }
+    free() {
+        if (this.isFreed)
+            return;
+        this.gl.deleteBuffer(this.buffer);
+        // this.buffer = null;
+        // this.gl = null;
+        this.isFreed = true;
+    }
+}
+exports.BufferManager = BufferManager;

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

@@ -1,173 +1,150 @@
-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) {
-        this.autoExtendBuffers(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;
-            offsetMap.set(item.key, offset);
-            offsets.push(offset);
-        }
-        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 | boolean {
-        if (this.tombstoneOffsets.length > 0) {
-            const offset = this.tombstoneOffsets.pop() as number;
-            return offset;
-        }
-        if (this._length < this._capacity) {
-            return this._length++;
-        }
-        return false;
-    }
-
-
-    autoExtendBuffers(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;
-    }
-}
-
-
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferOrchestrator = void 0;
+const EXTRA_SIZE = 10;
+class BufferOrchestrator {
+    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) {
+        this.autoExtendBuffers(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);
+        }
+        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;
+    }
+    autoExtendBuffers(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;
+    }
+}
+exports.BufferOrchestrator = BufferOrchestrator;

package/dist/util/account/single-attribute-buffer-management/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectStore = exports.BufferManager = exports.BufferOrchestrator = void 0;
+const buffer_orchestrator_1 = require("./buffer-orchestrator");
+Object.defineProperty(exports, "BufferOrchestrator", { enumerable: true, get: function () { return buffer_orchestrator_1.BufferOrchestrator; } });
+const buffer_manager_1 = require("./buffer-manager");
+Object.defineProperty(exports, "BufferManager", { enumerable: true, get: function () { return buffer_manager_1.BufferManager; } });
+const object_store_1 = require("./object-store");
+Object.defineProperty(exports, "ObjectStore", { enumerable: true, get: function () { return object_store_1.ObjectStore; } });