@pirireis/webglobeplugins 0.10.13-alpha → 0.11.0-alpha

package/programs/totems/camerauniformblock.js

@@ -1,7 +1,4 @@
 import { globeProgramCache } from "../programcache";
-// import { getFrustumPlanes } from "../../Math/frustum/from-projection-matrix";
-// import { getFrustum } from "../../Math/frustum/from-globeinfo"
-// import { Plane } from "../../Math/";
 export const CameraUniformBlockString = `
 layout(std140) uniform CameraUniformBlock {
     mat4 view; // 64 bytes           0
@@ -19,24 +16,31 @@ layout(std140) uniform CameraUniformBlock {
 `;
 const Radian = Math.PI / 180.0;
 export default class CameraUniformBlockTotem {
+    id;
+    description;
+    gl;
+    globe;
+    ubo;
+    traslateFloat32;
+    mapWHFloat32;
+    _isMovedParams;
+    _normalizedCameraVector;
+    // _frustumPlanes: any; // Uncomment and type if used
     constructor() {
         this.id = "CameraUniformBlockTotem";
-        this.description = `Sets a uniform block and provides buffer for it. The following is the glsl uniform block:` + CameraUniformBlockString;
+        this.description =
+            `Sets a uniform block and provides buffer for it. The following is the glsl uniform block:` +
+                CameraUniformBlockString;
         this.gl = null;
         this.globe = null;
         this.ubo = null;
-        // this._frustumPlanes = {
-        //     left: new Plane(),
-        //     right: new Plane(),
-        //     top: new Plane(),
-        //     bottom: new Plane(),
-        //     near: new Plane(),
-        //     far: new Plane()
-        // }
+        // this._frustumPlanes = { ... }
         this._isMovedParams = {
             lastLod: null,
             isMoved: false,
         };
+        this.traslateFloat32 = new Float32Array(3);
+        this.mapWHFloat32 = new Float32Array(2);
     }
     init(globe, gl) {
         this.gl = gl;
@@ -48,7 +52,7 @@ export default class CameraUniformBlockTotem {
         this.resize();
     }
     _createUBO() {
-        const { gl } = this;
+        const gl = this.gl;
         const ubo = gl.createBuffer();
         gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
         // 184 bytes in reality. Overflow on linux for some reason. So, 200 bytes.
@@ -58,21 +62,30 @@ export default class CameraUniformBlockTotem {
         return ubo;
     }
     resize() {
-        const { gl, globe, ubo } = this;
+        const gl = this.gl;
+        const globe = this.globe;
+        const ubo = this.ubo;
         gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
         gl.bufferSubData(gl.UNIFORM_BUFFER, 152, new Float32Array([globe.api_ScrW(), globe.api_ScrH()]));
         gl.bindBuffer(gl.UNIFORM_BUFFER, null);
     }
     setGeometry() {
-        const { gl, globe, ubo } = this;
-        const is3D = globe.api_GetCurrentGeometry() === 0;
+        const gl = this.gl;
+        const globe = this.globe;
+        const ubo = this.ubo;
+        const is3D = globe.api_GetCurrentGeometry() === 0 ? 1 : 0;
         gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
         gl.bufferSubData(gl.UNIFORM_BUFFER, 140, new Float32Array([is3D]));
     }
     draw3D(projection, modelView, translate) {
-        const { gl, traslateFloat32, ubo, mapWHFloat32, globe } = this;
+        const gl = this.gl;
+        const traslateFloat32 = this.traslateFloat32;
+        const ubo = this.ubo;
+        const mapWHFloat32 = this.mapWHFloat32;
+        const globe = this.globe;
         gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
-        { // view, projection, translat
+        {
+            // view, projection, translate
             gl.bufferSubData(gl.UNIFORM_BUFFER, 0, modelView);
             gl.bufferSubData(gl.UNIFORM_BUFFER, 64, projection);
             traslateFloat32.set([translate.x, translate.y, translate.z], 0);
@@ -82,7 +95,8 @@ export default class CameraUniformBlockTotem {
             // zoom level
             gl.bufferSubData(gl.UNIFORM_BUFFER, 160, new Float32Array([globe.api_GetCurrentLODWithDecimal()]));
         }
-        { // mapWH
+        {
+            // mapWH
             if (globe.api_GetCurrentGeometry() === 1) {
                 const { width, height } = globe.api_GetCurrentWorldWH();
                 mapWHFloat32.set([width, height]);
@@ -96,49 +110,77 @@ export default class CameraUniformBlockTotem {
             // vec2 world_center_radian; // 8 bytes    180
             const { CenterLong, CenterLat, Distance, Tilt, NorthAng } = globe.api_GetCurrentLookInfo();
             gl.bufferSubData(gl.UNIFORM_BUFFER, 164, new Float32Array([
-                Distance, Radian * Tilt, Radian * NorthAng, Radian * CenterLong, Radian * CenterLat
+                Distance,
+                Radian * Tilt,
+                Radian * NorthAng,
+                Radian * CenterLong,
+                Radian * CenterLat,
             ]));
         }
         // this._frustumPlanes = getFrustumPlanes(projection, translate);
         gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-        { // isMoved
+        {
+            // isMoved
             const currentLOD = globe.api_GetCurrentLODWithDecimal();
-            this._isMovedParams.isMoved = this._isMovedParams.lastLod !== currentLOD || globe.api_IsScreenMoving();
+            this._isMovedParams.isMoved =
+                this._isMovedParams.lastLod !== currentLOD ||
+                    globe.api_IsScreenMoving();
             this._isMovedParams.lastLod = currentLOD;
         }
         // getFrustum(globe, 50, this._frustumPlanes);
+        this._normalizedCameraVector = (() => {
+            const { Fp } = globe;
+            const cameraVector = [Fp.x, Fp.y, Fp.z];
+            const length = Math.sqrt(cameraVector.reduce((sum, val) => sum + val * val, 0));
+            return cameraVector.map((val) => val / length);
+        })();
     }
     assignBindingPoint(program, bindingPoint) {
-        const { gl } = this;
+        const gl = this.gl;
         const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
         gl.uniformBlockBinding(program, cameraBlockIndex, bindingPoint);
     }
     getUBO() {
         return this.ubo;
     }
-    getFrustumPlanes() {
-        return this._frustumPlanes;
-    }
+    // getFrustumPlanes() {
+    //     return this._frustumPlanes;
+    // }
     bind(bindingPoint) {
-        const { gl, ubo } = this;
+        const gl = this.gl;
+        const ubo = this.ubo;
         gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, ubo);
     }
     unbind(bindingPoint) {
-        const { gl } = this;
+        const gl = this.gl;
         gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, null);
     }
     isMoved() {
         return this._isMovedParams.isMoved;
     }
+    getCameraVector() {
+        const globe = this.globe;
+        return [globe.Fp.x, globe.Fp.y, globe.Fp.z];
+    }
+    getNormalizedCameraVector() {
+        return this._normalizedCameraVector;
+    }
+    getCameraUpPosition() {
+        const globe = this.globe;
+        return [globe.FUPos.x, globe.FUPos.y, globe.FUPos.z];
+    }
     free() {
-        const { gl, ubo } = this;
+        const gl = this.gl;
+        const ubo = this.ubo;
         gl.deleteBuffer(ubo);
     }
     readBuffer() {
+        const gl = this.gl;
+        const ubo = this.ubo;
         const result = new Float32Array(41);
-        this.gl.bindBuffer(this.gl.UNIFORM_BUFFER, this.ubo);
-        this.gl.getBufferSubData(this.gl.UNIFORM_BUFFER, 0, result);
-        this.gl.bindBuffer(this.gl.UNIFORM_BUFFER, null);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.getBufferSubData(gl.UNIFORM_BUFFER, 0, result);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
         return {
             view: result.slice(0, 16),
             projection: result.slice(16, 32),
@@ -146,11 +188,15 @@ export default class CameraUniformBlockTotem {
             is3D: result[35],
             mapWH: result.slice(36, 38),
             screenWH: result.slice(38, 40),
-            z_level: result[40]
+            z_level: result[40],
         };
     }
 }
 export const CameraUniformBlockTotemCache = Object.freeze({
-    get: (globe) => { return globeProgramCache.getProgram(globe, CameraUniformBlockTotem); },
-    release: (globe) => { return globeProgramCache.releaseProgram(globe, CameraUniformBlockTotem); }
+    get: (globe) => {
+        return globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
+    },
+    release: (globe) => {
+        return globeProgramCache.releaseProgram(globe, CameraUniformBlockTotem);
+    },
 });

package/programs/totems/camerauniformblock1.js

@@ -0,0 +1,171 @@
+import { globeProgramCache } from "../programcache";
+// import { getFrustumPlanes } from "../../Math/frustum/from-projection-matrix";
+// import { getFrustum } from "../../Math/frustum/from-globeinfo"
+// import { Plane } from "../../Math/";
+export const CameraUniformBlockString = `
+layout(std140) uniform CameraUniformBlock {
+    mat4 view; // 64 bytes           0
+    mat4 projection; // 64 bytes     64
+    vec3 translate; // 12 bytes      128
+    bool is3D; // 4 bytes            140
+    vec2 mapWH; // 8 bytes           144
+    vec2 screenWH; //  8 bytes       152
+    float z_level; // 4 bytes        160 | 164
+    float world_distance; // 4 bytes 164
+    float world_tilt; // 4 bytes     168
+    float world_north_angle; // 4 bytes 172
+    vec2 world_center_radian; // 8 bytes    176 | 184
+}; // 14 lines
+`;
+const Radian = Math.PI / 180.0;
+export default class CameraUniformBlockTotem {
+    constructor() {
+        this.id = "CameraUniformBlockTotem";
+        this.description = `Sets a uniform block and provides buffer for it. The following is the glsl uniform block:` + CameraUniformBlockString;
+        this.gl = null;
+        this.globe = null;
+        this.ubo = null;
+        // this._frustumPlanes = {
+        //     left: new Plane(),
+        //     right: new Plane(),
+        //     top: new Plane(),
+        //     bottom: new Plane(),
+        //     near: new Plane(),
+        //     far: new Plane()
+        // }
+        this._isMovedParams = {
+            lastLod: null,
+            isMoved: false,
+        };
+    }
+    init(globe, gl) {
+        this.gl = gl;
+        this.globe = globe;
+        this.ubo = this._createUBO();
+        this.traslateFloat32 = new Float32Array(3);
+        this.mapWHFloat32 = new Float32Array(2);
+        this.setGeometry();
+        this.resize();
+    }
+    _createUBO() {
+        const { gl } = this;
+        const ubo = gl.createBuffer();
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        // 184 bytes in reality. Overflow on linux for some reason. So, 200 bytes.
+        gl.bufferData(gl.UNIFORM_BUFFER, 200, gl.STREAM_DRAW);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, 0, ubo);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        return ubo;
+    }
+    resize() {
+        const { gl, globe, ubo } = this;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 152, new Float32Array([globe.api_ScrW(), globe.api_ScrH()]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+    setGeometry() {
+        const { gl, globe, ubo } = this;
+        const is3D = globe.api_GetCurrentGeometry() === 0;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 140, new Float32Array([is3D]));
+    }
+    draw3D(projection, modelView, translate) {
+        const { gl, traslateFloat32, ubo, mapWHFloat32, globe } = this;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        { // view, projection, translat
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 0, modelView);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 64, projection);
+            traslateFloat32.set([translate.x, translate.y, translate.z], 0);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 128, traslateFloat32);
+        }
+        {
+            // zoom level
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 160, new Float32Array([globe.api_GetCurrentLODWithDecimal()]));
+        }
+        { // mapWH
+            if (globe.api_GetCurrentGeometry() === 1) {
+                const { width, height } = globe.api_GetCurrentWorldWH();
+                mapWHFloat32.set([width, height]);
+                gl.bufferSubData(gl.UNIFORM_BUFFER, 144, mapWHFloat32);
+            }
+        }
+        {
+            // float world_distance; // 4 bytes 164
+            // float world_tilt; // 4 bytes     168
+            // float world_north_angle; // 4 bytes 172
+            // vec2 world_center_radian; // 8 bytes    180
+            const { CenterLong, CenterLat, Distance, Tilt, NorthAng } = globe.api_GetCurrentLookInfo();
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 164, new Float32Array([
+                Distance, Radian * Tilt, Radian * NorthAng, Radian * CenterLong, Radian * CenterLat
+            ]));
+        }
+        // this._frustumPlanes = getFrustumPlanes(projection, translate);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        { // isMoved
+            const currentLOD = globe.api_GetCurrentLODWithDecimal();
+            this._isMovedParams.isMoved = this._isMovedParams.lastLod !== currentLOD || globe.api_IsScreenMoving();
+            this._isMovedParams.lastLod = currentLOD;
+        }
+        // getFrustum(globe, 50, this._frustumPlanes);
+        this._normalizedCameraVector = (() => {
+            const { Fp, FUPos } = globe;
+            const cameraVector = [Fp.x, Fp.y, Fp.z];
+            const length = Math.sqrt(cameraVector.reduce((sum, val) => sum + val * val, 0));
+            return normalizedCameraVector.map(val => val / length);
+        })();
+    }
+    assignBindingPoint(program, bindingPoint) {
+        const { gl } = this;
+        const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        gl.uniformBlockBinding(program, cameraBlockIndex, bindingPoint);
+    }
+    getUBO() {
+        return this.ubo;
+    }
+    getFrustumPlanes() {
+        return this._frustumPlanes;
+    }
+    bind(bindingPoint) {
+        const { gl, ubo } = this;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, ubo);
+    }
+    unbind(bindingPoint) {
+        const { gl } = this;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, null);
+    }
+    isMoved() {
+        return this._isMovedParams.isMoved;
+    }
+    getCameraVector() {
+        return [this.globe.Fp.x, this.globe.Fp.y, this.globe.Fp.z];
+    }
+    getNormalizedCameraVector() {
+        return this._normalizedCameraVector;
+    }
+    getCameraUpPosition() {
+        return [this.globe.FUPos.x, this.globe.FUPos.y, this.globe.FUPos.z];
+    }
+    free() {
+        const { gl, ubo } = this;
+        gl.deleteBuffer(ubo);
+    }
+    readBuffer() {
+        const result = new Float32Array(41);
+        this.gl.bindBuffer(this.gl.UNIFORM_BUFFER, this.ubo);
+        this.gl.getBufferSubData(this.gl.UNIFORM_BUFFER, 0, result);
+        this.gl.bindBuffer(this.gl.UNIFORM_BUFFER, null);
+        return {
+            view: result.slice(0, 16),
+            projection: result.slice(16, 32),
+            translate: result.slice(32, 35),
+            is3D: result[35],
+            mapWH: result.slice(36, 38),
+            screenWH: result.slice(38, 40),
+            z_level: result[40]
+        };
+    }
+}
+export const CameraUniformBlockTotemCache = Object.freeze({
+    get: (globe) => { return globeProgramCache.getProgram(globe, CameraUniformBlockTotem); },
+    release: (globe) => { return globeProgramCache.releaseProgram(globe, CameraUniformBlockTotem); }
+});

