@mindexec/cli 0.2.430 → 0.2.432

package/wwwroot/_content/MindExecution.Shared/js/mind-map-lod-renderer.js

@@ -924,10 +924,10 @@
             // Create initial texture array
             this._createTextureArray();
 
-            // Line data cache & texture (for actual text-based lines)
-            this.maxInstances = 10000;
-            this.lineDataCache = new Map(); // nodeId -> { signature, lineCount, lineLengths }
-            this.lineDataArray = new Uint8Array(this.maxInstances * MAX_LINE_SAMPLES);
+            this.maxInstances = 10000;
+            this.lineDataCache = new Map();
+            this.lineTextureRows = window.MindMapRenderPlan?.initialLineTextureRows?.(this.maxInstances) || this.maxInstances;
+            this.lineDataArray = new Uint8Array(this.lineTextureRows * MAX_LINE_SAMPLES);
             this.lineDataTexture = null;
             this.lineDataDirty = true;
             this._lastInstanceCount = 0;
@@ -1211,7 +1211,7 @@
                 return this.imageAtlasFreeSlots.pop();
             }
 
-            if (this.imageAtlasNextSlot >= IMAGE_LOD_ATLAS_MAX_SLOTS) {
+            if (this.imageAtlasNextSlot >= (this.imageAtlasMaxSlots || IMAGE_LOD_ATLAS_MAX_SLOTS)) {
                 return -1;
             }
 
@@ -1219,9 +1219,10 @@
         }
 
         _getImageAtlasUvRect(slotIndex) {
-            const col = slotIndex % IMAGE_LOD_ATLAS_COLUMNS;
-            const row = Math.floor(slotIndex / IMAGE_LOD_ATLAS_COLUMNS);
-            const invAtlas = 1 / IMAGE_LOD_ATLAS_SIZE;
+            const columns = this.imageAtlasColumns || IMAGE_LOD_ATLAS_COLUMNS;
+            const col = slotIndex % columns;
+            const row = Math.floor(slotIndex / columns);
+            const invAtlas = 1 / (this.imageAtlasSize || IMAGE_LOD_ATLAS_SIZE);
             const inset = 1.0;
             return [
                 (col * IMAGE_LOD_THUMBNAIL_SIZE + inset) * invAtlas,
@@ -1232,7 +1233,7 @@
         }
 
         _getImagePlaceholderUvRect() {
-            const invAtlas = 1 / IMAGE_LOD_ATLAS_SIZE;
+            const invAtlas = 1 / (this.imageAtlasSize || IMAGE_LOD_ATLAS_SIZE);
             return [invAtlas, invAtlas, invAtlas, invAtlas];
         }
 
@@ -1583,8 +1584,9 @@
                 return false;
             }
 
-            const col = slot.slotIndex % IMAGE_LOD_ATLAS_COLUMNS;
-            const row = Math.floor(slot.slotIndex / IMAGE_LOD_ATLAS_COLUMNS);
+            const columns = this.imageAtlasColumns || IMAGE_LOD_ATLAS_COLUMNS;
+            const col = slot.slotIndex % columns;
+            const row = Math.floor(slot.slotIndex / columns);
             const x = col * IMAGE_LOD_THUMBNAIL_SIZE;
             const y = row * IMAGE_LOD_THUMBNAIL_SIZE;
             const size = IMAGE_LOD_THUMBNAIL_SIZE;
