638 lines
37 KiB
C#
638 lines
37 KiB
C#
// PD 지시 #814 · 발주서 WL-814b — Critter 픽셀 카메라 리그 검증 프로브 + 룩 캡처
|
||
// (에디트 모드 전용 · Play 0 · 로그인 0 · 디스크 에셋 무수정)
|
||
//
|
||
// 실행 (CLAUDE.md §1: using 금지 · 네임스페이스 풀어 쓰기)
|
||
// unity command run_script --file AgentScripts/WL814b_Probe.cs --entry WL814b_Probe.MakeAsset --timeout 300
|
||
// unity command run_script --file AgentScripts/WL814b_Probe.cs --entry WL814b_Probe.Edit --timeout 1800
|
||
//
|
||
// 무엇을 재는가
|
||
// A. 표 ① 보조 — 원본 Main Camera.prefab 값 · NewGameUI 캔버스 렌더 모드/카메라 · UICamera 스택
|
||
// B. 리그 — 임시 씬(추가 로드 · 저장 0)에 맵 + PC + 잡몹 + 원본 카메라 → 조립 → 구조 표
|
||
// C. 복원 — 원본 카메라 값 스냅샷 == 복원값(문자열 동일) · 리그 오브젝트 0 · RT 해제
|
||
// D. 매핑오차 — Camera.main 투영(WorldToViewportPoint) vs 실제 RT→쿼드→뷰 카메라 화면 좌표(5점 · px)
|
||
// E. GC — 프록시 미러 · 회전 스냅 판정 200k 회 할당 증가분(0 B 목표)
|
||
// F. C8 — RuntimeDisabled = true → Tick 이 즉시 복원 · 조립 0
|
||
// G. 캡처 — 1080×1920 4장(ortho 3.8×480 · 3.8×360 · 4.6×480 · 대조 원근 원본)
|
||
public static class WL814b_Probe
|
||
{
|
||
const string kOutDir = @"E:\NerdNavis\nn_himminji\Screenshots_WL\WL814b";
|
||
const string kMap = "Assets/Res_Addr/Map/WL_Nature.prefab";
|
||
const string kPc = "Assets/Res_Addr/PC/Ai01.prefab";
|
||
const string kCam = "Assets/ResWork/Prefabs/Ingame/Main Camera.prefab";
|
||
const string kRig = "Assets/3DPixelCamera/URP/PixelCameraSystem.prefab";
|
||
const string kSo = "Assets/WL/Combat/Settings/Resources/WL/WLPixelCameraSettings.asset";
|
||
const string kSnap = "AgentScripts/staging/WL814b/EDIT_PROBE.txt";
|
||
|
||
const int W = 1080, H = 1920;
|
||
|
||
static System.Text.StringBuilder sb;
|
||
static int pass, fail;
|
||
static UnityEngine.Vector3 s_lookAtWorld;
|
||
|
||
static void L(string s) { sb.Append(s).Append('\n'); }
|
||
static void Chk(bool ok, string label, string detail)
|
||
{
|
||
if (ok) pass++; else fail++;
|
||
sb.Append(ok ? " PASS " : " FAIL ").Append(label);
|
||
if (!string.IsNullOrEmpty(detail)) sb.Append(" ").Append(detail);
|
||
sb.Append('\n');
|
||
}
|
||
|
||
// ─────────────────────────────────────────────────────────────────────────
|
||
// SO 에셋 생성 (1회) — 손으로 YAML 쓰지 않고 에디터가 만들게 한다
|
||
// ─────────────────────────────────────────────────────────────────────────
|
||
public static string MakeAsset()
|
||
{
|
||
sb = new System.Text.StringBuilder();
|
||
var dir = System.IO.Path.GetDirectoryName(kSo).Replace('\\', '/');
|
||
if (!System.IO.Directory.Exists(dir)) { L("FAIL 폴더 없음 " + dir); return sb.ToString(); }
|
||
|
||
var so = UnityEditor.AssetDatabase.LoadAssetAtPath<WL.PixelArt.WLPixelCameraSettings>(kSo);
|
||
bool created = false;
|
||
if (so == null)
|
||
{
|
||
so = UnityEngine.ScriptableObject.CreateInstance<WL.PixelArt.WLPixelCameraSettings>();
|
||
UnityEditor.AssetDatabase.CreateAsset(so, kSo);
|
||
created = true;
|
||
}
|
||
|
||
var rig = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.GameObject>(kRig);
|
||
so.pixelCameraSystemPrefab = rig;
|
||
UnityEditor.EditorUtility.SetDirty(so);
|
||
UnityEditor.AssetDatabase.SaveAssets();
|
||
UnityEditor.AssetDatabase.Refresh();
|
||
|
||
L((created ? "생성" : "갱신") + " " + kSo);
|
||
L(" prefab=" + (rig == null ? "null(패키지 해제 확인)" : UnityEditor.AssetDatabase.GetAssetPath(rig)));
|
||
L(" guid=" + UnityEditor.AssetDatabase.AssetPathToGUID(kSo));
|
||
L(" enabled=" + so.enabled + " orthoSize=" + so.orthoSize + " pixelHeight=" + so.pixelHeight
|
||
+ " rigLayer=" + so.rigLayer + " proxyMode=" + so.proxyMode
|
||
+ " compensateViewZoom=" + so.compensateViewZoom);
|
||
return sb.ToString();
|
||
}
|
||
|
||
// ─────────────────────────────────────────────────────────────────────────
|
||
// 본 프로브
|
||
// ─────────────────────────────────────────────────────────────────────────
|
||
public static string Edit()
|
||
{
|
||
sb = new System.Text.StringBuilder();
|
||
pass = fail = 0;
|
||
System.IO.Directory.CreateDirectory(kOutDir);
|
||
|
||
L("# WL-814b 프로브 — " + System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
|
||
L("unity=" + UnityEngine.Application.unityVersion + " · isPlaying=" + UnityEngine.Application.isPlaying);
|
||
|
||
SectionA();
|
||
|
||
// 배치모드 에디터의 현재(무제목·빈) 씬에 직접 짓는다 — 추가 씬 생성은 무제목 씬이 열려 있으면 금지된다.
|
||
// 모든 인스턴스는 HideAndDontSave + DestroyImmediate 이므로 씬에 남지도, 저장되지도 않는다(811o 방식).
|
||
var scene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
|
||
L("현재 씬 = '" + scene.name + "' path='" + scene.path + "' dirty(before)=" + scene.isDirty
|
||
+ " rootCount=" + scene.rootCount);
|
||
|
||
UnityEngine.GameObject mapGo = null, pcGo = null, camGo = null, lightGo = null;
|
||
var mobs = new System.Collections.Generic.List<UnityEngine.GameObject>();
|
||
try
|
||
{
|
||
BuildScene(ref mapGo, ref pcGo, ref camGo, ref lightGo, mobs);
|
||
if (camGo == null) { L("FAIL 카메라 인스턴스 실패 — 중단"); }
|
||
else
|
||
{
|
||
var cam = camGo.GetComponent<UnityEngine.Camera>();
|
||
SectionBCD(cam, pcGo);
|
||
SectionE(cam);
|
||
SectionF(cam);
|
||
SectionG(cam);
|
||
}
|
||
}
|
||
catch (System.Exception ex) { L("EXCEPTION " + ex.GetType().Name + " " + ex.Message); L(ex.StackTrace); fail++; }
|
||
finally
|
||
{
|
||
WL.PixelArt.PixelCameraRig.Teardown("probe end");
|
||
WL.PixelArt.WLPixelCameraSettings.RuntimeDisabled = false;
|
||
for (int i = 0; i < mobs.Count; i++) if (mobs[i] != null) UnityEngine.Object.DestroyImmediate(mobs[i]);
|
||
if (pcGo != null) UnityEngine.Object.DestroyImmediate(pcGo);
|
||
if (camGo != null) UnityEngine.Object.DestroyImmediate(camGo);
|
||
if (mapGo != null) UnityEngine.Object.DestroyImmediate(mapGo);
|
||
if (lightGo != null) UnityEngine.Object.DestroyImmediate(lightGo);
|
||
var after = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
|
||
L("씬 정리 후: dirty=" + after.isDirty + " rootCount=" + after.rootCount + " (저장 0)");
|
||
}
|
||
|
||
L("");
|
||
L("RESULT " + (fail == 0 ? "PASS" : "FAIL") + " " + pass + "/" + (pass + fail));
|
||
var outPath = kSnap;
|
||
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(outPath));
|
||
System.IO.File.WriteAllText(outPath, sb.ToString(), new System.Text.UTF8Encoding(false));
|
||
return sb.ToString();
|
||
}
|
||
|
||
// ── A. 표 ① 보조 실측 ────────────────────────────────────────────────────
|
||
static void SectionA()
|
||
{
|
||
L("");
|
||
L("## A. 원본 카메라 · UI 캔버스 실측");
|
||
var camPf = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.GameObject>(kCam);
|
||
if (camPf == null) { L("FAIL Main Camera.prefab 로드 실패"); fail++; return; }
|
||
var c = camPf.GetComponent<UnityEngine.Camera>();
|
||
var rc = camPf.GetComponent("RealCamera");
|
||
var al = camPf.GetComponent<UnityEngine.AudioListener>();
|
||
var mrv = camPf.GetComponent("MeshRendererVisibility");
|
||
var ucd = camPf.GetComponent<UnityEngine.Rendering.Universal.UniversalAdditionalCameraData>();
|
||
L("Main Camera.prefab: tag=" + camPf.tag + " layer=" + camPf.layer + " parent=" + (camPf.transform.parent == null ? "none" : camPf.transform.parent.name)
|
||
+ " children=" + camPf.transform.childCount);
|
||
L(" Camera: ortho=" + c.orthographic + " fov=" + c.fieldOfView + " size=" + c.orthographicSize
|
||
+ " near=" + c.nearClipPlane + " far=" + c.farClipPlane + " depth=" + c.depth
|
||
+ " mask=" + c.cullingMask + " clear=" + c.clearFlags + " hdr=" + c.allowHDR + " msaa=" + c.allowMSAA
|
||
+ " occlusionCulling=" + c.useOcclusionCulling);
|
||
if (ucd != null)
|
||
L(" URP: type=" + ucd.renderType + " post=" + ucd.renderPostProcessing + " shadows=" + ucd.renderShadows
|
||
+ " volumeMask=" + ucd.volumeLayerMask.value + " aa=" + ucd.antialiasing
|
||
+ " stack=" + (ucd.cameraStack == null ? -1 : ucd.cameraStack.Count));
|
||
L(" 컴포넌트: RealCamera=" + (rc != null) + " AudioListener=" + (al != null) + " MeshRendererVisibility=" + (mrv != null));
|
||
Chk(rc != null && al != null, "원본 카메라 = RealCamera + AudioListener 보유(재부모화·비활성 금지 근거)", "");
|
||
|
||
var uiPf = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.GameObject>("Assets/Res_Addr/MainUI/NewGameUI.prefab");
|
||
if (uiPf != null)
|
||
{
|
||
var canvases = uiPf.GetComponentsInChildren<UnityEngine.Canvas>(true);
|
||
L("NewGameUI.prefab 캔버스 " + canvases.Length + "개");
|
||
for (int i = 0; i < canvases.Length; i++)
|
||
{
|
||
var cv = canvases[i];
|
||
L(" [" + i + "] " + cv.name + " renderMode=" + cv.renderMode
|
||
+ " worldCamera=" + (cv.worldCamera == null ? "null" : cv.worldCamera.name)
|
||
+ " planeDistance=" + cv.planeDistance + " sortingOrder=" + cv.sortingOrder + " layer=" + cv.gameObject.layer);
|
||
}
|
||
var cams = uiPf.GetComponentsInChildren<UnityEngine.Camera>(true);
|
||
for (int i = 0; i < cams.Length; i++)
|
||
L(" UI camera: " + cams[i].name + " ortho=" + cams[i].orthographic + " depth=" + cams[i].depth
|
||
+ " mask=" + cams[i].cullingMask + " clear=" + cams[i].clearFlags);
|
||
bool ssc = false;
|
||
for (int i = 0; i < canvases.Length; i++) if (canvases[i].renderMode == UnityEngine.RenderMode.ScreenSpaceCamera) ssc = true;
|
||
Chk(ssc, "인게임 UI 캔버스 = Screen Space - Camera(UICamera) → 원본 카메라를 끄면 UI 가 사라진다", "");
|
||
}
|
||
else { L("FAIL NewGameUI.prefab 로드 실패"); fail++; }
|
||
}
|
||
|
||
// ── 씬 조립 ──────────────────────────────────────────────────────────────
|
||
static void BuildScene(ref UnityEngine.GameObject mapGo, ref UnityEngine.GameObject pcGo,
|
||
ref UnityEngine.GameObject camGo, ref UnityEngine.GameObject lightGo,
|
||
System.Collections.Generic.List<UnityEngine.GameObject> mobs)
|
||
{
|
||
L("");
|
||
L("## B. 임시 씬(추가 로드 · 저장 0)");
|
||
|
||
var mapPf = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.GameObject>(kMap);
|
||
if (mapPf != null) { mapGo = UnityEngine.Object.Instantiate(mapPf); mapGo.name = "__WL814b_Map"; mapGo.hideFlags = UnityEngine.HideFlags.HideAndDontSave; }
|
||
L("맵 " + (mapGo == null ? "실패" : mapGo.name + " renderers=" + mapGo.GetComponentsInChildren<UnityEngine.Renderer>(true).Length));
|
||
|
||
// 지면 y 찾기 + 소품이 가장 많은 앵커 고르기(룩 캡처라 배경이 비어 있으면 안 된다)
|
||
UnityEngine.Physics.SyncTransforms();
|
||
var rends = mapGo == null ? new UnityEngine.Renderer[0] : mapGo.GetComponentsInChildren<UnityEngine.Renderer>(true);
|
||
// 소품이 실제로 모여 있는 곳을 찾는다 — 소품 중심들 중 반경 10 m 이웃이 가장 많은 지점
|
||
var cands = new System.Collections.Generic.List<UnityEngine.Vector3>();
|
||
for (int r = 0; r < rends.Length; r++)
|
||
{
|
||
if (rends[r] == null) continue;
|
||
var b = rends[r].bounds;
|
||
if (b.size.y < 1.0f || b.size.y > 20f) continue; // 지형/바닥/거대 오브젝트 제외
|
||
if (b.center.y > 6f) continue; // 언덕 위·공중 제외
|
||
cands.Add(b.center);
|
||
}
|
||
UnityEngine.Vector3 pcPos = new UnityEngine.Vector3(139f, 0.8f, -20f);
|
||
int bestCount = -1;
|
||
for (int i = 0; i < cands.Count; i++)
|
||
{
|
||
int n = 0;
|
||
for (int j = 0; j < cands.Count; j++)
|
||
if ((cands[j] - cands[i]).sqrMagnitude < 100f) n++; // 반경 10 m
|
||
if (n > bestCount) { bestCount = n; pcPos = cands[i]; }
|
||
}
|
||
string bestHit = "미검출";
|
||
UnityEngine.RaycastHit gh;
|
||
if (UnityEngine.Physics.Raycast(new UnityEngine.Vector3(pcPos.x, pcPos.y + 100f, pcPos.z), UnityEngine.Vector3.down, out gh, 400f))
|
||
{ pcPos.y = gh.point.y; bestHit = gh.collider.name; }
|
||
L(" 소품 후보 " + cands.Count + "개 · 가장 밀집한 지점 반경 10 m 이웃 " + bestCount + "개");
|
||
L("PC 위치 " + pcPos.ToString("F2") + " · 반경 10 m 소품 " + bestCount + "개 (지면 " + bestHit + ")");
|
||
|
||
var pcPf = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.GameObject>(kPc);
|
||
if (pcPf != null)
|
||
{
|
||
pcGo = UnityEngine.Object.Instantiate(pcPf);
|
||
pcGo.name = "__WL814b_PC";
|
||
pcGo.hideFlags = UnityEngine.HideFlags.HideAndDontSave;
|
||
pcGo.transform.position = pcPos;
|
||
pcGo.transform.rotation = UnityEngine.Quaternion.Euler(0f, 200f, 0f);
|
||
StripBehaviours(pcGo);
|
||
L("PC 포즈: " + PoseIdle(pcGo));
|
||
}
|
||
L("PC " + (pcGo == null ? "실패" : "ok"));
|
||
|
||
// 잡몹 3
|
||
string[] mobPaths = {
|
||
"Assets/Res_Addr/Mobs/Mob/Anto_A.prefab",
|
||
"Assets/Res_Addr/Mobs/Mob/Anto_B.prefab",
|
||
"Assets/Res_Addr/Mobs/Mob/Angez_A.prefab",
|
||
};
|
||
UnityEngine.Vector3[] mobOff = {
|
||
new UnityEngine.Vector3(2.2f, 0f, 1.6f),
|
||
new UnityEngine.Vector3(-2.4f, 0f, 0.8f),
|
||
new UnityEngine.Vector3(0.2f, 0f, 3.0f),
|
||
};
|
||
for (int i = 0; i < mobPaths.Length; i++)
|
||
{
|
||
var pf = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.GameObject>(mobPaths[i]);
|
||
if (pf == null) continue;
|
||
var g = UnityEngine.Object.Instantiate(pf);
|
||
g.name = "__WL814b_Mob" + i;
|
||
g.hideFlags = UnityEngine.HideFlags.HideAndDontSave;
|
||
var p = pcPos + mobOff[i];
|
||
UnityEngine.RaycastHit mh;
|
||
if (UnityEngine.Physics.Raycast(new UnityEngine.Vector3(p.x, 200f, p.z), UnityEngine.Vector3.down, out mh, 500f)) p.y = mh.point.y;
|
||
g.transform.position = p;
|
||
g.transform.rotation = UnityEngine.Quaternion.Euler(0f, 20f + i * 90f, 0f);
|
||
StripBehaviours(g);
|
||
PoseIdle(g);
|
||
mobs.Add(g);
|
||
}
|
||
L("잡몹 " + mobs.Count + "체");
|
||
|
||
lightGo = new UnityEngine.GameObject("__WL814b_Sun");
|
||
lightGo.hideFlags = UnityEngine.HideFlags.HideAndDontSave;
|
||
var lt = lightGo.AddComponent<UnityEngine.Light>();
|
||
lt.type = UnityEngine.LightType.Directional;
|
||
lt.intensity = 1.1f;
|
||
lt.color = new UnityEngine.Color(1f, 0.97f, 0.92f);
|
||
lightGo.transform.rotation = UnityEngine.Quaternion.Euler(48f, 35f, 0f);
|
||
|
||
// 원본 카메라 인스턴스 — 811o 구도(h 76 · d 3.0 · up 2.4)를 RealCamera 수식으로 직접 계산
|
||
var camPf = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.GameObject>(kCam);
|
||
if (camPf == null) return;
|
||
camGo = UnityEngine.Object.Instantiate(camPf);
|
||
camGo.name = "__WL814b_MainCamera";
|
||
camGo.hideFlags = UnityEngine.HideFlags.HideAndDontSave;
|
||
StripBehaviours(camGo); // RealCamera·MeshRendererVisibility 정지(트랜스폼은 우리가 잡는다)
|
||
var cam = camGo.GetComponent<UnityEngine.Camera>();
|
||
cam.aspect = (float)W / H;
|
||
|
||
const float camHeight = 76f, rotateAround = 347.21f, distanceAway = 3.0f, distanceUp = 2.4f;
|
||
var lookAt = new UnityEngine.Vector3(0f, 1.06f, 0f);
|
||
var rotv = UnityEngine.Quaternion.Euler(camHeight, rotateAround, 0f) * UnityEngine.Vector3.one;
|
||
var camPosition = pcPos + UnityEngine.Vector3.up * distanceUp - rotv * distanceAway;
|
||
camGo.transform.position = camPosition;
|
||
s_lookAtWorld = pcPos + lookAt;
|
||
camGo.transform.LookAt(s_lookAtWorld);
|
||
float dist = UnityEngine.Vector3.Distance(camPosition, pcPos + lookAt);
|
||
L("카메라(811o 구도) pos=" + camPosition.ToString("F3") + " euler=" + camGo.transform.eulerAngles.ToString("F2"));
|
||
L(" PC 주시점까지 거리 = " + dist.ToString("F3") + " m → 원근 fov 60 의 반높이 = " + (dist * UnityEngine.Mathf.Tan(30f * UnityEngine.Mathf.Deg2Rad)).ToString("F3") + " m");
|
||
}
|
||
|
||
/// <summary>에디트 모드에서는 Animator 가 돌지 않아 T 포즈가 된다 → idle 클립을 1프레임 샘플링한다.</summary>
|
||
static string PoseIdle(UnityEngine.GameObject go)
|
||
{
|
||
var anim = go.GetComponentInChildren<UnityEngine.Animator>(true);
|
||
if (anim == null || anim.runtimeAnimatorController == null) return "Animator 없음(T 포즈)";
|
||
var clips = anim.runtimeAnimatorController.animationClips;
|
||
if (clips == null || clips.Length == 0) return "클립 0(T 포즈)";
|
||
UnityEngine.AnimationClip pick = null;
|
||
for (int i = 0; i < clips.Length; i++)
|
||
{
|
||
if (clips[i] == null) continue;
|
||
var n = clips[i].name.ToLower();
|
||
if (n.Contains("idle") || n.Contains("wait") || n.Contains("stand")) { pick = clips[i]; break; }
|
||
}
|
||
if (pick == null) pick = clips[0];
|
||
pick.SampleAnimation(anim.gameObject, 0.4f);
|
||
return pick.name + " @0.4s (" + clips.Length + "클립)";
|
||
}
|
||
|
||
/// <summary>임시 씬에서 원본 로직이 돌지 않게 MonoBehaviour 를 전부 끈다(에셋 무변경 · 인스턴스만).</summary>
|
||
static void StripBehaviours(UnityEngine.GameObject go)
|
||
{
|
||
var all = go.GetComponentsInChildren<UnityEngine.MonoBehaviour>(true);
|
||
for (int i = 0; i < all.Length; i++)
|
||
{
|
||
if (all[i] == null) continue;
|
||
if (all[i] is UnityEngine.Rendering.Universal.UniversalAdditionalCameraData) continue;
|
||
try { all[i].enabled = false; } catch { }
|
||
}
|
||
}
|
||
|
||
// ── B/C/D. 조립 · 복원 · 매핑 오차 ──────────────────────────────────────
|
||
static void SectionBCD(UnityEngine.Camera cam, UnityEngine.GameObject pcGo)
|
||
{
|
||
L("");
|
||
L("## B. 리그 조립");
|
||
var cfg = MakeCfg(3.8f, 480, false);
|
||
if (cfg == null) { L("FAIL SO/프리팹 없음 — 중단"); fail++; return; }
|
||
|
||
string before = WL.PixelArt.PixelCameraRig.CurrentSummary(cam);
|
||
int origMask = cam.cullingMask;
|
||
L("조립 전 원본 카메라: " + before);
|
||
|
||
bool ok = WL.PixelArt.PixelCameraRig.Assemble(cfg, cam);
|
||
Chk(ok && WL.PixelArt.PixelCameraRig.IsAssembled, "조립 성공", WL.PixelArt.PixelCameraRig.LastLog);
|
||
if (!ok) return;
|
||
|
||
var rig = WL.PixelArt.PixelCameraRig.RigRoot;
|
||
var gameCam = WL.PixelArt.PixelCameraRig.GameCamera;
|
||
var viewCam = WL.PixelArt.PixelCameraRig.ViewCamera;
|
||
var mgr = WL.PixelArt.PixelCameraRig.Manager;
|
||
var proxy = WL.PixelArt.PixelCameraRig.Proxy;
|
||
|
||
L("리그 구조:");
|
||
Dump(rig.transform, 1);
|
||
L("프록시: " + (proxy == null ? "null" : proxy.name + " parent=" + (proxy.parent == null ? "none" : proxy.parent.name)
|
||
+ " worldPos=" + proxy.position.ToString("F4") + " camPos=" + cam.transform.position.ToString("F4")));
|
||
Chk(proxy != null && (proxy.position - cam.transform.position).sqrMagnitude < 1e-8f,
|
||
"프록시 월드 위치 == 원본 카메라 위치(지연 0)", "");
|
||
Chk(proxy != null && UnityEngine.Quaternion.Angle(proxy.rotation, cam.transform.rotation) < 1e-3f,
|
||
"프록시 회전 == 원본 카메라 회전", "");
|
||
|
||
string after = WL.PixelArt.PixelCameraRig.CurrentSummary(cam);
|
||
L("조립 후 원본 카메라: " + after);
|
||
Chk(cam.orthographic, "원본 카메라 직교 전환", "size=" + cam.orthographicSize);
|
||
Chk(cam.cullingMask == 0, "원본 카메라 월드 미렌더(cullingMask 0)", "mask=" + cam.cullingMask);
|
||
Chk(cam.tag == "MainCamera" && cam.enabled, "MainCamera 태그·enabled 유지(Camera.main 보존)", "tag=" + cam.tag);
|
||
|
||
// Critter 를 1프레임 강제로 돌린다(에디트 모드에는 LateUpdate 가 안 올 수 있다)
|
||
viewCam.aspect = (float)W / H;
|
||
mgr.SendMessage("LateUpdate", UnityEngine.SendMessageOptions.DontRequireReceiver);
|
||
|
||
var rt = gameCam.targetTexture;
|
||
L("게임 카메라: ortho=" + gameCam.orthographic + " size=" + gameCam.orthographicSize.ToString("F4")
|
||
+ " mask=" + gameCam.cullingMask + " depth=" + gameCam.depth
|
||
+ " RT=" + (rt == null ? "null" : rt.width + "×" + rt.height + " filter=" + rt.filterMode + " fmt=" + rt.format));
|
||
L("뷰 카메라: ortho=" + viewCam.orthographic + " size=" + viewCam.orthographicSize.ToString("F4")
|
||
+ " mask=" + viewCam.cullingMask + " near=" + viewCam.nearClipPlane + " far=" + viewCam.farClipPlane
|
||
+ " localPos=" + viewCam.transform.localPosition.ToString("F5"));
|
||
L("Critter: GameResolution=" + mgr.GameResolution + " zoom=" + mgr.GameCameraZoom.ToString("F5")
|
||
+ " viewZoom=" + mgr.ViewCameraZoom + " grid=" + mgr.VoxelGridMovement + " sub=" + mgr.SubpixelAdjustments
|
||
+ " followRot=" + mgr.FollowRotation);
|
||
Chk(rt != null && rt.height == 480 && rt.filterMode == UnityEngine.FilterMode.Point,
|
||
"저해상도 RT 480줄 · 포인트 필터", rt == null ? "null" : rt.width + "×" + rt.height);
|
||
Chk(gameCam.cullingMask == (origMask & ~(1 << cfg.rigLayer)),
|
||
"게임 카메라 = 원본 cullingMask 승계", "orig=" + origMask + " game=" + gameCam.cullingMask);
|
||
Chk((gameCam.cullingMask & (1 << cfg.rigLayer)) == 0, "게임 카메라가 픽셀 쿼드를 다시 그리지 않는다(리그 레이어 제외)", "");
|
||
Chk(viewCam.cullingMask == (1 << cfg.rigLayer), "뷰 카메라는 픽셀 쿼드만 그린다", "mask=" + viewCam.cullingMask);
|
||
|
||
// ── D. 매핑 오차
|
||
L("");
|
||
L("## D. 매핑 오차 — Camera.main 투영 vs 실제 화면(1080×1920 · px)");
|
||
MappingTable(cam, gameCam, viewCam, mgr, pcGo);
|
||
|
||
// ── C. 복원
|
||
L("");
|
||
L("## C. 복원");
|
||
var rtRef = gameCam.targetTexture;
|
||
WL.PixelArt.PixelCameraRig.Teardown("probe C");
|
||
string restored = WL.PixelArt.PixelCameraRig.CurrentSummary(cam);
|
||
L("복원 후 원본 카메라: " + restored);
|
||
Chk(restored == before, "원본 카메라 값 스냅샷 == 복원값(문자열 완전 일치)", restored == before ? "" : "\n before=" + before + "\n after =" + restored);
|
||
Chk(!WL.PixelArt.PixelCameraRig.IsAssembled, "리그 오브젝트 0", "");
|
||
Chk(rtRef == null, "RT 참조 해제(Release + Destroy)", "rt=" + (rtRef == null ? "null" : "alive"));
|
||
int strays = 0;
|
||
var left = UnityEngine.Object.FindObjectsByType<PixelCamera.PixelCameraManager>(UnityEngine.FindObjectsInactive.Include, UnityEngine.FindObjectsSortMode.None);
|
||
strays = left == null ? 0 : left.Length;
|
||
Chk(strays == 0, "씬에 PixelCameraManager 잔재 0", "found=" + strays);
|
||
int proxyLeft = 0;
|
||
for (int i = 0; i < cam.transform.childCount; i++) if (cam.transform.GetChild(i).name == WL.PixelArt.PixelCameraRig.ProxyName) proxyLeft++;
|
||
Chk(proxyLeft == 0, "원본 카메라 자식 프록시 0", "found=" + proxyLeft);
|
||
|
||
var mat = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.Material>("Assets/3DPixelCamera/URP/UpscaleMaterialURP.mat");
|
||
bool matClean = mat == null || !mat.HasProperty("_LowResTexture") || mat.GetTexture("_LowResTexture") == null;
|
||
Chk(matClean, "디스크 UpscaleMaterialURP.mat 의 _LowResTexture 오염 0(런타임 인스턴스 사용)",
|
||
mat == null ? "mat=null" : ("tex=" + (mat.GetTexture("_LowResTexture") == null ? "null" : mat.GetTexture("_LowResTexture").name)));
|
||
}
|
||
|
||
static void MappingTable(UnityEngine.Camera src, UnityEngine.Camera gameCam, UnityEngine.Camera viewCam,
|
||
PixelCamera.PixelCameraManager mgr, UnityEngine.GameObject pcGo)
|
||
{
|
||
var quad = FindQuad();
|
||
if (quad == null) { L("FAIL 픽셀 쿼드를 못 찾음"); fail++; return; }
|
||
var rt = gameCam.targetTexture;
|
||
if (rt == null) { L("FAIL RT 없음"); fail++; return; }
|
||
|
||
var basePos = pcGo != null ? pcGo.transform.position : src.transform.position + src.transform.forward * 6f;
|
||
var pts = new UnityEngine.Vector3[]
|
||
{
|
||
basePos,
|
||
basePos + new UnityEngine.Vector3(0f, 1.7f, 0f),
|
||
basePos + new UnityEngine.Vector3(1.8f, 0.2f, 1.4f),
|
||
basePos + new UnityEngine.Vector3(-2.1f, 1.0f, 1.0f),
|
||
basePos + new UnityEngine.Vector3(0.4f, 0.6f, 2.6f),
|
||
};
|
||
|
||
L(" # | world | Camera.main px | 실제 화면 px | 오차 px | RT양자화 포함 오차 px");
|
||
float maxErr = 0f, maxErrQ = 0f, sumErr = 0f, sumErrQ = 0f;
|
||
for (int i = 0; i < pts.Length; i++)
|
||
{
|
||
var p = pts[i];
|
||
var vSrc = src.WorldToViewportPoint(p);
|
||
var expect = new UnityEngine.Vector2(vSrc.x * W, vSrc.y * H);
|
||
|
||
var vGame = gameCam.WorldToViewportPoint(p);
|
||
var actual = ViewportToScreen(vGame.x, vGame.y, quad, viewCam);
|
||
|
||
float qx = (UnityEngine.Mathf.Floor(vGame.x * rt.width) + 0.5f) / rt.width;
|
||
float qy = (UnityEngine.Mathf.Floor(vGame.y * rt.height) + 0.5f) / rt.height;
|
||
var actualQ = ViewportToScreen(qx, qy, quad, viewCam);
|
||
|
||
float e = UnityEngine.Vector2.Distance(expect, actual);
|
||
float eq = UnityEngine.Vector2.Distance(expect, actualQ);
|
||
maxErr = UnityEngine.Mathf.Max(maxErr, e); maxErrQ = UnityEngine.Mathf.Max(maxErrQ, eq);
|
||
sumErr += e; sumErrQ += eq;
|
||
L(" " + (i + 1) + " | " + p.ToString("F2")
|
||
+ " | (" + expect.x.ToString("F1") + "," + expect.y.ToString("F1") + ")"
|
||
+ " | (" + actual.x.ToString("F1") + "," + actual.y.ToString("F1") + ")"
|
||
+ " | " + e.ToString("F2")
|
||
+ " | " + eq.ToString("F2"));
|
||
}
|
||
L(" 최대 " + maxErr.ToString("F2") + " px · 평균 " + (sumErr / pts.Length).ToString("F2")
|
||
+ " px (연속) / 최대 " + maxErrQ.ToString("F2") + " px · 평균 " + (sumErrQ / pts.Length).ToString("F2") + " px (RT 양자화 포함)");
|
||
L(" 참고: 1 RT 픽셀 = 화면 " + ((float)H / rt.height).ToString("F2") + " px(세로) · " + ((float)W / rt.width).ToString("F2") + " px(가로)");
|
||
Chk(maxErr <= 2.0f, "연속 매핑 오차 ≤ 2 px (compensateViewZoom 보정 확인)", "max=" + maxErr.ToString("F2") + " px");
|
||
Chk(maxErrQ <= (float)H / rt.height, "RT 양자화 포함 오차 ≤ 업스케일 1픽셀", "max=" + maxErrQ.ToString("F2") + " px");
|
||
}
|
||
|
||
static UnityEngine.Vector2 ViewportToScreen(float vx, float vy, UnityEngine.Transform quad, UnityEngine.Camera viewCam)
|
||
{
|
||
var quadLocal = new UnityEngine.Vector3(vx - 0.5f, vy - 0.5f, 0f);
|
||
var quadWorld = quad.TransformPoint(quadLocal);
|
||
var vView = viewCam.WorldToViewportPoint(quadWorld);
|
||
return new UnityEngine.Vector2(vView.x * W, vView.y * H);
|
||
}
|
||
|
||
static UnityEngine.Transform FindQuad()
|
||
{
|
||
var rig = WL.PixelArt.PixelCameraRig.RigRoot;
|
||
if (rig == null) return null;
|
||
var uc = rig.GetComponentInChildren<PixelCamera.UpscaledCanvas>(true);
|
||
return uc == null ? null : uc.transform;
|
||
}
|
||
|
||
static void Dump(UnityEngine.Transform t, int depth)
|
||
{
|
||
var line = new System.Text.StringBuilder();
|
||
line.Append(' ', depth * 2).Append("- ").Append(t.name).Append(" layer=").Append(t.gameObject.layer);
|
||
var comps = t.GetComponents<UnityEngine.Component>();
|
||
line.Append(" [");
|
||
for (int i = 0; i < comps.Length; i++) if (comps[i] != null) line.Append(comps[i].GetType().Name).Append(' ');
|
||
line.Append("]");
|
||
line.Append(" lp=").Append(t.localPosition.ToString("F4")).Append(" ls=").Append(t.localScale.ToString("F4"));
|
||
L(line.ToString());
|
||
for (int i = 0; i < t.childCount; i++) Dump(t.GetChild(i), depth + 1);
|
||
}
|
||
|
||
// ── E. GC ────────────────────────────────────────────────────────────────
|
||
static void SectionE(UnityEngine.Camera cam)
|
||
{
|
||
L("");
|
||
L("## E. GC (200k 회)");
|
||
var probeGo = new UnityEngine.GameObject("__WL814b_MirrorProbe");
|
||
probeGo.hideFlags = UnityEngine.HideFlags.HideAndDontSave;
|
||
var mirror = probeGo.AddComponent<WL.PixelArt.PixelCameraProxyMirror>();
|
||
mirror.Source = cam.transform;
|
||
|
||
System.GC.Collect();
|
||
long m0 = System.GC.GetAllocatedBytesForCurrentThread();
|
||
long t0 = System.GC.GetTotalMemory(false);
|
||
int g0 = System.GC.CollectionCount(0);
|
||
for (int i = 0; i < 200000; i++) mirror.Mirror();
|
||
long m1 = System.GC.GetAllocatedBytesForCurrentThread();
|
||
long t1 = System.GC.GetTotalMemory(false);
|
||
int g1 = System.GC.CollectionCount(0);
|
||
L("프록시 미러 ×200k: thread Δ" + (m1 - m0) + " B · total Δ" + (t1 - t0) + " B · gen0 " + (g1 - g0));
|
||
Chk(m1 - m0 == 0, "프록시 미러 GC 0 B", "Δ=" + (m1 - m0));
|
||
UnityEngine.Object.DestroyImmediate(probeGo);
|
||
|
||
var cfg = MakeCfg(3.8f, 480, false);
|
||
WL.PixelArt.PixelCameraRig.Assemble(cfg, cam);
|
||
System.GC.Collect();
|
||
long s0 = System.GC.GetAllocatedBytesForCurrentThread();
|
||
for (int i = 0; i < 200000; i++) WL.PixelArt.PixelCameraRig.ProbeSnapTick();
|
||
long s1 = System.GC.GetAllocatedBytesForCurrentThread();
|
||
L("회전 스냅 판정 ×200k: thread Δ" + (s1 - s0) + " B");
|
||
Chk(s1 - s0 == 0, "회전 스냅 판정 GC 0 B", "Δ=" + (s1 - s0));
|
||
WL.PixelArt.PixelCameraRig.Teardown("probe E");
|
||
}
|
||
|
||
// ── F. C8 ────────────────────────────────────────────────────────────────
|
||
static void SectionF(UnityEngine.Camera cam)
|
||
{
|
||
L("");
|
||
L("## F. C8 롤백");
|
||
var so = WL.PixelArt.WLPixelCameraSettings.Instance;
|
||
Chk(so != null, "SO 로드(Resources/WL/WLPixelCameraSettings)", so == null ? "null" : "enabled=" + so.enabled);
|
||
|
||
string before = WL.PixelArt.PixelCameraRig.CurrentSummary(cam);
|
||
var cfg = MakeCfg(3.8f, 480, false);
|
||
WL.PixelArt.PixelCameraRig.Assemble(cfg, cam);
|
||
Chk(WL.PixelArt.PixelCameraRig.IsAssembled, "조립됨(C8 전)", "");
|
||
|
||
WL.PixelArt.WLPixelCameraSettings.RuntimeDisabled = true;
|
||
Chk(!WL.PixelArt.WLPixelCameraSettings.Enabled, "RuntimeDisabled → Enabled=false", "");
|
||
WL.PixelArt.PixelCameraRig.Tick(); // Active=false → 즉시 Teardown
|
||
Chk(!WL.PixelArt.PixelCameraRig.IsAssembled, "Tick 1회에 리그 해체", "");
|
||
string after = WL.PixelArt.PixelCameraRig.CurrentSummary(cam);
|
||
Chk(after == before, "C8 복원값 == 원값", after == before ? "" : "\n before=" + before + "\n after =" + after);
|
||
|
||
WL.PixelArt.PixelCameraRig.Tick(); // 재호출해도 조립 0
|
||
Chk(!WL.PixelArt.PixelCameraRig.IsAssembled, "C8 상태에서 재조립 0", "");
|
||
WL.PixelArt.WLPixelCameraSettings.RuntimeDisabled = false;
|
||
}
|
||
|
||
// ── G. 캡처 ──────────────────────────────────────────────────────────────
|
||
static void SectionG(UnityEngine.Camera cam)
|
||
{
|
||
L("");
|
||
L("## G. 룩 캡처 1080×1920 → " + kOutDir);
|
||
L(CaptureControl(cam, "look_00_persp_original"));
|
||
L(CaptureRig(cam, 3.8f, 480, "look_01_ortho38_px480"));
|
||
L(CaptureRig(cam, 3.8f, 360, "look_02_ortho38_px360"));
|
||
L(CaptureRig(cam, 4.6f, 480, "look_03_ortho46_px480"));
|
||
// 보너스 — 811o 구도의 실측 거리(카메라→주시점)에서 원근 fov 60 과 PC 평면 크기가 정확히 같아지는 ortho
|
||
float matched = UnityEngine.Vector3.Distance(cam.transform.position, s_lookAtWorld) * UnityEngine.Mathf.Tan(30f * UnityEngine.Mathf.Deg2Rad);
|
||
L(CaptureRig(cam, matched, 480, "look_04_orthoMatched_px480") + " ← 실측 정합값 ortho " + matched.ToString("F3"));
|
||
}
|
||
|
||
static string CaptureControl(UnityEngine.Camera cam, string tag)
|
||
{
|
||
var rt = new UnityEngine.RenderTexture(W, H, 24, UnityEngine.RenderTextureFormat.ARGB32);
|
||
var prevTarget = cam.targetTexture;
|
||
float prevAspect = cam.aspect;
|
||
cam.aspect = (float)W / H;
|
||
cam.targetTexture = rt;
|
||
cam.Render();
|
||
cam.targetTexture = prevTarget;
|
||
cam.aspect = prevAspect;
|
||
string path = WritePng(rt, tag);
|
||
rt.Release(); UnityEngine.Object.DestroyImmediate(rt);
|
||
return " 대조(원근 fov " + cam.fieldOfView + ") → " + path;
|
||
}
|
||
|
||
static string CaptureRig(UnityEngine.Camera cam, float orthoSize, int pixelHeight, string tag)
|
||
{
|
||
var cfg = MakeCfg(orthoSize, pixelHeight, false); // viewCameraInMainStack=false → 뷰 카메라를 Base 로 직접 렌더
|
||
if (cfg == null) return " FAIL cfg";
|
||
if (!WL.PixelArt.PixelCameraRig.Assemble(cfg, cam)) return " FAIL assemble " + tag;
|
||
|
||
var gameCam = WL.PixelArt.PixelCameraRig.GameCamera;
|
||
var viewCam = WL.PixelArt.PixelCameraRig.ViewCamera;
|
||
var mgr = WL.PixelArt.PixelCameraRig.Manager;
|
||
|
||
var cap = new UnityEngine.RenderTexture(W, H, 24, UnityEngine.RenderTextureFormat.ARGB32);
|
||
viewCam.aspect = (float)W / H;
|
||
viewCam.targetTexture = cap;
|
||
mgr.SendMessage("LateUpdate", UnityEngine.SendMessageOptions.DontRequireReceiver);
|
||
mgr.SendMessage("LateUpdate", UnityEngine.SendMessageOptions.DontRequireReceiver); // RT 생성 후 위치·줌 확정
|
||
|
||
var lowRt = gameCam.targetTexture;
|
||
gameCam.Render(); // 저해상도 RT 를 채운다
|
||
viewCam.Render(); // 쿼드를 1080×1920 으로 업스케일
|
||
|
||
string path = WritePng(cap, tag);
|
||
string info = " ortho " + orthoSize.ToString("0.##") + " × px " + pixelHeight
|
||
+ " → RT " + (lowRt == null ? "null" : lowRt.width + "×" + lowRt.height)
|
||
+ " · gameZoom " + mgr.GameCameraZoom.ToString("F4")
|
||
+ " · viewSize " + viewCam.orthographicSize.ToString("F4")
|
||
+ " → " + path;
|
||
|
||
viewCam.targetTexture = null;
|
||
cap.Release(); UnityEngine.Object.DestroyImmediate(cap);
|
||
WL.PixelArt.PixelCameraRig.Teardown("capture " + tag);
|
||
return info;
|
||
}
|
||
|
||
static string WritePng(UnityEngine.RenderTexture rt, string tag)
|
||
{
|
||
var prev = UnityEngine.RenderTexture.active;
|
||
UnityEngine.RenderTexture.active = rt;
|
||
var tex = new UnityEngine.Texture2D(rt.width, rt.height, UnityEngine.TextureFormat.RGB24, false);
|
||
tex.ReadPixels(new UnityEngine.Rect(0, 0, rt.width, rt.height), 0, 0);
|
||
tex.Apply();
|
||
UnityEngine.RenderTexture.active = prev;
|
||
var path = System.IO.Path.Combine(kOutDir, tag + ".png");
|
||
System.IO.File.WriteAllBytes(path, UnityEngine.ImageConversion.EncodeToPNG(tex));
|
||
UnityEngine.Object.DestroyImmediate(tex);
|
||
return path;
|
||
}
|
||
|
||
// ── 임시 설정(디스크 SO 를 절대 건드리지 않는다) ─────────────────────────
|
||
static WL.PixelArt.WLPixelCameraSettings MakeCfg(float orthoSize, int pixelHeight, bool inStack)
|
||
{
|
||
var rig = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.GameObject>(kRig);
|
||
if (rig == null) return null;
|
||
var cfg = UnityEngine.ScriptableObject.CreateInstance<WL.PixelArt.WLPixelCameraSettings>();
|
||
cfg.hideFlags = UnityEngine.HideFlags.HideAndDontSave;
|
||
cfg.pixelCameraSystemPrefab = rig;
|
||
cfg.orthoSize = orthoSize;
|
||
cfg.pixelHeight = pixelHeight;
|
||
cfg.viewCameraInMainStack = inStack;
|
||
cfg.verboseLog = false;
|
||
return cfg;
|
||
}
|
||
}
|