public ImporterRule(XmlNode node)
{
node.TryGetValue("Name", ref name);
node.TryGetValue("Enabled", ref enabled);
string typeString = "";
if (node.TryGetValue("Type", ref typeString))
{
type = (ImporterRulesTypes)Enum.Parse(typeof(ImporterRulesTypes), typeString);
}
string pathComparerString = "";
if (node.TryGetValue("PathComparer", ref pathComparerString))
{
pathComparer = (ImporterRulesPathComparer)Enum.Parse(typeof(ImporterRulesPathComparer), pathComparerString);
}
node.TryGetValue("Path", ref path);
node.TryGetValue("Pattern", ref pattern);
XmlNode propsNode = node["Props"];
InitSettings();
UpdateActiveSettings();
activeSettings.Load(propsNode);
}
public static bool ApplyFirstRule(ImporterRulesTypes assetType, string assetPath, AssetImporter assetImporter)
{
if (ignoreApplyFirstRule)
{
return(false);
}
if (rules == null)
{
Load();
}
List <ImporterRule> currentRules = rules.Where(r => r.enabled && r.type == assetType).ToList();
if (currentRules.Count == 0)
{
return(false);
}
foreach (ImporterRule rule in currentRules)
{
if (rule.CheckPath(assetPath))
{
rule.Apply(assetImporter, assetPath);
return(true);
}
}
return(false);
}
private static void TryApplyRule(string assetPath, AssetImporter assetImporter, ImporterRulesTypes type)
{
if (waitPaths.Contains(assetPath))
{
waitPaths.Remove(assetPath);
}
else if (ImporterRulesWindow.ApplyFirstRule(type, assetPath, assetImporter))
{
waitPaths.Add(assetPath);
AssetDatabase.ImportAsset(assetPath, ImportAssetOptions.ForceUpdate);
}
}
public void CopyFrom(ImporterRule rule)
{
name = rule.name;
path = rule.path;
pattern = rule.pattern;
pathComparer = rule.pathComparer;
type = rule.type;
audioSettings = rule.audioSettings;
fontSettings = rule.fontSettings;
modelSettings = rule.modelSettings;
movieSettings = rule.movieSettings;
textureSettings = rule.textureSettings;
UpdateActiveSettings();
}
public void LoadFromAsset(Object obj)
{
string assetPath = AssetDatabase.GetAssetPath(obj);
FileAttributes attr = File.GetAttributes(assetPath);
if ((attr & FileAttributes.Directory) == FileAttributes.Directory)
{
path = assetPath.Substring(7) + "/";
pathComparer = ImporterRulesPathComparer.startWith;
return;
}
AssetImporter importer = AssetImporter.GetAtPath(assetPath);
if (importer == null)
{
return;
}
if (importer is TextureImporter)
{
type = ImporterRulesTypes.texture;
}
else if (importer is ModelImporter)
{
type = ImporterRulesTypes.model;
}
else if (importer is MovieImporter)
{
type = ImporterRulesTypes.movie;
}
else if (importer is AudioImporter)
{
type = ImporterRulesTypes.audio;
}
else if (importer is TrueTypeFontImporter)
{
type = ImporterRulesTypes.trueTypeFont;
}
UpdateActiveSettings();
activeSettings.GetSettingsFromImporter(importer);
}
public void DrawEditor(bool useScroll = true)
{
name = EditorGUILayout.TextField("Name: ", name);
EditorGUI.BeginChangeCheck();
type = (ImporterRulesTypes)EditorGUILayout.EnumPopup("Type: ", type);
if (EditorGUI.EndChangeCheck())
{
UpdateActiveSettings();
}
pathComparer = (ImporterRulesPathComparer)EditorGUILayout.EnumPopup("Path comparer: ", pathComparer);
if (pathComparer == ImporterRulesPathComparer.contains || pathComparer == ImporterRulesPathComparer.startWith || pathComparer == ImporterRulesPathComparer.notContains)
{
GUILayout.BeginHorizontal();
path = EditorGUILayout.TextField("Path: ", path);
DrawPathBrowse();
GUILayout.EndHorizontal();
}
else if (pathComparer == ImporterRulesPathComparer.regex)
{
pattern = EditorGUILayout.TextField("Pattern: ", pattern);
}
EditorGUILayout.Space();
if (useScroll)
{
scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
}
activeSettings.DrawEditor();
if (useScroll)
{
EditorGUILayout.EndScrollView();
}
}