package/shape-on-terrain/arc/naive/plugin.js

@@ -5,17 +5,21 @@
 // import { populateFloat32Array } from "../../../util/jshelpers/data-filler";
 // import { BufferManagementMap, BufferManager, BufferOrchestrator } from "../../../util/account/single-attribute-buffer-management/index";
 // import { globe3Dcoordinates, globe2Dcoordinates, RADIANS } from "../../../Math/methods";
+// import { generateArcPoints } from "../../../Math/arc-generate-points";
 // import { Vec3, Plane, Arc } from "../../../Math/types";
 // import * as vec3 from "../../../Math/vec3";
 // import * as plane from "../../../Math/plane";
 // import * as arc from "../../../Math/arc";
-// import { arcFrustumPlanesIntersection } from "../../../Math/intersections/arc-frustum-planes";
-// import { CameraUniformBlockTotemCache, CameraUniformBlockTotem } from "../../../programs/totems/camerauniformblock";
+// // import { arcFrustumPlanesIntersection } from "../../../Math/intersections/arc-frustum-planes";
+// import CameraUniformBlockTotem, { CameraUniformBlockTotemCache } from "../../../programs/totems/camerauniformblock";
 // import { FrustumPlanes } from "../../../Math/frustum/types";
 // const VERTEX_COUNT = 360;
 // const INITAL_CAPACITY = 10;
 // const _0vector = [0, 0, 0] as Vec3;
