@pirireis/webglobeplugins 0.15.35 → 0.16.0

package/dist/util/programs/texturetoglobe.js

@@ -0,0 +1,179 @@
+import { createProgram } from "../webglobjectbuilders";
+import { shaderfunctions } from "..";
+import { latLongBboxtoPixelXYBbox } from "..";
+/** TODO:
+ * 3d icin calistir
+ */
+//TODO: DELETE THIS FILE. 
+class TextureToGlobeProgram {
+    constructor(gl, globe) {
+        this.globe = globe;
+        this.gl = gl;
+        this._is3D = true;
+        this._programWrapper = this._createProgramWrapper();
+        this._resizeHandler = this._resizeEventHandler.bind(this);
+        window.addEventListener('resize', this._resizeHandler, true);
+    }
+    _initUniforms() {
+        const { gl, _programWrapper } = this;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        // set u_alpha
+        gl.uniformMatrix3fv(_programWrapper.u_bbox_matrix, false, new Float32Array([
+            1, 0, 0,
+            0, 1, 0,
+            0, 0, 1
+        ]));
+        gl.uniform1f(_programWrapper.u_alpha, 1.0);
+        gl.uniform1f(_programWrapper.u_is3D, 1.0);
+        gl.uniform1f(_programWrapper.height, 0.0);
+        gl.useProgram(currentProgram);
+    }
+    _createProgramWrapper() {
+        const gl = this.gl;
+        const vertexSource = `#version 300 es
+            precision highp float;
+
+            in vec2 a_position;
+
+            uniform mat3 u_bbox_matrix;
+
+            uniform mat4 u_model_view_matrix;
+            uniform mat4 u_proj_matrix;
+            uniform vec3 u_transpos;
+
+            uniform vec2 u_mapWH;
+            uniform vec2 u_scrWH;
+
+            uniform bool u_is3D;
+            uniform float height; 
+
+            out vec2 v_texcoord;
+
+
+            ` + shaderfunctions.pixelXYToCartesian3DPoint + `
+            ` + shaderfunctions.pixelXYToCartesian2DPoint + `
+
+
+            void main() {
+                vec3 pos = u_bbox_matrix * vec3(a_position, height);
+                if(u_is3D){
+                    pos = pixelXYToCartesian3DPoint(pos);
+                    gl_Position = u_proj_matrix * u_model_view_matrix * vec4(pos - u_transpos, 1.0);
+                } else {
+                    vec2 xy = pixelXYToCartesian2DPoint(pos.xy, u_transpos.xy, u_mapWH, u_scrWH);
+                    gl_Position = u_proj_matrix * vec4(xy.x, xy.y, 0.0, 1.0);
+                }
+                gl_PointSize = 100.0;
+                v_texcoord = a_position * 0.5 + 0.5; // need a check
+            }
+            `;
+        const fragmentSource = `#version 300 es
+            precision highp float;
+
+            in vec2 v_texcoord;
+
+            uniform float u_alpha;
+            uniform sampler2D u_texture;
+
+            out vec4 outColor;
+
+            void main() {
+                // outColor = texture(u_texture, v_texcoord);
+                // outColor.a *= u_alpha;
+                outColor = vec4(1.0, 0.0, 0.0, 0.5);
+            }   
+            `;
+        const program = createProgram(gl, vertexSource, fragmentSource);
+        const vao = gl.createVertexArray();
+        const buffer = gl.createBuffer();
+        gl.bindVertexArray(vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+            0, 0,
+            1, 0,
+            1, 1,
+            0, 1
+        ]), gl.STATIC_DRAW);
+        const a_position = -gl.getAttribLocation(program, 'a_position');
+        gl.enableVertexAttribArray(a_position);
+        gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 0, 0);
+        gl.bindVertexArray(null);
+        return {
+            program: program,
+            vao: vao,
+            u_model_view_matrix: gl.getUniformLocation(program, 'u_model_view_matrix'),
+            u_proj_matrix: gl.getUniformLocation(program, 'u_proj_matrix'),
+            u_transpos: gl.getUniformLocation(program, 'u_transpos'),
+            u_mapWH: gl.getUniformLocation(program, 'u_mapWH'),
+            u_scrWH: gl.getUniformLocation(program, 'u_scrWH'),
+            u_texture: gl.getUniformLocation(program, 'u_texture'),
+            u_bbox_matrix: gl.getUniformLocation(program, 'u_bbox_matrix'),
+            u_is3D: gl.getUniformLocation(program, 'u_is3D'),
+        };
+    }
+    draw(modelViewMatrix, projectionMatrix, transPos, texture) {
+        // console.log('draw')
+        const { gl, _programWrapper, _is3D } = this;
+        gl.useProgram(_programWrapper.program);
+        gl.bindVertexArray(_programWrapper.vao);
+        gl.uniformMatrix4fv(_programWrapper.u_model_view_matrix, false, modelViewMatrix);
+        gl.uniformMatrix4fv(_programWrapper.u_proj_matrix, false, projectionMatrix);
+        gl.uniform3f(_programWrapper.u_transpos, transPos.x, transPos.y, transPos.z);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.uniform1i(_programWrapper.u_texture, 0);
+        if (!_is3D) {
+            const mapWH = this.globe.api_GetCurrentWorldWH();
+            gl.uniform2f(_programWrapper.u_mapWH, mapWH.width, mapWH.height);
+        }
+        gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
+        gl.drawArrays(gl.POINTS, 0, 4);
+    }
+    setBBox(minx, maxx, miny, maxy) {
+        const { gl, _programWrapper } = this;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniformMatrix3fv(_programWrapper.u_bbox_matrix, false, new Float32Array([
+            maxx - minx, 0, minx,
+            0, maxy - miny, miny,
+            0, 0, 1
+        ]));
+        gl.useProgram(currentProgram);
+    }
+    setLatLongBBox(minx, maxx, miny, maxy) {
+        const bboxMatrix = latLongBboxtoPixelXYBbox(minx, miny, maxx, maxy);
+        const { gl, _programWrapper } = this;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniformMatrix3fv(_programWrapper.u_bbox_matrix, false, bboxMatrix);
+        gl.useProgram(currentProgram);
+    }
+    setScreenWH() {
+        const { gl, _programWrapper, globe } = this;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniform2f(_programWrapper.u_scrWH, globe.api_ScrW(), globe.api_ScrH());
+        gl.useProgram(currentProgram);
+    }
+    resize() {
+        const { globe } = this;
+        this.setScreenWH();
+    }
+    setGeometry() {
+        const { gl, globe, _programWrapper } = this;
+        this._is3D = globe.api_GetCurrentGeometry() === 0;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(_programWrapper.program);
+        gl.uniform1f(_programWrapper.u_is3D, this._is3D ? 1.0 : 0.0);
+        gl.useProgram(currentProgram);
+        this.resize();
+    }
+    free() {
+        window.removeEventListener('resize', this._resizeHandler, true);
+    }
+    _resizeEventHandler() {
+        this.resize();
+    }
+}
+export { TextureToGlobeProgram };

