@pirireis/webglobeplugins 0.9.7 → 0.9.8

package/dist/programs/totems/camerauniformblock.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CameraUniformBlockTotemCache = exports.CameraUniformBlockString = void 0;
+const programcache_1 = require("../programcache");
+// import { getFrustumPlanes } from "../../Math/frustum/from-projection-matrix";
+// import { getFrustum } from "../../Math/frustum/from-globeinfo"
+// import { Plane } from "../../Math/";
+exports.CameraUniformBlockString = `
+layout(std140) uniform CameraUniformBlock {
+    mat4 view; // 64 bytes           0
+    mat4 projection; // 64 bytes     64
+    vec3 translate; // 12 bytes      128
+    bool is3D; // 4 bytes            140
+    vec2 mapWH; // 8 bytes           144
+    vec2 screenWH; //  8 bytes       152
+    float z_level; // 4 bytes        160 | 164
+    float world_distance; // 4 bytes 164
+    float world_tilt; // 4 bytes     168
+    float world_north_angle; // 4 bytes 172
+    vec2 world_center_radian; // 8 bytes    176 | 184
+}; // 14 lines
+`;
+const Radian = Math.PI / 180.0;
+class CameraUniformBlockTotem {
+    constructor() {
+        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;
+        // this._frustumPlanes = {
+        //     left: new Plane(),
+        //     right: new Plane(),
+        //     top: new Plane(),
+        //     bottom: new Plane(),
+        //     near: new Plane(),
+        //     far: new Plane()
+        // }
+        this._isMovedParams = {
+            lastLod: null,
+            isMoved: false,
+        };
+    }
+    init(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();
+    }
+    _createUBO() {
+        const { gl } = this;
+        const ubo = gl.createBuffer();
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        // 184 bytes in reality. Overflow on linux for some reason. So, 200 bytes.
+        gl.bufferData(gl.UNIFORM_BUFFER, 200, gl.STREAM_DRAW);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, 0, ubo);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        return ubo;
+    }
+    resize() {
+        const { gl, globe, ubo } = this;
+        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);
+    }
+    setGeometry() {
+        const { gl, globe, ubo } = this;
+        const is3D = globe.api_GetCurrentGeometry() === 0;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 140, new Float32Array([is3D]));
+    }
+    draw3D(projection, modelView, translate) {
+        const { gl, traslateFloat32, ubo, mapWHFloat32, globe } = this;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        { // view, projection, translat
+            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) {
+                const { width, height } = globe.api_GetCurrentWorldWH();
+                mapWHFloat32.set([width, height]);
+                gl.bufferSubData(gl.UNIFORM_BUFFER, 144, mapWHFloat32);
+            }
+        }
+        {
+            // float world_distance; // 4 bytes 164
+            // float world_tilt; // 4 bytes     168
+            // float world_north_angle; // 4 bytes 172
+            // vec2 world_center_radian; // 8 bytes    180
+            const { CenterLong, CenterLat, Distance, Tilt, NorthAng } = globe.api_GetCurrentLookInfo();
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 164, new Float32Array([
+                Distance, Radian * Tilt, Radian * NorthAng, Radian * CenterLong, Radian * CenterLat
+            ]));
+        }
+        // this._frustumPlanes = getFrustumPlanes(projection, translate);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        { // isMoved
+            const currentLOD = globe.api_GetCurrentLODWithDecimal();
+            this._isMovedParams.isMoved = this._isMovedParams.lastLod !== currentLOD || globe.api_IsScreenMoving();
+            this._isMovedParams.lastLod = currentLOD;
+        }
+        // getFrustum(globe, 50, this._frustumPlanes);
+    }
+    assignBindingPoint(program, bindingPoint) {
+        const { gl } = this;
+        const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        gl.uniformBlockBinding(program, cameraBlockIndex, bindingPoint);
+    }
+    getUBO() {
+        return this.ubo;
+    }
+    getFrustumPlanes() {
+        return this._frustumPlanes;
+    }
+    bind(bindingPoint) {
+        const { gl, ubo } = this;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, ubo);
+    }
+    unbind(bindingPoint) {
+        const { gl } = this;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, null);
+    }
+    isMoved() {
+        return this._isMovedParams.isMoved;
+    }
+    free() {
+        const { gl, ubo } = this;
+        gl.deleteBuffer(ubo);
+    }
+    readBuffer() {
+        const 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]
+        };
+    }
+}
+exports.default = CameraUniformBlockTotem;
+exports.CameraUniformBlockTotemCache = Object.freeze({
+    get: (globe) => { return programcache_1.globeProgramCache.getProgram(globe, CameraUniformBlockTotem); },
+    release: (globe) => { return programcache_1.globeProgramCache.releaseProgram(globe, CameraUniformBlockTotem); }
+});

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CameraUniformBlockTotemCache = exports.WebglobeInfoUniformBlockString = void 0;
+const programcache_1 = require("../programcache");
+exports.WebglobeInfoUniformBlockString = `
+layout(std140) uniform WebglobeInfo {
+    vec2 canvas_resolution;
+    vec2 mouse_radian_long_lat;
+    vec2 mouse_pixel_xy;
+    float north_angle;
+    float world_tilt;
+    float earth_distance;
+}; 
+`;
+class CameraUniformBlockTotem {
+    constructor() {
+        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;
+    }
+    init(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();
+    }
+    _createUBO() {
+        const { gl } = this;
+        const 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;
+    }
+    resize() {
+        const { gl, globe, ubo } = this;
+        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);
+    }
+    setGeometry() {
+        const { gl, globe, ubo } = this;
+        const is3D = globe.api_GetCurrentGeometry() === 0;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 140, new Float32Array([is3D]));
+    }
+    draw3D(projection, modelView, translate) {
+        const { gl, traslateFloat32, ubo, mapWHFloat32, globe } = this;
+        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) {
+                const { width, height } = globe.api_GetCurrentWorldWH();
+                mapWHFloat32.set([width, height]);
+                gl.bufferSubData(gl.UNIFORM_BUFFER, 144, mapWHFloat32);
+            }
+        }
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+    getUBO() {
+        return this.ubo;
+    }
+    bind(bindingPoint) {
+        const { gl, ubo } = this;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, ubo);
+    }
+    unbind(bindingPoint) {
+        const { gl } = this;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, null);
+    }
+    free() {
+        const { gl, ubo } = this;
+        gl.deleteBuffer(ubo);
+    }
+    readBuffer() {
+        const 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]
+        };
+    }
+}
+exports.default = CameraUniformBlockTotem;
+exports.CameraUniformBlockTotemCache = Object.freeze({
+    get: (globe) => { return programcache_1.globeProgramCache.getProgram(globe, CameraUniformBlockTotem); },
+    release: (globe) => { return programcache_1.globeProgramCache.releaseProgram(globe, CameraUniformBlockTotem); }
+});

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CameraUniformBlockTotemCache = exports.CameraUniformBlockString = void 0;
+const programcache_1 = require("../programcache");
+// Loads mouse position to buffer
+// TODO implement it
+exports.CameraUniformBlockString = `
+layout(std140) uniform GpuSelectionUniformBlock {
+    vec2 mouse_pixel_position;
+    vec2 mouse_radian_long_lat;
+}; // 11 lines
+`;
+class CameraUniformBlockTotem {
+    constructor() {
+        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;
+    }
+    init(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();
+    }
+    _createUBO() {
+        const { gl } = this;
+        const 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;
+    }
+    resize() {
+        const { gl, globe, ubo } = this;
+        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);
+    }
+    setGeometry() {
+        const { gl, globe, ubo } = this;
+        const is3D = globe.api_GetCurrentGeometry() === 0;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 140, new Float32Array([is3D]));
+    }
+    draw3D(projection, modelView, translate) {
+        const { gl, traslateFloat32, ubo, mapWHFloat32, globe } = this;
+        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) {
+                const { width, height } = globe.api_GetCurrentWorldWH();
+                mapWHFloat32.set([width, height]);
+                gl.bufferSubData(gl.UNIFORM_BUFFER, 144, mapWHFloat32);
+            }
+        }
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+    getUBO() {
+        return this.ubo;
+    }
+    bind(bindingPoint) {
+        const { gl, ubo } = this;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, ubo);
+    }
+    unbind(bindingPoint) {
+        const { gl } = this;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, null);
+    }
+    free() {
+        const { gl, ubo } = this;
+        gl.deleteBuffer(ubo);
+    }
+    readBuffer() {
+        const 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]
+        };
+    }
+}
+exports.default = CameraUniformBlockTotem;
+exports.CameraUniformBlockTotemCache = Object.freeze({
+    get: (globe) => { return programcache_1.globeProgramCache.getProgram(globe, CameraUniformBlockTotem); },
+    release: (globe) => { return programcache_1.globeProgramCache.releaseProgram(globe, CameraUniformBlockTotem); }
+});

