public void AudioSourceSettingUpdate_NewValueIsWrittenBackToSettings()
{
var setting = "setting";
_audioSourceMock.SetupGet(s => s.Settings).Returns(new List <AudioSourceSettingAttribute> {
new AudioSourceSettingAttribute(setting)
});
var settingModel = new AudioSourceSetting {
Name = setting
};
var settings = new AudioSourceSettings
{
Settings = new List <AudioSourceSetting> {
settingModel
}
};
object newSettingValue = 1;
_audioSourceMock.SetupGet(s => s[It.Is <string>(x => x == setting)]).Returns(newSettingValue);
var vm = new AudioSourceSettingsCollectionViewModel(_audioSourceMock.Object, settings, _messageBus.Object);
_audioSourceMock.Raise(s => s.SettingChanged += null, new SettingChangedEventArgs(setting));
vm.EndEdit();
Assert.Equal(newSettingValue, settingModel.Value);
}
/// <summary>
/// Creates a settings view model for the new audio source.
/// </summary>
/// <param name="audioSource">The audio source.</param>
public void CreateViewModelForAudioSource(IInternalAudioSource audioSource)
{
var settings = audioSource.Settings;
if (settings.Count == 0)
{
return;
}
// check if the settings were saved previously and reuse them
var matchingSetting = _appSettings.AudioSourceSettings.FirstOrDefault(s => s.AudioSourceName == audioSource.Name);
if (matchingSetting != null)
{
var viewModel = new AudioSourceSettingsCollectionViewModel(audioSource, matchingSetting, _messageBus);
AudioSourcesSettings.Add(viewModel);
}
else
{
var newSettingsModel = new AudioSourceSettings {
AudioSourceName = audioSource.Name
};
_appSettings.AudioSourceSettings.Add(newSettingsModel);
var newViewModel = new AudioSourceSettingsCollectionViewModel(audioSource, newSettingsModel, _messageBus);
AudioSourcesSettings.Add(newViewModel);
}
_appSettings.Save();
}
/// <summary>
/// Setups the audio source to play the given sound at the given volume/spatial blend
/// A spatial blen higher than 0 makes the sound 3D with the highest value being 1
/// </summary>
/// <param name="clip">Clip to play</param>
/// <param name="volume">Volume to play at</param>
/// <param name="spatialBlend">1f = 3D, 0f = 2D</param>
/// <param name="loops">Loop sound playback</param>
void PlaySound(AudioClip clip, AudioSourceSettings settings)
{
if (clip == null)
{
Destroy(gameObject);
return;
}
m_soundPlayed = true;
// Keeps the Hierarchy a little cleaner
gameObject.name = clip.name + "_AudioSource";
// Confiure the AudioSource
Source.clip = clip;
Source.volume = Mathf.Clamp01(settings.volume);
Source.loop = settings.loops;
Source.priority = settings.priority;
Source.pitch = settings.pitch;
Source.panStereo = settings.stereoPan;
Source.reverbZoneMix = settings.reverbZoneMix;
Source.dopplerLevel = settings.dopplerLevel;
Source.spatialBlend = Mathf.Clamp01(settings.spatialBlend);
Source.spread = Mathf.Clamp(settings.spread, 0, 360);
Source.minDistance = settings.minDistance;
Source.maxDistance = settings.maxDistance;
Source.rolloffMode = settings.volumeRolloff;
Source.Play();
}
public void AudioSourceSettingUpdatesAreHandled()
{
var setting = "setting";
_audioSourceMock.SetupGet(s => s.Settings).Returns(new List <AudioSourceSettingAttribute> {
new AudioSourceSettingAttribute(setting)
});
var settingModel = new AudioSourceSetting {
Name = setting
};
var settings = new AudioSourceSettings
{
Settings = new List <AudioSourceSetting> {
settingModel
}
};
var vm = new AudioSourceSettingsVM(settings, _audioSourceMock.Object);
object newSettingValue = 1;
_audioSourceMock.SetupGet(s => s[It.Is <string>(x => x == setting)]).Returns(newSettingValue);
_audioSourceMock.Raise(s => s.SettingChanged += null, new SettingChangedEventArgs(setting));
Assert.AreEqual(settingModel.Value, newSettingValue);
}
public void NoMatchingSettings_CreatesNoChildViewModels()
{
_audioSourceMock.SetupGet(s => s.Settings).Returns(new List <AudioSourceSettingAttribute>());
var name = "test";
_audioSourceMock.SetupGet(x => x.Name).Returns(name);
var keyVals = new List <AudioSourceSetting>
{
new AudioSourceSetting {
Name = "key1", Value = "val1"
},
new AudioSourceSetting {
Name = "key2", Value = "val2"
}
};
var settings = new AudioSourceSettings {
AudioSourceName = name, Settings = keyVals
};
var vm = new AudioSourceSettingsCollectionViewModel(_audioSourceMock.Object, settings, _messageBus.Object);
Assert.Empty(vm.SettingsList);
Assert.Equal(name, vm.AudioSourceName);
}
public AudioObject(AudioObject ao, GameObject go)
{
name = ao.name;
settings = ao.settings;
AddAudioSource(go);
InitAudioSourceFromSettings();
}
public void Init()
{
_defaultAudioSettings = gameObject.AddComponent<AudioSourceSettings>();
for (int i = 0; i < DefaultSize; i++)
{
AddAudioSource();
}
}
public override void OnEnable()
{
base.OnEnable();
_sourceSettings = target as AudioSourceSettings;
_clipProperty = serializedObject.FindProperty("Clip");
InitializeTextures();
}
/// <summary>
/// Plays the given clip as a 2D sound with default audio settings
/// Use this when you need to quickly play a 2D sound without the need of custom settings
/// </summary>
/// <param name="clip"></param>
/// <param name="volume"></param>
/// <param name="pitch">change the pitch level</param>
public void Play2DSound(AudioClip clip, float volume, float pitch = 1f)
{
AudioSourceSettings settings = new AudioSourceSettings()
{
volume = volume,
pitch = pitch
};
PlaySound(clip, settings);
}
/// <summary>
/// Plays the given clip as 2D sound which means it will be heard equally from all speakers
/// If audio is set to loop it will only stop when either:
/// <see cref="PauseSounds"/> or <see cref="StopAll"/> are called
/// or when you stop it through the returned AudioSource
/// </summary>
/// <param name="clipName">The name of the clip to play</param>
/// <param name="volume">Modify the default volume of the clip</param>
/// <param name="pitch">Modify the pitch of the sound</param>
/// <returns></returns>
public AudioSource Play2DSound(AudioClipName clipName, float volume = 1f, float pitch = 1f)
{
AudioClipInfo info = GetClipInfo(clipName);
AudioSourceSettings settings = info.Settings;
// Override settings
settings.volume = volume * SoundFxVolume;
settings.pitch = pitch;
SingleShotAudio fx = CreateNewSoundSource();
fx.Play2DSound(info.Clip, settings);
return(fx.Source);
}
public void AudioSourceSettingsUpdated_AudioSourceIsUpdatedInPriority()
{
var setting1 = new AudioSourceSettingAttribute("test1")
{
Priority = 10
};
var setting2 = new AudioSourceSettingAttribute("test2")
{
Priority = 5
};
var setting3 = new AudioSourceSettingAttribute("test3")
{
Priority = 20
};
_audioSourceMock.SetupAllProperties();
_audioSourceMock.SetupGet(m => m.Settings).Returns(new List <AudioSourceSettingAttribute> {
setting1, setting2, setting3
});
var settings = new AudioSourceSettings
{
Settings = new List <AudioSourceSetting>
{
new AudioSourceSetting {
Name = setting1.Name
},
new AudioSourceSetting {
Name = setting2.Name
},
new AudioSourceSetting {
Name = setting3.Name
},
}
};
var s = new MockSequence();
_audioSourceMock.InSequence(s).SetupSet(source => source[It.Is <string>(x => x == setting3.Name)] = null);
_audioSourceMock.InSequence(s).SetupSet(source => source[It.Is <string>(x => x == setting1.Name)] = null);
_audioSourceMock.InSequence(s).SetupSet(source => source[It.Is <string>(x => x == setting2.Name)] = null);
var vm = new AudioSourceSettingsCollectionViewModel(_audioSourceMock.Object, settings, _messageBus.Object);
_audioSourceMock.VerifySet(source => source[setting3.Name] = null);
_audioSourceMock.VerifySet(source => source[setting1.Name] = null);
_audioSourceMock.VerifySet(source => source[setting2.Name] = null);
}
private async Task AddNewAudioSource(IInternalAudioSource audioSource)
{
var menuItem = new DeskBandMenuAction(audioSource.Name);
menuItem.Clicked += AudioSourceMenuItemOnClicked;
lock (_audiosourceListLock)
{
_audioSourceContextMenuItems.Add(menuItem);
RefreshContextMenu();
}
var settings = audioSource.Settings;
if (settings.Count > 0)
{
// check if the settings were saved previously and reuse them
var matchingSetting = _audioSourceSettingsModel.FirstOrDefault(s => s.AudioSourceName == audioSource.Name);
if (matchingSetting != null)
{
var viewModel = new AudioSourceSettingsVM(matchingSetting, audioSource);
// the collection was created on the ui thread
await _uiDispatcher.InvokeAsync(() => _settingsWindowVm.AudioSourceSettingsVM.Add(viewModel));
}
else
{
var newSettingsModel = new AudioSourceSettings {
AudioSourceName = audioSource.Name
};
_audioSourceSettingsModel.Add(newSettingsModel);
var newViewModel = new AudioSourceSettingsVM(newSettingsModel, audioSource);
await _uiDispatcher.InvokeAsync(() => _settingsWindowVm.AudioSourceSettingsVM.Add(newViewModel));
}
}
// If user was using this audio source last, then automatically activate it
var savedAudioSourceName = _appSettings.AudioSource;
if (savedAudioSourceName == null || audioSource.Name != savedAudioSourceName)
{
return;
}
await HandleAudioSourceContextMenuItemClick(menuItem).ConfigureAwait(false);
}
private async Task <SettingsWindowVM> SetupViewModels()
{
var albumArt = new AlbumArtVM(_albumArtModel, _trackModel);
var albumArtPopup = new AlbumArtPopupVM(_albumArtPopupModel, _trackModel);
var audioBand = new AudioBandVM(_audioBandModel);
var customLabels = new CustomLabelsVM(_customLabelsModel, this);
var nextButton = new NextButtonVM(_nextButtonModel);
var playPauseButton = new PlayPauseButtonVM(_playPauseButtonModel, _trackModel);
var prevButton = new PreviousButtonVM(_previousButtonModel);
var progressBar = new ProgressBarVM(_progressBarModel, _trackModel);
var allAudioSourceSettings = new List <AudioSourceSettingsVM>();
foreach (var audioSource in _audioSourceLoader.AudioSources)
{
var matchingSetting = _audioSourceSettingsModel.FirstOrDefault(s => s.AudioSourceName == audioSource.Name);
if (matchingSetting != null)
{
allAudioSourceSettings.Add(new AudioSourceSettingsVM(matchingSetting, audioSource));
}
else
{
var newSettings = new AudioSourceSettings {
AudioSourceName = audioSource.Name
};
_audioSourceSettingsModel.Add(newSettings);
allAudioSourceSettings.Add(new AudioSourceSettingsVM(newSettings, audioSource));
}
}
await _uiDispatcher.InvokeAsync(() => InitializeBindingSources(albumArtPopup, albumArt, audioBand, nextButton, playPauseButton, prevButton, progressBar));
return(new SettingsWindowVM
{
AlbumArtPopupVM = albumArtPopup,
ProgressBarVM = progressBar,
PreviousButtonVM = prevButton,
PlayPauseButtonVM = playPauseButton,
NextButtonVM = nextButton,
AudioBandVM = audioBand,
AboutVm = new AboutVM(),
AlbumArtVM = albumArt,
CustomLabelsVM = customLabels,
AudioSourceSettingsVM = allAudioSourceSettings
});
}
//A single function to unify play and play at point, under the hood
private ArdenAudioInstance Play_Internal(AudioSourceSettings settings, float volume, MixerGroup group, bool looped, bool playAtPoint, Vector3 location)
{
if (audioAssets == null)
{
return(null);
}
if (audioAssets.Count == 0)
{
return(null);
}
ArdenAudioPlayListInstance instance = new ArdenAudioPlayListInstance(this, settings);
instance.Init(volume, group, looped, playAtPoint, location);
return(instance);
}
public void MatchingSettingsShouldCreateVmsInOrder()
{
var setting1 = "Setting1";
var setting2 = "setting2";
object val1 = "val1";
object val2 = 2;
_audioSourceMock.SetupGet(s => s.Settings).Returns(new List <AudioSourceSettingAttribute>
{
new AudioSourceSettingAttribute(setting1),
new AudioSourceSettingAttribute(setting2),
});
_audioSourceMock.SetupGet(s => s[It.Is <string>(x => x == setting1)]).Returns(val1);
_audioSourceMock.SetupGet(s => s[It.Is <string>(x => x == setting2)]).Returns(val2);
_audioSourceMock.Setup(s => s.GetSettingType(It.Is <string>(x => x == setting1))).Returns(typeof(string));
_audioSourceMock.Setup(s => s.GetSettingType(It.Is <string>(x => x == setting2))).Returns(typeof(int));
var settingModels = new List <AudioSourceSetting>
{
new AudioSourceSetting {
Name = setting1, Value = val1
},
new AudioSourceSetting {
Name = setting2, Value = val2
}
};
var settings = new AudioSourceSettings {
Settings = settingModels
};
var vm = new AudioSourceSettingsCollectionViewModel(_audioSourceMock.Object, settings, _messageBus.Object);
Assert.AreEqual(settingModels.Count, vm.SettingsList.Count);
Assert.AreEqual(settingModels[0].Name, vm.SettingsList[0].Name);
Assert.AreEqual(settingModels[1].Name, vm.SettingsList[1].Name);
Assert.AreEqual(settingModels[0].Value, vm.SettingsList[0].Value);
Assert.AreEqual(settingModels[1].Value, vm.SettingsList[1].Value);
}
public void NoMatchingSettings()
{
_audioSourceMock.SetupGet(s => s.Settings).Returns(new List <AudioSourceSettingAttribute>());
var name = "test";
var keyVals = new List <AudioSourceSetting>
{
new AudioSourceSetting {
Name = "key1", Value = "val1"
},
new AudioSourceSetting {
Name = "key2", Value = "val2"
}
};
var settings = new AudioSourceSettings {
AudioSourceName = name, Settings = keyVals
};
var vm = new AudioSourceSettingsVM(settings, _audioSourceMock.Object);
Assert.AreEqual(0, vm.Settings.Count);
Assert.AreEqual(name, vm.AudioSourceName);
}
public void PlaySound(AudioClip clip, Vector3 position, AudioSourceSettings settings)
{
SetAudioSettings(settings);
PlaySound(clip, position);
}
public override ArdenAudioInstance Play(AudioSourceSettings settings, float volume = 1, MixerGroup group = MixerGroup.sfx, bool looped = false)
{
return(Play_Internal(settings, volume, group, looped, false, new Vector3()));
}
protected override void OnAwake()
{
AudioSettings = GetComponent<AudioSourceSettings>();
}
public static bool ChangeAudioSourceSettings(AudioSource source, AudioSourceSettings settings)
{
bool flag = false;
if (source.bypassEffects != settings.m_bypassEffects)
{
source.bypassEffects = settings.m_bypassEffects;
flag = true;
}
if (source.loop != settings.m_loop)
{
source.loop = settings.m_loop;
flag = true;
}
if (source.priority != settings.m_priority)
{
source.priority = settings.m_priority;
flag = true;
}
if (!object.Equals(source.volume, settings.m_volume))
{
source.volume = settings.m_volume;
flag = true;
}
if (!object.Equals(source.pitch, settings.m_pitch))
{
source.pitch = settings.m_pitch;
flag = true;
}
if (!object.Equals(source.panStereo, settings.m_stereoPan))
{
source.panStereo = settings.m_stereoPan;
flag = true;
}
if (!object.Equals(source.spatialBlend, settings.m_spatialBlend))
{
source.spatialBlend = settings.m_spatialBlend;
flag = true;
}
if (!object.Equals(source.reverbZoneMix, settings.m_reverbZoneMix))
{
source.reverbZoneMix = settings.m_reverbZoneMix;
flag = true;
}
if (source.rolloffMode != settings.m_rolloffMode)
{
source.rolloffMode = settings.m_rolloffMode;
flag = true;
}
if (!object.Equals(source.dopplerLevel, settings.m_dopplerLevel))
{
source.dopplerLevel = settings.m_dopplerLevel;
flag = true;
}
if (!object.Equals(source.minDistance, settings.m_minDistance))
{
source.minDistance = settings.m_minDistance;
flag = true;
}
if (!object.Equals(source.maxDistance, settings.m_maxDistance))
{
source.maxDistance = settings.m_maxDistance;
flag = true;
}
if (!object.Equals(source.spread, settings.m_spread))
{
source.spread = settings.m_spread;
flag = true;
}
return(flag);
}
public override ArdenAudioInstance PlayAtPoint(AudioSourceSettings settings, Vector3 location, float volume = 1, MixerGroup group = MixerGroup.sfx, bool looped = false)
{
return(Play_Internal(settings, volume, group, looped, true, location));
}
/// <summary>
/// Initializes a new instance of the <see cref="AudioSourceSettingsCollectionViewModel"/> class.
/// </summary>
/// <param name="audioSource">The audiosource that these settings belong to.</param>
/// <param name="settingsModel">The settings model.</param>
/// <param name="messageBus">The message bus.</param>
/// <param name="appSettings">The app settings.</param>
public AudioSourceSettingsCollectionViewModel(IInternalAudioSource audioSource, AudioSourceSettings settingsModel, IMessageBus messageBus, IAppSettings appSettings)
{
_audioSource = audioSource;
_messageBus = messageBus;
_appSettings = appSettings;
SettingsList = new ObservableCollection <AudioSourceSettingKeyValue>(CreateKeyValuePairs(audioSource, settingsModel));
_audioSource.SettingChanged += AudioSourceOnSettingChanged;
foreach (var audioSourceSettingKeyValue in SettingsList)
{
audioSourceSettingKeyValue.PropertyChanged += AudioSourceSettingKeyValueOnPropertyChanged;
}
UseMessageBus(messageBus);
}
/// <summary>
/// Forces the given clip to have a spatial blend of 0 to make it 2D
/// This overrides which ever values the given settings has
/// Note:
/// You could set the settings to spatialBlend 0 by default and use the PlaySoundAt,
/// be it will always play as 2D, but what this allows you to do is play any sound
/// as a 2D sound even if it was configured to be 3D
/// </summary>
/// <param name="clip"></param>
/// <param name="settings"></param>
public void Play2DSound(AudioClip clip, AudioSourceSettings settings)
{
PlaySound(clip, settings);
}
/// <summary>
/// Plays the given clip at the given position by moving the AudioSource parent object to that location
/// </summary>
/// <param name="clip"></param>
/// <param name="position"></param>
/// <param name="settings"></param>
public void PlaySoundAt(AudioClip clip, Vector3 position, AudioSourceSettings settings)
{
transform.position = position;
PlaySound(clip, settings);
}
public ArdenAudioPlayListInstance(ArdenAudioAsset asset, AudioSourceSettings settings) : base(asset, settings)
{
}
private List <AudioSourceSettingKeyValue> CreateKeyValuePairs(IInternalAudioSource source, AudioSourceSettings existingSettings)
{
// Using a list instead of a dictionary is simple and good enough for now. There are no observable dictionaries either.
var keyPairViewModels = new List <AudioSourceSettingKeyValue>();
var settingAttributes = source.Settings;
foreach (var settingAttribute in settingAttributes)
{
var matchingSetting = existingSettings.Settings.FirstOrDefault(s => s.Name == settingAttribute.Name);
if (matchingSetting != null)
{
keyPairViewModels.Add(new AudioSourceSettingKeyValue(source, matchingSetting, settingAttribute));
}
else
{
var name = settingAttribute.Name;
var defaultValue = source[name];
var newSettingModel = new AudioSourceSetting {
Name = name, Value = defaultValue
};
existingSettings.Settings.Add(newSettingModel);
keyPairViewModels.Add(new AudioSourceSettingKeyValue(source, newSettingModel, settingAttribute));
}
}
// apply changes in priority
foreach (var keyPair in keyPairViewModels.OrderByDescending(vm => vm.Priority))
{
keyPair.PropagateSettingToAudioSource();
}
return(keyPairViewModels);
}
public void SetAudioSettings(AudioSourceSettings settings)
{
if (settings == null)
{
settings = _pool.DefaultAudioSourceSettings;
}
Volume = settings.Volume;
TheAudioSource.rolloffMode = settings.VolumeRolloff;
TheAudioSource.bypassEffects = settings.BypassEffects;
TheAudioSource.loop = settings.Loop;
TheAudioSource.outputAudioMixerGroup = settings.MixerGroup;
TheAudioSource.dopplerLevel = settings.DopplerLevel;
TheAudioSource.maxDistance = settings.MaxDistance;
TheAudioSource.minDistance = settings.MinDistance;
TheAudioSource.priority = settings.Priority;
TheAudioSource.mute = settings.Mute;
TheAudioSource.reverbZoneMix = settings.ReverbZoneMix;
TheAudioSource.spatialBlend = settings.SpatialBlend;
TheAudioSource.spread = settings.Spread;
TheAudioSource.panStereo = settings.StereoPan;
TheAudioSource.pitch = 1;
}
