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);
}
