@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/heatwave/plugins/heatwaveglobeshell.js

@@ -0,0 +1,224 @@
+"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 });
+var util_1 = require("../../util");
+var programs_1 = require("../../programs");
+var typecheck_1 = require("../../util/check/typecheck");
+/**
+ * @param id : string
+ * @param dataManager : DataManager
+ * @param colorRampData : {values: string[], thresholds: number[], mode: string}
+ * @param dataWidthHeight : {width: number, height: number}
+ * @param options : {bbox: number[], minMaxEdges: {min: number, max: number}, escapeValue: number, resolution: number[], meshPartition: number[]}
+ */
+var HeatWaveGlobeShellPlugin = /** @class */ (function () {
+    function HeatWaveGlobeShellPlugin(id, dataManager, colorRampData, dataWidthHeight, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.bbox, bbox = _c === void 0 ? [-180, -90, 180, 90] : _c, _d = _b.minMaxEdges, minMaxEdges = _d === void 0 ? { min: -99999, max: 99999 } : _d, _e = _b.escapeValue, escapeValue = _e === void 0 ? 99999 : _e, _f = _b.resolution, resolution = _f === void 0 ? [2056, 2056] : _f, _g = _b.yFlip, yFlip = _g === void 0 ? true : _g;
+        this.id = id;
+        this.dataManager = dataManager;
+        this._dataWidthHeight = dataWidthHeight;
+        this._isOn = true;
+        this._bbox = bbox;
+        this._minMaxEdges = minMaxEdges;
+        this._escapeValue = escapeValue;
+        this._resolution = resolution;
+        this._colorRampData = colorRampData; // holds until init
+        this._yFlip = yFlip;
+        this._lastTexture0data = null;
+        this._lastTexture1data = null;
+        // output of heatProgram is written to ._coloredHeatTexture
+        this._frameBuffer = null;
+        this._coloredHeatTexture = null;
+        this.enabled = false;
+        this.isAble = false;
+    }
+    HeatWaveGlobeShellPlugin.prototype.setHeight = function (height) {
+        this.globeShell.setHeight(height);
+    };
+    HeatWaveGlobeShellPlugin.prototype.drawHeat = function () {
+        var gl = this.gl;
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this._frameBuffer);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._coloredHeatTexture, 0);
+        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var currentWidth = gl.canvas.width;
+        var currentHeight = gl.canvas.height;
+        gl.viewport.apply(gl, __spreadArray([0, 0], this._resolution, false));
+        this.heatProgram.draw();
+        gl.viewport(0, 0, currentWidth, currentHeight);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        gl.useProgram(currentProgram);
+        this.globe.DrawRender();
+    };
+    HeatWaveGlobeShellPlugin.prototype.setEscapeValue = function (escapeValue) {
+        this._escapeValue = escapeValue;
+        this.heatProgram.setEscapeValue(escapeValue);
+    };
+    HeatWaveGlobeShellPlugin.prototype._createPointCoordinatesDataCalculator = function () {
+        this.coordinatesDataCalculator = new util_1.PointCoordinatesDataCalculator(this._bbox, this._dataWidthHeight.width, this._dataWidthHeight.height);
+        this.dataManager.register(this._coordinatesDataCalculatorID(), this.coordinatesDataCalculator.updateData.bind(this.coordinatesDataCalculator));
+    };
+    HeatWaveGlobeShellPlugin.prototype._coordinatesDataCalculatorID = function () {
+        return this.id + "_coordinatesDataCalculator";
+    };
+    HeatWaveGlobeShellPlugin.prototype.updateTime = function (time) {
+        this.dataManager.updateTime(time);
+        this.globe.DrawRender();
+    };
+    HeatWaveGlobeShellPlugin.prototype.setWiggle = function (_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.wiggleInKm, wiggleInKm = _c === void 0 ? null : _c, _d = _b.wiggleSpeed, wiggleSpeed = _d === void 0 ? null : _d;
+        this.globeShell.setWiggle({ wiggleInKm: wiggleInKm, wiggleSpeed: wiggleSpeed });
+    };
+    HeatWaveGlobeShellPlugin.prototype.setMinMaxEdges = function (min, max) {
+        if (min === void 0) { min = null; }
+        if (max === void 0) { max = null; }
+        if (min)
+            this._minMaxEdges.min = min;
+        if (max)
+            this._minMaxEdges.max = max;
+        this.heatProgram.setMinMaxEdges(this._minMaxEdges.min, this._minMaxEdges.max);
+        this.drawHeat();
+    };
+    HeatWaveGlobeShellPlugin.prototype.setBBox = function (minLon, minLat, maxLon, maxLat) {
+        this._bbox = [minLon, minLat, maxLon, maxLat];
+        this.globeShell.setBBox({ minLon: minLon, minLat: minLat, maxLon: maxLon, maxLat: maxLat });
+        this.drawHeat();
+    };
+    HeatWaveGlobeShellPlugin.prototype.getPointCoordinatesDataCalculator = function () {
+        if (!this.coordinatesDataCalculator)
+            this._createPointCoordinatesDataCalculator();
+        return this.coordinatesDataCalculator;
+    };
+    /**
+     * @param {*} values n + 1 number of color hex values without alpha channel. Ex: ["#ff0000", "#00ff00", "#0000ff"]
+     * @param {*} thresholds n number of thresholds. Ex: [0, 10, 20]
+     * @param {*} mode "discrete" or "interpolated"
+     *
+     * There are maximum 256 pixels in the color ramp.
+     * The first values array is minimum edge value which is the first pixel, the second comes one pixel after the first.
+     */
+    HeatWaveGlobeShellPlugin.prototype.setColorRamp = function (values, thresholds, mode) {
+        if (mode === void 0) { mode = "interpolated"; }
+        var lowest = thresholds[0];
+        var highest = thresholds[thresholds.length - 1];
+        var range = highest - lowest;
+        var clampedThresholds = thresholds.map(function (t) { return (t - lowest) / range; });
+        var colors = (0, util_1.getColorRampModed)(values, clampedThresholds, mode);
+        this.heatProgram.setColorRampTextureData(colors, 256);
+        this.heatProgram.setColorRampRange(lowest, highest);
+        this.drawHeat();
+    };
+    HeatWaveGlobeShellPlugin.prototype.off = function () {
+        this._isOn = false;
+    };
+    HeatWaveGlobeShellPlugin.prototype.on = function () {
+        this._isOn = true;
+    };
+    HeatWaveGlobeShellPlugin.prototype._updateData = function (ratio, textureData0, textureData1) {
+        if (textureData0 === void 0) { textureData0 = null; }
+        if (textureData1 === void 0) { textureData1 = null; }
+        if (!textureData0 || !textureData1) {
+            if (this._disCarded)
+                return;
+            this.heatProgram.discard();
+            this.drawHeat();
+            this._disCarded = true;
+            return;
+        }
+        ;
+        this.heatProgram.setBlendRatio(ratio);
+        if (this._lastTexture0data !== textureData0 || this._lastTexture1data !== textureData1) {
+            this._disCarded = false;
+            this._lastTexture0data = textureData0;
+            this._lastTexture1data = textureData1;
+            this.heatProgram.setFloatTextureData(textureData0, textureData1, this._dataWidthHeight.width, this._dataWidthHeight.height, this._yFlip);
+        }
+        this.drawHeat();
+    };
+    HeatWaveGlobeShellPlugin.prototype.setDataWidthHeight = function (width, height) {
+        this._dataWidthHeight = { width: width, height: height };
+        this.heatProgram.setDataWidthHeight(width, height);
+        this.setGeometry();
+    };
+    HeatWaveGlobeShellPlugin.prototype.draw3D = function () {
+        if (!this._isOn)
+            return;
+        // if (!this.isAble) return;
+        this.gl.disable(this.gl.DEPTH_TEST);
+        this.globeShell.draw();
+        this.gl.enable(this.gl.DEPTH_TEST);
+    };
+    HeatWaveGlobeShellPlugin.prototype.setOpacity = function (opacity) {
+        (0, typecheck_1.opacityCheck)(opacity);
+        this.globeShell.setOpacity(opacity);
+    };
+    HeatWaveGlobeShellPlugin.prototype._setAfterInit = function () {
+        var _a = this._bbox, minLon = _a[0], minLat = _a[1], maxLon = _a[2], maxLat = _a[3];
+        this.globeShell.setBBox({ minLon: minLon, minLat: minLat, maxLon: maxLon, maxLat: maxLat });
+        this.setColorRamp(this._colorRampData.values, this._colorRampData.thresholds, this._colorRampData.mode);
+        delete this._colorRampData;
+        this.setMinMaxEdges(this._minMaxEdges.min, this._minMaxEdges.max);
+        this.setEscapeValue(this._escapeValue);
+    };
+    HeatWaveGlobeShellPlugin.prototype._init = function (globe, gl) {
+        var _this = this;
+        this.globeShell = new programs_1.GlobeShellWiggle(gl, globe, {
+            minLon: this._bbox[0],
+            minLat: this._bbox[1],
+            maxLon: this._bbox[2],
+            maxLat: this._bbox[3],
+            color: [1.0, 0.1, 0.4, 0.2],
+            height: 0,
+            wiggleInKM: 2,
+            eastWestTied: false,
+            displayMesh: false
+        });
+        this.heatProgram = new programs_1.Float2LegendWithRatio(gl);
+        this._frameBuffer = gl.createFramebuffer();
+        this.dataManager.register(this.id, function (ratio, t1, t2) { return _this._updateData(ratio, t1, t2); });
+        this.setResolution(this._resolution[0], this._resolution[1]);
+    };
+    HeatWaveGlobeShellPlugin.prototype.init = function (globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+        this._init(globe, gl);
+        this._setAfterInit();
+    };
+    HeatWaveGlobeShellPlugin.prototype.setGeometry = function () {
+        // globeShell has an implicit program, registered and sets its own geometry.
+        return;
+    };
+    // sets Density of middle texture which is used with framebuffers
+    HeatWaveGlobeShellPlugin.prototype.setResolution = function (width, height) {
+        var gl = this.gl;
+        this._resolution = [width, height];
+        this._coloredHeatTexture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, this._coloredHeatTexture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+        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);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        this.globeShell.setTexture(this._coloredHeatTexture);
+    };
+    HeatWaveGlobeShellPlugin.prototype.free = function () {
+        if (this.coordinatesDataCalculator) {
+            this.dataManager.unregister(this._coordinatesDataCalculatorID());
+            this.coordinatesDataCalculator = null;
+        }
+        this.dataManager.unregister(this.id);
+        this.globeShell.free();
+        this.heatProgram.free();
+    };
+    return HeatWaveGlobeShellPlugin;
+}());
+exports.default = HeatWaveGlobeShellPlugin;