package/dist/util/shaderfunctions/index.js

@@ -0,0 +1,2 @@
+export * from './geometrytransformations';
+export * from './nodata';

package/dist/util/shaderfunctions/nodata.js

@@ -0,0 +1,8 @@
+const vertexIDtoTextureCoordinate = `
+vec2 vertexIDtoTextureCoordinate(float id, vec2 textureDimentions) {
+    float x = mod(id, textureDimentions.x);
+    float y = floor(id / textureDimentions.x);
+    return vec2( x / textureDimentions.x, y / textureDimentions.y);
+}
+`;
+export { vertexIDtoTextureCoordinate };

package/dist/util/shaderfunctions/noisefunctions.js

@@ -0,0 +1,41 @@
+const permute34 = `` `vec3 permute34(vec3 x) {
+    x = ((x * 34.0) + 1.0) * x;
+    return x - floor(x * (1.0 / 289.0)) * 289.0;
+}` ``;
+const waveNoice = `` `float waveNoice(vec2 v)
+{
+    const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439); 
+
+	  vec2 i = floor(v + dot(v, C.yy));
+	  vec2 x0 = v - i + dot(i, C.xx);
+
+	  vec2 i1;
+    i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+
+	  vec4 x12 = x0.xyxy + C.xxzz;
+    x12.xy -= i1;
+
+    i = i - floor(i * (1.0 / 289.0)) * 289.0;
+
+	  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0))
+        + i.x + vec3(0.0, i1.x, 1.0));
+
+	  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
+    m = m * m;
+    m = m * m;
+
+	  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+	  vec3 h = abs(x) - 0.5;
+	  vec3 ox = floor(x + 0.5);
+	  vec3 a0 = x - ox;
+
+    m *= inversesqrt(a0 * a0 + h * h);
+
+	  vec3 g;
+    g.x = a0.x * x0.x + h.x * x0.y;
+    g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+    return 130.0 * dot(m, g);
+}` ``;
+export default {
+    permute34, waveNoice
+};

