public static void GenerateDependencies2(string strippedAssemblyDir, bool doStripping, out HashSet <UnityType> nativeClasses, out HashSet <string> nativeModules) { var dataFromLinker = AssemblyStripper.ReadLinkerToEditorData(strippedAssemblyDir); nativeClasses = doStripping ? new HashSet <UnityType>() : null; nativeModules = new HashSet <string>(); foreach (var module in dataFromLinker.report.modules) { nativeModules.Add(module.name); if (doStripping) { foreach (var dependency in module.dependencies) { var unityType = UnityType.FindTypeByName(dependency.name); if (unityType != null) { nativeClasses.Add(unityType); } } } } }
// When switching to explicitly defined clips, we must fix up the internalID's to not lose AnimationClip references. // When m_ClipAnimations is defined, the clips are identified by the clipName // When m_ClipAnimations is not defined, the clips are identified by the takeName void PatchDefaultClipTakeNamesToSplitClipNames() { foreach (TakeInfo takeInfo in singleImporter.importedTakeInfos) { UnityType animationClipType = UnityType.FindTypeByName("AnimationClip"); ImportSettingInternalID.Rename(serializedObject, animationClipType, takeInfo.name, takeInfo.defaultClipName); } }
static void GetAnnotationIdAndClass(Type type, out int id, out string klass) { var unityType = UnityType.FindTypeByName(type.Name); id = unityType?.persistentTypeID ?? 0; // In AnnotationManager, if script name is null or empty the persistent ID is used. If not, the type is // assumed to be a built-in type. klass = unityType == null ? type.Name : null; }
private static HashSet <UnityType> GenerateNativeClassList(RuntimeClassRegistry rcr, string directory, string[] rootAssemblies, StrippingInfo strippingInfo) { if (AssemblyStripper.UseUnityLinkerEngineModuleStripping) { throw new NotSupportedException("Don't want to rely on this method when UnityLinker EMS is used"); } HashSet <UnityType> nativeClasses = CollectNativeClassListFromRoots(directory, rootAssemblies, strippingInfo); // List native classes found in scenes foreach (string klassName in rcr.GetAllNativeClassesIncludingManagersAsString()) { UnityType klass = UnityType.FindTypeByName(klassName); if (klass != null && klass.baseClass != null) { nativeClasses.Add(klass); if (strippingInfo != null) { if (!klass.IsDerivedFrom(GameManagerTypeInfo)) { var scenes = rcr.GetScenesForClass(klass.persistentTypeID); if (scenes != null) { foreach (var scene in scenes) { strippingInfo.RegisterDependency(klassName, scene); if (scene.EndsWith(".unity")) { strippingInfo.SetIcon(scene, "class/SceneAsset"); } else { strippingInfo.SetIcon(scene, "class/AssetBundle"); } } } } } } } // Always include base classes of derived native classes. HashSet <UnityType> nativeClassesAndBaseClasses = new HashSet <UnityType>(); foreach (var klass in nativeClasses) { var current = klass; while (current.baseClass != null) { nativeClassesAndBaseClasses.Add(current); current = current.baseClass; } } return(nativeClassesAndBaseClasses); }
private static HashSet <UnityType> CollectNativeClassListFromRoots(string directory, string[] rootAssemblies, StrippingInfo strippingInfo) { HashSet <string> source = CodeStrippingUtils.CollectManagedTypeReferencesFromRoots(directory, rootAssemblies, strippingInfo); IEnumerable <UnityType> collection = from name in source select UnityType.FindTypeByName(name) into klass where klass != null && klass.baseClass != null select klass; return(new HashSet <UnityType>(collection)); }
private static UnityType FindTypeByNameChecked(string name, string msg) { UnityType result = UnityType.FindTypeByName(name); if (result == null) { throw new ArgumentException(string.Format("Could not map typename '{0}' to type info ({1})", name, msg ?? "no context")); } return(result); }
private static HashSet <UnityType> CollectNativeClassListFromRoots(string directory, string[] rootAssemblies, StrippingInfo strippingInfo) { // Collect managed types HashSet <string> managedTypeNames = CollectManagedTypeReferencesFromRoots(directory, rootAssemblies, strippingInfo); // Extract native types from managed types var infos = managedTypeNames.Select(name => UnityType.FindTypeByName(name)).Where(klass => klass != null && klass.baseClass != null); return(new HashSet <UnityType>(infos)); }
public static void InjectCustomDependencies(BuildTarget target, StrippingInfo strippingInfo, HashSet <UnityType> nativeClasses, HashSet <string> nativeModules) { // This function can be used to inject user-readable dependency information for specific classes which would not be obvious otherwise. // Can also be used to set up dependencies to modules which cannot be derived by the build pipeline without custom rules const string connectSettingsName = "UnityConnectSettings"; var connectSettings = UnityType.FindTypeByName(connectSettingsName); const string cloudWebServicesManagerName = "CloudWebServicesManager"; var cloudWebServicesManager = UnityType.FindTypeByName(cloudWebServicesManagerName); if (nativeClasses.Contains(connectSettings) || nativeClasses.Contains(cloudWebServicesManager)) { if (PlayerSettings.submitAnalytics) { const string requiredMessage = "Required by HW Statistics (See Player Settings)"; strippingInfo.RegisterDependency(connectSettingsName, requiredMessage); strippingInfo.RegisterDependency(cloudWebServicesManagerName, requiredMessage); strippingInfo.SetIcon(requiredMessage, "class/PlayerSettings"); } } const string analyticsManagerName = "UnityAnalyticsManager"; var analyticsManager = UnityType.FindTypeByName(analyticsManagerName); if (nativeClasses.Contains(analyticsManager)) { if (UnityEditor.Analytics.AnalyticsSettings.enabled) { const string requiredMessage = "Required by Unity Analytics (See Services Window)"; strippingInfo.RegisterDependency(analyticsManagerName, requiredMessage); strippingInfo.SetIcon(requiredMessage, "class/PlayerSettings"); } } if (UnityEditorInternal.VR.VRModule.ShouldInjectVRDependenciesForBuildTarget(target)) { const string moduleName = "VR"; const string requiredMessage = "Required because VR is enabled in PlayerSettings"; nativeModules.Add(moduleName); strippingInfo.RegisterDependency(StrippingInfo.ModuleName(moduleName), requiredMessage); strippingInfo.SetIcon(requiredMessage, "class/PlayerSettings"); } foreach (string module in ModuleMetadata.GetModuleNames()) { if (!ModuleMetadata.IsStrippableModule(module)) { string requiredMessage = module + " is always required"; nativeModules.Add(module); strippingInfo.AddModule(module); strippingInfo.RegisterDependency(StrippingInfo.ModuleName(module), requiredMessage); strippingInfo.SetIcon(requiredMessage, "class/DefaultAsset"); } } }
protected void AddNativeClassFromName(string className) { if (this.objectUnityType == null) { this.objectUnityType = UnityType.FindTypeByName("Object"); } UnityType unityType = UnityType.FindTypeByName(className); if (unityType != null && unityType.persistentTypeID != this.objectUnityType.persistentTypeID) { this.nativeClasses[unityType.persistentTypeID] = className; } }
public void AddNativeClassFromName(string className) { if (objectUnityType == null) { objectUnityType = UnityType.FindTypeByName("Object"); } var t = UnityType.FindTypeByName(className); ////System.Console.WriteLine("Looking for name {1} ID {0}", classID, className); if (t != null && t.persistentTypeID != objectUnityType.persistentTypeID) { allNativeClasses[t.persistentTypeID] = className; } }
private static HashSet <UnityType> CollectNativeClassListFromRoots(string directory, string[] rootAssemblies, StrippingInfo strippingInfo) { if (AssemblyStripper.UseUnityLinkerEngineModuleStripping) { throw new NotSupportedException("Don't want to rely on this method when UnityLinker EMS is used"); } // Collect managed types HashSet <string> managedTypeNames = CollectManagedTypeReferencesFromRoots(directory, rootAssemblies, strippingInfo); // Extract native types from managed types var infos = managedTypeNames.Select(name => UnityType.FindTypeByName(name)).Where(klass => klass != null && klass.baseClass != null); return(new HashSet <UnityType>(infos)); }
public static void InjectCustomDependencies(StrippingInfo strippingInfo, HashSet <UnityType> nativeClasses) { UnityType item = UnityType.FindTypeByName("UnityAnalyticsManager"); if (nativeClasses.Contains(item)) { if (PlayerSettings.submitAnalytics) { strippingInfo.RegisterDependency("UnityAnalyticsManager", "Required by HW Statistics (See Player Settings)"); strippingInfo.SetIcon("Required by HW Statistics (See Player Settings)", "class/PlayerSettings"); } if (AnalyticsSettings.enabled) { strippingInfo.RegisterDependency("UnityAnalyticsManager", "Required by Unity Analytics (See Services Window)"); strippingInfo.SetIcon("Required by Unity Analytics (See Services Window)", "class/PlayerSettings"); } } }
public static void InjectCustomDependencies(BuildTarget target, StrippingInfo strippingInfo, HashSet <UnityType> nativeClasses, HashSet <string> nativeModules) { UnityType item = UnityType.FindTypeByName("UnityConnectSettings"); UnityType item2 = UnityType.FindTypeByName("CloudWebServicesManager"); if (nativeClasses.Contains(item) || nativeClasses.Contains(item2)) { if (PlayerSettings.submitAnalytics) { strippingInfo.RegisterDependency("UnityConnectSettings", "Required by HW Statistics (See Player Settings)"); strippingInfo.RegisterDependency("CloudWebServicesManager", "Required by HW Statistics (See Player Settings)"); strippingInfo.SetIcon("Required by HW Statistics (See Player Settings)", "class/PlayerSettings"); } } UnityType item3 = UnityType.FindTypeByName("UnityAnalyticsManager"); if (nativeClasses.Contains(item3)) { if (AnalyticsSettings.enabled) { strippingInfo.RegisterDependency("UnityAnalyticsManager", "Required by Unity Analytics (See Services Window)"); strippingInfo.SetIcon("Required by Unity Analytics (See Services Window)", "class/PlayerSettings"); } } if (VRModule.ShouldInjectVRDependenciesForBuildTarget(target)) { nativeModules.Add("VR"); strippingInfo.RegisterDependency(StrippingInfo.ModuleName("VR"), "Required because VR is enabled in PlayerSettings"); strippingInfo.SetIcon("Required because VR is enabled in PlayerSettings", "class/PlayerSettings"); } string[] moduleNames = ModuleMetadata.GetModuleNames(); for (int i = 0; i < moduleNames.Length; i++) { string text = moduleNames[i]; if (!ModuleMetadata.IsStrippableModule(text)) { string text2 = text + " is always required"; nativeModules.Add(text); strippingInfo.AddModule(text, true); strippingInfo.RegisterDependency(StrippingInfo.ModuleName(text), text2); strippingInfo.SetIcon(text2, "class/DefaultAsset"); } } }
public static void InjectCustomDependencies(BuildTarget target, StrippingInfo strippingInfo, HashSet <UnityType> nativeClasses, HashSet <string> nativeModules) { UnityType item = UnityType.FindTypeByName("UnityAnalyticsManager"); if (nativeClasses.Contains(item)) { if (PlayerSettings.submitAnalytics) { strippingInfo.RegisterDependency("UnityAnalyticsManager", "Required by HW Statistics (See Player Settings)"); strippingInfo.SetIcon("Required by HW Statistics (See Player Settings)", "class/PlayerSettings"); } if (AnalyticsSettings.enabled) { strippingInfo.RegisterDependency("UnityAnalyticsManager", "Required by Unity Analytics (See Services Window)"); strippingInfo.SetIcon("Required by Unity Analytics (See Services Window)", "class/PlayerSettings"); } } if (CodeStrippingUtils.IsVRModuleUsed(target)) { nativeModules.Add("VR"); strippingInfo.RegisterDependency("VR", "Required by Scripts"); strippingInfo.SetIcon("Required because VR is enabled in PlayerSettings", "class/PlayerSettings"); } }
private static void ShowAssetsPopupMenu <T>(Rect buttonRect, string typeName, SerializedProperty serializedProperty, string fileExtension, string defaultFieldName) where T : UnityEngine.Object, new() { GenericMenu genericMenu = new GenericMenu(); int num = (!(serializedProperty.objectReferenceValue != null)) ? 0 : serializedProperty.objectReferenceValue.GetInstanceID(); bool flag = false; UnityType unityType = UnityType.FindTypeByName(typeName); int num2 = (unityType == null) ? 0 : unityType.persistentTypeID; BuiltinResource[] array = null; if (num2 > 0) { array = EditorGUIUtility.GetBuiltinResourceList(num2); BuiltinResource[] array2 = array; for (int i = 0; i < array2.Length; i++) { BuiltinResource resource = array2[i]; if (resource.m_Name == defaultFieldName) { GenericMenu arg_124_0 = genericMenu; GUIContent arg_124_1 = new GUIContent(resource.m_Name); bool arg_124_2 = resource.m_InstanceID == num; if (AssetPopupBackend.< > f__mg$cache0 == null) { AssetPopupBackend.< > f__mg$cache0 = new GenericMenu.MenuFunction2(AssetPopupBackend.AssetPopupMenuCallback); } arg_124_0.AddItem(arg_124_1, arg_124_2, AssetPopupBackend.< > f__mg$cache0, new object[] { resource.m_InstanceID, serializedProperty }); array = (from x in array where x != resource select x).ToArray <BuiltinResource>(); flag = true; break; } } } if (!flag) { GenericMenu arg_1A6_0 = genericMenu; GUIContent arg_1A6_1 = new GUIContent(defaultFieldName); bool arg_1A6_2 = num == 0; if (AssetPopupBackend.< > f__mg$cache1 == null) { AssetPopupBackend.< > f__mg$cache1 = new GenericMenu.MenuFunction2(AssetPopupBackend.AssetPopupMenuCallback); } arg_1A6_0.AddItem(arg_1A6_1, arg_1A6_2, AssetPopupBackend.< > f__mg$cache1, new object[] { 0, serializedProperty }); } HierarchyProperty hierarchyProperty = new HierarchyProperty(HierarchyType.Assets); SearchFilter searchFilter = new SearchFilter { classNames = new string[] { typeName } }; hierarchyProperty.SetSearchFilter(searchFilter); hierarchyProperty.Reset(); while (hierarchyProperty.Next(null)) { GenericMenu arg_23D_0 = genericMenu; GUIContent arg_23D_1 = new GUIContent(hierarchyProperty.name); bool arg_23D_2 = hierarchyProperty.instanceID == num; if (AssetPopupBackend.< > f__mg$cache2 == null) { AssetPopupBackend.< > f__mg$cache2 = new GenericMenu.MenuFunction2(AssetPopupBackend.AssetPopupMenuCallback); } arg_23D_0.AddItem(arg_23D_1, arg_23D_2, AssetPopupBackend.< > f__mg$cache2, new object[] { hierarchyProperty.instanceID, serializedProperty }); } if (num2 > 0 && array != null) { BuiltinResource[] array3 = array; for (int j = 0; j < array3.Length; j++) { BuiltinResource builtinResource = array3[j]; GenericMenu arg_2C7_0 = genericMenu; GUIContent arg_2C7_1 = new GUIContent(builtinResource.m_Name); bool arg_2C7_2 = builtinResource.m_InstanceID == num; if (AssetPopupBackend.< > f__mg$cache3 == null) { AssetPopupBackend.< > f__mg$cache3 = new GenericMenu.MenuFunction2(AssetPopupBackend.AssetPopupMenuCallback); } arg_2C7_0.AddItem(arg_2C7_1, arg_2C7_2, AssetPopupBackend.< > f__mg$cache3, new object[] { builtinResource.m_InstanceID, serializedProperty }); } } genericMenu.AddSeparator(""); genericMenu.AddItem(new GUIContent("Create New..."), false, delegate { T t = Activator.CreateInstance <T>(); ProjectWindowUtil.CreateAsset(t, "New " + typeName + "." + fileExtension); serializedProperty.objectReferenceValue = t; serializedProperty.m_SerializedObject.ApplyModifiedProperties(); }); genericMenu.DropDown(buttonRect); }
void AnimationSplitTable() { if (m_ClipList == null) { m_ClipList = new ReorderableList(new List <AnimationClipInfoProperties>(), typeof(string), false, true, true, true); m_ClipList.onAddCallback = AddClipInList; m_ClipList.onSelectCallback = SelectClipInList; m_ClipList.onRemoveCallback = RemoveClipInList; m_ClipList.drawElementCallback = DrawClipElement; m_ClipList.drawHeaderCallback = DrawClipHeader; m_ClipList.elementHeight = 16; UpdateList(); m_ClipList.index = selectedClipIndex; } m_ClipList.DoLayoutList(); EditorGUI.BeginChangeCheck(); // Show selected clip info { AnimationClipInfoProperties clip = GetSelectedClipInfo(); if (clip == null) { return; } if (m_AnimationClipEditor != null && selectedClipIndex != -1) { GUILayout.Space(5); AnimationClip actualClip = m_AnimationClipEditor.target as AnimationClip; if (!actualClip.legacy) { GetSelectedClipInfo().AssignToPreviewClip(actualClip); } TakeInfo[] importedTakeInfos = singleImporter.importedTakeInfos; string[] takeNames = new string[importedTakeInfos.Length]; for (int i = 0; i < importedTakeInfos.Length; i++) { takeNames[i] = importedTakeInfos[i].name; } EditorGUI.BeginChangeCheck(); string currentName = clip.name; int takeIndex = ArrayUtility.IndexOf(takeNames, clip.takeName); m_AnimationClipEditor.takeNames = takeNames; m_AnimationClipEditor.takeIndex = ArrayUtility.IndexOf(takeNames, clip.takeName); m_AnimationClipEditor.DrawHeader(); if (EditorGUI.EndChangeCheck()) { clip.name = clip.name.Trim(); if (clip.name == String.Empty) { clip.name = currentName; } // We renamed the clip name, try to maintain the localIdentifierInFile so we don't lose any data. if (clip.name != currentName) { var newName = clip.name; clip.name = currentName; clip.name = MakeUniqueClipName(newName); TransferDefaultClipsToCustomClips(); UnityType animationClipType = UnityType.FindTypeByName("AnimationClip"); ImportSettingInternalID.Rename(serializedObject, animationClipType, currentName, clip.name); } int newTakeIndex = m_AnimationClipEditor.takeIndex; if (newTakeIndex != -1 && newTakeIndex != takeIndex) { clip.name = MakeUniqueClipName(takeNames[newTakeIndex]); SetupTakeNameAndFrames(clip, importedTakeInfos[newTakeIndex]); GUIUtility.keyboardControl = 0; SelectClip(selectedClipIndex); // actualClip has been changed by SelectClip actualClip = m_AnimationClipEditor.target as AnimationClip; } } m_AnimationClipEditor.OnInspectorGUI(); AvatarMaskSettings(GetSelectedClipInfo()); if (!actualClip.legacy) { GetSelectedClipInfo().ExtractFromPreviewClip(actualClip); } } } if (EditorGUI.EndChangeCheck() || m_AnimationClipEditor.needsToGenerateClipInfo) { TransferDefaultClipsToCustomClips(); m_AnimationClipEditor.needsToGenerateClipInfo = false; } }
private static HashSet <UnityType> GenerateNativeClassList(RuntimeClassRegistry rcr, string directory, string[] rootAssemblies, StrippingInfo strippingInfo) { HashSet <UnityType> hashSet = CodeStrippingUtils.CollectNativeClassListFromRoots(directory, rootAssemblies, strippingInfo); UnityType[] blackListNativeClasses = CodeStrippingUtils.BlackListNativeClasses; for (int i = 0; i < blackListNativeClasses.Length; i++) { UnityType item = blackListNativeClasses[i]; hashSet.Add(item); } foreach (UnityType current in CodeStrippingUtils.BlackListNativeClassesDependency.Keys) { if (hashSet.Contains(current)) { UnityType item2 = CodeStrippingUtils.BlackListNativeClassesDependency[current]; hashSet.Add(item2); } } foreach (string current2 in rcr.GetAllNativeClassesIncludingManagersAsString()) { UnityType unityType = UnityType.FindTypeByName(current2); if (unityType != null && unityType.baseClass != null) { hashSet.Add(unityType); if (strippingInfo != null) { if (!unityType.IsDerivedFrom(CodeStrippingUtils.GameManagerTypeInfo)) { List <string> scenesForClass = rcr.GetScenesForClass(unityType.persistentTypeID); if (scenesForClass != null) { foreach (string current3 in scenesForClass) { strippingInfo.RegisterDependency(current2, current3); if (current3.EndsWith(".unity")) { strippingInfo.SetIcon(current3, "class/SceneAsset"); } else { strippingInfo.SetIcon(current3, "class/AssetBundle"); } } } } } } } HashSet <UnityType> hashSet2 = new HashSet <UnityType>(); foreach (UnityType current4 in hashSet) { UnityType unityType2 = current4; while (unityType2.baseClass != null) { hashSet2.Add(unityType2); unityType2 = unityType2.baseClass; } } return(hashSet2); }
private static HashSet <UnityType> GenerateNativeClassList(RuntimeClassRegistry rcr, string directory, string[] rootAssemblies, StrippingInfo strippingInfo) { HashSet <UnityType> nativeClasses = CollectNativeClassListFromRoots(directory, rootAssemblies, strippingInfo); // Inject blacklisted native types foreach (var klass in BlackListNativeClasses) { nativeClasses.Add(klass); } foreach (var dependent in BlackListNativeClassesDependency.Keys) { if (nativeClasses.Contains(dependent)) { var provider = BlackListNativeClassesDependency[dependent]; nativeClasses.Add(provider); } } // List native classes found in scenes foreach (string klassName in rcr.GetAllNativeClassesIncludingManagersAsString()) { UnityType klass = UnityType.FindTypeByName(klassName); if (klass != null && klass.baseClass != null) { nativeClasses.Add(klass); if (strippingInfo != null) { if (!klass.IsDerivedFrom(GameManagerTypeInfo)) { var scenes = rcr.GetScenesForClass(klass.persistentTypeID); if (scenes != null) { foreach (var scene in scenes) { strippingInfo.RegisterDependency(klassName, scene); if (scene.EndsWith(".unity")) { strippingInfo.SetIcon(scene, "class/SceneAsset"); } else { strippingInfo.SetIcon(scene, "class/AssetBundle"); } } } } } } } // Always include base classes of derived native classes. HashSet <UnityType> nativeClassesAndBaseClasses = new HashSet <UnityType>(); foreach (var klass in nativeClasses) { var current = klass; while (current.baseClass != null) { nativeClassesAndBaseClasses.Add(current); current = current.baseClass; } } return(nativeClassesAndBaseClasses); }