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