@pirireis/webglobeplugins 0.15.1-alpha → 0.15.2-3.alpha

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

@@ -1,6 +1,8 @@
 import { createProgram } from "../../../util/webglobjectbuilders";
 import { CameraUniformBlockTotem, CameraUniformBlockString } from "../../totems/index";
 import { noRegisterGlobeProgramCache, globeProgramCache } from "../../programcache";
+import { attributeLoader } from "../../../util/gl-util/buffer/attribute-loader";
+import { UniformBlockManager } from "../../../util/gl-util/uniform-block/manager";
 import { POLE, PI, longLatRadToMercator, mercatorXYToGLPosition, longLatRadToCartesian3D, circleLimpFromLongLatRadCenterCartesian3D_accurate, circleLimpFromLongLatRadCenterMercatorCompass_accurate, 
 //circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
 cartesian3DToGLPosition } from "../../../util/shaderfunctions/geometrytransformations";
@@ -9,6 +11,14 @@ cartesian3DToGLPosition } from "../../../util/shaderfunctions/geometrytransforma
  * 1. Triangle face looks at screen. if rotation angle is positive the last vertex must be the faintest.
  *
  */
+const uniformBindingPoints = {
+    camera: 0,
+    flexible: 1,
+};
+const flexibleBlockManager = new UniformBlockManager('FlexibleAttributes', [
+    { name: "u_color", type: "vec4", value: new Float32Array([0.12, 1, 0.1, 1]) },
+    { name: "u_opacity", type: "float", value: new Float32Array([1]) },
+], uniformBindingPoints.flexible);
 const drawModeMap = Object.freeze({
     LINE_STRIP: 0,
     TRIANGLE_FAN: 1,
@@ -25,11 +35,12 @@ ${circleLimpFromLongLatRadCenterCartesian3D_accurate}
 ${circleLimpFromLongLatRadCenterMercatorCompass_accurate}
 ${cartesian3DToGLPosition}
 
+${flexibleBlockManager.glslCode()}
+
+
 uniform float edge_count;
 uniform int draw_mode; // %2 => 0: LINE_STRIP, 1: TRIANGLE_FAN 
-uniform float plugin_alpha_multiplier;
-//, lat, startAngle, tailAngle, ...rgba, radius, rgbaMode
-// in vec2 center; // long, lat in radian
+
 in vec2 center2d;
 in vec3 center3d;
 in float start_angle2d; 
@@ -41,14 +52,15 @@ in float tail_angle3d;
 in vec4 color;
 in float radius; // in meter
 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;
 out vec4 v_color;
-// flat out float v_angle;
+
 
 void main() {
     // vid = gl_VertexID;
+    vec4 _color = (color.r == -1.0) ? u_color : color;
+
     if (filling_mode == 2.0 || radius == 0.0) { return; }
     float start_angle, tail_angle;
     if (is3D) {
@@ -62,7 +74,7 @@ void main() {
     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;
+    float alpha = u_opacity;
     if (draw_mode == 1) { // TRIANGLE_FAN
         if (gl_VertexID == 0) { 
             radius_ = 0.0; 
@@ -71,16 +83,15 @@ void main() {
         vertexID -= 1.0;
     }
     float phase = ( vertexID  / (edge_count - 1.0) );
-    // v_angle = tail_angle;
     
     if ( filling_mode_ == 1.0 ) {
         if ( tail_angle < 0.0 ) {
-                v_color = vec4( color.rgb , color.a * ( 1.0 - phase ) * alpha );
+                v_color = vec4( _color.rgb , _color.a * ( 1.0 - phase ) * alpha );
             } else {
-                v_color = vec4( color.rgb , color.a * phase * alpha );
+                v_color = vec4( _color.rgb , _color.a * phase * alpha );
         }
     } else {
-        v_color = vec4( color.rgb , color.a * alpha );
+        v_color = vec4( _color.rgb , _color.a * alpha );
     }
     if ( filling_mode == 0.0 && draw_mode == 1 ) {
         v_color.a /= 2.0;
@@ -106,16 +117,11 @@ void main() {
 }`;
 const fragmentShaderSource = `#version 300 es` + POLE + PI + `
 precision highp float;
-// flat in int vid;
 in vec4 v_color;
 in vec2 v_pos;
-// flat in float v_phase;
-// in float v_angle;
 out vec4 outColor;
 void main() {
-    // if( vid % 2 == 0 ) { discard; }
-    // if ( mod(v_angle, PI / 36.0 ) < (PI / 72.0)) { discard; }
-    // if ( mod(v_angle * v_phase,  PI / 90.0 ) < (PI / 180.0)) { discard; }
+
     if ( v_pos.x < -POLE || v_pos.x > POLE || v_pos.y < -POLE || v_pos.y > POLE ) { discard; }
     outColor = v_color;
 }`;
@@ -129,9 +135,10 @@ export class Logic {
     program;
     _edgeCountLocation;
     _draw_modeLocation;
-    _plugin_alpha_multiplierLocation;
     cameraBlockBindingPoint;
     cameraBlockTotem; // Type this based on your CameraUniformBlockTotem implementation
+    _ubosPublished = [];
+    _defaultFlexibleUBO;
     constructor(globe) {
         this.globe = globe;
         this.gl = globe.gl;
@@ -156,22 +163,21 @@ export class Logic {
         { // Uniforms
             this._edgeCountLocation = gl.getUniformLocation(program, 'edge_count');
             this._draw_modeLocation = gl.getUniformLocation(program, 'draw_mode');
-            this._plugin_alpha_multiplierLocation = gl.getUniformLocation(program, 'plugin_alpha_multiplier');
             const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
             gl.useProgram(program);
             gl.uniform1i(this._draw_modeLocation, this._lastMode);
             gl.uniform1f(this._edgeCountLocation, this._lastEdgeCount);
-            gl.uniform1f(this._plugin_alpha_multiplierLocation, 1.0);
             this.cameraBlockBindingPoint = 0;
             this.cameraBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
             const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
             gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBindingPoint);
+            flexibleBlockManager.assignBindingPoint(gl, program);
+            this._defaultFlexibleUBO = flexibleBlockManager.createUBO(gl);
             gl.useProgram(currentProgram);
         }
     }
-    draw(length, vao, edgeCount, alphaMultiplier, drawMode) {
+    draw(length, vao, edgeCount, drawMode, ubo = null) {
         const { gl, program, cameraBlockTotem, cameraBlockBindingPoint } = this;
-        // gl.disable(gl.DEPTH_TEST);
         gl.useProgram(program);
         if (drawModeMap[drawMode] !== this._lastMode) {
             gl.uniform1i(this._draw_modeLocation, drawModeMap[drawMode]);
@@ -181,9 +187,11 @@ export class Logic {
             gl.uniform1f(this._edgeCountLocation, edgeCount);
             this._lastEdgeCount = edgeCount;
         }
-        if (alphaMultiplier !== this._lastAlphaMultiplier) {
-            gl.uniform1f(this._plugin_alpha_multiplierLocation, alphaMultiplier);
-            this._lastAlphaMultiplier = alphaMultiplier;
+        if (ubo) {
+            ubo.bind();
+        }
+        else {
+            this._defaultFlexibleUBO.bind();
         }
         const overdraw = drawModeMap[drawMode];
         cameraBlockTotem.bind(cameraBlockBindingPoint);
@@ -191,11 +199,18 @@ export class Logic {
         gl.drawArraysInstanced(gl[drawMode], 0, edgeCount + overdraw, length);
         cameraBlockTotem.unbind(cameraBlockBindingPoint);
         gl.bindVertexArray(null);
-        // gl.enable(gl.DEPTH_TEST);
+        if (ubo) {
+            ubo.unbind();
+        }
+        else {
+            this._defaultFlexibleUBO.unbind();
+        }
     }
     free() {
         noRegisterGlobeProgramCache.releaseProgram(this.globe, CameraUniformBlockTotem);
         this.gl.deleteProgram(this.program);
+        this._defaultFlexibleUBO.free();
+        this._ubosPublished.forEach(ubo => ubo.free()); // TODO: can be called 2 times. is it a problem?
         this.program = null;
     }
     /**
@@ -210,74 +225,25 @@ export class Logic {
         const { gl } = this;
         const vao = gl.createVertexArray();
         gl.bindVertexArray(vao);
-        {
-            const { buffer, stride, offset } = center2dObj;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(0);
-            gl.vertexAttribPointer(0, 2, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(0, 1);
-        }
-        {
-            const { buffer, stride, offset } = center3dObj;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(1);
-            gl.vertexAttribPointer(1, 3, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(1, 1);
-        }
-        {
-            const { buffer, stride, offset } = startAngle2DObj;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(2);
-            gl.vertexAttribPointer(2, 1, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(2, 1);
-        }
-        {
-            const { buffer, stride, offset } = tailAngle2DObj;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(3);
-            gl.vertexAttribPointer(3, 1, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(3, 1);
-        }
-        {
-            const { buffer, stride, offset } = startAngle3DObj;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(4);
-            gl.vertexAttribPointer(4, 1, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(4, 1);
-        }
-        {
-            const { buffer, stride, offset } = tailAngle3DObj;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(5);
-            gl.vertexAttribPointer(5, 1, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(5, 1);
-        }
-        {
-            const { buffer, stride, offset } = colorObj;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(6);
-            gl.vertexAttribPointer(6, 4, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(6, 1);
-        }
-        {
-            const { buffer, stride, offset } = radiusObj;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(7);
-            gl.vertexAttribPointer(7, 1, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(7, 1);
-        }
-        {
-            const { buffer, stride, offset } = colorModeObj;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(8);
-            gl.vertexAttribPointer(8, 1, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(8, 1);
-        }
+        attributeLoader(gl, center2dObj, 0, 2, { divisor: 1 });
+        attributeLoader(gl, center3dObj, 1, 3, { divisor: 1 });
+        attributeLoader(gl, startAngle2DObj, 2, 1, { divisor: 1 });
+        attributeLoader(gl, tailAngle2DObj, 3, 1, { divisor: 1 });
+        attributeLoader(gl, startAngle3DObj, 4, 1, { divisor: 1 });
+        attributeLoader(gl, tailAngle3DObj, 5, 1, { divisor: 1 });
+        attributeLoader(gl, colorObj, 6, 4, { divisor: 1, escapeValues: [-1.0, -1.0, -1.0, -1.0] });
+        attributeLoader(gl, radiusObj, 7, 1, { divisor: 1, escapeValues: [-1.0] });
+        attributeLoader(gl, colorModeObj, 8, 1, { divisor: 1, escapeValues: [-1.0] });
         gl.bindVertexArray(null);
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
         return vao;
     }
     createUBO() {
+        const { gl } = this;
+        const bufferReadType = gl.DYNAMIC_DRAW;
+        const ubo = flexibleBlockManager.createUBO(gl, "STATIC_DRAW");
+        this._ubosPublished.push(ubo);
+        return ubo;
     }
 }
 export const PieceOfPieProgramCache = Object.freeze({

package/programs/totems/camerauniformblock.js

@@ -1,6 +1,7 @@
 import { globeProgramCache } from "../programcache";
 import { fromLongLatToUnitVector } from "../../Math/vec3";
 import { RADIANS } from "../../Math/methods";
+import { GlobeChangeObserver } from "./globe-changes";
 export const CameraUniformBlockString = `
 layout(std140) uniform CameraUniformBlock {
     mat4 view; // 64 bytes           0
@@ -29,6 +30,7 @@ export class CameraUniformBlockTotem {
     _isMovedParams;
     _normalizedCameraVector = [0, 0, 0]; // Normalized camera vector
     // _frustumPlanes: any; // Uncomment and type if used
+    _globeChangeObserver = null;
     constructor() {
         this.id = "CameraUniformBlockTotem";
         this.description =
@@ -51,6 +53,7 @@ export class CameraUniformBlockTotem {
         this.ubo = this._createUBO();
         this.traslateFloat32 = new Float32Array(3);
         this.mapWHFloat32 = new Float32Array(2);
+        this._globeChangeObserver = new GlobeChangeObserver(globe);
         this.setGeometry();
         this.resize();
     }
@@ -86,6 +89,7 @@ export class CameraUniformBlockTotem {
         const ubo = this.ubo;
         const mapWHFloat32 = this.mapWHFloat32;
         const globe = this.globe;
+        this._globeChangeObserver?.checkChanges();
         gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
         {
             // view, projection, translate
@@ -196,6 +200,9 @@ export class CameraUniformBlockTotem {
         fromLongLatToUnitVector(result, [CenterLong * RADIANS, CenterLat * RADIANS]);
         return result;
     }
+    getGlobeChanges() {
+        return this._globeChangeObserver?.getChanges();
+    }
     free() {
         const gl = this.gl;
         const ubo = this.ubo;

package/programs/totems/canvas-webglobe-info.js

@@ -1,13 +1,13 @@
 import { globeProgramCache } from "../programcache";
-export const WebGlobeInfoUniformBlockString = `
-layout(std140) uniform WebGlobeInfo {
-    vec2 canvas_resolution;
-    vec2 mouse_radian_long_lat;
-    vec2 mouse_pixel_xy;
-    float north_angle;
-    float world_tilt;
-    float earth_distance;
-}; 
+export const WebGlobeInfoUniformBlockString = `
+layout(std140) uniform WebGlobeInfo {
+    vec2 canvas_resolution;
+    vec2 mouse_radian_long_lat;
+    vec2 mouse_pixel_xy;
+    float north_angle;
+    float world_tilt;
+    float earth_distance;
+}; 
 `;
 export default class CanvasWebGlobeInfo {
     id;

package/programs/totems/globe-changes.js

@@ -0,0 +1,59 @@
+export class GlobeChangeObserver {
+    globe;
+    lastLOD = -1;
+    lastGeometry;
+    lastWorldWH = { width: 0, height: 0 };
+    lastLook = {
+        CenterLong: 0,
+        CenterLat: 0,
+        Distance: 0,
+        Tilt: 0,
+        NorthAng: 0
+    };
+    lastElevationCoefficient = NaN;
+    changes = {
+        geometry: false,
+        look: false,
+        lod: false,
+        lod2DWheel: false,
+        elevationScale: false,
+        screenMoved: false
+    };
+    constructor(globe) {
+        this.globe = globe;
+        this.lastGeometry = globe.api_GetCurrentGeometry();
+        this.lastLook = globe.api_GetCurrentLookInfo();
+        this.lastLOD = globe.api_GetCurrentLODWithDecimal();
+        this.lastWorldWH = globe.api_GetCurrentWorldWH();
+        this.lastElevationCoefficient = globe.api_GetZScale();
+    }
+    checkChanges() {
+        const globe = this.globe;
+        const currentGeometry = globe.api_GetCurrentGeometry();
+        const currentLook = globe.api_GetCurrentLookInfo();
+        const currentLOD = globe.api_GetCurrentLODWithDecimal();
+        const currentWorldWH = globe.api_GetCurrentWorldWH();
+        this.changes.geometry = (this.lastGeometry !== currentGeometry);
+        this.changes.look = (this.lastLook.CenterLong !== currentLook.CenterLong ||
+            this.lastLook.CenterLat !== currentLook.CenterLat ||
+            this.lastLook.Distance !== currentLook.Distance ||
+            this.lastLook.Tilt !== currentLook.Tilt ||
+            this.lastLook.NorthAng !== currentLook.NorthAng ||
+            this.lastWorldWH.width !== currentWorldWH.width ||
+            this.lastWorldWH.height !== currentWorldWH.height);
+        this.changes.lod = (this.lastLOD !== currentLOD);
+        this.changes.lod2DWheel = (!globe.api_IsScreenMoving() && this.changes.lod);
+        // Update last known states
+        this.lastGeometry = currentGeometry;
+        this.lastLook = currentLook;
+        this.lastLOD = currentLOD;
+        this.lastWorldWH = currentWorldWH;
+        this.changes.screenMoved = (this.changes.geometry ||
+            this.changes.look ||
+            this.changes.lod ||
+            this.changes.lod2DWheel);
+    }
+    getChanges() {
+        return this.changes;
+    }
+}

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

@@ -18,7 +18,7 @@ export const flatLinesInputAdapter = (bearingLine) => {
     };
 };
 export const flatLinesBearingInputAdapter = (bearingLine) => {
-    const { long, lat, rgba, key, bearingLat = 0, bearingLong = 0 } = bearingLine;
+    const { long, lat, rgba, key, bearingLat = 0, bearingLong = 0, msl } = bearingLine;
     return {
         key: key,
         start: [long, lat],
@@ -27,7 +27,7 @@ export const flatLinesBearingInputAdapter = (bearingLine) => {
     };
 };
 export const bearingLineToCircleInputAdapter = (globe) => (bearingLine) => {
-    const { long, lat, endLong, endLat, rgba, altitude = 0 } = bearingLine;
+    const { long, lat, endLong, endLat, rgba, altitude = 0, msl = null } = bearingLine;
     if (bearingLine.radius === undefined || bearingLine.radius === null) {
         const radius = globe.Math.GetDist2D(long, lat, endLong, endLat);
         bearingLine.radius = radius;
@@ -38,20 +38,22 @@ export const bearingLineToCircleInputAdapter = (globe) => (bearingLine) => {
         radius: bearingLine.radius,
         height: altitude,
         color: rgba,
+        msl
     };
 };
 export const bearingLineToArcInputAdapter = (bearingLine) => {
-    const { long, lat, endLong, endLat, rgba, altitude = 0 } = bearingLine;
+    const { long, lat, endLong, endLat, rgba, altitude = 0, msl } = bearingLine;
     return {
         key: bearingLine.key,
         start: [long, lat],
         end: [endLong, endLat],
         height: altitude,
         color: rgba,
+        msl: msl
     };
 };
 export const bearingLineToBearingArcInputAdapter = (globe, bearingLine) => {
-    const { long, lat, bearingAngle, rgba, altitude = 0, key } = bearingLine;
+    const { long, lat, bearingAngle, rgba, altitude = 0, key, msl } = bearingLine;
     if (bearingLine.radius === undefined || bearingLine.radius === null) {
         throw new Error("Bearing line radius is not defined. Please calculate it before converting to ArcInput.");
     }
@@ -64,6 +66,7 @@ export const bearingLineToBearingArcInputAdapter = (globe, bearingLine) => {
         end: [endLong, endLat],
         height: altitude,
         color: rgba,
+        msl,
     };
 };
 export const bearingLineToPieceOfPieInputAdapter = (globe, item) => {
@@ -71,7 +74,7 @@ export const bearingLineToPieceOfPieInputAdapter = (globe, item) => {
     const long = radian(item.long);
     const endLat = radian(item.endLat);
     const endLong = radian(item.endLong);
-    const altitude = (item.altitude ?? 0) / 1000;
+    const altitude = (item.altitude ?? 0);
     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);

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

@@ -32,7 +32,53 @@ export class BearingLinePlugin {
         flatStraightLineOn: true // This is a new option to control flat straight line drawing
     };
     _memory = new Map();
-    constructor(id, { textWritersMap, textDataPreAdaptor, opacities, drawOptions, } = {}) {
+    _semiPluginsOptions = {
+        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],
+            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, { textWritersMap, textDataPreAdaptor, opacities, drawOptions, circleOnTerrainOptions = {
+        defaultColor: [1, 1, 1, 0.5],
+        defaultHeightFromGroundIn3D: 30.0,
+        variativeColorsOn: false,
+    }, arcOnTerrainOptions = {
+        globeViewOn: true,
+        flatViewOn: false,
+        defaultColor: [1, 1, 1, 0.5],
+        defaultHeightFromGroundIn3D: 30.0,
+        variativeColorsOn: false,
+    }, lineOptions = {
+        flatViewOn: true,
+        globeViewOn: false,
+        variativeColorsOn: false,
+        defaultColor: [1, 1, 1, 0.5],
+    }, pieceOfPieOptions = {
+        defaultColor: [1, 1, 1, 0.5],
+        variativeColorsOn: false,
+        defaultHeightFromGroundIn3D: 1000.0,
+    } } = {}) {
         this.id = id;
         if (!(textWritersMap instanceof Map))
             throw new Error("textWritersMap is not an instance of Map");
@@ -40,28 +86,49 @@ export class BearingLinePlugin {
             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) => item.key));
         this._textDataPreAdaptor = textDataPreAdaptor || ((item) => item);
-        this.circlePlugin = new CircleOnTerrainPlugin(id + "_circle", {
-            variativeColorsOn: true,
-        });
+        this.circlePlugin = new CircleOnTerrainPlugin(id + "_circle", this._semiPluginsOptions.circleOnTerrainOptions);
         this.arcPlugin = new ArcOnTerrainPlugin(id + "_arc", {
-            variativeColorsOn: true,
+            ...this._semiPluginsOptions.arcOnTerrainOptions,
         });
         this.arcPluginBL = new ArcOnTerrainPlugin(id + "_arcBL", {
-            variativeColorsOn: true,
+            ...this._semiPluginsOptions.arcOnTerrainOptions,
         });
         this.pieceOfPiePlugin = new PieceOfPiePlugin(id + "_pieceOfPie", {
             bufferType: "DYNAMIC_DRAW",
+            ...this._semiPluginsOptions.pieceOfPieOptions
         });
         this.linePlugin = new LinePlugin(id + "_line", {
-            variativeColorsOn: true,
             bufferType: "DYNAMIC_DRAW",
+            ...this._semiPluginsOptions.lineOptions
         });
         this.linePluginBL = new LinePlugin(id + "_lineBL", {
-            variativeColorsOn: true,
-            bufferType: "DYNAMIC_DRAW",
+            ...this._semiPluginsOptions.lineOptions // flatViewOn: true,
         });
         if (opacities) {
             this._opacities = {
@@ -76,6 +143,39 @@ export class BearingLinePlugin {
             };
         }
     }
+    setDefaultSemiPluginColor(semiPluginName, 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) {
         if (this._freed) {
             throw new Error("Plugin has been freed, cannot set draw VRM.");
@@ -116,7 +216,6 @@ export class BearingLinePlugin {
         this.drawOptions.drawAngleRing = drawAngleRing;
         this.globe.DrawRender();
     }
-    // TODO:
     updatePartial(items, { textWriterIDs } = {}) {
         if (this._freed) {
             throw new Error("Plugin has been freed, cannot update item.");
@@ -313,11 +412,11 @@ export class BearingLinePlugin {
             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.setPluginOpacity(this._opacities.circle ?? this._opacities.general, false);
             this.circlePlugin.draw3D();
         }
         if (this.drawOptions.drawBearingLine) {
-            this.arcPluginBL.setPluginOpacity(this._opacities.arc ?? this._opacities.general);
+            this.arcPluginBL.setPluginOpacity(this._opacities.bearing ?? this._opacities.general, false);
             this.arcPluginBL.draw3D();
         }
         if (this.drawOptions.drawAngleRing) {
@@ -325,21 +424,19 @@ export class BearingLinePlugin {
             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.setPluginOpacity(opacity, false);
                 this.pieceOfPiePlugin.draw3D();
             }
         }
         const currentGeometry = this.globe.api_GetCurrentGeometry();
-        this.arcPlugin.setPluginOpacity(this._opacities.arc ?? this._opacities.general);
+        this.arcPlugin.setPluginOpacity(this._opacities.arc ?? this._opacities.general, false);
         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();
-            }
+        for (const textWriter of this._textWritersMap.values()) {
+            textWriter.draw();
         }
     }
     free() {