// WL-814a 프로브 — 도트 룩 스위치 검증 + 실측 표 + 룩 캡처 4단 (게임 코드 아님 · 에디트 모드 전용)
//   run:  unity command run_script --file AgentScripts/WL814a_Probe.cs --entry WL814a_Probe.RunAll
//   cap:  unity command run_script --file AgentScripts/WL814a_Probe.cs --entry WL814a_Probe.Capture
// 🔴 파이프라인 에셋에 SetDirty 를 부르지 않는다 · 임시 씬은 저장하지 않는다 · 에셋 파일 수정 0.

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using WL.Look;

public static class WL814a_Probe
{
    const string kOutDir = @"E:\NerdNavis\nn_himminji\Screenshots_WL\WL814a";
    const string kTxt = "AgentScripts/WL814a_PROBE.txt";
    const string kTxtCap = "AgentScripts/WL814a_CAPTURE.txt";

    static StringBuilder s_sb;
    static int s_pass, s_fail;
    static Camera s_uiCam;
    static RectTransform s_uiCanvas;

    static void L(string s) { s_sb.AppendLine(s); Debug.Log("[WL814a] " + s); }
    static void Chk(string name, bool ok, string detail)
    {
        if (ok) s_pass++; else s_fail++;
        L((ok ? "  PASS " : "  FAIL ") + name + " — " + detail);
    }

    // ═════════════════════════════════════════════════════════════════════════
    //  RunAll — 실측 표 + 적용/복원 + C8 + GC
    // ═════════════════════════════════════════════════════════════════════════
    public static void RunAll()
    {
        s_sb = new StringBuilder(); s_pass = 0; s_fail = 0;
        L("WL-814a 프로브 · " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " · Unity " + Application.unityVersion);
        try
        {
            A_Table();
            B_ApplyRestore();
            C_C8();
            D_Gc();
        }
        catch (Exception ex) { s_fail++; L("EXCEPTION " + ex); }
        finally
        {
            // 🔴 무슨 일이 있어도 원래 값으로
            PixelLook.RestoreNow("probe-final");
            WLPixelLookSettings.RuntimeDisabled = false;
        }

        L("");
        L("RESULT " + (s_fail == 0 ? "PASS" : "FAIL") + " · " + s_pass + "/" + (s_pass + s_fail) + " · FAIL " + s_fail);
        Write();
    }

    static void Write() { Write(kTxt); }

    static void Write(string path)
    {
        try
        {
            File.WriteAllText(path, s_sb.ToString(), new UTF8Encoding(false));
            Directory.CreateDirectory(kOutDir);
            File.WriteAllText(Path.Combine(kOutDir, "probe_" + DateTime.Now.ToString("HHmmss") + ".txt"),
                              s_sb.ToString(), new UTF8Encoding(false));
        }
        catch (Exception ex) { Debug.Log("[WL814a] 파일 쓰기 실패 " + ex.Message); }
    }

