316 lines
15 KiB
C#
316 lines
15 KiB
C#
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;
|
||
|
||
/// <summary>게임에 구워 둔 조명(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) 의 기본 칸(맵 평균 밝기, 방향 없음)을 쓴다.
|
||
///
|
||
/// 메모리: 배치를 모으는 동안은 텍스처 크기 · 칸 목록만 들고 있다가, Build 에서 페이지를 하나씩 풀어 바로 줄인다
|
||
/// (페이지가 200개 넘는 맵도 원래 크기 값은 한 장 분량만 메모리에 있다).</summary>
|
||
public sealed class Lightmaps
|
||
{
|
||
/// <summary>메시 하나가 차지한 칸: 범위(계수 0 · 1) · 페이지 안 위치</summary>
|
||
private readonly record struct Alloc(FVector4 S0, FVector4 A0, FVector4 S1, FVector4 A1, float Bx, float By, float Cx, float Cy);
|
||
|
||
private sealed class PageData
|
||
{
|
||
public required string Key;
|
||
public required UTexture2D Tex;
|
||
public required int W, H; // 계수 하나(텍스처 절반) 크기
|
||
public readonly List<Alloc> Allocs = new();
|
||
public int Ox, Oy, Sw, Sh2; // 아틀라스 위치 · 줄인 크기
|
||
public float[]? Irr, Sh; // 줄인 값 (Sw × Sh2 × 3)
|
||
public bool[]? Valid;
|
||
}
|
||
|
||
private readonly List<PageData> _pages = new();
|
||
private readonly Dictionary<string, int> _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;
|
||
|
||
/// <summary>라이트맵 텍스처 → 페이지 번호 (못 읽으면 -1). 여기서는 크기만 본다</summary>
|
||
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<UTexture2D>();
|
||
var w = t?.PlatformData?.SizeX ?? 0;
|
||
var h = (t?.PlatformData?.SizeY ?? 0) / 2;
|
||
if (t == null || w < 1 || h < 1) { Failed++; return _byKey[key] = -1; }
|
||
_pages.Add(new PageData { Key = key, Tex = t, W = w, H = 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;
|
||
}
|
||
}
|
||
|
||
/// <summary>메시 하나가 차지한 칸을 적어 둔다 (같은 칸은 한 번만, 푸는 건 Build 에서)</summary>
|
||
public void Allocate(int page, FLightMap2D lm, FVector2D bias)
|
||
{
|
||
if (page < 0 || !_done.Add((page, bias.X, bias.Y))) return;
|
||
Allocations++;
|
||
var cs = lm.CoordinateScale ?? new FVector2D(1, 1);
|
||
_pages[page].Allocs.Add(new Alloc(lm.ScaleVectors![0], lm.AddVectors![0], lm.ScaleVectors![1], lm.AddVectors![1], bias.X, bias.Y, cs.X, cs.Y));
|
||
}
|
||
|
||
/// <summary>페이지 공간 UV(0~1) → 아틀라스 UV. page < 0 이면 기본 칸 가운데</summary>
|
||
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;
|
||
public int Factor { get; private set; } = 1;
|
||
public int Pages => _pages.Count;
|
||
|
||
/// <summary>아틀라스를 만든다 (너비 maxSide · 넓이 약 maxSide² 안에 들어가게 페이지를 1/2 씩 줄인다). 이 뒤에 ToAtlas 를 쓴다</summary>
|
||
public (byte[] irr, byte[] sh)? Build(int maxSide)
|
||
{
|
||
if (_pages.Count == 0) return null;
|
||
// 줄이는 배율: 너비 maxSide · 높이 2×maxSide · 넓이 1.25×maxSide² 안에 들어갈 때까지 1/2 씩
|
||
var f = 1;
|
||
while (!Pack(f, maxSide) && f < 64) f *= 2;
|
||
Factor = f;
|
||
|
||
// 페이지마다: 풀기 → 칸 밖 채우기 → 줄이기 (원래 크기 값은 한 장 분량만)
|
||
var lum = new List<float>();
|
||
double sr = 0, sg = 0, sb = 0;
|
||
long n = 0;
|
||
foreach (var p in _pages)
|
||
{
|
||
float[] irrF, shF;
|
||
bool[] valid;
|
||
try
|
||
{
|
||
(irrF, shF, valid) = Decode(p);
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Failed++;
|
||
if (Failed <= 5) Console.Error.WriteLine($"라이트맵 실패 {p.Key}: {e.GetType().Name} {e.Message}");
|
||
continue; // 이 페이지는 평균 밝기로 남는다
|
||
}
|
||
for (var i = 0; i < valid.Length; i++)
|
||
if (valid[i])
|
||
{
|
||
if ((i & 7) == 0) lum.Add(MathF.Max(irrF[i * 3], MathF.Max(irrF[i * 3 + 1], irrF[i * 3 + 2])));
|
||
sr += irrF[i * 3]; sg += irrF[i * 3 + 1]; sb += irrF[i * 3 + 2];
|
||
n++;
|
||
}
|
||
Dilate(p.W, p.H, irrF, shF, valid, 8);
|
||
Shrink(p, f, irrF, shF, valid);
|
||
}
|
||
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) };
|
||
|
||
using var irr = new Image<Rgb24>(_atlasW, _atlasH);
|
||
using var sh = new Image<Rgb24>(_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)
|
||
{
|
||
// 여백은 가장자리 값으로
|
||
for (var y = -Pad; y < p.Sh2 + Pad; y++)
|
||
for (var x = -Pad; x < p.Sw + Pad; x++)
|
||
{
|
||
var k = Math.Clamp(y, 0, p.Sh2 - 1) * p.Sw + Math.Clamp(x, 0, p.Sw - 1);
|
||
var ax = p.Ox + x;
|
||
var ay = p.Oy + y;
|
||
if (p.Valid == null || !p.Valid[k])
|
||
{
|
||
irr[ax, ay] = IrrPx(avg[0], avg[1], avg[2]);
|
||
continue;
|
||
}
|
||
irr[ax, ay] = IrrPx(p.Irr![k * 3], p.Irr[k * 3 + 1], p.Irr[k * 3 + 2]);
|
||
sh[ax, ay] = ShPx(p.Sh![k * 3], p.Sh[k * 3 + 1], p.Sh[k * 3 + 2]);
|
||
}
|
||
p.Irr = p.Sh = null;
|
||
p.Valid = null;
|
||
}
|
||
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);
|
||
return (mi.ToArray(), ms.ToArray());
|
||
}
|
||
|
||
/// <summary>페이지 텍스처를 풀어 칸마다 그 범위로 irr · sh 를 계산한다 (원래 크기)</summary>
|
||
private static (float[] irr, float[] sh, bool[] valid) Decode(PageData p)
|
||
{
|
||
var c = CUE4Parse_Conversion.Textures.TextureDecoder.Decode(p.Tex) ?? throw new InvalidDataException("텍스처를 못 풂");
|
||
var bgra = c.PixelFormat == EPixelFormat.PF_B8G8R8A8;
|
||
if (!bgra && c.PixelFormat != EPixelFormat.PF_R8G8B8A8) throw new InvalidDataException("형식 " + c.PixelFormat);
|
||
if (c.Width != p.W || c.Height < p.H * 2 || c.Data.Length < c.Width * c.Height * 4) throw new InvalidDataException($"크기 {c.Width}x{c.Height}");
|
||
var src = c.Data;
|
||
int R = bgra ? 2 : 0, B = bgra ? 0 : 2;
|
||
var irr = new float[p.W * p.H * 3];
|
||
var sh = new float[p.W * p.H * 3];
|
||
var valid = new bool[p.W * p.H];
|
||
const float LogBlackPoint = 0.01858136f;
|
||
float C(int i) => src[i] / 255f;
|
||
foreach (var a in p.Allocs)
|
||
{
|
||
// 칸 + 1 텍셀 (UE 는 칸 둘레에 여백을 두고 구운 값을 채운다)
|
||
var x0 = Math.Max(0, (int)Math.Floor(a.Bx * p.W) - 1);
|
||
var y0 = Math.Max(0, (int)Math.Floor(a.By * p.H) - 1);
|
||
var x1 = Math.Min(p.W, (int)Math.Ceiling((a.Bx + a.Cx) * p.W) + 1);
|
||
var y1 = Math.Min(p.H, (int)Math.Ceiling((a.By + a.Cy) * p.H) + 1);
|
||
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;
|
||
var logL = C(i0 + 3) + C(i1 + 3) / 255f - 0.5f / 255f;
|
||
logL = logL * a.S0.W + a.A0.W;
|
||
var l = MathF.Max(0, MathF.Pow(2, logL) - LogBlackPoint);
|
||
var r = C(i0 + R) * C(i0 + R) * a.S0.X + a.A0.X;
|
||
var g = C(i0 + 1) * C(i0 + 1) * a.S0.Y + a.A0.Y;
|
||
var b = C(i0 + B) * C(i0 + B) * a.S0.Z + a.A0.Z;
|
||
var l0 = C(i1 + 3) * a.S1.W + a.A1.W;
|
||
if (l0 < 1e-4f) l0 = 0.282095f;
|
||
var o = (y * p.W + x) * 3;
|
||
irr[o] = MathF.Max(0, l * r * l0);
|
||
irr[o + 1] = MathF.Max(0, l * g * l0);
|
||
irr[o + 2] = MathF.Max(0, l * b * l0);
|
||
sh[o] = (C(i1 + R) * a.S1.X + a.A1.X) / l0;
|
||
sh[o + 1] = (C(i1 + 1) * a.S1.Y + a.A1.Y) / l0;
|
||
sh[o + 2] = (C(i1 + B) * a.S1.Z + a.A1.Z) / l0;
|
||
valid[y * p.W + x] = true;
|
||
}
|
||
}
|
||
return (irr, sh, valid);
|
||
}
|
||
|
||
/// <summary>f×f 평균으로 줄여 페이지에 둔다 (칸 밖 · 채우지 못한 텍셀은 빼고)</summary>
|
||
private static void Shrink(PageData p, int f, float[] irrF, float[] shF, bool[] validF)
|
||
{
|
||
p.Irr = new float[p.Sw * p.Sh2 * 3];
|
||
p.Sh = new float[p.Sw * p.Sh2 * 3];
|
||
p.Valid = new bool[p.Sw * p.Sh2];
|
||
for (var y = 0; y < p.Sh2; y++)
|
||
for (var x = 0; x < p.Sw; x++)
|
||
{
|
||
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, x * f + dx);
|
||
var py = Math.Min(p.H - 1, y * f + dy);
|
||
var k = py * p.W + px;
|
||
if (!validF[k]) continue;
|
||
r += irrF[k * 3]; g += irrF[k * 3 + 1]; b += irrF[k * 3 + 2];
|
||
hx += shF[k * 3]; hy += shF[k * 3 + 1]; hz += shF[k * 3 + 2];
|
||
cnt++;
|
||
}
|
||
if (cnt == 0) continue;
|
||
var o = (y * p.Sw + x) * 3;
|
||
p.Irr[o] = r / cnt; p.Irr[o + 1] = g / cnt; p.Irr[o + 2] = b / cnt;
|
||
p.Sh[o] = hx / cnt; p.Sh[o + 1] = hy / cnt; p.Sh[o + 2] = hz / cnt;
|
||
p.Valid[y * p.Sw + x] = true;
|
||
}
|
||
}
|
||
|
||
/// <summary>1/f 로 줄인 페이지를 너비 maxSide 선반에 쌓는다 (높은 것부터). 한도 안이면 true</summary>
|
||
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;
|
||
}
|
||
|
||
/// <summary>칸 밖 텍셀을 이웃 칸 값으로 채운다 (줄이기 · 선형 보간에서 검은 테두리가 번지지 않게)</summary>
|
||
private static void Dilate(int w, int h, float[] irr, float[] sh, bool[] valid, int passes)
|
||
{
|
||
var add = new List<int>();
|
||
for (var pass = 0; pass < passes; pass++)
|
||
{
|
||
add.Clear();
|
||
for (var y = 0; y < h; y++)
|
||
for (var x = 0; x < w; x++)
|
||
{
|
||
var k = y * w + x;
|
||
if (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 >= w || ny >= h) continue;
|
||
var j = ny * w + nx;
|
||
if (!valid[j]) continue;
|
||
r += irr[j * 3]; g += irr[j * 3 + 1]; b += irr[j * 3 + 2];
|
||
hx += sh[j * 3]; hy += sh[j * 3 + 1]; hz += sh[j * 3 + 2];
|
||
cnt++;
|
||
}
|
||
if (cnt == 0) continue;
|
||
irr[k * 3] = r / cnt; irr[k * 3 + 1] = g / cnt; irr[k * 3 + 2] = b / cnt;
|
||
sh[k * 3] = hx / cnt; sh[k * 3 + 1] = hy / cnt; sh[k * 3 + 2] = hz / cnt;
|
||
add.Add(k);
|
||
}
|
||
if (add.Count == 0) break;
|
||
foreach (var k in add) valid[k] = true;
|
||
}
|
||
}
|
||
}
|