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 ContentReference <T> reference, ArchiveMode mode, SerializationStream stream)
{
var contentSerializerContext = stream.Context.Get(ContentSerializerContext.ContentSerializerContextProperty);
if (contentSerializerContext != null)
{
if (mode == ArchiveMode.Serialize)
{
int index = contentSerializerContext.AddContentReference(reference);
stream.Write(index);
}
else
{
int index = stream.ReadInt32();
reference = contentSerializerContext.GetContentReference <T>(index);
}
}
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
stream.Write(reference.Location);
}
}
else
{
// No real case yet
throw new NotSupportedException();
}
}
}
/// <inheritdoc/>
public override void Serialize(ref EffectParameterKeyStandardGenerator obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(obj.Count);
foreach (var item in obj)
{
stream.SerializeExtended(item.Key, mode);
var valueType = item.Value.GetType();
if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(EffectParameterValuesGenerator <>))
{
var value = (IEffectParameterValueGenerator)item.Value;
var count = value.GenerateValues(item.Key).Count();
stream.Write(count);
foreach (var item2 in value.GenerateValues(item.Key))
{
stream.SerializeExtended(item2, mode);
}
}
else
{
stream.SerializeExtended(item.Value, mode);
}
}
}
else if (mode == ArchiveMode.Deserialize)
{
throw new NotImplementedException();
}
}
public void Write(SerializationStream stream)
{
stream.Write(Magic);
stream.Write(Version);
if (Version == 1)
{
stream.Write(Type);
stream.Write(OffsetToObject);
stream.Write(OffsetToReferences);
}
}
public void Write(SerializationStream stream)
{
stream.Write(Magic);
stream.Write(Version);
if (Version == 1)
{
stream.Write(Type);
stream.Write(OffsetToObject);
stream.Write(OffsetToReferences);
}
}
public override void PreSerialize(ref T obj, ArchiveMode mode, SerializationStream stream)
{
var cloneContext = stream.Context.Get(EntityCloner.CloneContextProperty);
if (mode == ArchiveMode.Serialize)
{
// Check against list of items that should be included in the stream (Entity and EntityComponent whose parent is the cloned Entity).
// First try MappedObjects, then ClonedObjects.
object mappedObject = null;
bool isSharedObject = cloneContext.MappedObjects != null && cloneContext.MappedObjects(obj, out mappedObject);
if (!isSharedObject && cloneContext.ClonedObjects != null && !cloneContext.ClonedObjects.Contains(obj))
{
isSharedObject = true;
mappedObject = obj;
}
stream.Write(isSharedObject);
if (isSharedObject)
{
stream.Write(cloneContext.SharedObjects.Count);
cloneContext.SharedObjects.Add(mappedObject);
}
else
{
cloneContext.SerializedObjects.Add(obj);
}
}
else
{
bool isSharedObject = stream.ReadBoolean();
if (isSharedObject)
{
var sharedObjectIndex = stream.ReadInt32();
obj = (T)cloneContext.SharedObjects[sharedObjectIndex];
// TODO: Hardcoded
// Model need to be cloned
if (obj is Model)
{
obj = (T)(object)((Model)(object)obj).Instantiate();
}
}
else
{
base.PreSerialize(ref obj, mode, stream);
cloneContext.SerializedObjects.Add(obj);
}
}
}
public override void Serialize(ref ChunkReference chunkReference, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(chunkReference.ObjectType.AssemblyQualifiedName);
stream.Write(chunkReference.Location);
}
else if (mode == ArchiveMode.Deserialize)
{
string typeName = stream.ReadString();
chunkReference = new ChunkReference(Type.GetType(typeName), stream.ReadString());
}
}
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 BuildParameter obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(obj.Name);
stream.Write(obj.Value);
}
else
{
var name = stream.ReadString();
var value = stream.ReadString();
obj = new BuildParameter(name, value);
}
}
/// <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 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);
}
}
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 ObjectId obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
var hasId = obj != Empty;
stream.Write(hasId);
if (hasId)
{
fixed(uint *hash = &obj.hash1)
stream.Serialize((IntPtr)hash, HashSize);
}
}
else if (mode == ArchiveMode.Deserialize)
{
var hasId = stream.ReadBoolean();
if (hasId)
{
var id = new byte[HashSize];
stream.Serialize(id, 0, HashSize);
obj = new ObjectId(id);
}
else
{
obj = ObjectId.Empty;
}
}
}
public void Serialize(SerializationStream stream, ArchiveMode mode)
{
// Check version number (should be 0 for now, for future use)
if (mode == ArchiveMode.Serialize)
{
stream.Write(0);
}
else if (mode == ArchiveMode.Deserialize)
{
if (stream.ReadInt32() != 0)
{
throw new InvalidOperationException("Unexpected version number.");
}
}
// Serialize content
stream.Serialize(ref IsBinary);
if (IsBinary)
{
stream.Serialize(ref BinaryFormat);
stream.Serialize(ref Binary, mode);
}
else
{
stream.Serialize(ref Profile);
stream.Serialize(ref EntryPoint);
stream.Serialize(ref Source);
}
}
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);
}
}
}
/// <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);
}
}
/// <inheritdoc/>
public override void Serialize(ref SiliconStudio.Core.Collections.SortedList <TKey, TValue> obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
// Should be null if it was
int count = stream.ReadInt32();
for (int i = 0; i < count; ++i)
{
TKey key = default(TKey);
TValue value = default(TValue);
keySerializer.Serialize(ref key, mode, stream);
valueSerializer.Serialize(ref value, mode, stream);
obj.Add(key, value);
}
}
else if (mode == ArchiveMode.Serialize)
{
stream.Write(obj.Count);
foreach (var item in obj)
{
keySerializer.Serialize(item.Key, stream);
valueSerializer.Serialize(item.Value, stream);
}
}
}
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);
}
}
/// <inheritdoc/>
public override void Serialize(ref IDictionary <TKey, TValue> obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
// Should be null if it was
var count = stream.ReadInt32();
for (var i = 0; i < count; ++i)
{
var key = default(TKey);
var value = default(TValue);
keySerializer.Serialize(ref key, mode, stream);
valueSerializer.Serialize(ref value, mode, stream);
obj.Add(key, value);
}
}
else if (mode == ArchiveMode.Serialize)
{
stream.Write(obj.Count);
foreach (var item in obj)
{
keySerializer.Serialize(item.Key, stream);
valueSerializer.Serialize(item.Value, stream);
}
}
}
protected override void SerializeInternal(object obj, SerializationStream stream)
{
var objectAsCollection = (ICollection)obj;
byte[] collectionSize = BitConverter.GetBytes(objectAsCollection.Count);
stream.Write(collectionSize);
BinaryConverter converter = new BinaryConverter();
foreach (var sourceElementValue in objectAsCollection)
{
if (sourceElementValue == null)
{
continue;
}
object elementValue = (sourceElementValue as IEnumerable <object>);
if (elementValue == null)
{
elementValue = sourceElementValue;
}
else
{
List <object> collectionOfObjects = new List <object>();
foreach (var item in (IList)elementValue)
{
collectionOfObjects.Add(item);
}
elementValue = collectionOfObjects;
}
byte[] data = converter.Serialize(elementValue);
stream.WriteWithLengthPrefix(data);
}
}
public override void Serialize(ref T obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(obj.Name);
stream.Write(obj.OwnerType.AssemblyQualifiedName);
}
else
{
var parameterName = stream.ReadString();
var ownerTypeName = stream.ReadString();
var ownerType = Type.GetType(ownerTypeName);
obj = (T)ownerType.GetTypeInfo().GetDeclaredField(parameterName).GetValue(null);
}
}
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 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);
}
}
/// <inheritdoc/>
public override void Serialize(ref Enum obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(obj != null ? obj.GetType().AssemblyQualifiedName : string.Empty);
stream.Write(Convert.ToInt32(obj));
}
else if (mode == ArchiveMode.Deserialize)
{
var type = AssemblyRegistry.GetType(stream.ReadString());
var value = stream.ReadInt32();
if (type != null)
{
obj = (Enum)Enum.ToObject(type, value);
}
}
}
protected override void SerializeInternal(decimal obj, SerializationStream stream)
{
int[] bits = decimal.GetBits(obj);
foreach (int bit in bits)
{
byte[] data = BitConverter.GetBytes(bit);
stream.Write(data);
}
}
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 Sound obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
var services = stream.Context.Tags.Get(ServiceRegistry.ServiceRegistryKey);
var audioEngine = services.GetServiceAs <IAudioEngineProvider>()?.AudioEngine;
obj.CompressedDataUrl = stream.ReadString();
obj.SampleRate = stream.ReadInt32();
obj.Channels = stream.ReadByte();
obj.StreamFromDisk = stream.ReadBoolean();
obj.Spatialized = stream.ReadBoolean();
obj.NumberOfPackets = stream.ReadInt16();
obj.MaxPacketLength = stream.ReadInt16();
if (!obj.StreamFromDisk && audioEngine != null && audioEngine.State != AudioEngineState.Invalidated && audioEngine.State != AudioEngineState.Disposed) //immediatelly preload all the data and decode
{
using (var soundStream = ContentManager.FileProvider.OpenStream(obj.CompressedDataUrl, VirtualFileMode.Open, VirtualFileAccess.Read, VirtualFileShare.Read, StreamFlags.Seekable))
using (var decoder = new Celt(obj.SampleRate, CompressedSoundSource.SamplesPerFrame, obj.Channels, true))
{
var reader = new BinarySerializationReader(soundStream);
var samplesPerPacket = CompressedSoundSource.SamplesPerFrame * obj.Channels;
obj.PreloadedBuffer = AudioLayer.BufferCreate(samplesPerPacket * obj.NumberOfPackets * sizeof(short));
var memory = new UnmanagedArray <short>(samplesPerPacket * obj.NumberOfPackets);
var offset = 0;
var outputBuffer = new short[samplesPerPacket];
for (var i = 0; i < obj.NumberOfPackets; i++)
{
var len = reader.ReadInt16();
var compressedBuffer = reader.ReadBytes(len);
var samplesDecoded = decoder.Decode(compressedBuffer, len, outputBuffer);
memory.Write(outputBuffer, offset, 0, samplesDecoded * obj.Channels);
offset += samplesDecoded * obj.Channels * sizeof(short);
}
AudioLayer.BufferFill(obj.PreloadedBuffer, memory.Pointer, memory.Length * sizeof(short), obj.SampleRate, obj.Channels == 1);
memory.Dispose();
}
}
if (audioEngine != null)
{
obj.Attach(audioEngine);
}
}
else
{
stream.Write(obj.CompressedDataUrl);
stream.Write(obj.SampleRate);
stream.Write((byte)obj.Channels);
stream.Write(obj.StreamFromDisk);
stream.Write(obj.Spatialized);
stream.Write((short)obj.NumberOfPackets);
stream.Write((short)obj.MaxPacketLength);
}
}
public override void Serialize(ref ParameterCollectionData obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
// Should be null if it was
int count = stream.ReadInt32();
for (int i = 0; i < count; ++i)
{
ParameterKey key = null;
object value = null;
bool matchingType = false;
stream.SerializeExtended(ref key, mode);
stream.Serialize(ref matchingType);
var valueType = matchingType ? key.PropertyType : typeof(object);
if (reuseReferences)
{
MemberReuseSerializer.SerializeExtended(stream, valueType, ref value, mode);
}
else
{
MemberNonSealedSerializer.SerializeExtended(stream, valueType, ref value, mode);
}
obj.Add(key, value);
}
}
else if (mode == ArchiveMode.Serialize)
{
stream.Write(obj.Count);
foreach (var item in obj)
{
var key = item.Key;
// When serializing convert the value type to the expecting type
// This should probably better done at the source (when creating/filling the ParameterCollectionData)
var value = item.Key.ConvertValue(item.Value);
stream.SerializeExtended(ref key, mode);
bool matchingType = value.GetType().GetTypeInfo().IsAssignableFrom(key.PropertyType.GetTypeInfo());
stream.Serialize(ref matchingType);
var valueType = matchingType ? key.PropertyType : typeof(object);
if (reuseReferences)
{
MemberReuseSerializer.SerializeExtended(stream, valueType, ref value, mode);
}
else
{
MemberNonSealedSerializer.SerializeExtended(stream, valueType, ref value, mode);
}
}
}
}
public override void Serialize(ref ShaderLevelBytecode obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(obj.DataES2 ?? "");
stream.Write(obj.DataES3 ?? "");
}
else
{
var es2Data = stream.ReadString();
var es3Data = stream.ReadString();
obj = new ShaderLevelBytecode
{
DataES2 = String.IsNullOrEmpty(es2Data) ? null : es2Data,
DataES3 = String.IsNullOrEmpty(es3Data) ? null : es3Data
};
}
}
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 CompressedTimeSpan timeSpan, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(timeSpan.Ticks);
}
else if (mode == ArchiveMode.Deserialize)
{
timeSpan = new CompressedTimeSpan(stream.ReadInt32());
}
}
