UP-Viagg-io/Viagg-io/Assets/Packages/Graphy - Ultimate Stats Mon.../Runtime/Audio/G_AudioGraph.cs

294 lines
10 KiB
C#
Raw Normal View History

/* ---------------------------------------
* Author: Martin Pane (martintayx@gmail.com) (@martinTayx)
* Contributors: https://github.com/Tayx94/graphy/graphs/contributors
* Project: Graphy - Ultimate Stats Monitor
* Date: 15-Dec-17
* Studio: Tayx
*
* Git repo: https://github.com/Tayx94/graphy
*
* This project is released under the MIT license.
* Attribution is not required, but it is always welcomed!
* -------------------------------------*/
using Tayx.Graphy.Graph;
using UnityEngine;
using UnityEngine.UI;
namespace Tayx.Graphy.Audio
{
public class G_AudioGraph : G_Graph
{
#region Variables -> Serialized Private
[SerializeField] private Image m_imageGraph = null;
[SerializeField] private Image m_imageGraphHighestValues = null;
[SerializeField] private Shader ShaderFull = null;
[SerializeField] private Shader ShaderLight = null;
[SerializeField] private bool m_isInitialized = false;
#endregion
#region Variables -> Private
private GraphyManager m_graphyManager = null;
private G_AudioMonitor m_audioMonitor = null;
private int m_resolution = 40;
private G_GraphShader m_shaderGraph = null;
private G_GraphShader m_shaderGraphHighestValues = null;
private float[] m_graphArray;
private float[] m_graphArrayHighestValue;
#endregion
#region Methods -> Unity Callbacks
private void OnEnable()
{
/* ----- NOTE: ----------------------------
* We used to Init() here regardless of
* whether this module was enabled.
* The reason we don't Init() here
* anymore is that some users are on
* platforms that do not support the arrays
* in the Shaders.
*
* See: https://github.com/Tayx94/graphy/issues/17
*
* Even though we don't Init() competely
* here anymore, we still need
* m_audioMonitor for in Update()
* --------------------------------------*/
m_audioMonitor = GetComponent<G_AudioMonitor>();
}
private void Update()
{
if( m_audioMonitor.SpectrumDataAvailable )
{
UpdateGraph();
}
}
#endregion
#region Methods -> Public
public void UpdateParameters()
{
if( m_shaderGraph == null )
{
// While Graphy is disabled (e.g. by default via Ctrl+H) and while in Editor after a Hot-Swap,
// the OnApplicationFocus calls this while m_shaderGraph == null, throwing a NullReferenceException
return;
}
switch( m_graphyManager.GraphyMode )
{
case GraphyManager.Mode.FULL:
m_shaderGraph.ArrayMaxSize = G_GraphShader.ArrayMaxSizeFull;
m_shaderGraph.Image.material = new Material( ShaderFull );
m_shaderGraphHighestValues.ArrayMaxSize = G_GraphShader.ArrayMaxSizeFull;
m_shaderGraphHighestValues.Image.material = new Material( ShaderFull );
break;
case GraphyManager.Mode.LIGHT:
m_shaderGraph.ArrayMaxSize = G_GraphShader.ArrayMaxSizeLight;
m_shaderGraph.Image.material = new Material( ShaderLight );
m_shaderGraphHighestValues.ArrayMaxSize = G_GraphShader.ArrayMaxSizeLight;
m_shaderGraphHighestValues.Image.material = new Material( ShaderLight );
break;
}
m_shaderGraph.InitializeShader();
m_shaderGraphHighestValues.InitializeShader();
m_resolution = m_graphyManager.AudioGraphResolution;
CreatePoints();
}
#endregion
#region Methods -> Protected Override
protected override void UpdateGraph()
{
// Since we no longer initialize by default OnEnable(),
// we need to check here, and Init() if needed
if( !m_isInitialized )
{
Init();
}
int incrementPerIteration = Mathf.FloorToInt( m_audioMonitor.Spectrum.Length / (float) m_resolution );
// Current values -------------------------
for( int i = 0; i <= m_resolution - 1; i++ )
{
float currentValue = 0;
for( int j = 0; j < incrementPerIteration; j++ )
{
currentValue += m_audioMonitor.Spectrum[ i * incrementPerIteration + j ];
}
// Uses 3 values for each bar to accomplish that look
if( (i + 1) % 3 == 0 && i > 1 )
{
float value =
(
m_audioMonitor.dBNormalized( m_audioMonitor.lin2dB( currentValue / incrementPerIteration ) )
+ m_graphArray[ i - 1 ]
+ m_graphArray[ i - 2 ]
) / 3;
m_graphArray[ i ] = value;
m_graphArray[ i - 1 ] = value;
m_graphArray[ i - 2 ] =
-1; // Always set the third one to -1 to leave gaps in the graph and improve readability
}
else
{
m_graphArray[ i ] =
m_audioMonitor.dBNormalized( m_audioMonitor.lin2dB( currentValue / incrementPerIteration ) );
}
}
for( int i = 0; i <= m_resolution - 1; i++ )
{
m_shaderGraph.ShaderArrayValues[ i ] = m_graphArray[ i ];
}
m_shaderGraph.UpdatePoints();
// Highest values -------------------------
for( int i = 0; i <= m_resolution - 1; i++ )
{
float currentValue = 0;
for( int j = 0; j < incrementPerIteration; j++ )
{
currentValue += m_audioMonitor.SpectrumHighestValues[ i * incrementPerIteration + j ];
}
// Uses 3 values for each bar to accomplish that look
if( (i + 1) % 3 == 0 && i > 1 )
{
float value =
(
m_audioMonitor.dBNormalized( m_audioMonitor.lin2dB( currentValue / incrementPerIteration ) )
+ m_graphArrayHighestValue[ i - 1 ]
+ m_graphArrayHighestValue[ i - 2 ]
) / 3;
m_graphArrayHighestValue[ i ] = value;
m_graphArrayHighestValue[ i - 1 ] = value;
m_graphArrayHighestValue[ i - 2 ] =
-1; // Always set the third one to -1 to leave gaps in the graph and improve readability
}
else
{
m_graphArrayHighestValue[ i ] =
m_audioMonitor.dBNormalized( m_audioMonitor.lin2dB( currentValue / incrementPerIteration ) );
}
}
for( int i = 0; i <= m_resolution - 1; i++ )
{
m_shaderGraphHighestValues.ShaderArrayValues[ i ] = m_graphArrayHighestValue[ i ];
}
m_shaderGraphHighestValues.UpdatePoints();
}
protected override void CreatePoints()
{
// Init Arrays
if( m_shaderGraph.ShaderArrayValues == null || m_shaderGraph.ShaderArrayValues.Length != m_resolution )
{
m_graphArray = new float[m_resolution];
m_graphArrayHighestValue = new float[m_resolution];
m_shaderGraph.ShaderArrayValues = new float[m_resolution];
m_shaderGraphHighestValues.ShaderArrayValues = new float[m_resolution];
}
for( int i = 0; i < m_resolution; i++ )
{
m_shaderGraph.ShaderArrayValues[ i ] = 0;
m_shaderGraphHighestValues.ShaderArrayValues[ i ] = 0;
}
// Color
m_shaderGraph.GoodColor = m_graphyManager.AudioGraphColor;
m_shaderGraph.CautionColor = m_graphyManager.AudioGraphColor;
m_shaderGraph.CriticalColor = m_graphyManager.AudioGraphColor;
m_shaderGraph.UpdateColors();
m_shaderGraphHighestValues.GoodColor = m_graphyManager.AudioGraphColor;
m_shaderGraphHighestValues.CautionColor = m_graphyManager.AudioGraphColor;
m_shaderGraphHighestValues.CriticalColor = m_graphyManager.AudioGraphColor;
m_shaderGraphHighestValues.UpdateColors();
// Threshold
m_shaderGraph.GoodThreshold = 0;
m_shaderGraph.CautionThreshold = 0;
m_shaderGraph.UpdateThresholds();
m_shaderGraphHighestValues.GoodThreshold = 0;
m_shaderGraphHighestValues.CautionThreshold = 0;
m_shaderGraphHighestValues.UpdateThresholds();
// Update Array
m_shaderGraph.UpdateArrayValuesLength();
m_shaderGraphHighestValues.UpdateArrayValuesLength();
// Average
m_shaderGraph.Average = 0;
m_shaderGraph.UpdateAverage();
m_shaderGraphHighestValues.Average = 0;
m_shaderGraphHighestValues.UpdateAverage();
}
#endregion
#region Methods -> Private
private void Init()
{
m_graphyManager = transform.root.GetComponentInChildren<GraphyManager>();
m_audioMonitor = GetComponent<G_AudioMonitor>();
m_shaderGraph = new G_GraphShader
{
Image = m_imageGraph
};
m_shaderGraphHighestValues = new G_GraphShader
{
Image = m_imageGraphHighestValues
};
UpdateParameters();
m_isInitialized = true;
}
#endregion
}
}