static AddressableAssetEntry CreateOrUpdateAddressableAssetEntry( AddressableAssetSettings settings, AddressableImportSettings importSettings, AddressableImportRule rule, string assetPath) { // Set group AddressableAssetGroup group; var groupName = rule.ParseGroupReplacement(assetPath); bool newGroup = false; if (!TryGetGroup(settings, groupName, out group)) { if (importSettings.allowGroupCreation) { //TODO Specify on editor which type to create. group = CreateAssetGroup <BundledAssetGroupSchema>(settings, groupName); newGroup = true; } else { Debug.LogErrorFormat("[AddressableImporter] Failed to find group {0} when importing {1}. Please check if the group exists, then reimport the asset.", rule.groupName, assetPath); return(null); } } // Set group settings from template if necessary if (rule.groupTemplate != null && (newGroup || rule.groupTemplateApplicationMode == GroupTemplateApplicationMode.AlwaysOverwriteGroupSettings)) { rule.groupTemplate.ApplyToAddressableAssetGroup(group); } var guid = AssetDatabase.AssetPathToGUID(assetPath); var entry = settings.CreateOrMoveEntry(guid, group); if (entry != null) { // Apply address replacement if address is empty or path. if (string.IsNullOrEmpty(entry.address) || entry.address.StartsWith("Assets/") || rule.simplified || !string.IsNullOrWhiteSpace(rule.addressReplacement)) { entry.address = rule.ParseAddressReplacement(assetPath); } // Add labels if (rule.LabelMode == LabelWriteMode.Replace) { entry.labels.Clear(); } foreach (var label in rule.labels) { entry.labels.Add(label); } } return(entry); }
public void Dispose() { _settings = null; if (_importRulesContainer) { Object.DestroyImmediate(_importRulesContainer); _importRulesContainer = null; } }
/// <summary> /// Creates a new AddressableImportSettings and add it to the EditorBuildSettings. /// </summary> public void Create(AddressableImportSettings settings) { settings = CreateInstance <AddressableImportSettings>(); AssetDatabase.CreateAsset(settings, "Assets/AddressableAssetsData/AddressableImportSettings.asset"); AssetDatabase.SaveAssets(); EditorBuildSettings.AddConfigObject("AddressableImportSettings", settings, true); settings.rules = new List <AddressableImportRule>(); }
public AddressableResult GetOrCreate(out AddressableImportSettings settingsFile) { if (!TryGet(out settingsFile)) { Debug.Log("Creating AddressableImportSettings"); Create(settingsFile); return(AddressableResult.Created); } return(AddressableResult.Loaded); }
private void OnEnable() { _target = target as AddressableImportSettings; _drawer = _drawer ?? new AddressableImporterOdinHandler(); if (_target == null) { return; } _drawer.Initialize(_target); _methods = AddressableImporterMethodHandler.CollectValidMembers(_target.GetType()); }
static bool ApplyImportRule( string assetPath, string movedFromAssetPath, AddressableAssetSettings settings, AddressableImportSettings importSettings) { var dirty = false; if (TryGetMatchedRule(assetPath, importSettings, out var matchedRule)) { if (matchedRule.IgnoreDirectory && Directory.Exists(assetPath) && ((File.GetAttributes(assetPath) & FileAttributes.Directory) == FileAttributes.Directory)) { return(dirty); } // Apply the matched rule. var entry = CreateOrUpdateAddressableAssetEntry(settings, importSettings, matchedRule, assetPath); if (entry != null) { if (matchedRule.HasLabel) { Debug.LogFormat("[AddressableImporter] Entry created/updated for {0} with address {1} and labels {2}", assetPath, entry.address, string.Join(", ", entry.labels)); } else { Debug.LogFormat("[AddressableImporter] Entry created/updated for {0} with address {1}", assetPath, entry.address); } } dirty = true; } else { // If assetPath doesn't match any of the rules, try to remove the entry. // But only if movedFromAssetPath has the matched rule, because the importer should not remove any unmanaged entries. if (!string.IsNullOrEmpty(movedFromAssetPath) && TryGetMatchedRule(movedFromAssetPath, importSettings, out matchedRule)) { var guid = AssetDatabase.AssetPathToGUID(assetPath); if (settings.RemoveAssetEntry(guid)) { dirty = true; Debug.LogFormat("[AddressableImporter] Entry removed for {0}", assetPath); } } } return(dirty); }
private void OnEnable() { _target = target as AddressableImportSettings; if (_target == null) { return; } #if ODIN_INSPECTOR _propertyTree = PropertyTree.Create(_target); #endif _methods = AddressableImporterMethodHandler.CollectValidMembers(_target.GetType()); }
public void Initialize(AddressableImportSettings importSettings) { _importSettings = importSettings; _drawerTree = PropertyTree.Create(this); _filters = new List <Func <AddressableImportRule, string, bool> >() { ValidateAddressableGroupName, ValidateRulePath, ValidateLabelsPath, }; _drawerTree.OnPropertyValueChanged += (property, index) => EditorUtility.SetDirty(_importSettings); }
static AddressableAssetEntry CreateOrUpdateAddressableAssetEntry( AddressableAssetSettings settings, string path, AddressableImportRule rule, AddressableImportSettings importSettings) { AddressableAssetGroup group; string groupName = importSettings.ParseGroupName(rule, path); if (TryGetGroup(settings, groupName, out group) == GroupSearchResult.NotFound) { if (importSettings.allowGroupCreation) { group = CreateAssetGroup <BundledAssetGroupSchema>(settings, groupName); } else { Debug.LogErrorFormat("[AddressableImporter] Failed to find group {0} when importing {1}. Please check the group exists, then reimport the asset.", groupName, path); return(null); } } var assetEntry = CreateAddressableAsset(settings, path, group); if (rule.Simplify && (string.IsNullOrEmpty(assetEntry.address) || assetEntry.address.StartsWith("Assets/"))) { SimplifyAddresByPath(assetEntry, path); } // Remove Labels assetEntry.labels.Clear(); // Add labels foreach (var label in rule.Labels) { if (!assetEntry.labels.Contains(label)) { assetEntry.labels.Add(label); } } return(assetEntry); }
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths) { var settings = AddressableAssetSettingsDefaultObject.Settings; AddressableImportSettings scriptable = ScriptableObject.CreateInstance <AddressableImportSettings>(); AddressableImportSettings importSettings; scriptable.GetOrCreate(out importSettings); if (importSettings.rules == null || importSettings.rules.Count == 0) { return; } // Handling imported assets var entriesAdded = new List <AddressableAssetEntry>(); foreach (string path in importedAssets) { foreach (var rule in importSettings.rules) { if (rule.Match(path)) { var entry = CreateOrUpdateAddressableAssetEntry(settings, path, rule, importSettings); if (entry != null) { entriesAdded.Add(entry); } } } } if (entriesAdded.Count > 0) { settings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entriesAdded, true); Debug.Log($"AddressablesImporter: {entriesAdded.Count} addressable assets processed."); AssetDatabase.SaveAssets(); } if (importSettings.removeEmtpyGroups) { settings.groups.RemoveAll(_ => _.entries.Count == 0); } }
static bool TryGetMatchedRule( string assetPath, AddressableImportSettings importSettings, out AddressableImportRule rule) { foreach (var r in importSettings.rules) { if (!r.Match(assetPath)) { continue; } rule = r; return(true); } rule = null; return(false); }
/// <summary> /// Attempts to load the current import settings from EditorBuildSettings. If not found, attempts to load from a fixed file path. /// </summary> public bool TryGet(out AddressableImportSettings settings) { AddressableImportSettings settingsFile; if (EditorBuildSettings.TryGetConfigObject("AddressableImportSettings", out settingsFile)) { settings = settingsFile; return(true); } if (settingsFile != null) { settings = AssetDatabase.LoadAssetAtPath <AddressableImportSettings>("Assets/AddressableAssetsData/AddressableImportSettings.asset"); return(settings != null); } settings = default; return(false); }
private AddressableImporterFilterOdinHandler CreateDrawer(AddressableImportSettings settings) { _importRulesContainer = ScriptableObject.CreateInstance <AddressableImporterFilterOdinHandler>(); _importRulesContainer.Initialize(settings); return(_importRulesContainer); }
public void Initialize(AddressableImportSettings target) { _settings = target; _importRulesContainer = CreateDrawer(_settings); }