public void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
this.UniqueID = (uint)reader.ReadElementContentAsInt("UniqueID", "");
this.Name = reader.ReadElementString("Name", "");
this.MaxSize = reader.ReadElementContentAsFloat("MaxSize", "");
this.Lod1Distance = reader.ReadElementContentAsFloat("Lod1Distance", "");
this.Lod2Distance = reader.ReadElementContentAsFloat("Lod2Distance", "");
this.Shadows = reader.ReadElementContentAsBoolean("Shadows", "");
this.SoftShadows = reader.ReadElementContentAsBoolean("SoftShadows", "");
this.Bloom = reader.ReadElementContentAsBoolean("Bloom", "");
this.UseGraph = reader.ReadElementContentAsBoolean("UseGraph", "");
this.UseLods = reader.ReadElementContentAsBoolean("UseLods", "");
if (reader.Name == "Wind")
{
reader.ReadStartElement();
Wind = new Vector2(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""));
reader.ReadEndElement();
}
reader.ReadEndElement();
}
void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
//reader.ReadStartElement();
CastShadows = reader.ReadElementContentAsBoolean("CastShadows", "");
reader.ReadStartElement("LightColor");
LightColor = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
reader.ReadStartElement("LightSpecularColor");
LightSpecularColor = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
reader.ReadStartElement("LightDirection");
LightDirection = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
base.ReadXml(reader);
}
void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
reader.ReadStartElement("LightColor");
LightColor = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
base.ReadXml(reader);
}
public override void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
base.ReadXml(reader);
if (reader.Name == "Material")
{
if (!TrashSoupGame.Instance.EditorMode)
{
contentPath = "../../../../TrashSoupContent/Materials/";
}
else
{
contentPath = "../../../TrashSoup/TrashSoupContent/Materials/";
}
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (reader.Name == "Name")
{
String newName = reader.ReadElementString("Name", "");
Material m = new SkyboxMaterial();
XmlSerializer serializer = new XmlSerializer(typeof(Material));
using (FileStream file = new FileStream(contentPath + newName + ".xml", FileMode.Open))
{
m = (Material)serializer.Deserialize(file);
m.Name = newName;
}
Mat = m;
}
}
reader.ReadEndElement();
}
if (reader.Name == "Size")
{
reader.ReadStartElement();
Size = new Vector2(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""));
reader.ReadEndElement();
}
reader.ReadEndElement();
}
public override void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
base.ReadXml(reader);
SunID = (uint)reader.ReadElementContentAsInt("SunID", "");
LightDayID = (uint)reader.ReadElementContentAsInt("LightDayID", "");
LightNightID = (uint)reader.ReadElementContentAsInt("LightNightID", "");
if (reader.Name == "TextureNames")
{
TextureNames = new string[TEXTURE_COUNT];
reader.ReadStartElement();
for (int i = 0; i < TEXTURE_COUNT; ++i)
{
TextureNames[i] = reader.ReadElementString("TextureName");
}
reader.ReadEndElement();
}
SunriseMinutes = reader.ReadElementContentAsInt("SunriseMinutes", "");
SunsetMinutes = reader.ReadElementContentAsInt("SunsetMinutes", "");
StateChangeMinutes = reader.ReadElementContentAsInt("StateChangeMinutes", "");
HorizonOffset = reader.ReadElementContentAsFloat("HorizonOffset", "");
reader.ReadEndElement();
}
public override void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
base.ReadXml(reader);
target = ResourceManager.Instance.CurrentScene.GetObject((uint)reader.ReadElementContentAsInt("TargetID", ""));
//target = ResourceManager.Instance.CurrentScene.GetObject(tmp);
if (reader.Name == "TargetPosition")
{
reader.ReadStartElement();
this.target.MyTransform.Position = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
//reader.MoveToContent();
//reader.ReadStartElement();
base.ReadXml(reader);
//Name = reader.ReadElementString("Name", "");
//MyEffect = ResourceManager.Instance.LoadEffect(reader.ReadElementString("EffectPath", ""));
if (reader.Name == "CubeMaps")
{
reader.ReadStartElement();
CubeMap = ResourceManager.Instance.LoadTextureCube(reader.ReadElementString("CubeMap", ""));
CubeMap1 = ResourceManager.Instance.LoadTextureCube(reader.ReadElementString("CubeMap1", ""));
CubeMap2 = ResourceManager.Instance.LoadTextureCube(reader.ReadElementString("CubeMap2", ""));
CubeMap3 = ResourceManager.Instance.LoadTextureCube(reader.ReadElementString("CubeMap3", ""));
reader.ReadEndElement();
}
if (reader.Name == "Probes")
{
reader.ReadStartElement();
Probes = new Vector4(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""),
reader.ReadElementContentAsFloat("W", ""));
reader.ReadEndElement();
}
//reader.ReadStartElement("SpecularColor");
//SpecularColor = new Vector3(reader.ReadElementContentAsFloat("X", ""),
// reader.ReadElementContentAsFloat("Y", ""),
// reader.ReadElementContentAsFloat("Z", ""));
//reader.ReadEndElement();
//Glossiness = reader.ReadElementContentAsFloat("Glossiness", "");
AssignParamsInitialize();
//reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.ReadStartElement();
if (reader.Name == "intObjects")
{
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
string s = reader.Name;
int i = reader.ReadElementContentAsInt(s, "");
SetInt(s, i);
}
reader.ReadEndElement();
}
if (reader.Name == "floatObjects")
{
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
string s = reader.Name;
float f = reader.ReadElementContentAsFloat(s, "");
SetFloat(s, f);
}
reader.ReadEndElement();
}
if (reader.Name == "boolObjects")
{
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
string s = reader.Name;
bool b = reader.ReadElementContentAsBoolean(s, "");
SetBool(s, b);
}
reader.ReadEndElement();
}
if (reader.Name == "vectorObjects")
{
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
string s = reader.Name;
string content = reader.ReadElementContentAsString(s, "");
}
reader.ReadEndElement();
}
reader.ReadEndElement();
}
public override void ReadXml(System.Xml.XmlReader reader)
{
//reader.MoveToContent();
//reader.ReadStartElement();
base.ReadXml(reader);
////worldMatrix
worldMatrix = this.MyObject.MyTransform.GetWorldMatrix();
IsTrigger = reader.ReadElementContentAsBoolean("IsTrigger", "");
DoNothing = reader.ReadElementContentAsBoolean("DoNothing", "");
if (reader.Name == "CustomScale")
{
reader.ReadStartElement();
CustomScale = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
if (reader.Name == "CustomOffset")
{
reader.ReadStartElement();
CustomOffset = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
//MyObject = ResourceManager.Instance.CurrentScene.GetObject(tmp);
//this.CreateCollider();
//reader.ReadEndElement();
}
public override void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
base.ReadXml(reader);
//MyObject = ResourceManager.Instance.CurrentScene.GetObject(tmp);
if (reader.Name == "Position")
{
reader.ReadStartElement();
Position = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
if (reader.Name == "Rotation")
{
reader.ReadStartElement();
Rotation = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
if (reader.Name == "Forward")
{
reader.ReadStartElement();
Forward = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
Scale = reader.ReadElementContentAsFloat("Scale", "");
reader.ReadEndElement();
}
public override void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
base.ReadXml(reader);
//MyObject = ResourceManager.Instance.CurrentScene.GetObject(tmp);
if (reader.Name == "Acceleration")
{
reader.ReadStartElement();
acceleration = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
Mass = reader.ReadElementContentAsFloat("Mass", "");
DragFactor = reader.ReadElementContentAsFloat("DragFactor", "");
IsUsingGravity = reader.ReadElementContentAsBoolean("IsUsingGravity", "");
if (reader.Name == "Velocity")
{
reader.ReadStartElement();
Velocity = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
RotationConstraints = (RotationConstraintsEnum)Enum.Parse(typeof(RotationConstraintsEnum),
reader.ReadElementString("RotationConstraints", ""));
PositionConstraints = (PositionConstraintsEnum)Enum.Parse(typeof(PositionConstraintsEnum),
reader.ReadElementString("PositionConstraints", ""));
reader.ReadEndElement();
}
public void ReadXml(System.Xml.XmlReader reader)
{
CastShadows = reader.ReadElementContentAsBoolean("CastShadows", "");
reader.ReadStartElement("Color");
LightColor = new Vector3(reader.ReadElementContentAsFloat("R", ""),
reader.ReadElementContentAsFloat("G", ""),
reader.ReadElementContentAsFloat("B", ""));
reader.ReadEndElement();
reader.ReadStartElement("SpecularColor");
LightSpecularColor = new Vector3(reader.ReadElementContentAsFloat("R", ""),
reader.ReadElementContentAsFloat("G", ""),
reader.ReadElementContentAsFloat("B", ""));
reader.ReadEndElement();
Attenuation = reader.ReadElementContentAsFloat("Attenuation", "");
base.ReadXml(reader);
this.MyCollider = new SphereCollider(this, true);
this.MyPhysicalObject = new PhysicalObject(this, 0.0f, 0.0f, false);
}
private static EasyTrackerConfig LoadConfigXml(XmlReader reader)
{
var result = new EasyTrackerConfig();
reader.ReadStartElement("analytics");
do
{
if (reader.IsStartElement())
{
switch (reader.Name)
{
case "trackingId":
result.TrackingId = reader.ReadElementContentAsString();
break;
case "appName":
result.AppName = reader.ReadElementContentAsString();
break;
case "appVersion":
result.AppVersion = reader.ReadElementContentAsString();
break;
case "sampleFrequency":
result.SampleFrequency = reader.ReadElementContentAsFloat();
break;
case "dispatchPeriod":
var dispatchPeriodInSeconds = reader.ReadElementContentAsInt();
result.DispatchPeriod = TimeSpan.FromSeconds(dispatchPeriodInSeconds);
break;
case "sessionTimeout":
var sessionTimeoutInSeconds = reader.ReadElementContentAsInt();
result.SessionTimeout = (sessionTimeoutInSeconds >= 0) ? TimeSpan.FromSeconds(sessionTimeoutInSeconds) : (TimeSpan?)null;
break;
case "debug":
result.Debug = reader.ReadElementContentAsBoolean();
break;
case "autoAppLifetimeTracking":
result.AutoAppLifetimeTracking = reader.ReadElementContentAsBoolean();
break;
case "autoAppLifetimeMonitoring":
result.AutoAppLifetimeMonitoring = reader.ReadElementContentAsBoolean();
break;
case "anonymizeIp":
result.AnonymizeIp = reader.ReadElementContentAsBoolean();
break;
case "reportUncaughtExceptions":
result.ReportUncaughtExceptions = reader.ReadElementContentAsBoolean();
break;
case "useSecure":
result.UseSecure = reader.ReadElementContentAsBoolean();
break;
case "autoTrackNetworkConnectivity":
result.AutoTrackNetworkConnectivity = reader.ReadElementContentAsBoolean();
break;
default:
reader.Skip();
break;
}
}
else
{
reader.ReadEndElement();
break;
}
}
while (true);
return result;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Reads a RoleInfo from an XmlReader
/// </summary>
/// <param name="reader">The XmlReader to use</param>
/// -----------------------------------------------------------------------------
public void ReadXml(XmlReader reader)
{
//Set status to approved by default
Status = RoleStatus.Approved;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
break;
}
if (reader.NodeType == XmlNodeType.Whitespace)
{
continue;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name.ToLowerInvariant())
{
case "rolename":
RoleName = reader.ReadElementContentAsString();
break;
case "description":
Description = reader.ReadElementContentAsString();
break;
case "billingfrequency":
BillingFrequency = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(BillingFrequency))
{
BillingFrequency = "N";
}
break;
case "billingperiod":
BillingPeriod = reader.ReadElementContentAsInt();
break;
case "servicefee":
ServiceFee = reader.ReadElementContentAsFloat();
if (ServiceFee < 0)
{
ServiceFee = 0;
}
break;
case "trialfrequency":
TrialFrequency = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(TrialFrequency))
{
TrialFrequency = "N";
}
break;
case "trialperiod":
TrialPeriod = reader.ReadElementContentAsInt();
break;
case "trialfee":
TrialFee = reader.ReadElementContentAsFloat();
if (TrialFee < 0)
{
TrialFee = 0;
}
break;
case "ispublic":
IsPublic = reader.ReadElementContentAsBoolean();
break;
case "autoassignment":
AutoAssignment = reader.ReadElementContentAsBoolean();
break;
case "rsvpcode":
RSVPCode = reader.ReadElementContentAsString();
break;
case "iconfile":
IconFile = reader.ReadElementContentAsString();
break;
case "issystemrole":
IsSystemRole = reader.ReadElementContentAsBoolean();
break;
case "roletype":
switch (reader.ReadElementContentAsString())
{
case "adminrole":
_RoleType = RoleType.Administrator;
break;
case "registeredrole":
_RoleType = RoleType.RegisteredUser;
break;
case "subscriberrole":
_RoleType = RoleType.Subscriber;
break;
case "unverifiedrole":
_RoleType = RoleType.UnverifiedUser;
break;
default:
_RoleType = RoleType.None;
break;
}
_RoleTypeSet = true;
break;
case "securitymode":
switch (reader.ReadElementContentAsString())
{
case "securityrole":
SecurityMode = SecurityMode.SecurityRole;
break;
case "socialgroup":
SecurityMode = SecurityMode.SocialGroup;
break;
case "both":
SecurityMode = SecurityMode.Both;
break;
}
break;
case "status":
switch (reader.ReadElementContentAsString())
{
case "pending":
Status = RoleStatus.Pending;
break;
case "disabled":
Status = RoleStatus.Disabled;
break;
default:
Status = RoleStatus.Approved;
break;
}
break;
}
}
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
break;
}
else if (reader.NodeType == XmlNodeType.Whitespace)
{
continue;
}
else if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name.ToLowerInvariant())
{
case "rolename":
RoleName = reader.ReadElementContentAsString();
break;
case "description":
Description = reader.ReadElementContentAsString();
break;
case "billingfrequency":
BillingFrequency = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(BillingFrequency))
{
BillingFrequency = "N";
}
break;
case "billingperiod":
BillingPeriod = reader.ReadElementContentAsInt();
break;
case "servicefee":
ServiceFee = reader.ReadElementContentAsFloat();
if (ServiceFee < 0)
{
ServiceFee = 0;
}
break;
case "trialfrequency":
TrialFrequency = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(TrialFrequency))
{
TrialFrequency = "N";
}
break;
case "trialperiod":
TrialPeriod = reader.ReadElementContentAsInt();
break;
case "trialfee":
TrialFee = reader.ReadElementContentAsFloat();
if (TrialFee < 0)
{
TrialFee = 0;
}
break;
case "ispublic":
IsPublic = reader.ReadElementContentAsBoolean();
break;
case "autoassignment":
AutoAssignment = reader.ReadElementContentAsBoolean();
break;
case "rsvpcode":
RSVPCode = reader.ReadElementContentAsString();
break;
case "iconfile":
IconFile = reader.ReadElementContentAsString();
break;
case "roletype":
switch (reader.ReadElementContentAsString())
{
case "adminrole":
_RoleType = Roles.RoleType.Administrator;
break;
case "registeredrole":
_RoleType = Roles.RoleType.RegisteredUser;
break;
case "subscriberrole":
_RoleType = Roles.RoleType.Subscriber;
break;
default:
_RoleType = Roles.RoleType.None;
break;
}
_RoleTypeSet = true;
break;
}
}
}
}
protected override Object DoRead(XmlReader reader)
{
return reader.ReadElementContentAsFloat();
}
public Venue parseVenue(XmlReader venueReader)
{
Venue venueResult = new Venue();
while (venueReader.Read())
{
if (venueReader.NodeType == XmlNodeType.Element)
{
switch (venueReader.Name)
{
case "id":
venueResult.Id = venueReader.ReadElementContentAsInt();
break;
case "name":
venueResult.Name = venueReader.ReadElementContentAsString();
break;
case "url":
venueResult.Url = venueReader.ReadElementContentAsString();
break;
case "city":
venueResult.City = venueReader.ReadElementContentAsString();
break;
case "region":
venueResult.Region = venueReader.ReadElementContentAsString();
break;
case "country":
venueResult.Country = venueReader.ReadElementContentAsString();
break;
case "latitude":
venueResult.Latitude = venueReader.ReadElementContentAsFloat();
break;
case "longitude":
venueResult.Longitude = venueReader.ReadElementContentAsFloat();
break;
}
}
}
return venueResult;
}
private void DeserializeGameplayMembers(XmlReader reader)
{
gameOver = reader.ReadElementContentAsBoolean("GameOver", SerializationNamespace);
enemySpawnTimer = reader.ReadElementContentAsFloat("EnemySpawnTimer", SerializationNamespace);
enemySpawnRate = reader.ReadElementContentAsFloat("EnemySpawnRate", SerializationNamespace);
enemySpeedMin = reader.ReadElementContentAsFloat("EnemySpeedMin", SerializationNamespace);
enemySpeedMax = reader.ReadElementContentAsFloat("EnemySpeedMax", SerializationNamespace);
highScore = reader.ReadElementContentAsInt("HighScore", SerializationNamespace);
}
public override float ReadElementContentAsFloat()
{
CheckAsync();
return(coreReader.ReadElementContentAsFloat());
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToContent();
reader.ReadStartElement();
Name = reader.ReadElementString("Name", "");
MyEffect = ResourceManager.Instance.LoadEffect(reader.ReadElementString("EffectPath", ""));
uint normColor = 0xFFFF0F0F;
uint blackColor = 0xFF000000;
Texture2D defDiff = null;
if (!ResourceManager.Instance.Textures.TryGetValue("DefaultDiffuse", out defDiff))
{
defDiff = new Texture2D(TrashSoupGame.Instance.GraphicsDevice, 1, 1, false, SurfaceFormat.Color);
defDiff.SetData <uint>(new uint[] { blackColor });
ResourceManager.Instance.Textures.Add("DefaultDiffuse", defDiff);
}
Texture2D defNrm = null;
if (!ResourceManager.Instance.Textures.TryGetValue("DefaultNormal", out defNrm))
{
defNrm = new Texture2D(TrashSoupGame.Instance.GraphicsDevice, 1, 1, false, SurfaceFormat.Color);
defNrm.SetData <uint>(new uint[] { normColor });
ResourceManager.Instance.Textures.Add("DefaultNormal", defNrm);
}
TextureCube defCbc = null;
if (!ResourceManager.Instance.TexturesCube.TryGetValue("DefaultCube", out defCbc))
{
defCbc = new TextureCube(TrashSoupGame.Instance.GraphicsDevice, 1, false, SurfaceFormat.Color);
defCbc.SetData <uint>(CubeMapFace.NegativeX, new uint[] { blackColor });
defCbc.SetData <uint>(CubeMapFace.PositiveX, new uint[] { blackColor });
defCbc.SetData <uint>(CubeMapFace.NegativeY, new uint[] { blackColor });
defCbc.SetData <uint>(CubeMapFace.PositiveY, new uint[] { blackColor });
defCbc.SetData <uint>(CubeMapFace.NegativeZ, new uint[] { blackColor });
defCbc.SetData <uint>(CubeMapFace.PositiveZ, new uint[] { blackColor });
ResourceManager.Instance.TexturesCube.Add("DefaultCube", defCbc);
}
DiffuseMap = ResourceManager.Instance.LoadTexture(reader.ReadElementString("DiffusePath", ""));
if (reader.Name == "NormalPath")
{
NormalMap = ResourceManager.Instance.LoadTexture(reader.ReadElementString("NormalPath", ""));
}
if (reader.Name == "CubePath")
{
CubeMap = ResourceManager.Instance.LoadTextureCube(reader.ReadElementString("CubePath", ""));
}
reader.ReadStartElement("DiffuseColor");
DiffuseColor = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
reader.ReadStartElement("SpecularColor");
SpecularColor = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
Glossiness = reader.ReadElementContentAsFloat("Glossiness", "");
reader.ReadStartElement("ReflectivityColor");
ReflectivityColor = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
ReflectivityBias = reader.ReadElementContentAsFloat("ReflectivityBias", "");
Transparency = reader.ReadElementContentAsFloat("Transparency", "");
PerPixelLighting = reader.ReadElementContentAsBoolean("PerPixelLighting", "");
RecieveShadows = reader.ReadElementContentAsBoolean("ReceiveShadows", "");
Unlit = reader.ReadElementContentAsBoolean("Unlit", "");
AssignParamsInitialize();
if (this.GetType() == typeof(Material))
{
reader.ReadEndElement();
}
}
private AxisConfiguration ReadAxisConfiguration(XmlReader reader)
{
AxisConfiguration axisConfig = new AxisConfiguration();
axisConfig.name = reader["name"];
bool endOfAxis = false;
while(reader.Read() && reader.IsStartElement() && !endOfAxis)
{
switch(reader.LocalName)
{
case "description":
axisConfig.description = reader.IsEmptyElement ? string.Empty : reader.ReadElementContentAsString();
break;
case "positive":
axisConfig.positive = AxisConfiguration.StringToKey(reader.ReadElementContentAsString());
break;
case "altPositive":
axisConfig.altPositive = AxisConfiguration.StringToKey(reader.ReadElementContentAsString());
break;
case "negative":
axisConfig.negative = AxisConfiguration.StringToKey(reader.ReadElementContentAsString());
break;
case "altNegative":
axisConfig.altNegative = AxisConfiguration.StringToKey(reader.ReadElementContentAsString());
break;
case "deadZone":
axisConfig.deadZone = reader.ReadElementContentAsFloat();
break;
case "gravity":
axisConfig.gravity = reader.ReadElementContentAsFloat();
break;
case "sensitivity":
axisConfig.sensitivity = reader.ReadElementContentAsFloat();
break;
case "snap":
axisConfig.snap = reader.ReadElementContentAsBoolean();
break;
case "invert":
axisConfig.invert = reader.ReadElementContentAsBoolean();
break;
case "type":
axisConfig.type = AxisConfiguration.StringToInputType(reader.ReadElementContentAsString());
break;
case "axis":
axisConfig.axis = reader.ReadElementContentAsInt();
break;
case "joystick":
axisConfig.joystick = reader.ReadElementContentAsInt();
break;
default:
endOfAxis = true;
break;
}
}
return axisConfig;
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
if (reader.IsEmptyElement) {
reader.ReadStartElement();
return;
}
reader.ReadStartElement();
while (!reader.EOF) {
if (reader.IsStartElement()) {
switch (reader.Name) {
case "Scale":
Scale = reader.ReadElementContentAsFloat();
break;
case "Rotation":
Rotation = reader.ReadElementContentAsFloat();
break;
case "Opacity":
Opacity = reader.ReadElementContentAsFloat();
break;
case "BlendColor":
BlendColor = ColorExt.ParseArgbHex(reader.ReadElementContentAsString());
break;
default:
reader.Skip();
break;
}
}
else if (reader.NodeType == XmlNodeType.EndElement) {
reader.ReadEndElement();
break;
}
else
reader.Read();
}
}
/// <summary>
/// Creates an instance of the main diagnostic config object from an XmlReader
/// </summary>
public static DiagnosticsConfig Load(XmlReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
var result = new DiagnosticsConfig();
List<EdgeServerRules> edgeServerRuleCollection = null;
reader.GoToElement();
reader.ReadStartElement();
if (!reader.IsEmptyElement)
{
while (reader.GoToSibling())
{
switch (reader.LocalName)
{
case "TraceMonitor":
result.TracingConfig = TracingConfig.Load(reader);
break;
case "EdgeServerRules":
if (!reader.IsEmptyElement)
{
if (edgeServerRuleCollection == null)
{
edgeServerRuleCollection = new List<EdgeServerRules>();
result.EdgeServerRuleCollection = edgeServerRuleCollection;
}
edgeServerRuleCollection.Add(EdgeServerRules.Load(reader));
}
else
reader.Skip();
break;
case "Diagnostics":
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
while (reader.GoToSibling())
{
switch (reader.LocalName)
{
case "TrackQuality":
result.TrackQuality = Convert.ToBoolean(reader.ReadElementContentAsInt());
break;
case "TrackDownloadErrors":
result.TrackDownloadErrors = Convert.ToBoolean(reader.ReadElementContentAsInt());
break;
case "AggregationIntervalMilliseconds":
result.AggregationInterval = TimeSpan.FromMilliseconds(reader.ReadElementContentAsInt());
break;
case "TrackQualitySnapshot":
result.TrackQualitySnapshot = Convert.ToBoolean(reader.ReadElementContentAsInt());
break;
case "SnapshotIntervalMilliseconds":
result.SnapshotInterval = TimeSpan.FromMilliseconds(reader.ReadElementContentAsInt());
break;
case "LatencyAlertThreshold":
result.LatencyAlertThreshold = reader.ReadElementContentAsFloat();
break;
case "RecordTraceLogs":
result.RecordTraceLogs = Convert.ToBoolean(reader.ReadElementContentAsInt());
break;
case "QualityTracking":
result.QualityConfig = QualityConfig.Load(reader);
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
}
else
reader.Skip();
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
}
else
reader.Skip();
return result;
}
public void Deserialize(XmlReader reader)
{
m_name = reader.GetAttribute("name");
int version = Convert.ToInt32(reader.GetAttribute("version"), CultureInfo.InvariantCulture);
reader.ReadStartElement(); //ParticleEffect
m_particleID = reader.ReadElementContentAsInt();
m_length = reader.ReadElementContentAsFloat();
m_preload = reader.ReadElementContentAsFloat();
if (reader.Name == "LowRes")
LowRes = reader.ReadElementContentAsBoolean();
bool isEmpty = reader.IsEmptyElement;
reader.ReadStartElement(); //Generations
while (reader.NodeType != XmlNodeType.EndElement)
{
MyParticleGeneration generation = MyParticlesManager.GenerationsPool.Allocate();
generation.Start(this);
generation.Init();
generation.Deserialize(reader);
AddGeneration(generation);
}
if (!isEmpty)
reader.ReadEndElement(); //Generations
reader.ReadEndElement(); //ParticleEffect
}
private MonsterData ReadMonster(XmlReader reader, Counter<string> badTags)
{
string identifier = null;
string name = null;
string imageName = null;
DiceRoll hitDice = DiceRoll.ZERO_ROLL;
List<AreaType> areaTypes = new List<AreaType>();
List<string> loot = new List<string>();
int initiative = 0;
int armorClass = 0;
int attackBonus = 0;
float challengeRating = 0;
WeaponStats weaponStats = new WeaponStats("blahh", DiceRoll.ZERO_ROLL, 1,30, null);
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "id")
{
identifier = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "name")
{
name = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "image_name")
{
imageName = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "hit_dice")
{
hitDice = XmlHelper.ReadDiceRoll(reader.ReadElementContentAsString());
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "initiative")
{
initiative = reader.ReadElementContentAsInt();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "armor_class")
{
armorClass = reader.ReadElementContentAsInt();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "attack")
{
attackBonus = reader.ReadElementContentAsInt();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "areas")
{
areaTypes = XmlHelper.ReadAreaTypes(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "weapon")
{
weaponStats = XmlHelper.ReadWeaponStats(reader, badTags, null);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "drops")
{
loot = XmlHelper.ReadDrops(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "challenge_rating")
{
challengeRating = reader.ReadElementContentAsFloat();
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "monster")
{
break;
}
}
return new MonsterData(identifier, name, imageName, hitDice, initiative, armorClass, challengeRating, attackBonus, weaponStats, areaTypes, loot);
}
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader.Name == "CameraPosition")
{
reader.ReadStartElement();
Position = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
if (reader.Name == "CameraTranslation")
{
reader.ReadStartElement();
Translation = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
if (reader.Name == "CameraDirection")
{
reader.ReadStartElement();
Direction = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
if (reader.Name == "CameraUp")
{
reader.ReadStartElement();
Up = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
if (reader.Name == "CameraTarget")
{
reader.ReadStartElement();
Target = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
if (reader.Name == "CameraRight")
{
reader.ReadStartElement();
Right = new Vector3(reader.ReadElementContentAsFloat("X", ""),
reader.ReadElementContentAsFloat("Y", ""),
reader.ReadElementContentAsFloat("Z", ""));
reader.ReadEndElement();
}
FOV = reader.ReadElementContentAsFloat("FOV", "");
Ratio = reader.ReadElementContentAsFloat("Ratio", "");
Near = reader.ReadElementContentAsFloat("Near", "");
Far = reader.ReadElementContentAsFloat("Far", "");
CreateLookAt();
CreateProjection();
base.ReadXml(reader);
}
public void Deserialize(XmlReader reader)
{
m_name = reader.GetAttribute("name");
int version = Convert.ToInt32(reader.GetAttribute("version"), CultureInfo.InvariantCulture);
reader.ReadStartElement(); //ParticleEffect
m_particleID = reader.ReadElementContentAsInt();
m_length = reader.ReadElementContentAsFloat();
if (reader.Name == "LowRes")
{
bool lowres = reader.ReadElementContentAsBoolean();
}
if (reader.Name == "Scale")
{
float globalScale = reader.ReadElementContentAsFloat();
}
bool isEmpty = reader.IsEmptyElement;
reader.ReadStartElement(); //Generations
while (reader.NodeType != XmlNodeType.EndElement)
{
if (isEmpty)
break;
if (reader.Name == "ParticleGeneration")
{
MyParticleGeneration generation;
MyParticlesManager.GenerationsPool.AllocateOrCreate(out generation);
generation.Start(this);
generation.Init();
generation.Deserialize(reader);
AddGeneration(generation);
}
else if (reader.Name == "ParticleGPUGeneration")
{
MyParticleGPUGeneration generation;
MyParticlesManager.GPUGenerationsPool.AllocateOrCreate(out generation);
generation.Start(this);
generation.Init();
generation.Deserialize(reader);
AddGeneration(generation);
}
else
reader.Read();
}
if (!isEmpty)
reader.ReadEndElement(); //Generations
if (reader.NodeType != XmlNodeType.EndElement)
{
isEmpty = reader.IsEmptyElement;
if (isEmpty)
{
reader.Read();
}
else
{
reader.ReadStartElement(); //Particle lights
while (reader.NodeType != XmlNodeType.EndElement)
{
MyParticleLight particleLight;
MyParticlesManager.LightsPool.AllocateOrCreate(out particleLight);
particleLight.Start(this);
particleLight.Init();
particleLight.Deserialize(reader);
AddParticleLight(particleLight);
}
reader.ReadEndElement(); //Particle lights
}
}
if (reader.NodeType != XmlNodeType.EndElement)
{
isEmpty = reader.IsEmptyElement;
if (isEmpty)
{
reader.Read();
}
else
{
reader.ReadStartElement(); //Particle sounds
while (reader.NodeType != XmlNodeType.EndElement)
{
MyParticleSound particleSound;
MyParticlesManager.SoundsPool.AllocateOrCreate(out particleSound);
particleSound.Start(this);
particleSound.Init();
particleSound.Deserialize(reader);
AddParticleSound(particleSound);
}
reader.ReadEndElement(); //Particle sounds
}
}
reader.ReadEndElement(); //ParticleEffect
}
/// <summary>
/// Deserializes all of the gameplay helper's simple members from an XML reader.
/// </summary>
/// <param name="writer">The reader to use for deserialization.</param>
private void DeserializeGameplayMembers(XmlReader reader)
{
gameOver = reader.ReadElementContentAsBoolean("GameOver", SerializationNamespace);
baseLevelKillCount = reader.ReadElementContentAsInt("BaseLevelKillCount", SerializationNamespace);
levelKillCount = reader.ReadElementContentAsInt("LevelKillCount", SerializationNamespace);
alienSpawnTimer = reader.ReadElementContentAsFloat("AlienSpawnTimer", SerializationNamespace);
alienSpawnRate = reader.ReadElementContentAsFloat("AlienSpawnRate", SerializationNamespace);
alienMaxAccuracy = reader.ReadElementContentAsFloat("AlienMaxAccuracy", SerializationNamespace);
alienSpeedMin = reader.ReadElementContentAsFloat("AlienSpeedMin", SerializationNamespace);
alienSpeedMax = reader.ReadElementContentAsFloat("AlienSpeedMax", SerializationNamespace);
alienScore = reader.ReadElementContentAsInt("AlienScore", SerializationNamespace);
nextLife = reader.ReadElementContentAsInt("NextLife", SerializationNamespace);
hitStreak = reader.ReadElementContentAsInt("HitStreak", SerializationNamespace);
highScore = reader.ReadElementContentAsInt("HighScore", SerializationNamespace);
transitionFactor = reader.ReadElementContentAsFloat("TransitionFactor", SerializationNamespace);
transitionRate = reader.ReadElementContentAsFloat("TransitionRate", SerializationNamespace);
cloud1Position = DeserializeVector(reader);
cloud2Position = DeserializeVector(reader);
sunPosition = DeserializeVector(reader);
}