@@ -1712,8 +1714,8 @@
             if (!this.lineDataTexture) {
                 this.lineDataTexture = new THREE.DataTexture(
                     this.lineDataArray,
-                    MAX_LINE_SAMPLES,
-                    this.maxInstances,
+                    MAX_LINE_SAMPLES,
+                    this.lineTextureRows,
                     THREE.RedFormat,
                     THREE.UnsignedByteType
                 );
@@ -2154,7 +2156,7 @@
             const lineMaterial = new THREE.ShaderMaterial({
                 uniforms: {
                     uLineDataTex: { value: this.lineDataTexture },
-                    uLineDataSize: { value: new THREE.Vector2(MAX_LINE_SAMPLES, this.maxInstances) },
+                    uLineDataSize: { value: new THREE.Vector2(MAX_LINE_SAMPLES, this.lineTextureRows) },
                     uLineHeightPx: { value: LINE_HEIGHT_PX },
                     uLinePaddingPx: { value: LINE_PADDING_PX },
                     uLineHalfThicknessPx: { value: LOD_TEXT_LINE_HALF_THICKNESS_SCREEN_PX },
@@ -2727,43 +2729,6 @@
             this._startFullResHandoff(previousBand || this._fullResHandoffPreviousBand || 'MID', 'pending-css', this._fullResPanHandoffMaxMs);
         }
 
-        _collectResidentModeCss3dCleanupIds(nodeObjectsById) {
-            const ids = new Set();
-            if (!nodeObjectsById?.forEach) {
-                return ids;
-            }
-
-            nodeObjectsById.forEach((entry, key) => {
-                if (!entry?.cssObject || isLivePortalCssLodModel(entry?.model)) {
-                    return;
-                }
-
-                const element = entry.cssObject.element || null;
-                const isAttached = !!entry.cssObject.parent;
-                const isDisplayed = !!element &&
-                    element.style.display !== 'none' &&
-                    element.style.visibility !== 'hidden' &&
-                    element.style.opacity !== '0';
-                const isVisible = entry.cssObject.visible === true || isAttached || isDisplayed;
-                if (!isVisible) {
-                    return;
-                }
-
-                const nodeId = String(
-                    entry.model?.id ||
-                    entry.model?.Id ||
-                    entry.glObject?.userData?.nodeId ||
-                    entry.cssObject?.userData?.nodeId ||
-                    key ||
-                    ''
-                ).trim();
-                if (nodeId) {
-                    ids.add(nodeId);
-                }
-            });
-
-            return ids;
-        }
         // ▲▲▲ [New] ▲▲▲
 
         // ═══════════════════════════════════════════════════════════════════════
@@ -3756,7 +3721,7 @@
                 }
             }
 
-            for (const nodeId of Array.from(this._lodImageCssFallbackNodeIds)) {
+            for (const nodeId of window.MindMapRenderPlan?.fallbackBatch?.(this,this._lodImageCssFallbackNodeIds)||Array.from(this._lodImageCssFallbackNodeIds)) {
                 if (nextFallbackIds.has(nodeId)) {
                     continue;
                 }
@@ -3779,7 +3744,7 @@
             }
 
             let hiddenCount = 0;
-            for (const nodeId of Array.from(this._lodImageCssFallbackNodeIds)) {
+            for (const nodeId of window.MindMapRenderPlan?.fallbackBatch?.(this,this._lodImageCssFallbackNodeIds)||Array.from(this._lodImageCssFallbackNodeIds)) {
                 const entry = nodeObjectsById?.get?.(nodeId) || null;
                 if (entry) {
                     this._hideCssMediaLodFallback(entry);
@@ -4554,6 +4519,7 @@
         }
 
         _restoreVisibleCss3dHighDetailForNear(nodeObjectsById, module, lodBand) {
+            // Full-res: NEAR / NORMAL. MID/FAR use resident instances.
             if ((lodBand !== 'NEAR' && lodBand !== 'NORMAL') || !nodeObjectsById) {
                 return 0;
             }
@@ -5826,8 +5792,8 @@
                     if (this.instancedImageMesh) this.instancedImageMesh.visible = false;
                     return;
                 }
+                window.MindMapRenderPlan?.scheduleResidentLinePrewarm?.(this, module, nodeObjectsById);
 
-                // Explicit bands: NEAR(DOM overlay + CSS3D), MID(resident nodes+lines), FAR(nodes only)
                 const shouldUseLOD = lodBand === 'MID' || lodBand === 'FAR';
                 perfMode = shouldUseLOD ? 'lod' : 'fullres';
                 const isLodPanFrame = shouldUseLOD &&
@@ -5890,8 +5856,6 @@
                     this._markCss3dSyncNeeded(true);
                 }
 
-                // State changed? Only toggle visibility on state change
-                // Also force transition when mode is unknown (after reset/re-activation).
                 if (modeChanged) {
                     const tModeStart = performance.now(); // ▼ [Timing]
                     this.isInLODMode = shouldUseLOD;
@@ -5904,7 +5868,6 @@
                     }
 
                     if (shouldUseLOD) {
-                        // LOD: instanced nodes are visible, halo is enabled in MID/FAR.
                         this._finishFullResHandoff('enter-lod');
                         this._clearFullResImageVisuals(nodeObjectsById);
                         this._fullResMotionHiddenGlIds.clear();
@@ -5923,7 +5886,6 @@
                         this._syncInstancedImageMeshVisibility();
                     }
 
-                        // Keep the resident MID/FAR instance buffers; only real node mutations mark them dirty.
                         const cssIdsToHide = new Set(this._nearCssVisibleIds);
                         for (let i = this._css3dQueueCursor || 0; i < this._css3dQueue.length; i++) {
                             const item = this._css3dQueue[i];
@@ -5933,17 +5895,13 @@
                             cssIdsToHide.add(nodeId);
                         }
                         const currentNodeMap = this._module?.nodeObjectsById;
-                        for (const nodeId of this._collectResidentModeCss3dCleanupIds(currentNodeMap)) {
-                            cssIdsToHide.add(nodeId);
-                        }
+                        for (const nodeId of this._activeFullResCssNodeIds) cssIdsToHide.add(nodeId);
                         this._clearCss3dQueue();
                         this._clearCss3dPrewarmQueue();
                         this._css3dProcessing = false;
                         this._nearCssVisibleIds.clear();
                         this._lastNearCssNoWorkKey = '';
 
-                        // Hide only CSS3D nodes that were actually on-screen; the LOD cleanup queue
-                        // catches any stale off-screen DOM without blocking the wheel transition.
                         const visibleIds = this._getNearVisibleIds(module);
                         const prioritizedWarm = currentNodeMap && visibleIds
                             ? this._getNearVisiblePriority(visibleIds, currentNodeMap, camera)
@@ -5958,7 +5916,26 @@
                                     if (!entry) continue;
                                     const model = entry.model;
                                     const isLivePortalCss = isLivePortalCssLodModel(model);
+                                    const isTextLike = isTextLikeModel(model);
                                     const shouldKeepConsoleProxy = false;
+                                    if (!isLivePortalCss && isTextLike) {
+                                        if (entry.cssObject) {
+                                            entry.cssObject.visible = false;
+                                            entry.cssObject.element?.style?.setProperty?.('display', 'none', 'important');
+                                        }
+                                        entry.currentType = 'GL';
+                                        if (entry.glObject) this._hideTextLodFullVisual(entry);
+                                        this._setGlowVisibility(entry, false);
+                                        continue;
+                                    }
+                                    const element = entry.cssObject?.element || null;
+                                    if (!isLivePortalCss && isCssMediaFallbackModel(model) &&
+                                        entry.cssObject?.visible === true && element && element.style.display !== 'none') {
+                                        this._lodImageCssFallbackNodeIds.add(nodeId);
+                                        entry.currentType = 'GL';
+                                        if (entry.glObject) this._hideGlBodyOnly(entry);
+                                        continue;
+                                    }
                                     if (entry.cssObject?.element) {
                                         this._hideAgentConsoleLodProxy(entry);
                                     }
@@ -5979,8 +5956,6 @@
                                         entry.currentType = 'GL';
                                     }
 
-                                    // Text-like nodes: hide GL body (InstancedMesh renders them)
-                                    const isTextLike = isTextLikeModel(model);
                                     const contentType = getNodeContentType(model);
                                     const isImage = isImageLodProxyModel(model);
                                     const isNodeSelected = isNodeSelectedForLod(nodeId, multiSelectedIds, selectedNodeId);
@@ -5988,7 +5963,6 @@
                                         this._hideTextLodFullVisual(entry);
                                     } else if (isImage) {
                                         if (shouldKeepCssMediaFallback) {
-                                            // Visible media stays on the CSS fallback path until its resident proxy is ready.
                                         } else {
                                             if (contentType === 'image' && !isCss3dRendererEnabled(module)) {
                                                 this._syncImageLodTransitionVisual(entry, lodBand, isNodeSelected, module);
@@ -6000,6 +5974,10 @@
 
                                     this._setGlowVisibility(entry, false);
                                 }
+                                if (module) {
+                                    module._css3dVisualChangedThisFrame = true;
+                                    module._css3dVisualChangedSinceLastRender = true;
+                                }
                             });
                             console.log(`[LODRenderer] CSS3D hidden synchronously in ${(performance.now() - hideStart).toFixed(1)}ms (${cssIdsToHide.size} active)`);
                         }
