highcharts 10.0.0 → 10.2.1

package/es-modules/Extensions/Boost/WGLShader.js

@@ -12,460 +12,454 @@
 'use strict';
 import U from '../../Core/Utilities.js';
 var clamp = U.clamp, error = U.error, pick = U.pick;
+/* *
+ *
+ *  Constants
+ *
+ * */
+var fragmentShader = [
+    /* eslint-disable max-len, @typescript-eslint/indent */
+    'precision highp float;',
+    'uniform vec4 fillColor;',
+    'varying highp vec2 position;',
+    'varying highp vec4 vColor;',
+    'uniform sampler2D uSampler;',
+    'uniform bool isCircle;',
+    'uniform bool hasColor;',
+    // 'vec4 toColor(float value, vec2 point) {',
+    //     'return vec4(0.0, 0.0, 0.0, 0.0);',
+    // '}',
+    'void main(void) {',
+    'vec4 col = fillColor;',
+    'vec4 tcol = texture2D(uSampler, gl_PointCoord.st);',
+    'if (hasColor) {',
+    'col = vColor;',
+    '}',
+    'if (isCircle) {',
+    'col *= tcol;',
+    'if (tcol.r < 0.0) {',
+    'discard;',
+    '} else {',
+    'gl_FragColor = col;',
+    '}',
+    '} else {',
+    'gl_FragColor = col;',
+    '}',
+    '}'
+    /* eslint-enable max-len, @typescript-eslint/indent */
+].join('\n');
+var vertexShader = [
+    /* eslint-disable max-len, @typescript-eslint/indent */
+    '#version 100',
+    '#define LN10 2.302585092994046',
+    'precision highp float;',
+    'attribute vec4 aVertexPosition;',
+    'attribute vec4 aColor;',
+    'varying highp vec2 position;',
+    'varying highp vec4 vColor;',
+    'uniform mat4 uPMatrix;',
+    'uniform float pSize;',
+    'uniform float translatedThreshold;',
+    'uniform bool hasThreshold;',
+    'uniform bool skipTranslation;',
+    'uniform float xAxisTrans;',
+    'uniform float xAxisMin;',
+    'uniform float xAxisMinPad;',
+    'uniform float xAxisPointRange;',
+    'uniform float xAxisLen;',
+    'uniform bool  xAxisPostTranslate;',
+    'uniform float xAxisOrdinalSlope;',
+    'uniform float xAxisOrdinalOffset;',
+    'uniform float xAxisPos;',
+    'uniform bool  xAxisCVSCoord;',
+    'uniform bool  xAxisIsLog;',
+    'uniform bool  xAxisReversed;',
+    'uniform float yAxisTrans;',
+    'uniform float yAxisMin;',
+    'uniform float yAxisMinPad;',
+    'uniform float yAxisPointRange;',
+    'uniform float yAxisLen;',
+    'uniform bool  yAxisPostTranslate;',
+    'uniform float yAxisOrdinalSlope;',
+    'uniform float yAxisOrdinalOffset;',
+    'uniform float yAxisPos;',
+    'uniform bool  yAxisCVSCoord;',
+    'uniform bool  yAxisIsLog;',
+    'uniform bool  yAxisReversed;',
+    'uniform bool  isBubble;',
+    'uniform bool  bubbleSizeByArea;',
+    'uniform float bubbleZMin;',
+    'uniform float bubbleZMax;',
+    'uniform float bubbleZThreshold;',
+    'uniform float bubbleMinSize;',
+    'uniform float bubbleMaxSize;',
+    'uniform bool  bubbleSizeAbs;',
+    'uniform bool  isInverted;',
+    'float bubbleRadius(){',
+    'float value = aVertexPosition.w;',
+    'float zMax = bubbleZMax;',
+    'float zMin = bubbleZMin;',
+    'float radius = 0.0;',
+    'float pos = 0.0;',
+    'float zRange = zMax - zMin;',
+    'if (bubbleSizeAbs){',
+    'value = value - bubbleZThreshold;',
+    'zMax = max(zMax - bubbleZThreshold, zMin - bubbleZThreshold);',
+    'zMin = 0.0;',
+    '}',
+    'if (value < zMin){',
+    'radius = bubbleZMin / 2.0 - 1.0;',
+    '} else {',
+    'pos = zRange > 0.0 ? (value - zMin) / zRange : 0.5;',
+    'if (bubbleSizeByArea && pos > 0.0){',
+    'pos = sqrt(pos);',
+    '}',
+    'radius = ceil(bubbleMinSize + pos * (bubbleMaxSize - bubbleMinSize)) / 2.0;',
+    '}',
+    'return radius * 2.0;',
+    '}',
+    'float translate(float val,',
+    'float pointPlacement,',
+    'float localA,',
+    'float localMin,',
+    'float minPixelPadding,',
+    'float pointRange,',
+    'float len,',
+    'bool  cvsCoord,',
+    'bool  isLog,',
+    'bool  reversed',
+    '){',
+    'float sign = 1.0;',
+    'float cvsOffset = 0.0;',
+    'if (cvsCoord) {',
+    'sign *= -1.0;',
+    'cvsOffset = len;',
+    '}',
+    'if (isLog) {',
+    'val = log(val) / LN10;',
+    '}',
+    'if (reversed) {',
+    'sign *= -1.0;',
+    'cvsOffset -= sign * len;',
+    '}',
+    'return sign * (val - localMin) * localA + cvsOffset + ',
+    '(sign * minPixelPadding);',
+    '}',
+    'float xToPixels(float value) {',
+    'if (skipTranslation){',
+    'return value;// + xAxisPos;',
+    '}',
+    'return translate(value, 0.0, xAxisTrans, xAxisMin, xAxisMinPad, xAxisPointRange, xAxisLen, xAxisCVSCoord, xAxisIsLog, xAxisReversed);// + xAxisPos;',
+    '}',
+    'float yToPixels(float value, float checkTreshold) {',
+    'float v;',
+    'if (skipTranslation){',
+    'v = value;// + yAxisPos;',
+    '} else {',
+    'v = translate(value, 0.0, yAxisTrans, yAxisMin, yAxisMinPad, yAxisPointRange, yAxisLen, yAxisCVSCoord, yAxisIsLog, yAxisReversed);// + yAxisPos;',
+    'if (v > yAxisLen) {',
+    'v = yAxisLen;',
+    '}',
+    '}',
+    'if (checkTreshold > 0.0 && hasThreshold) {',
+    'v = min(v, translatedThreshold);',
+    '}',
+    'return v;',
+    '}',
+    'void main(void) {',
+    'if (isBubble){',
+    'gl_PointSize = bubbleRadius();',
+    '} else {',
+    'gl_PointSize = pSize;',
+    '}',
+    // 'gl_PointSize = 10.0;',
+    'vColor = aColor;',
+    'if (skipTranslation && isInverted) {',
+    // If we get translated values from JS, just swap them (x, y)
+    'gl_Position = uPMatrix * vec4(aVertexPosition.y + yAxisPos, aVertexPosition.x + xAxisPos, 0.0, 1.0);',
+    '} else if (isInverted) {',
+    // But when calculating pixel positions directly,
+    // swap axes and values (x, y)
+    'gl_Position = uPMatrix * vec4(yToPixels(aVertexPosition.y, aVertexPosition.z) + yAxisPos, xToPixels(aVertexPosition.x) + xAxisPos, 0.0, 1.0);',
+    '} else {',
+    'gl_Position = uPMatrix * vec4(xToPixels(aVertexPosition.x) + xAxisPos, yToPixels(aVertexPosition.y, aVertexPosition.z) + yAxisPos, 0.0, 1.0);',
+    '}',
+    // 'gl_Position = uPMatrix * vec4(aVertexPosition.x, aVertexPosition.y, 0.0, 1.0);',
+    '}'
+    /* eslint-enable max-len, @typescript-eslint/indent */
+].join('\n');
+/* *
+ *
+ *  Class
+ *
+ * */
 /* eslint-disable valid-jsdoc */
 /**
  * A static shader mimicing axis translation functions found in Core/Axis
  *
  * @private
- * @function GLShader
  *
  * @param {WebGLContext} gl
  * the context in which the shader is active
  */
