/// <summary>
/// Clones the current value of this cloner with the specified new shadow registry (optional)
/// </summary>
/// <param name="idRemapping">A dictionary containing the remapping of <see cref="IIdentifiable.Id"/> if <see cref="AssetClonerFlags.GenerateNewIdsForIdentifiableObjects"/> has been passed to the cloner.</param>
/// <returns>A clone of the value associated with this cloner.</returns>
private object Clone(out Dictionary <Guid, Guid> idRemapping)
{
var stream = streamOrValueType as Stream;
if (stream != null)
{
stream.Position = 0;
var reader = new BinarySerializationReader(stream);
reader.Context.SerializerSelector = ClonerSelector;
var refFlag = (flags & AssetClonerFlags.ReferenceAsNull) != 0
? ContentSerializerContext.AttachedReferenceSerialization.AsNull
: ContentSerializerContext.AttachedReferenceSerialization.AsSerializableVersion;
reader.Context.Set(InvariantObjectListProperty, invariantObjects);
reader.Context.Set(ContentSerializerContext.SerializeAttachedReferenceProperty, refFlag);
reader.Context.Set(MemberSerializer.ObjectDeserializeCallback, OnObjectDeserialized);
object newObject = null;
reader.SerializeExtended(ref newObject, ArchiveMode.Deserialize);
if ((flags & AssetClonerFlags.RemoveUnloadableObjects) != 0)
{
UnloadableObjectRemover.Run(newObject);
}
idRemapping = cloningIdRemapping;
return(newObject);
}
// Else this is a value type, so it is cloned automatically
idRemapping = null;
return(streamOrValueType);
}
private void HandleEffectCompilerRequestedPacket(RemoteEffectCompilerEffectRequested packet, PackageViewModel package)
{
// Received a shader requested notification, add it to list of "pending shaders", and update count in UI
dispatcher.InvokeAsync(() =>
{
CheckEffectLogAsset(package);
// Try to decode request
try
{
// Deserialize as an object
var binaryReader = new BinarySerializationReader(new MemoryStream(packet.Request));
EffectCompileRequest effectCompileRequest = null;
binaryReader.Context.SerializerSelector = SerializerSelector.AssetWithReuse;
binaryReader.SerializeExtended(ref effectCompileRequest, ArchiveMode.Deserialize, null);
// Record in list of pending effects and check if it would result in a new shader
// (it is still recorded in list of pending effect, in case EffectLog asset is deleted in the meantime)
if (pendingEffects.Add(effectCompileRequest) && !effectLogStore.Contains(effectCompileRequest))
{
UpdateImportEffectLogPendingCount(session.ImportEffectLogPendingCount + 1);
}
}
catch
{
// TODO Log error
//Log.Warning("Received an effect compilation request which could not be decoded. Make sure Windows project compiled successfully and is up to date.");
}
});
}
private static object DecodeObject(byte[] serializedObject)
{
var reader = new BinarySerializationReader(new MemoryStream(serializedObject));
object command = null;
reader.SerializeExtended(ref command, ArchiveMode.Deserialize, null);
return(command);
}
private static object DecodeObject(byte[] serializedObject)
{
var reader = new BinarySerializationReader(new MemoryStream(serializedObject));
reader.Context.SerializerSelector = SerializerSelector.AssetWithReuse;
reader.Context.Set(ContentSerializerContext.SerializeAttachedReferenceProperty, ContentSerializerContext.AttachedReferenceSerialization.AsSerializableVersion);
object command = null;
reader.SerializeExtended(ref command, ArchiveMode.Deserialize, null);
return(command);
}
/// <summary>
/// Clones the specified object, taking special care of <see cref="Entity"/>, <see cref="EntityComponent"/> and external assets.
/// User can optionally provides list of cloned objects (list of data reference objects that should be cloned)
/// and mapped objects (list of data reference objects that should be ducplicated using the given instance).
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="clonedObjects">The cloned objects.</param>
/// <param name="mappedObjects">The mapped objects.</param>
/// <param name="entity">The entity.</param>
/// <returns></returns>
private static T Clone <T>(HashSet <object> clonedObjects, TryGetValueFunction <object, object> mappedObjects, T entity) where T : class
{
if (cloneSerializerSelector == null)
{
cloneSerializerSelector = new SerializerSelector();
cloneSerializerSelector.ReuseReferences = true;
cloneSerializerSelector
.RegisterProfile("Default")
.RegisterProfile("Clone")
.RegisterSerializer(new EntitySerializer())
.RegisterSerializer(new CloneSerializer <string>())
.RegisterSerializer(new CloneSerializer <Effect>())
.RegisterSerializer(new CloneSerializer <Mesh>())
.RegisterSerializer(new CloneSerializer <Model>())
.RegisterSerializer(new CloneSerializer <AnimationClip>());
}
// Initialize CloneContext
lock (cloneContext)
{
try
{
cloneContext.EntitySerializerSelector = cloneSerializerSelector;
cloneContext.ClonedObjects = clonedObjects;
cloneContext.MappedObjects = mappedObjects;
// Serialize
var memoryStream = cloneContext.MemoryStream;
var writer = new BinarySerializationWriter(memoryStream);
writer.Context.SerializerSelector = cloneSerializerSelector;
writer.Context.Set(CloneContextProperty, cloneContext);
writer.SerializeExtended(entity, ArchiveMode.Serialize, null);
// Deserialization reuses this list and expect it to be empty at the beginning.
cloneContext.SerializedObjects.Clear();
// Deserialize
T result = null;
memoryStream.Seek(0, SeekOrigin.Begin);
var reader = new BinarySerializationReader(memoryStream);
reader.Context.SerializerSelector = cloneSerializerSelector;
reader.Context.Set(CloneContextProperty, cloneContext);
reader.SerializeExtended(ref result, ArchiveMode.Deserialize, null);
return(result);
}
finally
{
cloneContext.Cleanup();
}
}
}
public async Task MessageLoop()
{
try
{
while (true)
{
// Get next packet size
var bufferSize = await context.ReadStream.ReadInt32Async();
// Get next packet data (until complete)
var buffer = new byte[bufferSize];
await context.ReadStream.ReadAllAsync(buffer, 0, bufferSize);
// Deserialize as an object
var binaryReader = new BinarySerializationReader(new MemoryStream(buffer));
object obj = null;
binaryReader.Context.SerializerSelector = SerializerSelector.AssetWithReuse;
binaryReader.SerializeExtended <object>(ref obj, ArchiveMode.Deserialize, null);
// If it's a message, process it separately (StreamId)
if (obj is SocketMessage)
{
var socketMessage = (SocketMessage)obj;
ProcessMessage(socketMessage);
}
// Check if there is a specific handler for this packet type
bool handlerFound;
Tuple <Action <object>, bool> handler;
lock (packetHandlers)
{
handlerFound = packetHandlers.TryGetValue(obj.GetType(), out handler);
// one-time handler
if (handlerFound && handler.Item2)
{
packetHandlers.Remove(obj.GetType());
}
}
if (handlerFound)
{
handler.Item1(obj);
}
}
}
catch (Exception)
{
context.Dispose();
throw;
}
}
private static object Decode(byte[] data, Serializer serializer = null)
{
object result = null;
var stream = new BinarySerializationReader(new MemoryStream(data));
if (serializer != null)
{
stream.Context.Serializer = serializer;
}
stream.SerializeExtended(null, ref result, ArchiveMode.Deserialize);
return(result);
}
public T Deserialize <T>(byte[] bytes)
{
if (null == bytes || bytes.Length == 0)
{
return(default(T));
}
var reader = new BinarySerializationReader(new MemoryStream(bytes));
reader.Context.SerializerSelector = SerializerSelector.AssetWithReuse;
reader.Context.Set(ContentSerializerContext.SerializeAttachedReferenceProperty, ContentSerializerContext.AttachedReferenceSerialization.AsSerializableVersion);
T command = default(T);
reader.SerializeExtended(ref command, ArchiveMode.Deserialize, null);
return(command);
}
internal T DeepClone <T>(T obj)
{
// Serialize
writer.SerializeExtended(obj, ArchiveMode.Serialize);
// Deserialize
obj = default(T);
memoryStream.Seek(0, SeekOrigin.Begin);
reader.SerializeExtended(ref obj, ArchiveMode.Deserialize);
// Reset stream and references
memoryStream.Seek(0, SeekOrigin.Begin);
memoryStream.SetLength(0);
return(obj);
}
void MessageLoop()
{
while (true)
{
//var obj = formatter.Deserialize(socketStream);
var remaining = socketBinaryReader.ReadInt32();
var buffer = new byte[remaining];
int offset = 0;
while (remaining > 0)
{
int read = socketStream.Read(buffer, offset, remaining);
remaining -= read;
offset += read;
}
var binaryReader = new BinarySerializationReader(new MemoryStream(buffer));
object obj = null;
binaryReader.Context.SerializerSelector = SerializerSelector.AssetWithReuse;
binaryReader.SerializeExtended <object>(ref obj, ArchiveMode.Deserialize, null);
if (obj is SocketMessage)
{
var socketMessage = (SocketMessage)obj;
ProcessMessage(socketMessage);
}
bool handlerFound;
Tuple <Action <object>, bool> handler;
lock (packetHandlers)
{
handlerFound = packetHandlers.TryGetValue(obj.GetType(), out handler);
// one-time handler
if (handlerFound && handler.Item2)
{
packetHandlers.Remove(obj.GetType());
}
}
if (handlerFound)
{
handler.Item1(obj);
}
}
}
/// <summary>
/// Clones the current value of this cloner with the specified new shadow registry (optional)
/// </summary>
/// <returns>A clone of the value associated with this cloner.</returns>
private object Clone()
{
var stream = streamOrValueType as Stream;
if (stream != null)
{
stream.Position = 0;
var reader = new BinarySerializationReader(stream);
reader.Context.SerializerSelector = ClonerSelector;
var refFlag = (flags & AssetClonerFlags.ReferenceAsNull) != 0
? ContentSerializerContext.AttachedReferenceSerialization.AsNull
: ContentSerializerContext.AttachedReferenceSerialization.AsSerializableVersion;
reader.Context.Set(InvariantObjectListProperty, invariantObjects);
reader.Context.Set(ContentSerializerContext.SerializeAttachedReferenceProperty, refFlag);
object newObject = null;
reader.SerializeExtended(ref newObject, ArchiveMode.Deserialize);
// If there are any references, we would like to copy all dynamic properties from ShadowObject to the new instances
if (objectReferences != null)
{
var newObjectReferences = reader.Context.Get(MemberSerializer.ObjectDeserializeReferences);
foreach (var objRef in objectReferences)
{
var innerObject = objRef.Key;
var newInnerObject = newObjectReferences[objRef.Value];
// Copy only when objects are non-null
if (innerObject != null && newInnerObject != null)
{
ShadowObject.CopyDynamicProperties(innerObject, newInnerObject);
if ((flags & AssetClonerFlags.RemoveOverrides) != 0)
{
Override.RemoveFrom(newInnerObject);
}
}
}
}
return(newObject);
}
// Else this is a value type, so it is cloned automatically
return(streamOrValueType);
}
/// <summary>
/// Clones the current value of this cloner with the specified new shadow registry (optional)
/// </summary>
/// <returns>A clone of the value associated with this cloner.</returns>
public object Clone()
{
var stream = streamOrValueType as Stream;
if (stream != null)
{
stream.Position = 0;
var reader = new BinarySerializationReader(stream);
reader.Context.SerializerSelector = ClonerSelector;
var refFlag = referencesAsNull ? ContentSerializerContext.AttachedReferenceSerialization.AsNull
: ContentSerializerContext.AttachedReferenceSerialization.AsSerializableVersion;
reader.Context.Set(InvariantObjectListProperty, invariantObjects);
reader.Context.Set(ContentSerializerContext.SerializeAttachedReferenceProperty, refFlag);
object newObject = null;
reader.SerializeExtended(ref newObject, ArchiveMode.Deserialize);
return(newObject);
}
// Else this is a value type, so it is cloned automatically
return(streamOrValueType);
}
public object Deserialize(byte[] bytes, string typeConfigName)
{
if (null == typeConfigName)
{
throw new ArgumentNullException(nameof(typeConfigName));
}
var type = typeConfigName.ToType();
if (null == typeConfigName || null == bytes || bytes.Length == 0)
{
return(type.GetDefault());
}
var reader = new BinarySerializationReader(new MemoryStream(bytes));
reader.Context.SerializerSelector = SerializerSelector.AssetWithReuse;
reader.Context.Set(ContentSerializerContext.SerializeAttachedReferenceProperty, ContentSerializerContext.AttachedReferenceSerialization.AsSerializableVersion);
object command = null;
reader.SerializeExtended(ref command, ArchiveMode.Deserialize, null);
return(command);
}
private static T Clone <T>(HashSet <object> clonedObjects, T entity) where T : class
{
if (cloneSerializerSelector == null)
{
cloneSerializerSelector = new SerializerSelector(true, "Default", "Clone");
}
// Initialize CloneContext
lock (CloneContext)
{
try
{
CloneContext.EntitySerializerSelector = cloneSerializerSelector;
CloneContext.ClonedObjects = clonedObjects;
// Serialize
var memoryStream = CloneContext.MemoryStream;
var writer = new BinarySerializationWriter(memoryStream);
writer.Context.SerializerSelector = cloneSerializerSelector;
writer.Context.Set(EntityCloner.CloneContextProperty, CloneContext);
writer.SerializeExtended(entity, ArchiveMode.Serialize);
// Deserialization reuses this list and expect it to be empty at the beginning.
CloneContext.SerializedObjects.Clear();
// Deserialize
T result = null;
memoryStream.Seek(0, SeekOrigin.Begin);
var reader = new BinarySerializationReader(memoryStream);
reader.Context.SerializerSelector = cloneSerializerSelector;
reader.Context.Set(EntityCloner.CloneContextProperty, CloneContext);
reader.SerializeExtended(ref result, ArchiveMode.Deserialize);
return(result);
}
finally
{
CloneContext.Cleanup();
}
}
}
/// <summary>
/// Clones the current value of this cloner with the specified new shadow registry (optional)
/// </summary>
/// <param name="idRemapping">A dictionary containing the remapping of <see cref="IIdentifiable.Id"/> if <see cref="AssetClonerFlags.GenerateNewIdsForIdentifiableObjects"/> has been passed to the cloner.</param>
/// <returns>A clone of the value associated with this cloner.</returns>
private object Clone([NotNull] out Dictionary <Guid, Guid> idRemapping)
{
if (streamOrValueType is Stream stream)
{
stream.Position = 0;
var reader = new BinarySerializationReader(stream);
reader.Context.SerializerSelector = ClonerSelector;
reader.Context.Set(InvariantObjectListProperty, invariantObjects);
reader.Context.Set(ContentSerializerContext.SerializeAttachedReferenceProperty, GenerateContentSerializerFlags(flags));
if (externalIdentifiables != null)
{
if ((flags & AssetClonerFlags.ClearExternalReferences) != 0)
{
externalIdentifiables.Clear();
}
reader.Context.Set(MemberSerializer.ExternalIdentifiables, externalIdentifiables);
}
if ((flags & AssetClonerFlags.KeepReferences) != 0)
{
reader.Context.Set(ReferenceSerializer.CloneReferences, cloneReferences);
}
reader.Context.Set(MemberSerializer.ObjectDeserializeCallback, OnObjectDeserialized);
object newObject = null;
reader.SerializeExtended(ref newObject, ArchiveMode.Deserialize);
if ((flags & AssetClonerFlags.RemoveUnloadableObjects) != 0)
{
UnloadableObjectRemover.Run(newObject);
}
idRemapping = cloningIdRemapping;
return(newObject);
}
// Else this is a value type, so it is cloned automatically
idRemapping = new Dictionary <Guid, Guid>();
return(streamOrValueType);
}
private static object Decode(byte[] data, Serializer serializer = null)
{
object result = null;
var stream = new BinarySerializationReader(new MemoryStream(data));
if (serializer != null)
stream.Context.Serializer = serializer;
stream.SerializeExtended(null, ref result, ArchiveMode.Deserialize);
return result;
}
public void Test()
{
var prefab = new PrefabAsset();
var modelComponent = new ModelComponent();
var entity = new Entity()
{
modelComponent
};
prefab.Hierarchy.Parts.Add(new EntityDesign(entity));
prefab.Hierarchy.RootPartIds.Add(entity.Id);
var material1 = new MaterialNull();
IdentifiableHelper.SetId(material1, new Guid("39E2B226-8752-4678-8E93-76FFBFBA337B"));
var material2 = new MaterialNull();
IdentifiableHelper.SetId(material2, new Guid("CC4F1B31-FBB7-4360-A3E7-060BDFDA0695"));
modelComponent.Materials.Add(material1);
modelComponent.Materials.Add(material2);
Action <PrefabAsset> checkPrefab = (newPrefab) =>
{
var previousEntityDesign = newPrefab.Hierarchy.Parts.FirstOrDefault();
Assert.NotNull(previousEntityDesign);
var previousEntity = previousEntityDesign.Entity;
var component = previousEntity.Get <ModelComponent>();
Assert.NotNull(component);
Assert.AreEqual(2, component.Materials.Count);
var newMaterial1 = component.Materials[0];
Assert.AreEqual(IdentifiableHelper.GetId(material1), IdentifiableHelper.GetId(newMaterial1));
var newMaterial2 = component.Materials[1];
Assert.AreEqual(IdentifiableHelper.GetId(material2), IdentifiableHelper.GetId(newMaterial2));
};
// Test yaml serialization
{
using (var stream = new MemoryStream())
{
AssetSerializer.Save(stream, prefab);
stream.Position = 0;
var serializedVersion = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(serializedVersion);
stream.Position = 0;
var newPrefab = (PrefabAsset)AssetSerializer.Load(stream, "myentity");
checkPrefab(newPrefab);
}
}
// Test cloning
var newPrefabClone = (PrefabAsset)AssetCloner.Clone(prefab);
checkPrefab(newPrefabClone);
// Test runtime serialization (runtime serialization is removing MaterialNull and replacing it by a null)
{
var stream = new MemoryStream();
var writer = new BinarySerializationWriter(stream)
{
Context = { SerializerSelector = SerializerSelector.AssetWithReuse }
};
writer.SerializeExtended(entity, ArchiveMode.Serialize);
writer.Flush();
stream.Position = 0;
var reader = new BinarySerializationReader(stream)
{
Context = { SerializerSelector = SerializerSelector.AssetWithReuse }
};
Entity newEntity = null;
reader.SerializeExtended(ref newEntity, ArchiveMode.Deserialize);
Assert.NotNull(newEntity);
var component = newEntity.Get <ModelComponent>();
Assert.NotNull(component);
Assert.AreEqual(2, component.Materials.Count);
Assert.Null(component.Materials[0]);
Assert.Null(component.Materials[1]);
}
}
public async Task MessageLoop()
{
try
{
while (true)
{
// Get next packet size
var bufferSize = await context.ReadStream.ReadInt32Async();
// Get next packet data (until complete)
var buffer = new byte[bufferSize];
await context.ReadStream.ReadAllAsync(buffer, 0, bufferSize);
// Deserialize as an object
var binaryReader = new BinarySerializationReader(new MemoryStream(buffer));
object obj = null;
binaryReader.Context.SerializerSelector = SerializerSelector.AssetWithReuse;
binaryReader.SerializeExtended <object>(ref obj, ArchiveMode.Deserialize, null);
// If it's a message, process it separately (StreamId)
var message = obj as SocketMessage;
if (message != null)
{
var socketMessage = message;
ProcessMessage(socketMessage);
}
// Check if there is a specific handler for this packet type
bool handlerFound;
Tuple <Func <object, Task>, bool> handler;
lock (packetHandlers)
{
handlerFound = packetHandlers.TryGetValue(obj.GetType(), out handler);
// one-time handler
if (handlerFound && handler.Item2)
{
packetHandlers.Remove(obj.GetType());
}
}
if (handlerFound)
{
try
{
await handler.Item1(obj);
}
catch (Exception ex)
{
if (message != null && message.StreamId != 0)
{
var exceptionMessage = new ExceptionMessage
{
ExceptionInfo = new ExceptionInfo(ex),
StreamId = message.StreamId,
};
await Send(exceptionMessage);
}
}
}
}
}
catch (Exception e)
{
context.Dispose();
lock (packetCompletionTasks)
{
// Cancel all pending packets
foreach (var packetCompletionTask in packetCompletionTasks)
{
packetCompletionTask.Value.TrySetException(e);
}
packetCompletionTasks.Clear();
}
throw;
}
}