public static UnityType FindTypeByName(string name)
{
UnityType result = null;
UnityType.ms_nameToTypeInfo.TryGetValue(name, out result);
return(result);
}
public static void GenerateRegisterClassesForStripping(HashSet <UnityType> nativeClassesAndBaseClasses, TextWriter output)
{
output.WriteLine("template <typename T> void RegisterClass();");
output.WriteLine("template <typename T> void RegisterStrippedTypeInfo(int, const char*, const char*);");
output.WriteLine();
foreach (UnityType current in UnityType.GetTypes())
{
if (current.baseClass != null && !current.isEditorOnly)
{
if (current.hasNativeNamespace)
{
output.WriteLine("class {0};", current.name);
}
else
{
output.WriteLine("namespace {0} {{ class {1}; }}", current.nativeNamespace, current.name);
}
output.WriteLine();
}
}
output.Write("void RegisterAllClasses() \n{\n");
output.WriteLine("\tvoid RegisterBuiltinTypes();");
output.WriteLine("\tRegisterBuiltinTypes();");
output.WriteLine("\t// Non stripped classes");
foreach (UnityType current2 in UnityType.GetTypes())
{
if (current2.baseClass != null && !current2.isEditorOnly && nativeClassesAndBaseClasses.Contains(current2))
{
output.WriteLine("\tRegisterClass<{0}>();", current2.qualifiedName);
}
}
output.WriteLine();
output.Write("\n}\n");
}
public static UnityType FindTypeByPersistentTypeID(int id)
{
UnityType result = null;
UnityType.ms_idToTypeInfo.TryGetValue(id, out result);
return(result);
}
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);
}
}
}
}
}
static UnityType()
{
UnityType.UnityTypeTransport[] array = UnityType.Internal_GetAllTypes();
UnityType.ms_types = new UnityType[array.Length];
UnityType.ms_idToTypeInfo = new Dictionary <int, UnityType>();
UnityType.ms_nameToTypeInfo = new Dictionary <string, UnityType>();
for (int i = 0; i < array.Length; i++)
{
UnityType baseClass = null;
if ((ulong)array[i].baseClassIndex < (ulong)((long)array.Length))
{
baseClass = UnityType.ms_types[(int)((UIntPtr)array[i].baseClassIndex)];
}
UnityType unityType = new UnityType
{
runtimeTypeIndex = array[i].runtimeTypeIndex,
descendantCount = array[i].descendantCount,
name = array[i].className,
nativeNamespace = array[i].classNamespace,
persistentTypeID = array[i].persistentTypeID,
baseClass = baseClass,
flags = (UnityTypeFlags)array[i].flags
};
UnityType.ms_types[i] = unityType;
UnityType.ms_typesReadOnly = new ReadOnlyCollection <UnityType>(UnityType.ms_types);
UnityType.ms_idToTypeInfo[unityType.persistentTypeID] = unityType;
UnityType.ms_nameToTypeInfo[unityType.name] = unityType;
}
}
public static UnityType FindTypeByPersistentTypeID(int persistentTypeId)
{
UnityType result = null;
ms_idToType.TryGetValue(persistentTypeId, out result);
return(result);
}
// 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);
}
}
public void AddNativeClassID(int ID)
{
string name = UnityType.FindTypeByPersistentTypeID(ID).name;
if (name.Length > 0)
{
this.allNativeClasses[ID] = name;
}
}
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");
}
}
}
internal GizmoInfo(Annotation annotation)
{
m_GizmoEnabled = annotation.gizmoEnabled > 0;
m_IconEnabled = annotation.iconEnabled > 0;
m_ClassID = annotation.classID;
m_ScriptClass = annotation.scriptClass;
m_Flags = annotation.flags;
m_Name = string.IsNullOrEmpty(m_ScriptClass)
? UnityType.FindTypeByPersistentTypeID(m_ClassID).name
: m_Name = m_ScriptClass;
}
public void AddNativeClassID(int ID)
{
string className = UnityType.FindTypeByPersistentTypeID(ID).name;
////System.Console.WriteLine("Looking for ID {0} name {1} --> is manager? {2}", ID, className, functionalityGroups.ContainsValue(className));
// Native class found
if (className.Length > 0)
{
allNativeClasses[ID] = className;
}
}
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 AddNativeClassID(int ID)
{
string name = UnityType.FindTypeByPersistentTypeID(ID).name;
if (name.Length > 0)
{
this.allNativeClasses[ID] = name;
if (!this.functionalityGroups.ContainsValue(name))
{
this.nativeClasses[ID] = name;
}
}
}
public static void ApplyManualStrippingOverrides(HashSet <UnityType> nativeClasses, HashSet <string> nativeModules, StrippingInfo strippingInfo)
{
string[] moduleNames = ModuleMetadata.GetModuleNames();
for (int i = 0; i < moduleNames.Length; i++)
{
string text = moduleNames[i];
ModuleIncludeSetting moduleIncludeSettingForModule = ModuleMetadata.GetModuleIncludeSettingForModule(text);
if (moduleIncludeSettingForModule == ModuleIncludeSetting.ForceInclude)
{
nativeModules.Add(text);
UnityType[] moduleTypes = ModuleMetadata.GetModuleTypes(text);
UnityType[] array = moduleTypes;
for (int j = 0; j < array.Length; j++)
{
UnityType unityType = array[j];
nativeClasses.Add(unityType);
if (strippingInfo != null)
{
strippingInfo.RegisterDependency(unityType.name, "Force included module");
strippingInfo.RegisterDependency(StrippingInfo.ModuleName(text), unityType.name);
}
}
if (strippingInfo != null)
{
strippingInfo.RegisterDependency(StrippingInfo.ModuleName(text), "Force included module");
}
}
else if (moduleIncludeSettingForModule == ModuleIncludeSetting.ForceExclude)
{
if (nativeModules.Contains(text))
{
nativeModules.Remove(text);
UnityType[] moduleTypes2 = ModuleMetadata.GetModuleTypes(text);
UnityType[] array2 = moduleTypes2;
for (int k = 0; k < array2.Length; k++)
{
UnityType item = array2[k];
if (nativeClasses.Contains(item))
{
nativeClasses.Remove(item);
}
}
if (strippingInfo != null)
{
strippingInfo.modules.Remove(StrippingInfo.ModuleName(text));
}
}
}
}
}
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 AInfo(bool gizmoEnabled, bool iconEnabled, int flags, int classID, string scriptClass)
{
m_GizmoEnabled = gizmoEnabled;
m_IconEnabled = iconEnabled;
m_ClassID = classID;
m_ScriptClass = scriptClass;
m_Flags = flags;
if (m_ScriptClass == "")
{
m_DisplayText = UnityType.FindTypeByPersistentTypeID(m_ClassID).name;
}
else
{
m_DisplayText = m_ScriptClass;
}
}
private static void ExcludeModuleManagers(ref HashSet <UnityType> nativeClasses)
{
string[] moduleNames = ModuleMetadata.GetModuleNames();
string[] array = moduleNames;
for (int i = 0; i < array.Length; i++)
{
string moduleName = array[i];
if (ModuleMetadata.GetModuleStrippable(moduleName))
{
UnityType[] moduleTypes = ModuleMetadata.GetModuleTypes(moduleName);
HashSet <UnityType> hashSet = new HashSet <UnityType>();
HashSet <UnityType> hashSet2 = new HashSet <UnityType>();
UnityType[] array2 = moduleTypes;
for (int j = 0; j < array2.Length; j++)
{
UnityType unityType = array2[j];
if (unityType.IsDerivedFrom(CodeStrippingUtils.GameManagerTypeInfo))
{
hashSet.Add(unityType);
}
else
{
hashSet2.Add(unityType);
}
}
if (hashSet2.Count != 0)
{
if (!nativeClasses.Overlaps(hashSet2))
{
foreach (UnityType current in hashSet)
{
nativeClasses.Remove(current);
}
}
else
{
foreach (UnityType current2 in hashSet)
{
nativeClasses.Add(current2);
}
}
}
}
}
}
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");
}
}
}
static UnityType()
{
var types = UnityType.Internal_GetAllTypes();
ms_types = new UnityType[types.Length];
ms_idToType = new Dictionary <int, UnityType>();
ms_nameToType = new Dictionary <string, UnityType>();
for (int i = 0; i < types.Length; ++i)
{
// Types are sorted so base < derived and null baseclass is passed from native as 0xffffffff
UnityType baseClass = null;
if (types[i].baseClassIndex < types.Length)
{
baseClass = ms_types[types[i].baseClassIndex];
}
var newType = new UnityType
{
runtimeTypeIndex = types[i].runtimeTypeIndex,
descendantCount = types[i].descendantCount,
name = types[i].className,
nativeNamespace = types[i].classNamespace,
module = types[i].module,
persistentTypeID = types[i].persistentTypeID,
baseClass = baseClass,
flags = (UnityTypeFlags)types[i].flags
};
Debug.Assert(types[i].runtimeTypeIndex == i);
ms_types[i] = newType;
ms_typesReadOnly = new ReadOnlyCollection <UnityType>(ms_types);
ms_idToType[newType.persistentTypeID] = newType;
ms_nameToType[newType.name] = newType;
}
}
public static void GenerateRegisterClassesForStripping(HashSet <UnityType> nativeClassesAndBaseClasses, TextWriter output)
{
output.WriteLine("template <typename T> void RegisterClass();");
output.WriteLine("template <typename T> void RegisterStrippedTypeInfo(int, const char*, const char*);");
output.WriteLine();
foreach (UnityType type in UnityType.GetTypes())
{
if ((type.baseClass != null) && !type.isEditorOnly)
{
if (!type.hasNativeNamespace)
{
output.WriteLine("class {0};", type.name);
}
else
{
output.WriteLine("namespace {0} {{ class {1}; }}", type.nativeNamespace, type.name);
}
output.WriteLine();
}
}
output.Write("void RegisterAllClasses() \n{\n");
output.WriteLine("\tvoid RegisterBuiltinTypes();");
output.WriteLine("\tRegisterBuiltinTypes();");
output.WriteLine("\t// {0} Non stripped classes", nativeClassesAndBaseClasses.Count);
int num = 1;
foreach (UnityType type2 in UnityType.GetTypes())
{
if (((type2.baseClass != null) && !type2.isEditorOnly) && nativeClassesAndBaseClasses.Contains(type2))
{
output.WriteLine("\t// {0}. {1}\n", num++, type2.qualifiedName);
output.WriteLine("\tRegisterClass<{0}>();\n", type2.qualifiedName);
}
}
output.WriteLine();
output.Write("\n}\n");
}
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");
}
}
public bool IsDerivedFrom(UnityType baseClass)
{
return(this.runtimeTypeIndex - baseClass.runtimeTypeIndex < baseClass.descendantCount);
}
private static void WriteStaticallyLinkedModuleClassRegistration(TextWriter w, HashSet <UnityType> nativeClasses, HashSet <UnityType> classesToSkip)
{
w.WriteLine("template <typename T> void RegisterUnityClass(const char*);");
w.WriteLine("template <typename T> void RegisterStrippedType(int, const char*, const char*);");
w.WriteLine();
WriteFunctionInvokeRegisterStaticallyLinkedModuleClasses(w, nativeClasses);
// Forward declare types
if (nativeClasses != null)
{
foreach (var type in UnityType.GetTypes())
{
if (type.baseClass == null || type.isEditorOnly || classesToSkip.Contains(type))
{
continue;
}
if (type.hasNativeNamespace)
{
w.Write("namespace {0} {{ class {1}; }} ", type.nativeNamespace, type.name);
}
else
{
w.Write("class {0}; ", type.name);
}
if (nativeClasses.Contains(type))
{
w.WriteLine("template <> void RegisterUnityClass<{0}>(const char*);", type.qualifiedName);
}
else
{
w.WriteLine();
}
}
w.WriteLine();
}
// Class registration function
w.WriteLine("void RegisterAllClasses()");
w.WriteLine("{");
if (nativeClasses == null)
{
w.WriteLine("\tvoid RegisterAllClassesGranular();");
w.WriteLine("\tRegisterAllClassesGranular();");
}
else
{
w.WriteLine("void RegisterBuiltinTypes();");
w.WriteLine("RegisterBuiltinTypes();");
w.WriteLine("\t//Total: {0} non stripped classes", nativeClasses.Count);
int index = 0;
foreach (var klass in nativeClasses)
{
w.WriteLine("\t//{0}. {1}", index, klass.qualifiedName);
if (classesToSkip.Contains(klass) || (klass.baseClass == null))
{
w.WriteLine("\t//Skipping {0}", klass.qualifiedName);
}
else
{
w.WriteLine("\tRegisterUnityClass<{0}>(\"{1}\");", klass.qualifiedName, klass.module);
}
++index;
}
w.WriteLine();
// Register stripped classes
// TODO (ulfj ) 2016-08-15 : Right now we cannot deal with types that are compiled into the editor
// but not the player due to other defines than UNITY_EDITOR in them module definition file
// (for example WorldAnchor only being there if ENABLE_HOLOLENS_MODULE_API). Doing this would
// require either some non trivial changes to the module registration macros or a way for these
// conditionals to be included in the RTTI so we can emit them when generating the code, so we
// disabling the registration of stripped classes for now and will get back to this when we have
// landed the remaining changes to the type system.
//w.WriteLine("\t//Stripped classes");
//foreach (var type in UnityType.GetTypes())
//{
// if (type.baseClass == null || type.isEditorOnly || classesToSkip.Contains(type) || nativeClasses.Contains(type))
// continue;
// w.WriteLine("\tRegisterStrippedType<{0}>({1}, \"{2}\", \"{3}\");", type.qualifiedName, type.persistentTypeID, type.name, type.nativeNamespace);
//}
}
w.WriteLine("}");
}