@pirireis/webglobeplugins 0.13.0-alpha → 0.14.0-alpha

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

@@ -0,0 +1,286 @@
+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,
+cartesian3DToGLPosition } from "../../../util/shaderfunctions/geometrytransformations";
+/**
+ * TODO:
+ * 1. Triangle face looks at screen. if rotation angle is positive the last vertex must be the faintest.
+ *
+ */
+const drawModeMap = Object.freeze({
+    LINE_STRIP: 0,
+    TRIANGLE_FAN: 1,
+});
+//${ circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate }
+const vertexShaderSource = `#version 300 es
+
+${CameraUniformBlockString} 
+${PI} 
+${longLatRadToMercator}
+${mercatorXYToGLPosition}
+${longLatRadToCartesian3D}
+${circleLimpFromLongLatRadCenterCartesian3D_accurate}
+${circleLimpFromLongLatRadCenterMercatorCompass_accurate}
+${cartesian3DToGLPosition}
+
+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; 
+in float tail_angle2d;
+
+in float start_angle3d;
+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;
+    if (filling_mode == 2.0 || radius == 0.0) { return; }
+    float start_angle, tail_angle;
+    if (is3D) {
+        start_angle = start_angle3d;
+        tail_angle = tail_angle3d;
+    } else {
+        start_angle = start_angle2d;
+        tail_angle = tail_angle2d;
+    }
+    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 ( filling_mode == 1.0 ) { alpha = 0.0; }
+        }
+        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 );
+            } else {
+                v_color = vec4( color.rgb , color.a * phase * alpha );
+        }
+    } else {
+        v_color = vec4( color.rgb , color.a * alpha );
+    }
+    if ( filling_mode == 0.0 && draw_mode == 1 ) {
+        v_color.a /= 2.0;
+    }
+    float angle;
+    if ( tail_angle > 0.0 ) { 
+        angle =  tail_angle * (-phase + 1.0) + start_angle;
+        } else {
+        angle = tail_angle * phase + start_angle;
+    }
+    if (is3D) {
+        vec3 pos = circleLimpFromLongLatRadCenterCartesian3D_accurate(center3d, radius_, angle);
+        v_pos = vec2(0.0, 0.0);
+        gl_Position = cartesian3DToGLPosition(pos);
+    }
+    else {
+        vec2 pos2 = circleLimpFromLongLatRadCenterMercatorCompass_accurate(center2d, radius_, angle);
+        v_pos = pos2;
+        gl_Position = mercatorXYToGLPosition(pos2);
+    }
+
+    gl_PointSize = 10.0;
+}`;
+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;
+}`;
+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;
+        this._lastMode = 0;
+        this._lastEdgeCount = 64;
+        this._lastAlphaMultiplier = 1.0;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+        const { gl, program } = this;
+        { // set attributes locations 
+            gl.bindAttribLocation(program, 0, 'center2d');
+            gl.bindAttribLocation(program, 1, 'center3d');
+            gl.bindAttribLocation(program, 2, 'start_angle2d');
+            gl.bindAttribLocation(program, 3, 'tail_angle2d');
+            gl.bindAttribLocation(program, 4, 'start_angle3d');
+            gl.bindAttribLocation(program, 5, 'tail_angle3d');
+            gl.bindAttribLocation(program, 6, 'color');
+            gl.bindAttribLocation(program, 7, 'radius');
+            gl.bindAttribLocation(program, 8, 'filling_mode');
+            // vao
+            // instanced draw read 1 
+        }
+        { // 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);
+            gl.useProgram(currentProgram);
+        }
+    }
+    draw(length, vao, edgeCount, alphaMultiplier, drawMode) {
+        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]);
+            this._lastMode = drawModeMap[drawMode];
+        }
+        if (edgeCount !== this._lastEdgeCount) {
+            gl.uniform1f(this._edgeCountLocation, edgeCount);
+            this._lastEdgeCount = edgeCount;
+        }
+        if (alphaMultiplier !== this._lastAlphaMultiplier) {
+            gl.uniform1f(this._plugin_alpha_multiplierLocation, alphaMultiplier);
+            this._lastAlphaMultiplier = alphaMultiplier;
+        }
+        const overdraw = drawModeMap[drawMode];
+        cameraBlockTotem.bind(cameraBlockBindingPoint);
+        gl.bindVertexArray(vao);
+        gl.drawArraysInstanced(gl[drawMode], 0, edgeCount + overdraw, length);
+        cameraBlockTotem.unbind(cameraBlockBindingPoint);
+        gl.bindVertexArray(null);
+        // gl.enable(gl.DEPTH_TEST);
+    }
+    free() {
+        noRegisterGlobeProgramCache.releaseProgram(this.globe, CameraUniformBlockTotem);
+        this.gl.deleteProgram(this.program);
+        this.program = null;
+    }
+    /**
+     * in vec2 center; // long, lat in radian
+    in float start_angle; // the start of partial circle from bearing point
+    in float tail_angle; // the rotation of the partial circle
+    in vec4 color;
+    in float radius; // in meter
+    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;
+        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);
+        }
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+    }
+    createUBO() {
+    }
+}
+export const PieceOfPieProgramCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+});

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/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
+};