@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/programs/totems/canvas-webglobe-info.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CameraUniformBlockTotemCache = exports.WebglobeInfoUniformBlockString = void 0;
+var programcache_1 = require("../programcache");
+exports.WebglobeInfoUniformBlockString = "\nlayout(std140) uniform WebglobeInfo {\n    vec2 canvas_resolution;\n    vec2 mouse_radian_long_lat;\n    vec2 mouse_pixel_xy;\n    float north_angle;\n    float world_tilt;\n    float earth_distance;\n}; \n";
+var CameraUniformBlockTotem = /** @class */ (function () {
+    function CameraUniformBlockTotem() {
+        this.id = "CameraUniformBlockTotem";
+        this.description = "Sets a uniform block and provides buffer for it. The following is the glsl uniform block:" + CameraUniformBlockString;
+        this.gl = null;
+        this.globe = null;
+        this.ubo = null;
+    }
+    CameraUniformBlockTotem.prototype.init = function (globe, gl) {
+        this.gl = gl;
+        this.globe = globe;
+        this.ubo = this._createUBO();
+        this.traslateFloat32 = new Float32Array(3);
+        this.mapWHFloat32 = new Float32Array(2);
+        this.setGeometry();
+        this.resize();
+    };
+    CameraUniformBlockTotem.prototype._createUBO = function () {
+        var gl = this.gl;
+        var ubo = gl.createBuffer();
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.bufferData(gl.UNIFORM_BUFFER, 164, gl.STREAM_DRAW);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, 0, ubo);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        return ubo;
+    };
+    CameraUniformBlockTotem.prototype.resize = function () {
+        var _a = this, gl = _a.gl, globe = _a.globe, ubo = _a.ubo;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 152, new Float32Array([globe.api_ScrW(), globe.api_ScrH()]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    };
+    CameraUniformBlockTotem.prototype.setGeometry = function () {
+        var _a = this, gl = _a.gl, globe = _a.globe, ubo = _a.ubo;
+        var is3D = globe.api_GetCurrentGeometry() === 0;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 140, new Float32Array([is3D]));
+    };
+    CameraUniformBlockTotem.prototype.draw3D = function (projection, modelView, translate) {
+        var _a = this, gl = _a.gl, traslateFloat32 = _a.traslateFloat32, ubo = _a.ubo, mapWHFloat32 = _a.mapWHFloat32, globe = _a.globe;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        { // view, projection, translate
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 0, modelView);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 64, projection);
+            traslateFloat32.set([translate.x, translate.y, translate.z], 0);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 128, traslateFloat32);
+        }
+        {
+            // zoom level
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 160, new Float32Array([globe.api_GetCurrentLODWithDecimal()]));
+        }
+        { // mapWH
+            if (globe.api_GetCurrentGeometry() === 1) {
+                var _b = globe.api_GetCurrentWorldWH(), width = _b.width, height = _b.height;
+                mapWHFloat32.set([width, height]);
+                gl.bufferSubData(gl.UNIFORM_BUFFER, 144, mapWHFloat32);
+            }
+        }
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    };
+    CameraUniformBlockTotem.prototype.getUBO = function () {
+        return this.ubo;
+    };
+    CameraUniformBlockTotem.prototype.bind = function (bindingPoint) {
+        var _a = this, gl = _a.gl, ubo = _a.ubo;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, ubo);
+    };
+    CameraUniformBlockTotem.prototype.unbind = function (bindingPoint) {
+        var gl = this.gl;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, null);
+    };
+    CameraUniformBlockTotem.prototype.free = function () {
+        var _a = this, gl = _a.gl, ubo = _a.ubo;
+        gl.deleteBuffer(ubo);
+    };
+    CameraUniformBlockTotem.prototype.readBuffer = function () {
+        var result = new Float32Array(41);
+        this.gl.bindBuffer(this.gl.UNIFORM_BUFFER, this.ubo);
+        this.gl.getBufferSubData(this.gl.UNIFORM_BUFFER, 0, result);
+        this.gl.bindBuffer(this.gl.UNIFORM_BUFFER, null);
+        return {
+            view: result.slice(0, 16),
+            projection: result.slice(16, 32),
+            translate: result.slice(32, 35),
+            is3D: result[35],
+            mapWH: result.slice(36, 38),
+            screenWH: result.slice(38, 40),
+            z_level: result[40]
+        };
+    };
+    return CameraUniformBlockTotem;
+}());
+exports.default = CameraUniformBlockTotem;
+exports.CameraUniformBlockTotemCache = Object.freeze({
+    get: function (globe) { return programcache_1.globeProgramCache.getProgram(globe, CameraUniformBlockTotem); },
+    release: function (globe) { return programcache_1.globeProgramCache.releaseProgram(globe, CameraUniformBlockTotem); }
+});

