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 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");
}
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("}");
}
public static void GenerateRegisterClassesForStripping(HashSet <UnityType> nativeClassesAndBaseClasses, TextWriter output)
{
// Forward declare template function
output.WriteLine("template <typename T> void RegisterClass(const char*);");
output.WriteLine("template <typename T> void RegisterStrippedType(int, const char*, const char*);");
output.WriteLine();
// Forward declaration
foreach (var type in UnityType.GetTypes())
{
if (type.baseClass == null || type.isEditorOnly)
{
continue;
}
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();");
// Write non stripped class registration
output.WriteLine("\t// {0} Non stripped classes\n", nativeClassesAndBaseClasses.Count);
int count = 1;
foreach (var type in UnityType.GetTypes())
{
if (type.baseClass == null || type.isEditorOnly || !nativeClassesAndBaseClasses.Contains(type))
{
continue;
}
output.WriteLine("\t// {0}. {1}", count++, type.qualifiedName);
output.WriteLine("\tRegisterClass<{0}>(\"{1}\");\n", type.qualifiedName, type.module);
}
output.WriteLine();
// Write stripped class registration
// 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.
//output.WriteLine("\t// Stripped classes");
//foreach (var type in UnityType.GetTypes())
//{
// if (type.baseClass == null || type.isEditorOnly || nativeClassesAndBaseClasses.Contains(type))
// continue;
// output.WriteLine("\tRegisterStrippedType<{0}>();", type.qualifiedName);
//}
output.Write("\n}\n");
}
private static void WriteModuleAndClassRegistrationFile(string file, HashSet <string> nativeModules, HashSet <UnityType> nativeClasses, HashSet <UnityType> classesToSkip)
{
using (TextWriter textWriter = new StreamWriter(file))
{
textWriter.WriteLine("template <typename T> void RegisterClass();");
textWriter.WriteLine("template <typename T> void RegisterStrippedTypeInfo(int, const char*, const char*);");
textWriter.WriteLine();
CodeStrippingUtils.WriteStaticallyLinkedModuleRegistration(textWriter, nativeModules, nativeClasses);
textWriter.WriteLine();
if (nativeClasses != null)
{
foreach (UnityType current in UnityType.GetTypes())
{
if (current.baseClass != null && !current.isEditorOnly && !classesToSkip.Contains(current))
{
if (current.hasNativeNamespace)
{
textWriter.Write("namespace {0} {{ class {1}; }} ", current.nativeNamespace, current.name);
}
else
{
textWriter.Write("class {0}; ", current.name);
}
if (nativeClasses.Contains(current))
{
textWriter.WriteLine("template <> void RegisterClass<{0}>();", current.qualifiedName);
}
else
{
textWriter.WriteLine();
}
}
}
textWriter.WriteLine();
}
textWriter.WriteLine("void RegisterAllClasses()");
textWriter.WriteLine("{");
if (nativeClasses == null)
{
textWriter.WriteLine("\tvoid RegisterAllClassesGranular();");
textWriter.WriteLine("\tRegisterAllClassesGranular();");
}
else
{
textWriter.WriteLine("void RegisterBuiltinTypes();");
textWriter.WriteLine("RegisterBuiltinTypes();");
textWriter.WriteLine("\t//Total: {0} non stripped classes", nativeClasses.Count);
int num = 0;
foreach (UnityType current2 in nativeClasses)
{
textWriter.WriteLine("\t//{0}. {1}", num, current2.qualifiedName);
if (classesToSkip.Contains(current2))
{
textWriter.WriteLine("\t//Skipping {0}", current2.qualifiedName);
}
else
{
textWriter.WriteLine("\tRegisterClass<{0}>();", current2.qualifiedName);
}
num++;
}
textWriter.WriteLine();
}
textWriter.WriteLine("}");
textWriter.Close();
}
}