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

package/Math/globe-util/horizon-plane.js

@@ -0,0 +1,112 @@
+"use strict";
+// TODO: REMOVE
+// // import { Vector3D, Quaternion, Plane, Ray, Matrix4 } from 'your-3d-math-library'; // <-- ADAPT THIS IMPORT
+// import { Vector3D } from '../vector3d';
+// import { Plane } from '../plane';
+// import { Line } from '../line';
+// import { Matrix4 } from '../matrix4';
+// import { Quaternion } from '../quaternion';
+// // --- Assume these static helper variables exist within your class ---
+// const _lookFromOrigin = new Vector3D();
+// const _cameraPosition = new Vector3D();
+// const _finalForward = new Vector3D();
+// const _approxUp = new Vector3D();
+// const _finalRight = new Vector3D();
+// const _finalUp = new Vector3D();
+// const _tempVec = new Vector3D(); // General purpose helper
+// const _initialBottomRayDir = new Vector3D();
+// const _qOrient = new Quaternion();
+// const _rollQuaternion = new Quaternion();
+// const _rotationMatrix = new Matrix4();
+// const _fieldOfViewBottomRay = new Line(new Vector3D(), new Vector3D());
+// const _origin3d = new Vector3D(0, 0, 0); // Globe Center
+// // --- Assume these constants exist ---
+// const WORLD_RADIUS_3D = 6371000; // Example: Earth radius
+// const FIELD_OF_VIEW = (25 * Math.PI) / 180; // Example: 25 degrees half-FOV in radians
+// // // --- Assume Plane class has these methods ---
+// // interface Plane {
+// //     setFromNormalAndPoint(normal: Vector3D, point: Vector3D): this;
+// //     set(normal: Vector3D, constant: number): this;
+// //     // ... other plane methods
+// // }
+// // // --- Assume Ray class has these methods ---
+// // interface Ray {
+// //     origin: Vector3D;
+// //     direction: Vector3D;
+// //     intersectionSphere(center: Vector3D, radius: number): Vector3D[] | null; // Or similar
+// //     // ... other ray methods
+// // }
+// // // --- Assume Vector3D has setFromLongLat ---
+// // interface Vector3D {
+// //     setFromLongLat(lon: number, lat: number): this;
+// //     // ... other vector methods
+// // }
+// // // --- END OF ASSUMPTIONS ---
+// /**
+//  * Calculates a culling plane representing the bottom edge of the camera's field of view.
+//  * @param globe - The globe object, expected to have api_GetCurrentLookInfo and Fp properties.
+//  * @param out - The Plane object to store the result.
+//  * @param fieldOfView - The vertical half-angle of the field of view in radians.
+//  * @returns The calculated Plane.
+//  */
+// function calculateHorizonPlane(globe: any, out: Plane, fieldOfView: number = FIELD_OF_VIEW): Plane {
+//     const cameraLookInfo = globe.api_GetCurrentLookInfo();
+//     cameraLookInfo.CenterLong *= Math.PI / 180;
+//     cameraLookInfo.CenterLat *= Math.PI / 180;
+//     // cameraLookInfo.Tilt *= Math.PI / 180; // Tilt is now implicitly handled
+//     cameraLookInfo.NorthAng *= Math.PI / 180;
+//     // Set _lookFromOrigin based on camera target (Lon/Lat)
+//     (_lookFromOrigin as any).setFromLongLat(cameraLookInfo.CenterLong, cameraLookInfo.CenterLat); // Cast to any if setFromLongLat is custom
+//     // 1. Calculate _cameraPosition and _finalForward (_lookFromCamera)
+//     _cameraPosition.set(globe.Fp.x, globe.Fp.y, globe.Fp.z); // Using your X negation
+//     _cameraPosition.divideScalar(WORLD_RADIUS_3D); // Scale to unit sphere
+//     Vector3D.subVectors(_lookFromOrigin, _cameraPosition, _finalForward).normalize();
+//     // 2. Calculate Q_orient (Final Camera Orientation Quaternion)
+//     // Use the vector from origin to camera as an initial 'up' reference
+//     _approxUp.copy(_cameraPosition).normalize();
+//     // Calculate Right vector using cross product
+//     Vector3D.crossVectors(_finalForward, _approxUp, _finalRight).normalize();
+//     // Handle edge case: If looking straight along (or opposite to) _approxUp
+//     if (_finalRight.lengthSq() < 0.0001) {
+//         // If vectors are parallel, _approxUp is not good.
+//         // Choose a different 'up', e.g., if _approxUp is near Z, use Y.
+//         if (Math.abs(_approxUp.z) > 0.9) {
+//             _approxUp.set(0, 1, 0);
+//         } else {
+//             _approxUp.set(0, 0, 1);
+//         }
+//         Vector3D.crossVectors(_finalForward, _approxUp, _finalRight).normalize();
+//     }
+//     // Calculate the 'true' Up vector, orthogonal to Right and Forward
+//     Vector3D.crossVectors(_finalRight, _finalForward, _finalUp).normalize();
+//     // Apply NorthAng (Roll) around the Forward axis
+//     _rollQuaternion.setFromAxisAngle(_finalForward, cameraLookInfo.NorthAng);
+//     _finalUp.applyQuaternion(_rollQuaternion);
+//     _finalRight.applyQuaternion(_rollQuaternion); // Must rotate Right as well!
+//     // Create Q_orient from the final basis vectors (Right, Up, -Forward)
+//     // This assumes a Matrix4.makeBasis(x, y, z) exists and builds a rotation matrix.
+//     // It also assumes local camera looks down -Z, hence negating _finalForward for the Z basis.
+//     _tempVec.copy(_finalForward).negate();
+//     _rotationMatrix.makeBasis(_finalRight, _finalUp, _tempVec); // <-- ADAPT: Ensure your library has makeBasis or equivalent
+//     _qOrient.setFromRotationMatrix(_rotationMatrix); // <-- ADAPT: Ensure this function exists
+//     // 3. Calculate Initial Bottom Ray (Local: -Z forward, Y up, X right)
+//     // Rotates (0, 0, -1) around (1, 0, 0) by fieldOfView
+//     _initialBottomRayDir.set(0, -Math.sin(fieldOfView), -Math.cos(fieldOfView));
+//     // 4. Calculate Final Bottom Ray (World)
+//     _fieldOfViewBottomRay.direction.copy(_initialBottomRayDir).applyQuaternion(_qOrient).normalize();
+//     _fieldOfViewBottomRay.origin.copy(_cameraPosition);
+//     // 5. Intersection and Plane
+//     const intersection = (_fieldOfViewBottomRay as any).intersectionSphere(_origin3d, 1); // Cast to any if method isn't standard
+//     if (intersection && intersection.length > 0) {
+//         // If ray intersects, use the closest point for the plane
+//         out.setFromNormalAndPoint(_lookFromOrigin, intersection[0]);
+//     } else {
+//         // If ray does not intersect (FOV covers globe or misses)
+//         // WARNING: This sets a plane through the globe's center.
+//         // This might not be the desired behavior for culling.
+//         // Consider what should happen if the whole globe *is* visible.
+//         out.set(_lookFromOrigin, 0.0);
+//     }
+//     return out;
+// }
+// export { calculateHorizonPlane };