-// const _0arc = arcCreate([1, 0, 0] as Vec3, [0, 1, 0] as Vec3); // zero arc for intersection tests
+// const _attractionPoint = [0, 0, 0] as Vec3;
+// const _start = [0, 0, 0] as Vec3;
+// const _end = [0, 0, 0] as Vec3;
+// const _0arc = arc.create([1, 0, 0] as Vec3, [0, 1, 0] as Vec3); // zero arc for intersection tests
 // // window add properties
 // declare global {
 //     interface Window {
@@ -24,11 +28,6 @@
 //     }
 // }
 // let interval = 1;
-// const testVec = [0, 0, 0] as Vec3;
-// testVec.fromL(30 * RADIANS, 30 * RADIANS);
-// console.log("testVec", testVec.x, testVec.y, testVec.z);
-// testVec.fromL(50 * RADIANS, 50 * RADIANS);
-// console.log("testVec", testVec.x, testVec.y, testVec.z);
 // export class NaiveLineOnTerrainPlugin {
 //     public id: string;
 //     private program: ProgramInterface | null = null;
@@ -45,9 +44,10 @@
 //     private gl: WebGL2RenderingContext | null = null;
 //     private _arcMap: Map<string, Arc>;
 //     private _arcMapTest: Map<string, Arc>;
