public void Write(SerializationStream stream) { stream.Write(Magic); stream.Write(Version); if (Version == 1) { stream.Write(Type); stream.Write(OffsetToObject); stream.Write(OffsetToReferences); } }
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 Dictionary <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); } } }
/// <inheritdoc/> public override void PreSerialize(ref SiliconStudio.Core.Collections.SortedList <TKey, TValue> obj, ArchiveMode mode, SerializationStream stream) { if (mode == ArchiveMode.Deserialize) { // TODO: Peek the SortedList size if (obj == null) { obj = new SiliconStudio.Core.Collections.SortedList <TKey, TValue>(); } else { obj.Clear(); } } }
public override void PreSerialize(ref NavigationMesh obj, ArchiveMode mode, SerializationStream stream) { base.PreSerialize(ref obj, mode, stream); if (mode == ArchiveMode.Deserialize) { if (obj == null) { obj = new NavigationMesh(); } } }
public override void Serialize(ref NavigationMeshTile tile, ArchiveMode mode, SerializationStream stream) { if (mode == ArchiveMode.Deserialize) { tile = new NavigationMeshTile(); } int dataLength = tile.Data?.Length ?? 0; stream.Serialize(ref dataLength); if (mode == ArchiveMode.Deserialize) { tile.Data = new byte[dataLength]; } if (dataLength > 0) { stream.Serialize(tile.Data, 0, tile.Data.Length); } }
public override unsafe void Serialize(ref Tetrahedron tetrahedron, ArchiveMode mode, SerializationStream stream) { fixed(Tetrahedron *tetrahedronPtr = &tetrahedron) stream.Serialize((IntPtr)tetrahedronPtr, sizeof(Tetrahedron)); }
internal static void Serialize(ArchiveMode mode, SerializationStream stream, Texture texture, bool allowContentStreaming) { if (mode == ArchiveMode.Deserialize) { var services = stream.Context.Tags.Get(ServiceRegistry.ServiceRegistryKey); var graphicsDeviceService = services.GetSafeServiceAs <IGraphicsDeviceService>(); var texturesStreamingProvider = services.GetService <ITexturesStreamingProvider>(); var isStreamable = stream.ReadBoolean(); if (!isStreamable) { texturesStreamingProvider?.UnregisterTexture(texture); // TODO: Error handling? using (var textureData = Image.Load(stream.NativeStream)) { if (texture.GraphicsDevice != null) { texture.OnDestroyed(); //Allows fast reloading todo review maybe? } texture.AttachToGraphicsDevice(graphicsDeviceService.GraphicsDevice); texture.InitializeFrom(textureData.Description, new TextureViewDescription(), textureData.ToDataBox()); // 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; texture.Reload = (graphicsResource) => { var textureDataReloaded = assetManager.Load <Image>(url); ((Texture)graphicsResource).Recreate(textureDataReloaded.ToDataBox()); assetManager.Unload(textureDataReloaded); }; } } } else { if (texture.GraphicsDevice != null) { texture.OnDestroyed(); } texture.AttachToGraphicsDevice(graphicsDeviceService.GraphicsDevice); texture.Reload = null; // Read image header var imageDescription = new ImageDescription(); ImageHelper.ImageDescriptionSerializer.Serialize(ref imageDescription, ArchiveMode.Deserialize, stream); // Read content storage header ContentStorageHeader storageHeader; ContentStorageHeader.Read(stream, out storageHeader); // Check if streaming service is available if (texturesStreamingProvider != null) { if (allowContentStreaming) { // Register texture for streaming texturesStreamingProvider.RegisterTexture(texture, ref imageDescription, ref storageHeader); // Note: here we don't load texture data and don't allocate GPU memory } else { // Request texture loading (should be fully loaded) texturesStreamingProvider.FullyLoadTexture(texture, ref imageDescription, ref storageHeader); } // Load initial texture (with limited number of mipmaps) if (storageHeader.InitialImage) { using (var textureData = Image.Load(stream.NativeStream)) { if (texture.GraphicsDevice != null) { texture.OnDestroyed(); //Allows fast reloading todo review maybe? } texture.InitializeFrom(textureData.Description, new TextureViewDescription(), textureData.ToDataBox()); } } } else { // Load initial texture and discard it (we are going to load the full chunk texture right after) if (storageHeader.InitialImage) { using (var textureData = Image.Load(stream.NativeStream)) { } } // Deserialize whole texture without streaming feature var contentSerializerContext = stream.Context.Get(ContentSerializerContext.ContentSerializerContextProperty); DeserializeTexture(contentSerializerContext.ContentManager, texture, ref imageDescription, ref storageHeader); } } } else { var textureData = texture.GetSerializationData(); if (textureData == null) { throw new InvalidOperationException("Trying to serialize a Texture without CPU info."); } textureData.Write(stream); } }
public override void Serialize(ref PropertyContainer propertyCollection, ArchiveMode mode, SerializationStream stream) { stream.SerializeExtended(ref propertyCollection.properties, mode); }
public override void PreSerialize(ref Buffer buffer, ArchiveMode mode, SerializationStream stream) { // Do not create object during preserialize (OK because not recursive) }
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 RasterizerState rasterizerState, ArchiveMode mode, SerializationStream stream) { if (mode == ArchiveMode.Serialize) { var rasterizerStateDescription = rasterizerState.Description; stream.Serialize(ref rasterizerStateDescription, mode); } else { // If we have a graphics context, we will instantiate GPU state, otherwise a CPU one. var services = stream.Context.Tags.Get(ServiceRegistry.ServiceRegistryKey); var graphicsDeviceService = services != null?services.GetSafeServiceAs <IGraphicsDeviceService>() : null; var rasterizerStateDescription = RasterizerStateDescription.Default; stream.Serialize(ref rasterizerStateDescription, mode); rasterizerState = graphicsDeviceService != null ? RasterizerState.New(graphicsDeviceService.GraphicsDevice, rasterizerStateDescription) : RasterizerState.NewFake(rasterizerStateDescription); } }
public override void Serialize(ref PermutationParameterKey <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 = (PermutationParameterKey <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 PermutationParameterKey <T>(parameterName, parameterLength, metadata); ParameterKeys.Merge(obj, null, parameterName); } } }
public override void Serialize(ref SettingsCollection obj, ArchiveMode mode, SerializationStream stream) { throw new System.NotImplementedException(); }
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(); } } }
/// <summary> /// Saves this instance to a stream. /// </summary> /// <param name="stream">The destination stream.</param> public void Write(SerializationStream stream) { var enableStreaming = EnableStreaming && Image.Description.MipLevels > InitialNonStreamedMipCount; stream.Write(enableStreaming); if (enableStreaming) { // Write image header ImageHelper.ImageDescriptionSerializer.Serialize(ref Image.Description, ArchiveMode.Serialize, stream); // Count number of mip maps that won't be part of initial load (they will be available through streaming) int skippedMipCount = Image.Description.MipLevels - InitialNonStreamedMipCount; // Determine whether we can store initial image StorageHeader.InitialImage = true; if (Image.Description.Format.IsCompressed()) { // Compressed: mips need to be multiple of 4, otherwise we can't do it var initialImageWidth = Image.PixelBuffers[skippedMipCount].Width; var initialImageHeight = Image.PixelBuffers[skippedMipCount].Height; if (initialImageWidth % 4 != 0 || initialImageHeight % 4 != 0) { StorageHeader.InitialImage = false; } } // Write storage header Debug.Assert(!string.IsNullOrEmpty(StorageHeader.DataUrl)); StorageHeader.Write(stream); if (StorageHeader.InitialImage) { // Note: in this scenario, we serialize only SkipStreamingMipCount (we know number is strictly higher than this due to previous check) var newDesc = Image.Description; newDesc.MipLevels = InitialNonStreamedMipCount; var pixelBuffers = new PixelBuffer[Image.Description.ArraySize * InitialNonStreamedMipCount]; for (uint item = 0; item < Image.Description.ArraySize; ++item) { for (uint level = 0; level < InitialNonStreamedMipCount; ++level) { pixelBuffers[item * InitialNonStreamedMipCount + level] = Image.PixelBuffers[item * Image.Description.MipLevels + level + skippedMipCount]; } } // Adjust new Width/Height newDesc.Width = pixelBuffers[0].Width; newDesc.Height = pixelBuffers[0].Height; var initialImage = new Image { Description = newDesc, PixelBuffers = pixelBuffers, }; // TODO: We end up duplicating some of the texture data; we could find a way to avoid that by saving only the chunks of higher level mips? initialImage.Save(stream.NativeStream, ImageFileType.Xenko); } } else { // Write whole image (old texture content serialization) Image.Save(stream.NativeStream, ImageFileType.Xenko); } }
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 PreSerialize(ref RuntimeRasterizedSpriteFont texture, ArchiveMode mode, SerializationStream stream) { // Do not create object during pre-serialize (OK because not recursive) }
/// <inheritdoc/> public override void Serialize(ContentSerializerContext context, SerializationStream stream, Texture texture) { Serialize(context.Mode, stream, texture, context.AllowContentStreaming); }
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); } }
internal void SerializeContent(SerializationStream stream, IContentSerializer serializer, object objToSerialize) { stream.Context.SerializerSelector = ContentManager.Serializer.LowLevelSerializerSelector; serializer.Serialize(this, stream, objToSerialize); }
public override void PreSerialize(ref ComputeColorParameters obj, ArchiveMode mode, SerializationStream stream) { if (mode == ArchiveMode.Deserialize) { // TODO: Peek the dictionary size if (obj == null) { obj = new ComputeColorParameters(); } else { obj.Clear(); } } }
public override unsafe void Serialize(ref Face face, ArchiveMode mode, SerializationStream stream) { fixed(Face *facePtr = &face) stream.Serialize((IntPtr)facePtr, sizeof(Face)); }
/// <inheritdoc/> public override void Serialize(ref ComputeColorParameters 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) { var value = new KeyValuePair <string, IComputeColorParameter>(); itemDataSerializer.Serialize(ref value, mode, stream); obj.Add(value.Key, value.Value); } } else if (mode == ArchiveMode.Serialize) { stream.Write(obj.Count); foreach (var item in obj.internalDictionary) { itemDataSerializer.Serialize(item, stream); } } }
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.elements); stream.Write(obj.instanceCount); stream.Write(obj.vertexStride); } }
protected override void SerializeInternal(object obj, SerializationStream stream) { stream.Write(); }
public override void Serialize(ref ParameterCollection parameterCollection, ArchiveMode mode, SerializationStream stream) { stream.Serialize(ref parameterCollection.parameterKeyInfos, mode); stream.SerializeExtended(ref parameterCollection.ObjectValues, mode); stream.Serialize(ref parameterCollection.DataValues, mode); }
public override void PreSerialize(ref AnimationKeyValuePair <T>[] obj, ArchiveMode mode, SerializationStream stream) { if (mode == ArchiveMode.Serialize) { stream.Write(obj.Length); } else if (mode == ArchiveMode.Deserialize) { int length = stream.ReadInt32(); obj = new AnimationKeyValuePair <T> [length]; } }
/// <inheritdoc/> public override void Serialize(ref KeyValuePair <TKey, TValue> obj, ArchiveMode mode, SerializationStream stream) { if (mode == ArchiveMode.Deserialize) { TKey key = default(TKey); TValue value = default(TValue); keySerializer.Serialize(ref key, mode, stream); valueSerializer.Serialize(ref value, mode, stream); obj = new KeyValuePair <TKey, TValue>(key, value); } else if (mode == ArchiveMode.Serialize) { keySerializer.Serialize(obj.Key, stream); valueSerializer.Serialize(obj.Value, stream); } }
public unsafe override void Serialize(ref AnimationKeyValuePair <T>[] obj, ArchiveMode mode, SerializationStream stream) { if (mode == ArchiveMode.Deserialize) { int count = obj.Length; var rawData = stream.ReadBytes(Utilities.SizeOf <AnimationKeyValuePair <T> >() * count); fixed(void *rawDataPtr = rawData) { Utilities.Read((IntPtr)rawDataPtr, obj, 0, count); } } else if (mode == ArchiveMode.Serialize) { int count = obj.Length; for (int i = 0; i < count; ++i) { itemDataSerializer.Serialize(ref obj[i], mode, stream); } } }
/// <inheritdoc/> public override void PreSerialize(ref IDictionary <TKey, TValue> obj, ArchiveMode mode, SerializationStream stream) { if (mode == ArchiveMode.Deserialize) { // TODO: Peek the dictionary size if (obj == null) { obj = new Dictionary <TKey, TValue>(); } else { obj.Clear(); } } }
protected override void SerializeInternal(DateTime obj, SerializationStream stream) { byte[] data = BitConverter.GetBytes(obj.Ticks); stream.Write(data); }