@pirireis/webglobeplugins 0.13.0-alpha → 0.15.0-alpha

package/range-tools-on-terrain/circle-line-chain/plugin.js

@@ -0,0 +1,388 @@
+import { CircleOnTerrainPlugin } from "../../semiplugins/shape-on-terrain/circle-plugin";
+import { LinePlugin } from "../../semiplugins/lightweight/line-plugin";
+import { ArcOnTerrainPlugin } from "../../semiplugins/shape-on-terrain/arc-plugin";
+import { keyMethod, lineDataAdaptor, arcDataAdaptor, circleDataAdaptor, getOpacity } from "./adapters";
+import { ContextTextWriter3 } from "../../write-text/context-text3";
+import { ChainListMap } from "./chain-list-map";
+import { mapGetOrThrow } from "../../util/check/typecheck";
+const textWriterGetOrThrow = mapGetOrThrow("textWriterIDs is invalid");
+export class CircleLineChainPlugin {
+    id;
+    globe = null;
+    gl = null;
+    circlePlugin = null;
+    linePlugin = null;
+    arcPlugin = null;
+    _freed = false;
+    _opacities;
+    _drawCircleOn = true;
+    _textWritersMap;
+    _textDataPreAdaptor = undefined;
+    _chainListMap;
+    _arcAdaptor = arcDataAdaptor;
+    _lineAdaptor = lineDataAdaptor;
+    _circleAdaptor = circleDataAdaptor;
+    _semiPluginOptions = {
+        circleOnTerrainOptions: {
+            variativeColorsOn: false,
+            defaultColor: [1, 1, 1, 1],
+            defaultHeightFromGroundIn3D: 30,
+        },
+        arcOnTerrainOptions: {
+            flatViewOn: true,
+            globeViewOn: true,
+            variativeColorsOn: false,
+            defaultColor: [1, 1, 1, 1],
+            defaultHeightFromGroundIn3D: 0,
+            vertexCount: 32,
+            cameraAttractionIsOn: true // If true, camera attraction is enabled else evenly distributed arc points are used
+        },
+        lineOptions: {
+            flatViewOn: true,
+            globeViewOn: true,
+            variativeColorsOn: false,
+            defaultColor: [1, 1, 1, 1],
+            dashedLineOpacityVariativeOn: false,
+            dashedLineRatioVariativeOn: false,
+            bufferType: "DYNAMIC_DRAW",
+            opacity: 1.0
+        }
+    };
+    constructor(id, { drawCircleOn, textWritersMap, textDataPreAdaptor, opacities, lineAdaptor, arcAdaptor, circleAdaptor, arcOnTerrainOptions, circleOnTerrainOptions, lineOptions } = {}) {
+        const defaults = {
+            drawCircleOn: true,
+            textWritersMap: new Map(),
+            textDataPreAdaptor: undefined,
+            lineAdaptor: lineDataAdaptor,
+            arcAdaptor: arcDataAdaptor,
+            circleAdaptor: circleDataAdaptor,
+            opacities: {
+                general: 1,
+                circle: null,
+                flatStraightLine: null,
+                flatGreatCircle: null,
+                globeArcFitsTerrain: null,
+                globeArcNotFitsTerrain: null
+            }
+        };
+        const finalOpacities = { ...defaults.opacities, ...opacities };
+        const config = {
+            ...defaults,
+            drawCircleOn: drawCircleOn ?? defaults.drawCircleOn,
+            textWritersMap: textWritersMap ?? defaults.textWritersMap,
+            textDataPreAdaptor: textDataPreAdaptor ?? defaults.textDataPreAdaptor,
+            lineAdaptor: lineAdaptor ?? defaults.lineAdaptor,
+            arcAdaptor: arcAdaptor ?? defaults.arcAdaptor,
+            circleAdaptor: circleAdaptor ?? defaults.circleAdaptor,
+            opacities: finalOpacities
+        };
+        this._semiPluginOptions.circleOnTerrainOptions = {
+            ...this._semiPluginOptions.circleOnTerrainOptions,
+            ...circleOnTerrainOptions
+        };
+        this._semiPluginOptions.arcOnTerrainOptions = {
+            ...this._semiPluginOptions.arcOnTerrainOptions,
+            ...arcOnTerrainOptions
+        };
+        this._semiPluginOptions.lineOptions = {
+            ...this._semiPluginOptions.lineOptions,
+            ...lineOptions
+        };
+        this.id = id;
+        this._drawCircleOn = config.drawCircleOn;
+        this._textWritersMap = config.textWritersMap;
+        this._textDataPreAdaptor = config.textDataPreAdaptor;
+        this._chainListMap = new ChainListMap(keyMethod);
+        this._arcAdaptor = config.arcAdaptor;
+        this._lineAdaptor = config.lineAdaptor;
+        this._circleAdaptor = config.circleAdaptor;
+        this._opacities = config.opacities;
+        this._checktextWritersMap(this._textWritersMap);
+        this._textWritersMap.forEach((writer) => {
+            writer.setKeyAdaptor((v) => v.__identity__);
+        });
+    }
+    // API
+    insertBulk(chains, { textWriterIDs = [] } = {}) {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot insert bulk.");
+            return;
+        }
+        if (chains.length === 0)
+            return;
+        const chainKeys = [];
+        const chainsToClean = [];
+        for (const { chainKey, chainProperties, nodes } of chains) {
+            if (this._chainListMap.hasChain(chainKey)) {
+                chainsToClean.push(chainKey);
+            }
+            this._chainListMap.setChain(chainKey, nodes);
+            this._chainListMap.setChainProperties(chainKey, chainProperties);
+            chainKeys.push(chainKey);
+        }
+        this._cleanChainsFromSemiPlugins(chainsToClean);
+        // Reconstruct chains
+        this._reconstructChains(chainKeys);
+        // Update texts
+        this._updateTexts(chainKeys, textWriterIDs);
+        this.globe?.DrawRender();
+    }
+    addNode(node, chainKey, { theNodeKeyFront, textWriterIDs = [] } = {}) {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot add node.");
+            return;
+        }
+        this._cleanChainsFromSemiPlugins([chainKey]);
+        this._chainListMap.addNode(node, chainKey, theNodeKeyFront);
+        this._reconstructChains([chainKey]);
+        this._updateTexts([chainKey], textWriterIDs);
+        this.globe?.DrawRender();
+    }
+    getChain(chainKey) {
+        return this._chainListMap.getNodes(chainKey);
+    }
+    setDrawCircleOn(value) {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot set drawCircleOn.");
+            return;
+        }
+        this._drawCircleOn = value;
+        this.globe?.DrawRender();
+    }
+    setOpacities(opacities) {
+        // TODO: Check opacities
+        this._opacities = {
+            ...this._opacities,
+            ...opacities
+        };
+        // set Opacities of plugins
+        this.globe?.DrawRender();
+    }
+    deleteChains(chainKeys) {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot delete chains.");
+            return;
+        }
+        for (const chainKey of chainKeys) {
+            const keys = this._chainListMap.deleteChainAndReturnChainKeys(chainKey);
+            if (keys.length <= 1) {
+                console.warn("No chains were deleted, chainKeys might be invalid.");
+                return;
+            }
+            keys.pop(); // Remove the last key which which is destination of the last circle
+            this.linePlugin?.deleteBulk(keys);
+            this.arcPlugin?.deleteBulk(keys);
+            this.circlePlugin?.deleteBulk(keys);
+            this._updateTexts(chainKeys, Array.from(this._textWritersMap.keys()));
+        }
+    }
+    deleteNodes(keysAndNodes, { textWriterIDs = [] } = {}) {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot delete nodes.");
+            return;
+        }
+        const chainKeysToReconstruct = [];
+        keysAndNodes.forEach(({ chainKey, nodeKeys }) => {
+            this._chainListMap.deleteNodesBelongToAChain(chainKey, nodeKeys);
+            chainKeysToReconstruct.push(chainKey);
+        });
+        this._cleanChainsFromSemiPlugins(chainKeysToReconstruct);
+        this._reconstructChains(chainKeysToReconstruct);
+        this._updateTexts(chainKeysToReconstruct, textWriterIDs);
+        this.globe?.DrawRender();
+    }
+    updateNodesProperties(chainKey, nodesAndPropertyMap, { textWriterIDs = [] } = {}) {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot update nodes properties.");
+            return;
+        }
+        this._chainListMap.updateNodesProperties(chainKey, nodesAndPropertyMap);
+        this._cleanChainsFromSemiPlugins([chainKey]);
+        this._reconstructChains([chainKey]);
+        this._updateTexts([chainKey], textWriterIDs);
+        this.globe?.DrawRender();
+    }
+    updateCoordinatesBulk(chains, { textWriterIDs = [] } = {}) {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot update coordinates.");
+            return;
+        }
+        const chainKeys = [];
+        for (const chain of chains) {
+            const { chainKey, nodes } = chain;
+            chainKeys.push(chainKey);
+            nodes.forEach((node, index) => {
+                this._chainListMap.updateCoordsinatesOfNode(node, chainKey);
+            });
+        }
+        this._updateTexts(chainKeys, textWriterIDs);
+        this._reconstructChains(chainKeys);
+    }
+    updateNodeCoordinates(node, chainKey, { textWriterIDs = [] } = {}) {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot update node coordinates.");
+            return;
+        }
+        this._chainListMap.updateCoordsinatesOfNode(node, chainKey);
+        if (textWriterIDs && textWriterIDs.length > 0) {
+            this._updateTexts([chainKey], textWriterIDs);
+        }
+        this._reconstructChains([chainKey]);
+        this.globe?.DrawRender();
+    }
+    updateChainProperties(chainKey, properties) {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot update chain properties.");
+            return;
+        }
+        this._chainListMap.updateChainProperties(chainKey, properties);
+        this._cleanChainsFromSemiPlugins([chainKey]);
+        this._reconstructChains([chainKey]);
+        this._updateTexts([chainKey], Array.from(this._textWritersMap.keys()));
+        this.globe?.DrawRender();
+    }
+    updateText(textWriterIDs, chainKeys = null) {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot update text.");
+            return;
+        }
+        if (!chainKeys) {
+            chainKeys = Array.from(this._chainListMap.getAllChainKeysIterator());
+        }
+        this._updateTexts(chainKeys, textWriterIDs);
+        this.globe?.DrawRender();
+    }
+    // IMPLICIT METHODS
+    _checktextWritersMap(textWritersMap) {
+        if (!(textWritersMap instanceof Map))
+            throw new Error("textWritersMap is not an instance of Map");
+        textWritersMap.forEach((v) => {
+            if (!(v instanceof ContextTextWriter3))
+                throw new Error("textWritersMap element is not an instance of ContextTextWriter3");
+        });
+    }
+    _updateTexts(chainKeys, textWriterIDs) {
+        if (textWriterIDs.length === 0)
+            return;
+        const textWriters = textWriterGetOrThrow(this._textWritersMap, textWriterIDs);
+        chainKeys.forEach((chainKey) => {
+            this._chainListMap.textUpdate(chainKey, textWriters, this._textDataPreAdaptor);
+        });
+    }
+    _cleanChainsFromSemiPlugins(chainKeys) {
+        if (!this.globe || !this.gl) {
+            throw new Error("Globe or WebGL context is not initialized");
+        }
+        for (const chainKey of chainKeys) {
+            // Clean chains from text writers
+            const nodeKeys = this._chainListMap.getNodeKeysOfChain(chainKey);
+            nodeKeys.pop(); // Remove the last key which is destination of the last circle
+            this.circlePlugin?.deleteBulk(nodeKeys);
+            this.linePlugin?.deleteBulk(nodeKeys);
+            this.arcPlugin?.deleteBulk(nodeKeys);
+        }
+    }
+    _reconstructChains(chainKeys) {
+        // TODO: this is core
+        // Get chain nodes
+        const globe = this.globe;
+        if (!globe || !this.gl) {
+            throw new Error("Globe or WebGL context is not initialized");
+        }
+        for (let chainKey of chainKeys) {
+            const chain = this._chainListMap.getChain(chainKey);
+            if (!chain) {
+                console.warn(`Chain with key ${chainKey} not found.`);
+                continue;
+            }
+            const lineInput = this._lineAdaptor(chain);
+            const arcInput = this._arcAdaptor(chain);
+            const circleInput = this._circleAdaptor(globe, chain);
+            this.linePlugin?.insertBulk(lineInput);
+            this.arcPlugin?.insertBulk(arcInput);
+            this.circlePlugin?.insertBulk(circleInput);
+        }
+    }
+    // GLOBE INTERFACE METHODS
+    init(globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+        // Initialize sub-plugins with unique IDs
+        this.circlePlugin = new CircleOnTerrainPlugin(`${this.id}_unregistered_circles`, this._semiPluginOptions.circleOnTerrainOptions);
+        this.linePlugin = new LinePlugin(`${this.id}_unregistered_lines`, this._semiPluginOptions.lineOptions);
+        this.arcPlugin = new ArcOnTerrainPlugin(`${this.id}_unregistered_arcs`, this._semiPluginOptions.arcOnTerrainOptions);
+        this.circlePlugin.init(globe, gl);
+        this.linePlugin.init(globe, gl);
+        this.arcPlugin.init(globe, gl);
+    }
+    draw3D() {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot draw.");
+            return;
+        }
+        const { globe, gl } = this;
+        if (!globe || !gl) {
+            console.warn("Globe or WebGL context is not initialized, cannot draw.");
+            return;
+        }
+        const circleOpacity = getOpacity(this._opacities, "circle");
+        if (this._drawCircleOn && circleOpacity !== 0) {
+            this.circlePlugin?.setPluginOpacity(circleOpacity);
+            this.circlePlugin?.draw3D();
+        }
+        const currentGeometry = globe.api_GetCurrentGeometry();
+        switch (currentGeometry) {
+            case 0: {
+                // globe view
+                const lineOpacity = getOpacity(this._opacities, "globeArc");
+                if (lineOpacity !== 0) {
+                    this.linePlugin?.setPluginOpacity(lineOpacity);
+                    this.linePlugin?.draw3D();
+                }
+                const arcOpacity = getOpacity(this._opacities, "globeArcFitsTerrain");
+                if (arcOpacity !== 0) {
+                    this.arcPlugin?.setPluginOpacity(arcOpacity);
+                    this.arcPlugin?.draw3D();
+                }
+                break;
+            }
+            case 1: {
+                // flat view
+                const lineOpacity = getOpacity(this._opacities, "flatStraightLine");
+                if (lineOpacity !== 0) {
+                    this.linePlugin?.setPluginOpacity(lineOpacity);
+                    this.linePlugin?.draw3D();
+                }
+                const arcOpacity = getOpacity(this._opacities, "flatGreatCircleLine");
+                if (arcOpacity !== 0) {
+                    this.arcPlugin?.setPluginOpacity(arcOpacity);
+                    this.arcPlugin?.draw3D();
+                }
+                break;
+            }
+            default: {
+                throw new Error("Unknown geometry type, Implementation need on Circle-Line-Chain Plugin");
+            }
+        }
+        this._textWritersMap.forEach((writer) => {
+            writer.draw();
+        });
+    }
+    free() {
+        if (this._freed)
+            return;
+        this._freed = true;
+        // Free sub-plugins
+        this.circlePlugin?.free();
+        this.linePlugin?.free();
+        this.arcPlugin?.free();
+        // Clear text writers map
+        this._textWritersMap.clear();
+        // Clear references
+        this.globe = null;
+        this.gl = null;
+        this.circlePlugin = null;
+        this.linePlugin = null;
+        this.arcPlugin = null;
+    }
+}

