// WL-814k 프로브 + 캡처 4장 (게임 코드 아님 · 에디트 모드 전용 · 임시 씬 저장 0 · 커밋 0)
//   probe: unity command run_script --file AgentScripts/WL814k_Probe.cs --entry WL814k_Probe.RunAll
//   cap  : unity command run_script --file AgentScripts/WL814k_Probe.cs --entry WL814k_Probe.Capture
// 🔴 원본 프리팹/머티리얼/애니메이션 수정 0. 씬 저장 0.

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;
using UnityEngine.Profiling;
using UnityEngine.SceneManagement;
using WL.Look.SpriteBake;

public static class WL814k_Probe
{
    const string kOutDir = @"E:\NerdNavis\nn_himminji\Screenshots_WL\WL814k";
    const string kTxt = "AgentScripts/WL814k_PROBE.txt";
    const string kTxtCap = "AgentScripts/WL814k_CAPTURE.txt";
    const string kRes = "Assets/WL/Look/Sprite/Resources/WL";
    const string kPcPrefab = "Assets/Res_Addr/PC/Ai01.prefab";
    const string kMobPrefab = "Assets/Res_Addr/Mobs/Mob/Batty_A.prefab";

    // 도트A 프리셋 실측 = orthoSize 3.4 · pixelHeight 240 · 내림각 43.609°
    const float kOrtho = 3.4f, kPitch = 43.609f;
    const int kLowH = 240, kLowW = 135, kHiW = 1080, kHiH = 1920;

    static StringBuilder s_sb;
    static int s_pass, s_fail;
    static void L(string s) { s_sb.AppendLine(s); Debug.Log("[WL814k] " + s); }
    static void Chk(string n, bool ok, string d) { if (ok) s_pass++; else s_fail++; L((ok ? "  PASS " : "  FAIL ") + n + " — " + d); }
    static void Write(string p) { File.WriteAllText(p, s_sb.ToString(), new UTF8Encoding(false)); Debug.Log("[WL814k] → " + p); }

    // ═════════════════════════════════════════════════════════════════════════
    //  프로브
    // ═════════════════════════════════════════════════════════════════════════
    public static void RunAll()
    {
        s_sb = new StringBuilder(); s_pass = 0; s_fail = 0;
        L("WL-814k 프로브 · " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " · Unity " + Application.unityVersion);
        try
        {
            A_Assets();
            EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
            B_AttachRestore();
            C_FrameDir();
            D_Gc();
            E_Sheet();
            F_C8();
        }
        catch (Exception ex) { s_fail++; L("EXCEPTION " + ex); }
        finally
        {
            SpriteBillboard.RestoreNow("probe-end");
            WLSpriteLookSettings.RuntimeDisabled = false;
            EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
        }
        L("");
        L("RESULT " + (s_fail == 0 ? "PASS" : "FAIL") + " — " + s_pass + " pass / " + s_fail + " fail");
        Write(kTxt);
    }

