/// <summary> To be called every time a Modifier changes so the properties can be recalculated </summary>
public void UpdateModifiers()
{
m_hasBeenUpdated = true;
List <ClipData> clips = new List <ClipData>(m_clipData);
for (int m = 0; m < m_modifiers.Length; ++m)
{
if (m_modifiers[m] == null)
{
continue;
}
m_modifiers[m].UpdateFadeValue();
if (m_modifiers[m].m_modRandomizeVolume)
{
if (m_modifiers[m].FadeValue > 0.5f)
{
_randomizeVolumeModIsSet = true;
_randomizeVolumeMod = m_modifiers[m].m_randomizeVolume;
}
}
if (m_modifiers[m].m_modRandomizePlaybackSpeed)
{
if (m_modifiers[m].FadeValue > 0.5f)
{
_randomizePlaybackSpeedModIsSet = true;
_randomizePlaybackSpeedMod = m_modifiers[m].m_randomizePlaybackSpeed;
}
}
if (m_modifiers[m].m_modClips)
{
if (m_modifiers[m].FadeValue >= 0.5f) //can only change the array fully or not at all ... so do it at half way up
{
if (m_modifiers[m].m_modClipsType == ClipModType.Add)
{
clips.AddRange(m_modifiers[m].m_clipData);
}
else if (m_modifiers[m].m_modClipsType == ClipModType.Remove)
{
foreach (ClipData clip in m_modifiers[m].m_clipData)
{
if (clip.m_clip != null)
{
clips.RemoveAll(delegate(ClipData c) {
return(c.m_clip == clip.m_clip);
});
}
}
}
else //Replace
{
clips = new List <ClipData>(m_modifiers[m].m_clipData);
}
}
}
}
float newLength = 0f;
clips.RemoveAll(c => c.m_clip == null);
foreach (ClipData clip in clips)
{
newLength += (AmbienceManager.GetAudioData(clip.m_clip).Length - m_crossFade) * PlaybackSpeed;
//newLength += (clip.length - m_crossFade) * PlaybackSpeed;
}
if (newLength != TotalLength)
{
TotalLength = newLength;
if (!string.IsNullOrEmpty(m_syncGroup))
{
SyncGroup.Get(m_syncGroup).UpdateLength();
}
}
lock (ClipsLockHandle)
Clips = clips.ToArray();
}
/// <summary>
/// Constructor using a single AudioClip as a source with optional AmbienceData source it came from
/// </summary>
/// <param name="clip">AudioClip to base AudioTrack on</param>
/// <param name="source">AmbienceData with settings for audio clip</param>
/// <param name="startingTime">Time in seconds from start of track to begin playback</param>
public AudioTrack(AudioClip clip, Sequence source, bool playOnce = false)
{
IsPlayOnce = playOnce;
CurFade = playOnce ? 1f : 0f;
trackTime = 0.0;
m_sequence = source;
if (clip == null)
{
Debug.LogError("Cannot create AudioTrack data for null source clip.");
RawClipData = new RawAudioData[0];
DirectClipData = new AudioClip[0];
return;
}
if (clip.loadType != AudioClipLoadType.DecompressOnLoad)
{
m_outputNeedsIntialized = true;
m_isOutputDirect = true; //Cannot read streaming or compressed clip data
}
m_name = clip.name;
DirectClipData = new AudioClip[1] {
clip
};
RawClipData = new RawAudioData[1] {
AmbienceManager.GetAudioData(clip)
};
currentClipIdx = 0;
if (m_sequence != null)
{
curPlaybackSpeed = m_sequence.PlaybackSpeed;
curVolume = m_sequence.Volume;
for (int i = 0; i < m_sequence.Clips.Length; ++i)
{
if (m_sequence.Clips[i].m_clip == clip)
{
curVolume *= m_sequence.Clips[i].m_volume;
break;
}
}
if (MySyncGroup == null && m_sequence.TrackDelayTime > 0)
{
//Debug.Log("Starting AudioTrack with delay of " + source.TrackDelayTime);
isDelaying = true;
}
if (m_sequence.RandomizeVolume)
{
curVolumeMod = Helpers.GetRandom(m_sequence.MinMaxVolume);
}
else
{
curVolumeMod = 1f;
}
if (!isSynced && m_sequence.RandomizePlaybackSpeed)
{
curPlaybackSpeedMod = Helpers.GetRandom(m_sequence.MinMaxPlaybackSpeed);
}
else
{
curPlaybackSpeedMod = 1f;
}
}
else
{
curPlaybackSpeed = 1f;
curPlaybackSpeedMod = 1f;
curVolume = 1f;
curVolumeMod = 1f;
}
}
/// <summary> Updates clip list if it changed. (Call from within Update() function) </summary>
public void UpdateClips()
{
if (m_sequence == null)
{
return;
}
List <AudioClip> allClips = new List <AudioClip>(m_sequence.Clips.Length);
foreach (Sequence.ClipData clip in m_sequence.Clips)
{
if (clip.m_clip != null)
{
allClips.Add(clip.m_clip);
}
}
if (allClips.Count == 0)
{
Debug.LogWarning("No audio clips found in Sequence '" + m_name + "'!");
}
bool changed = false;
if (allClips.Count != DirectClipData.Length)
{
//length changed so it definitly changed.
changed = true;
}
else
{
for (int c = 0; c < DirectClipData.Length; ++c)
{
if (DirectClipData[c] != allClips[c])
{
changed = true;
break;
}
}
}
if (changed) //update current raw clip list then select our current track if it still exists.
{
RawAudioData[] newRawClipData = new RawAudioData[allClips.Count];
AudioClip curClip = m_isOutputDirect ? DirectClipData[currentClipIdx] : RawClipData[currentClipIdx].BaseClip;
int newClipIdx = -1;
for (int c = 0; c < allClips.Count; ++c)
{
if (allClips[c] == curClip)
{
newClipIdx = c;
}
newRawClipData[c] = AmbienceManager.GetAudioData(allClips[c]);
}
NextClipIdx = -1;
if (newClipIdx < 0)
{
PlayToFade = RawClipData[currentClipIdx];
RawClipData = newRawClipData;
newClipIdx = NextClipIdx;
DirectFadeOut = true;
}
else
{
RawClipData = newRawClipData;
}
currentClipIdx = newClipIdx;
DirectClipData = allClips.ToArray();
if (m_sequence.RandomizeVolume)
{
curVolumeMod = Helpers.GetRandom(m_sequence.MinMaxVolume);
}
else
{
curVolumeMod = 1f;
}
if (!isSynced && m_sequence.RandomizePlaybackSpeed)
{
curPlaybackSpeedMod = Helpers.GetRandom(m_sequence.MinMaxPlaybackSpeed);
}
else
{
curPlaybackSpeedMod = 1f;
}
if (MySyncGroup != null)
{
MySyncGroup.UpdateLength();
}
}
}
/// <summary>
/// Constructor using AmbienceData as the source
/// </summary>
/// <param name="source">AmbienceData to base this track on</param>
/// <param name="startingTime">Time in seconds from start of track to begin playback</param>
public AudioTrack(Sequence source, bool playOnce = false)
{
IsPlayOnce = playOnce;
CurFade = playOnce ? 1f : 0f;
trackTime = 0.0;
m_sequence = source;
if (m_sequence == null)
{
Debug.LogError("Cannot create AudioTrack data for null source.");
RawClipData = new RawAudioData[0];
DirectClipData = new AudioClip[0];
m_name = "NULL";
return;
}
curPlaybackSpeed = m_sequence.PlaybackSpeed;
curVolume = m_sequence.Volume;
m_name = m_sequence.name;
//check for nulls and skip them
List <AudioClip> allClips = new List <AudioClip>(m_sequence.Clips.Length);
foreach (Sequence.ClipData clip in m_sequence.Clips)
{
if (clip.m_clip != null)
{
if (clip.m_clip.loadType != AudioClipLoadType.DecompressOnLoad)
{
m_outputNeedsIntialized = true;
m_isOutputDirect = true; //Cannot read streaming or compressed clip data
}
allClips.Add(clip.m_clip);
}
}
if (allClips.Count == 0)
{
Debug.LogWarning("No audio clips found in Sequence '" + m_name + "'!");
}
//get the actual audio data for the clips
DirectClipData = allClips.ToArray();
RawClipData = new RawAudioData[allClips.Count];
for (int c = 0; c < RawClipData.Length; ++c)
{
RawClipData[c] = AmbienceManager.GetAudioData(allClips[c]);
}
currentClipIdx = NextClipIdx;
if (m_sequence.m_clipData.Length > currentClipIdx)
{
curVolume *= m_sequence.m_clipData[currentClipIdx].m_volume;
}
if (m_sequence.RandomizeVolume)
{
curVolumeMod = Helpers.GetRandom(m_sequence.MinMaxVolume);
}
else
{
curVolumeMod = 1f;
}
if (!isSynced && m_sequence.RandomizePlaybackSpeed)
{
curPlaybackSpeedMod = Helpers.GetRandom(m_sequence.MinMaxPlaybackSpeed);
}
else
{
curPlaybackSpeedMod = 1f;
}
if (MySyncGroup == null && m_sequence.TrackDelayTime > 0)
{
//Debug.Log("Starting AudioTrack with delay of " + source.TrackDelayTime);
isDelaying = true;
}
}
