@pirireis/webglobeplugins 0.12.0-alpha → 0.14.0-alpha

package/programs/rings/partial-ring/piece-of-pie.js

@@ -1,5 +1,5 @@
-import { createProgram, shaderfunctions } from "../../../util";
-import { CameraUniformBlockTotem, CameraUniformBlockString } from "../../totems";
+import { createProgram } from "../../../util/webglobjectbuilders";
+import { CameraUniformBlockTotem, CameraUniformBlockString } from "../../totems/index";
 import { noRegisterGlobeProgramCache, globeProgramCache } from "../../programcache";
 import { POLE, PI, longLatRadToMercator, mercatorXYToGLPosition, longLatRadToCartesian3D, circleLimpFromLongLatRadCenterCartesian3D_accurate, circleLimpFromLongLatRadCenterMercatorCompass_accurate, 
 //circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
@@ -40,7 +40,7 @@ in float tail_angle3d;
 
 in vec4 color;
 in float radius; // in meter
-in float color_mode; // 0.0: constant, 1.0: fading, 2.0: hide
+in float filling_mode; // 0.0: constant, 1.0: fading, 2.0: hide
 // flat out int vid;
 // flat out float v_phase;
 out vec2 v_pos;
@@ -49,7 +49,7 @@ out vec4 v_color;
 
 void main() {
     // vid = gl_VertexID;
-    if (color_mode == 2.0 || radius == 0.0) { return; }
+    if (filling_mode == 2.0 || radius == 0.0) { return; }
     float start_angle, tail_angle;
     if (is3D) {
         start_angle = start_angle3d;
@@ -58,22 +58,22 @@ void main() {
         start_angle = start_angle2d;
         tail_angle = tail_angle2d;
     }
-    float color_mode_ = color_mode;
-    if ( draw_mode == 0 && color_mode == 1.0) {color_mode_ = 0.0;}
+    float filling_mode_ = filling_mode;
+    if ( draw_mode == 0 && filling_mode == 1.0) {filling_mode_ = 0.0;}
     float vertexID = float(gl_VertexID);
     float radius_ = radius;
     float alpha = plugin_alpha_multiplier;
     if (draw_mode == 1) { // TRIANGLE_FAN
         if (gl_VertexID == 0) { 
             radius_ = 0.0; 
-            if ( color_mode == 1.0 ) { alpha = 0.0; }
+            if ( filling_mode == 1.0 ) { alpha = 0.0; }
         }
         vertexID -= 1.0;
     }
     float phase = ( vertexID  / (edge_count - 1.0) );
     // v_angle = tail_angle;
     
-    if ( color_mode_ == 1.0 ) {
+    if ( filling_mode_ == 1.0 ) {
         if ( tail_angle < 0.0 ) {
                 v_color = vec4( color.rgb , color.a * ( 1.0 - phase ) * alpha );
             } else {
@@ -82,7 +82,7 @@ void main() {
     } else {
         v_color = vec4( color.rgb , color.a * alpha );
     }
-    if ( color_mode == 0.0 && draw_mode == 1 ) {
+    if ( filling_mode == 0.0 && draw_mode == 1 ) {
         v_color.a /= 2.0;
     }
     float angle;
@@ -121,6 +121,17 @@ void main() {
 }`;
 export const ITEM_SIZE = 10;
 export class Logic {
+    globe;
+    gl;
+    _lastMode;
+    _lastEdgeCount;
+    _lastAlphaMultiplier;
+    program;
+    _edgeCountLocation;
+    _draw_modeLocation;
+    _plugin_alpha_multiplierLocation;
+    cameraBlockBindingPoint;
+    cameraBlockTotem; // Type this based on your CameraUniformBlockTotem implementation
     constructor(globe) {
         this.globe = globe;
         this.gl = globe.gl;
@@ -138,7 +149,7 @@ export class Logic {
             gl.bindAttribLocation(program, 5, 'tail_angle3d');
             gl.bindAttribLocation(program, 6, 'color');
             gl.bindAttribLocation(program, 7, 'radius');
-            gl.bindAttribLocation(program, 8, 'color_mode');
+            gl.bindAttribLocation(program, 8, 'filling_mode');
             // vao
             // instanced draw read 1 
         }
@@ -162,9 +173,9 @@ export class Logic {
         const { gl, program, cameraBlockTotem, cameraBlockBindingPoint } = this;
         // gl.disable(gl.DEPTH_TEST);
         gl.useProgram(program);
-        if (drawMode !== this._lastMode) {
+        if (drawModeMap[drawMode] !== this._lastMode) {
             gl.uniform1i(this._draw_modeLocation, drawModeMap[drawMode]);
-            this._lastMode = drawMode;
+            this._lastMode = drawModeMap[drawMode];
         }
         if (edgeCount !== this._lastEdgeCount) {
             gl.uniform1f(this._edgeCountLocation, edgeCount);
@@ -193,7 +204,7 @@ export class Logic {
     in float tail_angle; // the rotation of the partial circle
     in vec4 color;
     in float radius; // in meter
-    in float color_mode; // 0.0: constant, 1.0: fading, 2.0: hide
+    in float filling_mode; // 0.0: constant, 1.0: fading, 2.0: hide
      */
     createVAO(center2dObj, center3dObj, startAngle2DObj, tailAngle2DObj, startAngle3DObj, tailAngle3DObj, colorObj, radiusObj, colorModeObj) {
         const { gl } = this;
@@ -266,6 +277,8 @@ export class Logic {
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
         return vao;
     }
+    createUBO() {
+    }
 }
 export const PieceOfPieProgramCache = Object.freeze({
     get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),

package/programs/totems/camerauniformblock.js

@@ -18,7 +18,7 @@ layout(std140) uniform CameraUniformBlock {
 `;
 const Radian = Math.PI / 180.0;
 const _0vec3 = [0, 0, 0];
-export default class CameraUniformBlockTotem {
+export class CameraUniformBlockTotem {
     id;
     description;
     gl;

package/programs/totems/index.js

@@ -1,2 +1,2 @@
-import CameraUniformBlockTotem, { CameraUniformBlockString, CameraUniformBlockTotemCache } from "./camerauniformblock";
+import { CameraUniformBlockTotem, CameraUniformBlockString, CameraUniformBlockTotemCache } from "./camerauniformblock";
 export { CameraUniformBlockTotem, CameraUniformBlockString, CameraUniformBlockTotemCache };

package/programs/vectorfields/logics/pixelbased.js

@@ -34,7 +34,7 @@ vec2 read_value(const vec2 uv) {
     return value;
 }
 
-vec2 lookup_wind(const vec2 uv) { // gerek kalmayabilir. sampler linear methodu ayni isi yapiyor
+vec2 lookup_wind(const vec2 uv) { 
     // return texture(vector_field, uv).rg; // lower-res hardware filtering
     vec2 res = vec2(textureSize(vector_field, 0));
     vec2 px = 1.0 / res;
@@ -49,23 +49,7 @@ vec2 lookup_wind(const vec2 uv) { // gerek kalmayabilir. sampler linear methodu
 }
 
 
-vec2 lookup_wind2(const vec2 uv) { // gerek kalmayabilir. sampler linear methodu ayni isi yapiyor
-    // return texture(vector_field, uv).rg; // lower-res hardware filtering
-    vec2 res = vec2(textureSize(vector_field, 0));
-    if (res.x == escape_value || res.y == escape_value){ return vec2(0.0);}
-    vec2 px = 1.0 / res;
-    vec2 vc = (floor(uv * res)) * px;
-    vec2 f = fract(uv * res);
-    vec2 tl = texture(vector_field, vc).rg;
-    vec2 tr = texture(vector_field, vc + vec2(px.x, 0)).rg;
-    vec2 bl = texture(vector_field, vc + vec2(0, px.y)).rg;
-    vec2 br = texture(vector_field, vc + px).rg;
-    if (tl.x == 0.0 && tl.y == 0.0){ return vec2(0.0);}
-    if (tr.x == 0.0 && tr.y == 0.0){ return vec2(0.0);}
-    if (bl.x == 0.0 && bl.y == 0.0){ return vec2(0.0);}
-    if (br.x == 0.0 && br.y == 0.0){ return vec2(0.0);}
-    return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);
-}
+
 
 
 vec2 random_position(vec2 st){
@@ -74,17 +58,17 @@ vec2 random_position(vec2 st){
 
 
 void main(){
-    vec2 vec = -lookup_wind(in_position).xy;
+    vec2 vec = lookup_wind(in_position).xy;
     if (vec.x == 0.0 && vec.y == 0.0){
         out_position = random_position(in_position);
         return;
     }
     float random_value = random(in_position + random_seed);
-    if (random_value < drop_rate){ //TODO: more sophisticated drop out mechanism mi
+    if (random_value < drop_rate){ 
         out_position = random_position(in_position);
         return;
     }
-    out_position = in_position - (vec / draw_texture_size)  * range; //*0.0014
+    out_position = in_position + (vec / draw_texture_size)  * range;
 }
 `;
 const fragmentShaderSource = `#version 300 es

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

@@ -0,0 +1,111 @@
+const radian = (degree) => degree * Math.PI / 180;
+const calculateStartAngle = (long, lat, endLong, endLat) => {
+    const dLat = (integralSec(endLat) - integralSec(lat)); // Because lines are strectes toward poles.
+    const dLong = endLong - long;
+    let angle = -Math.atan2(dLat, dLong);
+    return angle;
+};
+const integralSec = (angle) => {
+    return Math.log(Math.tan(angle / 2 + Math.PI / 4));
+};
+export const flatLinesInputAdapter = (bearingLine) => {
+    const { long, lat, endLong, endLat, rgba } = bearingLine;
+    return {
+        key: bearingLine.key,
+        start: [long, lat],
+        end: [endLong, endLat],
+        color: rgba,
+    };
+};
+export const flatLinesBearingInputAdapter = (bearingLine) => {
+    const { long, lat, rgba, key, bearingLat = 0, bearingLong = 0 } = bearingLine;
+    return {
+        key: key,
+        start: [long, lat],
+        end: [bearingLong, bearingLat],
+        color: rgba,
+    };
+};
+export const bearingLineToCircleInputAdapter = (globe) => (bearingLine) => {
+    const { long, lat, endLong, endLat, rgba, altitude = 0 } = bearingLine;
+    if (bearingLine.radius === undefined || bearingLine.radius === null) {
+        const radius = globe.Math.GetDist2D(long, lat, endLong, endLat);
+        bearingLine.radius = radius;
+    }
+    return {
+        key: bearingLine.key,
+        center: [long, lat],
+        radius: bearingLine.radius,
+        height: altitude,
+        color: rgba,
+    };
+};
+export const bearingLineToArcInputAdapter = (bearingLine) => {
+    const { long, lat, endLong, endLat, rgba, altitude = 0 } = bearingLine;
+    return {
+        key: bearingLine.key,
+        start: [long, lat],
+        end: [endLong, endLat],
+        height: altitude,
+        color: rgba,
+    };
+};
+export const bearingLineToBearingArcInputAdapter = (globe, bearingLine) => {
+    const { long, lat, bearingAngle, rgba, altitude = 0, key } = bearingLine;
+    if (bearingLine.radius === undefined || bearingLine.radius === null) {
+        throw new Error("Bearing line radius is not defined. Please calculate it before converting to ArcInput.");
+    }
+    const { long: endLong, lat: endLat } = globe.Math.FindPointByPolar(long, lat, bearingLine.radius, bearingAngle);
+    bearingLine.bearingLong = endLong;
+    bearingLine.bearingLat = endLat;
+    return {
+        key: key,
+        start: [long, lat],
+        end: [endLong, endLat],
+        height: altitude,
+        color: rgba,
+    };
+};
+export const bearingLineToPieceOfPieInputAdapter = (globe, item) => {
+    const lat = radian(item.lat);
+    const long = radian(item.long);
+    const endLat = radian(item.endLat);
+    const endLong = radian(item.endLong);
+    const altitude = (item.altitude ?? 0) / 1000;
+    const radius = item.radius ? item.radius * 0.2 : 10;
+    // @ts-ignore 
+    const { long: bearingLong, lat: bearingLat } = globe.Math.FindPointByPolar(item.long, item.lat, item.radius, item.bearingAngle);
+    const startAngle2d = calculateStartAngle(long, lat, endLong, endLat);
+    const bearingAngle2d = calculateStartAngle(long, lat, radian(bearingLong), radian(bearingLat));
+    let tailAngle2d = bearingAngle2d - startAngle2d;
+    if (tailAngle2d > 0) {
+        tailAngle2d -= Math.PI * 2;
+    }
+    const bearingAngle = radian(item.bearingAngle - 90);
+    const startAngleReal = globe.Math.GetAzimuthAngle(item.long, item.lat, item.endLong, item.endLat); //startAngle2d * 180 / Math.PI;
+    const startAngle3d = radian(startAngleReal - 90);
+    let tailAngle3d = bearingAngle - startAngle3d;
+    if (tailAngle3d > 0) {
+        tailAngle3d -= Math.PI * 2;
+    }
+    return {
+        key: item.key,
+        center: [item.long, item.lat],
+        radius: radius,
+        altitude: altitude + 230,
+        color: item.rgba,
+        startAngle2D: startAngle2d * 180 / Math.PI,
+        coverAngle2D: tailAngle2d * 180 / Math.PI,
+        startAngle3D: startAngle3d * 180 / Math.PI,
+        coverAngle3D: tailAngle3d * 180 / Math.PI,
+        fillingMode: item.pieFillingMode ?? 1,
+    };
+};
+export const pieceOfPieOpacityAdaptor = (lod, tiltAngle) => {
+    const lodThreshold = 7.5;
+    const lodFactor = Math.exp(-Math.max(0, lod - lodThreshold));
+    tiltAngle += 5;
+    const tiltFactor = Math.min(1, 1 / Math.tan(radian(tiltAngle)));
+    const opacity = Math.max(Math.min(lodFactor * tiltFactor, 1), 0);
+    return opacity < 0.1 ? 0 : opacity; // Ensure opacity is not less than 0.1
+};

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/bearing-line/types.js

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