@pirireis/webglobeplugins 0.17.1 → 1.0.3

package/semiplugins/shape-on-terrain/terrain-polygon/data/worker.js

@@ -0,0 +1,125 @@
+/// <reference lib="webworker" />
+import { Cache } from "./cache";
+import { partialTessellation, zoomLevelShowThreshold } from "../../../../Math/tessellation/triangle-tessellation";
+import { IndexAttributeEscapeValue } from "../../../../programs/polygon-on-globe/texture-dem-triangles";
+const cache = new Cache(100); // 100 km threshold
+let _pickableState = false;
+let _variativeColorsOnState = false;
+let showThreshold = 0;
+// eslint-disable-next-line no-restricted-globals
+self.onmessage = (event) => {
+    try {
+        const { bboxes, insertDeleteQueue, pickableState, variativeColorsOn } = event.data;
+        if (variativeColorsOn !== undefined) {
+            _variativeColorsOnState = variativeColorsOn;
+        }
+        if (pickableState !== undefined) {
+            _pickableState = pickableState;
+        }
+        // Process insert/delete queue
+        if (insertDeleteQueue[0] === "__CLEAR_ALL_ITEMS__") {
+            insertDeleteQueue.shift();
+            cache.clear();
+        }
+        for (const item of insertDeleteQueue) {
+            if (typeof item === 'string') {
+                cache.remove(item);
+            }
+            else {
+                cache.insert(item.key, item);
+            }
+        }
+        // Update bboxes if provided
+        if (bboxes) {
+            cache.setBBOXes(bboxes);
+            showThreshold = zoomLevelShowThreshold(bboxes[0].zoom, 0.03);
+        }
+        // Search for triangles in view
+        const trianglesInView = cache.search();
+        // Prepare arrays for merging
+        const results = [];
+        // Convert bbox to BBoxZoom format for partialTessellation
+        const bboxZooms = bboxes ? bboxes.map(b => ({
+            bbox: {
+                min: [b.minX, b.minY],
+                max: [b.maxX, b.maxY]
+            },
+            zoom: b.zoom
+        })) : []; // This will be empty if no bbox, causing issues
+        let counter = 0;
+        let indexCounter = 0;
+        // Process each triangle
+        for (const triangle of trianglesInView) {
+            if (triangle.tessellationMeta.showThreshold * 0.075 > showThreshold) {
+                continue;
+            }
+            const result = (triangle.tessellationMeta.showThreshold < showThreshold) ? partialTessellation(triangle.tessellationMeta, bboxZooms, 5 // innerCuts parameter
+            ) : triangle.tessellationMeta.shortCut;
+            counter += result.vec3s.length;
+            indexCounter += result.indices.length;
+            if (_pickableState) {
+                // TODO: find a better way to fill indeces to final array
+                result.pickIndex = triangle.polygon.index;
+            }
+            if (_variativeColorsOnState) {
+                const color = triangle.polygon.color || [IndexAttributeEscapeValue, IndexAttributeEscapeValue, IndexAttributeEscapeValue, IndexAttributeEscapeValue];
+                result.variativeColors = color;
+                // Update offset for next triangle
+            }
+            results.push(result);
+        }
+        // Send results back
+        const output = {
+            vec3s: new Float32Array(counter),
+            longLats: new Float32Array(counter / 3 * 2),
+            indices: new Uint32Array(indexCounter),
+        };
+        if (_pickableState) {
+            output.pickIndices = new Float32Array(counter / 3);
+        }
+        if (_variativeColorsOnState) {
+            output.variativeColors = new Float32Array(counter / 3 * 4);
+        }
+        let currentVertexOffset = 0;
+        let indexOffset = 0;
+        for (const result of results) {
+            output.vec3s.set(result.vec3s, currentVertexOffset);
+            output.longLats.set(result.longLats, (currentVertexOffset / 3) * 2);
+            output.indices.set(result.indices.map(i => i + currentVertexOffset / 3), indexOffset);
+            currentVertexOffset += result.vec3s.length;
+            indexOffset += result.indices.length;
+            if (_pickableState) {
+                const subArray = output.pickIndices.subarray(currentVertexOffset / 3 - result.vec3s.length / 3, currentVertexOffset / 3);
+                subArray.fill(result.pickIndex);
+            }
+            if (_variativeColorsOnState && result.variativeColors) {
+                const vertexCount = result.vec3s.length / 3;
+                const colorStartIndex = (currentVertexOffset / 3 - vertexCount) * 4;
+                for (let i = 0; i < vertexCount; i++) {
+                    const offset = colorStartIndex + i * 4;
+                    output.variativeColors[offset] = result.variativeColors[0];
+                    output.variativeColors[offset + 1] = result.variativeColors[1];
+                    output.variativeColors[offset + 2] = result.variativeColors[2];
+                    output.variativeColors[offset + 3] = result.variativeColors[3];
+                }
+            }
+        }
+        const buffers = [
+            output.vec3s.buffer,
+            output.indices.buffer,
+            output.longLats.buffer,
+        ];
+        if (pickableState && output.pickIndices) {
+            buffers.push(output.pickIndices.buffer);
+        }
+        if (_variativeColorsOnState && output.variativeColors) {
+            buffers.push(output.variativeColors.buffer);
+        }
+        // eslint-disable-next-line no-restricted-globals
+        self.postMessage(output, buffers);
+    }
+    catch (error) {
+        console.error('Error in worker:', error);
+        // self.postMessage({ error: error.message || 'Unknown error in worker' });
+    }
+};

