AnotherFoxGuy/DreadScripts-Archive
1
0
Fork 0
Code Pull Requests Activity

Initial Commit

Browse Source
This commit is contained in:
jellejurre
2025-07-19 01:03:02 +02:00
commit e7904e3140
304 changed files with 22521 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
PackageProcessor/Editor.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: df1ae91095633fd4d930d1e9b2b8193e
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

405
PackageProcessor/Editor/ExportPostProcessor.cs Normal file
View File

@@ -0,0 +1,405 @@
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using HarmonyLib;
using System.Reflection;
using System.IO;
using System.Linq;
using Object = UnityEngine.Object;
namespace DreadScripts.PackageProcessor
{
[InitializeOnLoad]
public class ExportPostProcessor
{
#region Patching
private static readonly System.Type packageExportType;
private static readonly System.Type packageTreeGUIType;
private static readonly FieldInfo includeDependenciesField;
private static readonly FieldInfo exportItemsField;
private static readonly MethodInfo refreshListMethod;
private static readonly MethodInfo getTreeItemMethod;
#endregion
#region Constants
private const string PARAM_FOLDERS = "exportDefaultOffFolders";
private const string PARAM_EXTENSIONS = "exportDefaultOffExtensions";
private const string PARAM_TYPES = "exportDefaultOffTypes";
private const string PARAM_ASSETS = "exportDefaultOffAssets";
#endregion
private static PackageProcessorData settings;
private static EditorWindow exporterInstance;
private static object rawItems;
private static ReflectedExportPackageItem[] reflectedItems;
private static bool firstStart = true;
static ExportPostProcessor()
{
packageExportType = GetType("UnityEditor.PackageExport");
packageTreeGUIType = GetType("UnityEditor.PackageExportTreeView+PackageExportTreeViewGUI");
includeDependenciesField = packageExportType.GetField("m_IncludeDependencies", BindingFlags.Instance | BindingFlags.NonPublic);
exportItemsField = packageExportType.GetField("m_ExportPackageItems", BindingFlags.Instance | BindingFlags.NonPublic);
refreshListMethod = GetType("UnityEditor.PackageExportTreeView").GetMethod("ComputeEnabledStateForFolders", BindingFlags.Instance | BindingFlags.NonPublic);
getTreeItemMethod = GetType("UnityEditor.PackageExportTreeView+PackageExportTreeViewItem").GetMethod("get_item", BindingFlags.Instance | BindingFlags.Public);
var harmony = new Harmony("com.dreadscripts.exportpostprocessor.tool");
void QuickPatch(System.Type targetType, string ogMethod, string preMethod = "", string poMethod = "")
{
MethodInfo originalMethod = AccessTools.GetDeclaredMethods(targetType).Find(m => m.Name == ogMethod);
HarmonyMethod prefixMethod = string.IsNullOrEmpty(preMethod) ? null : new HarmonyMethod(typeof(ExportPostProcessor).GetMethod(preMethod, BindingFlags.NonPublic | BindingFlags.Static));
HarmonyMethod postMethod = string.IsNullOrEmpty(poMethod) ? null : new HarmonyMethod(typeof(ExportPostProcessor).GetMethod(poMethod, BindingFlags.NonPublic | BindingFlags.Static));
harmony.Patch(originalMethod, prefixMethod, postMethod);
}
QuickPatch(packageExportType, "ShowExportPackage", null, nameof(ShowExportPost));
QuickPatch(packageExportType, "BuildAssetList", null, nameof(BuildAssetListPost));
QuickPatch(packageExportType, "OnGUI", null, nameof(packageGUIPost));
QuickPatch(packageTreeGUIType, "OnRowGUI", nameof(treeRowGUIPrefix));
}
static void ShowExportPost()
{
settings = PackageProcessorData.instance;
exporterInstance = EditorWindow.GetWindow(packageExportType);
firstStart = true;
if (settings.active)
includeDependenciesField.SetValue(exporterInstance, settings.includeDependencies);
}
static void BuildAssetListPost()
{
GetExportItems();
if (!firstStart || !settings.active) return;
firstStart = false;
List<System.Type> offTypes = new List<System.Type>();
settings.exportDefaultOffTypes.ForEach(t =>
{
if (string.IsNullOrWhiteSpace(t)) return;
System.Type targetType = GetType(t);
if (targetType != null)
offTypes.Add(targetType);
});
foreach (var i in reflectedItems)
{
if (offTypes.Any(t => t == i.type) ||
settings.exportDefaultOffFolders.Any(f => i.assetPath.Contains(f)) ||
settings.exportDefaultOffExtensions.Any(s => s == Path.GetExtension(i.assetPath)) ||
(!i.isFolder && settings.exportDefaultOffAssets.Any(g => g == i.guid)))
i.enabledState = 0;
}
}
static void packageGUIPost()
{
using (new GUILayout.HorizontalScope())
{
if (GUILayout.Button("Modified by Dreadrith#3238", "minilabel"))
Application.OpenURL("https://github.com/Dreadrith/DreadScripts");
GUILayout.FlexibleSpace();
}
}
static ReflectedExportPackageItem reflectedTargetItem;
static void treeRowGUIPrefix(Rect rowRect,UnityEditor.IMGUI.Controls.TreeViewItem tvItem)
{
if (Event.current.type == EventType.ContextClick && rowRect.Contains(Event.current.mousePosition))
{
object targetItem = getTreeItemMethod.Invoke(tvItem, null);
if (targetItem != null)
{
reflectedTargetItem = new ReflectedExportPackageItem(targetItem);
if (!reflectedTargetItem.isFolder)
{
GenericMenu myMenu = new GenericMenu();
myMenu.AddItem(new GUIContent("Toggle Type"), false, new GenericMenu.MenuFunction(ToggleSelectedType));
myMenu.AddSeparator("");
if (!HasSelectedAsset())
myMenu.AddItem(new GUIContent("Exclusions/Add Asset"), false, new GenericMenu.MenuFunction(ExcludeSelectedAsset));
else
myMenu.AddItem(new GUIContent("Exclusions/Remove Asset"), false, new GenericMenu.MenuFunction(IncludeSelectedAsset));
if (!HasSelectedType())
myMenu.AddItem(new GUIContent("Exclusions/Add Type"), false, new GenericMenu.MenuFunction(ExcludeSelectedType));
else
myMenu.AddItem(new GUIContent("Exclusions/Remove Type"), false, new GenericMenu.MenuFunction(IncludeSelectedType));
if (!HasSelectedExtension())
myMenu.AddItem(new GUIContent("Exclusions/Add Extension"), false, new GenericMenu.MenuFunction(ExcludeSelectedExtension));
else
myMenu.AddItem(new GUIContent("Exclusions/Remove Extension"), false, new GenericMenu.MenuFunction(IncludeSelectedExtension));
myMenu.ShowAsContext();
Event.current.Use();
}
else
{
GenericMenu myMenu = new GenericMenu();
if (!HasSelectedFolder())
myMenu.AddItem(new GUIContent("Exclusions/Add Folder"), false, new GenericMenu.MenuFunction(ExcludeSelectedFolder));
else
myMenu.AddItem(new GUIContent("Exclusions/Remove Folder"), false, new GenericMenu.MenuFunction(IncludeSelectedFolder));
myMenu.ShowAsContext();
Event.current.Use();
}
}
else
{
GenericMenu myMenu = new GenericMenu();
myMenu.AddDisabledItem(new GUIContent("Folder not being exported"));
myMenu.ShowAsContext();
Event.current.Use();
}
}
}
static void ToggleSelectedType()
{
List<ReflectedExportPackageItem> targetItems = new List<ReflectedExportPackageItem>();
bool allOn = true;
Iterate(reflectedItems, i =>
{
if (i.type == reflectedTargetItem.type)
{
targetItems.Add(i);
if (i.enabledState == 0)
{
allOn = false;
}
}
});
targetItems.ForEach(i => i.enabledState = allOn ? 0 : 1);
RefreshTreeView();
}
static bool HasExclusion(string property, string value)
{
SerializedObject data = new SerializedObject(PackageProcessorData.instance);
SerializedProperty targetProperty = data.FindProperty(property);
for (int i = 0; i < targetProperty.arraySize; i++)
{
if (targetProperty.GetArrayElementAtIndex(i).stringValue == value)
{
return true;
}
}
return false;
}
static void AddExclusion(string property, string value)
{
SerializedObject data = new SerializedObject(PackageProcessorData.instance);
SerializedProperty targetProperty = data.FindProperty(property);
targetProperty.arraySize++;
targetProperty.GetArrayElementAtIndex(targetProperty.arraySize - 1).stringValue = value;
data.ApplyModifiedPropertiesWithoutUndo();
}
static void RemoveExclusion(string property, string value)
{
SerializedObject data = new SerializedObject(PackageProcessorData.instance);
SerializedProperty targetProperty = data.FindProperty(property);
for (int i = 0; i < targetProperty.arraySize; i++)
{
if (targetProperty.GetArrayElementAtIndex(i).stringValue == value)
{
targetProperty.DeleteArrayElementAtIndex(i);
break;
}
}
data.ApplyModifiedPropertiesWithoutUndo();
}
#region Extension Exclusion
static bool HasSelectedExtension() => HasExclusion(PARAM_EXTENSIONS, Ext(reflectedTargetItem.assetPath));
static void ExcludeSelectedExtension() => AddExclusion(PARAM_EXTENSIONS, Ext(reflectedTargetItem.assetPath));
static void IncludeSelectedExtension() => RemoveExclusion(PARAM_EXTENSIONS, Ext(reflectedTargetItem.assetPath));
#endregion
#region Folder Exclusion
static bool HasSelectedFolder() => HasExclusion(PARAM_FOLDERS, reflectedTargetItem.assetPath);
static void ExcludeSelectedFolder() => AddExclusion(PARAM_FOLDERS, reflectedTargetItem.assetPath);
static void IncludeSelectedFolder() => RemoveExclusion(PARAM_FOLDERS, reflectedTargetItem.assetPath);
#endregion
#region Type Exclusion
static bool HasSelectedType() => PackageProcessorData.instance.exportDefaultOffTypes.Any(t => GetType(t) == reflectedTargetItem.type);
static void ExcludeSelectedType() => AddExclusion(PARAM_TYPES, reflectedTargetItem.type.AssemblyQualifiedName);
static void IncludeSelectedType()
{
SerializedObject data = new SerializedObject(PackageProcessorData.instance);
SerializedProperty targetProperty = data.FindProperty(PARAM_TYPES);
for (int i = 0; i < targetProperty.arraySize; i++)
{
Type currentType = GetType(targetProperty.GetArrayElementAtIndex(i).stringValue);
if (currentType == reflectedTargetItem.type)
{
targetProperty.DeleteArrayElementAtIndex(i);
break;
}
}
data.ApplyModifiedPropertiesWithoutUndo();
}
#endregion
#region Asset Exclusion
static bool HasSelectedAsset() => HasExclusion(PARAM_ASSETS, reflectedTargetItem.guid);
static void ExcludeSelectedAsset() => AddExclusion(PARAM_ASSETS, reflectedTargetItem.guid);
static void IncludeSelectedAsset() => RemoveExclusion(PARAM_ASSETS, reflectedTargetItem.guid);
#endregion
private static string Ext(string path) => Path.GetExtension(path);
private static void GetExportItems()
{
rawItems = exportItemsField.GetValue(exporterInstance);
object[] exportItems = (object[])rawItems;
exportItemsField.SetValue(exporterInstance, exportItems);
reflectedItems = new ReflectedExportPackageItem[exportItems.Length];
for (int i = 0; i < exportItems.Length; i++)
reflectedItems[i] = new ReflectedExportPackageItem(exportItems[i]);
}
private static void RefreshTreeView()
{
refreshListMethod.Invoke(packageExportType.GetField("m_Tree", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(exporterInstance), null);
}
private class ReflectedExportPackageItem
{
private readonly object instance;
public bool isFolder => AssetDatabase.IsValidFolder(assetPath);
private string _assetPath;
public string assetPath
{
get
{
if (string.IsNullOrEmpty(_assetPath))
_assetPath = (string)assetPathField.GetValue(instance);
return _assetPath;
}
}
private bool stateInit;
private int _enabledState;
public int enabledState
{
get
{
if (!stateInit)
return 1;
if (_enabledState == -2)
_enabledState = (int)enabledStateField.GetValue(instance);
return _enabledState;
}
set
{
stateInit = true;
_enabledState = value;
enabledStateField.SetValue(instance, value);
}
}
private string _guid;
public string guid
{
get
{
if (string.IsNullOrEmpty(_guid))
_guid = (string)guidField.GetValue(instance);
return _guid;
}
}
private System.Type _type;
public System.Type type
{
get
{
if (asset && _type == null)
_type = asset.GetType();
return _type;
}
}
private Object _asset;
private bool _assetLoaded;
private Object asset
{
get
{
if (_asset || _assetLoaded) return _asset;
_asset = AssetDatabase.LoadMainAssetAtPath(assetPath);
_assetLoaded = true;
return _asset;
}
}
static FieldInfo assetPathField;
static FieldInfo enabledStateField;
static FieldInfo guidField;
public ReflectedExportPackageItem(object instance)
{
this.instance = instance;
}
[InitializeOnLoadMethod]
static void InitializeFields()
{
System.Type targetType = AccessTools.TypeByName("ExportPackageItem");
assetPathField = targetType.GetField("assetPath", BindingFlags.Public | BindingFlags.Instance);
enabledStateField = targetType.GetField("enabledStatus", BindingFlags.Public | BindingFlags.Instance);
guidField = targetType.GetField("guid", BindingFlags.Public | BindingFlags.Instance);
}
}
private static System.Type GetType(string typeName)
{
System.Type myType = System.Type.GetType(typeName);
if (myType != null)
return myType;
foreach (Assembly assembly in System.AppDomain.CurrentDomain.GetAssemblies())
{
myType = assembly.GetType(typeName);
if (myType != null)
return myType;
}
return null;
}
public static void Iterate<T>(IEnumerable<T> collection, System.Action<T> action)
{
using (IEnumerator<T> myNum = collection.GetEnumerator())
{
while (myNum.MoveNext())
{
action(myNum.Current);
}
}
}
}
}

11
PackageProcessor/Editor/ExportPostProcessor.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: afc24f4a03a4b5d42a9c8ca0f1c4604e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

67
PackageProcessor/Editor/ImportPostProcessor.cs Normal file
View File

@@ -0,0 +1,67 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using HarmonyLib;
using UnityEngine;
using UnityEditor;
using Object = UnityEngine.Object;
namespace DreadScripts.PackageProcessor
{
[InitializeOnLoad]
public class ImportPostProcessor
{
private static readonly Harmony harmony;
private static readonly FieldInfo assetPathField;
private static readonly FieldInfo enabledStatusField;
private static readonly FieldInfo isFolderField;
static ImportPostProcessor()
{
harmony = new Harmony("com.dreadscripts.importpostprocessor.tool");
Type packageImportType = GetType("UnityEditor.PackageImport");
Type packageImportItemType = GetType("UnityEditor.ImportPackageItem");
assetPathField = packageImportItemType.GetField("destinationAssetPath", BindingFlags.Public | BindingFlags.Instance);
enabledStatusField = packageImportItemType.GetField("enabledStatus", BindingFlags.Public | BindingFlags.Instance);
isFolderField = packageImportItemType.GetField("isFolder", BindingFlags.Public | BindingFlags.Instance);
QuickPatch(packageImportType, "ShowImportPackage", string.Empty, nameof(ShowImportPackagePost));
}
private static void ShowImportPackagePost(object[] items)
{
foreach (var i in items)
{
string path = (string)assetPathField.GetValue(i) ;
bool isFolder = (bool)isFolderField.GetValue(i);
if (!isFolder && !string.IsNullOrEmpty(path) && (path.EndsWith(".cs") || path.EndsWith(".dll")))
enabledStatusField.SetValue(i, 0);
}
}
private static void QuickPatch(System.Type targetType, string ogMethod, string preMethod = "", string poMethod = "")
{
MethodInfo originalMethod = AccessTools.GetDeclaredMethods(targetType).Find(m => m.Name == ogMethod);
HarmonyMethod prefixMethod = string.IsNullOrEmpty(preMethod) ? null : new HarmonyMethod(typeof(ImportPostProcessor).GetMethod(preMethod, BindingFlags.NonPublic | BindingFlags.Static));
HarmonyMethod postMethod = string.IsNullOrEmpty(poMethod) ? null : new HarmonyMethod(typeof(ImportPostProcessor).GetMethod(poMethod, BindingFlags.NonPublic | BindingFlags.Static));
harmony.Patch(originalMethod, prefixMethod, postMethod);
}
private static System.Type GetType(string typeName)
{
System.Type myType = System.Type.GetType(typeName);
if (myType != null)
return myType;
foreach (Assembly assembly in System.AppDomain.CurrentDomain.GetAssemblies())
{
myType = assembly.GetType(typeName);
if (myType != null)
return myType;
}
return null;
}
}
}

11
PackageProcessor/Editor/ImportPostProcessor.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: cbdf79a44f36b9b4aaabc6ffa66403b9
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

55
PackageProcessor/Editor/PackageProcessorData.cs Normal file
View File

@@ -0,0 +1,55 @@
using System.Collections;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;
namespace DreadScripts.PackageProcessor
{
[System.Serializable]
public class PackageProcessorData : ScriptableObject
{
private static PackageProcessorData _instance;
public static PackageProcessorData instance
{
get
{
if (!_instance && Exists())
if (_instance = AssetDatabase.LoadAssetAtPath<PackageProcessorData>(SavePath))
return _instance;
_instance = CreateInstance<PackageProcessorData>();
if (!System.IO.Directory.Exists(folderPath))
System.IO.Directory.CreateDirectory(folderPath);
AssetDatabase.CreateAsset(_instance, SavePath);
return _instance;
}
}
private static string _folderPath;
public static string folderPath
{
get
{
if (string.IsNullOrEmpty(_folderPath))
_folderPath = PlayerPrefs.GetString("PackageProcessorDataPath", "Assets/DreadScripts/Saved Data/PackageProcessor");
return _folderPath;
}
set => _folderPath = value;
}
private static string SavePath => folderPath + "/PackageProcessorData.asset";
public bool active = true;
public bool includeDependencies = false;
public List<string> exportDefaultOffExtensions = new List<string>();
public List<string> exportDefaultOffFolders = new List<string>();
public List<string> exportDefaultOffTypes = new List<string>();
public List<string> exportDefaultOffAssets = new List<string>();
public static bool Exists() => System.IO.File.Exists(SavePath);
}
}

11
PackageProcessor/Editor/PackageProcessorData.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: ed2394df32bc4ff439e376a0a2aa49e6
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

248
PackageProcessor/Editor/PackageProcessorWindow.cs Normal file
View File

@@ -0,0 +1,248 @@
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using Object = UnityEngine.Object;
namespace DreadScripts.PackageProcessor
{
public class PackageProcessorWindow : EditorWindow
{
private static SerializedObject settings;
private static SerializedProperty includeDependencies;
private static SerializedProperty active;
private static SerializedProperty exportDefaultOffTypes;
private static SerializedProperty exportDefaultOffFolders;
private static SerializedProperty exportDefaultOffExtensions;
private static SerializedProperty exportDefaultOffAssets;
private static Object targetObject;
private static Object targetFolder;
private static Object targetAsset;
[MenuItem("DreadTools/Utility/Package Processor")]
public static void ShowWindow() => GetWindow<PackageProcessorWindow>(false, "Package Processor Settings", true);
private void OnGUI()
{
settings.Update();
using (new BGColorScope(active.boolValue, Color.green, Color.grey))
active.boolValue = GUILayout.Toggle(active.boolValue, "Active", "toolbarbutton");
using (new EditorGUI.DisabledScope(!active.boolValue))
{
using (new LabelWidthScope(200))
EditorGUILayout.PropertyField(includeDependencies, new GUIContent("Default Include Dependencies"));
DrawListProperty(exportDefaultOffExtensions);
DrawListProperty(exportDefaultOffFolders, FolderPropertyGUI);
DrawListProperty(exportDefaultOffTypes, TypePropertyGUI);
DrawAssetProperty(exportDefaultOffAssets);
}
PackageProcessorData.folderPath = AssetFolderPath(PackageProcessorData.folderPath, "Settings Path", "ExportPostProcessorDataPath");
settings.ApplyModifiedProperties();
}
#region GUI Methods
private void DrawListProperty(SerializedProperty p, Action guiCall = null)
{
using (new GUILayout.VerticalScope("box"))
{
p.isExpanded = EditorGUILayout.Foldout(p.isExpanded, p.displayName);
if (!p.isExpanded) return;
guiCall?.Invoke();
EditorGUI.indentLevel++;
if (GUILayout.Button("+"))
p.arraySize++;
for (int i = p.arraySize-1; i >= 0; i--)
{
using (new GUILayout.HorizontalScope())
{
EditorGUILayout.PropertyField(p.GetArrayElementAtIndex(i));
if (GUILayout.Button("X", GUILayout.Width(18)))
p.DeleteArrayElementAtIndex(i);
}
}
EditorGUI.indentLevel--;
}
}
private void TypePropertyGUI()
{
using (new GUILayout.HorizontalScope())
{
targetObject = EditorGUILayout.ObjectField("Add Type Of", targetObject, typeof(Object), true);
EditorGUI.BeginDisabledGroup(!targetObject);
if (GUILayout.Button("Add Type"))
{
exportDefaultOffTypes.arraySize++;
exportDefaultOffTypes.GetArrayElementAtIndex(exportDefaultOffTypes.arraySize - 1).stringValue = targetObject.GetType().AssemblyQualifiedName;
}
EditorGUI.EndDisabledGroup();
}
}
private void FolderPropertyGUI()
{
using (new GUILayout.HorizontalScope())
{
EditorGUI.BeginChangeCheck();
targetFolder = EditorGUILayout.ObjectField("Folder", targetFolder, typeof(Object), true);
if (EditorGUI.EndChangeCheck() && targetFolder)
{
string assetPath = AssetDatabase.GetAssetPath(targetFolder);
if (!AssetDatabase.IsValidFolder(assetPath))
targetFolder = AssetDatabase.LoadMainAssetAtPath(System.IO.Path.GetDirectoryName(assetPath));
}
EditorGUI.BeginDisabledGroup(!targetFolder);
if (GUILayout.Button("Add Folder"))
{
exportDefaultOffFolders.arraySize++;
exportDefaultOffFolders.GetArrayElementAtIndex(exportDefaultOffFolders.arraySize - 1).stringValue = AssetDatabase.GetAssetPath(targetFolder);
}
EditorGUI.EndDisabledGroup();
}
}
private void DrawAssetProperty(SerializedProperty p)
{
using (new GUILayout.VerticalScope("box"))
{
p.isExpanded = EditorGUILayout.Foldout(p.isExpanded, p.displayName);
if (p.isExpanded)
{
using (new GUILayout.HorizontalScope())
{
targetAsset = EditorGUILayout.ObjectField("Add GUID Of", targetAsset, typeof(Object), false);
if (AssetDatabase.IsValidFolder(AssetDatabase.GetAssetPath(targetAsset)))
targetAsset = null;
EditorGUI.BeginDisabledGroup(!targetAsset);
if (GUILayout.Button("Add GUID"))
{
AssetDatabase.TryGetGUIDAndLocalFileIdentifier(targetAsset, out string newGUID, out long _);
exportDefaultOffAssets.arraySize++;
exportDefaultOffAssets.GetArrayElementAtIndex(exportDefaultOffAssets.arraySize - 1).stringValue = newGUID;
}
EditorGUI.EndDisabledGroup();
}
EditorGUI.indentLevel++;
if (GUILayout.Button("+"))
{
p.arraySize++;
}
for (int i = p.arraySize - 1; i >= 0; i--)
{
using (new GUILayout.HorizontalScope())
{
EditorGUILayout.PropertyField(p.GetArrayElementAtIndex(i));
if (GUILayout.Button("X", GUILayout.Width(18)))
p.DeleteArrayElementAtIndex(i);
if (GUILayout.Button("?",GUILayout.Width(18)))
{
Object asset = AssetDatabase.LoadMainAssetAtPath(AssetDatabase.GUIDToAssetPath(p.GetArrayElementAtIndex(i).stringValue));
if (!asset)
{
if (EditorUtility.DisplayDialog("Not Found", "Asset for this GUID was not found. Delete?", "Delete", "Ignore"))
p.DeleteArrayElementAtIndex(i);
}
else
EditorGUIUtility.PingObject(asset);
}
}
}
EditorGUI.indentLevel--;
}
}
}
private static string AssetFolderPath(string variable, string title, string playerpref, bool isPlayerPrefs = true)
{
using (new GUILayout.HorizontalScope())
{
using (new EditorGUI.DisabledScope(true))
EditorGUILayout.TextField(title, variable);
if (GUILayout.Button("...", GUILayout.Width(30)))
{
var dummyPath = EditorUtility.OpenFolderPanel(title, AssetDatabase.IsValidFolder(variable) ? variable : "Assets", string.Empty);
if (string.IsNullOrEmpty(dummyPath))
return variable;
string newPath = FileUtil.GetProjectRelativePath(dummyPath);
if (!newPath.StartsWith("Assets"))
{
Debug.LogWarning("New Path must be a folder within Assets!");
return variable;
}
variable = newPath;
if (isPlayerPrefs) PlayerPrefs.SetString(playerpref, variable);
else EditorPrefs.SetString(playerpref, variable);
}
}
return variable;
}
#endregion
private void OnEnable()
{
if (settings == null)
{
settings = new SerializedObject(PackageProcessorData.instance);
includeDependencies = settings.FindProperty("includeDependencies");
active = settings.FindProperty("active");
exportDefaultOffTypes = settings.FindProperty("exportDefaultOffTypes");
exportDefaultOffFolders = settings.FindProperty("exportDefaultOffFolders");
exportDefaultOffExtensions = settings.FindProperty("exportDefaultOffExtensions");
exportDefaultOffAssets = settings.FindProperty("exportDefaultOffAssets");
}
}
#region Scope Classes
public class LabelWidthScope : System.IDisposable
{
private readonly float originalWidth;
public LabelWidthScope(float newWidth)
{
originalWidth = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = newWidth;
}
public void Dispose() => EditorGUIUtility.labelWidth = originalWidth;
}
public class BGColorScope : System.IDisposable
{
private readonly Color originalColor;
public BGColorScope(bool active, Color activeColor, Color inactiveColor)
{
originalColor = GUI.backgroundColor;
GUI.backgroundColor = active ? activeColor : inactiveColor;
}
public void Dispose() => GUI.backgroundColor = originalColor;
}
#endregion
}
}

11
PackageProcessor/Editor/PackageProcessorWindow.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 43224e74da76e8a4ca25914ed1364442
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

15
PackageProcessor/Editor/com.dreadrith.packageprocessor.Editor.asmdef Normal file
View File

@@ -0,0 +1,15 @@
{
"name": "com.dreadrith.packageprocessor.Editor",
"references": [],
"includePlatforms": [
"Editor"
],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [],
"noEngineReferences": false
}

7
PackageProcessor/Editor/com.dreadrith.packageprocessor.Editor.asmdef.meta Normal file
View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: b94789d11fa32064c84634c99b5a21bd
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

21
PackageProcessor/LICENSE Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2024 Dreadrith
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

7
PackageProcessor/LICENSE.meta Normal file
View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: e31dd2b2d1b36c94ba8b44b96eaa1632
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

37
PackageProcessor/README.md Normal file
View File

@@ -0,0 +1,37 @@
# Package Processor
Make it less tedious to import or export only the things that you need.
![image](https://cdn.discordapp.com/attachments/1096062312495972414/1096062312944783450/postprost.gif?ex=66343bd3&is=6632ea53&hm=3bec6fe57e3675b2a80bba600fcbb753f312ec7797d62ed5633d3defb8c09b21&)
Package Processor can be used to reduce the tediousness of having to Select/Deselect certain assets based on Exclusion rules and other features.
Settings can be found under
DreadTools > Scripts Settings > Package Processor
Currently, Import Processor only deselects scripts and doesn't have settings.
Settings Window
---------------
- "Active": Whether the settings should affect the exporting at all.
- "Include Dependencies": Whether opening the export window should have dependencies On or Off by default.
- "Default Off Extensions": Any File matching one of these extensions will be Off by default.
- "Default Off Folders": Any File whose path contains one of these paths will be Off by default.
- "Default Off Types": Any File whose type matches one of these types will be Off by default.
- "Default Off Assets": Any File whose GUID matches one of these GUIDs will be Off by default.
- "Settings Path": The path where the settings should be saved and loaded from.
Export Window
-------------
Right Clicking any file will open a Context menu for extra features
- File - Toggle Type: Turns On/Off all of the assets being exporting whose types match the one selected.
- Exclusions:
- Add/Remove Asset: Adds/Removes this File's GUID in the Default Off Assets list.
- Add/Remove Type: Adds/Removes this File's Type in the Default Off Types list.
- Add/Remove Extension: Adds/Removes this File's Extension in the Default Off Extensions list.
- Folder - Exclusions: Add/Remove Folder: Adds/Removes this Folder's Path in the Default Off Folders list.
**Requires Harmony!**
### Thank you
If you enjoy Package Processor, please consider [supporting me ♡](https://ko-fi.com/Dreadrith)!

7
PackageProcessor/README.md.meta Normal file
View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 3c7cb9dfc3a13214cb620c8f76deca94
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

17
PackageProcessor/package.json Normal file
View File

@@ -0,0 +1,17 @@
{
"name": "com.dreadrith.packageprocessor",
"displayName": "DreadScripts - PackageProcessor",
"version": "1.0.1",
"description": "Make it less tedious to import or export only the things that you need.",
"gitDependencies": {},
"vpmDependencies": {},
"author": {
"name": "Dreadrith",
"email": "dreadscripts@gmail.com",
"url": "https://www.dreadrith.com"
},
"legacyFolders": {},
"legacyFiles": {},
"type": "tool",
"unity": "2019.4"
}

7
PackageProcessor/package.json.meta Normal file
View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 779188ec76ff7e84f9da587fa51f2d2c
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant: