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