public override void Serialize(ref RuntimeRasterizedSpriteFont font, ArchiveMode mode, SerializationStream stream)
{
SpriteFont spriteFont = font;
parentSerializer.Serialize(ref spriteFont, mode, stream);
font = (RuntimeRasterizedSpriteFont)spriteFont;
if (mode == ArchiveMode.Deserialize)
{
var services = stream.Context.Tags.Get(ServiceRegistry.ServiceRegistryKey);
var fontSystem = services.GetSafeServiceAs <FontSystem>();
font.FontName = stream.Read <string>();
font.Style = stream.Read <FontStyle>();
font.UseKerning = stream.Read <bool>();
font.AntiAlias = stream.Read <FontAntiAliasMode>();
font.FontSystem = fontSystem;
}
else
{
stream.Write(font.FontName);
stream.Write(font.Style);
stream.Write(font.UseKerning);
stream.Write(font.AntiAlias);
}
}
public override void Serialize(ref T entityComponent, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(entityComponent.Entity);
stream.Write(CloneEntityComponentData.GenerateEntityComponentData(entityComponent));
}
else if (mode == ArchiveMode.Deserialize)
{
var entity = stream.Read <Entity>();
var data = stream.Read <CloneEntityComponentData>();
CloneEntityComponentData.RestoreEntityComponentData(entityComponent, data);
}
}
/// <inheritdoc/>
public override void Serialize(ref BasePart basePart, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(basePart.BasePartAsset);
stream.Write(basePart.BasePartId);
stream.Write(basePart.InstanceId);
}
else
{
var asset = stream.Read <AssetReference>();
var baseId = stream.Read <Guid>();
var instanceId = stream.Read <Guid>();
basePart = new BasePart(asset, baseId, instanceId);
}
}
public override void Serialize(ref UnloadableComponent obj, ArchiveMode mode, SerializationStream stream)
{
var invariantObjectList = stream.Context.Get(AssetCloner.InvariantObjectListProperty);
if (mode == ArchiveMode.Serialize)
{
stream.Write(invariantObjectList.Count);
invariantObjectList.Add(obj);
}
else
{
var index = stream.Read <int>();
if (index >= invariantObjectList.Count)
{
throw new InvalidOperationException($"The type [{nameof(UnloadableComponent)}] cannot be only be used for clone serialization");
}
var invariant = invariantObjectList[index] as UnloadableComponent;
if (invariant == null)
{
throw new InvalidOperationException($"Unexpected null {nameof(UnloadableComponent)} while cloning");
}
// Create a new UnloadableComponent to avoid exception when adding the previous component to another entity(EntityComponentCollection is validating that a component cannot be added more than once to an entity)
obj = new UnloadableComponent(new List <ParsingEvent>(invariant.ParsingEvents), invariant.TypeName);
}
}
public override void PreSerialize(ref T obj, ArchiveMode mode, SerializationStream stream)
{
var invariantObjectList = stream.Context.Get(InvariantObjectListProperty);
if (mode == ArchiveMode.Serialize)
{
stream.Write(invariantObjectList.Count);
invariantObjectList.Add(obj);
}
else
{
var index = stream.Read <int>();
if (index >= invariantObjectList.Count)
{
throw new InvalidOperationException($"The type [{typeof(T).FullName}] cannot be only be used for clone serialization");
}
var invariant = invariantObjectList[index] as T;
if (invariant == null)
{
throw new InvalidOperationException($"Unexpected null {typeof(T).FullName} while cloning");
}
// Create a new object to avoid exception in case its identity is important
obj = (T)Activator.CreateInstance(typeof(T), invariant.TypeName, invariant.AssemblyName, invariant.Error, invariant.ParsingEvents);
}
}
public override void Serialize(ref ParameterCollection parameterCollection, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
var parameters = new ParameterCollectionData();
foreach (var parameter in parameterCollection.InternalValues)
{
if (parameterCollection.IsValueOwner(parameter.Value))
{
parameters.Add(parameter.Key, parameter.Value.Object);
}
}
stream.Write(parameters);
}
else if (mode == ArchiveMode.Deserialize)
{
var parameters = stream.Read <ParameterCollectionData>();
foreach (var parameter in parameters)
{
var parameterValue = parameter.Value;
if (parameterValue is ContentReference)
{
parameterValue = ((ContentReference)parameterValue).ObjectValue;
}
parameterCollection.SetObject(parameter.Key, parameterValue);
}
}
}
public override void Serialize(ref Buffer buffer, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
var bufferData = stream.Read <BufferData>();
var services = stream.Context.Tags.Get(ServiceRegistry.ServiceRegistryKey);
if (services == null)
{
buffer.SetSerializationData(bufferData);
}
else
{
var graphicsDeviceService = services.GetSafeServiceAs <IGraphicsDeviceService>();
buffer.AttachToGraphicsDevice(graphicsDeviceService.GraphicsDevice);
buffer.InitializeFrom(bufferData.Content, bufferData.StructureByteStride, bufferData.BufferFlags, PixelFormat.None, bufferData.Usage);
// Setup reload callback (reload from asset manager)
var contentSerializerContext = stream.Context.Get(ContentSerializerContext.ContentSerializerContextProperty);
if (contentSerializerContext != null)
{
buffer.Reload = static (graphicsResource, services) =>
{
var assetManager = services.GetService <ContentManager>();
assetManager.TryGetAssetUrl(graphicsResource, out var url);
// When service isn't provided to the ContentManager, deserialized data is stored in a cache instead
// of being sent right away to GPU.
// See 'SetSerializationData()' above
assetManager = new ContentManager(services.GetService <IDatabaseFileProviderService>());
// TODO: Avoid loading/unloading the same data
// ^ perhaps out of date, will need to be discussed
var loadedBufferData = assetManager.Load <Buffer>(url);
try
{
var data = loadedBufferData.GetSerializationData().Content;
((Buffer)graphicsResource).Recreate(data);
}
finally
{
assetManager.Unload(loadedBufferData);
}
};
}
}
}
else
{
var bufferData = buffer.GetSerializationData();
if (bufferData == null)
{
throw new InvalidOperationException("Trying to serialize a Buffer without CPU info.");
}
stream.Write(bufferData);
}
}
public override void Serialize(ref PropertyContainer propertyCollection, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(propertyCollection.properties);
}
else if (mode == ArchiveMode.Deserialize)
{
propertyCollection.properties = stream.Read <Dictionary <PropertyKey, object> >();
}
}
/// <inheritdoc/>
public override void Serialize(ref SceneCameraSlotId assetReference, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(assetReference.Id);
}
else
{
var id = stream.Read <Guid>();
assetReference = new SceneCameraSlotId(id);
}
}
public override void Serialize(ref VertexBufferBinding vertexBufferBinding, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
var buffer = stream.Read <Buffer>();
var declaration = stream.Read <VertexDeclaration>();
var count = stream.ReadInt32();
var stride = stream.ReadInt32();
var offset = stream.ReadInt32();
vertexBufferBinding = new VertexBufferBinding(buffer, declaration, count, stride, offset);
}
else
{
stream.Write(vertexBufferBinding.Buffer);
stream.Write(vertexBufferBinding.Declaration);
stream.Write(vertexBufferBinding.Count);
stream.Write(vertexBufferBinding.Stride);
stream.Write(vertexBufferBinding.Offset);
}
}
public override void Serialize(ref BuildParameterCollection obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(obj.parameterList);
}
else
{
var parameterList = stream.Read <List <BuildParameter> >();
obj = new BuildParameterCollection();
obj.parameterList.AddRange(parameterList);
}
}
public override void Serialize(ref SignedDistanceFieldSpriteFont font, ArchiveMode mode, SerializationStream stream)
{
SpriteFont spriteFont = font;
parentSerializer.Serialize(ref spriteFont, mode, stream);
font = (SignedDistanceFieldSpriteFont)spriteFont;
if (mode == ArchiveMode.Deserialize)
{
var services = stream.Context.Tags.Get(ServiceRegistry.ServiceRegistryKey);
var fontSystem = services.GetSafeServiceAs <FontSystem>();
font.CharacterToGlyph = stream.Read <Dictionary <char, Glyph> >();
font.StaticTextures = stream.Read <List <Texture> >();
font.FontSystem = fontSystem;
}
else
{
stream.Write(font.CharacterToGlyph);
stream.Write(font.StaticTextures);
}
}
public override void Serialize(ref ObjectUrl obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(obj.Type);
stream.Write(obj.Path);
}
else
{
var type = stream.Read <UrlType>();
var path = stream.ReadString();
obj = new ObjectUrl(type, path);
}
}
public override void Serialize(ref T obj, ArchiveMode mode, SerializationStream stream)
{
var invariantObjectList = stream.Context.Get(AssetCloner.InvariantObjectListProperty);
if (mode == ArchiveMode.Serialize)
{
stream.Write(invariantObjectList.Count);
invariantObjectList.Add(obj);
}
else
{
var index = stream.Read <Int32>();
obj = (T)invariantObjectList[index];
}
}
/// <inheritdoc/>
public override void Serialize(ref AssetReference assetReference, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(assetReference.Id);
stream.Write(assetReference.Location);
}
else
{
var id = stream.Read <AssetId>();
var location = stream.ReadString();
assetReference = new AssetReference(id, location);
}
}
public override void Serialize(ref VertexDeclaration obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
var elements = stream.Read <VertexElement[]>();
var instanceCount = stream.ReadInt32();
var vertexStride = stream.ReadInt32();
obj = new VertexDeclaration(elements, instanceCount, vertexStride);
}
else
{
stream.Write(obj.VertexElements);
stream.Write(obj.InstanceCount);
stream.Write(obj.VertexStride);
}
}
public override void Serialize(ref RenderFrame renderFrame, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
var services = stream.Context.Tags.Get(ServiceRegistry.ServiceRegistryKey);
var graphicsDeviceService = services.GetSafeServiceAs <IGraphicsDeviceService>();
var descriptor = stream.Read <RenderFrameDescriptor>();
renderFrame.InitializeFrom(graphicsDeviceService.GraphicsDevice, descriptor);
}
else
{
var descriptor = renderFrame.Descriptor;
stream.Write(descriptor);
}
}
public override void Serialize(ref Buffer buffer, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
var bufferData = stream.Read <BufferData>();
var services = stream.Context.Tags.Get(ServiceRegistry.ServiceRegistryKey);
if (services == null)
{
buffer.SetSerializationData(bufferData);
}
else
{
var graphicsDeviceService = services.GetSafeServiceAs <IGraphicsDeviceService>();
buffer.AttachToGraphicsDevice(graphicsDeviceService.GraphicsDevice);
buffer.InitializeFrom(bufferData.Content, bufferData.StructureByteStride, bufferData.BufferFlags, PixelFormat.None, bufferData.Usage);
// Setup reload callback (reload from asset manager)
var contentSerializerContext = stream.Context.Get(ContentSerializerContext.ContentSerializerContextProperty);
if (contentSerializerContext != null)
{
var assetManager = contentSerializerContext.ContentManager;
var url = contentSerializerContext.Url;
buffer.Reload = (graphicsResource) =>
{
// TODO: Avoid loading/unloading the same data
var loadedBufferData = assetManager.Load <BufferData>(url);
((Buffer)graphicsResource).Recreate(loadedBufferData.Content);
assetManager.Unload(loadedBufferData);
};
}
}
}
else
{
var bufferData = buffer.GetSerializationData();
if (bufferData == null)
{
throw new InvalidOperationException("Trying to serialize a Buffer without CPU info.");
}
stream.Write(bufferData);
}
}
public override void Serialize(ref VertexElement obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
obj.semanticName = stream.ReadString();
obj.semanticIndex = stream.ReadInt32();
obj.format = stream.Read <PixelFormat>();
obj.alignedByteOffset = stream.ReadInt32();
obj.ComputeHashCode();
}
else
{
stream.Write(obj.semanticName);
stream.Write(obj.semanticIndex);
stream.Write(obj.format);
stream.Write(obj.alignedByteOffset);
}
}
public override void Serialize(ref IndexBufferBinding indexBufferBinding, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
var buffer = stream.Read <Buffer>();
var is32Bit = stream.ReadBoolean();
var count = stream.ReadInt32();
var offset = stream.ReadInt32();
indexBufferBinding = new IndexBufferBinding(buffer, is32Bit, count, offset);
}
else
{
stream.Write(indexBufferBinding.Buffer);
stream.Write(indexBufferBinding.Is32Bit);
stream.Write(indexBufferBinding.Count);
stream.Write(indexBufferBinding.Offset);
}
}
public override void Serialize(ref Effect effect, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
throw new InvalidOperationException();
}
var services = stream.Context.Tags.Get(ServiceRegistry.ServiceRegistryKey);
var graphicsDeviceService = services.GetSafeServiceAs <IGraphicsDeviceService>();
var effectBytecode = stream.Read <EffectBytecode>();
if (effect == null)
{
effect = new Effect();
}
effect.InitializeFrom(graphicsDeviceService.GraphicsDevice, effectBytecode);
}
/// <inheritdoc/>
public override void Serialize(ref T urlReference, ArchiveMode mode, [NotNull] SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
var attachedReference = AttachedReferenceManager.GetAttachedReference(urlReference);
if (attachedReference is null)
{
throw new InvalidOperationException("UrlReference does not have an AttachedReference.");
}
stream.Write(attachedReference.Id);
stream.Write(attachedReference.Url);
}
else
{
var id = stream.Read <AssetId>();
var url = stream.ReadString();
urlReference = (T)UrlReferenceHelper.CreateReference(typeof(T), id, url);
}
}
public override void Serialize(ref MaterialNull obj, ArchiveMode mode, SerializationStream stream)
{
if (stream.Context.SerializerSelector.HasProfile("AssetClone"))
{
// At design time, when performing a clone, we keep the associated id of this instance.
if (mode == ArchiveMode.Serialize)
{
var id = IdentifiableHelper.GetId(obj);
stream.Write(id);
}
else
{
var id = stream.Read <Guid>();
obj = new MaterialNull();
IdentifiableHelper.SetId(obj, id);
}
}
else
{
// For runtime serialization, a MaterialNull becomes null
obj = null;
}
}
public override void Serialize(ref ParameterCollection parameterCollection, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
var parameters = new Dictionary <ParameterKey, object>();
foreach (var parameter in parameterCollection.InternalValues)
{
if (parameterCollection.IsValueOwner(parameter.Value))
{
parameters.Add(parameter.Key, parameter.Value.Object);
}
}
stream.Write(parameters);
}
else if (mode == ArchiveMode.Deserialize)
{
var parameters = stream.Read <Dictionary <ParameterKey, object> >();
foreach (var parameter in parameters)
{
var parameterValue = parameter.Value;
parameterCollection.SetObject(parameter.Key, parameterValue);
}
}
}
public override void Serialize(ref T obj, ArchiveMode mode, SerializationStream stream)
{
var referenceSerialization = stream.Context.Get(ContentSerializerContext.SerializeAttachedReferenceProperty);
var contentSerializerContext = stream.Context.Get(ContentSerializerContext.ContentSerializerContextProperty);
if (contentSerializerContext != null)
{
if (mode == ArchiveMode.Serialize)
{
var contentReference = new ContentReference <T>(obj);
int index = contentSerializerContext.AddContentReference(contentReference);
stream.Write(index);
}
else
{
int index = stream.ReadInt32();
var contentReference = contentSerializerContext.GetContentReference <T>(index);
obj = contentReference.Value;
if (obj == null)
{
// Check if already deserialized
var assetReference = contentSerializerContext.ContentManager.FindDeserializedObject(contentReference.Location, typeof(T));
if (assetReference != null)
{
obj = (T)assetReference.Object;
if (obj != null)
{
contentReference.Value = obj;
}
}
}
if (obj == null && contentSerializerContext.LoadContentReferences)
{
var contentSerializer = cachedContentSerializer ?? (cachedContentSerializer = contentSerializerContext.ContentManager.Serializer.GetSerializer(null, typeof(T)));
if (contentSerializer == null)
{
// Need to read chunk header to know actual type (note that we can't cache it in cachedContentSerializer as it depends on content)
var chunkHeader = contentSerializerContext.ContentManager.ReadChunkHeader(contentReference.Location);
if (chunkHeader == null || (contentSerializer = contentSerializerContext.ContentManager.Serializer.GetSerializer(AssemblyRegistry.GetType(chunkHeader.Type), typeof(T))) == null)
{
throw new InvalidOperationException($"Could not find a valid content serializer for {typeof(T)} when loading {contentReference.Location}");
}
}
// First time, let's create it
if (contentSerializerContext.ContentManager.Exists(contentReference.Location))
{
obj = (T)contentSerializer.Construct(contentSerializerContext);
contentSerializerContext.ContentManager.RegisterDeserializedObject(contentReference.Location, obj);
contentReference.Value = obj;
}
}
}
}
else if (referenceSerialization == ContentSerializerContext.AttachedReferenceSerialization.AsNull)
{
if (mode == ArchiveMode.Deserialize)
{
obj = default(T);
}
}
else if (referenceSerialization == ContentSerializerContext.AttachedReferenceSerialization.AsSerializableVersion)
{
if (mode == ArchiveMode.Serialize)
{
// This case will happen when serializing build engine command hashes: we still want Location to still be written
var attachedReference = AttachedReferenceManager.GetAttachedReference(obj);
if (attachedReference?.Url == null)
{
throw new InvalidOperationException("Error when serializing reference.");
}
// TODO: Do not use string
stream.Write(obj.GetType().AssemblyQualifiedName);
stream.Write(attachedReference.Id);
stream.Write(attachedReference.Url);
}
else
{
var type = AssemblyRegistry.GetType(stream.ReadString());
var id = stream.Read <AssetId>();
var url = stream.ReadString();
obj = (T)AttachedReferenceManager.CreateProxyObject(type, id, url);
}
}
else
{
// This case will happen when serializing build engine command hashes: we still want Location to still be written
if (mode == ArchiveMode.Serialize)
{
// This case will happen when serializing build engine command hashes: we still want Location to still be written
var attachedReference = AttachedReferenceManager.GetAttachedReference(obj);
if (attachedReference?.Url == null)
{
throw new InvalidOperationException("Error when serializing reference.");
}
stream.Write(attachedReference.Url);
}
else
{
// No real case yet
throw new NotSupportedException();
}
}
}
