@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/timetracks/program.js

@@ -0,0 +1,466 @@
+"use strict";
+/**
+ * Author: Toprak Nihat Deniz Ozturk
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../util");
+var TrackGlowLineProgram = /** @class */ (function () {
+    /**
+     * @param {WebGL2RenderingContext} gl
+     * @param {number} width
+     * @param {number} height
+     * @param {Object} options
+     * @param {number} options.headPercentage 0 ~ 1
+     * @param {number} options.routeAlpha 0 ~ 1
+     * @param {Array.<Number>} options.weights  [w1, w2, w3, w4, w5]
+     * @param {number} options.alphaThreshold 0 ~ 1
+     * @param {number} options.exposure 0 ~ inf
+     * @param {number} options.gamma 0 ~ inf
+     * @param {number} options.finalAlphaRatio 0 ~ 1
+     * @param {+int} options.blurRepetition 1 ~ inf default 2
+     */
+    function TrackGlowLineProgram(gl, attrBuffer, width, height, options) {
+        if (options === void 0) { options = {}; }
+        this.gl = gl;
+        this.program = null;
+        this._premultipliedAlpha = false;
+        // this._inBuffer = gl.createBuffer();
+        this._inBuffer = attrBuffer;
+        this._frameBuffer = gl.createFramebuffer();
+        this._lineProgram = this._createLineProgram();
+        this._blurProgram = this._createBlurProgram();
+        this._combineProgram = this._createCombineProgram();
+        this.resize(width, height);
+        this._middleTexture = null;
+        this._blurTextures = null;
+        this._createInnerTextures();
+        this._blurFrameBuffers = [gl.createFramebuffer(), gl.createFramebuffer()];
+        this._blurRepetition = options.blurRepetition || 1;
+        this._totalLength = 0;
+        this._initUniforms(options);
+    }
+    TrackGlowLineProgram.prototype._createInnerTextures = function () {
+        this._middleTexture = this._createTextures();
+        this._blurTextures = [this._createTextures(), this._createTextures()];
+    };
+    TrackGlowLineProgram.prototype._initUniforms = function (options) {
+        if (options === void 0) { options = {}; }
+        var _a = this, gl = _a.gl, _lineProgram = _a._lineProgram, _blurProgram = _a._blurProgram, _combineProgram = _a._combineProgram;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_lineProgram.program);
+        gl.uniform1f(_lineProgram.u_head_percentage, options.headPercentage || 1.0 / 30.0);
+        gl.uniform1f(_lineProgram.u_route_alpha, options.routeAlpha || 0.025);
+        gl.useProgram(_blurProgram.program);
+        gl.uniform1fv(_blurProgram.u_weight, options.weights || [1, 0.45045946, 0.2216216, 0.154054, 0.056216]);
+        gl.uniform1f(_blurProgram.u_alpha_threshold, options.alphaThreshold || 0.0);
+        gl.uniform1i(_blurProgram.u_glow, 1);
+        gl.useProgram(_combineProgram.program);
+        gl.uniform1f(_combineProgram.u_exposure, options.exposure || 1.0);
+        gl.uniform1f(_combineProgram.u_gamma, options.gamma || 1.0);
+        gl.uniform1f(_combineProgram.u_final_alpha_ratio, options.finalAlphaRatio || 1.0);
+        gl.useProgram(currentProgram);
+    };
+    TrackGlowLineProgram.prototype.setPremultipliedAlpha = function (boolean) {
+        if (typeof boolean !== 'boolean') {
+            console.warn("boolean should be a boolean value, but got", boolean);
+            return;
+        }
+        this._premultipliedAlpha = boolean;
+    };
+    /**
+     * @param {number} alpha  0 ~ 1
+     * @returns
+     */
+    TrackGlowLineProgram.prototype.setAlphaThreshold = function (alpha) {
+        if (alpha < 0 || alpha > 1) {
+            console.warn("alpha should be between 0 and 1, but got", alpha);
+            return;
+        }
+        var _a = this, gl = _a.gl, _blurProgram = _a._blurProgram;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_blurProgram.program);
+        gl.uniform1f(_blurProgram.u_alpha_threshold, alpha);
+        gl.useProgram(currentProgram);
+    };
+    /**
+     * @param {number} gamma 0 ~ inf
+     */
+    TrackGlowLineProgram.prototype.setGamma = function (gamma) {
+        if (gamma < 0) {
+            console.warn("gamma should be equal or greater than 0, but got", gamma);
+            return;
+        }
+        var _a = this, gl = _a.gl, _combineProgram = _a._combineProgram;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_combineProgram.program);
+        gl.uniform1f(_combineProgram.u_gamma, gamma);
+        gl.useProgram(currentProgram);
+    };
+    /**
+     *
+     * @param {number} exposure 0 ~ inf
+     * @returns
+     */
+    TrackGlowLineProgram.prototype.setExposure = function (exposure) {
+        if (exposure < 0) {
+            console.warn("exposure should be equal or greater than 0, but got", exposure);
+            return;
+        }
+        var _a = this, gl = _a.gl, _combineProgram = _a._combineProgram;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_combineProgram.program);
+        gl.uniform1f(_combineProgram.u_exposure, exposure);
+        gl.useProgram(currentProgram);
+    };
+    /**
+     *
+     * @param {number} ratio  0 ~ 1
+     * @returns
+     */
+    TrackGlowLineProgram.prototype.setFinalAlphaRatio = function (ratio) {
+        if (ratio < 0 || ratio > 1) {
+            console.warn("ratio should be between 0 and 1, but got", ratio);
+            return;
+        }
+        var _a = this, gl = _a.gl, _combineProgram = _a._combineProgram;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_combineProgram.program);
+        gl.uniform1f(_combineProgram.u_final_alpha_ratio, ratio);
+        gl.useProgram(currentProgram);
+    };
+    /**
+     *  @param {Array.<Number>} weight  [w1, w2, w3, w4, w5]
+     */
+    TrackGlowLineProgram.prototype.setBlurWeights = function (weights) {
+        if (weights.length !== 5) {
+            console.warn("weights should be an array of 5 numbers, but got", weights);
+            return;
+        }
+        var _a = this, gl = _a.gl, _blurProgram = _a._blurProgram;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_blurProgram.program);
+        gl.uniform1fv(_blurProgram.u_weight, weights);
+        gl.useProgram(currentProgram);
+    };
+    /**
+     * @param {number} routeAlpha 0 ~ 1
+     */
+    TrackGlowLineProgram.prototype.setRouteAlpha = function (routeAlpha) {
+        if (routeAlpha < 0 || routeAlpha > 1) {
+            console.warn("routeAlpha should be between 0 and 1, but got", routeAlpha);
+            return;
+        }
+        var _a = this, gl = _a.gl, _lineProgram = _a._lineProgram;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_lineProgram.program);
+        gl.uniform1f(_lineProgram.u_route_alpha, routeAlpha);
+        gl.useProgram(currentProgram);
+    };
+    TrackGlowLineProgram.prototype.setGlow = function (boolean) {
+        if (typeof boolean !== 'boolean') {
+            console.warn("boolean should be a boolean value, but got", boolean);
+            return;
+        }
+        var _a = this, gl = _a.gl, _blurProgram = _a._blurProgram;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_blurProgram.program);
+        gl.uniform1i(_blurProgram.u_glow, boolean);
+        gl.useProgram(currentProgram);
+    };
+    /**
+     * blur uses pingpong effect. This number decides how many times the blur will be applied.
+     * @param {+int} repetition
+     * @returns
+     */
+    TrackGlowLineProgram.prototype.setBlurRepetition = function (repetition) {
+        if (repetition < 0 && repetition % 1 !== 0) {
+            console.warn("repetition should be an integer greater than 0, but got", repetition);
+            return;
+        }
+        this._blurRepetition = repetition;
+    };
+    /**
+     * Head Is colored as white. This number decides proportion of the head according to the total length of the line.
+     * @param {Number} percentage 0 ~ 1
+    */
+    TrackGlowLineProgram.prototype.setHeadPercentage = function (percentage) {
+        if (percentage < 0 || 1 < percentage) {
+            console.warn("percentage should be between 0 and 1, but got", percentage);
+            return;
+        }
+        ;
+        var _a = this, gl = _a.gl, _lineProgram = _a._lineProgram;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_lineProgram.program);
+        gl.uniform1f(_lineProgram.u_head_percentage, percentage);
+        gl.useProgram(currentProgram);
+    };
+    TrackGlowLineProgram.prototype._createCombineProgram = function () {
+        var gl = this.gl;
+        var vertexShader = "#version 300 es\n        precision lowp float;\n\n        in vec2 a_position;\n\n        out vec2 v_texcoord;\n\n        void main() {\n            gl_Position = vec4(a_position, 0.0, 1.0);\n            v_texcoord = a_position.xy * 0.5 + 0.5;\n        }\n        ";
+        var fragmentShader = "#version 300 es\n        precision lowp float;\n\n        in vec2 v_texcoord;\n\n        uniform sampler2D u_main_texture;\n        uniform sampler2D u_bloom_texture;\n\n        uniform float u_exposure;\n        uniform float u_gamma;\n        uniform float u_final_alpha_ratio;\n\n        out vec4 outColor;\n\n        void main() {\n            vec4 hdrColor = texture(u_main_texture, v_texcoord);      \n            vec4 bloomColor =  texture(u_bloom_texture, v_texcoord);\n            vec4 result;\n            if (bloomColor.a > 0.09){\n                result = bloomColor * u_exposure;\n            } else {\n                result = hdrColor + bloomColor * u_exposure;\n            }\n            result = pow(result, vec4(1.0 / u_gamma));\n            outColor = vec4(result.rgb, result.a * u_final_alpha_ratio);\n        }\n        ";
+        var program = (0, util_1.createProgram)(this.gl, vertexShader, fragmentShader);
+        var buffer = gl.createBuffer();
+        var a_position = gl.getAttribLocation(program, "a_position");
+        var vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+            -1, -1,
+            1, -1,
+            1, 1,
+            -1, -1,
+            1, 1,
+            -1, 1,
+        ]), gl.STATIC_DRAW);
+        gl.enableVertexAttribArray(a_position);
+        gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 0, 0);
+        gl.bindVertexArray(null);
+        return {
+            program: program,
+            vao: vao,
+            u_main_texture: gl.getUniformLocation(program, "u_main_texture"),
+            u_bloom_texture: gl.getUniformLocation(program, "u_bloom_texture"),
+            u_exposure: gl.getUniformLocation(program, "u_exposure"),
+            u_gamma: gl.getUniformLocation(program, "u_gamma"),
+            u_final_alpha_ratio: gl.getUniformLocation(program, "u_final_alpha_ratio"),
+        };
+    };
+    TrackGlowLineProgram.prototype._createBlurProgram = function () {
+        var gl = this.gl;
+        var vertexShader = "#version 300 es\nprecision highp float;\n\nin vec2 a_position;\nout vec2 v_texcoord;\n\nvoid main() {\n    gl_Position = vec4(a_position, 0.0, 1.0);\n    v_texcoord = a_position.xy * 0.5 + 0.5;\n}\n";
+        var fragmentShader = "#version 300 es\nprecision highp float;\n\nin vec2 v_texcoord;\n\nuniform sampler2D u_texture;\nuniform bool u_horizontal;\nuniform float u_weight[5];\nuniform float u_alpha_threshold;\nuniform bool u_glow;\nout vec4 outColor;\n\nvoid main()\n{             \n    vec2 tex_offset = vec2( \n        1.0 / float(textureSize(u_texture, 0).x),\n        1.0 / float(textureSize(u_texture, 0).y) ); // gets size of single texel\n    vec3 color = vec3(0.0);\n    float total_alpha = texture(u_texture, v_texcoord).a * u_weight[0]; \n    if (total_alpha > 0.0){\n        color = texture(u_texture, v_texcoord).rgb;\n    }\n    vec2 offset = vec2(0.0);\n    float alpha;\n    float color_count = 0.0;\n    if (!u_glow){\n        if(u_horizontal){\n            for(int i = 1; i < 5; ++i)\n            {\n                offset = vec2(tex_offset.x * float(i), 0.0);\n                alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];\n\n                if (alpha > u_alpha_threshold){\n                    // color =  max( color, texture(u_texture, v_texcoord + offset).rgb);\n                    color += texture(u_texture, v_texcoord + offset).rgb;\n                    total_alpha += alpha;\n                    color_count += 1.0;\n                }\n                alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];\n                if (alpha > u_alpha_threshold){\n                    // color =  max( color, texture(u_texture, v_texcoord - offset).rgb);\n                    color += texture(u_texture, v_texcoord - offset).rgb ;\n                    total_alpha += alpha;\n                    color_count += 1.0;\n\n                }\n            }\n} else {\n            for(int i = 1; i < 5; ++i)\n            {   \n                offset = vec2(0.0, tex_offset.y * float(i));\n                alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];\n                if (alpha > u_alpha_threshold){\n                    // color =  max( color , texture(u_texture, v_texcoord + offset).rgb);\n                    color += texture(u_texture, v_texcoord + offset).rgb;\n                    total_alpha += alpha;\n                    color_count += 1.0;\n\n                }\n                alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];\n                if (alpha > u_alpha_threshold){\n                    // color = max( color, texture(u_texture, v_texcoord - offset).rgb );\n                    color += texture(u_texture, v_texcoord - offset).rgb ;\n                    total_alpha += alpha;\n                    color_count += 1.0;\n\n                }\n            }\n\n        }\n                        if (color_count > 0.0){\n                color /= color_count;\n            }\n    } else {\n        if(u_horizontal)\n        {\n            for(int i = 1; i < 5; ++i)\n            {\n                offset = vec2(tex_offset.x * float(i), 0.0);\n                alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];\n\n                if (alpha > u_alpha_threshold){\n                    color =  max( color, texture(u_texture, v_texcoord + offset).rgb);\n                    total_alpha += alpha;\n                }\n                alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];\n                if (alpha > u_alpha_threshold){\n                    color =  max( color, texture(u_texture, v_texcoord - offset).rgb);\n\n                    total_alpha += alpha;\n                }\n            }\n        }\n        else\n        {\n            for(int i = 1; i < 5; ++i)\n            {\n                offset = vec2(0.0, tex_offset.y * float(i));\n                alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];\n                if (alpha > u_alpha_threshold){\n                    color =  max( color, texture(u_texture, v_texcoord + offset).rgb);\n                    total_alpha += alpha;\n                }\n                alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];\n                if (alpha > u_alpha_threshold){\n                    color = max( color, texture(u_texture, v_texcoord - offset).rgb );\n                    total_alpha += alpha;\n                }\n            }\n        }\n    }\n    outColor = vec4(color, total_alpha);\n}\n";
+        var program = (0, util_1.createProgram)(this.gl, vertexShader, fragmentShader);
+        var buffer = gl.createBuffer();
+        var a_position = gl.getAttribLocation(program, "a_position");
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+            -1, -1,
+            1, -1,
+            1, 1,
+            -1, -1,
+            1, 1,
+            -1, 1,
+        ]), gl.STATIC_DRAW);
+        var vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.enableVertexAttribArray(a_position);
+        gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 0, 0);
+        gl.bindVertexArray(null);
+        return {
+            program: program,
+            vao: vao,
+            u_texture: gl.getUniformLocation(program, "u_texture"),
+            u_horizontal: gl.getUniformLocation(program, "u_horizontal"),
+            u_weight: gl.getUniformLocation(program, "u_weight"),
+            u_alpha_threshold: gl.getUniformLocation(program, "u_alpha_threshold"),
+            u_glow: gl.getUniformLocation(program, "u_glow"),
+        };
+    };
+    TrackGlowLineProgram.prototype._createBlurProgramHOLD = function () {
+        var gl = this.gl;
+        var vertexShader = "#version 300 es\nprecision highp float;\n\nin vec2 a_position;\nout vec2 v_texcoord;\n\nvoid main() {\n    gl_Position = vec4(a_position, 0.0, 1.0);\n    v_texcoord = a_position.xy * 0.5 + 0.5;\n}\n";
+        var fragmentShader = "#version 300 es\nprecision highp float;\n\nin vec2 v_texcoord;\n\nuniform sampler2D u_texture;\nuniform bool u_horizontal;\nuniform float u_weight[5];\nuniform float u_alpha_threshold;\n\nout vec4 outColor;\n\nvoid main()\n{             \n    vec2 tex_offset = vec2(1) / vec2(textureSize(u_texture, 0)); // gets size of single texel\n    vec3 color = vec3(0.0);\n    float total_alpha = texture(u_texture, v_texcoord).a * u_weight[0]; \n    if (total_alpha > 0.0){\n        color = texture(u_texture, v_texcoord).rgb;\n    }\n    vec2 offset = vec2(0.0);\n    float alpha;\n\n    if(u_horizontal)\n    {\n        for(int i = 1; i < 5; ++i)\n        {\n            offset = vec2(tex_offset.x * float(i), 0.0);\n            alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];\n\n            if (alpha > u_alpha_threshold){\n                color =  max( color, texture(u_texture, v_texcoord + offset).rgb);\n                total_alpha += alpha;\n            }\n            alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];\n            if (alpha > u_alpha_threshold){\n                color =  max( color, texture(u_texture, v_texcoord - offset).rgb);\n                total_alpha += alpha;\n            }\n        }\n    }\n    else\n    {\n        for(int i = 1; i < 5; ++i)\n        {   \n            offset = vec2(0.0, tex_offset.y * float(i));\n            alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];\n            if (alpha > u_alpha_threshold){\n                color =  max( color , texture(u_texture, v_texcoord + offset).rgb);\n                total_alpha += alpha;\n            }\n            alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];\n            if (alpha > u_alpha_threshold){\n                color = max( color, texture(u_texture, v_texcoord - offset).rgb );\n                total_alpha += alpha;\n            }\n        }\n    }\n    outColor = vec4(color, total_alpha);\n}\n";
+        var program = (0, util_1.createProgram)(this.gl, vertexShader, fragmentShader);
+        var buffer = gl.createBuffer();
+        var a_position = gl.getAttribLocation(program, "a_position");
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+            -1, -1,
+            1, -1,
+            1, 1,
+            -1, -1,
+            1, 1,
+            -1, 1,
+        ]), gl.STATIC_DRAW);
+        var vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.enableVertexAttribArray(a_position);
+        gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 0, 0);
+        gl.bindVertexArray(null);
+        return {
+            program: program,
+            vao: vao,
+            u_texture: gl.getUniformLocation(program, "u_texture"),
+            u_horizontal: gl.getUniformLocation(program, "u_horizontal"),
+            u_weight: gl.getUniformLocation(program, "u_weight"),
+            u_alpha_threshold: gl.getUniformLocation(program, "u_alpha_threshold"),
+        };
+    };
+    TrackGlowLineProgram.prototype.resize = function (width, height) {
+        var _a = this, gl = _a.gl, _lineProgram = _a._lineProgram;
+        this._width = width;
+        this._height = height;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        this._createInnerTextures();
+        gl.useProgram(_lineProgram.program);
+        gl.uniform2fv(_lineProgram.u_scrWH, [width, height]);
+        gl.useProgram(currentProgram);
+    };
+    TrackGlowLineProgram.prototype._createLineProgram = function () {
+        var gl = this.gl;
+        var vertexShader = "#version 300 es\nprecision highp float;\n\nin vec3 a_position;\nin float a_time;\nin vec3 a_color;\nin float a_track_start_time;\nin float a_track_end_time;\n\nuniform mat4 uModelViewMatrix;\nuniform mat4 uProjectionMatrix;\nuniform vec3 uTranslate;\n\nuniform bool u_is_3d;\nuniform vec2 u_mapWH;\nuniform vec2 u_scrWH;\n\nout float v_time;\nout vec3 v_color;\nout float v_track_start_time;\nout float v_track_end_time;\n\n".concat(util_1.shaderfunctions.pixelXYToCartesian3DPoint, "\n").concat(util_1.shaderfunctions.pixelXYToCartesian2DPoint, "\n    \nvoid main() {\n    v_time = a_time;\n    v_color = a_color;\n    v_track_start_time = a_track_start_time;\n    v_track_end_time = a_track_end_time;\n    if (u_is_3d){\n        vec3 pos = pixelXYToCartesian3DPoint(a_position);\n        gl_Position = uProjectionMatrix * uModelViewMatrix * vec4(pos - uTranslate, 1.0);\n    }  else {\n        vec2 xy = pixelXYToCartesian2DPoint(a_position.xy, uTranslate.xy, u_mapWH, u_scrWH);\n        gl_Position = uProjectionMatrix * vec4(xy.x, xy.y, 0.0, 1.0);\n    \n    }\n    gl_PointSize = 1.0;\n}\n");
+        var fragmentShader = "#version 300 es\nprecision lowp float;\n\nin float v_time;\nin vec3 v_color;\nin float v_track_start_time;\nin float v_track_end_time;\n\nuniform float u_head_time;\nuniform float u_tail_time;\n\nuniform float u_head_percentage;\nuniform float u_route_alpha;\n\nlayout(location = 0) out vec4 outColor0;\nlayout(location = 1) out vec4 outColor1;\n\n\nvoid main() {\n    if ( u_tail_time > v_track_end_time || u_head_time < v_track_start_time) discard;\n    // if ( v_time < u_tail_time || v_time > u_head_time) discard;\n\n    float gap = u_head_time - u_tail_time;\n    float head = gap * u_head_percentage;\n    float dist = u_head_time - v_time;\n    if ((v_time > u_head_time ) || (v_time < u_tail_time) ){ \n        \n        outColor0 = vec4(v_color , u_route_alpha); \n    } else if (dist < head) {\n        // white head\n        outColor0 = vec4(1.0, 1.0, 1.0, 0.77 + ( u_route_alpha * 0.23)); \n        outColor1 = vec4(1.0, 1.0, 1.0, 0.77 + ( u_route_alpha * 0.23)); \n    // \n    } else {\n        // colored body of lines\n        float alpha = ((gap - dist) / gap) / 2.0 + 0.5;\n        outColor0 = vec4(v_color , alpha ); \n        outColor1 = vec4(v_color , alpha );  \n    }\n}\n";
+        var program = (0, util_1.createProgram)(this.gl, vertexShader, fragmentShader);
+        var a_position = gl.getAttribLocation(program, "a_position");
+        var a_time = gl.getAttribLocation(program, "a_time");
+        var a_track_start_time = gl.getAttribLocation(program, "a_track_start_time");
+        var a_track_end_time = gl.getAttribLocation(program, "a_track_end_time");
+        var a_color = gl.getAttribLocation(program, "a_color");
+        var vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._inBuffer);
+        gl.enableVertexAttribArray(a_position);
+        gl.vertexAttribPointer(a_position, 3, gl.FLOAT, false, 36, 0);
+        gl.enableVertexAttribArray(a_time);
+        gl.vertexAttribPointer(a_time, 1, gl.FLOAT, false, 36, 12);
+        gl.enableVertexAttribArray(a_color);
+        gl.vertexAttribPointer(a_color, 3, gl.FLOAT, false, 36, 16);
+        gl.enableVertexAttribArray(a_track_start_time);
+        gl.vertexAttribPointer(a_track_start_time, 1, gl.FLOAT, false, 36, 28);
+        gl.enableVertexAttribArray(a_track_end_time);
+        gl.vertexAttribPointer(a_track_end_time, 1, gl.FLOAT, false, 36, 32);
+        gl.bindVertexArray(null);
+        return {
+            program: program,
+            vao: vao,
+            u_head_time: gl.getUniformLocation(program, "u_head_time"),
+            u_tail_time: gl.getUniformLocation(program, "u_tail_time"),
+            uTranslate: gl.getUniformLocation(program, "uTranslate"),
+            uModelViewMatrix: gl.getUniformLocation(program, "uModelViewMatrix"),
+            uProjectionMatrix: gl.getUniformLocation(program, "uProjectionMatrix"),
+            u_is_3d: gl.getUniformLocation(program, "u_is_3d"),
+            u_mapWH: gl.getUniformLocation(program, "u_mapWH"),
+            u_scrWH: gl.getUniformLocation(program, "u_scrWH"),
+            u_head_percentage: gl.getUniformLocation(program, "u_head_percentage"),
+            u_route_alpha: gl.getUniformLocation(program, "u_route_alpha"),
+        };
+    };
+    /**
+     * @param { Float32Array} data // [x, y, z, time, x, y, z, time, ...]
+     */
+    // setInBuffer(data) {
+    //     const gl = this.gl;
+    //     gl.bindBuffer(gl.ARRAY_BUFFER, this._inBuffer);
+    //     gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
+    // }
+    TrackGlowLineProgram.prototype.setIs3D = function (is3d) {
+        var _a = this, gl = _a.gl, _lineProgram = _a._lineProgram;
+        var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_lineProgram.program);
+        gl.uniform1i(_lineProgram.u_is_3d, is3d);
+        gl.useProgram(currentProgram);
+    };
+    TrackGlowLineProgram.prototype.setTotalLength = function (totalLength) {
+        this._totalLength = totalLength;
+    };
+    TrackGlowLineProgram.prototype._createTextures = function () {
+        var _a = this, gl = _a.gl, _width = _a._width, _height = _a._height;
+        var texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _width, _height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null); // UNSIGNED_BYTE
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        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.bindTexture(gl.TEXTURE_2D, null);
+        return texture;
+    };
+    TrackGlowLineProgram.prototype._resetTexture = function () {
+        var _a = this, gl = _a.gl, _width = _a._width, _height = _a._height;
+        gl.bindTexture(gl.TEXTURE_2D, this._middleTexture); // UNSIGNED_BYTE
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _width, _height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+        gl.bindTexture(gl.TEXTURE_2D, this._blurTextures[0]);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _width, _height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+        gl.bindTexture(gl.TEXTURE_2D, this._blurTextures[1]);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, _width, _height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+    };
+    TrackGlowLineProgram.prototype.draw = function (u_head_time, u_tail_time, uProjectionMatrix, uModelViewMatrix, uTranslate, u_mapWH) {
+        if (u_mapWH === void 0) { u_mapWH = null; }
+        var _a = this, gl = _a.gl, _lineProgram = _a._lineProgram, _blurProgram = _a._blurProgram, _blurRepetition = _a._blurRepetition, _premultipliedAlpha = _a._premultipliedAlpha;
+        this._resetTexture();
+        // if (_premultipliedAlpha) {
+        gl.enable(gl.BLEND);
+        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+        // }
+        { // draw lines
+            gl.bindFramebuffer(gl.FRAMEBUFFER, this._frameBuffer);
+            gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._middleTexture, 0);
+            gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this._blurTextures[0], 0);
+            gl.drawBuffers([
+                gl.COLOR_ATTACHMENT0,
+                gl.COLOR_ATTACHMENT1,
+            ]);
+            gl.useProgram(_lineProgram.program);
+            gl.uniform1f(_lineProgram.u_head_time, u_head_time);
+            gl.uniform1f(_lineProgram.u_tail_time, u_tail_time);
+            gl.uniformMatrix4fv(_lineProgram.uProjectionMatrix, false, uProjectionMatrix);
+            if (u_mapWH) {
+                gl.uniform2fv(_lineProgram.u_mapWH, u_mapWH);
+            }
+            else {
+                gl.uniformMatrix4fv(_lineProgram.uModelViewMatrix, false, uModelViewMatrix);
+            }
+            gl.uniform3fv(_lineProgram.uTranslate, uTranslate);
+            gl.bindVertexArray(_lineProgram.vao);
+            gl.drawArrays(gl.LINES, 0, this._totalLength);
+            gl.drawBuffers([
+                gl.COLOR_ATTACHMENT0,
+                gl.NONE
+            ]);
+        }
+        { // blur ping pong
+            gl.useProgram(_blurProgram.program);
+            gl.bindVertexArray(_blurProgram.vao);
+            for (var i = 0; i < _blurRepetition * 2; i++) {
+                gl.bindFramebuffer(gl.FRAMEBUFFER, this._blurFrameBuffers[i % 2]);
+                gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this._blurTextures[(i + 1) % 2], 0);
+                gl.bindTexture(gl.TEXTURE_2D, this._blurTextures[i % 2]);
+                gl.uniform1i(_blurProgram.u_texture, 0);
+                gl.uniform1f(_blurProgram.u_horizontal, i % 2 == 0);
+                gl.drawArrays(gl.TRIANGLES, 0, 6);
+            }
+        }
+        if (!_premultipliedAlpha) {
+            (0, util_1.defaultblendfunction)(gl);
+        }
+        { // combine  
+            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+            gl.useProgram(this._combineProgram.program);
+            gl.bindVertexArray(this._combineProgram.vao);
+            gl.activeTexture(gl.TEXTURE1);
+            gl.bindTexture(gl.TEXTURE_2D, this._blurTextures[1]);
+            gl.uniform1i(this._combineProgram.u_bloom_texture, 1);
+            gl.activeTexture(gl.TEXTURE0);
+            gl.bindTexture(gl.TEXTURE_2D, this._middleTexture);
+            gl.uniform1i(this._combineProgram.u_main_texture, 0);
+            gl.drawArrays(gl.TRIANGLES, 0, 6);
+        }
+        gl.bindVertexArray(null);
+        if (_premultipliedAlpha) {
+            (0, util_1.defaultblendfunction)(gl);
+        }
+    };
+    TrackGlowLineProgram.prototype.free = function () {
+        var _a = this, gl = _a.gl, _lineProgram = _a._lineProgram, _blurProgram = _a._blurProgram, _combineProgram = _a._combineProgram;
+        gl.deleteBuffer(this._inBuffer);
+        gl.deleteFramebuffer(this._frameBuffer);
+        gl.deleteFramebuffer(this._blurFrameBuffers[0]);
+        gl.deleteFramebuffer(this._blurFrameBuffers[1]);
+        // gl.deleteBuffer(this._middleTexture);
+        gl.deleteTexture(this._middleTexture);
+        gl.deleteTexture(this._blurTextures[0]);
+        gl.deleteTexture(this._blurTextures[1]);
+        gl.deleteVertexArray(_lineProgram.vao);
+        gl.deleteVertexArray(_blurProgram.vao);
+        gl.deleteVertexArray(_combineProgram.vao);
+        gl.deleteProgram(_lineProgram.program);
+        gl.deleteProgram(_blurProgram.program);
+        gl.deleteProgram(_combineProgram.program);
+    };
+    return TrackGlowLineProgram;
+}());
+exports.default = TrackGlowLineProgram;

