// Start is called before the first frame update
void Start()
{
PlayMusic();
pitchBendGroup = Resources.Load <AudioMixerGroup>("Pitch Bender");
collectibleSound.outputAudioMixerGroup = pitchBendGroup;
}
public static AudioSource PlayClipAt(string name, Vector3 pos, AudioMixerGroup mixerGroup, float delay = 0f)
{
return(PlayClipAt(instance[name], pos, mixerGroup, delay));
}
public void ClearSFXMixing()
{
currentSfxMixer = null;
}
/// <summary>
/// 设置声音代理辅助器所在的混音组。
/// </summary>
/// <param name="audioMixerGroup">混音组。</param>
protected internal virtual void SetAudioMixerGroup(AudioMixerGroup audioMixerGroup)
{
m_AudioMixerGroup = audioMixerGroup;
}
public void Play(AudioClip i_AudioClip, AudioMixerGroup i_Group, float i_Volume, float i_Pitch)
{
Play(i_AudioClip, i_Group, i_Volume, i_Pitch, Vector3.zero, Quaternion.identity);
}
public SoundHandler Play(AudioClip clip, float volume = 1f, bool loop = false, float pitch = 1f,
bool ignoreListenerPause = false, float delay = 0f, AudioMixerGroup mixerGroup = null)
{
if (clip == null)
{
return(null);
}
if (_handlers.Count >= MaxSounds)
{
Debug.Log("[SoundManager] Too many sounds");
return(null);
}
var go = new GameObject(string.Format("Sound: {0}", clip.name));
go.transform.SetParent(transform);
var source = go.AddComponent <AudioSource>();
source.clip = clip;
source.priority = 128;
source.playOnAwake = false;
source.volume = volume;
source.loop = loop;
source.pitch = pitch;
source.outputAudioMixerGroup = mixerGroup;
source.ignoreListenerPause = ignoreListenerPause;
var sound = new SoundHandler(source);
_handlers.Add(sound);
if (delay > 0)
{
source.PlayDelayed(delay);
}
else
{
source.Play();
}
return(sound);
}
public void Toggle(AudioMixerGroup group)
{
AudioManager.Manager.Toggle(group);
}
public IEnumerator InitThings()
{
MelonLogger.Log("Waiting for init");
while (ReferenceEquals(NetworkManager.field_Internal_Static_NetworkManager_0, null))
{
yield return(null);
}
while (ReferenceEquals(VRCAudioManager.field_Private_Static_VRCAudioManager_0, null))
{
yield return(null);
}
while (ReferenceEquals(VRCUiManager.prop_VRCUiManager_0, null))
{
yield return(null);
}
var audioManager = VRCAudioManager.field_Private_Static_VRCAudioManager_0;
myUIGroup = new[]
{
audioManager.field_Public_AudioMixerGroup_0, audioManager.field_Public_AudioMixerGroup_1,
audioManager.field_Public_AudioMixerGroup_2
}.Single(it => it.name == "UI");
MelonLogger.Log("Start init");
NetworkManagerHooks.Initialize();
using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("JoinNotifier.joinnotifier.assetbundle"))
using (var tempStream = new MemoryStream((int)stream.Length))
{
stream.CopyTo(tempStream);
myAssetBundle = AssetBundle.LoadFromMemory_Internal(tempStream.ToArray(), 0);
myAssetBundle.hideFlags |= HideFlags.DontUnloadUnusedAsset;
}
myJoinSprite = myAssetBundle.LoadAsset_Internal("Assets/JoinNotifier/JoinIcon.png", Il2CppType.Of <Sprite>()).Cast <Sprite>();
myJoinSprite.hideFlags |= HideFlags.DontUnloadUnusedAsset;
if (File.Exists(CustomJoinSoundFileName))
{
MelonLogger.Msg("Loading custom join sound");
var uwr = UnityWebRequest.Get($"file://{Path.Combine(Environment.CurrentDirectory, CustomJoinSoundFileName)}");
var asyncOp = uwr.SendWebRequest();
while (uwr.isDone)
{
yield return(null);
}
myJoinClip = WebRequestWWW.InternalCreateAudioClipUsingDH(uwr.downloadHandler, uwr.url, false, false, AudioType.UNKNOWN);
}
if (myJoinClip == null)
{
myJoinClip = myAssetBundle.LoadAsset_Internal("Assets/JoinNotifier/Chime.ogg", Il2CppType.Of <AudioClip>()).Cast <AudioClip>();
}
myJoinClip.hideFlags |= HideFlags.DontUnloadUnusedAsset;
if (File.Exists(CustomLeaveSoundFileName))
{
MelonLogger.Msg("Loading custom leave sound");
var uwr = UnityWebRequest.Get($"file://{Path.Combine(Environment.CurrentDirectory, CustomLeaveSoundFileName)}");
var asyncOp = uwr.SendWebRequest();
while (uwr.isDone)
{
yield return(null);
}
myLeaveClip = WebRequestWWW.InternalCreateAudioClipUsingDH(uwr.downloadHandler, uwr.url, false, false, AudioType.UNKNOWN);
}
if (myLeaveClip == null)
{
myLeaveClip = myAssetBundle.LoadAsset_Internal("Assets/JoinNotifier/DoorClose.ogg", Il2CppType.Of <AudioClip>()).Cast <AudioClip>();
}
myLeaveClip.hideFlags |= HideFlags.DontUnloadUnusedAsset;
CreateGameObjects();
NetworkManagerHooks.OnJoin += OnPlayerJoined;
NetworkManagerHooks.OnLeave += OnPlayerLeft;
}
/// <summary>
/// Plays a sound, signature with all options
/// </summary>
/// <param name="audioClip"></param>
/// <param name="mmSoundManagerTrack"></param>
/// <param name="location"></param>
/// <param name="loop"></param>
/// <param name="volume"></param>
/// <param name="ID"></param>
/// <param name="fade"></param>
/// <param name="fadeInitialVolume"></param>
/// <param name="fadeDuration"></param>
/// <param name="fadeTween"></param>
/// <param name="persistent"></param>
/// <param name="recycleAudioSource"></param>
/// <param name="audioGroup"></param>
/// <param name="pitch"></param>
/// <param name="panStereo"></param>
/// <param name="spatialBlend"></param>
/// <param name="soloSingleTrack"></param>
/// <param name="soloAllTracks"></param>
/// <param name="autoUnSoloOnEnd"></param>
/// <param name="bypassEffects"></param>
/// <param name="bypassListenerEffects"></param>
/// <param name="bypassReverbZones"></param>
/// <param name="priority"></param>
/// <param name="reverbZoneMix"></param>
/// <param name="dopplerLevel"></param>
/// <param name="spread"></param>
/// <param name="rolloffMode"></param>
/// <param name="minDistance"></param>
/// <param name="maxDistance"></param>
/// <returns></returns>
public virtual AudioSource PlaySound(AudioClip audioClip, MMSoundManagerTracks mmSoundManagerTrack, Vector3 location,
bool loop = false, float volume = 1.0f, int ID = 0,
bool fade = false, float fadeInitialVolume = 0f, float fadeDuration = 1f, MMTweenType fadeTween = null,
bool persistent = false,
AudioSource recycleAudioSource = null, AudioMixerGroup audioGroup = null,
float pitch = 1f, float panStereo = 0f, float spatialBlend = 0.0f,
bool soloSingleTrack = false, bool soloAllTracks = false, bool autoUnSoloOnEnd = false,
bool bypassEffects = false, bool bypassListenerEffects = false, bool bypassReverbZones = false, int priority = 128, float reverbZoneMix = 1f,
float dopplerLevel = 1f, int spread = 0, AudioRolloffMode rolloffMode = AudioRolloffMode.Logarithmic, float minDistance = 1f, float maxDistance = 500f,
bool doNotAutoRecycleIfNotDonePlaying = false, float playbackTime = 0f
)
{
if (!audioClip)
{
return(null);
}
// audio source setup ---------------------------------------------------------------------------------
// we reuse an audiosource if one is passed in parameters
AudioSource audioSource = recycleAudioSource;
if (audioSource == null)
{
// we pick an idle audio source from the pool if possible
audioSource = _pool.GetAvailableAudioSource(PoolCanExpand, this.transform);
if ((audioSource != null) && (!loop))
{
recycleAudioSource = audioSource;
// we destroy the host after the clip has played (if it not tag for reusability.
StartCoroutine(_pool.AutoDisableAudioSource(audioClip.length / Mathf.Abs(pitch), audioSource, audioClip, doNotAutoRecycleIfNotDonePlaying));
}
}
// we create an audio source if needed
if (audioSource == null)
{
_tempAudioSourceGameObject = new GameObject("MMAudio_" + audioClip.name);
SceneManager.MoveGameObjectToScene(_tempAudioSourceGameObject, this.gameObject.scene);
audioSource = _tempAudioSourceGameObject.AddComponent <AudioSource>();
}
// audio source settings ---------------------------------------------------------------------------------
audioSource.transform.position = location;
audioSource.clip = audioClip;
audioSource.pitch = pitch;
audioSource.spatialBlend = spatialBlend;
audioSource.panStereo = panStereo;
audioSource.loop = loop;
audioSource.bypassEffects = bypassEffects;
audioSource.bypassListenerEffects = bypassListenerEffects;
audioSource.bypassReverbZones = bypassReverbZones;
audioSource.priority = priority;
audioSource.reverbZoneMix = reverbZoneMix;
audioSource.dopplerLevel = dopplerLevel;
audioSource.spread = spread;
audioSource.rolloffMode = rolloffMode;
audioSource.minDistance = minDistance;
audioSource.maxDistance = maxDistance;
audioSource.time = playbackTime;
// track and volume ---------------------------------------------------------------------------------
if (settingsSo != null)
{
audioSource.outputAudioMixerGroup = settingsSo.MasterAudioMixerGroup;
switch (mmSoundManagerTrack)
{
case MMSoundManagerTracks.Master:
audioSource.outputAudioMixerGroup = settingsSo.MasterAudioMixerGroup;
break;
case MMSoundManagerTracks.Music:
audioSource.outputAudioMixerGroup = settingsSo.MusicAudioMixerGroup;
break;
case MMSoundManagerTracks.Sfx:
audioSource.outputAudioMixerGroup = settingsSo.SfxAudioMixerGroup;
break;
case MMSoundManagerTracks.UI:
audioSource.outputAudioMixerGroup = settingsSo.UIAudioMixerGroup;
break;
}
}
if (audioGroup)
{
audioSource.outputAudioMixerGroup = audioGroup;
}
audioSource.volume = volume;
// we start playing the sound
audioSource.Play();
// we destroy the host after the clip has played if it was a one time AS.
if (!loop && !recycleAudioSource)
{
Destroy(_tempAudioSourceGameObject, audioClip.length);
}
// we fade the sound in if needed
if (fade)
{
FadeSound(audioSource, fadeDuration, fadeInitialVolume, volume, fadeTween);
}
// we handle soloing
if (soloSingleTrack)
{
MuteSoundsOnTrack(mmSoundManagerTrack, true, 0f);
audioSource.mute = false;
if (autoUnSoloOnEnd)
{
MuteSoundsOnTrack(mmSoundManagerTrack, false, audioClip.length);
}
}
else if (soloAllTracks)
{
MuteAllSounds();
audioSource.mute = false;
if (autoUnSoloOnEnd)
{
StartCoroutine(MuteAllSoundsCoroutine(audioClip.length - playbackTime, false));
}
}
// we prepare for storage
_sound.ID = ID;
_sound.Track = mmSoundManagerTrack;
_sound.Source = audioSource;
_sound.Persistent = persistent;
// we check if that audiosource is already being tracked in _sounds
bool alreadyIn = false;
for (int i = 0; i < _sounds.Count; i++)
{
if (_sounds[i].Source == audioSource)
{
_sounds[i] = _sound;
alreadyIn = true;
}
}
if (!alreadyIn)
{
_sounds.Add(_sound);
}
// we return the audiosource reference
return(audioSource);
}
/// <summary>
/// Play any sound
/// </summary>
/// <param name="audio">Audio to be played</param>
/// <param name="type">Type of sound</param>
//public void Play(string resourcePath, SoundType type, float volume = 1f, bool switchMusicSmooth = true, bool loop = false, bool exclusiveSound = false, float duration = 0, float pitch = 1f)
//{
// if (m_cachedSounds.ContainsKey(resourcePath))
// {
// Play(m_cachedSounds[resourcePath], type, volume, loop, switchMusicSmooth, exclusiveSound, duration, pitch);
// }
// else
// {
// AudioClip clip = Resources.Load<AudioClip>(resourcePath);
// m_cachedSounds.Add(resourcePath, clip);
// Play(m_cachedSounds[resourcePath], type, volume, loop, switchMusicSmooth, exclusiveSound, duration, pitch);
// }
//}
/// <summary>
/// Play any sound
/// </summary>
/// <param name="audio">Audio to be played</param>
/// <param name="type">Type of sound</param>
public void Play(AudioClip audioClip, SoundType type, float volume = 1f, bool loop = false,
bool exclusiveSound = true,
float duration = 0, float pitch = 1f, float panStereo = 0f, float startFrom = 0f,
AudioMixerGroup audioMixerGroup = null, bool switchMusicSmooth = false)
{
if (audioClip == null)
{
return;
}
switch (type)
{
case SoundType.Music:
if (_musicChannel != null && _musicChannel.clip != null &&
_musicChannel.clip.name.Equals(audioClip.name) && _musicChannel.isPlaying)
{
if (_musicChannel.clip.name.Equals(audioClip.name))
{
_musicChannel.volume = volume;
}
return;
}
if (_musicChannel.clip != null && switchMusicSmooth)
{
StartCoroutine(SwitchMusic(audioClip, volume));
}
else
{
//volume = m_musicVolume;
_musicChannel.volume = volume;
_musicChannel.clip = audioClip;
_musicChannel.loop = true;
_musicChannel.Play();
}
break;
case SoundType.SoundEffect2D:
if (_muteAudio)
{
return;
}
// volume = type == SoundType.SoundEffect2D ? m_soundVolume : m_narrationVolume;
if (exclusiveSound)
{
for (int i = 0; i < _exclusiveSounds.Count; i++)
{
if (!_exclusiveSounds[i].IsPlaying)
{
_exclusiveSounds[i].Play(audioClip, loop, volume, duration, pitch, panStereo, startFrom,
audioMixerGroup);
return;
}
}
GameObject go = new GameObject("ExclusiveSound");
var removeAfterPlay = go.AddComponent <PlayAndRemove>();
removeAfterPlay.Play(audioClip, loop, volume, duration, pitch, panStereo, startFrom,
audioMixerGroup);
_exclusiveSounds.Add(removeAfterPlay);
removeAfterPlay.transform.SetParent(transform);
return;
}
bool _freeChannel = false;
for (int i = 0; i < SoundEffectChannel; i++)
{
if (_soundEffectChannels[i].clip == null || !_soundEffectChannels[i].isPlaying)
{
_soundEffectChannels[i].clip = audioClip;
_soundEffectChannels[i].loop = loop;
_soundEffectChannels[i].volume = volume;
_soundEffectChannels[i].Play();
_freeChannel = true;
break;
}
}
if (!_freeChannel)
{
//Check last index used
if (_soundEffectChannels.Any(x => !x.loop))
{
var channel = _soundEffectChannels.FirstOrDefault(x => !x.loop);
_nextChannel = _soundEffectChannels.IndexOf(channel);
}
_soundEffectChannels[_nextChannel].clip = audioClip;
_soundEffectChannels[_nextChannel].loop = loop;
_soundEffectChannels[_nextChannel].volume = volume;
_soundEffectChannels[_nextChannel].Play();
_nextChannel++;
if (_nextChannel > _soundEffectChannels.Count - 1)
{
_nextChannel = 0;
}
}
break;
case SoundType.Speech:
break;
default:
break;
}
}
/// <summary> [Editor Only] Plays a sound preview in the Editor </summary>
/// <param name="audioSource"> AudioSource that will play the sound </param>
/// <param name="outputAudioMixerGroup"> The output AudioMixerGroup that the sound will get routed through </param>
public void PlaySoundPreview(AudioSource audioSource, AudioMixerGroup outputAudioMixerGroup)
{
PlaySoundPreview(audioSource, outputAudioMixerGroup, null);
}
public void CrossFadeSync(AudioClip clip, float delaySec = 0f, float fadeSec = 1.0f, AudioMixerGroup group = null)
{
StartCoroutine(CrossFadeCor(clip, delaySec, fadeSec, group, true));
}
// --- Cross Fade ---
public void CrossFade(AudioClip clip, float fadeSec = 1.0f, AudioMixerGroup group = null)
{
StartCoroutine(CrossFadeCor(clip, 0, fadeSec, group, false));
}
public void FadeInBGMDelay(AudioClip clip, float delaySec = 1.0f, float fadeSec = 1.0f, AudioMixerGroup group = null)
{
if (currentBGMSource.clip != clip)
{
StartCoroutine(FadeInCor(clip, delaySec, fadeSec, group));
}
}
unsafe internal static extern bool Internal_AudioRenderer_AddMixerGroupSink(AudioMixerGroup mixerGroup, void *ptr, int length, bool excludeFromMix);
public void Play(AudioClip clip, AudioMixerGroup group, float delay = 0, float volumeScale = 1)
{
StartCoroutine(RoutinePlay(clip, group, delay, volumeScale));
}
public abstract void SetMixerGroup(AudioMixerGroup amg);
public void SetVolume(AudioMixerGroup targetGroup, float value)
{
audioMixer.SetFloat(targetGroup.name, Mathf.Log10(value) * 20);
PlayerPrefs.SetFloat(targetGroup.name, value);
}
/*
-----------------------
GetMixerGroup()
-----------------------
*/
public AudioMixerGroup GetMixerGroup( AudioMixerGroup defaultMixerGroup ) {
if ( soundGroup != null ) {
return ( soundGroup.mixerGroup != null ) ? soundGroup.mixerGroup : defaultMixerGroup:
}
return defaultMixerGroup:
}
public static bool SetGroupVolume(AudioMixerGroup group, float volume)
{
return(group.audioMixer.SetFloat("Volume", NormalizedToMixerValue(volume)));
}
public void RePopulate(AudioMixerGroup audioMixerGroup, Slider slider)
{
FindObjectOfType <GameMangaer>().PopulateList(BackgroundMusic);
GeneralMixer = audioMixerGroup;
slider.value = volume;
}
public void PlayNote(AudioClip clip, AudioMixerGroup channel)
{
aS.PlayOneShot(clip);
}
public void Play(AudioClip i_AudioClip, AudioMixerGroup i_Group)
{
Play(i_AudioClip, i_Group, 1f, 1f, Vector3.zero, Quaternion.identity);
}
const float maxFXVOL = 3.0f; //in decibles
// Use this for initialization
void Start()
{
timer = 0.0;
AM = Resources.Load("MasterMixer") as AudioMixer;
loop1 = new AudioSource();
loop2 = new AudioSource();
drums = new AudioSource();
pedals = new AudioSource();
paint1 = new AudioSource();
paint2 = new AudioSource();
paint3 = new AudioSource();
paint4 = new AudioSource();
intro = this.gameObject.AddComponent(typeof(AudioSource)) as AudioSource;
loop1 = this.gameObject.AddComponent(typeof(AudioSource)) as AudioSource;
loop2 = this.gameObject.AddComponent(typeof(AudioSource)) as AudioSource;
drums = this.gameObject.AddComponent(typeof(AudioSource)) as AudioSource;
pedals = this.gameObject.AddComponent(typeof(AudioSource)) as AudioSource;
paint1 = this.gameObject.AddComponent(typeof(AudioSource)) as AudioSource;
paint2 = this.gameObject.AddComponent(typeof(AudioSource)) as AudioSource;
paint3 = this.gameObject.AddComponent(typeof(AudioSource)) as AudioSource;
paint4 = this.gameObject.AddComponent(typeof(AudioSource)) as AudioSource;
if (AM != null)
{
intro.outputAudioMixerGroup = AM.FindMatchingGroups("Intro") [0];
AudioMixerGroup looper = AM.FindMatchingGroups("Loops") [0];
loop1.outputAudioMixerGroup = looper;
loop2.outputAudioMixerGroup = looper;
drums.outputAudioMixerGroup = AM.FindMatchingGroups("Drums") [0];
pedals.outputAudioMixerGroup = AM.FindMatchingGroups("Pedals") [0];
AudioMixerGroup FXer = AM.FindMatchingGroups("FX") [0];
paint1.outputAudioMixerGroup = FXer;
paint2.outputAudioMixerGroup = FXer;
paint3.outputAudioMixerGroup = FXer;
paint4.outputAudioMixerGroup = FXer;
}
loops = new List <AudioClip> ();
tones = new List <AudioClip> ();
introClip = Resources.Load("Audio/loops/ClayOpen") as AudioClip;
loop1Clip = Resources.Load("Audio/loops/ClayLoop1") as AudioClip;
loop2Clip = Resources.Load("Audio/loops/ClayLoop2") as AudioClip;
loop3Clip = Resources.Load("Audio/loops/ClayLoop3") as AudioClip;
loop4Clip = Resources.Load("Audio/loops/ClayLoop4") as AudioClip;
loop5Clip = Resources.Load("Audio/loops/ClayLoop5") as AudioClip;
loop6Clip = Resources.Load("Audio/loops/ClayLoop6") as AudioClip;
loop7Clip = Resources.Load("Audio/loops/ClayLoop7") as AudioClip;
loop8Clip = Resources.Load("Audio/loops/ClayLoop8") as AudioClip;
loop9Clip = Resources.Load("Audio/loops/ClayLoop9") as AudioClip;
loop10Clip = Resources.Load("Audio/loops/ClayLoop10") as AudioClip;
loop11Clip = Resources.Load("Audio/loops/ClayLoop11") as AudioClip;
loop12Clip = Resources.Load("Audio/loops/ClayLoop12") as AudioClip;
loop13Clip = Resources.Load("Audio/loops/ClayLoop13") as AudioClip;
drumClip = Resources.Load("Audio/ClayDrumLop") as AudioClip;
pedal1Clip = Resources.Load("Audio/ClayPed1234") as AudioClip;
pedal2Clip = Resources.Load("Audio/ClayPed1235") as AudioClip;
tone1 = Resources.Load("Audio/scale/1") as AudioClip;
tone2 = Resources.Load("Audio/scale/2") as AudioClip;
tone3 = Resources.Load("Audio/scale/3") as AudioClip;
tone4 = Resources.Load("Audio/scale/4") as AudioClip;
tone5 = Resources.Load("Audio/scale/5") as AudioClip;
tone6 = Resources.Load("Audio/scale/6") as AudioClip;
tone7 = Resources.Load("Audio/scale/7") as AudioClip;
tone8 = Resources.Load("Audio/scale/8") as AudioClip;
loops.Add(loop1Clip);
loops.Add(loop2Clip);
loops.Add(loop3Clip);
loops.Add(loop4Clip);
loops.Add(loop5Clip);
loops.Add(loop6Clip);
loops.Add(loop7Clip);
loops.Add(loop8Clip);
loops.Add(loop9Clip);
loops.Add(loop10Clip);
loops.Add(loop11Clip);
loops.Add(loop12Clip);
loops.Add(loop13Clip);
tones.Add(tone1);
tones.Add(tone2);
tones.Add(tone3);
tones.Add(tone4);
tones.Add(tone5);
tones.Add(tone6);
tones.Add(tone7);
tones.Add(tone8);
introduction = true;
introTimer = introClip.length;
intro.clip = introClip;
intro.Play();
loopTimer = 0.0;
firstLoopIsPlaying = false;
loop1.clip = loop3Clip;
drums.clip = drumClip;
pedalTimer = 0.0;
pedals.clip = pedal2Clip;
introlowpasscufoffmin = 0.00f;
introlowpasscufoffmax = 22000.00f;
AM.SetFloat("IntroLowPassCutoff", introlowpasscufoffmin);
placing = false;
fading = false;
fadeTimer = 0.0f;
placingTonePos = 0;
placingTimer = 0.0;
}
static public void Trigger(AudioClip clipToPlay, AudioMixerGroup audioGroup = null, float volume = 1f, float pitch = 1f)
{
OnEvent?.Invoke(clipToPlay, audioGroup, volume, pitch);
}
public static AudioSource AddAudioSource(GameObject gameObject, AudioClip clip = null, float volume = 1f, bool rollOff = false, AudioMixerGroup group = null)
{
AudioSource newSource;
newSource = gameObject.AddComponent <AudioSource>();
newSource.clip = clip;
newSource.volume = volume;
newSource.playOnAwake = false;
if (rollOff)
{
newSource.rolloffMode = AudioRolloffMode.Linear;
newSource.minDistance = 3;
newSource.maxDistance = 15;
newSource.spatialBlend = 1; // Necessary for volume rolloff to take effect
}
newSource.outputAudioMixerGroup = group == null ? Instance.ungrouped : group;
return(newSource);
}
private static AudioSource PlayClipAt(List <AudioClipWithVolume> clips, Vector3 pos, AudioMixerGroup mixerGroup, float delay = 0f)
{
return(PlayClipAt(clips[UnityEngine.Random.Range(0, clips.Count)], pos, mixerGroup, delay));
}
// We should consider making this delegate-based in order to provide information like channel count and format. Also the term "sink" is quite audio-domain specific.
unsafe internal static bool AddMixerGroupSink(AudioMixerGroup mixerGroup, NativeArray <float> buffer, bool excludeFromMix)
{
return(Internal_AudioRenderer_AddMixerGroupSink(mixerGroup, buffer.GetUnsafePtr(), buffer.Length, excludeFromMix));
}
public void SetSFXMixing(string mixerId, string groupId)
{
currentSfxMixer = GetMixerGroup(mixerId, groupId);
}
/// <summary>
/// Plays the clip.
/// </summary>
/// <param name="clip">The AudioClip to play</param>
/// <param name="volume">The volume of the AudioSource playing the clip (0.0 to 1.0)</param>
/// <param name="loop">Loop the AudioClip?</param>
/// <param name="pitch">Pitch shift of the AudioSource</param>
/// <param name="delay">The volume of the AudioSource (0.0 to 1.0)</param>
/// <param name="audioMixerGroup">The target group to which the AudioSource should route its signal</param>
/// <returns></returns>
public AudioSource PlayClip(AudioClip clip, float volume = 1, bool loop = false, float pitch = 1, float delay = 0f, AudioMixerGroup audioMixerGroup = null)
{
if (clip == null)
{
Debug.LogWarning("Trying to play a null clip", this);
return(null);
}
AudioSource configuredAudioSource = ConfigureAudioSource(GetFreeAudioSource(), clip, volume, loop, pitch, audioMixerGroup);
configuredAudioSource.PlayDelayed(delay);
return(configuredAudioSource);
}
