@pirireis/webglobeplugins 0.16.4 → 0.17.0

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;

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