@pirireis/webglobeplugins 0.13.0-alpha → 0.14.0-alpha

package/range-tools-on-terrain/bearing-line/plugin.js

@@ -0,0 +1,360 @@
+import { ContextTextWriter3 } from "../../write-text/context-text3";
+import { flatLinesInputAdapter, flatLinesBearingInputAdapter, bearingLineToCircleInputAdapter, bearingLineToArcInputAdapter, bearingLineToBearingArcInputAdapter, bearingLineToPieceOfPieInputAdapter, pieceOfPieOpacityAdaptor } from "./adapters";
+import { CircleOnTerrainPlugin } from "../../semiplugins/shape-on-terrain/circle-plugin";
+import { PieceOfPiePlugin } from "../../semiplugins/lightweight/piece-of-pie-plugin";
+import { ArcOnTerrainPlugin } from "../../semiplugins/shape-on-terrain/arc-plugin";
+import { LinePlugin } from "../../semiplugins/lightweight/line-plugin";
+export class BearingLinePlugin {
+    id;
+    globe = null;
+    circlePlugin;
+    arcPlugin;
+    arcPluginBL;
+    pieceOfPiePlugin;
+    linePlugin;
+    linePluginBL;
+    _freed = false;
+    _opacities = {
+        general: 1,
+        circle: 1,
+        arc: 1,
+        pie: 1,
+        bearing: 1
+    };
+    _textWritersMap = new Map();
+    _textDataPreAdaptor = (item) => item;
+    drawOptions = {
+        drawVRM: true,
+        drawBearingLine: true,
+        drawAngleRing: true,
+        drawText: true,
+        flatRealLineOn: true, // This is a new option to control flat real line drawing
+        flatStraightLineOn: true // This is a new option to control flat straight line drawing
+    };
+    _memory = new Map();
+    constructor(id, { textWritersMap, textDataPreAdaptor, opacities, drawOptions, } = {}) {
+        this.id = id;
+        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");
+        });
+        this._textWritersMap = textWritersMap || new Map();
+        this._textWritersMap.forEach((writer) => writer.setKeyAdaptor((item) => item.key));
+        this._textDataPreAdaptor = textDataPreAdaptor || ((item) => item);
+        this.circlePlugin = new CircleOnTerrainPlugin(id + "_circle", {
+            variativeColorsOn: true,
+        });
+        this.arcPlugin = new ArcOnTerrainPlugin(id + "_arc", {
+            variativeColorsOn: true,
+        });
+        this.arcPluginBL = new ArcOnTerrainPlugin(id + "_arcBL", {
+            variativeColorsOn: true,
+        });
+        this.pieceOfPiePlugin = new PieceOfPiePlugin(id + "_pieceOfPie", {
+            bufferType: "DYNAMIC_DRAW",
+        });
+        this.linePlugin = new LinePlugin(id + "_line", {
+            variativeColorsOn: true,
+            bufferType: "DYNAMIC_DRAW",
+        });
+        this.linePluginBL = new LinePlugin(id + "_lineBL", {
+            variativeColorsOn: true,
+            bufferType: "DYNAMIC_DRAW",
+        });
+        if (opacities) {
+            this._opacities = {
+                ...this._opacities,
+                ...opacities,
+            };
+        }
+        if (drawOptions) {
+            this.drawOptions = {
+                ...this.drawOptions,
+                ...drawOptions
+            };
+        }
+    }
+    setDoDrawVRM(drawVRM) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot set draw VRM.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot set draw VRM.");
+        }
+        this.drawOptions.drawVRM = drawVRM;
+        this.globe.DrawRender();
+    }
+    setDoDrawText(drawText) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot set draw text.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot set draw text.");
+        }
+        this.drawOptions.drawText = drawText;
+        this.globe.DrawRender();
+    }
+    setDoDrawBearingLine(drawBearingLine) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot set draw bearing line.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot set draw bearing line.");
+        }
+        this.drawOptions.drawBearingLine = drawBearingLine;
+        this.globe.DrawRender();
+    }
+    setDoDrawAngleRing(drawAngleRing) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot set draw angle ring.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot set draw angle ring.");
+        }
+        this.drawOptions.drawAngleRing = drawAngleRing;
+        this.globe.DrawRender();
+    }
+    // TODO:
+    updatePartial(items, { textWriterIDs } = {}) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot update item.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot update item.");
+        }
+        const fixedItems = [];
+        for (const item of items) {
+            if (!this._memory.has(item.key)) {
+                throw new Error(`Item with key ${item.key} not found in memory.`);
+            }
+            fixedItems.push(this.__memorizeItem(item));
+        }
+        this._build(fixedItems, { textWriterIDs });
+    }
+    setDrawOptions(drawOptions) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot set draw options.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot set draw options.");
+        }
+        this.drawOptions = {
+            ...this.drawOptions,
+            ...drawOptions
+        };
+        this.globe.DrawRender();
+    }
+    updateCoordinatesBulk(items, { textWriterIDs } = {}) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot update coordinates.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot update coordinates.");
+        }
+        const fixedItems = [];
+        for (const item of items) {
+            if (!this._memory.has(item.key)) {
+                throw new Error(`Item with key ${item.key} not found in memory.`);
+            }
+            else {
+                fixedItems.push(this.__memorizeItem(item));
+            }
+        }
+        this._build(fixedItems, { textWriterIDs });
+    }
+    setOpacities(opacities) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot set opacities.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot set opacities.");
+        }
+        this._opacities = {
+            ...this._opacities,
+            ...opacities,
+        };
+        this.globe.DrawRender();
+    }
+    insertBulk(items, { textWriterIDs } = {}) {
+        this._build(items, { textWriterIDs });
+    }
+    deleteBulk(keys) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot delete items.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot delete items.");
+        }
+        if (!this.circlePlugin || !this.arcPlugin) {
+            throw new Error("Circle and Arc plugins are not initialized.");
+        }
+        this.circlePlugin.deleteBulk(keys);
+        this.arcPlugin.deleteBulk(keys);
+        this.arcPluginBL.deleteBulk(keys);
+        this.pieceOfPiePlugin.deleteBulk(keys);
+        this.linePlugin.deleteBulk(keys);
+        this.linePluginBL.deleteBulk(keys);
+        this.__deleteTexts(keys);
+        this.globe.DrawRender();
+    }
+    updateText(textWriterIDs, itemKeys = null) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot update text.");
+        }
+        const items = itemKeys ? itemKeys.map(key => this._memory.get(key)).filter(Boolean) : Array.from(this._memory.values());
+        this.__insertTexts(items, textWriterIDs);
+    }
+    _calculateRadiusFromBearingLine(bearingLine) {
+        const { long, lat, endLong, endLat } = bearingLine;
+        // @ts-ignore
+        bearingLine.radius = this.globe.Math.GetDist2D(long, lat, endLong, endLat);
+    }
+    __deleteTexts(keys) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot delete texts.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot delete texts.");
+        }
+        for (const textWriter of this._textWritersMap.values()) {
+            textWriter.deleteTextBulk(keys);
+        }
+        keys.forEach(key => {
+            this._memory.delete(key);
+        });
+    }
+    __insertTexts(items, textWriterIDs = []) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot insert texts.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot insert texts.");
+        }
+        if (textWriterIDs.length === 0) {
+            textWriterIDs = Array.from(this._textWritersMap.keys());
+        }
+        // check textWriterIDs
+        for (const textWriterID of textWriterIDs) {
+            const textWriter = this._textWritersMap.get(textWriterID);
+            if (!textWriter) {
+                throw new Error(`Text writer with ID ${textWriterID} not found.`);
+            }
+        }
+        for (const textWriterID of textWriterIDs) {
+            const textWriter = this._textWritersMap.get(textWriterID);
+            if (textWriter) {
+                textWriter.insertTextBulk(items.map(x => this._textDataPreAdaptor(x)), textWriterID);
+            }
+        }
+    }
+    __memorizeItem(item) {
+        const oldItem = this._memory.get(item.key);
+        let newItem = oldItem ? { ...oldItem, ...item } : item;
+        this._memory.set(item.key, newItem);
+        return newItem;
+    }
+    _build(items, { textWriterIDs } = {}) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot update coordinates.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot update coordinates.");
+        }
+        if (!this.circlePlugin || !this.arcPlugin) {
+            throw new Error("Circle and Arc plugins are not initialized.");
+        }
+        items.forEach(item => {
+            this._calculateRadiusFromBearingLine(item);
+        });
+        const processedItems = items.map((item) => this.__memorizeItem(item));
+        // @ts-ignore
+        const circleInputs = processedItems.map(bearingLineToCircleInputAdapter(this.globe));
+        this.circlePlugin.insertBulk(circleInputs);
+        const arcInputs = processedItems.map(bearingLineToArcInputAdapter);
+        this.arcPlugin.insertBulk(arcInputs);
+        // @ts-ignore
+        const bearingArcInputs = processedItems.map((x) => bearingLineToBearingArcInputAdapter(this.globe, x));
+        this.arcPluginBL.insertBulk(bearingArcInputs);
+        this.__insertTexts(processedItems, textWriterIDs);
+        // @ts-ignore
+        const pieceOfPieInputs = processedItems.map((x) => bearingLineToPieceOfPieInputAdapter(this.globe, x));
+        this.pieceOfPiePlugin.insertBulk(pieceOfPieInputs);
+        // line inputs
+        const lineInputs = processedItems.map(flatLinesInputAdapter);
+        this.linePlugin.insertBulk(lineInputs);
+        const lineInputsBL = processedItems.map(flatLinesBearingInputAdapter);
+        this.linePluginBL.insertBulk(lineInputsBL);
+        // @ts-ignore
+        this.globe.DrawRender();
+    }
+    // globe API
+    init(globe, gl) {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot initialize.");
+        }
+        this.globe = globe;
+        this.circlePlugin.init(globe, gl);
+        this.arcPlugin.init(globe, gl);
+        this.arcPluginBL.init(globe, gl);
+        this.linePlugin.init(globe, gl);
+        this.linePluginBL.init(globe, gl);
+        this.pieceOfPiePlugin.init(globe, gl);
+    }
+    draw3D() {
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot draw.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot draw.");
+        }
+        if (!this.circlePlugin || !this.arcPlugin) {
+            throw new Error("Circle and Arc plugins are not initialized.");
+        }
+        if (this.drawOptions.drawVRM) {
+            this.circlePlugin.setPluginOpacity(this._opacities.circle ?? this._opacities.general);
+            this.circlePlugin.draw3D();
+        }
+        if (this.drawOptions.drawBearingLine) {
+            this.arcPluginBL.setPluginOpacity(this._opacities.arc ?? this._opacities.general);
+            this.arcPluginBL.draw3D();
+        }
+        if (this.drawOptions.drawAngleRing) {
+            const currentLOD = this.globe.api_GetCurrentLODWithDecimal();
+            const tiltAngle = this.globe.api_GetCurrentLookInfo().Tilt;
+            const opacity = pieceOfPieOpacityAdaptor(currentLOD, tiltAngle) * (this._opacities.general ?? 1);
+            if (opacity > 0) {
+                this.pieceOfPiePlugin.setPluginOpacity(opacity);
+                this.pieceOfPiePlugin.draw3D();
+            }
+        }
+        const currentGeometry = this.globe.api_GetCurrentGeometry();
+        this.arcPlugin.setPluginOpacity(this._opacities.arc ?? this._opacities.general);
+        this.arcPlugin.draw3D();
+        if (currentGeometry === 1) {
+            this.linePlugin.draw3D();
+            this.linePluginBL.draw3D();
+        }
+        if (this.drawOptions.drawAngleRing) {
+            for (const textWriter of this._textWritersMap.values()) {
+                textWriter.draw();
+            }
+        }
+    }
+    free() {
+        if (this._freed) {
+            throw new Error("Plugin has already been freed.");
+        }
+        this._freed = true;
+        this.globe = null;
+        this._memory.clear();
+        this._textWritersMap.clear();
+        this.circlePlugin.free();
+        this.arcPlugin.free();
+        this.arcPluginBL.free();
+        this.pieceOfPiePlugin.free();
+        this.linePlugin.free();
+        this.linePluginBL.free();
+    }
+}

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