@@ -6016,8 +5994,6 @@
 
                     } else {
                         perfTime('fullResSetup', () => {
-                            // Full-res: NEAR / NORMAL. MID/FAR use resident instances.
-                            const tNearStart = performance.now();
                             if (this.instancedHaloMesh) this.instancedHaloMesh.visible = false;
                             if (this.instancedConsoleMesh) this.instancedConsoleMesh.visible = false;
                             this._startFullResHandoff(previousLodBand, 'enter-full-res', this._fullResHandoffMaxMs);
@@ -6051,8 +6027,6 @@
                                 window.MindMapCss3DManager?.setWillChange) {
                                 window.MindMapCss3DManager.setWillChange(true, module);
                             }
-                            const tModeEnd = performance.now();
-                            console.log(`[LODRenderer] ⏱️ Full-res band=${lodBand}: setup ${(tModeEnd - tNearStart).toFixed(1)}ms (visible-only CSS3D activation)`);
                             // ▲▲▲ [FIX] ▲▲▲
                         });
                     }
@@ -6091,8 +6065,12 @@
                 // ▼▼▼ [Fix] Keep CSS3D visibility synced while panning in near mode ▼▼▼
                 if (!this.isInLODMode) {
                     this._currentLodBand = lodBand;
-                    this._restoreVisibleCss3dHighDetailForNear(nodeObjectsById, module, lodBand);
                     const visibleIds = this._getNearVisibleIds(module);
+                    const renderPlan = window.MindMapRenderPlan;
+                    const css3dEnabled = isCss3dRendererEnabled(module);
+                    const stableFullResKey = renderPlan?.buildFullResKey(lodBand, visibilityVersion, lodSelectionKey, nodeObjectsById.size, visibleIds?.size || 0, this._nearCssVisibleIds.size, this._activeFullResCssNodeIds.size, css3dEnabled, module, this);
+                    if (visibleIds?.size > 0 && renderPlan?.shouldSkipStableFullRes(this, module, stableFullResKey, bandChangedWithoutModeSwitch)) return;
+                    this._restoreVisibleCss3dHighDetailForNear(nodeObjectsById, module, lodBand);
                     if (!visibleIds || visibleIds.size === 0) {
                         perfTime('fullResHandoff', () => {
                             this._activeFullResCssNodeIds.clear();
@@ -6172,17 +6150,8 @@
                         return;
                     }
 
-                    const nearCssNoWorkKey = `${lodBand}|${visibilityVersion}|${nodeObjectsById.size}|${this._nearCssVisibleIds.size}|${allowedCssIds.size}`;
-                    if (this._lastNearCssNoWorkKey === nearCssNoWorkKey &&
-                        !this._hasCss3dQueueItems() &&
-                        this._css3dQueuedMap.size === 0 &&
-                        this._css3dProcessing !== true &&
-                        this._nearEntryBoostFrames <= 0 &&
-                        this._fullResHandoffActive !== true &&
-                        cssReadinessDrift !== true &&
-                        !bandChangedWithoutModeSwitch) {
-                        return;
-                    }
+                    const nearCssNoWorkKey = renderPlan?.buildFullResKey(lodBand, visibilityVersion, lodSelectionKey, nodeObjectsById.size, visibleIds.size, this._nearCssVisibleIds.size, allowedCssIds.size, css3dEnabled, module, this);
+                    if (renderPlan?.commitStableFullRes(this, module, nearCssNoWorkKey, bandChangedWithoutModeSwitch, cssReadinessDrift)) return;
 
                     let hasNearCssWork =
                         this._hasCss3dQueueItems() ||
@@ -6590,7 +6559,7 @@
                         }
                         this._updateInstanceData(nodeObjectsById);
                         this._applyInstanceData();
-                        this._lineDetailsPatchPending = false;
+                        this._lineDetailsPatchPending = this._residentLineFallbackUsed === true;
                         if (fullBuildReason !== 'line-details') {
                             this._noteResidentFullBuild(fullBuildReason, lodBand);
                         }
@@ -6660,8 +6629,9 @@
             }
         }
 