package/range-tools-on-terrain/circle-line-chain/types.js

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

package/range-tools-on-terrain/range-ring/adapters.js

@@ -0,0 +1,25 @@
+// export const rangeRingToPaddingInputAdapter = () => (rangeRing: RangeRingInput): PaddingInput => {
+//     return {
+//         key: rangeRing.key,
+//         center: [rangeRing.long, rangeRing.lat],
+//         radius: rangeRing.radius,
+//         color: rangeRing.rgba as Color,
+//         altitude: rangeRing.altitude,
+//     };
+// }
+export const rangeRingToCircleInputAdapter = (rangeRing) => {
+    return rangeRing.rings.map(ring => ({
+        key: ring.rindID,
+        center: [rangeRing.long, rangeRing.lat],
+        radius: ring.radius,
+        color: rangeRing.rgba,
+        altitude: rangeRing.altitude,
+    }));
+};
+function rangeRingToPaddingsCoordinatesAdapter(globe, center, rangeRing, startAngle, stepAngle) {
+    return new Float32Array();
+}
+export const rangeRingToArcInputAdapter = (globe, rangeRing) => {
+    // TODO;
+    return [];
+};

package/range-tools-on-terrain/range-ring/plugin.js

@@ -0,0 +1,31 @@
+import { CircleOnTerrainPlugin } from "../../semiplugins/shape-on-terrain/circle-plugin";
+import { ArcOnTerrainPlugin } from "../../semiplugins/shape-on-terrain/arc-plugin";
+import { LinePlugin } from "../../semiplugins/lightweight/line-plugin";
+// @ts-ignore
+export class RangeRingPlugin {
+    id;
+    globe = null;
+    gl = null;
+    circlePlugin;
+    arcPlugin;
+    linePlugin;
+    _memory = new Map();
+    constructor(id) {
+        this.id = id;
+        this.circlePlugin = new CircleOnTerrainPlugin(this.id + "-circle");
+        this.arcPlugin = new ArcOnTerrainPlugin(this.id + "-arc", {
+            vertexCount: 5,
+        });
+        this.linePlugin = new LinePlugin(this.id + "-line");
+    }
+    insertBulk(items) {
+    }
+    _build() {
+    }
+    init(globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+    }
+    draw3D() {
+    }
+}

