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

package/Math/arc.js

@@ -143,8 +143,7 @@ function _populatePointsWithClosestPointInsideArc(out, arc, count, closestPoint)
  * @param {Vec3} cameraPosition - The position of the camera.
  * @param {number} quaternionReuseCount - The number of times to apply the same rotation before recalculating. Higher is faster but less accurate.
  */
-function _distanceSampling(out, count, inArc, cameraPosition = vec3create(0, 0, 0), // TODO
-quaternionReuseCount = 1) {
+function _distanceSampling(out, count, inArc, cameraPosition = vec3create(0, 0, 0), quaternionReuseCount = 1) {
     if (count === 0) {
         return;
     }

package/Math/circle-cdf-points.js

@@ -1,168 +1,4 @@
 import { RADIANS } from "./methods";
-function createTemplate(intervalCount, strength = 1.0) {
-    const out = new Array(intervalCount);
-    const TOTAL = 1;
-    let cummulative = 0;
-    if (strength <= 0) {
-        // If strength is 0, distribute evenly.
-        const step = TOTAL / (intervalCount - 1);
-        for (let i = 0; i < intervalCount; i++) {
-            out[i] = cummulative;
-            cummulative += step;
-        }
-        out[intervalCount - 1] = TOTAL; // Ensure the last value is exactly TOTAL
-        return out;
-    }
-    // If strength is greater than 0, bias towards the start.
-    const weights = new Array(intervalCount);
-    let currentStep = 1;
-    let totalWeight = 0;
-    // Calculate weights for each interval, decreasing for later intervals.
-    for (let i = 0; i < intervalCount; i++) {
-        // Using (i + 1) in the denominator gives earlier intervals the highest weight.
-        totalWeight += currentStep;
-        weights[i] = totalWeight;
-        currentStep += strength;
-    }
-    // Distribute the total angle based on the weights.
-    for (let i = 0; i < intervalCount; i++) {
-        // Round to the nearest whole number for this interval.
-        out[i] = (weights[i] / totalWeight) * TOTAL;
-    }
-    if (out[intervalCount - 1] !== TOTAL) {
-        out[intervalCount - 1] = TOTAL;
-    }
-    // console.log("createTemplate", "strength", strength, "intervalCount", intervalCount, "out", out);
-    return out;
-}
-function interpolation(a, b, t) {
-    return a + (b - a) * t;
-}
-/**
- * Populates the `out` array with values from the `template` array,
- * distributing the surplus length as interpolated values between the template samples.
- *
- * @param out The destination array to be filled. Its length must be >= template.length.
- * @param template An ordered array of numbers to be placed in the `out` array.
- * @param strength A parameter controlling the distribution bias of surplus samples.
- * - strength = 0: Surplus samples are distributed evenly.
- * - strength > 0: Surplus samples are biased towards the start of the template.
- * - Higher values create a stronger bias.
- */
-function increasePopulation(// TODO: THERE IS A BUG
-out, template, strength = 1.0) {
-    const sourceLength = template.length;
-    const destinationLength = out.length;
-    const outLengthAtStart = out.length;
-    // --- Handle Edge Cases ---
-    // If the template is empty, there is nothing to interpolate from.
-    if (sourceLength === 0) {
-        return;
-    }
-    // If the template has only one value, fill the output array with that value.
-    if (sourceLength === 1) {
-        out.fill(template[0]);
-        return;
-    }
-    // If the destination is not larger than the source, just copy the template values.
-    if (destinationLength <= sourceLength) {
-        for (let i = 0; i < destinationLength; i++) {
-            out[i] = template[i];
-        }
-        return;
-    }
-    // --- Main Logic ---
-    const surplus = destinationLength - sourceLength;
-    const numGaps = sourceLength - 1;
-    // This array will hold the number of extra samples to add in each gap.
-    const surplusPerGap = new Array(numGaps).fill(0);
-    if (surplus > 0) {
-        // --- Step 1: Determine the distribution of surplus items ---
-        // If strength is 0, distribute surplus items as evenly as possible.
-        if (strength <= 0) {
-            const baseToAdd = Math.floor(surplus / numGaps);
-            const remainder = surplus % numGaps;
-            for (let i = 0; i < numGaps; i++) {
-                // Distribute the remainder one by one to the first gaps.
-                surplusPerGap[i] = baseToAdd + (i < remainder ? 1 : 0);
-            }
-        }
-        else {
-            // Biased Distribution: more items in earlier gaps.
-            const weights = new Array(numGaps);
-            let totalWeight = 0;
-            // A. Calculate a weight for each gap. The weight decreases for later gaps.
-            // The `strength` parameter makes this decay steeper.
-            for (let i = 0; i < numGaps; i++) {
-                // Using (i + 1) in the denominator gives earlier gaps (i=0) the highest weight.
-                const weight = Math.pow(1 / (i + 1), strength);
-                weights[i] = weight;
-                totalWeight += weight;
-            }
-            // B. Distribute the surplus based on the calculated weights.
-            // This method ensures the total distributed count equals the surplus.
-            let distributedCount = 0;
-            for (let i = 0; i < numGaps - 1; i++) {
-                const idealCount = (weights[i] / totalWeight) * surplus;
-                // Round to the nearest whole number for this gap.
-                const countForThisGap = Math.ceil(idealCount);
-                surplusPerGap[i] = countForThisGap;
-                distributedCount += countForThisGap;
-            }
-            // Assign the remainder to the last gap to guarantee the sum is correct.
-            //surplusPerGap[numGaps - 1] = surplus - distributedCount; 
-            // add to first 
-            const leftover = surplus - distributedCount;
-            if (leftover > 0) {
-                surplusPerGap[0] += leftover; // Add any leftover to the first gap.
-            }
-            console.log("leftover", leftover, "distributedCount", distributedCount, "surplus", surplus);
-        }
-    }
-    // --- Step 2: Populate the `out` array ---
-    let outIndex = 0;
-    for (let i = 0; i < surplusPerGap.length; i++) {
-        if (typeof surplusPerGap[i] !== "number" || isNaN(surplusPerGap[i]) || !isFinite(surplusPerGap[i])) {
-            console.warn("increasePopulation: Invalid surplusPerGap value at index", i, ":", surplusPerGap[i]);
-        }
-    }
-    for (let i = 0; i < sourceLength; i++) {
-        // A. Add the original template item.
-        out[outIndex++] = template[i];
-        // B. If this is not the last template item, fill the gap after it.
-        if (i < numGaps) {
-            const numToAdd = surplusPerGap[i];
-            if (numToAdd <= 0)
-                continue;
-            const startVal = template[i];
-            const endVal = template[i + 1];
-            // C. Add the interpolated ("surplus") items for this gap.
-            // The total number of intervals in this gap is numToAdd + 1.
-            const totalIntervals = numToAdd + 1;
-            for (let j = 1; j <= numToAdd; j++) {
-                const t = j / totalIntervals; // The interpolation factor (0 < t < 1)
-                // Linear interpolation: out = start * (1 - t) + end * t
-                const interpolatedValue = startVal * (1 - t) + endVal * t;
-                out[outIndex++] = interpolatedValue;
-                if (outIndex >= out.length) {
-                    console.warn("increasePopulation: Output array overflow. Stopping early.");
-                    console.warn("processeed item ratio:", i, "/", sourceLength);
-                    let count = numToAdd - j;
-                    console.log("count", count);
-                    for (let _i = i; _i < sourceLength; _i++) {
-                        count += surplusPerGap[_i];
-                    }
-                    console.warn("increasePopulation: Not enough space to add", count, "more items.");
-                    return; // Prevent overflow if the output array is not large enough.
-                }
-            }
-        }
-    }
-    // --- Step 3: Ensure the output length is correct ---
-    if (outLengthAtStart !== out.length) {
-        console.warn("increasePopulation: Output length mismatch. Expected", outLengthAtStart, "but got", out.length);
-    }
-}
 function createCummulativeTemplate(numberOfPoints, strength, denseRatio = 0.5 // Ratio of points to be densely packed at the start.
 ) {
     // Handle edge cases for the number of points.
@@ -239,9 +75,4 @@ function globeFindPointByPolarHalfCircle(out, globe, centerLong, centerLat, radi
         offset -= 2;
     }
 }
-export { 
-// createTemplate,
-// increasePopulation,
-// interpolation,
-// createCummulativeTemplate,
-createCummulativeTemplateStash, globeFindPointByPolar, globeFindPointByPolarHalfCircle };
+export { createCummulativeTemplateStash, globeFindPointByPolar, globeFindPointByPolarHalfCircle };

package/Math/circle.js

@@ -29,30 +29,5 @@ function createCircleClosestAzimuthAngleProperties(circle) {
         normal: normal,
         northPointProjectedToOriginPlaneNormalized: N,
     };
-    // const distance = normal[2]; //dot(normal, [0, 0, 1] as Vec3)
-    // const N: Vec3 = [0, 0, 0];
-    // if (Math.abs(distance) < 1e-6) {
-    //     N[0] = -1;
-    //     N[1] = 0;
-    //     N[2] = 0;
-    // } else {
-    //     // TODO: add cases for 8 parts of the sphere
-    //     copy(N, normal);
-    //     multiplyScalar(N, N, distance);
-    //     if (N[2] >= 0) {
-    //         N[0] = -N[0];
-    //         N[1] = -N[1];
-    //         N[2] = 1 - N[2];
-    //     } else {
-    //         N[2] = -N[2];
-    //         N[0] = -N[0];
-    //         N[1] = -N[1];
-    //     }
-    // }
-    // normalize(N, N);
-    // return {
-    //     normal: normal,
-    //     northPointProjectedToOriginPlaneNormalized: N,
-    // }
 }
 export { closestAzimuthAngle, createCircleClosestAzimuthAngleProperties };

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, height = 0) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
+export const globe3Dcoordinates = (globe, longlats, height = 0, msl = false, { 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, 0);
+        const xyz = globe.api_GetCartesian3DPoint(long, lat, height, msl);
         result.set(xyz, i * 3);
     }
     return result;

