@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/point-heat-map/plugin-webworker.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointHeatmapPlugin = void 0;
+var point_to_heat_map_flow_1 = require("./point-to-heat-map-flow");
+// import { webworkerStr } from "../util/interpolation/timetrack/web-worker-str"; // TODO: Delete When this plugin is tested on production
+var index_1 = require("../util/interpolation/timetrack/index");
+var util_1 = require("../util");
+var typecheck_1 = require("../util/check/typecheck");
+var PointHeatmapPlugin = /** @class */ (function () {
+    function PointHeatmapPlugin(id, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.opacity, opacity = _c === void 0 ? 1.0 : _c, _d = _b.pointSize, pointSize = _d === void 0 ? 5.0 : _d, _e = _b.onInterpolationComplete, onInterpolationComplete = _e === void 0 ? function () { } : _e;
+        var _this = this;
+        this.id = id;
+        this.globe = null;
+        this.gl = null;
+        this.densityToLegendProgram = null;
+        this._time = null;
+        this._opacity = opacity;
+        this._pointSize = pointSize;
+        this._legendTexture = null;
+        this._throttleListener = null;
+        this._timeTracksAreSet = false;
+        // const blob = new Blob([webworkerStr], { type: 'application/javascript' });
+        // this.timeTrackInterpolationWorker = new Worker(URL.createObjectURL(blob), { type: 'module' });
+        this.timeTrackInterpolationWorker = (0, index_1.createWorker)();
+        this.timeTrackInterpolationWorker.onmessage = function (e) {
+            if (e.data.error) {
+                throw new Error(e.data.error);
+            }
+            if (e.data === true) {
+                onInterpolationComplete();
+            }
+            if (e.data instanceof Float32Array) {
+                _this.flow.setData(e.data);
+                _this._throttleListener = null;
+                onInterpolationComplete();
+            }
+        };
+    }
+    // globe interaction
+    PointHeatmapPlugin.prototype.init = function (globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+        this.flow = new point_to_heat_map_flow_1.PointHeatmapFlow(globe);
+        this.setGeometry();
+        this.resize();
+    };
+    PointHeatmapPlugin.prototype.setPointSize = function (pointSize) {
+        (0, typecheck_1.constraintFloat)(pointSize, 1);
+        this._pointSize = pointSize;
+        this.globe.DrawRender();
+    };
+    /**
+     * @param {Array<string>}
+     * @param {string} mode "interpolated" | "discrete"
+     */
+    PointHeatmapPlugin.prototype.setColorRamp = function (values, thresholds, mode) {
+        if (mode === void 0) { mode = "interpolated"; }
+        var gl = this.gl;
+        if (this.gl === null) {
+            throw new Error('Plugin not initialized');
+        }
+        ;
+        var rampData = (0, util_1.getColorRampModed)(values, thresholds, mode);
+        var texture = (0, util_1.createTexture)(gl, gl.LINEAR, rampData, 256, 1);
+        if (this._legendTexture) {
+            this.gl.deleteTexture(this._legendTexture);
+        }
+        this._legendTexture = texture;
+        this.globe.DrawRender();
+    };
+    PointHeatmapPlugin.prototype.setTime = function (time) {
+        var _this = this;
+        // TODO: WORK ON THIS
+        this._time = time;
+        if (this.isReady() && this._throttleListener === null) {
+            this._throttleListener = setTimeout(function () {
+                _this.timeTrackInterpolationWorker.postMessage({ time: _this._time });
+            }, 0);
+        }
+    };
+    PointHeatmapPlugin.prototype.setTimetracks = function (timeTracks) {
+        this._timeTracksAreSet = true;
+        this.timeTrackInterpolationWorker.postMessage({ timeTracks: timeTracks });
+        if (this._time !== null) {
+            this.setTime(this._time);
+        }
+        this.globe.DrawRender();
+    };
+    PointHeatmapPlugin.prototype.setOpacity = function (opacity) {
+        (0, typecheck_1.opacityCheck)(opacity);
+        this._opacity = opacity;
+        this.globe.DrawRender();
+    };
+    PointHeatmapPlugin.prototype.setGeometry = function () {
+        var geometry = this.globe.api_GetCurrentGeometry();
+        this.timeTrackInterpolationWorker.postMessage({ geometry: geometry });
+        if (this._time !== null) {
+            this.setTime(this._time);
+        }
+    };
+    PointHeatmapPlugin.prototype.draw3D = function () {
+        if (this.isReady()) {
+            this.flow.draw(this._legendTexture, this._pointSize, this._opacity);
+        }
+    };
+    PointHeatmapPlugin.prototype.resize = function () {
+        this.flow.resize();
+        if (this._time !== null) {
+            this.setTime(this._time);
+        }
+    };
+    PointHeatmapPlugin.prototype.isReady = function () {
+        return (this.gl !== null && this._legendTexture !== null && this._timeTracksAreSet);
+    };
+    PointHeatmapPlugin.prototype.free = function () {
+        if (this._isFreed)
+            return;
+        this.gl.deleteTexture(this._legendTexture);
+        this.flow.free();
+        this.flow = null;
+        this.gl = null;
+        this._isFreed = true;
+        this.timeTrackInterpolator = null;
+        this._legendTexture = null;
+        this.timeTrackInterpolationWorker.terminate();
+        this.timeTrackInterpolationWorker = null;
+    };
+    return PointHeatmapPlugin;
+}());
+exports.PointHeatmapPlugin = PointHeatmapPlugin;

