wwbsr/node_modules/highcharts/es-modules/Extensions/Boost/WGLShader.js

/* *
 *
 *  Copyright (c) 2019-2020 Highsoft AS
 *
 *  Boost module: stripped-down renderer for higher performance
 *
 *  License: highcharts.com/license
 *
 *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
 *
 * */
'use strict';
import U from '../../Core/Utilities.js';
var clamp = U.clamp, error = U.error, pick = U.pick;
/* 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
 *
 * @return {*}
 */
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;',
        'if (hasColor) {',
        'col = vColor;',
        '}',
        'if (isCircle) {',
        'tcol = texture2D(uSampler, gl_PointCoord.st);',
        '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'));
        }
    }
    /**
     * String to shader program
     * @private
     * @param {string} str - the program source
     * @param {string} type - the program type: either `vertex` or `fragment`
     * @returns {bool|shader}
     */
    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;
        }
        return shader;
    }
    /**
     * Create the shader.
     * Loads the shader program statically defined above
     * @private
     */
    function createShader() {
        var v = stringToProgram(vertShade, 'vertex'), f = stringToProgram(fragShade, 'fragment');
        if (!v || !f) {
            shaderProgram = false;
            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;
            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');
        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.
     * @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);
        }
    }
    /**
     * Set the active texture
     * @private
     * @param texture - the texture
     */
    function setTexture(texture) {
        if (gl && shaderProgram) {
            gl.uniform1i(uSamplerUniform, texture);
        }
    }
    /**
     * Set if inversion state
     * @private
     * @flag is the state
     */
    function setInverted(flag) {
        if (gl && shaderProgram) {
            gl.uniform1i(isInverted, flag);
        }
    }
    /**
     * Enable/disable circle drawing
     * @private
     */
    function setDrawAsCircle(flag) {
        if (gl && shaderProgram) {
            gl.uniform1i(isCircleUniform, flag ? 1 : 0);
        }
    }
    /**
     * Flush
     * @private
     */
    function reset() {
        if (gl && shaderProgram) {
            gl.uniform1i(isBubbleUniform, 0);
            gl.uniform1i(isCircleUniform, 0);
        }
    }
    /**
     * Set bubble uniforms
     * @private
     * @param series {Highcharts.Series} - the series to use
     */
    function setBubbleUniforms(series, zCalcMin, zCalcMax) {
        var seriesOptions = series.options, zMin = Number.MAX_VALUE, zMax = -Number.MAX_VALUE;
        if (gl && shaderProgram && series.type === 'bubble') {
            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
                .sizeByAbsoluteValue);
            setUniform('bubbleZMin', zMin);
            setUniform('bubbleZMax', zMax);
            setUniform('bubbleZThreshold', series.options.zThreshold);
            setUniform('bubbleMinSize', series.minPxSize);
            setUniform('bubbleMaxSize', series.maxPxSize);
        }
    }
    /**
     * Set the Color uniform.
     * @private
     * @param color {Array<float>} - an 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]);
        }
    }
    /**
     * Set skip translation
     * @private
     */
    function setSkipTranslation(flag) {
        if (gl && shaderProgram) {
            gl.uniform1i(skipTranslationUniform, flag === true ? 1 : 0);
        }
    }
    /**
     * Set the perspective matrix
     * @private
     * @param m {Matrix4x4} - the matrix
     */
    function setPMatrix(m) {
        if (gl && shaderProgram) {
            gl.uniformMatrix4fv(pUniform, false, m);
        }
    }
    /**
     * Set the point size.
     * @private
     * @param p {float} - point size
     */
    function setPointSize(p) {
        if (gl && shaderProgram) {
            gl.uniform1f(psUniform, p);
        }
    }
    /**
     * Get the shader program handle
     * @private
     * @return {GLInt} - the handle for the program
     */
    function getProgram() {
        return shaderProgram;
    }
    if (gl) {
        if (!createShader()) {
            return false;
        }
    }
    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;