@pirireis/webglobeplugins 0.16.7 → 0.17.0

package/semiplugins/utility/container-plugin.js

@@ -0,0 +1,94 @@
+import { CSRenderPassPluginKeys } from "../../constants";
+export class ContainerPlugin {
+    id;
+    container = new Map();
+    active = true;
+    globe = null;
+    /**
+     * Asagidaki degerleri false yapmak ufak performans kazanclari saglar.
+     * Örneğin containera atılan pluginlerin sadece normal passda cizim yapmasi isteniyorsa
+     * supportSelectedPass ve supportEditingPass false yapilabilir.
+     */
+    supportNormalPass = true;
+    supportSelectedPass = true;
+    supportEditingPass = true;
+    constructor(id, container) {
+        this.id = id;
+        this.container = container;
+    }
+    init(globe, gl) {
+        this.globe = globe;
+        this.container.forEach((plugin) => {
+            plugin.init(globe, gl);
+        });
+    }
+    setActive(active) {
+        this.active = active;
+        this.globe?.DrawRender();
+    }
+    draw3D(projectionMatrix, modelViewMatrix, transPosition, csRenderPass) {
+        if (!this.active)
+            return;
+        const passSupportKey = CSRenderPassPluginKeys[csRenderPass];
+        for (const plugin of this.container.values()) {
+            if (plugin[passSupportKey] === false) {
+                continue;
+            }
+            if (plugin.draw3D) {
+                plugin.draw3D(projectionMatrix, modelViewMatrix, transPosition, csRenderPass);
+            }
+        }
+    }
+    draw2D(csRenderPass) {
+        if (!this.active)
+            return;
+        const passSupportKey = CSRenderPassPluginKeys[csRenderPass];
+        for (const plugin of this.container.values()) {
+            if (plugin[passSupportKey] === false) {
+                continue;
+            }
+            if (plugin.draw2D) {
+                plugin.draw2D(csRenderPass);
+            }
+        }
+    }
+    free() {
+        for (const plugin of this.container.values()) {
+            plugin.free();
+        }
+        this.container.clear();
+    }
+    _forwardMouseEvent(eventName, x, y, event, csRenderPass) {
+        if (!this.active)
+            return false;
+        const passSupportKey = CSRenderPassPluginKeys[csRenderPass];
+        for (const plugin of this.container.values()) {
+            if (plugin[passSupportKey] === false) {
+                continue;
+            }
+            const handler = plugin[eventName];
+            if (handler) {
+                const result = handler.call(plugin, x, y, event, csRenderPass);
+                if (result === true) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    mouseClick(x, y, event, csRenderPass) {
+        return this._forwardMouseEvent('mouseClick', x, y, event, csRenderPass);
+    }
+    mouseDblClick(x, y, event, csRenderPass) {
+        return this._forwardMouseEvent('mouseDblClick', x, y, event, csRenderPass);
+    }
+    mouseDown(x, y, event, csRenderPass) {
+        return this._forwardMouseEvent('mouseDown', x, y, event, csRenderPass);
+    }
+    mouseMove(x, y, event, csRenderPass) {
+        return this._forwardMouseEvent('mouseMove', x, y, event, csRenderPass);
+    }
+    mouseUp(x, y, event, csRenderPass) {
+        return this._forwardMouseEvent('mouseUp', x, y, event, csRenderPass);
+    }
+}

package/semiplugins/utility/object-pass-container-plugin.js

@@ -0,0 +1,80 @@
+/**
+ * object-pass-plugin.ts
+ * Manages object pass between instances of same plugin with different configurations
+ */
+import { ContainerPlugin } from "./container-plugin";
+export class ObjectPassContainerPlugin extends ContainerPlugin {
+    keyMethod;
+    insertMethod;
+    removeMethod;
+    objectContainer;
+    constructor(id, container, keyMethod, insertMethod, removeMethod) {
+        super(id, container);
+        this.keyMethod = keyMethod;
+        this.insertMethod = insertMethod;
+        this.removeMethod = removeMethod;
+        this.objectContainer = new Map();
+    }
+    passObjects(keys, extraParameters, toPluginId) {
+        const toPlugin = this.container.get(toPluginId);
+        if (!toPlugin) {
+            throw new Error(`Plugin with id ${toPluginId} not found in plugin container`);
+        }
+        const itemsToPass = [];
+        for (const key of keys) {
+            const entry = this.objectContainer.get(key);
+            if (!entry) {
+                console.warn(`Object with key ${key} not found in object container`);
+                continue;
+            }
+            const [pluginId, item] = entry;
+            if (pluginId === toPluginId) {
+                console.warn(`Object with key ${key} is already in the target plugin ${toPluginId}`);
+                continue;
+            }
+            itemsToPass.push(item);
+            const fromPlugin = this.container.get(pluginId);
+            if (!fromPlugin) {
+                throw new Error(`Plugin with id ${pluginId} not found in plugin container`);
+            }
+            entry[0] = toPluginId; // update plugin id in the container
+            this.removeMethod(key, extraParameters, fromPlugin);
+        }
+        if (this.insertMethod) {
+            this.insertMethod(itemsToPass, extraParameters, toPlugin);
+        }
+    }
+    insertObjects(items, extraParameters, toPluginId) {
+        const toPlugin = this.container.get(toPluginId);
+        if (!toPlugin) {
+            throw new Error(`Plugin with id ${toPluginId} not found in plugin container`);
+        }
+        for (const item of items) {
+            const key = this.keyMethod(item);
+            this.objectContainer.set(key, [toPluginId, item]);
+        }
+        if (this.insertMethod) {
+            this.insertMethod(items, extraParameters, toPlugin);
+        }
+    }
+    removeObjects(keys, extraParameters) {
+        for (const key of keys) {
+            const entry = this.objectContainer.get(key);
+            if (!entry) {
+                console.warn(`Object with key ${key} not found in object container`);
+                continue;
+            }
+            const [pluginId, item] = entry;
+            const fromPlugin = this.container.get(pluginId);
+            if (!fromPlugin) {
+                throw new Error(`Plugin with id ${pluginId} not found in plugin container`);
+            }
+            this.removeMethod(key, extraParameters, fromPlugin);
+            this.objectContainer.delete(key);
+        }
+    }
+    passAllObjects(extraParameters, toPluginId) {
+        const keys = Array.from(this.objectContainer.keys());
+        this.passObjects(keys, extraParameters, toPluginId);
+    }
+}

package/{point-heat-map → tracks/point-heat-map}/adaptors/timetracksplugin-format-to-this.js

@@ -29,7 +29,7 @@
  * @property {Array<Number>} times
  * @param {Array<Timetrack>} timeTracks
  */
-import { pixelXYLenghtToUnitVectorWithHeight } from "../../Math/methods";
+import { pixelXYLenghtToUnitVectorWithHeight } from "../../../Math/methods";
 const processACut = (array, offset) => {
     // first 3 values of array
     const v3 = array.slice(offset, offset + 3);

package/{point-heat-map → tracks/point-heat-map}/plugin-webworker.js

@@ -1,7 +1,7 @@
 import { PointHeatmapFlow } from "./point-to-heat-map-flow";
-import { createWorker } from "../util/interpolation/timetrack/index";
-import { createTexture, getColorRampModed } from "../util";
-import { opacityCheck, constraintFloat } from "../util/check/typecheck";
+import { createWorker } from "../../util/interpolation/timetrack/index";
+import { createTexture, getColorRampModed } from "../../util/webglobjectbuilders";
+import { opacityCheck, constraintFloat } from "../../util/check/typecheck";
 class PointHeatmapPlugin {
     constructor(id, { opacity = 1.0, pointSize = 5.0, onInterpolationComplete = () => { } } = {}) {
         this.id = id;

package/{point-heat-map → tracks/point-heat-map}/point-to-heat-map-flow.js

@@ -1,7 +1,7 @@
-import { densityToLegendProgramCache } from "../programs/data2legend/density-to-legend";
-import { pointToDensityTextureCache } from "../programs/data2legend/point-to-density-texture";
-// import { textureOnCanvasProgramCache } from "../util/programs/draw-texture-on-canvas";
-import { defaultblendfunction } from "../util/webglobe/gldefaultstates";
+import { densityToLegendProgramCache } from "../../programs/data2legend/density-to-legend";
+import { pointToDensityTextureCache } from "../../programs/data2legend/point-to-density-texture";
+// import { textureOnCanvasProgramCache } from "../../util/programs/draw-texture-on-canvas";
+import { defaultblendfunction } from "../../util/webglobe/gldefaultstates";
 class PointHeatmapFlow {
     constructor(globe) {
         this.globe = null;
@@ -15,16 +15,13 @@ class PointHeatmapFlow {
         // this.testTextureProgram = textureOnCanvasProgramCache.get(globe.gl);
         this._lookInfo = globe.api_GetCurrentLookInfo();
         const { gl } = this;
-        {
-            this.buffer = gl.createBuffer();
-            this.vao2D = this.pointToDensityProgram.createVAO(this.buffer, 2);
-            this.vao3D = this.pointToDensityProgram.createVAO(this.buffer, 3);
-        }
-        { // framebuffer and texture
-            this.framebuffer = gl.createFramebuffer();
-            this.densityTexture = this._createDensityTexture();
-            this._bindTextureToFramebuffer();
-        }
+        this.buffer = gl.createBuffer();
+        this.vao2D = this.pointToDensityProgram.createVAO(this.buffer, 2);
+        this.vao3D = this.pointToDensityProgram.createVAO(this.buffer, 3);
+        // framebuffer and texture
+        this.framebuffer = gl.createFramebuffer();
+        this.densityTexture = this._createDensityTexture();
+        this._bindTextureToFramebuffer();
     }
     _bindTextureToFramebuffer() {
         const { gl, densityTexture, framebuffer } = this;

package/{point-tracks → tracks/point-tracks}/plugin.js

@@ -1,7 +1,7 @@
-import { BufferOrchestrator, BufferManager, ObjectStore } from "../util/account/index";
-import { PickerDisplayer } from "../util/picking/picker-displayer";
-import { PointOnGlobeProgramCache } from "../programs/point-on-globe/square-pixel-point";
-import { wgs84ToCartesian3d, wgs84ToMercator } from "../Math/methods";
+import { BufferOrchestrator, BufferManager, ObjectStore } from "../../util/account/index";
+import { PickerDisplayer } from "../../util/picking/picker-displayer";
+import { PointOnGlobeProgramCache } from "../../programs/point-on-globe/square-pixel-point";
+import { wgs84ToCartesian3d, wgs84ToMercator } from "../../Math/methods";
 const _0vec3 = /* @__PURE__ */ [0, 0, 0];
 /**
  * @typedef {number} long
@@ -347,7 +347,7 @@ class PointTracksPlugin {
                 const key = keyMethod(trackID, pointID);
                 const index = this._bufferOrchestrator.offsetMap.get(key);
                 if (index === undefined) {
-                    throw new Error;
+                    throw new Error(`Point with key ${key} not found in buffer orchestrator.`);
                 }
                 indexes.push(index);
                 length++;

package/{timetracks → tracks/timetracks}/adaptors-line-strip.js

@@ -1,4 +1,4 @@
-import { latLongToPixelXY } from "../util";
+import { latLongToPixelXY } from "../util/geometry/index";
 /**
  * @param {Array.<Array.<number>>} coordinates
  * @param {Array.<number>} timestamps

package/{timetracks → tracks/timetracks}/program-line-strip.js

@@ -1,7 +1,10 @@
 /**
  * Author: Toprak Nihat Deniz Ozturk
  */
-import { createProgram, defaultblendfunction, shaderfunctions } from "../util";
+// import { createProgram, defaultblendfunction, shaderfunctions } from "../../util";
+import { createProgram } from "../../util/webglobjectbuilders";
+import { defaultblendfunction } from "../../util/webglobe/gldefaultstates";
+import { pixelXYToCartesian2DPoint, pixelXYToCartesian3DPoint, } from "../../util/shaderfunctions";
 export default class TrackGlowLineProgram {
     /**
      * @param {WebGL2RenderingContext} gl
@@ -398,8 +401,8 @@ out float v_time;
 out vec3 v_color;
 out float v_track_start_time;
 out float v_track_end_time;
-${shaderfunctions.pixelXYToCartesian3DPoint}
-${shaderfunctions.pixelXYToCartesian2DPoint}
+${pixelXYToCartesian3DPoint}
+${pixelXYToCartesian2DPoint}
     
 void main() {
 
@@ -535,56 +538,53 @@ void main() {
         this._resetTexture();
         gl.enable(gl.BLEND);
         gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
-        { // draw lines
-            gl.bindFramebuffer(gl.FRAMEBUFFER, this._frameBuffer);
-            gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._middleTexture, 0);
-            gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this._blurTextures[0], 0);
-            gl.drawBuffers([
-                gl.COLOR_ATTACHMENT0,
-                gl.COLOR_ATTACHMENT1,
-            ]);
-            gl.useProgram(_lineProgram.program);
-            gl.uniform1f(_lineProgram.u_head_time, u_head_time);
-            gl.uniform1f(_lineProgram.u_tail_time, u_tail_time);
-            gl.uniformMatrix4fv(_lineProgram.uProjectionMatrix, false, uProjectionMatrix);
-            if (u_mapWH) {
-                gl.uniform2fv(_lineProgram.u_mapWH, u_mapWH);
-            }
-            else {
-                gl.uniformMatrix4fv(_lineProgram.uModelViewMatrix, false, uModelViewMatrix);
-            }
-            gl.uniform3fv(_lineProgram.uTranslate, uTranslate);
-            gl.bindVertexArray(_lineProgram.vao);
-            gl.drawArrays(gl.LINE_STRIP, 0, this._totalLength);
-            gl.drawBuffers([
-                gl.COLOR_ATTACHMENT0,
-                gl.NONE
-            ]);
+        // draw lines
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this._frameBuffer);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._middleTexture, 0);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this._blurTextures[0], 0);
+        gl.drawBuffers([
+            gl.COLOR_ATTACHMENT0,
+            gl.COLOR_ATTACHMENT1,
+        ]);
+        gl.useProgram(_lineProgram.program);
+        gl.uniform1f(_lineProgram.u_head_time, u_head_time);
+        gl.uniform1f(_lineProgram.u_tail_time, u_tail_time);
+        gl.uniformMatrix4fv(_lineProgram.uProjectionMatrix, false, uProjectionMatrix);
+        if (u_mapWH) {
+            gl.uniform2fv(_lineProgram.u_mapWH, u_mapWH);
         }
-        { // blur ping pong
-            gl.useProgram(_blurProgram.program);
-            gl.bindVertexArray(_blurProgram.vao);
-            for (let i = 0; i < _blurRepetition * 2; i++) {
-                gl.bindFramebuffer(gl.FRAMEBUFFER, this._blurFrameBuffers[i % 2]);
-                gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._blurTextures[(i + 1) % 2], 0);
-                gl.bindTexture(gl.TEXTURE_2D, this._blurTextures[i % 2]);
-                gl.uniform1i(_blurProgram.u_texture, 0);
-                gl.uniform1f(_blurProgram.u_horizontal, i % 2 == 0);
-                gl.drawArrays(gl.TRIANGLES, 0, 6);
-            }
+        else {
+            gl.uniformMatrix4fv(_lineProgram.uModelViewMatrix, false, uModelViewMatrix);
         }
-        { // combine  
-            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-            gl.useProgram(this._combineProgram.program);
-            gl.bindVertexArray(this._combineProgram.vao);
-            gl.activeTexture(gl.TEXTURE1);
-            gl.bindTexture(gl.TEXTURE_2D, this._blurTextures[1]);
-            gl.uniform1i(this._combineProgram.u_bloom_texture, 1);
-            gl.activeTexture(gl.TEXTURE0);
-            gl.bindTexture(gl.TEXTURE_2D, this._middleTexture);
-            gl.uniform1i(this._combineProgram.u_main_texture, 0);
+        gl.uniform3fv(_lineProgram.uTranslate, uTranslate);
+        gl.bindVertexArray(_lineProgram.vao);
+        gl.drawArrays(gl.LINE_STRIP, 0, this._totalLength);
+        gl.drawBuffers([
+            gl.COLOR_ATTACHMENT0,
+            gl.NONE
+        ]);
+        // blur ping pong
+        gl.useProgram(_blurProgram.program);
+        gl.bindVertexArray(_blurProgram.vao);
+        for (let i = 0; i < _blurRepetition * 2; i++) {
+            gl.bindFramebuffer(gl.FRAMEBUFFER, this._blurFrameBuffers[i % 2]);
+            gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._blurTextures[(i + 1) % 2], 0);
+            gl.bindTexture(gl.TEXTURE_2D, this._blurTextures[i % 2]);
+            gl.uniform1i(_blurProgram.u_texture, 0);
+            gl.uniform1f(_blurProgram.u_horizontal, i % 2 === 0);
             gl.drawArrays(gl.TRIANGLES, 0, 6);
         }
+        // combine  
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        gl.useProgram(this._combineProgram.program);
+        gl.bindVertexArray(this._combineProgram.vao);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, this._blurTextures[1]);
+        gl.uniform1i(this._combineProgram.u_bloom_texture, 1);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, this._middleTexture);
+        gl.uniform1i(this._combineProgram.u_main_texture, 0);
+        gl.drawArrays(gl.TRIANGLES, 0, 6);
         gl.bindVertexArray(null);
         defaultblendfunction(gl);
     }

package/{timetracks → tracks/timetracks}/programpoint-line-strip.js

@@ -1,16 +1,19 @@
-import { createProgram, shaderfunctions } from "../util";
-import { CameraUniformBlockTotem, globeProgramCache } from "../programs";
+import { createProgram } from "../../util/webglobjectbuilders";
+import { pixelXYToCartesian2DPoint, pixelXYToCartesian3DPoint } from "../../util/shaderfunctions";
+import { CameraUniformBlockTotem, globeProgramCache } from "../../programs";
+import { CameraUniformBlockString } from "../../programs/totems/camerauniformblock";
+// layout(std140) uniform GlobeCamera {
+//     mat4 view; // 64 bytes           0
+//     mat4 projection; // 64 bytes     64
+//     vec3 translate; // 12 bytes      128
+//     bool is3D; // 4 bytes            140
+//     vec2 mapWH; // 8 bytes           144
+//     vec2 screenWH; //  8 bytes       152
+//     float z_level; // 4 bytes        160
+// };
 const vertexShader = `#version 300 es
 
-layout(std140) uniform GlobeCamera {
-    mat4 view; // 64 bytes           0
-    mat4 projection; // 64 bytes     64
-    vec3 translate; // 12 bytes      128
-    bool is3D; // 4 bytes            140
-    vec2 mapWH; // 8 bytes           144
-    vec2 screenWH; //  8 bytes       152
-    float z_level; // 4 bytes        160
-};
+${CameraUniformBlockString}
 
 layout(std140) uniform Globals {
     float head_time;
@@ -26,7 +29,7 @@ in float end_time;
 in vec3 end_color;
 out vec4 v_color;
 
-` + shaderfunctions.pixelXYToCartesian3DPoint + shaderfunctions.pixelXYToCartesian2DPoint + `
+` + pixelXYToCartesian3DPoint + pixelXYToCartesian2DPoint + `
 
 void main() {
     if (head_time < start_time || head_time > end_time) { return; }
@@ -56,7 +59,7 @@ void main() {
         outColor.a = 0.0;    
  }
 }`;
-export default class {
+export default class ProgramPointLineStrip {
     constructor(gl, globe, attrBuffer, options) {
         this.gl = gl;
         this._cameraBlockBindingPoint = 0;

package/types.js

@@ -1,3 +1,9 @@
+export var CSRenderPass;
+(function (CSRenderPass) {
+    CSRenderPass[CSRenderPass["NORMAL"] = 0] = "NORMAL";
+    CSRenderPass[CSRenderPass["SELECTED"] = 1] = "SELECTED";
+    CSRenderPass[CSRenderPass["EDITING"] = 2] = "EDITING";
+})(CSRenderPass || (CSRenderPass = {}));
 export var CSMeasureTextPositionTypes;
 (function (CSMeasureTextPositionTypes) {
     CSMeasureTextPositionTypes["CENTER"] = "center";

package/util/account/bufferoffsetmanager.js

@@ -17,7 +17,7 @@
  * READ, most of the time is not needed to be read, unless for defraging.
  * This unpredicatable behavior is not handled by this class.
  */
-export default class {
+export default class BufferOffsetManager {
     constructor(itemSize, { capacity = 10, bufferType = "STATIC_DRAW" } = {}) {
         this.itemSize = itemSize;
         this.bufferType = bufferType;

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

@@ -12,99 +12,13 @@ export class BufferOrchestrator {
     }
     resetWithCapacity(bufferManagersMap, capacity = null) {
         this._capacity = capacity !== null ? capacity : this._capacity;
-        for (const [key, { bufferManager }] of bufferManagersMap) {
+        for (const [, { 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
@@ -135,7 +49,7 @@ export class BufferOrchestrator {
                     }
                 }
                 else {
-                    for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+                    for (const [, { bufferManager, adaptor }] of bufferManagersMap) {
                         bufferManager.insertBulk([adaptor(item)], [o]);
                     }
                 }
@@ -173,7 +87,7 @@ export class BufferOrchestrator {
             }
         }
         else {
-            for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+            for (const [, { bufferManager, adaptor }] of bufferManagersMap) {
                 bufferManager.insertBlock(blockLoad, offsetStart, adaptor, Float32Array);
             }
         }
@@ -201,7 +115,7 @@ export class BufferOrchestrator {
             }
         }
         else {
-            for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+            for (const [, { bufferManager, adaptor }] of bufferManagersMap) {
                 bufferManager.insertBulk(items.map(adaptor), offsets);
             }
         }
@@ -216,7 +130,7 @@ export class BufferOrchestrator {
                 this.tombstoneOffsets.push(offset);
             }
         }
-        for (const [key, { bufferManager }] of bufferManagersMap) {
+        for (const [, { bufferManager }] of bufferManagersMap) {
             bufferManager.deleteBulk(offsets);
         }
     }
@@ -240,7 +154,7 @@ export class BufferOrchestrator {
         if (itemsLength <= this.emptySpace)
             return;
         const newCapacity = this.length + itemsLength;
-        for (const [key, { bufferManager }] of bufferManagersMap) {
+        for (const [, { bufferManager }] of bufferManagersMap) {
             bufferManager.extendBuffer(this.length, newCapacity);
         }
         this._capacity = newCapacity;
@@ -252,14 +166,14 @@ export class BufferOrchestrator {
             for (const key of bufferKeys) {
                 const offset = offsetMap.get(key);
                 if (offset !== undefined) {
-                    for (const [key, { bufferManager }] of bufferManagers) {
+                    for (const [, { bufferManager }] of bufferManagers) {
                         bufferManager.defrag([offset], this.length, newCapacity);
                     }
                 }
             }
         }
         else {
-            for (const [key, { bufferManager }] of bufferManagers) {
+            for (const [, { bufferManager }] of bufferManagers) {
                 bufferManager.defrag(offsetMap.values(), this.length, newCapacity);
             }
         }
@@ -281,7 +195,7 @@ export class BufferOrchestrator {
     _defrag() {
         const newOffsetMap = new Map();
         let newOffset = 0;
-        for (const [key, offset] of this.offsetMap) {
+        for (const [key,] of this.offsetMap) {
             newOffsetMap.set(key, newOffset++);
         }
         this.offsetMap = newOffsetMap;

package/util/gl-util/uniform-block/manager.js

@@ -1,4 +1,3 @@
-import "./types";
 const typeSizes = {
     'float': 4,
     'vec2': 8,

package/util/gl-util/uniform-block/types.js

@@ -1,8 +1 @@
 "use strict";
-/**
- * @typedef {string} UniformBlockName
- *
- * @typedef {string} GLSLType | mat4, mat3, vec4, vec3, vec2, float, int, bool
- * @typedef {{name: string, type: GLSLType, value: null|Float32Array}} UniformBlockMember
- *
- */