package/index.js

@@ -34,25 +34,25 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pointheatmap = exports.partialring = exports.arrowfield = exports.programs = exports.util = exports.heatwave = exports.compassrose = exports.rangerings = exports.timetracks = exports.waveparticles = exports.wind = void 0;
-const wind = __importStar(require("./wind"));
+var wind = __importStar(require("./wind"));
 exports.wind = wind;
-const waveparticles = __importStar(require("./waveparticles"));
+var waveparticles = __importStar(require("./waveparticles"));
 exports.waveparticles = waveparticles;
-const timetracks = __importStar(require("./timetracks"));
+var timetracks = __importStar(require("./timetracks"));
 exports.timetracks = timetracks;
-const arrowfield = __importStar(require("./arrowfield"));
+var arrowfield = __importStar(require("./arrowfield"));
 exports.arrowfield = arrowfield;
-const rangerings = __importStar(require("./rangerings"));
+var rangerings = __importStar(require("./rangerings"));
 exports.rangerings = rangerings;
-const partialring = __importStar(require("./partialrings"));
+var partialring = __importStar(require("./partialrings"));
 exports.partialring = partialring;
-const compassrose = __importStar(require("./compassrose"));
+var compassrose = __importStar(require("./compassrose"));
 exports.compassrose = compassrose;
