@pirireis/webglobeplugins 0.15.34 → 0.16.0

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

@@ -0,0 +1,607 @@
+import { Chain, Node, StyleProperties, Opacities } from "./types";
+
+import { CircleOnTerrainPlugin, CircleInput, CircleOnTerrainPluginOptions } from "../../semiplugins/shape-on-terrain/circle-plugin";
+import { LinePlugin, LineInput, LinePluginOptions } from "../../semiplugins/lightweight/line-plugin";
+import { ArcOnTerrainPlugin, ArcInput, ArcOnTerrainPluginOptions } from "../../semiplugins/shape-on-terrain/arc-plugin";
+
+
+import { keyMethod, lineDataAdaptor, arcDataAdaptor, circleDataAdaptor, getOpacity, nodeKeysFromChain } from "./adapters";
+
+import { Globe, DrawRangeIndexParams, PluginInterface, Color } from "../../types";
+import { ContextTextWriter3 } from "../../write-text/context-text3";
+import { ChainListMap } from "./chain-list-map";
+import { opacityCheck, mapGetOrThrow } from "../../util/check/typecheck";
+
+
+const textWriterGetOrThrow = mapGetOrThrow("textWriterIDs is invalid");
+
+export type DrawSemiPluginDraw = {
+    circleOn: boolean;
+    arcOn: boolean;
+    line: boolean;
+};
+
+
+export class CircleLineChainPlugin implements PluginInterface {
+    id: string;
+    globe: Globe | null = null;
+    gl: WebGL2RenderingContext | null = null;
+    circlePlugin: CircleOnTerrainPlugin | null = null;
+    linePlugin: LinePlugin | null = null;
+    arcPlugin: ArcOnTerrainPlugin | null = null;
+
+    private _freed: boolean = false;
+    private _opacities: Opacities;
+    private _drawCircleOn: boolean = true;
+    private _textWritersMap: Map<string, ContextTextWriter3>;
+    private _textDataPreAdaptor: ((item: Node, index: number, nodes: Node[]) => any) | undefined = undefined;
+    private _chainListMap: ChainListMap;
+    private _semiPluginOptions: {
+        circleOnTerrainOptions: Partial<CircleOnTerrainPluginOptions>;
+        arcOnTerrainOptions: Partial<ArcOnTerrainPluginOptions>;
+        lineOptions: Partial<LinePluginOptions>;
+    } = {
+            circleOnTerrainOptions: {
+                variativeColorsOn: false,
+                defaultColor: [1, 1, 1, 1],
+                defaultHeightFromGroundIn3D: 30,
+                isMSL: false
+            },
+            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
+                isMSL: false, // If true, no elevation of terrain
+
+            },
+            lineOptions: {
+                flatViewOn: true,
+                globeViewOn: true,
+                variativeColorsOn: false,
+                defaultColor: [1, 1, 1, 1],
+                dashedLineOpacityVariativeOn: false,
+                dashedLineRatioVariativeOn: false,
+                bufferType: "DYNAMIC_DRAW",
+                opacity: 1.0,
+
+            }
+        }
+
+    constructor(id: string, {
+        drawCircleOn,
+        textWritersMap,
+        textDataPreAdaptor,
+        opacities,
+        arcOnTerrainOptions,
+        circleOnTerrainOptions,
+        lineOptions
+    }: {
+        drawCircleOn?: boolean;
+        textWritersMap?: Map<string, ContextTextWriter3>;
+        textDataPreAdaptor?: (item: Node, index: number, nodes: Node[]) => any | null;
+        opacities?: Opacities;
+        arcOnTerrainOptions?: Partial<ArcOnTerrainPluginOptions>;
+        circleOnTerrainOptions?: Partial<CircleOnTerrainPluginOptions>;
+        lineOptions?: Partial<LinePluginOptions>;
+    } = {}) {
+        const defaults = {
+            drawCircleOn: true,
+            textWritersMap: new Map<string, ContextTextWriter3>(),
+            textDataPreAdaptor: undefined,
+            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,
+            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._opacities = config.opacities;
+
+        this._checktextWritersMap(this._textWritersMap);
+        this._textWritersMap.forEach((writer) => {
+            writer.setKeyAdaptor((v: any) => v.__identity__);
+        });
+    }
+
+
+    // API
+
+    insertBulk(chains: Chain[], { textWriterIDs = [] }: { textWriterIDs?: string[] } = {}): void {
+        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._cleanChainsFromSemiPlugins(chainsToClean);
+
+        for (const { chainKey, chainProperties, nodes } of chains) {
+            if (!chainKey || !chainProperties || !nodes || nodes.length === 0) {
+                console.warn("Invalid chain data, skipping insertion.");
+                continue;
+            }
+            this._chainListMap.setChain(chainKey, nodes);
+            this._chainListMap.setChainProperties(chainKey, chainProperties);
+            chainKeys.push(chainKey);
+        }
+
+        // Reconstruct chains
+        this._reconstructChains(chainKeys);
+
+        // Update texts
+        this._updateTexts(chainKeys, textWriterIDs);
+        this.globe?.DrawRender();
+    }
+
+
+    addNode(node: Node, chainKey: string, { theNodeKeyFront, textWriterIDs = [] }: { theNodeKeyFront?: undefined | string, textWriterIDs?: string[] } = {}): void {
+        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: string): Node[] | undefined {
+        return this._chainListMap.getNodes(chainKey);
+    }
+
+
+    setDrawCircleOn(value: boolean): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot set drawCircleOn.");
+            return;
+        }
+        this._drawCircleOn = value;
+        this.globe?.DrawRender();
+    }
+
+
+
+    setOpacities(opacities: Partial<Opacities>): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot set opacities.");
+            return;
+        }
+        this._opacities = {
+            ...this._opacities,
+            ...opacities
+        };
+        this.globe?.DrawRender();
+    }
+
+
+    setElevationMode(mode: "msl" | "agl"): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot set elevation mode.");
+            return;
+        }
+        this.arcPlugin?.setElevationMode(mode);
+        this.circlePlugin?.setElevationMode(mode);
+
+        this.globe?.DrawRender();
+    }
+
+
+
+    deleteChains(chainKeys: string[]): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot delete chains.");
+            return;
+        }
+        // type check chainKeys
+        if (!Array.isArray(chainKeys) || chainKeys.some(key => typeof key !== "string")) {
+            console.warn("Invalid chainKeys array.");
+            return;
+        }
+
+        for (const chainKey of chainKeys) {
+            const keys = this._chainListMap.deleteChainAndReturnChainKeys(chainKey, this._textWritersMap);
+            if (keys.length <= 1) {
+                console.warn(`Deleted chain ${chainKey}, was too small to be displayed.`);
+                continue;
+            }
+            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()));
+        }
+        this.globe?.DrawRender();
+    }
+
+
+    deleteNodes(keysAndNodes: Array<{
+        chainKey: string;
+        nodeKeys: string[];
+    }>): void {
+
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot delete nodes.");
+            return;
+        }
+        const chainKeysToReconstruct: string[] = keysAndNodes.map(({ chainKey }) => chainKey);
+        // this._chainListMap.deleteTexts(chainKeysToReconstruct, this._textWritersMap); // TODO: delete this method from chain-list-map
+        this._cleanChainsFromSemiPlugins(chainKeysToReconstruct);
+        keysAndNodes.forEach(({ chainKey, nodeKeys }) => {
+            this._chainListMap.deleteNodesBelongToAChain(chainKey, nodeKeys);
+        });
+        this._reconstructChains(chainKeysToReconstruct);
+        this._updateTexts(chainKeysToReconstruct, Array.from(this._textWritersMap.keys()));
+
+        this.globe?.DrawRender();
+    }
+
+
+    updateNodesProperties(chainKey: string,
+        nodesAndPropertyList: Pick<Node, "key" | "circleProperties" | "lineProperties" | "circleOn" | "arcOn" | "lineOn">[],
+        { textWriterIDs = [] }: { textWriterIDs?: string[] } = {}): void {
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot update nodes properties.");
+            return;
+        }
+        const hasChain = this._chainListMap.hasChain(chainKey);
+        if (!hasChain) {
+            console.warn(`Chain with key ${chainKey} not found.`);
+            return;
+        }
+        this._chainListMap.updateNodesProperties(chainKey, nodesAndPropertyList);
+        this._cleanChainsFromSemiPlugins([chainKey]);
+        this._reconstructChains([chainKey]);
+        this._updateTexts([chainKey], textWriterIDs);
+        this.globe?.DrawRender();
+    }
+
+
+    updateChainDrawOptionsProperties(chainKey: string,
+        drawOptions: Partial<DrawSemiPluginDraw>,
+    ): void {
+
+        if (this._freed) {
+            console.warn("CircleLineChainPlugin is freed, cannot update chain draw options properties.");
+            return;
+        }
+
+        const chain = this._chainListMap.getChain(chainKey);
+        if (!chain) {
+            console.warn(`Chain with key ${chainKey} not found.`);
+            return;
+        }
+        const { nodes } = chain;
+        nodes.forEach((node) => {
+            if (drawOptions.circleOn !== undefined) {
+                node.circleOn = drawOptions.circleOn;
+            }
+            if (drawOptions.arcOn !== undefined) {
+                node.arcOn = drawOptions.arcOn;
+            }
+            if (drawOptions.line !== undefined) {
+                node.lineOn = drawOptions.line;
+            }
+        });
+
+        this._cleanChainsFromSemiPlugins([chainKey]);
+        this._reconstructChains([chainKey]);
+        this._updateTexts([chainKey], Array.from(this._textWritersMap.keys()));
+        this.globe?.DrawRender();
+    }
+
+
+
+    updateCoordinatesBulk(chains: Pick<Chain, "chainKey" | "nodes">[], { textWriterIDs = [] }: { textWriterIDs?: string[] } = {}): void {
+        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: Pick<Node, "key" | "lat" | "long">,
+        chainKey: string,
+        { textWriterIDs = [] }: { textWriterIDs?: string[] } = {}
+    ) {
+        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: string, properties: Map<string, any>): void {
+        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: string[], chainKeys: string[] | null = null): void {
+        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();
+    }
+
+
+    setDefaultSemiPluginColor(
+        semiPluginName: "circleOnTerrain" | "arcOnTerrain" | "line" | "ALL",
+        color: Color
+    ) {
+
+        if (semiPluginName === "ALL") {
+            this._semiPluginOptions.circleOnTerrainOptions.defaultColor = color;
+            this._semiPluginOptions.arcOnTerrainOptions.defaultColor = color;
+            this._semiPluginOptions.lineOptions.defaultColor = color;
+            this.circlePlugin?.setDefaultColor(color);
+            this.arcPlugin?.setDefaultColor(color);
+            this.linePlugin?.setDefaultColor(color);
+            return;
+        }
+        switch (semiPluginName) {
+            case "circleOnTerrain":
+                this._semiPluginOptions.circleOnTerrainOptions.defaultColor = color;
+                this.circlePlugin?.setDefaultColor(color);
+                break;
+            case "arcOnTerrain":
+                this._semiPluginOptions.arcOnTerrainOptions.defaultColor = color;
+                this.arcPlugin?.setDefaultColor(color);
+                break;
+            case "line":
+                this._semiPluginOptions.lineOptions.defaultColor = color;
+                this.linePlugin?.setDefaultColor(color);
+                break;
+            default:
+                throw new Error(`Unknown semi-plugin name: ${semiPluginName}`);
+        }
+    }
+    // IMPLICIT METHODS
+
+
+    _checktextWritersMap(textWritersMap: Map<string, ContextTextWriter3>): void {
+        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: string[], textWriterIDs: string[]): void {
+        if (textWriterIDs.length === 0) return;
+        const textWriters = textWriterGetOrThrow(this._textWritersMap, textWriterIDs)
+        chainKeys.forEach((chainKey) => {
+            this._chainListMap.textUpdate(chainKey, textWriters, this._textDataPreAdaptor);
+        });
+    }
+
+
+
+
+    _cleanChainsFromSemiPlugins(chainKeys: string[]): void {
+        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);
+            this._textWritersMap.forEach((writer) => {
+                writer.deleteTextBulk(nodeKeys);
+            });
+            nodeKeys.pop(); // Remove the last key which is destination of the last circle
+            // Clean chains from semi-plugins
+            this.circlePlugin?.deleteBulk(nodeKeys);
+            this.linePlugin?.deleteBulk(nodeKeys);
+            this.arcPlugin?.deleteBulk(nodeKeys);
+        }
+    }
+
+
+
+    _reconstructChains(chainKeys: string[]): void {
+        // TODO: this is core
+        // Get chain nodes
+        const globe = this.globe as 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 = lineDataAdaptor(chain);
+            const arcInput = arcDataAdaptor(chain);
+            const circleInput = circleDataAdaptor(globe, chain);
+            this.linePlugin?.insertBulk(lineInput);
+            this.arcPlugin?.insertBulk(arcInput);
+            this.circlePlugin?.insertBulk(circleInput);
+
+        }
+    }
+
+
+
+
+    // GLOBE INTERFACE METHODS
+
+    init(globe: Globe, gl: WebGL2RenderingContext): void {
+        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(): void {
+        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, false);
+            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, false);
+                    this.linePlugin?.draw3D();
+                }
+                const arcOpacity = getOpacity(this._opacities, "globeArcFitsTerrain");
+                if (arcOpacity !== 0) {
+                    this.arcPlugin?.setPluginOpacity(arcOpacity, false);
+                    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(): void {
+        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.ts

@@ -0,0 +1,43 @@
+import { Color } from "../../types";
+
+interface Node {
+    key: string;
+    long: number;
+    lat: number;
+    __identity__?: string; // TODO: remove this property.. It is the result of keyMethod. Same for adaptors
+    circleProperties?: Record<string, any>;
+    lineProperties?: Record<string, any>;
+    circleOn: boolean;
+    lineOn: boolean;
+    arcOn: boolean;
+}
+
+type Chain = {
+    chainKey: string;
+    chainProperties: StyleProperties;
+    nodes: Node[];
+};
+
+
+type StyleProperties = {
+    rgba?: Color;
+    altitude?: number; // Is this implemented
+    msl?: boolean | null | undefined; // This is a new property to control whether the chain is drawn in MSL or not
+}
+
+type Opacities = {
+    general?: number;
+    circle?: number | null;
+    flatStraightLine?: number | null;
+    flatGreatCircleLine?: number | null;
+    globeArcFitsTerrain?: number | null;
+    globeArc?: number | null;
+}
+
+
+export {
+    Node,
+    Chain,
+    StyleProperties,
+    Opacities
+}