@@ -0,0 +1,83 @@
+export const keyMethod = (chainKey, nodeKey) => `${chainKey}_${nodeKey}`;
+const distance = (node1, node2) => {
+    const dx = node1.long - node2.long;
+    const dy = node1.lat - node2.lat;
+    return Math.sqrt(dx * dx + dy * dy);
+};
+export const circleDataAdaptor = (globe, chain) => {
+    const circleInputs = [];
+    const { chainKey, chainProperties, nodes } = chain;
+    for (let i = 0; i < nodes.length - 1; i++) {
+        const node = nodes[i];
+        const { key, long, lat, circleProperties } = node;
+        const color = circleProperties?.rgba ?? chainProperties.rgba ?? [1, 1, 1, 1]; // Default color if not specified
+        if (key === "Sakarya") {
+            console.log("circleProperties", circleProperties, "chainProperties", chainProperties);
+            console.log("Sakarya color", color);
+        }
+        const radius = globe.Math.GetDist2D(long, lat, nodes[i + 1].long, nodes[i + 1].lat);
+        const nodeKey = keyMethod(chainKey, key);
+        circleInputs.push({
+            key: nodeKey,
+            center: [long, lat],
+            radius,
+            height: chainProperties.altitude ?? 0,
+            color: color,
+        });
+    }
+    return circleInputs;
+};
+export function arcDataAdaptor(chain) {
+    const arcInputs = [];
+    const { chainKey, chainProperties, nodes } = chain;
+    for (let i = 0; i < nodes.length - 1; i++) {
+        const node = nodes[i];
+        const nextNode = nodes[i + 1];
+        const { key, long, lat, lineProperties } = node;
+        const nodeKey = keyMethod(chainKey, key);
+        const { long: nextLong, lat: nextLat } = nextNode;
+        const color = lineProperties?.rgba ?? chainProperties.rgba ?? [1, 1, 1, 1]; // Default color if not specified
+        arcInputs.push({
+            key: nodeKey,
+            start: [long, lat],
+            end: [nextLong, nextLat],
+            height: chainProperties.altitude ?? 0,
+            color: color,
+        });
+    }
+    return arcInputs;
+}
+export function lineDataAdaptor(chain) {
+    const lineInputs = [];
+    const { chainKey, chainProperties, nodes } = chain;
+    for (let i = 0; i < nodes.length - 1; i++) {
+        const node = nodes[i];
+        const nextNode = nodes[i + 1];
+        const { key, long, lat, lineProperties } = node;
+        const nodeKey = keyMethod(chainKey, key);
+        const { long: nextLong, lat: nextLat } = nextNode;
+        const color = lineProperties?.rgba ?? chainProperties.rgba ?? [1, 1, 1, 1]; // Default color if not specified
+        lineInputs.push({
+            key: nodeKey,
+            start: [long, lat],
+            end: [nextLong, nextLat],
+            start_altitude: chainProperties.altitude ?? 0,
+            end_altitude: chainProperties.altitude ?? 0,
+            color: color,
+        });
+    }
+    return lineInputs;
+}
+export function getOpacity(opacities, key) {
+    return opacities[key] ?? opacities.general ?? 1;
+}
+export function nodeKeysFromChain(chainKey, nodes) {
+    return nodes.map((node) => keyMethod(chainKey, node.key));
+}
+export function clipANodeReturnIndex(nodes, nodeKey) {
+    const index = nodes.findIndex(node => node.key === nodeKey);
+    if (index === -1) {
+        throw new Error(`Node with key ${nodeKey} not found in the chain.`);
+    }
+    nodes.splice(index, 1); // Remove the node from the array
+}