라이트맵 추출 메모리: 칸 목록만 모으고 Build 에서 페이지를 하나씩 풀어 바로 줄인다 (펄 맵이 6GB 한도에서 OutOfMemory 이던 것, 고친 뒤 최대 2.7GB)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
EJClaw
2026-10-29 16:41:06 +09:00
parent 185e8c17bd
commit 33e83256ed
2 changed files with 147 additions and 102 deletions

View File

@@ -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 로 줄여 그림자 가장자리가 흐리다. 움직이는 것(요원)은 구운 조명을 받지 않는다 (볼륨 라이트맵은 아직 안 씀). 어비스 낭떠러지처럼 게임에서 어두운 곳은 그대로 어둡다.

View File

@@ -10,23 +10,30 @@ namespace GvrMapExtract;
/// <summary>게임에 구워 둔 조명(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) 의 기본 칸(맵 평균 밝기, 방향 없음)을 쓴다.</summary>
/// 칸 밖 텍셀은 이웃 값으로 채워(번짐 방지) 줄인 뒤 페이지째 아틀라스에 놓는다. 라이트맵이 없는 배치는 (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 required byte[] Src; // RGBA, W × 2H
public Half[] Irr = null!, Sh = null!; // 메모리를 줄이려고 반 정밀도 (맵 하나에 페이지 100개 넘게)
public bool[] Valid = null!;
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();
@@ -37,7 +44,7 @@ public sealed class Lightmaps
private const int Pad = 4; // 페이지 사이 여백 (밉맵 번짐 방지)
private const int DefaultCell = 8;
/// <summary>라이트맵 텍스처 → 페이지 번호 (못 읽으면 -1)</summary>
/// <summary>라이트맵 텍스처 → 페이지 번호 (못 읽으면 -1). 여기서는 크기만 본다</summary>
public int Page(FLightMap2D lm)
{
var idx = lm.Textures?[0];
@@ -47,19 +54,10 @@ public sealed class Lightmaps
try
{
var t = idx.Load<UTexture2D>();
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
}
}
/// <summary>메시 하나가 차지한 칸을 풀어 둔다 (같은 칸은 한 번만)</summary>
/// <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 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));
}
/// <summary>페이지 공간 UV(0~1) → 아틀라스 UV. page &lt; 0 이면 기본 칸 가운데</summary>
@@ -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;
/// <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)
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<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);
@@ -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;
/// <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)
@@ -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;
/// <summary>칸 밖 텍셀을 이웃 칸 값으로 채운다 (줄이기 · 선형 보간에서 검은 테두리가 번지지 않게)</summary>
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<int>();
for (var pass = 0; pass < passes; pass++)
{
var add = new List<int>();
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;
}
}
}