public static void Serialize(ByteBuffer buffer, ServerGameObject NGGameObject)
{
using (SafeWrapByteBuffer.Get(buffer))
{
NGGameObject.ProcessComponents();
buffer.Append(NGGameObject.instanceID);
buffer.AppendUnicodeString(NGGameObject.gameObject.tag);
buffer.Append(NGGameObject.gameObject.layer);
buffer.Append(NGGameObject.gameObject.isStatic);
buffer.Append(NGGameObject.components.Count);
for (int i = NGGameObject.components.Count - 1; i >= 0; --i)
{
try
{
NetComponent.Serialize(buffer, NGGameObject.components[i]);
}
catch (Exception ex)
{
InternalNGDebug.LogException("GameObject \"" + NGGameObject.gameObject.name + "\" failed on Component \"" + NGGameObject.components[i].component.name + "\" (" + (i + 1) + "/" + NGGameObject.components.Count + ").", ex);
throw;
}
}
}
}
public override void Out(ByteBuffer buffer)
{
if (this.OutResponseStatus(buffer))
{
buffer.Append(this.typeIndex);
buffer.Append(this.members.Length);
for (int i = 0; i < this.members.Length; i++)
{
using (SafeWrapByteBuffer wrap = SafeWrapByteBuffer.Get(buffer))
{
try
{
if (this.members[i] is FieldModifier)
{
FieldModifier modifier = (this.members[i] as FieldModifier);
buffer.Append(modifier.fieldInfo.IsLiteral == false || modifier.fieldInfo.IsInitOnly == true);
}
else
{
buffer.Append((this.members[i] as PropertyModifier).propertyInfo.GetSetMethod() != null);
}
NetField.Serialize(buffer, null, this.members[i]);
}
catch (Exception ex)
{
InternalNGDebug.LogException("Inspectable type index \"" + this.typeIndex + "\" at static member \"" + this.members[i].Name + "\" failed.", ex);
wrap.Erase();
}
}
}
}
}
public static void Serialize(ByteBuffer buffer, Type fieldType, UnityObject o)
{
using (SafeWrapByteBuffer.Get(buffer))
{
buffer.AppendUnicodeString((o.instanceID != 0 ? o.type : fieldType).GetShortAssemblyType());
buffer.Append(o.gameObjectInstanceID);
buffer.Append(o.instanceID);
if (o.instanceID != 0)
{
buffer.AppendUnicodeString(o.name);
}
}
}
public static void Serialize(ServerGameObject node, ByteBuffer buffer)
{
using (SafeWrapByteBuffer.Get(buffer))
{
buffer.Append(node.gameObject.activeSelf);
buffer.AppendUnicodeString(node.gameObject.name);
buffer.Append(node.instanceID);
buffer.Append(node.children.Count);
for (int i = 0; i < node.children.Count; i++)
{
NetGameObject.Serialize(node.children[i], buffer);
}
}
}
public static void Serialize(ByteBuffer buffer, Type fieldType, Object o)
{
using (SafeWrapByteBuffer.Get(buffer))
{
if (o != null)
{
GameObject gameObject = o as GameObject;
buffer.AppendUnicodeString(o.GetType().GetShortAssemblyType());
if (gameObject != null)
{
buffer.Append(gameObject.GetInstanceID());
}
else
{
Component component = o as Component;
if (component != null)
{
buffer.Append(component.gameObject.GetInstanceID());
}
else
{
buffer.Append(0);
}
}
int instanceID = o.GetInstanceID();
buffer.Append(instanceID);
if (instanceID != 0)
{
buffer.AppendUnicodeString(o.name);
}
}
else
{
buffer.AppendUnicodeString(fieldType.GetShortAssemblyType());
buffer.Append(0);
buffer.Append(0);
}
}
}
public static void Serialize(ByteBuffer buffer, object instance, IFieldModifier field)
{
using (SafeWrapByteBuffer.Get(buffer))
{
buffer.AppendUnicodeString(field.Type.GetShortAssemblyType());
buffer.AppendUnicodeString(field.Name);
buffer.Append(field.IsPublic);
TypeHandler handler = TypeHandlersManager.GetTypeHandler(field.Type);
if (handler != null)
{
if (field.MemberInfo.DeclaringType.IsGenericTypeDefinition == false || ((field is FieldModifier) == true && (field as FieldModifier).fieldInfo.IsLiteral == true))
{
buffer.AppendUnicodeString(handler.GetType().GetShortAssemblyType());
try
{
buffer.Append((byte)TypeHandlersManager.GetTypeSignature(field.Type));
ByteBuffer handlerBuffer = Utility.GetBBuffer();
handler.Serialize(handlerBuffer, field.Type, field.GetValue(instance));
buffer.Append(Utility.ReturnBBuffer(handlerBuffer));
}
catch (Exception ex)
{
buffer.Append((byte)TypeSignature.Null);
InternalNGDebug.LogException("Member \"" + field.Name + "\" failed.", ex);
throw;
}
}
else // Leave it unsupported.
{
buffer.Append(0);
}
}
else
{
buffer.Append(0);
}
}
}
public static void Serialize(ByteBuffer buffer, ServerComponent component)
{
using (SafeWrapByteBuffer.Get(buffer))
{
Type componentType = component.component.GetType();
buffer.Append(component.instanceID);
buffer.Append(Utility.IsComponentEnableable(component.component),
(component.component is Transform) == false); // Deletable
buffer.AppendUnicodeString(componentType.GetShortAssemblyType());
buffer.AppendUnicodeString(componentType.Name);
buffer.Append(component.fields.Length);
for (int i = 0; i < component.fields.Length; i++)
{
try
{
NetField.Serialize(buffer, component.component, component.fields[i]);
}
catch (Exception ex)
{
InternalNGDebug.LogException("Component \"" + componentType.Name + "\" failed on field \"" + component.fields[i].Name + "\" (" + (i + 1) + "/" + component.fields.Length + ").", ex);
throw;
}
}
buffer.Append(component.methods.Length);
for (int i = 0; i < component.methods.Length; i++)
{
try
{
NetMethod.Serialize(buffer, component.methods[i]);
}
catch (Exception ex)
{
InternalNGDebug.LogException("Component \"" + componentType.Name + "\" failed on method \"" + component.methods[i].methodInfo.Name + "\" (" + (i + 1) + "/" + component.methods.Length + ").", ex);
throw;
}
}
}
}
public static void Serialize(ByteBuffer buffer, Type fieldType, object instance)
{
using (SafeWrapByteBuffer.Get(buffer))
{
if (instance == null)
{
buffer.Append(-1);
return;
}
FieldInfo[] fields = fieldType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
int lengthPosition = buffer.Length;
int countFieldsAppended = 0;
buffer.Append(0);
for (int i = 0; i < fields.Length; i++)
{
if (Utility.CanExposeFieldInInspector(fields[i]) == false)
{
continue;
}
NetField.Serialize(buffer, instance, new FieldModifier(fields[i]));
++countFieldsAppended;
}
if (countFieldsAppended > 0)
{
int restoreLengthPosition = buffer.Length;
buffer.Length = lengthPosition;
buffer.Append(countFieldsAppended);
buffer.Length = restoreLengthPosition;
}
}
}
public static void Serializer(ByteBuffer buffer, Type fieldType, object instance)
{
using (SafeWrapByteBuffer.Get(buffer))
{
IEnumerable array = instance as IEnumerable;
if (array == null)
{
buffer.Append(-1); // -1 = null array
return;
}
bool isBigArray = false;
int count = 0;
if (fieldType.IsArray == true)
{
Array a = array as Array;
count = a.Length;
isBigArray = a.Length > ArrayData.BigArrayThreshold;
}
else if (typeof(IList).IsAssignableFrom(fieldType) == true)
{
IList a = array as IList;
count = a.Count;
isBigArray = a.Count > ArrayData.BigArrayThreshold;
}
else
{
throw new InvalidCastException("Array of type \"" + fieldType + "\" is not supported.");
}
buffer.Append(count);
if (ArrayData.forceBigArray == true)
{
ArrayData.forceBigArray = false;
isBigArray = false;
}
buffer.Append(isBigArray);
if (isBigArray == false)
{
Type subType = Utility.GetArraySubType(fieldType);
TypeHandler subHandler;
if (subType != null)
{
subHandler = TypeHandlersManager.GetTypeHandler(subType);
}
else
{
subType = typeof(object);
subHandler = TypeHandlersManager.GetTypeHandler(subType);
}
if (subHandler != null)
{
buffer.AppendUnicodeString(subHandler.GetType().GetShortAssemblyType());
buffer.Append((byte)TypeHandlersManager.GetTypeSignature(subType));
foreach (object item in array)
{
subHandler.Serialize(buffer, subType, item);
}
}
else
{
buffer.Append(0);
}
}
}
}
