@pirireis/webglobeplugins 0.15.35 → 0.16.1

package/write-text/context-text-bulk.js

@@ -0,0 +1,198 @@
+// @ts-ignore
+import { CSZMode } from "@pirireis/webglobe";
+import { isTextFont, opacityCheck } from "../util/check/typecheck";
+// import { CameraUniformBlockTotem, CameraUniformBlockTotemCache } from "../programs/totems/camerauniformblock";
+// @ts-ignore
+import RBush from 'rbush';
+/**
+ * TODOs:
+ * 1) update all if initials change (propably need a context and a callback to iterate over zPayload)
+ * 2) expose a mechanic to update text on zoom change
+ * 3) extend the mechanic on 2 to other events
+ *
+ * TODO: key check and raise error if doesnt exist
+ */
+const defaultStyle = {
+    textFont: {
+        name: 'Arial',
+        textColor: '#FFFFFF', // beyaz
+        hollowColor: '#000000', // siyah
+        size: 12, // piksel
+        hollow: true,
+        bold: false,
+        italic: false,
+    },
+    opacity: 1.0,
+    zMode: CSZMode.Z_GROUND_PERVERTEX,
+};
+// xOffset = 0,
+// yOffset = 0,
+// doDraw = true,
+// textAdapter = null,
+// coordinatesAdapter = null,
+// keyAdapter = null,
+// opacityAdapter = null,
+// angleAdapter = null,
+// angleOnSphere = false,
+// positionAdapter = (item: any, i: number, container: any[], properties?: any): string => "left",
+class MyRBush extends RBush {
+    toBBox({ long, lat, key }) { return { minX: long, minY: lat, maxX: long, maxY: lat }; }
+    compareMinX(a, b) { return a.long - b.long; }
+    compareMinY(a, b) { return a.lat - b.lat; }
+}
+export class ContextTexBulk {
+    globe;
+    dataMap;
+    style;
+    doDraw;
+    keyAdapter;
+    textAdapter;
+    zoomLevelAdapter;
+    inputZoomAdapter;
+    xOffset;
+    yOffset;
+    // private cameraTotem: CameraUniformBlockTotem;
+    angleOptions;
+    constructor(globe, keyAdapter, textAdapter, zoomLevelAdapter = (zoomLevel) => (item) => {
+        return {
+            opacityMultiplier: 1,
+            sizeMultiplier: 1
+        };
+    }, inputZoomAdapter = (input, zoomLevel) => {
+        return {
+            opacityMultiplier: 1,
+            sizeMultiplier: 1
+        };
+    }, style = defaultStyle, angleOptions = {
+        angleOnSphere: false,
+        angleIsOn: false
+    }, doDraw = true, offset = { x: 0, y: 0 }) {
+        this.globe = globe;
+        this.dataMap = new Map();
+        isTextFont(style.textFont);
+        opacityCheck(style.opacity);
+        this.style = { ...style, textFont: { ...style.textFont } };
+        this.angleOptions = angleOptions;
+        this.doDraw = doDraw;
+        this.angleOptions = angleOptions;
+        this.keyAdapter = keyAdapter;
+        this.textAdapter = textAdapter;
+        this.zoomLevelAdapter = zoomLevelAdapter;
+        this.inputZoomAdapter = inputZoomAdapter;
+        this.xOffset = offset.x;
+        this.yOffset = offset.y;
+        // this.cameraTotem = CameraUniformBlockTotemCache.get(globe);
+    }
+    setDoDraw(bool) {
+        this.doDraw = bool;
+        this.globe.DrawRender();
+    }
+    setStyle(style) {
+        isTextFont(style.textFont);
+        opacityCheck(style.opacity);
+        this.style = { ...style, textFont: { ...style.textFont } };
+        this.globe.DrawRender();
+    }
+    setOpacity(opacity) {
+        this.style.opacity = opacity;
+        this.globe.DrawRender();
+    }
+    draw() {
+        if (!this.doDraw)
+            return;
+        const { globe, style, dataMap, xOffset, yOffset } = this;
+        const { textFont, opacity: opacity_ } = style;
+        const textSize = textFont.size;
+        const is3D = globe.api_GetCurrentGeometry() === 0;
+        const angleIsOn = is3D ? (this.angleOptions.angleIsOn && this.angleOptions.angleOnSphere) : (this.angleOptions.angleIsOn);
+        const bbox = globe.api_GetCurrentWorldLimit();
+        // @ts-ignore
+        const data = dataMap.values();
+        const zoomLevel = globe.api_GetCurrentLODWithDecimal();
+        // const zoomLevel = this.cameraTotem.getApproximatedLOD();
+        const zoomAdapter = this.zoomLevelAdapter(zoomLevel);
+        for (const { input, tree } of data) {
+            const inputZoomResult = this.inputZoomAdapter({ input, tree }.input, zoomLevel);
+            if (inputZoomResult.sizeMultiplier === 0 || inputZoomResult.opacityMultiplier === 0)
+                continue;
+            // @ts-ignore
+            const itemsInBBox = tree.search({ minX: bbox.ll.x, minY: bbox.ll.y, maxX: bbox.ur.x, maxY: bbox.ur.y });
+            const itemsLen = itemsInBBox.length;
+            for (let i = 0; i < itemsLen; i++) {
+                const item = itemsInBBox[i];
+                const { lat, long, text, opacity = null, angle = null, zPayload, position } = item;
+                const { x, y } = globe.api_GetScreenPointFromGeo({
+                    long: long,
+                    lat: lat,
+                    z: 0,
+                }, style.zMode === CSZMode.Z_MSL);
+                const { opacityMultiplier, sizeMultiplier } = zoomAdapter(zPayload);
+                const o = (opacity === null ? opacity_ : opacity * opacity_) * opacityMultiplier * inputZoomResult.opacityMultiplier;
+                textFont.size = sizeMultiplier * textSize * inputZoomResult.sizeMultiplier;
+                textFont.position = position;
+                if (x !== null && y !== null)
+                    globe.api_DrawContextTextMultiLine(text, textFont, o, { x: x + xOffset, y: y - yOffset }, angleIsOn, angle);
+            }
+            textFont.size = textSize;
+        }
+    }
+    insertText(data) {
+        const key = this.keyAdapter(data);
+        const textDatas = this.textAdapter(data);
+        const tree = new MyRBush();
+        // @ts-ignore
+        tree.load(textDatas);
+        this.dataMap.set(key, { input: data, tree });
+        this.globe.DrawRender();
+    }
+    insertTextBulk(inputs) {
+        for (const input of inputs) {
+            const key = this.keyAdapter(input);
+            const textDatas = this.textAdapter(input);
+            const tree = new MyRBush();
+            // @ts-ignore
+            tree.load(textDatas);
+            this.dataMap.set(key, { input, tree });
+        }
+        this.globe.DrawRender();
+    }
+    deleteText(data) {
+        const keys = this.keyAdapter(data);
+        if (this.dataMap.has(keys)) {
+            this.dataMap.delete(keys);
+        }
+        this.globe.DrawRender();
+    }
+    deleteTextBulk(inputs) {
+        for (const input of inputs) {
+            const key = this.keyAdapter(input);
+            this.dataMap.delete(key);
+        }
+        this.globe.DrawRender();
+    }
+    deleteTextByKey(key) {
+        if (this.dataMap.has(key)) {
+            this.dataMap.delete(key);
+        }
+        this.globe.DrawRender();
+    }
+    deleteTextBulkByKey(keys) {
+        for (const key of keys) {
+            this.dataMap.delete(key);
+        }
+        this.globe.DrawRender();
+    }
+    setOffsets(x, y) {
+        this.xOffset = x;
+        this.yOffset = y;
+    }
+    clear() {
+        // @ts-ignore
+        this.dataMap.clear();
+        this.globe.DrawRender();
+    }
+    free() {
+        this.dataMap.clear();
+        // CameraUniformBlockTotemCache.release(this.globe)
+    }
+}

