@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/altitude-locator/plugin.js

@@ -0,0 +1,357 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointGlowLineToEarthPlugin = void 0;
+require("./types.js");
+var pickable_renderer_js_1 = require("../programs/picking/pickable-renderer.js");
+var element_point_glow_js_1 = require("../programs/point-on-globe/element-point-glow.js");
+var element_globe_surface_glow_js_1 = require("../programs/point-on-globe/element-globe-surface-glow.js");
+var naive_accurate_flexible_js_1 = require("../programs/line-on-globe/naive-accurate-flexible.js");
+var account_1 = require("../util/account");
+var picker_displayer_js_1 = require("../util/picking/picker-displayer.js");
+var methods_js_1 = require("../Math/methods.js");
+var typecheck_js_1 = require("../util/check/typecheck.js");
+var attribute_loader_1 = require("../util/gl-util/buffer/attribute-loader");
+var camerauniformblock_js_1 = require("../programs/totems/camerauniformblock.js");
+/**
+ * is used with depth we can create a line from surface to the point.
+ */
+var glowOverSize = 1.35; // 1.25 is the default value in the shader
+var PointGlowLineToEarthPlugin = /** @class */ (function () {
+    function PointGlowLineToEarthPlugin(_a) {
+        var _b = _a.isGlowPointOn, isGlowPointOn = _b === void 0 ? true : _b, _c = _a.isGlowSurfaceOn, isGlowSurfaceOn = _c === void 0 ? true : _c;
+        this.globe = null;
+        this.gl = null;
+        this._pickableWrapper = {};
+        this._glowPointWrapper = {};
+        this._glowSurfaceWrapper = {};
+        this._lineProgramWrapper = {};
+        this._modes = {
+            isGlowPointOn: isGlowPointOn,
+            isGlowSurfaceOn: isGlowSurfaceOn
+        };
+        this._hoveredObjectId = null;
+        this._lastWH = { w: 0, h: 0 };
+        this._opacity = 1.0;
+        this._hoverAgentParams = {
+            timePass: 0,
+            timeGap: 150,
+            stillPicking: false
+        };
+        this._cameraBlockTotem = null;
+        this._tickPhase = 0;
+        this._parametersChanged = false;
+    }
+    PointGlowLineToEarthPlugin.prototype.init = function (globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+        this._init();
+        this._cameraBlockTotem = camerauniformblock_js_1.CameraUniformBlockTotemCache.get(this.globe);
+    };
+    PointGlowLineToEarthPlugin.prototype._init = function () {
+        var _a, _b;
+        var _this = this;
+        var _c = this, globe = _c.globe, gl = _c.gl, _pickableWrapper = _c._pickableWrapper, _glowPointWrapper = _c._glowPointWrapper, _glowSurfaceWrapper = _c._glowSurfaceWrapper, _lineProgramWrapper = _c._lineProgramWrapper;
+        var bufferType = "STATIC_DRAW";
+        var initialCapacity = 50;
+        this._bufferOrchestrator = new account_1.BufferOrchestrator({ initialCapacity: initialCapacity });
+        this._bufferManagersMap = new Map([
+            ['pos3D', {
+                    bufferManager: new account_1.BufferManager(gl, 6, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                    adaptor: function (item) { return new Float32Array(__spreadArray(__spreadArray([], (0, methods_js_1.wgs84ToCartesian3d)(item.long, item.lat, item.altitude / 1000), true), (0, methods_js_1.wgs84ToCartesian3d)(item.long, item.lat, 0 / 1000), true)); }
+                }],
+            ['pos2D', {
+                    bufferManager: new account_1.BufferManager(gl, 2, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                    adaptor: function (item) { return new Float32Array((0, methods_js_1.wgs84ToMercator)(item.long, item.lat)); }
+                }],
+            ['rgba', {
+                    bufferManager: new account_1.BufferManager(gl, 8, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                    adaptor: function (item) { return new Float32Array(__spreadArray(__spreadArray([], item.color, true), item.color, true)); }
+                }],
+            ['size', {
+                    bufferManager: new account_1.BufferManager(gl, 1, { bufferType: bufferType, initialCapacity: initialCapacity }),
+                    adaptor: function (item) { return new Float32Array([item.size]); }
+                }],
+        ]);
+        _pickableWrapper.program = pickable_renderer_js_1.PickableRendererProgramCache.get(globe);
+        _glowPointWrapper.program = element_point_glow_js_1.ElementPointGlowProgramCache.get(globe);
+        _lineProgramWrapper.program = naive_accurate_flexible_js_1.LineOnGlobeCache.get(globe);
+        this._pickerDisplayer = new picker_displayer_js_1.PickerDisplayer(globe);
+        var obj = function (key) { return key === null ? null : (0, attribute_loader_1.createBufferAndReadInfo)(_this._bufferManagersMap.get(key).bufferManager.buffer); };
+        _pickableWrapper.vao = _pickableWrapper.program.createVAO((0, attribute_loader_1.createBufferAndReadInfo)(this._bufferManagersMap.get('pos3D').bufferManager.buffer, 6 * 4, 0), (0, attribute_loader_1.createBufferAndReadInfo)(this._bufferManagersMap.get('pos2D').bufferManager.buffer), (0, attribute_loader_1.createBufferAndReadInfo)(this._bufferManagersMap.get('rgba').bufferManager.buffer, 8 * 4, 0), (0, attribute_loader_1.createBufferAndReadInfo)(this._bufferManagersMap.get('size').bufferManager.buffer));
+        _pickableWrapper.vaoLine = (_a = _pickableWrapper.program).createVAO.apply(_a, ['pos3D', 'pos2D', 'rgba', null].map(obj));
+        _pickableWrapper.vaoHoverPoint = _pickableWrapper.program.createVAO((0, attribute_loader_1.createBufferAndReadInfo)(this._bufferManagersMap.get('pos3D').bufferManager.buffer, 6 * 4, 0), (0, attribute_loader_1.createBufferAndReadInfo)(this._bufferManagersMap.get('pos2D').bufferManager.buffer), null, (0, attribute_loader_1.createBufferAndReadInfo)(this._bufferManagersMap.get('size').bufferManager.buffer));
+        _pickableWrapper.vaoHoverLine = (_b = _pickableWrapper.program).createVAO.apply(_b, ['pos3D', 'pos2D', null, null].map(obj));
+        _glowPointWrapper.vao = _glowPointWrapper.program.createVAO((0, attribute_loader_1.createBufferAndReadInfo)(this._bufferManagersMap.get('pos3D').bufferManager.buffer, 6 * 4, 0), (0, attribute_loader_1.createBufferAndReadInfo)(this._bufferManagersMap.get('pos2D').bufferManager.buffer), null, (0, attribute_loader_1.createBufferAndReadInfo)(this._bufferManagersMap.get('size').bufferManager.buffer));
+        // _lineProgramWrapper.vao = _lineProgramWrapper.program.createVAO(
+        //     ...[null, 'pos3D', null, 'reverse3D', null, null, "rgba"].map(obj)
+        // );
+        // _pickableWrapper.vaoRev = _pickableWrapper.program.createVAO(
+        //     ...['reverse3D', 'pos2D', 'rgba', 'size'].map(obj)
+        // );
+        _pickableWrapper.ubo = _pickableWrapper.program.createUBO();
+        _pickableWrapper.ubo.update(new Map([
+            ["u_rgba", [1, 1, 1, 1]],
+            ["u_opacity", [1.0]],
+            ["u_size_multiplier", [1.0]],
+            ["u_size", [1.0]],
+            ["u_is_circle", [1.0]],
+            ["u_dash_opacity_multiplier", [0.75]],
+            ["u_dash_phase", [1.57]],
+            ["u_dash_count", [0.5]],
+            ["u_is_circle", [1.0]]
+        ]));
+        _pickableWrapper.uboLine = _pickableWrapper.program.createUBO();
+        _pickableWrapper.uboLine.update(new Map([
+            ["u_rgba", [1, 1, 1, 1]],
+            ["u_opacity", [1.0]],
+            ["u_size_multiplier", [1.0]],
+            ["u_size", [1.0]],
+            ["u_draw_mode", [1.0]], // 0.0 for default, 1.0 for line
+            ["u_dash_phase", [1.0]],
+            ["u_dash_count", [1.0]],
+            ["u_dash_opacity_multiplier", [1.0]],
+            ["u_is_circle", [0.0]]
+        ]));
+        _pickableWrapper.uboLineGlow = _pickableWrapper.program.createUBO();
+        _pickableWrapper.uboLineGlow.update(new Map([
+            ["u_rgba", [1, 1, 1, 1]],
+            ["u_opacity", [1.0]],
+            ["u_size_multiplier", [1.0]],
+            ["u_size", [1.0]],
+            ["u_draw_mode", [1]], // 0.0 for default, 1.0 for line
+            ["u_dash_phase", [0.0]],
+            ["u_dash_count", [5.0]],
+            ["u_dash_opacity_multiplier", [0.5]],
+            ["u_is_circle", [0.0]]
+        ]));
+        // _pickableWrapper._phase = 1;
+        // _pickableWrapper.phaseTick = () => {
+        //     _pickableWrapper._phase -= 0.003;
+        //     if (_pickableWrapper._phase < 0) {
+        //         _pickableWrapper._phase = 1;
+        //     }
+        //     _pickableWrapper.uboLineGlow.update(new Map([["u_dash_phase", [_pickableWrapper._phase]]]));
+        // }
+        _glowPointWrapper.ubo = _glowPointWrapper.program.createUBO();
+        _glowPointWrapper.ubo.update(new Map([
+            ["u_size", new Float32Array([30.0])],
+            ["u_size_multiplier", new Float32Array([glowOverSize])],
+        ]));
+        // _glowPointWrapper._phase = 0;
+        // _glowPointWrapper.phaseTick = () => {
+        //     _glowPointWrapper._phase += 0.0175;
+        //     if (_glowPointWrapper._phase < 0) {
+        //         _glowPointWrapper._phase = 1;
+        //     }
+        //     _glowPointWrapper.ubo.update(new Map([["u_phase", [_glowPointWrapper._phase]]]));
+        // }
+    };
+    /**
+     *
+     * @param {Array<PointGlowData>} data
+     */
+    PointGlowLineToEarthPlugin.prototype.insertBulk = function (data) {
+        var _a = this, _bufferManagersMap = _a._bufferManagersMap, _bufferOrchestrator = _a._bufferOrchestrator, globe = _a.globe;
+        _bufferOrchestrator.insertBulk(data, _bufferManagersMap);
+        this._changed();
+    };
+    PointGlowLineToEarthPlugin.prototype.setPointSizeMultiplier = function (sizeMultiplier) {
+        (0, typecheck_js_1.constraintFloat)(sizeMultiplier, 0.1, null);
+        this._pickableWrapper.ubo.update(new Map([["u_size_multiplier", [sizeMultiplier]]]));
+        this._glowPointWrapper.ubo.update(new Map([["u_size_multiplier", [sizeMultiplier * 1.25]]]));
+        this._changed();
+    };
+    /**
+     * @param {DrawRange} drawRange if null draws all
+     * @returns
+     */
+    PointGlowLineToEarthPlugin.prototype.setDrawRange = function (drawRange) {
+        if (drawRange === void 0) { drawRange = null; }
+        this._drawRange = drawRange;
+        this._changed();
+    };
+    /**
+     *
+     * sophisticated setDrawRange,
+     * 3 concepts:
+     */
+    PointGlowLineToEarthPlugin.prototype.setGlowIndexes = function (glowIndexes) {
+        var gl = this.gl;
+        if (!this._elementBuffer) {
+            this._elementBuffer = gl.createBuffer();
+        }
+        // filter glowIndexes with DrawRange
+        gl.bindElementArrayBuffer(this._elementBuffer);
+        this._parametersChanged = true;
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint32Array(glowIndexes), gl.DYNAMIC_DRAW);
+    };
+    PointGlowLineToEarthPlugin.prototype.setOpacity = function (opacity) {
+        (0, typecheck_js_1.opacityCheck)(opacity);
+        this._opacity = opacity;
+        this._pickableWrapper.ubo.update(new Map([["u_opacity", [opacity]]]));
+        this._pickableWrapper.uboLine.update(new Map([["u_opacity", [opacity]]]));
+        this._glowPointWrapper.ubo.update(new Map([["u_opacity", [opacity * glowOverSize]]]));
+        this._changed();
+    };
+    PointGlowLineToEarthPlugin.prototype.draw3D = function () {
+        var _a = this, _pickableWrapper = _a._pickableWrapper, _bufferOrchestrator = _a._bufferOrchestrator, _drawRange = _a._drawRange, _pickerDisplayer = _a._pickerDisplayer;
+        var _b = this, globe = _b.globe, gl = _b.gl;
+        this._hoverAgent();
+        this.resize();
+        var is3D = globe.api_GetCurrentGeometry() == 0;
+        var drawRange = _drawRange || { first: 0, count: _bufferOrchestrator.length };
+        var drawOptionsPoint = {
+            drawRange: drawRange,
+        };
+        this._doDraw(drawOptionsPoint, is3D, drawRange);
+        _pickerDisplayer.drawColorTexture();
+        if (this._hoveredObjectId === -1) {
+            return;
+        }
+        // hover draw
+        gl.disable(gl.DEPTH_TEST);
+        var program = _pickableWrapper.program, vaoHoverPoint = _pickableWrapper.vaoHoverPoint, vaoHoverLine = _pickableWrapper.vaoHoverLine, uboLineGlow = _pickableWrapper.uboLineGlow;
+        var drawOptionsHoveredPoint = {
+            drawRange: {
+                first: this._hoveredObjectId,
+                count: 1
+            },
+        };
+        // program.draw(vaoHoverPoint, drawptionsHoveredPoint, ubo);
+        if (true || this._modes.isGlowPointOn) {
+            var _c = this._glowPointWrapper, program_1 = _c.program, vao = _c.vao, ubo = _c.ubo;
+            // this._glowPointWrapper.phaseTick();
+            program_1.draw(vao, drawOptionsHoveredPoint, ubo);
+        }
+        else {
+        }
+        this.globe.DrawRender();
+        if (is3D) {
+            var drawOptionsHoveredLine = {
+                drawRange: {
+                    first: this._hoveredObjectId * 2,
+                    count: 2
+                },
+                drawMode: gl.LINES
+            };
+            // _pickableWrapper.phaseTick();
+            program.draw(vaoHoverLine, drawOptionsHoveredLine, uboLineGlow);
+        }
+        this._phaseTick();
+        gl.enable(gl.DEPTH_TEST);
+    };
+    PointGlowLineToEarthPlugin.prototype._doDraw = function (drawOptionsPoint, is3D, drawRange) {
+        var _a = this, gl = _a.gl, _pickableWrapper = _a._pickableWrapper, _pickerDisplayer = _a._pickerDisplayer;
+        var program = _pickableWrapper.program, vao = _pickableWrapper.vao, ubo = _pickableWrapper.ubo, uboLine = _pickableWrapper.uboLine, vaoLine = _pickableWrapper.vaoLine;
+        if (this._doesChanged()) {
+            _pickerDisplayer.bindFBO();
+            _pickerDisplayer.clearTextures();
+            gl.enable(gl.DEPTH_TEST);
+            program.draw(vao, drawOptionsPoint, ubo);
+        }
+        if (is3D) {
+            var drawOptionsLine = {
+                drawRange: {
+                    first: drawRange.first * 2,
+                    count: drawRange.count * 2
+                },
+                drawMode: gl.LINES
+            };
+            if (this._doesChanged) {
+                uboLine.update(new Map([
+                    ["u_opacity", [0.01]]
+                ]));
+                program.draw(vaoLine, drawOptionsLine, uboLine);
+            }
+            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+            uboLine.update(new Map([
+                ["u_opacity", [this._opacity]]
+            ]));
+            program.draw(vaoLine, drawOptionsLine, uboLine);
+        }
+    };
+    PointGlowLineToEarthPlugin.prototype.getCurrentSelection = function () {
+        return this._hoveredObjectId;
+    };
+    PointGlowLineToEarthPlugin.prototype.resize = function () {
+        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();
+        this._changed();
+    };
+    PointGlowLineToEarthPlugin.prototype.free = function () {
+        var _this = this;
+        var _a = this, _pickableWrapper = _a._pickableWrapper, _glowPointWrapper = _a._glowPointWrapper, _glowSurfaceWrapper = _a._glowSurfaceWrapper, _lineProgramWrapper = _a._lineProgramWrapper;
+        [_pickableWrapper, _glowPointWrapper, _glowSurfaceWrapper, _lineProgramWrapper].forEach(function (item) {
+            var vao = item.vao, ubo = item.ubo;
+            ubo === null || ubo === void 0 ? void 0 : ubo.free();
+            _this.gl.deleteVertexArray(vao);
+        });
+        pickable_renderer_js_1.PickableRendererProgramCache.release(this.globe);
+        element_point_glow_js_1.ElementPointGlowProgramCache.release(this.globe);
+        // ElementGlobeSufaceGlowCache.release(this.globe); // TODO: uncomment when needed
+        naive_accurate_flexible_js_1.LineOnGlobeCache.release(this.globe);
+        if (this._elementBuffer)
+            this.gl.deleteBuffer(this._elementBuffer);
+        this._pickerDisplayer.free();
+        this._bufferManagersMap.forEach(function (item) { return item.bufferManager.free(); });
+        this._bufferManagersMap.clear();
+        camerauniformblock_js_1.CameraUniformBlockTotemCache.release(this.globe);
+    };
+    PointGlowLineToEarthPlugin.prototype._phaseTick = function () {
+        this._tickPhase += 0.003;
+        if (this._tickPhase > 1) {
+            this._tickPhase = 0;
+        }
+        this._glowPointWrapper.ubo.update(new Map([["u_phase", [this._tickPhase * 2]]]));
+        this._pickableWrapper.uboLineGlow.update(new Map([["u_dash_phase", [1 - this._tickPhase]]]));
+    };
+    PointGlowLineToEarthPlugin.prototype._hoverAgent = function () {
+        var _this = this;
+        var _a = this, globe = _a.globe, _hoverAgentParams = _a._hoverAgentParams;
+        var pos = globe.api_GetMousePos();
+        var currentTime = new Date().getTime();
+        if (_hoverAgentParams.stillPicking || _hoverAgentParams.timePass > currentTime) {
+            return;
+        }
+        ;
+        _hoverAgentParams.timePass = currentTime + _hoverAgentParams.timeGap;
+        var x = pos.canvasX;
+        var y = globe.api_ScrH() - pos.canvasY;
+        _hoverAgentParams.stillPicking = true;
+        this._pickerDisplayer.pickXY(x, y, 1, function (idSet) {
+            _hoverAgentParams.stillPicking = false;
+            if (idSet.size === 0) {
+                _this._hoveredObjectId = -1;
+                return;
+            }
+            var index = __spreadArray([], idSet, true)[0];
+            if (index !== _this._hoveredObjectId) {
+                _this._hoveredObjectId = index;
+                _this.globe.DrawRender();
+            }
+        });
+    };
+    PointGlowLineToEarthPlugin.prototype._doesChanged = function () {
+        return this._cameraBlockTotem.isMoved() || this._parametersChanged; // TODO: implement
+    };
+    PointGlowLineToEarthPlugin.prototype._changed = function () {
+        this._parametersChanged = true;
+        this.globe.DrawRender();
+    };
+    return PointGlowLineToEarthPlugin;
+}());
+exports.PointGlowLineToEarthPlugin = PointGlowLineToEarthPlugin;

package/altitude-locator/types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../types");
+/**
+ * @typedef PointGlowData
+ * @type {Object}
+ * @property {number} key
+ * @property {number} latitude
+ * @property {number} longitude
+ * @property {number} height
+ * @property {number} size
+ * @property {[number, number, number]} color
+ */
+/**
+ *
+ *
+ * drawSubsetOptions
+ * @typedef DrawSubsetOptions
+ * @type {Object}
+ * @property {null|Color} color if provided, it will override the color
+ * @property {Opacity} opacity default 1.0
+ * @property {DrawRangeIndexParams} drawOptions
+ */ 

package/arrowfield/adaptor.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.centigradePlus90ToRadians = centigradePlus90ToRadians;
+function centigradePlus90ToRadians(centigradeArray, noDataValue) {
+    if (noDataValue === void 0) { noDataValue = -9999; }
+    var radiansArray = new Float32Array(centigradeArray.length);
+    for (var i = 0; i < centigradeArray.length; i++) {
+        if (centigradeArray[i] === noDataValue) {
+            radiansArray[i] = noDataValue;
+            continue;
+        }
+        radiansArray[i] = (centigradeArray[i] + 90.0) * Math.PI / 180;
+    }
+    return radiansArray;
+}

package/arrowfield/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.centigradePlus90ToRadians = exports.ArrowField = void 0;
+var plugin_1 = __importDefault(require("./plugin"));
+exports.ArrowField = plugin_1.default;
+var adaptor_1 = require("./adaptor");
+Object.defineProperty(exports, "centigradePlus90ToRadians", { enumerable: true, get: function () { return adaptor_1.centigradePlus90ToRadians; } });

package/arrowfield/plugin.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var programs_1 = require("../programs");
+var ArrowFieldPlugin = /** @class */ (function () {
+    function ArrowFieldPlugin(id, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.minLon, minLon = _c === void 0 ? -180 : _c, _d = _b.maxLon, maxLon = _d === void 0 ? 180 : _d, _e = _b.minLat, minLat = _e === void 0 ? -90 : _e, _f = _b.maxLat, maxLat = _f === void 0 ? 90 : _f, _g = _b.height, height = _g === void 0 ? 0 : _g, _h = _b.opacity, opacity = _h === void 0 ? 1 : _h, _j = _b.tailLengthRatio, tailLengthRatio = _j === void 0 ? 1 : _j, _k = _b.wingLengthRatio, wingLengthRatio = _k === void 0 ? 0.5 : _k, _l = _b.color, color = _l === void 0 ? [0.04, 0.2, 0.8] : _l, _m = _b.targetWidth, targetWidth = _m === void 0 ? 100 : _m, _o = _b.targetHeight, targetHeight = _o === void 0 ? 100 : _o, _p = _b.data, data = _p === void 0 ? null : _p, _q = _b.dataWidth, dataWidth = _q === void 0 ? null : _q, _r = _b.dataHeight, dataHeight = _r === void 0 ? null : _r, _s = _b.maxMagnitude, maxMagnitude = _s === void 0 ? null : _s, _t = _b.noDataValue, noDataValue = _t === void 0 ? null : _t;
+        this.id = id;
+        this.options = {
+            minLon: minLon,
+            maxLon: maxLon,
+            minLat: minLat,
+            maxLat: maxLat,
+            height: height,
+            tailLengthRatio: tailLengthRatio,
+            wingLengthRatio: wingLengthRatio,
+            opacity: opacity,
+            color: color,
+            data: data,
+            targetHeight: targetHeight,
+            targetWidth: targetWidth,
+            dataWidth: dataWidth,
+            dataHeight: dataHeight,
+            maxMagnitude: maxMagnitude,
+            noDataValue: noDataValue
+        };
+        this.arrowFieldObj = null;
+        this._doDraw = true;
+    }
+    ArrowFieldPlugin.prototype.init = function (globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+        this.arrowFieldObj = new programs_1.ArrowField(gl, globe, this.options);
+    };
+    ArrowFieldPlugin.prototype.draw3D = function () {
+        if (this._doDraw) {
+            var _a = this, gl = _a.gl, arrowFieldObj = _a.arrowFieldObj;
+            gl.disable(gl.DEPTH_TEST);
+            arrowFieldObj.draw();
+            gl.enable(gl.DEPTH_TEST);
+        }
+    };
+    ArrowFieldPlugin.prototype.free = function () {
+        this.arrowFieldObj.free();
+        this.arrowFieldObj = null;
+    };
+    // user interaction methods
+    ArrowFieldPlugin.prototype.on = function () {
+        this._doDraw = true;
+    };
+    ArrowFieldPlugin.prototype.off = function () {
+        this._doDraw = false;
+    };
+    ArrowFieldPlugin.prototype.setBBox = function (_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.minLon, minLon = _c === void 0 ? -180 : _c, _d = _b.maxLon, maxLon = _d === void 0 ? 180 : _d, _e = _b.minLat, minLat = _e === void 0 ? -90 : _e, _f = _b.maxLat, maxLat = _f === void 0 ? 90 : _f;
+        this.arrowFieldObj.setBBox({ minLon: minLon, maxLon: maxLon, minLat: minLat, maxLat: maxLat });
+    };
+    ArrowFieldPlugin.prototype.setHeight = function (height) {
+        this.arrowFieldObj.update({ height: height });
+    };
+    ArrowFieldPlugin.prototype.setColor = function (color) {
+        this.arrowFieldObj.update({ color: color });
+    };
+    ArrowFieldPlugin.prototype.setOpacity = function (opacity) {
+        this.arrowFieldObj.update({ opacity: opacity });
+    };
+    ArrowFieldPlugin.prototype.setTailLengthRatio = function (tailLengthRatio) {
+        this.arrowFieldObj.update({ tailLengthRatio: tailLengthRatio });
+    };
+    ArrowFieldPlugin.prototype.setWingLengthRatio = function (wingLengthRatio) {
+        this.arrowFieldObj.update({ wingLengthRatio: wingLengthRatio });
+    };
+    ArrowFieldPlugin.prototype.setDataResolution = function (dataWidth, dataHeight) {
+        this.arrowFieldObj.update({ dataWidth: dataWidth, dataHeight: dataHeight });
+    };
+    ArrowFieldPlugin.prototype.setTargetResolution = function (targetWidth, targetHeight) {
+        this.arrowFieldObj.update({ resolution: [targetWidth, targetHeight] });
+    };
+    ArrowFieldPlugin.prototype.setMaxMagnitude = function (maxMagnitude) {
+        this.arrowFieldObj.update({ maxMagnitude: maxMagnitude });
+    };
+    ArrowFieldPlugin.prototype.setNoDataValue = function (noDataValue) {
+        this.arrowFieldObj.update({ noDataValue: noDataValue });
+    };
+    ArrowFieldPlugin.prototype.setData = function (rotationData) {
+        this.arrowFieldObj.setData(rotationData);
+    };
+    return ArrowFieldPlugin;
+}());
+exports.default = ArrowFieldPlugin;

package/bearing-line/index.js

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