package/dist/util/surface-line-data/arcs-to-cuts.js

@@ -0,0 +1,50 @@
+"use strict";
+class ArcsToCutsManager {
+    constructor(rbush, { dotDistanceOfArcCuts = 0.01 }) {
+        this._map = new Map();
+        this._dotDistanceOfArcCuts = dotDistanceOfArcCuts;
+        this._rbush = rbush;
+    }
+    insertArcs(arc) {
+        if (this._map.has(arc.id)) {
+            this._deleteCuts(arc.id);
+        }
+    }
+    _deleteCuts(id) {
+        const cuts = this._map.get(id);
+        if (cuts) {
+            cuts.forEach(cut => cut.remove());
+        }
+    }
+    _cutArcAndAddToRBush(arc) {
+        const cuts = this._cutArcToBBoxs(arc);
+        cuts.forEach(cut => {
+            this._rbush.insert(cut);
+        });
+        this._map.set(arc.id, cuts);
+    }
+    _cutArcToBBoxs(arc) {
+        const cuts = [];
+        // Calculate the bounding box of the arc
+        // Create a cut object and add it to the cuts array
+        const cut = {
+            minX: bbox.minX,
+            minY: bbox.minY,
+            maxX: bbox.maxX,
+            maxY: bbox.maxY,
+            arcId: arc.id,
+        };
+        cuts.push(cut);
+        return cuts;
+    }
+}
+function sphericalLinearInterpolation(phi1, lambda1, phi2, lambda2, t) {
+    // Spherical linear interpolation between two points on a sphere
+    // Args: phi1, lambda1: starting point (in radians)
+    //       phi2, lambda2: ending point (in radians)
+    //       t: interpolation parameter (0 <= t <= 1)
+    // Returns: [phi, lambda] in radians
+    const phi = phi1 + t * (phi2 - phi1);
+    const lambda = lambda1 + t * (lambda2 - lambda1);
+    return [phi, lambda];
+}

package/dist/util/surface-line-data/cut-arc.js

@@ -0,0 +1 @@
+"use strict";

package/dist/util/surface-line-data/rbush-manager.js

@@ -0,0 +1 @@
+"use strict";

package/dist/util/surface-line-data/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/util/surface-line-data/web-worker.js

@@ -0,0 +1 @@
+"use strict";

package/dist/util/webglobe/gldefaultstates.js

@@ -0,0 +1,4 @@
+export function defaultblendfunction(gl) {
+    gl.blendEquation(gl.FUNC_ADD); // TODO: TESTING THIS
+    gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+}

package/dist/util/webglobe/index.js

