@pirireis/webglobeplugins 0.15.35 → 0.16.0

package/dist/programs/rings/distancering/index.js

@@ -0,0 +1,6 @@
+"use strict";
+// import { programCache as circleProgramCache } from './circleflatprogram';
+// import { PaddingProgramCache } from './paddyflatprogram';
+// import CirclePaddySharedBuffer from './circlepaddysharedbuffer';
+// // import { PaddingFreeAngleCache } from './circlepaddingfreeangleprogram';
+// // export { circleProgramCache, PaddingProgramCache, CirclePaddySharedBuffer, PaddingFreeAngleCache };

package/dist/programs/rings/distancering/paddyflatprogram.js

@@ -0,0 +1,127 @@
+"use strict";
+// TODO: Delete this file if it is not needed anymore.
+// import { createProgram, shaderfunctions } from "../../../util";
+// import CameraUniformBlockTotem, { CameraUniformBlockString } from "../../totems/camerauniformblock";
+// import { globeProgramCache, noRegisterGlobeProgramCache } from "../../programcache";
+// const vertexShader = `#version 300 es ` +
+//     shaderfunctions.PI +
+//     shaderfunctions.R +
+//     shaderfunctions.POLE +
+//     CameraUniformBlockString +
+//     shaderfunctions.mercatorXYToGLPosition +
+//     shaderfunctions.longLatRadToMercator +
+//     shaderfunctions.longLatRadToCartesian3D +
+//     shaderfunctions.circleLimpFromLongLatRadCenterCartesian3D +
+//     shaderfunctions.circleLimpFromLongLatRadCenterMercatorCompass +
+//     shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistancePadding +
+//     shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistance + `
+// in vec2 center;
+// in float radius;
+// in float pad_range;
+// in vec4 color;
+// in float flag;
+// uniform int compass;
+// uniform float pad_count;
+// uniform float opacity;
+// out vec2 v_limp;
+// out vec4 v_color;
+// void main() {
+//     float alpha_padding =  z_level * z_level / (pad_range/ 100.0 );
+//     if( flag == 2.0 || flag == 1.0 || radius == 0.0 || alpha_padding < 0.1 || z_level < 3.0 ) return; // 1.0 is hide
+//     v_color = vec4(color.rgb, color.a * alpha_padding * opacity);
+//     gl_PointSize = 2.0;
+//     float odd = mod(float(gl_VertexID), 2.0);
+//     float index = (float(gl_VertexID)- odd ) / 2.0;
+//     float angle = 3.1415926535897932384626433832795 * 2.0 * (index / pad_count );
+//     float radius_ = radius - (pad_range * odd);
+//     if ( is3D){
+//         gl_Position = projection * view * vec4(
+//             circleLimpFromLongLatRadCenterCartesian3D( center, radius_, angle) - translate, 1.0);
+//         v_limp = vec2(0.0, 0.0);
+//         return;
+//     }
+//     vec2 limp;
+//     if ( compass == 1 ){
+//         limp = circleLimpFromLongLatRadCenterMercatorCompass(center , radius_, angle);
+//     } else {
+//         // limp = circleLimpFromLongLatRadCenterMercatorRealDistancePadding(center, radius_, angle);
+//         limp = circleLimpFromLongLatRadCenterMercatorRealDistance(center, radius_, angle);
+//     }
+//     v_limp = limp;
+//     gl_Position = mercatorXYToGLPosition(limp);
+// }`;
+// const fragmentShader = `#version 300 es
+// precision highp float; `+
+//     shaderfunctions.POLE + `
+// in vec4 v_color;
+// in vec2 v_limp;
+// out vec4 outColor;
+// void main() {
+//     if ( v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE ){ discard; }
+//     outColor = v_color;
+// }`;
+// class Logic {
+//     constructor(globe) {
+//         this.globe = globe;
+//         this.gl = globe.gl;
+//         this.program = createProgram(this.gl, vertexShader, fragmentShader);
+//         { // bind positions so bufferManager can use them
+//             this.gl.bindAttribLocation(this.program, 0, "center");
+//             this.gl.bindAttribLocation(this.program, 1, "radius");
+//             this.gl.bindAttribLocation(this.program, 2, "pad_range");
+//             this.gl.bindAttribLocation(this.program, 3, "color");
+//             this.gl.bindAttribLocation(this.program, 4, "flag");
+//         }
+//         this.cameraBlockBindingPoint = 0;
+//         const cameraBlockIndex = this.gl.getUniformBlockIndex(this.program, "CameraUniformBlock");
+//         this.gl.uniformBlockBinding(this.program, cameraBlockIndex, this.cameraBlockBindingPoint);
+//         this.cameraBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
+//         this._padCountLocation = this.gl.getUniformLocation(this.program, "pad_count");
+//         this._opacityLocation = this.gl.getUniformLocation(this.program, "opacity");
+//         this._compassLocation = this.gl.getUniformLocation(this.program, "compass");
+//         this._compassMode = 1;
+//         this._opacity = 1.0;
+//         this._padCount = 360;
+//         {
+//             const currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
+//             this.gl.useProgram(this.program);
+//             this.gl.uniform1i(this._compassLocation, 1);
+//             this.gl.uniform1f(this._opacityLocation, 1.0);
+//             this.gl.uniform1f(this._padCountLocation, 360)
+//             this.gl.useProgram(currentProgram);
+//         }
+//     }
+//     draw(attrBufferManager, padCount, compass, opacity) {
+//         const { gl, program, _padCountLocation, cameraBlockBindingPoint, cameraBlockTotem, _compassLocation } = this;
+//         gl.useProgram(program);
+//         attrBufferManager.bindPaddingVAO();
+//         cameraBlockTotem.bind(cameraBlockBindingPoint);
+//         // draw instanced
+//         if (padCount !== this._padCount) {
+//             this._padCount = padCount;
+//             // console.log("padCount", padCount);
+//             gl.uniform1f(_padCountLocation, padCount);
+//         }
+//         if (compass !== this._compassMode) {
+//             // console.log("compass", compass);
+//             gl.uniform1i(_compassLocation, compass);
+//             this._compassMode = compass;
+//         }
+//         if (opacity !== this._opacity) {
+//             // console.log("opacity", opacity);
+//             this._opacity = opacity;
+//             gl.uniform1f(this._opacityLocation, opacity);
+//         }
+//         gl.drawArraysInstanced(gl.LINES, 0, padCount * 2, attrBufferManager.length);
+//         gl.bindVertexArray(null);
+//         cameraBlockTotem.unbind(cameraBlockBindingPoint);
+//     }
+//     free() {
+//         this.gl.deleteProgram(this.program);
+//         globeProgramCache.releaseProgram(this.globe, CameraUniformBlockTotem);
+//     }
+// }
+// export const PaddingProgramCache = Object.freeze({
+//     getProgram: (globe) => { return noRegisterGlobeProgramCache.getProgram(globe, Logic) },
+//     releaseProgram: (globe) => { noRegisterGlobeProgramCache.releaseProgram(globe, Logic) }
+// })