package/Math/frustum/camera.js

@@ -1,24 +0,0 @@
-"use strict";
-// import { WORLD_RADIUS_3D } from '../constants';
-// import { Plane } from '../plane';
-// import { Vector3D } from '../vector3d';
-// import { Quaternion } from '../quaternion';
-// function cameraFrustum(
-//     globe: any,
-//     out: {
-//         near: Plane,
-//         far: Plane,
-//         left: Plane,
-//         right: Plane,
-//         top: Plane,
-//         bottom: Plane
-//     },
-//     fieldOfView: number = 50 // in degrees
-// ): void {
-//     const lookinfo = globe.api_GetCurrentLookInfo();
-//     lookinfo.CenterLong *= Math.PI / 180; // convert degrees to radians
-//     lookinfo.CenterLat *= Math.PI / 180; // convert degrees to radians
-//     const lookAtPosition = Vector3D.fromLongLatRadians(lookinfo.CenterLong, lookinfo.CenterLat);
-//     const cameraPosition = new Vector3D(globe.Fp.x, globe.Fp.y, globe.Fp.z).divideByScaler(WORLD_RADIUS_3D);
-//     return
-// }

package/Math/frustum/from-globeinfo.js

@@ -1,48 +0,0 @@
-"use strict";
-// import { Plane } from "../plane";
-// import { Vector3D } from "../vector3d";
-// import { WORLD_RADIUS_3D } from "../constants";
-// import { Quaternion } from "../quaternion";
-// import { FrustumPlanes } from "./types";
-// const _quaternion = new Quaternion();
-// export function getFrustum(globe: any, fieldOfView: number = 50 * Math.PI / 180,
-//     out: FrustumPlanes): void {
-//     const lookinfo = globe.api_GetCurrentLookInfo();
-//     lookinfo.CenterLong *= Math.PI / 180; // convert degrees to radians
-//     lookinfo.CenterLat *= Math.PI / 180; // convert degrees to radians
-//     lookinfo.NorthAng *= Math.PI / 180; // convert degrees to radians
-//     const lookAtPosition = Vector3D.fromLongLatRadians(lookinfo.CenterLong, lookinfo.CenterLat);
-//     const cameraPosition = new Vector3D(globe.Fp.x, globe.Fp.y, globe.Fp.z).divideByScaler(WORLD_RADIUS_3D);
-//     const lookFromCamera = lookAtPosition.clone().subtract(cameraPosition).normalize();
-//     const cameraZ = new Vector3D(globe.Fu.x, globe.Fu.y, globe.Fu.z);
-//     const cameraY = cameraZ.clone().cross(lookFromCamera).normalize();
-//     const bottomNormal = cameraZ.clone().applyQuaternion(
-//         _quaternion.setFromAxisAngle(cameraY, -fieldOfView)
-//     ).normalize();
-//     const topNormal = cameraZ.clone().applyQuaternion(
-//         _quaternion.setFromAxisAngle(cameraY, fieldOfView)
-//     ).negate().normalize();
-//     const leftNormal = cameraY.clone().applyQuaternion(
-//         _quaternion.setFromAxisAngle(cameraZ, fieldOfView)
-//     ).negate().normalize();
-//     const rightNormal = cameraY.clone().applyQuaternion(
-//         _quaternion.setFromAxisAngle(cameraZ, -fieldOfView)
-//     ).normalize();
-//     out.top.set(topNormal, topNormal.dot(cameraPosition));
-//     out.bottom.set(bottomNormal, bottomNormal.dot(cameraPosition));
-//     out.left.set(leftNormal, leftNormal.dot(cameraPosition));
-//     out.right.set(rightNormal, rightNormal.dot(cameraPosition));
-//     out.far.set(cameraPosition.normalize(), 0.01);
-//     out.near = null; // Near plane is not calculated in this function, set to null
-//     vectorInfo(globe, [out]);
-// }
-// let interval = 0;
-// const vectorInfo = (globe, args: null | Array<any>) => {
-//     interval++;
-//     if (interval % 100 === 0) {
-//         console.log("Fp:", globe.Fp.x / WORLD_RADIUS_3D, globe.Fp.y / WORLD_RADIUS_3D, globe.Fp.z / WORLD_RADIUS_3D);
-//         console.log("Fu:", globe.Fu.x, globe.Fu.y, globe.Fu.z);
-//         if (args) console.log(...args)
-//         interval = 0;
-//     }
-// }

package/Math/frustum/types.js

@@ -1 +0,0 @@
-export {};