@pirireis/webglobeplugins 0.15.34 → 0.16.0

package/util/shaderfunctions/index.js

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

package/util/shaderfunctions/nodata.js

@@ -4,5 +4,7 @@ vec2 vertexIDtoTextureCoordinate(float id, vec2 textureDimentions) {
     float y = floor(id / textureDimentions.x);
     return vec2( x / textureDimentions.x, y / textureDimentions.y);
 }
-`;
-export { vertexIDtoTextureCoordinate };
+`;
+
+
+export {vertexIDtoTextureCoordinate};

package/util/shaderfunctions/noisefunctions.js

@@ -1,8 +1,9 @@
-const permute34 = `` `vec3 permute34(vec3 x) {
+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 waveNoice = ```float waveNoice(vec2 v)
 {
     const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439); 
 
@@ -35,7 +36,9 @@ const waveNoice = `` `float waveNoice(vec2 v)
     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
-};
+}```;
+
+
+export default {
+    permute34, waveNoice
+}

package/util/surface-line-data/arc-bboxes.ts

@@ -0,0 +1,42 @@
+
+
+// function naiveBBox(a: number[], b: number[]): BBox {
+//     return {
+//         minX: Math.min(a[0], b[0]),
+//         minY: Math.min(a[1], b[1]),
+//         maxX: Math.max(a[0], b[0]),
+//         maxY: Math.max(a[1], b[1])
+//     };
+
+// }
+
+
+// function slerp(a: Vector, b: Vector, t: number, theta: number, sinTheta: number): Vector {
+
+// }
+
+
+// function getArcBBoxes(arc: Arc, dotStep: number = 0.025): BBox[] {
+//     const start = arc.start;
+//     const end = arc.end;
+//     const a = [start[0], start[1], start[2]];
+//     const b = [end[0], end[1], end[2]];
+
+
+
+
+//     const theta = Math.acos(a[0] * b[0] + a[1] * b[1] + a[2] * b[2]);
+//     const step = dotStep / theta;
+
+//     if (step >= 1) {
+//         return [naiveBBox(start, end)];
+//     }
+
+
+//     let points = [start] as Vector[];
+
+
+//     let currentStep =
+
+//     return bbox;
+// }

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

@@ -1,50 +1,74 @@
-"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];
-}
+
+
+
+
+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/util/surface-line-data/cut-arc.js

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

package/util/surface-line-data/flow.ts

@@ -0,0 +1,52 @@
+
+
+
+
+// class FlowManager {
+//     _populateCount: number;
+//     _rbush: RBush<any>;
+//     _arcToCutsManager: ArcToCutsManager;
+//     consturctor({ populateCount = 36, dotDistanceOfArcCuts = 1 / Math.pow(2, 10 - 1) }) {
+//         this._populateCount = populateCount;
+
+//         // does the cutting and id mapping(one to many)
+//         // cuts have their bbox ready for rbush
+//         this._rbush = new RBush(1000);
+//         this._arcToCutsManager = new ArcToCutsManager({ dotDistanceOfArcCuts, rbush: this._rbush }); // 10km
+
+//     }
+
+
+
+
+
+//     /**
+//      * adds or updates an arc in the rbush and the cuts manager
+//      */
+//     insertArc(arc: Arc) {
+//         this._arcToCutsManager.insertArc(arc);
+
+//     }
+
+
+
+//     deleteArc(id: Arc['id']) {
+//         this._arcToCutsManager.deleteArc(id);
+//     }
+
+
+//     queryBBox(bbox: BBox) {
+
+//         const arcIDSet = new Set(this._rbush.query(bbox).map(x => x.id)); // sets Of ids of arcs
+
+//         // arcs U bbox => arcs
+
+
+//         // populate points
+//         // return typed array of points belonging to all the arcs of cuts
+//     }
+
+
+
+
+// }

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

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

package/util/surface-line-data/types.ts

@@ -0,0 +1,27 @@
+type BBox = {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    id?: string;
+}
+
+type Point = { lon: number, lat: number };
+type Vector = [number, number, number];  // x y z 
+
+
+type Arc = {
+    id: string;
+    start: number[];
+    end: number[];
+};
+
+
+interface RBUSH {
+    insert: (item: BBox) => void;
+    remove: (item: BBox) => void;
+    search: (bbox: BBox) => BBox[];
+    clear: () => void;
+    all: () => BBox[];
+
+}

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

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

package/util/webglobe/gldefaultstates.js

@@ -1,4 +1,5 @@
-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);
-}
+
+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/util/webglobe/index.js

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

package/util/webglobe/rasteroverlay.js

@@ -1,75 +1,96 @@
-/**
- * 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 };
+/**
+ * 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 };