package/semiplugins/shape-on-terrain/terrain-polygon/terrain-polygon.js

@@ -0,0 +1,219 @@
+import { WorkerContact } from "./data/worker-contact";
+import { TextureDemTriangles } from "../../../programs/polygon-on-globe/texture-dem-triangles";
+import { noRegisterGlobeProgramCache } from "../../../programs/programcache";
+import { PickerDisplayer } from "../../../util/picking/picker-displayer";
+import { IndexPolygonMap } from "./data/index-polygon-map";
+export class TerrainPolygonSemiPlugin {
+    id;
+    globe = null;
+    _options = {
+        pickable: false,
+        variativeColorsOn: false,
+        defaultColor: [0.5, 0.5, 1, 1],
+        pickedColor: [1, 0, 0, 1],
+        opacity: 1.0,
+        showTesselationPoints: false,
+    };
+    _workerContact = null;
+    _program = null;
+    _pickerDisplayer = null;
+    _indexPolygonMap = new IndexPolygonMap();
+    _lastPickedPolygon = null;
+    _elementArrayBuffer = null;
+    _vec3Buffer = null;
+    _pickIndexBuffer = null;
+    _variativeColorBuffer = null;
+    _mercatorXYBuffer = null;
+    _vao = null;
+    _uboHandler = null;
+    _drawPointsRangeIndexParams = {
+        drawRange: {
+            first: 0,
+            count: 0,
+        },
+        drawMode: WebGL2RenderingContext.POINTS,
+        elementBufferIndexType: WebGL2RenderingContext.UNSIGNED_INT,
+        elementBuffer: WebGLBuffer = null,
+    };
+    _drawRangeIndexParams = {
+        drawRange: {
+            first: 0,
+            count: 0,
+        },
+        drawMode: WebGL2RenderingContext.TRIANGLES,
+        elementBufferIndexType: WebGL2RenderingContext.UNSIGNED_INT,
+        elementBuffer: WebGLBuffer = null,
+    };
+    constructor(id, options = {}) {
+        this.id = id;
+        this._options = { ...this._options, ...options };
+    }
+    ;
+    init(globe, gl) {
+        this.globe = globe;
+        this._drawRangeIndexParams.drawMode = globe.gl.TRIANGLES;
+        this._drawRangeIndexParams.elementBufferIndexType = globe.gl.UNSIGNED_INT;
+        this._program = noRegisterGlobeProgramCache.getProgram(this.globe, TextureDemTriangles);
+        this._elementArrayBuffer = gl.createBuffer();
+        this._vec3Buffer = gl.createBuffer();
+        this._mercatorXYBuffer = gl.createBuffer();
+        this._uboHandler = this._program.createUBO();
+        this._uboHandler.updateSingle("opacity", new Float32Array([this._options.opacity]));
+        this._uboHandler.updateSingle("defaultColor", new Float32Array(this._options.defaultColor));
+        if (this._options.pickable) {
+            this._pickIndexBuffer = gl.createBuffer();
+            this._pickerDisplayer = new PickerDisplayer(this.globe, "R32I");
+            this._uboHandler.updateSingle("private_isPickedOn", new Float32Array([1.0]));
+            this._uboHandler.updateSingle("pickedColor", new Float32Array(this._options.pickedColor));
+        }
+        if (this._options.variativeColorsOn) {
+            this._variativeColorBuffer = gl.createBuffer();
+        }
+        this._vao = this._program.createVAO({
+            offset: 0,
+            stride: 0,
+            buffer: this._vec3Buffer
+        }, {
+            offset: 0,
+            stride: 0,
+            buffer: this._mercatorXYBuffer
+        }, this._options.pickable ? {
+            offset: 0,
+            stride: 0,
+            buffer: this._pickIndexBuffer
+        } : undefined, this._options.variativeColorsOn ? {
+            offset: 0,
+            stride: 0,
+            buffer: this._variativeColorBuffer
+        } : undefined);
+        this._drawRangeIndexParams.elementBuffer = this._elementArrayBuffer;
+        this._workerContact = new WorkerContact(this.globe, this._options, (result) => {
+            // console.log('TerrainPolygonSemiPlugin received data from worker', result);
+            this.setBuffers(result);
+        });
+        this._drawRangeIndexParams.elementBuffer = this._elementArrayBuffer;
+        this._drawPointsRangeIndexParams.elementBuffer = this._elementArrayBuffer;
+    }
+    insertBulk(polygons) {
+        // if (this._indexPolygonMap) {
+        polygons = this._indexPolygonMap.insertBulk(polygons);
+        // }
+        this._workerContact.insertBulk(polygons);
+    }
+    deleteBulk(keys) {
+        this._workerContact.deleteBulk(keys);
+        this._indexPolygonMap.deleteBulk(keys);
+    }
+    setUniform(name, value) {
+        // check options have the key name
+        if (name.startsWith("private_")) {
+            throw new Error(`Cannot set private uniform ${name}`);
+        }
+        if (this._options.hasOwnProperty(name)) {
+            if (this._options[name] === value) {
+                return;
+            }
+            this._options[name] = value;
+        }
+        this._uboHandler.updateSingle(name, value);
+        this.globe.DrawRender();
+    }
+    setOpacity(opacity) {
+        if (this._options.opacity !== opacity) {
+            this._options.opacity = opacity;
+            this._uboHandler.updateSingle("opacity", new Float32Array([opacity]));
+            this.globe.DrawRender();
+        }
+    }
+    setBuffers(data) {
+        console.log("TerrainPolygonSemiPlugin updating buffers", data.indices.length / 3, "triangles");
+        const gl = this.globe.gl;
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._elementArrayBuffer);
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data.indices, gl.STREAM_DRAW);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._vec3Buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, data.vec3s, gl.STREAM_DRAW);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._mercatorXYBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, data.longLats, gl.STREAM_DRAW);
+        if (this._options.pickable) {
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._pickIndexBuffer);
+            gl.bufferData(gl.ARRAY_BUFFER, data.pickIndices, gl.STREAM_DRAW);
+        }
+        if (this._options.variativeColorsOn) {
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._variativeColorBuffer);
+            gl.bufferData(gl.ARRAY_BUFFER, data.variativeColors, gl.STREAM_DRAW);
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this._drawRangeIndexParams.drawRange.count = data.indices.length;
+        this._drawPointsRangeIndexParams.drawRange.count = data.indices.length;
+        this.globe.DrawRender();
+    }
+    getPickedPolygon() {
+        if (this._options.pickable === false) {
+            throw new Error("TerrainPolygonSemiPlugin is not pickable. Set pickable option to true on construction to enable picking.");
+        }
+        return this._lastPickedPolygon;
+    }
+    _selfSelect() {
+        const { globe, _pickerDisplayer } = this;
+        const pos = globe.api_GetMousePos();
+        const x = pos.canvasX;
+        const y = globe.api_ScrH() - pos.canvasY;
+        _pickerDisplayer.pickXY(x, y, 0, (selectedIDsSet) => {
+            if (selectedIDsSet.size > 0) {
+                const selectedID = Array.from(selectedIDsSet)[0];
+                const newPolygon = this._indexPolygonMap.get(selectedID) || null;
+                if (newPolygon !== this._lastPickedPolygon) {
+                    this._lastPickedPolygon = newPolygon;
+                    globe.DrawRender();
+                    this._uboHandler.updateSingle("private_pickedIndex", new Float32Array([selectedID]));
+                }
+            }
+            else {
+                if (this._lastPickedPolygon !== null) {
+                    this._lastPickedPolygon = null;
+                    globe.DrawRender();
+                    this._uboHandler.updateSingle("private_pickedIndex", new Float32Array([-1]));
+                }
+            }
+        });
+    }
+    clear() {
+        this._workerContact.clear();
+        this._indexPolygonMap.clear();
+    }
+    // GLOBE API INTERACTION METHODS
+    resize() {
+        if (this._options.pickable) {
+            this._pickerDisplayer?.resize();
+        }
+    }
+    draw3D() {
+        const gl = this.globe.gl;
+        gl.disable(gl.DEPTH_TEST);
+        // drawPoints 
+        if (this._options.showTesselationPoints) {
+            this._program.draw(this._vao, this._drawPointsRangeIndexParams, this._uboHandler);
+        }
+        if (this._pickerDisplayer) {
+            this._pickerDisplayer.bindFBO();
+            this._pickerDisplayer.clearTextures();
+            // gl.enable(gl.DEPTH_TEST);
+        }
+        else {
+            // gl.disable(gl.DEPTH_TEST);
+        }
+        gl.frontFace(gl.CW);
+        this._program.draw(this._vao, this._drawRangeIndexParams, this._uboHandler);
+        gl.frontFace(gl.CCW);
+        if (this._pickerDisplayer) {
+            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+            this._pickerDisplayer.drawColorTexture();
+            this._selfSelect();
+        }
+        gl.enable(gl.DEPTH_TEST);
+    }
+    free() {
+        this._workerContact.free();
+        noRegisterGlobeProgramCache.releaseProgram(this.globe, TextureDemTriangles);
+    }
+}

