ThreeKingdomsSlingshot/Assets/Scripts/Runtime/Skills/FxStyleLayer.cs

346 lines
20 KiB
C#
Raw Normal View History

using System.Collections.Generic;
using System.Globalization;
using UnityEngine;
namespace TKS
{
/// <summary>
/// 이펙트 화풍 층(2026-11-11 PD 「우리 게임의 화풍을 고려해 이펙트를 조절하거나 셰이더 등으로 색감·질감·라이팅을 조정 · 그대로 쓰면 너무 이질적」).
/// 이 게임 그림 = 굵은 먹선 외곽선 + 평평한 단색 면 + 빛 번짐 없음 → 팩 이펙트(부드러운 빛 · 그러데이션 · 3D 느낌)를 재질마다 고치지 않고
/// 「이펙트만 따로 그린 그림」을 한 번에 화풍으로 바꾼다:
/// ① 표 skill_vfx.csv 의 b_cel 1 인 행으로 띄운 이펙트를 전용 층(유닛 아래 = <see cref="LayerUnder"/> · 유닛 위 = <see cref="LayerOver"/>)으로 옮김(주 카메라는 그 층을 안 그림)
/// ② 주 카메라가 그리기 직전, 같은 시점의 보조 카메라로 그 층만 검은 바탕·흰 바탕에 한 번씩 그림 → 셰이더 TKS/FxResolve 가 칠한 색·덮은 정도를 되찾음
/// ③ 화면을 딱 덮는 판 2장(유닛 아래 순서 · 유닛 위 순서)에 셰이더 TKS/FxStyle 로 그림 = 면 2~4단 + 무광 색 + 먹선 외곽선 + 선 떨림
/// 값 = 표 <c>Resources/Skills/fx_style.csv</c>(코드 상수 없음 · C45) · 화풍 층 이펙트가 하나도 없으면 아무것도 그리지 않는다(비용 0).
/// 팩 원본 프리팹·재질은 고치지 않는다 · b_cel 빈칸인 행(유비 · 기본 공격 IB 이펙트)은 전과 같이 그대로 그려진다.
/// </summary>
public class FxStyleLayer : MonoBehaviour
{
public const string TablePath = "Skills/fx_style";
public const string ResolveShader = "Shaders/TKS_FxResolve";
public const string StyleShader = "Shaders/TKS_FxStyle";
/// <summary>유닛 아래에 그릴 화풍 층 이펙트의 층 번호(TagManager 이름 TKS_FxUnder).</summary>
public const int LayerUnder = 28;
/// <summary>유닛 위에 그릴 화풍 층 이펙트의 층 번호(TagManager 이름 TKS_FxOver).</summary>
public const int LayerOver = 29;
/// <summary>
/// 변형 값(표 skill_vfx.csv s_style · fx_style.csv 「키@변형」)을 쓰는 유닛 아래 이펙트의 층 번호 — 판·그림을 따로 써서 그 이펙트만 다른 먹선 색으로 그린다
/// (2026-11-11 PD 「흙먼지 이펙트 가장자리도 검은색 보다는 좀 더 부드러운 브라운 계열」 · 다른 화풍 층 이펙트의 먹선은 그대로).
/// </summary>
public const int LayerUnderAlt = 27;
/// <summary>판 수: 0 = 유닛 아래 · 1 = 유닛 위 · 2 = 유닛 아래 변형.</summary>
const int Groups = 3;
/// <summary>유닛 아래 판의 그리는 순서(= 유닛 바로 아래 n_order −14 와 같음).</summary>
public const int OrderUnder = SkillVfx.SortingBase - 14;
static FxStyleLayer instance;
static Dictionary<string, string> values;
/// <summary>변형 판이 쓰는 변형 이름(마지막으로 등록한 행의 s_style · 변형은 한 번에 하나).</summary>
static string altStyle = "";
Camera main;
Camera fxCam;
Material resolveMat;
readonly Material[] styleMats = new Material[Groups];
readonly RenderTexture[] resolved = new RenderTexture[Groups];
/// <summary>번진 몸 마스크(먹선용 · 화풍 층 그림의 절반 해상도).</summary>
readonly RenderTexture[] masks = new RenderTexture[Groups];
readonly MeshRenderer[] quads = new MeshRenderer[Groups];
readonly List<GameObject> tracked = new List<GameObject>();
/// <summary>표를 다시 읽는다(전투 시작 · 스킬 테스트 씬 「다시 배치」 · SkillVfx.Reload 가 부름).</summary>
public static void Reload()
{
values = null;
}
static void EnsureValues()
{
if (values != null) return;
values = new Dictionary<string, string>();
var ta = Resources.Load<TextAsset>(TablePath);
if (ta == null) return;
foreach (var raw in ta.text.Replace("\r", "").Split('\n'))
{
var line = raw.TrimStart('');
if (line.Trim().Length == 0 || line.TrimStart().StartsWith("#")) continue;
var c = SkillVfx.SplitCsv(line);
if (c.Length < 2 || c[0].Trim() == "s_key") continue;
values[c[0].Trim()] = c[1].Trim();
}
}
/// <param name="variant">변형 이름 — 「키@변형」 줄이 있으면 그 값 · 없으면 기본 값.</param>
public static float F(string key, float def, string variant = "")
{
EnsureValues();
string v;
float f;
if (variant.Length > 0 && values.TryGetValue(key + "@" + variant, out v) && float.TryParse(v, NumberStyles.Float, CultureInfo.InvariantCulture, out f)) return f;
return values.TryGetValue(key, out v) && float.TryParse(v, NumberStyles.Float, CultureInfo.InvariantCulture, out f) ? f : def;
}
public static Color C(string key, Color def, string variant = "")
{
EnsureValues();
string v;
Color c;
if (variant.Length > 0 && values.TryGetValue(key + "@" + variant, out v) && ColorUtility.TryParseHtmlString(v, out c)) return c;
return values.TryGetValue(key, out v) && ColorUtility.TryParseHtmlString(v, out c) ? c : def;
}
/// <summary>
/// 표 값을 두 재질에 넣는다(실행 중 화풍 층 · 에디터 미리보기 도구 공용). worldPerTexel = 화풍 층 그림 1 텍셀의 월드 길이(먹선·떨림 굵기를 월드 단위로 유지).
/// </summary>
/// <param name="worldPerPixel">화면(또는 미리보기 그림) 1 픽셀의 월드 길이 — 가는 줄기 판정 거리를 먹선 굵기에 맞춤.</param>
public static void ApplyParams(Material resolve, Material style, float worldPerPixel, string variant = "")
{
if (resolve != null)
{
resolve.SetFloat("_GlowGain", F("glow_gain", 1f));
resolve.SetFloat("_GlowKnee", F("glow_knee", 0.15f));
resolve.SetFloat("_T1", F("t_body", 0.26f));
}
if (style == null) return;
style.SetFloat("_T0", F("t_wash", 0.08f, variant));
style.SetFloat("_T1", F("t_body", 0.26f, variant));
style.SetFloat("_T2", F("t_light", 0.55f, variant));
style.SetFloat("_WashAlpha", F("wash_alpha", 0.15f, variant));
style.SetFloat("_BodyAlpha", F("body_alpha", 0.95f, variant));
style.SetFloat("_FaintAlpha", F("faint_alpha", 0.55f, variant));
style.SetFloat("_Soft", F("soft", 0.04f, variant));
style.SetFloat("_Steps", Mathf.Max(1f, F("steps", 3f, variant)));
style.SetFloat("_CBody", F("c_body", 0.5f, variant));
style.SetFloat("_CLight", F("c_light", 0.2f, variant));
style.SetFloat("_SBody", F("s_body", 0.82f, variant));
style.SetFloat("_SLight", F("s_light", 0.4f, variant));
style.SetFloat("_SCore", F("s_core", 0.06f, variant));
style.SetFloat("_VMin", F("v_min", 0.35f, variant));
style.SetFloat("_GrayVMin", F("gray_v_min", 0.72f, variant));
style.SetFloat("_VMax", F("v_max", 0.93f, variant));
style.SetFloat("_LightMix", F("light_mix", 0.22f, variant));
style.SetColor("_CoreColor", C("core_color", new Color(1f, 0.96f, 0.84f), variant));
style.SetColor("_InkColor", C("ink_color", new Color(0.11f, 0.08f, 0.06f), variant));
style.SetFloat("_InkAlpha", F("ink_alpha", 0.9f, variant));
style.SetFloat("_InkTint", F("ink_tint", 0.25f, variant));
style.SetFloat("_InkLevel", F("ink_level", 0.12f, variant));
style.SetFloat("_SolidLo", F("solid_lo", 0.32f, variant));
style.SetFloat("_SolidHi", F("solid_hi", 0.6f, variant));
style.SetFloat("_ProbePx", F("ink_world", 0.035f, variant) / Mathf.Max(1e-5f, worldPerPixel) * 2f);
style.SetFloat("_ThinLo", F("thin_lo", 0.45f, variant));
style.SetFloat("_ThinHi", F("thin_hi", 0.75f, variant));
style.SetFloat("_HoleLo", F("hole_lo", 0.55f, variant));
style.SetFloat("_HoleHi", F("hole_hi", 0.75f, variant));
style.SetFloat("_ToneSmooth", F("tone_smooth", 1f, variant));
style.SetFloat("_BlackLo", F("black_lo", 0.05f, variant));
style.SetFloat("_BlackHi", F("black_hi", 0.18f, variant));
style.SetFloat("_Opacity", F("opacity", 1f, variant));
}
/// <summary>
/// 검은 바탕·흰 바탕에 그린 이펙트 두 장 → dst(칠한 색 × 덮음 · 덮음 — 가장자리를 다듬은 것) + mask(번진 몸 마스크 · 먹선용 · 보통 절반 해상도).
/// 실행 중 화풍 층과 에디터 미리보기 도구(Tools/fx_style_preview.cs)가 같이 쓴다. worldPerTexel = dst 1 텍셀의 월드 길이(다듬기·먹선 굵기를 월드 단위로 유지).
/// </summary>
public static void Resolve(Texture black, Texture white, RenderTexture dst, RenderTexture mask, Material resolve, float worldPerTexel)
{
float wpt = Mathf.Max(1e-5f, worldPerTexel);
resolve.SetTexture("_WhiteTex", white);
// ① 되찾기 → ② 가장자리 다듬기(톱니·잔 알갱이를 둥글게 · smooth_iter 번)
int iter = Mathf.Clamp(Mathf.RoundToInt(F("smooth_iter", 2f)), 0, 4);
var cur = iter == 0 ? dst : RenderTexture.GetTemporary(dst.width, dst.height, 0, dst.format);
Graphics.Blit(black, cur, resolve, 0);
resolve.SetFloat("_BlurPx", Mathf.Max(0.5f, F("smooth_world", 0.015f) / wpt));
for (int i = 0; i < iter; i++)
{
var to = i == iter - 1 ? dst : RenderTexture.GetTemporary(dst.width, dst.height, 0, dst.format);
Graphics.Blit(cur, to, resolve, 1);
RenderTexture.ReleaseTemporary(cur);
cur = to;
}
// ③ 몸 마스크를 먹선 굵기만큼 번지게(세 번 · 간격 = 먹선 굵기) — FxStyle 이 일정 높이로 잘라 고른 굵기의 선으로
float step = Mathf.Max(0.5f, F("ink_world", 0.035f) / wpt); // dst 텍셀 단위
float toMask = mask.width / (float)dst.width;
var m1 = RenderTexture.GetTemporary(mask.width, mask.height, 0, mask.format);
var m2 = RenderTexture.GetTemporary(mask.width, mask.height, 0, mask.format);
resolve.SetFloat("_BlurPx", step);
Graphics.Blit(dst, m1, resolve, 2);
resolve.SetFloat("_BlurPx", Mathf.Max(0.5f, step * toMask));
Graphics.Blit(m1, m2, resolve, 1);
Graphics.Blit(m2, mask, resolve, 1);
RenderTexture.ReleaseTemporary(m1);
RenderTexture.ReleaseTemporary(m2);
}
/// <summary>
/// 띄운 이펙트를 화풍 층으로 옮긴다(SkillVfx · 그리는 순서를 다 정한 뒤 부름): 그리는 순서가 유닛(0)보다 아래인 층 = 아래 판 · 그 밖 = 위 판.
/// </summary>
/// <param name="style">변형 이름(표 s_style · 빈칸 = 기본) — 유닛 아래 층만 변형 판으로 간다.</param>
public static void Register(GameObject go, string style = "")
{
if (go == null || !Application.isPlaying) return;
if (instance == null)
{
var host = new GameObject("FxStyleLayer");
DontDestroyOnLoad(host);
instance = host.AddComponent<FxStyleLayer>();
}
bool alt = !string.IsNullOrEmpty(style);
if (alt) altStyle = style;
foreach (var rd in go.GetComponentsInChildren<Renderer>(true))
rd.gameObject.layer = rd.sortingOrder < 0 ? (alt ? LayerUnderAlt : LayerUnder) : LayerOver;
instance.tracked.Add(go);
}
void OnEnable()
{
Camera.onPreCull += OnCam;
}
void OnDisable()
{
Camera.onPreCull -= OnCam;
}
void OnDestroy()
{
for (int i = 0; i < Groups; i++)
{
if (resolved[i] != null) resolved[i].Release();
if (masks[i] != null) masks[i].Release();
if (styleMats[i] != null) Destroy(styleMats[i]);
}
if (resolveMat != null) Destroy(resolveMat);
if (instance == this) instance = null;
}
bool Build()
{
if (resolveMat != null) return true;
var rs = Resources.Load<Shader>(ResolveShader);
var ss = Resources.Load<Shader>(StyleShader);
if (rs == null || ss == null)
{
Debug.LogWarning("[TKS] 화풍 층 셰이더 없음: Resources/" + ResolveShader + " · " + StyleShader);
return false;
}
resolveMat = new Material(rs);
var cgo = new GameObject("FxStyleCam");
cgo.transform.SetParent(transform, false);
fxCam = cgo.AddComponent<Camera>();
fxCam.enabled = false;
var mesh = new Mesh { name = "FxStyleQuad" };
mesh.vertices = new[] { new Vector3(-0.5f, -0.5f, 0f), new Vector3(0.5f, -0.5f, 0f), new Vector3(0.5f, 0.5f, 0f), new Vector3(-0.5f, 0.5f, 0f) };
mesh.uv = new[] { new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(0f, 1f) };
mesh.triangles = new[] { 0, 2, 1, 0, 3, 2 };
for (int i = 0; i < Groups; i++)
{
styleMats[i] = new Material(ss);
var q = new GameObject(i == 0 ? "FxStyleQuadUnder" : i == 1 ? "FxStyleQuadOver" : "FxStyleQuadUnderAlt");
q.transform.SetParent(transform, false);
q.AddComponent<MeshFilter>().sharedMesh = mesh;
quads[i] = q.AddComponent<MeshRenderer>();
quads[i].sharedMaterial = styleMats[i];
quads[i].sortingOrder = i == 1 ? SkillVfx.SortingBase : OrderUnder;
quads[i].shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
quads[i].receiveShadows = false;
quads[i].enabled = false;
}
return true;
}
void OnCam(Camera cam)
{
if (main == null) main = Camera.main;
if (cam != main || main == null) return;
const int mask = (1 << LayerUnder) | (1 << LayerOver) | (1 << LayerUnderAlt);
if ((cam.cullingMask & mask) != 0) cam.cullingMask &= ~mask; // 주 카메라는 화풍 층 이펙트를 직접 그리지 않음
bool under = false, over = false, alt = false;
for (int i = tracked.Count - 1; i >= 0; i--)
{
var go = tracked[i];
if (go == null)
{
tracked.RemoveAt(i);
continue;
}
if (!go.activeInHierarchy) continue;
foreach (var rd in go.GetComponentsInChildren<Renderer>(false))
{
if (rd.gameObject.layer == LayerUnder) under = true;
else if (rd.gameObject.layer == LayerOver) over = true;
else if (rd.gameObject.layer == LayerUnderAlt) alt = true;
}
}
if (!under && !over && !alt)
{
if (quads[0] != null)
for (int i = 0; i < Groups; i++) quads[i].enabled = false;
return;
}
if (!Build()) return;
float scale = Mathf.Clamp(F("rt_scale", 1f), 0.25f, 2f);
int w = Mathf.Max(32, Mathf.RoundToInt(cam.pixelWidth * scale)), h = Mathf.Max(32, Mathf.RoundToInt(cam.pixelHeight * scale));
float viewH = cam.orthographicSize * 2f, viewW = viewH * cam.aspect;
int mw = Mathf.Max(16, w / 2), mh = Mathf.Max(16, h / 2);
var prev = RenderTexture.active;
for (int i = 0; i < Groups; i++)
if (prev != null && (prev == resolved[i] || prev == masks[i])) prev = null;
for (int li = 0; li < Groups; li++)
{
bool on = li == 0 ? under : li == 1 ? over : alt;
quads[li].enabled = on;
if (!on) continue;
if (resolved[li] == null || resolved[li].width != w || resolved[li].height != h)
{
if (resolved[li] != null)
{
if (RenderTexture.active == resolved[li]) RenderTexture.active = null; // 쓰는 중인 그림을 놓으면 경고
resolved[li].Release();
}
// 16비트 = 옅은 곳의 색·밝기 단 경계에 8비트 계단 무늬(자글자글한 점)가 생기지 않게(지원 안 하면 8비트)
resolved[li] = new RenderTexture(w, h, 0, SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBHalf) ? RenderTextureFormat.ARGBHalf : RenderTextureFormat.ARGB32)
{ name = "TKS_FxStyle" + li, filterMode = FilterMode.Bilinear, wrapMode = TextureWrapMode.Clamp };
}
if (masks[li] == null || masks[li].width != mw || masks[li].height != mh)
{
if (masks[li] != null)
{
if (RenderTexture.active == masks[li]) RenderTexture.active = null;
masks[li].Release();
}
masks[li] = new RenderTexture(mw, mh, 0, RenderTextureFormat.ARGB32)
{ name = "TKS_FxStyleMask" + li, filterMode = FilterMode.Bilinear, wrapMode = TextureWrapMode.Clamp };
}
var rb = RenderTexture.GetTemporary(w, h, 16, RenderTextureFormat.ARGB32);
var rw = RenderTexture.GetTemporary(w, h, 16, RenderTextureFormat.ARGB32);
fxCam.CopyFrom(cam);
fxCam.enabled = false;
fxCam.cullingMask = 1 << (li == 0 ? LayerUnder : li == 1 ? LayerOver : LayerUnderAlt);
fxCam.clearFlags = CameraClearFlags.SolidColor;
fxCam.allowHDR = false;
fxCam.allowMSAA = false;
fxCam.backgroundColor = Color.black;
fxCam.targetTexture = rb;
fxCam.Render();
fxCam.backgroundColor = Color.white;
fxCam.targetTexture = rw;
fxCam.Render();
fxCam.targetTexture = null;
ApplyParams(resolveMat, styleMats[li], viewH / Mathf.Max(1, cam.pixelHeight), li == 2 ? altStyle : "");
Resolve(rb, rw, resolved[li], masks[li], resolveMat, viewH / h);
RenderTexture.ReleaseTemporary(rb);
RenderTexture.ReleaseTemporary(rw);
styleMats[li].mainTexture = resolved[li];
styleMats[li].SetTexture("_MaskTex", masks[li]);
var qt = quads[li].transform;
var cp = cam.transform.position;
// 변형 판(흙먼지)은 같은 순서의 기본 아래 판보다 조금 멀리 = 먼저 그려짐(다른 화풍 층 이펙트 아래)
qt.position = new Vector3(cp.x, cp.y, li == 2 ? 0.01f : 0f);
qt.rotation = cam.transform.rotation;
qt.localScale = new Vector3(viewW, viewH, 1f);
}
RenderTexture.active = prev;
}
}
}