package/programs/totems/gpu-selection-uniform-block.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CameraUniformBlockTotemCache = exports.CameraUniformBlockString = void 0;
+var programcache_1 = require("../programcache");
+// Loads mouse position to buffer
+// TODO implement it
+exports.CameraUniformBlockString = "\nlayout(std140) uniform GpuSelectionUniformBlock {\n    vec2 mouse_pixel_position;\n    vec2 mouse_radian_long_lat;\n}; // 11 lines\n";
+var CameraUniformBlockTotem = /** @class */ (function () {
+    function CameraUniformBlockTotem() {
+        this.id = "CameraUniformBlockTotem";
+        this.description = "Sets a uniform block and provides buffer for it. The following is the glsl uniform block:" + exports.CameraUniformBlockString;
+        this.gl = null;
+        this.globe = null;
+        this.ubo = null;
+    }
+    CameraUniformBlockTotem.prototype.init = function (globe, gl) {
+        this.gl = gl;
+        this.globe = globe;
+        this.ubo = this._createUBO();
+        this.traslateFloat32 = new Float32Array(3);
+        this.mapWHFloat32 = new Float32Array(2);
+        this.setGeometry();
+        this.resize();
+    };
+    CameraUniformBlockTotem.prototype._createUBO = function () {
+        var gl = this.gl;
+        var ubo = gl.createBuffer();
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.bufferData(gl.UNIFORM_BUFFER, 164, gl.STREAM_DRAW);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, 0, ubo);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        return ubo;
+    };
+    CameraUniformBlockTotem.prototype.resize = function () {
+        var _a = this, gl = _a.gl, globe = _a.globe, ubo = _a.ubo;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 152, new Float32Array([globe.api_ScrW(), globe.api_ScrH()]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    };
+    CameraUniformBlockTotem.prototype.setGeometry = function () {
+        var _a = this, gl = _a.gl, globe = _a.globe, ubo = _a.ubo;
+        var is3D = globe.api_GetCurrentGeometry() === 0;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 140, new Float32Array([is3D]));
+    };
+    CameraUniformBlockTotem.prototype.draw3D = function (projection, modelView, translate) {
+        var _a = this, gl = _a.gl, traslateFloat32 = _a.traslateFloat32, ubo = _a.ubo, mapWHFloat32 = _a.mapWHFloat32, globe = _a.globe;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        { // view, projection, translate
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 0, modelView);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 64, projection);
+            traslateFloat32.set([translate.x, translate.y, translate.z], 0);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 128, traslateFloat32);
+        }
+        {
+            // zoom level
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 160, new Float32Array([globe.api_GetCurrentLODWithDecimal()]));
+        }
+        { // mapWH
+            if (globe.api_GetCurrentGeometry() === 1) {
+                var _b = globe.api_GetCurrentWorldWH(), width = _b.width, height = _b.height;
+                mapWHFloat32.set([width, height]);
+                gl.bufferSubData(gl.UNIFORM_BUFFER, 144, mapWHFloat32);
+            }
+        }
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    };
+    CameraUniformBlockTotem.prototype.getUBO = function () {
+        return this.ubo;
+    };
+    CameraUniformBlockTotem.prototype.bind = function (bindingPoint) {
+        var _a = this, gl = _a.gl, ubo = _a.ubo;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, ubo);
+    };
+    CameraUniformBlockTotem.prototype.unbind = function (bindingPoint) {
+        var gl = this.gl;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, null);
+    };
+    CameraUniformBlockTotem.prototype.free = function () {
+        var _a = this, gl = _a.gl, ubo = _a.ubo;
+        gl.deleteBuffer(ubo);
+    };
+    CameraUniformBlockTotem.prototype.readBuffer = function () {
+        var result = new Float32Array(41);
+        this.gl.bindBuffer(this.gl.UNIFORM_BUFFER, this.ubo);
+        this.gl.getBufferSubData(this.gl.UNIFORM_BUFFER, 0, result);
+        this.gl.bindBuffer(this.gl.UNIFORM_BUFFER, null);
+        return {
+            view: result.slice(0, 16),
+            projection: result.slice(16, 32),
+            translate: result.slice(32, 35),
+            is3D: result[35],
+            mapWH: result.slice(36, 38),
+            screenWH: result.slice(38, 40),
+            z_level: result[40]
+        };
+    };
+    return CameraUniformBlockTotem;
+}());
+exports.default = CameraUniformBlockTotem;
+exports.CameraUniformBlockTotemCache = Object.freeze({
+    get: function (globe) { return programcache_1.globeProgramCache.getProgram(globe, CameraUniformBlockTotem); },
+    release: function (globe) { return programcache_1.globeProgramCache.releaseProgram(globe, CameraUniformBlockTotem); }
+});