    // ───────────────────────────────────────────── ⓐ 실측 표
    static void A_Table()
    {
        L("");
        L("ⓐ 실측 표");

        // ① Quality → URP 에셋 (ProjectSettings/QualitySettings.asset 원문 파싱 · 읽기만)
        string qsPath = "ProjectSettings/QualitySettings.asset";
        string[] qs = File.Exists(qsPath) ? File.ReadAllLines(qsPath) : new string[0];
        int perPlatCount = 0; bool perPlatEmpty = false;
        var qNames = new List<string>(); var qGuids = new List<string>();
        foreach (var raw in qs)
        {
            string t = raw.Trim();
            if (t.StartsWith("m_PerPlatformDefaultQuality:"))
                perPlatEmpty = t.EndsWith("{}");
            else if (t.StartsWith("name: ") && raw.StartsWith("    name: ")) qNames.Add(t.Substring(6));
            else if (t.StartsWith("customRenderPipeline:"))
            {
                int g = t.IndexOf("guid: ");
                qGuids.Add(g >= 0 ? t.Substring(g + 6).TrimEnd(',', ' ') : "-");
            }
            else if (perPlatEmpty == false && t.StartsWith("- first:")) perPlatCount++;
        }
        L("  ① m_PerPlatformDefaultQuality = " + (perPlatEmpty ? "{} (비어 있음 → 플랫폼별 지정 0 = 전 플랫폼이 m_CurrentQuality 레벨을 쓴다)" : perPlatCount + "개"));

        string[] names = QualitySettings.names;
        int cur = QualitySettings.GetQualityLevel();
        for (int i = 0; i < names.Length; i++)
        {
            string g = i < qGuids.Count ? qGuids[i] : "-";
            string p = g != "-" ? AssetDatabase.GUIDToAssetPath(g) : "";
            L("     level " + i + " '" + names[i] + "'" + (i == cur ? "  ← m_CurrentQuality(현재)" : "") +
              " → " + (string.IsNullOrEmpty(p) ? "(없음 → Graphics 기본)" : System.IO.Path.GetFileNameWithoutExtension(p)));
        }
        var qrp = QualitySettings.renderPipeline as UniversalRenderPipelineAsset;
        L("     QualitySettings.renderPipeline(현재 레벨 오버라이드) = " + (qrp != null ? qrp.name : "(없음)"));
        var def = GraphicsSettings.defaultRenderPipeline as UniversalRenderPipelineAsset;
        var act = GraphicsSettings.currentRenderPipeline as UniversalRenderPipelineAsset;
        L("     GraphicsSettings.defaultRenderPipeline = " + (def != null ? def.name : "(없음)"));
        L("     🔴 GraphicsSettings.currentRenderPipeline(= 실제 활성) = " + (act != null ? act.name : "(없음)") +
          "  path=" + (act != null ? AssetDatabase.GetAssetPath(act) : "-"));
        Chk("A1 활성 URP 에셋 존재", act != null, act != null ? act.name : "null");

        // ② 각 URP 에셋 값
        foreach (var g in AssetDatabase.FindAssets("t:UniversalRenderPipelineAsset", new[] { "Assets/Settings" }))
        {
            string p = AssetDatabase.GUIDToAssetPath(g);
            var a = AssetDatabase.LoadAssetAtPath<UniversalRenderPipelineAsset>(p);
            if (a == null) continue;
            L("  ② " + a.name.PadRight(20) + " renderScale=" + a.renderScale +
              " · upscalingFilter=" + a.upscalingFilter +
              " · MSAA=" + a.msaaSampleCount +
              " · HDR=" + (a.supportsHDR ? 1 : 0) +
              " · mainLightShadow=" + (a.supportsMainLightShadows ? 1 : 0) +
              " · shadowDist=" + a.shadowDistance +
              (a == act ? "   ← 활성" : ""));
        }

        // ③ 인게임 UI 캔버스 렌더 모드
        var ui = AssetDatabase.LoadAssetAtPath<GameObject>("Assets/Res_Addr/MainUI/NewGameUI.prefab");
        if (ui != null)
        {
            var canvases = ui.GetComponentsInChildren<Canvas>(true);
            L("  ③ NewGameUI.prefab Canvas " + canvases.Length + "개");
            foreach (var c in canvases)
                L("     - " + HierPath(c.transform) + " renderMode=" + c.renderMode +
                  " worldCamera=" + (c.worldCamera != null ? c.worldCamera.name : "null") +
                  " planeDistance=" + c.planeDistance + " sortingOrder=" + c.sortingOrder);
            var scaler = ui.GetComponentInChildren<CanvasScaler>(true);
            if (scaler != null)
                L("     CanvasScaler ref=" + scaler.referenceResolution + " mode=" + scaler.uiScaleMode +
                  " match=" + scaler.screenMatchMode + "  → 1080×1920 scaleFactor=" +
                  Mathf.Min(1080f / scaler.referenceResolution.x, 1920f / scaler.referenceResolution.y).ToString("0.####"));
            var uiCam = ui.GetComponentInChildren<Camera>(true);
            if (uiCam != null)
            {
                var d = uiCam.GetUniversalAdditionalCameraData();
                L("     UI 카메라 '" + uiCam.name + "' renderType=" + (d != null ? d.renderType.ToString() : "?") +
                  " depth=" + uiCam.depth + " clear=" + uiCam.clearFlags + " ortho=" + uiCam.orthographic +
                  " cullingMask=" + uiCam.cullingMask);
                Chk("A3 UI 카메라 = URP Overlay(= 베이스 카메라 스택에 들어간다 → 렌더 스케일 영향 받음)",
                    d != null && d.renderType == CameraRenderType.Overlay, d != null ? d.renderType.ToString() : "?");
            }
            bool anyOverlayCanvas = false, anyWorld = false;
            foreach (var c in canvases)
            {
                if (c.renderMode == RenderMode.ScreenSpaceOverlay) anyOverlayCanvas = true;
                if (c.renderMode == RenderMode.WorldSpace) anyWorld = true;
            }
            Chk("A3b 인게임 루트 캔버스 = ScreenSpaceCamera(Overlay 아님)", !anyOverlayCanvas, "Overlay 캔버스 " + (anyOverlayCanvas ? "있음" : "0"));
            Chk("A4 월드 공간 캔버스 0", !anyWorld, anyWorld ? "있음" : "0");

            // 스킬 버튼(카드) 크기 — 캡처 표의 「스킬 버튼 영역」 근거
            foreach (var mb in ui.GetComponentsInChildren<BattleUI>(true))
            {
                if (mb.skillCards == null) continue;
                for (int i = 0; i < mb.skillCards.Length && i < 2; i++)
                {
                    var rt = mb.skillCards[i] != null ? mb.skillCards[i].GetComponent<RectTransform>() : null;
                    if (rt != null) L("     스킬카드[" + i + "] sizeDelta=" + rt.sizeDelta + " (유닛) → 1080×1920 화면 px = " +
                                      (rt.sizeDelta * 0.5625f));
                }
            }
        }
        else Chk("A3 NewGameUI.prefab 로드", false, "없음");

        // ④ 월드 UI(HP 바 · 데미지 숫자) 방식
        var hud = AssetDatabase.LoadAssetAtPath<GameObject>("Assets/Res_Addr/Ingame/HUDUI.prefab");
        var dmg = AssetDatabase.LoadAssetAtPath<GameObject>("Assets/Res_Addr/Ingame/HUDDMGUI.prefab");
        L("  ④ HUDUI.prefab Canvas=" + (hud != null ? hud.GetComponentsInChildren<Canvas>(true).Length : -1) +
          " · HUDDMGUI.prefab Canvas=" + (dmg != null ? dmg.GetComponentsInChildren<Canvas>(true).Length : -1) +
          "  (0 = 자체 캔버스 없음 = 부모 캔버스[NewGameUI]를 그대로 쓴다 · HUDBase 가 WorldToViewportPoint 로 anchoredPosition 만 옮긴다)");
        Chk("A4b HP바/데미지숫자 = 스크린 공간(자체 캔버스 0)",
            hud != null && dmg != null && hud.GetComponentsInChildren<Canvas>(true).Length == 0 && dmg.GetComponentsInChildren<Canvas>(true).Length == 0,
            "HUDUI/HUDDMGUI 자체 Canvas 0");

        // ⑤ 카메라 스택
        var camPrefab = AssetDatabase.LoadAssetAtPath<GameObject>("Assets/ResWork/Prefabs/Ingame/Main Camera.prefab");
        if (camPrefab != null)
        {
            var c = camPrefab.GetComponentInChildren<Camera>(true);
            var d = c.GetUniversalAdditionalCameraData();
            L("  ⑤ Main Camera.prefab renderType=" + d.renderType + " · cameraStack(프리팹)=" + d.cameraStack.Count +
              " · postProcessing=" + d.renderPostProcessing + " · antialiasing=" + d.antialiasing +
              " · fov=" + c.fieldOfView + " · ortho=" + c.orthographic + " · rendererIndex(프리팹 직렬화 −1 = 기본)");
            L("     🔴 런타임 스택 = NewGameUI.Start() 가 `Camera.main…cameraStack.Add(UICamera)` (Assets/Script/UI/NewGameUI.cs:38) → Base 1 + Overlay 1");
            Chk("A5 Main Camera = Base", d.renderType == CameraRenderType.Base, d.renderType.ToString());
        }
    }