package/range-tools-on-terrain/range-ring/types.js

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

package/rangerings/plugin.js

@@ -28,7 +28,7 @@ import { centerCoords2dflatDataCreatorWithRadius, CircleCache as CircleCache2D }
 import { CircleCache as CircleCache3D } from "../programs/line-on-globe/circle-accurate-3d";
 import { LinesColorInstancedFlatCache } from "../programs/line-on-globe/lines-color-instanced-flat";
 import { BufferOrchestrator, BufferManager } from "../util/account";
-import { mapGetOrThrow } from "../util/check/get";
+// import { mapGetOrThrow } from "../util/check/get";
 import { populateFloat32Array } from "../util/jshelpers/data-filler";
 import { RingAccount, ringBigPaddingKeyMethod, ringKeyMethod } from "./ring-account";
 import { CirclePadding3DCache } from "../programs/line-on-globe/degree-padding-around-circle-3d";
@@ -36,13 +36,9 @@ import { LineOnGlobeCache } from '../programs/line-on-globe/naive-accurate-flexi
 import RangeRingAngleText from "./rangeringangletext";
 import { Z_ALPHA_MODE } from "../programs/line-on-globe/util";
 import { ENUM_HIDE } from "./enum";
-import { opacityCheck, constraintFloat } from "../util/check/typecheck";
-import { normalize } from "../util/geometry";
+import { opacityCheck, mapGetOrThrow } from "../util/check/typecheck";
+import { sphereCoord } from "../util/geometry/index";
 const CIRCLE_FLAT_EDGE_COUNT = 362; // 360 + 2 for closing the circle and a cutting point