package/dist/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;
+const 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/dist/programs/two-d/pixel-circle.js

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

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

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelPaddingForFlatCompassCache = void 0;
+const util_1 = require("../../util");
+const totems_1 = require("../totems");
+const programcache_1 = require("../programcache");
+const vertexCount = 720;
+const vertexShaderSource = `#version 300 es
+${totems_1.CameraUniformBlockString}
+
+in vec2 screen_coordinate;
+in float pixel_radius_small_ratio;
+in float pixel_radius_big_ratio;
+in vec4 rgba;
+out vec4 v_rgba;
+uniform float plugin_opacity;
+
+vec3 coord_opacity(){
+    float radius;
+    float angle;
+    float gap = (pixel_radius_big_ratio - pixel_radius_small_ratio);
+    if( gl_VertexID % 2 == 0){
+        // if( gl_VertexID % 180 == 0){
+        //      radius = pixel_radius_small_ratio ;
+        // } else
+        if ( gl_VertexID % 60 == 0){
+            radius =  pixel_radius_small_ratio; 
+        } else if( gl_VertexID % 10 == 0) {
+            radius =  pixel_radius_small_ratio + gap * 0.5;
+        } else {
+            radius =  pixel_radius_small_ratio + gap* 0.75;
+        }
+        angle = (float(gl_VertexID) / (${vertexCount}.0));
+    } else {
+        if ( gl_VertexID % 180 == 1){
+            radius = pixel_radius_big_ratio + gap * 0.1;
+
+        } else {
+            radius = pixel_radius_big_ratio;
+         }
+        angle = (float(gl_VertexID - 1) / (${vertexCount}.0));
+    }
+    float opacity =  fract(angle + 0.2475) / 1.5 + 0.33;
+    angle = angle * ${Math.PI * 2.0} + world_north_angle;
+    radius = radius *  min(screenWH.x, screenWH.y) / 2.0;;
+    return vec3( screen_coordinate + vec2( cos(angle), sin(angle)) * radius, opacity);
+}
+
+vec2 adjust_pos(vec2 pos) {
+    return vec2(
+        (pos.x / screenWH.x - 0.5) * 2.0,
+        (0.5 - pos.y / screenWH.y) * 2.0
+    );
+}
+
+void main(){
+    vec3 c = coord_opacity();
+    gl_Position = vec4( adjust_pos(c.xy), 0.0, 1.0);
+    v_rgba = rgba;
+    v_rgba.a *= plugin_opacity;
+    gl_PointSize = 10.0;
+}
+`;
+const fragmentShaderSource = `#version 300 es
+precision highp float;
+in vec4 v_rgba;
+out vec4 color;
+void main(){
+    color = v_rgba;
+}
+`;
+class Logic {
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._lastOpacity = 1;
+        this.program = (0, util_1.createProgram)(this.gl, vertexShaderSource, fragmentShaderSource);
+        const { gl, program } = this;
+        { // 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");
+            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(this._opacityLocation, this._lastOpacity);
+            gl.useProgram(currentProgram);
+        }
+        {
+            this.cameraBlockBindingPoint = 0;
+            const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+            this.cameraBlockTotem = totems_1.CameraUniformBlockTotemCache.get(globe);
+            gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBindingPoint);
+        }
+    }
+    draw(vao, length, opacity) {
+        const { globe, gl, program, cameraBlockTotem, cameraBlockBindingPoint, _opacityLocation } = this;
+        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);
+    }
+    createVAO(screenCoordsBufferObj, pixelRadiusRatioSmallBufferObj, pixelRadiusRatioBigBufferObj, rgbaBufferObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        {
+            const { buffer, stride = 0, offset = 0 } = screenCoordsBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(0);
+            gl.vertexAttribPointer(0, 2, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(0, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = pixelRadiusRatioSmallBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(1);
+            gl.vertexAttribPointer(1, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(1, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = pixelRadiusRatioBigBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(2);
+            gl.vertexAttribPointer(2, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(2, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = rgbaBufferObj;
+            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;
+    }
+    free() {
+        const { globe } = this;
+        totems_1.CameraUniformBlockTotemCache.release(globe);
+    }
+}
+exports.PixelPaddingForFlatCompassCache = Object.freeze({
+    get: (globe) => programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+});

package/dist/programs/util.js

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

package/dist/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;
+const pingpongbuffermanager_1 = __importDefault(require("./pingpongbuffermanager"));
+exports.PingPongBufferManager = pingpongbuffermanager_1.default;
+__exportStar(require("./logics"), exports);