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