-//     private _screenPlane: Plane = new Plane();
+//     private _screenPlane: Plane = { normal: [0, 0, 1] as Vec3, distance: 0 } as Plane;
 //     private _doBuild: boolean = false
-//     private _cameraUniformBlock: CameraUniformBlockTotem;
+//     private _cameraUniformBlock: CameraUniformBlockTotem | null = null;
+//     private _attractionStrength: number = 50;
 //     public fieldOfView = 50 * RADIANS; // 50 degrees in radians
 //     constructor(id: string) {
 //         this.id = id;
@@ -58,30 +58,32 @@
 //         if (this._arcMap.has(key)) {
 //             this._arcMap.delete(key);
 //         }
-//         const start = _0vector.setFromLongLat(startPoint.long * RADIANS, startPoint.lat * RADIANS).clone();
-//         const end = _0vector.setFromLongLat(endPoint.long * RADIANS, endPoint.lat * RADIANS).clone();
-//         window.startPoint = start;
-//         window.endPoint = end;
-//         const arc = new Arc(start, end);
-//         this._arcMap.set(key, arc);
-//         this._arcMapTest.set(key, arc.clone());
-//         const longLatArr = new Float32Array(2 * VERTEX_COUNT);
-//         const _3Dpoints = arc.populatePoints3D(VERTEX_COUNT);
-//         const longLat = {
-//             long: 1,
-//             lat: 1
-//         };
-//         for (let i = 0; i < _3Dpoints.length / 3; i++) {
-//             _0vector.set(_3Dpoints[i * 3], _3Dpoints[i * 3 + 1], _3Dpoints[i * 3 + 2]).toLongLat(longLat);
-//             longLatArr.set([longLat.long / RADIANS, longLat.lat / RADIANS], i * 2);
-//         }
-//         const result = [{
-//             key: key,
-//             longLatArr: longLatArr,
-//         }
-//         ]
-//         this._testOrchestrator.insertBulk(result, this._bufferManagersCompMapTest);
+//         vec3.fromUnitVectorLongLat(_start, [startPoint.long * RADIANS, startPoint.lat * RADIANS]);
+//         vec3.fromUnitVectorLongLat(_end, [endPoint.long * RADIANS, endPoint.lat * RADIANS]);
+//         window.startPoint = _start;
+//         window.endPoint = _end;
+//         const _arc = arc.create(_start, _end);
+//         this._arcMap.set(key, _arc);
+//         this._arcMapTest.set(key, arc.clone(_arc));
+//         // const longLatArr = new Float32Array(2 * VERTEX_COUNT);
+//         // //
+//         // const _3Dpoints = generateArcPoints(_start, _end, VERTEX_COUNT);
+//         // const longLat = {
+//         //     long: 1,
+//         //     lat: 1
+//         // };
+//         // for (let i = 0; i < _3Dpoints.length / 3; i++) {
+//         //     _0vector.set(_3Dpoints[i * 3], _3Dpoints[i * 3 + 1], _3Dpoints[i * 3 + 2]).toLongLat(longLat);
+//         //     longLatArr.set([longLat.long / RADIANS, longLat.lat / RADIANS], i * 2);
+//         // }
+//         // const result = [{
+//         //     key: key,
+//         //     longLatArr: longLatArr,
+//         // }
+//         // ]
+//         // this._testOrchestrator.insertBulk(result, this._bufferManagersCompMapTest);
 //         this._doBuild = true;