package/semiplugins/shape-on-terrain/terrain-polygon/types.js

@@ -0,0 +1,8 @@
+/**
+ * @module WebGLobePlugins/SemiPlugins/ShapeOnTerrain/TerrainPolygon
+ * @description
+ * Type definitions for TerrainPolygon plugin
+ * /
+ *
+ */
+export {};

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

@@ -1,6 +1,6 @@
 import { createProgram } from '../../../util/webglobjectbuilders';
 import { noRegisterGlobeProgramCache } from '../../../programs/programcache';
-import { CameraUniformBlockString, CameraUniformBlockTotemCache, CameraUniformBlockTotem } from "../../../programs/totems/camerauniformblock";
+import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../../../programs/totems/camerauniformblock";
 const UniformBlockBindingPoints = {
     ShellBlock: 0,
     CameraBlock: 1,
@@ -99,9 +99,20 @@ const fragmentShader = `#version 300 es
            outColor = texture(u_texture, v_texture_coordinate);
            outColor.a *= v_opacity;
         }`;
-class BBOXGlobeShellProgram {
+export class BBOXGlobeShellProgram {
+    id = "BBOXGlobeShellProgram";
+    description;
+    gl;
+    globe;
+    programWrapper;
+    cameraBlockTotem;
+    _transformArray;
+    _xRes;
+    _yRes;
+    _vao;
+    _indexBuffer;
+    _drawCount;
     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 .";
@@ -111,8 +122,6 @@ class BBOXGlobeShellProgram {
         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 });
     }
@@ -128,9 +137,9 @@ class BBOXGlobeShellProgram {
             program,
             u_texture: gl.getUniformLocation(program, "u_texture"),
             u_mesh_resolution: gl.getUniformLocation(program, "u_mesh_resolution"),
+            u_time: gl.getUniformLocation(program, "u_time")
         };
     }
