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 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);
}
}
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 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 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 ServiceSyncInfo info, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(info.CompressionThreshold);
stream.Write(info.ServiceKeyIndex);
stream.Write(info.UseCompression);
stream.Write(info.MethodInfos.Length);
foreach (var method in info.MethodInfos)
{
stream.Write(method.MethodIdent);
stream.Write(method.MethodName);
stream.Write(method.MethodReturnType);
stream.Write(method.ParameterTypes.Length);
foreach (var paramType in method.ParameterTypes)
{
stream.Write(paramType);
}
}
}
else if (mode == ArchiveMode.Deserialize)
{
info.CompressionThreshold = stream.ReadInt32();
info.ServiceKeyIndex = stream.ReadInt32();
info.UseCompression = stream.ReadBoolean();
var length = stream.ReadInt32();
info.MethodInfos = new MethodSyncInfo[length];
for (int i = 0; i < length; i++)
{
info.MethodInfos[i] = new MethodSyncInfo();
info.MethodInfos[i].MethodIdent = stream.ReadInt32();
info.MethodInfos[i].MethodName = stream.ReadString();
info.MethodInfos[i].MethodReturnType = stream.ReadString();
var paramLength = stream.ReadInt32();
info.MethodInfos[i].ParameterTypes = new string[paramLength];
for (int j = 0; j < paramLength; j++)
{
info.MethodInfos[i].ParameterTypes[j] = stream.ReadString();
}
}
}
}
public override void Serialize(ref PropertyInfo propertyInfo, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(propertyInfo.DeclaringType.AssemblyQualifiedName);
stream.Write(propertyInfo.Name);
}
else
{
var declaringTypeName = stream.ReadString();
var propertyName = stream.ReadString();
var ownerType = AssemblyRegistry.GetType(declaringTypeName);
if (ownerType == null)
{
throw new InvalidOperationException("Could not find the appropriate type.");
}
propertyInfo = ownerType.GetTypeInfo().GetDeclaredProperty(propertyName);
}
}
public override void Serialize(ref Type type, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(type.AssemblyQualifiedName);
}
else
{
var typeName = stream.ReadString();
type = AssemblyRegistry.GetType(typeName);
}
}
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 Video video, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
var services = stream.Context.Tags.Get(ServiceRegistry.ServiceRegistryKey);
video.FileProvider = services.GetService <IDatabaseFileProviderService>()?.FileProvider;
video.CompressedDataUrl = stream.ReadString();
}
else
{
stream.Write(video.CompressedDataUrl);
}
}
/// <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 AssetBase assetBase, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(assetBase.Location);
stream.SerializeExtended(assetBase.Asset, mode);
}
else
{
var location = stream.ReadString();
Asset asset = null;
stream.SerializeExtended(ref asset, mode);
assetBase = new AssetBase(location, asset);
}
}
/// <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);
}
}
}
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 static ChunkHeader Read(SerializationStream stream)
{
int magic = stream.ReadInt32();
if (magic != Magic)
{
// Rewind
stream.NativeStream.Seek(-4, SeekOrigin.Current);
return null;
}
int version = stream.ReadInt32();
var header = new ChunkHeader(version);
if (version == 1)
{
header.Type = stream.ReadString();
header.OffsetToObject = stream.ReadInt32();
header.OffsetToReferences = stream.ReadInt32();
}
return header;
}
/// <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 static ChunkHeader Read(SerializationStream stream)
{
int magic = stream.ReadInt32();
if (magic != Magic)
{
// Rewind
stream.NativeStream.Seek(-4, SeekOrigin.Current);
return(null);
}
int version = stream.ReadInt32();
var header = new ChunkHeader(version);
if (version == 1)
{
header.Type = stream.ReadString();
header.OffsetToObject = stream.ReadInt32();
header.OffsetToReferences = stream.ReadInt32();
}
return(header);
}
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.GetService <IAudioEngineProvider>()?.AudioEngine;
obj.FileProvider = services.GetService <IDatabaseFileProviderService>()?.FileProvider;
obj.CompressedDataUrl = stream.ReadString();
obj.SampleRate = stream.ReadInt32();
obj.Channels = stream.ReadByte();
obj.StreamFromDisk = stream.ReadBoolean();
obj.Spatialized = stream.ReadBoolean();
obj.NumberOfPackets = stream.ReadInt32();
obj.MaxPacketLength = stream.ReadInt16();
obj.Samples = stream.ReadInt32();
if (!obj.StreamFromDisk && audioEngine != null && audioEngine.State != AudioEngineState.Invalidated && audioEngine.State != AudioEngineState.Disposed) //immediatelly preload all the data and decode
{
obj.LoadSoundInMemory();
}
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(obj.NumberOfPackets);
stream.Write((short)obj.MaxPacketLength);
stream.Write(obj.Samples);
}
}
public override void Serialize(ref ParameterKey <T> obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(obj.Name);
stream.Write(obj.Length);
}
else
{
var parameterName = stream.ReadString();
var parameterLength = stream.ReadInt32();
obj = (ParameterKey <T>)ParameterKeys.FindByName(parameterName);
// If parameter could not be found, create one matching this type.
if (obj == null)
{
var metadata = new ParameterKeyValueMetadata <T>();
obj = new ParameterKey <T>(parameterName, parameterLength, metadata);
ParameterKeys.Merge(obj, null, parameterName);
}
}
}
/// <summary>
/// Reads header instance from a stream.
/// </summary>
/// <param name="stream">The source stream.</param>
/// <param name="result">Result data</param>
public static void Read(SerializationStream stream, out ContentStorageHeader result)
{
result = new ContentStorageHeader();
var version = stream.ReadInt32();
if (version == 1)
{
result.DataUrl = stream.ReadString();
result.PackageTime = new DateTime(stream.ReadInt64());
int chunksCount = stream.ReadInt32();
result.Chunks = new ChunkEntry[chunksCount];
for (int i = 0; i < chunksCount; i++)
{
result.Chunks[i].Location = stream.ReadInt32();
result.Chunks[i].Size = stream.ReadInt32();
}
result.HashCode = stream.ReadInt32();
return;
}
throw new SerializationException($"Invald {nameof(ContentStorageHeader)} version.");
}
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();
}
}
}