+//         this.globe.DrawRender();
 //     }
 //     init(globe: any, gl: WebGL2RenderingContext) {
 //         this.globe = globe;
@@ -130,7 +132,7 @@
 //             ]
 //         ]
 //         );
-//         this._bufferOrchestrator = new BufferOrchestrator(gl, this._bufferManagersCompMap);
+//         this._bufferOrchestrator = new BufferOrchestrator();
 //         this._arcUBOHandler = this.program.createUBO();
 //         this._arcUBOHandler.update(new Map([
 //             ["u_color", new Float32Array([1, 0, 0, 1])],
@@ -140,15 +142,15 @@
 //             ["u_color", new Float32Array([0, 0, 1, 1])],
 //         ]));
 //         this._vao = this.program.createVAO(
-//             createBufferAndReadInfo(this._bufferManagersCompMap.get("position3d").bufferManager.buffer),
-//             createBufferAndReadInfo(this._bufferManagersCompMap.get("position2d").bufferManager.buffer),
+//             createBufferAndReadInfo(this._bufferManagersCompMap.get("position3d")?.bufferManager.buffer as WebGLBuffer),
+//             createBufferAndReadInfo(this._bufferManagersCompMap.get("position2d")?.bufferManager.buffer as WebGLBuffer),
 //             null,
 //             null,
 //             null,
 //         );
 //         this._vaoAllTest = this.program.createVAO(
