public void SerializeTileData(TileData data, Stream stream)
{
var node = new TWXmlNode(TWXmlNode.CreateXmlDocument(), "TileData");
var guide = node.CreateChildNode("Guid");
XMLSerializer.WriteGuid(guide, data.Guid);
var mesh = node.CreateChildNode("Mesh");
XMLSerializer.WriteGuid(mesh, data.Mesh.Guid);
var dimensions = node.CreateChildNode("Dimensions");
XMLSerializer.WriteVector3(dimensions, data.Dimensions);
var facetypes = node.CreateChildNode("Faces");
for (int i = 0; i < data.FaceTypes.Length; i++)
{
if (data.FaceTypes[i] == null)
{
continue;
}
var faceNode = facetypes.CreateChildNode("Face");
var face = (TileFace)(i + 1);
faceNode.AddAttribute("Face", face.ToString());
XMLSerializer.WriteGuid(faceNode.CreateChildNode("Type"), data.FaceTypes[i].GetRoot().Guid);
XMLSerializer.WriteBoolean(faceNode.CreateChildNode("Winding"), data.GetTotalWinding(face));
}
node.XmlDocument.Save(stream);
}
public bool DeserializeElement(TWXmlNode node, Type type, out object value, IInternalSerializer s)
{
if (type == typeof(Vector3[]))
{
var floats = XMLSerializer.ReadFloatArray(node);
var array = new Vector3[floats.Length / 3];
for (int i = 0; i < array.Length; i++)
{
array[i] = new Vector3(floats[i * 3 + 0], floats[i * 3 + 1], floats[i * 3 + 2]);
}
value = array;
return(true);
}
if (type == typeof(Vector2[]))
{
var floats = XMLSerializer.ReadFloatArray(node);
var array = new Vector2[floats.Length / 2];
for (int i = 0; i < array.Length; i++)
{
array[i] = new Vector2(floats[i * 2 + 0], floats[i * 2 + 1]);
}
value = array;
return(true);
}
if (type == typeof(int[]))
{
value = XMLSerializer.ReadIntArray(node);
return(true);
}
value = null;
return(false);
}
public void Save(DirectoryInfo dir)
{
TWXmlNode root = new TWXmlNode(TWXmlNode.CreateXmlDocument(), "World");
root.AddChildNode("SerializerVersion", "0.1");
var entitiesNode = root.CreateChildNode("Entities");
entitiesNode.AddAttributeInt("Count", entities.Count);
dir.Create();
for (int i = 0; i < entities.Count; i++)
{
var ent = entities[i];
var relativePath = "Entity" + i.ToString("0000") + ".xml";
var fi = new FileInfo(dir.FullName + "\\" + relativePath);
saveEntity(ent, fi);
var entityNode = entitiesNode.CreateChildNode("Entity");
entityNode.AddAttribute("Type", ent.GetType().AssemblyQualifiedName);
entityNode.AddAttribute("RelativePath", relativePath);
}
using (var fs = new FileStream(dir.FullName + "\\World.xml", FileMode.Create))
{
root.Document.Save(fs);
}
}
private void serializeObject(Type type, TWXmlNode node, object obj)
{
foreach (var fieldInfo in type.GetFields())
{
object value = fieldInfo.GetValue(obj);
if (value == null)
{
continue;
}
serializeElement(node.CreateChildNode(fieldInfo.Name), fieldInfo.FieldType, value);
}
foreach (var propertyInfo in type.GetProperties())
{
if (propertyInfo.GetGetMethod() == null || propertyInfo.GetSetMethod() == null)
{
continue;
}
if (propertyInfo.GetIndexParameters().Length != 0)
{
continue;
}
object value = propertyInfo.GetValue(obj, null);
if (value == null)
{
continue;
}
serializeElement(node.CreateChildNode(propertyInfo.Name), propertyInfo.PropertyType, value);
}
}
public void Load(DirectoryInfo dir)
{
TWXmlNode root = TWXmlNode.GetRootNodeFromFile(dir.FullName + "\\World.xml");
var entitiesNode = root.FindChildNode("Entities");
var entityNodes = entitiesNode.GetChildNodes();
for (int i = 0; i < entityNodes.Length; i++)
{
var entityNode = entityNodes[i];
var type = entityNode.GetAttribute("Type");
var relativePath = entityNode.GetAttribute("RelativePath");
var serializer = new XmlSerializer(Type.GetType(type));
var fi = new FileInfo(dir.FullName + "\\" + relativePath);
var ent = loadEntity(fi, Type.GetType(type));
entities.Add(ent);
}
using (var fs = new FileStream(dir.FullName + "\\World.xml", FileMode.OpenOrCreate))
{
root.Document.Save(fs);
}
}
public void SerializeWorld(World world, Stream stream)
{
var rootNode = new TWXmlNode(TWXmlNode.CreateXmlDocument(), "World");
var typesList = new List <WorldObjectType>();
var worldObjectsNode = rootNode.CreateChildNode("WorldObjects");
for (int i = 0; i < world.WorldObjectList.Count; i++)
{
var wObj = world.WorldObjectList[i];
if (!typesList.Contains(wObj.ObjectType))
{
typesList.Add(wObj.ObjectType);
}
SerializeWorldObject(wObj, worldObjectsNode.CreateChildNode("WorldObject"));
}
var typesNode = rootNode.CreateChildNode("WorldObjectTypes");
for (int i = 0; i < typesList.Count; i++)
{
var type = typesList[i];
SerializeWorldObjectType(type, typesNode.CreateChildNode("Type"));
}
rootNode.Document.Save(stream);
}
private void deserializeObject(Type type, TWXmlNode node, object obj)
{
foreach (var fieldInfo in type.GetFields())
{
var childNode = node.FindChildNode(fieldInfo.Name);
if (childNode == null)
{
continue;
}
fieldInfo.SetValue(obj, deserializeElement(childNode, fieldInfo.FieldType));
}
foreach (var propertyInfo in type.GetProperties())
{
if (propertyInfo.GetGetMethod() == null || propertyInfo.GetSetMethod() == null)
{
continue;
}
if (propertyInfo.GetIndexParameters().Length != 0)
{
continue;
}
var childNode = node.FindChildNode(propertyInfo.Name);
if (childNode == null)
{
continue;
}
propertyInfo.SetValue(obj, deserializeElement(childNode, propertyInfo.PropertyType), null);
}
}
public void Deserialize(T obj, Stream strm)
{
var type = typeof(T);
var rootNode = TWXmlNode.GetRootNodeFromStream(strm);
deserializeObject(type, rootNode, obj);
}
public WorldObject DeserializeWorldObject(World world, TWXmlNode node)
{
var obj = world.CreateNewWorldObject(game, worldObjectTypeFactory.GetWorldObjectType(XMLSerializer.ReadGuid(node.FindChildNode("Type"))), renderer);
obj.Position = XMLSerializer.ReadVector3(node.FindChildNode("Position"));
obj.Rotation = XMLSerializer.ReadQuaternion(node.FindChildNode("Rotation"));
return(obj);
}
public bool SerializeElement(TWXmlNode node, Type type, object value, IInternalSerializer s)
{
if (type != typeof(SimpleClass))
{
return(false);
}
node.Value = "SimpleClass!!";
return(true);
}
public void Serialize(T obj, Stream strm)
{
var type = typeof(T);
var rootNode = new TWXmlNode(TWXmlNode.CreateXmlDocument(), type.Name);
serializeObject(type, rootNode, obj);
rootNode.Document.Save(strm);
}
public WorldObjectType DeserializeWorldObjectType(TWXmlNode node)
{
var type = new WorldObjectType(meshFactory.GetMesh(XMLSerializer.ReadGuid(node.FindChildNode("Mesh"))),
XMLSerializer.ReadGuid(node.FindChildNode("Guid")), builder);
type.TileData = diskTileDataFactory.GetTileData(XMLSerializer.ReadGuid(node.FindChildNode("TileData")));
if (type.TileData == null)
{
throw new InvalidOperationException("TileData For WorldObjectType not found!!");
}
return(type);
}
public void SerializeWorldObjectType(WorldObjectType type, TWXmlNode node)
{
var guid = node.CreateChildNode("Guid");
XMLSerializer.WriteGuid(guid, type.Guid);
var mesh = node.CreateChildNode("Mesh");
XMLSerializer.WriteGuid(mesh, type.Mesh.Guid);
var tileData = node.CreateChildNode("TileData");
XMLSerializer.WriteGuid(tileData, type.TileData.Guid);
}
public void SerializeWorldObject(WorldObject obj, TWXmlNode node)
{
var position = node.CreateChildNode("Position");
XMLSerializer.WriteVector3(position, obj.Position);
var rotation = node.CreateChildNode("Rotation");
XMLSerializer.WriteQuaternion(rotation, obj.Rotation);
var type = node.CreateChildNode("Type");
XMLSerializer.WriteGuid(type, obj.ObjectType.Guid);
}
public bool DeserializeElement(TWXmlNode node, Type type, out object value, IInternalSerializer s)
{
value = null;
if (type != typeof(SimpleClass))
{
return(false);
}
if (node.Value != "SimpleClass!!")
{
throw new InvalidOperationException("This xml is invalid!");
}
value = new SimpleClass();
return(true);
}
public void Load(TWXmlNode assetNode)
{
UpAxis = UpAxisType.None;
UnitName = "Unknown";
UnitInMeters = 1;
string up_axis = assetNode.ReadChildNodeValue("up_axis", "");
if (up_axis == "Z_UP")
{
UpAxis = UpAxisType.Z_UP;
}
TWXmlNode unitNode = assetNode.FindChildNode("unit");
UnitName = unitNode.GetAttribute("inch");
UnitInMeters = float.Parse(unitNode.GetAttribute("meter"));
}
public TileData DeserializeTileData(Stream stream)
{
var node = TWXmlNode.GetRootNodeFromStream(stream);
var data = new TileData(XMLSerializer.ReadGuid(node.FindChildNode("Guid")))
{
Mesh = meshFactory.GetMesh(XMLSerializer.ReadGuid(node.FindChildNode("Mesh"))),
Dimensions = XMLSerializer.ReadVector3(node.FindChildNode("Dimensions"))
};
var faces = node.FindChildNode("Faces").GetChildNodes();
for (int i = 0; i < faces.Length; i++)
{
var cFace = faces[i];
var face = (TileFace)Enum.Parse(typeof(TileFace), cFace.GetAttribute("Face"));
data.SetFaceType(face, tileFaceTypeFactory.GetTileFaceType(XMLSerializer.ReadGuid(cFace.FindChildNode("Type"))));
data.SetLocalWinding(face, XMLSerializer.ReadBoolean(cFace.FindChildNode("Winding")));
}
return(data);
}
public void DeserializeWorld(World world, Stream stream)
{
var rootNode = TWXmlNode.GetRootNodeFromStream(stream);
var typesNodes = rootNode.FindChildNode("WorldObjectTypes").GetChildNodes();
for (int i = 0; i < typesNodes.Length; i++)
{
var nType = typesNodes[i];
worldObjectTypeFactory.AddWorldObjectType(DeserializeWorldObjectType(nType));
}
var objectNodes = rootNode.FindChildNode("WorldObjects").GetChildNodes();
for (int i = 0; i < objectNodes.Length; i++)
{
var nObj = objectNodes[i];
// Auto-adds it to the world
DeserializeWorldObject(world, nObj);
}
}
public bool SerializeElement(TWXmlNode node, Type type, object value, IInternalSerializer s)
{
if (type == typeof(Vector3[]))
{
var array = (Vector3[])value;
var floats = new float[array.Length * 3];
for (int i = 0; i < array.Length; i++)
{
floats[i * 3 + 0] = array[i].X;
floats[i * 3 + 1] = array[i].Y;
floats[i * 3 + 2] = array[i].Z;
}
XMLSerializer.WriteFloatArray(node, floats);
return(true);
}
if (type == typeof(Vector2[]))
{
var array = (Vector2[])value;
var floats = new float[array.Length * 2];
for (int i = 0; i < array.Length; i++)
{
floats[i * 2 + 0] = array[i].X;
floats[i * 2 + 1] = array[i].Y;
}
XMLSerializer.WriteFloatArray(node, floats);
return(true);
}
if (type == typeof(int[]))
{
var array = (int[])value;
XMLSerializer.WriteIntArray(node, array);
return(true);
}
return(false);
}
object IInternalSerializer.deserializeElement(TWXmlNode node, Type type)
{
return(deserializeElement(node, type));
}
/// <summary>
/// The node is the node for this element, not for the parent object
/// </summary>
private object deserializeElement(TWXmlNode node, Type type)
{
if (!type.IsValueType && !node.HasChildNodes)
{
return(null);
}
foreach (var customSerializer in elementSerializers)
{
if (!type.IsAssignableFrom(customSerializer.Key))
{
continue;
}
return(customSerializer.Value.Deserialize(node));
}
for (int i = 0; i < serializers.Count; i++)
{
var s = serializers[i];
object obj;
if (s.DeserializeElement(node, type, out obj, this))
{
return(obj);
}
}
if (type == typeof(float))
{
return(float.Parse(node.Value));
}
if (type == typeof(string))
{
return(node.Value);
}
if (type == typeof(Int16))
{
return(Int16.Parse(node.Value));
}
if (type == typeof(Int32))
{
return(Int32.Parse(node.Value));
}
if (type == typeof(Int64))
{
return(Int64.Parse(node.Value));
}
if (type.IsEnum)
{
return(Enum.Parse(type, node.Value));
}
if (type.IsArray)
{
var childNodes = node.GetChildNodes();
var array = (IList)Activator.CreateInstance(type, childNodes.Length);
int i = 0;
var elementType = type.GetElementType();
foreach (var arrayChildNode in childNodes)
{
array[i] = deserializeElement(arrayChildNode, elementType);
i++;
}
return(array);
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List <>))
{
var childNodes = node.GetChildNodes();
var array = (IList)Activator.CreateInstance(type);
var elementType = type.GetGenericArguments()[0];
foreach (var arrayChildNode in childNodes)
{
array.Add(deserializeElement(arrayChildNode, elementType));
}
return(array);
}
if (type == typeof(Color))
{
return(XMLSerializer.ReadColor(node));
}
if (type == typeof(Matrix))
{
return(XMLSerializer.ReadMatrix(node));
}
if (type.IsPrimitive)
{
throw new InvalidOperationException("Can't serialize primitive type");
}
var childObject = Activator.CreateInstance(type);
deserializeObject(type, node, childObject);
return(childObject);
}
void IInternalSerializer.serializeElement(TWXmlNode node, Type type, object value)
{
serializeElement(node, type, value);
}
public void LoadFromXML(TWXmlNode node)
{
}
/// <summary>
/// The node is the node for this element, not for the parent object
/// </summary>
private void serializeElement(TWXmlNode node, Type type, object value)
{
if (value == null)
{
return;
}
foreach (var customSerializer in elementSerializers)
{
if (!type.IsAssignableFrom(customSerializer.Key))
{
continue;
}
customSerializer.Value.Serialize(node, value);
return;
}
for (int i = 0; i < serializers.Count; i++)
{
var s = serializers[i];
if (s.SerializeElement(node, type, value, this))
{
return;
}
}
if (type == typeof(float) ||
type == typeof(string) ||
type == typeof(Int16) ||
type == typeof(Int32) ||
type == typeof(Int64))
{
node.Value = value.ToString();
}
else if (type.IsEnum)
{
node.Value = value.ToString();
}
else if (type.IsArray)
{
int count;
Type elementType;
count = (int)type.GetProperty("Length").GetValue(value, null);
elementType = type.GetElementType();
var getMethod = type.GetMethod("Get");
for (int i = 0; i < count; i++)
{
serializeElement(
node.CreateChildNode(elementType.Name),
elementType,
getMethod.Invoke(value, new object[] { i }));
}
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List <>))
{
int count;
Type elementType;
elementType = type.GetGenericArguments()[0];
count = (int)type.GetProperty("Count").GetValue(value, null);
var indexerProperty = (PropertyInfo)type.GetDefaultMembers()[0];
for (int i = 0; i < count; i++)
{
serializeElement(
node.CreateChildNode(elementType.Name),
elementType,
indexerProperty.GetValue(value, new object[] { i }));
}
}
else if (type == typeof(Color))
{
XMLSerializer.WriteColor(node, (Color)value);
}
else if (type == typeof(Matrix))
{
XMLSerializer.WriteMatrix(node, (Matrix)value);
}
else
{
if (type.IsPrimitive)
{
throw new InvalidOperationException("Can't serialize primitive type");
}
serializeObject(type, node, value);
}
}
public void SaveToXML(TWXmlNode node)
{
}
