243 lines
9.4 KiB
C#
243 lines
9.4 KiB
C#
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
namespace Code.OfficeGame.BattleMode.Actions
|
|
{
|
|
public class EntityPreviewVisuals : MonoBehaviour
|
|
{
|
|
public const int MaxGhostStages = 5; // 0 = Commit + до 4 прерываний
|
|
|
|
[Header("Материалы MKToon")]
|
|
[SerializeField] private Material snapshotGhostMaterial;
|
|
[SerializeField] private Material activePreviewMaterial;
|
|
|
|
[Header("Цвета проекции по стадиям прерываний")]
|
|
[SerializeField] private Color[] stageProjectionTints =
|
|
{
|
|
new(0.55f, 0.85f, 1.0f, 1f), // Stage 0: до первого прерывания (голубой)
|
|
new(1.0f, 0.85f, 0.35f, 1f), // Stage 1: после 1-го прерывания (жёлтый)
|
|
new(1.0f, 0.55f, 0.25f, 1f), // Stage 2: после 2-го прерывания (оранжевый)
|
|
new(0.95f, 0.3f, 0.5f, 1f), // Stage 3+: 3+ прерываний (малиновый)
|
|
};
|
|
|
|
[Header("Цвета статичных слепков")]
|
|
[SerializeField] private Color defaultGhostTint = new(0.6f, 0.85f, 1f, 0.35f);
|
|
[SerializeField] private Color completedActorGhostColor = new(0.2f, 1f, 0.45f, 0.65f);
|
|
|
|
private sealed class GhostSlot
|
|
{
|
|
public GameObject Root;
|
|
public Mesh[] BakedMeshes;
|
|
public MeshFilter[] Filters;
|
|
public MeshRenderer[] Renderers;
|
|
public int TriggerFrame = int.MaxValue;
|
|
public bool IsActiveInBake;
|
|
}
|
|
|
|
private SkinnedMeshRenderer[] _skinnedRenderers;
|
|
private MeshRenderer[] _meshRenderers;
|
|
private readonly Dictionary<Renderer, Material[]> _originalMaterials = new();
|
|
private GhostSlot[] _ghostSlots;
|
|
|
|
private MaterialPropertyBlock _propBlock;
|
|
private static readonly int AlbedoColorId = Shader.PropertyToID("_AlbedoColor");
|
|
private static readonly int BaseColorId = Shader.PropertyToID("_BaseColor");
|
|
private static readonly int RimColorId = Shader.PropertyToID("_RimColor");
|
|
|
|
private bool _isPreviewLookApplied;
|
|
private int _currentAppliedStage = -1;
|
|
|
|
private void Awake()
|
|
{
|
|
_propBlock = new MaterialPropertyBlock();
|
|
_skinnedRenderers = GetComponentsInChildren<SkinnedMeshRenderer>();
|
|
_meshRenderers = GetComponentsInChildren<MeshRenderer>();
|
|
|
|
foreach (var sr in _skinnedRenderers) _originalMaterials[sr] = sr.sharedMaterials;
|
|
foreach (var mr in _meshRenderers) _originalMaterials[mr] = mr.sharedMaterials;
|
|
|
|
InitializeGhostPool();
|
|
}
|
|
|
|
private void InitializeGhostPool()
|
|
{
|
|
_ghostSlots = new GhostSlot[MaxGhostStages];
|
|
|
|
for (int s = 0; s < MaxGhostStages; s++)
|
|
{
|
|
var root = new GameObject($"{gameObject.name}_GhostStage_{s}");
|
|
root.SetActive(false);
|
|
|
|
int count = _skinnedRenderers.Length;
|
|
var slot = new GhostSlot
|
|
{
|
|
Root = root,
|
|
BakedMeshes = new Mesh[count],
|
|
Filters = new MeshFilter[count],
|
|
Renderers = new MeshRenderer[count]
|
|
};
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
var partGo = new GameObject($"Part_{i}");
|
|
partGo.transform.SetParent(root.transform, false);
|
|
|
|
var mf = partGo.AddComponent<MeshFilter>();
|
|
var mr = partGo.AddComponent<MeshRenderer>();
|
|
mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
|
|
|
|
var mesh = new Mesh { name = $"BakedGhost_{s}_{i}" };
|
|
mf.sharedMesh = mesh;
|
|
|
|
slot.BakedMeshes[i] = mesh;
|
|
slot.Filters[i] = mf;
|
|
slot.Renderers[i] = mr;
|
|
}
|
|
|
|
_ghostSlots[s] = slot;
|
|
}
|
|
}
|
|
|
|
public void ClearAllGhosts()
|
|
{
|
|
if (_ghostSlots == null) return;
|
|
foreach (var slot in _ghostSlots)
|
|
{
|
|
slot.IsActiveInBake = false;
|
|
slot.TriggerFrame = int.MaxValue;
|
|
if (slot.Root != null) slot.Root.SetActive(false);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Запекает статичный слепок во время BakeFrom (в точке Commit или в точке прерывания).
|
|
/// </summary>
|
|
public void BakeGhostAtStage(int stageIndex, int triggerFrame, bool isCompletingActor)
|
|
{
|
|
if (snapshotGhostMaterial == null || stageIndex < 0 || stageIndex >= MaxGhostStages)
|
|
return;
|
|
|
|
var slot = _ghostSlots[stageIndex];
|
|
slot.TriggerFrame = triggerFrame;
|
|
slot.IsActiveInBake = true;
|
|
slot.Root.transform.SetPositionAndRotation(transform.position, transform.rotation);
|
|
|
|
Color ghostColor = isCompletingActor
|
|
? completedActorGhostColor
|
|
: GetStageColor(stageIndex, alphaOverride: defaultGhostTint.a);
|
|
|
|
for (int i = 0; i < _skinnedRenderers.Length; i++)
|
|
{
|
|
var sr = _skinnedRenderers[i];
|
|
sr.BakeMesh(slot.BakedMeshes[i]);
|
|
|
|
var ghostTransform = slot.Filters[i].transform;
|
|
ghostTransform.SetPositionAndRotation(sr.transform.position, sr.transform.rotation);
|
|
|
|
int subMeshCount = Mathf.Max(1, slot.BakedMeshes[i].subMeshCount);
|
|
var mats = new Material[subMeshCount];
|
|
for (int m = 0; m < subMeshCount; m++) mats[m] = snapshotGhostMaterial;
|
|
slot.Renderers[i].sharedMaterials = mats;
|
|
|
|
slot.Renderers[i].GetPropertyBlock(_propBlock);
|
|
_propBlock.SetColor(AlbedoColorId, ghostColor);
|
|
_propBlock.SetColor(BaseColorId, ghostColor);
|
|
slot.Renderers[i].SetPropertyBlock(_propBlock);
|
|
}
|
|
|
|
slot.Root.SetActive(false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Синхронизирует видимость слепков и цвет проекции для текущего кадра ползунка.
|
|
/// Для прошлых кадров (viewFrame <= committedFrame) проекция автоматически выключается!
|
|
/// </summary>
|
|
public void UpdateForTimelineFrame(int viewFrame, int committedFrame, int interruptionStage, bool showPreviewVisuals)
|
|
{
|
|
bool inFuture = showPreviewVisuals && viewFrame > committedFrame;
|
|
|
|
if (!inFuture)
|
|
{
|
|
HidePreviewLook();
|
|
for (int s = 0; s < _ghostSlots.Length; s++)
|
|
if (_ghostSlots[s].Root.activeSelf) _ghostSlots[s].Root.SetActive(false);
|
|
return;
|
|
}
|
|
|
|
ApplyPreviewLook(interruptionStage);
|
|
|
|
for (int s = 0; s < _ghostSlots.Length; s++)
|
|
{
|
|
var slot = _ghostSlots[s];
|
|
bool shouldShow = slot.IsActiveInBake && viewFrame > slot.TriggerFrame;
|
|
if (slot.Root.activeSelf != shouldShow)
|
|
slot.Root.SetActive(shouldShow);
|
|
}
|
|
}
|
|
|
|
public void HidePreviewState()
|
|
{
|
|
ClearAllGhosts();
|
|
HidePreviewLook();
|
|
}
|
|
|
|
private void ApplyPreviewLook(int stage)
|
|
{
|
|
if (_isPreviewLookApplied && _currentAppliedStage == stage) return;
|
|
_isPreviewLookApplied = true;
|
|
_currentAppliedStage = stage;
|
|
|
|
Color tint = GetStageColor(stage);
|
|
|
|
foreach (var (renderer, origMats) in _originalMaterials)
|
|
{
|
|
if (renderer == null) continue;
|
|
|
|
if (activePreviewMaterial != null)
|
|
{
|
|
var previewMats = new Material[origMats.Length];
|
|
for (int i = 0; i < previewMats.Length; i++) previewMats[i] = activePreviewMaterial;
|
|
renderer.sharedMaterials = previewMats;
|
|
}
|
|
|
|
renderer.GetPropertyBlock(_propBlock);
|
|
_propBlock.SetColor(AlbedoColorId, tint);
|
|
_propBlock.SetColor(RimColorId, tint * 1.5f);
|
|
renderer.SetPropertyBlock(_propBlock);
|
|
}
|
|
}
|
|
|
|
private void HidePreviewLook()
|
|
{
|
|
if (!_isPreviewLookApplied) return;
|
|
_isPreviewLookApplied = false;
|
|
_currentAppliedStage = -1;
|
|
|
|
foreach (var (renderer, origMats) in _originalMaterials)
|
|
{
|
|
if (renderer == null) continue;
|
|
if (activePreviewMaterial != null) renderer.sharedMaterials = origMats;
|
|
renderer.SetPropertyBlock(null);
|
|
}
|
|
}
|
|
|
|
private Color GetStageColor(int stage, float? alphaOverride = null)
|
|
{
|
|
Color c = stageProjectionTints[Mathf.Clamp(stage, 0, stageProjectionTints.Length - 1)];
|
|
if (alphaOverride.HasValue) c.a = alphaOverride.Value;
|
|
return c;
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
if (_ghostSlots == null) return;
|
|
foreach (var slot in _ghostSlots)
|
|
{
|
|
if (slot == null) continue;
|
|
foreach (var mesh in slot.BakedMeshes)
|
|
if (mesh != null) Destroy(mesh);
|
|
if (slot.Root != null) Destroy(slot.Root);
|
|
}
|
|
}
|
|
}
|
|
} |