package/Math/methods.js

@@ -73,13 +73,13 @@ export const pixelXYLenghtToUnitVectorWithHeight = (pixelXYHeight) => {
     const radius = WORLD_RADIUS_3D + pixelXYHeight[2];
     return [...radianToCartesian3d([long, lat]), radius];
 };
-export const globe3Dcoordinates = (globe, longlats, height = 0, msl = false, { paddingCount = 0, paddingValue = NaN }) => {
+export const globe3Dcoordinates = (globe, height = 0) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
     const len = longlats.length / 2;
     const result = new Float32Array(len * 3 + paddingCount * 3).fill(paddingValue);
     for (let i = 0; i < len; i++) {
         const long = longlats[i * 2];
         const lat = longlats[i * 2 + 1];
-        const xyz = globe.api_GetCartesian3DPoint(long, lat, height, msl);
+        const xyz = globe.api_GetCartesian3DPoint(long, lat, height, 0);
         result.set(xyz, i * 3);
     }
     return result;

package/Math/vec3.js

@@ -60,11 +60,7 @@ function length(a) {
 function normalize(outVec, inVec) {
     const len = length(inVec);
     if (len === 0) {
-        console.warn('Cannot normalize a zero vector');
-        outVec[0] = 0;
-        outVec[1] = 0;
-        outVec[2] = 0;
-        return;
+        throw new Error('Cannot normalize a zero vector');
     }
     outVec[0] = inVec[0] / len;
     outVec[1] = inVec[1] / len;
@@ -85,7 +81,7 @@ function equals(a, b) {
         Math.abs(a[2] - b[2]) < EPSILON);
 }
 function fromUnitVectorToLongLat(out, a) {
-    const len = length(a);
+    const len = length(a); // TODO Might drop length check 
     if (len === 0) {
         throw new Error('Cannot convert a zero vector to unit vector');
     }

package/altitude-locator/draw-subset-obj.js

@@ -0,0 +1,16 @@
+import "./types";
+/**
+ * @param {DrawSubsetOptions} drawSubsetOptions
+ */
+// TODO: Draw all is an optional property for the target plugin, with this approach.
+class DrawSubsetOptionRegistry {
+    constructor() {
+        this._drawSubsetOptions = new Map();
+    }
+    register(key, drawSubsetOptions) {
+        this._drawSubsetOptions.set(key, drawSubsetOptions);
+    }
+    unregister(key) {
+        this._drawSubsetOptions.delete(key);
+    }
+}

package/altitude-locator/plugin.js

@@ -335,7 +335,7 @@ class PointGlowLineToEarthPlugin {
         });
     }
     _doesChanged() {
-        return this.globe.api_IsScreenMoving();
+        return this._cameraBlockTotem.isMoved() || this._parametersChanged; // TODO: implement
     }
     _changed() {
         this._parametersChanged = true;

package/bearing-line/plugin.js

@@ -397,9 +397,8 @@ export default class BearingLinePlugin {
         const drawRange = { first: 0, count: this.bufferOrchestrator.length };
         this.lineProgram.draw(this.lineVao, { drawRange }, this._opacity);
         if (this.drawAngleRing) {
-            this.pieceOfPieProgram._defaultFlexibleUBO.updateSingle("u_opacity", this._opacity * 0.8);
-            this.pieceOfPieProgram.draw(this.bufferOrchestrator.length, this.ringVao, 360, RINGPARTIAL_DRAW_MODE.TRIANGLE_FAN);
-            this.pieceOfPieProgram.draw(this.bufferOrchestrator.length, this.ringVao, 360, RINGPARTIAL_DRAW_MODE.LINE_STRIP);
+            this.pieceOfPieProgram.draw(this.bufferOrchestrator.length, this.ringVao, 360, this._opacity * 0.8, RINGPARTIAL_DRAW_MODE.TRIANGLE_FAN);
+            this.pieceOfPieProgram.draw(this.bufferOrchestrator.length, this.ringVao, 360, this._opacity * 0.8, RINGPARTIAL_DRAW_MODE.LINE_STRIP);
         }
         if (this.drawBearingLine) {
             // this.lineProgram.draw(this.bearingLineVAO, this.bufferOrchestrator.length, this._opacity );

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.15.23.alpha",
+    "version": "0.15.2-alpha",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT",

package/point-tracks/plugin.js

@@ -1,4 +1,4 @@
-import { BufferOrchestrator, BufferManager, ObjectStore } from "../util/account/index";
+import { BufferOrchestrator, BufferManager, ObjectStore } from "../util/account";
 import { PickerDisplayer } from "../util/picking/picker-displayer";
 import { PointOnGlobeProgramCache } from "../programs/point-on-globe/square-pixel-point";
 import { wgs84ToCartesian3d, wgs84ToMercator } from "../Math/methods";
@@ -14,7 +14,7 @@ const _0vec3 = /* @__PURE__ */ [0, 0, 0];
  * @typedef {Array<Point>, rgba, trackID} Track
  */
 class PointTracksPlugin {
-    constructor(id, { pointSize = 2, hoveredPointSize = 4, selectionPointFilling = 4, opacity = 1.0, objectStoreExtraParameters = ["long", "lat", "height"], initialCapacity = 1000 } = {}) {
+    constructor(id, { pointSize = 2, hoveredPointSize = 4, selectionPointFilling = 4, opacity = 1.0 } = {}) {
         this.id = id;
         this._isFreed = false;
         this._pointProgram = null;
@@ -25,20 +25,15 @@ class PointTracksPlugin {
         this._selectedID = -1;
         this._selectedObj = null;
         this._tracksToPointsMap = new Map(); // one to many
-        this._opacity = opacity ? opacity : 1.0;
+        this._opacity = opacity;
         this.program = null;
         this._lastWH = { w: 0, h: 0 };
         this._focusParams = { on: false, length: 0, elementBuffer: null, trackIDs: [] };
         this.pointSizes = {
-            pointSize: pointSize ? pointSize : 2,
-            selectionPointFilling: selectionPointFilling ? selectionPointFilling : 4,
-            hoveredPointSize: hoveredPointSize ? hoveredPointSize : 4
+            pointSize,
+            selectionPointFilling,
+            hoveredPointSize
         };
-        this._objectStoreExtraParameters = objectStoreExtraParameters ? objectStoreExtraParameters : [];
-        this._objectStoreExtraParametersFiltered = objectStoreExtraParameters.filter(param => {
-            return !["long", "lat", "height", "ID", "trackID"].includes(param);
-        });
-        this._bufferOrchestrator = new BufferOrchestrator({ capacity: initialCapacity ? initialCapacity : 1000 });
     }
     init(globe, gl) {
         this.globe = globe;
@@ -50,8 +45,9 @@ class PointTracksPlugin {
     }
     _initBufferManagers() {
         const { gl } = this;
-        const initialCapacity = this._bufferOrchestrator.capacity;
+        const initialCapacity = 10;
         const bufferType = "DYNAMIC_DRAW";
+        this._bufferOrchestrator = new BufferOrchestrator({ initialCapacity });
         this._bufferManagersMap = new Map([
             ["pos3D", {
                     bufferManager: new BufferManager(gl, 3, { bufferType, initialCapacity }),
@@ -71,17 +67,9 @@ class PointTracksPlugin {
             ["objectStore", {
                     bufferManager: new ObjectStore({ initialCapacity }),
                     adaptor: (item) => {
-                        const result = {
-                            trackID: item.trackID,
-                            pointID: item.pointID,
+                        return {
+                            trackID: item.trackID, pointID: item.pointID
                         };
-                        // Add extra parameters specified in _objectStoreExtraParameters
-                        this._objectStoreExtraParameters.forEach(param => {
-                            if (item.hasOwnProperty(param)) {
-                                result[param] = item[param];
-                            }
-                        });
-                        return result;
                     }
                 }]
         ]);
@@ -144,8 +132,8 @@ class PointTracksPlugin {
      * @returns
      */
     insertBulk(tracks) {
-        this._fillTracksToPointsMap(tracks);
-        const flattenedPoints = tracks.map(trackToFlatPoints, this._objectStoreExtraParametersFiltered).flat();
+        this._fillTracksToPointsMap(tracks); // TODO error should be at the top
+        const flattenedPoints = tracks.map(trackToFlatPoints).flat();
         const currentLoad = this._bufferOrchestrator.length;
         if (currentLoad + flattenedPoints.length >= 2147483647) {
             throw new Error("Too many points, Point count cannot exceed 2147483647");
@@ -167,8 +155,8 @@ class PointTracksPlugin {
      * @param {string} trackID
      */
     deleteTrack(trackID) {
-        const pointList = this._tracksToPointsMap.get(trackID);
-        const points = Array.from(pointList);
+        const pointSet = this._tracksToPointsMap.get(trackID);
+        const points = Array.from(pointSet);
         const { _bufferOrchestrator, _bufferManagersMap } = this;
         _bufferOrchestrator.deleteBulk(points.map((pointID) => keyMethod(trackID, pointID)), _bufferManagersMap);
         this._tracksToPointsMap.delete(trackID);
@@ -201,23 +189,6 @@ class PointTracksPlugin {
         }
         this.globe.DrawRender();
     }
-    updateTrackColor(trackID, rgba) {
-        if (!this._tracksToPointsMap.has(trackID)) {
-            console.warn(`Track with ID ${trackID} does not exist.`);
-            return;
-        }
-        const pointList = this._tracksToPointsMap.get(trackID);
-        const points = Array.from(pointList);
-        const { _bufferOrchestrator, _bufferManagersMap } = this;
-        _bufferOrchestrator.updateBulk(points.map((pointID) => {
-            return {
-                key: keyMethod(trackID, pointID),
-                rgba: new Float32Array(rgba)
-            };
-        }), _bufferManagersMap, ["rgba"]);
-        this._refillFocus();
-        this.globe?.DrawRender();
-    }
     // GLOBE API METHODS
     free() {
         if (this._isFreed)
@@ -230,12 +201,6 @@ class PointTracksPlugin {
     }
     draw3D() {
         const { gl, _pointProgram, _pickerDisplayer, _bufferOrchestrator, _vao } = this;
-        if (!gl) {
-            throw new Error("GL is not loaded, PointTracks Plugin");
-        }
-        if (this._isFreed) {
-            throw new Error("Plugin is unregistered, PointTracks Plugin");
-        }
         this.resize();
         _pickerDisplayer.bindFBO();
         _pickerDisplayer.clearTextures();
@@ -281,12 +246,7 @@ class PointTracksPlugin {
             const pointSet = this._tracksToPointsMap.get(trackID);
             for (let p = 0; p < points.length; p++) {
                 const pointID = points[p].ID;
-                if (!pointSet.has(pointID)) {
-                    pointSet.add(pointID);
-                }
-                else {
-                    console.warn(`Point with ID ${pointID} already exists in track ${trackID}. Skipping duplicate.`);
-                }
+                pointSet.add(pointID);
             }
         }
     }
@@ -296,21 +256,9 @@ class PointTracksPlugin {
         }
     }
     _deletePointsFromTracksMap(trackID, pointIDs) {
-        const trackIDs = this._tracksToPointsMap.get(trackID);
-        if (trackIDs === undefined) {
-            console.warn(`Track with ID ${trackID} not found.`);
-            return;
-        }
+        const trackSet = this._tracksToPointsMap.get(trackID);
         for (const pointID of pointIDs) {
-            if (!trackIDs.has(pointID)) {
-                console.warn(`Point with ID ${pointID} not found in track ${trackID}.`);
-            }
-            else {
-                trackIDs.delete(pointID);
-            }
-        }
-        if (trackIDs.size === 0) {
-            this._tracksToPointsMap.delete(trackID);
+            trackSet.delete(pointID);
         }
     }
     _selfSelect() {
@@ -334,16 +282,14 @@ class PointTracksPlugin {
         const indexes = [];
         const foundTracks = [];
         for (const trackID of trackIDs) {
-            const pointList = this._tracksToPointsMap.get(trackID);
-            if (!pointList)
+            const pointSet = this._tracksToPointsMap.get(trackID);
+            if (!pointSet)
                 continue;
             foundTracks.push(trackID);
-            for (const pointID of pointList) {
+            const points = Array.from(pointSet);
+            for (const pointID of points) {
                 const key = keyMethod(trackID, pointID);
                 const index = this._bufferOrchestrator.offsetMap.get(key);
-                if (index === undefined) {
-                    throw new Error;
-                }
                 indexes.push(index);
                 length++;
             }
@@ -360,7 +306,7 @@ class PointTracksPlugin {
         return true;
     }
 }
-const trackToFlatPoints = (track, extraParameters) => {
+const trackToFlatPoints = (track) => {
     const trackID = track.trackID;
     const points = track.points;
     const rgba = new Float32Array(track.rgba);
@@ -375,12 +321,6 @@ const trackToFlatPoints = (track, extraParameters) => {
             rgba,
             trackID
         });
-        for (let i = 0; i < extraParameters.length; i++) {
-            const param = extraParameters[i];
-            if (point.hasOwnProperty(param)) {
-                flatPoints[flatPoints.length - 1][param] = point[param];
-            }
-        }
     }
     return flatPoints;
 };

package/programs/line-on-globe/lines-color-instanced-flat.js

@@ -8,6 +8,7 @@ import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
  * This program draws line between points provided from the first and second buffer.
  * draw method gl.drawArraysInstanced( gl.POINTS, 0,2, lineCount);
  * */
+// TODO: find better way to eleminate edge case distance(posA, posB) > 37000000.0
 const vertexShaderSource = `#version 300 es
 precision highp float;
 ${CameraUniformBlockString}

package/programs/line-on-globe/linestrip/linestrip.js

@@ -3,6 +3,7 @@ import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../../to
 import { cartesian3DToGLPosition, mercatorXYToGLPosition, } from "../../../util/shaderfunctions/geometrytransformations";
 import { noRegisterGlobeProgramCache } from "../../programcache";
 import { attributeLoader } from "../../../util/gl-util/buffer/attribute-loader";
+import "../../../util/gl-util/buffer/attribute-loader";
 import { UniformBlockManager } from "../../../util/gl-util/uniform-block/manager";
 import { drawArrays } from "../../../util/gl-util/draw-options/methods";
 const ESCAPE_VALUE = -1;
@@ -28,14 +29,24 @@ uniform float u_opacity;
 in vec3 position3d;
 in vec2 position2d;
 in vec4 color; 
+// in float dash_length;
+// in float dash_opacity;
+
+// out float v_dash_length;
+// out float v_dash_opacity;
 out vec4 v_color;
 
 flat out vec3 v_flat_position;
 out vec3 v_position;
 
 void main() {
+
     v_color = ( color.r == -1.0 ) ? u_color : color;
     v_color.a *= u_opacity;
+
+    // v_dash_length = ( dash_length == -1.0 ) ? u_dash_length : dash_length;
+    // v_dash_opacity = ( dash_opacity == -1.0 ) ? u_dash_opacity : dash_opacity;
+
     if ( is3D ) {
         gl_Position = cartesian3DToGLPosition( position3d );
         v_position = position3d;
@@ -62,8 +73,18 @@ in vec3 v_position;
 out vec4 outColor;
 
 void main() {
-    outColor = vec4( v_color.rgb, v_color.a );
+    outColor = v_color;
+    return;
+    // float dash_length = v_dash_length;
+    // float dash_opacity = v_dash_opacity;
 
+    // if ( dash_length == 0.0 ) {
+        outColor = vec4( v_color.rgb, v_color.a );
+    // } else {
+    //     float dist = distance( v_flat_position, v_position );
+    //     // float alpha = mod( dist , v_dash_length * 2.0 ) / v_dash_length < 1.0 ? 1.0 : v_dash_opacity;
+    //     outColor = vec4( 1.0, 1.0, 1.0,  v_color.a * opacity *alpha);
+    // }
 }`;
 export class LineProgram {
     _vaosPublished = [];
@@ -89,6 +110,8 @@ export class LineProgram {
         this.gl.bindAttribLocation(this.program, 0, "position3d");
         this.gl.bindAttribLocation(this.program, 1, "position2d");
         this.gl.bindAttribLocation(this.program, 2, "color");
+        // this.gl.bindAttribLocation(this.program, 3, "dash_length");
+        // this.gl.bindAttribLocation(this.program, 4, "dash_opacity");
         this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
         this.cameraBlockTotem.assignBindingPoint(this.program, uniformBindingPoints.camera);
         flexibleBlockManager.assignBindingPoint(this.gl, this.program);
@@ -100,13 +123,16 @@ export class LineProgram {
         this._ubosPublished.push(ubo);
         return ubo;
     }
-    createVAO(position3D, position2D, color) {
+    createVAO(position3D, position2D, color //, dashLength: BufferAndReadInfo, dashOpacity: BufferAndReadInfo,
+    ) {
         const { gl } = this;
         const vao = gl.createVertexArray();
         gl.bindVertexArray(vao);
         attributeLoader(gl, position3D, 0, 3);
         attributeLoader(gl, position2D, 1, 2);
         attributeLoader(gl, color, 2, 4, { escapeValues: [ESCAPE_VALUE, ESCAPE_VALUE, ESCAPE_VALUE, ESCAPE_VALUE] });
+        // attributeLoader(gl, dashLength, 3, 1, { escapeValues: [ESCAPE_VALUE] });
+        // attributeLoader(gl, dashOpacity, 4, 1, { escapeValues: [ESCAPE_VALUE] });
         gl.bindVertexArray(null);
         return vao;
     }

package/programs/line-on-globe/paddings/paddings.js

@@ -0,0 +1 @@
+"use strict";

package/programs/point-on-globe/element-globe-surface-glow.js

@@ -100,6 +100,7 @@ class Logic {
         const vao = gl.createVertexArray();
         const divisor = 1;
         gl.bindVertexArray(vao);
+        // TODO constants to escape values
         attributeLoader(gl, pos3DObj, 0, 3, { divisor });
         attributeLoader(gl, radiusObj, 1, 1, { divisor, escapeValues: [-1] });
         attributeLoader(gl, colorObj, 2, 4, { divisor, escapeValues: [-1, -1, -1, -1] });