diff --git a/docs/dev/replay-3d.md b/docs/dev/replay-3d.md index 3628b59..11bad9c 100644 --- a/docs/dev/replay-3d.md +++ b/docs/dev/replay-3d.md @@ -51,6 +51,18 @@ - 개발 확인: 효과 하나만 따로 그리는 판(`~/.tmp/gvr/vfxHarness.ts` 를 `site/web/src/dev/` 에 잠시 두고 vite dev 에서 `import('/src/dev/vfxHarness.ts')`). 저장소에는 넣지 않았다. - 한계: 재질 그래프 근사라 색 · 무늬가 게임과 조금 다르다. 리본 · beam 일부, 화면 효과(섬광 눈부심 등)는 없다. 오멘 연막처럼 추출기가 클래스를 못 찾은 것은 예전 모양. +## 구운 조명 (2026-10-29, 실감 3단계) +- 계기: aim.sheepu.dev(브라우저 발로란트 에임 연습장)의 맵이 게임처럼 보이는 이유를 보니 게임이 구워 둔 라이트맵(밝기 + SH 방향)을 그대로 쓴다. 우리 맵은 텍스처 × 장면 조명(하늘빛 + 해)이라 평평했다. 그 사이트 파일은 쓰지 않고 우리 추출기로 게임 파일에서 직접 뽑는다. +- 게임 쪽: 레벨마다 `<레벨>_BuiltData` (UMapBuildDataRegistry). 컴포넌트 `LODData[0].MapBuildDataId` → FMeshMapBuildData → FLightMap2D (텍스처 · ScaleVectors/AddVectors · CoordinateScale/Bias), ISM 은 인스턴스마다 `PerInstanceLightmapData[i].LightmapUVBias` (HISM 은 `InstanceReorderTable`). 라이트맵 UV 채널은 메시 `LightMapCoordinateIndex`, LOD0 에만 있다 (구운 조명이 있는 배치는 LOD0, 삼각형은 거의 같다: 어센트 233만 → 235만). + - HQ_Lightmap 텍스처(DXT5 1024²)는 위 절반 = 계수 0(UVW² · 로그 밝기), 아래 절반 = 계수 1(SH 방향 xyz · 밝기 나머지). 푸는 식은 UE `LightmapCommon.ush` GetLightMapColorHQ 와 같다. 햇빛 그림자까지 다 구워져 있다 (정적 조명). +- 추출기 `src/Lightmaps.cs`: 메시가 차지한 칸마다 그 메시 범위로 풀어 irr(L·UVW·L0, sRGB/K) · sh(방향/L0, ±2) 두 장으로 → 칸 밖은 이웃 값으로 채움 → 1/2 씩 줄여 선반 쌓기 아틀라스(너비 `GVR_LIGHTMAP` 기본 2048, 넓이 약 그 제곱 안). 조명 없는 배치는 (0,0) 기본 칸(맵 평균 밝기). + - glb: 모든 재질에 `occlusionTexture`(irr) · `emissiveTexture`(sh, 세기 0) 를 TEXCOORD_1 로, `extras.lightmap.k`. gltfpack 이 쓰지 않는 UV 채널을 버리지 않게 텍스처가 그 채널을 가리켜야 한다. 옛 사이트는 aoMap 으로만 써서(어두워지기만) 깨지지 않는다. + - pack.py 는 맵을 `-vtf`(UV 실수) 로: gltfpack 은 재질마다 TEXCOORD_0(반복, 수십 단위) · TEXCOORD_1 을 한 범위로 양자화해서 정수로 줄이면 라이트맵이 몇 텍셀씩 어긋난다. + - 13.09 실측: 어센트 페이지 72 → 1864×1360(1/4) 2.5MB, 어비스 116 → 1864×2176(1/4) 3.4MB. 맵 압축 크기 어센트 14.7 → 18.8MB, 어비스 12.1 → 17.4MB. 최대 메모리 3.4~3.6GB (페이지 값은 반 정밀도). +- 사이트 `lib/map3d.ts` `installShader`: 색 = 텍스처 × irr × K × max(0, 1 + dot(sh, N.yzx)) (N 은 glb 법선 = UE 월드 법선 그대로), 0.8 위는 살짝 눌러 하얗게 날지 않게. 장면 조명은 맵에 쓰지 않는다 (요원 · 효과는 그대로 장면 조명). +- 조사 명령: `gvr-map-extract lmprobe <레벨.umap>` (빌드 데이터 · 텍스처 · 연결 통계, `GVR_LM_DUMP=<폴더>` 면 라이트맵 png). +- 한계: 1/4 로 줄여 그림자 가장자리가 흐리다. 움직이는 것(요원)은 구운 조명을 받지 않는다 (볼륨 라이트맵은 아직 안 씀). 어비스 낭떠러지처럼 게임에서 어두운 곳은 그대로 어둡다. + ## 남은 일 - 실제 경기로 동기화 오차 확인 (사이트 아래 줄 "킬 N개로 맞춤 (최대 오차 X초)") diff --git a/site/web/src/lib/map3d.ts b/site/web/src/lib/map3d.ts index eed238b..a4e6230 100644 --- a/site/web/src/lib/map3d.ts +++ b/site/web/src/lib/map3d.ts @@ -51,6 +51,8 @@ export async function findMap3d(mapUrl: string): Promise { * glb 를 받아 장면 하나로. onProgress: 0~1 * 재질이 든 glb(텍스처 · 색)는 그 재질에 천장 자르기만 붙이고, 재질이 없는 옛 glb 는 fallback(높이 색) 재질을 쓴다. * 두 층 재질(extras.blend = {texture, tint})은 정점 색 R 로 A 층(기본 텍스처) · B 층을 섞는다. + * 구운 조명(extras.lightmap = {k}): 추출기가 aoMap(irr) · emissiveMap(sh) 자리에 TEXCOORD_1 로 넣어 둔 아틀라스로 + * 색 = 텍스처 × irr × K × max(0, 1 + dot(sh, N.yzx)) (N 은 UE 월드 법선, tools/map-extract/src/Lightmaps.cs). 장면 조명은 쓰지 않는다. */ export function loadMap3d(url: string, clip: THREE.Plane, fallback: () => THREE.Material, onProgress?: (p: number) => void): Promise { const loader = new GLTFLoader(); @@ -73,6 +75,7 @@ export function loadMap3d(url: string, clip: THREE.Plane, fallback: () => THREE. } const src = mesh.material as THREE.MeshStandardMaterial; const blend = src.userData?.blend as { texture?: number; tint?: number[] } | undefined; + const lm = src.userData?.lightmap as { k?: number } | undefined; // 정점 색은 색칠이 아니라 두 층 섞는 비율이다 const col = mesh.geometry.getAttribute('color'); if (col) { @@ -91,7 +94,20 @@ export function loadMap3d(url: string, clip: THREE.Plane, fallback: () => THREE. m.metalness = 0; if (m.map) m.map.anisotropy = 4; if (m.transparent) m.depthWrite = false; - if (blend) pending.push(blendLayer(gltf.parser, m, blend)); + const shader: ShaderParts = {}; + if (lm?.k && m.aoMap && m.emissiveMap) { + shader.lightmap = { k: lm.k }; + for (const t of [m.aoMap, m.emissiveMap]) { + t.colorSpace = THREE.NoColorSpace; // 셰이더에서 직접 푼다 + t.anisotropy = 4; + } + } else { + // 조명 없는 재질에 붙은 조명 텍스처는 쓰지 않는다 + m.aoMap = null; + m.emissiveMap = null; + } + const ready = blend ? blendLayer(gltf.parser, blend).then((b) => void (shader.blend = b)) : Promise.resolve(); + pending.push(ready.then(() => installShader(m, shader))); done.set(src, m); mat = m; } @@ -105,8 +121,13 @@ export function loadMap3d(url: string, clip: THREE.Plane, fallback: () => THREE. }); } -/** B 층 텍스처 · 색을 붙이고 셰이더에서 정점 색 R 로 섞는다 */ -async function blendLayer(parser: { getDependency: (type: string, i: number) => Promise }, m: THREE.MeshStandardMaterial, b: { texture?: number; tint?: number[] }) { +interface ShaderParts { + blend?: { texB: THREE.Texture | null; tintB: THREE.Color }; + lightmap?: { k: number }; +} + +/** B 층 텍스처 · 색 (셰이더에서 정점 색 R 로 섞는다) */ +async function blendLayer(parser: { getDependency: (type: string, i: number) => Promise }, b: { texture?: number; tint?: number[] }) { let texB: THREE.Texture | null = null; if (b.texture != null) { // 텍스처 하나를 못 읽어도 맵 전체를 버리지 않고 B 층 색만 쓴다 @@ -117,26 +138,65 @@ async function blendLayer(parser: { getDependency: (type: string, i: number) => } } const tintB = new THREE.Color().setRGB(b.tint?.[0] ?? 1, b.tint?.[1] ?? 1, b.tint?.[2] ?? 1, THREE.SRGBColorSpace); + return { texB, tintB }; +} + +/** 두 층 섞기 · 구운 조명을 셰이더에 넣는다 */ +function installShader(m: THREE.MeshStandardMaterial, parts: ShaderParts) { + const { blend, lightmap } = parts; + if (!blend && !lightmap) return; const md = m as unknown as { defines?: Record }; - md.defines = { ...(md.defines ?? {}), GVR_BLEND: '', ...(texB ? { GVR_BLEND_MAP: '' } : {}) }; + md.defines = { ...(md.defines ?? {}) }; + if (blend) { + md.defines.GVR_BLEND = ''; + if (blend.texB) md.defines.GVR_BLEND_MAP = ''; + } + if (lightmap) md.defines.GVR_LIGHTMAP = ''; + // 같은 프로그램을 나눠 쓰도록 (uniform 값만 재질마다 다름) + m.customProgramCacheKey = () => `gvr:${blend ? (blend.texB ? 'bm' : 'b') : ''}:${lightmap ? 'l' : ''}`; m.onBeforeCompile = (sh) => { - sh.uniforms.mapB = { value: texB }; - sh.uniforms.tintB = { value: tintB }; - sh.vertexShader = sh.vertexShader - .replace('#include ', '#include \nattribute vec4 blendCol;\nvarying float vBlend;\nvarying vec2 vUvB;') - .replace('#include ', '#include \nvBlend = blendCol.r;\nvUvB = uv;'); - sh.fragmentShader = sh.fragmentShader - .replace('#include ', '#include \nuniform sampler2D mapB;\nuniform vec3 tintB;\nvarying float vBlend;\nvarying vec2 vUvB;') - .replace( - '#include ', - `#include + if (blend) { + sh.uniforms.mapB = { value: blend.texB }; + sh.uniforms.tintB = { value: blend.tintB }; + sh.vertexShader = sh.vertexShader + .replace('#include ', '#include \nattribute vec4 blendCol;\nvarying float vBlend;\nvarying vec2 vUvB;') + .replace('#include ', '#include \nvBlend = blendCol.r;\nvUvB = uv;'); + sh.fragmentShader = sh.fragmentShader + .replace('#include ', '#include \nuniform sampler2D mapB;\nuniform vec3 tintB;\nvarying float vBlend;\nvarying vec2 vUvB;') + .replace( + '#include ', + `#include #ifdef GVR_BLEND_MAP vec3 layerB = texture2D(mapB, vUvB).rgb * tintB; #else vec3 layerB = tintB; #endif diffuseColor.rgb = mix(layerB, diffuseColor.rgb, vBlend);`, - ); + ); + } + if (lightmap) { + sh.uniforms.lmK = { value: lightmap.k }; + sh.vertexShader = sh.vertexShader + .replace('#include ', '#include \nvarying vec3 vUeN;') + .replace('#include ', '#include \nvUeN = objectNormal;'); + sh.fragmentShader = sh.fragmentShader + .replace('#include ', '#include \nuniform float lmK;\nvarying vec3 vUeN;') + .replace( + '#include ', + `{ + // 구운 조명 (UE HQ 라이트맵을 추출기가 풀어 둔 값): irr 는 sRGB, sh 는 ±2 → 0~1 + vec3 lmIrr = texture2D(aoMap, vAoMapUv).rgb; + lmIrr = mix(lmIrr / 12.92, pow((lmIrr + 0.055) / 1.055, vec3(2.4)), step(vec3(0.04045), lmIrr)); + vec3 lmSh = texture2D(emissiveMap, vEmissiveMapUv).rgb * 4.0 - 2.0; + vec3 n = normalize(vUeN); + float lmDir = max(0.0, 1.0 + dot(lmSh, n.yzx)); + vec3 lit = diffuseColor.rgb * lmIrr * (lmK * lmDir); + // 밝은 곳이 하얗게 날아가지 않게 살짝 누른다 + outgoingLight = lit / (1.0 + max(lit - 0.8, 0.0)); +} +#include `, + ); + } }; m.needsUpdate = true; } diff --git a/tools/map-extract/scripts/install.sh b/tools/map-extract/scripts/install.sh index eed19ce..81baa19 100755 --- a/tools/map-extract/scripts/install.sh +++ b/tools/map-extract/scripts/install.sh @@ -2,7 +2,7 @@ # 맵 3D 자동 갱신을 이 리눅스 서버(.9)에 설치한다. 저장소에서: tools/map-extract/scripts/install.sh # - gvr-map-extract 를 빌드해 $GVR_MAPS_HOME/bin 에 둔다 (저장소 작업 폴더가 바뀌어도 타이머는 그대로 돈다) # - systemd 사용자 타이머 gvr-maps-update.timer (30분마다 update.sh). 메모리 6GB · CPU 3코어 상한, 봇과 다른 cgroup -# 코드를 고쳤으면 다시 실행하면 된다. 지금 바로 한 번 돌리기: systemctl --user start gvr-maps-update +# 코드를 고쳤으면 다시 실행하면 된다 (타이머를 꺼 뒀으면 꺼진 채로 둔다). 지금 바로 한 번 돌리기: systemctl --user start gvr-maps-update set -euo pipefail here="$(cd "$(dirname "$0")/.." && pwd)" GVR_MAPS_HOME="${GVR_MAPS_HOME:-$HOME/gvr-maps}" @@ -26,6 +26,8 @@ chmod +x "$GVR_MAPS_HOME/scripts/update.sh" unit="$HOME/.config/systemd/user" mkdir -p "$unit" +# 이미 설치돼 있는데 타이머를 꺼 뒀으면(사용자가 자동 갱신을 멈춤) 다시 켜지 않는다 +timer_was="$( [ -f "$unit/gvr-maps-update.timer" ] && (systemctl --user is-enabled gvr-maps-update.timer 2>/dev/null || true) || echo new)" node_dir="$(dirname "$(command -v node)")" cat > "$unit/gvr-maps-update.service" <//<코드>.glb.gz (gltfpack -cc 로 meshopt 압축 · 위치 양자화 → gzip) + <출력>/index.json - -ke: 재질 extras(두 층 섞기 B 층) 유지, -vt 14: 반복 UV 가 뭉개지지 않게 + -ke: 재질 extras(두 층 섞기 B 층 · 구운 조명 K) 유지 + -vtf: UV 를 실수 그대로. gltfpack 은 재질마다 TEXCOORD_0(반복 UV, 수십 단위) · TEXCOORD_1(라이트맵 아틀라스 0~1)을 + 한 범위로 묶어 양자화해서, 정수로 줄이면 라이트맵 UV 가 몇 텍셀씩 어긋난다 (meshopt 압축 뒤 크기는 비슷) 사이트 서버 data/maps3d 에 그대로 올리면 된다 (site/server/src/maps3d.ts).""" import datetime, gzip, json, os, re, shutil, subprocess, sys @@ -22,7 +24,7 @@ for name in sorted(os.listdir(src)): if not os.path.exists(glb) or info.get('triangles', 0) == 0: continue packed = os.path.join(out, d, code + '.glb') - subprocess.run(['npx', '-y', 'gltfpack@1.3.0', '-i', glb, '-o', packed, '-cc', '-ke', '-vt', '14'], check=True, stdout=subprocess.DEVNULL) + subprocess.run(['npx', '-y', 'gltfpack@1.3.0', '-i', glb, '-o', packed, '-cc', '-ke', '-vtf'], check=True, stdout=subprocess.DEVNULL) with open(packed, 'rb') as f, gzip.open(packed + '.gz', 'wb', 9) as g: shutil.copyfileobj(f, g) os.remove(packed) diff --git a/tools/map-extract/src/Glb.cs b/tools/map-extract/src/Glb.cs index 9574c6d..bc2f112 100644 --- a/tools/map-extract/src/Glb.cs +++ b/tools/map-extract/src/Glb.cs @@ -77,12 +77,24 @@ public sealed class Glb return Accessor(v, 5126, data.Length / comps, type); } - /// 텍스처 (반복 샘플러) 번호 - public int Texture(byte[] image, string mime) + private int _clampSampler = -1; + + /// 텍스처 번호 (기본 반복 샘플러, clamp 면 가장자리 고정 샘플러) + public int Texture(byte[] image, string mime, bool clamp = false) { if (Samplers.Count == 0) Samplers.Add(new JsonObject { ["magFilter"] = 9729, ["minFilter"] = 9987, ["wrapS"] = 10497, ["wrapT"] = 10497 }); + var sampler = 0; + if (clamp) + { + if (_clampSampler < 0) + { + Samplers.Add(new JsonObject { ["magFilter"] = 9729, ["minFilter"] = 9987, ["wrapS"] = 33071, ["wrapT"] = 33071 }); + _clampSampler = Samplers.Count - 1; + } + sampler = _clampSampler; + } Images.Add(new JsonObject { ["bufferView"] = View(image, null), ["mimeType"] = mime }); - Textures.Add(new JsonObject { ["sampler"] = 0, ["source"] = Images.Count - 1 }); + Textures.Add(new JsonObject { ["sampler"] = sampler, ["source"] = Images.Count - 1 }); return Textures.Count - 1; } diff --git a/tools/map-extract/src/Lightmaps.cs b/tools/map-extract/src/Lightmaps.cs new file mode 100644 index 0000000..3832eb3 --- /dev/null +++ b/tools/map-extract/src/Lightmaps.cs @@ -0,0 +1,271 @@ +using CUE4Parse.UE4.Assets.Exports.BuildData; +using CUE4Parse.UE4.Assets.Exports.Texture; +using CUE4Parse.UE4.Objects.Core.Math; +using SixLabors.ImageSharp; +using SixLabors.ImageSharp.Formats.Jpeg; +using SixLabors.ImageSharp.PixelFormats; + +namespace GvrMapExtract; + +/// 게임에 구워 둔 조명(HQ 라이트맵)을 맵 하나에 아틀라스 두 장으로 모은다. +/// +/// 게임 라이트맵 텍스처(LightMapTexture2D, DXT5)는 위 절반이 계수 0(색 UVW² · 로그 밝기), 아래 절반이 계수 1(SH 방향 · 밝기 나머지)이다. +/// 메시마다(FLightMap2D) 범위(ScaleVectors · AddVectors)가 달라서, 메시가 차지한 칸(UV × CoordinateScale + Bias)마다 그 범위로 풀어 둔다 +/// (UE LightmapCommon.ush GetLightMapColorHQ 와 같은 식). +/// +/// 결과 +/// irr: sRGB(밝기 / K) — 표면 방향을 빼고 본 조명 색 (L · UVW · L0) +/// sh : 방향 계수 / L0 를 ±2 → 0~1 로 — 사이트에서 조명 = irr · K · max(0, 1 + dot(sh, N.yzx)) (N 은 UE 월드 법선) +/// 칸 밖 텍셀은 이웃 값으로 채워(번짐 방지) 줄인 뒤 페이지째 아틀라스에 놓는다. 라이트맵이 없는 배치는 (0,0) 의 기본 칸(맵 평균 밝기, 방향 없음)을 쓴다. +public sealed class Lightmaps +{ + private sealed class PageData + { + public required string Key; + public required int W, H; // 계수 하나(텍스처 절반) 크기 + public required byte[] Src; // RGBA, W × 2H + public Half[] Irr = null!, Sh = null!; // 메모리를 줄이려고 반 정밀도 (맵 하나에 페이지 100개 넘게) + public bool[] Valid = null!; + public int Ox, Oy, Sw, Sh2; // 아틀라스 위치 · 줄인 크기 + } + + private readonly List _pages = new(); + private readonly Dictionary _byKey = new(StringComparer.OrdinalIgnoreCase); + private readonly HashSet<(int, float, float)> _done = new(); + public int Allocations, Failed; + private int _atlasW, _atlasH; + private const int Pad = 4; // 페이지 사이 여백 (밉맵 번짐 방지) + private const int DefaultCell = 8; + + /// 라이트맵 텍스처 → 페이지 번호 (못 읽으면 -1) + public int Page(FLightMap2D lm) + { + var idx = lm.Textures?[0]; + if (idx == null || idx.IsNull) return -1; + var key = idx.ResolvedObject?.GetPathName() ?? idx.Name; + if (_byKey.TryGetValue(key, out var p)) return p; + try + { + var t = idx.Load(); + var c = t == null ? null : CUE4Parse_Conversion.Textures.TextureDecoder.Decode(t); + if (c == null || c.Height < 2 || c.Data.Length < c.Width * c.Height * 4) { Failed++; return _byKey[key] = -1; } + var bgra = c.PixelFormat == EPixelFormat.PF_B8G8R8A8; + if (!bgra && c.PixelFormat != EPixelFormat.PF_R8G8B8A8) { Failed++; return _byKey[key] = -1; } + var src = c.Data; + if (bgra) + { + src = (byte[])src.Clone(); + for (var i = 0; i < src.Length; i += 4) (src[i], src[i + 2]) = (src[i + 2], src[i]); + } + var w = c.Width; + var h = c.Height / 2; + _pages.Add(new PageData { Key = key, W = w, H = h, Src = src, Irr = new Half[w * h * 3], Sh = new Half[w * h * 3], Valid = new bool[w * h] }); + return _byKey[key] = _pages.Count - 1; + } + catch (Exception e) + { + Failed++; + if (Failed <= 5) Console.Error.WriteLine($"라이트맵 실패 {key}: {e.GetType().Name} {e.Message}"); + return _byKey[key] = -1; + } + } + + /// 메시 하나가 차지한 칸을 풀어 둔다 (같은 칸은 한 번만) + public void Allocate(int page, FLightMap2D lm, FVector2D bias) + { + if (page < 0 || !_done.Add((page, bias.X, bias.Y))) return; + Allocations++; + var p = _pages[page]; + var cs = lm.CoordinateScale ?? new FVector2D(1, 1); + var s0 = lm.ScaleVectors![0]; + var a0 = lm.AddVectors![0]; + var s1 = lm.ScaleVectors![1]; + var a1 = lm.AddVectors![1]; + // 칸 + 1 텍셀 (UE 는 칸 둘레에 여백을 두고 구운 값을 채운다) + var x0 = Math.Max(0, (int)Math.Floor(bias.X * p.W) - 1); + var y0 = Math.Max(0, (int)Math.Floor(bias.Y * p.H) - 1); + var x1 = Math.Min(p.W, (int)Math.Ceiling((bias.X + cs.X) * p.W) + 1); + var y1 = Math.Min(p.H, (int)Math.Ceiling((bias.Y + cs.Y) * p.H) + 1); + const float LogBlackPoint = 0.01858136f; + for (var y = y0; y < y1; y++) + for (var x = x0; x < x1; x++) + { + var i0 = (y * p.W + x) * 4; + var i1 = ((y + p.H) * p.W + x) * 4; + float C(int i) => p.Src[i] / 255f; + var logL = C(i0 + 3) + C(i1 + 3) / 255f - 0.5f / 255f; + logL = logL * s0.W + a0.W; + var l = MathF.Max(0, MathF.Pow(2, logL) - LogBlackPoint); + var r = C(i0) * C(i0) * s0.X + a0.X; + var g = C(i0 + 1) * C(i0 + 1) * s0.Y + a0.Y; + var b = C(i0 + 2) * C(i0 + 2) * s0.Z + a0.Z; + var l0 = C(i1 + 3) * s1.W + a1.W; + if (l0 < 1e-4f) l0 = 0.282095f; + var o = (y * p.W + x) * 3; + p.Irr[o] = (Half)(MathF.Max(0, l * r * l0)); + p.Irr[o + 1] = (Half)(MathF.Max(0, l * g * l0)); + p.Irr[o + 2] = (Half)(MathF.Max(0, l * b * l0)); + p.Sh[o] = (Half)((C(i1) * s1.X + a1.X) / l0); + p.Sh[o + 1] = (Half)((C(i1 + 1) * s1.Y + a1.Y) / l0); + p.Sh[o + 2] = (Half)((C(i1 + 2) * s1.Z + a1.Z) / l0); + p.Valid[y * p.W + x] = true; + } + } + + /// 페이지 공간 UV(0~1) → 아틀라스 UV. page < 0 이면 기본 칸 가운데 + public (float u, float v) ToAtlas(int page, float u, float v) + { + if (page < 0 || _atlasW == 0) return ((DefaultCell / 2f) / Math.Max(1, _atlasW), (DefaultCell / 2f) / Math.Max(1, _atlasH)); + var p = _pages[page]; + u = Math.Clamp(u, 0, 1); + v = Math.Clamp(v, 0, 1); + return ((p.Ox + u * p.Sw) / _atlasW, (p.Oy + v * p.Sh2) / _atlasH); + } + + public bool Any => _pages.Count > 0; + public float K { get; private set; } = 1; + public int AtlasW => _atlasW; + public int AtlasH => _atlasH; + + /// 아틀라스를 만든다 (너비 maxSide · 넓이 약 maxSide² 안에 들어가게 페이지를 1/2 씩 줄인다). 이 뒤에 ToAtlas 를 쓴다 + public (byte[] irr, byte[] sh)? Build(int maxSide) + { + if (_pages.Count == 0) return null; + // 맵 평균 · 최대 밝기 + var lum = new List(); + double sr = 0, sg = 0, sb = 0; + long n = 0; + foreach (var p in _pages) + for (var i = 0; i < p.Valid.Length; i++) + if (p.Valid[i]) + { + var m = MathF.Max((float)p.Irr[i * 3], MathF.Max((float)p.Irr[i * 3 + 1], (float)p.Irr[i * 3 + 2])); + if ((i & 7) == 0) lum.Add(m); + sr += (float)p.Irr[i * 3]; sg += (float)p.Irr[i * 3 + 1]; sb += (float)p.Irr[i * 3 + 2]; + n++; + } + if (n == 0) return null; + lum.Sort(); + K = Math.Max(0.05f, lum[(int)(lum.Count * 0.998)]); + var avg = new[] { (float)(sr / n), (float)(sg / n), (float)(sb / n) }; + + foreach (var p in _pages) Dilate(p, 8); + // 줄이는 배율: 너비 maxSide · 높이 2×maxSide · 넓이 1.25×maxSide² 안에 들어갈 때까지 1/2 씩 + var f = 1; + while (!Pack(f, maxSide) && f < 64) f *= 2; + using var irr = new Image(_atlasW, _atlasH); + using var sh = new Image(_atlasW, _atlasH, new Rgb24(128, 128, 128)); + static byte Enc(float v) => (byte)Math.Clamp(MathF.Round(v * 255), 0, 255); + static float Srgb(float v) => v <= 0.0031308f ? v * 12.92f : 1.055f * MathF.Pow(v, 1 / 2.4f) - 0.055f; + Rgb24 IrrPx(float r, float g, float b) => new(Enc(Srgb(Math.Min(1, r / K))), Enc(Srgb(Math.Min(1, g / K))), Enc(Srgb(Math.Min(1, b / K)))); + static Rgb24 ShPx(float x, float y, float z) => new(Enc(x / 4 + 0.5f), Enc(y / 4 + 0.5f), Enc(z / 4 + 0.5f)); + // 기본 칸 + for (var y = 0; y < DefaultCell; y++) + for (var x = 0; x < DefaultCell; x++) irr[x, y] = IrrPx(avg[0], avg[1], avg[2]); + foreach (var p in _pages) + { + // 줄이기 (f×f 평균) + 여백은 가장자리 값으로 + for (var y = -Pad; y < p.Sh2 + Pad; y++) + for (var x = -Pad; x < p.Sw + Pad; x++) + { + var sx = Math.Clamp(x, 0, p.Sw - 1); + var sy = Math.Clamp(y, 0, p.Sh2 - 1); + float r = 0, g = 0, b = 0, hx = 0, hy = 0, hz = 0; + var cnt = 0; + for (var dy = 0; dy < f; dy++) + for (var dx = 0; dx < f; dx++) + { + var px = Math.Min(p.W - 1, sx * f + dx); + var py = Math.Min(p.H - 1, sy * f + dy); + var k = py * p.W + px; + if (!p.Valid[k]) continue; + r += (float)p.Irr[k * 3]; g += (float)p.Irr[k * 3 + 1]; b += (float)p.Irr[k * 3 + 2]; + hx += (float)p.Sh[k * 3]; hy += (float)p.Sh[k * 3 + 1]; hz += (float)p.Sh[k * 3 + 2]; + cnt++; + } + var ax = p.Ox + x; + var ay = p.Oy + y; + if (cnt == 0) + { + irr[ax, ay] = IrrPx(avg[0], avg[1], avg[2]); + continue; + } + irr[ax, ay] = IrrPx(r / cnt, g / cnt, b / cnt); + sh[ax, ay] = ShPx(hx / cnt, hy / cnt, hz / cnt); + } + } + var enc = new JpegEncoder { Quality = 90, ColorType = JpegEncodingColor.YCbCrRatio444 }; + using var mi = new MemoryStream(); + irr.SaveAsJpeg(mi, enc); + using var ms = new MemoryStream(); + sh.SaveAsJpeg(ms, enc); + Factor = f; + foreach (var p in _pages) { p.Src = []; p.Irr = []; p.Sh = []; } + return (mi.ToArray(), ms.ToArray()); + } + + public int Factor { get; private set; } = 1; + + /// 1/f 로 줄인 페이지를 너비 maxSide 선반에 쌓는다 (높은 것부터). 한도 안이면 true + private bool Pack(int f, int maxSide) + { + foreach (var p in _pages) + { + p.Sw = Math.Max(1, p.W / f); + p.Sh2 = Math.Max(1, p.H / f); + } + var order = Enumerable.Range(0, _pages.Count).OrderByDescending(i => _pages[i].Sh2).ThenByDescending(i => _pages[i].Sw).ToList(); + int cx = DefaultCell + Pad, cy = 0, shelf = DefaultCell, wMax = 0; + foreach (var i in order) + { + var p = _pages[i]; + if (p.Sw + Pad * 2 > maxSide) return false; + if (cx + p.Sw + Pad * 2 > maxSide) { cx = 0; cy += shelf; shelf = 0; } + p.Ox = cx + Pad; + p.Oy = cy + Pad; + cx += p.Sw + Pad * 2; + shelf = Math.Max(shelf, p.Sh2 + Pad * 2); + wMax = Math.Max(wMax, cx); + } + // WebGL2 는 2 의 거듭제곱이 아니어도 밉맵을 쓴다 → 8 의 배수로만 (JPEG 블록) + _atlasW = (wMax + 7) / 8 * 8; + _atlasH = (cy + shelf + 7) / 8 * 8; + return _atlasH <= maxSide * 2 && (long)_atlasW * _atlasH <= (long)maxSide * maxSide * 5 / 4; + } + public int Pages => _pages.Count; + + /// 칸 밖 텍셀을 이웃 칸 값으로 채운다 (줄이기 · 선형 보간에서 검은 테두리가 번지지 않게) + private static void Dilate(PageData p, int passes) + { + for (var pass = 0; pass < passes; pass++) + { + var add = new List(); + for (var y = 0; y < p.H; y++) + for (var x = 0; x < p.W; x++) + { + var k = y * p.W + x; + if (p.Valid[k]) continue; + float r = 0, g = 0, b = 0, hx = 0, hy = 0, hz = 0; + var cnt = 0; + for (var dy = -1; dy <= 1; dy++) + for (var dx = -1; dx <= 1; dx++) + { + var nx = x + dx; + var ny = y + dy; + if (nx < 0 || ny < 0 || nx >= p.W || ny >= p.H) continue; + var j = ny * p.W + nx; + if (!p.Valid[j]) continue; + r += (float)p.Irr[j * 3]; g += (float)p.Irr[j * 3 + 1]; b += (float)p.Irr[j * 3 + 2]; + hx += (float)p.Sh[j * 3]; hy += (float)p.Sh[j * 3 + 1]; hz += (float)p.Sh[j * 3 + 2]; + cnt++; + } + if (cnt == 0) continue; + p.Irr[k * 3] = (Half)(r / cnt); p.Irr[k * 3 + 1] = (Half)(g / cnt); p.Irr[k * 3 + 2] = (Half)(b / cnt); + p.Sh[k * 3] = (Half)(hx / cnt); p.Sh[k * 3 + 1] = (Half)(hy / cnt); p.Sh[k * 3 + 2] = (Half)(hz / cnt); + add.Add(k); + } + if (add.Count == 0) break; + foreach (var k in add) p.Valid[k] = true; + } + } +} diff --git a/tools/map-extract/src/MapScene.cs b/tools/map-extract/src/MapScene.cs index ec03026..c7d0211 100644 --- a/tools/map-extract/src/MapScene.cs +++ b/tools/map-extract/src/MapScene.cs @@ -1,6 +1,7 @@ using System.Text; using CUE4Parse.FileProvider; using CUE4Parse.UE4.Assets.Exports; +using CUE4Parse.UE4.Assets.Exports.BuildData; using CUE4Parse.UE4.Assets.Exports.Component.StaticMesh; using CUE4Parse.UE4.Assets.Exports.StaticMesh; using CUE4Parse.UE4.Assets.Exports.Material; @@ -80,13 +81,19 @@ public sealed class MapScene private static readonly string[] SkipMesh = ["Box_For_Volumes", "BasicShapes/Plane", "Blockout", "/Sky", "Vista", "EditorMeshes", "Cubemap"]; private sealed record Sec(int First, int Tris, int Mat); - /// 메시 한 LOD: 위치 · 법선 · UV · 정점 색 · 삼각형 · 재질 구간 - private sealed record Geo(FVector[] V, FVector[] N, float[] Uv, FColor[]? Col, uint[] Ib, Sec[] Secs, int Lod); + /// 메시 한 LOD: 위치 · 법선 · UV · 라이트맵 UV(LOD0 만) · 정점 색 · 삼각형 · 재질 구간 + private sealed record Geo(FVector[] V, FVector[] N, float[] Uv, float[]? Lm, FColor[]? Col, uint[] Ib, Sec[] Secs, int Lod); + + /// 배치 하나의 라이트맵 자리: 페이지 · 페이지 안 UV = 라이트맵 UV × Scale + Bias + private readonly record struct LmPlace(int Page, float Sx, float Sy, float Bx, float By); + private readonly Lightmaps _lm = new(); + public int LitPlacements; /// 재질 하나 = glb primitive 하나. 같은 재질의 배치를 모두 모은다 private sealed class Bucket { - public readonly List Pos = new(), Nrm = new(), Uv = new(); + public readonly List Pos = new(), Nrm = new(), Uv = new(), Lm = new(); + public readonly List LmPage = new(); public readonly List Col = new(); public readonly List Idx = new(); } @@ -130,6 +137,12 @@ public sealed class MapScene { s._levels.Add(Path.GetFileNameWithoutExtension(level)); var pkg = provider.LoadPackage(level); + // 이 레벨에 구워 둔 조명 (<레벨>_BuiltData) + UMapBuildDataRegistry? reg = null; + var bd = level[..^".umap".Length] + "_BuiltData.uasset"; + if (provider.Files.ContainsKey(bd)) + try { reg = provider.LoadPackage(bd).GetExports().OfType().FirstOrDefault(); } + catch (Exception e) { Console.Error.WriteLine($"{bd}: 조명 읽기 실패 {e.GetType().Name} {e.Message}"); } foreach (var lazy in pkg.ExportsLazy) { UObject o; @@ -141,13 +154,21 @@ public sealed class MapScene if (mesh == null) continue; var path = mesh.GetPathName(); if (SkipMesh.Any(x => path.Contains(x, StringComparison.OrdinalIgnoreCase))) { s.Skipped++; continue; } - if (!meshCache.TryGetValue(path, out var geo)) + // 구운 조명이 있으면 LOD0 (라이트맵 UV 는 LOD0 에만 있다), 없으면 가장 낮은 LOD + FLightMap2D? lm = null; + FMeshMapBuildData? bdata = null; + if (reg?.MeshBuildData != null && c.LODData is { Length: > 0 } ld0 && reg.MeshBuildData.TryGetValue(ld0[0].MapBuildDataId, out bdata) + && bdata.LightMap is FLightMap2D l2 && l2.Textures?[0] is { IsNull: false } && l2.ScaleVectors != null && l2.AddVectors != null) lm = l2; + var lmIdx = lm != null ? mesh.GetOrDefault("LightMapCoordinateIndex", 0) : -1; + var key = lm != null ? $"{path}#lm{lmIdx}" : path; + if (!meshCache.TryGetValue(key, out var geo)) { - try { geo = Geometry(mesh); } catch { geo = null; s.Failed++; } - meshCache[path] = geo; + try { geo = Geometry(mesh, lmIdx); } catch { geo = null; s.Failed++; } + meshCache[key] = geo; if (geo != null) s.Meshes++; } if (geo == null) continue; + var page = lm != null && geo.Lm != null ? s._lm.Page(lm) : -1; FTransform w; try { w = c.GetAbsoluteTransform(); } catch { s.Failed++; continue; } // 재질: 컴포넌트가 바꾼 것 먼저, 없으면 메시 기본 @@ -164,26 +185,44 @@ public sealed class MapScene // 칠한 정점 색 (두 층 섞기에 쓴다): 컴포넌트 값이 정점 수와 맞을 때만 var col = geo.Col; if (c is { LODData: { } lodData } && geo.Lod < lodData.Length && lodData[geo.Lod].OverrideVertexColors is { Data: { } oc } && oc.Length == geo.V.Length) col = oc; + var cs = lm?.CoordinateScale ?? new FVector2D(1, 1); + LmPlace? Place(FVector2D bias) + { + if (page < 0) return null; + s._lm.Allocate(page, lm!, bias); + return new LmPlace(page, cs.X, cs.Y, bias.X, bias.Y); + } if (c is UInstancedStaticMeshComponent ism && ism.PerInstanceSMData is { Length: > 0 } data) - foreach (var d in data) s.Add(geo, mats, col, d.TransformData * w); - else s.Add(geo, mats, col, w); + { + // 인스턴스마다 라이트맵 칸이 따로 (FPerInstanceLightmapData). HISM 은 순서가 바뀌어 있을 수 있다 (InstanceReorderTable) + var per = bdata?.PerInstanceLightmapData ?? []; + var reorder = c.GetOrDefault("InstanceReorderTable", []); + for (var i = 0; i < data.Length; i++) + { + var ri = reorder.Length == data.Length ? reorder[i] : i; + var lp = ri >= 0 && ri < per.Length ? Place(per[ri].LightmapUVBias) : null; + s.Add(geo, mats, col, data[i].TransformData * w, lp); + } + } + else s.Add(geo, mats, col, w, lm != null ? Place(lm.CoordinateBias ?? new FVector2D(0, 0)) : null); } } return s; } - /// 가장 낮은 LOD (사이트에서 쓰기에 충분하고 가볍다) - private static Geo? Geometry(UStaticMesh mesh) + /// 가장 낮은 LOD (사이트에서 쓰기에 충분하고 가볍다). lmIdx ≥ 0 이면 LOD0 + 그 UV 채널(라이트맵) + private static Geo? Geometry(UStaticMesh mesh, int lmIdx = -1) { var lods = mesh.RenderData?.LODs; if (lods == null) return null; - for (var l = lods.Length - 1; l >= 0; l--) + for (var l = lmIdx >= 0 ? 0 : lods.Length - 1; l >= 0 && l < lods.Length; l += lmIdx >= 0 ? 1 : -1) { var lod = lods[l]; if (lod.SkipLod || lod.PositionVertexBuffer?.Verts is not { Length: > 0 } v || lod.IndexBuffer?.Buffer is not { Length: > 0 } ib) continue; var uvItems = lod.VertexBuffer?.UV; var n = new FVector[v.Length]; var uv = new float[v.Length * 2]; + var lmUv = lmIdx >= 0 && uvItems != null && uvItems.Length == v.Length && uvItems.All(x => x.UV != null && x.UV.Length > lmIdx) ? new float[v.Length * 2] : null; if (uvItems != null && uvItems.Length == v.Length) for (var i = 0; i < v.Length; i++) { @@ -194,17 +233,23 @@ public sealed class MapScene uv[i * 2] = it.UV[0].U; uv[i * 2 + 1] = it.UV[0].V; } + if (lmUv != null) + { + lmUv[i * 2] = it.UV[lmIdx].U; + lmUv[i * 2 + 1] = it.UV[lmIdx].V; + } } var col = lod.ColorVertexBuffer?.Data is { } cd && cd.Length == v.Length ? cd : null; var secs = lod.Sections.Select(x => new Sec(x.FirstIndex, x.NumTriangles, x.MaterialIndex)).ToArray(); - return new Geo(v, n, uv, col, ib.Select(x => (uint)x).ToArray(), secs, l); + return new Geo(v, n, uv, lmUv, col, ib.Select(x => (uint)x).ToArray(), secs, l); } return null; } - private void Add(Geo g, Mat?[] mats, FColor[]? col, FTransform t) + private void Add(Geo g, Mat?[] mats, FColor[]? col, FTransform t, LmPlace? lp) { Placements++; + if (lp != null) LitPlacements++; // UE 는 왼손 좌표계라 glTF(오른손, 반시계 앞면) 로 그대로 옮기면 앞뒤가 바뀐다 → 기본으로 뒤집는다. // 크기가 음수(거울)면 한 번 더 뒤집힌다 var flip = t.Scale3D.X * t.Scale3D.Y * t.Scale3D.Z >= 0; @@ -228,6 +273,16 @@ public sealed class MapScene if (len > 1e-6f) nn /= len; b.Nrm.Add(nn.X); b.Nrm.Add(nn.Y); b.Nrm.Add(nn.Z); b.Uv.Add(g.Uv[i * 2]); b.Uv.Add(g.Uv[i * 2 + 1]); + if (lp is { } q && g.Lm != null) + { + b.Lm.Add(g.Lm[i * 2] * q.Sx + q.Bx); b.Lm.Add(g.Lm[i * 2 + 1] * q.Sy + q.By); + b.LmPage.Add(q.Page); + } + else + { + b.Lm.Add(0); b.Lm.Add(0); + b.LmPage.Add(-1); + } if (m.Blend) { var c = col != null ? col[i] : new FColor(255, 255, 255, 255); @@ -255,7 +310,8 @@ public sealed class MapScene public long Triangles => _tris; public int Materials => _buckets.Count; public int TextureCount, TextureFailed; - public long TextureBytes; + public long TextureBytes, LightmapBytes; + public string LightmapSummary => _lm.Any ? $"조명 {LitPlacements}/{Placements} 배치 · 페이지 {_lm.Pages}(실패 {_lm.Failed}) · 칸 {_lm.Allocations} · 아틀라스 {_lm.AtlasW}x{_lm.AtlasH} (1/{_lm.Factor}) {LightmapBytes >> 10}KB · K {_lm.K:F2}" : "조명 없음"; /// glb: 재질마다 primitive 하나 (위치는 UE 월드 cm 그대로, 법선 · UV · (두 층 재질만) 정점 색). /// 재질은 baseColor 텍스처 + 색(tint). 두 층 재질은 extras.blend = {texture, tint} 로 B 층을 넘긴다 (사이트가 정점 색 R 로 섞는다) @@ -264,6 +320,16 @@ public sealed class MapScene var glb = new Glb(); var tex = new TexStore(provider, glb, maxTex); var prims = new System.Text.Json.Nodes.JsonArray(); + // 구운 조명 아틀라스: 모든 재질에 occlusionTexture(irr) · emissiveTexture(sh, 세기 0) 로 TEXCOORD_1 에 붙인다. + // (gltfpack 이 쓰지 않는 UV 채널을 버리지 않게 텍스처가 그 채널을 가리켜야 한다. 사이트는 둘을 떼어 조명으로 쓴다) + int? irrTex = null, shTex = null; + var lmMax = int.Parse(Environment.GetEnvironmentVariable("GVR_LIGHTMAP") ?? "2048"); + if (lmMax > 0 && _lm.Build(lmMax) is var (irrJpg, shJpg)) + { + irrTex = glb.Texture(irrJpg, "image/jpeg", clamp: true); + shTex = glb.Texture(shJpg, "image/jpeg", clamp: true); + LightmapBytes = irrJpg.Length + shJpg.Length; + } var byKey = _mats.Values.Where(x => x != null).ToDictionary(x => x!.Key, x => x!); foreach (var (key, b) in _buckets.OrderBy(x => x.Key, StringComparer.Ordinal)) { @@ -279,6 +345,12 @@ public sealed class MapScene }; if (a is { } at) pbr["baseColorTexture"] = new System.Text.Json.Nodes.JsonObject { ["index"] = at.tex }; var mat = new System.Text.Json.Nodes.JsonObject { ["name"] = m.Name, ["pbrMetallicRoughness"] = pbr }; + if (irrTex is { } it && shTex is { } st) + { + mat["occlusionTexture"] = new System.Text.Json.Nodes.JsonObject { ["index"] = it, ["texCoord"] = 1, ["strength"] = 1 }; + mat["emissiveTexture"] = new System.Text.Json.Nodes.JsonObject { ["index"] = st, ["texCoord"] = 1 }; + mat["emissiveFactor"] = new System.Text.Json.Nodes.JsonArray(0, 0, 0); + } if (m.Translucent) mat["alphaMode"] = "BLEND"; else if (m.Masked && a is { alpha: true }) { @@ -286,12 +358,16 @@ public sealed class MapScene mat["alphaCutoff"] = 0.333; mat["doubleSided"] = true; } + var extras = new System.Text.Json.Nodes.JsonObject(); if (m.Blend) { var ex = new System.Text.Json.Nodes.JsonObject { ["tint"] = new System.Text.Json.Nodes.JsonArray(Clamp(m.TintB[0]), Clamp(m.TintB[1]), Clamp(m.TintB[2])) }; if (bt is { } btt) ex["texture"] = btt.tex; - mat["extras"] = new System.Text.Json.Nodes.JsonObject { ["blend"] = ex }; + extras["blend"] = ex; } + // 구운 조명: irr 텍스처 값(sRGB) 1 = 밝기 K + if (irrTex != null) extras["lightmap"] = new System.Text.Json.Nodes.JsonObject { ["k"] = _lm.K, ["v"] = 1 }; + if (extras.Count > 0) mat["extras"] = extras; glb.Materials.Add(mat); var attrs = new System.Text.Json.Nodes.JsonObject { @@ -300,6 +376,13 @@ public sealed class MapScene ["TEXCOORD_0"] = glb.Floats(b.Uv.ToArray(), 2), }; if (m.Blend) attrs["COLOR_0"] = glb.Bytes(b.Col.ToArray(), 4); + if (irrTex != null) + { + var lmuv = new float[b.Lm.Count]; + for (var i = 0; i < b.LmPage.Count; i++) + (lmuv[i * 2], lmuv[i * 2 + 1]) = _lm.ToAtlas(b.LmPage[i], b.Lm[i * 2], b.Lm[i * 2 + 1]); + attrs["TEXCOORD_1"] = glb.Floats(lmuv, 2); + } prims.Add(new System.Text.Json.Nodes.JsonObject { ["attributes"] = attrs, ["indices"] = glb.Indices(b.Idx.ToArray()), ["material"] = glb.Materials.Count - 1, ["mode"] = 4 }); } glb.Meshes.Add(new System.Text.Json.Nodes.JsonObject { ["name"] = _code, ["primitives"] = prims }); @@ -327,6 +410,7 @@ public sealed class MapScene textures = TextureCount, texturesFailed = TextureFailed, textureBytes = TextureBytes, + lightmap = _lm.Any ? new { placements = LitPlacements, pages = _lm.Pages, failed = _lm.Failed, allocations = _lm.Allocations, atlas = new[] { _lm.AtlasW, _lm.AtlasH }, factor = _lm.Factor, bytes = LightmapBytes, k = _lm.K } : null, skipped = Skipped, failed = Failed, manifest, diff --git a/tools/map-extract/src/ProbeLight.cs b/tools/map-extract/src/ProbeLight.cs new file mode 100644 index 0000000..e1bfd0c --- /dev/null +++ b/tools/map-extract/src/ProbeLight.cs @@ -0,0 +1,76 @@ +using SixLabors.ImageSharp; +using CUE4Parse.FileProvider; +using CUE4Parse.UE4.Assets.Exports; +using CUE4Parse.UE4.Assets.Exports.BuildData; +using CUE4Parse.UE4.Assets.Exports.Component.StaticMesh; +using CUE4Parse.UE4.Assets.Exports.StaticMesh; +using CUE4Parse.UE4.Assets.Exports.Texture; + +namespace GvrMapExtract; + +/// 조사용: 레벨 BuiltData 의 라이트맵 +public static class ProbeLight +{ + public static void Run(IFileProvider provider, string umap) + { + var bd = umap[..^".umap".Length] + "_BuiltData.uasset"; + var pkg = provider.LoadPackage(bd); + var reg = pkg.GetExports().OfType().FirstOrDefault(); + Console.WriteLine($"{bd}: exports {string.Join(',', pkg.GetExports().GroupBy(e => e.ExportType).Select(g => g.Key + "x" + g.Count()))}"); + if (reg == null) return; + Console.WriteLine($"mesh build data {reg.MeshBuildData?.Count} light {reg.LightBuildData?.Count} vlm {reg.LevelPrecomputedVolumetricLightmapBuildData?.Count}"); + var dump = Environment.GetEnvironmentVariable("GVR_LM_DUMP"); + foreach (var t in pkg.GetExports().OfType().Where(t => !t.Name.StartsWith("AOMaterial"))) + { + Console.WriteLine($" tex {t.Name} {t.ExportType} {t.PlatformData?.SizeX}x{t.PlatformData?.SizeY} {t.Format} mips {t.PlatformData?.Mips?.Length} srgb {t.SRGB}"); + if (dump == null) continue; + var c = CUE4Parse_Conversion.Textures.TextureDecoder.Decode(t); + if (c == null) { Console.WriteLine(" decode null"); continue; } + Console.WriteLine($" decoded {c.Width}x{c.Height} {c.PixelFormat} {c.Data.Length}"); + Directory.CreateDirectory(dump); + var px = c.Data; + using var rgb = new SixLabors.ImageSharp.Image(c.Width, c.Height); + using var a = new SixLabors.ImageSharp.Image(c.Width, c.Height); + var bgra = c.PixelFormat == CUE4Parse.UE4.Assets.Exports.Texture.EPixelFormat.PF_B8G8R8A8; + for (var y = 0; y < c.Height; y++) for (var x = 0; x < c.Width; x++) + { + var i = (y * c.Width + x) * 4; + rgb[x, y] = bgra ? new(px[i + 2], px[i + 1], px[i], 255) : new(px[i], px[i + 1], px[i + 2], 255); + a[x, y] = new(px[i + 3]); + } + rgb.SaveAsPng(Path.Combine(dump, t.Name + ".rgb.png")); + a.SaveAsPng(Path.Combine(dump, t.Name + ".a.png")); + } + var n = 0; + foreach (var (g, d) in reg.MeshBuildData ?? new()) + { + if (n++ >= 4) break; + if (d.LightMap is FLightMap2D lm) + Console.WriteLine($" {g}: tex {lm.Textures?[0]?.Name}/{lm.Textures?[1]?.Name} vt {lm.VirtualTextures?[0]?.Name} sky {lm.SkyOcclusionTexture?.Name} scale {string.Join(' ', lm.ScaleVectors!.Select(v => $"({v.X:F3},{v.Y:F3},{v.Z:F3},{v.W:F3})"))} add {string.Join(' ', lm.AddVectors!.Select(v => $"({v.X:F3},{v.Y:F3},{v.Z:F3},{v.W:F3})"))} cs {lm.CoordinateScale} cb {lm.CoordinateBias} inst {d.PerInstanceLightmapData.Length} shadow {d.ShadowMap?.GetType().Name}"); + else Console.WriteLine($" {g}: lightmap {d.LightMap?.GetType().Name ?? "none"} inst {d.PerInstanceLightmapData.Length}"); + } + // 레벨 컴포넌트 → 빌드 데이터 연결 + var lvl = provider.LoadPackage(umap); + int comps = 0, hit = 0, ism = 0, ismHit = 0, lodMulti = 0; + foreach (var lazy in lvl.ExportsLazy) + { + UObject o; + try { o = lazy.Value; } catch { continue; } + if (o is not UStaticMeshComponent c) continue; + comps++; + var ids = c.LODData?.Select(l => l.MapBuildDataId).ToArray() ?? []; + if (ids.Length > 1) lodMulti++; + var ok = ids.Length > 0 && reg.MeshBuildData!.ContainsKey(ids[0]); + if (ok) hit++; + if (c is UInstancedStaticMeshComponent im) { ism++; if (ok) ismHit++; } + if (comps <= 5) + { + UStaticMesh? mesh = null; + try { mesh = c.GetStaticMesh()?.Load(); } catch { } + var lods = mesh?.RenderData?.LODs; + Console.WriteLine($" comp {c.Name} {c.ExportType} lods {ids.Length} [{string.Join(',', ids.Select(i => reg.MeshBuildData!.ContainsKey(i) ? "Y" : "n"))}] mesh {mesh?.Name} lmIdx {mesh?.GetOrDefault("LightMapCoordinateIndex")} lmRes {mesh?.GetOrDefault("LightMapResolution")} meshLods {lods?.Length} uvs {string.Join('/', lods?.Select(l => l.VertexBuffer?.NumTexCoords ?? 0) ?? [])} compLmRes {c.GetOrDefault("OverriddenLightMapRes")}"); + } + } + Console.WriteLine($"comps {comps} with build data {hit}; ism {ism} hit {ismHit}; multi-lod {lodMulti}"); + } +} diff --git a/tools/map-extract/src/Program.cs b/tools/map-extract/src/Program.cs index a330ec1..541bfbf 100644 --- a/tools/map-extract/src/Program.cs +++ b/tools/map-extract/src/Program.cs @@ -24,6 +24,7 @@ using GvrMapExtract; // GVR_MANIFEST 매니페스트 URL (없으면 지금 라이브 패치를 Riot 설정에서 찾는다) // GVR_CACHE_MB 받은 조각을 메모리에 둘 크기 (기본 1500) // GVR_TEX 텍스처 최대 크기 (기본 256) +// GVR_LIGHTMAP 구운 조명 아틀라스 너비 (기본 2048, 넓이도 약 이것의 제곱 안. 0 이면 조명을 넣지 않는다) // GVR_OODLE Oodle 라이브러리 경로 (없으면 실행 파일 옆, 없으면 받는다) Serilog.Log.Logger = new Serilog.LoggerConfiguration().MinimumLevel.Error().WriteTo.Console().CreateLogger(); @@ -102,7 +103,7 @@ switch (args[0]) var r = MapScene.Build(provider, m); r.WriteGlb(provider, Path.Combine(outDir, m.Code + ".glb"), int.Parse(Environment.GetEnvironmentVariable("GVR_TEX") ?? "256")); r.WriteInfo(Path.Combine(outDir, m.Code + ".json"), manifestUrl, usmap); - Console.WriteLine($"{m.Code}: 배치 {r.Placements} · 메시 {r.Meshes} · 삼각형 {r.Triangles} · 재질 {r.Materials} · 텍스처 {r.TextureCount}({r.TextureBytes >> 20}MB, 실패 {r.TextureFailed}) · 빠짐 {r.Skipped} · 실패 {r.Failed} · 받은 양 {(store.DownloadedBytes - d0) >> 20}MB · {(sw.Elapsed - t0).TotalSeconds:F0}초"); + Console.WriteLine($"{m.Code}: 배치 {r.Placements} · 메시 {r.Meshes} · 삼각형 {r.Triangles} · 재질 {r.Materials} · 텍스처 {r.TextureCount}({r.TextureBytes >> 20}MB, 실패 {r.TextureFailed}) · {r.LightmapSummary} · 빠짐 {r.Skipped} · 실패 {r.Failed} · 받은 양 {(store.DownloadedBytes - d0) >> 20}MB · {(sw.Elapsed - t0).TotalSeconds:F0}초"); } catch (Exception e) { @@ -182,6 +183,9 @@ switch (args[0]) case "abilities": // 요원 스킬 3D 재료: abilities.json + m_*.glb + t_*.png (Abilities.cs) return Abilities.Run(provider, args[1], args.Skip(2).ToList(), store); + case "lmprobe": + foreach (var a in args.Skip(1)) ProbeLight.Run(provider, a); + break; case "anim": foreach (var a in args.Skip(1)) ProbeAnim.Anim(provider, a); break;