public override object Read <T>(ES3Reader reader)
{
UnityEngine.Object obj = null;
// Read the intial properties regarding the instance we're loading.
while (true)
{
var propertyName = ReadPropertyName(reader);
if (propertyName == ES3Type.typeFieldName)
{
return(ES3TypeMgr.GetOrCreateES3Type(reader.ReadType()).Read <T>(reader));
}
else if (propertyName == ES3ReferenceMgrBase.referencePropertyName)
{
var refMgr = ES3ReferenceMgrBase.Current;
if (refMgr == null)
{
reader.Skip();
continue;
}
long id = reader.Read <long>(ES3Type_long.Instance);
obj = refMgr.Get(id);
if (obj == null)
{
// If an instance isn't already registered for this object, create an instance and register the reference.
obj = new GameObject();
refMgr.Add(obj, id);
}
else if (!ES3Reflection.IsAssignableFrom(typeof(T), obj.GetType()))
{
throw new MissingReferenceException("The instance with ID \"" + id + "\" is a different type than expected. Expected \"" + typeof(T) + "\", found \"" + obj.GetType() + "\"");
}
// Now load the Transform's ID and assign it to the Transform of our object.
long transformID = reader.ReadProperty <long>(ES3Type_long.Instance);
refMgr.Add(((GameObject)obj).transform, transformID);
}
else if (propertyName == prefabPropertyName)
{
if (ES3ReferenceMgrBase.Current == null)
{
reader.Skip();
}
else
{
obj = reader.Read <GameObject>(ES3Type_ES3PrefabInternal.Instance);
}
}
else if (propertyName == null)
{
return(obj);
}
else
{
reader.overridePropertiesName = propertyName;
break;
}
}
if (obj == null)
{
obj = new GameObject();
}
ReadInto <T>(reader, obj);
return(obj);
}
/// <summary>Reads a value of type T from the reader.</summary>
public virtual T Read <T>()
{
return(Read <T>(ES3TypeMgr.GetOrCreateES3Type(typeof(T))));
}
private void ReadComponents(ES3Reader reader, GameObject go)
{
if (reader.StartReadCollection())
{
return;
}
var components = new List <Component>(go.GetComponents <Component>());
// Read each Component in Components array
while (true)
{
if (!reader.StartReadCollectionItem())
{
break;
}
if (reader.StartReadObject())
{
return;
}
Type type = null;
string propertyName;
while (true)
{
propertyName = ReadPropertyName(reader);
if (propertyName == ES3Type.typeFieldName)
{
type = reader.ReadType();
}
else if (propertyName == ES3ReferenceMgrBase.referencePropertyName)
{
if (type == null)
{
throw new InvalidOperationException("Cannot load Component because no type data has been stored with it, so it's not possible to determine it's type");
}
reader.Read_ref(); // We don't load Components by reference when loading GameObjects, so read the ref and ignore it.
// Rather than loading by reference, load using the Components list.
var c = components.Find(x => x.GetType() == type);
// If the Component exists in the Component list, load into it and remove it from the list.
if (c != null)
{
ES3TypeMgr.GetOrCreateES3Type(type).ReadInto <Component>(reader, c);
components.Remove(c);
}
// Else, create a new Component.
else
{
ES3TypeMgr.GetOrCreateES3Type(type).Read <Component>(reader);
}
break;
}
else if (propertyName == null)
{
break;
}
else
{
reader.overridePropertiesName = propertyName;
ReadObject <Component>(reader);
break;
}
}
reader.EndReadObject();
if (reader.EndReadCollectionItem())
{
break;
}
}
reader.EndReadCollection();
}
protected override object ReadObject <T>(ES3Reader reader)
{
UnityEngine.Object obj = null;
var refMgr = ES3ReferenceMgrBase.Current;
long id = 0;
// Read the intial properties regarding the instance we're loading.
while (true)
{
if (refMgr == null)
{
throw new InvalidOperationException("An Easy Save 3 Manager is required to load references. To add one to your scene, exit playmode and go to Assets > Easy Save 3 > Add Manager to Scene");
}
var propertyName = ReadPropertyName(reader);
if (propertyName == ES3Type.typeFieldName)
{
return(ES3TypeMgr.GetOrCreateES3Type(reader.ReadType()).Read <T>(reader));
}
else if (propertyName == ES3ReferenceMgrBase.referencePropertyName)
{
id = reader.Read_ref();
obj = refMgr.Get(id, true);
}
else if (propertyName == transformPropertyName)
{
// Now load the Transform's ID and assign it to the Transform of our object.
long transformID = reader.Read_ref();
if (obj == null)
{
obj = CreateNewGameObject(refMgr, id);
}
refMgr.Add(((GameObject)obj).transform, transformID);
}
else if (propertyName == prefabPropertyName)
{
if (obj != null || ES3ReferenceMgrBase.Current == null)
{
reader.ReadRefProperty(); // Skip the ref as we don't need it.
reader.ReadInto <GameObject>(obj); // ReadInto to apply the prefab references.
}
else
{
obj = reader.Read <GameObject>(ES3Type_ES3PrefabInternal.Instance);
ES3ReferenceMgrBase.Current.Add(obj, id);
}
}
else if (propertyName == null)
{
if (obj == null)
{
return(CreateNewGameObject(refMgr, id));
}
return(obj);
}
else
{
reader.overridePropertiesName = propertyName;
break;
}
}
if (obj == null)
{
obj = CreateNewGameObject(refMgr, id);
}
ReadInto <T>(reader, obj);
return(obj);
}
protected void ReadUsingDerivedType <T>(ES3Reader reader, object obj)
{
ES3TypeMgr.GetOrCreateES3Type(reader.ReadType()).ReadInto <T>(reader, obj);
}
protected void WriteProperties(object obj, ES3Writer writer)
{
if (members == null)
{
GetMembers(writer.settings.safeReflection);
}
for (int i = 0; i < members.Length; i++)
{
var property = members[i];
writer.WriteProperty(property.name, property.reflectedMember.GetValue(obj), ES3TypeMgr.GetOrCreateES3Type(property.type), writer.settings.memberReferenceMode);
}
}
/// <summary>Reads a value of type T from the reader into an existing object.</summary>
/// <param name="obj">The object we want to read our value into.</param>
public virtual void ReadInto <T>(object obj)
{
ReadInto <T>(obj, ES3TypeMgr.GetOrCreateES3Type(typeof(T)));
}
public T ReadProperty <T>()
{
return(ReadProperty <T>(ES3TypeMgr.GetOrCreateES3Type(typeof(T))));
}
/// <summary>Writes a field or property to the writer. Note that this should only be called within an ES3Type.</summary>
/// <param name="name">The name of the field or property.</param>
/// <param name="value">The value we want to write.</param>
public virtual void WriteProperty <T>(string name, object value)
{
StartWriteProperty(name); Write(value, ES3TypeMgr.GetOrCreateES3Type(typeof(T)), settings.memberReferenceMode);
}
protected object ReadProperties(ES3Reader reader, object obj)
{
// Iterate through each property in the file and try to load it using the appropriate
// ES3Member in the members array.
foreach (string propertyName in reader.Properties)
{
// Find the property.
ES3Member property = null;
for (int i = 0; i < members.Length; i++)
{
if (members[i].name == propertyName)
{
property = members[i];
break;
}
}
// If this is a class which derives directly from Dictionary, we need to load it's dictionary first.
if (propertyName == "_Values")
{
var baseType = ES3TypeMgr.GetOrCreateES3Type(ES3Reflection.BaseType(obj.GetType()));
if (baseType.isDictionary)
{
var dict = (IDictionary)obj;
var loaded = (IDictionary)baseType.Read <IDictionary>(reader);
foreach (DictionaryEntry kvp in loaded)
{
dict[kvp.Key] = kvp.Value;
}
}
else if (baseType.isCollection)
{
var loaded = (IEnumerable)baseType.Read <ICollection>(reader);
var type = baseType.GetType();
if (type == typeof(ES3ListType))
{
foreach (var item in loaded)
{
((IList)obj).Add(item);
}
}
else if (type == typeof(ES3QueueType))
{
var method = baseType.type.GetMethod("Enqueue");
foreach (var item in loaded)
{
method.Invoke(obj, new object[] { item });
}
}
else if (type == typeof(ES3StackType))
{
var method = baseType.type.GetMethod("Push");
foreach (var item in loaded)
{
method.Invoke(obj, new object[] { item });
}
}
else if (type == typeof(ES3HashSetType))
{
var method = baseType.type.GetMethod("Add");
foreach (var item in loaded)
{
method.Invoke(obj, new object[] { item });
}
}
}
}
if (property == null)
{
reader.Skip();
}
else
{
var type = ES3TypeMgr.GetOrCreateES3Type(property.type);
if (ES3Reflection.IsAssignableFrom(typeof(ES3DictionaryType), type.GetType()))
{
property.reflectedMember.SetValue(obj, ((ES3DictionaryType)type).Read(reader));
}
else if (ES3Reflection.IsAssignableFrom(typeof(ES3CollectionType), type.GetType()))
{
property.reflectedMember.SetValue(obj, ((ES3CollectionType)type).Read(reader));
}
else
{
object readObj = reader.Read <object>(type);
property.reflectedMember.SetValue(obj, readObj);
}
}
}
return(obj);
}
public override void Write(object obj, ES3Writer writer)
{
// Manage NULL values.
if (obj == null)
{
writer.WriteNull(); return;
}
;
UnityEngine.Object unityObj = obj as UnityEngine.Object;
bool isUnityEngineObject = (unityObj != null);
// If this is a derived type, write the type as a property and use it's specific ES3Type.
var objType = obj.GetType();
if (objType != this.type)
{
writer.WriteType(objType);
ES3TypeMgr.GetOrCreateES3Type(objType).Write(obj, writer);
return;
}
if (isUnityEngineObject)
{
writer.WriteRef(unityObj);
}
if (members == null)
{
GetMembers(writer.settings.safeReflection);
}
for (int i = 0; i < members.Length; i++)
{
var property = members[i];
if (ES3Reflection.IsAssignableFrom(typeof(UnityEngine.Object), property.type))
{
object valueObj = property.reflectedMember.GetValue(obj);
UnityEngine.Object value = (valueObj == null) ? null : (UnityEngine.Object)valueObj;
writer.WritePropertyByRef(property.name, value);
}
else
{
writer.WriteProperty(property.name, property.reflectedMember.GetValue(obj), ES3TypeMgr.GetOrCreateES3Type(property.type));
}
}
}
public virtual void Write(object value, ES3Type type, ES3.ReferenceMode memberReferenceMode = ES3.ReferenceMode.ByRef)
{
// Deal with System.Objects
if (type.type == typeof(object))
{
var valueType = value.GetType();
type = ES3TypeMgr.GetOrCreateES3Type(valueType);
if (!type.isCollection && !type.isDictionary)
{
StartWriteObject(null);
WriteType(valueType);
type.Write(value, this);
EndWriteObject(null);
return;
}
}
// Note that we have to check UnityEngine.Object types for null by casting it first, otherwise
// it will always return false.
if (value == null || (type.isES3TypeUnityObject && ((UnityEngine.Object)value) == null))
{
WriteNull();
return;
}
if (type == null)
{
throw new ArgumentNullException("ES3Type argument cannot be null.");
}
if (type.isUnsupported)
{
throw new NotSupportedException("Types of " + type.type + " are not supported.");
}
if (type.isPrimitive)
{
type.Write(value, this);
}
else if (type.isCollection)
{
StartWriteCollection();
((ES3CollectionType)type).Write(value, this, memberReferenceMode);
EndWriteCollection();
}
else if (type.isDictionary)
{
StartWriteDictionary();
((ES3DictionaryType)type).Write(value, this, memberReferenceMode);
EndWriteDictionary();
}
else
{
if (type.type == typeof(GameObject))
{
((ES3Type_GameObject)type).saveChildren = settings.saveChildren;
}
StartWriteObject(null);
if (type.isES3TypeUnityObject)
{
((ES3UnityObjectType)type).WriteObject(value, this, memberReferenceMode);
}
else
{
type.Write(value, this);
}
EndWriteObject(null);
}
}
protected override object ReadObject <T>(ES3Reader reader)
{
UnityEngine.Object obj = null;
var refMgr = ES3ReferenceMgrBase.Current;
long id = 0;
// Read the intial properties regarding the instance we're loading.
while (true)
{
if (refMgr == null)
{
reader.Skip();
continue;
}
var propertyName = ReadPropertyName(reader);
if (propertyName == ES3Type.typeFieldName)
{
return(ES3TypeMgr.GetOrCreateES3Type(reader.ReadType()).Read <T>(reader));
}
else if (propertyName == ES3ReferenceMgrBase.referencePropertyName)
{
if (refMgr == null)
{
reader.Skip();
continue;
}
id = reader.Read <long>(ES3Type_long.Instance);
obj = refMgr.Get(id);
}
else if (propertyName == transformPropertyName)
{
if (refMgr == null)
{
reader.Skip();
continue;
}
// Now load the Transform's ID and assign it to the Transform of our object.
long transformID = reader.Read <long>(ES3Type_long.Instance);
if (obj == null)
{
obj = CreateNewGameObject(refMgr, id);
}
refMgr.Add(((GameObject)obj).transform, transformID);
}
else if (propertyName == prefabPropertyName)
{
if (obj != null || ES3ReferenceMgrBase.Current == null)
{
reader.Skip();
}
else
{
obj = reader.Read <GameObject>(ES3Type_ES3PrefabInternal.Instance);
ES3ReferenceMgrBase.Current.Add(obj, id);
}
}
else if (propertyName == null)
{
if (obj == null)
{
return(CreateNewGameObject(refMgr, id));
}
return(obj);
}
else
{
reader.overridePropertiesName = propertyName;
break;
}
}
if (obj == null)
{
obj = CreateNewGameObject(refMgr, id);
}
ReadInto <T>(reader, obj);
return(obj);
}
