public void loadAllGameSoundBank(string lang = "")
    {
        string text = string.Concat(new string[]
        {
            Application.streamingAssetsPath,
            "/Audio/GeneratedSoundBanks/",
            AkBasePathGetter.GetPlatformName(),
            "/",
            lang
        });

        if (!Directory.Exists(text))
        {
            Debug.LogError(text + " does not exist!");
            return;
        }
        string[] files = Directory.GetFiles(text);
        string[] array = files;
        for (int i = 0; i < array.Length; i++)
        {
            string text2 = array[i];
            if (text2.EndsWith(".bnk"))
            {
                int    num   = text2.LastIndexOf("/");
                string text3 = text2.Substring(num + 1, text2.Length - num - 1);
                string name  = text3;
                AkBankManager.LoadBank(name, 0);
            }
        }
    }
    public static string GetPlatformBasePath()
    {
        string result = string.Empty;

        result = Path.Combine(AkBasePathGetter.GetFullSoundBankPath(), AkBasePathGetter.GetPlatformName());
        AkBasePathGetter.FixSlashes(ref result);
        return(result);
    }
    public void loadLanguageSoundBank(string filename)
    {
        string text = string.Concat(new string[]
        {
            Application.streamingAssetsPath,
            "/Audio/GeneratedSoundBanks/",
            AkBasePathGetter.GetPlatformName(),
            "/",
            this.language
        });

        AkBankManager.LoadBank(filename + ".bnk", 0);
    }
        public void OnBeforeSerialize()
        {
#if UNITY_EDITOR
            string wwisePlatform = AkBasePathGetter.GetPlatformName();
            if (m_dataPerPlatformList != null)
            {
                foreach (var entry in m_dataPerPlatformList)
                {
                    entry.LocalizedBankKeys             = entry.LocalizedBanks.Keys.ToArray();
                    entry.LocalizedBanksValues          = entry.LocalizedBanks.Values.ToArray();
                    entry.LocalizedStreamingMediaKeys   = entry.LocalizedStreamingMedia.Keys.ToArray();
                    entry.LocalizedStreamingMediaValues = new LocalizedStreamingMediaList();
                    entry.LocalizedStreamingMediaValues.Add(entry.LocalizedStreamingMedia.Values.ToList());

                    if (entry.WwisePlatform == wwisePlatform)
                    {
                        CurrentPlatformAssets = entry;
                    }
                }
            }
#endif
            loadState = BankLoadState.Unloaded;
        }
Esempio n. 5
0
        //Parse soundbank xml file to get a dict of the streaming wem files
        public static PlatformEntry ParsePlatformSoundbanksXML(string platformName, string newBankName)
        {
            if (platformName == null)
            {
                platformName = AkBasePathGetter.GetPlatformName();
            }

            if (!AkBasePathGetter.GetSoundBankPaths(platformName, out string sourceFolder, out string destinationFolder))
            {
                Debug.LogError($"Could not find containing folder for {newBankName} soundbank - platform: {platformName}. Check the Generated Soundbanks Path in the Unity Wwise project settings.");
                return(null);
            }

            var xmlFilename = Path.Combine(sourceFolder, "SoundbanksInfo.xml");

            if (!File.Exists(xmlFilename))
            {
                Debug.LogError($"Could not find SoundbanksInfo for {platformName} platform. Check the Generated Soundbanks Path in the Unity Wwise project settings.");
                return(null);
            }
            bool doParse = false;

            if (!soundbanksInfo.ContainsKey(platformName))
            {
                doParse = true;
            }
            else if (soundbanksInfo.ContainsKey(platformName) && !soundbanksInfo[platformName].ContainsKey(newBankName))
            {
                doParse = true;
            }
            else
            {
                var fileModifiedTime = System.IO.File.GetLastWriteTime(xmlFilename);
                if (fileModifiedTime.Ticks > soundbanksInfo[platformName].lastParseTime)
                {
                    doParse = true;
                }
            }

            if (doParse)
            {
                var soundBanks = new PlatformEntry();
                soundBanks.lastParseTime = DateTime.Now.Ticks;
                var doc = new System.Xml.XmlDocument();
                doc.Load(xmlFilename);

                var soundBanksRootNode = doc.GetElementsByTagName("SoundBanks");
                for (var i = 0; i < soundBanksRootNode.Count; i++)
                {
                    var soundBankNodes = soundBanksRootNode[i].SelectNodes("SoundBank");
                    for (var j = 0; j < soundBankNodes.Count; j++)
                    {
                        var bankName = soundBankNodes[j].SelectSingleNode("ShortName").InnerText;
                        var language = soundBankNodes[j].Attributes.GetNamedItem("Language").Value;

                        AddSoundBank(bankName, language, ref soundBanks);

                        if (bankName.Equals("Init"))
                        {
                            continue;
                        }

                        var includedEventsNode = soundBankNodes[j].SelectSingleNode("IncludedEvents");
                        if (includedEventsNode != null)
                        {
                            var eventNodes = includedEventsNode.SelectNodes("Event");
                            for (var e = 0; e < eventNodes.Count; e++)
                            {
                                soundBanks[bankName][language].events.Add(eventNodes[e].Attributes["Name"].Value);

                                var streamedFilesRootNode = eventNodes[e].SelectSingleNode("ReferencedStreamedFiles");
                                if (streamedFilesRootNode != null)
                                {
                                    var streamedFileNodes = streamedFilesRootNode.SelectNodes("File");
                                    if (streamedFileNodes.Count > 0)
                                    {
                                        for (var s = 0; s < streamedFileNodes.Count; s++)
                                        {
                                            var streamedFilelanguage = streamedFileNodes[s].Attributes.GetNamedItem("Language").Value;

                                            if (!soundBanks[bankName].ContainsKey(streamedFilelanguage))
                                            {
                                                AddSoundBank(bankName, streamedFilelanguage, ref soundBanks);
                                            }
                                            var streamedFile = new SoundBankStreamedFile
                                            {
                                                id   = streamedFileNodes[s].Attributes["Id"].Value,
                                                path = Path.GetFileName(streamedFileNodes[s].SelectSingleNode("Path").InnerText)
                                            };

                                            soundBanks[bankName][streamedFilelanguage].streamedFiles.Add(streamedFile);
                                            if (!soundBanks.eventToSoundBankMap.ContainsKey(streamedFile.id))
                                            {
                                                soundBanks.eventToSoundBankMap[streamedFile.id] = new List <string>();
                                            }
                                            soundBanks.eventToSoundBankMap[streamedFile.id].Add(bankName);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                soundbanksInfo[platformName] = soundBanks;
            }
            return(soundbanksInfo[platformName]);
        }
Esempio n. 6
0
 public static string GetWwisePlatformName(BuildTarget platform)
 {
     return(AkBasePathGetter.GetPlatformName());
 }