diff --git a/docs/dev/replay-3d.md b/docs/dev/replay-3d.md index 11bad9c..4f54d3f 100644 --- a/docs/dev/replay-3d.md +++ b/docs/dev/replay-3d.md @@ -58,7 +58,8 @@ - 추출기 `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 (페이지 값은 반 정밀도). + - 13.09 실측: 어센트 페이지 72 → 1864×1360(1/4) 2.5MB, 어비스 116 → 1864×2176(1/4) 3.4MB. 맵 압축 크기 어센트 14.7 → 18.8MB, 어비스 12.1 → 17.4MB. + - 메모리: 배치를 모으는 동안은 칸 목록만 두고 Build 에서 페이지를 하나씩 풀어 바로 줄인다. 처음(모든 페이지를 원래 크기로 들고 있던 것)에는 페이지 200개 넘는 펄(Pitt)이 서비스 한도 6GB 에서 OutOfMemory 였다. 고친 뒤 펄 최대 2.7GB. - 사이트 `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 로 줄여 그림자 가장자리가 흐리다. 움직이는 것(요원)은 구운 조명을 받지 않는다 (볼륨 라이트맵은 아직 안 씀). 어비스 낭떠러지처럼 게임에서 어두운 곳은 그대로 어둡다. diff --git a/tools/map-extract/src/Lightmaps.cs b/tools/map-extract/src/Lightmaps.cs index 3832eb3..d6f341b 100644 --- a/tools/map-extract/src/Lightmaps.cs +++ b/tools/map-extract/src/Lightmaps.cs @@ -10,23 +10,30 @@ namespace GvrMapExtract; /// 게임에 구워 둔 조명(HQ 라이트맵)을 맵 하나에 아틀라스 두 장으로 모은다. /// /// 게임 라이트맵 텍스처(LightMapTexture2D, DXT5)는 위 절반이 계수 0(색 UVW² · 로그 밝기), 아래 절반이 계수 1(SH 방향 · 밝기 나머지)이다. -/// 메시마다(FLightMap2D) 범위(ScaleVectors · AddVectors)가 달라서, 메시가 차지한 칸(UV × CoordinateScale + Bias)마다 그 범위로 풀어 둔다 +/// 메시마다(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) 의 기본 칸(맵 평균 밝기, 방향 없음)을 쓴다. +/// 칸 밖 텍셀은 이웃 값으로 채워(번짐 방지) 줄인 뒤 페이지째 아틀라스에 놓는다. 라이트맵이 없는 배치는 (0,0) 의 기본 칸(맵 평균 밝기, 방향 없음)을 쓴다. +/// +/// 메모리: 배치를 모으는 동안은 텍스처 크기 · 칸 목록만 들고 있다가, Build 에서 페이지를 하나씩 풀어 바로 줄인다 +/// (페이지가 200개 넘는 맵도 원래 크기 값은 한 장 분량만 메모리에 있다). public sealed class Lightmaps { + /// 메시 하나가 차지한 칸: 범위(계수 0 · 1) · 페이지 안 위치 + 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 required byte[] Src; // RGBA, W × 2H - public Half[] Irr = null!, Sh = null!; // 메모리를 줄이려고 반 정밀도 (맵 하나에 페이지 100개 넘게) - public bool[] Valid = null!; + public readonly List Allocs = new(); public int Ox, Oy, Sw, Sh2; // 아틀라스 위치 · 줄인 크기 + public float[]? Irr, Sh; // 줄인 값 (Sw × Sh2 × 3) + public bool[]? Valid; } private readonly List _pages = new(); @@ -37,7 +44,7 @@ public sealed class Lightmaps private const int Pad = 4; // 페이지 사이 여백 (밉맵 번짐 방지) private const int DefaultCell = 8; - /// 라이트맵 텍스처 → 페이지 번호 (못 읽으면 -1) + /// 라이트맵 텍스처 → 페이지 번호 (못 읽으면 -1). 여기서는 크기만 본다 public int Page(FLightMap2D lm) { var idx = lm.Textures?[0]; @@ -47,19 +54,10 @@ public sealed class Lightmaps 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] }); + 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) @@ -70,46 +68,13 @@ public sealed class Lightmaps } } - /// 메시 하나가 차지한 칸을 풀어 둔다 (같은 칸은 한 번만) + /// 메시 하나가 차지한 칸을 적어 둔다 (같은 칸은 한 번만, 푸는 건 Build 에서) 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; - } + _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)); } /// 페이지 공간 UV(0~1) → 아틀라스 UV. page < 0 이면 기본 칸 가운데 @@ -126,33 +91,51 @@ public sealed class Lightmaps 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; /// 아틀라스를 만든다 (너비 maxSide · 넓이 약 maxSide² 안에 들어가게 페이지를 1/2 씩 줄인다). 이 뒤에 ToAtlas 를 쓴다 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(); 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]) + { + 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]) { - 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]; + 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) }; - 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); @@ -164,47 +147,108 @@ public sealed class Lightmaps 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 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 (cnt == 0) + if (p.Valid == null || !p.Valid[k]) { 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); + 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); - 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; + /// 페이지 텍스처를 풀어 칸마다 그 범위로 irr · sh 를 계산한다 (원래 크기) + 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); + } + + /// f×f 평균으로 줄여 페이지에 둔다 (칸 밖 · 채우지 못한 텍셀은 빼고) + 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; + } + } /// 1/f 로 줄인 페이지를 너비 maxSide 선반에 쌓는다 (높은 것부터). 한도 안이면 true private bool Pack(int f, int maxSide) @@ -232,19 +276,19 @@ public sealed class Lightmaps _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) + private static void Dilate(int w, int h, float[] irr, float[] sh, bool[] valid, int passes) { + var add = new List(); 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++) + add.Clear(); + for (var y = 0; y < h; y++) + for (var x = 0; x < w; x++) { - var k = y * p.W + x; - if (p.Valid[k]) continue; + 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++) @@ -252,20 +296,20 @@ public sealed class Lightmaps { 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]; + 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; - 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); + 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) p.Valid[k] = true; + foreach (var k in add) valid[k] = true; } } }