-//             createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest3d").bufferManager.buffer),
-//             createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest2d").bufferManager.buffer),
+//             createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest3d")?.bufferManager.buffer as WebGLBuffer),
+//             createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest2d")?.bufferManager.buffer as WebGLBuffer),
 //             null,
 //             null,
 //             null,
@@ -159,54 +161,88 @@
 //         this.globe.DrawRender();
 //     }
 //     _buildArcs() {
-//         // updatePlane
-//         const { globe, _arcMap } = this;
-//         const planes = this._cameraUniformBlock.getFrustumPlanes() as FrustumPlanes;
-//         //
-//         const cameraPostition = new Vector3D();
-//         cameraPostition.copy(globe.Fp as Vector3D).normalize();
-//         // calculateHorizonPlane(globe, _screenPlane, this.fieldOfView);
+//         const { globe, _arcMap, _cameraUniformBlock } = this;
+//         const cameraPositionNormalized = _cameraUniformBlock.getCameraPositionNormalized() as Vec3;
 //         const result = [];
-//         const longLat = {
-//             long: 1,
-//             lat: 1
-//         }
-//         let counter = 0;
-//         for (const [key, arc] of _arcMap) {
-//             // const isArc = arc.intersectionMedium(_screenPlane, _0arc) as Arc;
-//             _0arc.copy(arc);
-//             const isArc = arcFrustumPlanesIntersection(_0arc, planes, _0arc);
-//             if (!isArc) {
-//                 continue;
+//         const longLat = [0, 0] as [number, number];
+//         for (const [key, arcInstance] of _arcMap) {
+//             arc.copy(_0arc, arcInstance);
+//             const isOnArc = arc.closestPoint(_attractionPoint, _0arc, cameraPositionNormalized);
+//             if (!isOnArc) {
+//                 vec3.distanceSquared(cameraPositionNormalized, _0arc.p0) < vec3.distanceSquared(cameraPositionNormalized, _0arc.p1) ?
+//                     vec3.copy(_attractionPoint, _0arc.p0) : vec3.copy(_attractionPoint, _0arc.p1);
 //             }
-//             counter++;
+//             const generatedPoints = generateArcPoints(_0arc.p0, _0arc.p1, _0arc.normal, _attractionPoint, VERTEX_COUNT, this._attractionStrength);
 //             const longLatArr = new Float32Array(2 * VERTEX_COUNT);
-//             // const _3Dpoints = _0arc.populatePoints3DInRespectToCamera(cameraPostition, VERTEX_COUNT);
-//             const _3Dpoints = _0arc.populatePoints3D(VERTEX_COUNT);
-//             for (let i = 0; i < _3Dpoints.length / 3; i++) {
-//                 _0vector.set(_3Dpoints[i * 3], _3Dpoints[i * 3 + 1], _3Dpoints[i * 3 + 2]).toLongLat(longLat);
-//                 longLatArr.set([longLat.long / RADIANS, longLat.lat / RADIANS], i * 2);
+//             for (let i = 0; i < generatedPoints.length; i++) {
+//                 const point = generatedPoints[i];
+//                 vec3.toUnitVectorLongLat(longLat, point);
+//                 longLatArr.set([longLat[0] / RADIANS, longLat[1] / RADIANS], i * 2);
 //             }
 //             result.push({
 //                 key: key,
 //                 longLatArr: longLatArr,