    // ── A. 에셋 · 메타 ──────────────────────────────────────────────────────
    static void A_Assets()
    {
        L("");
        L("== A. 에셋 · 메타 ==");
        var bake = AssetDatabase.LoadAssetAtPath<WLSpriteBakeSettings>(kRes + "/WLSpriteBakeSettings.asset");
        var look = AssetDatabase.LoadAssetAtPath<WLSpriteLookSettings>(kRes + "/WLSpriteLookSettings.asset");
        Chk("A1 굽기 SO", bake != null, bake == null ? "없음" : "내림각 " + bake.PitchDeg.ToString("0.000") + "° · 픽셀 " + bake.WorldPerPixel.ToString("0.00000") + " m");
        Chk("A2 런타임 SO", look != null && look.sets != null && look.sets.Length == 2, look == null ? "없음" : "sets " + look.sets.Length);
        if (look == null) return;
        foreach (var s in look.sets)
        {
            Chk("A3 시트 " + (s == null ? "null" : s.name), s != null && s.IsUsable,
                s == null ? "null" : string.Format("{0} · 프레임 {1}×{2} · {3}열×{4}행 · 방향 {5} · 총 {6}칸 · 텍스처 {7}×{8}",
                    s.actorNamePrefix, s.frameWidth, s.frameHeight, s.columns, s.rows, s.dirCount, s.TotalFrames,
                    s.sheet == null ? 0 : s.sheet.width, s.sheet == null ? 0 : s.sheet.height));
            if (s == null || s.sheet == null) continue;
            var ti = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(s.sheet)) as TextureImporter;
            Chk("A4 임포트 " + s.name, ti != null && ti.filterMode == FilterMode.Point && !ti.mipmapEnabled
                    && ti.textureCompression == TextureImporterCompression.Uncompressed && ti.alphaIsTransparency,
                ti == null ? "임포터 없음" : "filter " + ti.filterMode + " · mipmap " + ti.mipmapEnabled + " · 압축 " + ti.textureCompression
                    + " · alphaIsTransparency " + ti.alphaIsTransparency + " · maxSize " + ti.maxTextureSize + " · type " + ti.textureType);
            int need = s.TotalFrames;
            int cap = s.columns * s.rows;
            Chk("A5 격자 " + s.name, cap >= need && s.sheet.width == s.columns * s.frameWidth && s.sheet.height == s.rows * s.frameHeight,
                "칸 " + cap + " ≥ 필요 " + need + " · 텍스처 " + s.sheet.width + "×" + s.sheet.height);
            var act = new StringBuilder();
            foreach (var a in s.actions) act.Append(a.key + "[" + a.startIndex + "+" + a.frameCount + "] ");
            Chk("A6 동작표 " + s.name, s.actions.Length >= 4, s.actions.Length + "개 · " + act.ToString().TrimEnd());
        }
    }

    // ── B. 부착 → 원복 ──────────────────────────────────────────────────────
    static void B_AttachRestore()
    {
        L("");
        L("== B. 부착 → 원복 (원본 파괴 0 · 렌더러 원값 복원) ==");
        var look = WLSpriteLookSettings.Instance;
        var actor = Spawn(kPcPrefab, Vector3.zero, 0.7f);
        var set = SpriteBillboard.MatchSet(actor.name, look);
        Chk("B1 이름 매칭", set != null, "액터 '" + actor.name + "' → " + (set == null ? "매칭 실패" : set.name));
        if (set == null) { UnityEngine.Object.DestroyImmediate(actor); return; }

        var smrs = actor.GetComponentsInChildren<SkinnedMeshRenderer>(true);
        int before = 0; foreach (var r in smrs) if (r.enabled) before++;
        int childBefore = CountAll(actor);

        var e = SpriteBillboard.TryAttach(actor, set);
        int after = 0; foreach (var r in smrs) if (r.enabled) after++;
        Chk("B2 원본 끔", e != null && after == 0 && before > 0, "SMR " + before + "개 → 켜져 있는 것 " + after + "개");
        Chk("B3 쿼드 1개", e != null && e.quad != null, e == null ? "-" : e.quad.name + " · 부모 " + e.quad.transform.parent.name + " · 레이어 " + e.quad.layer);
        Chk("B4 파괴 0", CountAll(actor) == childBefore + 1, "노드 " + childBefore + " → " + CountAll(actor) + " (쿼드 +1)");

        SpriteBillboard.Detach(actor);
        int restored = 0; foreach (var r in smrs) if (r != null && r.enabled) restored++;
        Chk("B5 원복", restored == before && CountAll(actor) == childBefore, "SMR 켜짐 " + restored + "/" + before + " · 노드 " + CountAll(actor) + "/" + childBefore);
        UnityEngine.Object.DestroyImmediate(actor);
    }

    // ── C. 프레임 · 방향 선택 ───────────────────────────────────────────────
    static void C_FrameDir()
    {
        L("");
        L("== C. 프레임 · 방향 선택 (Animator 폴링 · 원본 코드 수정 0) ==");
        var look = WLSpriteLookSettings.Instance;
        var cam = MakeCam(kLowW, kLowH);
        var actor = Spawn(kPcPrefab, Vector3.zero, 0.7f);
        var set = SpriteBillboard.MatchSet(actor.name, look);
        var anim = actor.GetComponent<Animator>();
        anim.applyRootMotion = false; anim.cullingMode = AnimatorCullingMode.AlwaysAnimate; anim.Rebind();
        var e = SpriteBillboard.TryAttach(actor, set);

        // ⓐ 상태 해시 → 동작
        int okState = 0, allState = 0;
        foreach (var a in set.actions)
            foreach (var n in a.stateNames)
            {
                allState++;
                var found = set.FindByStateHash(Animator.StringToHash(n));
                if (found == a) okState++;
            }
        Chk("C1 상태→동작", okState == allState, okState + "/" + allState + "개 상태가 정확한 동작으로 간다");

        // ⓑ normalizedTime → 프레임
        var idle = set.FindByKey("idle");
        var lines = new StringBuilder();
        bool frameOk = true;
        for (int f = 0; f < idle.frameCount; f++)
        {
            float nt = (f + 0.5f) / idle.frameCount;
            anim.Play(Animator.StringToHash("idle"), 0, nt);
            anim.Update(0f);
            SpriteBillboard.UpdateAll(cam.cam);
            if (e.frame != f) frameOk = false;
            lines.Append("nt " + nt.ToString("0.00") + "→f" + e.frame + " ");
        }
        Chk("C2 시간→프레임", frameOk, lines.ToString().Trim());

        // ⓑ-2 기본 상태가 아닌 동작도 폴링으로 맞는가 (에디트 모드 실측)
        lines.Length = 0; int hit = 0, tot = 0;
        foreach (var a in set.actions)
        {
            int h = Animator.StringToHash(a.stateNames[0]);
            if (!anim.HasState(0, h)) continue;
            tot++;
            anim.Play(h, 0, 0.5f);
            anim.Update(0f);
            SpriteBillboard.UpdateAll(cam.cam);
            bool ok = e.action != null && e.action.key == a.key;
            if (ok) hit++;
            lines.Append(a.key + "→" + (e.action == null ? "-" : e.action.key) + (ok ? " " : "✗ "));
        }
        Chk("C2b 상태 폴링(에디트 모드)", hit == tot, hit + "/" + tot + " · " + lines.ToString().Trim());

        // ⓒ 상대 yaw → 방향
        lines.Length = 0; bool dirOk = true;
        anim.Play(Animator.StringToHash("idle"), 0, 0f); anim.Update(0f);
        for (int d = 0; d < set.dirCount; d++)
        {
            actor.transform.rotation = Quaternion.Euler(0f, d * (360f / set.dirCount), 0f);
            SpriteBillboard.UpdateAll(cam.cam);
            if (e.dir != d) dirOk = false;
            lines.Append(d * 45 + "°→d" + e.dir + " ");
        }
        Chk("C3 각도→방향", dirOk, lines.ToString().Trim());

        // ⓓ 쿼드 크기 = 프레임 px × 픽셀 월드 크기 (스케일 보정 포함)
        actor.transform.rotation = Quaternion.identity;
        SpriteBillboard.UpdateAll(cam.cam);
        float expect = set.frameWidth * set.worldPerPixel * (0.7f / set.bakeScale);
        float got = e.quadTf.lossyScale.x;
        Chk("C4 쿼드 크기", Mathf.Abs(got - expect) < 0.002f,
            string.Format("월드 {0:0.0000} m (기대 {1:0.0000}) · 스케일 보정 {2:0.000}", got, expect, e.scaleK));
        Chk("C5 쿼드 자세", Quaternion.Angle(e.quadTf.rotation, cam.cam.transform.rotation) < 0.01f,
            "카메라 정렬 오차 " + Quaternion.Angle(e.quadTf.rotation, cam.cam.transform.rotation).ToString("0.000") + "°");

        SpriteBillboard.Detach(actor);
        UnityEngine.Object.DestroyImmediate(actor);
        cam.Dispose();
    }

    // ── D. GC ───────────────────────────────────────────────────────────────
    static void D_Gc()
    {
        L("");
        L("== D. GC (프레임당 할당 0) ==");
        var look = WLSpriteLookSettings.Instance;
        var cam = MakeCam(kLowW, kLowH);
        var a1 = Spawn(kPcPrefab, Vector3.zero, 0.7f);
        var a2 = Spawn(kMobPrefab, new Vector3(1.5f, 0f, 0f), 0f);
        SpriteBillboard.TryAttach(a1, SpriteBillboard.MatchSet(a1.name, look));
        SpriteBillboard.TryAttach(a2, SpriteBillboard.MatchSet(a2.name, look));

        for (int i = 0; i < 200; i++) SpriteBillboard.UpdateAll(cam.cam);   // 워밍업
        GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect();
        long m0 = Profiler.GetMonoUsedSizeLong();
        int g0 = GC.CollectionCount(0);
        for (int i = 0; i < 200000; i++) SpriteBillboard.UpdateAll(cam.cam);
        long m1 = Profiler.GetMonoUsedSizeLong();
        int g1 = GC.CollectionCount(0);
        Chk("D1 UpdateAll ×200k", m1 - m0 == 0 && g1 == g0, "mono Δ " + (m1 - m0) + " B · gen0 " + (g1 - g0) + "회");

        SpriteBillboard.RestoreNow("gc-probe");
        UnityEngine.Object.DestroyImmediate(a1); UnityEngine.Object.DestroyImmediate(a2);
        cam.Dispose();
    }

    // ── E. 시트 내용 ────────────────────────────────────────────────────────
    static void E_Sheet()
    {
        L("");
        L("== E. 시트 내용 (도트화가 실제로 강제됐는가) ==");
        var look = WLSpriteLookSettings.Instance;
        foreach (var s in look.sets)
        {
            if (s == null || s.sheet == null) continue;
            var path = AssetDatabase.GetAssetPath(s.sheet);
            var bytes = File.ReadAllBytes(path);
            var t = new Texture2D(2, 2, TextureFormat.RGBA32, false, false);
            t.LoadImage(bytes);
            var px = t.GetPixels32();
            // 기대 팔레트 = 채널당 levels 단계 · 여기에 외곽선 색(SO)만 예외로 허용한다
            var bake = AssetDatabase.LoadAssetAtPath<WLSpriteBakeSettings>(kRes + "/WLSpriteBakeSettings.asset");
            int lv = bake != null ? bake.paletteLevels : 6;
            var allowed = new HashSet<int>();
            for (int i = 0; i < lv; i++) allowed.Add(Mathf.RoundToInt((float)i / (lv - 1) * 255f));
            Color32 oc = bake != null ? (Color32)bake.outlineColor : new Color32(14, 11, 17, 255);

            bool bands = bake == null || bake.paletteValueBands;
            int opaque = 0, semi = 0, outline = 0, offPalette = 0;
            var levels = new HashSet<int>();
            var colors = new HashSet<int>();
            for (int i = 0; i < px.Length; i++)
            {
                if (px[i].a == 0) continue;
                if (px[i].a == 255) opaque++; else semi++;
                levels.Add(bands ? Mathf.Max(px[i].r, Mathf.Max(px[i].g, px[i].b)) : px[i].r);
                if (!bands) { levels.Add(px[i].g); levels.Add(px[i].b); }
                colors.Add((px[i].r << 16) | (px[i].g << 8) | px[i].b);
                bool isOutline = px[i].r == oc.r && px[i].g == oc.g && px[i].b == oc.b;
                if (isOutline) { outline++; continue; }
                if (bands)
                {
                    if (!allowed.Contains(Mathf.Max(px[i].r, Mathf.Max(px[i].g, px[i].b)))) offPalette++;
                }
                else if (!allowed.Contains(px[i].r) || !allowed.Contains(px[i].g) || !allowed.Contains(px[i].b)) offPalette++;
            }
            Chk("E1 알파 이진화 " + s.name, semi == 0, "불투명 " + opaque + " · 반투명 " + semi + "(0 이어야 한다)");
            Chk("E2 팔레트 양자화 " + s.name, offPalette == 0,
                (bands ? "밝기 " : "채널 ") + lv + "단계 " + Join(allowed) + " 밖 픽셀 " + offPalette + "개 · 실제 " + levels.Count + "가지 " + Join(levels)
                + " (외곽선 색 " + oc.r + "," + oc.g + "," + oc.b + " 제외) · 색 " + colors.Count + "종");
            Chk("E3 외곽선 " + s.name, outline > opaque * 0.05f, "어두운 테두리 픽셀 " + outline + " / 불투명 " + opaque
                + " (" + (100f * outline / Mathf.Max(1, opaque)).ToString("0.0") + " %)");
            Chk("E4 PNG 크기 " + s.name, bytes.Length > 0, bytes.Length.ToString("N0") + " B (" + (bytes.Length / 1024.0).ToString("0.0") + " KB) · "
                + s.sheet.width + "×" + s.sheet.height + " · RGBA32 런타임 " + (s.sheet.width * s.sheet.height * 4 / 1024.0 / 1024.0).ToString("0.00") + " MB");
            UnityEngine.Object.DestroyImmediate(t);
        }
    }

    static string Join(HashSet<int> s)
    {
        var l = new List<int>(s); l.Sort();
        var sb = new StringBuilder("[");
        foreach (var v in l) sb.Append(v).Append(' ');
        return sb.ToString().TrimEnd() + "]";
    }

    // ── F. C8 (SO off → 원본 3D 100 %) ─────────────────────────────────────
    static void F_C8()
    {
        L("");
        L("== F. C8 롤백 (SO off → 원본 3D 100 %) ==");
        var look = WLSpriteLookSettings.Instance;
        var actor = Spawn(kPcPrefab, Vector3.zero, 0.7f);
        var smrs = actor.GetComponentsInChildren<SkinnedMeshRenderer>(true);
        var mrs = actor.GetComponentsInChildren<MeshRenderer>(true);
        int smrOn0 = 0; foreach (var r in smrs) if (r.enabled) smrOn0++;
        int mrOn0 = 0; foreach (var r in mrs) if (r.enabled) mrOn0++;
        int nodes0 = CountAll(actor);

        SpriteBillboard.TryAttach(actor, SpriteBillboard.MatchSet(actor.name, look));
        WLSpriteLookSettings.RuntimeDisabled = true;
        Chk("F1 게이트", !WLSpriteLookSettings.Enabled && !SpriteBillboard.ShouldBeOn, "RuntimeDisabled → Enabled=false · ShouldBeOn=false");
        int n = SpriteBillboard.RestoreNow("C8");
        WLSpriteLookSettings.RuntimeDisabled = false;

        int smrOn1 = 0; foreach (var r in smrs) if (r != null && r.enabled) smrOn1++;
        int mrOn1 = 0; foreach (var r in mrs) if (r != null && r.enabled) mrOn1++;
        Chk("F2 렌더러 100 % 복원", smrOn1 == smrOn0 && mrOn1 == mrOn0, "SMR " + smrOn1 + "/" + smrOn0 + " · MR " + mrOn1 + "/" + mrOn0);
        Chk("F3 쿼드 0", CountAll(actor) == nodes0 && SpriteBillboard.ActiveCount == 0, "노드 " + CountAll(actor) + "/" + nodes0 + " · 대상 " + SpriteBillboard.ActiveCount);

        // 시트를 안 가진 액터는 아예 안 걸린다
        var other = Spawn("Assets/Res_Addr/PC/Ai02.prefab", Vector3.zero, 0.7f);
        if (other != null)
        {
            Chk("F4 목록 밖 액터", SpriteBillboard.MatchSet(other.name, look) == null, "'" + other.name + "' → 매칭 0 = 원본 3D 그대로");
            UnityEngine.Object.DestroyImmediate(other);
        }
        UnityEngine.Object.DestroyImmediate(actor);
    }

    // ═════════════════════════════════════════════════════════════════════════
    //  캡처 4장
    // ═════════════════════════════════════════════════════════════════════════
    public static void Capture()
    {
        s_sb = new StringBuilder(); s_pass = 0; s_fail = 0;
        L("WL-814k 캡처 · " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
        Directory.CreateDirectory(kOutDir);
        try
        {
            EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
            World();
            var look = WLSpriteLookSettings.Instance;

            // 두 캐릭터를 나란히 (PC 왼쪽 · 몹 오른쪽)
            var pc = Spawn(kPcPrefab, new Vector3(-1.0f, 0f, 0f), 0.7f);
            var mob = Spawn(kMobPrefab, new Vector3(1.1f, 0f, 0f), 0f);
            // 🔴 구운 프레임과 **정확히 같은 시각**으로 3D 를 세운다(프레임 양자화 차이를 A/B 에서 빼기 위해)
            PoseFrame(pc, look, "attack", 2, 315f);
            PoseFrame(mob, look, "attack", 3, 45f);

            var ground = Ground();
            var cam = MakeCam(kLowW, kLowH);
            cam.cam.transform.position = new Vector3(0f, 1.0f, 0f) - cam.cam.transform.forward * 40f;
            cam.cam.orthographicSize = kOrtho;

            // 지면만 찍은 기준 컷(실루엣을 차분으로 정확히 잰다)
            pc.SetActive(false); mob.SetActive(false);
            var bg = cam.Grab();
            pc.SetActive(true); mob.SetActive(true);

            // ⓐ 3D 원본
            var a = cam.Grab();
            SavePoint(a, kLowW, kLowH, kOutDir + @"\k_1_3d_original.png");
            L("  ⓐ 3D 원본 → k_1_3d_original.png");

            // ⓑ 구운 스프라이트로 교체(같은 구도 · 같은 포즈 · 같은 방향)
            var ePc = SpriteBillboard.TryAttach(pc, SpriteBillboard.MatchSet(pc.name, look));
            var eMob = SpriteBillboard.TryAttach(mob, SpriteBillboard.MatchSet(mob.name, look));
            SpriteBillboard.UpdateAll(cam.cam);
            L(string.Format("  폴링 결과 — PC {0} d{1} f{2} / 몹 {3} d{4} f{5}",
                ePc.action != null ? ePc.action.key : "-", ePc.dir, ePc.frame,
                eMob.action != null ? eMob.action.key : "-", eMob.dir, eMob.frame));
            // 🔴 A/B 는 「같은 포즈」여야 하므로 프레임을 못 박는다(폴링 정확도는 프로브 C 가 따로 잰다)
            SpriteBillboard.SetManualFrame(pc, "attack", 7, 2);
            SpriteBillboard.SetManualFrame(mob, "attack", 1, 3);
            SpriteBillboard.UpdateAll(cam.cam);
            var b = cam.Grab();
            SavePoint(b, kLowW, kLowH, kOutDir + @"\k_2_sprite_baked.png");
            L("  ⓑ 스프라이트 교체 → k_2_sprite_baked.png");

            // 정렬 실측 — 같은 구도에서 3D 실루엣과 스프라이트 실루엣이 몇 px 어긋나는가
            var boxA = Box(a, bg, kLowW, kLowH, 0, kLowW / 2);
            var boxB = Box(b, bg, kLowW, kLowH, 0, kLowW / 2);
            L(string.Format("  정렬 실측(PC 쪽 절반) — 3D x[{0}..{1}] y[{2}..{3}] / 스프라이트 x[{4}..{5}] y[{6}..{7}] → Δ좌 {8} · Δ우 {9} · Δ하 {10} · Δ상 {11} px",
                boxA[0], boxA[1], boxA[2], boxA[3], boxB[0], boxB[1], boxB[2], boxB[3],
                boxB[0] - boxA[0], boxB[1] - boxA[1], boxB[2] - boxA[2], boxB[3] - boxA[3]));
            L(string.Format("  밝기 실측 — 3D 평균 {0:0.0} · 스프라이트 평균 {1:0.0} (0~255 · 캐릭터 픽셀만) · 캐릭터 픽셀 3D {2} / 스프라이트 {3} (외곽선 +{4})",
                MeanLum(a, bg), MeanLum(b, bg), CountDiff(a, bg), CountDiff(b, bg), CountDiff(b, bg) - CountDiff(a, bg)));

            // ⓒ 2배 클로즈업 — 위 3D / 아래 스프라이트
            CloseUp(a, b, bg, kLowW, kLowH, kOutDir + @"\k_3_closeup_2x.png");
            L("  ⓒ 클로즈업 → k_3_closeup_2x.png");

            // ⓓ 방향 8종 한 장
            SpriteBillboard.RestoreNow("capture-dir");
            Directions(cam, pc, mob, ground, kOutDir + @"\k_4_directions.png");
            L("  ⓓ 방향 8종 → k_4_directions.png");

            cam.Dispose();
        }
        catch (Exception ex) { s_fail++; L("EXCEPTION " + ex); }
        finally
        {
            SpriteBillboard.RestoreNow("capture-end");
            EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
        }
        L("");
        L("캡처 " + (s_fail == 0 ? "PASS" : "FAIL") + " — " + kOutDir);
        Write(kTxtCap);
    }

    // 방향 8종을 한 장에 — 위 줄 = 3D · 아래 줄 = 스프라이트
    static void Directions(CamRig cam, GameObject pc, GameObject mob, GameObject ground, string file)
    {
        int cell = 64;                  // 셀 하나의 저해상도 픽셀 크기
        var rig = MakeCam(cell, cell);
        rig.cam.transform.rotation = cam.cam.transform.rotation;
        rig.cam.orthographicSize = cell * (2f * kOrtho / kLowH) * 0.5f;
        mob.SetActive(false);
        pc.transform.position = Vector3.zero;

        int cols = 8, rows = 2;
        var sheet = new Color32[cols * cell * rows * cell];
        var look = WLSpriteLookSettings.Instance;

        for (int pass = 0; pass < 2; pass++)
        {
            if (pass == 1)
            {
                var e = SpriteBillboard.TryAttach(pc, SpriteBillboard.MatchSet(pc.name, look));
            }
            for (int d = 0; d < cols; d++)
            {
                Pose(pc, "idle", 0.0f, d * 45f);
                rig.cam.transform.position = new Vector3(0f, 0.6f, 0f) - rig.cam.transform.forward * 40f;
                if (pass == 1) SpriteBillboard.UpdateAll(rig.cam);
                var px = rig.Grab();
                BlitInto(px, cell, cell, sheet, cols * cell, d * cell, (rows - 1 - pass) * cell);
            }
        }
        SpriteBillboard.RestoreNow("dir-capture");
        mob.SetActive(true);
        SavePoint(sheet, cols * cell, rows * cell, file, 4);
        rig.Dispose();
    }

    // 클로즈업 — 캐릭터 주변을 잘라 확대해 위/아래로 붙인다
    static void CloseUp(Color32[] a, Color32[] b, Color32[] bg, int w, int h, string file)
    {
        var box = Box(a, bg, w, h, 0, w);
        int pad = 6;
        int x0 = Mathf.Max(0, box[0] - pad), x1 = Mathf.Min(w - 1, box[1] + pad);
        int y0 = Mathf.Max(0, box[2] - pad), y1 = Mathf.Min(h - 1, box[3] + pad);
        int cw = x1 - x0 + 1, ch = y1 - y0 + 1;
        int zoom = Mathf.Max(2, Mathf.Min(1080 / Mathf.Max(1, cw), 900 / Mathf.Max(1, ch)));
        int outW = cw * zoom, outH = ch * zoom * 2 + 8;
        var outPx = new Color32[outW * outH];
        for (int i = 0; i < outPx.Length; i++) outPx[i] = new Color32(24, 26, 30, 255);
        // 아래 = 스프라이트 · 위 = 3D
        CropZoom(b, w, h, x0, y0, cw, ch, zoom, outPx, outW, 0, 0);
        CropZoom(a, w, h, x0, y0, cw, ch, zoom, outPx, outW, 0, ch * zoom + 8);
        L(string.Format("     클로즈업 crop {0}×{1} px → ×{2} = {3}×{4} (위 3D · 아래 스프라이트)", cw, ch, zoom, outW, outH));
        SaveRaw(outPx, outW, outH, file);
    }

    static void CropZoom(Color32[] src, int w, int h, int x0, int y0, int cw, int ch, int zoom,
                         Color32[] dst, int dw, int dx, int dy)
    {
        for (int y = 0; y < ch * zoom; y++)
            for (int x = 0; x < cw * zoom; x++)
            {
                int sx = x0 + x / zoom, sy = y0 + y / zoom;
                if (sx < 0 || sy < 0 || sx >= w || sy >= h) continue;
                int di = (dy + y) * dw + (dx + x);
                if (di < 0 || di >= dst.Length) continue;
                dst[di] = src[sy * w + sx];
            }
    }

    /// <summary>지면만 찍은 컷과 다른 픽셀 = 캐릭터 픽셀.</summary>
    static bool Diff(Color32[] px, Color32[] bg, int i)
    {
        if (bg == null) return px[i].a >= 8;
        return Mathf.Abs(px[i].r - bg[i].r) + Mathf.Abs(px[i].g - bg[i].g) + Mathf.Abs(px[i].b - bg[i].b) > 8
               || Mathf.Abs(px[i].a - bg[i].a) > 8;
    }

    static float MeanLum(Color32[] px, Color32[] bg)
    {
        double sum = 0; int n = 0;
        for (int i = 0; i < px.Length; i++)
        {
            if (!Diff(px, bg, i)) continue;
            sum += 0.299 * px[i].r + 0.587 * px[i].g + 0.114 * px[i].b; n++;
        }
        return n == 0 ? 0f : (float)(sum / n);
    }

    static int CountDiff(Color32[] px, Color32[] bg)
    {
        int n = 0;
        for (int i = 0; i < px.Length; i++) if (Diff(px, bg, i)) n++;
        return n;
    }

    static int[] Box(Color32[] px, Color32[] bg, int w, int h, int xFrom, int xTo)
    {
        int minX = int.MaxValue, maxX = -1, minY = int.MaxValue, maxY = -1;
        for (int y = 0; y < h; y++)
            for (int x = xFrom; x < Mathf.Min(w, xTo); x++)
            {
                if (!Diff(px, bg, y * w + x)) continue;
                if (x < minX) minX = x; if (x > maxX) maxX = x;
                if (y < minY) minY = y; if (y > maxY) maxY = y;
            }
        return new[] { minX, maxX, minY, maxY };
    }

    /// <summary>지면 — PD 가 「게임 화면처럼」 볼 수 있게 단색 평면 1장(커밋 0 · 임시 씬).</summary>
    static GameObject Ground()
    {
        var go = GameObject.CreatePrimitive(PrimitiveType.Plane);
        go.name = "[WL814k] Ground";
        go.transform.position = Vector3.zero;
        go.transform.localScale = new Vector3(6f, 1f, 6f);
        UnityEngine.Object.DestroyImmediate(go.GetComponent<Collider>());
        var mr = go.GetComponent<MeshRenderer>();
        var sh = Shader.Find("Universal Render Pipeline/Lit");
        var m = new Material(sh != null ? sh : Shader.Find("Standard"));
        m.hideFlags = HideFlags.HideAndDontSave;
        m.SetColor("_BaseColor", new Color(0.34f, 0.40f, 0.25f, 1f));
        m.SetFloat("_Smoothness", 0f);
        mr.sharedMaterial = m;
        mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
        mr.receiveShadows = false;
        return go;
    }

    // ═════════════════════════════════════════════════════════════════════════
    //  공통
    // ═════════════════════════════════════════════════════════════════════════
    static void World()
    {
        var bake = AssetDatabase.LoadAssetAtPath<WLSpriteBakeSettings>(kRes + "/WLSpriteBakeSettings.asset");
        RenderSettings.fog = false;
        RenderSettings.skybox = AssetDatabase.GetBuiltinExtraResource<Material>("Default-Skybox.mat");
        RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Skybox;
        RenderSettings.ambientIntensity = 1f;
        DynamicGI.UpdateEnvironment();
        var sun = new GameObject("Sun").AddComponent<Light>();
        sun.type = LightType.Directional; sun.shadows = LightShadows.None;
        sun.color = bake != null ? bake.sunColor : Color.white;
        sun.intensity = bake != null ? bake.sunIntensity : 1.2f;
        sun.transform.rotation = Quaternion.Euler(bake != null ? bake.sunEuler : new Vector3(26.4f, 238.6f, 0f));
        if (bake != null && bake.fillIntensity > 0f)
        {
            var fill = new GameObject("Fill").AddComponent<Light>();
            fill.type = LightType.Directional; fill.shadows = LightShadows.None;
            fill.color = bake.fillColor; fill.intensity = bake.fillIntensity;
            fill.transform.rotation = Quaternion.Euler(bake.fillEuler);
        }
    }

    static GameObject Spawn(string prefabPath, Vector3 pos, float scale)
    {
        var src = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
        if (src == null) return null;
        var go = (GameObject)PrefabUtility.InstantiatePrefab(src);
        PrefabUtility.UnpackPrefabInstance(go, PrefabUnpackMode.Completely, InteractionMode.AutomatedAction);
        go.name = Path.GetFileNameWithoutExtension(prefabPath) + "(Clone)";
        go.transform.position = pos; go.transform.rotation = Quaternion.identity;
        if (scale > 0.0001f) go.transform.localScale = Vector3.one * scale;
        foreach (var c in go.GetComponentsInChildren<Collider>(true)) UnityEngine.Object.DestroyImmediate(c);
        foreach (var c in go.GetComponentsInChildren<UnityEngine.AI.NavMeshAgent>(true)) UnityEngine.Object.DestroyImmediate(c);
        foreach (var c in go.GetComponentsInChildren<Rigidbody>(true)) UnityEngine.Object.DestroyImmediate(c);
        foreach (var c in go.GetComponentsInChildren<ParticleSystem>(true)) UnityEngine.Object.DestroyImmediate(c.gameObject);
        foreach (var mb in go.GetComponentsInChildren<MonoBehaviour>(true)) if (mb != null) UnityEngine.Object.DestroyImmediate(mb);
        foreach (var sm in go.GetComponentsInChildren<SkinnedMeshRenderer>(true))
        { sm.updateWhenOffscreen = true; sm.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; }
        var an = go.GetComponent<Animator>();
        if (an != null) { an.applyRootMotion = false; an.cullingMode = AnimatorCullingMode.AlwaysAnimate; an.Rebind(); }
        // 굽기와 같은 Toon 머티리얼로(같은 조건 비교)
        var bake = AssetDatabase.LoadAssetAtPath<WLSpriteBakeSettings>(kRes + "/WLSpriteBakeSettings.asset");
        if (bake != null && bake.useToonMaterials)
            foreach (var rend in go.GetComponentsInChildren<Renderer>(true))
            {
                if (rend == null || rend is ParticleSystemRenderer) continue;
                var mats = rend.sharedMaterials; bool any = false;
                for (int i = 0; i < mats.Length; i++)
                {
                    if (mats[i] == null) continue;
                    var t = AssetDatabase.LoadAssetAtPath<Material>(bake.toonMaterialDir + "/" + mats[i].name + bake.toonMaterialSuffix + ".mat");
                    if (t != null) { mats[i] = t; any = true; }
                }
                if (any) rend.sharedMaterials = mats;
            }
        return go;
    }

    static void Pose(GameObject go, string state, float nt, float yaw)
    {
        go.transform.rotation = Quaternion.Euler(0f, yaw, 0f);
        var an = go.GetComponent<Animator>();
        if (an == null) return;
        int h = Animator.StringToHash(state);
        if (!an.HasState(0, h)) return;
        an.Play(h, 0, nt);
        an.Update(0f);
    }

    /// <summary>시트가 가진 프레임 f 와 **같은 시각**으로 3D 를 세운다(A/B 를 같은 포즈로 맞추기 위해).</summary>
    static void PoseFrame(GameObject go, WLSpriteLookSettings look, string key, int frame, float yaw)
    {
        var set = SpriteBillboard.MatchSet(go.name, look);
        var a = set != null ? set.FindByKey(key) : null;
        if (a == null) { Pose(go, key, 0f, yaw); return; }
        float nt = a.loop ? (frame + 0.001f) / a.frameCount : (a.frameCount > 1 ? (float)frame / (a.frameCount - 1) : 0f);
        Pose(go, key, nt, yaw);
    }

    static int CountAll(GameObject go) { return go.GetComponentsInChildren<Transform>(true).Length; }

    sealed class CamRig
    {
        public Camera cam; public RenderTexture rt; public Texture2D tex; public int w, h;
        public Color32[] Grab()
        {
            cam.targetTexture = rt; cam.Render(); cam.targetTexture = null;
            var active = RenderTexture.active; RenderTexture.active = rt;
            tex.ReadPixels(new Rect(0, 0, w, h), 0, 0); tex.Apply(false, false);
            RenderTexture.active = active;
            return tex.GetPixels32();
        }
        public void Dispose()
        {
            RenderTexture.active = null;
            if (rt != null) { rt.Release(); UnityEngine.Object.DestroyImmediate(rt); }
            if (tex != null) UnityEngine.Object.DestroyImmediate(tex);
            if (cam != null) UnityEngine.Object.DestroyImmediate(cam.gameObject);
        }
    }

    static CamRig MakeCam(int w, int h)
    {
        var go = new GameObject("[WL814k] CapCam");
        var c = go.AddComponent<Camera>();
        c.orthographic = true;
        c.orthographicSize = h * (2f * kOrtho / kLowH) * 0.5f;
        c.nearClipPlane = 0.01f; c.farClipPlane = 200f;
        c.clearFlags = CameraClearFlags.SolidColor;
        c.backgroundColor = new Color(0.27f, 0.34f, 0.22f, 1f);   // 지면 평면 밖은 이 색(지면이 화면을 덮는다)
        c.allowHDR = false; c.allowMSAA = false; c.useOcclusionCulling = false;
        go.transform.rotation = Quaternion.Euler(kPitch, 0f, 0f);
        go.transform.position = new Vector3(0f, 1.0f, 0f) - go.transform.forward * 40f;
        var rt = new RenderTexture(w, h, 24, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
        rt.filterMode = FilterMode.Point; rt.antiAliasing = 1; rt.Create();
        var tex = new Texture2D(w, h, TextureFormat.RGBA32, false, false);
        return new CamRig { cam = c, rt = rt, tex = tex, w = w, h = h };
    }

    // 저해상도 → Point 확대 저장(도트 모드가 화면에 내보내는 방식 그대로)
    static void SavePoint(Color32[] px, int w, int h, string file, int zoomOverride = 0)
    {
        int zoom = zoomOverride > 0 ? zoomOverride : Mathf.Max(1, kHiH / h);
        int ow = w * zoom, oh = h * zoom;
        var outPx = new Color32[ow * oh];
        for (int y = 0; y < oh; y++)
            for (int x = 0; x < ow; x++)
                outPx[y * ow + x] = px[(y / zoom) * w + (x / zoom)];
        SaveRaw(outPx, ow, oh, file);
    }

    static void SaveRaw(Color32[] px, int w, int h, string file)
    {
        var t = new Texture2D(w, h, TextureFormat.RGBA32, false, false);
        t.SetPixels32(px); t.Apply(false, false);
        File.WriteAllBytes(file, t.EncodeToPNG());
        UnityEngine.Object.DestroyImmediate(t);
    }

    static void BlitInto(Color32[] src, int sw, int sh, Color32[] dst, int dw, int dx, int dy)
    {
        for (int y = 0; y < sh; y++)
            for (int x = 0; x < sw; x++)
            {
                int di = (dy + y) * dw + (dx + x);
                if (di >= 0 && di < dst.Length) dst[di] = src[y * sw + x];
            }
    }
}