private void Awake()
{
// Create and initialize the chorus filter.
if (UseChorus)
{
chorusFilter = gameObject.AddComponent <AudioChorusFilter>();
chorusFilter.enabled = true;
UpdateChorusFilter();
}
// Create and initialize the echo filter.
if (UseEcho)
{
echoFilter = gameObject.AddComponent <AudioEchoFilter>();
echoFilter.enabled = true;
UpdateEchoFilter();
}
// Confgure the microphone stream to use the high quality voice source
// at the application's output sample rate.
MicStream.MicInitializeCustomRate(
(int)MicStream.StreamCategory.HIGH_QUALITY_VOICE,
AudioSettings.outputSampleRate);
// Set the initial microphone gain.
MicStream.MicSetGain(InputGain);
// Start the stream.
// Do not keep the data and do not preview.
MicStream.MicStartStream(false, false);
MicStream.MicPause();
}
void Start()
{
cam = GameObject.FindWithTag("MainCamera");
lowPassFilter = cam.GetComponent <AudioLowPassFilter>();
chorusFilter = cam.GetComponent <AudioChorusFilter>();
SlomoOff();
}
//Get all audio components attached to the object
void Start()
{
aud = GetComponent <AudioSource>();
chorus = GetComponent <AudioChorusFilter>();
reverb = GetComponent <AudioReverbFilter>();
mat = GetComponentInChildren <Renderer>().material;
t = this.transform;
}
void Awake()
{
audioFilter = GetComponent <AudioChorusFilter>();
sampling_frequency = AudioSettings.outputSampleRate;
lowPassFilter = GetComponent <AudioLowPassFilter>();
Update();
}
public void SetToFilter(AudioChorusFilter filter)
{
filter.delay = delay;
filter.depth = depth;
filter.dryMix = dryMix;
filter.rate = rate;
filter.wetMix1 = wetMix1;
filter.wetMix2 = wetMix2;
filter.wetMix3 = wetMix3;
}
private void AssignValues(AudioChorusFilter component)
{
component.dryMix = dryMix;
component.wetMix1 = wetMix01;
component.wetMix2 = wetMix02;
component.wetMix3 = wetMix03;
component.delay = delay;
component.rate = rate;
component.depth = depth;
}
public override UnityEngine.Component CreateComponent(GameObject gameObject)
{
AudioChorusFilter audioChorusFilter = gameObject.GetComponent <AudioChorusFilter>();
if (audioChorusFilter == null)
{
audioChorusFilter = gameObject.AddComponent <AudioChorusFilter>();
}
return(audioChorusFilter);
}
private void Start()
{
MLHands.Start();
_gestures = new MLHandKeyPose[5];
_gestures[0] = MLHandKeyPose.Ok;
_gestures[1] = MLHandKeyPose.Finger;
_gestures[2] = MLHandKeyPose.OpenHand;
_gestures[3] = MLHandKeyPose.Fist;
_gestures[4] = MLHandKeyPose.Thumb;
MLHands.KeyPoseManager.EnableKeyPoses(_gestures, true, false);
pos = new Vector3[3];
aS = GetComponent <AudioSource>();
chorus = GetComponent <AudioChorusFilter>();
}
void Awake()
{
foreach (Sound s in sounds)
{
s.source = gameObject.AddComponent <AudioSource>();
s.source.clip = s.clip;
s.source.volume = s.volumn;
s.source.pitch = s.pitch;
}
current = Array.Find(sounds, sound => sound.name == "TNPN");
playpauseAni = gameObject.GetComponent <PlayPause>();
audioChrousFilter = gameObject.GetComponent <AudioChorusFilter>();
}
private void save_shared_settings_filter(ConfigNode node, AudioChorusFilter chorusFilter)
{
ConfigNode _filter = new ConfigNode();
_filter = new ConfigNode();
_filter.AddValue("enabled", chorusFilter.enabled);
_filter.AddValue("dry_mix", chorusFilter.dryMix);
_filter.AddValue("wet_mix_1", chorusFilter.wetMix1);
_filter.AddValue("wet_mix_2", chorusFilter.wetMix2);
_filter.AddValue("wet_mix_3", chorusFilter.wetMix3);
_filter.AddValue("delay", chorusFilter.delay);
_filter.AddValue("rate", chorusFilter.rate);
_filter.AddValue("depth", chorusFilter.depth);
node.SetNode("CHORUS", _filter, true);
}
public void Refresh()
{
// Init references
if (_instrument == null)
{
_instrument = Instrument.AllInstruments[_instrumentIndex];
}
_source = MusicManager.Instance.GetAudioSource(_instrument);
_distortion = _source.GetComponent <AudioDistortionFilter>();
_tremolo = _source.GetComponent <AudioTremoloFilter>();
_chorus = _source.GetComponent <AudioChorusFilter>();
_flanger = _source.GetComponent <AudioFlangerFilter>();
_echo = _source.GetComponent <AudioEchoFilter>();
_reverb = _source.GetComponent <AudioReverbFilter>();
}
public void SetFilters(AudioManagerCategory cat)
{
if (cat.UseLowPassFilter)
{
AudioLowPassFilter filter = EnableFilter <AudioLowPassFilter>(EAudioFilter.LowPass);
cat.AudioFilters.LowPass.SetToFilter(filter);
}
if (cat.UseHighPassFilter)
{
AudioHighPassFilter filter = EnableFilter <AudioHighPassFilter>(EAudioFilter.HighPass);
cat.AudioFilters.HighPass.SetToFilter(filter);
}
if (cat.UseChorusFilter)
{
AudioChorusFilter filter = EnableFilter <AudioChorusFilter>(EAudioFilter.Chorus);
cat.AudioFilters.Chorus.SetToFilter(filter);
}
if (cat.UseDistortionFilter)
{
AudioDistortionFilter filter = EnableFilter <AudioDistortionFilter>(EAudioFilter.Distortion);
cat.AudioFilters.Distortion.SetToFilter(filter);
}
if (cat.UseEchoFilter)
{
AudioEchoFilter filter = EnableFilter <AudioEchoFilter>(EAudioFilter.Echo);
cat.AudioFilters.Echo.SetToFilter(filter);
}
if (cat.UseReverbFilter)
{
AudioReverbFilter filter = EnableFilter <AudioReverbFilter>(EAudioFilter.Reverb);
cat.AudioFilters.Reverb.SetToFilter(filter);
}
if (cat.UseFadeIn)
{
m_FadeInData = cat.AudioFilters.FadeIn;
}
if (cat.UseFadeOut)
{
m_FadeOutData = cat.AudioFilters.FadeOut;
}
}
public static AudioChorusFilter Deserialize(this SAudioChorusFilter _audioChorusFilter, ref GameObject _providedObject)
{
AudioChorusFilter returnVal = _providedObject.GetComponent <AudioChorusFilter>();
returnVal.enabled = _audioChorusFilter.enabled;
returnVal.dryMix = _audioChorusFilter.dryMix;
returnVal.wetMix1 = _audioChorusFilter.wetMix1;
returnVal.wetMix2 = _audioChorusFilter.wetMix2;
returnVal.wetMix3 = _audioChorusFilter.wetMix3;
returnVal.delay = _audioChorusFilter.delay;
returnVal.rate = _audioChorusFilter.rate;
returnVal.depth = _audioChorusFilter.depth;
return(returnVal);
}
static int _CreateAudioChorusFilter(IntPtr L)
{
int count = LuaDLL.lua_gettop(L);
if (count == 0)
{
AudioChorusFilter obj = new AudioChorusFilter();
LuaScriptMgr.Push(L, obj);
return(1);
}
else
{
LuaDLL.luaL_error(L, "invalid arguments to method: AudioChorusFilter.New");
}
return(0);
}
public static SAudioChorusFilter Serialize(this AudioChorusFilter _audioChorusFilter)
{
SAudioChorusFilter returnVal = new SAudioChorusFilter
{
existsOnObject = (_audioChorusFilter == null) ? false : true,
enabled = _audioChorusFilter.enabled,
dryMix = _audioChorusFilter.dryMix,
wetMix1 = _audioChorusFilter.wetMix1,
wetMix2 = _audioChorusFilter.wetMix2,
wetMix3 = _audioChorusFilter.wetMix3,
delay = _audioChorusFilter.delay,
rate = _audioChorusFilter.rate,
depth = _audioChorusFilter.depth
};
return(returnVal);
}
void Start()
{
playAudio = true;
AS = GetComponent <AudioSource> ();
ACF = GetComponent <AudioChorusFilter> ();
Freq = UnityEngine.Random.Range(1, 10);
ACF.rate = 7.4f;
ACF.depth = .7f;
ACF.delay = 70;
ACF.wetMix1 = .5f;
ACF.wetMix2 = .5f;
ACF.enabled = this.GetType() != typeof(StorylineProgressor);
AS.spatialBlend = 1.0f;
AS.Play();
}
private void load_shared_settings_filter(ConfigNode node, AudioChorusFilter chorusFilter)
{
if (node.HasValue("enabled"))
{
chorusFilter.enabled = Boolean.Parse(node.GetValue("enabled"));
}
if (node.HasValue("dry_mix"))
{
chorusFilter.dryMix = Single.Parse(node.GetValue("dry_mix"));
}
if (node.HasValue("wet_mix_1"))
{
chorusFilter.wetMix1 = Single.Parse(node.GetValue("wet_mix_1"));
}
if (node.HasValue("wet_mix_2"))
{
chorusFilter.wetMix2 = Single.Parse(node.GetValue("wet_mix_2"));
}
if (node.HasValue("wet_mix_3"))
{
chorusFilter.wetMix3 = Single.Parse(node.GetValue("wet_mix_3"));
}
}
static int get_wetMix1(IntPtr L)
{
object o = LuaScriptMgr.GetLuaObject(L, 1);
if (o == null)
{
LuaTypes types = LuaDLL.lua_type(L, 1);
if (types == LuaTypes.LUA_TTABLE)
{
LuaDLL.luaL_error(L, "unknown member name wetMix1");
}
else
{
LuaDLL.luaL_error(L, "attempt to index wetMix1 on a nil value");
}
}
AudioChorusFilter obj = (AudioChorusFilter)o;
LuaScriptMgr.Push(L, obj.wetMix1);
return(1);
}
static int set_depth(IntPtr L)
{
object o = LuaScriptMgr.GetLuaObject(L, 1);
if (o == null)
{
LuaTypes types = LuaDLL.lua_type(L, 1);
if (types == LuaTypes.LUA_TTABLE)
{
LuaDLL.luaL_error(L, "unknown member name depth");
}
else
{
LuaDLL.luaL_error(L, "attempt to index depth on a nil value");
}
}
AudioChorusFilter obj = (AudioChorusFilter)o;
obj.depth = (float)LuaScriptMgr.GetNumber(L, 3);
return(0);
}
public override void UpdateParameters()
{
if (_dryMix.HasReachedTarget() && _wetMix1.HasReachedTarget() && _wetMix2.HasReachedTarget() && _wetMix3.HasReachedTarget() && _delay.HasReachedTarget() && _rate.HasReachedTarget() && _depth.HasReachedTarget() && _feedback.HasReachedTarget())
{
return;
}
FabricTimer.Get();
for (int i = 0; i < _dspInstances.Count; i++)
{
AudioChorusFilter audioChorusFilter = _dspInstances[i] as AudioChorusFilter;
if ((bool)audioChorusFilter)
{
audioChorusFilter.dryMix = _dryMix.GetValue();
audioChorusFilter.wetMix1 = _wetMix1.GetValue();
audioChorusFilter.wetMix2 = _wetMix2.GetValue();
audioChorusFilter.wetMix3 = _wetMix3.GetValue();
audioChorusFilter.delay = _delay.GetValue();
audioChorusFilter.rate = _rate.GetValue();
audioChorusFilter.depth = _depth.GetValue();
}
}
base.UpdateParameters();
}
public void SetExpression(Pig.Expressions exp)
{
if (this.m_currentExpression != exp)
{
switch (exp)
{
case Pig.Expressions.Normal:
this.m_faceAnimation.Play("Normal");
break;
case Pig.Expressions.Laugh:
this.m_faceAnimation.Play("Laugh");
break;
case Pig.Expressions.Grin:
this.m_faceAnimation.Play("Grin");
break;
case Pig.Expressions.Fear:
this.m_faceAnimation.Play("Fear_1");
break;
case Pig.Expressions.Fear2:
this.m_faceAnimation.Play("Fear_2");
break;
case Pig.Expressions.Hit:
this.m_faceAnimation.Play("Hit");
break;
case Pig.Expressions.Blink:
this.m_faceAnimation.Play("Blink");
break;
case Pig.Expressions.FearfulGrin:
this.m_faceAnimation.Play("FearfulGrin");
break;
}
if (Singleton <GameManager> .Instance.IsInGame() && WPFMonoBehaviour.levelManager != null && WPFMonoBehaviour.levelManager.gameState != LevelManager.GameState.Building)
{
AudioSource[] sound = this.m_expressions[(int)exp].sound;
if (sound != null && sound.Length > 0)
{
for (int i = 0; i < sound.Length; i++)
{
sound[i].pitch = this.m_pitch;
}
if (this.m_currentSound)
{
this.m_currentSound.Stop();
}
this.m_currentSound = ((!this.m_isSilent) ? Singleton <AudioManager> .Instance.SpawnOneShotEffect(sound, base.transform) : null);
if (this.m_chorusFilter)
{
AudioChorusFilter audioChorusFilter = this.m_currentSound.gameObject.AddComponent <AudioChorusFilter>();
audioChorusFilter.dryMix = this.m_chorusFilter.dryMix;
audioChorusFilter.wetMix1 = this.m_chorusFilter.wetMix1;
audioChorusFilter.wetMix2 = this.m_chorusFilter.wetMix2;
audioChorusFilter.wetMix3 = this.m_chorusFilter.wetMix3;
audioChorusFilter.delay = this.m_chorusFilter.delay;
audioChorusFilter.rate = this.m_chorusFilter.rate;
audioChorusFilter.depth = this.m_chorusFilter.depth;
}
if (this.m_distortionFilter)
{
AudioDistortionFilter audioDistortionFilter = this.m_currentSound.gameObject.AddComponent <AudioDistortionFilter>();
audioDistortionFilter.distortionLevel = this.m_distortionFilter.distortionLevel;
}
if (this.m_echoFilter)
{
AudioEchoFilter audioEchoFilter = this.m_currentSound.gameObject.AddComponent <AudioEchoFilter>();
audioEchoFilter.delay = this.m_echoFilter.delay;
audioEchoFilter.decayRatio = this.m_echoFilter.decayRatio;
audioEchoFilter.wetMix = this.m_echoFilter.wetMix;
audioEchoFilter.dryMix = this.m_echoFilter.dryMix;
}
if (this.m_hpFilter)
{
AudioHighPassFilter audioHighPassFilter = this.m_currentSound.gameObject.AddComponent <AudioHighPassFilter>();
audioHighPassFilter.cutoffFrequency = this.m_hpFilter.cutoffFrequency;
audioHighPassFilter.highpassResonanceQ = this.m_hpFilter.highpassResonanceQ;
}
if (this.m_lpFilter)
{
AudioLowPassFilter audioLowPassFilter = this.m_currentSound.gameObject.AddComponent <AudioLowPassFilter>();
audioLowPassFilter.cutoffFrequency = this.m_lpFilter.cutoffFrequency;
audioLowPassFilter.lowpassResonanceQ = this.m_lpFilter.lowpassResonanceQ;
}
if (this.m_reverbFilter)
{
AudioReverbFilter audioReverbFilter = this.m_currentSound.gameObject.AddComponent <AudioReverbFilter>();
if (this.m_reverbFilter.reverbPreset == AudioReverbPreset.User)
{
audioReverbFilter.dryLevel = this.m_reverbFilter.dryLevel;
audioReverbFilter.room = this.m_reverbFilter.room;
audioReverbFilter.roomHF = this.m_reverbFilter.roomHF;
audioReverbFilter.roomLF = this.m_reverbFilter.roomLF;
audioReverbFilter.decayTime = this.m_reverbFilter.decayTime;
audioReverbFilter.decayHFRatio = this.m_reverbFilter.decayHFRatio;
audioReverbFilter.reflectionsLevel = this.m_reverbFilter.reflectionsLevel;
audioReverbFilter.reflectionsDelay = this.m_reverbFilter.reflectionsDelay;
audioReverbFilter.hfReference = this.m_reverbFilter.hfReference;
audioReverbFilter.lfReference = this.m_reverbFilter.lfReference;
audioReverbFilter.diffusion = this.m_reverbFilter.diffusion;
audioReverbFilter.density = this.m_reverbFilter.density;
}
else
{
audioReverbFilter.reverbPreset = this.m_reverbFilter.reverbPreset;
}
}
}
}
this.m_expressionSetTime = Time.time;
this.m_currentExpression = exp;
}
}
void OnTriggerEnter(Collider collider)
{
Debug.Log("trigger enter");
AudioSource source = collider.gameObject.GetComponent <AudioSource>();
if (source)
{
if (fx.Contains("distortion"))
{
//Apply Filter
AudioDistortionFilter f = collider.gameObject.GetComponent <AudioDistortionFilter> ();
if (f == null)
{
f = collider.gameObject.AddComponent <AudioDistortionFilter> ();
}
f.enabled = true;
f.distortionLevel = 0.8f;
filters.Add(f);
}
if (fx.Contains("echo"))
{
//Apply Filter
AudioEchoFilter f = collider.gameObject.GetComponent <AudioEchoFilter> ();
if (f == null)
{
f = collider.gameObject.AddComponent <AudioEchoFilter> ();
}
f.enabled = true;
f.delay = 100f;
f.decayRatio = 0.9f;
filters.Add(f);
}
if (fx.Contains("chorus"))
{
//Apply Filter
AudioChorusFilter f = collider.gameObject.GetComponent <AudioChorusFilter> ();
if (f == null)
{
f = collider.gameObject.AddComponent <AudioChorusFilter> ();
}
//f.depth = 0.99f;
f.enabled = true;
filters.Add(f);
}
if (fx.Contains("highpass"))
{
//Apply Filter
AudioHighPassFilter f = collider.gameObject.GetComponent <AudioHighPassFilter> ();
if (f == null)
{
f = collider.gameObject.AddComponent <AudioHighPassFilter> ();
}
f.enabled = true;
filters.Add(f);
}
if (fx.Contains("lowpass"))
{
//Apply Filter
AudioLowPassFilter f = collider.gameObject.GetComponent <AudioLowPassFilter> ();
if (f == null)
{
f = collider.gameObject.AddComponent <AudioLowPassFilter> ();
}
f.lowpassResonanceQ = 2;
f.cutoffFrequency = 1000;
f.enabled = true;
filters.Add(f);
}
}
}
public static Tween TweenRate(this AudioChorusFilter filter, float to, float duration) =>
Tweening.To(getter: () => filter.rate,
setter: rate => filter.rate = rate,
to, duration).SetTarget(filter);
public override void OnEnable() => Component = gameObject.GetComponent <AudioChorusFilter>();
public static Tween TweenDryMix(this AudioChorusFilter filter, float to, float duration) =>
Tweening.To(getter: () => filter.dryMix,
setter: dryMix => filter.dryMix = dryMix,
to, duration).SetTarget(filter);
public static Tween TweenWetMix3(this AudioChorusFilter filter, float to, float duration) =>
Tweening.To(getter: () => filter.wetMix3,
setter: wetMix3 => filter.wetMix3 = wetMix3,
to, duration).SetTarget(filter);
public void ApplyEffects()
{
if (audioFile.chorusFilter.enabled)
{
if (!chorusFilter)
{
chorusFilter = gameObject.AddComponent <AudioChorusFilter>();
}
chorusFilter.enabled = true;
chorusFilter.dryMix = audioFile.chorusFilter.dryMix;
chorusFilter.wetMix1 = audioFile.chorusFilter.wetMix1;
chorusFilter.wetMix2 = audioFile.chorusFilter.wetMix2;
chorusFilter.wetMix3 = audioFile.chorusFilter.wetMix3;
chorusFilter.delay = audioFile.chorusFilter.delay;
chorusFilter.rate = audioFile.chorusFilter.rate;
chorusFilter.depth = audioFile.chorusFilter.depth;
}
else if (!audioFile.chorusFilter.enabled && chorusFilter)
{
chorusFilter.enabled = false;
}
if (audioFile.distortionFilter.enabled)
{
if (!distortionFilter)
{
distortionFilter = gameObject.AddComponent <AudioDistortionFilter>();
}
distortionFilter.enabled = true;
distortionFilter.distortionLevel = audioFile.distortionFilter.distortionLevel;
}
else if (!audioFile.distortionFilter.enabled && distortionFilter)
{
distortionFilter.enabled = false;
}
if (audioFile.echoFilter.enabled)
{
if (!echoFilter)
{
echoFilter = gameObject.AddComponent <AudioEchoFilter>();
}
echoFilter.enabled = true;
echoFilter.delay = audioFile.echoFilter.delay;
echoFilter.decayRatio = audioFile.echoFilter.decayRatio;
echoFilter.wetMix = audioFile.echoFilter.wetMix;
echoFilter.dryMix = audioFile.echoFilter.dryMix;
}
else if (!audioFile.echoFilter.enabled && echoFilter)
{
echoFilter.enabled = false;
}
if (audioFile.highPassFilter.enabled)
{
if (!highPassFilter)
{
highPassFilter = gameObject.AddComponent <AudioHighPassFilter>();
}
highPassFilter.enabled = true;
highPassFilter.cutoffFrequency = audioFile.highPassFilter.cutoffFrequency;
highPassFilter.highpassResonanceQ = audioFile.highPassFilter.highpassResonanceQ;
}
else if (!audioFile.highPassFilter.enabled && highPassFilter)
{
highPassFilter.enabled = false;
}
if (audioFile.lowPassFilter.enabled)
{
if (!lowPassFilter)
{
lowPassFilter = gameObject.AddComponent <AudioLowPassFilter>();
}
lowPassFilter.enabled = true;
lowPassFilter.cutoffFrequency = audioFile.lowPassFilter.cutoffFrequency;
lowPassFilter.lowpassResonanceQ = audioFile.lowPassFilter.lowpassResonanceQ;
}
else if (!audioFile.lowPassFilter.enabled && lowPassFilter)
{
lowPassFilter.enabled = false;
}
if (audioFile.reverbFilter.enabled)
{
if (!reverbFilter)
{
reverbFilter = gameObject.AddComponent <AudioReverbFilter>();
}
reverbFilter.enabled = true;
reverbFilter.reverbPreset = audioFile.reverbFilter.reverbPreset;
reverbFilter.dryLevel = audioFile.reverbFilter.dryLevel;
reverbFilter.room = audioFile.reverbFilter.room;
reverbFilter.roomHF = audioFile.reverbFilter.roomHF;
reverbFilter.roomLF = audioFile.reverbFilter.roomLF;
reverbFilter.decayTime = audioFile.reverbFilter.decayTime;
reverbFilter.decayHFRatio = audioFile.reverbFilter.decayHFRatio;
reverbFilter.reflectionsLevel = audioFile.reverbFilter.reflectionsLevel;
reverbFilter.reflectionsDelay = audioFile.reverbFilter.reflectionsDelay;
reverbFilter.reverbLevel = audioFile.reverbFilter.reverbLevel;
reverbFilter.reverbDelay = audioFile.reverbFilter.reverbDelay;
reverbFilter.hfReference = audioFile.reverbFilter.hFReference;
reverbFilter.lfReference = audioFile.reverbFilter.lFReference;
reverbFilter.diffusion = audioFile.reverbFilter.diffusion;
reverbFilter.density = audioFile.reverbFilter.density;
}
else if (!audioFile.reverbFilter.enabled && reverbFilter)
{
reverbFilter.enabled = false;
}
}
public static Tween TweenDelay(this AudioChorusFilter filter, float to, float duration) =>
Tweening.To(getter: () => filter.delay,
setter: delay => filter.delay = delay,
to, duration).SetTarget(filter);
/// <summary>
/// Coroutine to load instruments.
/// </summary>
IEnumerator LoadInstruments()
{
List <string> loadMessages = new List <string>()
{
"Renting instruments...",
"Grabbing instruments...",
"Unpacking instruments..."
};
// Update loading message
LoadingScreen.Instance.SetLoadingMessage(loadMessages.Random());
// Mark start time
float startTime = Time.realtimeSinceStartup;
int numLoaded = 0;
// Init audio source dict
_instrumentAudioSources = new Dictionary <Instrument, AudioSource>();
// Foreach instrument
for (int i = 0; i < Instrument.AllInstruments.Count; i++)
{
// Load instrument data
Instrument.AllInstruments[i].Load();
// Create instrument AudioSource GameObject
GameObject obj = new GameObject(Instrument.AllInstruments[i].Name);
AudioSource source = obj.AddComponent <AudioSource>();
// Group instrument under MusicManager
obj.transform.parent = transform.parent;
// Connect AudioSource to mixer
source.outputAudioMixerGroup = _mixer.FindMatchingGroups(obj.name)[0];
// Connect instrument to AudioSource
_instrumentAudioSources.Add(Instrument.AllInstruments[i], source);
// Add distortion filter
AudioDistortionFilter distortion = obj.AddComponent <AudioDistortionFilter>();
distortion.enabled = false;
// Add tremolo filter
AudioTremoloFilter tremolo = obj.AddComponent <AudioTremoloFilter>();
tremolo.enabled = false;
// Add chorus filter
AudioChorusFilter chorus = obj.AddComponent <AudioChorusFilter>();
chorus.enabled = false;
// Add flanger filter
AudioFlangerFilter flanger = obj.AddComponent <AudioFlangerFilter>();
flanger.enabled = false;
// Add echo filter
AudioEchoFilter echo = obj.AddComponent <AudioEchoFilter>();
echo.enabled = false;
// Add reverb filter based on MusicManager's reverb filter
AudioReverbFilter reverb = obj.AddComponent <AudioReverbFilter>();
AudioReverbFilter masterReverb = GetComponent <AudioReverbFilter>();
reverb.dryLevel = masterReverb.dryLevel;
reverb.room = masterReverb.room;
reverb.roomHF = masterReverb.roomHF;
reverb.roomLF = masterReverb.roomLF;
reverb.decayTime = masterReverb.decayTime;
reverb.decayHFRatio = masterReverb.decayHFRatio;
reverb.reflectionsLevel = masterReverb.reflectionsLevel;
reverb.reflectionsDelay = masterReverb.reflectionsDelay;
reverb.reverbLevel = masterReverb.reverbLevel;
reverb.hfReference = masterReverb.hfReference;
reverb.lfReference = masterReverb.lfReference;
reverb.diffusion = masterReverb.diffusion;
reverb.density = masterReverb.density;
reverb.enabled = false;
numLoaded++;
// If over time
if (Time.realtimeSinceStartup - startTime > GameManager.LoadingTargetDeltaTime)
{
yield return(null);
startTime = Time.realtimeSinceStartup;
GameManager.Instance.ReportLoaded(numLoaded);
numLoaded = 0;
}
}
// When done, start building scales
if (_instrumentAudioSources.Count == Instrument.AllInstruments.Count)
{
KeyManager.Instance.DoBuildScales();
}
yield return(null);
}
