@pirireis/webglobeplugins 0.6.12 → 0.6.15

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

@@ -0,0 +1,219 @@
+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 = 100;
+const ITEM_SIZE = 9;
+
+const vertexShader = `#version 300 es
+precision highp float;
+${R_3D}
+${CameraUniformBlockString}
+${pointsOnSphereBetween}
+${mercatorXYToGLPosition}
+${cartesian3DToGLPosition}
+
+in vec2 start_position;
+in vec3 start_poisition3d;
+in vec2 end_position;
+in vec3 end_position3;
+in float dash_ratio;
+in vec4 color;
+in float dash_opacity;
+out vec4 v_color;
+out vec2 v_limp;
+out float interpolation;
+out float v_dash_ratio;
+out float v_dash_opacity;
+
+
+void main() {
+    vec2 longLat;
+    if (is3D) {
+        interpolation = float(gl_VertexID) / ${GLOBE_MIDPOINT_COUNT - 1}.0;
+        vec3 cartesian = pointsOnSphereBetween(start_poisition3d, end_position3, interpolation) * R_3D;
+        gl_Position = cartesian3DToGLPosition(cartesian);
+        v_limp = vec2(0.0, 0.0);
+    } else {
+        interpolation = float(gl_VertexID);
+        if (gl_VertexID % 2 == 0) {
+            longLat = start_position;
+        } else {
+            longLat = end_position;
+        }
+        v_limp = longLat;
+        gl_Position = mercatorXYToGLPosition(longLat);
+    }
+    // if ( gl_VertexID % 2 == 0) {v_color = color;}
+    // else {v_color = vec4(0.0, 0.0, 0.0, 0.0);}
+    v_color = color;
+    v_dash_ratio = dash_ratio;
+    v_dash_opacity = dash_opacity;
+}
+`;
+
+const fragmentShader = `#version 300 es
+${POLE}
+precision highp float;
+uniform float opacity;
+in vec4 v_color;
+out vec4 color;
+in float interpolation;
+in float v_dash_ratio;
+in vec2 v_limp;
+in float v_dash_opacity;
+void main() {
+    if (v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE) { discard; }
+    color = v_color;
+    color.a *= opacity;
+    if ( v_dash_ratio >= 1.0 ) { return; }
+    if (interpolation > 0.95) { return; }
+    if (fract(interpolation / (2.0 * v_dash_ratio)) < 0.5) { color.a *= v_dash_opacity; }
+
+}
+`;
+
+
+class Logic {
+
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = createProgram(this.gl, vertexShader, fragmentShader);
+        this._lastOpacity = 1.0;
+        const { gl, program } = this;
+        {
+            // assign attribute locations
+            gl.bindAttribLocation(program, 0, "start_position");
+            gl.bindAttribLocation(program, 1, "start_position3d");
+            gl.bindAttribLocation(program, 2, "end_position");
+            gl.bindAttribLocation(program, 3, "end_position3d");
+            gl.bindAttribLocation(program, 4, "dash_ratio");
+            gl.bindAttribLocation(program, 5, "color");
+            gl.bindAttribLocation(program, 6, "dash_opacity");
+        }
+
+        {
+            this._opacityLocation = gl.getUniformLocation(program, "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 = this.gl.getUniformBlockIndex(this.program, "CameraUniformBlock");
+        this.cameraBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
+        gl.uniformBlockBinding(this.program, cameraBlockIndex, this.cameraBlockBindingPoint);
+
+
+    }
+
+
+    draw(vao, length, opacity) {
+        const { gl, program, globe, cameraBlockTotem, cameraBlockBindingPoint } = this;
+        gl.useProgram(program);
+        cameraBlockTotem.bind(cameraBlockBindingPoint);
+        gl.bindVertexArray(vao);
+        if (opacity !== this._lastOpacity) {
+            gl.uniform1f(this._opacityLocation, opacity);
+            this._lastOpacity = opacity;
+        }
+        const drawCount = globe.api_GetCurrentGeometry() === 0 ? GLOBE_MIDPOINT_COUNT : 2;
+        // gl.disable(gl.DEPTH_TEST);
+        gl.drawArraysInstanced(gl.LINE_STRIP, 0, drawCount, length);
+        gl.bindVertexArray(null);
+        cameraBlockTotem.unbind(cameraBlockBindingPoint);
+        // gl.enable(gl.DEPTH_TEST);
+    }
+
+    //
+    createVAO(
+        startPotisionBufferObj, startPotision3DBufferObj,
+        endPositionBufferObj, endPosition3DBufferObj,
+        dashRatioBufferObj,
+        dashOpacityBufferObj,
+        colorBufferObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        {
+            const { buffer, stride = 0, offset = 0 } = startPotisionBufferObj;
+            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 } = startPotision3DBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(1);
+            gl.vertexAttribPointer(1, 3, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(1, 1);
+        }
+        {
+
+            const { buffer, stride = 0, offset = 0 } = endPositionBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(2);
+            gl.vertexAttribPointer(2, 2, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(2, 1);
+        }
+        {
+
+            const { buffer, stride = 0, offset = 0 } = endPosition3DBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(3);
+            gl.vertexAttribPointer(3, 3, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(3, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = dashRatioBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(4);
+            gl.vertexAttribPointer(4, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(4, 1);
+        }
+
+        {
+            const { buffer, stride = 0, offset = 0 } = colorBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(5);
+            gl.vertexAttribPointer(5, 4, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(5, 1);
+        }
+
+        {
+            const { buffer, stride = 0, offset = 0 } = dashOpacityBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(6);
+            gl.vertexAttribPointer(6, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(6, 1);
+        }
+
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+
+    }
+
+
+    free() {
+        if (this.isFreed) return;
+        programCache.releaseProgram(this.globe, CameraUniformBlockTotem);
+        this.gl.deleteProgram(this.program);
+        this.isFreed = true;
+    }
+}
+
+
+
+export const LineOnGlobeCache = Object.freeze({
+    get: (globe) => { return noRegisterGlobeProgramCache.getProgram(globe, Logic) },
+    release: (globe) => { return noRegisterGlobeProgramCache.releaseProgram(globe, Logic) }
+});
+

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/programs/two-d/pixel-padding-for-compass.js

@@ -53,11 +53,8 @@ vec2 adjust_pos(vec2 pos) {
 void main(){
     vec3 c = coord_opacity();
     gl_Position = vec4( adjust_pos(c.xy), 0.0, 1.0);
-    // gl_Position = vec4( 0.0, 0.0, 0.0, 1.0);
     v_rgba = rgba;
     v_rgba.a *= plugin_opacity;
-    // float opacity = (float((gl_VertexID + 179) % 720 ) / (${vertexCount}.0)) / 1.5 + 0.5;
-    v_rgba.a *= c.z;
     gl_PointSize = 10.0;
 }
 `

package/util/shaderfunctions/geometrytransformations.js

@@ -93,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 + `
@@ -281,4 +289,24 @@ float realDistanceOnSphereR1(vec2 longLat1, vec2 longLat2) {
     float c = 2.0 * atan(sqrt(a), sqrt(1.0 - a));
     return c;
 }
-`;
+`;
+
+const pointsOnSphereBetween = `vec3 pointsOnSphereBetween(vec3 a, vec3 b, float ratio) {
+    // Normalize the input points to ensure they are on the unit sphere
+    a = normalize(a);
+    b = normalize(b);
+
+    // Compute the angle between the points
+    float theta = acos(dot(a, b));
+
+    // Compute the interpolated point using spherical linear interpolation (slerp)
+    vec3 result = (sin((1.0 - ratio) * theta) * a + sin(ratio * theta) * b) / sin(theta);
+
+    // Return the normalized result to ensure it lies on the sphere
+    return normalize(result);
+}`
+
+export {
+    pointsOnSphereBetween
+
+}

package/heatwavemaps/index.js

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