-    // this method implements data part of flyweight pattern
     getShellBlockBufferManager() {
         return new ShellBlockManager(this.gl);
     }
@@ -141,57 +150,6 @@ class BBOXGlobeShellProgram {
         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.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;
@@ -277,7 +235,9 @@ class BBOXGlobeShellProgram {
         return { _vao };
     }
 }
-class ShellBlockManager {
+export class ShellBlockManager {
+    gl;
+    buffer;
     constructor(gl) {
         this.gl = gl;
         this.buffer = gl.createBuffer();

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

@@ -1,14 +1,24 @@
 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
-     } = {}) {
+    gl;
+    globe;
+    program;
+    shellBlockManager;
+    update;
+    innerTime;
+    texture;
+    bbox;
+    wiggleInKM;
+    wiggleSpeed;
+    constructor(gl, globe, { minLon = -180, maxLon = 180, minLat = -90, maxLat = 90, height = 0, u_opacity = 1, wiggleInKM = 0, wiggleSpeed = 0, } = {}) {
         this.gl = gl;
         this.globe = globe;
         this.program = BBOXGlobeShellProgramCache.get(globe);
         this.shellBlockManager = this.program.getShellBlockBufferManager();
         this.update = this.shellBlockManager.update.bind(this.shellBlockManager);
         this.innerTime = 0;
+        this.wiggleInKM = wiggleInKM;
+        this.wiggleSpeed = wiggleSpeed;
         this.setBBox({ minLon, maxLon, minLat, maxLat });
         this.setOpacity(u_opacity);
         this.setHeight(height);
@@ -34,9 +44,10 @@ export class BBOXGlobeShell {
         // y
         const vertOffset = (90 - maxLat) * Math.PI / 180;
         const vertSize = (maxLat - minLat) * Math.PI / 180;
-        const offset_rad = new Float32Array([horOffset, vertOffset]);
-        const size_rad = new Float32Array([horSize, vertSize]);
-        this.shellBlockManager.update({ gridSizeRad: size_rad, gridOffsetRad: offset_rad });
+        this.shellBlockManager.update({
+            gridSizeRad: [horSize, vertSize],
+            gridOffsetRad: [horOffset, vertOffset]
+        });
         this.globe.DrawRender();
     }
     setWiggle({ wiggleSpeed = null, wiggleInKM = null }) {
@@ -47,11 +58,10 @@ export class BBOXGlobeShell {
         this.shellBlockManager.update({ wiggleInKM });
     }
     /**
-     *
-     * @param {*} program  modelView, projection, translate, mapWH, scrWH, should be set before calling this function
+     * @param csRenderPass - modelView, projection, translate, mapWH, scrWH, should be set before calling this function
      */
     draw(csRenderPass) {
-        this.program.draw(this.texture, this.shellBlockManager, csRenderPass);
+        this.program.draw(this.texture, this.shellBlockManager, false, csRenderPass);
         if (this.wiggleInKM > 0 && this.wiggleSpeed > 0) {
             this.innerTime += this.wiggleSpeed;
             this.shellBlockManager.update({ innerTime: this.innerTime });

package/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 { defaultblendfunction } from "../../util/globe-default-gl-states";
 class PointHeatmapFlow {
     constructor(globe) {
         this.globe = null;

package/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 { defaultblendfunction } from "../../util/webglobe/gldefaultstates";
+import { defaultblendfunction } from "../../util/globe-default-gl-states";
 import { wgs84ToCartesian3d, wgs84ToMercator } from "../../Math/methods";
 const _0vec3 = /* @__PURE__ */ [0, 0, 0];
 /**
@@ -66,8 +66,14 @@ class PointTracksPlugin {
                     adaptor: (item) => new Float32Array(wgs84ToMercator(item.long, item.lat))
                 }],
             ["rgba", {
-                    bufferManager: new BufferManager(gl, 4, { bufferType, initialCapacity }),
-                    adaptor: (item) => item.rgba
+                    bufferManager: new BufferManager(gl, 4, { bufferType, initialCapacity, typedArrayConstructor: Float32Array }),
+                    // adaptor: (item) => new Uint8Array([
+                    //     item.rgba[0] * 255,
+                    //     item.rgba[1] * 255,
+                    //     item.rgba[2] * 255,
+                    //     item.rgba[3] * 255
+                    // ])
+                    adaptor: (item) => new Float32Array(item.rgba)
                 }],
             ["objectStore", {
                     bufferManager: new ObjectStore({ initialCapacity }),
@@ -196,12 +202,13 @@ class PointTracksPlugin {
     focusTracks(trackIDs = null) {
         if (!this.globe)
             return;
-        if (!trackIDs) {
+        if (trackIDs === null) {
             this._focusParams.on = false;
             this.globe?.DrawRender();
             return;
         }
-        this._focusParams.on = this._fillElementBuffer(trackIDs);
+        this._focusParams.on = true;
+        this._fillElementBuffer(trackIDs);
         if (!this._focusParams.on) {
             this._turnOffFocus();
         }
@@ -218,7 +225,7 @@ class PointTracksPlugin {
         _bufferOrchestrator.updateBulk(points.map((pointID) => {
             return {
                 key: keyMethod(trackID, pointID),
-                rgba: new Float32Array(rgba)
+                rgba: rgba
             };
         }), _bufferManagersMap, ["rgba"]);
         this._refillFocus();

package/tracks/timetracks/program-line-strip.js

@@ -3,7 +3,7 @@
  */
 // import { createProgram, defaultblendfunction, shaderfunctions } from "../../util";
 import { createProgram } from "../../util/webglobjectbuilders";
-import { defaultblendfunction } from "../../util/webglobe/gldefaultstates";
+import { defaultblendfunction } from "../../util/globe-default-gl-states";
 import { pixelXYToCartesian2DPoint, pixelXYToCartesian3DPoint, } from "../../util/shaderfunctions";
 export default class TrackGlowLineProgram {
     /**

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

@@ -21,13 +21,15 @@ export class BufferManager {
     buffer;
     itemSize;
     bufferType;
+    typedArrayConstructor;
     isFreed = false;
-    constructor(gl, itemSize, { bufferType = "STATIC_DRAW", buffer = null, initialCapacity = 10 } = {}) {
+    constructor(gl, itemSize, { bufferType = "STATIC_DRAW", buffer = null, initialCapacity = 10, typedArrayConstructor = Float32Array } = {}) {
         this.gl = gl;
         this.itemSize = itemSize;
         this.bufferType = bufferType;
         this.buffer = buffer === null ? gl.createBuffer() : buffer;
         this.resetWithCapacity(initialCapacity);
+        this.typedArrayConstructor = typedArrayConstructor;
     }
     resetWithCapacity(capacity) {
         const { gl, buffer, bufferType, itemSize } = this;
@@ -60,8 +62,8 @@ export class BufferManager {
         }
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
     }
-    insertBlock(items, offset, adapter, Constructor = Float32Array) {
-        const { gl, buffer, itemSize } = this;
+    insertBlock(items, offset, adapter) {
+        const { gl, buffer, itemSize, typedArrayConstructor: Constructor } = this;
         const cpuBuffer = new Constructor(itemSize * items.length);
         for (let i = 0; i < items.length; i++) {
             cpuBuffer.set(adapter(items[i]), i * itemSize);

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

@@ -83,12 +83,12 @@ export class BufferOrchestrator {
                 if (bufferManagerComp === undefined)
                     throw new Error("insertBulk bufferKey does not exist");
                 const { bufferManager, adaptor } = bufferManagerComp;
-                bufferManager.insertBlock(blockLoad, offsetStart, adaptor, Float32Array);
+                bufferManager.insertBlock(blockLoad, offsetStart, adaptor);
             }
         }
         else {
             for (const [, { bufferManager, adaptor }] of bufferManagersMap) {
-                bufferManager.insertBlock(blockLoad, offsetStart, adaptor, Float32Array);
+                bufferManager.insertBlock(blockLoad, offsetStart, adaptor);
             }
         }
     }