-function GLShader(gl) {
-    var vertShade = [
-        /* eslint-disable max-len, @typescript-eslint/indent */
-        '#version 100',
-        '#define LN10 2.302585092994046',
-        'precision highp float;',
-        'attribute vec4 aVertexPosition;',
-        'attribute vec4 aColor;',
-        'varying highp vec2 position;',
-        'varying highp vec4 vColor;',
-        'uniform mat4 uPMatrix;',
-        'uniform float pSize;',
-        'uniform float translatedThreshold;',
-        'uniform bool hasThreshold;',
-        'uniform bool skipTranslation;',
-        'uniform float xAxisTrans;',
-        'uniform float xAxisMin;',
-        'uniform float xAxisMinPad;',
-        'uniform float xAxisPointRange;',
-        'uniform float xAxisLen;',
-        'uniform bool  xAxisPostTranslate;',
-        'uniform float xAxisOrdinalSlope;',
-        'uniform float xAxisOrdinalOffset;',
-        'uniform float xAxisPos;',
-        'uniform bool  xAxisCVSCoord;',
-        'uniform bool  xAxisIsLog;',
-        'uniform bool  xAxisReversed;',
-        'uniform float yAxisTrans;',
-        'uniform float yAxisMin;',
-        'uniform float yAxisMinPad;',
-        'uniform float yAxisPointRange;',
-        'uniform float yAxisLen;',
-        'uniform bool  yAxisPostTranslate;',
-        'uniform float yAxisOrdinalSlope;',
-        'uniform float yAxisOrdinalOffset;',
-        'uniform float yAxisPos;',
-        'uniform bool  yAxisCVSCoord;',
-        'uniform bool  yAxisIsLog;',
-        'uniform bool  yAxisReversed;',
-        'uniform bool  isBubble;',
-        'uniform bool  bubbleSizeByArea;',
-        'uniform float bubbleZMin;',
-        'uniform float bubbleZMax;',
-        'uniform float bubbleZThreshold;',
-        'uniform float bubbleMinSize;',
-        'uniform float bubbleMaxSize;',
-        'uniform bool  bubbleSizeAbs;',
-        'uniform bool  isInverted;',
-        'float bubbleRadius(){',
-        'float value = aVertexPosition.w;',
-        'float zMax = bubbleZMax;',
-        'float zMin = bubbleZMin;',
-        'float radius = 0.0;',
-        'float pos = 0.0;',
-        'float zRange = zMax - zMin;',
-        'if (bubbleSizeAbs){',
-        'value = value - bubbleZThreshold;',
-        'zMax = max(zMax - bubbleZThreshold, zMin - bubbleZThreshold);',
-        'zMin = 0.0;',
-        '}',
-        'if (value < zMin){',
-        'radius = bubbleZMin / 2.0 - 1.0;',
-        '} else {',
-        'pos = zRange > 0.0 ? (value - zMin) / zRange : 0.5;',
-        'if (bubbleSizeByArea && pos > 0.0){',
-        'pos = sqrt(pos);',
-        '}',
-        'radius = ceil(bubbleMinSize + pos * (bubbleMaxSize - bubbleMinSize)) / 2.0;',
-        '}',
-        'return radius * 2.0;',
-        '}',
-        'float translate(float val,',
-        'float pointPlacement,',
-        'float localA,',
-        'float localMin,',
-        'float minPixelPadding,',
-        'float pointRange,',
-        'float len,',
-        'bool  cvsCoord,',
-        'bool  isLog,',
-        'bool  reversed',
-        '){',
-        'float sign = 1.0;',
-        'float cvsOffset = 0.0;',
-        'if (cvsCoord) {',
-        'sign *= -1.0;',
-        'cvsOffset = len;',
-        '}',
-        'if (isLog) {',
-        'val = log(val) / LN10;',
-        '}',
-        'if (reversed) {',
-        'sign *= -1.0;',
-        'cvsOffset -= sign * len;',
-        '}',
-        'return sign * (val - localMin) * localA + cvsOffset + ',
-        '(sign * minPixelPadding);',
-        '}',
-        'float xToPixels(float value) {',
-        'if (skipTranslation){',
-        'return value;// + xAxisPos;',
-        '}',
-        'return translate(value, 0.0, xAxisTrans, xAxisMin, xAxisMinPad, xAxisPointRange, xAxisLen, xAxisCVSCoord, xAxisIsLog, xAxisReversed);// + xAxisPos;',
-        '}',
-        'float yToPixels(float value, float checkTreshold) {',
-        'float v;',
-        'if (skipTranslation){',
-        'v = value;// + yAxisPos;',
-        '} else {',
-        'v = translate(value, 0.0, yAxisTrans, yAxisMin, yAxisMinPad, yAxisPointRange, yAxisLen, yAxisCVSCoord, yAxisIsLog, yAxisReversed);// + yAxisPos;',
-        'if (v > yAxisLen) {',
-        'v = yAxisLen;',
-        '}',
-        '}',
-        'if (checkTreshold > 0.0 && hasThreshold) {',
-        'v = min(v, translatedThreshold);',
-        '}',
-        'return v;',
-        '}',
-        'void main(void) {',
-        'if (isBubble){',
-        'gl_PointSize = bubbleRadius();',
-        '} else {',
-        'gl_PointSize = pSize;',
-        '}',
-        // 'gl_PointSize = 10.0;',
-        'vColor = aColor;',
-        'if (skipTranslation && isInverted) {',
-        // If we get translated values from JS, just swap them (x, y)
-        'gl_Position = uPMatrix * vec4(aVertexPosition.y + yAxisPos, aVertexPosition.x + xAxisPos, 0.0, 1.0);',
-        '} else if (isInverted) {',
-        // But when calculating pixel positions directly,
-        // swap axes and values (x, y)
-        'gl_Position = uPMatrix * vec4(yToPixels(aVertexPosition.y, aVertexPosition.z) + yAxisPos, xToPixels(aVertexPosition.x) + xAxisPos, 0.0, 1.0);',
-        '} else {',
-        'gl_Position = uPMatrix * vec4(xToPixels(aVertexPosition.x) + xAxisPos, yToPixels(aVertexPosition.y, aVertexPosition.z) + yAxisPos, 0.0, 1.0);',
-        '}',
-        // 'gl_Position = uPMatrix * vec4(aVertexPosition.x, aVertexPosition.y, 0.0, 1.0);',
-        '}'
-        /* eslint-enable max-len, @typescript-eslint/indent */
-    ].join('\n'), 
-    // Fragment shader source
-    fragShade = [
-        /* eslint-disable max-len, @typescript-eslint/indent */
-        'precision highp float;',
-        'uniform vec4 fillColor;',
-        'varying highp vec2 position;',
-        'varying highp vec4 vColor;',
-        'uniform sampler2D uSampler;',
-        'uniform bool isCircle;',
-        'uniform bool hasColor;',
-        // 'vec4 toColor(float value, vec2 point) {',
-        //     'return vec4(0.0, 0.0, 0.0, 0.0);',
-        // '}',
-        'void main(void) {',
-        'vec4 col = fillColor;',
-        'vec4 tcol = texture2D(uSampler, gl_PointCoord.st);',
-        'if (hasColor) {',
-        'col = vColor;',
-        '}',
-        'if (isCircle) {',
-        'col *= tcol;',
-        'if (tcol.r < 0.0) {',
-        'discard;',
-        '} else {',
-        'gl_FragColor = col;',
-        '}',
-        '} else {',
-        'gl_FragColor = col;',
-        '}',
-        '}'
-        /* eslint-enable max-len, @typescript-eslint/indent */
-    ].join('\n'), uLocations = {}, 
-    // The shader program
-    shaderProgram, 
-    // Uniform handle to the perspective matrix
-    pUniform, 
-    // Uniform for point size
-    psUniform, 
-    // Uniform for fill color
-    fillColorUniform, 
-    // Uniform for isBubble
-    isBubbleUniform, 
-    // Uniform for bubble abs sizing
-    bubbleSizeAbsUniform, bubbleSizeAreaUniform, 
-    // Skip translation uniform
-    skipTranslationUniform, 
-    // Set to 1 if circle
-    isCircleUniform, 
-    // Uniform for invertion
-    isInverted, 
-    // Error stack
-    errors = [], 
-    // Texture uniform
-    uSamplerUniform;
-    /**
-     * Handle errors accumulated in errors stack
-     * @private
-     */
-    function handleErrors() {
-        if (errors.length) {
-            error('[highcharts boost] shader error - ' + errors.join('\n'));
+var WGLShader = /** @class */ (function () {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    function WGLShader(gl) {
+        // Error stack
+        this.errors = [];
+        this.uLocations = {};
+        this.gl = gl;
+        if (gl && !this.createShader()) {
+            return void 0;
         }
     }
+    /* *
+     *
+     *  Functions
+     *
+     * */
     /**
-     * String to shader program
+     * Bind the shader.
+     * This makes the shader the active one until another one is bound,
+     * or until 0 is bound.
      * @private
-     * @param {string} str
-     * the program source
-     * @param {string} type
-     * the program type: either `vertex` or `fragment`
      */
-    function stringToProgram(str, type) {
-        var t = type === 'vertex' ? gl.VERTEX_SHADER : gl.FRAGMENT_SHADER, shader = gl.createShader(t);
-        gl.shaderSource(shader, str);
-        gl.compileShader(shader);
-        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-            errors.push('when compiling ' +
-                type +
-                ' shader:\n' +
-                gl.getShaderInfoLog(shader));
-            return false;
+    WGLShader.prototype.bind = function () {
+        if (this.gl && this.shaderProgram) {
+            this.gl.useProgram(this.shaderProgram);
         }
-        return shader;
-    }
+    };
     /**
      * Create the shader.
      * Loads the shader program statically defined above
      * @private
      */
-    function createShader() {
-        var v = stringToProgram(vertShade, 'vertex'), f = stringToProgram(fragShade, 'fragment');
+    WGLShader.prototype.createShader = function () {
+        var _this = this;
+        var v = this.stringToProgram(vertexShader, 'vertex'), f = this.stringToProgram(fragmentShader, 'fragment'), uloc = function (n) { return (_this.gl.getUniformLocation(_this.shaderProgram, n)); };
         if (!v || !f) {
-            shaderProgram = false;
-            handleErrors();
+            this.shaderProgram = false;
+            this.handleErrors();
             return false;
         }
-        /**
-         * @private
-         */
-        function uloc(n) {
-            return gl.getUniformLocation(shaderProgram, n);
-        }
-        shaderProgram = gl.createProgram();
-        gl.attachShader(shaderProgram, v);
-        gl.attachShader(shaderProgram, f);
-        gl.linkProgram(shaderProgram);
-        if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {
-            errors.push(gl.getProgramInfoLog(shaderProgram));
-            handleErrors();
-            shaderProgram = false;
+        this.shaderProgram = this.gl.createProgram();
+        this.gl.attachShader(this.shaderProgram, v);
+        this.gl.attachShader(this.shaderProgram, f);
+        this.gl.linkProgram(this.shaderProgram);
+        if (!this.gl.getProgramParameter(this.shaderProgram, this.gl.LINK_STATUS)) {
+            this.errors.push(this.gl.getProgramInfoLog(this.shaderProgram));
+            this.handleErrors();
+            this.shaderProgram = false;
             return false;
         }
-        gl.useProgram(shaderProgram);
-        gl.bindAttribLocation(shaderProgram, 0, 'aVertexPosition');
-        pUniform = uloc('uPMatrix');
-        psUniform = uloc('pSize');
-        fillColorUniform = uloc('fillColor');
-        isBubbleUniform = uloc('isBubble');
-        bubbleSizeAbsUniform = uloc('bubbleSizeAbs');
-        bubbleSizeAreaUniform = uloc('bubbleSizeByArea');
-        uSamplerUniform = uloc('uSampler');
-        skipTranslationUniform = uloc('skipTranslation');
-        isCircleUniform = uloc('isCircle');
-        isInverted = uloc('isInverted');
+        this.gl.useProgram(this.shaderProgram);
+        this.gl.bindAttribLocation(this.shaderProgram, 0, 'aVertexPosition');
+        this.pUniform = uloc('uPMatrix');
+        this.psUniform = uloc('pSize');
+        this.fcUniform = uloc('fillColor');
+        this.isBubbleUniform = uloc('isBubble');
+        this.bubbleSizeAbsUniform = uloc('bubbleSizeAbs');
+        this.bubbleSizeAreaUniform = uloc('bubbleSizeByArea');
+        this.uSamplerUniform = uloc('uSampler');
+        this.skipTranslationUniform = uloc('skipTranslation');
+        this.isCircleUniform = uloc('isCircle');
+        this.isInverted = uloc('isInverted');
         return true;
-    }
-    /**
-     * Destroy the shader
-     * @private
-     */
-    function destroy() {
-        if (gl && shaderProgram) {
-            gl.deleteProgram(shaderProgram);
-            shaderProgram = false;
-        }
-    }
-    /**
-     * Bind the shader.
-     * This makes the shader the active one until another one is bound,
-     * or until 0 is bound.
-     * @private
-     */
-    function bind() {
-        if (gl && shaderProgram) {
-            gl.useProgram(shaderProgram);
-        }
-    }
+    };
     /**
-     * Set a uniform value.
-     * This uses a hash map to cache uniform locations.
+     * Handle errors accumulated in errors stack
      * @private
-     * @param name {string} - the name of the uniform to set
-     * @param val {float} - the value to set
      */
-    function setUniform(name, val) {
-        if (gl && shaderProgram) {
-            var u = uLocations[name] = (uLocations[name] ||
-                gl.getUniformLocation(shaderProgram, name));
-            gl.uniform1f(u, val);
+    WGLShader.prototype.handleErrors = function () {
+        if (this.errors.length) {
+            error('[highcharts boost] shader error - ' +
+                this.errors.join('\n'));
         }
-    }
+    };
     /**
-     * Set the active texture
+     * String to shader program
      * @private
-     * @param texture
-     * the texture
+     * @param {string} str
+     * Program source
+     * @param {string} type
+     * Program type: either `vertex` or `fragment`
      */
-    function setTexture(texture) {
-        if (gl && shaderProgram) {
-            gl.uniform1i(uSamplerUniform, texture);
+    WGLShader.prototype.stringToProgram = function (str, type) {
+        var shader = this.gl.createShader(type === 'vertex' ? this.gl.VERTEX_SHADER : this.gl.FRAGMENT_SHADER);
+        this.gl.shaderSource(shader, str);
+        this.gl.compileShader(shader);
+        if (!this.gl.getShaderParameter(shader, this.gl.COMPILE_STATUS)) {
+            this.errors.push('when compiling ' +
+                type +
+                ' shader:\n' +
+                this.gl.getShaderInfoLog(shader));
+            return false;
         }
-    }
+        return shader;
+    };
     /**
-     * Set if inversion state
+     * Destroy the shader
      * @private
-     * @param {number} flag
-     * is the state
      */
-    function setInverted(flag) {
-        if (gl && shaderProgram) {
-            gl.uniform1i(isInverted, flag);
+    WGLShader.prototype.destroy = function () {
+        if (this.gl && this.shaderProgram) {
+            this.gl.deleteProgram(this.shaderProgram);
+            this.shaderProgram = false;
         }
-    }
+    };
+    WGLShader.prototype.fillColorUniform = function () {
+        return this.fcUniform;
+    };
     /**
-     * Enable/disable circle drawing
+     * Get the shader program handle
      * @private
+     * @return {WebGLProgram}
+     * The handle for the program
      */
-    function setDrawAsCircle(flag) {
-        if (gl && shaderProgram) {
-            gl.uniform1i(isCircleUniform, flag ? 1 : 0);
-        }
-    }
+    WGLShader.prototype.getProgram = function () {
+        return this.shaderProgram;
+    };
+    WGLShader.prototype.pointSizeUniform = function () {
+        return this.psUniform;
+    };
+    WGLShader.prototype.perspectiveUniform = function () {
+        return this.pUniform;
+    };
     /**
      * Flush
      * @private
      */
-    function reset() {
-        if (gl && shaderProgram) {
-            gl.uniform1i(isBubbleUniform, 0);
-            gl.uniform1i(isCircleUniform, 0);
+    WGLShader.prototype.reset = function () {
+        if (this.gl && this.shaderProgram) {
+            this.gl.uniform1i(this.isBubbleUniform, 0);
+            this.gl.uniform1i(this.isCircleUniform, 0);
         }
-    }
+    };
     /**
      * Set bubble uniforms
      * @private
-     * @param series {Highcharts.Series} - the series to use
+     * @param {Highcharts.Series} series
+     * Series to use
      */
-    function setBubbleUniforms(series, zCalcMin, zCalcMax, pixelRatio) {
+    WGLShader.prototype.setBubbleUniforms = function (series, zCalcMin, zCalcMax, pixelRatio) {
         if (pixelRatio === void 0) { pixelRatio = 1; }
-        var seriesOptions = series.options, zMin = Number.MAX_VALUE, zMax = -Number.MAX_VALUE;
-        if (gl && shaderProgram && series.is('bubble')) {
+        var seriesOptions = series.options;
+        var zMin = Number.MAX_VALUE, zMax = -Number.MAX_VALUE;
+        if (this.gl && this.shaderProgram && series.is('bubble')) {
             var pxSizes = series.getPxExtremes();
             zMin = pick(seriesOptions.zMin, clamp(zCalcMin, seriesOptions.displayNegative === false ?
                 seriesOptions.zThreshold : -Number.MAX_VALUE, zMin));
             zMax = pick(seriesOptions.zMax, Math.max(zMax, zCalcMax));
-            gl.uniform1i(isBubbleUniform, 1);
-            gl.uniform1i(isCircleUniform, 1);
-            gl.uniform1i(bubbleSizeAreaUniform, (series.options.sizeBy !== 'width'));
-            gl.uniform1i(bubbleSizeAbsUniform, series.options
+            this.gl.uniform1i(this.isBubbleUniform, 1);
+            this.gl.uniform1i(this.isCircleUniform, 1);
+            this.gl.uniform1i(this.bubbleSizeAreaUniform, (series.options.sizeBy !== 'width'));
+            this.gl.uniform1i(this.bubbleSizeAbsUniform, series.options
                 .sizeByAbsoluteValue);
-            setUniform('bubbleZMin', zMin);
-            setUniform('bubbleZMax', zMax);
-            setUniform('bubbleZThreshold', series.options.zThreshold);
-            setUniform('bubbleMinSize', pxSizes.minPxSize * pixelRatio);
-            setUniform('bubbleMaxSize', pxSizes.maxPxSize * pixelRatio);
+            this.setUniform('bubbleMinSize', pxSizes.minPxSize * pixelRatio);
+            this.setUniform('bubbleMaxSize', pxSizes.maxPxSize * pixelRatio);
+            this.setUniform('bubbleZMin', zMin);
+            this.setUniform('bubbleZMax', zMax);
+            this.setUniform('bubbleZThreshold', series.options.zThreshold);
         }
-    }
+    };
     /**
      * Set the Color uniform.
      * @private
-     * @param color {Array<float>} - an array with RGBA values
+     * @param {Array<number>} color
+     * Array with RGBA values.
      */
-    function setColor(color) {
-        if (gl && shaderProgram) {
-            gl.uniform4f(fillColorUniform, color[0] / 255.0, color[1] / 255.0, color[2] / 255.0, color[3]);
+    WGLShader.prototype.setColor = function (color) {
+        if (this.gl && this.shaderProgram) {
+            this.gl.uniform4f(this.fcUniform, color[0] / 255.0, color[1] / 255.0, color[2] / 255.0, color[3]);
         }
-    }
+    };
     /**
-     * Set skip translation
+     * Enable/disable circle drawing
      * @private
      */
-    function setSkipTranslation(flag) {
-        if (gl && shaderProgram) {
-            gl.uniform1i(skipTranslationUniform, flag === true ? 1 : 0);
+    WGLShader.prototype.setDrawAsCircle = function (flag) {
+        if (this.gl && this.shaderProgram) {
+            this.gl.uniform1i(this.isCircleUniform, flag ? 1 : 0);
         }
-    }
+    };
+    /**
+     * Set if inversion state
+     * @private
+     * @param {number} flag
+     * Inversion flag
+     */
+    WGLShader.prototype.setInverted = function (flag) {
+        if (this.gl && this.shaderProgram) {
+            this.gl.uniform1i(this.isInverted, flag);
+        }
+    };
     /**
      * Set the perspective matrix
      * @private
-     * @param m {Matrix4x4} - the matrix
+     * @param {Float32List} m
+     * Matrix 4 x 4
      */
-    function setPMatrix(m) {
-        if (gl && shaderProgram) {
-            gl.uniformMatrix4fv(pUniform, false, m);
+    WGLShader.prototype.setPMatrix = function (m) {
+        if (this.gl && this.shaderProgram) {
+            this.gl.uniformMatrix4fv(this.pUniform, false, m);
         }
-    }
+    };
     /**
      * Set the point size.
      * @private
-     * @param p {float} - point size
+     * @param {number} p
+     * Point size
      */
-    function setPointSize(p) {
-        if (gl && shaderProgram) {
-            gl.uniform1f(psUniform, p);
+    WGLShader.prototype.setPointSize = function (p) {
+        if (this.gl && this.shaderProgram) {
+            this.gl.uniform1f(this.psUniform, p);
         }
-    }
+    };
     /**
-     * Get the shader program handle
+     * Set skip translation
      * @private
-     * @return {GLInt} - the handle for the program
      */
-    function getProgram() {
-        return shaderProgram;
-    }
-    if (gl) {
-        if (!createShader()) {
-            return false;
+    WGLShader.prototype.setSkipTranslation = function (flag) {
+        if (this.gl && this.shaderProgram) {
+            this.gl.uniform1i(this.skipTranslationUniform, flag === true ? 1 : 0);
+        }
+    };
+    /**
+     * Set the active texture
+     * @private
+     * @param {number} texture
+     * Texture to activate
+     */
+    WGLShader.prototype.setTexture = function (texture) {
+        if (this.gl && this.shaderProgram) {
+            this.gl.uniform1i(this.uSamplerUniform, texture);
+        }
+    };
+    /**
+     * Set a uniform value.
+     * This uses a hash map to cache uniform locations.
+     * @private
+     * @param {string} name
+     * Name of the uniform to set.
+     * @param {number} val
+     * Value to set
+     */
+    WGLShader.prototype.setUniform = function (name, val) {
+        if (this.gl && this.shaderProgram) {
+            var u = this.uLocations[name] = (this.uLocations[name] ||
+                this.gl.getUniformLocation(this.shaderProgram, name));
+            this.gl.uniform1f(u, val);
         }
-    }
-    return {
-        psUniform: function () {
-            return psUniform;
-        },
-        pUniform: function () {
-            return pUniform;
-        },
-        fillColorUniform: function () {
-            return fillColorUniform;
-        },
-        setBubbleUniforms: setBubbleUniforms,
-        bind: bind,
-        program: getProgram,
-        create: createShader,
-        setUniform: setUniform,
-        setPMatrix: setPMatrix,
-        setColor: setColor,
-        setPointSize: setPointSize,
-        setSkipTranslation: setSkipTranslation,
-        setTexture: setTexture,
-        setDrawAsCircle: setDrawAsCircle,
-        reset: reset,
-        setInverted: setInverted,
-        destroy: destroy
     };
-}
-export default GLShader;
+    return WGLShader;
+}());
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default WGLShader;