package/dist/programs/rings/distancering/paddyflatprogram2d.js

@@ -0,0 +1,129 @@
+"use strict";
+// TODO: Delete this file if it is not needed anymore.
+// import { createProgram, shaderfunctions } from "../../../util";
+// import CameraUniformBlockTotem, { CameraUniformBlockString } from "../../totems/camerauniformblock";
+// import { globeProgramCache, noRegisterGlobeProgramCache } from "../../programcache";
+// const vertexShader = `#version 300 es ` +
+//     shaderfunctions.PI +
+//     shaderfunctions.R +
+//     shaderfunctions.POLE +
+//     CameraUniformBlockString +
+//     shaderfunctions.mercatorXYToGLPosition +
+//     shaderfunctions.longLatRadToMercator +
+//     shaderfunctions.longLatRadToCartesian3D +
+//     shaderfunctions.circleLimpFromLongLatRadCenterCartesian3D +
+//     shaderfunctions.circleLimpFromLongLatRadCenterMercatorCompass +
+//     shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistancePadding +
+//     shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistance + `
+// in vec2 center;
+// in float radius;
+// in float pad_range;
+// in vec4 color;
+// in float flag;
+// uniform int compass;
+// uniform float pad_count;
+// uniform float opacity;
+// out vec2 v_limp;
+// out vec4 v_color;
+// void main() {
+//     float alpha_padding =  z_level * z_level / (pad_range/ 100.0 );
+//     if( flag == 2.0 || flag == 1.0 || radius == 0.0 || alpha_padding < 0.1 || z_level < 3.0 ) return; // 1.0 is hide
+//     v_color = vec4(color.rgb, color.a * alpha_padding * opacity);
+//     gl_PointSize = 2.0;
+//     float odd = mod(float(gl_VertexID), 2.0);
+//     float index = (float(gl_VertexID)- odd ) / 2.0;
+//     float angle = 3.1415926535897932384626433832795 * 2.0 * (index / pad_count );
+//     float radius_ = radius - (pad_range * odd);
+//     if ( is3D){
+//         gl_Position = projection * view * vec4(
+//             circleLimpFromLongLatRadCenterCartesian3D( center, radius_, angle) - translate, 1.0);
+//         v_limp = vec2(0.0, 0.0);
+//         return;
+//     }
+//     vec2 limp;
+//     if ( compass == 1 ){
+//         limp = circleLimpFromLongLatRadCenterMercatorCompass(center , radius_, angle);
+//     } else {
+//         // limp = circleLimpFromLongLatRadCenterMercatorRealDistancePadding(center, radius_, angle);
+//         limp = circleLimpFromLongLatRadCenterMercatorRealDistance(center, radius_, angle);
+//     }
+//     v_limp = limp;
+//     gl_Position = mercatorXYToGLPosition(limp);
+// }`;
+// const fragmentShader = `#version 300 es
+// precision highp float; `+
+//     shaderfunctions.POLE + `
+// in vec4 v_color;
+// in vec2 v_limp;
+// out vec4 outColor;
+// void main() {
+//     if ( v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE ){ discard; }
+//     outColor = v_color;
+// }`;
+// class Logic {
+//     constructor(globe) {
+//         this.globe = globe;
+//         this.gl = globe.gl;
+//         this.program = createProgram(this.gl, vertexShader, fragmentShader);
+//         { // bind positions so bufferManager can use them
+//             this.gl.bindAttribLocation(this.program, 0, "center");
+//             this.gl.bindAttribLocation(this.program, 1, "radius");
+//             this.gl.bindAttribLocation(this.program, 2, "pad_range");
+//             this.gl.bindAttribLocation(this.program, 3, "color");
+//             this.gl.bindAttribLocation(this.program, 4, "flag");
+//         }
+//         this.cameraBlockBindingPoint = 0;
+//         const cameraBlockIndex = this.gl.getUniformBlockIndex(this.program, "CameraUniformBlock");
+//         this.gl.uniformBlockBinding(this.program, cameraBlockIndex, this.cameraBlockBindingPoint);
+//         this.cameraBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
+//         this._padCountLocation = this.gl.getUniformLocation(this.program, "pad_count");
+//         this._opacityLocation = this.gl.getUniformLocation(this.program, "opacity");
+//         this._compassLocation = this.gl.getUniformLocation(this.program, "compass");
+//         this._compassMode = 1;
+//         this._opacity = 1.0;
+//         this._padCount = 360;
+//         {
+//             const currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
+//             this.gl.useProgram(this.program);
+//             this.gl.uniform1i(this._compassLocation, 1);
+//             this.gl.uniform1f(this._opacityLocation, 1.0);
+//             this.gl.uniform1f(this._padCountLocation, 360)
+//             this.gl.useProgram(currentProgram);
+//         }
+//     }
+//     draw(vao, length, opaity) {
+//     }
+//     draw(attrBufferManager, padCount, compass, opacity) {
+//         const { gl, program, _padCountLocation, cameraBlockBindingPoint, cameraBlockTotem, _compassLocation } = this;
+//         gl.useProgram(program);
+//         attrBufferManager.bindPaddingVAO();
+//         cameraBlockTotem.bind(cameraBlockBindingPoint);
+//         // draw instanced
+//         if (padCount !== this._padCount) {
+//             this._padCount = padCount;
+//             // console.log("padCount", padCount);
+//             gl.uniform1f(_padCountLocation, padCount);
+//         }
+//         if (compass !== this._compassMode) {
+//             // console.log("compass", compass);
+//             gl.uniform1i(_compassLocation, compass);
+//             this._compassMode = compass;
+//         }
+//         if (opacity !== this._opacity) {
+//             // console.log("opacity", opacity);
+//             this._opacity = opacity;
+//             gl.uniform1f(this._opacityLocation, opacity);
+//         }
+//         gl.drawArraysInstanced(gl.LINES, 0, padCount * 2, attrBufferManager.length);
+//         gl.bindVertexArray(null);
+//         cameraBlockTotem.unbind(cameraBlockBindingPoint);
+//     }
+//     free() {
+//         this.gl.deleteProgram(this.program);
+//         globeProgramCache.releaseProgram(this.globe, CameraUniformBlockTotem);
+//     }
+// }
+// export const PaddingProgramCache = Object.freeze({
+//     getProgram: (globe) => { return noRegisterGlobeProgramCache.getProgram(globe, Logic) },
+//     releaseProgram: (globe) => { noRegisterGlobeProgramCache.releaseProgram(globe, Logic) }
+// })

