@pirireis/webglobeplugins 0.16.7 → 0.17.1

package/range-tools-on-terrain/range-ring/plugin.js

@@ -1,7 +1,7 @@
 import { CircleOnTerrainPlugin } from "../../semiplugins/shape-on-terrain/circle-plugin";
 import { ArcOnTerrainPlugin } from "../../semiplugins/shape-on-terrain/arc-plugin";
 import { Padding1DegreePlugin } from '../../semiplugins/shape-on-terrain/padding-1-degree';
-import { padding1DegreeInputAdapter, rangeRingToArcInputAdapter, rangeRingToCircleInputAdapter, allCircleKeysAdapter, allArcKeysAdapter, createColorRatios } from "./adapters";
+import { padding1DegreeInputAdapter, rangeRingToArcInputAdapter, rangeRingToCircleInputAdapter, allCircleKeysAdapter, allArcKeysAdapter, createColorRatios, } from "./adapters";
 import RangeRingAngleText from "./rangeringangletext";
 import { opacityCheck } from "../../util/check/typecheck";
 export var ENUM_HIDE;
@@ -311,7 +311,7 @@ export class RangeRingPlugin {
         if (this.draw1degrePadding) {
             this.paddingPlugin?.draw3D();
         }
-        for (const [key, writer] of this.textWritersMap) {
+        for (const [, writer] of this.textWritersMap) {
             writer.draw();
         }
     }
@@ -338,7 +338,6 @@ export class RangeRingPlugin {
             console.warn("Globe or WebGL context is not initialized, cannot update text");
             return;
         }
-        const globe = this.globe;
         const textWritersMap = this.textWritersMap;
         let keys = centerIDs ?? this._memory.keys();
         for (const centerID of keys) {
@@ -351,7 +350,7 @@ export class RangeRingPlugin {
             if (rangeRingData.textHide === ENUM_TEXT_HIDE.HIDE) {
                 continue;
             }
-            for (const [key, writer] of textWritersMap) {
+            for (const [, writer] of textWritersMap) {
                 writer.insertText(rangeRingData);
             }
         }
@@ -365,13 +364,12 @@ export class RangeRingPlugin {
             console.warn("Globe or WebGL context is not initialized, cannot delete text");
             return;
         }
-        const globe = this.globe;
         const textWritersMap = this.textWritersMap;
         for (const centerID of centerIDs) {
             const rangeRingData = this._memory.get(centerID);
             if (!rangeRingData)
                 continue;
-            for (const [key, writer] of textWritersMap) {
+            for (const [, writer] of textWritersMap) {
                 writer.deleteText(rangeRingData);
             }
         }

package/semiplugins/lightweight/line-plugin.js

@@ -164,7 +164,6 @@ export class LinePlugin {
         const globe = this.globe;
         const { flatViewOn, globeViewOn, variativeColorsOn, dashedLineOpacityVariativeOn, dashedLineRatioVariativeOn, bufferType = "DYNAMIC_DRAW" } = this._options;
         const m = this.bufferManagersMap;
-        const initialCapacity = this._options.initialCapacity;
         if (flatViewOn) {
             m.set("start_position", {
                 bufferManager: new BufferManager(globe.gl, 2, { bufferType, initialCapacity: this._options.initialCapacity }),

package/semiplugins/shape-on-terrain/arc-plugin.js

@@ -1,7 +1,6 @@
 // import { ArcOnTerrainPluginOptions } from "./type";
 import { LineStripProgramCache } from "../../programs/line-on-globe/linestrip/linestrip";
 import { createBufferAndReadInfo } from "../../util/gl-util/buffer/attribute-loader";
-// import { populateFloat32Array } from "../../util/jshelpers/data-filler";
 import { BufferManager, BufferOrchestrator } from "../../util/account/single-attribute-buffer-management/index";
 import { globe3Dcoordinates, globe2Dcoordinates, RADIAN } from "../../Math/methods";
 import { generateArcPoints, evenlySpacedArcPoints } from "../../Math/arc-cdf-points";
@@ -138,6 +137,15 @@ export class ArcOnTerrainPlugin {
         this.bufferOrchestrator.deleteBulk(keys, this.bufferManagersMap);
         this.globe.DrawRender();
     }
+    deleteAll() {
+        if (!this.bufferOrchestrator || !this.bufferManagersMap || !this.globe) {
+            console.warn("Buffer orchestrator or buffer manager map is not initialized.");
+            return;
+        }
+        this.bufferOrchestrator.resetWithCapacity(this.bufferManagersMap, this._arcMap.size);
+        this._arcMap.clear();
+        this.globe.DrawRender();
+    }
     updateColors(keyColorCouples, drawRender = true) {
         if (this._freed) {
             console.warn("Plugin is freed, cannot update color");
@@ -279,7 +287,6 @@ export class ArcOnTerrainPlugin {
         if (!this.bufferManagersMap?.has(bufferKey[0]))
             return;
         const longLat = [0, 0];
-        const _attractionStrength = 0;
         const longLatArr = new Float32Array(2 * this._options.vertexCount);
         const data = [{
                 key: "staticArcs",

package/semiplugins/shape-on-terrain/circle-plugin.js

@@ -297,7 +297,7 @@ export class CircleOnTerrainPlugin {
             return;
         const wrapper = [null];
         for (const key of subSetIDs) {
-            const [circleInput, circleForAzimuthCalc] = this.circleMap.get(key) || [];
+            const [circleInput,] = this.circleMap.get(key) || [];
             if (circleInput) {
                 wrapper[0] = circleInput;
                 this.bufferOrchestrator.insertBulk(wrapper, this.bufferManagersMap, ["color"]);
@@ -393,7 +393,7 @@ export class CircleOnTerrainPlugin {
                 console.warn(`CircleOnTerrainPlugin: Circle ${key} not found in circleMap.`);
                 continue;
             }
-            const [{ radius, center, height = null, color = null, msl = undefined }, _] = this.circleMap.get(key);
+            const [{ radius, center, height = null, color = null, msl = undefined },] = this.circleMap.get(key);
             const circlePointsLongLat = new Float64Array((CIRCLE_POINTS_COUNT) * 2);
             CircleCDF.globeFindPointByPolarHalfCircle(circlePointsLongLat, globe, center[0], center[1], radius, zeroRotation, templateAngles);
             datas.push({

package/semiplugins/shape-on-terrain/padding-1-degree.js

@@ -513,7 +513,7 @@ function preAdapter(globe, paddingInput, paddingRatio, outerCoords) {
             paddingInput.radius * paddingRatio, // inner radius
             i);
             const longDifference = Math.abs(long - endLong);
-            const latDifference = Math.abs(lat - endLat);
+            // const latDifference = Math.abs(lat - endLat);
             if (longDifference > 45) {
                 outerCoords[i] = null;
                 innerCoords[i] = null;

package/semiplugins/shell/bbox-renderer/index.js

@@ -0,0 +1,2 @@
+import { BBOXGlobeShell } from './object';
+export { BBOXGlobeShell };

package/{programs/globeshell/wiggle → semiplugins/shell/bbox-renderer}/logic.js

@@ -1,23 +1,11 @@
-import { createProgram } from '../../../util';
-export default class Logic {
-    constructor() {
-        this.id = "GlobeShellProgram";
-        this.description = "This program implements flyweight pattern for globe." +
-            "At globes draw3D call stack, this program should be prior to any program that uses it." +
-            "draw3D method of this object only sets Projetion, ModelView and Translate matrices and if the mode is 2D mapWH .";
-    }
-    init(globe, gl) {
-        this.gl = gl;
-        this.globe = globe;
-        this.programWrapper = this._createProgramWrapper();
-        this._transformArray = new Float32Array(3);
-        this.setGeometry();
-        this.resize();
-        this.updateTime(0);
-        this.setMesh({ xRes: 64, yRes: 64, eastWestTied: false });
-    }
-    _createProgramWrapper() {
-        const vertexShader = `#version 300 es
+import { createProgram } from '../../../util/webglobjectbuilders';
+import { noRegisterGlobeProgramCache } from '../../../programs/programcache';
+import { CameraUniformBlockString, CameraUniformBlockTotemCache, CameraUniformBlockTotem } from "../../../programs/totems/camerauniformblock";
+const UniformBlockBindingPoints = {
+    ShellBlock: 0,
+    CameraBlock: 1,
+};
+const vertexShader = `#version 300 es
         #define R 6378.137
         #define PI 3.1415926535897932384626433832795
         #define POLE 20037508.34
@@ -35,14 +23,7 @@ export default class Logic {
             float u_opacity;
         };
 
-        uniform mat4 u_model_view_matrix;
-        uniform mat4 u_projection_matrix;
-        uniform vec3 u_translate;
-
-        uniform vec2 u_mapWH;
-        uniform vec2 u_scrWH;
-
-        uniform bool u_is3D; 
+        ${CameraUniformBlockString}
 
         out float v_opacity;
         out vec2 v_texture_coordinate;
@@ -72,8 +53,8 @@ export default class Logic {
             float mercX = x * POLE_BY_PI;
             float mercY = log(tan(HALF_PI - y / 2.0 )) * POLE_BY_PI;
 
-            float normX = ( mercX - u_translate.x ) / u_mapWH.x;
-            float normY = ( mercY - u_translate.y ) / u_mapWH.y;
+            float normX = ( mercX - translate.x ) / mapWH.x;
+            float normY = ( mercY - translate.y ) / mapWH.y;
             return vec2(normX, normY);
         }       
 
@@ -89,16 +70,16 @@ export default class Logic {
 
         void main() {
             vec2 texCoord = f_texCoord();
-            if (u_is3D){
+            if (is3D){
                 vec3 unit_sphere_pos = f_onSphere(texCoord);
                 float wiggle = f_wiggle(texCoord);
                 vec3 position = f_position(unit_sphere_pos, wiggle);
-                gl_Position = u_projection_matrix * u_model_view_matrix * vec4(position  - u_translate, 1.0);
+                gl_Position = projection * view * vec4(position  - translate, 1.0);
             }  else {
                 vec2 position = f_onFlat(texCoord);
-                gl_Position = u_projection_matrix * vec4(
-                    position.x * u_scrWH.x,
-                    (1.0 - position.y) * u_scrWH.y,
+                gl_Position = projection * vec4(
+                    position.x * screenWH.x,
+                    (1.0 - position.y) * screenWH.y,
                     0.0,
                     1.0);
             }
@@ -106,7 +87,7 @@ export default class Logic {
             v_opacity = u_opacity;
         }
         `;
-        const fragmentShader = `#version 300 es
+const fragmentShader = `#version 300 es
         precision lowp float;
         in vec2 v_texture_coordinate;
         in float v_opacity;
@@ -118,22 +99,33 @@ export default class Logic {
            outColor = texture(u_texture, v_texture_coordinate);
            outColor.a *= v_opacity;
         }`;
+class BBOXGlobeShellProgram {
+    constructor(globe) {
+        this.id = "BBOXGlobeShellProgram";
+        this.description = "This program implements flyweight pattern for globe." +
+            "At globes draw3D call stack, this program should be prior to any program that uses it." +
+            "draw3D method of this object only sets Projetion, ModelView and Translate matrices and if the mode is 2D mapWH .";
+        this.gl = globe.gl;
+        this.globe = globe;
+        this.programWrapper = this._createProgramWrapper();
+        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+        this.cameraBlockTotem.assignBindingPoint(this.programWrapper.program, UniformBlockBindingPoints.CameraBlock);
+        this._transformArray = new Float32Array(3);
+        // this.setGeometry();
+        // this.resize();
+        this.updateTime(0);
+        this.setMesh({ xRes: 64, yRes: 64, eastWestTied: false });
+    }
+    _createProgramWrapper() {
         const gl = this.gl;
         const program = createProgram(gl, vertexShader, fragmentShader);
         const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(program);
-        this.shellBlockBindingPoint = 0;
         const shellBlockIndex = gl.getUniformBlockIndex(program, "ShellBlock");
-        gl.uniformBlockBinding(program, shellBlockIndex, this.shellBlockBindingPoint);
+        gl.uniformBlockBinding(program, shellBlockIndex, UniformBlockBindingPoints.ShellBlock);
         gl.useProgram(currentProgram);
         return {
             program,
-            u_model_view_matrix: gl.getUniformLocation(program, "u_model_view_matrix"),
-            u_projection_matrix: gl.getUniformLocation(program, "u_projection_matrix"),
-            u_translate: gl.getUniformLocation(program, "u_translate"),
-            u_is3D: gl.getUniformLocation(program, "u_is3D"),
-            u_scrWH: gl.getUniformLocation(program, "u_scrWH"),
-            u_mapWH: gl.getUniformLocation(program, "u_mapWH"),
             u_texture: gl.getUniformLocation(program, "u_texture"),
             u_mesh_resolution: gl.getUniformLocation(program, "u_mesh_resolution"),
         };
@@ -149,62 +141,58 @@ export default class Logic {
         gl.uniform1f(this.programWrapper.u_time, time);
         gl.useProgram(currentProgram);
     }
-    setRotationAndTranslation(uProjectionMatrix, uModelViewMatrix, uTranslate, resetCurrentProgram = false) {
-        const gl = this.gl;
-        let currentProgram = null;
-        if (resetCurrentProgram) {
-            currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        }
-        ;
-        gl.useProgram(this.programWrapper.program);
-        gl.uniformMatrix4fv(this.programWrapper.u_projection_matrix, false, uProjectionMatrix);
-        gl.uniformMatrix4fv(this.programWrapper.u_model_view_matrix, false, uModelViewMatrix);
-        this._transformArray.set([uTranslate.x, uTranslate.y, uTranslate.z], 0);
-        gl.uniform3fv(this.programWrapper.u_translate, this._transformArray);
-        if (resetCurrentProgram)
-            gl.useProgram(currentProgram);
-    }
-    setGeometry() {
-        const { globe, gl } = this;
-        const { u_is3D, u_scrWH, program } = this.programWrapper;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        const is3D = this.globe.api_GetCurrentGeometry() === 0;
-        gl.useProgram(program);
-        if (globe.api_GetCurrentGeometry() === globe.api_GeometryTypes().FLAT) {
-            gl.uniform2f(u_scrWH, globe.api_ScrW(), globe.api_ScrH());
-        }
-        gl.uniform1i(u_is3D, is3D);
-        gl.useProgram(currentProgram);
-    }
-    resize() {
-        const { gl, globe } = this;
-        if (!globe)
-            return;
-        const { program, u_scrWH } = this.programWrapper;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        gl.useProgram(program);
-        if (globe.api_GetCurrentGeometry() === globe.api_GeometryTypes().FLAT) {
-            gl.uniform2f(u_scrWH, globe.api_ScrW(), globe.api_ScrH());
-        }
-        gl.useProgram(currentProgram);
-    }
-    // only sets data does not draw
-    draw3D(uProjectionMatrix, uModelViewMatrix, uTranslate) {
-        const { gl, globe } = this;
-        const { program, u_model_view_matrix, u_projection_matrix, u_translate } = this.programWrapper;
-        gl.disable(gl.DEPTH_TEST);
-        gl.useProgram(program);
-        gl.uniformMatrix4fv(u_projection_matrix, false, uProjectionMatrix);
-        gl.uniformMatrix4fv(u_model_view_matrix, false, uModelViewMatrix);
-        // this._transformArray.set([], 0);
-        gl.uniform3f(u_translate, uTranslate.x, uTranslate.y, uTranslate.z);
-        if (globe.api_GetCurrentGeometry() === 1) {
-            const { width, height } = globe.api_GetCurrentWorldWH();
-            gl.uniform2fv(this.programWrapper.u_mapWH, [width, height]);
-        }
-        gl.enable(gl.DEPTH_TEST);
-    }
-    draw(texture, shellBlockDataManager, drawLines = false) {
+    // setRotationAndTranslation(uProjectionMatrix, uModelViewMatrix, uTranslate, resetCurrentProgram = false) {
+    //     const gl = this.gl;
+    //     let currentProgram = null;
+    //     if (resetCurrentProgram) { currentProgram = gl.getParameter(gl.CURRENT_PROGRAM) };
+    //     gl.useProgram(this.programWrapper.program);
+    //     gl.uniformMatrix4fv(this.programWrapper.projection, false, uProjectionMatrix);
+    //     gl.uniformMatrix4fv(this.programWrapper.view, false, uModelViewMatrix);
+    //     this._transformArray.set([uTranslate.x, uTranslate.y, uTranslate.z], 0);
+    //     gl.uniform3fv(this.programWrapper.translate, this._transformArray);
+    //     if (resetCurrentProgram) gl.useProgram(currentProgram);
+    // }
+    // setGeometry() {
+    //     const { globe, gl } = this;
+    //     const { is3D, screenWH, program } = this.programWrapper;
+    //     const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+    //     const is3D = this.globe.api_GetCurrentGeometry() === 0;
+    //     gl.useProgram(program);
+    //     if (globe.api_GetCurrentGeometry() === globe.api_GeometryTypes().FLAT) {
+    //         gl.uniform2f(screenWH, globe.api_ScrW(), globe.api_ScrH());
+    //     }
+    //     gl.uniform1i(is3D, is3D);
+    //     gl.useProgram(currentProgram);
+    // }
+    // resize() {
+    //     const { gl, globe } = this;
+    //     if (!globe) return;
+    //     const { program, screenWH } = this.programWrapper;
+    //     const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+    //     gl.useProgram(program);
+    //     if (globe.api_GetCurrentGeometry() === globe.api_GeometryTypes().FLAT) {
+    //         gl.uniform2f(screenWH, globe.api_ScrW(), globe.api_ScrH());
+    //     }
+    //     gl.useProgram(currentProgram);
+    // }
+    // only sets
+    //  data does not draw
+    // draw3D(csRenderPass) {
+    //     const { gl, globe } = this;
+    //     const { program } = this.programWrapper; //view, projection, translate
+    //     gl.disable(gl.DEPTH_TEST);
+    //     gl.useProgram(program);
+    //     // gl.uniformMatrix4fv(projection, false, uProjectionMatrix);
+    //     // gl.uniformMatrix4fv(view, false, uModelViewMatrix);
+    //     // // this._transformArray.set([], 0);
+    //     // gl.uniform3f(translate, uTranslate.x, uTranslate.y, uTranslate.z);
+    //     if (globe.api_GetCurrentGeometry() === 1) {
+    //         const { width, height } = globe.api_GetCurrentWorldWH();
+    //         gl.uniform2fv(this.programWrapper.mapWH, [width, height]);
+    //     }
+    //     gl.enable(gl.DEPTH_TEST);
+    // }
+    draw(texture, shellBlockDataManager, drawLines = false, csRenderPass) {
         const { gl, programWrapper, _vao, _drawCount } = this;
         const { program, u_texture } = programWrapper;
         gl.useProgram(program);
@@ -213,15 +201,18 @@ export default class Logic {
         gl.bindTexture(gl.TEXTURE_2D, texture);
         gl.uniform1i(u_texture, 0);
         shellBlockDataManager.bind();
+        this.cameraBlockTotem.bind(UniformBlockBindingPoints.CameraBlock);
         if (drawLines)
             gl.drawElements(gl.LINES, _drawCount, gl.UNSIGNED_SHORT, 0);
         gl.clearColor(0, 0, 0, 0);
         gl.drawElements(gl.TRIANGLES, _drawCount, gl.UNSIGNED_SHORT, 0);
         shellBlockDataManager.unbind();
+        this.cameraBlockTotem.unbind(UniformBlockBindingPoints.CameraBlock);
         gl.bindVertexArray(null);
     }
     free() {
         const { gl, programWrapper, _vao, _indexBuffer } = this;
+        CameraUniformBlockTotemCache.release(this.globe);
         gl.deleteBuffer(_indexBuffer);
         gl.deleteVertexArray(_vao);
         gl.deleteProgram(programWrapper.program);
@@ -329,7 +320,7 @@ class ShellBlockManager {
     }
     bind() {
         const { gl, buffer } = this;
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.shellBlockBindingPoint, buffer);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, UniformBlockBindingPoints.ShellBlock, buffer);
     }
     free() {
         const { gl, buffer } = this;
@@ -337,6 +328,14 @@ class ShellBlockManager {
     }
     unbind() {
         const { gl } = this;
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.shellBlockBindingPoint, null);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, UniformBlockBindingPoints.ShellBlock, null);
     }
 }
+export const BBOXGlobeShellProgramCache = Object.freeze({
+    get: function (globe) {
+        return noRegisterGlobeProgramCache.getProgram(globe, BBOXGlobeShellProgram);
+    },
+    release: function (globe) {
+        noRegisterGlobeProgramCache.releaseProgram(globe, BBOXGlobeShellProgram);
+    }
+});

package/{programs/globeshell/wiggle → semiplugins/shell/bbox-renderer}/object.js

@@ -1,12 +1,11 @@
-import { globeProgramCache } from '../../programcache';
-import GlobeShellProgram from './logic';
-export default class GlobeShell {
+import { BBOXGlobeShellProgramCache } from './logic';
+export class BBOXGlobeShell {
     constructor(gl, globe, { minLon = -180, maxLon = 180, minLat = -90, maxLat = 90, height = 0, u_opacity = 1, wiggleInKM = 0, wiggleSpeed = 0,
     // eastWestTied, Not implemented yet
      } = {}) {
         this.gl = gl;
         this.globe = globe;
-        this.program = globeProgramCache.getProgram(globe, GlobeShellProgram);
+        this.program = BBOXGlobeShellProgramCache.get(globe);
         this.shellBlockManager = this.program.getShellBlockBufferManager();
         this.update = this.shellBlockManager.update.bind(this.shellBlockManager);
         this.innerTime = 0;
@@ -51,8 +50,8 @@ export default class GlobeShell {
      *
      * @param {*} program  modelView, projection, translate, mapWH, scrWH, should be set before calling this function
      */
-    draw() {
-        this.program.draw(this.texture, this.shellBlockManager);
+    draw(csRenderPass) {
+        this.program.draw(this.texture, this.shellBlockManager, csRenderPass);
         if (this.wiggleInKM > 0 && this.wiggleSpeed > 0) {
             this.innerTime += this.wiggleSpeed;
             this.shellBlockManager.update({ innerTime: this.innerTime });
@@ -60,7 +59,7 @@ export default class GlobeShell {
         }
     }
     free() {
-        globeProgramCache.releaseProgram(this.globe, GlobeShellProgram);
+        BBOXGlobeShellProgramCache.release(this.globe);
         this.shellBlockManager.free();
     }
 }

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;