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