public static IEnumerable <float> GatherAssetRules(List <AssetRule> _assetRules, List <string> _assetRuleNames)
{
int progress = 0;
string[] foundAssets = AssetDatabase.FindAssets("", new[] { AssetAuditorPreferences.ProxyAssetsDirectory });
// get all assets in the proxyassets folder
foreach (string asset in foundAssets)
{
string guidToAssetPath = AssetDatabase.GUIDToAssetPath(asset);
AssetImporter assetImporter = AssetImporter.GetAtPath(guidToAssetPath);
AssetRule ar = new AssetRule();
ar = JsonUtility.FromJson <AssetRule>(assetImporter.userData);
_assetRules.Add(ar);
progress++;
yield return(progress / (float)foundAssets.Length);
}
_assetRuleNames.Clear();
foreach (AssetRule assetRule in _assetRules)
{
_assetRuleNames.Add(assetRule.RuleName);
}
yield return(1f);
}
public static void CheckConfig(hwmAddressablesSystemConfig config)
{
for (int iGroup = 0; iGroup < config.GroupRules.Length; iGroup++)
{
GroupRule iterGroupRule = config.GroupRules[iGroup];
if (string.IsNullOrWhiteSpace(iterGroupRule.GroupName))
{
Debug.LogError(string.Format("Group-{0}的GroupName为空", iterGroupRule.GroupName));
}
for (int iAsset = 0; iAsset < iterGroupRule.AssetRules.Length; iAsset++)
{
AssetRule iterAssetRule = iterGroupRule.AssetRules[iAsset];
if (!(iterAssetRule.Path.StartsWith("Assets") &&
iterAssetRule.Path.EndsWith("/")))
{
Debug.LogError(string.Format("Group-{0}({1})的AssetRule-{2}的Path不是\"Assets*/\"格式", iGroup, iterGroupRule.GroupName, iAsset));
}
for (int iExtension = 0; iExtension < iterAssetRule.ExtensionFilters.Count; iExtension++)
{
string iterExtension = iterAssetRule.ExtensionFilters[iExtension];
if (!iterExtension.StartsWith("."))
{
Debug.LogError(string.Format("Group-{0}({1})的AssetRule-{2}的ExtensionFilters-{3}({4})不是\".*/\"格式", iGroup, iterGroupRule.GroupName, iAsset, iExtension, iterExtension));
}
}
}
}
Debug.Log("Check config finish");
}
private void DrawTextureSettings(AssetRule assetRule)
{
GUILayout.Space(20);
GUILayout.Label(" TEXTURE SETTINGS ");
GUILayout.Space(20);
GetValidPlatforms();
// mip maps
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Generate Mip Maps");
assetRule.settings.textureSettings.mipmapEnabled = EditorGUILayout.Toggle(assetRule.settings.textureSettings.mipmapEnabled);
EditorGUILayout.EndHorizontal();
//read write enabled
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Read/Write Enabled");
assetRule.settings.textureSettings.readable = EditorGUILayout.Toggle(assetRule.settings.textureSettings.readable);
EditorGUILayout.EndHorizontal();
// per platform settings
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Max Texture Size");
assetRule.settings.textureSettings.maxTextureSize =
EditorGUILayout.IntPopup(assetRule.settings.textureSettings.maxTextureSize, sizeStrings, sizes);
EditorGUILayout.EndHorizontal();
}
/// <summary>
/// 当前目录查找，然后往上递归
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
private AssetRule SearchRecursive(string path)
{
foreach (var findAsset in AssetDatabase.FindAssets("t:AssetRule", new[] { Path.GetDirectoryName(path) }))
{
var p = Path.GetDirectoryName(AssetDatabase.GUIDToAssetPath(findAsset));
if (p == Path.GetDirectoryName(path))
{
string setName = string.Empty;
AssetRule rule = AssetDatabase.LoadAssetAtPath <AssetRule>(AssetDatabase.GUIDToAssetPath(findAsset));
if (rule != null && rule.IsMatch(assetImporter, out setName))
{
//Debug.LogWarning("Find:" + rule + " " + setName);
return(rule);
}
}
}
path = Directory.GetParent(path).FullName;
path = path.Replace('\\', '/');
path = path.Remove(0, Application.dataPath.Length);
path = path.Insert(0, "Assets");
if (path != "Assets")
{
return(SearchRecursive(path));
}
return(null);
}
public static bool RuleExists(AssetRule assetRule)
{
if (!AssetDatabase.IsValidFolder(AssetAuditorPreferences.ProxyAssetsDirectory))
{
string folder = AssetAuditorPreferences.ProxyAssetsDirectory.Split(Path.DirectorySeparatorChar).Last();
string dir = AssetAuditorPreferences.ProxyAssetsDirectory.Substring(0,
AssetAuditorPreferences.ProxyAssetsDirectory.Length - folder.Length);
AssetDatabase.CreateFolder(dir, folder);
}
foreach (string asset in AssetDatabase.FindAssets("", new[] { AssetAuditorPreferences.ProxyAssetsDirectory }))
{
string guidToAssetPath = AssetDatabase.GUIDToAssetPath(asset);
AssetImporter assetImporter = AssetImporter.GetAtPath(guidToAssetPath);
AssetRule ar = new AssetRule();
ar = JsonUtility.FromJson <AssetRule>(assetImporter.userData);
if (ar.RuleName == assetRule.RuleName && ar.WildCard == assetRule.WildCard &&
ar.WildCardMatchType == assetRule.WildCardMatchType)
{
return(true);
}
}
return(false);
}
public static void CreateAssetRule()
{
AssetRule newRule = AssetRule.CreateAssetRule();
string selectionPath = "Assets";
foreach (Object obj in Selection.GetFiltered(typeof(Object), SelectionMode.Assets))
{
selectionPath = AssetDatabase.GetAssetPath(obj);
if (File.Exists(selectionPath))
{
selectionPath = Path.GetDirectoryName(selectionPath);
}
break;
}
string newRuleFileName = AssetDatabase.GenerateUniqueAssetPath(Path.Combine(selectionPath, "NewAssetRule.asset"));
newRuleFileName = newRuleFileName.Replace("\\", "/");
AssetDatabase.CreateAsset(newRule, newRuleFileName);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
EditorUtility.FocusProjectWindow();
Selection.activeObject = newRule;
}
public static AssetRule CreateAssetRule()
{
var assetRule = AssetRule.CreateInstance <AssetRule>();
assetRule.ApplyDefaults();
return(assetRule);
}
public static AssetRule CreateAssetRule()
{
AssetRule assetRule = AssetRule.CreateInstance <AssetRule>();
assetRule.Init();
return(assetRule);
}
private void DrawMeshSettings(AssetRule assetRule)
{
GUILayout.Space(20);
GUILayout.Label("MESH SETTINGS ");
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Change Readable Settings");
assetRule.settings.meshSettings.changeReadableSettings = EditorGUILayout.Toggle(assetRule.settings.meshSettings.changeReadableSettings);
EditorGUILayout.EndHorizontal();
if (assetRule.settings.meshSettings.changeReadableSettings)
{
// read write enabled
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Read/Write Enabled");
assetRule.settings.meshSettings.readWriteEnabled = EditorGUILayout.Toggle(assetRule.settings.meshSettings.readWriteEnabled);
EditorGUILayout.EndHorizontal();
}
// optimise mesh
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Optimise Mesh");
assetRule.settings.meshSettings.optimiseMesh = EditorGUILayout.Toggle(assetRule.settings.meshSettings.optimiseMesh);
EditorGUILayout.EndHorizontal();
// optimise mesh
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Blend Shapes");
assetRule.settings.meshSettings.ImportBlendShapes = EditorGUILayout.Toggle(assetRule.settings.meshSettings.ImportBlendShapes);
EditorGUILayout.EndHorizontal();
// optimise mesh
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Import Materials");
assetRule.settings.meshSettings.importMaterials = EditorGUILayout.Toggle(assetRule.settings.meshSettings.importMaterials);
EditorGUILayout.EndHorizontal();
// optimise mesh
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Import Nomals");
assetRule.settings.meshSettings.normalImportMode = (ModelImporterNormals)EditorGUILayout.EnumPopup(assetRule.settings.meshSettings.normalImportMode);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Animation Type");
assetRule.settings.meshSettings.animationType = (ModelImporterAnimationType)EditorGUILayout.EnumPopup(assetRule.settings.meshSettings.animationType);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Mesh Compression");
assetRule.settings.meshSettings.meshCompression = (ModelImporterMeshCompression)EditorGUILayout.EnumPopup(assetRule.settings.meshSettings.meshCompression);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Import Tangents");
assetRule.settings.meshSettings.importTangents = (ModelImporterTangents)EditorGUILayout.EnumPopup(assetRule.settings.meshSettings.importTangents);
EditorGUILayout.EndHorizontal();
}
private void OnPreprocessModel()
{
AssetRule rule = FindAssetRule(assetImporter.assetPath);
if (rule == null)
{
return;
}
rule.ApplySettings(assetImporter);
}
private void OnPreprocessModel()
{
AssetRule rule = FindRuleForAsset(assetImporter.assetPath);
if (rule == null)
{
Debug.Log("No asset rules found for asset");
return;
}
rule.ApplySettings(assetImporter);
}
public static void WriteUserData(string path, AssetRule assetRule)
{
AssetImporter assetImporter = AssetImporter.GetAtPath(path);
assetRule.AssetGuid = AssetDatabase.AssetPathToGUID(assetImporter.assetPath);
assetImporter.userData = JsonUtility.ToJson(assetRule);
EditorUtility.SetDirty(assetImporter);
AssetDatabase.WriteImportSettingsIfDirty(path);
AssetDatabase.SaveAssets();
}
public static void CreateProxyTexture(AssetRule newRule, ref string currentAsset)
{
string textureProxy = AssetAuditorPreferences.ProxyTexturePath;
string ext = textureProxy.Substring(textureProxy.LastIndexOf('.'));
string newAssetPath = AssetAuditorPreferences.ProxyAssetsDirectory + Path.DirectorySeparatorChar + newRule.RuleName + ext;
if (!AssetDatabase.CopyAsset(textureProxy, newAssetPath))
{
Debug.LogWarning("Failed to copy proxy asset from " + textureProxy);
return;
}
AssetDatabase.ImportAsset(newAssetPath);
WriteUserData(newAssetPath, newRule, ref currentAsset);
}
private void OnPreprocessModel()
{
var setting = LBootEditor.PipelineSettings.Load();
if (setting != null && !setting.ImportPathWatches.Any(x => assetImporter.assetPath.Contains(x)))
{
return;
}
AssetRule rule = FindRuleForAsset(assetImporter.assetPath, assetImporter);
if (rule == null)
{
// LogUtil.Debug("No asset rules found for asset");
return;
}
rule.ApplySettings(assetImporter);
}
public override void OnInspectorGUI()
{
m_CurRule = (AssetRule)target;
DrawAddBtn();
string[] names = GetNames();
if (names != null && names.Length > 0)
{
GUILayout.Space(20);
m_SelectedID = EditorGUILayout.Popup("Sets", m_SelectedID, names);
}
DrawDelete();
DrawSelect();
serializedObject.ApplyModifiedProperties();
}
public static IEnumerable <float> FixAll(AssetAuditTreeView treeView, AssetRule assetRule)
{
List <AssetAuditTreeElement> list = new List <AssetAuditTreeElement>();
TreeElementUtility.TreeToList(treeView.treeModel.root, list);
float progress = 0f;
foreach (AssetAuditTreeElement assetAuditTreeElement in list)
{
if (assetAuditTreeElement.isAsset && !assetAuditTreeElement.conforms)
{
FixRule(assetAuditTreeElement, assetRule);
}
progress += 1f;
yield return(progress / list.Count);
}
}
public static void UpdateAffectedAssets(AssetRule assetRule)
{
foundAssets = new List <string>();
switch (assetRule.WildCardMatchType)
{
case WildCardMatchType.NameContains:
ClearQueue();
AddEnumerator(DoNameContainsSearch(foundAssets, assetRule));
break;
case WildCardMatchType.Regex:
ClearQueue();
AddEnumerator(DoRegexNameSearch(foundAssets, assetRule));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private static void GenerateWithGroupRule(AddressableAssetSettings settings, GenerateSetting generateSetting, GroupRule groupRule)
{
AddressableAssetGroup oldGroup = settings.FindGroup(groupRule.GroupName);
AddressableAssetGroup group;
if (generateSetting.RecreateGroup)
{
if (oldGroup)
{
settings.RemoveGroup(oldGroup);
oldGroup = null;
}
group = settings.CreateGroup(groupRule.GroupName, false, false, true, groupRule.SchemasToCopy);
}
else
{
if (oldGroup)
{
group = oldGroup;
}
else
{
group = settings.CreateGroup(groupRule.GroupName, false, false, true, groupRule.SchemasToCopy);
}
}
if (generateSetting.ApplyAssetRule)
{
for (int iAssetRule = 0; iAssetRule < groupRule.AssetRules.Length; iAssetRule++)
{
AssetRule iterAssetRule = groupRule.AssetRules[iAssetRule];
GenerateWithAssetRule(settings, generateSetting, group, groupRule, iterAssetRule);
}
}
if (generateSetting.RemoveInvalidAsset)
{
RemoveInvalidAsset(group);
}
}
private void DrawMeshSettings(AssetRule assetRule)
{
GUILayout.Space(20);
GUILayout.Label("MESH SETTINGS ");
// read write enabled
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Read/Write Enabled");
assetRule.settings.meshSettings.readWriteEnabled = EditorGUILayout.Toggle(assetRule.settings.meshSettings.readWriteEnabled);
EditorGUILayout.EndHorizontal();
// optimise mesh
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Optimise Mesh");
assetRule.settings.meshSettings.optimiseMesh = EditorGUILayout.Toggle(assetRule.settings.meshSettings.optimiseMesh);
EditorGUILayout.EndHorizontal();
// optimise mesh
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Blend Shapes");
assetRule.settings.meshSettings.ImportBlendShapes = EditorGUILayout.Toggle(assetRule.settings.meshSettings.ImportBlendShapes);
EditorGUILayout.EndHorizontal();
}
private static bool CheckAffectedAsset(string affectedAsset, AssetRule assetRule, int selectedSelective)
{
SerializedObject assetImporterSO = null;
SerializedObject ruleImporterSO = null;
if (TypeFromAssetType(assetRule.assetType) == typeof(Texture))
{
TextureImporter assetimporter =
AssetImporter.GetAtPath(affectedAsset) as
TextureImporter;
// this may happen (e.g. render texture)
if (assetimporter == null)
{
return(false);
}
TextureImporter ruleimporter =
AssetImporter.GetAtPath(AssetDatabase.GUIDToAssetPath(assetRule.AssetGuid)) as
TextureImporter;
if (assetimporter.GetInstanceID() == ruleimporter.GetInstanceID())
{
return(false); // this shouldnt happen but is a nice failsafe
}
assetImporterSO = new SerializedObject(assetimporter);
ruleImporterSO = new SerializedObject(ruleimporter);
}
if (TypeFromAssetType(assetRule.assetType) == typeof(GameObject))
{
ModelImporter assetimporter =
AssetImporter.GetAtPath(affectedAsset) as
ModelImporter;
ModelImporter ruleimporter =
AssetImporter.GetAtPath(AssetDatabase.GUIDToAssetPath(assetRule.AssetGuid)) as
ModelImporter;
if (assetimporter.GetInstanceID() == ruleimporter.GetInstanceID())
{
return(false); // this shouldnt happen but is a nice failsafe
}
assetImporterSO = new SerializedObject(assetimporter);
ruleImporterSO = new SerializedObject(ruleimporter);
}
if (TypeFromAssetType(assetRule.assetType) == typeof(AudioClip))
{
AudioImporter assetimporter =
AssetImporter.GetAtPath(affectedAsset) as
AudioImporter;
AudioImporter ruleimporter =
AssetImporter.GetAtPath(AssetDatabase.GUIDToAssetPath(assetRule.AssetGuid)) as
AudioImporter;
if (assetimporter.GetInstanceID() == ruleimporter.GetInstanceID())
{
return(false); // this shouldnt happen but is a nice failsafe
}
assetImporterSO = new SerializedObject(assetimporter);
ruleImporterSO = new SerializedObject(ruleimporter);
}
if (assetImporterSO == null || ruleImporterSO == null)
{
return(false); // TODO log message here
}
if (!assetRule.SelectiveMode || assetRule.SelectiveProperties.Count <= 0)
{
return(CompareSerializedObject(assetImporterSO, ruleImporterSO));
}
string property = assetRule.SelectiveProperties[selectedSelective];
string realname = GetPropertyNameFromDisplayName(assetImporterSO, property);
SerializedProperty foundAssetSP = assetImporterSO.FindProperty(realname);
SerializedProperty assetRuleSP = ruleImporterSO.FindProperty(realname);
return(CompareSerializedProperty(foundAssetSP, assetRuleSP));
}
public static void FixRule(AssetAuditTreeElement data, AssetRule assetRule)
{
string ruleAssetPath = AssetDatabase.GUIDToAssetPath(assetRule.AssetGuid);
string affectedAssetPath = data.projectPath;
switch (data.assetType)
{
case AssetType.Texture:
TextureImporter ruleTexImporter = AssetImporter.GetAtPath(ruleAssetPath) as TextureImporter;
TextureImporter affectedAssetTexImporter = AssetImporter.GetAtPath(affectedAssetPath) as TextureImporter;
if (assetRule.SelectiveMode)
{
SerializedObject ruleImporterSO = new SerializedObject(ruleTexImporter);
SerializedObject affectedAssetImporterSO = new SerializedObject(affectedAssetTexImporter);
CopySelectiveProperties(affectedAssetImporterSO, ruleImporterSO, assetRule);
}
else
{
EditorUtility.CopySerialized(ruleTexImporter, affectedAssetTexImporter);
}
affectedAssetTexImporter.userData = "";
affectedAssetTexImporter.SaveAndReimport();
break;
case AssetType.Model:
ModelImporter ruleModelImporter = AssetImporter.GetAtPath(ruleAssetPath) as ModelImporter;
ModelImporter affectedAssetModelImporter = AssetImporter.GetAtPath(affectedAssetPath) as ModelImporter;
if (assetRule.SelectiveMode)
{
SerializedObject ruleImporterSO = new SerializedObject(ruleModelImporter);
SerializedObject affectedAssetImporterSO = new SerializedObject(affectedAssetModelImporter);
CopySelectiveProperties(affectedAssetImporterSO, ruleImporterSO, assetRule);
}
else
{
EditorUtility.CopySerialized(ruleModelImporter, affectedAssetModelImporter);
}
affectedAssetModelImporter.userData = "";
affectedAssetModelImporter.SaveAndReimport();
break;
case AssetType.Audio:
AudioImporter ruleAudioImporter = AssetImporter.GetAtPath(ruleAssetPath) as AudioImporter;
AudioImporter affectedAssetAudioImporter = AssetImporter.GetAtPath(affectedAssetPath) as AudioImporter;
if (assetRule.SelectiveMode)
{
SerializedObject ruleImporterSO = new SerializedObject(ruleAudioImporter);
SerializedObject affectedAssetImporterSO = new SerializedObject(affectedAssetAudioImporter);
CopySelectiveProperties(affectedAssetImporterSO, ruleImporterSO, assetRule);
}
else
{
EditorUtility.CopySerialized(ruleAudioImporter, affectedAssetAudioImporter);
}
affectedAssetAudioImporter.userData = "";
affectedAssetAudioImporter.SaveAndReimport();
break;
case AssetType.Folder:
break;
default:
throw new ArgumentOutOfRangeException();
}
data.conforms = true;
}
private static void CopySelectiveProperties(SerializedObject affectedAssetImporterSO, SerializedObject ruleImporterSO, AssetRule assetRule)
{
foreach (string property in assetRule.SelectiveProperties)
{
string realname = GetPropertyNameFromDisplayName(affectedAssetImporterSO, property);
SerializedProperty assetRuleSP = ruleImporterSO.FindProperty(realname);
affectedAssetImporterSO.CopyFromSerializedProperty(assetRuleSP);
bool applyModifiedProperties = affectedAssetImporterSO.ApplyModifiedProperties();
if (!applyModifiedProperties)
{
Debug.Log(" copy failed ");
}
}
}
public static IEnumerable <float> GatherData(AssetRule assetRule, List <AssetAuditTreeElement> elements, int selectedSelective)
{
int id = -1;
// get the affected assets
string[] affectedAssets = GetAffectedAssets();
if (affectedAssets == null)
{
Debug.Log(" null affected assets");
}
// build the directory tree from the affected assets
elements.Add(new AssetAuditTreeElement("Root", "", -1, 0, false, false, AssetType.Folder));
// early out if there are no affected assets
if (affectedAssets.Length == 0)
{
Debug.Log("no affected assets ");
if (queueComplete != null)
{
queueComplete.Invoke();
}
yield break;
}
AssetAuditTreeElement assetsFolder = new AssetAuditTreeElement("Assets", "Assets", 0, id++, false, false,
AssetType.Folder);
// add the project root "Assets" folder
elements.Add(assetsFolder);
if (assetsFolder.children == null)
{
assetsFolder.children = new List <TreeElement>();
}
float progress = 0f;
foreach (var affectedAsset in affectedAssets)
{
// split the path
string path = affectedAsset.Substring(7);
var strings = path.Split(new[] { '/' }, StringSplitOptions.None);
string projectPath = "Assets";
// the first entries have lower depth
for (int i = 0; i < strings.Length; i++)
{
projectPath += "/" + strings[i];
// the last element is the asset itself
if (i == strings.Length - 1)
{
var result = CheckAffectedAsset(affectedAsset, assetRule, selectedSelective);
var element = new AssetAuditTreeElement(strings[i], projectPath, i + 1, id + 1, true, result,
assetRule.assetType);
elements.Add(element);
id++;
}
else if (!elements.Exists(element => element.name == strings[i] && element.projectPath == projectPath))
{
var assetAuditTreeElement = new AssetAuditTreeElement(strings[i], projectPath, i + 1, id + 1, false, false, AssetType.Folder);
elements.Add(assetAuditTreeElement);
id++;
}
}
progress += 1f;
yield return(progress / affectedAssets.Length);
}
}
private void Apply(AssetRule assetRule)
{
// get the directories that we do not want to apply changes to
List <string> dontapply = new List <string>();
var assetrulepath = AssetDatabase.GetAssetPath(assetRule).Replace(assetRule.name + ".asset", "").TrimEnd('/');
string projPath = Application.dataPath;
projPath = projPath.Remove(projPath.Length - 6);
string[] directories = Directory.GetDirectories(Path.GetDirectoryName(projPath + AssetDatabase.GetAssetPath(assetRule)), "*", SearchOption.AllDirectories);
foreach (var directory in directories)
{
var d = directory.Replace(Application.dataPath, "Assets");
var appDirs = AssetDatabase.FindAssets("t:AssetRule", new[] { d });
if (appDirs.Length != 0)
{
d = d.TrimEnd('/');
d = d.Replace('\\', '/');
dontapply.Add(d);
}
}
List <string> finalAssetList = new List <string>();
foreach (var findAsset in AssetDatabase.FindAssets("", new[] { assetrulepath }))
{
var asset = AssetDatabase.GUIDToAssetPath(findAsset);
if (!File.Exists(asset))
{
continue;
}
if (dontapply.Contains(Path.GetDirectoryName(asset)))
{
continue;
}
if (!assetRule.IsMatch(AssetImporter.GetAtPath(asset)))
{
continue;
}
if (finalAssetList.Contains(asset))
{
continue;
}
if (asset == AssetDatabase.GetAssetPath(assetRule))
{
continue;
}
finalAssetList.Add(asset);
}
int i = 1;
foreach (var asset in finalAssetList)
{
AssetImporter.GetAtPath(asset).SaveAndReimport();
i++;
}
changed = false;
}
void OnEnable()
{
changed = false;
orig = (AssetRule)target;
Undo.RecordObject(target, "assetruleundo");
}
private void DrawTextureSettings(AssetRule assetRule)
{
GUILayout.Space(20);
GUILayout.Label(" TEXTURE SETTINGS ");
GUILayout.Space(20);
GetValidPlatforms();
// mip maps
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Generate Mip Maps");
assetRule.settings.textureSettings.mipmapEnabled = EditorGUILayout.Toggle(assetRule.settings.textureSettings.mipmapEnabled);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Change readable settings");
assetRule.settings.changeReadableSetting = EditorGUILayout.Toggle(assetRule.settings.changeReadableSetting);
EditorGUILayout.EndHorizontal();
//read write enabled
if (assetRule.settings.changeReadableSetting)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Read/Write Enabled");
assetRule.settings.textureSettings.readable = EditorGUILayout.Toggle(assetRule.settings.textureSettings.readable);
EditorGUILayout.EndHorizontal();
}
//lightmap
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Lightmap");
assetRule.settings.textureSettings.lightmap = EditorGUILayout.Toggle(assetRule.settings.textureSettings.lightmap);
EditorGUILayout.EndHorizontal();
// per platform settings
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Max Texture Size");
assetRule.settings.textureSettings.maxTextureSize =
EditorGUILayout.IntPopup(assetRule.settings.textureSettings.maxTextureSize, sizeStrings, sizes);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Change Texture Format");
assetRule.settings.enableCompressSetting = EditorGUILayout.Toggle(assetRule.settings.enableCompressSetting);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Texture SpriteMode");
var mode = (SpriteImportMode)EditorGUILayout.EnumPopup((SpriteImportMode)assetRule.settings.textureSettings.spriteMode);
assetRule.settings.textureSettings.spriteMode = (int)mode;
EditorGUILayout.EndHorizontal();
// per platform settings
if (assetRule.settings.enableCompressSetting)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Texture Format");
assetRule.settings.textureSettings.textureFormat =
(TextureImporterFormat)EditorGUILayout.EnumPopup(assetRule.settings.textureSettings.textureFormat);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Compression Quality");
assetRule.settings.textureSettings.compressionQuality = (int)EditorGUILayout.Slider(assetRule.settings.textureSettings.compressionQuality, 0f, 100f);
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Override iOS Format");
assetRule.settings.overrideIos = EditorGUILayout.Toggle(assetRule.settings.overrideIos);
EditorGUILayout.EndHorizontal();
if (assetRule.settings.overrideIos)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("iOS Texture Format");
assetRule.settings.iosTextureFormat =
(TextureImporterFormat)EditorGUILayout.EnumPopup(assetRule.settings.iosTextureFormat);
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Override Android Format");
assetRule.settings.overrideAndroid = EditorGUILayout.Toggle(assetRule.settings.overrideAndroid);
EditorGUILayout.EndHorizontal();
if (assetRule.settings.overrideAndroid)
{
// EditorGUILayout.BeginHorizontal();
// EditorGUILayout.LabelField("Alpha Split");
// assetRule.settings.textureSettings.allowsAlphaSplit = EditorGUILayout.Toggle(assetRule.settings.textureSettings.allowsAlphaSplit);
// EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Android Texture Format");
assetRule.settings.androidTextureFormat =
(TextureImporterFormat)EditorGUILayout.EnumPopup(assetRule.settings.androidTextureFormat);
EditorGUILayout.EndHorizontal();
}
}
private static void GenerateWithAssetRule(AddressableAssetSettings settings, GenerateSetting generateSetting, AddressableAssetGroup group, GroupRule groupRule, AssetRule assetRule)
{
int assetsIndexOf = Application.dataPath.LastIndexOf("Assets");
string realPath = Application.dataPath.Substring(0, assetsIndexOf) + assetRule.Path;
if (!Directory.Exists(realPath))
{
Debug.LogError(string.Format("Path ({0}) of group ({1}) not exists", realPath, groupRule.GroupName));
return;
}
DirectoryInfo directoryInfo = new DirectoryInfo(realPath);
FileInfo[] files = directoryInfo.GetFiles("*.*", assetRule.IncludeChilder ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
for (int iFile = 0; iFile < files.Length; iFile++)
{
FileInfo iterFile = files[iFile];
string iterFileName = iterFile.Name.Substring(0, iterFile.Name.Length - iterFile.Extension.Length);
// meta文件肯定是要忽略的
if (iterFile.Extension == ".meta")
{
continue;
}
if (!Filter(assetRule.ExtensionFilterType, iterFile.Extension, assetRule.ExtensionFilters) ||
!Filter(assetRule.FileNameFilterType, iterFileName, assetRule.FileNameFilters))
{
continue;
}
string iterAssetPath = iterFile.FullName.Substring(assetsIndexOf);
string assetKey;
switch (assetRule.AssetKeyType)
{
case AssetKeyType.FileName:
assetKey = iterFileName;
break;
case AssetKeyType.FileNameFormat:
assetKey = string.Format(assetRule.AssetKeyFormat, iterFileName);
break;
case AssetKeyType.Path:
// Unity默认的路径分隔符是'/'
assetKey = iterAssetPath.Replace('\\', '/');
break;
default:
assetKey = string.Empty;
throw new System.Exception(string.Format("not support ExtensionFilterType ({0})", assetRule.ExtensionFilterType));
}
string iterAssetGuid = AssetDatabase.AssetPathToGUID(iterAssetPath);
AddressableAssetEntry iterAssetEntry = AddressableAssetSettingsDefaultObject.Settings.CreateOrMoveEntry(iterAssetGuid, group);
if (iterAssetEntry == null)
{
Debug.LogError(string.Format("Cant load asset at path ({0})", iterAssetPath));
}
iterAssetEntry.SetAddress(assetKey);
for (int iLabel = 0; iLabel < assetRule.AssetLables.Length; iLabel++)
{
iterAssetEntry.SetLabel(assetRule.AssetLables[iLabel], true);
}
}
}
public static IEnumerable <float> DoNameContainsSearch(List <string> foundAssets, AssetRule assetRule)
{
string type = "";
switch (assetRule.assetType)
{
case AssetType.Texture:
type = "Texture";
break;
case AssetType.Model:
type = "GameObject";
break;
case AssetType.Audio:
type = "AudioClip";
break;
case AssetType.Folder:
break;
default:
throw new ArgumentOutOfRangeException();
}
foreach (string findAsset in AssetDatabase.FindAssets("t:" + type + " " + assetRule.WildCard))
{
string guidToAssetPath = AssetDatabase.GUIDToAssetPath(findAsset);
if (guidToAssetPath.Contains(AssetAuditorPreferences.ProxyAssetsDirectory))
{
continue;
}
foundAssets.Add(guidToAssetPath);
}
AssetAuditor.foundAssets = foundAssets;
yield return(1f);
}