-//             });
-//             // if (!arc.imaginaryPlane.equals(_0arc.imaginaryPlane) || !arc.imaginaryPlane.equalsReverseOriantation(_0arc.imaginaryPlane)) {
-//             //     // console.log("Arc with key", key, "has imaginary plane equal to the original arc's imaginary plane.");
-//             //     throw new Error("The arc segment is not on the parent arc")
-//             // }
-//         }
-//         interval += 1;
-//         if (interval === 100) {
-//             interval = 1;
-//             console.log("Arc count on screen:", counter);
+//             })
 //         }
-//         // update buffer
 //         this._bufferOrchestrator.resetWithCapacity(this._bufferManagersCompMap, result.length);
 //         this._bufferOrchestrator.insertBulk(result, this._bufferManagersCompMap);
-//         this._doBuild = false;
+//         this._doBuild = false; // reset build flag
 //         this._checkIfCorrupted(); // check if any arc is corrupted
 //     }
+//     setAttractionStrength(strength: number) {
+//         this._attractionStrength = strength;
+//         this._doBuild = true; // trigger rebuild
+//         this.globe.DrawRender();
+//     }
+//     // _buildArcs() {
+//     //     // updatePlane
+//     //     const { globe, _arcMap } = this;
+//     //     const planes = this._cameraUniformBlock.getFrustumPlanes() as FrustumPlanes;
+//     //     //
+//     //     const cameraPostition = new Vector3D();
+//     //     cameraPostition.copy(globe.Fp as Vector3D).normalize();
+//     //     // calculateHorizonPlane(globe, _screenPlane, this.fieldOfView);
+//     //     const result = [];
+//     //     const longLat = {
+//     //         long: 1,
+//     //         lat: 1
+//     //     }
+//     //     let counter = 0;
+//     //     for (const [key, arc] of _arcMap) {
+//     //         // const isArc = arc.intersectionMedium(_screenPlane, _0arc) as Arc;
+//     //         _0arc.copy(arc);
+//     //         const isArc = arcFrustumPlanesIntersection(_0arc, planes, _0arc);
+//     //         if (!isArc) {
+//     //             continue;
+//     //         }
+//     //         counter++;
+//     //         const longLatArr = new Float32Array(2 * VERTEX_COUNT);
+//     //         // const _3Dpoints = _0arc.populatePoints3DInRespectToCamera(cameraPostition, VERTEX_COUNT);
+//     //         const _3Dpoints = _0arc.populatePoints3D(VERTEX_COUNT);
+//     //         for (let i = 0; i < _3Dpoints.length / 3; i++) {
+//     //             _0vector.set(_3Dpoints[i * 3], _3Dpoints[i * 3 + 1], _3Dpoints[i * 3 + 2]).toLongLat(longLat);
+//     //             longLatArr.set([longLat.long / RADIANS, longLat.lat / RADIANS], i * 2);
+//     //         }
+//     //         result.push({
+//     //             key: key,
+//     //             longLatArr: longLatArr,
+//     //         });
+//     //         // if (!arc.imaginaryPlane.equals(_0arc.imaginaryPlane) || !arc.imaginaryPlane.equalsReverseOriantation(_0arc.imaginaryPlane)) {
+//     //         //     // console.log("Arc with key", key, "has imaginary plane equal to the original arc's imaginary plane.");
+//     //         //     throw new Error("The arc segment is not on the parent arc")
+//     //         // }
+//     //     }
+//     //     interval += 1;
+//     //     if (interval === 100) {
+//     //         interval = 1;
+//     //         console.log("Arc count on screen:", counter);
+//     //     }
+//     //     // update buffer
+//     //     this._bufferOrchestrator.resetWithCapacity(this._bufferManagersCompMap, result.length);
+//     //     this._bufferOrchestrator.insertBulk(result, this._bufferManagersCompMap);
+//     //     this._doBuild = false;
+//     //     this._checkIfCorrupted(); // check if any arc is corrupted
+//     // }
 //     draw3D() {
 //         // Drawing logic here
 //         this._buildArcs() // can be async

package/types.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @typedef DrawRange
  * @type {Object}
@@ -10,6 +9,4 @@
  * @property {null|DrawRange} drawRange
  * @property {null|Int32List} indexes
  */
-/**
- * * @typedef {Array<number>} Color rgba color 0-1 values
- */
+export {};