// Register here all hard coded types, that come from NitroxModel-Subnautica or NitroxServer-Subnautica
private void RegisterHardCodedTypes()
{
Model.Add(typeof(Light), true);
Model.Add(typeof(BoxCollider), true);
Model.Add(typeof(SphereCollider), true);
Model.Add(typeof(MeshCollider), true);
Model.Add(typeof(Vector3), false).SetSurrogate(typeof(Vector3Surrogate));
Model.Add(typeof(NitroxVector3), false).SetSurrogate(typeof(Vector3Surrogate));
Model.Add(typeof(Quaternion), false).SetSurrogate(typeof(QuaternionSurrogate));
Model.Add(typeof(NitroxQuaternion), false).SetSurrogate(typeof(QuaternionSurrogate));
Model.Add(typeof(Transform), false).SetSurrogate(typeof(NitroxTransform));
Model.Add(typeof(GameObject), false).SetSurrogate(typeof(NitroxServer.UnityStubs.GameObject));
MetaType vehicleModel = Model.Add(typeof(VehicleModel), false);
vehicleModel.AddSubType(100, typeof(ExosuitModel));
vehicleModel.AddSubType(200, typeof(SeamothModel));
vehicleModel.AddSubType(300, typeof(CyclopsModel));
vehicleModel.AddSubType(400, typeof(NeptuneRocketModel));
MetaType movementData = Model.Add(typeof(VehicleMovementData), false);
movementData.AddSubType(100, typeof(ExosuitMovementData));
MetaType rotationData = Model.Add(typeof(RotationMetadata), false);
rotationData.AddSubType(50, typeof(CorridorRotationMetadata));
rotationData.AddSubType(60, typeof(MapRoomRotationMetadata));
rotationData.AddSubType(70, typeof(BaseModuleRotationMetadata));
rotationData.AddSubType(80, typeof(AnchoredFaceRotationMetadata));
}
public static void AddType(Type t, Action <object, string> action)
{
ushort number = GetInt16HashCode(t.FullName);
if (t.IsDefined(typeof(SynchronizableAttribute), false))
{
model.Add(t, true);
type.AddSubType(number, t);
}
typesDictionary.Add(t, number);
types.Add(number, t);
typesActions.Add(number, action);
}
private void RegisterHardCodedTypes()
{
model.Add(typeof(UnityEngine.Light), true);
model.Add(typeof(UnityEngine.BoxCollider), true);
model.Add(typeof(UnityEngine.SphereCollider), true);
model.Add(typeof(UnityEngine.MeshCollider), true);
model.Add(typeof(UnityEngine.Vector3), false).SetSurrogate(typeof(UnityStubs.Vector3));
model.Add(typeof(UnityEngine.Quaternion), false).SetSurrogate(typeof(UnityStubs.Quaternion));
model.Add(typeof(UnityEngine.Transform), false).SetSurrogate(typeof(UnityStubs.Transform));
model.Add(typeof(UnityEngine.GameObject), false).SetSurrogate(typeof(UnityStubs.GameObject));
MetaType metaType = model.Add(typeof(RotationMetadata), false);
metaType.AddSubType(50, typeof(CorridorRotationMetadata));
metaType.AddSubType(60, typeof(MapRoomRotationMetadata));
}
// Register here all hard coded types, that come from NitroxModel-Subnautica or NitroxServer-Subnautica
private void RegisterHardCodedTypes()
{
MetaType vehicleModel = Model.Add(typeof(VehicleModel), false);
vehicleModel.AddSubType(100, typeof(ExosuitModel));
vehicleModel.AddSubType(200, typeof(SeamothModel));
vehicleModel.AddSubType(300, typeof(CyclopsModel));
MetaType movementData = Model.Add(typeof(VehicleMovementData), false);
movementData.AddSubType(100, typeof(ExosuitMovementData));
MetaType rotationData = Model.Add(typeof(RotationMetadata), false);
rotationData.AddSubType(50, typeof(CorridorRotationMetadata));
rotationData.AddSubType(60, typeof(MapRoomRotationMetadata));
}
public static MetaType AddCurrencies(this MetaType metaType, ICurrencies currencies)
{
for (var i = 0; i < currencies.Count; ++i)
{
metaType.AddSubType(i + 1, currencies[i].GetType());
}
return(metaType);
}
private static void AddSubTypes(Type parentType, MetaType metaType, RuntimeTypeModel typeModel, IEnumerable <Assembly> assemblies)
{
foreach (var childType in GetBaseTypesOfParentInAssemblies(parentType, assemblies))
{
var subModel = typeModel.Add(childType, true);
metaType.AddSubType(_field, childType);
Interlocked.Increment(ref _field);
AddSubTypes(parentType, subModel, typeModel, assemblies);
}
}
// Register here all hard coded types, that come from NitroxModel-Subnautica or NitroxServer-Subnautica
private void RegisterHardCodedTypes()
{
MetaType vehicleModel = Model.Add(typeof(VehicleModel), false);
vehicleModel.AddSubType(100, typeof(ExosuitModel));
MetaType movementData = Model.Add(typeof(VehicleMovementData), false);
movementData.AddSubType(100, typeof(ExosuitMovementData));
}
static Command()
{
try
{
// Get all CommandHandler subclasses in the CSM.Commands.Handler namespace
Type[] handlers = typeof(Command).Assembly.GetTypes()
.Where(t => t.Namespace != null)
.Where(t => t.Namespace.StartsWith("CSM.Commands.Handler", StringComparison.Ordinal))
.Where(t => t.IsSubclassOf(typeof(CommandHandler)))
.Where(t => !t.IsAbstract)
.ToArray();
// Create a protobuf model
RuntimeTypeModel model = TypeModel.Create();
// Set type surrogates
model[typeof(Vector3)].SetSurrogate(typeof(Vector3Surrogate));
model[typeof(NetTool.ControlPoint)].SetSurrogate(typeof(ControlPointSurrogate));
// Add Quaternion Surrogate
model[typeof(Quaternion)].SetSurrogate(typeof(QuaternionSurrogate));
// Add Color Surrogate
model[typeof(Color)].SetSurrogate(typeof(ColorSurrogate));
// Add base command to the protobuf model with all attributes
model.Add(typeof(CommandBase), true);
MetaType baseCmd = model[typeof(CommandBase)];
// Lowest id of the subclasses
int id = 100;
// Create instances of the handlers, initialize mappings and register command subclasses in the protobuf model
foreach (Type type in handlers)
{
CommandHandler handler = (CommandHandler)Activator.CreateInstance(type);
_cmdMapping.Add(handler.GetDataType(), handler);
// Add subtype to the protobuf model with all attributes
baseCmd.AddSubType(id, handler.GetDataType());
model.Add(handler.GetDataType(), true);
id++;
}
// Compile the protobuf model
model.CompileInPlace();
Model = model;
}
catch (Exception ex)
{
_logger.Error(ex, "Failed to initialize data model");
}
}
public static RuntimeTypeModel Create()
{
RuntimeTypeModel model = TypeModel.Create();
RegisterAutoTypes(model);
RegisterUserDefinedTypes(model);
Type[] serializableTypes = Reflection.GetAllFromCurrentAssembly()
.Where(type => type.IsDefined(typeof(ProtoContractAttribute), false)).ToArray();
MetaType primitiveContract = model.Add(typeof(PrimitiveContract), false);
int fieldNumber = 16;
foreach (Type type in serializableTypes)
{
if (type.IsGenericType())
{
continue;
}
Type derivedType = typeof(PrimitiveContract <>).MakeGenericType(type.MakeArrayType());
primitiveContract.AddSubType(fieldNumber, derivedType);
fieldNumber++;
model.Add(derivedType, true);
model.Add(typeof(List <>).MakeGenericType(type), true);
}
Type[] primitiveTypes = new[] {
typeof(bool),
typeof(char),
typeof(byte),
typeof(short),
typeof(int),
typeof(long),
typeof(ushort),
typeof(uint),
typeof(ulong),
typeof(string),
typeof(float),
typeof(double),
typeof(decimal)
};
foreach (Type type in primitiveTypes)
{
if (type.IsGenericType())
{
continue;
}
model.Add(typeof(List <>).MakeGenericType(type), true);
}
return(model);
}
internal static void Init()
{
model = RuntimeTypeModel.Default;
type = model.Add(typeof(ISync), true);
var containerType = type.AddSubType(6, typeof(Container));
containerType.AddSubType(1, typeof(StringContainer));
typesActions.Add(1, (object data, string senderID) => { if (typesDictionary.ContainsKey(typeof(string)))
{
typesActions[typesDictionary[typeof(string)]].Invoke((data as StringContainer).value, senderID);
}
});
typesDictionary.Add(typeof(StringContainer), 1);
types.Add(1, typeof(StringContainer));
containerType.AddSubType(2, typeof(IntContainer));
typesActions.Add(2, (object data, string senderID) => { if (typesDictionary.ContainsKey(typeof(int)))
{
typesActions[typesDictionary[typeof(int)]].Invoke((data as IntContainer).value, senderID);
}
});
typesDictionary.Add(typeof(IntContainer), 2);
types.Add(2, typeof(IntContainer));
containerType.AddSubType(3, typeof(UintContainer));
typesActions.Add(3, (object data, string senderID) => { if (typesDictionary.ContainsKey(typeof(uint)))
{
typesActions[typesDictionary[typeof(uint)]].Invoke((data as UintContainer).value, senderID);
}
});
typesDictionary.Add(typeof(UintContainer), 3);
types.Add(3, typeof(UintContainer));
containerType.AddSubType(4, typeof(FloatContainer));
typesActions.Add(4, (object data, string senderID) => { if (typesDictionary.ContainsKey(typeof(float)))
{
typesActions[typesDictionary[typeof(float)]].Invoke((data as FloatContainer).value, senderID);
}
});
typesDictionary.Add(typeof(FloatContainer), 4);
types.Add(4, typeof(FloatContainer));
containerType.AddSubType(5, typeof(DoubleContainer));
typesActions.Add(5, (object data, string senderID) => { if (typesDictionary.ContainsKey(typeof(double)))
{
typesActions[typesDictionary[typeof(double)]].Invoke((data as DoubleContainer).value, senderID);
}
});
typesDictionary.Add(typeof(DoubleContainer), 5);
types.Add(5, typeof(DoubleContainer));
}
// Token: 0x06000C7E RID: 3198 RVA: 0x00025F7C File Offset: 0x0002417C
public void AddTypeToSerializer(Type parent, Type type)
{
if (type == null || parent == null)
{
throw new ArgumentNullException();
}
if (!RuntimeTypeModel.Default[parent].GetSubtypes().Any((SubType subType) => subType.DerivedType.Type == type))
{
MetaType metaType = RuntimeTypeModel.Default[parent];
int typeIndex = this._typeIndex;
this._typeIndex = typeIndex + 1;
metaType.AddSubType(typeIndex, type);
}
}
public static void LoadSerialization()
{
//Add subtypes
if (!RuntimeTypeModel.Default.IsDefined(typeof(NetworkEntityData)))
{
MetaType entityDataType = RuntimeTypeModel.Default.Add(typeof(NetworkEntityData), false).Add(GetFields(typeof(NetworkEntityData)));
entityDataType.UseConstructor = false;
Type[] subTypes = Assembly.GetAssembly(typeof(NetworkEntityData)).GetTypes().Where(t => (t.IsSubclassOf(typeof(NetworkEntityData)))).ToArray();
for (int i = 0; i < subTypes.Length; i++)
{
RuntimeTypeModel.Default.Add(subTypes[i], false).Add(GetFields(subTypes[i])).UseConstructor = false;
entityDataType.AddSubType(INDEX_OFFSET + i, subTypes[i]);
}
}
}
public void InitialStartup(ref int progress)
{
RuntimeTypeModel current = RuntimeTypeModel.Create();
foreach (ITeachSerialization item in this.Teachers)
{
item.Teach(current);//Point teacher ain't loading
progress++;
}
MetaType baseMessageType = current.Add(typeof(BaseMessage), true);
// = ReflectionUtil.LoadAllInterface<IHasSubclasses>(Assembly.GetAssembly(typeof(BaseMessage)));
List <IHasSubclasses> ToProcess = new List <IHasSubclasses>();
ToProcess.AddRange(ReflectionUtil.LoadAllInterface <IHasSubclasses>(Assembly.GetAssembly(typeof(Tile))));
foreach (IHasSubclasses item in ToProcess)
{
MetaType meta = current.Add(item.GetBaseType(), true);
foreach (KeyValuePair <Type, int> subs in item.GetSubclassInformation())
{
meta.AddSubType(subs.Value, subs.Key);
}
}
//Must start at 2 because Protobuf-net can't have members and inheritance attributes with the same ID. I think. :D
int i = 2;
int length = this.Messages.Count + 2;
while (i < length)
{
current.Add(this.Messages[i - 2], true);
baseMessageType.AddSubType(i, this.Messages[i - 2]);
BaseMessage sample = (BaseMessage)Activator.CreateInstance(this.Messages[i - 2]);
ProtoUtil.IDToMessage.Add(sample.ID, this.Messages[i - 2]);
i++;
progress++;
}
//ProtoUtil.TypeModel = RuntimeTypeModel.Default.
//ProtoUtil.TypeModel = current.Compile();
//ProtoUtil.TypeModel
ProtoUtil.TypeModel = current;
}
// Token: 0x06000AFD RID: 2813 RVA: 0x000225A8 File Offset: 0x000207A8
public static void PopulateTypes(Type t)
{
using (IEnumerator enumerator = RuntimeTypeModel.Default.GetTypes().GetEnumerator())
{
while (enumerator.MoveNext())
{
MetaType metaType;
if ((metaType = (enumerator.Current as MetaType)) != null && metaType.Type == t)
{
return;
}
}
}
Type typeFromHandle = typeof(object);
List <Type> list = new List <Type>();
do
{
list.Insert(0, t);
t = t.BaseType;
}while (t != null && t != typeFromHandle);
for (int i = 0; i < list.Count - 1; i++)
{
Type type = list[i];
MetaType metaType2 = null;
bool flag = false;
RuntimeTypeModel @default = RuntimeTypeModel.Default;
foreach (object obj in ((@default != null) ? @default.GetTypes() : null))
{
MetaType metaType3 = (MetaType)obj;
if (metaType3.Name.Equals(type.Name))
{
flag = true;
metaType2 = metaType3;
break;
}
}
if (!flag)
{
RuntimeTypeModel default2 = RuntimeTypeModel.Default;
metaType2 = ((default2 != null) ? default2.Add(type, true) : null);
}
metaType2.AddSubType((metaType2.GetSubtypes().Length + 1) * 100, list[i + 1]);
}
}
/// <summary>
/// Adds a default protobuf data contract to the protobuf runtime model
/// </summary>
/// <param name="allTypes">All types available</param>
/// <param name="type">The type to add to the model</param>
private static void AddProtobufType(Type[] allTypes, Type type)
{
MetaType metaType = RuntimeTypeModel.Default.Add(type, true);
string[] memberNames = (from pi in type.GetProperties()
where pi.CanWrite
select pi.Name).ToArray();
metaType.Add(memberNames);
int index = memberNames.Length;
// add subtypes
foreach (Type allType in allTypes)
{
if (allType.IsSubclassOf(type))
{
metaType.AddSubType(++index, allType);
}
}
}
public static void PopulateTypes(Type t)
{
foreach (object type2 in RuntimeTypeModel.Default.GetTypes())
{
MetaType metaType;
if ((metaType = (type2 as MetaType)) != null && metaType.Type == t)
{
return;
}
}
Type typeFromHandle = typeof(object);
List <Type> list = new List <Type>();
do
{
list.Insert(0, t);
t = t.BaseType;
}while (t != null && t != typeFromHandle);
for (int i = 0; i < list.Count - 1; i++)
{
Type type = list[i];
MetaType metaType2 = null;
bool flag = false;
foreach (MetaType item in RuntimeTypeModel.Default?.GetTypes())
{
if (item.Name.Equals(type.Name))
{
flag = true;
metaType2 = item;
break;
}
}
if (!flag)
{
metaType2 = RuntimeTypeModel.Default?.Add(type, applyDefaultBehaviour: true);
}
metaType2.AddSubType((metaType2.GetSubtypes().Length + 1) * 100, list[i + 1]);
}
}
public static void InitialiseSerializer()
{
if (!m_isInitialised)
{
m_isInitialised = true;
Type packetType = typeof(Packet);
Assembly protocolAssembly = Assembly.GetAssembly(packetType);
Type[] types = protocolAssembly.GetTypes();
MetaType metaType = RuntimeTypeModel.Default.Add(packetType, true);
//Count how many ProtoMembers Packet has and start tagging from there
int startTag = packetType.GetProperties().Where(p => p.GetCustomAttributes(typeof(ProtoMemberAttribute), false).Count() > 0).Count() + 1;
foreach (Type packetSubclass in types.Where(t => t.IsSubclassOf(packetType)))
{
metaType.AddSubType(startTag++, packetSubclass);
}
RuntimeTypeModel.Default.CompileInPlace();
RuntimeTypeModel.Default.AutoCompile = true;
}
}
public void RegisterInheritance(Type derivedType)
{
Meta.AddSubType(Tag++, derivedType);
}
public static RuntimeTypeModel CreateTypeModel()
{
RuntimeTypeModel model = TypeModel.Create();
model.Add(typeof(IntArray), true);
model.Add(typeof(ProjectItem), true)
.AddSubType(1025, typeof(AssetItem));
model.Add(typeof(AssetItem), true);
model.Add(typeof(AssetBundleItemInfo), true);
model.Add(typeof(AssetBundleInfo), true);
model.Add(typeof(ProjectInfo), true);
model.Add(typeof(PrefabPart), true);
model.Add(typeof(Preview), true);
model.Add(typeof(PersistentDescriptor <long>), true);
model.Add(typeof(PersistentPersistentCall <long>), true);
model.Add(typeof(PersistentArgumentCache <long>), true);
model.Add(typeof(PersistentBlendShapeFrame <long>), true);
model.Add(typeof(PersistentBlendShapeFrame <Guid>), true);
model.Add(typeof(PersistentDescriptor <Guid>), true);
model.Add(typeof(PersistentPersistentCall <Guid>), true);
model.Add(typeof(PersistentArgumentCache <Guid>), true);
ITypeModelCreator typeModelCreator = IOC.Resolve <ITypeModelCreator>();
if (typeModelCreator == null)
{
DefaultTypeModel(model);
}
else
{
typeModelCreator.Create(model);
}
MetaType primitiveContract = model.Add(typeof(PrimitiveContract), false);
int fieldNumber = 16;
//NOTE: Items should be added to TypeModel in exactly the same order!!!
//It is allowed to append new types, but not to insert new types in the middle.
Type[] types = new[] {
typeof(bool),
typeof(char),
typeof(byte),
typeof(short),
typeof(int),
typeof(long),
typeof(ushort),
typeof(uint),
typeof(ulong),
typeof(string),
typeof(float),
typeof(double),
typeof(decimal),
typeof(PersistentColor <long>),
typeof(PersistentVector4 <long>),
typeof(Guid),
typeof(PersistentColor <Guid>),
typeof(PersistentVector4 <Guid>)
};
foreach (Type type in types)
{
//if (type.IsGenericType())
//{
// continue;
//}
Type derivedType = typeof(PrimitiveContract <>).MakeGenericType(type.MakeArrayType());
primitiveContract.AddSubType(fieldNumber, derivedType);
fieldNumber++;
model.Add(derivedType, true);
derivedType = typeof(PrimitiveContract <>).MakeGenericType(type);
primitiveContract.AddSubType(fieldNumber, derivedType);
fieldNumber++;
model.Add(derivedType, true);
model.Add(typeof(List <>).MakeGenericType(type), true);
}
//This is special kind of peristent object which can be used to serialize types using reflection. (This is required to serialize objects of type created at runtime for example)
model.Add(typeof(PersistentRuntimeSerializableObject <long>), true);
model[typeof(PersistentObject <long>)].AddSubType(1024, typeof(PersistentRuntimeSerializableObject <long>));
model.Add(typeof(PersistentRuntimeSerializableObject <Guid>), true);
model[typeof(PersistentObject <Guid>)].AddSubType(1024, typeof(PersistentRuntimeSerializableObject <Guid>));
model.AutoAddMissingTypes = false;
return(model);
}
public virtual void ApplyDefaultBehaviour(MetaType metaType)
{
var type = metaType.Type;
Type baseType = metaType.GetBaseType();
if (baseType != null &&
CanAutoAddType(baseType) &&
MetaType.CanHaveSubType(baseType))
{
Model.FindOrAddAuto(baseType, true, false, false);
}
try
{
AttributeFamily family;
TypeState mapped;
{
AttributeMap[] typeAttribs = AttributeMap.Create(Model, type, false);
family = GetContractFamily(type, typeAttribs);
mapped = TypeMapper.Map(
new TypeArgsValue(type, typeAttribs, AcceptableAttributes, Model)
{
Family = family,
ImplicitFallbackMode = ImplicitFallbackMode,
});
foreach (var candidate in mapped.DerivedTypes)
{
if (metaType.IsValidSubType(candidate.Type))
{
metaType.AddSubType(candidate.Tag, candidate.Type);
}
}
metaType.ReplaceClientSettings(mapped.SettingsValue);
}
var partialMembers = mapped.PartialMembers;
int dataMemberOffset = mapped.DataMemberOffset;
int implicitFirstTag = mapped.ImplicitFirstTag;
bool inferTagByName = mapped.InferTagByName;
ImplicitFieldsMode implicitMode = mapped.ImplicitFields;
family = mapped.Input.Family;
MethodInfo[] callbacks = null;
var members = new List <MappedMember>();
bool isEnum = Helpers.IsEnum(type);
#if WINRT
System.Collections.Generic.IEnumerable <MemberInfo> foundList;
if (isEnum)
{
foundList = type.GetRuntimeFields().Where(x => x.IsStatic && x.IsPublic);
}
else
{
System.Collections.Generic.List <MemberInfo> list = new System.Collections.Generic.List <MemberInfo>();
foreach (PropertyInfo prop in type.GetRuntimeProperties())
{
MethodInfo getter = Helpers.GetGetMethod(prop, false, false);
if (getter != null && !getter.IsStatic)
{
list.Add(prop);
}
}
foreach (FieldInfo fld in type.GetRuntimeFields())
{
if (fld.IsPublic && !fld.IsStatic)
{
list.Add(fld);
}
}
foreach (MethodInfo mthd in type.GetRuntimeMethods())
{
if (mthd.IsPublic && !mthd.IsStatic)
{
list.Add(mthd);
}
}
foundList = list;
}
#else
MemberInfo[] foundList = type.GetMembers(isEnum
? BindingFlags.Public | BindingFlags.Static
: BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (isEnum)
{
foundList = foundList.Where(x => x is FieldInfo).ToArray();
}
#endif
foreach (MemberInfo member in foundList)
{
if (member.DeclaringType != type)
{
continue;
}
var map = AttributeMap.Create(Model, member, true);
{
var args = new MemberArgsValue(member, map, AcceptableAttributes, Model)
{
DataMemberOffset = dataMemberOffset,
Family = family,
InferTagByName = inferTagByName,
PartialMembers = partialMembers,
IsEnumValueMember = isEnum
};
PropertyInfo property;
FieldInfo field;
if ((property = member as PropertyInfo) != null)
{
bool isPublic = Helpers.GetGetMethod(property, false, false) != null;
bool canBeMapped = isPublic || Helpers.GetGetMethod(property, true, true) != null;
if (canBeMapped &&
(!mapped.ImplicitOnlyWriteable ||
Helpers.CheckIfPropertyWritable
(
Model,
property,
implicitMode == ImplicitFieldsMode.AllProperties || implicitMode == ImplicitFieldsMode.AllFieldsAndProperties,
false)))
{
switch (implicitMode)
{
case ImplicitFieldsMode.AllProperties:
args.IsForced = true;
break;
case ImplicitFieldsMode.PublicProperties:
if (isPublic)
{
args.IsForced = true;
}
break;
case ImplicitFieldsMode.PublicFieldsAndProperties:
if (isPublic)
{
args.IsForced = true;
}
break;
case ImplicitFieldsMode.AllFieldsAndProperties:
args.IsForced = true;
break;
}
}
var r = ApplyDefaultBehaviour_AddMembers(args);
if (r != null)
{
if (!canBeMapped)
{
throw new MemberAccessException("Property " + property + " should be readable to be mapped.");
}
members.Add(r);
}
}
else if ((field = member as FieldInfo) != null)
{
bool isPublic = field.IsPublic;
if (!args.IsEnumValueMember)
{
switch (implicitMode)
{
case ImplicitFieldsMode.AllFields:
args.IsForced = true;
break;
case ImplicitFieldsMode.PublicFields:
if (isPublic)
{
args.IsForced = true;
}
break;
case ImplicitFieldsMode.PublicFieldsAndProperties:
if (isPublic)
{
args.IsForced = true;
}
break;
case ImplicitFieldsMode.AllFieldsAndProperties:
args.IsForced = true;
break;
}
}
var r = ApplyDefaultBehaviour_AddMembers(args);
if (r != null)
{
members.Add(r);
}
}
}
MethodInfo method;
if ((method = member as MethodInfo) != null)
{
AttributeMap[] memberAttribs = AttributeMap.Create(Model, method, false);
if (memberAttribs != null && memberAttribs.Length > 0)
{
const int max = 11;
if (CanUse(AttributeType.ProtoBuf))
{
CheckForCallback(method, memberAttribs, "ProtoBuf.ProtoBeforeSerializationAttribute", ref callbacks, 0, max);
CheckForCallback(method, memberAttribs, "ProtoBuf.ProtoAfterSerializationAttribute", ref callbacks, 1, max);
CheckForCallback(method, memberAttribs, "ProtoBuf.ProtoBeforeDeserializationAttribute", ref callbacks, 2, max);
CheckForCallback(method, memberAttribs, "ProtoBuf.ProtoAfterDeserializationAttribute", ref callbacks, 3, max);
}
CheckForCallback(method, memberAttribs, "System.Runtime.Serialization.OnSerializingAttribute", ref callbacks, 4, max);
CheckForCallback(method, memberAttribs, "System.Runtime.Serialization.OnSerializedAttribute", ref callbacks, 5, max);
CheckForCallback(method, memberAttribs, "System.Runtime.Serialization.OnDeserializingAttribute", ref callbacks, 6, max);
CheckForCallback(method, memberAttribs, "System.Runtime.Serialization.OnDeserializedAttribute", ref callbacks, 7, max);
if (CanUse(AttributeType.Aqla))
{
CheckForCallback(method, memberAttribs, "AqlaSerializer.BeforeSerializationCallbackAttribute", ref callbacks, 8, max);
CheckForCallback(method, memberAttribs, "AqlaSerializer.AfterSerializationCallbackAttribute", ref callbacks, 9, max);
CheckForCallback(method, memberAttribs, "AqlaSerializer.BeforeDeserializationCallbackAttribute", ref callbacks, 10, max);
CheckForCallback(method, memberAttribs, "AqlaSerializer.AfterDeserializationCallbackAttribute", ref callbacks, 11, max);
}
}
}
}
if (inferTagByName || implicitMode != ImplicitFieldsMode.None)
{
members.Sort();
foreach (var member in members)
{
if (!member.MappingState.TagIsPinned) // if ProtoMember etc sets a tag, we'll trust it
{
member.Tag = -1;
}
}
}
foreach (var member in members.OrderBy(m => m.MappingState.TagIsPinned ? 0 : 1))
{
ApplyDefaultBehaviour(metaType, member,
(inferTagByName || implicitMode != ImplicitFieldsMode.None) ? (int?)implicitFirstTag : null);
}
if (callbacks != null)
{
metaType.SetCallbacks(Coalesce(callbacks, 0, 4, 8), Coalesce(callbacks, 1, 5, 9),
Coalesce(callbacks, 2, 6, 10), Coalesce(callbacks, 3, 7, 11));
}
if (!DisableAutoAddingMemberTypes)
{
foreach (var member in members)
{
if (!member.MappingState.Input.IsEnumValueMember)
{
Type memberType = Helpers.GetMemberType(member.Member);
memberType = Helpers.GetNullableUnderlyingType(memberType) ?? memberType;
if (memberType.IsArray)
{
memberType = memberType.GetElementType();
}
memberType = TypeModel.GetListItemType(Model, memberType) ?? memberType;
if (memberType == null)
{
continue;
}
if (CanAutoAddType(memberType))
{
Model.FindOrAddAuto(memberType, true, false, false);
}
}
}
}
if (UseLegacyTupleFields)
{
foreach (ValueMember vm in metaType.GetTupleFields())
{
vm.SetSettings(x => x.V.DefaultsMode = MemberDefaultsMode.LegacyTuple);
}
}
}
finally
{
if (baseType != null && GetContractFamily(baseType) != AttributeFamily.None)
{
if (Model.FindWithoutAdd(baseType) != null)
{
MetaType baseMeta = Model[baseType];
// we can't add to frozen base type
// but this is not always an error
// e.g. dynamic member of base type doesn't need registered subtype
if (!baseMeta.IsFrozen && !DisableAutoRegisteringSubtypes && !baseMeta.IsList && baseMeta.IsValidSubType(type) && CanAutoAddType(baseType))
{
baseMeta.AddSubType(baseMeta.GetNextFreeFieldNumber(AutoRegisteringSubtypesFirstTag), type);
}
}
}
}
}
public static void AddBaseTypeProtoMembers(MetaType metaType, Type derivedType)
{
//var myType = runtimeTypeModel[typeof(MachineTarget)];
metaType.AddSubType(100, derivedType);
}
public static RuntimeTypeModel Create()
{
RuntimeTypeModel model = TypeModel.Create();
model.Add(typeof(IntArray), true);
model.Add(typeof(ProjectItem), true)
.AddSubType(1025, typeof(AssetItem));
model.Add(typeof(AssetItem), true);
model.Add(typeof(AssetBundleItemInfo), true);
model.Add(typeof(AssetBundleInfo), true);
model.Add(typeof(ProjectInfo), true);
model.Add(typeof(PrefabPart), true);
model.Add(typeof(Preview), true);
model.Add(typeof(PersistentDescriptor), true);
model.Add(typeof(PersistentPersistentCall), true);
model.Add(typeof(PersistentArgumentCache), true);
RegisterAutoTypes(model);
RegisterUserDefinedTypes(model);
if (m_createDefaultTypeModel)
{
DefaultTypeModel(model);
}
MetaType primitiveContract = model.Add(typeof(PrimitiveContract), false);
int fieldNumber = 16;
//NOTE: Items should be added to TypeModel in exactly the same order!!!
//It is allowed to append new types, but not to insert new types in the middle.
Type[] types = new[] {
typeof(bool),
typeof(char),
typeof(byte),
typeof(short),
typeof(int),
typeof(long),
typeof(ushort),
typeof(uint),
typeof(ulong),
typeof(string),
typeof(float),
typeof(double),
typeof(decimal),
typeof(PersistentColor),
typeof(PersistentVector4)
};
foreach (Type type in types)
{
if (type.IsGenericType())
{
continue;
}
Type derivedType = typeof(PrimitiveContract <>).MakeGenericType(type.MakeArrayType());
primitiveContract.AddSubType(fieldNumber, derivedType);
fieldNumber++;
model.Add(derivedType, true);
derivedType = typeof(PrimitiveContract <>).MakeGenericType(type);
primitiveContract.AddSubType(fieldNumber, derivedType);
fieldNumber++;
model.Add(derivedType, true);
model.Add(typeof(List <>).MakeGenericType(type), true);
}
model.AutoAddMissingTypes = false;
return(model);
}
public void Register(ILayoutSerializer buttonSerializer, MetaType edb)
{
layoutSerializers[buttonSerializer.LayoutElementType] = buttonSerializer;
edb.AddSubType(layoutSerializers.Count, buttonSerializer.LayoutDataType);
}
private bool InternalRegister(Type typeToRegister)
{
//Ok so here the fun begins.
//We need a recursive algorithm for walking the graph of the Type to register each
//serializable type. So, for every member we must look down into that Type recursively and register it.
//However, we must make sure to check if it's already been registered or we might get circular graphs which
//would overflow. But that'd be a weird type anyway.
if (typeToRegister == null)
{
throw new ArgumentNullException(nameof(typeToRegister), $"Provided {typeToRegister} is a null arg.");
}
//Can't use isDefined exclusively but it'll fail when doing two-way subtypes
if (registeredTypes.ContainsKey(typeToRegister))
{
return(true);
}
if (typeof(IEnumerable).IsAssignableFrom(typeToRegister) || typeToRegister.IsArray)
{
if (typeToRegister.IsArray)
{
Register(typeToRegister.GetElementType());
}
else
{
foreach (var gparam in typeToRegister.GetGenericArguments())
{
Register(gparam);
}
}
}
//if (RuntimeTypeModel.Default.IsDefined(typeToRegister))
// return true;
if (typeToRegister.IsEnum)
{
MetaType enumMetaType = RuntimeTypeModel.Default.Add(typeToRegister, false);
enumMetaType.EnumPassthru = true;
enumMetaType.AsReferenceDefault = false;
return(true);
}
//If it's not defined we need to add it.
if (typeToRegister.Attribute <GladNetSerializationContractAttribute>() == null)
{
return(false);
}
MetaType typeModel = RuntimeTypeModel.Default.Add(typeToRegister, false);
//Add each member
foreach (MemberInfo mi in typeToRegister.MembersWith <GladNetMemberAttribute>(MemberTypes.Field | MemberTypes.Property, Flags.InstanceAnyDeclaredOnly)) //keep this declare only because of Unity3D serialization issues with NetSendable
{
typeModel.Add(mi.Attribute <GladNetMemberAttribute>().TagID, mi.Name);
//Now we might need to register this type aswell.
//Recur to try to register this type
Register(mi.Type());
}
//If might have a include on it so we should check it to register it with the subtype
IEnumerable <GladNetSerializationIncludeAttribute> includes = typeToRegister.Attributes <GladNetSerializationIncludeAttribute>();
foreach (GladNetSerializationIncludeAttribute include in includes)
{
//if we don't know about the type register it
if (!registeredTypes.ContainsKey(include.TypeToWireTo))
{
Register(include.TypeToWireTo);
}
//this is the simple case; however unlike protobuf we support two-include
if (include != null && include.IncludeForDerived)
{
if (include.TypeToWireTo == typeModel.Type || !typeModel.Type.IsAssignableFrom(include.TypeToWireTo))
{
continue;
}
else
{
typeModel.AddSubType(include.TagID, include.TypeToWireTo);
}
}
else
if (include != null && !include.IncludeForDerived)
{
//this is not for mappping a base type to setup mapping for its child
//we need to map this child to its base
//so we need to get the MetaType for it
RuntimeTypeModel.Default[include.TypeToWireTo]
.AddSubType(include.TagID, typeToRegister);
}
}
registeredTypes.Add(typeToRegister, null);
return(true);
}
// Token: 0x060000F9 RID: 249 RVA: 0x00004008 File Offset: 0x00002208
public static void PopulateTypes(Type t)
{
using (IEnumerator enumerator = RuntimeTypeModel.Default.GetTypes().GetEnumerator())
{
while (enumerator.MoveNext())
{
MetaType metaType;
if ((metaType = (enumerator.Current as MetaType)) != null && metaType.Type == t)
{
return;
}
}
}
Type typeFromHandle = typeof(object);
List <Type> list = new List <Type>();
do
{
list.Insert(0, t);
t = t.BaseType;
if (t == null)
{
break;
}
}while (t != typeFromHandle);
int i = 0;
while (i < list.Count - 1)
{
Type type = list[i];
MetaType metaType2 = null;
bool flag = false;
RuntimeTypeModel expr_A3 = RuntimeTypeModel.Default;
using (IEnumerator enumerator = ((expr_A3 != null) ? expr_A3.GetTypes() : null).GetEnumerator())
{
while (enumerator.MoveNext())
{
MetaType metaType3 = (MetaType)enumerator.Current;
if (metaType3.Name.Equals(type.Name))
{
flag = true;
metaType2 = metaType3;
break;
}
}
goto IL_142;
}
goto IL_101;
IL_117:
metaType2.AddSubType((metaType2.GetSubtypes().Length + 1) * 100, list[i + 1]);
i++;
continue;
IL_101:
RuntimeTypeModel expr_106 = RuntimeTypeModel.Default;
metaType2 = ((expr_106 != null) ? expr_106.Add(type, true) : null);
goto IL_117;
IL_142:
if (!flag)
{
goto IL_101;
}
goto IL_117;
}
}