    static string HierPath(Transform t)
    {
        string s = t.name;
        while (t.parent != null) { t = t.parent; s = t.name + "/" + s; }
        return s;
    }

    // ───────────────────────────────────────────── ⓑ 적용 / 복원
    static void B_ApplyRestore()
    {
        L("");
        L("ⓑ 적용 / 복원 (에디트 모드 · 가짜 경계 = ApplyNow/RestoreNow 직접 호출)");
        WLPixelLookSettings.ClearCache();
        var cfg = WLPixelLookSettings.Instance;
        Chk("B0 SO 로드", cfg != null, cfg != null ? "targetHeightPx=" + cfg.targetHeightPx + " filter=" + cfg.filter +
            " applyOnlyInBattleMap=" + cfg.applyOnlyInBattleMap + " restoreOnExit=" + cfg.restoreOnExit : "null");
        if (cfg == null) return;

        PixelLook.ResetForProbe();
        var asset = PixelLook.CurrentAsset;
        if (asset == null) { Chk("B1 활성 에셋", false, "null"); return; }

        float before = asset.renderScale;
        var beforeF = asset.upscalingFilter;
        L("  전  : " + asset.name + " renderScale=" + before + " filter=" + beforeF);

        bool applied = PixelLook.ApplyNow(cfg.targetHeightPx, 1920, "probe");
        L("  후  : renderScale=" + asset.renderScale + " filter=" + asset.upscalingFilter);
        Chk("B1 적용됨", applied && Mathf.Approximately(asset.renderScale, 0.25f) && asset.upscalingFilter == UpscalingFilterSelection.Point,
            "renderScale=" + asset.renderScale + " (기대 0.25 = 480/1920) · filter=" + asset.upscalingFilter);
        Chk("B2 원래 값 기억", Mathf.Approximately(PixelLook.OriginalRenderScale, before) && PixelLook.OriginalFilter == beforeF,
            "orig=" + PixelLook.OriginalRenderScale + "/" + PixelLook.OriginalFilter);

        // 4단 스케일 산식
        foreach (int px in new[] { 1920, 640, 480, 360 })
            L("  산식: targetHeightPx " + px + " → renderScale " + PixelLook.ComputeRenderScale(px, 1920).ToString("0.####") +
              " → 실제 그려지는 세로 픽셀 " + Mathf.RoundToInt(1920f * PixelLook.ComputeRenderScale(px, 1920)));

        // 하한 클램프
        L("  클램프: 96px/1920 = " + (96f / 1920f).ToString("0.####") + " → " + PixelLook.ComputeRenderScale(96, 1920).ToString("0.####") + " (하한 0.1)");
        Chk("B3 하한 0.1 클램프", Mathf.Approximately(PixelLook.ComputeRenderScale(96, 1920), 0.1f), PixelLook.ComputeRenderScale(96, 1920).ToString());

        bool restored = PixelLook.RestoreNow("probe");
        L("  복원: renderScale=" + asset.renderScale + " filter=" + asset.upscalingFilter);
        Chk("B4 복원 프로브 — renderScale == 원래값", restored && Mathf.Approximately(asset.renderScale, before),
            asset.renderScale + " == " + before);
        Chk("B5 복원 프로브 — upscalingFilter == 원래값", asset.upscalingFilter == beforeF,
            asset.upscalingFilter + " == " + beforeF);
        Chk("B6 이중 복원 무해", !PixelLook.RestoreNow("probe-again"), "두 번째 RestoreNow = false(무동작)");

        // 🔴 디스크 오염 검사 — 에셋이 dirty 로 표시되지 않았는가
        bool dirty = EditorUtility.IsDirty(asset);
        Chk("B7 🔴 파이프라인 에셋 dirty 아님(= Save Project 해도 디스크에 안 써진다)", !dirty, "IsDirty=" + dirty);
    }

