private bool ValidateMatchType(AddressableImportRule rule, string filter)
{
var matchTypeName = matchTypeNames[(int)rule.matchType];
var result = matchTypeName.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0;
return(result);
}
public void ParseGroupReplacementTest()
{
AddressableImportRule rule = new AddressableImportRule();
// Test empty path
rule.matchType = AddressableImportRuleMatchType.Wildcard;
rule.path = "";
rule.groupName = "somegroup";
Assert.IsNull(rule.ParseGroupReplacement("Assets/Sprites/cat/cat.png"));
rule.path = " ";
rule.groupName = "somegroup";
Assert.IsNull(rule.ParseGroupReplacement("Assets/Sprites/cat/cat.png"));
// Test empy groupName
rule.matchType = AddressableImportRuleMatchType.Wildcard;
rule.path = @"Assets/Sprites/*/*.png";
rule.groupName = "";
Assert.IsNull(rule.ParseGroupReplacement("Assets/Sprites/cat/cat.png"));
rule.path = "Assets/Sprites/*/*.png";
rule.groupName = " ";
Assert.IsNull(rule.ParseGroupReplacement("Assets/Sprites/cat/cat.png"));
// Test static groupName
rule.matchType = AddressableImportRuleMatchType.Wildcard;
rule.path = "Assets/Sprites/*/*.png";
rule.groupName = "group-a";
Assert.AreEqual("group-a", rule.ParseGroupReplacement("Assets/Sprites/cat/cat.png"));
// Test wildcard + path elements
rule.matchType = AddressableImportRuleMatchType.Wildcard;
rule.path = "Assets/Sprites/*/*.png";
rule.groupName = "${PATH[0]}";
Assert.AreEqual("Assets", rule.ParseGroupReplacement("Assets/Sprites/cat/cat.png"));
rule.groupName = "${PATH[1]}";
Assert.AreEqual("Sprites", rule.ParseGroupReplacement("Assets/Sprites/cat/cat.png"));
rule.groupName = "${PATH[-1]}";
Assert.AreEqual("cat", rule.ParseGroupReplacement("Assets/Sprites/cat/cat.png"));
rule.groupName = "${PATH[0]}:${PATH[-1]}-group";
Assert.AreEqual("Assets:cat-group", rule.ParseGroupReplacement("Assets/Sprites/cat/cat.png"));
// Test regex + path elements
rule.matchType = AddressableImportRuleMatchType.Regex;
rule.path = @"Assets/Sprites/(.*)/(.*)\.png";
rule.groupName = "${PATH[0]}";
Assert.AreEqual("Assets", rule.ParseGroupReplacement("Assets/Sprites/cat/cat.png"));
rule.groupName = "${PATH[1]}";
Assert.AreEqual("Sprites", rule.ParseGroupReplacement("Assets/Sprites/cat/cat.png"));
rule.groupName = "${PATH[-1]}";
Assert.AreEqual("cat", rule.ParseGroupReplacement("Assets/Sprites/cat/cat.png"));
rule.groupName = "${PATH[0]}:${PATH[-1]}-group";
Assert.AreEqual("Assets:cat-group", rule.ParseGroupReplacement("Assets/Sprites/cat/cat.png"));
// Test regex + unnamed groups
rule.matchType = AddressableImportRuleMatchType.Regex;
rule.path = @"Assets/Sprites/(.*)/(.*)\.png";
rule.groupName = "${PATH[0]}:$1-$2";
Assert.AreEqual("Assets:cat-foo", rule.ParseGroupReplacement("Assets/Sprites/cat/foo.png"));
// Test regex + named groups
rule.matchType = AddressableImportRuleMatchType.Regex;
rule.path = @"Assets/Sprites/(?<category>.*)/(?<asset>.*)\.png";
rule.groupName = "${PATH[0]}:${category}-${asset}";
Assert.AreEqual("Assets:cat-foo", rule.ParseGroupReplacement("Assets/Sprites/cat/foo.png"));
}
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 MatchRegexTest()
{
AddressableImportRule rule = new AddressableImportRule();
rule.matchType = AddressableImportRuleMatchType.Regex;
rule.path = @"Assets/Sprites/.*/.*\.png";
Assert.IsTrue(rule.Match("Assets/Sprites/cat/cat.png"));
Assert.IsFalse(rule.Match("Assets/Sprites/cat/cat.jpg"));
}
private bool ValidateLabelsPath(AddressableImportRule rule, string filter)
{
var labels = rule.labelRefs
.Select(x => x.labelString)
.Concat(rule.dynamicLabels);
var result = labels.Any(x => x.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0);
return(result);
}
private bool ValidateGroupTemplate(AddressableImportRule rule, string filter)
{
var template = rule.groupTemplate;
if (!template)
{
return(string.IsNullOrEmpty(filter));
}
var result = template.Name.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0 ||
template.Description.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0;
return(result);
}
public bool IsMatch(AddressableImportRule rule, string filter)
{
for (var i = 0; i < _filters.Count; i++)
{
var filterRule = _filters[i];
var result = filterRule(rule, filter);
if (result)
{
return(true);
}
}
return(false);
}
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 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);
}
public void AddressSimplifyTest()
{
AddressableImportRule rule = new AddressableImportRule();
// Test wildcard + simplify
rule.matchType = AddressableImportRuleMatchType.Wildcard;
rule.path = "Assets/Sprites/*/*.png";
rule.simplified = true;
Assert.AreEqual("cat", rule.ParseAddressReplacement("Assets/Sprites/cat/cat.png"));
// Test regex + simplify
rule.matchType = AddressableImportRuleMatchType.Regex;
rule.path = @"Assets/Sprites/(.*)/(.*)\.png";
rule.simplified = true;
Assert.AreEqual("cat", rule.ParseAddressReplacement("Assets/Sprites/cat/cat.png"));
// Test simplify + non empty address replacement
rule.matchType = AddressableImportRuleMatchType.Regex;
rule.addressReplacement = "somevalue";
rule.path = @"Assets/Sprites/(.*)/(.*)\.png";
rule.simplified = true;
Assert.AreEqual("cat", rule.ParseAddressReplacement("Assets/Sprites/cat/cat.png"));
}
public void ParseAddressReplacementTest()
{
AddressableImportRule rule = new AddressableImportRule();
// Test empty path
rule.matchType = AddressableImportRuleMatchType.Regex;
rule.path = "";
Assert.AreEqual("Assets/Sprites/cat/cat.png", rule.ParseAddressReplacement("Assets/Sprites/cat/cat.png"));
rule.path = " ";
Assert.AreEqual("Assets/Sprites/cat/cat.png", rule.ParseAddressReplacement("Assets/Sprites/cat/cat.png"));
// Test empty address replacement
rule.matchType = AddressableImportRuleMatchType.Regex;
rule.path = @"Assets/Sprites/(.*)/(.*)\.png";
rule.addressReplacement = "";
Assert.AreEqual("Assets/Sprites/cat/cat.png", rule.ParseAddressReplacement("Assets/Sprites/cat/cat.png"));
rule.addressReplacement = " ";
Assert.AreEqual("Assets/Sprites/cat/cat.png", rule.ParseAddressReplacement("Assets/Sprites/cat/cat.png"));
// Test regex + path elements
rule.matchType = AddressableImportRuleMatchType.Regex;
rule.path = @"Assets/Sprites/(.*)/(.*)\.png";
rule.addressReplacement = "${PATH[0]}";
Assert.AreEqual("Assets", rule.ParseAddressReplacement("Assets/Sprites/cat/cat.png"));
rule.addressReplacement = "${PATH[1]}";
Assert.AreEqual("Sprites", rule.ParseAddressReplacement("Assets/Sprites/cat/cat.png"));
rule.addressReplacement = "${PATH[-1]}";
Assert.AreEqual("cat", rule.ParseAddressReplacement("Assets/Sprites/cat/cat.png"));
rule.addressReplacement = "${PATH[0]}:${PATH[-1]}-element";
Assert.AreEqual("Assets:cat-element", rule.ParseAddressReplacement("Assets/Sprites/cat/cat.png"));
// Test regex + unnamed groups
rule.matchType = AddressableImportRuleMatchType.Regex;
rule.path = @"Assets/Sprites/(.*)/(.*)\.png";
rule.addressReplacement = "${PATH[0]}:$1-$2";
Assert.AreEqual("Assets:cat-foo", rule.ParseAddressReplacement("Assets/Sprites/cat/foo.png"));
// Test regex + named groups
rule.matchType = AddressableImportRuleMatchType.Regex;
rule.path = @"Assets/Sprites/(?<category>.*)/(?<asset>.*)\.png";
rule.addressReplacement = "${PATH[0]}:${category}-${asset}";
Assert.AreEqual("Assets:cat-foo", rule.ParseAddressReplacement("Assets/Sprites/cat/foo.png"));
}
public void MatchWildcardTest()
{
AddressableImportRule rule = new AddressableImportRule();
rule.matchType = AddressableImportRuleMatchType.Wildcard;
// Raw path
rule.path = "Assets/Sprites/";
Assert.IsTrue(rule.Match("Assets/Sprites/cat/cat.png"));
Assert.IsFalse(rule.Match("Assets/Fbx/cat/cat.fbx"));
// '*' wildcard
rule.path = "Assets/Sprites/*/*.png";
Assert.IsTrue(rule.Match("Assets/Sprites/cat/cat.png"));
Assert.IsFalse(rule.Match("Assets/Sprites/cat/cat.jpg"));
// '?' wildcard
rule.path = "Assets/Sprites/*/???.png";
Assert.IsTrue(rule.Match("Assets/Sprites/cat/cat.png"));
Assert.IsFalse(rule.Match("Assets/Sprites/cat/bird.png"));
// rule.groupName = "";
// rule.LabelMode = LabelWriteMode.Add;
// rule.simplified = true;
// rule.addressReplacement = "";
}
private bool ValidateRule(AddressableImportRule rule, string filter)
{
return(string.IsNullOrEmpty(filter) || _filters.Any(x => x(rule, filter)));
}
private bool ValidateRulePath(AddressableImportRule rule, string filter)
{
var result = rule.path.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0;
return(result);
}
private bool ValidateAddressReplacement(AddressableImportRule rule, string filter)
{
var result = rule.addressReplacement.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0;
return(result);
}
private void CustomRemoveElementFunction(AddressableImportRule item)
{
var index = rules.IndexOf(item);
CustomRemoveIndexFunction(index);
}
private bool ValidateLabelsPath(AddressableImportRule rule, string filter)
{
return(rule.labels.Any(x => x.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0));
}
private bool ValidateAddressableGroupName(AddressableImportRule rule, string filter)
{
return(rule.groupName.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0);
}
/// <summary>
/// Gets a group name based on Rule's target group name and provided path
/// </summary>
public string ParseGroupName(AddressableImportRule rule, string path)
{
return(rule.ParsePath(rule.TargetGroupName, path));
}
