590 lines
34 KiB
C#
590 lines
34 KiB
C#
// ─────────────────────────────────────────────────────────────────────────────
|
||
// WL876_NpcPaletteBake.cs — 상인 NPC(Peasant Nolant)를 PC 와 같은 「팔레트 UV(도트) + 툰」 아트풍으로 굽기 (2026-10-15 PD #876)
|
||
//
|
||
// PD 「상인 NPC 의 크기를 플레이어 크기를 기준으로 더 크게 키우고 쉐이더나 텍스쳐를 개선해 캐릭터와 같은 아트 풍을 낼 수 있도록
|
||
// 수정해줘. (기존 캐릭터 디자인 변경했던 방법과 동일한 방법을 사용하면 됨)」
|
||
//
|
||
// ■ 기존 방법 = WL-814x(PC) · WL-816b(무기) 굽기와 같다
|
||
// 면 평균색(원본 텍스처) → 이웃 면을 Lab 색차로 덩어리 병합 → k-means 팔레트 → 칸 H 원본 복원(±8° 클램프) →
|
||
// 면 UV 를 팔레트 칸 한가운데로(면이 영구 단색) · 팔레트 32×32 · 칸 8 px · Point · 밉 OFF · 무압축 ·
|
||
// 재질 = PC 팔레트 재질 `M05_ToonP`(Shader Graphs/Toon · 외곽선) 사본 + _BaseMap 만 이 팔레트.
|
||
// ■ 다른 점(스킨 메시) — 정점 복제 때 뼈 가중치·바인드포즈를 그대로 옮긴다(애니메이션 유지).
|
||
// ■ 얼굴 — PC 와 같은 구성: 피부는 팔레트(머리 = `Skin_ToonP` 처럼 단색), 눈·눈썹·입은 **투명 얼굴 데칼**
|
||
// (PC `face02_ToonS` = Unlit/Transparent 와 같은 셰이더) — 얼굴 칸(UV 왼쪽 위) 삼각형만 따로 떼어 데칼 메시로,
|
||
// 원본 텍스처에서 피부와 색차가 큰 픽셀만 남긴 작은 텍스처(256²)를 입힌다.
|
||
// 🔴 원본(Assets/Stylized NPC - Peasant Nolant/**)은 읽기만 한다 — 산출물은 전부 Assets/WL/Island/NPC/ 아래.
|
||
//
|
||
// 실행 = unity command run_script --file AgentScripts/WL876_NpcPaletteBake.cs --entry WL876NpcBake.Run
|
||
// --args "[\"Yellow\", 40, 6, 16, 10, 24]" (색 · 몸 덩어리 · 모자 덩어리 · 팔레트 칸 · 데칼 색차 시작 · 끝)
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Text;
|
||
using UnityEditor;
|
||
using UnityEngine;
|
||
|
||
public static class WL876NpcBake
|
||
{
|
||
const string SRC = "Assets/Stylized NPC - Peasant Nolant";
|
||
const string OUT = "Assets/WL/Island/NPC/";
|
||
const int CELL = 8;
|
||
const float HUE_LIMIT = 8f;
|
||
static readonly StringBuilder sb = new StringBuilder();
|
||
static void L(string s) { sb.AppendLine(s); }
|
||
|
||
// ───────────────────────────── 색공간 (816b 와 같은 식)
|
||
static float S2L(float c) { return c <= 0.04045f ? c / 12.92f : Mathf.Pow((c + 0.055f) / 1.055f, 2.4f); }
|
||
struct Lab { public float L, a, b; }
|
||
static Lab ToLab(Vector3 srgb)
|
||
{
|
||
var lin = new Vector3(S2L(srgb.x), S2L(srgb.y), S2L(srgb.z));
|
||
float x = 0.4124f * lin.x + 0.3576f * lin.y + 0.1805f * lin.z;
|
||
float y = 0.2126f * lin.x + 0.7152f * lin.y + 0.0722f * lin.z;
|
||
float z = 0.0193f * lin.x + 0.1192f * lin.y + 0.9505f * lin.z;
|
||
x /= 0.95047f; z /= 1.08883f;
|
||
Func<float, float> f = t => t > 0.008856f ? Mathf.Pow(t, 1f / 3f) : (7.787f * t + 16f / 116f);
|
||
float fx = f(x), fy = f(y), fz = f(z);
|
||
return new Lab { L = 116f * fy - 16f, a = 500f * (fx - fy), b = 200f * (fy - fz) };
|
||
}
|
||
static float LabD(Lab p, Lab q) { float dl = p.L - q.L, da = p.a - q.a, db = p.b - q.b; return Mathf.Sqrt(dl * dl + da * da + db * db); }
|
||
static void RgbToHsv(Vector3 c, out float h, out float s, out float v)
|
||
{
|
||
float r = c.x, g = c.y, b = c.z;
|
||
float mx = Mathf.Max(r, Mathf.Max(g, b)), mn = Mathf.Min(r, Mathf.Min(g, b)), d = mx - mn;
|
||
h = 0f;
|
||
if (d > 1e-6f)
|
||
{
|
||
if (mx == r) h = ((g - b) / d + 6f) % 6f;
|
||
else if (mx == g) h = (b - r) / d + 2f;
|
||
else h = (r - g) / d + 4f;
|
||
}
|
||
h *= 60f; s = mx > 1e-6f ? d / mx : 0f; v = mx;
|
||
}
|
||
static Vector3 HsvToRgb(float h, float s, float v)
|
||
{
|
||
var c = Color.HSVToRGB(((h % 360f) + 360f) % 360f / 360f, Mathf.Clamp01(s), Mathf.Clamp01(v), false);
|
||
return new Vector3(c.r, c.g, c.b);
|
||
}
|
||
static float DHue(float a, float b) { return (b - a + 540f) % 360f - 180f; }
|
||
|
||
// ───────────────────────────── 텍스처 (디스크 원본 PNG · 무압축)
|
||
class Tex { public int w, h; public Vector3[] px; }
|
||
static Tex LoadPng(string path)
|
||
{
|
||
var tmp = new Texture2D(2, 2, TextureFormat.RGBA32, false);
|
||
tmp.LoadImage(File.ReadAllBytes(path));
|
||
var p32 = tmp.GetPixels32();
|
||
var t = new Tex { w = tmp.width, h = tmp.height, px = new Vector3[p32.Length] };
|
||
for (int i = 0; i < p32.Length; i++) t.px[i] = new Vector3(p32[i].r / 255f, p32[i].g / 255f, p32[i].b / 255f);
|
||
UnityEngine.Object.DestroyImmediate(tmp);
|
||
return t;
|
||
}
|
||
static Vector3 Sample(Tex t, float u, float v)
|
||
{
|
||
int x = Mathf.Clamp(Mathf.FloorToInt(u * t.w), 0, t.w - 1);
|
||
int y = Mathf.Clamp(Mathf.FloorToInt(v * t.h), 0, t.h - 1);
|
||
return t.px[y * t.w + x];
|
||
}
|
||
static Vector3 SampleBilinear(Tex t, float u, float v)
|
||
{
|
||
float x = u * t.w - 0.5f, y = v * t.h - 0.5f;
|
||
int x0 = Mathf.Clamp(Mathf.FloorToInt(x), 0, t.w - 1), y0 = Mathf.Clamp(Mathf.FloorToInt(y), 0, t.h - 1);
|
||
int x1 = Mathf.Min(x0 + 1, t.w - 1), y1 = Mathf.Min(y0 + 1, t.h - 1);
|
||
float fx = Mathf.Clamp01(x - x0), fy = Mathf.Clamp01(y - y0);
|
||
var a = Vector3.Lerp(t.px[y0 * t.w + x0], t.px[y0 * t.w + x1], fx);
|
||
var b = Vector3.Lerp(t.px[y1 * t.w + x0], t.px[y1 * t.w + x1], fx);
|
||
return Vector3.Lerp(a, b, fy);
|
||
}
|
||
static Vector3 TriAvg(Tex tex, Vector2 a, Vector2 b, Vector2 c)
|
||
{
|
||
float au = a.x * tex.w, av = a.y * tex.h, bu = b.x * tex.w, bv = b.y * tex.h, cu = c.x * tex.w, cv = c.y * tex.h;
|
||
float areaTexels = Mathf.Abs((bu - au) * (cv - av) - (cu - au) * (bv - av)) * 0.5f;
|
||
int n = Mathf.Clamp(Mathf.CeilToInt(Mathf.Sqrt(areaTexels)) * 2, 8, 64);
|
||
Vector3 sum = Vector3.zero; int cnt = 0;
|
||
for (int i = 0; i < n; i++)
|
||
for (int j = 0; j < n - i; j++)
|
||
{
|
||
float w0 = (i + 1f / 3f) / n, w1 = (j + 1f / 3f) / n;
|
||
if (1f - w0 - w1 < 0f) continue;
|
||
var uv = a * (1f - w0 - w1) + b * w0 + c * w1;
|
||
sum += Sample(tex, uv.x, uv.y); cnt++;
|
||
}
|
||
return cnt == 0 ? Sample(tex, (a.x + b.x + c.x) / 3f, (a.y + b.y + c.y) / 3f) : sum / cnt;
|
||
}
|
||
|
||
// ───────────────────────────── 덩어리 병합 (816b 와 같은 식)
|
||
class Face { public int i0, i1, i2; public Vector3 col; public float area; }
|
||
class Region { public Vector3 sum; public float area; public int count; public float hx, hy, sw; public Vector3 Col { get { return sum / Mathf.Max(area, 1e-9f); } } }
|
||
static long Key(Vector3 v)
|
||
{
|
||
long x = (long)Mathf.RoundToInt(v.x * 100000f) & 0x1FFFFF;
|
||
long y = (long)Mathf.RoundToInt(v.y * 100000f) & 0x1FFFFF;
|
||
long z = (long)Mathf.RoundToInt(v.z * 100000f) & 0x1FFFFF;
|
||
return (x << 42) | (y << 21) | z;
|
||
}
|
||
static int Find(int[] uf, int i) { while (uf[i] != i) { uf[i] = uf[uf[i]]; i = uf[i]; } return i; }
|
||
static float Cost(Region a, Region b)
|
||
{
|
||
float d = LabD(ToLab(a.Col), ToLab(b.Col));
|
||
float w = (a.area * b.area) / Mathf.Max(a.area + b.area, 1e-9f);
|
||
return d * d * w;
|
||
}
|
||
static void AccHue(Region r, Vector3 c, float area)
|
||
{
|
||
float h, s, v; RgbToHsv(c, out h, out s, out v);
|
||
float w = s * area;
|
||
r.hx += w * Mathf.Cos(h * Mathf.Deg2Rad); r.hy += w * Mathf.Sin(h * Mathf.Deg2Rad); r.sw += w;
|
||
}
|
||
static int Merge(int[] uf, Region[] reg, List<KeyValuePair<int, int>> adj, int target)
|
||
{
|
||
var ver = new int[uf.Length];
|
||
var pq = new SortedSet<(float cost, int a, int b, int va, int vb)>(Comparer<(float, int, int, int, int)>.Create((p, q) =>
|
||
{
|
||
int c = p.Item1.CompareTo(q.Item1); if (c != 0) return c;
|
||
c = p.Item2.CompareTo(q.Item2); if (c != 0) return c;
|
||
c = p.Item3.CompareTo(q.Item3); if (c != 0) return c;
|
||
c = p.Item4.CompareTo(q.Item4); if (c != 0) return c;
|
||
return p.Item5.CompareTo(q.Item5);
|
||
}));
|
||
var nb = new Dictionary<int, HashSet<int>>();
|
||
foreach (var e in adj)
|
||
{
|
||
HashSet<int> sa, sbb;
|
||
if (!nb.TryGetValue(e.Key, out sa)) { sa = new HashSet<int>(); nb[e.Key] = sa; }
|
||
if (!nb.TryGetValue(e.Value, out sbb)) { sbb = new HashSet<int>(); nb[e.Value] = sbb; }
|
||
sa.Add(e.Value); sbb.Add(e.Key);
|
||
}
|
||
foreach (var kv in nb) foreach (var o in kv.Value) if (kv.Key < o) pq.Add((Cost(reg[kv.Key], reg[o]), kv.Key, o, 0, 0));
|
||
int count = uf.Length;
|
||
while (count > target && pq.Count > 0)
|
||
{
|
||
var e = pq.Min; pq.Remove(e);
|
||
int a = Find(uf, e.a), b = Find(uf, e.b);
|
||
if (a == b) continue;
|
||
int lo = Mathf.Min(a, b), hi = Mathf.Max(a, b);
|
||
if (ver[a] != e.va || ver[b] != e.vb) { pq.Add((Cost(reg[a], reg[b]), lo, hi, ver[lo], ver[hi])); continue; }
|
||
if (count <= 2) break;
|
||
uf[b] = a;
|
||
reg[a].sum += reg[b].sum; reg[a].area += reg[b].area; reg[a].count += reg[b].count;
|
||
reg[a].hx += reg[b].hx; reg[a].hy += reg[b].hy; reg[a].sw += reg[b].sw;
|
||
ver[a]++; count--;
|
||
HashSet<int> sb2;
|
||
if (nb.TryGetValue(b, out sb2))
|
||
{
|
||
HashSet<int> sa2;
|
||
if (!nb.TryGetValue(a, out sa2)) { sa2 = new HashSet<int>(); nb[a] = sa2; }
|
||
foreach (var o in sb2)
|
||
{
|
||
int r = Find(uf, o); if (r == a) continue;
|
||
sa2.Add(r);
|
||
HashSet<int> sr; if (nb.TryGetValue(r, out sr)) sr.Add(a);
|
||
int l2 = Mathf.Min(a, r), h2 = Mathf.Max(a, r);
|
||
pq.Add((Cost(reg[a], reg[r]), l2, h2, ver[l2], ver[h2]));
|
||
}
|
||
}
|
||
}
|
||
return count;
|
||
}
|
||
static Vector3[] KMeans(Vector3[] cols, float[] wts, int k)
|
||
{
|
||
int n = cols.Length;
|
||
var labs = cols.Select(ToLab).ToArray();
|
||
var cent = new Lab[k]; var centRgb = new Vector3[k];
|
||
var rnd = new System.Random(12345);
|
||
var d2 = new float[n];
|
||
int first = 0; float bw = -1;
|
||
for (int i = 0; i < n; i++) if (wts[i] > bw) { bw = wts[i]; first = i; }
|
||
cent[0] = labs[first]; centRgb[0] = cols[first];
|
||
for (int j = 1; j < k; j++)
|
||
{
|
||
double tot = 0;
|
||
for (int i = 0; i < n; i++)
|
||
{
|
||
float best = float.MaxValue;
|
||
for (int q = 0; q < j; q++) { float d = LabD(labs[i], cent[q]); if (d < best) best = d; }
|
||
d2[i] = best * best * wts[i]; tot += d2[i];
|
||
}
|
||
double pick = rnd.NextDouble() * tot, acc = 0; int sel = n - 1;
|
||
for (int i = 0; i < n; i++) { acc += d2[i]; if (acc >= pick) { sel = i; break; } }
|
||
cent[j] = labs[sel]; centRgb[j] = cols[sel];
|
||
}
|
||
var asg = new int[n];
|
||
for (int it = 0; it < 80; it++)
|
||
{
|
||
bool ch = false;
|
||
for (int i = 0; i < n; i++)
|
||
{
|
||
float bd = float.MaxValue; int bj = 0;
|
||
for (int j = 0; j < k; j++) { float d = LabD(labs[i], cent[j]); if (d < bd) { bd = d; bj = j; } }
|
||
if (asg[i] != bj) { asg[i] = bj; ch = true; }
|
||
}
|
||
var sumRgb = new Vector3[k]; var sw = new double[k];
|
||
for (int i = 0; i < n; i++) { sumRgb[asg[i]] += cols[i] * wts[i]; sw[asg[i]] += wts[i]; }
|
||
for (int j = 0; j < k; j++) if (sw[j] > 1e-9) { centRgb[j] = sumRgb[j] / (float)sw[j]; cent[j] = ToLab(centRgb[j]); }
|
||
if (!ch) break;
|
||
}
|
||
return centRgb;
|
||
}
|
||
|
||
// ───────────────────────────── 메시 1개 분석
|
||
class MeshWork
|
||
{
|
||
public string name; public Mesh src; public Vector3[] vt; public Vector2[] uv; public int[] tr;
|
||
public List<Face> faces; public int[] uf; public Region[] reg; public List<int> roots; public int regions;
|
||
public int[] assign; // roots 인덱스 → 팔레트
|
||
}
|
||
|
||
static MeshWork Analyze(string name, Mesh src, Tex tex, int chunkTarget)
|
||
{
|
||
var w = new MeshWork { name = name, src = src, vt = src.vertices, uv = src.uv, tr = src.triangles };
|
||
w.faces = new List<Face>(w.tr.Length / 3);
|
||
for (int t = 0; t < w.tr.Length; t += 3)
|
||
{
|
||
int a = w.tr[t], b = w.tr[t + 1], c = w.tr[t + 2];
|
||
w.faces.Add(new Face { i0 = a, i1 = b, i2 = c, area = Vector3.Cross(w.vt[b] - w.vt[a], w.vt[c] - w.vt[a]).magnitude * 0.5f, col = TriAvg(tex, w.uv[a], w.uv[b], w.uv[c]) });
|
||
}
|
||
var map = new Dictionary<long, int>(); var weld = new int[w.vt.Length];
|
||
for (int i = 0; i < w.vt.Length; i++) { long k = Key(w.vt[i]); int id; if (!map.TryGetValue(k, out id)) { id = map.Count; map[k] = id; } weld[i] = id; }
|
||
var edgeMap = new Dictionary<long, int>(); var adj = new List<KeyValuePair<int, int>>();
|
||
for (int f = 0; f < w.faces.Count; f++)
|
||
{
|
||
var fa = w.faces[f]; int[] ii = { weld[fa.i0], weld[fa.i1], weld[fa.i2] };
|
||
for (int e = 0; e < 3; e++)
|
||
{
|
||
int p = ii[e], q = ii[(e + 1) % 3];
|
||
long k = p < q ? ((long)p << 32) | (uint)q : ((long)q << 32) | (uint)p;
|
||
int other;
|
||
if (edgeMap.TryGetValue(k, out other)) { if (other != f) adj.Add(new KeyValuePair<int, int>(other, f)); }
|
||
else edgeMap[k] = f;
|
||
}
|
||
}
|
||
w.reg = new Region[w.faces.Count]; w.uf = new int[w.faces.Count];
|
||
for (int i = 0; i < w.faces.Count; i++)
|
||
{
|
||
w.uf[i] = i;
|
||
var r = new Region { sum = w.faces[i].col * w.faces[i].area, area = w.faces[i].area, count = 1 };
|
||
AccHue(r, w.faces[i].col, w.faces[i].area);
|
||
w.reg[i] = r;
|
||
}
|
||
w.regions = Merge(w.uf, w.reg, adj, chunkTarget);
|
||
w.roots = new List<int>();
|
||
var seen = new HashSet<int>();
|
||
for (int i = 0; i < w.faces.Count; i++) { int r = Find(w.uf, i); if (seen.Add(r)) w.roots.Add(r); }
|
||
return w;
|
||
}
|
||
|
||
// ───────────────────────────── 팔레트 메시 (스킨 정보 보존)
|
||
static Mesh BuildPaletteMesh(MeshWork w, int G)
|
||
{
|
||
var src = w.src; var vt = w.vt; var nmv = src.normals; var tg = src.tangents; var bwt = src.boneWeights;
|
||
var rootIndex = new Dictionary<int, int>(); for (int i = 0; i < w.roots.Count; i++) rootIndex[w.roots[i]] = i;
|
||
var map = new Dictionary<long, int>();
|
||
var nv = new List<Vector3>(); var nn = new List<Vector3>(); var nt = new List<Vector4>(); var nuv = new List<Vector2>(); var nbw = new List<BoneWeight>(); var ntri = new List<int>();
|
||
Func<int, int, int> get = (vi, pal) =>
|
||
{
|
||
long k = ((long)vi << 16) | (uint)pal; int id;
|
||
if (map.TryGetValue(k, out id)) return id;
|
||
id = nv.Count; map[k] = id;
|
||
nv.Add(vt[vi]);
|
||
if (nmv != null && nmv.Length == vt.Length) nn.Add(nmv[vi]);
|
||
if (tg != null && tg.Length == vt.Length) nt.Add(tg[vi]);
|
||
if (bwt != null && bwt.Length == vt.Length) nbw.Add(bwt[vi]);
|
||
nuv.Add(new Vector2((pal % G + 0.5f) / G, (pal / G + 0.5f) / G));
|
||
return id;
|
||
};
|
||
for (int f = 0; f < w.faces.Count; f++)
|
||
{
|
||
int pal = w.assign[rootIndex[Find(w.uf, f)]];
|
||
var fa = w.faces[f];
|
||
ntri.Add(get(fa.i0, pal)); ntri.Add(get(fa.i1, pal)); ntri.Add(get(fa.i2, pal));
|
||
}
|
||
var mesh = new Mesh { name = "WL_Nolant_" + w.name + "_PAL" };
|
||
mesh.indexFormat = nv.Count > 65000 ? UnityEngine.Rendering.IndexFormat.UInt32 : UnityEngine.Rendering.IndexFormat.UInt16;
|
||
mesh.SetVertices(nv);
|
||
if (nn.Count == nv.Count) mesh.SetNormals(nn);
|
||
if (nt.Count == nv.Count) mesh.SetTangents(nt);
|
||
mesh.SetUVs(0, nuv);
|
||
mesh.SetTriangles(ntri, 0);
|
||
if (nbw.Count == nv.Count) mesh.boneWeights = nbw.ToArray();
|
||
mesh.bindposes = src.bindposes;
|
||
mesh.bounds = src.bounds;
|
||
return mesh;
|
||
}
|
||
|
||
// ───────────────────────────── 얼굴 데칼 (PC face02 처럼 투명 위 눈·눈썹·입)
|
||
static Mesh BuildDecalMesh(MeshWork w, List<int> faceTris, Rect uvRect, float offset)
|
||
{
|
||
var src = w.src; var vt = w.vt; var nmv = src.normals; var bwt = src.boneWeights;
|
||
var map = new Dictionary<int, int>();
|
||
var nv = new List<Vector3>(); var nn = new List<Vector3>(); var nuv = new List<Vector2>(); var nbw = new List<BoneWeight>(); var ntri = new List<int>();
|
||
foreach (var f in faceTris)
|
||
{
|
||
var fa = w.faces[f];
|
||
foreach (var vi in new[] { fa.i0, fa.i1, fa.i2 })
|
||
{
|
||
int id;
|
||
if (!map.TryGetValue(vi, out id))
|
||
{
|
||
id = nv.Count; map[vi] = id;
|
||
var n = nmv != null && nmv.Length == vt.Length ? nmv[vi] : Vector3.zero;
|
||
nv.Add(vt[vi] + n.normalized * offset); // 피부 위로 아주 조금 띄운다(같은 면 z-fighting 방지)
|
||
nn.Add(n);
|
||
if (bwt != null && bwt.Length == vt.Length) nbw.Add(bwt[vi]);
|
||
var u = w.uv[vi];
|
||
nuv.Add(new Vector2((u.x - uvRect.xMin) / uvRect.width, (u.y - uvRect.yMin) / uvRect.height));
|
||
}
|
||
ntri.Add(id);
|
||
}
|
||
}
|
||
var mesh = new Mesh { name = "WL_Nolant_FaceDecal" };
|
||
mesh.SetVertices(nv); mesh.SetNormals(nn); mesh.SetUVs(0, nuv); mesh.SetTriangles(ntri, 0);
|
||
if (nbw.Count == nv.Count) mesh.boneWeights = nbw.ToArray();
|
||
mesh.bindposes = src.bindposes;
|
||
mesh.bounds = src.bounds;
|
||
return mesh;
|
||
}
|
||
|
||
static void SaveMesh(Mesh m, string path)
|
||
{
|
||
if (AssetDatabase.LoadAssetAtPath<Mesh>(path) != null) AssetDatabase.DeleteAsset(path);
|
||
AssetDatabase.CreateAsset(m, path);
|
||
}
|
||
|
||
static void ImportPalette(string path, int S)
|
||
{
|
||
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
|
||
var ti = (TextureImporter)AssetImporter.GetAtPath(path);
|
||
ti.textureType = TextureImporterType.Default; ti.mipmapEnabled = false; ti.filterMode = FilterMode.Point;
|
||
ti.wrapMode = TextureWrapMode.Clamp; ti.sRGBTexture = true; ti.npotScale = TextureImporterNPOTScale.None;
|
||
ti.maxTextureSize = Mathf.Max(32, Mathf.NextPowerOfTwo(S)); ti.textureCompression = TextureImporterCompression.Uncompressed;
|
||
ti.SaveAndReimport();
|
||
}
|
||
|
||
static void ImportDecal(string path)
|
||
{
|
||
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
|
||
var ti = (TextureImporter)AssetImporter.GetAtPath(path);
|
||
ti.textureType = TextureImporterType.Default; ti.alphaIsTransparency = true; ti.mipmapEnabled = true;
|
||
ti.filterMode = FilterMode.Bilinear; ti.wrapMode = TextureWrapMode.Clamp; ti.sRGBTexture = true; ti.maxTextureSize = 256;
|
||
var ps = ti.GetPlatformTextureSettings("Android"); ps.overridden = true; ps.maxTextureSize = 256; ps.format = TextureImporterFormat.ASTC_6x6; ti.SetPlatformTextureSettings(ps);
|
||
ti.SaveAndReimport();
|
||
}
|
||
|
||
// ───────────────────────────── 진입점
|
||
public static string Run(string color, int bodyChunks, int hatChunks, int paletteN, float decalLo, float decalHi)
|
||
{
|
||
sb.Length = 0;
|
||
if (string.IsNullOrEmpty(color)) color = "Yellow";
|
||
string prefabPath = SRC + "/Prefabs/Peasant Nolant " + color + "(Free Version).prefab";
|
||
string texPath = SRC + "/Textures/Peasant Nolant " + color + ".png";
|
||
string variantPath = OUT + "WL_Merchant_Nolant_" + color + ".prefab";
|
||
var pf = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
|
||
if (pf == null || !File.Exists(texPath)) return "원본 없음 — " + prefabPath + " / " + texPath;
|
||
var baseMat = AssetDatabase.LoadAssetAtPath<Material>("Assets/WL/Look/Character/Materials/M05_ToonP.mat");
|
||
var faceMat = AssetDatabase.LoadAssetAtPath<Material>("Assets/WL/Look/Character/Materials/face02_ToonS.mat");
|
||
if (baseMat == null || faceMat == null) return "기준 재질(M05_ToonP · face02_ToonS) 없음";
|
||
var tex = LoadPng(texPath);
|
||
L("=== WL #876 상인 NPC 팔레트 굽기 — " + color + " · 몸 덩어리 " + bodyChunks + " · 모자 " + hatChunks + " · 팔레트 " + paletteN + "칸 · 데칼 색차 " + decalLo + "~" + decalHi + " ===");
|
||
|
||
SkinnedMeshRenderer bodyR = null, hatR = null;
|
||
foreach (var r in pf.GetComponentsInChildren<SkinnedMeshRenderer>(true)) { if (r.name == "Hat") hatR = r; else if (r.name == "Peasant Nolant") bodyR = r; }
|
||
if (bodyR == null || hatR == null) return "렌더러(Peasant Nolant · Hat) 못 찾음";
|
||
|
||
var body = Analyze("Body", bodyR.sharedMesh, tex, bodyChunks);
|
||
var hat = Analyze("Hat", hatR.sharedMesh, tex, hatChunks);
|
||
L("덩어리: 몸 " + body.regions + "(삼각형 " + body.faces.Count + ") · 모자 " + hat.regions + "(삼각형 " + hat.faces.Count + ")");
|
||
|
||
// ── 두 메시 덩어리를 한 팔레트로(재질 1장 공유)
|
||
var all = new List<KeyValuePair<MeshWork, int>>();
|
||
foreach (var r in body.roots) all.Add(new KeyValuePair<MeshWork, int>(body, r));
|
||
foreach (var r in hat.roots) all.Add(new KeyValuePair<MeshWork, int>(hat, r));
|
||
int N = Mathf.Min(paletteN, all.Count);
|
||
var pal = KMeans(all.Select(p => p.Key.reg[p.Value].Col).ToArray(), all.Select(p => p.Key.reg[p.Value].area).ToArray(), N);
|
||
var asg = new int[all.Count];
|
||
for (int i = 0; i < all.Count; i++)
|
||
{
|
||
var lab = ToLab(all[i].Key.reg[all[i].Value].Col);
|
||
float bd = float.MaxValue; int bj = 0;
|
||
for (int j = 0; j < N; j++) { float d = LabD(lab, ToLab(pal[j])); if (d < bd) { bd = d; bj = j; } }
|
||
asg[i] = bj;
|
||
}
|
||
// 칸 H 원본 복원 + ±8° 클램프 · 채도는 부풀리지 않는다(816b 와 같은 규칙)
|
||
var palS = new Vector3[N];
|
||
for (int j = 0; j < N; j++)
|
||
{
|
||
double hx = 0, hy = 0, sw = 0, ssum = 0, aw = 0;
|
||
for (int i = 0; i < all.Count; i++)
|
||
{
|
||
if (asg[i] != j) continue;
|
||
var reg = all[i].Key.reg[all[i].Value];
|
||
hx += reg.hx; hy += reg.hy; sw += reg.sw;
|
||
float h2, s2, v2; RgbToHsv(reg.Col, out h2, out s2, out v2);
|
||
ssum += s2 * reg.area; aw += reg.area;
|
||
}
|
||
float ph, ps, pv; RgbToHsv(pal[j], out ph, out ps, out pv);
|
||
float hue = sw > 1e-6 ? (float)((Math.Atan2(hy, hx) * 180.0 / Math.PI + 360.0) % 360.0) : ph;
|
||
float d8 = DHue(ph, hue);
|
||
if (Mathf.Abs(d8) > HUE_LIMIT) hue = ph + Mathf.Sign(d8) * HUE_LIMIT;
|
||
float satRestored = aw > 1e-6 ? (float)(ssum / aw) : ps;
|
||
palS[j] = HsvToRgb(hue, Mathf.Min(ps, satRestored), pv);
|
||
}
|
||
body.assign = new int[body.roots.Count]; hat.assign = new int[hat.roots.Count];
|
||
{ int bi = 0, hi = 0; for (int i = 0; i < all.Count; i++) { if (all[i].Key == body) body.assign[bi++] = asg[i]; else hat.assign[hi++] = asg[i]; } }
|
||
|
||
int G = Mathf.NextPowerOfTwo(Mathf.CeilToInt(Mathf.Sqrt(N)));
|
||
int S = G * CELL;
|
||
Directory.CreateDirectory(OUT + "Meshes"); Directory.CreateDirectory(OUT + "Textures");
|
||
string palPath = OUT + "Textures/WLPaletteN_Nolant_" + color + ".png";
|
||
{
|
||
var ptex = new Texture2D(S, S, TextureFormat.RGBA32, false);
|
||
var ppx = new Color32[S * S];
|
||
for (int i = 0; i < ppx.Length; i++) ppx[i] = new Color32(255, 0, 255, 255);
|
||
for (int j = 0; j < N; j++)
|
||
{
|
||
int gx = j % G, gy = j / G;
|
||
var c = new Color32((byte)Mathf.RoundToInt(Mathf.Clamp01(palS[j].x) * 255f), (byte)Mathf.RoundToInt(Mathf.Clamp01(palS[j].y) * 255f), (byte)Mathf.RoundToInt(Mathf.Clamp01(palS[j].z) * 255f), 255);
|
||
for (int y = 0; y < CELL; y++) for (int x = 0; x < CELL; x++) ppx[(gy * CELL + y) * S + gx * CELL + x] = c;
|
||
}
|
||
ptex.SetPixels32(ppx); ptex.Apply();
|
||
File.WriteAllBytes(palPath, ptex.EncodeToPNG());
|
||
UnityEngine.Object.DestroyImmediate(ptex);
|
||
ImportPalette(palPath, S);
|
||
}
|
||
var sbPal = new StringBuilder();
|
||
for (int j = 0; j < N; j++) sbPal.Append(ColorUtility.ToHtmlStringRGB(new Color(palS[j].x, palS[j].y, palS[j].z)) + " ");
|
||
L("팔레트 " + N + "칸(" + S + "×" + S + "): " + sbPal);
|
||
|
||
var bodyPal = BuildPaletteMesh(body, G); var hatPal = BuildPaletteMesh(hat, G);
|
||
SaveMesh(bodyPal, OUT + "Meshes/" + bodyPal.name + ".asset");
|
||
SaveMesh(hatPal, OUT + "Meshes/" + hatPal.name + ".asset");
|
||
L("메시: 몸 정점 " + body.src.vertexCount + "→" + bodyPal.vertexCount + " · 모자 " + hat.src.vertexCount + "→" + hatPal.vertexCount + " · 뼈 가중치 " + (bodyPal.boneWeights.Length == bodyPal.vertexCount) + "/" + (hatPal.boneWeights.Length == hatPal.vertexCount));
|
||
|
||
// ── 얼굴 데칼 — 얼굴 칸(UV 왼쪽 위 · 원본 텍스처의 얼굴 그림) 삼각형
|
||
var faceTris = new List<int>();
|
||
for (int f = 0; f < body.faces.Count; f++)
|
||
{
|
||
var fa = body.faces[f]; bool inF = true;
|
||
foreach (var vi in new[] { fa.i0, fa.i1, fa.i2 }) { var u = body.uv[vi]; if (!(u.x <= 0.18f && u.y >= 0.72f)) inF = false; }
|
||
if (inF) faceTris.Add(f);
|
||
}
|
||
float umin = 1, umax = 0, vmin = 1, vmax = 0;
|
||
foreach (var f in faceTris) { var fa = body.faces[f]; foreach (var vi in new[] { fa.i0, fa.i1, fa.i2 }) { var u = body.uv[vi]; umin = Mathf.Min(umin, u.x); umax = Mathf.Max(umax, u.x); vmin = Mathf.Min(vmin, u.y); vmax = Mathf.Max(vmax, u.y); } }
|
||
var rect = Rect.MinMaxRect(Mathf.Max(0, umin - 0.004f), Mathf.Max(0, vmin - 0.004f), Mathf.Min(1, umax + 0.004f), Mathf.Min(1, vmax + 0.004f));
|
||
// 피부 기준색 = 얼굴 삼각형 면 평균에서 출발해 가까운 것만 다시 평균(2회) — 눈·눈썹이 섞이지 않게
|
||
Vector3 skin = Vector3.zero; float sa = 0;
|
||
foreach (var f in faceTris) { skin += body.faces[f].col * body.faces[f].area; sa += body.faces[f].area; }
|
||
skin /= Mathf.Max(sa, 1e-9f);
|
||
const int D = 256;
|
||
for (int it = 0; it < 2; it++)
|
||
{
|
||
var sl = ToLab(skin); Vector3 acc = Vector3.zero; int n = 0;
|
||
for (int y = 0; y < D; y += 2) for (int x = 0; x < D; x += 2)
|
||
{
|
||
var c = Sample(tex, rect.xMin + (x + 0.5f) / D * rect.width, rect.yMin + (y + 0.5f) / D * rect.height);
|
||
if (LabD(ToLab(c), sl) < 14f) { acc += c; n++; }
|
||
}
|
||
if (n > 0) skin = acc / n;
|
||
}
|
||
// 덮개(얼굴 삼각형이 덮는 텍셀) — 밖은 투명
|
||
var cover = new bool[D * D];
|
||
foreach (var f in faceTris)
|
||
{
|
||
var fa = body.faces[f];
|
||
Vector2 a = Px(body.uv[fa.i0], rect, D), b = Px(body.uv[fa.i1], rect, D), c = Px(body.uv[fa.i2], rect, D);
|
||
int x0 = Mathf.Max(0, Mathf.FloorToInt(Mathf.Min(a.x, Mathf.Min(b.x, c.x))) - 1), x1 = Mathf.Min(D - 1, Mathf.CeilToInt(Mathf.Max(a.x, Mathf.Max(b.x, c.x))) + 1);
|
||
int y0 = Mathf.Max(0, Mathf.FloorToInt(Mathf.Min(a.y, Mathf.Min(b.y, c.y))) - 1), y1 = Mathf.Min(D - 1, Mathf.CeilToInt(Mathf.Max(a.y, Mathf.Max(b.y, c.y))) + 1);
|
||
for (int y = y0; y <= y1; y++) for (int x = x0; x <= x1; x++) if (Inside(new Vector2(x + 0.5f, y + 0.5f), a, b, c, 1.0f)) cover[y * D + x] = true;
|
||
}
|
||
var dtex = new Texture2D(D, D, TextureFormat.RGBA32, false);
|
||
var dpx = new Color32[D * D]; var skinLab = ToLab(skin); int feat = 0;
|
||
for (int y = 0; y < D; y++)
|
||
for (int x = 0; x < D; x++)
|
||
{
|
||
var c = SampleBilinear(tex, rect.xMin + (x + 0.5f) / D * rect.width, rect.yMin + (y + 0.5f) / D * rect.height);
|
||
float d = LabD(ToLab(c), skinLab);
|
||
float al = cover[y * D + x] ? Mathf.Clamp01((d - decalLo) / Mathf.Max(0.01f, decalHi - decalLo)) : 0f;
|
||
if (al > 0.5f) feat++;
|
||
dpx[y * D + x] = new Color32((byte)Mathf.RoundToInt(c.x * 255f), (byte)Mathf.RoundToInt(c.y * 255f), (byte)Mathf.RoundToInt(c.z * 255f), (byte)Mathf.RoundToInt(al * 255f));
|
||
}
|
||
dtex.SetPixels32(dpx); dtex.Apply();
|
||
string decalPath = OUT + "Textures/WL_Nolant_FaceDecal_" + color + ".png";
|
||
File.WriteAllBytes(decalPath, dtex.EncodeToPNG());
|
||
UnityEngine.Object.DestroyImmediate(dtex);
|
||
ImportDecal(decalPath);
|
||
float offset = body.src.bounds.size.magnitude * 0.0012f;
|
||
var decal = BuildDecalMesh(body, faceTris, rect, offset);
|
||
SaveMesh(decal, OUT + "Meshes/" + decal.name + ".asset");
|
||
L("얼굴 데칼: 삼각형 " + faceTris.Count + " · UV 칸 " + rect.ToString("F3") + " · 피부 " + ColorUtility.ToHtmlStringRGB(new Color(skin.x, skin.y, skin.z)) + " · 남긴 텍셀 " + feat + "/" + (D * D) + " · 띄움 " + offset.ToString("F5") + "(메시 단위)");
|
||
|
||
// ── 재질 — PC 팔레트 재질(M05_ToonP) 사본 + 이 팔레트 · PC 얼굴 데칼 재질(face02_ToonS) 사본 + 이 데칼
|
||
string matPath = OUT + "WL_Nolant_" + color + "_ToonP.mat";
|
||
var m = AssetDatabase.LoadAssetAtPath<Material>(matPath);
|
||
if (m == null) { m = new Material(baseMat); AssetDatabase.CreateAsset(m, matPath); }
|
||
m.shader = baseMat.shader; m.CopyPropertiesFromMaterial(baseMat);
|
||
var ptex2 = AssetDatabase.LoadAssetAtPath<Texture2D>(palPath);
|
||
if (m.HasProperty("_BaseMap")) m.SetTexture("_BaseMap", ptex2);
|
||
if (m.HasProperty("_MainTex")) m.SetTexture("_MainTex", ptex2);
|
||
m.enableInstancing = true;
|
||
EditorUtility.SetDirty(m);
|
||
string fmPath = OUT + "WL_Nolant_" + color + "_FaceDecal.mat";
|
||
var fm = AssetDatabase.LoadAssetAtPath<Material>(fmPath);
|
||
if (fm == null) { fm = new Material(faceMat); AssetDatabase.CreateAsset(fm, fmPath); }
|
||
fm.shader = faceMat.shader; fm.CopyPropertiesFromMaterial(faceMat);
|
||
var dtex2 = AssetDatabase.LoadAssetAtPath<Texture2D>(decalPath);
|
||
if (fm.HasProperty("_MainTex")) fm.SetTexture("_MainTex", dtex2);
|
||
if (fm.HasProperty("_BaseMap")) fm.SetTexture("_BaseMap", dtex2);
|
||
EditorUtility.SetDirty(fm);
|
||
AssetDatabase.SaveAssets();
|
||
L("재질: " + matPath + "(" + m.shader.name + ") · " + fmPath + "(" + fm.shader.name + ")");
|
||
|
||
// ── WL 프리팹 변형에 배선 — 몸·모자 = 팔레트 메시 + 툰 재질 · 얼굴 데칼 렌더러 추가(PC 의 Face 렌더러와 같은 구성)
|
||
if (AssetDatabase.LoadAssetAtPath<GameObject>(variantPath) == null) return sb + "🔴 WL 프리팹 변형 없음 — 먼저 WL_NolantMerchantSetup 실행";
|
||
var root = PrefabUtility.LoadPrefabContents(variantPath);
|
||
try
|
||
{
|
||
SkinnedMeshRenderer vb = null, vh = null, vd = null;
|
||
foreach (var r in root.GetComponentsInChildren<SkinnedMeshRenderer>(true))
|
||
{
|
||
if (r.name == "Peasant Nolant") vb = r; else if (r.name == "Hat") vh = r; else if (r.name == "Face_Decal") vd = r;
|
||
}
|
||
if (vb == null || vh == null) return sb + "🔴 변형 안 렌더러 못 찾음";
|
||
vb.sharedMesh = AssetDatabase.LoadAssetAtPath<Mesh>(OUT + "Meshes/" + bodyPal.name + ".asset"); vb.sharedMaterials = new[] { m };
|
||
vh.sharedMesh = AssetDatabase.LoadAssetAtPath<Mesh>(OUT + "Meshes/" + hatPal.name + ".asset"); vh.sharedMaterials = new[] { m };
|
||
if (vd == null)
|
||
{
|
||
var go = new GameObject("Face_Decal");
|
||
go.transform.SetParent(vb.transform.parent, false);
|
||
go.transform.localPosition = vb.transform.localPosition; go.transform.localRotation = vb.transform.localRotation; go.transform.localScale = vb.transform.localScale;
|
||
go.layer = vb.gameObject.layer;
|
||
vd = go.AddComponent<SkinnedMeshRenderer>();
|
||
}
|
||
vd.sharedMesh = AssetDatabase.LoadAssetAtPath<Mesh>(OUT + "Meshes/" + decal.name + ".asset");
|
||
vd.bones = vb.bones; vd.rootBone = vb.rootBone; vd.localBounds = vb.localBounds;
|
||
vd.sharedMaterials = new[] { fm };
|
||
vd.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; vd.receiveShadows = false;
|
||
vd.quality = vb.quality; vd.updateWhenOffscreen = false;
|
||
PrefabUtility.SaveAsPrefabAsset(root, variantPath);
|
||
L("프리팹 변형 배선: " + variantPath + " · 몸/모자 팔레트 메시 · 얼굴 데칼 렌더러(뼈 " + vd.bones.Length + ")");
|
||
}
|
||
finally { PrefabUtility.UnloadPrefabContents(root); }
|
||
AssetDatabase.SaveAssets();
|
||
File.WriteAllText("AgentScripts/WL876_BAKE.txt", sb.ToString(), new UTF8Encoding(true));
|
||
return sb.ToString();
|
||
}
|
||
|
||
static Vector2 Px(Vector2 uv, Rect r, int D) { return new Vector2((uv.x - r.xMin) / r.width * D, (uv.y - r.yMin) / r.height * D); }
|
||
static bool Inside(Vector2 p, Vector2 a, Vector2 b, Vector2 c, float pad)
|
||
{
|
||
// 무게중심 좌표 + 픽셀 반 칸 여유(경계 텍셀까지 덮는다)
|
||
float d = (b.y - c.y) * (a.x - c.x) + (c.x - b.x) * (a.y - c.y);
|
||
if (Mathf.Abs(d) < 1e-9f) return false;
|
||
float l1 = ((b.y - c.y) * (p.x - c.x) + (c.x - b.x) * (p.y - c.y)) / d;
|
||
float l2 = ((c.y - a.y) * (p.x - c.x) + (a.x - c.x) * (p.y - c.y)) / d;
|
||
float l3 = 1f - l1 - l2;
|
||
float e = pad / Mathf.Max(1f, Mathf.Sqrt(Mathf.Abs(d)));
|
||
return l1 >= -e && l2 >= -e && l3 >= -e;
|
||
}
|
||
}
|