package/Math/vec3.js

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

package/altitude-locator/plugin.js

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

package/bearing-line/plugin.js

@@ -397,8 +397,9 @@ 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.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);
+            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);
         }
         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.1-alpha",
+    "version": "0.15.23.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";
+import { BufferOrchestrator, BufferManager, ObjectStore } from "../util/account/index";
 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 } = {}) {
+    constructor(id, { pointSize = 2, hoveredPointSize = 4, selectionPointFilling = 4, opacity = 1.0, objectStoreExtraParameters = ["long", "lat", "height"], initialCapacity = 1000 } = {}) {
         this.id = id;
         this._isFreed = false;
         this._pointProgram = null;
@@ -25,15 +25,20 @@ class PointTracksPlugin {
         this._selectedID = -1;
         this._selectedObj = null;
         this._tracksToPointsMap = new Map(); // one to many
-        this._opacity = opacity;
+        this._opacity = opacity ? opacity : 1.0;
         this.program = null;
         this._lastWH = { w: 0, h: 0 };
         this._focusParams = { on: false, length: 0, elementBuffer: null, trackIDs: [] };
         this.pointSizes = {
-            pointSize,
-            selectionPointFilling,
-            hoveredPointSize
+            pointSize: pointSize ? pointSize : 2,
+            selectionPointFilling: selectionPointFilling ? selectionPointFilling : 4,
+            hoveredPointSize: hoveredPointSize ? hoveredPointSize : 4
         };
+        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;
@@ -45,9 +50,8 @@ class PointTracksPlugin {
     }
     _initBufferManagers() {
         const { gl } = this;
-        const initialCapacity = 10;
+        const initialCapacity = this._bufferOrchestrator.capacity;
         const bufferType = "DYNAMIC_DRAW";
-        this._bufferOrchestrator = new BufferOrchestrator({ initialCapacity });
         this._bufferManagersMap = new Map([
             ["pos3D", {
                     bufferManager: new BufferManager(gl, 3, { bufferType, initialCapacity }),
@@ -67,9 +71,17 @@ class PointTracksPlugin {
             ["objectStore", {
                     bufferManager: new ObjectStore({ initialCapacity }),
                     adaptor: (item) => {
-                        return {
-                            trackID: item.trackID, pointID: item.pointID
+                        const result = {
+                            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;
                     }
                 }]
         ]);
@@ -132,8 +144,8 @@ class PointTracksPlugin {
      * @returns
      */
     insertBulk(tracks) {
-        this._fillTracksToPointsMap(tracks); // TODO error should be at the top
-        const flattenedPoints = tracks.map(trackToFlatPoints).flat();
+        this._fillTracksToPointsMap(tracks);
+        const flattenedPoints = tracks.map(trackToFlatPoints, this._objectStoreExtraParametersFiltered).flat();
         const currentLoad = this._bufferOrchestrator.length;
         if (currentLoad + flattenedPoints.length >= 2147483647) {
             throw new Error("Too many points, Point count cannot exceed 2147483647");
@@ -155,8 +167,8 @@ class PointTracksPlugin {
      * @param {string} trackID
      */
     deleteTrack(trackID) {
-        const pointSet = this._tracksToPointsMap.get(trackID);
-        const points = Array.from(pointSet);
+        const pointList = this._tracksToPointsMap.get(trackID);
+        const points = Array.from(pointList);
         const { _bufferOrchestrator, _bufferManagersMap } = this;
         _bufferOrchestrator.deleteBulk(points.map((pointID) => keyMethod(trackID, pointID)), _bufferManagersMap);
         this._tracksToPointsMap.delete(trackID);
@@ -189,6 +201,23 @@ 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)
@@ -201,6 +230,12 @@ 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();
@@ -246,7 +281,12 @@ class PointTracksPlugin {
             const pointSet = this._tracksToPointsMap.get(trackID);
             for (let p = 0; p < points.length; p++) {
                 const pointID = points[p].ID;
-                pointSet.add(pointID);
+                if (!pointSet.has(pointID)) {
+                    pointSet.add(pointID);
+                }
+                else {
+                    console.warn(`Point with ID ${pointID} already exists in track ${trackID}. Skipping duplicate.`);
+                }
             }
         }
     }
@@ -256,9 +296,21 @@ class PointTracksPlugin {
         }
     }
     _deletePointsFromTracksMap(trackID, pointIDs) {
-        const trackSet = this._tracksToPointsMap.get(trackID);
+        const trackIDs = this._tracksToPointsMap.get(trackID);
+        if (trackIDs === undefined) {
+            console.warn(`Track with ID ${trackID} not found.`);
+            return;
+        }
         for (const pointID of pointIDs) {
-            trackSet.delete(pointID);
+            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);
         }
     }
     _selfSelect() {
@@ -282,14 +334,16 @@ class PointTracksPlugin {
         const indexes = [];
         const foundTracks = [];
         for (const trackID of trackIDs) {
-            const pointSet = this._tracksToPointsMap.get(trackID);
-            if (!pointSet)
+            const pointList = this._tracksToPointsMap.get(trackID);
+            if (!pointList)
                 continue;
             foundTracks.push(trackID);
-            const points = Array.from(pointSet);
-            for (const pointID of points) {
+            for (const pointID of pointList) {
                 const key = keyMethod(trackID, pointID);
                 const index = this._bufferOrchestrator.offsetMap.get(key);
+                if (index === undefined) {
+                    throw new Error;
+                }
                 indexes.push(index);
                 length++;
             }
@@ -306,7 +360,7 @@ class PointTracksPlugin {
         return true;
     }
 }
-const trackToFlatPoints = (track) => {
+const trackToFlatPoints = (track, extraParameters) => {
     const trackID = track.trackID;
     const points = track.points;
     const rgba = new Float32Array(track.rgba);
@@ -321,6 +375,12 @@ const trackToFlatPoints = (track) => {
             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,7 +8,6 @@ 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,7 +3,6 @@ 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;
@@ -14,8 +13,6 @@ const uniformBindingPoints = {
 // const one = new Float32Array([1]);
 const flexibleBlockManager = new UniformBlockManager('FlexibleAttributes', [
     { name: "u_color", type: "vec4", value: new Float32Array([0.12, 1, 0.1, 1]) },
-    // { name: "u_dash_opacity", type: "float", value: one },
-    // { name: "u_dash_length", type: "float", value: one },
 ], uniformBindingPoints.flexible);
 const vertexShaderSource = `#version 300 es
 precision highp float;
@@ -31,24 +28,14 @@ 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;
@@ -75,18 +62,8 @@ in vec3 v_position;
 out vec4 outColor;
 
 void main() {
-    outColor = v_color;
-    return;
-    // float dash_length = v_dash_length;
-    // float dash_opacity = v_dash_opacity;
+    outColor = vec4( v_color.rgb, v_color.a );
 
-    // 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 = [];
@@ -112,8 +89,6 @@ 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);
@@ -125,16 +100,13 @@ export class LineProgram {
         this._ubosPublished.push(ubo);
         return ubo;
     }
-    createVAO(position3D, position2D, color //, dashLength: BufferAndReadInfo, dashOpacity: BufferAndReadInfo,
-    ) {
+    createVAO(position3D, position2D, color) {
         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/point-on-globe/element-globe-surface-glow.js

@@ -100,7 +100,6 @@ 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] });