@mindexec/cli 0.2.0

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

@@ -0,0 +1,646 @@
+// mind-map-text-lod-system.js
+// [NEW] 텍스트 LOD 시스템 - 카메라 Z 기반 동적 텍스처 품질 관리
+(function () {
+    'use strict';
+
+    // LOD 설정 - 카메라 Z 기반
+    const CAMERA_Z_THRESHOLD = 4000; // z < 4000이면 고해상도, 이상이면 저해상도
+    const ENABLE_WEBGL_GLOW = false;
+
+    const QUALITY_SCALES = {
+        HIGH: 1.0,
+        LOW: 1.0
+    };
+
+    // ★ LOD 텍스처 캐시 (노드별로 LOW/HIGH 분리 저장)
+    // 저해상도: 항상 유지 (재생성 없음)
+    // 고해상도: 필요시 생성, 화면 밖으로 나가면 dispose
+    const lodTextureCache = new Map(); // nodeId -> { low: texture, high: texture|null }
+
+    // 업데이트 큐 (프레임당 여러 개 처리 가능)
+    const updateQueue = [];
+    let isProcessing = false;
+    let module = null;
+    let lastCameraZ = null;
+    let lastDesiredLevel = null;
+    function isDocumentHidden() {
+        return typeof document !== 'undefined' && document.visibilityState === 'hidden';
+    }
+
+    function scheduleNonVisualFrame(callback, hiddenDelay = 16) {
+        if (typeof requestAnimationFrame === 'function' && !isDocumentHidden()) {
+            return requestAnimationFrame(callback);
+        }
+
+        return setTimeout(() => callback(typeof performance !== 'undefined' ? performance.now() : Date.now()), hiddenDelay);
+    }
+
+    // ▼▼▼ [Perf] Yield heavy work to idle time ▼▼▼
+    function yieldToIdle() {
+        return new Promise(resolve => {
+            if (typeof requestIdleCallback === 'function') {
+                requestIdleCallback(() => resolve());
+            } else {
+                setTimeout(resolve, 0);
+            }
+        });
+    }
+
+    function deferDispose(tex) {
+        if (!tex || typeof tex.dispose !== 'function') return;
+        if (typeof requestIdleCallback === 'function') {
+            requestIdleCallback(() => { try { tex.dispose(); } catch { } });
+        } else {
+            setTimeout(() => { try { tex.dispose(); } catch { } }, 0);
+        }
+    }
+
+    function removeGlowMesh(group) {
+        if (!group?.getObjectByName) return null;
+        const glowMesh = group.getObjectByName('glow');
+        if (!glowMesh) return null;
+
+        group.remove(glowMesh);
+        deferDispose(glowMesh.geometry);
+        deferDispose(glowMesh.material);
+        return null;
+    }
+    // ▲▲▲ [Perf] ▲▲▲
+
+    /**
+     * LOD 시스템 초기화
+     */
+    function init(moduleInstance) {
+        module = moduleInstance;
+        console.log('[TextLOD] System initialized (Camera Z threshold: ' + CAMERA_Z_THRESHOLD + ')');
+    }
+
+    /**
+     * 노드가 화면에 보이는지 확인 (frustum culling 기반)
+     */
+    function isNodeVisible(nodeEntry, frustum) {
+        // 기본적으로 glObject가 visible이어야 함 (수동 제어)
+        if (!nodeEntry?.glObject?.visible) return false;
+
+        // ★ [Fix] 실제 카메라 절두체 검사 (화면 밖 노드는 LOW로 처리하여 성능 확보)
+        if (frustum && nodeEntry.glObject) {
+            // body mesh 기준으로 체크 (가장 큰 요소)
+            const body = nodeEntry.glObject.getObjectByName('body');
+            if (body) {
+                return frustum.intersectsObject(body);
+            }
+            return frustum.intersectsObject(nodeEntry.glObject);
+        }
+        return true;
+    }
+
+    /**
+     * 모든 노드의 LOD 상태 검사 (카메라 Z 기반 + 100ms마다 visible 노드 재검사)
+     */
+    let lastCheckTime = 0;
+    const CHECK_INTERVAL_MS = 100; // 100ms마다 visible 노드 재검사 (캐시 사용하므로 부하 적음)
+
+    function update() {
+        if (!module || !module.camera) return;
+
+        // CSS3D/TextureArray 전환은 LODRenderer가 담당함
+        // TextLOD의 품질/텍스처 전환 로직은 비활성화
+        return;
+
+        // (unreachable)
+
+        const now = performance.now();
+        const cameraZ = module.camera.position.z;
+        const desiredLevel = cameraZ < CAMERA_Z_THRESHOLD ? 'HIGH' : 'LOW';
+
+        // ★ 레벨 변경 OR 1초 경과 OR 강제 업데이트 요청 시 visible 노드 재검사
+        const levelChanged = desiredLevel !== lastDesiredLevel;
+        const intervalPassed = (now - lastCheckTime) > CHECK_INTERVAL_MS;
+        const forceUpdate = window.MindMapTextLOD._forceUpdate === true;
+
+        // ▼▼▼ [Perf] 줌 중에는 스킵 (단, 강제 업데이트 요청이 있으면 처리) ▼▼▼
+        if (!levelChanged && !intervalPassed && !forceUpdate) {
+            return; // 변경 없고 1초 안 지났으면 스킵
+        }
+
+        // 강제 업데이트 플래그 리셋
+        if (forceUpdate) {
+            window.MindMapTextLOD._forceUpdate = false;
+            console.log('[TextLOD] Force update triggered after zoom end');
+        }
+        // ▲▲▲ [Perf] ▲▲▲
+
+        if (levelChanged) {
+            console.log(`[TextLOD] Camera Z=${cameraZ.toFixed(0)}, switching all visible nodes to ${desiredLevel}`);
+        }
+
+        lastDesiredLevel = desiredLevel;
+        lastCheckTime = now;
+
+        if (ENABLE_WEBGL_GLOW) {
+            // ★ 모든 노드의 glow 가시성을 카메라 거리에 따라 일괄 업데이트
+            const showGlow = desiredLevel === 'HIGH';
+            module.nodeObjectsById.forEach((nodeEntry) => {
+                const glowMesh = nodeEntry.glObject?.getObjectByName('glow');
+                if (glowMesh && glowMesh.visible !== showGlow) {
+                    glowMesh.visible = showGlow;
+                }
+            });
+        } else {
+            module.nodeObjectsById.forEach((nodeEntry) => removeGlowMesh(nodeEntry.glObject));
+        }
+
+        // ★ [Perf] Frustum 생성 (한 번만 생성해서 재사용)
+        const frustum = new THREE.Frustum();
+        const matrix = new THREE.Matrix4().multiplyMatrices(module.camera.projectionMatrix, module.camera.matrixWorldInverse);
+        frustum.setFromProjectionMatrix(matrix);
+
+        // 화면에 보이는 노드 → 현재 desiredLevel로
+        // 화면 밖 노드 → 저해상도로 다운그레이드 (메모리 절약)
+        module.nodeObjectsById.forEach((nodeEntry, nodeId) => {
+            const model = nodeEntry.model;
+            // ▼▼▼ [Fix] markdown, image 타입도 포함 ▼▼▼
+            if (!model || (model.contentType !== 'text' && model.contentType !== 'note' && model.contentType !== 'memo' && model.contentType !== 'markdown' && model.contentType !== 'image')) {
+                return;
+            }
+            // ▲▲▲ [Fix] ▲▲▲
+
+            const currentLevel = nodeEntry.glObject?.userData?.lodLevel;
+            // ★ [Fix] Frustum 전달
+            const visible = isNodeVisible(nodeEntry, frustum);
+
+            let targetLevel;
+            if (visible) {
+                // 보이는 노드 → desiredLevel
+                targetLevel = desiredLevel;
+            } else {
+                // 안 보이는 노드
+                // ★ [Fix] HIGH 모드에서 CSS3D 지원 노드는 화면 밖이라도 LOW(WebGL)로 내리지 않고 HIGH(CSS3D) 유지
+                // 이렇게 해야 화면 안으로 들어올 때 WebGL -> CSS3D 전환 깜빡임이 없고, 사용자가 원하는 "무조건 CSS3D"가 됨.
+                // (성능 주의: DOM 요소가 많아질 수 있음)
+                const supportsCss3d = model.contentType === 'text' ||
+                    model.contentType === 'note' ||
+                    model.contentType === 'memo' ||
+                    model.contentType === 'markdown';
+                if (desiredLevel === 'HIGH' && supportsCss3d) {
+                    targetLevel = 'HIGH';
+                } else {
+                    targetLevel = 'LOW';
+                }
+            }
+
+            // ★ [Fix] 불필요한 반복 업데이트 차단
+            // 1. 레벨이 이미 같고
+            // 2. 현재 렌더링 타입(CSS/GL)도 목표와 일치하면 업데이트 불필요
+            if (currentLevel === targetLevel) {
+                const isCorrectType = (targetLevel === 'HIGH' && nodeEntry.currentType === 'CSS') ||
+                    (targetLevel === 'LOW' && nodeEntry.currentType === 'GL');
+
+                if (isCorrectType) return; // 이미 완벽한 상태
+            }
+
+            // 'NEEDS_UPDATE'는 항상 업데이트 트리거
+            // 레벨이 다르거나, 'NEEDS_UPDATE'이거나, null이면 큐에 추가
+            const needsUpdate = currentLevel === 'NEEDS_UPDATE' ||
+                currentLevel === null ||
+                currentLevel === undefined ||
+                currentLevel !== targetLevel;
+
+            if (needsUpdate) {
+                if (!updateQueue.find(item => item.nodeId === nodeId)) {
+                    updateQueue.push({
+                        nodeId: nodeId,
+                        nodeEntry: nodeEntry,
+                        level: targetLevel
+                    });
+                }
+            }
+
+            // ★ [Safety] CSS3D 모드(HIGH)라면 WebGL Body/Tail 숨김 강제 (외부 간섭 방지)
+            // 다른 로직(선택, 인터랙션 등)에서 실수로 body.visible = true로 되돌리는 경우를 방지
+            const supportsCss3d = model.contentType === 'text' ||
+                model.contentType === 'note' ||
+                model.contentType === 'memo' ||
+                model.contentType === 'markdown';
+            if (supportsCss3d && targetLevel === 'HIGH' && nodeEntry.currentType === 'CSS') {
+                const body = nodeEntry.glObject?.getObjectByName('body');
+                if (body && body.visible) body.visible = false;
+
+                const tail = nodeEntry.glObject?.getObjectByName('tail');
+                if (tail && tail.visible) tail.visible = false;
+            }
+        });
+
+        if (updateQueue.length > 0) {
+            console.log(`[TextLOD] Queued ${updateQueue.length} nodes for LOD update`);
+        }
+    }
+
+    /**
+     * 큐에서 처리 (프레임당 3개씩 - 속도와 프레임 드랍 균형)
+     */
+    async function processQueue() {
+        if (isProcessing || updateQueue.length === 0) return;
+
+        isProcessing = true;
+
+        // 타임슬라이스: 프레임 예산 내에서만 처리해 UI 스터터 최소화
+        const frameBudgetMs = 8; // ~0.5 frame @60fps
+        const start = performance.now();
+
+        while (updateQueue.length > 0) {
+            const item = updateQueue.shift();
+            if (!item) break;
+
+            try {
+                await applyTextureQuality(item.nodeEntry, item.level);
+            } catch (e) {
+                console.error('[TextLOD] Error processing queue:', e);
+            }
+
+            if ((performance.now() - start) >= frameBudgetMs) {
+                break; // 다음 프레임으로 이월
+            }
+        }
+
+        isProcessing = false;
+
+        // 남은 작업은 다음 프레임에 처리
+        if (updateQueue.length > 0) {
+            scheduleNonVisualFrame(() => processQueue());
+        }
+    }
+
+    async function applyTextureQuality(nodeEntry, level) {
+        if (!nodeEntry?.glObject || !nodeEntry?.model) return;
+
+        const nodeModel = nodeEntry.model;
+        const nodeId = nodeModel.id;
+
+        // 이미 같은 레벨이면 스킵
+        if (nodeEntry.glObject.userData.lodLevel === level) return;
+
+        // ▼▼▼ [Perf] 줌 중에는 업데이트 스킵 (줌 멈출 때만 업데이트) ▼▼▼
+        if (module.isZooming && level === 'HIGH') {
+            console.log(`[TextLOD] Skipping HIGH update for ${nodeId} (zooming in progress)`);
+            return;
+        }
+        // ▲▲▲ [Perf] ▲▲▲
+
+        // ★ 현재 선택 상태 확인
+        const isSelected = module.multiSelectedNodeIds?.has(nodeId) || module.selectedNodeIdJs === nodeId;
+
+        try {
+            if (level === 'LOW') {
+                // ★ LOW 모드: WebGL 인스턴싱 사용 (현행 유지)
+                // ▼▼▼ [Fix] currentType을 'GL'로 설정 ▼▼▼
+                nodeEntry.currentType = 'GL';
+                // ▲▲▲ [Fix] ▲▲▲
+
+                // CSS3D 숨기고 WebGL 보이기
+                if (nodeEntry.cssObject) {
+                    nodeEntry.cssObject.visible = false;
+                }
+
+                // WebGL body/tail 보이기
+                const bodyMesh = nodeEntry.glObject.getObjectByName('body');
+                const tailMesh = nodeEntry.glObject.getObjectByName('tail');
+                if (bodyMesh) bodyMesh.visible = true;
+                if (tailMesh) tailMesh.visible = true;
+
+                // LOD 캐시 가져오기 또는 생성
+                let cache = lodTextureCache.get(nodeId);
+                if (!cache) {
+                    cache = { low: null, lowSelected: null, high: null, highSelected: null };
+                    lodTextureCache.set(nodeId, cache);
+                }
+
+                // ★ [Image Node Exception] Image nodes do not generate low-res textures (yet).
+                // They just hide the CSS3D object. The hitBody remains (invisible).
+                if (nodeEntry.model.contentType === 'image') {
+                    // Do nothing for texture generation.
+                    // Just ensure bodyMesh material is basic/invisible if needed.
+                    // (Our implementation of image node uses invisible request hitBody, so we are good)
+                    return;
+                }
+
+                let targetTextures = null;
+                const cacheKey = isSelected ? 'lowSelected' : 'low';
+
+                if (cache[cacheKey]) {
+                    targetTextures = { body: cache[cacheKey] };
+                } else {
+                    // ★ [Optimization] First check if MindMapNodes.textureCache already has this texture
+                    const existingTextureEntry = window.MindMapNodes?.textureCache?.get(nodeId);
+                    const existingTexture = isSelected
+                        ? existingTextureEntry?.selected?.body
+                        : existingTextureEntry?.default?.body;
+
+                    // Reuse if it exists and was created with LOW quality scale
+                    if (existingTexture && existingTexture._qualityScale === QUALITY_SCALES.LOW) {
+                        cache[cacheKey] = existingTexture;
+                        targetTextures = { body: existingTexture };
+                        console.log(`[TextLOD] Reusing existing low-res texture for ${nodeId}`);
+                    } else {
+                        await yieldToIdle();
+                        // ★ 저해상도 텍스처 새로 생성 (skipBorder=true 옵션 전달)
+                        const { textures } = await window.MindMapTextureFactory.generateAndCacheTextures(
+                            module,
+                            nodeModel,
+                            window.MindMapNodes.imageCache,
+                            { skipMeasure: true, skipSelected: !isSelected, skipBorder: true },
+                            QUALITY_SCALES.LOW
+                        );
+                        const textureData = isSelected ? textures?.selected : textures?.default;
+                        if (textureData?.body) {
+                            cache[cacheKey] = textureData.body;
+                            targetTextures = { body: cache[cacheKey] };
+                        }
+                    }
+                }
+
+                // 메시에 적용
+                if (targetTextures?.body && bodyMesh) {
+                    bodyMesh.material.map = targetTextures.body;
+                    bodyMesh.material.needsUpdate = true;
+                }
+
+            } else if (level === 'HIGH') {
+                // ▼▼▼ [Changed] HIGH 모드: CSS3D 사용 (텍스처 메모리 절약) ▼▼▼
+                // text, note, markdown 타입만 CSS3D 전환
+                const supportsCss3d = nodeModel.contentType === 'text' ||
+                    nodeModel.contentType === 'note' ||
+                    nodeModel.contentType === 'memo' ||
+                    nodeModel.contentType === 'markdown';
+
+                // ▼▼▼ [Fix] cssObject가 없으면 동적 생성 시도 ▼▼▼
+                if (supportsCss3d && !nodeEntry.cssObject) {
+                    console.log(`[TextLOD] Creating cssObject for ${nodeId} (contentType=${nodeModel.contentType})`);
+                    if (window.MindMapCss3DManager) {
+                        nodeEntry.cssObject = window.MindMapCss3DManager.createCss3dObject(module, nodeModel);
+                        if (nodeEntry.cssObject) {
+                            const glPos = nodeEntry.glObject.position;
+                            nodeEntry.cssObject.position.set(glPos.x, glPos.y, glPos.z);
+                            (module.cssScene || module.scene).add(nodeEntry.cssObject);
+                            console.log(`[TextLOD] ✅ cssObject created and added to scene for ${nodeId}`);
+                        } else {
+                            console.warn(`[TextLOD] ⚠️ Failed to create cssObject for ${nodeId}`);
+                        }
+                    }
+                }
+                // ▲▲▲ [Fix] ▲▲▲
+
+                if (supportsCss3d && nodeEntry.cssObject) {
+                    console.log(`[TextLOD] Switching ${nodeId} to CSS3D mode (HIGH)`);
+
+                    // ▼▼▼ [Fix] currentType을 'CSS'로 설정하여 cullAndLOD()에서 올바르게 처리되도록 ▼▼▼
+                    nodeEntry.currentType = 'CSS';
+                    // ▲▲▲ [Fix] ▲▲▲
+
+                    // CSS3D 위치 동기화 (WebGL과 동일하게)
+                    const glPos = nodeEntry.glObject.position;
+                    nodeEntry.cssObject.position.copy(glPos);
+
+                    // CSS3D 크기 동기화
+                    const wrapper = nodeEntry.cssObject.element;
+                    if (wrapper) {
+                        wrapper.style.width = (nodeModel.width || 400) + 'px';
+                        wrapper.style.height = (nodeModel.height || 200) + 'px';
+
+                        const innerContent = wrapper.firstElementChild;
+                        if (innerContent) {
+                            innerContent.style.width = (nodeModel.width || 400) + 'px';
+                            innerContent.style.height = (nodeModel.height || 200) + 'px';
+                        }
+                    }
+
+                    // CSS3D 보이기
+                    nodeEntry.cssObject.visible = true;
+
+                    // WebGL body/tail 숨기기 (glow와 outline은 유지)
+                    const bodyMesh = nodeEntry.glObject.getObjectByName('body');
+                    const tailMesh = nodeEntry.glObject.getObjectByName('tail');
+                    if (bodyMesh) bodyMesh.visible = false;
+                    if (tailMesh) tailMesh.visible = false;
+
+                    // ▼▼▼ [Memory Optimization] Dispose WebGL textures when in CSS3D mode ▼▼▼
+                    if (bodyMesh && bodyMesh.material && bodyMesh.material.map) {
+                        // Don't dispose if it's the shared placeholder or if another node is using it (unlikely unless shared)
+                        if (!bodyMesh.material.map._isShared) {
+                            try { bodyMesh.material.map.dispose(); } catch (e) { }
+                        }
+                        bodyMesh.material.map = null;
+                        bodyMesh.material.needsUpdate = true;
+                    }
+                    if (tailMesh && tailMesh.material && tailMesh.material.map) {
+                        try { tailMesh.material.map.dispose(); } catch (e) { }
+                        tailMesh.material.map = null;
+                        tailMesh.material.needsUpdate = true;
+                    }
+
+                    // Clear caches to force regeneration when returning to LOW mode
+                    lodTextureCache.delete(nodeId);
+                    if (window.MindMapNodes && window.MindMapNodes.textureCache) {
+                        // 선택된 상태라면 선택 텍스처도 날아갈 수 있으므로 주의. 
+                        // 하지만 CSS3D에서는 선택 표시도 CSS(Glow)로 하거나 별도 처리를 하므로
+                        // WebGL 텍스처는 날려도 됩니다.
+                        window.MindMapNodes.textureCache.delete(nodeId);
+                    }
+                    // ▲▲▲ [Memory Optimization] ▲▲▲
+
+                    // glObject 자체는 visible 유지 (glow 렌더링용)
+                    nodeEntry.glObject.visible = true;
+
+                } else if (!supportsCss3d) {
+                    // CSS3D 미지원 노드
+                    console.log(`[TextLOD] ${nodeId} does not support CSS3D, using WebGL texture`);
+
+                    // Same exception for image checks if logic flows here (redundant but safe)
+                    if (nodeModel.contentType === 'image') return;
+
+                    // LOD 캐시 가져오기 또는 생성
+                    let cache = lodTextureCache.get(nodeId);
+                    if (!cache) {
+                        cache = { low: null, lowSelected: null, high: null, highSelected: null };
+                        lodTextureCache.set(nodeId, cache);
+                    }
+
+                    let targetTextures = null;
+                    const cacheKey = isSelected ? 'highSelected' : 'high';
+
+                    if (cache[cacheKey]) {
+                        targetTextures = { body: cache[cacheKey] };
+                    } else {
+                        const existingTextureEntry = window.MindMapNodes?.textureCache?.get(nodeId);
+                        const existingTexture = isSelected
+                            ? existingTextureEntry?.selected?.body
+                            : existingTextureEntry?.default?.body;
+
+                        if (existingTexture && existingTexture._qualityScale === QUALITY_SCALES.HIGH) {
+                            cache[cacheKey] = existingTexture;
+                            targetTextures = { body: existingTexture };
+                        } else {
+                            await yieldToIdle();
+                            const { textures } = await window.MindMapTextureFactory.generateAndCacheTextures(
+                                module,
+                                nodeModel,
+                                window.MindMapNodes.imageCache,
+                                { skipMeasure: true, skipSelected: !isSelected },
+                                QUALITY_SCALES.HIGH
+                            );
+                            const textureData = isSelected ? textures?.selected : textures?.default;
+                            if (textureData?.body) {
+                                cache[cacheKey] = textureData.body;
+                                targetTextures = { body: cache[cacheKey] };
+                            }
+                        }
+                    }
+
+                    // 메시에 적용
+                    if (targetTextures?.body) {
+                        const bodyMesh = nodeEntry.glObject.getObjectByName('body');
+                        if (bodyMesh) {
+                            bodyMesh.material.map = targetTextures.body;
+                            bodyMesh.material.needsUpdate = true;
+                        }
+                    }
+                }
+                // ▲▲▲ [Changed] ▲▲▲
+            }
+
+            if (ENABLE_WEBGL_GLOW) {
+                // ★ glow 가시성은 level에 따라 설정
+                const glowMesh = nodeEntry.glObject.getObjectByName('glow');
+                if (glowMesh) {
+                    glowMesh.visible = (level === 'HIGH');
+                }
+            } else {
+                removeGlowMesh(nodeEntry.glObject);
+            }
+
+            // LOD 레벨 저장
+            nodeEntry.glObject.userData.lodLevel = level;
+
+        } catch (e) {
+            console.error(`[TextLOD] Failed to apply texture for ${nodeId}:`, e);
+        }
+    }
+
+    /**
+     * 초기 로딩용 품질 스케일 반환
+     */
+    function getInitialQualityScale() {
+        return 1.0;
+    }
+
+    /**
+     * 강제로 모든 노드를 특정 품질로 변경
+     */
+    function setAllNodesQuality(level) {
+        if (!module) return;
+
+        module.nodeObjectsById.forEach((nodeEntry, nodeId) => {
+            if (nodeEntry.model?.contentType === 'text' || nodeEntry.model?.contentType === 'note' || nodeEntry.model?.contentType === 'memo') {
+                updateQueue.push({
+                    nodeId: nodeId,
+                    nodeEntry: nodeEntry,
+                    level: level
+                });
+            }
+        });
+
+        console.log(`[TextLOD] Queued ${updateQueue.length} nodes for ${level} quality`);
+    }
+
+    /**
+     * 특정 노드의 LOD 캐시 무효화 (콘텐츠 변경 시 호출)
+     */
+    function invalidateNodeCache(nodeId, regenerate = false) {
+        const cache = lodTextureCache.get(nodeId);
+        if (cache) {
+            // Dispose cached textures
+            deferDispose(cache.low);
+            deferDispose(cache.lowSelected);
+            deferDispose(cache.high);
+            deferDispose(cache.highSelected);
+            lodTextureCache.delete(nodeId);
+            console.log(`[TextLOD] Cache invalidated for node ${nodeId}`);
+        }
+
+        // ★ [New] Optionally queue for immediate regeneration
+        if (regenerate && module) {
+            const nodeEntry = module.nodeObjectsById.get(nodeId);
+            if (nodeEntry && (nodeEntry.model?.contentType === 'text' || nodeEntry.model?.contentType === 'note' || nodeEntry.model?.contentType === 'memo')) {
+                const cameraZ = module.camera?.position?.z || 0;
+                const desiredLevel = cameraZ < CAMERA_Z_THRESHOLD ? 'HIGH' : 'LOW';
+
+                // Reset LOD level to force regeneration
+                if (nodeEntry.glObject) {
+                    nodeEntry.glObject.userData.lodLevel = null;
+                }
+
+                // Add to queue if not already there
+                if (!updateQueue.find(item => item.nodeId === nodeId)) {
+                    updateQueue.push({
+                        nodeId: nodeId,
+                        nodeEntry: nodeEntry,
+                        level: desiredLevel
+                    });
+                }
+            }
+        }
+    }
+
+    /**
+     * 여러 노드의 LOD 캐시 무효화 및 재생성
+     */
+    function invalidateMultipleNodeCaches(nodeIds) {
+        if (!module || !nodeIds || nodeIds.length === 0) return;
+
+        const cameraZ = module.camera?.position?.z || 0;
+        const desiredLevel = cameraZ < CAMERA_Z_THRESHOLD ? 'HIGH' : 'LOW';
+
+        let count = 0;
+        for (const nodeId of nodeIds) {
+            const cache = lodTextureCache.get(nodeId);
+            if (cache) {
+                deferDispose(cache.low);
+                deferDispose(cache.lowSelected);
+                deferDispose(cache.high);
+                deferDispose(cache.highSelected);
+                lodTextureCache.delete(nodeId);
+            }
+
+            const nodeEntry = module.nodeObjectsById.get(nodeId);
+            if (nodeEntry && (nodeEntry.model?.contentType === 'text' || nodeEntry.model?.contentType === 'note' || nodeEntry.model?.contentType === 'memo')) {
+                if (nodeEntry.glObject) {
+                    nodeEntry.glObject.userData.lodLevel = null;
+                }
+
+                if (!updateQueue.find(item => item.nodeId === nodeId)) {
+                    updateQueue.push({
+                        nodeId: nodeId,
+                        nodeEntry: nodeEntry,
+                        level: desiredLevel
+                    });
+                    count++;
+                }
+            }
+        }
+
+        console.log(`[TextLOD] Invalidated and queued ${count} nodes for ${desiredLevel} regeneration`);
+    }
+
+    // 전역 노출
+    window.MindMapTextLOD = {
+        init,
+        update,
+        getInitialQualityScale,
+        setAllNodesQuality,
+        invalidateNodeCache,
+        invalidateMultipleNodeCaches,  // ★ [New] Batch invalidation
+        QUALITY_SCALES,
+        CAMERA_Z_THRESHOLD
+    };
+
+})();