package/dist/programs/rings/distancering/paddyflatprogram3d.js

@@ -0,0 +1,128 @@
+"use strict";
+// TODO: Delete this file if it is not needed anymore.
+// import { createProgram, shaderfunctions } from "../../../util";
+// import CameraUniformBlockTotem, { CameraUniformBlockString } from "../../totems/camerauniformblock";
+// import { globeProgramCache, noRegisterGlobeProgramCache } from "../../programcache";
+// const vertexShader = `#version 300 es ` +
+//     shaderfunctions.PI +
+//     shaderfunctions.R +
+//     shaderfunctions.POLE +
+//     CameraUniformBlockString +
+//     shaderfunctions.mercatorXYToGLPosition +
+//     shaderfunctions.longLatRadToMercator +
+//     shaderfunctions.longLatRadToCartesian3D +
+//     shaderfunctions.circleLimpFromLongLatRadCenterCartesian3D +
+//     shaderfunctions.circleLimpFromLongLatRadCenterMercatorCompass +
+//     shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistancePadding +
+//     shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistance + `
+// in vec2 center;
+// in float radius;
+// in float pad_range;
+// in vec4 color;
+// in float flag;
+// uniform int compass;
+// uniform float pad_count;
+// uniform float opacity;
+// out vec2 v_limp;
+// out vec4 v_color;
+// void main() {
+//     float alpha_padding =  z_level * z_level / (pad_range/ 100.0 );
+//     if( flag == 2.0 || flag == 1.0 || radius == 0.0 || alpha_padding < 0.1 || z_level < 3.0 ) return; // 1.0 is hide
+//     v_color = vec4(color.rgb, color.a * alpha_padding * opacity);
+//     gl_PointSize = 2.0;
+//     float odd = mod(float(gl_VertexID), 2.0);
+//     float index = (float(gl_VertexID)- odd ) / 2.0;
+//     float angle = 3.1415926535897932384626433832795 * 2.0 * (index / pad_count );
+//     float radius_ = radius - (pad_range * odd);
+//     if ( is3D){
+//         gl_Position = projection * view * vec4(
+//             circleLimpFromLongLatRadCenterCartesian3D( center, radius_, angle) - translate, 1.0);
+//         v_limp = vec2(0.0, 0.0);
+//         return;
+//     }
+//     vec2 limp;
+//     if ( compass == 1 ){
+//         limp = circleLimpFromLongLatRadCenterMercatorCompass(center , radius_, angle);
+//     } else {
+//         // limp = circleLimpFromLongLatRadCenterMercatorRealDistancePadding(center, radius_, angle);
+//         limp = circleLimpFromLongLatRadCenterMercatorRealDistance(center, radius_, angle);
+//     }
+//     v_limp = limp;
+//     gl_Position = mercatorXYToGLPosition(limp);
+// }`;
+// const fragmentShader = `#version 300 es
+// precision highp float; `+
+//     shaderfunctions.POLE + `
+// in vec4 v_color;
+// in vec2 v_limp;
+// out vec4 outColor;
+// void main() {
+//     if ( v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE ){ discard; }
+//     outColor = v_color;
+// }`;
+// class Logic {
+//     constructor(globe) {
+//         this.globe = globe;
+//         this.gl = globe.gl;
+//         this.program = createProgram(this.gl, vertexShader, fragmentShader);
+//         { // bind positions so bufferManager can use them
+//             this.gl.bindAttribLocation(this.program, 0, "center");
+//             this.gl.bindAttribLocation(this.program, 1, "radius");
+//             this.gl.bindAttribLocation(this.program, 2, "pad_range");
+//             this.gl.bindAttribLocation(this.program, 3, "color");
+//             this.gl.bindAttribLocation(this.program, 4, "flag");
+//         }
+//         this.cameraBlockBindingPoint = 0;
+//         const cameraBlockIndex = this.gl.getUniformBlockIndex(this.program, "CameraUniformBlock");
+//         this.gl.uniformBlockBinding(this.program, cameraBlockIndex, this.cameraBlockBindingPoint);
+//         this.cameraBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
+//         this._padCountLocation = this.gl.getUniformLocation(this.program, "pad_count");
+//         this._opacityLocation = this.gl.getUniformLocation(this.program, "opacity");
+//         this._compassLocation = this.gl.getUniformLocation(this.program, "compass");
+//         this._compassMode = 1;
+//         this._opacity = 1.0;
+//         this._padCount = 360;
+//         {
+//             const currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
+//             this.gl.useProgram(this.program);
+//             this.gl.uniform1i(this._compassLocation, 1);
+//             this.gl.uniform1f(this._opacityLocation, 1.0);
+//             this.gl.uniform1f(this._padCountLocation, 360)
+//             this.gl.useProgram(currentProgram);
+//         }
+//     }
+//     draw(attrBufferManager, padCount, compass, opacity) {
+//         const { gl, program, _padCountLocation, cameraBlockBindingPoint, cameraBlockTotem, _compassLocation } = this;
+//         gl.useProgram(program);
+//         attrBufferManager.bindPaddingVAO();
+//         cameraBlockTotem.bind(cameraBlockBindingPoint);
+//         // draw instanced
+//         if (padCount !== this._padCount) {
+//             this._padCount = padCount;
+//             // console.log("padCount", padCount);
+//             gl.uniform1f(_padCountLocation, padCount);
+//         }
+//         if (compass !== this._compassMode) {
+//             // console.log("compass", compass);
+//             gl.uniform1i(_compassLocation, compass);
+//             this._compassMode = compass;
+//         }
+//         if (opacity !== this._opacity) {
+//             // console.log("opacity", opacity);
+//             this._opacity = opacity;
+//             gl.uniform1f(this._opacityLocation, opacity);
+//         }
+//         gl.drawArraysInstanced(gl.LINES, 0, padCount * 2, attrBufferManager.length);
+//         gl.bindVertexArray(null);
+//         cameraBlockTotem.unbind(cameraBlockBindingPoint);
+//     }
+//     free() {
+//         this.gl.deleteProgram(this.program);
+//         globeProgramCache.releaseProgram(this.globe, CameraUniformBlockTotem);
+//     }
+// }
+// //
+// export const PaddingProgramCache = Object.freeze({
+//     getProgram: (globe) => { return noRegisterGlobeProgramCache.getProgram(globe, Logic) },
+//     releaseProgram: (globe) => { noRegisterGlobeProgramCache.releaseProgram(globe, Logic) }
+// })

package/dist/programs/rings/index.js

@@ -0,0 +1 @@
+export * from "./distancering";

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

@@ -0,0 +1,104 @@
+import { globeProgramCache } from "../programcache";
+// Loads mouse position to buffer
+// TODO implement it
+export const CameraUniformBlockString = `
+layout(std140) uniform GpuSelectionUniformBlock {
+    vec2 mouse_pixel_position;
+    vec2 mouse_radian_long_lat;
+}; // 11 lines
+`;
+export default 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]
+        };
+    }
+}
+export const CameraUniformBlockTotemCache = Object.freeze({
+    get: (globe) => { return globeProgramCache.getProgram(globe, CameraUniformBlockTotem); },
+    release: (globe) => { return globeProgramCache.releaseProgram(globe, CameraUniformBlockTotem); }
+});

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,159 @@
+import { createProgram } from "../../util";
+import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
+import { noRegisterGlobeProgramCache } from "../programcache";
+const vertexCount = 720;
+const vertexShaderSource = `#version 300 es
+${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 = 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 = 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;
+        CameraUniformBlockTotemCache.release(globe);
+    }
+}
+export const PixelPaddingForFlatCompassCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+});