@pirireis/webglobeplugins 0.17.1 → 1.0.3

package/Math/tessellation/tile-merger.js

@@ -1,52 +1,89 @@
-function displayTileMetaData(tilesMetaData) {
-    // show maxZoom minZoom
-    console.log(`Max Level: ${tilesMetaData.maxLevel}
-    Min Level: ${tilesMetaData.minLevel}`);
+import { calculateMergedMeshDimLength } from "./methods";
+import { NearestValuePadding } from "./nearest-value-padding";
+function keyMethod(x, y, level) {
+    return `${level}_${x}_${y}`;
 }
-function keyMethod(row, column, level) {
-    return `${level}_${row}_${column}`;
-}
-function calculateParentTile(row, column, level) {
+function calculateParentTile(x, y, level) {
     return {
-        row: Math.floor(row / 2),
-        column: Math.floor(column / 2),
+        x: Math.floor(x / 2),
+        y: Math.floor(y / 2),
         level: level - 1
     };
 }
-function createMapAndMetaData(tiles) {
+function createMapAndMetaData(tiles, globe) {
     const tileMap = new Map();
     let maxLevel = -Infinity;
     let minLevel = Infinity;
-    const tileLimitsByZoom = new Map();
+    // Intermediate storage to analyze distributions per zoom level
+    const zoomData = new Map();
+    // 1. First Pass: Populate Map and Collect Coordinates
     for (const tile of tiles) {
-        const key = keyMethod(tile.row, tile.column, tile.level);
+        const key = keyMethod(tile.x, tile.y, tile.level);
         tileMap.set(key, tile);
-        if (tile.level > maxLevel) {
+        // Update Level Range
+        if (tile.level > maxLevel)
             maxLevel = tile.level;
-        }
-        if (tile.level < minLevel) {
+        if (tile.level < minLevel)
             minLevel = tile.level;
+        // Collect Data
+        if (!zoomData.has(tile.level)) {
+            zoomData.set(tile.level, { xValues: [], yValues: [] });
         }
-        if (!tileLimitsByZoom.has(tile.level)) {
-            tileLimitsByZoom.set(tile.level, {
-                minRow: tile.row,
-                maxRow: tile.row,
-                minCol: tile.column,
-                maxCol: tile.column
-            });
+        const data = zoomData.get(tile.level);
+        data.xValues.push(tile.x);
+        data.yValues.push(tile.y);
+    }
+    const tileLimitsByZoom = new Map();
+    // 2. Second Pass: Analyze Data per Zoom Level
+    zoomData.forEach((data, level) => {
+        // --- Calculate Gravity Centers (Mode) ---
+        // --- Calculate Min/Max and Antimeridian ---
+        // Sort X values to detect gaps
+        const sortedX = [...new Set(data.xValues)].sort((a, b) => a - b);
+        const minY = Math.min(...data.yValues);
+        const maxY = Math.max(...data.yValues);
+        let minX = sortedX[0];
+        let maxX = sortedX[sortedX.length - 1];
+        let isAntimeridian = false;
+        // We only check for wrapping if we have tiles near both edges (0 and Max)
+        // A simple heuristic: find the largest gap between sorted indices.
+        let maxGap = 0;
+        let gapIndex = -1;
+        for (let i = 0; i < sortedX.length - 1; i++) {
+            const gap = sortedX[i + 1] - sortedX[i];
+            if (gap > maxGap) {
+                maxGap = gap;
+                gapIndex = i;
+            }
         }
-        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;
+        // Also check the wrap-around gap (distance from last tile to world end + first tile)
+        // Though strictly for clustering split, we usually look for the internal gap.
+        // If the largest internal gap is significantly large (e.g., > worldWidth / 2),
+        // we treat the smaller numbers as the "East of view" (Right side) 
+        // and large numbers as "West of view" (Left side) relative to the dateline.
+        // let centerX = getGravityCenter(data.xValues);
+        // const centerY = getGravityCenter(data.yValues);
+        const { x: centerX, y: centerY } = getCenterFromCamera(globe, level);
+        if (maxGap > 5 && maxX === Math.pow(2, level) - 1 && minX === 0) {
+            isAntimeridian = true;
+            // Cluster 1 (Low X): sortedX[0] ... sortedX[gapIndex]  -> "West Cluster" (The Americas/Left side of map 0..x)
+            // Cluster 2 (High X): sortedX[gapIndex+1] ... end      -> "East Cluster" (Asia/Right side of map x..max)
+            // Per requirements:
+            // "max value now represents max of west cluster" -> Max of the Low X numbers
+            maxX = sortedX[gapIndex];
+            // "min values represents min of east cluster" -> Min of the High X numbers
+            minX = sortedX[gapIndex + 1];
         }
-    }
+        tileLimitsByZoom.set(level, {
+            minX,
+            maxX,
+            minY,
+            maxY,
+            antimeridian: isAntimeridian,
+            centerX,
+            centerY
+        });
+    });
     return {
         tileMap,
         maxLevel,
@@ -54,98 +91,234 @@ function createMapAndMetaData(tiles) {
         tileLimitsByZoom
     };
 }
+// Helper to find the most frequent value (Gravity Center)
+function getMode(arr) {
+    if (arr.length === 0)
+        return 0;
+    const map = new Map();
+    let maxCount = 0;
+    let mode = arr[0];
+    for (const num of arr) {
+        const count = (map.get(num) || 0) + 1;
+        map.set(num, count);
+        if (count > maxCount) {
+            maxCount = count;
+            mode = num;
+        }
+    }
+    return mode;
+}
+function getGravityCenter(arr) {
+    if (arr.length === 0)
+        return 0;
+    const sum = arr.reduce((acc, val) => acc + val, 0);
+    return Math.round(sum / arr.length);
+}
+function getCenterFromCamera(globe, zoom) {
+    const camLongLat = globe.FCamera.FCamLongLat;
+    const n = Math.pow(2, zoom);
+    const x = Math.floor((camLongLat.x / (2 * Math.PI) + 0.5) * n);
+    const y = Math.floor((camLongLat.y / Math.PI + 0.5) * n);
+    return { x, y };
+}
 function populateTileIntoHigherZoomLevel(tileMesh, tileDimensionLength, targetDimensionLength) {
-    const newMesh = new Array(targetDimensionLength).fill(0).map(() => new Float32Array(targetDimensionLength));
+    const newMesh = Array.from({ length: targetDimensionLength }, () => 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);
+            const sourceRow = row / (targetDimensionLength - 1) * (tileDimensionLength - 1);
+            const sourceCol = col / (targetDimensionLength - 1) * (tileDimensionLength - 1);
+            const rowLow = Math.floor(sourceRow);
+            const rowHigh = Math.min(Math.ceil(sourceRow), tileDimensionLength - 1);
+            const colLow = Math.floor(sourceCol);
+            const colHigh = Math.min(Math.ceil(sourceCol), tileDimensionLength - 1);
+            const topLeft = tileMesh[rowLow][colLow];
+            const topRight = tileMesh[rowLow][colHigh];
+            const bottomLeft = tileMesh[rowHigh][colLow];
+            const bottomRight = tileMesh[rowHigh][colHigh];
+            const top = topLeft + (topRight - topLeft) * (sourceCol - colLow);
+            const bottom = bottomLeft + (bottomRight - bottomLeft) * (sourceCol - colLow);
+            newMesh[row][col] = top + (bottom - top) * (sourceRow - rowLow);
         }
     }
     return newMesh;
 }
+function fillFromChildren(targetMesh, targetDimensionLength, childrenMeshes, sourceDimensionLength, startX, startY) {
+    const halfDim = (sourceDimensionLength - 1) / 2;
+    // Child 0: Top Left
+    if (childrenMeshes[0]) {
+        const child = childrenMeshes[0];
+        for (let r = 0; r <= halfDim; r++) {
+            // Read from top of child (source convention is bottom-up, so top is index Length-1)
+            // We skip every second row: (L-1), (L-3), ...
+            const childRowIndex = (sourceDimensionLength - 1) - (r * 2);
+            const rowData = child[childRowIndex];
+            for (let c = 0; c <= halfDim; c++) {
+                // Skip every second column
+                const val = rowData[c * 2];
+                const targetIdx = (startY + r) * targetDimensionLength + (startX + c);
+                targetMesh[targetIdx] = val;
+            }
+        }
+    }
+    // Child 1: Top Right
+    // In mergeTiles loop (dx outer, dy inner), index 2 corresponds to dx=1, dy=0 (Top Right)
+    if (childrenMeshes[2]) {
+        const child = childrenMeshes[2];
+        for (let r = 0; r <= halfDim; r++) {
+            const childRowIndex = (sourceDimensionLength - 1) - (r * 2);
+            const rowData = child[childRowIndex];
+            for (let c = 0; c <= halfDim; c++) {
+                const val = rowData[c * 2];
+                const targetIdx = (startY + r) * targetDimensionLength + (startX + halfDim + c);
+                if (isNaN(targetMesh[targetIdx])) {
+                    targetMesh[targetIdx] = val;
+                }
+            }
+        }
+    }
+    // Child 2: Bottom Left
+    // In mergeTiles loop, index 1 corresponds to dx=0, dy=1 (Bottom Left)
+    if (childrenMeshes[1]) {
+        const child = childrenMeshes[1];
+        for (let r = 0; r <= halfDim; r++) {
+            const childRowIndex = (sourceDimensionLength - 1) - (r * 2);
+            const rowData = child[childRowIndex];
+            for (let c = 0; c <= halfDim; c++) {
+                const val = rowData[c * 2];
+                const targetIdx = (startY + halfDim + r) * targetDimensionLength + (startX + c);
+                if (isNaN(targetMesh[targetIdx])) {
+                    targetMesh[targetIdx] = val;
+                }
+            }
+        }
+    }
+    // Child 3: Bottom Right
+    if (childrenMeshes[3]) {
+        const child = childrenMeshes[3];
+        for (let r = 0; r <= halfDim; r++) {
+            const childRowIndex = (sourceDimensionLength - 1) - (r * 2);
+            const rowData = child[childRowIndex];
+            for (let c = 0; c <= halfDim; c++) {
+                const val = rowData[c * 2];
+                const targetIdx = (startY + halfDim + r) * targetDimensionLength + (startX + halfDim + c);
+                if (isNaN(targetMesh[targetIdx])) {
+                    targetMesh[targetIdx] = val;
+                }
+            }
+        }
+    }
+}
 // 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;
+    // sourceMesh[0][0] is south west corner
+    // targetMesh[0][0] is top left corner
+    let targetIndex = startY * targetDimensionLength + startX;
+    for (let y = 0; y < sourceDimensionLength; y++) {
+        // Read from bottom to top (source mesh convention)
+        const vertical = sourceMesh[sourceDimensionLength - y - 1];
+        for (let x = 0; x < sourceDimensionLength; x++) {
+            const value = vertical[x];
+            // const currentValue = targetMesh[targetIndex];
+            // TODO: investigate why overlapping values are not the same. cancel parent filling
+            // if (!isNaN(value) && value !== 0 && currentValue !== 0) {
+            //     if (currentValue !== value) {
+            //         console.warn(`Overlapping values are not the same: currentValue=${currentValue}, newValue=${value}`);
+            //     }
+            // }
+            if (isNaN(targetMesh[targetIndex])) {
+                targetMesh[targetIndex] = value;
             }
-            targetMesh[targetIndex] = value;
+            targetIndex++;
         }
+        targetIndex += targetDimensionLength - sourceDimensionLength;
     }
 }
 function limitCheck(limit, limitRange = 12) {
-    const rowRange = limit.maxRow - limit.minRow + 1;
-    const colRange = limit.maxCol - limit.minCol + 1;
+    // TODO: far tiles from camera should be pruned to fit in the limit range
+    const rowRange = limit.maxX - limit.minX + 1;
+    const colRange = limit.maxY - limit.minY + 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 mergedMeshDimLength = calculateMergedMeshDimLength(mergeCount, tileDimensionLength);
+    const nearestValuePadding = new NearestValuePadding(tileDimensionLength, mergeCount);
+    // Helper to check if a number is between range (inclusive)
     const result = [];
     for (let zoom = tilesMetaData.maxLevel; zoom >= tilesMetaData.minLevel; zoom--) {
-        let processedTileCountFromCurrentLevel = 0;
-        let processedTileCountFromParentLevel = 0;
         if (tilesMetaData.maxLevel - zoom >= processLimit) {
             break;
         }
         const limits = tilesMetaData.tileLimitsByZoom.get(zoom);
-        const mergedMesh = new Float32Array(mergedMeshDimLength * mergedMeshDimLength).fill(0);
+        if (!limits)
+            continue;
+        const mergedMesh = new Float32Array(mergedMeshDimLength * mergedMeshDimLength).fill(NaN);
+        // Initialize BBox. 
+        // We track East (high X) and West (low X) clusters separately for Antimeridian cases.
         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;
+        // Specific BBox trackers for antimeridian split
+        let eastClusterMinX = Infinity; // For the left side of the view (e.g. 170)
+        let westClusterMaxX = -Infinity; // For the right side of the view (e.g. -170)
+        // limitCheck(limits, 20); // Assumed helper<
+        const worldWidth = Math.pow(2, zoom);
+        // --- Task 1: Calculate Grid Origin (Centering) ---
+        // We determine where the top-left of our mergeCount x mergeCount grid starts in tile coordinates.
+        let originX = limits.minX;
+        let originY = limits.minY;
+        const rangeX = limits.antimeridian
+            ? (worldWidth - limits.minX) + limits.maxX + 1
+            : limits.maxX - limits.minX + 1;
+        const rangeY = limits.maxY - limits.minY + 1;
+        // If the data is wider than the mesh, center it using centerX
+        if (rangeX > mergeCount && limits.centerX !== undefined) {
+            originX = Math.floor(limits.centerX - (mergeCount / 2));
+        }
+        // If the data is taller than the mesh, center it using centerY
+        if (rangeY > mergeCount && limits.centerY !== undefined) {
+            originY = Math.floor(limits.centerY - (mergeCount / 2));
+        }
+        // --- Task 2: Iterate Grid Slots ---
+        // Instead of iterating tile coordinates, we iterate the target grid slots (0..mergeCount)
+        // and calculate which tile belongs there.
+        for (let i = 0; i < mergeCount; i++) {
+            for (let j = 0; j < mergeCount; j++) {
+                // Calculate actual Tile Coordinates
+                // Handle X Wrapping for Antimeridian
+                let tileX = (originX + i);
+                // JS modulo of negative numbers behaves oddly, ensure positive wrap
+                tileX = ((tileX % worldWidth) + worldWidth) % worldWidth;
+                const tileY = originY + j;
+                // --- Validity Check ---
+                // Check if this specific tileX/tileY is actually part of the visible map data
+                let isValidX = false;
+                if (limits.antimeridian) {
+                    isValidX = tileX >= limits.minX || tileX <= limits.maxX;
+                }
+                else {
+                    isValidX = tileX >= limits.minX && tileX <= limits.maxX;
                 }
+                const isValidY = tileY >= limits.minY && tileY <= limits.maxY;
+                if (!isValidX || !isValidY)
+                    continue;
+                const key = keyMethod(tileX, tileY, zoom);
                 const tile = tilesMetaData.tileMap.get(key);
+                // Calculate mesh offset (target position in pixels/floats)
+                const meshOffsetX = i * (tileDimensionLength - 1);
+                const meshOffsetY = j * (tileDimensionLength - 1);
                 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
+                    // 1. Direct Tile Found
+                    nearestValuePadding.insert(tile.x, tile.y); // Using original coordinates for padding logic
+                    moveMeshToMergedMesh(mergedMesh, mergedMeshDimLength, tile.mesh, tileDimensionLength, meshOffsetX, meshOffsetY);
+                    // Update BBox Limits
+                    // We simply expand the LL/UR. 
+                    // Post-processing will fix the inverted X for antimeridian.
                     if (tile.bbox.ll.x < bboxLimit.ll.x)
                         bboxLimit.ll.x = tile.bbox.ll.x;
                     if (tile.bbox.ll.y < bboxLimit.ll.y)
@@ -154,145 +327,103 @@ function mergeTiles(tilesMetaData, mergeCount = 8, tileDimensionLength = 5, proc
                         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);
+                    // Track clusters for antimeridian split
+                    // High X values (East Cluster) -> Left side of visual boundary
+                    // Low X values (West Cluster) -> Right side of visual boundary
+                    if (limits.antimeridian) {
+                        if (tileX >= limits.minX) {
+                            if (tile.bbox.ll.x < eastClusterMinX)
+                                eastClusterMinX = tile.bbox.ll.x;
+                        }
+                        else {
+                            if (tile.bbox.ur.x > westClusterMaxX)
+                                westClusterMaxX = tile.bbox.ur.x;
+                        }
+                    }
+                }
+                else {
+                    // 2. Parent Tile Fallback
+                    const parentTileCoord = calculateParentTile(tileX, tileY, zoom);
+                    const parentKey = keyMethod(parentTileCoord.x, parentTileCoord.y, parentTileCoord.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;
+                        const populatedMesh = populateTileIntoHigherZoomLevel(parentTile.mesh, tileDimensionLength, tileDimensionLength * 2 - 1);
+                        // Adjust offset for parent logic
+                        // If current tile is odd (right/bottom), the parent mesh drawing needs to shift back
+                        // because 'populatedMesh' covers 2x2.
+                        const parentDrawOffsetX = meshOffsetX - (tileX % 2) * (tileDimensionLength - 1);
+                        const parentDrawOffsetY = meshOffsetY - (tileY % 2) * (tileDimensionLength - 1);
+                        moveMeshToMergedMesh(mergedMesh, mergedMeshDimLength, populatedMesh, tileDimensionLength * 2 - 1, parentDrawOffsetX, parentDrawOffsetY);
+                        // Padding logic for parents
+                        const xP = parentTile.x * 2;
+                        const yP = parentTile.y * 2;
+                        for (let dx = 0; dx < 2; dx++) {
+                            for (let dy = 0; dy < 2; dy++) {
+                                nearestValuePadding.insert(xP + dx, yP + dy);
                             }
-
-                            // 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);
+                        }
+                    }
+                    else {
+                        // 3. Children Tile Fallback
+                        const childrenTiles = [];
+                        let anyChildren = 0;
+                        for (let dx = 0; dx < 2; dx++) {
+                            for (let dy = 0; dy < 2; dy++) {
+                                const childX = tileX * 2 + dx;
+                                const childY = tileY * 2 + dy;
+                                const childKey = keyMethod(childX, childY, zoom + 1);
+                                const childTile = tilesMetaData.tileMap.get(childKey);
+                                if (childTile) {
+                                    anyChildren++;
+                                    childrenTiles.push(childTile.mesh);
+                                }
+                                else {
+                                    childrenTiles.push(undefined);
                                 }
                             }
-
-                            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 (anyChildren > 0) {
+                            nearestValuePadding.insert(tileX, tileY);
+                            fillFromChildren(mergedMesh, mergedMeshDimLength, childrenTiles, tileDimensionLength, meshOffsetX, meshOffsetY);
+                        }
                     }
-               
-                    */
                 }
             }
         }
-        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 } });
+        // Post-Processing BBox for Antimeridian
+        if (limits.antimeridian) {
+            // Task: bbox.ll should contain lower-left of East Cluster, bbox.ur should contain upper-right of West Cluster
+            // This creates the condition ur.x < ll.x (e.g. 170 to -170)
+            // Only update if we actually found tiles in those clusters
+            if (eastClusterMinX !== Infinity)
+                bboxLimit.ll.x = eastClusterMinX;
+            if (westClusterMaxX !== -Infinity)
+                bboxLimit.ur.x = westClusterMaxX;
+            // console.log("Antimeridian BBox adjusted:", bboxLimit);
+        }
+        // We pad the merged mesh based on the VALID range we iterated.
+        // Since we iterate 0..mergeCount, the indices are implicitly 0..mergeCount
+        // However, the clamp function usually expects absolute coordinates. 
+        // Given the new "Grid" approach, the mesh is always locally 0 to mergeCount in valid data.
+        // We pass the grid-relative limits to clamp.
+        nearestValuePadding.clamp(mergedMesh, 0, 0, mergeCount, mergeCount);
+        nearestValuePadding.clear();
+        // Calculate Cover Ratio
+        // How much of the mesh grid (mergeCount) is covered by actual data range?
+        const currentWidth = limits.antimeridian ? rangeX : (limits.maxX - limits.minX + 1);
+        const currentHeight = limits.maxY - limits.minY + 1;
+        const usedWidth = Math.min(mergeCount, currentWidth);
+        const usedHeight = Math.min(mergeCount, currentHeight);
+        const xRatio = calculateMergedMeshDimLength(usedWidth, tileDimensionLength) / mergedMeshDimLength;
+        const yRatio = calculateMergedMeshDimLength(usedHeight, tileDimensionLength) / mergedMeshDimLength;
+        result.push({ mesh: mergedMesh, bbox: bboxLimit, zoom: zoom, coverRatio: { x: xRatio, y: yRatio } });
     }
     return result;
 }
-export function mergeMeshes(tiles, mergeCount = 12, tileDimensionLength = 5, processLimit = 6) {
+export function mergeMeshes(tiles, mergeCount = 12, tileDimensionLength = 5, processLimit = 6, globe) {
     // filter out tiles with NaN values
     // return returnTop6tiles(tiles);
-    const tilesMetaData = createMapAndMetaData(tiles);
+    const tilesMetaData = createMapAndMetaData(tiles, globe);
     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 },
-        };
-    }
-    for (const tile of tiles) {
-        if (counter === 0)
-            break;
-        if (tile.level === hightestZoom) {
-            result.push(tileToMergedTileInfo(tile));
-            counter--;
-        }
-    }
-    return result;
-}