Exemple #1
0
        //Called when improting .bnk and .wem files. Will attempt to find an existing metadata object in the project and load it.
        public static bool GetMetadata(string assetName, string platformName, string languageName, ref AddressableMetadata metaData)
        {
            AddressableMetadata asset = FindMetadataAsset(assetName, platformName, languageName);

            if (asset)
            {
                metaData = asset;
                return(true);
            }
            return(false);
        }
Exemple #2
0
        //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);
        }
        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;
                AkAddressablesEditorUtilities.ParseAssetPath(assetPath, out platform, out language);
                AddressableMetadata assetMetadata = ScriptableObject.CreateInstance <AddressableMetadata>();

                if (parseGroupNames)
                {
                    if (string.IsNullOrEmpty(platform))
                    {
                        Debug.LogError($"Wwise Addressables import : could not parse platform for {assetPath}. It will not be made addressable.");
                        continue;
                    }
                    if (GetAssetMetadataDelegate != null)
                    {
                        if (!GetAssetMetadataDelegate.Invoke(Path.GetFileName(assetPath), platform, language, ref assetMetadata))
                        {
                            // If we can't find a metadata asset use the default group name
                            assetMetadata.groupName = GetDefaultAddressableGroup(Path.GetFileName(assetPath), platform);
                        }
                    }
                    else
                    {
                        assetMetadata.groupName = GetDefaultAddressableGroup(Path.GetFileName(assetPath), platform);
                    }
                }
                else
                {
                    assetMetadata.groupName = groupName;
                }

                AddressableAssetGroup group = GetOrAddGroup(settings, assetMetadata.groupName);
                var groupEntry = settings.CreateOrMoveEntry(guid, group);
                if (groupEntry != null)
                {
                    if (assetMetadata.labels.Count > 0)
                    {
                        foreach (string label in assetMetadata.labels)
                        {
                            groupEntry.labels.Add(label);
                        }
                    }
                    groupEntriesModified.Add(groupEntry);
                }
            }

            if (groupEntriesModified.Count > 0)
            {
                settings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, groupEntriesModified, true);
                AssetDatabase.SaveAssets();
            }
        }
Exemple #4
0
 public bool IsDifferent(AddressableMetadata other)
 {
     return(other.groupName != groupName || other.labels != labels);
 }