Nuclex.Support/Source/Serialization/BinarySerializer.cs

287 lines
11 KiB
C#

#region CPL License
/*
Nuclex Framework
Copyright (C) 2002-2008 Nuclex Development Labs
This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.
You should have received a copy of the IBM Common Public
License along with this library
*/
#endregion
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using Microsoft.Xna.Framework;
namespace Nuclex.Support.Serialization {
/// <summary>Utility class for serializating objects into binary data</summary>
public static class BinarySerializer {
#region System.Collections.Generic.ICollection
/// <summary>Loads a collection from its serialized representation</summary>
/// <param name="reader">Reader to use for reading the collection</param>
/// <param name="collection">Collection to be deserialized into</param>
public static void Load<BinarySerializableType>(
BinaryReader reader, ICollection<BinarySerializableType> collection
) where BinarySerializableType : IBinarySerializable {
// Read and verify the version of the file format this was saved in
int version = reader.ReadInt32();
if(version > 1)
throw new InvalidOperationException("File format mismatch");
// Read all the serialized blueprints
int count = reader.ReadInt32();
for(int index = 0; index < count; ++index) {
// Try to create an instance from the serialized type name
BinarySerializableType item = (BinarySerializableType)Activator.CreateInstance(
Type.GetType(reader.ReadString())
);
// Let the blueprint load its own data and add it to the collection
(item as IBinarySerializable).Load(reader);
collection.Add(item);
} // for
}
/// <summary>Serializes a collection of binary serializable objects</summary>
/// <param name="writer">BinaryWriter to serialize the collection into</param>
/// <param name="collection">Collection to be serialized</param>
public static void Save<BinarySerializableType>(
BinaryWriter writer, ICollection<BinarySerializableType> collection
) where BinarySerializableType : IBinarySerializable {
// Save the file format version so the loading routine can detect
// which version of the file format has to be loaded
writer.Write((int)1);
// Serialize all the blueprints in the collection
writer.Write((int)collection.Count);
foreach(BinarySerializableType item in collection) {
// Save the type name of the object so we can recreate it later
writer.Write(item.GetType().AssemblyQualifiedName);
// Let the object save its own data
((IBinarySerializable)item).Save(writer);
} // foreach
}
#endregion // System.Collections.Generic.ICollection
#region Microsoft.Xna.Framework.Matrix
/// <summary>Loads a matrix from its serialized representation</summary>
/// <param name="reader">Reader to use for reading the matrix</param>
/// <param name="matrix">Matrix to be deserialized</param>
public static void Load(BinaryReader reader, out Matrix matrix) {
matrix.M11 = reader.ReadSingle();
matrix.M12 = reader.ReadSingle();
matrix.M13 = reader.ReadSingle();
matrix.M14 = reader.ReadSingle();
matrix.M21 = reader.ReadSingle();
matrix.M22 = reader.ReadSingle();
matrix.M23 = reader.ReadSingle();
matrix.M24 = reader.ReadSingle();
matrix.M31 = reader.ReadSingle();
matrix.M32 = reader.ReadSingle();
matrix.M33 = reader.ReadSingle();
matrix.M34 = reader.ReadSingle();
matrix.M41 = reader.ReadSingle();
matrix.M42 = reader.ReadSingle();
matrix.M43 = reader.ReadSingle();
matrix.M44 = reader.ReadSingle();
}
/// <summary>Serializes a matrix into a binary data stream</summary>
/// <param name="writer">BinaryWriter to serialize the matrix into</param>
/// <param name="matrix">Matrix to be serialized</param>
public static void Save(BinaryWriter writer, ref Matrix matrix) {
writer.Write(matrix.M11);
writer.Write(matrix.M12);
writer.Write(matrix.M13);
writer.Write(matrix.M14);
writer.Write(matrix.M21);
writer.Write(matrix.M22);
writer.Write(matrix.M23);
writer.Write(matrix.M24);
writer.Write(matrix.M31);
writer.Write(matrix.M32);
writer.Write(matrix.M33);
writer.Write(matrix.M34);
writer.Write(matrix.M41);
writer.Write(matrix.M42);
writer.Write(matrix.M43);
writer.Write(matrix.M44);
}
#endregion // Microsoft.Xna.Framework.Matrix
#region Microsoft.Xna.Framework.Vector2
/// <summary>Loads a vector from its serialized representation</summary>
/// <param name="reader">Reader to use for reading the vector</param>
/// <param name="vector">Vector to be deserialized</param>
public static void Load(BinaryReader reader, out Vector2 vector) {
vector.X = reader.ReadSingle();
vector.Y = reader.ReadSingle();
}
/// <summary>Serializes a vector into a binary data stream</summary>
/// <param name="writer">BinaryWriter to serialize the vector into</param>
/// <param name="vector">Vector to be serialized</param>
public static void Save(BinaryWriter writer, ref Vector2 vector) {
writer.Write(vector.X);
writer.Write(vector.Y);
}
#endregion // Microsoft.Xna.Framework.Vector2
#region Microsoft.Xna.Framework.Vector3
/// <summary>Loads a vector from its serialized representation</summary>
/// <param name="reader">Reader to use for reading the vector</param>
/// <param name="vector">Vector to be deserialized</param>
public static void Load(BinaryReader reader, out Vector3 vector) {
vector.X = reader.ReadSingle();
vector.Y = reader.ReadSingle();
vector.Z = reader.ReadSingle();
}
/// <summary>Serializes a vector into a binary data stream</summary>
/// <param name="writer">BinaryWriter to serialize the vector into</param>
/// <param name="vector">Vector to be serialized</param>
public static void Save(BinaryWriter writer, ref Vector3 vector) {
writer.Write(vector.X);
writer.Write(vector.Y);
writer.Write(vector.Z);
}
#endregion // Microsoft.Xna.Framework.Vector3
#region Microsoft.Xna.Framework.Vector4
/// <summary>Loads a vector from its serialized representation</summary>
/// <param name="reader">Reader to use for reading the vector</param>
/// <param name="vector">Vector to be deserialized</param>
public static void Load(BinaryReader reader, out Vector4 vector) {
vector.X = reader.ReadSingle();
vector.Y = reader.ReadSingle();
vector.Z = reader.ReadSingle();
vector.W = reader.ReadSingle();
}
/// <summary>Serializes a vector into a binary data stream</summary>
/// <param name="writer">BinaryWriter to serialize the vector into</param>
/// <param name="vector">Vector to be serialized</param>
public static void Save(BinaryWriter writer, ref Vector4 vector) {
writer.Write(vector.X);
writer.Write(vector.Y);
writer.Write(vector.Z);
writer.Write(vector.W);
}
#endregion // Microsoft.Xna.Framework.Vector4
#region Microsoft.Xna.Framework.Quaternion
/// <summary>Loads a quaternion from its serialized representation</summary>
/// <param name="reader">Reader to use for reading the quaternion</param>
/// <param name="quaternion">Quaternion to be deserialized</param>
public static void Load(BinaryReader reader, out Quaternion quaternion) {
quaternion.X = reader.ReadSingle();
quaternion.Y = reader.ReadSingle();
quaternion.Z = reader.ReadSingle();
quaternion.W = reader.ReadSingle();
}
/// <summary>Serializes a quaternion into a binary data stream</summary>
/// <param name="writer">BinaryWriter to serialize the quaternion into</param>
/// <param name="quaternion">Quaternion to be serialized</param>
public static void Save(BinaryWriter writer, ref Quaternion quaternion) {
writer.Write(quaternion.X);
writer.Write(quaternion.Y);
writer.Write(quaternion.Z);
writer.Write(quaternion.W);
}
#endregion // Microsoft.Xna.Framework.Quaternion
#region Microsoft.Xna.Framework.Curve
/// <summary>Loads a curve from its serialized representation</summary>
/// <param name="reader">Reader to use for reading the curve</param>
/// <param name="curve">Curve to be deserialized</param>
public static void Load(BinaryReader reader, Curve curve) {
curve.Keys.Clear();
// Load the curve's loop settings
curve.PreLoop = (CurveLoopType)reader.ReadByte();
curve.PostLoop = (CurveLoopType)reader.ReadByte();
// Load the key frames defined for the curve
int keyCount = reader.ReadInt32();
for(int keyIndex = 0; keyIndex < curve.Keys.Count; ++keyIndex) {
float position = reader.ReadSingle();
float value = reader.ReadSingle();
float tangentIn = reader.ReadSingle();
float tangentOut = reader.ReadSingle();
CurveContinuity continuity = (CurveContinuity)reader.ReadByte();
curve.Keys.Add(new CurveKey(position, value, tangentIn, tangentOut, continuity));
}
}
/// <summary>Serializes a curve into a binary data stream</summary>
/// <param name="writer">BinaryWriter to serialize the curve into</param>
/// <param name="curve">Curve to be serialized</param>
public static void Save(BinaryWriter writer, Curve curve) {
// Save the curve's loop settings
writer.Write((byte)curve.PreLoop);
writer.Write((byte)curve.PostLoop);
// Save the key frames contained in the curve
writer.Write(curve.Keys.Count);
for(int keyIndex = 0; keyIndex < curve.Keys.Count; ++keyIndex) {
CurveKey key = curve.Keys[keyIndex];
writer.Write(key.Position);
writer.Write(key.Value);
writer.Write(key.TangentIn);
writer.Write(key.TangentOut);
writer.Write((byte)key.Continuity);
}
}
#endregion // Microsoft.Xna.Framework.Curve
} // class BinarySerializer
} // namespace Nuclex.Support.Serialization