-        _updateInstanceData(nodeObjectsById) {
-            const positions = [];
+        _updateInstanceData(nodeObjectsById) {
+            this._residentLineFallbackUsed = false;
+            const positions = [];
             const sizes = [];
             const selections = [];
             const seeds = [];
@@ -6872,8 +6842,10 @@
                         }
                     }
                 } else {
-                    // Build actual line length data from text
-                    const lineData = this._getLineDataForNode(model, entry.lodSeed, w, h, entry);
+                    const lineData = window.MindMapRenderPlan?.resolveResidentLineData?.(
+                        this, entry, w, h, this._residentBuilt === true,
+                        MAX_LINE_SAMPLES, LINE_HEIGHT_PX, LINE_PADDING_PX
+                    ) || this._getLineDataForNode(model, entry.lodSeed, w, h, entry);
                     lineCounts.push(lineData.lineCount);
                     lineHeights.push(lineData.lineHeightPx || LINE_HEIGHT_PX);
                     linePaddings.push(lineData.paddingX || LINE_PADDING_PX, lineData.paddingY || LINE_PADDING_PX);
@@ -7589,6 +7561,7 @@
             }
 
             const nodeIds = Array.isArray(this.instanceData?.nodeIds) ? this.instanceData.nodeIds : [];
+            if (window.MindMapRenderPlan?.areResidentLinesPrepared?.(this, nodeObjectsById, nodeIds) === false) return false;
             const lineCounts = this.instanceData?.lineCounts || [];
             const lineLengths = this.instanceData?.lineLengths || [];
             const lineHeights = this.instanceData?.lineHeights || [];
