@pirireis/webglobeplugins 0.17.0 → 0.17.1

package/Math/methods.js

@@ -16,6 +16,12 @@ export const radianToMercator = (xy) => {
         WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))
     ];
 };
+export function radianToMercatorXY(xy) {
+    return [
+        xy[0] * Math.pow(2, 8),
+        Math.log(Math.tan(Math.PI / 4 + xy[1] / 2)) * Math.pow(2, 8)
+    ];
+}
 export const radianToCartesian3d = (xy) => {
     const x = Math.cos(xy[1]) * Math.cos(xy[0]);
     const y = Math.cos(xy[1]) * Math.sin(xy[0]);

package/Math/tessellation/tile-merger.js

@@ -1,56 +1,298 @@
-"use strict";
-function _sortXY(a, b) {
-    if (a.y === b.y) {
-        return a.x - b.x;
-    }
-    return a.y - b.y;
+function displayTileMetaData(tilesMetaData) {
+    // show maxZoom minZoom
+    console.log(`Max Level: ${tilesMetaData.maxLevel}
+    Min Level: ${tilesMetaData.minLevel}`);
+}
+function keyMethod(row, column, level) {
+    return `${level}_${row}_${column}`;
 }
-function groupByZoomLevel(tiles) {
-    const map = new Map();
+function calculateParentTile(row, column, level) {
+    return {
+        row: Math.floor(row / 2),
+        column: Math.floor(column / 2),
+        level: level - 1
+    };
+}
+function createMapAndMetaData(tiles) {
+    const tileMap = new Map();
+    let maxLevel = -Infinity;
+    let minLevel = Infinity;
+    const tileLimitsByZoom = new Map();
     for (const tile of tiles) {
-        if (!map.has(tile.z)) {
-            map.set(tile.z, []);
+        const key = keyMethod(tile.row, tile.column, tile.level);
+        tileMap.set(key, tile);
+        if (tile.level > maxLevel) {
+            maxLevel = tile.level;
+        }
+        if (tile.level < minLevel) {
+            minLevel = tile.level;
+        }
+        if (!tileLimitsByZoom.has(tile.level)) {
+            tileLimitsByZoom.set(tile.level, {
+                minRow: tile.row,
+                maxRow: tile.row,
+                minCol: tile.column,
+                maxCol: tile.column
+            });
+        }
+        else {
+            const limits = tileLimitsByZoom.get(tile.level);
+            if (tile.row < limits.minRow)
+                limits.minRow = tile.row;
+            if (tile.row > limits.maxRow)
+                limits.maxRow = tile.row;
+            if (tile.column < limits.minCol)
+                limits.minCol = tile.column;
+            if (tile.column > limits.maxCol)
+                limits.maxCol = tile.column;
         }
-        map.get(tile.z).push(tile);
     }
-    map.forEach((tileList, z) => {
-        tileList.sort(_sortXY);
-    });
-    return map;
-}
-function _insertDEM(sourceDEM, sourceWidth, sourceHeight, targetDEM, targetWidth, targetHeight, offsetX, offsetY) {
-    for (let row = 0; row < sourceHeight; row++) {
-        for (let col = 0; col < sourceWidth; col++) {
-            const sourceIndex = row * sourceWidth + col;
-            const targetIndex = (row + offsetY) * targetWidth + (col + offsetX);
-            targetDEM[targetIndex] = sourceDEM[sourceIndex];
+    return {
+        tileMap,
+        maxLevel,
+        minLevel,
+        tileLimitsByZoom
+    };
+}
+function populateTileIntoHigherZoomLevel(tileMesh, tileDimensionLength, targetDimensionLength) {
+    const newMesh = new Array(targetDimensionLength).fill(0).map(() => new Float32Array(targetDimensionLength));
+    // use linear interpolation to populate
+    for (let row = 0; row < targetDimensionLength; row++) {
+        for (let col = 0; col < targetDimensionLength; col++) {
+            const srcRow = row * (tileDimensionLength - 1) / (targetDimensionLength - 1);
+            const srcCol = col * (tileDimensionLength - 1) / (targetDimensionLength - 1);
+            const srcRowLow = Math.floor(srcRow);
+            const srcRowHigh = Math.min(Math.ceil(srcRow), tileDimensionLength - 1);
+            const srcColLow = Math.floor(srcCol);
+            const srcColHigh = Math.min(Math.ceil(srcCol), tileDimensionLength - 1);
+            const topLeft = tileMesh[srcRowLow][srcColLow];
+            const topRight = tileMesh[srcRowLow][srcColHigh];
+            const bottomLeft = tileMesh[srcRowHigh][srcColLow];
+            const bottomRight = tileMesh[srcRowHigh][srcColHigh];
+            const top = topLeft + (topRight - topLeft) * (srcCol - srcColLow);
+            const bottom = bottomLeft + (bottomRight - bottomLeft) * (srcCol - srcColLow);
+            newMesh[row][col] = top + (bottom - top) * (srcRow - srcRowLow);
         }
     }
+    return newMesh;
 }
-function mergeTiles(tiles, demWidth, demHeight) {
-    let minX = Number.MAX_VALUE;
-    let maxX = Number.MIN_VALUE;
-    let minY = Number.MAX_VALUE;
-    let maxY = Number.MIN_VALUE;
-    for (let tile of tiles) {
-        if (tile.x < minX) {
-            minX = tile.x;
+// This function is correct, assuming its inputs are prepared properly.
+// This function is correct, assuming its inputs are prepared properly.
+function moveMeshToMergedMesh(targetMesh, targetDimensionLength, sourceMesh, sourceDimensionLength, startX, startY) {
+    for (let row = 0; row < sourceDimensionLength; row++) {
+        for (let col = 0; col < sourceDimensionLength; col++) {
+            const targetIndex = (startY + row) * targetDimensionLength + (startX + col);
+            // Check if source value exists
+            if (sourceMesh[row] === undefined || sourceMesh[row][col] === undefined) {
+                console.warn(`Source data missing at [${row}][${col}]`);
+                continue;
+            }
+            const value = sourceMesh[row][col];
+            if (isNaN(value)) {
+                console.warn(`NaN value found in source mesh at row: ${row}, col: ${col}`);
+            }
+            ;
+            if (targetIndex >= targetMesh.length) {
+                console.warn(`⚠️ Target index out of bounds: ${targetIndex} >= ${targetMesh.length}`);
+                continue;
+            }
+            targetMesh[targetIndex] = value;
         }
-        if (tile.x > maxX) {
-            maxX = tile.x;
+    }
+}
+function limitCheck(limit, limitRange = 12) {
+    const rowRange = limit.maxRow - limit.minRow + 1;
+    const colRange = limit.maxCol - limit.minCol + 1;
+    if (rowRange > limitRange || colRange > limitRange) {
+        console.warn(`Tile limit range exceeded: Row Range = ${rowRange}, Col Range = ${colRange}, Limit Range = ${limitRange}`);
+        throw new Error("Tile limit range exceeded");
+    }
+}
+function mergeTiles(tilesMetaData, mergeCount = 8, tileDimensionLength = 5, processLimit = 6) {
+    const mergedMeshDimLength = tileDimensionLength * mergeCount - (mergeCount - 1);
+    const processedTiles = new Set();
+    const result = [];
+    for (let zoom = tilesMetaData.maxLevel; zoom >= tilesMetaData.minLevel; zoom--) {
+        let processedTileCountFromCurrentLevel = 0;
+        let processedTileCountFromParentLevel = 0;
+        if (tilesMetaData.maxLevel - zoom >= processLimit) {
+            break;
         }
-        if (tile.y < minY) {
-            minY = tile.y;
+        const limits = tilesMetaData.tileLimitsByZoom.get(zoom);
+        const mergedMesh = new Float32Array(mergedMeshDimLength * mergedMeshDimLength).fill(0);
+        const bboxLimit = {
+            ur: { x: -Infinity, y: -Infinity },
+            ll: { x: Infinity, y: Infinity }
+        };
+        if (!limits)
+            continue;
+        limitCheck(limits, 12);
+        for (let row = limits.minRow; row <= limits.maxRow; row++) {
+            for (let col = limits.minCol; col <= limits.maxCol; col++) {
+                const key = keyMethod(row, col, zoom);
+                if (processedTiles.has(key)) {
+                    continue;
+                }
+                const tile = tilesMetaData.tileMap.get(key);
+                if (tile) {
+                    // move tile mesh to merged mesh
+                    moveMeshToMergedMesh(mergedMesh, mergedMeshDimLength, tile.mesh, tileDimensionLength, (row - limits.minRow) * (tileDimensionLength - 1), (col - limits.minCol) * (tileDimensionLength - 1));
+                    // moveMeshToMergedMesh2(
+                    //     mergedMesh, mergedMeshDimLength,
+                    //     (row + col) % 2 === 0 ? 0.1 : 0,
+                    //     tileDimensionLength,
+                    //     (row - limits.minRow) * (tileDimensionLength - 1), (col - limits.minCol) * (tileDimensionLength - 1)
+                    // );
+                    processedTiles.add(key);
+                    processedTileCountFromCurrentLevel++;
+                    // update bbox
+                    if (tile.bbox.ll.x < bboxLimit.ll.x)
+                        bboxLimit.ll.x = tile.bbox.ll.x;
+                    if (tile.bbox.ll.y < bboxLimit.ll.y)
+                        bboxLimit.ll.y = tile.bbox.ll.y;
+                    if (tile.bbox.ur.x > bboxLimit.ur.x)
+                        bboxLimit.ur.x = tile.bbox.ur.x;
+                    if (tile.bbox.ur.y > bboxLimit.ur.y)
+                        bboxLimit.ur.y = tile.bbox.ur.y;
+                    /**
+                } else {
+                    // try to find parent tile
+                    const parent = calculateParentTile(row, col, zoom);
+                    const parentKey = keyMethod(parent.row, parent.column, parent.level);
+                    const parentTile = tilesMetaData.tileMap.get(parentKey);
+
+                    if (parentTile) {
+                        // Parent's 4 children at current zoom level
+                        const parentTopLeftChildRow = parent.row * 2;
+                        const parentTopLeftChildCol = parent.column * 2;
+                        const topLeftChildKey = keyMethod(parentTopLeftChildRow, parentTopLeftChildCol, zoom);
+
+                        // Only process parent once
+                        if (!processedTiles.has(topLeftChildKey)) {
+                            // Check if parent's area is within or overlaps the current limits
+                            const parentBottomRightChildRow = parentTopLeftChildRow + 1;
+                            const parentBottomRightChildCol = parentTopLeftChildCol + 1;
+
+                            // Check if parent's children overlap with current zoom's limits
+                            if (parentTopLeftChildRow > limits.maxRow ||
+                                parentBottomRightChildRow < limits.minRow ||
+                                parentTopLeftChildCol > limits.maxCol ||
+                                parentBottomRightChildCol < limits.minCol) {
+                                // Parent doesn't overlap, skip
+                                processedTiles.add(key);
+                                continue;
+                            }
+
+                            // Upscale parent to cover all 4 children
+                            const parentTileUpscaledMesh = populateTileIntoHigherZoomLevel(
+                                parentTile.mesh,
+                                tileDimensionLength,
+                                tileDimensionLength * 2 - 1
+                            );
+
+                            // Calculate destination position (parent's top-left child position)
+                            // Clamp to limits to handle edge cases
+                            const actualStartRow = Math.max(parentTopLeftChildRow, limits.minRow);
+                            const actualStartCol = Math.max(parentTopLeftChildCol, limits.minCol);
+
+                            const destRow = (actualStartRow - limits.minRow) * (tileDimensionLength - 1);
+                            const destCol = (actualStartCol - limits.minCol) * (tileDimensionLength - 1);
+
+                            // Calculate source offset if parent starts before limits
+                            const srcRowOffset = (actualStartRow - parentTopLeftChildRow) * (tileDimensionLength - 1);
+                            const srcColOffset = (actualStartCol - parentTopLeftChildCol) * (tileDimensionLength - 1);
+
+                            // Calculate how much to copy
+                            const actualEndRow = Math.min(parentBottomRightChildRow, limits.maxRow);
+                            const actualEndCol = Math.min(parentBottomRightChildCol, limits.maxCol);
+
+                            const copyRows = (actualEndRow - actualStartRow + 1) * (tileDimensionLength - 1);
+                            const copyCols = (actualEndCol - actualStartCol + 1) * (tileDimensionLength - 1);
+
+                            // Copy only the visible portion
+                            moveMeshToMergedMeshPartial(
+                                mergedMesh,
+                                mergedMeshDimLength,
+                                parentTileUpscaledMesh,
+                                tileDimensionLength * 2 - 1,
+                                destRow,
+                                destCol,
+                                srcRowOffset,
+                                srcColOffset,
+                                copyRows,
+                                copyCols
+                            );
+
+                            // Mark all 4 child positions as processed (even if out of bounds)
+                            for (let dr = 0; dr < 2; dr++) {
+                                for (let dc = 0; dc < 2; dc++) {
+                                    const childRow = parentTopLeftChildRow + dr;
+                                    const childCol = parentTopLeftChildCol + dc;
+                                    const childKey = keyMethod(childRow, childCol, zoom);
+                                    processedTiles.add(childKey);
+                                }
+                            }
+
+                            processedTileCountFromParentLevel++;
+
+                            // Update bbox (use actual parent bbox, not child bbox)
+                            if (parentTile.bbox.ll.x < bboxLimit.ll.x) bboxLimit.ll.x = parentTile.bbox.ll.x;
+                            if (parentTile.bbox.ll.y < bboxLimit.ll.y) bboxLimit.ll.y = parentTile.bbox.ll.y;
+                            if (parentTile.bbox.ur.x > bboxLimit.ur.x) bboxLimit.ur.x = parentTile.bbox.ur.x;
+                            if (parentTile.bbox.ur.y > bboxLimit.ur.y) bboxLimit.ur.y = parentTile.bbox.ur.y;
+                        } else {
+                            // Already processed via parent
+                            processedTiles.add(key);
+                        }
+                    } else {
+                        // No parent available
+                        processedTiles.add(key);
+                    }
+               
+                    */
+                }
+            }
         }
-        if (tile.y > maxY) {
-            maxY = tile.y;
+        const rowRatio = (limits.maxRow - limits.minRow + 1) / mergeCount;
+        const colRatio = (limits.maxCol - limits.minCol + 1) / mergeCount;
+        // console.log(`Zoom ${zoom}: Processed ${processedTileCountFromCurrentLevel} from current level, ${processedTileCountFromParentLevel} from parent level. Coverage: ${(rowRatio * 100).toFixed(1)}% x ${(colRatio * 100).toFixed(1)}%`);
+        result.push({ mesh: mergedMesh, bbox: bboxLimit, zoom: zoom, coverRatio: { x: rowRatio, y: colRatio } });
+    }
+    return result;
+}
+export function mergeMeshes(tiles, mergeCount = 12, tileDimensionLength = 5, processLimit = 6) {
+    // filter out tiles with NaN values
+    // return returnTop6tiles(tiles);
+    const tilesMetaData = createMapAndMetaData(tiles);
+    const mergedTiles = mergeTiles(tilesMetaData, mergeCount, tileDimensionLength, processLimit);
+    return mergedTiles;
+}
+function returnTop6tiles(tiles) {
+    const tilesMetaData = createMapAndMetaData(tiles);
+    const hightestZoom = tilesMetaData.maxLevel;
+    const result = [];
+    let counter = 6;
+    function tileToMergedTileInfo(tile) {
+        const mesh = new Float32Array(tile.mesh[0].length * tile.mesh[0].length);
+        for (let row = 0; row < tile.mesh[0].length; row++) {
+            for (let col = 0; col < tile.mesh[0].length; col++) {
+                mesh[row * tile.mesh[0].length + col] = tile.mesh[0][row * tile.mesh[0].length + col];
+            }
         }
+        return {
+            mesh: mesh,
+            zoom: tile.level,
+            bbox: tile.bbox,
+            coverRatio: { x: 1, y: 1 },
+        };
     }
-    const xCount = maxX - minX + 1;
-    const yCount = maxY - minY + 1;
-    const mergedDEM = new Float32Array(xCount * demWidth * yCount * demHeight).fill(0);
-    for (let tile of tiles) {
-        _insertDEM(tile.DEM, demWidth, demHeight, mergedDEM, xCount * demWidth, yCount * demHeight, (tile.x - minX) * demWidth, (tile.y - minY) * demHeight);
+    for (const tile of tiles) {
+        if (counter === 0)
+            break;
+        if (tile.level === hightestZoom) {
+            result.push(tileToMergedTileInfo(tile));
+            counter--;
+        }
     }
-    return mergedDEM;
+    return result;
 }

package/Math/tessellation/triangle-tessellation-meta.js

@@ -8,6 +8,7 @@ import { pointsOnArc } from "../juction/arc-plane";
 import { latToTileY, tileYtoLat } from "./methods";
 import { isOnTileEdge } from "./methods";
 import Delaunator from "delaunator";
+import { radianToMercatorXY } from "../methods";
 // TODO:get rid of embedded lists. always flat list
 const TILE_DEM_VERTEX_COUNT = 5; // 5x5 grid for DEM
 const TILE_DEM_STEPCOUNT = TILE_DEM_VERTEX_COUNT - 1; // 4 inner divisions in each dimension
@@ -271,6 +272,11 @@ export function getAllPoints(triangleMeta, zoom, innerCuts = TILE_DEM_STEPCOUNT)
     const edgeIndexes = shellPoints.map((e, index) => index * 2); // edge points are always first points in list
     indices = filteroutEdgeConnections(indices, edgeIndexes);
     // rotateIndices(indices);
+    // for (let i = 0; i < longLatPoints.length / 2; i++) {
+    //     const xy = radianToMercatorXY([longLatPoints[i * 2], longLatPoints[i * 2 + 1]]);
+    //     longLatPoints[i * 2] = xy[0];
+    //     longLatPoints[i * 2 + 1] = xy[1];
+    // }
     return { vec3s: new Float32Array(points), longLats: new Float32Array(longLatPoints), indices: indices };
 }
 function fillBetweenInParallels(lat, p1, p2, step, fillVec3Arr, longLatPoints) {
@@ -307,16 +313,6 @@ function filterDuplicate(points) {
 function showLongLatRadian(longLat) {
     return `(${(longLat[0] * 180 / Math.PI).toFixed(2)}°, ${(longLat[1] * 180 / Math.PI).toFixed(2)}°)`;
 }
-function rotateIndices(indices) {
-    const len = indices.length / 3;
-    let hold;
-    for (let i = 0; i < len; i++) {
-        hold = indices[i * 3];
-        indices[i * 3] = indices[i * 3 + 1];
-        indices[i * 3 + 1] = hold;
-    }
-    return indices;
-}
 // This method for removing external edge connections. The connections are unnecessary and cause a veil descending to the center of sphere from the edges
 function filteroutEdgeConnections(indexes, filterOutIndexes) {
     const length = indexes.length / 3;
@@ -377,6 +373,7 @@ export function partialTessellation(triangleMeta, limits, innerCuts) {
     const allVec3s = [];
     const allLongLats = [];
     let pointCounter = 0;
+    const stepCount = innerCuts - 1; // 
     /**
      * Precision for coordinate keys in the map. 1e-12 radians is
      * extremely small (sub-millimeter on Earth's surface) and avoids
@@ -432,14 +429,16 @@ export function partialTessellation(triangleMeta, limits, innerCuts) {
         }
         // 2b. Calculate grid steps for this tile's zoom
         const tileCount = TILE_COUNTS[zoom];
-        const lonStep = (2 * Math.PI) / tileCount / innerCuts;
-        const latStep = 1.0 / innerCuts; // This is in tileY units
+        const lonStep = (2 * Math.PI) / tileCount / stepCount;
+        const latStep = 1.0 / stepCount; // This is in tileY units
         // 2c. Generate Latitude (Parallel) Points
         const startTileY = latToTileY(workBBox.max[1], zoom); // max lat -> min tileY
         const endTileY = latToTileY(workBBox.min[1], zoom); // min lat -> max tileY
-        let currentY = Math.ceil(startTileY / latStep) * latStep;
-        if (currentY < startTileY - 1e-9)
-            currentY += latStep; // Ensure we start inside or on edge
+        // let currentY = Math.ceil(startTileY / latStep) * latStep;
+        let currentY = startTileY - Math.abs(startTileY % latStep);
+        // if (currentY < startTileY - 1e-9) currentY += latStep; // Ensure we start inside or on edge
+        if (currentY === startTileY)
+            currentY -= latStep; // since start point is already added
         while (currentY <= endTileY + 1e-9) {
             const lat = tileYtoLat(currentY, zoom);
             // Skip if rounding put us slightly outside the work box
@@ -508,6 +507,14 @@ export function partialTessellation(triangleMeta, limits, innerCuts) {
     let indices = delaunator.triangles;
     // 4. Filter out triangles connected to the "shell" points
     indices = filteroutEdgeConnections(indices, shellPointIndices);
+    // console.log(...allLongLats.slice(0, 10));
+    for (let i = 0; i < allLongLats.length / 2; i++) {
+        const xy = radianToMercatorXY([allLongLats[i * 2], allLongLats[i * 2 + 1]]);
+        allLongLats[i * 2] = xy[0];
+        allLongLats[i * 2 + 1] = xy[1];
+    }
+    // show first 5
+    // console.log(...allLongLats.slice(0, 10));
     return {
         vec3s: new Float32Array(allVec3s),
         longLats: new Float32Array(allLongLats),

package/investigation-tools/draw/tiles/adapters.js

@@ -0,0 +1,67 @@
+function boilerArcInput(start, end, color, key) {
+    return {
+        key: key,
+        start: start,
+        end: end,
+        color: color,
+        height: null,
+        msl: null
+    };
+}
+export function tileToArcInputs(tiles, color) {
+    if (tiles.length === 0)
+        return [];
+    const result = [];
+    // (alias) type ArcInput = {
+    //     key: string;
+    //     start: LongLat;
+    //     end: LongLat;
+    //     color: Color;
+    //     height?: Meter | null;
+    //     msl?: boolean | null;
+    // }
+    for (const tile of tiles) {
+        const tileKey = `tile_${tile.row}_${tile.column}`;
+        const bbox = tile.bbox;
+        // left side
+        result.push(boilerArcInput([bbox.ll.x, bbox.ll.y], [bbox.ll.x, bbox.ur.y], color, `${tileKey}_left`));
+        // top side
+        result.push(boilerArcInput([bbox.ll.x, bbox.ur.y], [bbox.ur.x, bbox.ur.y], color, `${tileKey}_top`));
+        // bottom side
+        result.push(boilerArcInput([bbox.ll.x, bbox.ll.y], [bbox.ur.x, bbox.ll.y], color, `${tileKey}_bottom`));
+        // right side
+        result.push(boilerArcInput([bbox.ur.x, bbox.ll.y], [bbox.ur.x, bbox.ur.y], color, `${tileKey}_right`));
+    }
+    return result;
+}
+export function mergedTileToArcInputs(mergedTile, color) {
+    const result = [];
+    const bbox = mergedTile.bbox;
+    // left side
+    result.push(boilerArcInput([bbox.ll.x, bbox.ll.y], [bbox.ll.x, bbox.ur.y], color, `${mergedTile.zoom}_left`));
+    // right side
+    result.push(boilerArcInput([bbox.ur.x, bbox.ll.y], [bbox.ur.x, bbox.ur.y], color, `${mergedTile.zoom}_right`));
+    // top side
+    result.push(boilerArcInput([bbox.ll.x, bbox.ur.y], [bbox.ur.x, bbox.ur.y], color, `${mergedTile.zoom}_top`));
+    // bottom side
+    result.push(boilerArcInput([bbox.ll.x, bbox.ll.y], [bbox.ur.x, bbox.ll.y], color, `${mergedTile.zoom}_bottom`));
+    return result;
+}
+export function tilesToContextWriter4Inputs(tiles) {
+    const result = [];
+    for (const tile of tiles) {
+        const tileKey = `L_${tile.level}_R${tile.row}_C${tile.column}`;
+        const centerLong = (tile.bbox.ll.x + tile.bbox.ur.x) / 2;
+        const centerLat = (tile.bbox.ll.y + tile.bbox.ur.y) / 2;
+        result.push({
+            key: tileKey,
+            long: centerLong,
+            lat: centerLat,
+            text: tileKey,
+            opacity: null,
+            angle: null,
+            position: 'center'
+        });
+    }
+    return result;
+}

package/investigation-tools/draw/tiles/tiles.js

@@ -0,0 +1,128 @@
+import { ArcOnTerrainPlugin } from "../../../semiplugins/shape-on-terrain/arc-plugin";
+import { tileToArcInputs, tilesToContextWriter4Inputs, mergedTileToArcInputs } from "./adapters";
+import { ContextTextWriter4 } from "../../../write-text/context-text4";
+import { mergeMeshes } from "../../../Math/tessellation/tile-merger";
+// diverse ColorRamp
+const defaultColorsRamp = [
+    [0.0, [0, 0, 255, 255]], // Blue
+    // [0.3, [255, 165, 0, 255]],    // Orange
+    [0.25, [0, 255, 0, 255]], // Green
+    // [0.4, [255, 0, 0, 255]],      // Red
+    [0.5, [128, 0, 128, 255]], // Purple
+    // [0.6, [0, 255, 255, 255]],    // Cyan
+    [0.75, [255, 192, 203, 255]], // Pink
+    [1.0, [255, 255, 255, 255]], // White
+    // [1.0, [0, 0, 0, 255]]         // Black
+];
+export class TilesRendererPlugin {
+    id;
+    globe;
+    gl;
+    arcPlugin;
+    contextTextWriter;
+    colorsRamp;
+    _lastTilesUniqueIdentifier = null;
+    constructor(id, colorsRamp = defaultColorsRamp) {
+        this.globe = null;
+        this.gl = null;
+        this.contextTextWriter = null;
+        this.id = id;
+        this.colorsRamp = colorsRamp;
+        this.arcPlugin = new ArcOnTerrainPlugin(id + "_arc_plugin", {
+            variativeColorsOn: true,
+            defaultHeightFromGroundIn3D: 0,
+        });
+    }
+    init(globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+        this.contextTextWriter = new ContextTextWriter4(globe, (item) => { return [item]; }, (item) => { return item.key; }, (zoomLevel) => (item) => {
+            return {
+                opacityMultiplier: 1,
+                sizeMultiplier: 1
+            };
+        });
+        this.arcPlugin.init(globe, gl);
+    }
+    draw3D(projectionMatrix, modelViewMatrix, transPosition) {
+        // if (this.globe.api_IsScreenMoving()) {
+        this._prepareArcInputs();
+        // }
+        this.arcPlugin.draw3D();
+        this.contextTextWriter.draw();
+    }
+    free() {
+        this.arcPlugin.free();
+    }
+    _prepareArcInputs() {
+        // const drawnTiles = filterTilesInScreen(
+        //     this.globe.api_GetDrawedTilesInfo(),
+        //     this.globe
+        // );
+        const drawnTiles = this.globe.api_GetDrawedTilesInfo();
+        let maxLevel = 0;
+        let minLevel = Number.MAX_VALUE;
+        const tileMap = new Map();
+        for (const tile of drawnTiles) {
+            if (tile.level > maxLevel) {
+                maxLevel = tile.level;
+            }
+            if (tile.level < minLevel) {
+                minLevel = tile.level;
+            }
+            if (!tileMap.has(tile.level)) {
+                tileMap.set(tile.level, []);
+            }
+            tileMap.get(tile.level).push(tile);
+        }
+        let tilesUniqueId = "";
+        for (let level = minLevel; level <= maxLevel; level++) {
+            const tiles = tileMap.get(level);
+            if (!tiles)
+                continue;
+            tilesUniqueId += `L${level}_C${tiles.length}_`;
+        }
+        if (tilesUniqueId === this._lastTilesUniqueIdentifier)
+            return;
+        this._lastTilesUniqueIdentifier = tilesUniqueId;
+        const levelRange = maxLevel - minLevel;
+        const colors = this._interpolateColors(levelRange);
+        this.arcPlugin.deleteAll();
+        for (let level = maxLevel; level >= minLevel; level--) {
+            const tiles = tileMap.get(level);
+            if (!tiles)
+                continue;
+            const colorIndex = level - minLevel;
+            const color = colors[colorIndex];
+            const arcInputs = tileToArcInputs(tiles, color);
+            this.arcPlugin.insertBulk(arcInputs);
+        }
+        // drawMergedBBoxes:
+        const mergedTiles = mergeMeshes(drawnTiles, 12, 5, 4);
+        const color = [255, 255, 0, 255]; // Yellow
+        const arcMergedInputs = mergedTiles.map(mergedTile => mergedTileToArcInputs(mergedTile, color)).flat();
+        this.arcPlugin.insertBulk(arcMergedInputs);
+        const contextWriterInputs = tilesToContextWriter4Inputs(drawnTiles);
+        this.contextTextWriter.clear();
+        this.contextTextWriter.insertTextBulk(contextWriterInputs);
+    }
+    _interpolateColors(maxValue) {
+        let colors = [];
+        let colorRampIndex = 0;
+        for (let i = 0; i <= maxValue; i++) {
+            const t = i / maxValue;
+            while (colorRampIndex < this.colorsRamp.length - 1 && t > this.colorsRamp[colorRampIndex + 1][0]) {
+                colorRampIndex++;
+            }
+            const [t0, color0] = this.colorsRamp[colorRampIndex];
+            const [t1, color1] = this.colorsRamp[Math.min(colorRampIndex + 1, this.colorsRamp.length - 1)];
+            const localT = (t - t0) / (t1 - t0);
+            const r = Math.round(color0[0] + (color1[0] - color0[0]) * localT);
+            const g = Math.round(color0[1] + (color1[1] - color0[1]) * localT);
+            const b = Math.round(color0[2] + (color1[2] - color0[2]) * localT);
+            // const a = Math.round(color0[3] + (color1[3] - color0[3]) * localT);
+            colors.push([r, g, b, 255]);
+        }
+        return colors;
+    }
+}

package/package.json

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