-const heatwave = __importStar(require("./heatwave"));
+var heatwave = __importStar(require("./heatwave"));
 exports.heatwave = heatwave;
-const util = __importStar(require("./util"));
+var util = __importStar(require("./util"));
 exports.util = util;
-const programs = __importStar(require("./programs"));
+var programs = __importStar(require("./programs"));
 exports.programs = programs;
-const pointheatmap = __importStar(require("./point-heat-map"));
+var pointheatmap = __importStar(require("./point-heat-map"));
 exports.pointheatmap = pointheatmap;

package/jest.config.js

@@ -0,0 +1,7 @@
+"use strict";
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    testMatch: ['**/tests/**/*.test.ts'],
+    moduleFileExtensions: ['ts', 'js'],
+};

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.9.9",
+    "version": "0.9.11",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT",
     "scripts": {
         "build": "tsc"
     },
-    "files": [
-        "dist"
-    ]
+    "devDependencies": {
+        "typescript": "^5.0.0"
+    }
 }

package/partialrings/buffer-manager.js

@@ -0,0 +1,113 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var bufferoffsetmanager_1 = __importDefault(require("../util/account/bufferoffsetmanager"));
+var ITEM_SIZE = 10;
+var BufferManager = /** @class */ (function (_super) {
+    __extends(BufferManager, _super);
+    function BufferManager(globe, gl, buffer, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.initialCapacity, initialCapacity = _c === void 0 ? 10 : _c, _d = _b.bufferType, bufferType = _d === void 0 ? "DYNAMIC_DRAW" : _d;
+        var _this = _super.call(this, ITEM_SIZE, { capacity: initialCapacity }) || this;
+        _this.globe = globe;
+        _this.gl = gl;
+        _this.buffer = buffer;
+        _this.bufferType = bufferType;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, initialCapacity * ITEM_SIZE * 4, gl[bufferType]);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return _this;
+    }
+    /**
+     *
+     * @param { Array<{key, long, lat, startAngle, tailAngle, radius, rgba[4], rgbaMode }>} rings
+     * @returns
+     */
+    BufferManager.prototype.insertBulk = function (items) {
+        if (items.length === 0)
+            return;
+        this.autoExtendBuffer(items.length);
+        var _a = this, gl = _a.gl, buffer = _a.buffer;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+            var _b = items_1[_i], key = _b.key, long = _b.long, lat = _b.lat, startAngle = _b.startAngle, tailAngle = _b.tailAngle, rgba = _b.rgba, radius = _b.radius, rgbaMode = _b.rgbaMode;
+            var offset = this.getOffset(key) | this.nextOffset();
+            this.setOffset(key, offset);
+            var block = new Float32Array(__spreadArray(__spreadArray([
+                long, lat, startAngle, tailAngle
+            ], rgba, true), [
+                radius, rgbaMode
+            ], false));
+            gl.bufferSubData(gl.ARRAY_BUFFER, offset, block);
+            // 2         1       1           1         4       1 = 10
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this.globe.DrawRender();
+    };
+    /**
+     * @param {Array<{key, long, lat, startAngle, tailAngle}>} items
+     *
+     * */
+    BufferManager.prototype.updateCenterAndAngleBulk = function (items) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        for (var _i = 0, items_2 = items; _i < items_2.length; _i++) {
+            var _b = items_2[_i], key = _b.key, long = _b.long, lat = _b.lat, startAngle = _b.startAngle, tailAngle = _b.tailAngle;
+            var offset = this.getOffset(key);
+            if (offset === null) {
+                console.warn("key ".concat(key, " not found"));
+                continue;
+            }
+            var block = new Float32Array([long, lat, startAngle, tailAngle]);
+            gl.bufferSubData(gl.ARRAY_BUFFER, offset, block);
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this.globe.DrawRender();
+    };
+    /**
+     *
+     * @param {Array<{key:string, payload:Float32Array}} items
+     * @param {PART_OFFSET_LOOPUP} part | long, lat, START_ANGLE, ROTATION_ANGLE, RADIUS, rgba, rgba_MODE
+     * @returns
+     */
+    BufferManager.prototype.updatePartial = function (items, part) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer;
+        this._updatePartial(items, part, gl, buffer);
+        this.globe.DrawRender();
+    };
+    BufferManager.prototype.deleteBulk = function (keys) {
+        this._deleteBulk(keys);
+        this.globe.DrawRender();
+    };
+    BufferManager.prototype.free = function () {
+        this.gl.deleteBuffer(this.buffer);
+        this.buffer = null;
+    };
+    return BufferManager;
+}(bufferoffsetmanager_1.default));
+exports.default = BufferManager;

