public static void FindAndSetBankReference(WwiseAddressableSoundBank addressableBankAsset, string name)
{
System.Reflection.Assembly[] assemblies = System.AppDomain.CurrentDomain.GetAssemblies();
var assembly = Assembly.Load("AK.Wwise.Unity.API.WwiseTypes");
var AkBankReferenceType = assembly.GetType("WwiseBankReference");
bool success = (bool)AkBankReferenceType.GetMethod("FindBankReferenceAndSetAddressableBank").Invoke(null, new object[] { addressableBankAsset, name });
}
internal static void UpdateAddressableBankReference(WwiseAddressableSoundBank asset, string bankName)
{
bool bankScriptableObjectUpdated = false;
if (AkAssetUtilities.AddressableBankUpdated != null)
{
bankScriptableObjectUpdated = AkAssetUtilities.AddressableBankUpdated.GetInvocationList().Select(x => (bool)x.DynamicInvoke(asset, bankName)).Any(v => v);
}
if (!bankScriptableObjectUpdated)
{
AkAssetUtilities.FindAndSetBankReference(asset, bankName);
}
}
private void OnBankLoaded(WwiseAddressableSoundBank bank)
{
if (bank.loadState == BankLoadState.Loaded)
{
UnityEngine.Debug.Log($"Wwise Addressable Bank Manager : Loaded {bank.name} bank - Bank ID : {bank.soundbankId}");
if (InitBankLoaded && bank.name == InitBank.name)
{
foreach (var b in m_AddressableBanks.Values)
{
if (b.loadState == BankLoadState.WaitingForInitBankToLoad)
{
LoadBank(b, b.decodeBank, b.saveDecodedBank);
}
}
}
//Fire any events that were waiting on the bank load
var eventsToRemove = new List <uint>();
foreach (var e in m_eventsToFireOnBankLoad)
{
if (bank.eventNames.Contains(e.Value.eventName))
{
UnityEngine.Debug.Log($"Wwise Addressable Bank Manager: Triggering delayed event {e.Value.eventName}");
MethodInfo handleEvent = EventType.GetMethod(e.Value.methodName, e.Value.methodArgTypes);
handleEvent.Invoke(e.Value.eventObject, e.Value.methodArgs);
eventsToRemove.Add(e.Key);
}
}
foreach (var e in eventsToRemove)
{
m_eventsToFireOnBankLoad.TryRemove(e, out _);
}
}
//Reset bank state if load failed
if (bank.loadState == BankLoadState.LoadFailed)
{
UnloadBank(bank, ignoreRefCount: true);
}
if (m_banksToUnload.Keys.Contains(bank.name))
{
UnloadBank(bank);
}
}
public void UnloadBank(WwiseAddressableSoundBank bank, bool ignoreRefCount = false, bool removeFromBankDictionary = true)
{
if (!ignoreRefCount)
{
bank.refCount = Math.Max(0, bank.refCount - 1);
if (bank.refCount != 0)
{
return;
}
}
if (bank.loadState == BankLoadState.Loading)
{
UnityEngine.Debug.Log($"Wwise Addressable Bank Manager: {bank.name} will be unloaded after it is done loading");
m_banksToUnload.TryAdd(bank.name, bank.name);
return;
}
if (bank.loadState == BankLoadState.Loaded)
{
UnityEngine.Debug.Log($"Wwise Addressable Bank Manager: Unloading {bank.name} sound bank - Bank ID : {bank.soundbankId}");
AkSoundEngine.UnloadBank(bank.soundbankId, System.IntPtr.Zero);
}
m_banksToUnload.TryRemove(bank.name, out _);
bank.soundbankId = 0;
bank.refCount = 0;
bank.loadState = BankLoadState.Unloaded;
if (removeFromBankDictionary)
{
if (!m_AddressableBanks.TryRemove(bank.name, out _))
{
#if UNITY_EDITOR
// Don't unnecessarily log messages when caused by domain reload
if (UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode && !UnityEditor.EditorApplication.isPlaying)
{
return;
}
#endif
if (InitBank && bank.name != InitBank.name)
{
UnityEngine.Debug.LogError($"Wwise Addressable Bank Manager: Unloaded {bank.name}, but it was not in the list of loaded banks");
}
}
}
}
public void UnloadBank(WwiseAddressableSoundBank bank, bool ignoreRefCount = false, bool removeFromBankDictionary = true)
{
if (bank.loadState == BankLoadState.Loading || bank.loadState == BankLoadState.WaitingForInitBankToLoad)
{
UnityEngine.Debug.LogError($"Wwise Addressable Bank Manager: Will unload {bank.name} when it has finished loading");
m_banksToUnload.TryAdd(bank.name, bank.name);
return;
}
if (!ignoreRefCount)
{
bank.refCount = Math.Max(0, bank.refCount - 1);
if (bank.refCount != 0)
{
return;
}
}
if (bank.loadState == BankLoadState.Loaded)
{
UnityEngine.Debug.Log($"Wwise Addressable Bank Manager: Unloading {bank.name} sound bank - Bank ID : {bank.soundbankId}");
AkSoundEngine.UnloadBank(bank.soundbankId, System.IntPtr.Zero);
bank.soundbankId = 0;
bank.loadState = BankLoadState.Unloaded;
bank.refCount = 0;
if (removeFromBankDictionary)
{
if (!m_AddressableBanks.TryRemove(bank.name, out _))
{
#if UNITY_EDITOR
if (UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode && !UnityEditor.EditorApplication.isPlaying)
{
return;
}
#endif
UnityEngine.Debug.LogError($"Wwise Addressable Bank Manager: Did not unload {bank.name} as it was not in the list of loaded banks");
}
}
}
}
internal static void AddBankReferenceToAddressableBankAsset(ConcurrentDictionary <string, WwiseAddressableSoundBank> addressableAssetCache, HashSet <string> bankAssetsAdded)
{
List <CreateAssetEntry> itemsToCreate = new List <CreateAssetEntry>();
try
{
foreach (var bankPath in bankAssetsAdded)
{
string name = Path.GetFileNameWithoutExtension(bankPath);
string platform;
string language;
AkAssetUtilities.ParseAssetPath(bankPath, out platform, out language);
// First find or create AddressableBank asset
WwiseAddressableSoundBank addressableBankAsset = null;
if (!addressableAssetCache.TryGetValue(name, out addressableBankAsset))
{
var results = AssetDatabase.FindAssets(string.Format("{0} t:{1}", name, nameof(WwiseAddressableSoundBank)));
if (results.Length > 0)
{
string addressableBankGuid = results.First();
addressableBankAsset = AssetDatabase.LoadAssetAtPath <WwiseAddressableSoundBank>(AssetDatabase.GUIDToAssetPath(addressableBankGuid));
}
string addressableBankAssetDirectory = AkAssetUtilities.GetSoundbanksPath();
string addressableBankAssetPath = string.Format("{0}/{1}", addressableBankAssetDirectory, Path.ChangeExtension(name, ".asset"));
if (addressableBankAsset == null)
{
if (!AssetDatabase.IsValidFolder(addressableBankAssetDirectory))
{
StringBuilder currentPathBuilder = new StringBuilder();
var addressableBankAssetParts = addressableBankAssetDirectory.Split('/');
currentPathBuilder.Append(addressableBankAssetParts[0]);
for (int i = 1; i < addressableBankAssetParts.Length; ++i)
{
string previousPath = currentPathBuilder.ToString();
currentPathBuilder.AppendFormat("/{0}", addressableBankAssetParts[i]);
string currentPath = currentPathBuilder.ToString();
if (!AssetDatabase.IsValidFolder(currentPath))
{
AssetDatabase.CreateFolder(previousPath, addressableBankAssetParts[i]);
}
}
}
addressableBankAsset = ScriptableObject.CreateInstance <WwiseAddressableSoundBank>();
itemsToCreate.Add(new CreateAssetEntry {
Asset = addressableBankAsset, Path = addressableBankAssetPath, Name = name
});
}
else
{
UpdateAddressableBankReference(addressableBankAsset, name);
}
addressableAssetCache.AddOrUpdate(name, addressableBankAsset, (key, oldValue) => addressableBankAsset);
if (name == "Init")
{
var wwiseGlobablGameObject = GameObject.Find("WwiseGlobal");
InitBankHolder bankHolder;
if (wwiseGlobablGameObject != null)
{
bankHolder = wwiseGlobablGameObject.GetComponent <InitBankHolder>();
if (bankHolder == null)
{
wwiseGlobablGameObject.AddComponent <InitBankHolder>();
bankHolder = wwiseGlobablGameObject.GetComponent <InitBankHolder>();
}
bankHolder.InitBank = addressableBankAsset;
}
else
{
bankHolder = UnityEngine.Object.FindObjectOfType <InitBankHolder>();
if (bankHolder != null)
{
bankHolder.InitBank = addressableBankAsset;
}
else
{
Debug.Log("Could not find or create the InitBankHolder, you will have to add one to the WwiseGlobal object in your scene and ensure it references the Init bank.");
}
}
}
}
if (!string.IsNullOrEmpty(platform))
{
var soundbankInfos = AkAssetUtilities.ParsePlatformSoundbanksXML(platform, name);
addressableBankAsset.UpdateLocalizationLanguages(platform, soundbankInfos[name].Keys.ToList());
addressableBankAsset.AddOrUpdate(platform, language, new AssetReferenceWwiseBankData(AssetDatabase.AssetPathToGUID(bankPath)));
EditorUtility.SetDirty(addressableBankAsset);
}
}
}
finally
{
if (itemsToCreate.Count > 0)
{
AssetDatabase.StartAssetEditing();
foreach (var entry in itemsToCreate)
{
AssetDatabase.CreateAsset(entry.Asset, entry.Path);
UpdateAddressableBankReference(entry.Asset, entry.Name);
}
AssetDatabase.StopAssetEditing();
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
}
public async void LoadBankAsync(WwiseAddressableSoundBank bank, AssetReferenceWwiseBankData bankData)
{
var AsyncHandle = bankData.LoadAssetAsync();
await AsyncHandle.Task;
if (AsyncHandle.IsValid() && AsyncHandle.Status == AsyncOperationStatus.Succeeded)
{
bank.eventNames = new HashSet <string>(AsyncHandle.Result.eventNames);
var data = AsyncHandle.Result.RawData;
bank.GCHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
var result = AkSoundEngine.LoadBankMemoryCopy(bank.GCHandle.AddrOfPinnedObject(), (uint)data.Length, out uint bankID);
if (result == AKRESULT.AK_Success)
{
bank.soundbankId = bankID;
bank.loadState = BankLoadState.Loaded;
}
else
{
bank.soundbankId = INVALID_SOUND_BANK_ID;
bank.loadState = BankLoadState.LoadFailed;
UnityEngine.Debug.Log($"Wwise Addressable Bank Manager : Sound Engine failed to load {bank.name} SoundBank");
}
bank.GCHandle.Free();
Addressables.Release(AsyncHandle);
string destinationDir;
if (bank.StreamingMedia != null)
{
foreach (var language in bank.StreamingMedia.Keys)
{
if (language == "SFX")
{
destinationDir = UnityEngine.Application.persistentDataPath;;
}
else
{
destinationDir = Path.Combine(UnityEngine.Application.persistentDataPath, language);
}
if (!Directory.Exists(destinationDir))
{
Directory.CreateDirectory(destinationDir);
}
foreach (var streamedAsset in bank.StreamingMedia[language].media)
{
if (streamedAsset == null)
{
UnityEngine.Debug.LogError($"Wwise Addressable Bank Manager: Streaming media asset referenced in {bank.name} SoundBank is null");
continue;
}
var loadHandle = streamedAsset.LoadAssetAsync();
await loadHandle.Task;
if (loadHandle.IsValid() && loadHandle.Status == AsyncOperationStatus.Succeeded)
{
AkAssetUtilities.UpdateWwiseFileIfNecessary(destinationDir, loadHandle.Result);
Addressables.Release(loadHandle);
}
else
{
UnityEngine.Debug.LogError($"Wwise Addressable Bank Manager: Failed to load streaming media asset {streamedAsset.id} in {bank.name} SoundBank");
}
}
}
}
}
else
{
UnityEngine.Debug.Log($"Wwise Addressable Bank Manager : Failed to load {bank.name} SoundBank");
bank.loadState = BankLoadState.LoadFailed;
Addressables.Release(AsyncHandle);
}
//Make sure the asset is cleared from memory
UnityEngine.Resources.UnloadUnusedAssets();
OnBankLoaded(bank);
}
//Todo : support decoding banks and saving decoded banks
public void LoadBank(WwiseAddressableSoundBank bank, bool decodeBank = false, bool saveDecodedBank = false, bool addToBankDictionary = true)
{
bank.decodeBank = decodeBank;
bank.saveDecodedBank = saveDecodedBank;
if (m_AddressableBanks.ContainsKey(bank.name))
{
m_AddressableBanks.TryGetValue(bank.name, out bank);
}
else if (addToBankDictionary)
{
m_AddressableBanks.TryAdd(bank.name, bank);
}
if (bank.loadState == BankLoadState.Unloaded || bank.loadState == BankLoadState.WaitingForInitBankToLoad)
{
if (!InitBankLoaded && bank.name != "Init")
{
UnityEngine.Debug.Log($"Wwise Addressable Bank Manager: {bank.name} bank will be loaded after the init bank is loaded");
bank.loadState = BankLoadState.WaitingForInitBankToLoad;
return;
}
}
if (bank.loadState == BankLoadState.Loading)
{
bank.refCount += 1;
return;
}
if (bank.loadState == BankLoadState.Loaded)
{
bank.refCount += 1;
return;
}
bank.refCount += 1;
bank.loadState = BankLoadState.Loading;
if (bank.Data == null)
{
UnityEngine.Debug.LogError($"Wwise Addressable Bank Manager : {bank.name} could not be loaded - Bank reference not set");
m_AddressableBanks.TryRemove(bank.name, out _);
return;
}
AssetReferenceWwiseBankData bankData;
if (bank.Data.ContainsKey("SFX"))
{
UnityEngine.Debug.Log($"Wwise Addressable Bank Manager: Loading {bank.name} bank");
bankData = bank.Data["SFX"];
bank.currentLanguage = "SFX";
}
else
{
var currentLanguage = AkSoundEngine.GetCurrentLanguage();
if (bank.Data.ContainsKey(currentLanguage))
{
bankData = bank.Data[currentLanguage];
bank.currentLanguage = currentLanguage;
UnityEngine.Debug.Log($"Wwise Addressable Bank Manager: Loading {bank.name} - {currentLanguage}");
}
else
{
UnityEngine.Debug.LogError($"Wwise Addressable Bank Manager: {bank.name} could not be loaded in {currentLanguage} language ");
m_AddressableBanks.TryRemove(bank.name, out _);
return;
}
}
LoadBankAsync(bank, bankData);
}
public void LoadBankEditor(WwiseAddressableSoundBank bank, AssetReferenceWwiseBankData bankData)
{
var p = UnityEditor.AssetDatabase.GetAssetPath(bankData.editorAsset);
var loadedBank = UnityEditor.AssetDatabase.LoadAssetAtPath <WwiseSoundBankAsset>(p);
bank.eventNames = new HashSet <string>(loadedBank.eventNames);
var data = loadedBank.RawData;
bank.GCHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
var result = AkSoundEngine.LoadBankMemoryCopy(bank.GCHandle.AddrOfPinnedObject(), (uint)data.Length, out uint bankID);
if (result == AKRESULT.AK_Success)
{
bank.soundbankId = bankID;
}
else
{
bank.soundbankId = INVALID_SOUND_BANK_ID;
}
bank.GCHandle.Free();
string outFolder = UnityEngine.Application.persistentDataPath;
if (!Directory.Exists(outFolder))
{
Directory.CreateDirectory(outFolder);
}
string destinationDir;
if (bank.StreamingMedia != null)
{
foreach (var language in bank.StreamingMedia.Keys)
{
if (language == "SFX")
{
destinationDir = UnityEngine.Application.persistentDataPath;
}
else
{
destinationDir = Path.Combine(UnityEngine.Application.persistentDataPath, language);
}
if (!Directory.Exists(destinationDir))
{
Directory.CreateDirectory(destinationDir);
}
foreach (var streamedAsset in bank.StreamingMedia[language].media)
{
if (streamedAsset == null)
{
UnityEngine.Debug.LogError($"Wwise Addressable Bank Manager: Streaming media asset referenced in {bank.name} soundbank is null");
continue;
}
var mediaPath = UnityEditor.AssetDatabase.GetAssetPath(streamedAsset.editorAsset);
var media = UnityEditor.AssetDatabase.LoadAssetAtPath <WwiseStreamingMediaAsset>(mediaPath);
AkAssetUtilities.UpdateWwiseFileIfNecessary(destinationDir, media);
}
}
}
//Make sure the asset is cleared from memory
UnityEngine.Resources.UnloadUnusedAssets();
OnBankLoaded(bank);
}
