void CheckForBeat()
{
GameObject beatCube = GameObject.FindGameObjectWithTag("Beat Cube");
Renderer cubeRend = beatCube.GetComponent <Renderer>();
float[] rightChannel = new float[SAMPLE_SIZE];
float[] leftChannel = new float[SAMPLE_SIZE];
source.GetOutputData(rightChannel, 0);
source.GetOutputData(leftChannel, 1);
float instantEnergy = AudioAnalyser.GetInstantEnergy(rightChannel, leftChannel);
float localAverageEnergy = AudioAnalyser.GetLocalAverageEnergy(instantEnergyHistory);
float variance = AudioAnalyser.GetEnergyVariance(instantEnergyHistory, localAverageEnergy);
float constant = AudioAnalyser.GetEnergyFormulaConstant(variance);
float[] shiftArray = new float[instantEnergyHistory.Length];
Array.Copy(instantEnergyHistory, 0, shiftArray, 1, instantEnergyHistory.Length - 1);
shiftArray[0] = instantEnergy;
Array.Copy(shiftArray, instantEnergyHistory, shiftArray.Length);
float beatEnergyTarget = constant * localAverageEnergy;
Debug.Log("Instant Energy: " + instantEnergyHistory[0] + "\nAverage Energy: " + localAverageEnergy + "\nEnergy Constant: " + constant + "\nBeat target: " + beatEnergyTarget);
if (instantEnergy > beatEnergyTarget)
{
Debug.Log("Beat Detected");
cubeRend.material.color = Color.green;
beatCount += 1;
}
else
{
cubeRend.material.color = Color.red;
}
}
// Use this for initialization
void Start()
{
elapsedTime = 0;
GameObject audioAnalyser = GameObject.FindGameObjectWithTag("AudioAnalyser");
analyser = audioAnalyser.GetComponent <AudioAnalyser>();
}
private Beat[] ProcessStereo(float[] samples, int numOfSamples, int frequency)
{
Debug.Log("Processing Stereo Song");
float[] rightSamples = new float[numOfSamples];
float[] leftSamples = new float[numOfSamples];
for (int i = 0; i < numOfSamples; i += 1)
{
rightSamples[i] = samples[i * 2];
leftSamples[i] = samples[(i * 2) + 1];
}
Beat[] beatTrack = new Beat[windowIterations + 1];
for (int i = 0; i < beatTrack.Length; i += 1)
{
float[] tempRight = new float[windowInterval];
float[] tempLeft = new float[windowInterval];
if (i < windowIterations)
{
for (int j = 0; j < windowInterval; j += 1)
{
tempRight[j] = rightSamples[(windowInterval * i) + j];
tempLeft[j] = leftSamples[(windowInterval * i) + j];
}
}
else
{
for (int j = 0; j < lastWindowSize; j += 1)
{
tempRight[j] = rightSamples[(windowInterval * i) + j];
tempLeft[j] = leftSamples[(windowInterval * i) + j];
}
}
List <float[]> bandsRight = AudioAnalyser.GetDistinctBands(FastFourierTransform.FftMag(tempRight), frequency, windowInterval / 2.0f);
List <float[]> bandsLeft = AudioAnalyser.GetDistinctBands(FastFourierTransform.FftMag(tempLeft), frequency, windowInterval / 2.0f);
if (energyHistories.Count == 0)
{
Debug.Log("Creating histories");
energyHistories = new List <float[]>();
for (int b = 0; b < bandsRight.Count; b += 1)
{
energyHistories.Add(new float[historyBufferLength]);
bandVariances.Add(new float[historyBufferLength]);
}
}
beatTrack[i] = CheckForBeatBands(bandsRight, bandsLeft);
if (beatTrack[i] != null)
{
beatTrack[i].windowNumber = i;
beatTrack[i].timeStamp = WindowPositionToTime(i);
}
}
return(beatTrack);
}
// Use this for initialization
void Start()
{
canFire = true;
cooldownTime = isPlayer ? 5 : 60;
timeLeftToFire = cooldownTime;
GameObject audioAnalyser = GameObject.FindGameObjectWithTag("AudioAnalyser");
analyser = audioAnalyser.GetComponent <AudioAnalyser>();
target = GameObject.FindGameObjectWithTag("Player");
targetPosition = new Vector3(target.transform.position.x, target.transform.position.y + 1f, target.transform.position.z);
}
// Start is called before the first frame update
void Awake()
{
if (instance)
{
Destroy(this);
}
else
{
instance = this;
}
audioSource = GetComponent <AudioSource>();
audioSource.clip = musicClip;
}
private Beat CheckForBeatBands(List <float[]> rightChannel, List <float[]> leftChannel)
{
float[] instantEnergies = new float[rightChannel.Count];
float[] averageEnergies = new float[rightChannel.Count];
float[] targetTemp = new float[rightChannel.Count];
int beatNum = 0;
for (int i = 0; i < rightChannel.Count; i += 1)
{
if (leftChannel != null)
{
instantEnergies[i] = AudioAnalyser.GetInstantEnergy(rightChannel.ElementAt(i), leftChannel.ElementAt(i));
}
else
{
instantEnergies[i] = AudioAnalyser.GetInstantEnergy(rightChannel.ElementAt(i), null);
}
float[] shiftArray = new float[historyBufferLength];
Array.Copy(energyHistories.ElementAt(i), 0, shiftArray, 1, historyBufferLength - 1);
shiftArray[0] = instantEnergies[i];
energyHistories.Insert(i, shiftArray);
averageEnergies[i] = AudioAnalyser.GetLocalAverageEnergy(energyHistories.ElementAt(i));
float variance = AudioAnalyser.GetEnergyVariance(energyHistories.ElementAt(i), averageEnergies[i]);
float constant = 1;
float[] varianceShift = new float[historyBufferLength];
Array.Copy(bandVariances.ElementAt(i), 0, varianceShift, 1, historyBufferLength - 1);
varianceShift[0] = variance;
bandVariances.Insert(i, varianceShift);
float beatEnergyTarget = constant * averageEnergies[i];
float averageVariance = bandVariances.ElementAt(i).Average();
if (variance > averageVariance && instantEnergies[i] > beatEnergyTarget)
{
Debug.Log("Instant Energy: " + instantEnergies[i] + "\nAverage Energy: " + averageEnergies[i] + "\nEnergy Constant: " + constant + "\nBeat target: " + beatEnergyTarget);
Debug.Log("Variance: " + variance + "\nAverage Variance: " + averageVariance);
targetTemp[i] = beatEnergyTarget;
beatNum += 1;
}
}
if (beatNum > 0)
{
return(new Beat(0, 0, instantEnergies, averageEnergies, targetTemp));
}
return(null);
}
private void Update()
{
Mesh mesh = GetComponent <MeshFilter>().mesh;
vertices = mesh.vertices;
source.GetSpectrumData(spectrum, 0, FFTWindow.BlackmanHarris);
bands = AudioAnalyser.GetBandAverages(spectrum, source.clip.frequency, SAMPLE_SIZE);
int vertexCount = 0;
for (float x = 0; x <= meshDepth; x += xInterval)
{
for (float z = 0; z <= roadLength; z += zInterval)
{
if (x == 0 || x == meshDepth || z == 0 || z == roadLength)
{
height = 0;
}
else
{
float risingInterpolater = 0;
float fallingInterpolator = 0;
float interpolation = 0;
int reverseArrayPosition = ((int)meshDepth - 1) - (int)x;
float scaleY = bands.ElementAt(reverseArrayPosition) * scaleMultiplier;
risingInterpolater += Time.deltaTime * risingSmoothSpeed;
fallingInterpolator += Time.deltaTime * fallingSmoothSpeed;
interpolation = scaleY > previousY?Mathf.Lerp(eqBandPreviousY[reverseArrayPosition], scaleY, risingInterpolater)
: Mathf.Lerp(eqBandPreviousY[reverseArrayPosition], eqBandPreviousY[reverseArrayPosition] * 0.8f, fallingInterpolator);
height = interpolation;
eqBandPreviousY[reverseArrayPosition] = interpolation;
}
if (orientation == Orientation.Left)
{
vertices[vertexCount] = new Vector3(-x, height, z);
}
else
{
vertices[vertexCount] = new Vector3(x, height, z);
}
vertexCount += 1;
}
}
mesh.vertices = vertices;
mesh.RecalculateNormals();
mesh.RecalculateBounds();
}
private void ControlMusic()
{
// Playing and pausing
if (Input.GetButton("Left Bumper") && Input.GetButtonDown("A") || Input.GetKeyDown(KeyCode.Space))
{
AudioAnalyser.GetInstance().TogglePlayback();
}
// Stopping
if (Input.GetButton("Left Bumper") && Input.GetButtonDown("B") || Input.GetKey(KeyCode.Backspace))
{
print("here");
AudioAnalyser.GetInstance().StopPlayback();
}
}
// Use this for initialization
void Start()
{
audioAnalyser = GetComponent <AudioAnalyser>();
clock = GetComponent <Clock>();
numBands = 16;
gameObjects = new List <GameObject>();
beats = new List <GameObject>();
frequencyBandAmplitudes = audioAnalyser.spectrum;
for (int i = 0; i < frequencyBandAmplitudes.Length; ++i)
{
GameObject go = GameObject.Instantiate <GameObject>(cube, new Vector3((i - 30) * .6f, 0, 30), Quaternion.identity);
go.GetComponent <Renderer>().material.color = Color.HSVToRGB(i * 4 / (float)frequencyBandAmplitudes.Length, 1, 1);
gameObjects.Add(go);
}
}
private Beat[] ProcessMono(float[] samples, int frequency)
{
Debug.Log("Processing Mono Song");
Beat[] beatTrack = new Beat[windowIterations + 1];
for (int i = 0; i < beatTrack.Length; i += 1)
{
float[] temp = new float[windowInterval];
if (i < windowIterations)
{
for (int j = 0; j < windowInterval; j += 1)
{
temp[j] = samples[(windowInterval * i) + j];
}
}
else
{
for (int j = 0; j < lastWindowSize; j += 1)
{
temp[j] = samples[(windowInterval * i) + j];
}
}
List <float[]> bands = AudioAnalyser.GetDistinctBands(FastFourierTransform.FftMag(temp), frequency, windowInterval / 2.0f);
if (energyHistories.Count == 0)
{
Debug.Log("Creating histories");
energyHistories = new List <float[]>();
for (int b = 0; b < bands.Count - 1; b += 1)
{
energyHistories.Add(new float[historyBufferLength]);
bandVariances.Add(new float[historyBufferLength]);
}
}
beatTrack[i] = CheckForBeatBands(bands, null);
if (beatTrack[i] != null)
{
beatTrack[i].windowNumber = i;
beatTrack[i].timeStamp = WindowPositionToTime(i);
}
}
return(beatTrack);
}
private Beat CheckForBeat(float[] rightChannel, float[] leftChannel)
{
float instantEnergy = AudioAnalyser.GetInstantEnergy(rightChannel, leftChannel);
float localAverageEnergy = AudioAnalyser.GetLocalAverageEnergy(instantEnergyHistory);
float variance = AudioAnalyser.GetEnergyVariance(instantEnergyHistory, localAverageEnergy);
float constant = AudioAnalyser.GetEnergyFormulaConstant(variance, sensitivity);
float[] shiftArray = new float[instantEnergyHistory.Length];
Array.Copy(instantEnergyHistory, 0, shiftArray, 1, instantEnergyHistory.Length - 1);
shiftArray[0] = instantEnergy;
Array.Copy(shiftArray, instantEnergyHistory, shiftArray.Length);
float beatEnergyTarget = constant * localAverageEnergy;
Debug.Log("Instant Energy: " + instantEnergyHistory[0] + "\nAverage Energy: " + localAverageEnergy + "\nEnergy Constant: " + constant + "\nBeat target: " + beatEnergyTarget);
if (instantEnergy > beatEnergyTarget && instantEnergy > Mathf.Epsilon)
{
return(new Beat(0, 0, instantEnergy, localAverageEnergy, beatEnergyTarget));
}
return(null);
}
void Awake()
{
_instance = this;
_as = GetComponent<AudioSource>();
}