@pirireis/webglobeplugins 0.6.21 → 0.6.23-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/circle-line-chain/plugin.js

@@ -83,7 +83,7 @@ export class CircleLineChainPlugin {
         this.circleProgram2d = CircleCache.get(globe);
         this.circle3DProgram = Circle3DCache.get(globe);
 
-        this.lineToTheOriginProgram = LineToTheOriginCache.get(globe);
+        // this.lineToTheOriginProgram = LineToTheOriginCache.get(globe);
         const _circleFlatEdgeCount = this._circleFlatEdgeCount;
         {
             // createBuffers
@@ -174,8 +174,8 @@ export class CircleLineChainPlugin {
                 ...['centerCoords2d', 'centerCoords3d', 'targetCoords2d', 'targetCoords3d', 'dashRatio', 'dashOpacity', 'rgba'].map(key => obj(this.bufferManagersCompMap.get(key))));
             this.circleVao2d = this.circleProgram2d.createVAO(
                 ...["centerCoords2dMercator", "rgbaCircleMercator", "circleDashAngleMercator", "dashOpacityMercator"].map(key => obj(this.bufferManagersCompMap.get(key))));
-            this.toOriginVao = this.lineToTheOriginProgram.createVAO(
-                ...["targetCoords3d", "rgba"].map(key => obj(this.bufferManagersCompMap.get(key))));
+            // this.toOriginVao = this.lineToTheOriginProgram.createVAO(
+            //     ...["targetCoords3d", "rgba"].map(key => obj(this.bufferManagersCompMap.get(key))));
             this.circle3DVao = this.circle3DProgram.createVAO(
                 ...["centerCoords3d", "bigRadius", "rgbaCircle", "circleDashAngle", "dashOpacity"].map(key => obj(this.bufferManagersCompMap.get(key)))
             );
@@ -426,7 +426,7 @@ export class CircleLineChainPlugin {
         const { gl } = this;
         gl.deleteVertexArray(this.lineVao);
         gl.deleteVertexArray(this.circleVao2d);
-        gl.deleteVertexArray(this.toOriginVao);
+        // gl.deleteVertexArray(this.toOriginVao);
         this.lineProgram = null;
         this.circleProgram2d = null;
         this.isFreed = true;
@@ -437,7 +437,7 @@ export class CircleLineChainPlugin {
         gl.disable(gl.DEPTH_TEST);
         this.lineProgram.draw(this.lineVao, this.bufferOrchestrator.length, this._opacity);
         this._textContextWriterInjectionMap.forEach((writer) => writer.draw());
-        this.lineToTheOriginProgram.draw(this.toOriginVao, this.bufferOrchestrator.length, this._opacity);
+        // this.lineToTheOriginProgram.draw(this.toOriginVao, this.bufferOrchestrator.length, this._opacity);
         const is3D = globe.api_GetCurrentGeometry() === 0;
         if (this._drawCircleOn) {
             if (is3D) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.6.21",
+    "version": "0.6.23-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/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.drawInstanced( 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 = 15.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, index, buffer, 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.drawInstanced(gl.POINTS, 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/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 };