@@ -7614,7 +7587,8 @@
                 const model = entry.model;
                 const w = model.width || 400;
                 const h = model.height || 200;
-                const lineData = this._getLineDataForNode(model, entry.lodSeed, w, h, entry);
+                const lineData = window.MindMapRenderPlan?.getPreparedLineData?.(this, entry, w, h) ||
+                    this._getLineDataForNode(model, entry.lodSeed, w, h, entry);
                 const base = i * MAX_LINE_SAMPLES;
 
                 lineCounts[i] = lineData.lineCount || 0;
@@ -8410,18 +8384,16 @@
             const consoleCount = consolePositions.length / 3;
             const imageCount = imagePositions.length / 3;
 
-            // Resize buffers if needed (simple resize strategy: if full, create bigger)
-            // For now assuming 10000 is enough, or it will just slice (visual glitch but no crash)
-            const max = positionAttr.count;
+            const max = positionAttr.count;
             if (count > max) {
                 console.warn('[LODRenderer] Buffer overflow, need to resize (omitted for safety)');
             }
 
             const safeCount = Math.min(count, max);
+            window.MindMapRenderPlan?.ensureLineTextureCapacity?.(this, safeCount, MAX_LINE_SAMPLES);
             let lineRowsRewritten = false;
             const suspendLineDetailsForPan = this._isPanLineDetailSuspended();
 
-            // Update attribute data
             for (let i = 0; i < safeCount; i++) {
                 positionAttr.setXYZ(i, positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2]);
                 sizeAttr.setXY(i, sizes[i * 2], sizes[i * 2 + 1]);