private void IncludePlatformSpecificBundles(UnityEditor.BuildTarget target)
{
var wwisePlatform = AkAssetUtilities.GetWwisePlatformName(target);
var addressableSettings = AddressableAssetSettingsDefaultObject.Settings;
if (addressableSettings == null)
{
UnityEngine.Debug.LogWarningFormat("[Addressables] settings file not found.\nPlease go to Menu/Window/Asset Management/Addressables/Groups, then click 'Create Addressables Settings' button.");
return;
}
foreach (var group in addressableSettings.groups)
{
var include = true;
if (group.Name.Contains("WwiseData"))
{
if (!group.Name.Contains(wwisePlatform) && !group.name.Contains("AddressableSoundbanks"))
{
include = false;
}
var bundleSchema = group.GetSchema <BundledAssetGroupSchema>();
if (bundleSchema != null)
{
bundleSchema.IncludeInBuild = include;
}
}
}
}
internal static void RemoveBanksFromAddressableSoundbanks(HashSet <string> bankAssetsToRemove)
{
try
{
var foundBanks = AssetDatabase.FindAssets($"t:{typeof(WwiseAddressableSoundBank).Name}");
var updatedBanks = new List <string>();
foreach (var assetPath in bankAssetsToRemove)
{
string platform;
string language;
AkAssetUtilities.ParseAssetPath(assetPath, out platform, out language);
var assetGuid = AssetDatabase.AssetPathToGUID(assetPath);
foreach (var bankGuid in foundBanks)
{
var bankPath = AssetDatabase.GUIDToAssetPath(bankGuid);
var bank = AssetDatabase.LoadAssetAtPath <WwiseAddressableSoundBank>(bankPath);
if (bank.TryRemoveBank(platform, language, assetGuid))
{
EditorUtility.SetDirty(bank);
break;
}
}
}
}
finally
{
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
}
//Clear parsed soundbank info after updating assets (force reparse when new bnk and wem assets are added)
static string[] OnWillSaveAssets(string[] paths)
{
bool wwiseAssetsModified = false;
foreach (var item in paths)
{
if (Path.GetExtension(item) == ".bnk")
{
wwiseAssetsModified = true;
break;
}
else if (Path.GetExtension(item) == ".wem")
{
wwiseAssetsModified = true;
break;
}
}
if (wwiseAssetsModified)
{
AkAssetUtilities.ClearSoundbankInfo();
}
return(paths);
}
internal static void AddAssetsToAddressablesGroup(HashSet <string> assetsAdded, string groupName = "")
{
if (AddressableAssetSettingsDefaultObject.Settings == null)
{
AddressableAssetSettingsDefaultObject.Settings =
AddressableAssetSettings.Create(AddressableAssetSettingsDefaultObject.kDefaultConfigFolder,
AddressableAssetSettingsDefaultObject.kDefaultConfigAssetName, true, true);
}
var settings = AddressableAssetSettingsDefaultObject.Settings;
if (settings == null)
{
Debug.LogWarningFormat("[Addressables] settings file not found.\nPlease go to Menu/Window/Asset Management/Addressables/Groups, then click 'Create Addressables Settings' button.");
return;
}
List <AddressableAssetEntry> groupEntriesModified = new List <AddressableAssetEntry>();
var parseGroupNames = string.IsNullOrEmpty(groupName);
foreach (var assetPath in assetsAdded)
{
string guid = AssetDatabase.AssetPathToGUID(assetPath);
string platform;
string language;
AkAssetUtilities.ParseAssetPath(assetPath, out platform, out language);
if (parseGroupNames)
{
if (string.IsNullOrEmpty(platform))
{
Debug.LogError($"Wwise Addressables import : could not parse platform for {assetPath}.");
continue;
}
groupName = $"WwiseData_{platform}";
if (Path.GetFileName(assetPath) == "Init.bnk")
{
groupName = $"WwiseData_{platform}_InitBank";
}
}
AddressableAssetGroup group = GetOrAddGroup(settings, groupName);
var groupEntry = settings.CreateOrMoveEntry(guid, group);
if (groupEntry != null)
{
groupEntriesModified.Add(groupEntry);
}
}
if (groupEntriesModified.Count > 0)
{
settings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, groupEntriesModified, true);
AssetDatabase.SaveAssets();
}
}
public static WwiseAddressableSoundBank GetAddressableBankAsset(string name)
{
var assetPath = System.IO.Path.Combine(AkAssetUtilities.GetSoundbanksPath(), name + ".asset");
var asset = AssetDatabase.LoadAssetAtPath <WwiseAddressableSoundBank>(assetPath);
if (asset == null)
{
Debug.LogError($"Could not find addressable bank asset : {assetPath}");
}
return(asset);
}
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);
}
}
internal static void AddStreamedAssetsToBanks(HashSet <string> streamingAssetsAdded)
{
try
{
var updatedBanks = new List <string>();
foreach (var assetPath in streamingAssetsAdded)
{
string name = Path.GetFileNameWithoutExtension(assetPath);
string platform;
string language;
AkAddressablesEditorUtilities.ParseAssetPath(assetPath, out platform, out language);
var soundbankInfos = AkAddressablesEditorUtilities.ParsePlatformSoundbanksXML(platform, name);
var bankNames = soundbankInfos.eventToSoundBankMap[name];
foreach (var bankName in bankNames)
{
string bankAssetDir = Path.GetDirectoryName(assetPath);
string addressableBankAssetDir = AkAssetUtilities.GetSoundbanksPath();
string addressableBankAssetPath = System.IO.Path.Combine(addressableBankAssetDir, bankName + ".asset");
var bankAsset = AssetDatabase.LoadAssetAtPath <WwiseAddressableSoundBank>(addressableBankAssetPath);
if (bankAsset == null)
{
continue;
}
if (!string.IsNullOrEmpty(platform))
{
List <string> MediaIds = soundbankInfos[bankName][language].streamedFiles.Select(streamedFile => streamedFile.id).ToList();
bankAsset.UpdateLocalizationLanguages(platform, soundbankInfos[bankName].Keys.ToList());
bankAsset.SetStreamingMedia(platform, language, bankAssetDir, MediaIds);
EditorUtility.SetDirty(bankAsset);
}
}
}
}
finally
{
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
}
//Create the necessary subfolders and the metadata asset
public static void CreateMetadataAsset(string assetPath, HashSet <string> assetLabels, string groupName)
{
string soundbankPath = assetPath.Replace(AkAssetUtilities.GetSoundbanksPath(), "");
var splitBankPath = soundbankPath.Split('/');
AddressableMetadata metaDataAsset = ScriptableObject.CreateInstance <AddressableMetadata>();
metaDataAsset.labels = new List <string>(assetLabels);
metaDataAsset.groupName = groupName;
var rootPath = AkAddressablesEditorSettings.Instance.MetadataPath;
if (!Directory.Exists(Path.Combine(Application.dataPath, rootPath)))
{
UnityEditor.AssetDatabase.CreateFolder("Assets", rootPath);
}
for (int i = 1; i < splitBankPath.Length - 1; i++)
{
if (!Directory.Exists(Path.Combine(Application.dataPath, Path.Combine(rootPath, splitBankPath[i]))))
{
AssetDatabase.CreateFolder(Path.Combine("Assets", rootPath), splitBankPath[i]);
}
rootPath = Path.Combine(rootPath, splitBankPath[i]);
}
string assetMetadataPath = Path.Combine("Assets", rootPath, Path.GetFileNameWithoutExtension(assetPath) + ".asset");
AddressableMetadata oldAsset = AssetDatabase.LoadAssetAtPath <AddressableMetadata>(assetMetadataPath);
if (oldAsset)
{
if (!metaDataAsset.IsDifferent(oldAsset))
{
return;
}
}
UnityEditor.AssetDatabase.CreateAsset(metaDataAsset, assetMetadataPath);
}
public override void OnImportAsset(AssetImportContext ctx)
{
string assetName = Path.GetFileNameWithoutExtension(ctx.assetPath);
string platform;
string language;
AkAssetUtilities.ParseAssetPath(ctx.assetPath, out platform, out language);
if (platform == null)
{
return;
}
WwiseStreamingMediaAsset dataAsset = ScriptableObject.CreateInstance <WwiseStreamingMediaAsset>();
dataAsset.RawData = File.ReadAllBytes(Path.GetFullPath(ctx.assetPath));
byte[] hash = MD5.Create().ComputeHash(dataAsset.RawData);
dataAsset.hash = hash;
ctx.AddObjectToAsset(string.Format("WwiseSteamingMedia_{0}{1}_{2}", platform, language, assetName), dataAsset);
ctx.SetMainObject(dataAsset);
}
public override void OnImportAsset(AssetImportContext ctx)
{
string assetName = Path.GetFileNameWithoutExtension(ctx.assetPath);
string platform;
string language;
AkAssetUtilities.ParseAssetPath(ctx.assetPath, out platform, out language);
if (platform == null)
{
return;
}
var soundbankInfos = AkAssetUtilities.ParsePlatformSoundbanksXML(platform, assetName);
if (!soundbankInfos.ContainsKey(assetName))
{
Debug.LogWarning($"Could not properly parse soundbank at {ctx.assetPath} - skipping it.");
return;
}
WwiseSoundBankAsset dataAsset = ScriptableObject.CreateInstance <WwiseSoundBankAsset>();
dataAsset.RawData = File.ReadAllBytes(Path.GetFullPath(ctx.assetPath));
var eventNames = soundbankInfos[assetName][language].events;
if (language != "SFX" && soundbankInfos[assetName].ContainsKey("SFX"))
{
eventNames.AddRange(soundbankInfos[assetName]["SFX"].events);
}
dataAsset.eventNames = eventNames;
byte[] hash = MD5.Create().ComputeHash(dataAsset.RawData);
dataAsset.hash = hash;
ctx.AddObjectToAsset(string.Format("WwiseBank_{0}{1}_{2}", platform, language, assetName), dataAsset);
ctx.SetMainObject(dataAsset);
}
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);
}
public static AssetReferenceWwiseAddressableBank GetAddressableBankAssetReference(string name)
{
var assetPath = System.IO.Path.Combine(AkAssetUtilities.GetSoundbanksPath(), name + ".asset");
return(new AssetReferenceWwiseAddressableBank(AssetDatabase.AssetPathToGUID(assetPath)));
}
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);
}
