@pirireis/webglobeplugins 0.9.10 → 0.9.11

package/wind/plugin.js

@@ -39,9 +39,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const util = __importStar(require("../util"));
-const imagetovectorfieldandmagnitude_1 = __importDefault(require("./imagetovectorfieldandmagnitude"));
-const util_1 = require("../util");
+var util = __importStar(require("../util"));
+var imagetovectorfieldandmagnitude_1 = __importDefault(require("./imagetovectorfieldandmagnitude"));
+var util_1 = require("../util");
 /**
  * Shader Dökümanı:
  * * Vektör alan haritasında kaçış değeri
@@ -71,258 +71,13 @@ const util_1 = require("../util");
  * @property {Array} thresholds - list of integers
  * @property {Array} values - list of colors
  */
-const quadVert = `
-precision mediump float;
-
-attribute vec2 a_pos;
-
-varying vec2 v_tex_pos;
-
-void main() {
-    v_tex_pos = a_pos;
-    gl_Position = vec4(1.0 - 2.0 * a_pos, 0, 1);
-}`;
-const screenFrag = `precision mediump float;
-
-uniform sampler2D u_screen;
-uniform float u_opacity;
-
-varying vec2 v_tex_pos;
-
-void main() {
-    vec4 color = texture2D(u_screen, 1.0 - v_tex_pos);
-    // a hack to guarantee opacity fade out even with a value close to 1.0
-    gl_FragColor = vec4( floor(255.0 * color * u_opacity) / 255.0);
-}
-
-`;
-const updateFrag = `
-precision highp float;
-
-uniform sampler2D u_particles;
-uniform sampler2D u_wind;
-uniform vec2 u_wind_res;
-uniform vec2 u_wind_min;
-uniform vec2 u_wind_max;
-uniform float u_rand_seed;
-uniform float u_speed_factor;
-uniform float u_drop_rate;
-uniform float u_drop_rate_bump;
-
-varying vec2 v_tex_pos;
-
-// pseudo-random generator
-const vec3 rand_constants = vec3(12.9898, 78.233, 4375.85453);
-float rand(const vec2 co) {
-    float t = dot(rand_constants.xy, co);
-    return fract(sin(t) * (rand_constants.z + t));
-}
-
-// wind speed lookup; use manual bilinear filtering based on 4 adjacent pixels for smooth interpolation
-vec2 lookup_wind(const vec2 uv) {
-    // return texture2D(u_wind, uv).rg; // lower-res hardware filtering
-    vec2 px = 1.0 / u_wind_res;
-    vec2 vc = (floor(uv * u_wind_res)) * px;
-    vec2 f = fract(uv * u_wind_res);
-    vec2 tl = texture2D(u_wind, vc).rg;
-    vec2 tr = texture2D(u_wind, vc + vec2(px.x, 0)).rg;
-    vec2 bl = texture2D(u_wind, vc + vec2(0, px.y)).rg;
-    vec2 br = texture2D(u_wind, vc + px).rg;
-    return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);
-}
-
-void main() {
-    vec4 color = texture2D(u_particles, v_tex_pos);
-    vec2 pos = vec2(
-        color.r / 255.0 + color.b,
-        color.g / 255.0 + color.a); // decode particle position from pixel RGBA
-
-    if ( texture2D(u_wind, pos).rg == vec2(0.0, 0.0) ) {
-        discard;
-    }
-
-    vec2 velocity = mix(u_wind_min, u_wind_max, lookup_wind(pos));
-    float speed_t = length(velocity) / length(u_wind_max);
-
-    // take EPSG:4236 distortion into account for calculating where the particle moved
-    // float distortion = 1.0; //cos(radians(pos.y * 180.0 - 90.0));
-    // vec2 offset = vec2(velocity.x / distortion, -velocity.y) * 0.0001 * u_speed_factor;
-    vec2 offset = vec2(velocity.x, velocity.y) * 0.0001 * u_speed_factor;
-
-    // update particle position, wrapping around the date line
-    pos = fract(1.0 + pos + offset);
-
-    // a random seed to use for the particle drop
-    vec2 seed = (pos + v_tex_pos) * u_rand_seed;
-
-    // drop rate is a chance a particle will restart at random position, to avoid degeneration
-    float drop_rate = u_drop_rate + speed_t * u_drop_rate_bump;
-    float drop = step(1.0 - drop_rate, rand(seed));
-
-    vec2 random_pos = vec2(
-        rand(seed + 1.3),
-        rand(seed + 2.1));
-    pos = mix(pos, random_pos, drop);
-
-    // encode the new particle position back into RGBA
-    gl_FragColor = vec4(
-        fract(pos * 255.0),
-        floor(pos * 255.0) / 255.0);
-}
-`;
-const drawFrag = `precision mediump float;
-
-uniform sampler2D u_wind;
-uniform vec2 u_wind_min;
-uniform vec2 u_wind_max;
-uniform sampler2D u_color_ramp;
-uniform float u_color_ramp_max;
-uniform float u_base_opacity;
-
-uniform float u_min_speed;
-uniform float u_max_speed;
-
-varying vec2 v_particle_pos;
-
-void main() {
-    
-
-    if ( texture2D(u_wind, v_particle_pos).rg == vec2(0.0, 0.0) ) {
-        discard;
-    }
-    vec2 velocity = mix(u_wind_min, u_wind_max, texture2D(u_wind, v_particle_pos).rg);
-    float speed = length(velocity);
-    if (speed < u_min_speed || speed > u_max_speed) {
-        discard;
-    }
-    if (speed >= u_color_ramp_max) {
-        gl_FragColor = texture2D(u_color_ramp, 
-            vec2( 0.99999 , 0.0001 )) * u_base_opacity;
-        return;
-    }
-
-    float speed_t = speed / u_color_ramp_max; // length(u_wind_max); // 
-    // color ramp olusturulan method finalde texture ters çevriliyor. bu yüzden speed_t 1.0 - speed_t oluyor.
-    speed_t = 1.0 - speed_t;
-    // color ramp is encoded in a 16.0 x 16.0 texture
-    vec2 ramp_pos = vec2(
-        fract(16.0 * speed_t),
-        floor(16.0 * speed_t) / 16.0);
-
-
-    gl_FragColor = texture2D(u_color_ramp, ramp_pos) * u_base_opacity;
-}
-`;
-const drawSphereVert = `
-precision mediump float;
-
-attribute float a_index;
-
-uniform float u_point_size;
-uniform sampler2D u_particles;
-uniform float u_particles_res;
-
-uniform float u_height;
-
-varying vec2 v_particle_pos;
-varying float v_z;
-
-uniform mat3 u_bbox_matrix;
-
-uniform mat4 uModelViewMatrix;
-uniform mat4 uProjectionMatrix;
-uniform vec3 uTranslate;
-
-const float PI = 3.141592653589793;
-const float R = 6378.137;
-
-vec3 cartesian3DPoint( float longRad, float latRad, float height) {
-    float radius = R + height;
-    float x = radius * sin(latRad) * cos(longRad);
-    float y = radius * sin(latRad) * sin(longRad);
-    float z = radius * cos(latRad);
-    return vec3(
-        x, 
-        y, 
-        z) ;
-}
-
-void main() {
-    vec4 color = texture2D(u_particles, vec2(
-        fract(a_index / u_particles_res),
-        floor(a_index / u_particles_res) / u_particles_res));
-
-    v_particle_pos = vec2(
-        color.r / 255.0 + color.b,
-        color.g / 255.0 + color.a);
-    
-
-    if ( v_particle_pos.y < 0.0265 || v_particle_pos.y > 0.9735 ) {
-        gl_Position = vec4(-2.0, -2.0, -2.0, 1.0);
-        return;
-    }
-    vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, v_particle_pos.y, 1.0);
-    
-
-    float xRad = PI * (2.0 * pos.x - 1.0);
-    float yRad = pos.y * PI;
-
-    pos = cartesian3DPoint(xRad, yRad, u_height);
-    gl_Position = uProjectionMatrix * uModelViewMatrix * vec4(pos - uTranslate, 1.0);
-    gl_PointSize = u_point_size;
-
-}`;
-const drawFlatVert = `
-precision mediump float;
-
-uniform mat3 u_bbox_matrix;
-
-uniform vec3 uTranslate;
-// uniform mat4 uModelViewMatrix;
-uniform mat4 uProjectionMatrix;
-
-attribute float a_index;
-uniform sampler2D u_particles;
-uniform float u_particles_res;
-uniform float u_point_size;
-uniform vec2 u_mapWH;
-uniform vec2 u_scrWH;
-
-varying vec2 v_particle_pos;
-
-const float PI = 3.141592653589793;
-const float POLE = 20037508.34;
-const float POLE_BY_PI = POLE / PI;
-const float HALF_PI = PI / 2.0;
-
-
-void main() {
-
-    vec4 color = texture2D(u_particles, vec2(
-        fract(a_index / u_particles_res),
-        floor(a_index / u_particles_res) / u_particles_res));
-
-    v_particle_pos = vec2(
-        color.r / 255.0 + color.b,
-        color.g / 255.0 + color.a);
-
-    if ( v_particle_pos.y < 0.0265 || v_particle_pos.y > 0.9735 ) {
-        gl_Position = vec4(-2.0, -2.0, -2.0, 1.0);
-        return;
-    }
-    vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, v_particle_pos.y, 1.0);
-    
-    float x = (2.0 * pos.x - 1.0);
-    float mercator_x = x * POLE;
-    float mercator_y = log( tan( ( 1.0 - pos.y ) * HALF_PI  ) ) * POLE_BY_PI;
-
-    float normalizedX = ( mercator_x - uTranslate.x) / u_mapWH.x;
-    float normalizedY = ( mercator_y - uTranslate.y) / u_mapWH.y;
-    gl_Position = uProjectionMatrix * vec4(normalizedX * u_scrWH.x, (1.0 - normalizedY) * u_scrWH.y, 0.0, 1.0);
-
-    gl_PointSize = u_point_size;
-}`;
-const defaultRampColors = [
+var quadVert = "\nprecision mediump float;\n\nattribute vec2 a_pos;\n\nvarying vec2 v_tex_pos;\n\nvoid main() {\n    v_tex_pos = a_pos;\n    gl_Position = vec4(1.0 - 2.0 * a_pos, 0, 1);\n}";
+var screenFrag = "precision mediump float;\n\nuniform sampler2D u_screen;\nuniform float u_opacity;\n\nvarying vec2 v_tex_pos;\n\nvoid main() {\n    vec4 color = texture2D(u_screen, 1.0 - v_tex_pos);\n    // a hack to guarantee opacity fade out even with a value close to 1.0\n    gl_FragColor = vec4( floor(255.0 * color * u_opacity) / 255.0);\n}\n\n";
+var updateFrag = "\nprecision highp float;\n\nuniform sampler2D u_particles;\nuniform sampler2D u_wind;\nuniform vec2 u_wind_res;\nuniform vec2 u_wind_min;\nuniform vec2 u_wind_max;\nuniform float u_rand_seed;\nuniform float u_speed_factor;\nuniform float u_drop_rate;\nuniform float u_drop_rate_bump;\n\nvarying vec2 v_tex_pos;\n\n// pseudo-random generator\nconst vec3 rand_constants = vec3(12.9898, 78.233, 4375.85453);\nfloat rand(const vec2 co) {\n    float t = dot(rand_constants.xy, co);\n    return fract(sin(t) * (rand_constants.z + t));\n}\n\n// wind speed lookup; use manual bilinear filtering based on 4 adjacent pixels for smooth interpolation\nvec2 lookup_wind(const vec2 uv) {\n    // return texture2D(u_wind, uv).rg; // lower-res hardware filtering\n    vec2 px = 1.0 / u_wind_res;\n    vec2 vc = (floor(uv * u_wind_res)) * px;\n    vec2 f = fract(uv * u_wind_res);\n    vec2 tl = texture2D(u_wind, vc).rg;\n    vec2 tr = texture2D(u_wind, vc + vec2(px.x, 0)).rg;\n    vec2 bl = texture2D(u_wind, vc + vec2(0, px.y)).rg;\n    vec2 br = texture2D(u_wind, vc + px).rg;\n    return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);\n}\n\nvoid main() {\n    vec4 color = texture2D(u_particles, v_tex_pos);\n    vec2 pos = vec2(\n        color.r / 255.0 + color.b,\n        color.g / 255.0 + color.a); // decode particle position from pixel RGBA\n\n    if ( texture2D(u_wind, pos).rg == vec2(0.0, 0.0) ) {\n        discard;\n    }\n\n    vec2 velocity = mix(u_wind_min, u_wind_max, lookup_wind(pos));\n    float speed_t = length(velocity) / length(u_wind_max);\n\n    // take EPSG:4236 distortion into account for calculating where the particle moved\n    // float distortion = 1.0; //cos(radians(pos.y * 180.0 - 90.0));\n    // vec2 offset = vec2(velocity.x / distortion, -velocity.y) * 0.0001 * u_speed_factor;\n    vec2 offset = vec2(velocity.x, velocity.y) * 0.0001 * u_speed_factor;\n\n    // update particle position, wrapping around the date line\n    pos = fract(1.0 + pos + offset);\n\n    // a random seed to use for the particle drop\n    vec2 seed = (pos + v_tex_pos) * u_rand_seed;\n\n    // drop rate is a chance a particle will restart at random position, to avoid degeneration\n    float drop_rate = u_drop_rate + speed_t * u_drop_rate_bump;\n    float drop = step(1.0 - drop_rate, rand(seed));\n\n    vec2 random_pos = vec2(\n        rand(seed + 1.3),\n        rand(seed + 2.1));\n    pos = mix(pos, random_pos, drop);\n\n    // encode the new particle position back into RGBA\n    gl_FragColor = vec4(\n        fract(pos * 255.0),\n        floor(pos * 255.0) / 255.0);\n}\n";
+var drawFrag = "precision mediump float;\n\nuniform sampler2D u_wind;\nuniform vec2 u_wind_min;\nuniform vec2 u_wind_max;\nuniform sampler2D u_color_ramp;\nuniform float u_color_ramp_max;\nuniform float u_base_opacity;\n\nuniform float u_min_speed;\nuniform float u_max_speed;\n\nvarying vec2 v_particle_pos;\n\nvoid main() {\n    \n\n    if ( texture2D(u_wind, v_particle_pos).rg == vec2(0.0, 0.0) ) {\n        discard;\n    }\n    vec2 velocity = mix(u_wind_min, u_wind_max, texture2D(u_wind, v_particle_pos).rg);\n    float speed = length(velocity);\n    if (speed < u_min_speed || speed > u_max_speed) {\n        discard;\n    }\n    if (speed >= u_color_ramp_max) {\n        gl_FragColor = texture2D(u_color_ramp, \n            vec2( 0.99999 , 0.0001 )) * u_base_opacity;\n        return;\n    }\n\n    float speed_t = speed / u_color_ramp_max; // length(u_wind_max); // \n    // color ramp olusturulan method finalde texture ters \u00E7evriliyor. bu y\u00FCzden speed_t 1.0 - speed_t oluyor.\n    speed_t = 1.0 - speed_t;\n    // color ramp is encoded in a 16.0 x 16.0 texture\n    vec2 ramp_pos = vec2(\n        fract(16.0 * speed_t),\n        floor(16.0 * speed_t) / 16.0);\n\n\n    gl_FragColor = texture2D(u_color_ramp, ramp_pos) * u_base_opacity;\n}\n";
+var drawSphereVert = "\nprecision mediump float;\n\nattribute float a_index;\n\nuniform float u_point_size;\nuniform sampler2D u_particles;\nuniform float u_particles_res;\n\nuniform float u_height;\n\nvarying vec2 v_particle_pos;\nvarying float v_z;\n\nuniform mat3 u_bbox_matrix;\n\nuniform mat4 uModelViewMatrix;\nuniform mat4 uProjectionMatrix;\nuniform vec3 uTranslate;\n\nconst float PI = 3.141592653589793;\nconst float R = 6378.137;\n\nvec3 cartesian3DPoint( float longRad, float latRad, float height) {\n    float radius = R + height;\n    float x = radius * sin(latRad) * cos(longRad);\n    float y = radius * sin(latRad) * sin(longRad);\n    float z = radius * cos(latRad);\n    return vec3(\n        x, \n        y, \n        z) ;\n}\n\nvoid main() {\n    vec4 color = texture2D(u_particles, vec2(\n        fract(a_index / u_particles_res),\n        floor(a_index / u_particles_res) / u_particles_res));\n\n    v_particle_pos = vec2(\n        color.r / 255.0 + color.b,\n        color.g / 255.0 + color.a);\n    \n\n    if ( v_particle_pos.y < 0.0265 || v_particle_pos.y > 0.9735 ) {\n        gl_Position = vec4(-2.0, -2.0, -2.0, 1.0);\n        return;\n    }\n    vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, v_particle_pos.y, 1.0);\n    \n\n    float xRad = PI * (2.0 * pos.x - 1.0);\n    float yRad = pos.y * PI;\n\n    pos = cartesian3DPoint(xRad, yRad, u_height);\n    gl_Position = uProjectionMatrix * uModelViewMatrix * vec4(pos - uTranslate, 1.0);\n    gl_PointSize = u_point_size;\n\n}";
+var drawFlatVert = "\nprecision mediump float;\n\nuniform mat3 u_bbox_matrix;\n\nuniform vec3 uTranslate;\n// uniform mat4 uModelViewMatrix;\nuniform mat4 uProjectionMatrix;\n\nattribute float a_index;\nuniform sampler2D u_particles;\nuniform float u_particles_res;\nuniform float u_point_size;\nuniform vec2 u_mapWH;\nuniform vec2 u_scrWH;\n\nvarying vec2 v_particle_pos;\n\nconst float PI = 3.141592653589793;\nconst float POLE = 20037508.34;\nconst float POLE_BY_PI = POLE / PI;\nconst float HALF_PI = PI / 2.0;\n\n\nvoid main() {\n\n    vec4 color = texture2D(u_particles, vec2(\n        fract(a_index / u_particles_res),\n        floor(a_index / u_particles_res) / u_particles_res));\n\n    v_particle_pos = vec2(\n        color.r / 255.0 + color.b,\n        color.g / 255.0 + color.a);\n\n    if ( v_particle_pos.y < 0.0265 || v_particle_pos.y > 0.9735 ) {\n        gl_Position = vec4(-2.0, -2.0, -2.0, 1.0);\n        return;\n    }\n    vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, v_particle_pos.y, 1.0);\n    \n    float x = (2.0 * pos.x - 1.0);\n    float mercator_x = x * POLE;\n    float mercator_y = log( tan( ( 1.0 - pos.y ) * HALF_PI  ) ) * POLE_BY_PI;\n\n    float normalizedX = ( mercator_x - uTranslate.x) / u_mapWH.x;\n    float normalizedY = ( mercator_y - uTranslate.y) / u_mapWH.y;\n    gl_Position = uProjectionMatrix * vec4(normalizedX * u_scrWH.x, (1.0 - normalizedY) * u_scrWH.y, 0.0, 1.0);\n\n    gl_PointSize = u_point_size;\n}";
+var defaultRampColors = [
     [0.0, '#5e4fa2'],
     [0.08, '#3288bd'],
     [0.2, '#66c2a5'],
@@ -333,7 +88,7 @@ const defaultRampColors = [
     [0.7, '#f46d43'],
     [1.0, '#d53e4f']
 ];
-const windyLegendData = {
+var windyLegendData = {
     "thresholds": [0, 3, 3, 5, 5, 7, 10, 10, 13, 15, 15, 17, 20, 20, 25, 25, 30],
     //  0 5 10 20 30 40 60
     // "thresholds": [0, 5, 5, 10, 10, 15, 15, 20, 20, 25, 25, 30, 30, 35, 40, 60],
@@ -357,7 +112,7 @@ const windyLegendData = {
         "#5B88A1"
     ]
 };
-class WindPlugin {
+var WindPlugin = /** @class */ (function () {
     /**
      * @param {String} id
      * @param {Object} windDataMeta
@@ -377,7 +132,8 @@ class WindPlugin {
      * @param {number} numParticles - number of particles | positive integer
      * @param {LegendData} options.legendData - legend data
      */
-    constructor(id, windDataMeta, { fadeOpacity = 0.746, speedFactor = 0.6, dropRate = 0.007, dropRateBump = 0.001, baseOpacity = 1.0, pointSize = 2.0, minSpeed = 0.0, maxSpeed = 1000.0, height = 0.0, numParticles = 40000, legendData = windyLegendData } = {}) {
+    function WindPlugin(id, windDataMeta, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.fadeOpacity, fadeOpacity = _c === void 0 ? 0.746 : _c, _d = _b.speedFactor, speedFactor = _d === void 0 ? 0.6 : _d, _e = _b.dropRate, dropRate = _e === void 0 ? 0.007 : _e, _f = _b.dropRateBump, dropRateBump = _f === void 0 ? 0.001 : _f, _g = _b.baseOpacity, baseOpacity = _g === void 0 ? 1.0 : _g, _h = _b.pointSize, pointSize = _h === void 0 ? 2.0 : _h, _j = _b.minSpeed, minSpeed = _j === void 0 ? 0.0 : _j, _k = _b.maxSpeed, maxSpeed = _k === void 0 ? 1000.0 : _k, _l = _b.height, height = _l === void 0 ? 0.0 : _l, _m = _b.numParticles, numParticles = _m === void 0 ? 40000 : _m, _o = _b.legendData, legendData = _o === void 0 ? windyLegendData : _o;
         this.id = id;
         this._windDataMeta = windDataMeta;
         this.globe = null;
@@ -402,62 +158,98 @@ class WindPlugin {
         this._drawParticles = this._drawParticlesSphere;
         this._lastLOD = 0;
     }
-    // Uniforms are loaded once, on initiation and when they are changed.
-    set height(value) {
-        this._height = value;
-        this._loadHeight();
-    }
-    set minSpeed(value) {
-        this._minSpeed = value;
-        this._loadMinMaxSpeed();
-    }
-    set maxSpeed(value) {
-        this._maxSpeed = value;
-        this._loadMinMaxSpeed();
-    }
-    set fadeOpacity(value) {
-        this._fadeOpacity = value;
-        this._loadFadeOpacity();
-    }
-    set speedFactor(value) {
-        this._speedFactor = value;
-        this._loadSpeedFactor();
-    }
-    set dropRate(value) {
-        this._dropRate = value;
-        this._loadDropRate();
-    }
-    set dropRateBump(value) {
-        this._dropRateBump = value;
-        this._loadDropRateBump();
-    }
-    set baseOpacity(value) {
-        this._baseOpacity = value;
-        this._loadBaseOpacity();
-    }
-    set pointSize(value) {
-        this._pointSize = value;
-        this._loadPointSize();
-    }
+    Object.defineProperty(WindPlugin.prototype, "height", {
+        // Uniforms are loaded once, on initiation and when they are changed.
+        set: function (value) {
+            this._height = value;
+            this._loadHeight();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WindPlugin.prototype, "minSpeed", {
+        set: function (value) {
+            this._minSpeed = value;
+            this._loadMinMaxSpeed();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WindPlugin.prototype, "maxSpeed", {
+        set: function (value) {
+            this._maxSpeed = value;
+            this._loadMinMaxSpeed();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WindPlugin.prototype, "fadeOpacity", {
+        set: function (value) {
+            this._fadeOpacity = value;
+            this._loadFadeOpacity();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WindPlugin.prototype, "speedFactor", {
+        set: function (value) {
+            this._speedFactor = value;
+            this._loadSpeedFactor();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WindPlugin.prototype, "dropRate", {
+        set: function (value) {
+            this._dropRate = value;
+            this._loadDropRate();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WindPlugin.prototype, "dropRateBump", {
+        set: function (value) {
+            this._dropRateBump = value;
+            this._loadDropRateBump();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WindPlugin.prototype, "baseOpacity", {
+        set: function (value) {
+            this._baseOpacity = value;
+            this._loadBaseOpacity();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WindPlugin.prototype, "pointSize", {
+        set: function (value) {
+            this._pointSize = value;
+            this._loadPointSize();
+        },
+        enumerable: false,
+        configurable: true
+    });
     // Color ramp methods. 
     // Color ramp is used to colorize the particles according to their speed.
     // Legend max value is used to normalize the speed values.
-    setColorRamp(colors) {
+    WindPlugin.prototype.setColorRamp = function (colors) {
         // lookup texture for colorizing the particles according to their speed
         if (this.gl == null) {
             return;
         }
         this.colorRampTexture = util.createTexture(this.gl, this.gl.LINEAR, util.getColorRamp(colors), 16, 16);
-    }
-    setColorRampDefault() {
-        const { uMax, uMin, vMax, vMin } = this.windData;
-        const maxSpeed = Math.sqrt(uMax * uMax + vMax * vMax);
-        const minSpeed = Math.sqrt(uMin * uMin + vMin * vMin);
+    };
+    WindPlugin.prototype.setColorRampDefault = function () {
+        var _a = this.windData, uMax = _a.uMax, uMin = _a.uMin, vMax = _a.vMax, vMin = _a.vMin;
+        var maxSpeed = Math.sqrt(uMax * uMax + vMax * vMax);
+        var minSpeed = Math.sqrt(uMin * uMin + vMin * vMin);
         // console.log("maxSpeed", maxSpeed, "minSpeed", minSpeed);
         this._rampMax = maxSpeed > minSpeed ? maxSpeed : minSpeed;
         this._loadRampMax();
         this.setColorRamp(defaultRampColors);
-    }
+    };
     /**
      *
      * @param {*} legendData
@@ -465,60 +257,64 @@ class WindPlugin {
      * @param {Array} legendData.values - list of colors in hex format like #ff0000 (alpha is not included)
      *
      */
-    setLegend(legendData) {
-        const { gl } = this;
+    WindPlugin.prototype.setLegend = function (legendData) {
+        var gl = this.gl;
         if (gl === null) {
             throw new Error("wind plugin. setColorRampFromService is called before plugin is registered.");
         }
-        const { thresholds, values } = legendData;
+        var thresholds = legendData.thresholds, values = legendData.values;
         if (thresholds.length === 0 || values.length === 0) {
             return;
         }
         thresholds.push(thresholds[thresholds.length - 1]);
         values.push(values[values.length - 1]);
-        const maxVelocity = thresholds[thresholds.length - 1];
-        const colors = [];
-        for (let i = 0; i < thresholds.length; i++) {
+        var maxVelocity = thresholds[thresholds.length - 1];
+        var colors = [];
+        for (var i = 0; i < thresholds.length; i++) {
             colors.push([
                 thresholds[i] / maxVelocity,
                 values[i]
             ]);
         }
-        const colorRamp = util.getColorRamp(colors);
+        var colorRamp = util.getColorRamp(colors);
         this.colorRampTexture = util.createTexture(gl, gl.LINEAR, colorRamp, 16, 16);
         this._rampMax = maxVelocity;
         this._loadRampMax();
-    }
-    // particle coordinates are encoded into RGBA texture
-    set numParticles(numParticles) {
-        const gl = this.gl;
-        // we create a square texture where each pixel will hold a particle position encoded as RGBA
-        const particleRes = this.particleStateResolution = Math.ceil(Math.sqrt(numParticles));
-        this._numParticles = particleRes * particleRes;
-        const particleState = new Uint8Array(this._numParticles * 4);
-        for (let i = 0; i < particleState.length; i++) {
-            particleState[i] = Math.floor(Math.random() * 256); // randomize the initial particle positions
-        }
-        // textures to hold the particle state for the current and the next frame
-        this.particleStateTexture0 = util.createTexture(gl, gl.NEAREST, particleState, particleRes, particleRes);
-        this.particleStateTexture1 = util.createTexture(gl, gl.NEAREST, particleState, particleRes, particleRes);
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        gl.useProgram(this.updateProgram.program);
-        gl.uniform1f(this.updateProgram.u_wind_res, this.particleStateResolution);
-        gl.useProgram(this.drawSphereProgram.program);
-        gl.uniform1f(this.drawSphereProgram.u_particles_res, this.particleStateResolution);
-        gl.useProgram(this.drawFlatProgram.program);
-        gl.uniform1f(this.drawFlatProgram.u_particles_res, this.particleStateResolution);
-        gl.useProgram(currentProgram);
-        // console.log("numParticles", this._numParticles);
-        const particleIndices = new Float32Array(this._numParticles);
-        for (let i = 0; i < this._numParticles; i++)
-            particleIndices[i] = i;
-        this.particleIndexBuffer = util.createBuffer(gl, particleIndices);
-    }
-    get numParticles() {
-        return this._numParticles;
-    }
+    };
+    Object.defineProperty(WindPlugin.prototype, "numParticles", {
+        get: function () {
+            return this._numParticles;
+        },
+        // particle coordinates are encoded into RGBA texture
+        set: function (numParticles) {
+            var gl = this.gl;
+            // we create a square texture where each pixel will hold a particle position encoded as RGBA
+            var particleRes = this.particleStateResolution = Math.ceil(Math.sqrt(numParticles));
+            this._numParticles = particleRes * particleRes;
+            var particleState = new Uint8Array(this._numParticles * 4);
+            for (var i = 0; i < particleState.length; i++) {
+                particleState[i] = Math.floor(Math.random() * 256); // randomize the initial particle positions
+            }
+            // textures to hold the particle state for the current and the next frame
+            this.particleStateTexture0 = util.createTexture(gl, gl.NEAREST, particleState, particleRes, particleRes);
+            this.particleStateTexture1 = util.createTexture(gl, gl.NEAREST, particleState, particleRes, particleRes);
+            var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(this.updateProgram.program);
+            gl.uniform1f(this.updateProgram.u_wind_res, this.particleStateResolution);
+            gl.useProgram(this.drawSphereProgram.program);
+            gl.uniform1f(this.drawSphereProgram.u_particles_res, this.particleStateResolution);
+            gl.useProgram(this.drawFlatProgram.program);
+            gl.uniform1f(this.drawFlatProgram.u_particles_res, this.particleStateResolution);
+            gl.useProgram(currentProgram);
+            // console.log("numParticles", this._numParticles);
+            var particleIndices = new Float32Array(this._numParticles);
+            for (var i = 0; i < this._numParticles; i++)
+                particleIndices[i] = i;
+            this.particleIndexBuffer = util.createBuffer(gl, particleIndices);
+        },
+        enumerable: false,
+        configurable: true
+    });
     // Vector field texture is used to calculate the particle movement.
     /**
      * @param {Object} windData
@@ -529,27 +325,27 @@ class WindPlugin {
      * @param {number} windData.uMax - maximum u value
      * @param {number} windData.vMax - maximum v value
      */
-    setWind(windData) {
+    WindPlugin.prototype.setWind = function (windData) {
         if (windData === null) {
             return;
         }
-        const windDataMeta = this._windDataMeta;
-        const gl = this.gl;
+        var windDataMeta = this._windDataMeta;
+        var gl = this.gl;
         this.windData = windData;
         this.windTexture = util.createTexture(gl, gl.LINEAR, windData.image);
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(this.updateProgram.program);
         gl.uniform2f(this.updateProgram.u_wind_res, windDataMeta.width, windDataMeta.height);
         gl.uniform2f(this.updateProgram.u_wind_min, this.windData.uMin, this.windData.vMin);
         gl.uniform2f(this.updateProgram.u_wind_max, this.windData.uMax, this.windData.vMax);
         this.setGeometry();
-        const minXY = this._latLongToPixelXY(windDataMeta.bbox[1], windDataMeta.bbox[0]);
-        const maxXY = this._latLongToPixelXY(windDataMeta.bbox[3], windDataMeta.bbox[2]);
+        var minXY = this._latLongToPixelXY(windDataMeta.bbox[1], windDataMeta.bbox[0]);
+        var maxXY = this._latLongToPixelXY(windDataMeta.bbox[3], windDataMeta.bbox[2]);
         this._loadBoundingBoxData(minXY.x, minXY.y, maxXY.x, maxXY.y);
         gl.useProgram(currentProgram);
         this._setCoorcinatesDataCalculatorData();
         this.resize();
-    }
+    };
     // Vector field texture is used to calculate the particle movement.
     /**
      * @param {Object} windData
@@ -562,58 +358,59 @@ class WindPlugin {
      * @param {number} windData.vMax - maximum v value
      * @param {Array} windData.bbox - bounding box [minLon, minLat, maxLon, maxLat]
      */
-    setWindDataWithImageBase64(windData) {
-        const image = util.createImageFromBase64(windData.image);
-        image.onload = () => {
+    WindPlugin.prototype.setWindDataWithImageBase64 = function (windData) {
+        var _this = this;
+        var image = util.createImageFromBase64(windData.image);
+        image.onload = function () {
             windData.image = image;
-            this.setWind(windData);
+            _this.setWind(windData);
         };
-    }
-    getPointCoordinatesDataCalculator() {
+    };
+    WindPlugin.prototype.getPointCoordinatesDataCalculator = function () {
         if (!this.coordinatesDataCalculator)
             this._createPointCoordinatesDataCalculator();
         return this.coordinatesDataCalculator;
-    }
-    _createPointCoordinatesDataCalculator() {
-        const { bbox, width, height } = this._windDataMeta;
+    };
+    WindPlugin.prototype._createPointCoordinatesDataCalculator = function () {
+        var _a = this._windDataMeta, bbox = _a.bbox, width = _a.width, height = _a.height;
         this.coordinatesDataCalculator = new util_1.PointCoordinatesDataCalculator(bbox, width, height);
         this._setCoorcinatesDataCalculatorData();
-    }
-    _setCoorcinatesDataCalculatorData() {
+    };
+    WindPlugin.prototype._setCoorcinatesDataCalculatorData = function () {
         if (!this.windData || !this.coordinatesDataCalculator) {
             return;
         }
-        const magnitude = (0, imagetovectorfieldandmagnitude_1.default)(this.windData);
+        var magnitude = (0, imagetovectorfieldandmagnitude_1.default)(this.windData);
         this.coordinatesDataCalculator.updateData(0, magnitude, magnitude);
-    }
+    };
     // -----------------------------------------------
     //             --- inner methods ---
     // -----------------------------------------------
-    _latLongToPixelXY(latitude, longitude) {
+    WindPlugin.prototype._latLongToPixelXY = function (latitude, longitude) {
         return {
             x: (longitude + 180) / 360,
             y: (90 - latitude) / 180
         };
-    }
-    _loadBoundingBoxData(minX, minY, maxX, maxY) {
+    };
+    WindPlugin.prototype._loadBoundingBoxData = function (minX, minY, maxX, maxY) {
         // console.log("minX", minX, "minY", minY, "maxX", maxX, "maxY", maxY)
-        const gl = this.gl;
-        const bboxMatrix = new Float32Array([
+        var gl = this.gl;
+        var bboxMatrix = new Float32Array([
             maxX - minX, 0, 0,
             0, maxY - minY, 0,
             minX, minY, 1
         ]);
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(this.drawSphereProgram.program);
         gl.uniformMatrix3fv(this.drawSphereProgram.u_bbox_matrix, false, bboxMatrix);
         gl.useProgram(this.drawFlatProgram.program);
         gl.uniformMatrix3fv(this.drawFlatProgram.u_bbox_matrix, false, bboxMatrix);
         gl.useProgram(currentProgram);
-    }
+    };
     // When the screen is moved, the particles are reset to random positions.
     // During movement plugin should not draw the particles.
-    _doDraw() {
-        const globe = this.globe;
+    WindPlugin.prototype._doDraw = function () {
+        var globe = this.globe;
         if (this.windData === null) {
             return false;
         }
@@ -632,23 +429,23 @@ class WindPlugin {
             }
             return true;
         }
-    }
-    _draw() {
-        const gl = this.gl;
+    };
+    WindPlugin.prototype._draw = function () {
+        var gl = this.gl;
         this._drawScreen();
         this._updateParticles();
         gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    }
+    };
     // globe calls `draw3D` method on each frame
-    draw3D(projMatrix, modelviewMatrix, transPos) {
-        const gl = this.gl;
+    WindPlugin.prototype.draw3D = function (projMatrix, modelviewMatrix, transPos) {
+        var gl = this.gl;
         gl.bindFramebuffer(gl.FRAMEBUFFER, null);
         this.transPos.set([transPos.x, transPos.y, transPos.z], 0);
         this.projMatrix = projMatrix;
         this.modelviewMatrix = modelviewMatrix;
         gl.activeTexture(gl.TEXTURE0);
         if (this._doDraw()) {
-            const depthTest = gl.isEnabled(gl.DEPTH_TEST);
+            var depthTest = gl.isEnabled(gl.DEPTH_TEST);
             if (depthTest)
                 gl.disable(gl.DEPTH_TEST);
             // if (gl.disable(gl.STENCIL_TEST); // 
@@ -666,9 +463,9 @@ class WindPlugin {
         // this._drawTexture(this.colorRampTexture, 1.0);
         this._resetMachineStates();
         this.globe.DrawRender();
-    }
-    _drawScreen() {
-        const { gl, globe } = this;
+    };
+    WindPlugin.prototype._drawScreen = function () {
+        var _a = this, gl = _a.gl, globe = _a.globe;
         util.bindTexture(gl, this.windTexture, 0);
         util.bindTexture(gl, this.particleStateTexture0, 1);
         // draw the screen into a temporary framebuffer to retain it as the background on the next frame
@@ -682,33 +479,33 @@ class WindPlugin {
         this._drawTexture(this.screenTexture, 1.0);
         gl.disable(gl.BLEND);
         // save the current screen as the background for the next frame
-        const temp = this.backgroundTexture;
+        var temp = this.backgroundTexture;
         this.backgroundTexture = this.screenTexture;
         this.screenTexture = temp;
-    }
-    _drawTexture(texture, opacity) {
-        const gl = this.gl;
-        const program = this.screenProgram;
+    };
+    WindPlugin.prototype._drawTexture = function (texture, opacity) {
+        var gl = this.gl;
+        var program = this.screenProgram;
         gl.useProgram(program.program);
         util.bindAttribute(gl, this.quadBuffer, program.a_pos, 2);
         util.bindTexture(gl, texture, 2);
         gl.uniform1i(program.u_screen, 2);
         gl.uniform1f(program.u_opacity, opacity);
         gl.drawArrays(gl.TRIANGLES, 0, 6);
-    }
-    _loadRampMax() {
-        const { gl } = this;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+    };
+    WindPlugin.prototype._loadRampMax = function () {
+        var gl = this.gl;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         // console.log("load ramp max", this._rampMax);
         gl.useProgram(this.drawSphereProgram.program);
         gl.uniform1f(this.drawSphereProgram.u_color_ramp_max, this._rampMax);
         gl.useProgram(this.drawFlatProgram.program);
         gl.uniform1f(this.drawFlatProgram.u_color_ramp_max, this._rampMax);
         gl.useProgram(currentProgram);
-    }
-    _drawParticlesSphere() {
-        const { gl, projMatrix, modelviewMatrix, transPos } = this;
-        const program = this.drawSphereProgram;
+    };
+    WindPlugin.prototype._drawParticlesSphere = function () {
+        var _a = this, gl = _a.gl, projMatrix = _a.projMatrix, modelviewMatrix = _a.modelviewMatrix, transPos = _a.transPos;
+        var program = this.drawSphereProgram;
         gl.useProgram(program.program);
         util.bindAttribute(gl, this.particleIndexBuffer, program.a_index, 1);
         util.bindTexture(gl, this.colorRampTexture, 2);
@@ -719,10 +516,10 @@ class WindPlugin {
         gl.uniformMatrix4fv(program.uModelViewMatrix, false, modelviewMatrix);
         gl.uniform3fv(program.uTranslate, transPos);
         gl.drawArrays(gl.POINTS, 0, this._numParticles);
-    }
-    _drawParticlesFlat() {
-        const { gl, transPos, projMatrix, globe } = this;
-        const program = this.drawFlatProgram;
+    };
+    WindPlugin.prototype._drawParticlesFlat = function () {
+        var _a = this, gl = _a.gl, transPos = _a.transPos, projMatrix = _a.projMatrix, globe = _a.globe;
+        var program = this.drawFlatProgram;
         gl.useProgram(program.program);
         util.bindAttribute(gl, this.particleIndexBuffer, program.a_index, 1);
         util.bindTexture(gl, this.colorRampTexture, 2);
@@ -730,20 +527,20 @@ class WindPlugin {
         gl.uniform1i(program.u_particles, 1);
         gl.uniform1i(program.u_color_ramp, 2);
         gl.uniform2f(program.u_scrWH, globe.api_ScrW(), globe.api_ScrH());
-        const { width, height } = globe.api_GetCurrentWorldWH();
+        var _b = globe.api_GetCurrentWorldWH(), width = _b.width, height = _b.height;
         gl.uniform2f(program.u_mapWH, width, height);
         gl.uniformMatrix4fv(program.uProjectionMatrix, false, projMatrix);
         gl.uniform3fv(program.uTranslate, transPos);
         gl.drawArrays(gl.POINTS, 0, this._numParticles);
-    }
+    };
     // globe calls `setGeometry` method on map projection change. FLAT or SPHERE
-    setGeometry() {
+    WindPlugin.prototype.setGeometry = function () {
         if (this.windData === null) {
             return;
         }
-        const { globe, gl } = this;
-        const geometry = globe.api_GetCurrentGeometry();
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var _a = this, globe = _a.globe, gl = _a.gl;
+        var geometry = globe.api_GetCurrentGeometry();
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         if (geometry === globe.api_GeometryTypes().SPHERE) {
             this._drawParticles = this._drawParticlesSphere;
             gl.useProgram(this.drawSphereProgram.program);
@@ -761,10 +558,10 @@ class WindPlugin {
         }
         gl.useProgram(currentProgram);
         this.resize();
-    }
-    _updateParticles() {
-        const gl = this.gl;
-        const program = this.updateProgram;
+    };
+    WindPlugin.prototype._updateParticles = function () {
+        var gl = this.gl;
+        var program = this.updateProgram;
         gl.useProgram(program.program);
         gl.viewport(0, 0, this.particleStateResolution, this.particleStateResolution);
         util.bindAttribute(gl, this.quadBuffer, program.a_pos, 2);
@@ -775,31 +572,31 @@ class WindPlugin {
         util.bindFramebuffer(gl, this.framebuffer, this.particleStateTexture1);
         gl.drawArrays(gl.TRIANGLES, 0, 6);
         // swap the particle state textures so the new one becomes the current one
-        const temp = this.particleStateTexture0;
+        var temp = this.particleStateTexture0;
         this.particleStateTexture0 = this.particleStateTexture1;
         this.particleStateTexture1 = temp;
-    }
-    _resetMachineStates() {
-        const { gl, globe } = this;
+    };
+    WindPlugin.prototype._resetMachineStates = function () {
+        var _a = this, gl = _a.gl, globe = _a.globe;
         // gl.disable(gl.DEPTH_TEST);
         // gl.disable(gl.STENCIL_TEST);
         gl.activeTexture(gl.TEXTURE0);
         gl.viewport(0, 0, globe.api_ScrW(), globe.api_ScrH());
-    }
-    _loadHeight() {
-        const { gl, drawSphereProgram } = this;
+    };
+    WindPlugin.prototype._loadHeight = function () {
+        var _a = this, gl = _a.gl, drawSphereProgram = _a.drawSphereProgram;
         if (gl == null)
             return;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(drawSphereProgram.program);
         gl.uniform1f(drawSphereProgram.u_height, this._height);
         gl.useProgram(currentProgram);
-    }
-    _loadMinMaxSpeed() {
-        const { gl, drawSphereProgram, drawFlatProgram } = this;
+    };
+    WindPlugin.prototype._loadMinMaxSpeed = function () {
+        var _a = this, gl = _a.gl, drawSphereProgram = _a.drawSphereProgram, drawFlatProgram = _a.drawFlatProgram;
         if (gl == null)
             return;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(drawSphereProgram.program);
         gl.uniform1f(drawSphereProgram.u_min_speed, this._minSpeed);
         gl.uniform1f(drawSphereProgram.u_max_speed, this._maxSpeed);
@@ -807,73 +604,73 @@ class WindPlugin {
         gl.uniform1f(drawFlatProgram.u_min_speed, this._minSpeed);
         gl.uniform1f(drawFlatProgram.u_max_speed, this._maxSpeed);
         gl.useProgram(currentProgram);
-    }
-    _loadFadeOpacity() {
-        const { gl, screenProgram } = this;
+    };
+    WindPlugin.prototype._loadFadeOpacity = function () {
+        var _a = this, gl = _a.gl, screenProgram = _a.screenProgram;
         if (gl == null) {
             return;
         }
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(screenProgram.program);
         gl.uniform1f(screenProgram.u_opacity, this._fadeOpacity);
         gl.useProgram(currentProgram);
-    }
-    _loadSpeedFactor() {
-        const { gl, globe, updateProgram } = this;
+    };
+    WindPlugin.prototype._loadSpeedFactor = function () {
+        var _a = this, gl = _a.gl, globe = _a.globe, updateProgram = _a.updateProgram;
         if (gl == null) {
             return;
         }
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(updateProgram.program);
         gl.uniform1f(updateProgram.u_speed_factor, this._speedFactor / Math.ceil(Math.sqrt(globe.api_GetCurrentLOD())));
         gl.useProgram(currentProgram);
-    }
-    _loadDropRate() {
-        const { gl, updateProgram } = this;
+    };
+    WindPlugin.prototype._loadDropRate = function () {
+        var _a = this, gl = _a.gl, updateProgram = _a.updateProgram;
         if (gl == null) {
             return;
         }
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(updateProgram.program);
         gl.uniform1f(updateProgram.u_drop_rate, this._dropRate);
         gl.useProgram(currentProgram);
-    }
-    _loadDropRateBump() {
-        const { gl, updateProgram } = this;
+    };
+    WindPlugin.prototype._loadDropRateBump = function () {
+        var _a = this, gl = _a.gl, updateProgram = _a.updateProgram;
         if (gl == null) {
             return;
         }
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(updateProgram.program);
         gl.uniform1f(updateProgram.u_drop_rate_bump, this._dropRateBump);
         gl.useProgram(currentProgram);
-    }
-    _loadBaseOpacity() {
-        const { gl, drawSphereProgram, drawFlatProgram } = this;
+    };
+    WindPlugin.prototype._loadBaseOpacity = function () {
+        var _a = this, gl = _a.gl, drawSphereProgram = _a.drawSphereProgram, drawFlatProgram = _a.drawFlatProgram;
         if (gl == null) {
             return;
         }
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(drawSphereProgram.program);
         gl.uniform1f(drawSphereProgram.u_base_opacity, this._baseOpacity);
         gl.useProgram(drawFlatProgram.program);
         gl.uniform1f(drawFlatProgram.u_base_opacity, this._baseOpacity);
         gl.useProgram(currentProgram);
-    }
-    _loadPointSize() {
-        const { gl, drawSphereProgram, drawFlatProgram } = this;
+    };
+    WindPlugin.prototype._loadPointSize = function () {
+        var _a = this, gl = _a.gl, drawSphereProgram = _a.drawSphereProgram, drawFlatProgram = _a.drawFlatProgram;
         if (gl == null) {
             return;
         }
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(drawSphereProgram.program);
         gl.uniform1f(drawSphereProgram.u_point_size, this._pointSize);
         gl.useProgram(drawFlatProgram.program);
         gl.uniform1f(drawFlatProgram.u_point_size, this._pointSize);
         gl.useProgram(currentProgram);
-    }
+    };
     // globe plugin init methodu
-    init(globe, gl) {
+    WindPlugin.prototype.init = function (globe, gl) {
         // console.log("init wind plugin")
         this.globe = globe;
         this.gl = gl;
@@ -896,18 +693,18 @@ class WindPlugin {
         }
         this.numParticles = this._numParticles;
         this.resize();
-    }
-    resize(a, b) {
-        const { gl, globe } = this;
-        const emptyPixels = new Uint8Array(globe.api_ScrW() * globe.api_ScrH() * 4);
+    };
+    WindPlugin.prototype.resize = function (a, b) {
+        var _a = this, gl = _a.gl, globe = _a.globe;
+        var emptyPixels = new Uint8Array(globe.api_ScrW() * globe.api_ScrH() * 4);
         // screen textures to hold the drawn screen for the previous and the current frame
         this.backgroundTexture = util.createTexture(gl, gl.LINEAR, emptyPixels, globe.api_ScrW(), globe.api_ScrH());
         this.screenTexture = util.createTexture(gl, gl.LINEAR, emptyPixels, globe.api_ScrW(), globe.api_ScrH());
         gl.viewport(0, 0, globe.api_ScrW(), globe.api_ScrH());
-    }
+    };
     // globe calls this `free` on plugin object unregistration
-    free() {
-        const gl = this.gl;
+    WindPlugin.prototype.free = function () {
+        var gl = this.gl;
         gl.deleteBuffer(this.quadBuffer);
         gl.deleteFramebuffer(this.framebuffer);
         gl.deleteTexture(this.backgroundTexture);
@@ -921,6 +718,7 @@ class WindPlugin {
         gl.deleteProgram(this.updateProgram.program);
         gl.deleteProgram(this.drawFlatProgram.program);
         gl.deleteBuffer(this.particleIndexBuffer);
-    }
-}
+    };
+    return WindPlugin;
+}());
 exports.default = WindPlugin;