protected override void RemoveItem(int index)
{
IAether item = this[index];
_visibleParticles.Remove((IPhotonNode)item);
base.RemoveItem(index);
}
public void ReadParticle(string name, out IAether particle)
{
particle = null;
//reader.ReadStartElement(name);
//UniqueID uid;
//ReadParticle(out uid, out particle);
//reader.ReadEndElement();
reader.ReadToFollowing(name);
if (reader.IsEmptyElement)
{
reader.Read(); return;
}
reader.ReadStartElement(name);
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.Read();
if (reader.NodeType == XmlNodeType.Element)
{
UniqueID uid;
ReadParticle(out uid, out particle);
if (particle == null)
{
throw new Exception("Cant read particle.");
}
break;
}
}
reader.ReadEndElement();
}
private void WriteParticle(UniqueID uid, IAether particle)
{
string particleName = Engine.GetParticleName(particle);
uid.Save(this);
bool isParticleSerialized = serialisedParticles.Contains(uid);
writer.Write(isParticleSerialized);
if (!isParticleSerialized)
{
if (!uid.Equals(UniqueID.Unknown))
{
serialisedParticles.Add(uid);
}
writer.Write(particleName); //name
Type particleType = particle.GetType();
string typeName = particleType.FullName + ", " + particleType.Assembly.GetName().Name;
writer.Write(typeName); //type
IAetherSerialization serialisableParticle = particle as IAetherSerialization;
bool isSerialisableParticle = serialisableParticle != null;
writer.Write(isSerialisableParticle); //mark whether Particle has data to serialize
if (isSerialisableParticle)
{
serialisableParticle.Save(this);
}
}
return;
}
public static Matrix GetWorldTransform(IAether particle)
{
Matrix result;
GetWorldTransform(particle, out result);
return(result);
}
public static void GetWorldTransform(IAether particle, out Matrix world)
{
var worldTransform = particle as IWorldTransform;
if (worldTransform != null)
{
world = worldTransform.WorldTransform;
return;
}
var localTransform = particle as ILocalTransform;
if (localTransform != null)
{
world = localTransform.LocalTransform;
return;
}
var position = particle as IPosition;
if (position != null)
{
world = Matrix.CreateTranslation(position.Position);
return;
}
world = Matrix.Identity;
}
public static T GetComponent <T>(this IAether element) where T : class
{
T result = null;
try { return((T)element); }
catch (InvalidCastException ice) { }
return(result);
}
public void RegisterParticle(UniqueID uid, IAether particle)
{
TValue value = particle as TValue;
if (value == null)
{
return;
}
this.Add(uid, (TValue)particle);
OnRegisterParticle(uid, particle);
}
public void UnregisterParticle(UniqueID uid)
{
if (!this.ContainsKey(uid))
{
return;
}
IAether particle = this[uid];
OnUnregisterParticle(uid, particle);
this.Remove(uid);
}
public void WriteParticles <T>(string name, IDictionary <UniqueID, T> particles) where T : IAether
{
//writer.Write(name);
writer.Write((Int32)particles.Count);
foreach (KeyValuePair <UniqueID, T> pair in particles)
{
IAether particle = pair.Value;
UniqueID uid = pair.Key;
WriteParticle(uid, particle);
}
}
public bool RemoveParticleName(IAether particle)
{
foreach (KeyValuePair <string, IAether> nameParticlePair in _names)
{
if (nameParticlePair.Value == particle)
{
return(_names.Remove(nameParticlePair.Key));
}
}
return(false);
}
public void UnregisterParticle(IAether particle)
{
UniqueID uid = FindUniqueId(particle);
//notify managers
foreach (IAetherManager particleManager in Managers)
{
particleManager.UnregisterParticle(uid);
}
this.Remove(uid);
}
public void WriteParticles <T>(string name, IDictionary <UniqueID, T> particles) where T : IAether
{
writer.WriteStartElement(name);
foreach (KeyValuePair <UniqueID, T> pair in particles)
{
IAether particle = pair.Value;
UniqueID uid = pair.Key;
WriteParticle(uid, particle);
}
writer.WriteEndElement();
}
public string GetParticleName(IAether particle)
{
foreach (KeyValuePair <string, IAether> nameParticlePair in _names)
{
if (nameParticlePair.Value == particle)
{
return(nameParticlePair.Key);
}
}
return(string.Empty);
}
public void WriteParticle(string name, IAether particle)
{
writer.WriteStartElement(name);
{
UniqueID uid = Engine.GetParticleUID(particle);
if (uid != UniqueID.Unknown)
{
WriteParticle(uid, particle);
}
}
writer.WriteEndElement();
}
public void WriteParticle(string name, IAether particle)
{
//writer.Write(name);
UniqueID uid = Engine.GetParticleUID(particle);
bool isParticleUnknown = uid == UniqueID.Unknown;
writer.Write(isParticleUnknown);
if (!isParticleUnknown)
{
WriteParticle(uid, particle);
}
}
public IAether CreateInstance(string type)
{
Type particleType;
particleType = Type.GetType(type, false);
if (particleType == null)
{
throw new ArgumentException(String.Format("Can't find type '{0}'", type), "typeName");
}
IAether particle = (IAether)Activator.CreateInstance(particleType);
return(particle);
}
public void ReadParticle(string name, out IAether particle)
{
//string name2 = reader.ReadString();
//System.Diagnostics.Debug.Assert(name == name2);
bool isParticleUnknown = reader.ReadBoolean();
UniqueID uniqueID;
if (isParticleUnknown)
{
particle = null;
}
else
{
ReadParticle(out uniqueID, out particle);
}
}
private UniqueID FindUniqueId(IAether particle)
{
if (!this.Values.Contains(particle))
{
return(UniqueID.Unknown);
}
foreach (UniqueID uid in this.Keys)
{
if (this[uid] == particle)
{
return(uid);
}
}
return(UniqueID.Unknown);
}
private void ReadParticle(out UniqueID uid, out IAether particle)
{
uid = new UniqueID();
uid.Load(this);
bool isParticleSerialized = reader.ReadBoolean();
if (isParticleSerialized)
{
particle = deserialisedParticles[uid];
return;
}
string particleName = reader.ReadString();
string AssemblyQualifiedName = reader.ReadString();
if (Engine.ContainsName(particleName))
{
particle = Engine[particleName];
}
else
{
particle = TypeResolver.CreateInstance(AssemblyQualifiedName);
}
if (!uid.Equals(UniqueID.Unknown))
{
deserialisedParticles.Add(uid, particle);
}
bool isSerialisableParticle = reader.ReadBoolean();
if (isSerialisableParticle)
{
IAetherSerialization serialisableParticle = particle as IAetherSerialization;
serialisableParticle.Load(this);
}
if (particleName != string.Empty)
{
Engine.SetParticleName(particle, particleName);
}
return;
}
private void WriteParticle(UniqueID uid, IAether particle)
{
string particleName = Engine.GetParticleName(particle);
if (serialisedParticles.Contains(uid))
{
writer.WriteStartElement("AetherParticleRef");
writer.WriteStartAttribute("UID"); uid.Save(this); writer.WriteEndAttribute();
if (particleName != String.Empty)
{
writer.WriteAttributeString("Name", particleName);
}
writer.WriteEndElement();
return;
}
else
{
Type particleType = particle.GetType();
if (!uid.Equals(UniqueID.Unknown))
{
serialisedParticles.Add(uid);
}
writer.WriteStartElement("AetherParticle");
writer.WriteStartAttribute("UID"); uid.Save(this); writer.WriteEndAttribute();
if (particleName != String.Empty)
{
writer.WriteAttributeString("Name", particleName);
}
string typeName = particleType.FullName + ", " + particleType.Assembly.GetName().Name;
writer.WriteAttributeString("Type", typeName);
IAetherSerialization serialisableParticle = particle as IAetherSerialization;
if (serialisableParticle != null)
{
serialisableParticle.Save(this);
}
writer.WriteEndElement();
}
return;
}
private void Render(GameTime gameTime, IAether particle)
{
Matrix worldTransform;
LeptonsManager.GetWorldTransform(particle, out worldTransform);
IPhoton photon = particle as IPhoton;
IMaterial material = (photon != null) ? photon.Material : null;
if (photon != null && material != null)
{
((IShaderMatrices)material).World = worldTransform;
((IShaderMatrices)material).View = this.View;
((IShaderMatrices)material).Projection = this.Projection;
material.Apply();
material.ApplyTextures(photon.Textures);
photon.Accept(material);
return;
}
return;
}
public UniqueID RegisterParticle(IAether particle)
{
// check if particle is allready registered
UniqueID uid = FindUniqueId(particle);
if (!uid.Equals(UniqueID.Unknown))
{
return(uid);
}
//create new uid and add particle
uid = EngineData.NextUniqueID.GetNext();
EngineData.NextUniqueID = uid;
this.Add(uid, particle);
//notify managers
foreach (IAetherManager particleManager in Managers)
{
particleManager.RegisterParticle(uid, particle);
}
return(uid);
}
protected override void OnUnregisterParticle(UniqueID uid, IAether particle)
{
System.Diagnostics.Debug.Assert(particle is ICameraNode);
ICameraNode item = particle as ICameraNode;
}
protected virtual void OnUnregisterParticle(UniqueID uid, IAether particle)
{
}
public IAether Convert(IAether particle)
{
return(particle);
}
public void Add(UniqueID key, IAether value)
{
particles.Add(key, value);
}
public bool TryGetValue(UniqueID key, out IAether value)
{
bool result = particles.TryGetValue(key, out value);
return(result);
}
private void ReadParticle(out UniqueID uid, out IAether particle)
{
uid = new UniqueID();
particle = null;
string elementName = reader.Name;
//read attribute
string particleName = string.Empty;
string typeName = string.Empty;
while (reader.MoveToNextAttribute())
{
switch (reader.Name)
{
case "UID": uid.Load(this);
break;
case "Name": particleName = reader.ReadContentAsString();
break;
case "Type": typeName = reader.ReadContentAsString();
break;
}
}
reader.MoveToElement();
bool isEmptyElement = reader.IsEmptyElement;
reader.ReadStartElement();
if (elementName == "AetherParticleRef")
{
particle = deserialisedParticles[uid];
}
else if (elementName == "AetherParticle")
{
if (Engine.ContainsName(particleName))
{
//TOD: is this even possible?
//isn't it a bug to deserialize an object using a name for cache key?
//System.Diagnostics.Debug.Assert(false);
particle = Engine[particleName];
}
else
{
particle = TypeResolver.CreateInstance(typeName);
}
if (!uid.Equals(UniqueID.Unknown))
{
deserialisedParticles.Add(uid, particle);
}
//particle = (IAetherParticle)FormatterServices.GetUninitializedObject(particleType); //this behaves the same the build in Serialisation. Not available on WP7
IAetherSerialization serialisableParticle = particle as IAetherSerialization;
if (serialisableParticle != null)
{
serialisableParticle.Load(this);
}
particle = TypeResolver.Convert(particle);
deserialisedParticles[uid] = particle; // update converted particle
if (particleName != string.Empty)
{
Engine.SetParticleName(particle, particleName);
}
if (!isEmptyElement)
{
reader.ReadEndElement();
}
}
return;
}
protected override void OnUnregisterParticle(UniqueID uid, IAether particle)
{
System.Diagnostics.Debug.Assert(particle is IChronon);
Root.Remove((IChronon)particle);
}
protected override void OnUnregisterParticle(UniqueID uid, IAether particle)
{
System.Diagnostics.Debug.Assert(particle is ILeptonNode);
//_engine.RemoveChild(Root, (ILeptonNode)particle);
}