    // ───────────────────────────────────────────── ⓒ C8
    static void C_C8()
    {
        L("");
        L("ⓒ C8 롤백");
        var cfg = WLPixelLookSettings.Instance;
        var asset = PixelLook.CurrentAsset;
        if (cfg == null || asset == null) return;

        float before = asset.renderScale;
        WLPixelLookSettings.RuntimeDisabled = true;      // enabled=0 과 같은 경로(에셋 파일은 안 건드린다)
        bool applied = PixelLook.ApplyNow(480, 1920, "c8");
        Chk("C1 스위치 off → 적용 0", !applied && Mathf.Approximately(asset.renderScale, before),
            "applied=" + applied + " renderScale=" + asset.renderScale);
        Chk("C2 스위치 off → Enabled=false", !WLPixelLookSettings.Enabled, WLPixelLookSettings.Enabled.ToString());
        WLPixelLookSettings.RuntimeDisabled = false;

        // 러너: 에디트 모드에서는 EnsureRunner 가 오브젝트를 만들지 않는다
        int before2 = CountRunners();
        PixelLook.EnsureRunnerForProbe();
        int after2 = CountRunners();
        Chk("C3 에디트 모드 러너 오브젝트 0", before2 == 0 && after2 == 0, before2 + " → " + after2);
    }

    static int CountRunners()
    {
        int n = 0;
        foreach (var go in Resources.FindObjectsOfTypeAll<GameObject>())
            if (go.name == "[WL814a] PixelLookRunner") n++;
        return n;
    }

    // ───────────────────────────────────────────── ⓓ GC
    static void D_Gc()
    {
        L("");
        L("ⓓ GC 0 (Tick × 200k · 에디트 모드라 PollBoundary 는 즉시 반환하는 경로)");
        var cfg = WLPixelLookSettings.Instance;
        if (cfg == null) return;

        PixelLook.TickForProbe();   // 워밍
        GC.Collect();
        long m0 = UnityEngine.Profiling.Profiler.GetMonoUsedSizeLong();
        long t0 = GC.GetTotalMemory(false);
        int g0 = GC.CollectionCount(0);
        for (int i = 0; i < 200000; i++) PixelLook.TickForProbe();
        long m1 = UnityEngine.Profiling.Profiler.GetMonoUsedSizeLong();
        long t1 = GC.GetTotalMemory(false);
        int g1 = GC.CollectionCount(0);
        Chk("D1 Tick ×200k 할당 0", (m1 - m0) == 0 && (t1 - t0) == 0 && (g1 - g0) == 0,
            "monoΔ=" + (m1 - m0) + "B · totalΔ=" + (t1 - t0) + "B · gen0=" + (g1 - g0));
    }