package/partialrings/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PART_OFFSET_LOOPUP = exports.RINGPARTIAL_DRAW_MODE = exports.RINGPARTIAL_ALPHA_MODE = exports.PartialRing = void 0;
+var plugin_1 = __importStar(require("./plugin"));
+exports.PartialRing = plugin_1.default;
+Object.defineProperty(exports, "RINGPARTIAL_ALPHA_MODE", { enumerable: true, get: function () { return plugin_1.RINGPARTIAL_ALPHA_MODE; } });
+Object.defineProperty(exports, "RINGPARTIAL_DRAW_MODE", { enumerable: true, get: function () { return plugin_1.RINGPARTIAL_DRAW_MODE; } });
+Object.defineProperty(exports, "PART_OFFSET_LOOPUP", { enumerable: true, get: function () { return plugin_1.PART_OFFSET_LOOPUP; } });

package/partialrings/plugin.js

@@ -0,0 +1,171 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PART_OFFSET_LOOPUP = exports.RINGPARTIAL_ALPHA_MODE = exports.RINGPARTIAL_DRAW_MODE = void 0;
+var bufferoffsetmanager_1 = __importDefault(require("../util/account/bufferoffsetmanager"));
+var program_1 = require("./program");
+var typecheck_1 = require("../util/check/typecheck");
+var emptyBlock = new Float32Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+exports.RINGPARTIAL_DRAW_MODE = Object.freeze({
+    LINE_STRIP: "LINE_STRIP",
+    TRIANGLE_FAN: "TRIANGLE_FAN",
+});
+exports.RINGPARTIAL_ALPHA_MODE = Object.freeze({
+    CONSTANT: 0,
+    FADING: 1,
+    HIDE: 2,
+});
+exports.PART_OFFSET_LOOPUP = Object.freeze({
+    LONG: 0,
+    LAT: 1,
+    START_ANGLE: 2,
+    TAIL_ANGLE: 3,
+    RGBA: 4,
+    RADIUS: 8,
+    RGBA_MODE: 9,
+});
+var default_1 = /** @class */ (function () {
+    function default_1(id, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.edgeCount, edgeCount = _c === void 0 ? 10 : _c, _d = _b.drawMode, drawMode = _d === void 0 ? exports.RINGPARTIAL_DRAW_MODE.LINE_STRIP : _d, _e = _b.startLod, startLod = _e === void 0 ? 3 : _e, _f = _b.endLod, endLod = _f === void 0 ? 13 : _f, _g = _b.alphaMultiplier, alphaMultiplier = _g === void 0 ? 1 : _g;
+        this.id = id;
+        this.edgeCount = edgeCount;
+        this.drawMode = drawMode;
+        this.startLod = startLod;
+        this.endLod = endLod;
+        this.alphaMultiplier = alphaMultiplier;
+    }
+    default_1.prototype.init = function (globe, gl) {
+        this.gl = gl;
+        this.globe = globe;
+        this.program = program_1.programCache.get(globe);
+        var _a = this.program.getVaoBuffer(), vao = _a.vao, buffer = _a.buffer;
+        this.vao = vao;
+        this.buffer = buffer;
+    };
+    default_1.prototype.draw3D = function () {
+        var LOD = this.globe.api_GetCurrentLOD();
+        if (LOD < this.startLod || LOD > this.endLod)
+            return;
+        this.program.draw(this.bufferManager.length, this.vao, this.edgeCount, this.alphaMultiplier, this.drawMode);
+    };
+    /**
+     *
+     * @param {RINGPARTIAL_DRAW_MODE} drawMode
+     */
+    default_1.prototype.setDrawMode = function (drawMode) {
+        this.drawMode = drawMode;
+    };
+    default_1.prototype.setOpacity = function (opacity) {
+        (0, typecheck_1.opacityCheck)(opacity);
+        this.alphaMultiplier = opacity;
+    };
+    default_1.prototype.setStartEndLOD = function (_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.startLod, startLod = _c === void 0 ? null : _c, _d = _b.endLod, endLod = _d === void 0 ? null : _d;
+        if (startLod !== null)
+            this.startLod = startLod;
+        if (endLod !== null)
+            this.endLod = endLod;
+    };
+    default_1.prototype.createBufferMAnager = function (initialCapacity, bufferType) {
+        if (initialCapacity === void 0) { initialCapacity = 10; }
+        if (bufferType === void 0) { bufferType = 'DYNAMIC_DRAW'; }
+        if (!this.bufferManager) {
+            this.bufferManager = new BufferManager(this.globe, this.gl, this.buffer, { initialCapacity: initialCapacity, bufferType: bufferType, });
+        }
+        return this.bufferManager;
+    };
+    default_1.prototype.free = function () {
+        program_1.programCache.free(this.globe);
+        this.bufferManager.free();
+    };
+    return default_1;
+}());
+exports.default = default_1;
+var BufferManager = /** @class */ (function (_super) {
+    __extends(BufferManager, _super);
+    function BufferManager(globe, gl, buffer, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.initialCapacity, initialCapacity = _c === void 0 ? 10 : _c, bufferType = _b.bufferType;
+        var _this = _super.call(this, 10, { capacity: initialCapacity, bufferType: bufferType, }) || this;
+        _this.globe = globe;
+        _this.gl = gl;
+        _this.buffer = buffer;
+        _this.bufferType = bufferType;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, initialCapacity * program_1.ITEM_SIZE * 4, gl[bufferType]);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return _this;
+    }
+    /**
+     *
+     * @param { Array<{key, long, lat, startAngle, tailAngle, radius, rgba[4], rgbaMode }>} rings
+     * @returns
+     */
+    BufferManager.prototype.insertBulk = function (items) {
+        if (items.length === 0)
+            return;
+        this.autoExtendBuffer(items.length);
+        var _a = this, gl = _a.gl, buffer = _a.buffer;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+            var _b = items_1[_i], key = _b.key, long = _b.long, lat = _b.lat, startAngle = _b.startAngle, tailAngle = _b.tailAngle, rgba = _b.rgba, radius = _b.radius, rgbaMode = _b.rgbaMode;
+            var offset = this.getOffset(key) | this.nextOffset();
+            this.setOffset(key, offset);
+            var block = new Float32Array(__spreadArray(__spreadArray([
+                long, lat, startAngle, tailAngle
+            ], rgba, true), [
+                radius, rgbaMode
+            ], false));
+            gl.bufferSubData(gl.ARRAY_BUFFER, offset, block);
+            // 2         1       1           1         4       1 = 10
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this.globe.DrawRender();
+    };
+    /**
+     *
+     * @param {Array<{key:string, payload:Float32Array}} items
+     * @param {PART_OFFSET_LOOPUP} part | long, lat, START_ANGLE, ROTATION_ANGLE, RADIUS, rgba, rgba_MODE
+     * @returns
+     */
+    BufferManager.prototype.updatePartial = function (items, part) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer;
+        this._updatePartial(items, part, gl, buffer);
+        this.globe.DrawRender();
+    };
+    BufferManager.prototype.delete = function (keys) {
+        var _a = this, gl = _a.gl, buffer = _a.buffer;
+        this._removefromBuffer(gl, buffer, keys, emptyBlock);
+        this.globe.DrawRender();
+    };
+    BufferManager.prototype.free = function () {
+        this.gl.deleteBuffer(this.buffer);
+        this.buffer = null;
+    };
+    return BufferManager;
+}(bufferoffsetmanager_1.default));