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