@pirireis/webglobeplugins 0.6.22 → 0.6.24-a

package/bearing-line/plugin.js

@@ -66,7 +66,7 @@ export default class Plugin {
 
         this.drawText = drawText;
 
-        this.circleFlatEdgeCount = circleFlatEdgeCount + 2;//circleFlatEdgeCount;
+        this.circleFlatEdgeCount = circleFlatEdgeCount + 2; //circleFlatEdgeCount;
     }
 
     setDoDrawVRM(bool) {
@@ -230,8 +230,8 @@ export default class Plugin {
 
                     // normal circle
                     ["circleDashAngle", {
-                        'bufferManager': new BufferManager(gl, circleFlatEdgeCount, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array(item.rgba),
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.circleDashAngle / 360]),
                     }],
                     // CIRCLE Mercator
                     ["rgbaMercator", {
@@ -476,9 +476,7 @@ export default class Plugin {
         const result = []
         for (const item of propertyIDs) {
             result.push(item);
-            console.log(item + " is processing")
             if (s.has(item)) {
-                console.log(item + "Mercator is added")
                 result.push(item + "Mercator");
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.6.22",
+    "version": "0.6.24-a",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT"

package/programs/line-on-globe/circle-accurate-3d.js

@@ -45,14 +45,12 @@ out float interpolation;
 out vec4 v_color;
 out float v_dash_ratio;
 out float v_dash_opacity;
-out vec2 v_limp;
 void main() {
     interpolation = float( gl_VertexID ) / ${EDGE_COUNT_ON_SPHERE}.0;
     if ( is3D ) {
         float angle = PI * 2.0 * interpolation;
         vec3 position = circleLimpFromLongLatRadCenterCartesian3D_accurate(center_position3d, radius, angle);
         gl_Position = cartesian3DToGLPosition(position);
-        v_limp = vec2(0.0, 0.0);
     } else {
         return;
     }
@@ -73,7 +71,6 @@ in float interpolation;
 in vec2 v_limp;
 out vec4 color;
 void main() {
-    if ( v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE ){ color = vec4(0.0,0.0,0.0,0.0); return; }
     color = v_color;
     color.a *= opacity;
     if ( v_dash_ratio == 1.0 || v_dash_ratio == 0.0 ) return;
@@ -110,8 +107,8 @@ class Logic {
             gl.bindAttribLocation(program, 0, "center_position3d");
             gl.bindAttribLocation(program, 1, "radius");
             gl.bindAttribLocation(program, 2, "color");
-            gl.bindAttribLocation(program, 2, "dash_ratio");
-            gl.bindAttribLocation(program, 3, "dash_opacity");
+            gl.bindAttribLocation(program, 3, "dash_ratio");
+            gl.bindAttribLocation(program, 4, "dash_opacity");
         }
 
         this.cameraBindingPoint = 0;

package/programs/line-on-globe/circle-accurate-flat.js

@@ -69,8 +69,7 @@ void main() {
     if (fract(interpolation / (2.0 * v_dash_ratio)) < 0.5 ) {
         color.a *= v_dash_opacity;
     }   
-}
-`;
+}`;
 
 
 
@@ -180,9 +179,9 @@ const CircleCache = Object.freeze({
 });
 
 
-function centerCoords2dflatDataCreator(globe, centerLong, centerLat, targetLong, targetLat, { startAngleOfCircle = null, edgeCount = EDGE_COUNT } = {}) {
+function centerCoords2dflatDataCreator(globe, centerLong, centerLat, targetLong, targetLat, { startAngleOfCircle = null, edgeCount = EDGE_COUNT, radiusOffset = 0 } = {}) {
     const centerCoords2dflat = new Float32Array(edgeCount * 2);
-    const radius2d = globe.Math.GetDist2D(centerLong, centerLat, targetLong, targetLat);
+    const radius2d = globe.Math.GetDist2D(centerLong, centerLat, targetLong, targetLat) + radiusOffset;
     let angle;
     if (startAngleOfCircle === null) {
         angle = globe.Math.GetAzimuthAngle(centerLong, centerLat, targetLong, targetLat);
@@ -205,6 +204,26 @@ function centerCoords2dflatDataCreator(globe, centerLong, centerLat, targetLong,
     return centerCoords2dflat;
 }
 
+
+function centerCoords2dflatDataCreatorWithRadius(globe, centerLong, centerLat, radius2d, { startAngleOfCircle = null, edgeCount = EDGE_COUNT } = {}) {
+    const centerCoords2dflat = new Float32Array(edgeCount * 2);
+    const pointsLongLat = globe.Math.GetEllipseGeo(
+        centerLong,
+        centerLat,
+        radius2d,
+        radius2d,
+        0,
+        360 / (edgeCount - 2), // 1 for return to start point, 1 for cutting circles
+    );
+
+    for (let i = 1; i < edgeCount; i++) {
+        const { long: lg, lat: lt } = pointsLongLat[i - 1];
+        centerCoords2dflat.set(globe.api_GetMercator2DPoint(lg, lt), i * 2);
+    }
+    return centerCoords2dflat;
+}
+
+
 export {
-    CircleCache, EDGE_COUNT, centerCoords2dflatDataCreator
+    CircleCache, EDGE_COUNT, centerCoords2dflatDataCreator, centerCoords2dflatDataCreatorWithRadius
 }

package/programs/line-on-globe/degree-padding-around-circle-3d.js

@@ -0,0 +1,189 @@
+import { createProgram } from "../../util/webglobjectbuilders";
+import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../totems/camerauniformblock";
+import { noRegisterGlobeProgramCache } from "../programcache";
+import { vaoAttributeLoader } from "../../util/account/util";
+import {
+    longLatRadToMercator, longLatRadToCartesian3D, cartesian3DToGLPosition, mercatorXYToGLPosition, realDistanceOnSphereR1,
+    circleLimpFromLongLatRadCenterCartesian3D_accurate,
+    circleLimpFromLongLatRadCenterMercatorCompass_accurate,
+    circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
+    POLE
+} from "../../util/shaderfunctions/geometrytransformations";
+
+
+/**
+ * TODO: 
+ * 1. integrate geometry functions for radius angle and center
+ * 2. integrate attributes
+ * 
+ * TODO:
+ * center_position is too small or doenst loaded as expected.
+ */
+
+const INITIAL_EDGE_COUNT = 360;
+
+const vertexShaderSource = `#version 300 es
+precision highp float;
+${CameraUniformBlockString}
+${longLatRadToMercator}
+${longLatRadToCartesian3D}
+${cartesian3DToGLPosition}
+${mercatorXYToGLPosition}
+${realDistanceOnSphereR1}
+${circleLimpFromLongLatRadCenterCartesian3D_accurate}
+${circleLimpFromLongLatRadCenterMercatorCompass_accurate}
+${circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate}
+
+
+in vec3 center_position3d;
+in float big_radius;
+in float small_radius;
+in vec4 color;
+
+uniform float edge_count;
+uniform float step_angle;
+
+out float interpolation;
+out vec4 v_color;
+void main() {
+    if( !is3D) {
+        return;
+    }
+    int pad_phase =  gl_VertexID % 2; // 0 or 1
+    interpolation = float( gl_VertexID - pad_phase) / edge_count;
+    float angle = float( gl_VertexID - pad_phase) * step_angle;
+    vec3 position;
+    if ( pad_phase == 0 ) {
+        position = circleLimpFromLongLatRadCenterCartesian3D_accurate(center_position3d, big_radius, angle);
+    } else {
+        position = circleLimpFromLongLatRadCenterCartesian3D_accurate(center_position3d, small_radius, angle);
+    }
+    gl_Position = cartesian3DToGLPosition(position);
+    v_color = color;
+    gl_PointSize = 5.0;
+}`
+
+const fragmentShaderSource = `#version 300 es
+${POLE}
+precision highp float;
+uniform float opacity;
+in vec4 v_color;
+in float interpolation;
+in vec2 v_limp;
+out vec4 color;
+void main() {
+    color = v_color;
+    color.a *= opacity;
+}
+`;
+
+
+
+class Logic {
+
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._lastOpacity = 1.0;
+        this._lastEdgeCount = INITIAL_EDGE_COUNT;
+        this._lastStepAngle = 360 / INITIAL_EDGE_COUNT;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+
+        const { gl, program } = this;
+        this.program.uniforms = {
+            opacity: gl.getUniformLocation(program, "opacity"),
+            edgeCount: gl.getUniformLocation(program, "edge_count"),
+            stepAngle: gl.getUniformLocation(program, "step_angle")
+        };
+
+        { // initial uniform values
+            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(program.uniforms.opacity, 1.0);
+            gl.uniform1f(program.uniforms.edgeCount, INITIAL_EDGE_COUNT * 2);
+            gl.uniform1f(program.uniforms.stepAngle, this._lastStepAngle * Math.PI / 180);
+            gl.useProgram(currentProgram);
+        }
+
+        {   // assign attribute locations
+            gl.bindAttribLocation(program, 0, "center_position3d");
+            gl.bindAttribLocation(program, 1, "big_radius");
+            gl.bindAttribLocation(program, 2, "small_radius");
+            gl.bindAttribLocation(program, 3, "color");
+
+        }
+
+        this.cameraBindingPoint = 0;
+        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+        const cameraBlockLocation = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        gl.uniformBlockBinding(program, cameraBlockLocation, this.cameraBindingPoint);
+    }
+
+    createVAO(center3dObj, bigRadiusObj, smallRadiusObj, colorObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        const divisor = 1;
+        gl.bindVertexArray(vao);
+        {  // make this a function end import from account module. 
+            const { buffer, stride = 0, offset = 0 } = center3dObj;
+            vaoAttributeLoader(gl, buffer, 0, 3, stride, offset, divisor);
+        }
+        {
+            console.log("bigRadiusObj", bigRadiusObj);
+            const { buffer, stride = 0, offset = 0 } = bigRadiusObj;
+            vaoAttributeLoader(gl, buffer, 1, 1, stride, offset, divisor);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = smallRadiusObj;
+            vaoAttributeLoader(gl, buffer, 2, 1, stride, offset, divisor);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = colorObj;
+            vaoAttributeLoader(gl, buffer, 3, 4, stride, offset, divisor);
+        }
+
+        gl.bindVertexArray(null);
+        gl.bindVertexArray(null);
+        return vao;
+    }
+
+    draw(vao, length, edgeCount, stepAngle, opacity) {
+        const { gl, program, cameraBlockTotem, cameraBindingPoint } = this;
+        gl.useProgram(program);
+
+        if (this._lastOpacity !== opacity) {
+            gl.uniform1f(program.uniforms.opacity, opacity);
+            this._lastOpacity = opacity;
+        }
+        if (this._lastEdgeCount !== edgeCount) {
+            gl.uniform1f(program.uniforms.edgeCount, 2 * edgeCount);
+            this._lastEdgeCount = edgeCount;
+        }
+        if (this._lastStepAngle !== stepAngle) {
+            gl.uniform1f(program.uniforms.stepAngle, stepAngle * Math.PI / 180);
+            this._lastStepAngle = stepAngle;
+        }
+        gl.bindVertexArray(vao);
+        cameraBlockTotem.bind(cameraBindingPoint);
+        gl.drawArraysInstanced(gl.LINES, 0, edgeCount * 2, length);
+        // gl.drawArraysInstanced(gl.POINTS, 0, edgeCount, length);
+        cameraBlockTotem.unbind(cameraBindingPoint);
+        gl.bindVertexArray(null);
+    }
+
+
+
+    free() {
+        if (this.isFreed) return;
+        CameraUniformBlockTotemCache.release(this.globe);
+        this.gl.deleteProgram(this.program);
+        this.isFreed = true;
+    }
+}
+
+
+
+export const CirclePadding3DCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+});

package/programs/line-on-globe/lines-color-instanced-flat.js

@@ -0,0 +1,145 @@
+import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
+import { mercatorXYToGLPosition } from "../../util/shaderfunctions/geometrytransformations";
+import { noRegisterGlobeProgramCache } from "../programcache";
+import { createProgram } from "../../util";
+import { vaoAttributeLoader } from "../../util/account/util";
+
+/**
+ * This program draws line between points provided from the first and second buffer.
+ * draw method gl.drawArraysInstanced( gl.POINTS, 0,2, lineCount);
+ * */
+
+const Z_ALPHA_MODE = Object.freeze({
+    ON: 1,
+    OFF: 0
+});
+
+const vertexShaderSource = `#version 300 es
+precision highp float;
+${CameraUniformBlockString}
+${mercatorXYToGLPosition}
+uniform float opacity;
+uniform int z_alpha_on;
+
+in vec2 posA;
+in vec2 posB;
+in vec4 color;
+
+out vec4 v_color;
+
+void main() {
+    if ( is3D ) {
+        return;
+    }
+    float z_alpha;
+    if ( z_alpha_on == 1){
+        z_alpha =  z_level * z_level / (distance(posA, posB) / 100.0 );
+        if( z_alpha < 0.1 ) {return;}
+        if( z_alpha > 1.0 ) {z_alpha = 1.0;}
+    } else {
+        z_alpha = 1.0;
+    }
+        vec2 pos;
+        if ( gl_VertexID == 0 ) {
+            pos = posA;
+            } else {
+                pos = posB;
+        }
+    gl_Position = mercatorXYToGLPosition( pos );
+    v_color = color;
+    v_color.a *= z_alpha * opacity;
+    gl_PointSize = 4.0;
+}`;
+
+
+const fragmentShaderSource = `#version 300 es
+precision highp float;
+in vec4 v_color;
+out vec4 outColor;
+void main() {
+    outColor = v_color;
+}`;
+
+
+class Logic {
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+        this._lastOpicity = 1.0;
+        this._lastZAlphaOn = Z_ALPHA_MODE.OFF;
+
+        const { gl, program } = this;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(program);
+        { // assign attribute locations
+            gl.bindAttribLocation(program, 0, 'posA');
+            gl.bindAttribLocation(program, 1, 'posB');
+            gl.bindAttribLocation(program, 2, 'color');
+        }
+
+        {   // uniform locations
+            this._opacityLocation = gl.getUniformLocation(program, 'opacity');
+            this._zAlphaOnLocation = gl.getUniformLocation(program, 'z_alpha_on');
+            gl.uniform1i(this._zAlphaOnLocation, this._lastZAlphaOn);
+            gl.uniform1f(this._opacityLocation, this._lastOpicity);
+        }
+        {   // uniform block
+            this._cameraUniformBlock = CameraUniformBlockTotemCache.get(globe);
+            this._cameraBindingPoint = 0;
+            const cameraBlockBindingIndex = gl.getUniformBlockIndex(program, 'CameraUniformBlock');
+            gl.uniformBlockBinding(program, cameraBlockBindingIndex, this._cameraBindingPoint);
+        }
+        gl.useProgram(currentProgram);
+    }
+    createVAO(posAObj, posBObj, colorObj) {
+
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        const type = gl.Float;
+        const divisor = 1;
+        gl.bindVertexArray(vao);
+        [posAObj, posBObj, colorObj].forEach((obj, index) => {
+            const { buffer, size, stride, offset } = obj;
+            vaoAttributeLoader(gl, buffer, index, size, stride, offset, divisor, type);
+        });
+        gl.bindVertexArray(null);
+        return vao;
+    }
+
+
+    draw(vao, lineCount, opacity = 1.0, zAlphaOn = Z_ALPHA_MODE.OFF) {
+        const { gl, program, _cameraBindingPoint, _cameraUniformBlock } = this;
+        gl.useProgram(program);
+        _cameraUniformBlock.bind(_cameraBindingPoint);
+        gl.bindVertexArray(vao);
+        if (this._lastOpicity !== opacity) {
+            this._lastOpicity = opacity;
+            gl.uniform1f(this._opacityLocation, opacity);
+        }
+        if (this._lastZAlphaOn !== zAlphaOn) {
+            this._lastZAlphaOn = zAlphaOn;
+            gl.uniform1i(this._zAlphaOnLocation, zAlphaOn);
+        }
+        gl.drawArraysInstanced(gl.LINES, 0, 2, lineCount);
+        _cameraUniformBlock.unbind(_cameraBindingPoint);
+        gl.bindVertexArray(null);
+    }
+
+
+    free() {
+        if (this.isFreed) return;
+        const { gl, program, globe } = this;
+        CameraUniformBlockTotemCache.release(globe);
+        gl.deleteProgram(program);
+        this.isFreed = true;
+    }
+}
+
+
+const LinesColorInstancedFlatCache = Object.freeze({
+    get: (globe) => { return noRegisterGlobeProgramCache.getProgram(globe, Logic) },
+    release: (globe) => { noRegisterGlobeProgramCache.releaseProgram(globe, Logic) }
+});
+
+export { LinesColorInstancedFlatCache, Z_ALPHA_MODE };

package/programs/line-on-globe/naive-accurate.js

@@ -2,11 +2,9 @@ import { CameraUniformBlockString, CameraUniformBlockTotem } from "../totems";
 import { pointsOnSphereBetween, POLE, R_3D, mercatorXYToGLPosition, cartesian3DToGLPosition } from "../../util/shaderfunctions/geometrytransformations";
 import { createProgram } from "../../util";
 import { noRegisterGlobeProgramCache, globeProgramCache } from "../programcache";
-import BufferOffsetManger from "../../util/account/bufferoffsetmanager";
 import { programCache } from "../rings/distancering/circleflatprogram";
 
 const GLOBE_MIDPOINT_COUNT = 30;
-const ITEM_SIZE = 9;
 
 const vertexShader = `#version 300 es
 precision highp float;

package/programs/rings/distancering/paddyflatprogram2d.js

@@ -1,8 +1,4 @@
 import { createProgram, shaderfunctions } from "../../../util";
-import {
-    circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
-    circleLimpFromLongLatRadCenterCartesian3D_accurate_accurate
-} from "../../../util/shaderfunctions/geometrytransformations";
 import CameraUniformBlockTotem, { CameraUniformBlockString } from "../../totems/camerauniformblock";
 import { globeProgramCache, noRegisterGlobeProgramCache } from "../../programcache";
 
@@ -14,12 +10,11 @@ const vertexShader = `#version 300 es ` +
     shaderfunctions.mercatorXYToGLPosition +
     shaderfunctions.longLatRadToMercator +
     shaderfunctions.longLatRadToCartesian3D +
+    shaderfunctions.circleLimpFromLongLatRadCenterCartesian3D +
     shaderfunctions.circleLimpFromLongLatRadCenterMercatorCompass +
     shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistancePadding +
     shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistance + `
 
-${circleLimpFromLongLatRadCenterCartesian3D_accurate_accurate}
-
 in vec2 center;
 in float radius;
 in float pad_range;
@@ -51,7 +46,7 @@ void main() {
 
     if ( is3D){  
         gl_Position = projection * view * vec4(
-            circleLimpFromLongLatRadCenterCartesian3D_accurate( center, radius_, angle) - translate, 1.0);
+            circleLimpFromLongLatRadCenterCartesian3D( center, radius_, angle) - translate, 1.0);
         v_limp = vec2(0.0, 0.0);
         return;
     }
@@ -111,6 +106,10 @@ class Logic {
     }
 
 
+    draw(vao, length, opaity) {
+
+    }
+
     draw(attrBufferManager, padCount, compass, opacity) {
         const { gl, program, _padCountLocation, cameraBlockBindingPoint, cameraBlockTotem, _compassLocation } = this;
         gl.useProgram(program);

package/programs/rings/distancering/paddyflatprogram3d.js

@@ -1,8 +1,4 @@
 import { createProgram, shaderfunctions } from "../../../util";
-import {
-    circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
-    circleLimpFromLongLatRadCenterCartesian3D_accurate_accurate
-} from "../../../util/shaderfunctions/geometrytransformations";
 import CameraUniformBlockTotem, { CameraUniformBlockString } from "../../totems/camerauniformblock";
 import { globeProgramCache, noRegisterGlobeProgramCache } from "../../programcache";
 
@@ -14,12 +10,11 @@ const vertexShader = `#version 300 es ` +
     shaderfunctions.mercatorXYToGLPosition +
     shaderfunctions.longLatRadToMercator +
     shaderfunctions.longLatRadToCartesian3D +
+    shaderfunctions.circleLimpFromLongLatRadCenterCartesian3D +
     shaderfunctions.circleLimpFromLongLatRadCenterMercatorCompass +
     shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistancePadding +
     shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistance + `
 
-${circleLimpFromLongLatRadCenterCartesian3D_accurate_accurate}
-
 in vec2 center;
 in float radius;
 in float pad_range;
@@ -51,7 +46,7 @@ void main() {
 
     if ( is3D){  
         gl_Position = projection * view * vec4(
-            circleLimpFromLongLatRadCenterCartesian3D_accurate( center, radius_, angle) - translate, 1.0);
+            circleLimpFromLongLatRadCenterCartesian3D( center, radius_, angle) - translate, 1.0);
         v_limp = vec2(0.0, 0.0);
         return;
     }

package/rangerings/rangerings.js

@@ -19,7 +19,6 @@ const { circleProgramCache, PaddingProgramCache, CirclePaddySharedBuffer } = rin
  */
 
 
-
 export default class {
 
     constructor(id, { oneDegreePadding = true, compass = COMPASS_MODES.REAL, showNumbers = true, numbersStyle = null, opacity = 1 } = {}) {
@@ -73,11 +72,7 @@ export default class {
     }
 
 
-    setOpacity(opacity) {
-        this._opacity = opacity;
-        this.textPlugin?.setOpacity(opacity); // TODO impolement this
-        this.globe.DrawRender();
-    }
+
 
     setGeometry() {
         this.textPlugin?.setGeometry();
@@ -97,6 +92,14 @@ export default class {
 
 
 
+
+    setOpacity(opacity) {
+        this._opacity = opacity;
+        this.textPlugin?.setOpacity(opacity); // TODO impolement this
+        this.globe.DrawRender();
+    }
+
+
     /**
      * @param {RangeRingData} rangeRingData
      * 0 compass limps

package/rangerings-2/enum.js

@@ -0,0 +1,7 @@
+
+export const ENUM_HIDE = Object.freeze({ SHOW: 0, HIDE: 1, HIDE_1_DEGREE_PADDINGS: 2 });
+export const ENUM_TEXT_HIDE = Object.freeze({ SHOW: 0, HIDE: 1 });
+export const COMPASS_MODES = Object.freeze({
+    COMPASS: 1,
+    REAL: 0,
+});

package/rangerings-2/index.js

@@ -0,0 +1,4 @@
+import { RangeRings } from "./plugin";
+import RangeRingAngleText from './rangeringangletext';
+import { ENUM_HIDE, ENUM_TEXT_HIDE, COMPASS_MODES } from './enum';
+export { RangeRings, ENUM_HIDE, ENUM_TEXT_HIDE, COMPASS_MODES, RangeRingAngleText };