package/point-heat-map/point-to-heat-map-flow.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointHeatmapFlow = void 0;
+var density_to_legend_1 = require("../programs/data2legend/density-to-legend");
+var point_to_density_texture_1 = require("../programs/data2legend/point-to-density-texture");
+// import { textureOnCanvasProgramCache } from "../util/programs/draw-texture-on-canvas";
+var gldefaultstates_1 = require("../util/webglobe/gldefaultstates");
+var PointHeatmapFlow = /** @class */ (function () {
+    function PointHeatmapFlow(globe) {
+        this.globe = null;
+        this.gl = null;
+        this.program = null;
+        this.densityToLegendProgram = null;
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.pointToDensityProgram = point_to_density_texture_1.pointToDensityTextureCache.get(globe);
+        this.densityToLegendProgram = density_to_legend_1.densityToLegendProgramCache.get(globe);
+        // this.testTextureProgram = textureOnCanvasProgramCache.get(globe.gl);
+        this._lookInfo = globe.api_GetCurrentLookInfo();
+        var gl = this.gl;
+        {
+            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();
+        }
+    }
+    PointHeatmapFlow.prototype._bindTextureToFramebuffer = function () {
+        var _a = this, gl = _a.gl, densityTexture = _a.densityTexture, framebuffer = _a.framebuffer;
+        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, densityTexture, 0);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    };
+    PointHeatmapFlow.prototype.draw = function (legendTexture, pointSize, opacity) {
+        if (opacity === void 0) { opacity = 1.0; }
+        var _a = this, gl = _a.gl, globe = _a.globe, framebuffer = _a.framebuffer;
+        if (this._drawDensityRequired || this._isVisionChanged()) {
+            gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+            gl.clearColor(0, 0, 0, 0);
+            gl.viewport(0, 0, Math.floor(globe.api_ScrW()), Math.floor(globe.api_ScrH()));
+            gl.clear(gl.COLOR_BUFFER_BIT);
+            this._drawDensity(pointSize);
+            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        }
+        (0, gldefaultstates_1.defaultblendfunction)(gl);
+        this._drawLegend(legendTexture, opacity);
+    };
+    PointHeatmapFlow.prototype.resize = function () {
+        var _a = this, gl = _a.gl, densityTexture = _a.densityTexture;
+        gl.deleteTexture(densityTexture);
+        this.densityTexture = this._createDensityTexture();
+        this._bindTextureToFramebuffer();
+        this._drawDensityRequired = true;
+    };
+    // USER API
+    /**
+     * @param {Float32Array} data
+     * @format [x, y, z, height] x,y,z is normalized 3d cartesian coordinates. Height in kilometers. Set 6378.137 for ground level.
+     */
+    PointHeatmapFlow.prototype.setData = function (data) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
+        // use program
+        this.dataLength = data.length;
+        this._drawDensityRequired = true;
+        this.globe.DrawRender();
+    };
+    // implicit Methods
+    PointHeatmapFlow.prototype._createDensityTexture = function () {
+        var _a = this, gl = _a.gl, globe = _a.globe;
+        var width = Math.floor(globe.api_ScrW());
+        var height = Math.floor(globe.api_ScrH());
+        var texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        return texture;
+    };
+    PointHeatmapFlow.prototype._drawDensity = function (pointSize) {
+        var _a = this, gl = _a.gl, globe = _a.globe, pointToDensityProgram = _a.pointToDensityProgram, vao2D = _a.vao2D, vao3D = _a.vao3D, dataLength = _a.dataLength;
+        var is3D = globe.api_GetCurrentGeometry() === 0;
+        var vao = is3D ? vao3D : vao2D;
+        var length = dataLength / (is3D ? 3 : 2);
+        gl.blendEquation(gl.FUNC_ADD);
+        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE, gl.SRC_ALPHA, gl.ONE);
+        pointToDensityProgram.draw(vao, length, pointSize);
+        this._drawDensityRequired = false;
+    };
+    PointHeatmapFlow.prototype._drawLegend = function (legendTexture, opacity) {
+        var _a = this, densityToLegendProgram = _a.densityToLegendProgram, densityTexture = _a.densityTexture;
+        densityToLegendProgram.draw(densityTexture, legendTexture, opacity);
+    };
+    PointHeatmapFlow.prototype._isVisionChanged = function () {
+        var currentLookInfo = this.globe.api_GetCurrentLookInfo();
+        var _lookInfo = this._lookInfo;
+        if (currentLookInfo.CenterLong !== _lookInfo.CenterLong ||
+            currentLookInfo.CenterLat !== _lookInfo.CenterLat ||
+            currentLookInfo.Distance !== _lookInfo.Distance ||
+            currentLookInfo.Tilt !== _lookInfo.Tilt ||
+            currentLookInfo.NorthAng !== _lookInfo.NorthAng) {
+            this._lookInfo = currentLookInfo;
+            return true;
+        }
+        return false;
+    };
+    PointHeatmapFlow.prototype.free = function () {
+        if (this._isFreed)
+            return;
+        this._isFreed = true;
+        density_to_legend_1.densityToLegendProgramCache.release(this.globe);
+        point_to_density_texture_1.pointToDensityTextureCache.release(this.globe);
+        // textureOnCanvasProgramCache.release(this.gl);
+        this.gl.deleteTexture(this.densityTexture);
+        this.gl.deleteFramebuffer(this.framebuffer);
+        this.gl.deleteBuffer(this.buffer);
+        this.gl.deleteVertexArray(this.vao2D);
+        this.gl.deleteVertexArray(this.vao3D);
+    };
+    return PointHeatmapFlow;
+}());
+exports.PointHeatmapFlow = PointHeatmapFlow;

