@pirireis/webglobeplugins 0.6.11 → 0.6.14

package/circle-line-chain/chain-list-map.js

@@ -174,8 +174,8 @@ export class ChainListMap {
      */
     textUpdate(chainKey, textWriterObjs, dataPreAdaptor) {
         const chain = this._chainMap.get(chainKey);
-        const data = (dataPreAdaptor) ? chain.map(dataPreAdaptor) : chain;
         if (!chain) return;
+        const data = (dataPreAdaptor) ? chain.map(dataPreAdaptor) : chain;
         const properties = this._chainSideProperties.get(chainKey);
         textWriterObjs.forEach((writer) => {
             writer.insertTextBulk(data, properties);

package/circle-line-chain/plugin.js

@@ -1,5 +1,6 @@
 import { LineOnGlobeCache } from '../programs/line-on-globe/naive';
 import { CircleCache } from '../programs/line-on-globe/circle';
+import { LineToTheOriginCache } from "../programs/line-on-globe/to-the-origin"
 import { BufferOrchestrator, BufferManager } from "../util/account";
 import { ChainListMap } from "./chain-list-map";
 import { mapGetOrThrow } from "../util/check/get";
@@ -76,6 +77,7 @@ export class CircleLineChainPlugin {
         const { gl, globe } = this;
         this.lineProgram = LineOnGlobeCache.get(globe);
         this.circleProgram = CircleCache.get(globe);
+        this.lineToTheOriginProgram = LineToTheOriginCache.get(globe);
         {
             // createBuffers
             const bufferType = "DYNAMIC_DRAW";
@@ -134,14 +136,14 @@ export class CircleLineChainPlugin {
                 ...['centerCoords', 'targetCoords', 'dashRatio', 'dashOpacity', 'rgba'].map(key => obj(this.bufferManagersCompMap.get(key))));
             this.circleVao = this.circleProgram.createVAO(
                 ...["centerCoords", "bigRadius", "rgbaCircle", "circleDashAngle", "dashOpacity"].map(key => obj(this.bufferManagersCompMap.get(key))));
+            this.toOriginVao = this.lineToTheOriginProgram.createVAO(
+                ...["targetCoords", "rgba"].map(key => obj(this.bufferManagersCompMap.get(key))));
         }
 
     }
 
 
     // API
-
-
     setDrawCircleOn(bool) {
         if (typeof bool !== 'boolean') throw new Error("setDrawCircleOn parameter must be a boolean");
         this._drawCircleOn = bool;
@@ -377,12 +379,13 @@ export class CircleLineChainPlugin {
     }
 
     draw3D() {
-        const { gl } = this;
+        const { gl, globe } = this;
         gl.disable(gl.DEPTH_TEST);
         this.lineProgram.draw(this.lineVao, this.bufferOrchestrator.length, this._opacity);
         if (this._drawCircleOn) this.circleProgram.draw(this.circleVao, this.bufferOrchestrator.length, this._opacity);
         this._textContextWriterInjectionMap.forEach((writer) => writer.draw());
         gl.enable(gl.DEPTH_TEST);
+        this.lineToTheOriginProgram.draw(this.toOriginVao, this.bufferOrchestrator.length, this._opacity);
     }
 }
 

package/compass-rose/compass-rose-padding-flat.js

@@ -57,14 +57,27 @@ export class PixelPaddingCompassPlugin {
         this._initOrchestrations()
     }
 
+
+    /**
+     * @param {string} key
+     * @param {number} long
+     * @param {number} lat
+     * @typedef properties
+     * @property {number} pixelRadiusBig
+     * @property {number} pixelRadiusSmall
+     * @property {[4 numbers between 0-1]} rgba 
+     */
     insert(key, long, lat, properties = null) {
         this.__insertText(key, null, null, { properties, update: true });
         this.compassMap.insert(key, long, lat, properties);
         this.globe.DrawRender();
-
     }
 
 
+    /**
+     * 
+     * @param {string} key 
+     */
     delete(key) {
         this.compassMap.delete(key);
         this.globe.DrawRender();

package/heatwave/plugins/heatwaveglobeshell.js

@@ -140,8 +140,6 @@ export default class Plugin {
     }
 
 
-
-
     _updateData(ratio, textureData0 = null, textureData1 = null) {
         if (!textureData0 || !textureData1) {
             this.isAble = false;

package/package.json

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

package/{heatwavemaps/isobar/objectarraylabels.js → pin/pin-object-array.js}

@@ -1,9 +1,30 @@
+
+/**
+ * IconData;
+ *  iconMap, iconCoords for objectArray
+ * 
+ * Pin data:
+ *  long, lat, payload
+ * 
+ * methods insertPin pin and its data
+ * methods deletePin
+ * 
+ * Behaviur injection:
+ * hover
+ * move
+ * pick drop
+ * mouseclicks
+ * keyboard clicks
+ * mouse curser changes ( this can be implemented inside above methods)
+ */
+
 import {
     CSGlobe,
     CSIconTypes,
     CSObjectTypes,
     CSObjectArrayUpdateTypes,
 } from "@pirireis/webglobe";
+import AlarmTimeLineFadeInFadeOut from "../../plugins/alarms/alarmFadeInFadeOutPlugin/AlarmTimeLineFadeInFadeOutPlugin";
 
 /**
  * @typedef {Object} IconPayload
@@ -30,6 +51,118 @@ import {
  * @property {PointPayload[]} attribs
  */
 
+function addIconMap(globe, mapName = "IconMapName", ICON_MAP_URL, ICON_MAP_JSON_URL) {
+    globe.api_AddIconMap('IconMapName', ICON_MAP_URL, ICON_MAP_JSON_URL);
+}
+
+class ObjectArray {
+    constructor(symbolSet, style) {
+        this.symbolSet = symbolSet;
+        this.style = style;
+    }
+
+    setSymbolSet(symbolSet) {
+        this.symbolSet = symbolSet;
+    }
+
+
+}
+
+
+class PinPointObjectArray {
+    constructor(id,
+        globe,
+        symbolSet, // iconMapName
+        style,
+        callBacks = {
+            mouseDown: (pinItem, event) => { },
+            mouseMove: (pinItem, event) => { },
+            mouseUp: (pinItem, event) => { },
+            mouseClick: (pinItem, event) => { },
+            mouseDblClick: (pinItem, event) => { },
+
+        } = {}) {
+        this.id = id
+        this.globe = globe;
+        this.symbolSet = symbolSet;
+        this.style = style;
+        this.iconMapName = iconMapName;
+        this.callBacks = callBacks;
+
+        // this item will be used
+
+        this.currentItem = null
+    }
+
+
+    insertPins(pins) {
+
+    }
+
+    deletePins(pinsIDs) {
+        const deleteBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        }
+    }
+
+
+    _queryByScreenFindFirst() {
+        const { clientX, clientY } = this.globe.api_GetMousePos();
+        const allObjects = this.globe.queryByScreen(clientX, clientY);
+        for (let i = 0; i < allObjects.length; i++) {
+            const { obj, owner } = allObjects[i];
+            if (owner === this.objectArray) {
+                return obj;
+            }
+        }
+    }
+
+    // mouseDown(x, y, event) {
+    //     return false
+    // }
+
+
+    // // mouse'a basılıp hareket ettirildiğinde, mouseDown'dan true dönmüşse çağrılır
+    // mouseMove(x, y, event) {
+
+    // }
+
+    // // mouse bırakıldığında çağrılır
+    // mouseUp(x, y, event) {
+
+    // }
+
+    // // harita üzerinde tıklandığında çağrılır
+    // mouseClick() {
+    //     return false
+    // }
+
+    // // harita üzerinde çift tıklandığında çağrılır
+    // mouseDblClick() {
+    //     return false
+    // }
+
+
+    free() {
+        this.globe.api_ClearMouseEvents() // TODO
+    }
+
+    _setMouseEvent() {
+        const { globe } = this;
+        globe.api_SetMouseEvents()
+    }
+
+    _getIdForGlobe() {
+        const { globe, objectArray } = this;
+        const callback = () => {
+            const allObjects = globe.api_queryByScreen()
+        }
+        return `${this.id}_pinObjectArrayMouseEvent`;
+    }
+}
+
 class ObjectArrayLabels {
     /**
      * @param {number | string} id
@@ -244,4 +377,5 @@ class ObjectArrayLabels {
     }
 }
 
-export default ObjectArrayLabels;
+export default ObjectArrayLabels;
+

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

@@ -55,7 +55,7 @@ void main() {
         v_limp = vec2(0.0, 0.0);
     } else {
         vec2 position;
-        if (radius < 1200.0) {
+        if (radius < 1400.0) {
             position = circleLimpFromLongLatRadCenterMercatorCompass( center_position, radius/ cos(center_position.y), angle);
         } else {
            position = circleLimpFromLongLatRadCenterMercatorRealDistance( center_position, radius, angle);

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

@@ -4,7 +4,7 @@ import { createProgram } from "../../util";
 import { noRegisterGlobeProgramCache, globeProgramCache } from "../programcache";
 import BufferOffsetManger from "../../util/account/bufferoffsetmanager";
 import { programCache } from "../rings/distancering/circleflatprogram";
-const Radian = Math.PI / 180.0;
+
 const GLOBE_MIDPOINT_COUNT = 100;
 const ITEM_SIZE = 9;
 

package/programs/line-on-globe/to-the-origin.js

@@ -0,0 +1,165 @@
+import { createProgram } from "../../util";
+import { longLatRadToCartesian3DWithR, cartesian3DToGLPosition, R_3D } from "../../util/shaderfunctions/geometrytransformations";
+import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../totems";
+import { noRegisterGlobeProgramCache } from "../programcache";
+
+/**
+ * Creates beams from long, lat, radian coordinates to origin on global view.
+ * Ojects with hight, float over terrain and does not propose information of their actual coordinates.
+ * You start drawing after zoom level 9-10
+ * Does not work on mercator.
+ */
+
+
+const vertexShaderSource = `#version 300 es
+precision highp float;
+${CameraUniformBlockString}
+${R_3D}
+${longLatRadToCartesian3DWithR}
+${cartesian3DToGLPosition}
+
+in vec2 position2d;
+in vec4 rgba;
+uniform float origin_r;
+flat out vec4 v_rgba;
+out float interpolation_value;
+
+void main() {
+    if (!is3D) {return;} 
+    vec3 cartesian;
+    if(gl_VertexID == 0) {
+        cartesian = longLatRadToCartesian3DWithR(position2d, R_3D);
+        interpolation_value = 1.0;
+    } else {
+        cartesian = longLatRadToCartesian3DWithR(position2d, origin_r);
+        interpolation_value = 0.0;
+    }
+    gl_Position = cartesian3DToGLPosition(cartesian);
+    v_rgba = rgba;
+    gl_PointSize = 10.0; // for testing
+}
+`;
+
+const fragmentShaderSource = `#version 300 es
+precision highp float;
+
+uniform float plugin_opacity;
+in float interpolation_value;
+flat in vec4 v_rgba;
+out vec4 color;
+void main(){
+    if ( fract( interpolation_value * 100.0) < 0.5) {discard;}
+    color = vec4( 
+        v_rgba.rgb,
+        v_rgba.a * plugin_opacity * interpolation_value * 0.9
+    );
+}`;
+
+
+class Logic {
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+        this._lastOpacity = 1.0;
+        this._lastOriginR = 6378.137 - 1;
+        const { gl, program } = this;
+        {
+            gl.bindAttribLocation(program, 0, "position2d");
+            gl.bindAttribLocation(program, 1, "rgba");
+
+        }
+        {
+            this._opacityLocation = gl.getUniformLocation(program, "plugin_opacity");
+            this._originRLocation = gl.getUniformLocation(program, "origin_r")
+            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(this._opacityLocation, this._lastOpacity);
+            gl.uniform1f(this._originRLocation, this._lastOriginR);
+            gl.useProgram(currentProgram);
+        }
+        {
+            this.cameraBlockBindingPoint = 0;
+            const cameraBlockIndex = this.gl.getUniformBlockIndex(this.program, "CameraUniformBlock");
+            this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+            gl.uniformBlockBinding(this.program, cameraBlockIndex, this.cameraBlockBindingPoint);
+        }
+    }
+
+    draw(vao, length, opacity, originR = null) {
+        const { gl, program, globe, cameraBlockTotem, cameraBlockBindingPoint } = this;
+        const is3D = globe.api_GetCurrentGeometry() == 0;
+        if (!is3D) return;
+        const lod = globe.api_GetCurrentLODWithDecimal()
+        if (lod < 12) return;
+        gl.useProgram(program);
+        cameraBlockTotem.bind(cameraBlockBindingPoint);
+        gl.bindVertexArray(vao);
+        if (opacity !== this._lastOpacity) {
+            gl.uniform1f(this._opacityLocation, opacity);
+            this._checkOpacity(opacity);
+            this._lastOpacity = opacity;
+        }
+        if (originR !== null && originR !== this._lastOriginR) {
+            this._checkOriginR(originR);
+            gl.uniform1f(this._originRLocation, originR);
+            this._lastOriginR = originR;
+        }
+
+        // gl.disable(gl.DEPTH_TEST);
+        gl.drawArraysInstanced(gl.LINE_STRIP, 0, 2, length);
+        gl.bindVertexArray(null);
+        cameraBlockTotem.unbind(cameraBlockBindingPoint);
+        // gl.enable(gl.DEPTH_TEST);
+    }
+
+    _checkOpacity(opacity) {
+        if (opacity < 0.0 || opacity > 1) throw RangeError("Opacity should be between 0 and 1");
+
+    }
+
+    _checkOriginR(r) {
+        if (r < 0.0 || r > 6378.137 - 0.3) throw RangeError("r should be between 0 and 6378.137 - 0.3");
+    }
+
+    createVAO(potisionBufferObj, colorBufferObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        {
+            const { buffer, stride = 0, offset = 0 } = potisionBufferObj;
+            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 } = colorBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(1);
+            gl.vertexAttribPointer(1, 4, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(1, 1);
+        }
+
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+
+    }
+
+
+    free() {
+        if (this.isFreed) return;
+        CameraUniformBlockTotemCache.release(this.globe);
+        this.isFreed = true;
+    }
+}
+
+const LineToTheOriginCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+})
+
+export {
+    LineToTheOriginCache
+}

package/util/shaderfunctions/geometrytransformations.js

@@ -18,6 +18,7 @@ export const R = `
 export const PI = `
 #ifndef PI
 #define PI 3.141592653589793
+
 #endif
 `;
 
@@ -77,6 +78,7 @@ export const longLatRadToMercator = R + PI + `
 vec2 longLatRadToMercator( vec2 longLatRad) {
     float x = R * longLatRad.x;
     float y = R * log( tan( PI / 4.0 + longLatRad.y / 2.0 ) );
+    y -= mix(-60.0, 60.0, abs(longLatRad.y + PI / 8.0) / (PI / 4.0));
     return vec2(x, y);
 }
 `;
@@ -91,6 +93,14 @@ vec3 longLatRadToCartesian3D( vec2 longLat) {
 }
 `;
 
+export const longLatRadToCartesian3DWithR = `
+vec3 longLatRadToCartesian3DWithR( vec2 longLat, float radius) {
+    float x = radius * cos(longLat.y) * cos(longLat.x);
+    float y = radius * cos(longLat.y) * sin(longLat.x);
+    float z = radius * sin(longLat.y);
+    return vec3(x, y, z);
+}
+`;
 
 // TODO: Make it precise. It doesnt use haversine formula. If this changes, change the formmula which calculates text position. 
 export const circleLimpFromLongLatRadCenterCartesian3D = R + `
@@ -110,7 +120,7 @@ vec3 circleLimpFromLongLatRadCenterCartesian3D( vec2 center, float radius, float
 
 // TODO: Make it precise. Y axis is not correct.
 
-export const circleLimpFromLongLatRadCenterMercatorRealDistance = PI + `
+export const circleLimpFromLongLatRadCenterMercatorRealDistanceNew = PI + `
 vec2 circleLimpFromLongLatRadCenterMercatorRealDistance(vec2 center, float radius, float angle) {
     float ang = angle + PI / 2.0; // Shift angle to align with +x axis
     float r = radius / R;
@@ -130,7 +140,7 @@ vec2 circleLimpFromLongLatRadCenterMercatorRealDistance(vec2 center, float radiu
 }`;
 
 
-export const circleLimpFromLongLatRadCenterMercatorRealDistanceOLD = PI + `
+export const circleLimpFromLongLatRadCenterMercatorRealDistance = PI + `
 vec2 circleLimpFromLongLatRadCenterMercatorRealDistance(vec2 center, float radius, float angle){
     float ang = angle + PI / 2.0; // this is there because the other methods are implemented in, angle 0 is +x axis orientatation
     float r = radius / R;

package/heatwavemaps/index.js

@@ -1,4 +0,0 @@
-import HeatWavePlugin from './plugins/heatwaveglobeshell';
-import { IsobarRasterToVector } from './isobar/plugin';
-export { HeatWavePlugin, IsobarRasterToVector };
-