package/programs/totems/index.js

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

package/programs/two-d/pixel-circle.js

@@ -0,0 +1 @@
+"use strict";

package/programs/two-d/pixel-padding-for-compass.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelPaddingForFlatCompassCache = void 0;
+var util_1 = require("../../util");
+var totems_1 = require("../totems");
+var programcache_1 = require("../programcache");
+var vertexCount = 720;
+var vertexShaderSource = "#version 300 es\n".concat(totems_1.CameraUniformBlockString, "\n\nin vec2 screen_coordinate;\nin float pixel_radius_small_ratio;\nin float pixel_radius_big_ratio;\nin vec4 rgba;\nout vec4 v_rgba;\nuniform float plugin_opacity;\n\nvec3 coord_opacity(){\n    float radius;\n    float angle;\n    float gap = (pixel_radius_big_ratio - pixel_radius_small_ratio);\n    if( gl_VertexID % 2 == 0){\n        // if( gl_VertexID % 180 == 0){\n        //      radius = pixel_radius_small_ratio ;\n        // } else\n        if ( gl_VertexID % 60 == 0){\n            radius =  pixel_radius_small_ratio; \n        } else if( gl_VertexID % 10 == 0) {\n            radius =  pixel_radius_small_ratio + gap * 0.5;\n        } else {\n            radius =  pixel_radius_small_ratio + gap* 0.75;\n        }\n        angle = (float(gl_VertexID) / (").concat(vertexCount, ".0));\n    } else {\n        if ( gl_VertexID % 180 == 1){\n            radius = pixel_radius_big_ratio + gap * 0.1;\n\n        } else {\n            radius = pixel_radius_big_ratio;\n         }\n        angle = (float(gl_VertexID - 1) / (").concat(vertexCount, ".0));\n    }\n    float opacity =  fract(angle + 0.2475) / 1.5 + 0.33;\n    angle = angle * ").concat(Math.PI * 2.0, " + world_north_angle;\n    radius = radius *  min(screenWH.x, screenWH.y) / 2.0;;\n    return vec3( screen_coordinate + vec2( cos(angle), sin(angle)) * radius, opacity);\n}\n\nvec2 adjust_pos(vec2 pos) {\n    return vec2(\n        (pos.x / screenWH.x - 0.5) * 2.0,\n        (0.5 - pos.y / screenWH.y) * 2.0\n    );\n}\n\nvoid main(){\n    vec3 c = coord_opacity();\n    gl_Position = vec4( adjust_pos(c.xy), 0.0, 1.0);\n    v_rgba = rgba;\n    v_rgba.a *= plugin_opacity;\n    gl_PointSize = 10.0;\n}\n");
+var fragmentShaderSource = "#version 300 es\nprecision highp float;\nin vec4 v_rgba;\nout vec4 color;\nvoid main(){\n    color = v_rgba;\n}\n";
+var Logic = /** @class */ (function () {
+    function Logic(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._lastOpacity = 1;
+        this.program = (0, util_1.createProgram)(this.gl, vertexShaderSource, fragmentShaderSource);
+        var _a = this, gl = _a.gl, program = _a.program;
+        { // assign attribute locations
+            //             in vec2 screen_coordinate;
+            // in float pixel_radius_small_ratio;
+            // in float pixel_radius_big_ratio;
+            // in vec4 rgba;
+            gl.bindAttribLocation(program, 0, "screen_coordinate");
+            gl.bindAttribLocation(program, 1, "pixel_radius_small_ratio");
+            gl.bindAttribLocation(program, 2, "pixel_radius_big_ratio");
+            gl.bindAttribLocation(program, 3, "rgba");
+        }
+        {
+            this._opacityLocation = gl.getUniformLocation(program, "plugin_opacity");
+            var currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(this._opacityLocation, this._lastOpacity);
+            gl.useProgram(currentProgram);
+        }
+        {
+            this.cameraBlockBindingPoint = 0;
+            var cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+            this.cameraBlockTotem = totems_1.CameraUniformBlockTotemCache.get(globe);
+            gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBindingPoint);
+        }
+    }
+    Logic.prototype.draw = function (vao, length, opacity) {
+        var _a = this, globe = _a.globe, gl = _a.gl, program = _a.program, cameraBlockTotem = _a.cameraBlockTotem, cameraBlockBindingPoint = _a.cameraBlockBindingPoint, _opacityLocation = _a._opacityLocation;
+        if (globe.api_GetCurrentGeometry() === 0)
+            return;
+        gl.useProgram(program);
+        cameraBlockTotem.bind(cameraBlockBindingPoint);
+        if (opacity !== this._lastOpacity) {
+            this._lastOpacity = opacity;
+            gl.uniform1f(_opacityLocation, opacity);
+        }
+        gl.bindVertexArray(vao);
+        gl.drawArraysInstanced(gl.LINES, 0, vertexCount, length);
+        gl.bindVertexArray(null);
+        cameraBlockTotem.unbind(cameraBlockBindingPoint);
+    };
+    Logic.prototype.createVAO = function (screenCoordsBufferObj, pixelRadiusRatioSmallBufferObj, pixelRadiusRatioBigBufferObj, rgbaBufferObj) {
+        var gl = this.gl;
+        var vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        {
+            var buffer = screenCoordsBufferObj.buffer, _a = screenCoordsBufferObj.stride, stride = _a === void 0 ? 0 : _a, _b = screenCoordsBufferObj.offset, offset = _b === void 0 ? 0 : _b;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(0);
+            gl.vertexAttribPointer(0, 2, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(0, 1);
+        }
+        {
+            var buffer = pixelRadiusRatioSmallBufferObj.buffer, _c = pixelRadiusRatioSmallBufferObj.stride, stride = _c === void 0 ? 0 : _c, _d = pixelRadiusRatioSmallBufferObj.offset, offset = _d === void 0 ? 0 : _d;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(1);
+            gl.vertexAttribPointer(1, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(1, 1);
+        }
+        {
+            var buffer = pixelRadiusRatioBigBufferObj.buffer, _e = pixelRadiusRatioBigBufferObj.stride, stride = _e === void 0 ? 0 : _e, _f = pixelRadiusRatioBigBufferObj.offset, offset = _f === void 0 ? 0 : _f;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(2);
+            gl.vertexAttribPointer(2, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(2, 1);
+        }
+        {
+            var buffer = rgbaBufferObj.buffer, _g = rgbaBufferObj.stride, stride = _g === void 0 ? 0 : _g, _h = rgbaBufferObj.offset, offset = _h === void 0 ? 0 : _h;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(3);
+            gl.vertexAttribPointer(3, 4, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(3, 1);
+        }
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+    };
+    Logic.prototype.free = function () {
+        var globe = this.globe;
+        totems_1.CameraUniformBlockTotemCache.release(globe);
+    };
+    return Logic;
+}());
+exports.PixelPaddingForFlatCompassCache = Object.freeze({
+    get: function (globe) { return programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic); },
+    release: function (globe) { return programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, Logic); }
+});

package/programs/util.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.longlatbbox2normalbbox = longlatbbox2normalbbox;
+function longlatbbox2normalbbox(_a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.minLon, minLon = _c === void 0 ? -180 : _c, _d = _b.maxLon, maxLon = _d === void 0 ? 180 : _d, _e = _b.minLat, minLat = _e === void 0 ? -90 : _e, _f = _b.maxLat, maxLat = _f === void 0 ? 90 : _f;
+    // x
+    var horOffset = (minLon) * Math.PI / 180;
+    var horSize = (maxLon - minLon) * Math.PI / 180;
+    // y
+    var vertOffset = (90 - maxLat) * Math.PI / 180;
+    var vertSize = (maxLat - minLat) * Math.PI / 180;
+    var result = {
+        bboxOffsetRad: new Float32Array([horOffset, vertOffset]),
+        bboxSizeRad: new Float32Array([horSize, vertSize])
+    };
+    console.log("longlatbbox2normalbbox", result);
+    return result;
+}

package/programs/vectorfields/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PingPongBufferManager = void 0;
+var pingpongbuffermanager_1 = __importDefault(require("./pingpongbuffermanager"));
+exports.PingPongBufferManager = pingpongbuffermanager_1.default;
+__exportStar(require("./logics"), exports);

package/programs/vectorfields/logics/drawrectangleparticles.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../../../util");
+var ubo_js_1 = require("./ubo.js");
+var programcache_1 = require("../../programcache");
+/**
+ * [+] ubo
+ */
+var vertexShaderSource = "#version 300 es\nprecision highp float;\n" + ubo_js_1.shaderUboSource + "\nuniform sampler2D u_vector_field;\nin vec2 in_position;\nout vec3 base_color;\nvec2 lookup_wind(const vec2 uv) { // gerek kalmayabilir. sampler linear methodu ayni isi yapiyor \n    // return texture(u_vector_field, uv).rg; // lower-res hardware filtering\n    vec2 res = vec2(textureSize(u_vector_field, 0));\n    vec2 px = 1.0 / res;\n    vec2 vc = (floor(uv * res)) * px;\n    vec2 f = fract(uv * res);\n    vec2 tl = texture(u_vector_field, vc).rg;\n    vec2 tr = texture(u_vector_field, vc + vec2(px.x, 0)).rg;\n    vec2 bl = texture(u_vector_field, vc + vec2(0, px.y)).rg;\n    vec2 br = texture(u_vector_field, vc + px).rg;\n    return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);\n}\n\n\nvoid main(){\n    vec2 direction_vector = lookup_wind(in_position);\n    if (direction_vector.r == 0.0 && direction_vector.g == 0.0){ return;}\n\n    vec2 limp;\n    if ( 0 == gl_VertexID) { limp = -tail_wing_base_limp; }\n    else if ( 1 == gl_VertexID) { limp = vec2( tail_wing_base_limp.x, -tail_wing_base_limp.y); }\n    else if ( 2 == gl_VertexID) { limp = tail_wing_base_limp; }\n    else  { limp = vec2(-tail_wing_base_limp.x,  tail_wing_base_limp.y); } // if ( 3 == gl_VertexID)\n\n    limp = (limp  * mat2( \n        direction_vector.x, -direction_vector.y,\n        direction_vector.y, direction_vector.x)) / draw_texture_size;\n\n    vec2 pos = in_position * 2.0 - 1.0;\n    gl_Position = vec4(pos + limp, 0.0, 1.0);\n    base_color = color;\n}";
+var fragmentShaderSource = "#version 300 es\nprecision highp float;\nout vec4 outColor;\nin vec3 base_color;\nvoid main(){\n    outColor = vec4(base_color, 1.0);\n}";
+var Logic = /** @class */ (function () {
+    function Logic(gl) {
+        var _a;
+        this.gl = gl;
+        _a = this._createProgram(), this.program = _a[0], this._vector_field_location = _a[1];
+        // this.decoyBuffer = new DecoyBufferManager(gl);
+    }
+    Logic.prototype._createProgram = function () {
+        var gl = this.gl;
+        var program = (0, util_1.createProgram)(gl, vertexShaderSource, fragmentShaderSource);
+        // ubo point
+        var ubo_location = gl.getUniformBlockIndex(program, 'UBO');
+        gl.uniformBlockBinding(program, ubo_location, ubo_js_1.UBO_BINDING_POINT);
+        return [program, gl.getUniformLocation(program, 'u_vector_field')];
+    };
+    /**
+     * @param {*} bufferManager | PingPongBufferManager
+     * @param {*} vectorTexture | RG32F texture R: x, G: y
+     * @param {*} uboManager | WaveParticalUboManager under ubo.js
+     */
+    Logic.prototype.draw = function (bufferManager, vectorTexture, uboManager) {
+        var _a = this, gl = _a.gl, program = _a.program;
+        gl.useProgram(program);
+        gl.bindVertexArray(bufferManager.getSourceVao());
+        // gl.bindVertexArray(this.decoyBuffer.getSourceVao());
+        uboManager.bind();
+        gl.activeTexture(gl.TEXTURE0);
+        gl.uniform1i(this._vector_field_location, 0);
+        gl.bindTexture(gl.TEXTURE_2D, vectorTexture);
+        gl.drawArraysInstanced(gl.TRIANGLE_FAN, 0, 4, bufferManager.length);
+        gl.drawArraysInstanced(gl.POINTS, 0, 4, bufferManager.length);
+        gl.bindVertexArray(null);
+        uboManager.unbind();
+    };
+    Logic.prototype.free = function () {
+        this.gl.deleteProgram(this.program);
+        this.program = null;
+    };
+    return Logic;
+}());
+var default_1 = /** @class */ (function () {
+    function default_1(gl) {
+        this.gl = gl;
+        this.logic = programcache_1.glProgramCache.getProgram(gl, Logic);
+    }
+    default_1.prototype.draw = function (bufferManager, vectorTexture, uboManager) {
+        this.logic.draw(bufferManager, vectorTexture, uboManager);
+    };
+    default_1.prototype.free = function () {
+        programcache_1.glProgramCache.releaseProgram(this.gl, Logic);
+        this.logic = null;
+        this.gl = null;
+    };
+    return default_1;
+}());
+exports.default = default_1;

package/programs/vectorfields/logics/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaveParticalUboManager = exports.DrawRectangleParticles = exports.PixelBasedMove = void 0;
+var pixelbased_1 = __importDefault(require("./pixelbased"));
+exports.PixelBasedMove = pixelbased_1.default;
+var drawrectangleparticles_1 = __importDefault(require("./drawrectangleparticles"));
+exports.DrawRectangleParticles = drawrectangleparticles_1.default;
+var ubo_1 = require("./ubo");
+Object.defineProperty(exports, "WaveParticalUboManager", { enumerable: true, get: function () { return ubo_1.WaveParticalUboManager; } });

package/programs/vectorfields/logics/pixelbased.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../../../util");
+var ubo_js_1 = require("./ubo.js");
+var programcache_1 = require("../../programcache");
+// program output is buffer
+// TODO: Mechanism for randomness
+//  drop out mechanism
+//  random particle position mechanism
+var vertexShaderSource = "#version 300 es\n" + ubo_js_1.shaderUboSource + "\n\nuniform sampler2D vector_field;\nin vec2 in_position;\nout vec2 out_position;\n\n// float random(vec2 st){\n//     float t = dot(st, vec2(12.9898,78.233));\n//     return fract(sin(t) * (t+43758.5453123));\n// }\n\n\nconst vec3 rand_constants = vec3(12.9898, 78.233, 4375.85453);\nfloat random(const vec2 co) {\n    float t = dot(rand_constants.xy, co);\n    return fract(sin(t) * (rand_constants.z + t));\n}\n\nvec2 lookup_wind(const vec2 uv) { // gerek kalmayabilir. sampler linear methodu ayni isi yapiyor\n    // return texture(vector_field, uv).rg; // lower-res hardware filtering\n    vec2 res = vec2(textureSize(vector_field, 0));\n    if (res.x == 0.0 || res.y == 0.0){ return vec2(0.0);}\n    vec2 px = 1.0 / res;\n    vec2 vc = (floor(uv * res)) * px;\n    vec2 f = fract(uv * res);\n    vec2 tl = texture(vector_field, vc).rg;\n    vec2 tr = texture(vector_field, vc + vec2(px.x, 0)).rg;\n    vec2 bl = texture(vector_field, vc + vec2(0, px.y)).rg;\n    vec2 br = texture(vector_field, vc + px).rg;\n    if (tl.x == 0.0 && tl.y == 0.0){ return vec2(0.0);}\n    if (tr.x == 0.0 && tr.y == 0.0){ return vec2(0.0);}\n    if (bl.x == 0.0 && bl.y == 0.0){ return vec2(0.0);}\n    if (br.x == 0.0 && br.y == 0.0){ return vec2(0.0);}\n    return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);\n}\n\n\nvec2 random_position(vec2 st){\n    return vec2(random(st), random(st + 1.0));\n}\n\n\nvoid main(){\n    vec2 vec = lookup_wind(in_position).xy;\n    if (vec.x == 0.0 && vec.y == 0.0){\n        out_position = random_position(in_position);\n        return;\n    }\n    float random_value = random(in_position + random_seed);\n    if (random_value < drop_rate){ //TODO: more sophisticated drop out mechanism mi\n        out_position = random_position(in_position);\n        return;\n    }\n    out_position = in_position - (vec / draw_texture_size)  * range; //*0.0014\n}\n";
+var fragmentShaderSource = "#version 300 es\nprecision highp float;\nvoid main(){\n}";
+var Logic = /** @class */ (function () {
+    function Logic(gl) {
+        var _a;
+        this.gl = gl;
+        _a = this._createProgram(), this.program = _a[0], this._vector_field_location = _a[1];
+    }
+    /**
+     * @param {*} bufferManager | PingPongBufferManager
+     * @param {*} vectorTexture RG32F texture R: x, G: y
+     * @param {*} uboManager | WaveParticalUboManager under ubo.js
+     */
+    Logic.prototype.move = function (bufferManager, vectorTexture, uboManager) {
+        var _a = this, gl = _a.gl, program = _a.program, _vector_field_location = _a._vector_field_location;
+        gl.useProgram(program);
+        gl.enable(gl.RASTERIZER_DISCARD);
+        gl.bindVertexArray(bufferManager.getSourceVao());
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, bufferManager.getTargetTF());
+        gl.beginTransformFeedback(gl.POINTS);
+        uboManager.bind();
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, vectorTexture);
+        gl.uniform1i(_vector_field_location, 0);
+        gl.drawArraysInstanced(gl.POINTS, 0, 1, bufferManager.length);
+        gl.endTransformFeedback();
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
+        gl.bindVertexArray(null);
+        uboManager.unbind();
+        gl.disable(gl.RASTERIZER_DISCARD);
+    };
+    // -- private methods
+    Logic.prototype._createProgram = function () {
+        var gl = this.gl;
+        var vertexShader = (0, util_1.createShader)(gl, gl.VERTEX_SHADER, vertexShaderSource);
+        var fragmentShader = (0, util_1.createShader)(gl, gl.FRAGMENT_SHADER, fragmentShaderSource);
+        var program = gl.createProgram();
+        gl.attachShader(program, vertexShader);
+        gl.attachShader(program, fragmentShader);
+        gl.transformFeedbackVaryings(program, ["out_position"], gl.SEPARATE_ATTRIBS);
+        gl.linkProgram(program);
+        if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+            throw new Error(gl.getProgramParameter(program));
+        }
+        var ubo_location = gl.getUniformBlockIndex(program, 'UBO');
+        gl.uniformBlockBinding(program, ubo_location, ubo_js_1.UBO_BINDING_POINT);
+        return [program, gl.getUniformLocation(program, 'vector_field')];
+        ;
+    };
+    Logic.prototype.free = function () {
+        this.gl.deleteProgram(this.program);
+        this.program = null;
+    };
+    Logic.prototype.getInPositionLocation = function () {
+        return this.gl.getAttribLocation(this.program, 'in_position');
+    };
+    return Logic;
+}());
+var default_1 = /** @class */ (function () {
+    function default_1(gl) {
+        this.gl = gl;
+        this.logic = programcache_1.glProgramCache.getProgram(gl, Logic);
+    }
+    default_1.prototype.move = function (bufferManager, vectorTexture, uboManager) {
+        this.logic.move(bufferManager, vectorTexture, uboManager);
+    };
+    default_1.prototype.free = function () {
+        programcache_1.glProgramCache.releaseProgram(this.gl, Logic);
+        this.program = null;
+        this.gl = null;
+    };
+    default_1.prototype.getInPositionLocation = function () {
+        return this.logic.getInPositionLocation();
+    };
+    return default_1;
+}());
+exports.default = default_1;