package/point-tracks/key-methods.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pointKeyMeyhod = void 0;
+var pointKeyMeyhod = function (trackId, pointID) { return "".concat(trackId, "-").concat(pointID); };
+exports.pointKeyMeyhod = pointKeyMeyhod;

package/point-tracks/plugin.js

@@ -0,0 +1,353 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyMethod = exports.PointTracksPlugin = void 0;
+var account_1 = require("../util/account");
+var picker_displayer_1 = require("../util/picking/picker-displayer");
+var square_pixel_point_1 = require("../programs/point-on-globe/square-pixel-point");
+var methods_1 = require("../Math/methods");
+/**
+ * @typedef {number} long
+ * @typedef {number} lat
+ * @typedef {number} height
+ * @typedef {string} ID
+ * @typedef {string} trackID
+ * @typedef {[number, number, number, number]} rgba 0-1
+ * @typedef { long ,lat, height, ID } Point
+ * @typedef {Array<Point>, rgba, trackID} Track
+ */
+var PointTracksPlugin = /** @class */ (function () {
+    function PointTracksPlugin(id, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.pointSize, pointSize = _c === void 0 ? 2 : _c, _d = _b.hoveredPointSize, hoveredPointSize = _d === void 0 ? 4 : _d, _e = _b.selectionPointFilling, selectionPointFilling = _e === void 0 ? 4 : _e, _f = _b.opacity, opacity = _f === void 0 ? 1.0 : _f;
+        this.id = id;
+        this._isFreed = false;
+        this._pointProgram = null;
+        this._vao = null;
+        this._bufferManagersMap = null;
+        this._bufferOrchestrator = null;
+        this._pickerDisplayer = null;
+        this._selectedID = -1;
+        this._selectedObj = null;
+        this._tracksToPointsMap = new Map(); // one to many
+        this._opacity = opacity;
+        this.program = null;
+        this._lastWH = { w: 0, h: 0 };
+        this._focusParams = { on: false, length: 0, elementBuffer: null, trackIDs: [] };
+        this.pointSizes = {
+            pointSize: pointSize,
+            selectionPointFilling: selectionPointFilling,
+            hoveredPointSize: hoveredPointSize
+        };
+    }
+    PointTracksPlugin.prototype.init = function (globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+        this._pickerDisplayer = new picker_displayer_1.PickerDisplayer(globe);
+        this._pointProgram = square_pixel_point_1.PointOnGlobeProgramCache.get(globe);
+        this._focusParams.elementBuffer = gl.createBuffer();
+        this._initBufferManagers();
+    };
+    PointTracksPlugin.prototype._initBufferManagers = function () {
+        var gl = this.gl;
+        var initialCapacity = 10;
+        var bufferType = "DYNAMIC_DRAW";
+        this._bufferOrchestrator = new account_1.BufferOrchestrator({ initialCapacity: initialCapacity });
+        this._bufferManagersMap = new Map([
+            ["pos3D", {
+                    bufferManager: new account_1.BufferManager(gl, 3, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                    adaptor: function (item) { return new Float32Array((0, methods_1.wgs84ToCartesian3d)(item.long, item.lat, item.height / 1000)); } // height is in meters
+                }],
+            ["pos2D", {
+                    bufferManager: new account_1.BufferManager(gl, 2, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                    adaptor: function (item) { return new Float32Array((0, methods_1.wgs84ToMercator)(item.long, item.lat)); }
+                }],
+            ["rgba", {
+                    bufferManager: new account_1.BufferManager(gl, 4, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                    adaptor: function (item) { return item.rgba; }
+                }],
+            ["objectStore", {
+                    bufferManager: new account_1.ObjectStore({ initialCapacity: initialCapacity }),
+                    adaptor: function (item) {
+                        return {
+                            trackID: item.trackID, pointID: item.pointID
+                        };
+                    }
+                }]
+        ]);
+        this._vao = this._pointProgram.createVAO(this._bufferManagersMap.get("pos3D").bufferManager.buffer, this._bufferManagersMap.get("pos2D").bufferManager.buffer, this._bufferManagersMap.get("rgba").bufferManager.buffer);
+    };
+    PointTracksPlugin.prototype.setPointSize = function (size) {
+        var _a;
+        this.pointSizes.pointSize = size;
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    };
+    PointTracksPlugin.prototype.setSelectionPointFilling = function (size) {
+        var _a;
+        this.pointSizes.selectionPointFilling = size;
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    };
+    PointTracksPlugin.prototype.setHoveredPointSize = function (size) {
+        var _a;
+        this.pointSizes.hoveredPointSize = size;
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    };
+    PointTracksPlugin.prototype.setOpacity = function (opacity) {
+        var _a;
+        if (opacity < 0 || opacity > 1)
+            return;
+        this._opacity = opacity;
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    };
+    PointTracksPlugin.prototype.getCurrentSelection = function () {
+        return this._selectedObj;
+    };
+    /**
+     *
+     * @param {*} x screen x
+     * @param {*} y screen y
+     * @param {*} callback callback on selection
+     */
+    PointTracksPlugin.prototype.screenSelection = function (x, y, callback) {
+        var _this = this;
+        var _a = this, pointSizes = _a.pointSizes, _pickerDisplayer = _a._pickerDisplayer;
+        var objectStore = this._bufferManagersMap.get("objectStore").bufferManager;
+        var wrapper = function (selectedIDsSet) {
+            var selectedIDs = Array.from(selectedIDsSet);
+            if (selectedIDs.length === 0) {
+                _this._selectedObj = null;
+                _this._selectedID = -1;
+                callback([]);
+                return;
+            }
+            var selectedPoints = [];
+            for (var i = 0; i < selectedIDs.length; i++) {
+                var id = selectedIDs[i];
+                if (i === 0) {
+                    _this._selectedID = id;
+                    _this._selectedObj = objectStore.get(id);
+                }
+                var obj = objectStore.get(id);
+                selectedPoints.push(obj);
+            }
+            callback(selectedPoints);
+        };
+        _pickerDisplayer.pickXY(x, y, pointSizes.selectionPointFilling, wrapper);
+    };
+    /**
+     * @param {Array<Track>} tracks
+     * @returns
+     */
+    PointTracksPlugin.prototype.insertBulk = function (tracks) {
+        var _a;
+        this._fillTracksToPointsMap(tracks); // TODO error should be at the top
+        var flattenedPoints = tracks.map(trackToFlatPoints).flat();
+        var currentLoad = this._bufferOrchestrator.length;
+        if (currentLoad + flattenedPoints.length >= 2147483647) {
+            throw new Error("Too many points, Point count cannot exceed 2147483647");
+        }
+        var _b = this, _bufferManagersMap = _b._bufferManagersMap, _bufferOrchestrator = _b._bufferOrchestrator;
+        _bufferOrchestrator.insertBulk(flattenedPoints, _bufferManagersMap);
+        this._refillFocus();
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    };
+    PointTracksPlugin.prototype.flush = function () {
+        var _a, _b;
+        var capacity = 100;
+        (_a = this._bufferOrchestrator) === null || _a === void 0 ? void 0 : _a.flush({ capacity: capacity });
+        this._bufferManagersMap.forEach(function (_a) {
+            var bufferManager = _a.bufferManager;
+            return bufferManager.resetWithCapacity(capacity);
+        });
+        this._turnOffFocus();
+        this._tracksToPointsMap.clear();
+        (_b = this.globe) === null || _b === void 0 ? void 0 : _b.DrawRender();
+    };
+    /**
+     * @param {string} trackID
+     */
+    PointTracksPlugin.prototype.deleteTrack = function (trackID) {
+        var _a;
+        var pointSet = this._tracksToPointsMap.get(trackID);
+        var points = Array.from(pointSet);
+        var _b = this, _bufferOrchestrator = _b._bufferOrchestrator, _bufferManagersMap = _b._bufferManagersMap;
+        _bufferOrchestrator.deleteBulk(points.map(function (pointID) { return keyMethod(trackID, pointID); }), _bufferManagersMap);
+        this._tracksToPointsMap.delete(trackID);
+        this._redraw = true;
+        this._refillFocus();
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    };
+    /**
+     * @param {string} trackID
+     * @param {Array<string>} pointIDs
+     */
+    PointTracksPlugin.prototype.deletePoints = function (trackID, pointIDs) {
+        var _a;
+        var _b = this, _bufferOrchestrator = _b._bufferOrchestrator, _bufferManagersMap = _b._bufferManagersMap;
+        _bufferOrchestrator.deleteBulk(pointIDs.map(function (pointID) { return keyMethod(trackID, pointID); }), _bufferManagersMap);
+        this._deletePointsFromTracksMap(trackID, pointIDs);
+        this._refillFocus();
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    };
+    PointTracksPlugin.prototype.focusTracks = function (trackIDs) {
+        var _a;
+        if (trackIDs === void 0) { trackIDs = null; }
+        if (!this.globe)
+            return;
+        if (!trackIDs) {
+            this._focusParams.on = false;
+            (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+            return;
+        }
+        this._focusParams.on = this._fillElementBuffer(trackIDs);
+        if (!this._focusParams.on) {
+            this._turnOffFocus();
+        }
+        this.globe.DrawRender();
+    };
+    // GLOBE API METHODS
+    PointTracksPlugin.prototype.free = function () {
+        if (this._isFreed)
+            return;
+        this._isFreed = true;
+        this._pickerDisplayer.free();
+        square_pixel_point_1.PointOnGlobeProgramCache.release(this.globe);
+        this.gl.deleteBuffer(this._focusParams.elementBuffer);
+        this._bufferManagersMap.forEach(function (_a) {
+            var bufferManager = _a.bufferManager, adaptor = _a.adaptor;
+            return bufferManager.free();
+        });
+    };
+    PointTracksPlugin.prototype.draw3D = function () {
+        var _a = this, gl = _a.gl, _pointProgram = _a._pointProgram, _pickerDisplayer = _a._pickerDisplayer, _bufferOrchestrator = _a._bufferOrchestrator, _vao = _a._vao;
+        this.resize();
+        _pickerDisplayer.bindFBO();
+        _pickerDisplayer.clearTextures();
+        if (this._focusParams.on) {
+            _pointProgram.draw(_vao, this._focusParams.length, {
+                hoveredID: this._selectedID,
+                opacity: this._opacity,
+                pointSize: this.pointSizes.pointSize,
+                hoveredPointSize: this.pointSizes.hoveredPointSize,
+                elementBuffer: this._focusParams.elementBuffer
+            });
+        }
+        else {
+            _pointProgram.draw(_vao, _bufferOrchestrator.length, {
+                hoveredID: this._selectedID,
+                opacity: this._opacity,
+                pointSize: this.pointSizes.pointSize,
+                hoveredPointSize: this.pointSizes.hoveredPointSize
+            });
+        }
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        _pickerDisplayer.drawColorTexture();
+        this._selfSelect();
+    };
+    PointTracksPlugin.prototype.resize = function () {
+        var _a;
+        var w = this.globe.api_ScrW();
+        var h = this.globe.api_ScrH();
+        if (w === this._lastWH.w && h === this._lastWH.h)
+            return;
+        this._lastWH.w = w;
+        this._lastWH.h = h;
+        this._pickerDisplayer.resize();
+        (_a = this.globe) === null || _a === void 0 ? void 0 : _a.DrawRender();
+    };
+    // IMPLICIT METHODS
+    PointTracksPlugin.prototype._fillTracksToPointsMap = function (tracks) {
+        for (var _i = 0, tracks_1 = tracks; _i < tracks_1.length; _i++) {
+            var track = tracks_1[_i];
+            var trackID = track.trackID;
+            var points = track.points;
+            if (!this._tracksToPointsMap.has(trackID)) {
+                this._tracksToPointsMap.set(trackID, new Set());
+            }
+            var pointSet = this._tracksToPointsMap.get(trackID);
+            for (var p = 0; p < points.length; p++) {
+                var pointID = points[p].ID;
+                pointSet.add(pointID);
+            }
+        }
+    };
+    PointTracksPlugin.prototype._refillFocus = function () {
+        if (this._focusParams.on) {
+            this.focusTracks(this._focusParams.trackIDs);
+        }
+    };
+    PointTracksPlugin.prototype._deletePointsFromTracksMap = function (trackID, pointIDs) {
+        var trackSet = this._tracksToPointsMap.get(trackID);
+        for (var _i = 0, pointIDs_1 = pointIDs; _i < pointIDs_1.length; _i++) {
+            var pointID = pointIDs_1[_i];
+            trackSet.delete(pointID);
+        }
+    };
+    PointTracksPlugin.prototype._selfSelect = function () {
+        var globe = this.globe;
+        var pos = globe.api_GetMousePos();
+        var x = pos.canvasX;
+        var y = globe.api_ScrH() - pos.canvasY;
+        this.screenSelection(x, y, function (selectedPoints) {
+        });
+    };
+    PointTracksPlugin.prototype._turnOffFocus = function () {
+        var gl = this.gl;
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._focusParams.elementBuffer);
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint32Array([]), gl.STATIC_DRAW);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+        this._focusParams.length = 0;
+        this._focusParams.on = false;
+    };
+    PointTracksPlugin.prototype._fillElementBuffer = function (trackIDs) {
+        var length = 0;
+        var indexes = [];
+        var foundTracks = [];
+        for (var _i = 0, trackIDs_1 = trackIDs; _i < trackIDs_1.length; _i++) {
+            var trackID = trackIDs_1[_i];
+            var pointSet = this._tracksToPointsMap.get(trackID);
+            if (!pointSet)
+                continue;
+            foundTracks.push(trackID);
+            var points = Array.from(pointSet);
+            for (var _a = 0, points_1 = points; _a < points_1.length; _a++) {
+                var pointID = points_1[_a];
+                var key = keyMethod(trackID, pointID);
+                var index = this._bufferOrchestrator.offsetMap.get(key);
+                indexes.push(index);
+                length++;
+            }
+        }
+        this._focusParams.trackIDs = foundTracks;
+        this._focusParams.length = length;
+        if (length === 0) {
+            return false;
+        }
+        var gl = this.gl;
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._focusParams.elementBuffer);
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint32Array(indexes), gl.STATIC_DRAW);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+        return true;
+    };
+    return PointTracksPlugin;
+}());
+exports.PointTracksPlugin = PointTracksPlugin;
+var trackToFlatPoints = function (track) {
+    var trackID = track.trackID;
+    var points = track.points;
+    var rgba = new Float32Array(track.rgba);
+    var flatPoints = [];
+    for (var _i = 0, points_2 = points; _i < points_2.length; _i++) {
+        var point = points_2[_i];
+        flatPoints.push({
+            key: keyMethod(trackID, point.ID),
+            long: point.long,
+            lat: point.lat,
+            height: point.height,
+            pointID: point.ID,
+            rgba: rgba,
+            trackID: trackID
+        });
+    }
+    return flatPoints;
+};
+var keyMethod = function (trackID, pointID) { return "".concat(trackID, "_").concat(pointID); };
+exports.keyMethod = keyMethod;

package/programs/arrowfield/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var object_1 = __importDefault(require("./object"));
+exports.default = object_1.default;