public PrefabMetadataContainer(GameObject gameObject, SerializationMetadata metadata)
{
PropertyOverrides = new List <RuntimePrefabPropertyOverride>();
AssetPack.GetPrefabMetadata(gameObject, out var guid, metadata.AssetPack);
m_Guid = guid;
var overrides = PrefabUtility.GetObjectOverrides(gameObject, true);
foreach (var over in overrides)
{
var instanceObject = over.instanceObject;
if (instanceObject == null)
{
continue;
}
SerializationUtils.GetTransformPathAndComponentIndex(gameObject.transform, instanceObject,
out var transformPath, out var componentIndex);
RuntimePrefabPropertyOverride.GetOverrides(instanceObject, PropertyOverrides, transformPath, componentIndex, metadata);
}
RemovedComponents = new List <RuntimeRemovedComponent>();
var removedComponents = PrefabUtility.GetRemovedComponents(gameObject);
foreach (var component in removedComponents)
{
// TODO: optimize get component index
var assetComponent = component.assetComponent;
// Stale overrides can have a null reference on assetComponent
if (assetComponent == null)
{
continue;
}
assetComponent.gameObject.GetComponents(k_Components);
var index = k_Components.IndexOf(assetComponent);
if (index < 0)
{
Debug.LogWarning("Could not find removed component " + assetComponent);
continue;
}
RemovedComponents.Add(new RuntimeRemovedComponent
{
TransformPath = gameObject.transform.GetTransformPath(component.containingInstanceGameObject.transform),
ComponentIndex = index
});
}
AddedGameObjects = new List <RuntimeAddedGameObject>();
AddedComponents = new List <RuntimeAddedComponent>();
GetMetadataRecursively(gameObject, metadata);
}
public object Deserialize(IByteBuffer buffer, SerializationMetadata typeMetadata)
{
var id = buffer.ReadUnsignedIntLE();
if (!SerializationMap.GetTypeById(id, out var typeInfo))
{
throw new NotSupportedException();
}
if (Equals(typeInfo, NullTypeInfo))
{
return(null);
}
var customObjectSerializer = SerializationMap.GetSerializator(typeInfo);
if (customObjectSerializer != null && !Equals(customObjectSerializer.SupportedType, SupportedType))
{
return(customObjectSerializer.Deserialize(buffer, typeMetadata));
}
var metadatas = GetMetadatas(typeInfo);
var typeForCreate = (typeMetadata != null && typeInfo.IsGenericType && typeInfo.IsClass
? typeMetadata.PropertyTypeInfo
: typeInfo).AsType();
var obj = Activator.CreateInstance(typeForCreate);
foreach (var metadata in metadatas)
{
if (metadata.CanSerializeIndex.HasValue)
{
var flags = (BitArray)metadata.CanSerializeSource.GetValue(obj);
if (!flags[metadata.CanSerializeIndex.Value])
{
continue;
}
}
if (metadata.FromFlagIndex.HasValue)
{
var flags = (BitArray)metadata.FromFlagSource.GetValue(obj);
var flagValue = flags[metadata.FromFlagIndex.Value];
metadata.PropertyInfo.SetValue(obj, flagValue);
continue;
}
var value = Serializer.Deserialize(buffer, metadata);
metadata.PropertyInfo.SetValue(obj, value);
}
return((IObject)obj);
}
public static UnityObjectReference GetReferenceForObject(UnityObject obj, SerializationMetadata metadata)
{
if (obj)
{
if (metadata == null)
{
return(NullObjectReference);
}
var sceneID = metadata.GetSceneID(obj);
if (sceneID != SerializationMetadata.InvalidID)
{
return new UnityObjectReference {
sceneID = sceneID
}
}
;
string guid;
long fileId;
metadata.GetAssetMetadata(obj, out guid, out fileId);
if (string.IsNullOrEmpty(guid))
{
// Check if target object is marked as "DontSave"--that means it is a scene object but won't be found in metadata
if ((obj.hideFlags & HideFlags.DontSave) != HideFlags.None)
{
return(NullObjectReference);
}
// Suppress warning if scene object metadata is not setup (i.e. during deserialization)
if (metadata.SceneObjectsSetup)
{
Debug.LogWarningFormat("Could not find GUID for {0}", obj);
}
return(NullObjectReference);
}
if (fileId < 0)
{
Debug.LogWarningFormat("Could not find sub-asset for {0} at fileId {1}", obj, fileId);
return(NullObjectReference);
}
return(new UnityObjectReference {
guid = guid, fileId = fileId
});
}
return(NullObjectReference);
}
public void Serialize(object value, IByteBuffer buffer, SerializationMetadata metadata)
{
buffer.WriteIntLE((int)VectorId);
var collection = (IList)value;
buffer.WriteIntLE(collection.Count);
foreach (var item in collection)
{
Serializer.Serialize(item, buffer);
}
}
public static UnityObject GetObject(UnityObjectReference objectReference, SerializationMetadata metadata)
{
var guid = objectReference.guid;
if (!string.IsNullOrEmpty(guid))
{
return(GetAsset(guid, objectReference.fileId, metadata?.AssetPack));
}
var sceneId = objectReference.sceneID;
return(sceneId == SerializationMetadata.InvalidID ? null : metadata?.GetSceneObject(sceneId));
}
protected internal override void ApplyOverrideToTarget(UnityObject target, SerializationMetadata metadata)
{
foreach (var propertyOverride in m_List)
{
if (propertyOverride == null)
{
Debug.LogError("Encountered null property override");
continue;
}
propertyOverride.ApplyOverrideToTarget(target, metadata);
}
}
static void SetValueTyped(List <UnityObjectReference> referenceList, IMemberInfo memberInfoClosure,
object container, SerializationMetadata metadata)
{
void SetValue()
{
var count = referenceList.Count;
var list = new List <TElement>(count);
void Add(UnityObject unityObject)
{
if (!(unityObject is TElement element))
{
list.Add(default);
public GameObjectContainer(GameObject gameObject, SerializationMetadata metadata)
{
m_GameObject = gameObject;
m_Components = new List <Component>();
#if UNITY_EDITOR
if (PrefabUtility.IsPartOfPrefabInstance(gameObject))
{
PrefabMetadataContainer = new PrefabMetadataContainer(gameObject, metadata);
return;
}
#endif
var prefabMetadata = gameObject.GetComponent <PrefabMetadata>();
if (prefabMetadata != null)
{
PrefabMetadataContainer = new PrefabMetadataContainer(prefabMetadata, metadata);
return;
}
gameObject.GetComponents(k_TempComponents);
foreach (var component in k_TempComponents)
{
//TODO: Insert null component for missing scripts
if (component == null)
{
Debug.LogWarningFormat("Found missing script on {0} during serialization", gameObject.name);
continue;
}
if (component.GetType() != typeof(PrefabMetadata) && (component.hideFlags & HideFlags.DontSave) != 0)
{
continue;
}
m_Components.Add(component);
}
m_Children = new List <GameObjectContainer>();
foreach (Transform child in gameObject.transform)
{
var childGameObject = child.gameObject;
if ((childGameObject.hideFlags & HideFlags.DontSave) != 0)
{
continue;
}
m_Children.Add(new GameObjectContainer(childGameObject, metadata));
}
}
public void Serialize(BinaryWriter writer, object value, SerializationMetadata metadata)
{
var array = (TContainerMessage[])value;
writer.Write(array.Length);
foreach (var item in array)
{
var data = Serializer.SerializeObject(item);
writer.Write(item.MsgId);
writer.Write(item.SeqNo);
writer.Write(data.Length);
writer.Write(data);
}
}
public void Serialize(BinaryWriter writer, object value, SerializationMetadata metadata)
{
Serializer.Serialize(value, writer);
if (IsAssignableToGenericType(value.GetType().GetTypeInfo(), typeof(TVector <>)))
{
var collection = (ICollection)((dynamic)value).Items;
writer.Write(collection.Count);
foreach (var item in collection)
{
Serializer.Serialize(item, writer);
}
}
}
public PrefabMetadataContainer(PrefabMetadata prefabMetadata, SerializationMetadata metadata)
{
m_Guid = prefabMetadata.Guid;
AddedGameObjects = prefabMetadata.AddedGameObjects;
AddedComponents = prefabMetadata.AddedComponents;
RemovedComponents = prefabMetadata.RemovedComponents;
PropertyOverrides = prefabMetadata.PropertyOverrides;
// Convert any UnityObject properties back to UnityObjectReference for serialization
if (PropertyOverrides == null)
{
return;
}
PostProcessOverrideList(PropertyOverrides, metadata);
}
public object Deserialize(IByteBuffer buffer, SerializationMetadata metadata)
{
buffer.SkipBytes(4);
var length = buffer.ReadIntLE();
var genParameter = metadata.PropertyTypeInfo.GenericTypeArguments[0];
var vectorType = typeof(TVector <>).MakeGenericType(genParameter);
var vector = (IList)Activator.CreateInstance(vectorType);
for (var j = 0; j < length; j++)
{
var child = Serializer.Deserialize(buffer, genParameter.GetTypeInfo());
vector.Add(child);
}
return(vector);
}
public void Serialize(object obj, IByteBuffer buffer, SerializationMetadata _)
{
if (obj == null)
{
obj = Null;
}
var objectType = obj.GetType().GetTypeInfo();
if (SerializationMap.GetIdByType(objectType, out var typeId))
{
buffer.WriteIntLE((int)typeId);
var metadatas = GetMetadatas(objectType);
ComputeFlags(obj, metadatas);
foreach (var metadata in metadatas)
{
var value = metadata.PropertyInfo.GetValue(obj);
if (metadata.CanSerializeIndex.HasValue)
{
var flags = (BitArray)metadata.CanSerializeSource.GetValue(obj);
if (!flags[metadata.CanSerializeIndex.Value])
{
continue;
}
}
if (metadata.FromFlagIndex.HasValue)
{
var flags = (BitArray)metadata.FromFlagSource.GetValue(obj);
flags[metadata.FromFlagIndex.Value] = (bool)value;
continue;
}
Serializer.Serialize(value, buffer, metadata);
}
}
else
{
throw new NotSupportedException();
}
}
public static void GetOverrides(UnityObject instanceObject,
List <RuntimePrefabPropertyOverride> overrides, string transformPath, int componentIndex, SerializationMetadata metadata)
{
var type = instanceObject.GetType();
if (!k_GetOverridesMethods.TryGetValue(type, out var method))
{
method = k_GetOverridesMethod.MakeGenericMethod(type);
}
k_GetOverridesArguments[0] = instanceObject;
k_GetOverridesArguments[1] = overrides;
k_GetOverridesArguments[2] = transformPath;
k_GetOverridesArguments[3] = componentIndex;
k_GetOverridesArguments[4] = metadata;
method.Invoke(null, k_GetOverridesArguments);
}
void HandlePropertyOverrides(List <RuntimePrefabPropertyOverride> overrides, SerializationMetadata metadata)
{
var root = m_GameObject.transform;
foreach (var propertyOverride in overrides)
{
if (propertyOverride == null)
{
Debug.LogError("Encountered null property override");
continue;
}
propertyOverride.ApplyOverride(root, metadata);
}
// Convert UnityObjectReference properties to UnityObjects because SceneId's might change
PrefabMetadata.PostProcessOverrideList(overrides, metadata);
}
public object Deserialize(BinaryReader reader, SerializationMetadata metadata)
{
var length = reader.ReadInt32();
var items = new List <TContainerMessage>();
for (var i = 0; i < length; i++)
{
var item = new TContainerMessage
{
MsgId = reader.ReadInt64(),
SeqNo = reader.ReadInt32(),
Bytes = reader.ReadInt32(),
Body = Serializer.DeserializeObject(reader)
};
items.Add(item);
}
return(items.ToArray());
}
public object Deserialize(IByteBuffer buffer, SerializationMetadata metadata)
{
var length = buffer.ReadIntLE();
var items = new List <TContainerMessage>();
for (var i = 0; i < length; i++)
{
var item = new TContainerMessage
{
MsgId = buffer.ReadLongLE(),
SeqNo = buffer.ReadIntLE(),
Bytes = buffer.ReadIntLE(),
};
item.Body = Serializer.Deserialize(buffer.ReadSlice(item.Bytes));
items.Add(item);
}
return(items.ToArray());
}
public void Serialize(object value, IByteBuffer buffer, SerializationMetadata metadata)
{
var array = (byte[])value;
if (metadata?.ArrayLength != null)
{
buffer.WriteBytes(array, 0, metadata.ArrayLength.Value);
}
else
{
int padding;
if (array.Length < 254)
{
padding = (array.Length + 1) % 4;
buffer.WriteByte((byte)array.Length);
buffer.WriteBytes(array);
}
else
{
padding = array.Length % 4;
buffer.WriteByte(254);
buffer.WriteByte((byte)array.Length);
buffer.WriteByte((byte)(array.Length >> 8));
buffer.WriteByte((byte)(array.Length >> 16));
buffer.WriteBytes(array);
}
if (padding != 0)
{
padding = 4 - padding;
}
for (var i = 0; i < padding; i++)
{
buffer.WriteByte(0);
}
}
}
public void Serialize(BinaryWriter writer, object value, SerializationMetadata metadata)
{
var array = (byte[])value;
if (metadata?.ArrayLength != null)
{
writer.Write(array, 0, metadata.ArrayLength.Value);
}
else
{
int padding;
if (array.Length < 254)
{
padding = (array.Length + 1) % 4;
writer.Write((byte)array.Length);
writer.Write(array);
}
else
{
padding = array.Length % 4;
writer.Write((byte)254);
writer.Write((byte)array.Length);
writer.Write((byte)(array.Length >> 8));
writer.Write((byte)(array.Length >> 16));
writer.Write(array);
}
if (padding != 0)
{
padding = 4 - padding;
}
for (var i = 0; i < padding; i++)
{
writer.Write((byte)0);
}
}
}
public void Serialize(object value, IByteBuffer buffer, SerializationMetadata metadata)
{
var array = (TContainerMessage[])value;
buffer.WriteIntLE(array.Length);
foreach (var item in array)
{
buffer.WriteLongLE(item.MsgId);
buffer.WriteIntLE(item.SeqNo);
var dataBuffer = Serializer.Serialize(item.Body);
try
{
buffer.WriteIntLE(dataBuffer.ReadableBytes);
buffer.WriteBytes(dataBuffer);
}
finally
{
dataBuffer.Release();
}
}
}
internal void FinalizePrefab(PrefabMetadataContainer metadataContainer, SerializationMetadata metadata)
{
var removedComponents = metadataContainer.RemovedComponents;
if (removedComponents != null)
{
HandleRemovedComponents(removedComponents);
}
if (Application.isPlaying)
{
m_GameObject.AddComponent <PrefabMetadata>().Setup(metadataContainer);
}
var overrides = metadataContainer.PropertyOverrides;
if (overrides == null)
{
return;
}
metadata.EnqueuePostSerializationAction(() => { HandlePropertyOverrides(overrides, metadata); });
}
void GetMetadataRecursively(GameObject gameObject, SerializationMetadata metadata, string parentTransformPath = "", string transformPath = "")
{
var transform = gameObject.transform;
if (PrefabUtility.IsAddedGameObjectOverride(gameObject))
{
AddedGameObjects.Add(new RuntimeAddedGameObject
{
TransformPath = parentTransformPath,
GameObject = new GameObjectContainer(gameObject, metadata)
});
}
gameObject.GetComponents(k_Components);
foreach (var component in k_Components)
{
if (PrefabUtility.IsAddedComponentOverride(component))
{
AddedComponents.Add(new RuntimeAddedComponent
{
TransformPath = transformPath,
Component = component
});
}
}
foreach (Transform child in transform)
{
var childTransformPath = child.name;
if (!string.IsNullOrEmpty(transformPath))
{
childTransformPath = $"{transformPath}/{child.name}";
}
GetMetadataRecursively(child.gameObject, metadata, transformPath, childTransformPath);
}
}
public void ApplyOverride(Transform root, SerializationMetadata metadata)
{
var targetTransform = root.GetTransformAtPath(m_TransformPath);
if (targetTransform == null)
{
Debug.LogError($"Failed to apply override {m_PropertyPath}. Could not find {m_TransformPath} in {root.name}");
return;
}
var targetGameObject = targetTransform.gameObject;
var target = targetGameObject.GetTargetObjectWithComponentIndex(m_ComponentIndex);
if (target == null)
{
return;
}
var targetType = target.GetType();
if (targetType == typeof(Transform))
{
// Skip root order property as it is handled by scene hierarchy
if (PropertyPath.Contains("m_RootOrder"))
{
return;
}
// TODO: Support Euler hint
if (PropertyPath.Contains("m_LocalEulerAnglesHint"))
{
return;
}
}
ApplyOverrideToTarget(target, metadata);
}
public object Deserialize(IByteBuffer buffer, SerializationMetadata metadata)
{
byte[] data;
if (metadata?.ArrayLength != null)
{
data = new byte[metadata.ArrayLength.Value];
buffer.ReadBytes(data);
return(data);
}
var firstByte = buffer.ReadByte();
int len, padding;
if (firstByte == 254)
{
len = buffer.ReadByte() | (buffer.ReadByte() << 8) | (buffer.ReadByte() << 16);
padding = len % 4;
}
else
{
len = firstByte;
padding = (len + 1) % 4;
}
data = new byte[len];
buffer.ReadBytes(data);
if (padding > 0)
{
padding = 4 - padding;
buffer.SkipBytes(padding);
}
return(data);
}
public void Serialize(object value, IByteBuffer buffer, SerializationMetadata metadata)
{
buffer.WriteLongLE((long)value);
}
public object Deserialize(IByteBuffer buffer, SerializationMetadata metadata)
{
return((ulong)buffer.ReadLongLE());
}
public object Deserialize(BinaryReader reader, SerializationMetadata metadata)
{
var obj = Serializer.Deserialize(reader, null);
return(obj is TBoolTrue);
}
public void Serialize(object value, IByteBuffer buffer, SerializationMetadata metadata)
{
throw new NotSupportedException();
}
public object Deserialize(IByteBuffer buffer, SerializationMetadata metadata)
{
var data = (byte[])Serializer.Deserialize(buffer, typeof(byte[]));
return(UnzipPackage(data, metadata));
}
public object Deserialize(BinaryReader reader, SerializationMetadata metadata) => reader.ReadUInt32();
