private static void GetUserSortingComparers()
{
m_SortingMethods = new List <MethodInfo>();
foreach (var sortingMethod in EditorAssemblies.GetAllMethodsWithAttribute <GridPaintSortingAttribute>())
{
if (!sortingMethod.ReturnType.IsAssignableFrom(typeof(IComparer <GameObject>)))
{
continue;
}
if (sortingMethod.GetGenericArguments().Length > 0)
{
continue;
}
m_SortingMethods.Add(sortingMethod);
}
m_SortingTypes = new List <Type>();
foreach (var sortingType in TypeCache.GetTypesWithAttribute <GridPaintSortingAttribute>())
{
if (sortingType.IsAbstract)
{
continue;
}
m_SortingTypes.Add(sortingType);
}
}
void GetMenuItemExtraInfoIfNeeded()
{
if (m_DebugInfoFetched)
{
return;
}
m_DebugInfoFetched = true;
var managedMenuItemMethods = EditorAssemblies.GetAllMethodsWithAttribute <MenuItem>();
foreach (var managedMenuItemMethod in managedMenuItemMethods)
{
var attributes = managedMenuItemMethod.GetCustomAttributes(typeof(MenuItem), false);
foreach (var attribute in attributes)
{
var menuAttribute = (MenuItem)attribute;
if (menuAttribute.menuItem == m_MenuItemPath)
{
var sourceInfo = MethodSourceFinderUtility.GetSourceInfo(managedMenuItemMethod);
m_FilePath = sourceInfo.filePath;
m_LineNumber = sourceInfo.lineNumber;
m_FullMemberName = managedMenuItemMethod.DeclaringType.FullName + "." + managedMenuItemMethod.Name;
return;
}
}
}
}
/// <summary>
/// Initialized and collect methods with SpriteDataProviderFactoryAttribute and SpriteDataProviderAssetPathProviderAttribute.
/// </summary>
public void Init()
{
var factories = EditorAssemblies.loadedTypes.Where(x => x.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(ISpriteDataProviderFactory <>))).ToArray();
var factoryList = new List <SpriteDataProviderFactory>();
foreach (var factory in factories)
{
try
{
var ins = Activator.CreateInstance(factory);
foreach (var i in factory.GetInterfaces())
{
var genericArguments = i.GetGenericArguments();
if (genericArguments.Length == 1)
{
var s = new SpriteDataProviderFactory();
s.instance = ins;
var method = i.GetMethod("CreateDataProvider");
s.method = method;
s.methodType = genericArguments[0];
factoryList.Add(s);
}
}
}
catch (Exception ex)
{
Debug.LogAssertion(ex);
}
}
m_Factories = factoryList.ToArray();
m_AssetPathProvider = EditorAssemblies.GetAllMethodsWithAttribute <SpriteEditorAssetPathProviderAttribute>(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).ToArray();
m_SpriteObjectProvider = EditorAssemblies.GetAllMethodsWithAttribute <SpriteObjectProviderAttribute>(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).ToArray();
}
public void ApplyActiveProfile()
{
m_ActiveProfile = new ShortcutProfile(k_UserProfileId);
ApplyProfile(m_ActiveProfile);
MigrateUserSpecifiedPrefKeys(
EditorAssemblies.GetAllMethodsWithAttribute <FormerlyPrefKeyAsAttribute>(), m_Entries
);
}
private static void GetCreateTileFromPaletteAttributeMethods()
{
m_CreateTileFromPaletteMethods = new List <MethodInfo>();
foreach (var sortingMethod in EditorAssemblies.GetAllMethodsWithAttribute <CreateTileFromPaletteAttribute>())
{
m_CreateTileFromPaletteMethods.Add(sortingMethod);
}
}
public IEnumerable <IShortcutEntryDiscoveryInfo> GetDefinedShortcuts()
{
const BindingFlags staticMethodsBindings = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
var methods = EditorAssemblies.GetAllMethodsWithAttribute <ShortcutBaseAttribute>(staticMethodsBindings);
var results = new List <IShortcutEntryDiscoveryInfo>(methods.Count());
foreach (var methodInfo in methods)
{
var attributes = (ShortcutBaseAttribute[])methodInfo.GetCustomAttributes(typeof(ShortcutBaseAttribute), true);
foreach (var attribute in attributes)
{
var discoveredAttributeEntry = new ShortcutAttributeEntryInfo(methodInfo, attribute);
results.Add(discoveredAttributeEntry);
}
}
return(results);
}
public IEnumerable <ShortcutEntry> GetAllShortcuts()
{
var staticMethodsBindings = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
var methods = EditorAssemblies.GetAllMethodsWithAttribute <ShortcutAttribute>(staticMethodsBindings);
var results = new List <ShortcutEntry>(methods.Count());
foreach (var methodInfo in methods)
{
var attributes = (ShortcutAttribute[])methodInfo.GetCustomAttributes(typeof(ShortcutAttribute), true);
foreach (var attribute in attributes)
{
var shortcutEntry = ShortcutEntry.CreateFromAttribute(methodInfo, attribute);
results.Add(shortcutEntry);
}
}
return(results);
}
internal static void InitializeBuildCallbacks(BuildCallbacks findFlags)
{
if (findFlags == previousFlags)
{
return;
}
CleanupBuildCallbacks();
previousFlags = findFlags;
bool findBuildProcessors = (findFlags & BuildCallbacks.BuildProcessors) == BuildCallbacks.BuildProcessors;
bool findSceneProcessors = (findFlags & BuildCallbacks.SceneProcessors) == BuildCallbacks.SceneProcessors;
bool findTargetProcessors = (findFlags & BuildCallbacks.BuildTargetProcessors) == BuildCallbacks.BuildTargetProcessors;
bool findFilterProcessors = (findFlags & BuildCallbacks.FilterAssembliesProcessors) == BuildCallbacks.FilterAssembliesProcessors;
bool findShaderProcessors = (findFlags & BuildCallbacks.ShaderProcessors) == BuildCallbacks.ShaderProcessors;
var postProcessBuildAttributeParams = new Type[] { typeof(BuildTarget), typeof(string) };
foreach (var t in EditorAssemblies.GetAllTypesWithInterface <IOrderedCallback>())
{
if (t.IsAbstract || t.IsInterface)
{
continue;
}
// Defer creating the instance until we actually add it to one of the lists
object instance = null;
if (findBuildProcessors)
{
AddToListIfTypeImplementsInterface(t, ref instance, ref processors.buildPreprocessors);
AddToListIfTypeImplementsInterface(t, ref instance, ref processors.buildPreprocessorsWithReport);
AddToListIfTypeImplementsInterface(t, ref instance, ref processors.buildPostprocessors);
AddToListIfTypeImplementsInterface(t, ref instance, ref processors.buildPostprocessorsWithReport);
}
if (findSceneProcessors)
{
AddToListIfTypeImplementsInterface(t, ref instance, ref processors.sceneProcessors);
AddToListIfTypeImplementsInterface(t, ref instance, ref processors.sceneProcessorsWithReport);
}
if (findTargetProcessors)
{
AddToListIfTypeImplementsInterface(t, ref instance, ref processors.buildTargetProcessors);
}
if (findFilterProcessors)
{
AddToListIfTypeImplementsInterface(t, ref instance, ref processors.filterBuildAssembliesProcessor);
}
if (findShaderProcessors)
{
AddToListIfTypeImplementsInterface(t, ref instance, ref processors.shaderProcessors);
}
}
if (findBuildProcessors)
{
foreach (var m in EditorAssemblies.GetAllMethodsWithAttribute <Callbacks.PostProcessBuildAttribute>())
{
if (ValidateMethod <Callbacks.PostProcessBuildAttribute>(m, postProcessBuildAttributeParams))
{
AddToList(new AttributeCallbackWrapper(m), ref processors.buildPostprocessorsWithReport);
}
}
}
if (findSceneProcessors)
{
foreach (var m in EditorAssemblies.GetAllMethodsWithAttribute <Callbacks.PostProcessSceneAttribute>())
{
if (ValidateMethod <Callbacks.PostProcessSceneAttribute>(m, Type.EmptyTypes))
{
AddToList(new AttributeCallbackWrapper(m), ref processors.sceneProcessorsWithReport);
}
}
}
if (processors.buildPreprocessors != null)
{
processors.buildPreprocessors.Sort(CompareICallbackOrder);
}
if (processors.buildPreprocessorsWithReport != null)
{
processors.buildPreprocessorsWithReport.Sort(CompareICallbackOrder);
}
if (processors.buildPostprocessors != null)
{
processors.buildPostprocessors.Sort(CompareICallbackOrder);
}
if (processors.buildPostprocessorsWithReport != null)
{
processors.buildPostprocessorsWithReport.Sort(CompareICallbackOrder);
}
if (processors.buildTargetProcessors != null)
{
processors.buildTargetProcessors.Sort(CompareICallbackOrder);
}
if (processors.sceneProcessors != null)
{
processors.sceneProcessors.Sort(CompareICallbackOrder);
}
if (processors.sceneProcessorsWithReport != null)
{
processors.sceneProcessorsWithReport.Sort(CompareICallbackOrder);
}
if (processors.filterBuildAssembliesProcessor != null)
{
processors.filterBuildAssembliesProcessor.Sort(CompareICallbackOrder);
}
if (processors.shaderProcessors != null)
{
processors.shaderProcessors.Sort(CompareICallbackOrder);
}
}
internal static void InitializeBuildCallbacks(BuildCallbacks findFlags)
{
if (findFlags == previousFlags)
{
return;
}
CleanupBuildCallbacks();
previousFlags = findFlags;
bool findBuildProcessors = (findFlags & BuildCallbacks.BuildProcessors) == BuildCallbacks.BuildProcessors;
bool findSceneProcessors = (findFlags & BuildCallbacks.SceneProcessors) == BuildCallbacks.SceneProcessors;
bool findTargetProcessors = (findFlags & BuildCallbacks.BuildTargetProcessors) == BuildCallbacks.BuildTargetProcessors;
var postProcessBuildAttributeParams = new Type[] { typeof(BuildTarget), typeof(string) };
foreach (var t in EditorAssemblies.GetAllTypesWithInterface <IOrderedCallback>())
{
if (t.IsAbstract || t.IsInterface)
{
continue;
}
object instance = null;
if (findBuildProcessors)
{
if (ValidateType <IPreprocessBuild>(t))
{
AddToList(instance = Activator.CreateInstance(t), ref buildPreprocessors);
}
if (ValidateType <IPostprocessBuild>(t))
{
AddToList(instance = instance == null ? Activator.CreateInstance(t) : instance, ref buildPostprocessors);
}
}
if (findSceneProcessors && ValidateType <IProcessScene>(t))
{
AddToList(instance = instance == null ? Activator.CreateInstance(t) : instance, ref sceneProcessors);
}
if (findTargetProcessors && ValidateType <IActiveBuildTargetChanged>(t))
{
AddToList(instance = instance == null ? Activator.CreateInstance(t) : instance, ref buildTargetProcessors);
}
}
if (findBuildProcessors)
{
foreach (var m in EditorAssemblies.GetAllMethodsWithAttribute <Callbacks.PostProcessBuildAttribute>())
{
if (ValidateMethod <Callbacks.PostProcessBuildAttribute>(m, postProcessBuildAttributeParams))
{
AddToList(new AttributeCallbackWrapper(m), ref buildPostprocessors);
}
}
}
if (findSceneProcessors)
{
foreach (var m in EditorAssemblies.GetAllMethodsWithAttribute <Callbacks.PostProcessSceneAttribute>())
{
if (ValidateMethod <Callbacks.PostProcessSceneAttribute>(m, Type.EmptyTypes))
{
AddToList(new AttributeCallbackWrapper(m), ref sceneProcessors);
}
}
}
if (buildPreprocessors != null)
{
buildPreprocessors.Sort(CompareICallbackOrder);
}
if (buildPostprocessors != null)
{
buildPostprocessors.Sort(CompareICallbackOrder);
}
if (buildTargetProcessors != null)
{
buildTargetProcessors.Sort(CompareICallbackOrder);
}
if (sceneProcessors != null)
{
sceneProcessors.Sort(CompareICallbackOrder);
}
}
void MigrateUserSpecifiedPrefKeys()
{
// If migration already happened then don't do anything
if (EditorPrefs.GetBool(k_ProfileMigratedEditorPrefKey, false))
{
return;
}
EditorPrefs.SetBool(k_ProfileMigratedEditorPrefKey, true);
// Find shortcut entries that might need to be migrated
var allShortcuts = new List <ShortcutEntry>();
directory.GetAllShortcuts(allShortcuts);
// Find existing or create migrated profile and make it active so we can amend it
var originalActiveProfile = profileManager.activeProfile;
var migratedProfile = profileManager.GetProfileById(k_MigratedProfileId);
var migratedProfileAlreadyExisted = migratedProfile != null;
if (!migratedProfileAlreadyExisted)
{
migratedProfile = profileManager.CreateProfile(k_MigratedProfileId);
}
profileManager.activeProfile = migratedProfile;
var migratedProfileModified = false;
var tempKeyCombinations = new KeyCombination[1];
var methodsWithFormerlyPrefKeyAs = EditorAssemblies.GetAllMethodsWithAttribute <FormerlyPrefKeyAsAttribute>();
foreach (var method in methodsWithFormerlyPrefKeyAs)
{
var shortcutAttr = Attribute.GetCustomAttribute(method, typeof(ShortcutAttribute), true) as ShortcutAttribute;
if (shortcutAttr == null)
{
continue;
}
var entry = allShortcuts.Find(e => string.Equals(e.identifier.path, shortcutAttr.identifier));
if (entry == null)
{
continue;
}
// Ignore former PrefKey if it is overriden in existing migrated profile
if (entry.overridden)
{
continue;
}
// Parse default pref key value from FormerlyPrefKeyAs attribute
var prefKeyAttr = (FormerlyPrefKeyAsAttribute)Attribute.GetCustomAttribute(method, typeof(FormerlyPrefKeyAsAttribute));
var editorPrefDefaultValue = $"{prefKeyAttr.name};{prefKeyAttr.defaultValue}";
string name;
Event keyboardEvent;
string shortcut;
if (!TryParseUniquePrefKeyString(editorPrefDefaultValue, out name, out keyboardEvent, out shortcut))
{
continue;
}
var prefKeyDefaultKeyCombination = KeyCombination.FromPrefKeyKeyboardEvent(keyboardEvent);
// Parse current pref key value (falling back on default pref key value)
if (!TryParseUniquePrefKeyString(EditorPrefs.GetString(prefKeyAttr.name, editorPrefDefaultValue), out name, out keyboardEvent, out shortcut))
{
continue;
}
var prefKeyCurrentKeyCombination = KeyCombination.FromPrefKeyKeyboardEvent(keyboardEvent);
// Only migrate pref keys that the user actually overwrote
if (prefKeyCurrentKeyCombination.Equals(prefKeyDefaultKeyCombination))
{
continue;
}
string invalidBindingMessage;
tempKeyCombinations[0] = prefKeyCurrentKeyCombination;
if (!bindingValidator.IsBindingValid(tempKeyCombinations, out invalidBindingMessage))
{
Debug.LogWarning($"Could not migrate existing binding for shortcut \"{entry.identifier.path}\" with invalid binding.\n{invalidBindingMessage}.");
continue;
}
profileManager.ModifyShortcutEntry(entry.identifier, new List <KeyCombination> {
prefKeyCurrentKeyCombination
});
migratedProfileModified = true;
}
// Delete migrated profile if it was created and not modified
if (!migratedProfileAlreadyExisted && !migratedProfileModified)
{
profileManager.DeleteProfile(migratedProfile);
}
// Restore original active profile unless last loaded profile was null and the migrated profile was created
if (originalActiveProfile != null || migratedProfileAlreadyExisted)
{
profileManager.activeProfile = originalActiveProfile;
}
}
internal static void InitializeBuildCallbacks(BuildPipelineInterfaces.BuildCallbacks findFlags)
{
if (findFlags != BuildPipelineInterfaces.previousFlags)
{
BuildPipelineInterfaces.previousFlags = findFlags;
BuildPipelineInterfaces.CleanupBuildCallbacks();
bool flag = (findFlags & BuildPipelineInterfaces.BuildCallbacks.BuildProcessors) == BuildPipelineInterfaces.BuildCallbacks.BuildProcessors;
bool flag2 = (findFlags & BuildPipelineInterfaces.BuildCallbacks.SceneProcessors) == BuildPipelineInterfaces.BuildCallbacks.SceneProcessors;
bool flag3 = (findFlags & BuildPipelineInterfaces.BuildCallbacks.BuildTargetProcessors) == BuildPipelineInterfaces.BuildCallbacks.BuildTargetProcessors;
Type[] expectedArguments = new Type[]
{
typeof(BuildTarget),
typeof(string)
};
foreach (Type current in EditorAssemblies.GetAllTypesWithInterface <IOrderedCallback>())
{
if (!current.IsAbstract && !current.IsInterface)
{
object obj = null;
if (flag)
{
if (BuildPipelineInterfaces.ValidateType <IPreprocessBuild>(current))
{
BuildPipelineInterfaces.AddToList <IPreprocessBuild>(obj = Activator.CreateInstance(current), ref BuildPipelineInterfaces.buildPreprocessors);
}
if (BuildPipelineInterfaces.ValidateType <IPostprocessBuild>(current))
{
BuildPipelineInterfaces.AddToList <IPostprocessBuild>(obj = ((obj != null) ? obj : Activator.CreateInstance(current)), ref BuildPipelineInterfaces.buildPostprocessors);
}
}
if (flag2 && BuildPipelineInterfaces.ValidateType <IProcessScene>(current))
{
BuildPipelineInterfaces.AddToList <IProcessScene>(obj = ((obj != null) ? obj : Activator.CreateInstance(current)), ref BuildPipelineInterfaces.sceneProcessors);
}
if (flag3 && BuildPipelineInterfaces.ValidateType <IActiveBuildTargetChanged>(current))
{
BuildPipelineInterfaces.AddToList <IActiveBuildTargetChanged>((obj != null) ? obj : Activator.CreateInstance(current), ref BuildPipelineInterfaces.buildTargetProcessors);
}
}
}
if (flag)
{
foreach (MethodInfo current2 in EditorAssemblies.GetAllMethodsWithAttribute <PostProcessBuildAttribute>(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
{
if (BuildPipelineInterfaces.ValidateMethod <PostProcessBuildAttribute>(current2, expectedArguments))
{
BuildPipelineInterfaces.AddToList <IPostprocessBuild>(new BuildPipelineInterfaces.AttributeCallbackWrapper(current2), ref BuildPipelineInterfaces.buildPostprocessors);
}
}
}
if (flag2)
{
foreach (MethodInfo current3 in EditorAssemblies.GetAllMethodsWithAttribute <PostProcessSceneAttribute>(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
{
if (BuildPipelineInterfaces.ValidateMethod <PostProcessSceneAttribute>(current3, Type.EmptyTypes))
{
BuildPipelineInterfaces.AddToList <IProcessScene>(new BuildPipelineInterfaces.AttributeCallbackWrapper(current3), ref BuildPipelineInterfaces.sceneProcessors);
}
}
}
if (BuildPipelineInterfaces.buildPreprocessors != null)
{
List <IPreprocessBuild> arg_263_0 = BuildPipelineInterfaces.buildPreprocessors;
if (BuildPipelineInterfaces.< > f__mg$cache0 == null)
{
BuildPipelineInterfaces.< > f__mg$cache0 = new Comparison <IPreprocessBuild>(BuildPipelineInterfaces.CompareICallbackOrder);
}
arg_263_0.Sort(BuildPipelineInterfaces.< > f__mg$cache0);
}
if (BuildPipelineInterfaces.buildPostprocessors != null)
{
List <IPostprocessBuild> arg_294_0 = BuildPipelineInterfaces.buildPostprocessors;
if (BuildPipelineInterfaces.< > f__mg$cache1 == null)
{
BuildPipelineInterfaces.< > f__mg$cache1 = new Comparison <IPostprocessBuild>(BuildPipelineInterfaces.CompareICallbackOrder);
}
arg_294_0.Sort(BuildPipelineInterfaces.< > f__mg$cache1);
}
if (BuildPipelineInterfaces.buildTargetProcessors != null)
{
List <IActiveBuildTargetChanged> arg_2C5_0 = BuildPipelineInterfaces.buildTargetProcessors;
if (BuildPipelineInterfaces.< > f__mg$cache2 == null)
{
BuildPipelineInterfaces.< > f__mg$cache2 = new Comparison <IActiveBuildTargetChanged>(BuildPipelineInterfaces.CompareICallbackOrder);
}
arg_2C5_0.Sort(BuildPipelineInterfaces.< > f__mg$cache2);
}
if (BuildPipelineInterfaces.sceneProcessors != null)
{
List <IProcessScene> arg_2F6_0 = BuildPipelineInterfaces.sceneProcessors;
if (BuildPipelineInterfaces.< > f__mg$cache3 == null)
{
BuildPipelineInterfaces.< > f__mg$cache3 = new Comparison <IProcessScene>(BuildPipelineInterfaces.CompareICallbackOrder);
}
arg_2F6_0.Sort(BuildPipelineInterfaces.< > f__mg$cache3);
}
}
}