package/timetracks/programpoint-line-strip.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../util");
+var programs_1 = require("../programs");
+var vertexShader = "#version 300 es\n\nlayout(std140) uniform GlobeCamera {\n    mat4 view; // 64 bytes           0\n    mat4 projection; // 64 bytes     64\n    vec3 translate; // 12 bytes      128\n    bool is3D; // 4 bytes            140\n    vec2 mapWH; // 8 bytes           144\n    vec2 screenWH; //  8 bytes       152\n    float z_level; // 4 bytes        160\n};\n\nlayout(std140) uniform Globals {\n    float head_time;\n    float final_opacity;\n    float point_size;\n};\n\nin vec3 start_position;\nin float start_time;\nin vec3 start_color;\nin vec3 end_position;\nin float end_time;\nin vec3 end_color;\nout vec4 v_color;\n\n" + util_1.shaderfunctions.pixelXYToCartesian3DPoint + util_1.shaderfunctions.pixelXYToCartesian2DPoint + "\n\nvoid main() {\n    if (head_time < start_time || head_time > end_time) { return; }\n    if ( start_color.r < 0.0 || end_color.r < 0.0) { return; }\n    float t = (head_time - start_time) / (end_time - start_time);\n    vec3 position = mix(start_position, end_position, t);\n    if (is3D){\n        vec3 pos = pixelXYToCartesian3DPoint(position);\n        gl_Position = projection * view * vec4(pos - translate, 1.0);\n    }  else {\n        vec2 xy = pixelXYToCartesian2DPoint(position.xy, translate.xy, mapWH, screenWH);\n        gl_Position = projection * vec4(xy.x, xy.y, 0.0, 1.0);\n    }\n    v_color = vec4(mix(start_color, end_color, t), final_opacity);\n    gl_PointSize = point_size;\n}";
+var fragmentShader = "#version 300 es\nprecision highp float;\nin vec4 v_color;\nout vec4 outColor;\nvoid main() {\n    // circle point\n    vec2 cxy = 2.0 * gl_PointCoord - 1.0;\n    float cc = dot(cxy, cxy);\n    outColor = v_color;\n    if (cc > 0.5) {\n        outColor.a = 0.0;    \n }\n}";
+var default_1 = /** @class */ (function () {
+    function default_1(gl, globe, attrBuffer, options) {
+        this.gl = gl;
+        this._cameraBlockBindingPoint = 0;
+        this._globalsBlockBindingPoint = 1;
+        this.cameraUniformBlockTotem = programs_1.globeProgramCache.getProgram(globe, programs_1.CameraUniformBlockTotem);
+        this._vao = gl.createVertexArray();
+        this._attbuffer = attrBuffer;
+        this.program = this._createProgram();
+        this._drawCount = 0;
+        this._globalsbuffer = gl.createBuffer();
+        {
+            var _a = this, gl_1 = _a.gl, _globalsbuffer = _a._globalsbuffer;
+            gl_1.bindBuffer(gl_1.UNIFORM_BUFFER, _globalsbuffer);
+            gl_1.bufferData(gl_1.UNIFORM_BUFFER, 12, gl_1.STREAM_DRAW);
+            gl_1.bufferSubData(gl_1.UNIFORM_BUFFER, 0, new Float32Array([0, options.opacity, options.pointSize]));
+            gl_1.bindBufferBase(gl_1.UNIFORM_BUFFER, this._globalsBlockBindingPoint, _globalsbuffer);
+            gl_1.bindBuffer(gl_1.UNIFORM_BUFFER, null);
+        }
+    }
+    default_1.prototype._createProgram = function () {
+        var gl = this.gl;
+        var program = (0, util_1.createProgram)(gl, vertexShader, fragmentShader);
+        var ubo = this.cameraUniformBlockTotem.getUBO(); // ubo bl
+        var cameraBlockIndex = gl.getUniformBlockIndex(program, "GlobeCamera");
+        gl.uniformBlockBinding(program, cameraBlockIndex, this._cameraBlockBindingPoint);
+        var globalsBlockIndex = gl.getUniformBlockIndex(program, "Globals");
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._cameraBlockBindingPoint, ubo);
+        gl.uniformBlockBinding(program, globalsBlockIndex, this._globalsBlockBindingPoint);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._globalsBlockBindingPoint, this._globalsbuffer);
+        // numaralarda yanlışlık olabilir
+        var start_position = gl.getAttribLocation(program, "start_position");
+        var start_time = gl.getAttribLocation(program, "start_time");
+        var start_color = gl.getAttribLocation(program, "start_color");
+        var end_position = gl.getAttribLocation(program, "end_position");
+        var end_time = gl.getAttribLocation(program, "end_time");
+        var end_color = gl.getAttribLocation(program, "end_color");
+        gl.bindVertexArray(this._vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._attbuffer);
+        gl.enableVertexAttribArray(start_position);
+        gl.vertexAttribPointer(start_position, 3, gl.FLOAT, false, 36, 0);
+        gl.enableVertexAttribArray(start_time);
+        gl.vertexAttribPointer(start_time, 1, gl.FLOAT, false, 36, 12);
+        gl.enableVertexAttribArray(start_color);
+        gl.vertexAttribPointer(start_color, 3, gl.FLOAT, false, 36, 16);
+        gl.enableVertexAttribArray(end_position);
+        gl.vertexAttribPointer(end_position, 3, gl.FLOAT, false, 36, 36);
+        gl.enableVertexAttribArray(end_time);
+        gl.vertexAttribPointer(end_time, 1, gl.FLOAT, false, 36, 48);
+        gl.enableVertexAttribArray(end_color);
+        gl.vertexAttribPointer(end_color, 3, gl.FLOAT, false, 36, 52);
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return program;
+    };
+    default_1.prototype.setOpacity = function (opacity) {
+        var _a = this, gl = _a.gl, _globalsbuffer = _a._globalsbuffer;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 4, new Float32Array([opacity]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    };
+    default_1.prototype.setDrawCount = function (count) {
+        this._drawCount = count;
+    };
+    default_1.prototype.setPointSize = function (size) {
+        var _a = this, gl = _a.gl, _globalsbuffer = _a._globalsbuffer;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 8, new Float32Array([size]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    };
+    default_1.prototype.setHeadTime = function (time) {
+        var _a = this, gl = _a.gl, _globalsbuffer = _a._globalsbuffer;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([time]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    };
+    default_1.prototype.draw = function () {
+        var _a = this, gl = _a.gl, program = _a.program, _vao = _a._vao, _drawCount = _a._drawCount;
+        gl.useProgram(program);
+        gl.bindVertexArray(_vao);
+        gl.disable(gl.DEPTH_TEST);
+        gl.drawArrays(gl.POINTS, 0, _drawCount);
+        gl.enable(gl.DEPTH_TEST);
+        gl.bindVertexArray(null);
+    };
+    default_1.prototype.free = function () {
+        var _a = this, gl = _a.gl, _vao = _a._vao, _globalsbuffer = _a._globalsbuffer, program = _a.program;
+        gl.deleteVertexArray(_vao);
+        // gl.deleteBuffer(_attbuffer);
+        gl.deleteBuffer(_globalsbuffer);
+        gl.deleteProgram(program);
+    };
+    return default_1;
+}());
+exports.default = default_1;