-const coordOnSphere = (long, lat, globe, altitude = 0) => {
-    const coord = globe.api_GetCartesian3DPoint(long, lat, 0, 0);
-    return normalize(coord, 6378.137 + altitude);
-};
 /**
  *
  *
@@ -395,8 +391,8 @@ class RangeRings {
                     key: ringBigPaddingKeyMethod(centerID, ringID, azimuthAngle),
                     circlePoint2d: new Float32Array(globe.api_GetMercator2DPoint(circlePoint.long, circlePoint.lat)),
                     paddingPoint2d: new Float32Array(globe.api_GetMercator2DPoint(paddingPoint.long, paddingPoint.lat)),
-                    circlePoint3d: coordOnSphere(circlePoint.long, circlePoint.lat, globe, altitude / 1000),
-                    paddingPoint3d: coordOnSphere(paddingPoint.long, paddingPoint.lat, globe, altitude / 1000),
+                    circlePoint3d: sphereCoord(circlePoint.long, circlePoint.lat, globe, altitude / 1000),
+                    paddingPoint3d: sphereCoord(paddingPoint.long, paddingPoint.lat, globe, altitude / 1000),
                     rgba: color,
                     hide,
                     textHide
@@ -412,14 +408,14 @@ class RangeRings {
         if (centerItem === undefined)
             throw new Error("Center not found");
         const { long, lat, rgba, rings, hide = 0, textHide = 0, altitude: centralAltitude = 0 } = centerItem;
-        const centerCoords3d = coordOnSphere(long, lat, globe, centralAltitude / 1000);
+        const centerCoords3d = sphereCoord(long, lat, globe, centralAltitude / 1000);
         const result = [];
         for (const { ringID, radius, padding, __identity__, altitude = centralAltitude } of rings) {
             const key = __identity__;
             const centerCoords2dflat = centerCoords2dflatDataCreatorWithRadius(globe, long, lat, radius, { edgeCount: CIRCLE_FLAT_EDGE_COUNT });
             const radiusPadding = hide === ENUM_HIDE.HIDE_1_DEGREE_PADDINGS ? radius : radius - padding / 3;
             const targetPoint = globe.Math.FindPointByPolar(long, lat, radius, 0); // long lat
-            const targetCoords3d = coordOnSphere(targetPoint.long, targetPoint.lat, globe, altitude / 1000);
+            const targetCoords3d = sphereCoord(targetPoint.long, targetPoint.lat, globe, altitude / 1000);
             const centerCoords2dflatForPadding = centerCoords2dflatDataCreatorWithRadius(globe, long, lat, radiusPadding, { edgeCount: CIRCLE_FLAT_EDGE_COUNT });
             result.push({
                 key,