@@ -0,0 +1,2 @@
+export * from './rasteroverlay';
+export * from './gldefaultstates';

package/dist/util/webglobe/rasteroverlay.js

@@ -0,0 +1,75 @@
+/**
+ * Iceride bir canvas uretir ve degisiklikler bu kanvasta yapilir
+ */
+// this class loads texture to raster overlay
+class RasterOverlayLoader {
+    constructor(id, globe, { opacity = 1.0, minLon = -180, minLat = -90, maxLon = 180, maxLat = 90, beforeObject = null, canvas = null, callBack = null } = {}) {
+        this.canvas = canvas || document.createElement('canvas');
+        this.gl = this.canvas.getContext('webgl2');
+        this.globe = globe;
+        this.id = id;
+        this._opacity = opacity;
+        this.bbox = { ll: { x: minLon, y: minLat }, ur: { x: maxLon, y: maxLat } };
+        this._beforeObject = beforeObject;
+        this._isProcessing = false;
+        this._callBack = callBack;
+    }
+    getGL() {
+        return this.gl;
+    }
+    getCanvasURL() {
+        return this.canvas.toDataURL();
+    }
+    setBBox(minLon, minLat, maxLon, maxLat) {
+        this.bbox = { ll: { x: minLon, y: minLat }, ur: { x: maxLon, y: maxLat } };
+        this.draw();
+    }
+    setCanvasWidthHeight(width, height) {
+        this.canvas.width = width;
+        this.canvas.height = height;
+        this.gl.viewport(0, 0, width, height);
+    }
+    draw() {
+        if (!this._isProcessing) {
+            requestAnimationFrame(this._draw.bind(this));
+            this._isProcessing = true;
+        }
+    }
+    _draw() {
+        this.globe.api_DeleteImageOverlay(this.id);
+        const id = this.id;
+        const imgUrl = this.getCanvasURL();
+        const bbox = this.bbox;
+        const opacity = this._opacity;
+        const rotDeg = 0;
+        const color = null;
+        const beforeObject = this._beforeObject;
+        const callback = this._callBack || function () { };
+        this.globe.api_AddImageOverlay(id, imgUrl, bbox, color, opacity, rotDeg, beforeObject, callback);
+        this._isProcessing = false;
+    }
+    setBeforeObject(beforeObject) {
+        this._beforeObject = beforeObject;
+        this.draw();
+    }
+    setCallback(callback) {
+        this._callBack = callback;
+    }
+    setOpacity(opacity) {
+        if (opacity < 0 || opacity > 1) {
+            return;
+        }
+        this._opacity = opacity;
+        this.globe.api_SetImageOverlayColor(this.id, null, opacity);
+    }
+    free() {
+        this.globe.api_DeleteImageOverlay(this.id);
+    }
+    on() {
+        this.draw();
+    }
+    off() {
+        this.globe.api_DeleteImageOverlay(this.id);
+    }
+}
+export { RasterOverlayLoader };

package/dist/waveparticles/adaptor.js

@@ -0,0 +1,15 @@
+function centigradePlus90ToVectorArray(centigradeArray, noDataValue = -9999) {
+    const vectorArray = new Float32Array(centigradeArray.length * 2);
+    for (let i = 0; i < centigradeArray.length; i++) {
+        if (centigradeArray[i] === noDataValue) {
+            vectorArray.set([0, 0], i * 2);
+            continue;
+        }
+        const rad = (centigradeArray[i] + 90.0) * Math.PI / 180;
+        const x = Math.cos(rad);
+        const y = Math.sin(rad);
+        vectorArray.set([x, y], i * 2);
+    }
+    return vectorArray;
+}
+export { centigradePlus90ToVectorArray };

package/dist/waveparticles/index.js

@@ -0,0 +1,3 @@
+import VectorFieldWaveParticle from "./plugin";
+import { centigradePlus90ToVectorArray } from "./adaptor";
+export { centigradePlus90ToVectorArray, VectorFieldWaveParticle };