    // ═════════════════════════════════════════════════════════════════════════
    //  Capture — 임시 씬(저장 0) · 1080×1920 · 4단
    // ═════════════════════════════════════════════════════════════════════════
    public static void Capture()
    {
        s_sb = new StringBuilder(); s_pass = 0; s_fail = 0;
        L("WL-814a 룩 캡처 · " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));

        Scene temp = default(Scene);
        s_uiCam = null; s_uiCanvas = null;
        Camera cam = null;
        var asset = PixelLook.CurrentAsset;
        float origScale = asset != null ? asset.renderScale : 1f;
        var origFilter = asset != null ? asset.upscalingFilter : UpscalingFilterSelection.Auto;

        try
        {
            Directory.CreateDirectory(kOutDir);
            temp = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);

            // 기본 카메라 제거(우리 프리팹 카메라만 쓴다)
            foreach (var go in temp.GetRootGameObjects())
                if (go.GetComponent<Camera>() != null) UnityEngine.Object.DestroyImmediate(go);

            // 맵
            var map = Inst("Assets/Res_Addr/Map/WL_Nature.prefab", Vector3.zero);
            Chk("E0 맵 배치", map != null, "WL_Nature");

            // PC 위치 = 811o 와 같은 기준점(Portal_Start) 앞 · 지면 스냅
            Vector3 anchor = Vector3.zero;
            string anchorName = "(origin)";
            if (map != null)
                foreach (var t in map.GetComponentsInChildren<Transform>(true))
                    if (t.name == "Portal_Start") { anchor = t.position; anchorName = "Portal_Start"; break; }

            Vector3 pcPos = anchor + new Vector3(0f, 0f, 6f);      // 포탈 앞 6 m(존1 방향)
            RaycastHit hit;
            if (Physics.Raycast(pcPos + Vector3.up * 200f, Vector3.down, out hit, 500f)) pcPos = hit.point;
            L("  PC 위치(" + anchorName + " " + anchor + " 앞 6 m · 지면 스냅) = " + pcPos);

            // 카메라(811o 구도 h 76 · d 3 · up 2.4 · rotateAround 233 · m_LookAt (0,1.06,0))
            var camGo = Inst("Assets/ResWork/Prefabs/Ingame/Main Camera.prefab", Vector3.zero);
            cam = camGo != null ? camGo.GetComponentInChildren<Camera>(true) : null;
            Chk("E3 카메라 프리팹", cam != null, camGo != null ? camGo.name : "null");
            if (cam == null) return;

            // 에디트 모드에서 원본 스크립트가 돌지 않게(Update 는 어차피 안 돈다) 카메라 스크립트만 비활성
            foreach (var mb in camGo.GetComponentsInChildren<MonoBehaviour>(true))
                if (mb != null && !(mb is UniversalAdditionalCameraData)) mb.enabled = false;

            const float h = 76f, dAway = 3f, dUp = 2.4f, yaw = 233f;
            Vector3 rotateVector = Quaternion.Euler(h, yaw, 0f) * Vector3.one;
            Vector3 lookAt = new Vector3(0f, 1.06f, 0f);
            cam.transform.position = pcPos + Vector3.up * dUp - rotateVector * dAway;
            cam.transform.LookAt(pcPos + lookAt);

            // 카메라가 보는 수평 방향 = 「PC 앞」
            Vector3 fwd = pcPos - cam.transform.position; fwd.y = 0f; fwd.Normalize();
            Vector3 right = Vector3.Cross(Vector3.up, fwd);
            L("  카메라 = " + cam.transform.position + " → look " + (pcPos + lookAt) +
              " · fov " + cam.fieldOfView + " · 811o(h 76 · d 3 · up 2.4 · yaw 233) · 화면 앞 방향 " + fwd);

            var pc = Inst("Assets/Res_Addr/PC/Ai01.prefab", pcPos);
            if (pc != null) pc.transform.rotation = Quaternion.LookRotation(fwd, Vector3.up);
            Chk("E1 PC 배치", pc != null, "Ai01 @ " + pcPos);

            // 잡몹 3(존1 = MonsterList 101/102/103 → Mob/Batty_A·B·C · f_DefaultScale 1.5) — PC 앞(화면 안쪽)
            string[] mobs = { "Batty_A", "Batty_B", "Batty_C" };
            Vector2[] off = { new Vector2(3.2f, 1.6f), new Vector2(4.6f, -2.0f), new Vector2(6.4f, 0.6f) };  // (앞, 옆)
            var mobGos = new List<GameObject>();
            for (int i = 0; i < mobs.Length; i++)
            {
                Vector3 p = pcPos + fwd * off[i].x + right * off[i].y;
                if (Physics.Raycast(p + Vector3.up * 50f, Vector3.down, out hit, 200f)) p = hit.point;
                var m = Inst("Assets/Res_Addr/Mobs/Mob/" + mobs[i] + ".prefab", p);
                if (m != null) { m.transform.localScale = Vector3.one * 1.5f; m.transform.rotation = Quaternion.LookRotation(-fwd, Vector3.up); mobGos.Add(m); }
            }
            Chk("E2 잡몹 배치", mobGos.Count == 3, mobGos.Count + "/3 (Batty_A/B/C · scale 1.5 · PC 앞 3~6 m)");