package/programs/vectorfields/logics/ubo.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shaderUboSource = exports.UBO_BINDING_POINT = exports.UBO_SIZE = exports.WaveParticalUboManager = void 0;
+var UBO_BINDING_POINT = 0;
+exports.UBO_BINDING_POINT = UBO_BINDING_POINT;
+var INITIAL_UBO_DATA = new Float32Array([93.17, 0.2, 1.0, 7.0, 1.0, 1.0, 1.0, 0.05, 2000, 2000]);
+var shaderUboSource = "\nlayout(std140) uniform UBO {\n    float random_seed;\n    float range;\n    vec2 tail_wing_base_limp;\n    vec3 color;\n    float drop_rate;\n    vec2 draw_texture_size;\n};";
+exports.shaderUboSource = shaderUboSource;
+var UBO_SIZE = 40;
+exports.UBO_SIZE = UBO_SIZE;
+var WaveParticalUboManager = /** @class */ (function () {
+    function WaveParticalUboManager(gl) {
+        this.gl = gl;
+        this.ubo = this._createBuffer();
+        this._data = null;
+    }
+    WaveParticalUboManager.prototype.update = function (_a) {
+        var range = _a.range, random_seed = _a.random_seed, tail_wing_base_limp = _a.tail_wing_base_limp, draw_texture_size = _a.draw_texture_size, drop_rate = _a.drop_rate, color = _a.color;
+        var _b = this, gl = _b.gl, ubo = _b.ubo;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        if (random_seed !== undefined)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([random_seed]));
+        if (range !== undefined)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 4, new Float32Array([range]));
+        if (tail_wing_base_limp !== undefined)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 8, new Float32Array(tail_wing_base_limp));
+        if (color !== undefined)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 16, new Float32Array(color));
+        if (drop_rate !== undefined)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 28, new Float32Array([drop_rate]));
+        if (draw_texture_size !== undefined)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 32, new Float32Array(draw_texture_size));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    };
+    WaveParticalUboManager.prototype._createBuffer = function () {
+        var gl = this.gl;
+        var buffer = gl.createBuffer();
+        gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
+        gl.bufferData(gl.UNIFORM_BUFFER, INITIAL_UBO_DATA, gl.STATIC_DRAW);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        return buffer;
+    };
+    WaveParticalUboManager.prototype.bind = function () {
+        var _a = this, gl = _a.gl, ubo = _a.ubo;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, UBO_BINDING_POINT, ubo);
+    };
+    WaveParticalUboManager.prototype.unbind = function () {
+        var gl = this.gl;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, UBO_BINDING_POINT, null);
+    };
+    WaveParticalUboManager.prototype.free = function () {
+        var _a = this, gl = _a.gl, _buffer = _a._buffer;
+        gl.deleteBuffer(_buffer);
+    };
+    return WaveParticalUboManager;
+}());
+exports.WaveParticalUboManager = WaveParticalUboManager;