429 lines
17 KiB
C#
429 lines
17 KiB
C#
using UnityEngine;
|
|
using UnityEngine.Pool;
|
|
using System.Collections.Generic;
|
|
|
|
public class groundParticularController : MonoBehaviour
|
|
{
|
|
[System.Serializable]
|
|
public struct MaterialConfig
|
|
{
|
|
public Material material;
|
|
public bool isEnabled;
|
|
[Tooltip("是否为该材质启用渐变颜色覆盖")]
|
|
public bool useGradientOverride;
|
|
[Tooltip("粒子生命周期内的颜色渐变 (仅在 useGradientOverride 开启时有效)")]
|
|
public Gradient colorGradient;
|
|
}
|
|
|
|
[Header("References")]
|
|
[Tooltip("粒子的起点")]
|
|
[SerializeField] private Transform startPoint;
|
|
[Tooltip("粒子的终点")]
|
|
[SerializeField] private Transform endPoint;
|
|
[Tooltip("作为粒子的预制体")]
|
|
[SerializeField] private GameObject particlePrefab;
|
|
|
|
[Header("Visuals")]
|
|
[Tooltip("粒子可用的材质配置列表")]
|
|
[SerializeField] private List<MaterialConfig> particleMaterials = new List<MaterialConfig>();
|
|
[Tooltip("粒子最小缩放比例")]
|
|
[SerializeField] private float minParticleScale = 0.8f;
|
|
[Tooltip("粒子最大缩放比例")]
|
|
[SerializeField] private float maxParticleScale = 1.2f;
|
|
|
|
[Header("Settings")]
|
|
[Tooltip("性能门控：是否启用粒子生成")]
|
|
public bool enableParticles = true;
|
|
[Tooltip("粒子的物理层级 (Layer Name)")]
|
|
[SerializeField] private string physicsLayerName = "particles";
|
|
[Tooltip("粒子的渲染层级名称 (Sorting Layer)")]
|
|
[SerializeField] private string sortingLayerName = "Default";
|
|
[Tooltip("粒子的渲染层级编号 (Order in Layer)")]
|
|
[SerializeField] private int sortingOrder = 0;
|
|
[Tooltip("渲染队列偏移 (Render Queue Offset)，用于解决 3D 物体与 UI 遮挡问题。数值越小越先渲染（被遮挡）")]
|
|
[SerializeField] private int renderQueueOffset = 0;
|
|
|
|
[Header("Spawn Quantity")]
|
|
[Tooltip("基础发射频率（每秒发射次数）")]
|
|
[SerializeField] private float baseEmitRate = 10f;
|
|
[Tooltip("每次发射生成的粒子数量 (Batch Size) - 增加此数值可显著增加粒子密度")]
|
|
[SerializeField] private int emitBatchSize = 1;
|
|
|
|
[Header("Spawn Randomness")]
|
|
[Tooltip("混乱度：随机时间偏移范围")]
|
|
[SerializeField] private float chaosRandomDelay = 0.05f;
|
|
[Tooltip("出生点 X 轴随机偏移范围")]
|
|
[SerializeField] private float spawnOffsetX = 0.5f;
|
|
[Tooltip("出生点 Z 轴 (深度) 随机偏移范围")]
|
|
[SerializeField] private float spawnOffsetY = 0.5f;
|
|
[Tooltip("速率系数，用于调节基础移动速度")]
|
|
[SerializeField] private float speedMultiplier = 0.1f;
|
|
[Tooltip("发射速度倍增器")]
|
|
[SerializeField] private float emissionSpeedMultiplier = 1f;
|
|
[SerializeField] private float perFrameMoveMultiplier = 0.01f;
|
|
|
|
[Header("Rotation Randomness")]
|
|
[Tooltip("If enabled, each spawned particle gets a random initial rotation offset.")]
|
|
[SerializeField] private bool enableRandomRotation = false;
|
|
[Tooltip("Random initial rotation range in degrees. Each axis is offset from -range to +range.")]
|
|
[SerializeField] private float randomRotationRangeDegrees = 0f;
|
|
|
|
[Tooltip("起点缩放抖动强度 (基于音频电平)")]
|
|
[SerializeField] private float shakeIntensity = 0.1f;
|
|
|
|
[Header("External References")]
|
|
[Tooltip("粒子生成的父物体")]
|
|
[SerializeField] private Transform particleParent;
|
|
[Tooltip("主音频源，用于同步音乐状态")]
|
|
public AudioSource musicSource;
|
|
[Tooltip("赋值对应的 BeatmapManager 以获取当前歌曲的 BPM")]
|
|
public BeatmapManager beatmapManager;
|
|
|
|
[Header("Audio Analysis")]
|
|
public bool useAudioAnalysis = true;
|
|
[Range(0, 1)] public float audioSensitivity = 0.5f;
|
|
[Tooltip("音频对发射频率的影响强度")]
|
|
[SerializeField] private float audioEmitBoost = 50f;
|
|
|
|
private float[] _audioSamples = new float[128];
|
|
private float _currentAverageVolume = 0f;
|
|
private float _emitTimer = 0f;
|
|
|
|
// 性能：复用一个 MaterialPropertyBlock，避免每颗粒子 new(GC)。
|
|
private MaterialPropertyBlock _sharedPropBlock;
|
|
// 性能：缓存粒子的 Renderer，避免 Emit/MoveRoutine 每次 GetComponent。
|
|
private readonly Dictionary<GameObject, Renderer> _rendererCache = new Dictionary<GameObject, Renderer>();
|
|
// 性能：记录已对某共享材质设过 renderQueue，避免重复写。
|
|
private readonly HashSet<Material> _renderQueueApplied = new HashSet<Material>();
|
|
// Shader 属性 ID 缓存(比字符串查找快，且避免每帧字符串)。
|
|
private static readonly int _headColorId = Shader.PropertyToID("_HeadColor");
|
|
private static readonly int _tailColorId = Shader.PropertyToID("_TailColor");
|
|
private static readonly int _moveDirId = Shader.PropertyToID("_MoveDir");
|
|
|
|
// 材质均衡分配逻辑
|
|
private List<MaterialConfig> _cachedEnabledConfigs = new List<MaterialConfig>();
|
|
private int _materialIndex = 0;
|
|
|
|
private IObjectPool<GameObject> _pool;
|
|
private Vector3 _originalStartScale;
|
|
|
|
private void Awake()
|
|
{
|
|
if (startPoint != null) _originalStartScale = startPoint.localScale;
|
|
_sharedPropBlock = new MaterialPropertyBlock();
|
|
|
|
_pool = new ObjectPool<GameObject>(
|
|
createFunc: () => {
|
|
GameObject go = Instantiate(particlePrefab);
|
|
go.SetActive(false);
|
|
// 创建时缓存 Renderer，后续 Emit/Move 复用，避免每颗粒子 GetComponent。
|
|
var r = go.GetComponent<Renderer>();
|
|
if (r != null) _rendererCache[go] = r;
|
|
return go;
|
|
},
|
|
actionOnGet: (obj) => {
|
|
obj.SetActive(true);
|
|
// 解决对象池拉线问题：如果球体带拖尾，获取时必须清除旧路径
|
|
var trail = obj.GetComponent<TrailRenderer>();
|
|
if (trail != null) trail.Clear();
|
|
},
|
|
actionOnRelease: (obj) => obj.SetActive(false),
|
|
actionOnDestroy: (obj) => Destroy(obj),
|
|
defaultCapacity: 30
|
|
);
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
// 执行实时音频 analysis（获取音量强度）
|
|
AnalyzeAudio();
|
|
|
|
// 持续发射逻辑
|
|
UpdateContinuousEmit();
|
|
|
|
|
|
|
|
// 起点缩放抖动
|
|
if (startPoint != null)
|
|
{
|
|
float shakeEffect = _currentAverageVolume * shakeIntensity;
|
|
startPoint.localScale = _originalStartScale * (1f + shakeEffect);
|
|
}
|
|
}
|
|
|
|
private void UpdateContinuousEmit()
|
|
{
|
|
// 门控检查：如果玩家禁用了粒子，则不执行生成逻辑
|
|
if (!enableParticles || musicSource == null || !musicSource.isPlaying) return;
|
|
|
|
// 计算当前瞬间的发射频率：基础频率 + 音频增益
|
|
float currentRate = baseEmitRate + (_currentAverageVolume * audioEmitBoost);
|
|
if (currentRate <= 0) return;
|
|
|
|
float interval = 1f / currentRate;
|
|
_emitTimer += Time.deltaTime;
|
|
|
|
if (_emitTimer >= interval)
|
|
{
|
|
_emitTimer = 0;
|
|
|
|
// 批量生成
|
|
for (int i = 0; i < emitBatchSize; i++)
|
|
{
|
|
// 引入混乱度：随机延迟发射。用协程替代 Invoke(nameof)——
|
|
// 后者每次做字符串反射+分配；协程延迟无字符串开销。
|
|
if (chaosRandomDelay > 0)
|
|
{
|
|
StartCoroutine(DelayedEmitRoutine(Random.Range(0f, chaosRandomDelay)));
|
|
}
|
|
else
|
|
{
|
|
Emit();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private System.Collections.IEnumerator DelayedEmitRoutine(float delay)
|
|
{
|
|
if (delay > 0f) yield return new WaitForSeconds(delay);
|
|
Emit();
|
|
}
|
|
|
|
// 取粒子缓存的 Renderer；未缓存(异常情况)则补取一次。
|
|
private Renderer GetCachedRenderer(GameObject particle)
|
|
{
|
|
if (particle == null) return null;
|
|
if (_rendererCache.TryGetValue(particle, out Renderer r) && r != null) return r;
|
|
r = particle.GetComponent<Renderer>();
|
|
if (r != null) _rendererCache[particle] = r;
|
|
return r;
|
|
}
|
|
|
|
private void AnalyzeAudio()
|
|
{
|
|
if (musicSource == null || !musicSource.isPlaying || !useAudioAnalysis)
|
|
{
|
|
_currentAverageVolume = 0;
|
|
return;
|
|
}
|
|
|
|
// 使用 GetOutputData 获取实时波形采样数据（电平）
|
|
musicSource.GetOutputData(_audioSamples, 0);
|
|
|
|
float sum = 0;
|
|
for (int i = 0; i < _audioSamples.Length; i++)
|
|
{
|
|
sum += Mathf.Abs(_audioSamples[i]);
|
|
}
|
|
|
|
// 计算平均振幅并应用敏感度
|
|
_currentAverageVolume = (sum / _audioSamples.Length) * audioSensitivity * 2.0f;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 发射一个粒子
|
|
/// </summary>
|
|
public void Emit()
|
|
{
|
|
if (startPoint == null || endPoint == null || particlePrefab == null) return;
|
|
|
|
// 1. 获取粒子
|
|
GameObject particle = _pool.Get();
|
|
|
|
// 2. 设置层级
|
|
particle.transform.SetParent(particleParent != null ? particleParent : null);
|
|
|
|
// 3. 计算缩放
|
|
float randomScale = Random.Range(minParticleScale, maxParticleScale);
|
|
float audioBoost = useAudioAnalysis ? (1f + _currentAverageVolume) : 1f;
|
|
particle.transform.localScale = particlePrefab.transform.localScale * randomScale * audioBoost;
|
|
|
|
// 4. 计算位置 (全表面随机 - XZ 平面)
|
|
// 修改为 X 和 Z 轴随机，以覆盖地面 (Ground) 的水平和深度方向
|
|
Vector3 surfaceRandomPos = new Vector3(Random.Range(-0.5f, 0.5f), 0f, Random.Range(-0.5f, 0.5f));
|
|
Vector3 finalLocalPos = surfaceRandomPos + new Vector3(
|
|
Random.Range(-spawnOffsetX, spawnOffsetX),
|
|
0f,
|
|
Random.Range(-spawnOffsetY, spawnOffsetY)
|
|
);
|
|
particle.transform.position = startPoint.TransformPoint(finalLocalPos);
|
|
particle.transform.rotation = GetSpawnRotation();
|
|
|
|
// 5. 材质均衡选取逻辑
|
|
MaterialConfig? selectedConfig = GetBalancedMaterialConfig();
|
|
|
|
// 设置物理层级
|
|
int layer = LayerMask.NameToLayer(physicsLayerName);
|
|
if (layer != -1)
|
|
{
|
|
particle.layer = layer;
|
|
}
|
|
|
|
Renderer renderer = GetCachedRenderer(particle);
|
|
if (renderer != null)
|
|
{
|
|
// 设置渲染层级
|
|
renderer.sortingLayerName = sortingLayerName;
|
|
renderer.sortingOrder = sortingOrder;
|
|
|
|
if (selectedConfig != null)
|
|
{
|
|
Material mat = selectedConfig.Value.material;
|
|
// 用共享材质(sharedMaterial)避免克隆实例产生 GC / 破坏合批。
|
|
// renderQueue 是全局统一配置(renderQueueOffset)，只需对每个材质设一次即可，
|
|
// 所有用该材质的粒子渲染队列一致，视觉与原来相同。
|
|
if (renderQueueOffset != 0 && _renderQueueApplied.Add(mat))
|
|
{
|
|
mat.renderQueue = mat.renderQueue + renderQueueOffset;
|
|
}
|
|
if (renderer.sharedMaterial != mat)
|
|
{
|
|
renderer.sharedMaterial = mat;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 6. 开始移动
|
|
StartCoroutine(MoveRoutine(particle, finalLocalPos, selectedConfig));
|
|
}
|
|
|
|
/// <summary>
|
|
/// 轮询式均衡选取材质，确保每种材质数量大致相同
|
|
/// </summary>
|
|
|
|
private Quaternion GetSpawnRotation()
|
|
{
|
|
if (!enableRandomRotation || randomRotationRangeDegrees <= 0f || startPoint == null)
|
|
{
|
|
return startPoint != null ? startPoint.rotation : Quaternion.identity;
|
|
}
|
|
|
|
float range = Mathf.Abs(randomRotationRangeDegrees);
|
|
Vector3 randomEuler = new Vector3(
|
|
Random.Range(-range, range),
|
|
Random.Range(-range, range),
|
|
Random.Range(-range, range)
|
|
);
|
|
|
|
return startPoint.rotation * Quaternion.Euler(randomEuler);
|
|
}
|
|
|
|
private MaterialConfig? GetBalancedMaterialConfig()
|
|
{
|
|
if (particleMaterials == null || particleMaterials.Count == 0) return null;
|
|
|
|
// 过滤出所有启用的材质
|
|
_cachedEnabledConfigs.Clear();
|
|
foreach (var config in particleMaterials)
|
|
{
|
|
if (config.isEnabled && config.material != null)
|
|
_cachedEnabledConfigs.Add(config);
|
|
}
|
|
|
|
if (_cachedEnabledConfigs.Count == 0) return null;
|
|
|
|
// 轮询选取
|
|
_materialIndex = (_materialIndex + 1) % _cachedEnabledConfigs.Count;
|
|
return _cachedEnabledConfigs[_materialIndex];
|
|
}
|
|
|
|
private System.Collections.IEnumerator MoveRoutine(GameObject particle, Vector3 initialLocalPos, MaterialConfig? config)
|
|
{
|
|
if (startPoint == null || endPoint == null) yield break;
|
|
|
|
// 【关键修复】在协程开始时，缓存起点的世界坐标
|
|
Vector3 spawnWorldPos = startPoint.TransformPoint(initialLocalPos);
|
|
|
|
Vector3 currentStartPos = startPoint.position;
|
|
Vector3 currentEndPos = endPoint.position;
|
|
Vector3 moveDir = (currentEndPos - currentStartPos).normalized;
|
|
float totalDist = Vector3.Distance(currentStartPos, currentEndPos);
|
|
float traveledDist = 0f;
|
|
|
|
particle.transform.position = spawnWorldPos;
|
|
|
|
// 复用共享属性块(不 new，避免每颗粒子 GC)与缓存的 Renderer。
|
|
MaterialPropertyBlock propBlock = _sharedPropBlock;
|
|
Renderer renderer = GetCachedRenderer(particle);
|
|
|
|
while (particle != null && particle.activeInHierarchy)
|
|
{
|
|
// 如果游戏暂停，则等待直到取消暂停
|
|
if (PauseManager.Instance != null && PauseManager.Instance.IsPaused)
|
|
{
|
|
yield return new WaitUntil(() => !PauseManager.Instance.IsPaused);
|
|
}
|
|
|
|
float currentBPM = GetCurrentBPM();
|
|
float noteSpawnerSpeedMultiplier = 1.0f;
|
|
// 粒子速度须与音符下落同速：跟随 NoteSpawner 的“有效 BPM”(开关决定用谱面 bpm 还是固定参考 bpm)。
|
|
if (beatmapManager != null && beatmapManager.noteSpawner != null)
|
|
{
|
|
noteSpawnerSpeedMultiplier = beatmapManager.noteSpawner.EffectiveSpeedMultiplier;
|
|
currentBPM = beatmapManager.noteSpawner.EffectiveBpm;
|
|
}
|
|
|
|
float effectiveBPM = Mathf.Max(currentBPM, 60f);
|
|
float noteSpeed = (totalDist * effectiveBPM * noteSpawnerSpeedMultiplier) / 240f;
|
|
|
|
float step = noteSpeed * speedMultiplier * emissionSpeedMultiplier * perFrameMoveMultiplier * Time.deltaTime;
|
|
if (step <= 0) step = 0.01f;
|
|
|
|
traveledDist += step;
|
|
particle.transform.position += moveDir * step;
|
|
|
|
// 【动态空间渐变色逻辑】
|
|
if (config != null && config.Value.useGradientOverride && renderer != null)
|
|
{
|
|
// 获取渐变的首尾颜色
|
|
Color headColor = config.Value.colorGradient.Evaluate(1f);
|
|
Color tailColor = config.Value.colorGradient.Evaluate(0f);
|
|
|
|
renderer.GetPropertyBlock(propBlock);
|
|
// 用缓存的属性 ID(避免每帧字符串查找)
|
|
propBlock.SetColor(_headColorId, headColor);
|
|
propBlock.SetColor(_tailColorId, tailColor);
|
|
propBlock.SetVector(_moveDirId, moveDir);
|
|
renderer.SetPropertyBlock(propBlock);
|
|
}
|
|
|
|
if (traveledDist >= totalDist)
|
|
{
|
|
if (particle.activeInHierarchy) _pool.Release(particle);
|
|
yield break;
|
|
}
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
private float GetCurrentBPM()
|
|
{
|
|
if (beatmapManager != null && beatmapManager.assignedSongData != null)
|
|
{
|
|
return beatmapManager.assignedSongData.bpm;
|
|
}
|
|
return 120f;
|
|
}
|
|
|
|
private void OnDrawGizmosSelected()
|
|
{
|
|
if (startPoint == null) return;
|
|
|
|
// 绘制起点的发射区域（完全匹配 Cube 的视觉大小）
|
|
Gizmos.matrix = startPoint.localToWorldMatrix;
|
|
Gizmos.color = Color.cyan;
|
|
Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
|
|
|
|
if (endPoint != null)
|
|
{
|
|
Gizmos.matrix = Matrix4x4.identity; // 切回世界坐标画线
|
|
Gizmos.color = Color.red;
|
|
Gizmos.DrawLine(startPoint.position, endPoint.position);
|
|
|
|
Gizmos.matrix = endPoint.localToWorldMatrix;
|
|
Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
|
|
}
|
|
}
|
|
}
|