            // T 포즈 방지 — 컨트롤러의 Idle 클립을 0.5 s 지점으로 샘플(에디트 모드)
            Pose(pc); foreach (var m in mobGos) Pose(m);

            // 🔴 UI 도 실제 게임과 같은 경로로 얹는다: Overlay UI 카메라 + ScreenSpaceCamera 캔버스(ref 1920×1080 Expand)
            //    = 렌더 스케일이 UI 까지 픽셀화하는지 눈으로 확인하기 위한 것(실측 표 ③ 결론의 그림 증거).
            bool uiOk = BuildUiMock(cam);
            Chk("E3b UI 목업(화면 픽셀 1:1 · 스킬카드 65px × 4 + HP 바)", uiOk, uiOk ? "배치됨" : "실패");

            // 캡처 4단
            int[] steps = { 1920, 640, 480, 360 };
            var rows = new List<string>();
            foreach (int px in steps)
            {
                float scale = px / 1920f;
                if (asset != null) { asset.renderScale = Mathf.Clamp(scale, 0.1f, 1f); asset.upscalingFilter = UpscalingFilterSelection.Point; }
                string file = System.IO.Path.Combine(kOutDir, "look_" + px + ".png");
                string row = Shot(cam, pc, mobGos, file, px, asset != null ? asset.renderScale : 1f);
                rows.Add(row);
                Chk("E4 look_" + px + ".png", File.Exists(file), new FileInfo(file).Length + " B");
            }
            L("");
            L("  | targetHeightPx | renderScale | 실제 그려진 해상도 | PC 키(px) | 잡몹 키(px) | 스킬버튼 한 변(px) |");
            L("  |---|---|---|---|---|---|");
            foreach (var r in rows) L("  " + r);
        }
        catch (Exception ex) { s_fail++; L("EXCEPTION " + ex); }
        finally
        {
            if (asset != null) { asset.renderScale = origScale; asset.upscalingFilter = origFilter; }   // 🔴 복원 · SetDirty 0
            L("");
            L("  복원: renderScale=" + (asset != null ? asset.renderScale.ToString() : "-") +
              " filter=" + (asset != null ? asset.upscalingFilter.ToString() : "-") +
              " · dirty=" + (asset != null ? EditorUtility.IsDirty(asset).ToString() : "-"));
            // 임시 씬은 저장하지 않는다(커밋 0)
            try { EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single); } catch { }
        }
        L("");
        L("RESULT " + (s_fail == 0 ? "PASS" : "FAIL") + " · " + s_pass + "/" + (s_pass + s_fail) + " · FAIL " + s_fail);
        Write(kTxtCap);
    }

    /// <summary>Animator 컨트롤러의 Idle 계열 클립을 0.5 s 로 샘플해서 T 포즈를 없앤다(에디트 모드 · 애니메이터 상태 변경 0).</summary>
    static void Pose(GameObject go)
    {
        if (go == null) return;
        try
        {
            var an = go.GetComponentInChildren<Animator>(true);
            if (an == null || an.runtimeAnimatorController == null) return;
            var clips = an.runtimeAnimatorController.animationClips;
            AnimationClip pick = null;
            foreach (var c in clips)
            {
                if (c == null) continue;
                if (c.name.ToLower().Contains("idle")) { pick = c; break; }
                if (pick == null) pick = c;
            }
            if (pick != null) pick.SampleAnimation(an.gameObject, 0.5f);
        }
        catch { }
    }

    /// <summary>
    /// UI 목업 — 화면 픽셀 1:1 로 배치한 캔버스.
    /// 🔴 실제 게임 경로(URP Overlay 카메라 + ScreenSpaceCamera 캔버스)는 **에디트 모드 Camera.Render 에서 스택이 그려지지 않아**
    ///    캡처에 안 나온다(이 함수 안에서 실측 · 로그로 남긴다). 그래서 캡처용으로만 캔버스를 베이스 카메라 앞
    ///    월드 공간에 두고 화면 픽셀과 1:1 이 되게 스케일한다 — 같은 렌더 타겟(= 같은 renderScale)에 그려지므로
    ///    「렌더 스케일이 UI 를 어떻게 만드는가」는 실제와 같다.
    /// </summary>
    static bool BuildUiMock(Camera baseCam)
    {
        try
        {
            int realUiLayer = LayerMask.NameToLayer("UI"); if (realUiLayer < 0) realUiLayer = 5;
            bool baseSeesUi = (baseCam.cullingMask & (1 << realUiLayer)) != 0;
            L("  🔴 인게임 베이스 카메라 cullingMask = " + baseCam.cullingMask + " · UI 레이어(" + realUiLayer + ") 포함? " +
              (baseSeesUi ? "예" : "아니오 → UI 는 반드시 Overlay UI 카메라가 그린다 = 같은 스택 = 같은 렌더 스케일"));
            L("  UI 경로(실기) = ScreenSpaceCamera 캔버스 + Overlay 카메라 스택 · 캡처 목업은 베이스 카메라가 보는 레이어 0 에 화면 픽셀 1:1 로 둔다");
            int uiLayer = 0;   // 목업 전용(베이스 카메라 cullingMask 안)

            // 화면 픽셀 1:1 — 카메라 앞 dist 에서 세로 1920 px 이 정확히 프러스텀 높이가 되게 스케일
            const float dist = 2.0f;
            float worldH = 2f * dist * Mathf.Tan(baseCam.fieldOfView * 0.5f * Mathf.Deg2Rad);
            float unit = worldH / 1920f;

            var canvasGo = new GameObject("UI_Mock(1080x1920)", typeof(RectTransform), typeof(Canvas));
            canvasGo.layer = uiLayer;
            var canvas = canvasGo.GetComponent<Canvas>();
            canvas.renderMode = RenderMode.WorldSpace;
            canvas.worldCamera = baseCam;
            var crt = canvasGo.GetComponent<RectTransform>();
            crt.SetParent(baseCam.transform, false);
            crt.sizeDelta = new Vector2(1080f, 1920f);
            crt.localPosition = new Vector3(0f, 0f, dist);
            crt.localRotation = Quaternion.identity;
            crt.localScale = Vector3.one * unit;

            // 스킬 카드 4개 — 실측 115 유닛 × NewGameUI Expand 계수 0.5625 = 화면 64.7 px
            float card = 115f * 0.5625f;
            for (int i = 0; i < 4; i++)
            {
                var c = Quad(canvasGo.transform, uiLayer, new Vector2(card, card),
                             new Vector2(1f, 0f), new Vector2(-40f - i * (card + 14f), 90f), new Color(0.12f, 0.14f, 0.20f, 0.95f));
                Quad(c.transform, uiLayer, new Vector2(card - 9f, card - 9f), new Vector2(0.5f, 0.5f), Vector2.zero,
                     new Color(0.85f, 0.72f, 0.28f, 1f));
            }
            // 상단 HP 바(760×34 유닛 → 428×19 px)
            var hp = Quad(canvasGo.transform, uiLayer, new Vector2(760f * 0.5625f, 34f * 0.5625f), new Vector2(0.5f, 1f),
                          new Vector2(0f, -60f), new Color(0.10f, 0.10f, 0.12f, 0.9f));
            Quad(hp.transform, uiLayer, new Vector2(520f * 0.5625f, 22f * 0.5625f), new Vector2(0f, 0.5f),
                 new Vector2(70f, 0f), new Color(0.90f, 0.21f, 0.16f, 1f));

            s_uiCanvas = crt;
            return true;
        }
        catch (Exception ex) { L("  UI 목업 실패 " + ex.Message); return false; }
    }

    static GameObject Quad(Transform parent, int layer, Vector2 size, Vector2 anchor, Vector2 pos, Color col)
    {
        var go = new GameObject("q", typeof(RectTransform), typeof(Image));
        go.layer = layer;
        var rt = go.GetComponent<RectTransform>();
        rt.SetParent(parent, false);
        rt.anchorMin = rt.anchorMax = anchor;
        rt.pivot = anchor;
        rt.sizeDelta = size;
        rt.anchoredPosition = pos;
        var img = go.GetComponent<Image>();
        img.sprite = null; img.color = col; img.raycastTarget = false;
        return go;
    }

    static GameObject Inst(string path, Vector3 pos)
    {
        var src = AssetDatabase.LoadAssetAtPath<GameObject>(path);
        if (src == null) { L("  프리팹 없음 " + path); return null; }
        var go = (GameObject)PrefabUtility.InstantiatePrefab(src);
        go.transform.position = pos;
        return go;
    }

    static string Shot(Camera cam, GameObject pc, List<GameObject> mobs, string file, int targetPx, float scale)
    {
        var rt = new RenderTexture(1080, 1920, 24, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
        rt.antiAliasing = 1;
        rt.Create();
        var prev = cam.targetTexture;
        cam.targetTexture = rt;
        // 🔴 ScreenSpaceCamera 캔버스는 worldCamera.pixelRect 로 크기를 정한다 → 오버레이 카메라에도 같은 RT 를 물려
        //    1080×1920 기준으로 배치시킨다(URP 는 오버레이의 targetTexture 를 무시하고 베이스의 타겟에 그린다).
        if (s_uiCam != null) s_uiCam.targetTexture = rt;
        Canvas.ForceUpdateCanvases();
        cam.Render();

        var active = RenderTexture.active;
        RenderTexture.active = rt;
        var tex = new Texture2D(1080, 1920, TextureFormat.RGB24, false);
        tex.ReadPixels(new Rect(0, 0, 1080, 1920), 0, 0);
        tex.Apply();
        RenderTexture.active = active;

        File.WriteAllBytes(file, tex.EncodeToPNG());

        // 화면 픽셀 측정(전체 해상도 기준) → × renderScale = 실제 그려진 픽셀
        float pcPx = ScreenHeightPx(cam, pc);
        float mobPx = mobs.Count > 0 ? ScreenHeightPx(cam, mobs[0]) : 0f;
        float skillPx = SkillButtonPx();   // 스킬 카드 실측 유닛 × 0.5625(NewGameUI Expand 계수)

        // 색 분산(빈 화면 방지)
        var px32 = tex.GetPixels32();
        var seen = new HashSet<int>();
        for (int i = 0; i < px32.Length; i += 977) seen.Add((px32[i].r << 16) | (px32[i].g << 8) | px32[i].b);
        int distinct = seen.Count;

        cam.targetTexture = prev;
        if (s_uiCam != null) s_uiCam.targetTexture = null;
        foreach (var c in UnityEngine.Object.FindObjectsByType<Camera>(FindObjectsInactive.Include, FindObjectsSortMode.None))
            if (c != null && c.targetTexture == rt) c.targetTexture = null;
        RenderTexture.active = null;
        UnityEngine.Object.DestroyImmediate(tex);
        rt.Release(); UnityEngine.Object.DestroyImmediate(rt);

        L("  캡처 " + System.IO.Path.GetFileName(file) + " · renderScale=" + scale.ToString("0.####") +
          " · 색 " + distinct + "종(1 이면 빈 화면) · PC " + pcPx.ToString("0") + "px(전체해상도) · 스킬버튼 " + skillPx.ToString("0") + "px" +
          " · Screen " + Screen.width + "×" + Screen.height +
          " · uiCam px " + (s_uiCam != null ? s_uiCam.pixelWidth + "×" + s_uiCam.pixelHeight : "-") +
          " · 캔버스 rect " + (s_uiCanvas != null ? s_uiCanvas.rect.size.ToString() : "-"));

        return "| " + targetPx + " | " + scale.ToString("0.####") + " | " +
               Mathf.RoundToInt(1080f * scale) + "×" + Mathf.RoundToInt(1920f * scale) + " | " +
               Mathf.RoundToInt(pcPx * scale) + " | " + Mathf.RoundToInt(mobPx * scale) + " | " +
               Mathf.RoundToInt(skillPx * scale) + " |";
    }

    /// <summary>렌더러 바운드를 화면에 투영한 세로 픽셀(1080×1920 전체 해상도 기준).</summary>
    static float ScreenHeightPx(Camera cam, GameObject go)
    {
        if (go == null) return 0f;
        var rs = go.GetComponentsInChildren<Renderer>();
        if (rs.Length == 0) return 0f;
        var b = rs[0].bounds;
        foreach (var r in rs) b.Encapsulate(r.bounds);
        float minY = float.MaxValue, maxY = float.MinValue;
        for (int i = 0; i < 8; i++)
        {
            var c = new Vector3(((i & 1) == 0 ? b.min : b.max).x, ((i & 2) == 0 ? b.min : b.max).y, ((i & 4) == 0 ? b.min : b.max).z);
            var s = cam.WorldToScreenPoint(c);
            if (s.z <= 0f) continue;
            minY = Mathf.Min(minY, s.y); maxY = Mathf.Max(maxY, s.y);
        }
        return maxY > minY ? maxY - minY : 0f;
    }

    /// <summary>스킬 카드 한 변의 1080×1920 화면 픽셀. NewGameUI(ref 1920×1080 · Expand) scaleFactor 0.5625 적용.</summary>
    static float SkillButtonPx()
    {
        var ui = AssetDatabase.LoadAssetAtPath<GameObject>("Assets/Res_Addr/MainUI/NewGameUI.prefab");
        if (ui == null) return 0f;
        foreach (var b in ui.GetComponentsInChildren<BattleUI>(true))
        {
            if (b.skillCards == null || b.skillCards.Length == 0 || b.skillCards[0] == null) continue;
            var rt = b.skillCards[0].GetComponent<RectTransform>();
            if (rt != null) return Mathf.Max(rt.sizeDelta.x, rt.sizeDelta.y) * 0.5625f;
        }
        return 0f;
    }
}