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(); } } }