333 lines
9.8 KiB
C#
333 lines
9.8 KiB
C#
using UnityEngine;
|
|
using System.Collections.Generic;
|
|
|
|
public enum WaveformType
|
|
{
|
|
Sine,
|
|
Square,
|
|
Triangle,
|
|
Sawtooth,
|
|
Noise,
|
|
Composite,
|
|
Pulse,
|
|
}
|
|
|
|
[RequireComponent(typeof(LineRenderer))]
|
|
public class WaveformVisualizer : MonoBehaviour
|
|
{
|
|
[HideInInspector]
|
|
public int samples = 1024;
|
|
[HideInInspector]
|
|
private float amplitude = 0.6f;
|
|
|
|
public float spatialFrequency = 1f;
|
|
public float temporalFrequency = 0.1f;
|
|
private float targetWaveformNoiseAmplitude = 0.1f;
|
|
public float noiseAmplitude = 0.5f;
|
|
[Range(0f, 1f)]
|
|
[HideInInspector]
|
|
public float clarity = 0f;
|
|
|
|
public Color noiseColor = Color.gray;
|
|
public Color clearColor = Color.green;
|
|
|
|
private LineRenderer lineRenderer;
|
|
[HideInInspector]
|
|
private SpriteRenderer spriteRenderer;
|
|
[HideInInspector]
|
|
public float spriteWidth;
|
|
[HideInInspector]
|
|
public float spriteHeight;
|
|
[HideInInspector]
|
|
public float[] waveformData;
|
|
private float[] noiseData;
|
|
[HideInInspector]
|
|
public float[] displayData;
|
|
private float[] antiWaveformData;
|
|
|
|
public int SpikeIndex => spikeIndex; // 使 spikeIndex 可通过属性访问
|
|
|
|
[HideInInspector]
|
|
public WaveformType waveformType = WaveformType.Sine;
|
|
|
|
public float amplitudeModulationFrequency = 0.5f;
|
|
public float amplitudeModulationDepth = 0.5f;
|
|
|
|
public float phaseShift = 0f; // 相位偏移
|
|
|
|
private bool isCaptured = false; // 是否已拍照（冻结波形）
|
|
|
|
private int spikeIndex; // 单个突刺位置
|
|
private bool isCorrect=true;
|
|
|
|
private bool isSpikeIndexSet = false; // 标志位，判断 spikeIndex 是否已设置
|
|
private TargetPointData targetdata;
|
|
public bool isErrorFind=false;
|
|
|
|
private LineRenderer scanLineRenderer; // 新的 LineRenderer
|
|
public float scanSpeed = 1f; // 扫描速度
|
|
private bool isScanning = false; // 是否正在扫描
|
|
|
|
|
|
|
|
void Start()
|
|
{
|
|
lineRenderer = GetComponent<LineRenderer>();
|
|
lineRenderer.positionCount = samples;
|
|
lineRenderer.useWorldSpace = false;
|
|
|
|
spriteRenderer = GetComponentInParent<SpriteRenderer>();
|
|
if (spriteRenderer != null)
|
|
{
|
|
spriteWidth = spriteRenderer.bounds.size.x;
|
|
spriteHeight = spriteRenderer.bounds.size.y;
|
|
lineRenderer.sortingLayerID = spriteRenderer.sortingLayerID;
|
|
lineRenderer.sortingOrder = spriteRenderer.sortingOrder + 3;
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError("Could not find SpriteRenderer in parent object.");
|
|
}
|
|
|
|
waveformData = new float[samples];
|
|
noiseData = new float[samples];
|
|
displayData = new float[samples];
|
|
antiWaveformData = new float[samples];
|
|
|
|
|
|
DrawWaveform(); // 初始化波形
|
|
}
|
|
|
|
void Update()
|
|
{
|
|
GenerateNoiseData();
|
|
GenerateWaveformData();
|
|
|
|
if (phaseShift > 0)
|
|
{
|
|
GenerateAntiWaveformData();
|
|
}
|
|
|
|
for (int i = 0; i < samples; i++)
|
|
{
|
|
displayData[i] = Mathf.Lerp(noiseData[i], waveformData[i], clarity);
|
|
if (phaseShift > 0)
|
|
{
|
|
displayData[i] += antiWaveformData[i];
|
|
}
|
|
if (!isCorrect)
|
|
{
|
|
HandleErrorDisplay(i);
|
|
}
|
|
displayData[i] = Mathf.Clamp(displayData[i], -spriteHeight / 1.8f, spriteHeight / 1.8f);
|
|
}
|
|
if(!isCorrect)
|
|
{
|
|
CheckError();
|
|
}
|
|
|
|
DrawWaveform();
|
|
|
|
}
|
|
|
|
void GenerateNoiseData()
|
|
{
|
|
float adjustedNoiseAmplitude = Mathf.Lerp(noiseAmplitude, targetWaveformNoiseAmplitude, clarity);
|
|
for (int i = 0; i < samples; i++)
|
|
{
|
|
noiseData[i] = Random.Range(-adjustedNoiseAmplitude, adjustedNoiseAmplitude);
|
|
}
|
|
}
|
|
|
|
void GenerateWaveformData()
|
|
{
|
|
for (int i = 0; i < samples; i++)
|
|
{
|
|
float t = (float)i / samples;
|
|
waveformData[i] = GetWaveformValue(t, 0) * clarity;
|
|
}
|
|
if(!isCorrect)
|
|
{
|
|
GenerateErrorData();
|
|
}
|
|
|
|
}
|
|
private void GenerateErrorData()
|
|
{
|
|
if (targetdata.spikeIndex != -1)
|
|
{
|
|
spikeIndex = targetdata.spikeIndex;
|
|
return;
|
|
}
|
|
|
|
if (isSpikeIndexSet) return; // 如果已设置，则不再随机
|
|
|
|
float threshold = 0.9f; // 80% 的阈值
|
|
|
|
// 找到波形数据中的最大绝对值
|
|
float maxAmplitude = 0f;
|
|
for (int i = 0; i < samples; i++)
|
|
{
|
|
maxAmplitude = Mathf.Max(maxAmplitude, Mathf.Abs(waveformData[i]));
|
|
}
|
|
|
|
// 计算超过 80% 最大值的阈值
|
|
float amplitudeThreshold = maxAmplitude * threshold;
|
|
|
|
// 找到所有超过阈值的点
|
|
List<int> candidateIndices = new List<int>();
|
|
for (int i = 0; i < samples; i++)
|
|
{
|
|
if (Mathf.Abs(waveformData[i]) > amplitudeThreshold)
|
|
{
|
|
candidateIndices.Add(i);
|
|
}
|
|
}
|
|
|
|
// 随机选择一个满足条件的点作为 spikeIndex
|
|
if (candidateIndices.Count > 0)
|
|
{
|
|
int randomIndex = Random.Range(0, candidateIndices.Count);
|
|
spikeIndex = candidateIndices[randomIndex];
|
|
isSpikeIndexSet = true; // 标志位设为 true，表示已设置过 spikeIndex
|
|
}
|
|
else
|
|
{
|
|
spikeIndex = 0; // 如果没有找到满足条件的点，则默认为 0
|
|
isSpikeIndexSet = true; // 即使没有找到满足条件的点，也将标志位设为 true
|
|
}
|
|
|
|
if (targetdata != null)
|
|
{
|
|
targetdata.spikeIndex = spikeIndex;
|
|
}
|
|
}
|
|
public void SetError(TargetPointData target)
|
|
{
|
|
isCorrect=false;
|
|
targetdata=target;
|
|
}
|
|
float GetWaveformValue(float t, float phaseOffset)
|
|
{
|
|
float time = Time.time * temporalFrequency;
|
|
//float amplitudeModulation = 1f + amplitudeModulationDepth * Mathf.Sin(2f * Mathf.PI * amplitudeModulationFrequency * Time.time);
|
|
float angle = t * Mathf.PI * 2f * spatialFrequency + phaseOffset;
|
|
|
|
float value = 0f;
|
|
|
|
// 计算波形值
|
|
switch (waveformType)
|
|
{
|
|
case WaveformType.Sine:
|
|
clearColor=Color.green;
|
|
value = Mathf.Sin(angle);
|
|
break;
|
|
case WaveformType.Square:
|
|
clearColor=Color.green;
|
|
value = Mathf.Sign(Mathf.Sin(angle));
|
|
break;
|
|
case WaveformType.Triangle:
|
|
clearColor=Color.green;
|
|
value = Mathf.PingPong(angle / Mathf.PI, 1f) * 2f - 1f;
|
|
break;
|
|
case WaveformType.Sawtooth:
|
|
clearColor=Color.green;
|
|
value = ((angle / (Mathf.PI * 2f)) % 1f) * 2f - 1f; // 统一周期为 2π
|
|
break;
|
|
case WaveformType.Pulse:
|
|
clearColor=Color.green;
|
|
value = Mathf.PingPong(angle / (Mathf.PI * 2f), 1f) > 0.5f ? 1f : -1f; // 统一周期为 2π
|
|
break;
|
|
case WaveformType.Noise:
|
|
clearColor=Color.red;
|
|
value = Mathf.PerlinNoise(angle / (Mathf.PI * 0.05f), Time.time * temporalFrequency*4) * 2f - 1f; // 统一周期为 2π
|
|
break;
|
|
case WaveformType.Composite:
|
|
clearColor=Color.green;
|
|
value = Mathf.Sin(angle) + Mathf.Sin(angle * 2f) * 0.5f; // 组合波形也统一周期
|
|
break;
|
|
default:
|
|
value = 0f;
|
|
break;
|
|
}
|
|
|
|
return value * amplitude; // 最终返回波形值
|
|
//return value * amplitude * amplitudeModulation; // 最终返回波形值
|
|
}
|
|
private void HandleErrorDisplay(int index)
|
|
{
|
|
float amplitudeScale = Mathf.Lerp(0.2f, 1f, clarity);
|
|
int distanceToSpike = Mathf.Abs(spikeIndex - index);
|
|
if (distanceToSpike <= 20) // 扩大扰动的半径
|
|
{
|
|
float attenuation = 1f - (float)distanceToSpike / 20f;
|
|
attenuation *= 0.9f; // 降低扰动强度
|
|
float baseAmplitude = displayData[index] * amplitudeScale * (spriteHeight / 2f);
|
|
float randomRange = (Mathf.Abs(baseAmplitude) - amplitude / 3f) * attenuation;
|
|
//isErrorFind = Mathf.Abs(baseAmplitude) < amplitude / 3;
|
|
if (Mathf.Abs(baseAmplitude) < amplitude / 3)
|
|
{
|
|
float randomOffset = Random.Range(-randomRange, randomRange);
|
|
displayData[index] += randomOffset; // 对 Y 值进行随机扰动
|
|
}
|
|
|
|
|
|
//displayData[index] += Random.Range(-attenuation * 0.5f, attenuation * 0.5f); // 添加随机扰动
|
|
}
|
|
}
|
|
private void CheckError()
|
|
{
|
|
isErrorFind=displayData[spikeIndex]<amplitude / 3f;
|
|
}
|
|
|
|
|
|
void GenerateAntiWaveformData()
|
|
{
|
|
for (int i = 0; i < samples; i++)
|
|
{
|
|
float t = (float)i / samples;
|
|
antiWaveformData[i] = -GetWaveformValue(t, phaseShift) * clarity;
|
|
}
|
|
}
|
|
void DrawWaveform()
|
|
{
|
|
for (int i = 0; i < samples; i++)
|
|
{
|
|
float x = ((float)i / (samples - 1)) * spriteWidth - (spriteWidth / 2f);
|
|
float amplitudeScale = Mathf.Lerp(0.2f, 1f, clarity);
|
|
|
|
// 获取波形值
|
|
float y = displayData[i] * amplitudeScale * (spriteHeight / 2f);
|
|
|
|
Vector3 position = new Vector3(x, y, 0);
|
|
lineRenderer.SetPosition(i, position);
|
|
}
|
|
|
|
Color waveColor = Color.Lerp(noiseColor, clearColor, clarity);
|
|
lineRenderer.startColor = waveColor;
|
|
lineRenderer.endColor = waveColor;
|
|
|
|
float startWidth = Mathf.Lerp(0.02f, 0.05f, clarity);
|
|
lineRenderer.startWidth = startWidth;
|
|
lineRenderer.endWidth = startWidth;
|
|
}
|
|
|
|
// 应用相位偏移
|
|
public void SetPhaseShift(float phaseShiftValue)
|
|
{
|
|
phaseShift = phaseShiftValue;
|
|
}
|
|
// 重置波形
|
|
public void ResetWaveform()
|
|
{
|
|
clearColor=Color.green;
|
|
isCaptured = false;
|
|
phaseShift = 0f;
|
|
spikeIndex=0;
|
|
isCorrect=true;
|
|
isSpikeIndexSet = false;
|
|
targetdata=null;
|
|
isErrorFind=false;
|
|
}
|
|
}
|