@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/timetracks/programpoint.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../util");
+var programs_1 = require("../programs");
+var vertexShader = "#version 300 es\n\nlayout(std140) uniform GlobeCamera {\n    mat4 view; // 64 bytes           0\n    mat4 projection; // 64 bytes     64\n    vec3 translate; // 12 bytes      128\n    bool is3D; // 4 bytes            140\n    vec2 mapWH; // 8 bytes           144\n    vec2 screenWH; //  8 bytes       152\n    float z_level; // 4 bytes        160\n};\n\nlayout(std140) uniform Globals {\n    float head_time;\n    float final_opacity;\n    float point_size;\n};\n\nin vec3 start_position;\nin float start_time;\nin vec3 start_color;\nin vec3 end_position;\nin float end_time;\nin vec3 end_color;\nout vec4 v_color;\n\n" + util_1.shaderfunctions.pixelXYToCartesian3DPoint + util_1.shaderfunctions.pixelXYToCartesian2DPoint + "\n\nvoid main() {\n    if (head_time < start_time || head_time > end_time) { return; }\n    float t = (head_time - start_time) / (end_time - start_time);\n    vec3 position = mix(start_position, end_position, t);\n    if (is3D){\n        vec3 pos = pixelXYToCartesian3DPoint(position);\n        gl_Position = projection * view * vec4(pos - translate, 1.0);\n    }  else {\n        vec2 xy = pixelXYToCartesian2DPoint(position.xy, translate.xy, mapWH, screenWH);\n        gl_Position = projection * vec4(xy.x, xy.y, 0.0, 1.0);\n    }\n    v_color = vec4(mix(start_color, end_color, t), final_opacity);\n    gl_PointSize = point_size;\n}";
+var fragmentShader = "#version 300 es\nprecision highp float;\nin vec4 v_color;\nout vec4 outColor;\nvoid main() {\n    outColor = v_color;\n}";
+var default_1 = /** @class */ (function () {
+    function default_1(gl, globe, attrBuffer, options) {
+        this.gl = gl;
+        this._cameraBlockBindingPoint = 0;
+        this._globalsBlockBindingPoint = 1;
+        this.cameraUniformBlockTotem = programs_1.globeProgramCache.getProgram(globe, programs_1.CameraUniformBlockTotem);
+        this._vao = gl.createVertexArray();
+        this._attbuffer = attrBuffer;
+        this.program = this._createProgram();
+        this._drawCount = 0;
+        this._globalsbuffer = gl.createBuffer();
+        {
+            var _a = this, gl_1 = _a.gl, _globalsbuffer = _a._globalsbuffer;
+            gl_1.bindBuffer(gl_1.UNIFORM_BUFFER, _globalsbuffer);
+            gl_1.bufferData(gl_1.UNIFORM_BUFFER, 12, gl_1.STREAM_DRAW);
+            gl_1.bufferSubData(gl_1.UNIFORM_BUFFER, 0, new Float32Array([0, options.opacity, options.pointSize]));
+            gl_1.bindBufferBase(gl_1.UNIFORM_BUFFER, this._globalsBlockBindingPoint, _globalsbuffer);
+            gl_1.bindBuffer(gl_1.UNIFORM_BUFFER, null);
+        }
+    }
+    default_1.prototype._createProgram = function () {
+        var gl = this.gl;
+        var program = (0, util_1.createProgram)(gl, vertexShader, fragmentShader);
+        var ubo = this.cameraUniformBlockTotem.getUBO(); // ubo bl
+        var cameraBlockIndex = gl.getUniformBlockIndex(program, "GlobeCamera");
+        gl.uniformBlockBinding(program, cameraBlockIndex, this._cameraBlockBindingPoint);
+        var globalsBlockIndex = gl.getUniformBlockIndex(program, "Globals");
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._cameraBlockBindingPoint, ubo);
+        gl.uniformBlockBinding(program, globalsBlockIndex, this._globalsBlockBindingPoint);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._globalsBlockBindingPoint, this._globalsbuffer);
+        // numaralarda yanlışlık olabilir
+        var start_position = gl.getAttribLocation(program, "start_position");
+        var start_time = gl.getAttribLocation(program, "start_time");
+        var start_color = gl.getAttribLocation(program, "start_color");
+        var end_position = gl.getAttribLocation(program, "end_position");
+        var end_time = gl.getAttribLocation(program, "end_time");
+        var end_color = gl.getAttribLocation(program, "end_color");
+        gl.bindVertexArray(this._vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._attbuffer);
+        gl.enableVertexAttribArray(start_position);
+        gl.vertexAttribPointer(start_position, 3, gl.FLOAT, false, 72, 0);
+        gl.enableVertexAttribArray(start_time);
+        gl.vertexAttribPointer(start_time, 1, gl.FLOAT, false, 72, 12);
+        gl.enableVertexAttribArray(start_color);
+        gl.vertexAttribPointer(start_color, 3, gl.FLOAT, false, 72, 16);
+        gl.enableVertexAttribArray(end_position);
+        gl.vertexAttribPointer(end_position, 3, gl.FLOAT, false, 72, 36);
+        gl.enableVertexAttribArray(end_time);
+        gl.vertexAttribPointer(end_time, 1, gl.FLOAT, false, 72, 48);
+        gl.enableVertexAttribArray(end_color);
+        gl.vertexAttribPointer(end_color, 3, gl.FLOAT, false, 72, 52);
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return program;
+    };
+    default_1.prototype.setOpacity = function (opacity) {
+        var _a = this, gl = _a.gl, _globalsbuffer = _a._globalsbuffer;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 4, new Float32Array([opacity]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    };
+    default_1.prototype.setDrawCount = function (count) {
+        this._drawCount = count;
+    };
+    default_1.prototype.setPointSize = function (size) {
+        var _a = this, gl = _a.gl, _globalsbuffer = _a._globalsbuffer;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 8, new Float32Array([size]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    };
+    default_1.prototype.setHeadTime = function (time) {
+        var _a = this, gl = _a.gl, _globalsbuffer = _a._globalsbuffer;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([time]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    };
+    default_1.prototype.draw = function () {
+        var _a = this, gl = _a.gl, program = _a.program, _vao = _a._vao, _drawCount = _a._drawCount;
+        gl.useProgram(program);
+        gl.bindVertexArray(_vao);
+        gl.disable(gl.DEPTH_TEST);
+        gl.drawArrays(gl.POINTS, 0, _drawCount);
+        gl.enable(gl.DEPTH_TEST);
+        gl.bindVertexArray(null);
+    };
+    default_1.prototype.free = function () {
+        var _a = this, gl = _a.gl, _vao = _a._vao, _globalsbuffer = _a._globalsbuffer, program = _a.program;
+        gl.deleteVertexArray(_vao);
+        // gl.deleteBuffer(_attbuffer);
+        gl.deleteBuffer(_globalsbuffer);
+        gl.deleteProgram(program);
+    };
+    return default_1;
+}());
+exports.default = default_1;

package/types.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * @typedef DrawRange
+ * @type {Object}
+ * @property {int} first
+ * @property {int} count
+ *
+ * @typedef DrawRangeIndexParamsClient
+ * @type {Object}
+ * @property {null|DrawRange} drawRange
+ * @property {null|Int32List} indexes
+ */
+/**
+ * * @typedef {Array<number>} Color rgba color 0-1 values
+ */

package/util/account/bufferoffsetmanager.js

@@ -0,0 +1,202 @@
+"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 });
+var default_1 = /** @class */ (function () {
+    function default_1(itemSize, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.capacity, capacity = _c === void 0 ? 10 : _c, _d = _b.bufferType, bufferType = _d === void 0 ? "STATIC_DRAW" : _d;
+        this.itemSize = itemSize;
+        this.bufferType = bufferType;
+        this.offSetMap = new Map();
+        this.tombstoneOffSet = [];
+        this._capacity = capacity;
+        this._length = 0;
+    }
+    Object.defineProperty(default_1.prototype, "length", {
+        get: function () {
+            return this._length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(default_1.prototype, "capacity", {
+        get: function () {
+            return this._capacity;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    default_1.prototype.getOffset = function (key) {
+        return this.offSetMap.get(key);
+    };
+    default_1.prototype.setOffset = function (key, offset) {
+        this.offSetMap.set(key, offset);
+    };
+    default_1.prototype.nextOffset = function () {
+        if (this.tombstoneOffSet.length > 0) {
+            var offset = this.tombstoneOffSet.pop();
+            return offset;
+        }
+        if (this._length < this._capacity) {
+            return this._length++ * this.itemSize * 4;
+        }
+        return false;
+    };
+    Object.defineProperty(default_1.prototype, "spaceLeft", {
+        get: function () {
+            return this._capacity - (this._length - this.tombstoneOffSet.length);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(default_1.prototype, "itemCount", {
+        get: function () {
+            return this._length - this.tombstoneOffSet.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    default_1.prototype.deleteFromAccount = function (key) {
+        var offSet = this.offSetMap.get(key);
+        if (offSet !== undefined) {
+            this.tombstoneOffSet.push(offSet);
+            this.offSetMap.delete(key);
+            return true;
+        }
+        else {
+            return false;
+        }
+    };
+    default_1.prototype._deleteBulk = function (keys) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer;
+        var emptyBlock = new Float32Array(this.itemSize).fill(0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+            var key = keys_1[_i];
+            var offset = this.getOffset(key);
+            if (offset !== undefined) {
+                this.deleteFromAccount(key);
+                gl.bufferSubData(gl.ARRAY_BUFFER, offset, emptyBlock);
+            }
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    };
+    default_1.prototype.offsetMapIterator = function () {
+        return this.offSetMap.entries();
+    };
+    // TODO: this is broken
+    default_1.prototype.defrag = function (newCapacity) {
+        if (newCapacity === void 0) { newCapacity = null; }
+        var _a = this, gl = _a.gl, buffer = _a.buffer, bufferType = _a.bufferType;
+        if (gl === undefined || buffer === undefined || bufferType === undefined) {
+            throw new Error("gl, buffer, bufferType are required");
+        }
+        var itemSize = this.itemSize;
+        var itemCount = this.itemCount;
+        var capacity = (newCapacity && newCapacity > itemCount) ? newCapacity : itemCount;
+        var newArray = new Float32Array(itemCount * itemSize);
+        var bufferData = this._getBufferData();
+        var newOffSet = 0;
+        var newOffSetMap = new Map();
+        for (var _i = 0, _b = this.offSetMap; _i < _b.length; _i++) {
+            var _c = _b[_i], key = _c[0], offSet = _c[1];
+            var itemOffSet = offSet / 4;
+            newArray.set(bufferData.slice(itemOffSet, itemOffSet + itemSize), newOffSet);
+            // this.offSetMap.set(key, newOffSet * 4);
+            newOffSetMap.set(key, newOffSet * 4);
+            newOffSet += itemSize;
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, capacity * itemSize * 4, gl[bufferType]);
+        gl.bufferSubData(gl.ARRAY_BUFFER, 0, newArray);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this._capacity = capacity;
+        this.tombstoneOffSet = [];
+        this._length = itemCount;
+        this.offSetMap = newOffSetMap;
+    };
+    default_1.prototype.autoExtendBuffer = function (payloadSize) {
+        if (payloadSize <= this.spaceLeft)
+            return;
+        var newCapacity = Math.ceil((payloadSize + this.length));
+        this.extendBuffer(newCapacity);
+    };
+    default_1.prototype.extendBuffer = function (newCapacity) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer, bufferType = _a.bufferType;
+        var itemSize = this.itemSize;
+        var bufferData = this._getBufferData();
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
+        gl.bufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this._capacity = newCapacity;
+    };
+    /** implicit methods to be used by the child class */
+    /**
+     * @typedef {Float32Array} payload
+     * @param {Array<{key, payload}>} items
+     * @param {number} partOffset
+     * @returns
+     */
+    default_1.prototype._updatePartial = function (items, partOffset) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer;
+        var partStart = partOffset * 4;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+            var _b = items_1[_i], key = _b.key, payload = _b.payload;
+            var offset = this.getOffset(key);
+            if (offset !== undefined) {
+                gl.bufferSubData(gl.ARRAY_BUFFER, offset + partStart, payload);
+            }
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    };
+    default_1.prototype._getBufferData = function () {
+        var _a = this, gl = _a.gl, buffer = _a.buffer;
+        var size = new Float32Array(this.length * this.itemSize);
+        var 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;
+    };
+    default_1.prototype._removeFromBuffer = function (keys) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer;
+        var emptyBlock = new Float32Array(this.itemSize).fill(0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {
+            var key = keys_2[_i];
+            var offset = this.getOffset(key);
+            if (offset !== undefined) {
+                this.deleteFromAccount(key);
+                gl.bufferSubData(gl.ARRAY_BUFFER, offset, emptyBlock);
+            }
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    };
+    default_1.prototype.free = function () {
+        this.gl.deleteBuffer(this.buffer);
+        this.buffer = null;
+        this.vao = null;
+        this.gl = null;
+    };
+    return default_1;
+}());
+exports.default = default_1;

package/util/account/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferOffsetManager = void 0;
+var bufferoffsetmanager_1 = __importDefault(require("./bufferoffsetmanager"));
+exports.BufferOffsetManager = bufferoffsetmanager_1.default;
+__exportStar(require("./single-attribute-buffer-management/index"), exports);

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

@@ -0,0 +1,112 @@
+"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;
+var BufferManager = /** @class */ (function () {
+    function BufferManager(gl, itemSize, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.bufferType, bufferType = _c === void 0 ? "STATIC_DRAW" : _c, _d = _b.buffer, buffer = _d === void 0 ? null : _d, _e = _b.initialCapacity, initialCapacity = _e === void 0 ? null : _e;
+        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);
+    }
+    BufferManager.prototype.resetWithCapacity = function (capacity) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer, bufferType = _a.bufferType, itemSize = _a.itemSize;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        // @ts-ignore
+        gl.bufferData(gl.ARRAY_BUFFER, capacity * itemSize * 4, gl[bufferType]);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    };
+    BufferManager.prototype.deleteBulk = function (offsets) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer, itemSize = _a.itemSize;
+        var emptyBlock = new Float32Array(this.itemSize).fill(NaN);
+        var offsetMultiplier = itemSize * 4;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        for (var _i = 0, offsets_1 = offsets; _i < offsets_1.length; _i++) {
+            var offset = offsets_1[_i];
+            if (offset !== undefined) {
+                gl.bufferSubData(gl.ARRAY_BUFFER, offset * offsetMultiplier, emptyBlock);
+            }
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    };
+    BufferManager.prototype.insertBulk = function (blocks, offsets) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer, itemSize = _a.itemSize;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        var offsetMultiplier = itemSize * 4;
+        for (var i = 0; i < blocks.length; i++) {
+            var block = blocks[i];
+            var offset = offsets[i] * offsetMultiplier;
+            if (offset !== undefined)
+                gl.bufferSubData(gl.ARRAY_BUFFER, offset, block);
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    };
+    // TODO: this is broken
+    BufferManager.prototype.defrag = function (offsetValues, occupiedCapacity, newCapacity) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer, bufferType = _a.bufferType, itemSize = _a.itemSize;
+        var newArray = new Float32Array(newCapacity * itemSize);
+        var bufferData = this._getBufferData(occupiedCapacity);
+        var newOffset = 0;
+        for (var _i = 0, offsetValues_1 = offsetValues; _i < offsetValues_1.length; _i++) {
+            var offset = offsetValues_1[_i];
+            var 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);
+    };
+    BufferManager.prototype.extendBuffer = function (occupiedCapacity, newCapacity) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer, bufferType = _a.bufferType;
+        var itemSize = this.itemSize;
+        var 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);
+    };
+    BufferManager.prototype._getBufferData = function (occupiedCapacity) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer;
+        var size = occupiedCapacity * this.itemSize;
+        var 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;
+    };
+    BufferManager.prototype.free = function () {
+        if (this.isFreed)
+            return;
+        this.gl.deleteBuffer(this.buffer);
+        // this.buffer = null;
+        // this.gl = null;
+        this.isFreed = true;
+    };
+    return BufferManager;
+}());
+exports.BufferManager = BufferManager;

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

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferOrchestrator = void 0;
+var EXTRA_SIZE = 10;
+var BufferOrchestrator = /** @class */ (function () {
+    function BufferOrchestrator(_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.capacity, capacity = _c === void 0 ? 10 : _c;
+        this._capacity = capacity;
+        this.offsetMap = new Map();
+        this.tombstoneOffsets = [];
+        this._length = 0;
+    }
+    BufferOrchestrator.prototype.resetWithCapacity = function (bufferManagersMap, capacity) {
+        if (capacity === void 0) { capacity = null; }
+        this._capacity = capacity !== null ? capacity : this._capacity;
+        for (var _i = 0, bufferManagersMap_1 = bufferManagersMap; _i < bufferManagersMap_1.length; _i++) {
+            var _a = bufferManagersMap_1[_i], key = _a[0], bufferManager = _a[1].bufferManager;
+            bufferManager.resetWithCapacity(this._capacity);
+        }
+        this.offsetMap.clear();
+        this.tombstoneOffsets = [];
+        this._length = 0;
+    };
+    BufferOrchestrator.prototype.insertBulk = function (items, bufferManagersMap) {
+        this.autoExtendBuffers(items.length, bufferManagersMap);
+        var offsetMap = this.offsetMap;
+        var offsets = [];
+        for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+            var item = items_1[_i];
+            var o = offsetMap.get(item.key);
+            var offset = o !== undefined ? o : this.nextOffset();
+            offsetMap.set(item.key, offset);
+            offsets.push(offset);
+        }
+        for (var _a = 0, bufferManagersMap_2 = bufferManagersMap; _a < bufferManagersMap_2.length; _a++) {
+            var _b = bufferManagersMap_2[_a], key = _b[0], _c = _b[1], bufferManager = _c.bufferManager, adaptor = _c.adaptor;
+            bufferManager.insertBulk(items.map(adaptor), offsets);
+        }
+    };
+    // does not assign offset to the new items.
+    BufferOrchestrator.prototype.updateBulk = function (items, bufferManagersMap, bufferKeys) {
+        if (bufferKeys === void 0) { bufferKeys = null; }
+        var offsetMap = this.offsetMap;
+        var offsets = [];
+        for (var _i = 0, items_2 = items; _i < items_2.length; _i++) {
+            var item = items_2[_i];
+            var offset = offsetMap.get(item.key);
+            if (offset !== undefined) {
+                offsets.push(offset);
+            }
+            else {
+                throw new Error("updateBulk item Key does not exist");
+            }
+        }
+        if (bufferKeys) {
+            for (var _a = 0, bufferKeys_1 = bufferKeys; _a < bufferKeys_1.length; _a++) {
+                var key = bufferKeys_1[_a];
+                var bufferManagerComp = bufferManagersMap.get(key);
+                if (bufferManagerComp === undefined)
+                    throw new Error("updateBulk bufferKey does not exist");
+                var bufferManager = bufferManagerComp.bufferManager, adaptor = bufferManagerComp.adaptor;
+                bufferManager.insertBulk(items.map(adaptor), offsets);
+            }
+        }
+        else {
+            for (var _b = 0, bufferManagersMap_3 = bufferManagersMap; _b < bufferManagersMap_3.length; _b++) {
+                var _c = bufferManagersMap_3[_b], key = _c[0], _d = _c[1], bufferManager = _d.bufferManager, adaptor = _d.adaptor;
+                bufferManager.insertBulk(items.map(adaptor), offsets);
+            }
+        }
+    };
+    BufferOrchestrator.prototype.deleteBulk = function (keys, bufferManagersMap) {
+        var offsets = [];
+        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+            var key = keys_1[_i];
+            var offset = this.getOffset(key);
+            if (offset !== undefined) {
+                offsets.push(offset);
+                this.offsetMap.delete(key);
+                this.tombstoneOffsets.push(offset);
+            }
+        }
+        for (var _a = 0, bufferManagersMap_4 = bufferManagersMap; _a < bufferManagersMap_4.length; _a++) {
+            var _b = bufferManagersMap_4[_a], key = _b[0], bufferManager = _b[1].bufferManager;
+            bufferManager.deleteBulk(offsets);
+        }
+    };
+    BufferOrchestrator.prototype.getOffset = function (key) {
+        return this.offsetMap.get(key);
+    };
+    BufferOrchestrator.prototype.nextOffset = function () {
+        if (this.tombstoneOffsets.length > 0) {
+            var offset = this.tombstoneOffsets.pop();
+            return offset;
+        }
+        if (this._length < this._capacity) {
+            return this._length++;
+        }
+        return false;
+    };
+    BufferOrchestrator.prototype.autoExtendBuffers = function (itemsLength, bufferManagersMap) {
+        if (itemsLength <= this.emptySpace)
+            return;
+        var newCapacity = this.length + itemsLength;
+        for (var _i = 0, bufferManagersMap_5 = bufferManagersMap; _i < bufferManagersMap_5.length; _i++) {
+            var _a = bufferManagersMap_5[_i], key = _a[0], bufferManager = _a[1].bufferManager;
+            bufferManager.extendBuffer(this.length, newCapacity);
+        }
+        this._capacity = newCapacity;
+    };
+    BufferOrchestrator.prototype.defrag = function (bufferManagers, bufferKeys) {
+        var offsetMap = this.offsetMap;
+        var newCapacity = offsetMap.size + EXTRA_SIZE;
+        if (bufferKeys) {
+            for (var _i = 0, bufferKeys_2 = bufferKeys; _i < bufferKeys_2.length; _i++) {
+                var key = bufferKeys_2[_i];
+                var offset = offsetMap.get(key);
+                if (offset !== undefined) {
+                    for (var _a = 0, bufferManagers_1 = bufferManagers; _a < bufferManagers_1.length; _a++) {
+                        var _b = bufferManagers_1[_a], key_1 = _b[0], bufferManager = _b[1].bufferManager;
+                        bufferManager.defrag([offset], this.length, newCapacity);
+                    }
+                }
+            }
+        }
+        else {
+            for (var _c = 0, bufferManagers_2 = bufferManagers; _c < bufferManagers_2.length; _c++) {
+                var _d = bufferManagers_2[_c], key = _d[0], bufferManager = _d[1].bufferManager;
+                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
+     */
+    BufferOrchestrator.prototype.flush = function (_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.capacity, capacity = _c === void 0 ? 10 : _c;
+        this._length = 0;
+        this._capacity = capacity;
+        this.tombstoneOffsets = [];
+        this.offsetMap.clear();
+    };
+    BufferOrchestrator.prototype._defrag = function () {
+        var newOffsetMap = new Map();
+        var newOffset = 0;
+        for (var _i = 0, _a = this.offsetMap; _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], offset = _b[1];
+            newOffsetMap.set(key, newOffset++);
+        }
+        this.offsetMap = newOffsetMap;
+    };
+    Object.defineProperty(BufferOrchestrator.prototype, "length", {
+        get: function () {
+            return this._length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BufferOrchestrator.prototype, "emptySpace", {
+        get: function () {
+            return this._capacity - this.offsetMap.size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BufferOrchestrator.prototype, "capacity", {
+        get: function () {
+            return this._capacity;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BufferOrchestrator;
+}());
+exports.BufferOrchestrator = BufferOrchestrator;

package/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;
+var buffer_orchestrator_1 = require("./buffer-orchestrator");
+Object.defineProperty(exports, "BufferOrchestrator", { enumerable: true, get: function () { return buffer_orchestrator_1.BufferOrchestrator; } });
+var buffer_manager_1 = require("./buffer-manager");
+Object.defineProperty(exports, "BufferManager", { enumerable: true, get: function () { return buffer_manager_1.BufferManager; } });
+var object_store_1 = require("./object-store");
+Object.defineProperty(exports, "ObjectStore", { enumerable: true, get: function () { return object_store_1.ObjectStore; } });