@pirireis/webglobeplugins 0.15.35 → 0.16.0

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

@@ -0,0 +1,569 @@
+import { BearingLineInput, Opacities, drawOption } from "./types";
+import { Globe, PluginInterface, UBOHandler, Color } from "../../types";
+
+import { ContextTextWriter3 } from "../../write-text/context-text3";
+import {
+    flatLinesInputAdapter,
+    flatLinesBearingInputAdapter,
+    bearingLineToCircleInputAdapter,
+    bearingLineToArcInputAdapter,
+    bearingLineToBearingArcInputAdapter,
+    bearingLineToPieceOfPieInputAdapter,
+    pieceOfPieOpacityAdaptor
+} from "./adapters";
+import { CircleOnTerrainPlugin, CircleOnTerrainPluginOptions } from "../../semiplugins/shape-on-terrain/circle-plugin";
+import { PieceOfPiePlugin, PieceOfPiePluginOptions } from "../../semiplugins/lightweight/piece-of-pie-plugin";
+import { ArcOnTerrainPlugin, ArcOnTerrainPluginOptions } from "../../semiplugins/shape-on-terrain/arc-plugin";
+import { LinePlugin, LinePluginOptions } from "../../semiplugins/lightweight/line-plugin";
+
+
+export class BearingLinePlugin implements PluginInterface {
+
+    id: string;
+    private globe: Globe | null = null;
+    private circlePlugin: CircleOnTerrainPlugin;
+    private arcPlugin: ArcOnTerrainPlugin;
+    private arcPluginBL: ArcOnTerrainPlugin;
+    private pieceOfPiePlugin: PieceOfPiePlugin;
+    private linePlugin: LinePlugin;
+    private linePluginBL: LinePlugin;
+    private _freed: boolean = false;
+    private _opacities: Opacities = {
+        general: 1,
+        circle: 1,
+        arc: 1,
+        pie: 1,
+        bearing: 1
+    };
+    private _textWritersMap: Map<string, ContextTextWriter3> = new Map();
+    private _textDataPreAdaptor: ((item: BearingLineInput) => any) = (item) => item;
+    private drawOptions: drawOption = {
+        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
+    }
+    private _memory: Map<string, any> = new Map();
+
+    private _semiPluginsOptions: {
+        circleOnTerrainOptions: Partial<CircleOnTerrainPluginOptions>,
+        arcOnTerrainOptions: Partial<ArcOnTerrainPluginOptions>,
+        lineOptions: Partial<LinePluginOptions>,
+        pieceOfPieOptions: Partial<PieceOfPiePluginOptions>,
+
+    } = {
+            circleOnTerrainOptions: {
+                defaultColor: [1, 1, 1, 0.5],
+                defaultHeightFromGroundIn3D: 30.0,
+                variativeColorsOn: false,
+                isMSL: false
+            },
+            arcOnTerrainOptions: {
+                defaultHeightFromGroundIn3D: 30.0,
+                variativeColorsOn: false,
+                defaultColor: [1, 1, 1, 0.5] as Color,
+                globeViewOn: true,
+                flatViewOn: false,
+                isMSL: false
+            },
+            lineOptions: {
+                flatViewOn: true,
+                globeViewOn: true,
+                variativeColorsOn: false,
+                defaultColor: [1, 1, 1, 0.5],
+            },
+            pieceOfPieOptions: {
+                defaultColor: [1, 1, 1, 0.5],
+                variativeColorsOn: false,
+                defaultHeightFromGroundIn3D: 1000.0,
+            }
+        }
+
+    constructor(id: string,
+        {
+            textWritersMap,
+            textDataPreAdaptor,
+            opacities,
+            drawOptions,
+            circleOnTerrainOptions = {
+                defaultColor: [1, 1, 1, 0.5] as Color,
+                defaultHeightFromGroundIn3D: 30.0,
+                variativeColorsOn: false,
+            },
+            arcOnTerrainOptions = {
+                globeViewOn: true,
+                flatViewOn: false,
+                defaultColor: [1, 1, 1, 0.5] as Color,
+                defaultHeightFromGroundIn3D: 30.0,
+                variativeColorsOn: false,
+            },
+            lineOptions = {
+                flatViewOn: true,
+                globeViewOn: false,
+                variativeColorsOn: false,
+                defaultColor: [1, 1, 1, 0.5] as Color,
+            },
+            pieceOfPieOptions = {
+                defaultColor: [1, 1, 1, 0.5] as Color,
+                variativeColorsOn: false,
+                defaultHeightFromGroundIn3D: 1000.0,
+            }
+        }: {
+            textWritersMap?: Map<string, ContextTextWriter3>,
+            textDataPreAdaptor?: (item: BearingLineInput) => any,
+            opacities?: Partial<Opacities>,
+            drawOptions?: Partial<drawOption>,
+            circleOnTerrainOptions?: Partial<CircleOnTerrainPluginOptions>,
+            arcOnTerrainOptions?: Partial<ArcOnTerrainPluginOptions>,
+            lineOptions?: Partial<LinePluginOptions>,
+            pieceOfPieOptions?: Partial<PieceOfPiePluginOptions>,
+        } = {}
+    ) {
+        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");
+        });
+
+
+        if (circleOnTerrainOptions) {
+            this._semiPluginsOptions.circleOnTerrainOptions = {
+                ...this._semiPluginsOptions.circleOnTerrainOptions,
+                ...circleOnTerrainOptions
+            };
+        }
+        if (arcOnTerrainOptions) {
+            this._semiPluginsOptions.arcOnTerrainOptions = {
+                ...this._semiPluginsOptions.arcOnTerrainOptions,
+                ...arcOnTerrainOptions
+            };
+        }
+        if (lineOptions) {
+            this._semiPluginsOptions.lineOptions = {
+                ...this._semiPluginsOptions.lineOptions,
+                ...lineOptions
+            };
+        }
+        if (pieceOfPieOptions) this._semiPluginsOptions.pieceOfPieOptions = {
+            ...this._semiPluginsOptions.pieceOfPieOptions,
+            ...pieceOfPieOptions
+        };
+
+
+        this._textWritersMap = textWritersMap || new Map();
+        this._textWritersMap.forEach((writer) => writer.setKeyAdaptor((item: { key: string }) => item.key));
+        this._textDataPreAdaptor = textDataPreAdaptor || ((item) => item);
+        this.circlePlugin = new CircleOnTerrainPlugin(id + "_circle",
+            this._semiPluginsOptions.circleOnTerrainOptions as CircleOnTerrainPluginOptions
+        )
+        this.arcPlugin = new ArcOnTerrainPlugin(id + "_arc", {
+            ...this._semiPluginsOptions.arcOnTerrainOptions,
+        })
+        this.arcPluginBL = new ArcOnTerrainPlugin(id + "_arcBL", {
+            ...this._semiPluginsOptions.arcOnTerrainOptions,
+        })
+        this.pieceOfPiePlugin = new PieceOfPiePlugin(id + "_pieceOfPie", {
+            bufferType: "DYNAMIC_DRAW",
+            ...this._semiPluginsOptions.pieceOfPieOptions
+
+        });
+        this.linePlugin = new LinePlugin(id + "_line", {
+            bufferType: "DYNAMIC_DRAW",
+            ...this._semiPluginsOptions.lineOptions
+        });
+        this.linePluginBL = new LinePlugin(id + "_lineBL", {
+            ...this._semiPluginsOptions.lineOptions           // flatViewOn: true,
+        });
+        if (opacities) {
+            this._opacities = {
+                ...this._opacities,
+                ...opacities,
+            }
+        }
+        if (drawOptions) {
+            this.drawOptions = {
+                ...this.drawOptions,
+                ...drawOptions
+            };
+        }
+
+
+    }
+
+
+
+    setDefaultSemiPluginColor(
+        semiPluginName: "circleOnTerrain" | "arcOnTerrain" | "line" | "pieceOfPie" | "ALL",
+        color: Color
+    ) {
+
+
+        if (this._freed) {
+            throw new Error("Plugin has been freed, cannot set default semi plugin color.");
+        }
+        if (!this.globe) {
+            throw new Error("Globe is not set, cannot set default semi plugin color.");
+        }
+
+        if (semiPluginName === "ALL") {
+            this.circlePlugin.setDefaultColor(color);
+            this.arcPlugin.setDefaultColor(color);
+            this.arcPluginBL.setDefaultColor(color);
+            this.linePlugin.setDefaultColor(color);
+            this.linePluginBL.setDefaultColor(color);
+            this.pieceOfPiePlugin.setDefaultColor(color);
+            return;
+        }
+
+        switch (semiPluginName) {
+            case "circleOnTerrain":
+                this.circlePlugin.setDefaultColor(color);
+                break;
+            case "arcOnTerrain":
+                this.arcPlugin.setDefaultColor(color);
+                break;
+            case "line":
+                this.linePlugin.setDefaultColor(color);
+                break;
+            case "pieceOfPie":
+                this.pieceOfPiePlugin.setDefaultColor(color);
+                break;
+            default:
+                throw new Error(`Unknown semi plugin name: ${semiPluginName}`);
+        }
+    }
+
+    setDoDrawVRM(drawVRM: boolean): void {
+        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: boolean): void {
+        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: boolean): void {
+        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: boolean): void {
+        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();
+    }
+
+
+
+    updatePartial(items: (Partial<BearingLineInput> & { key: string })[], { textWriterIDs }: { textWriterIDs?: string[] } = {}) {
+        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: Partial<drawOption>) {
+        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: BearingLineInput[], { textWriterIDs }: { textWriterIDs?: string[] } = {}) {
+        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: Partial<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: BearingLineInput[], { textWriterIDs }: { textWriterIDs?: string[] } = {}) {
+
+        this._build(items, { textWriterIDs });
+    }
+
+    deleteBulk(keys: string[]) {
+        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: string[], itemKeys: string[] | null = 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: BearingLineInput): void {
+        const { long, lat, endLong, endLat } = bearingLine;
+        // @ts-ignore
+        bearingLine.radius = this.globe.Math.GetDist2D(long, lat, endLong, endLat);
+    }
+
+    __deleteTexts(keys: string[]) {
+        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: BearingLineInput[], textWriterIDs: string[] = []) {
+        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: { key: string } & Partial<BearingLineInput>): BearingLineInput {
+        const oldItem = this._memory.get(item.key);
+        let newItem = oldItem ? { ...oldItem, ...item } : item;
+        this._memory.set(item.key, newItem);
+        return newItem;
+    }
+
+    _build(items: BearingLineInput[], { textWriterIDs }: { textWriterIDs?: string[] } = {}) {
+        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)) as CircleInput[];
+        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: Globe, gl: WebGL2RenderingContext): void {
+        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(): void {
+
+        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, false);
+            this.circlePlugin.draw3D();
+        }
+
+
+        if (this.drawOptions.drawBearingLine) {
+            this.arcPluginBL.setPluginOpacity(this._opacities.bearing ?? this._opacities.general, false);
+            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, false);
+                this.pieceOfPiePlugin.draw3D();
+            }
+        }
+
+        const currentGeometry = this.globe.api_GetCurrentGeometry();
+
+        this.arcPlugin.setPluginOpacity(this._opacities.arc ?? this._opacities.general, false);
+        this.arcPlugin.draw3D();
+
+        if (currentGeometry === 1) {
+            this.linePlugin.draw3D();
+            this.linePluginBL.draw3D();
+        }
+
+        for (const textWriter of this._textWritersMap.values()) {
+            textWriter.draw();
+        }
+    }
+
+
+    free(): void {
+        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/bearing-line/types.ts

@@ -0,0 +1,65 @@
+import { Color, Meter, BUFFER_TYPE, LongLat, CentigradeDegree } from "../../types";
+import { FillingMode } from "../../semiplugins/lightweight/piece-of-pie-plugin";
+/**
+     * @typedef {{key, long, lat, endLong, endLat, bearingAngle, radius,  rgba:[4numbers], rgbaMode, bigRadius, dashRatio, dashOpacity, circleDashAngle}} BearingLineItem
+     * @property {string} key   
+     * @property {number} long
+     * @property {number} lat
+     * @property {number} endLong
+     * @property {number} endLat 
+     * @property {number} bearingAngle 0-360
+     * @property {number} radius angle ring radius
+     * @property {number} altitude in meters effects all parts of the item
+     * @property {Array<numbers>} rgba [r,g,b,a] 0-1
+     * @property {number} rgbaMode 0 constant, 1 fading, 2 hides angle ring
+     * @property {number} bigRadius undefined means it will be calculated from long, lat, endLong, endLat
+     * @property {number} dashRatio 0-1
+     * @property {number} dashOpacity 0-1
+     * @property {number} circleDashAngle 0-360
+ */
+
+
+
+
+export type Opacities = {
+    general: number;
+    circle: number | null;
+    arc: number | null;
+    pie: number | null;
+    bearing: number | null;
+}
+
+
+export type drawOption = {
+    drawVRM: boolean,
+    drawBearingLine: boolean,
+    drawAngleRing: boolean,
+    drawText: boolean
+    flatRealLineOn: boolean, // This is a new option to control flat real line drawing
+    flatStraightLineOn: boolean // This is a new option to control flat straight line drawing
+}
+
+export type BearingLineInput = {
+    key: string,
+    long: number,
+    lat: number,
+    endLong: number,
+    endLat: number,
+    bearingAngle: number,
+    piechartRadius: number,
+    altitude: number,
+    rgba: Color,
+    rgbaMode: number,
+    bigRadius: number,
+    pieFillingMode?: FillingMode, // 0 - constant, 1 - fading, 2 - hides angle ring. Default is 1
+    msl?: boolean
+};
+
+
+export type ImplicitBearingLineInput = BearingLineInput & {
+    // automatically calculated
+    radius?: number | null,
+    bearingLong?: number,
+    bearingLat?: number,
+    // automatically calculated
+}