/// <summary>Creates a new ES3Settings object with the given path.</summary>
/// <param name="path">The path associated with this ES3Settings object.</param>
/// <param name="enums">Accepts an ES3.EncryptionType, ES3.CompressionType, ES3.Location, ES3.Directory or ES3.ReferenceMode.</param>
public ES3Settings(params System.Enum[] enums) : this(true)
{
foreach (var setting in enums)
{
if (setting is ES3.EncryptionType)
{
this.encryptionType = (ES3.EncryptionType)setting;
}
else if (setting is ES3.Location)
{
this.location = (ES3.Location)setting;
}
else if (setting is ES3.CompressionType)
{
this.compressionType = (ES3.CompressionType)setting;
}
else if (setting is ES3.ReferenceMode)
{
this.referenceMode = (ES3.ReferenceMode)setting;
}
else if (setting is ES3.Format)
{
this.format = (ES3.Format)setting;
}
else if (setting is ES3.Directory)
{
this.directory = (ES3.Directory)setting;
}
}
}
public override void Write(object obj, ES3Writer writer, ES3.ReferenceMode unityObjectType)
{
var array = (System.Array)obj;
if (elementType == null)
{
throw new ArgumentNullException("ES3Type argument cannot be null.");
}
//writer.StartWriteCollection();
for (int i = 0; i < array.GetLength(0); i++)
{
writer.StartWriteCollectionItem(i);
writer.StartWriteCollection();
for (int j = 0; j < array.GetLength(1); j++)
{
writer.StartWriteCollectionItem(j);
writer.Write(array.GetValue(i, j), elementType, unityObjectType);
writer.EndWriteCollectionItem(j);
}
writer.EndWriteCollection();
writer.EndWriteCollectionItem(i);
}
//writer.EndWriteCollection();
}
public virtual void WriteObject(object obj, ES3Writer writer, ES3.ReferenceMode mode)
{
if (WriteUsingDerivedType(obj, writer, mode))
{
return;
}
var instance = obj as UnityEngine.Object;
if (obj != null && instance == null)
{
throw new ArgumentException("Only types of UnityEngine.Object can be written with this method, but argument given is type of " + obj.GetType());
}
// If this object is in the instance manager, store it's instance ID with it.
var refMgr = ES3ReferenceMgrBase.Current;
if (mode != ES3.ReferenceMode.ByValue)
{
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");
}
writer.WriteRef(instance);
if (mode == ES3.ReferenceMode.ByRef)
{
return;
}
}
WriteUnityObject(instance, writer);
}
public override void Write(object obj, ES3Writer writer, ES3.ReferenceMode memberReferenceMode)
{
if (obj == null)
{
writer.WriteNull(); return;
}
;
var list = (IList)obj;
if (elementType == null)
{
throw new ArgumentNullException("ES3Type argument cannot be null.");
}
writer.StartWriteCollection(list.Count);
int i = 0;
foreach (object item in list)
{
writer.StartWriteCollectionItem(i);
writer.Write(item, elementType, memberReferenceMode);
writer.EndWriteCollectionItem(i);
i++;
}
writer.EndWriteCollection();
}
public virtual void WriteObject(object obj, ES3Writer writer, ES3.ReferenceMode mode)
{
if (WriteUsingDerivedType(obj, writer))
{
return;
}
var instance = obj as UnityEngine.Object;
if (obj != null && instance == null)
{
throw new ArgumentException("Only types of UnityEngine.Object can be written with this method, but argument given is type of " + obj.GetType());
}
// If this object is in the instance manager, store it's instance ID with it.
var refMgr = ES3ReferenceMgrBase.Current;
if (refMgr != null && mode != ES3.ReferenceMode.ByValue)
{
writer.WriteRef(instance);
if (mode == ES3.ReferenceMode.ByRef)
{
return;
}
}
WriteUnityObject(instance, writer);
}
/// <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>
/// <param name="memberReferenceMode">Whether we want to write the property by reference, by value, or both.</param>
public virtual void WriteProperty(string name, object value, ES3.ReferenceMode memberReferenceMode)
{
if (SerializationDepthLimitExceeded())
{
return;
}
StartWriteProperty(name); Write(value, memberReferenceMode); EndWriteProperty(name);
}
public override void WriteObject(object obj, ES3Writer writer, ES3.ReferenceMode mode)
{
if (WriteUsingDerivedType(obj, writer))
{
return;
}
var instance = (UnityEngine.GameObject)obj;
if (ES3ReferenceMgrBase.Current != null && mode != ES3.ReferenceMode.ByValue)
{
var es3Prefab = instance.GetComponent <ES3Prefab>();
if (es3Prefab != null)
{
writer.WriteProperty(prefabPropertyName, es3Prefab, ES3Type_ES3PrefabInternal.Instance);
}
else
{
writer.WriteRef(instance);
// Write the ID of this Transform so we can assign it's ID when we load.
writer.WriteProperty(transformPropertyName, ES3ReferenceMgrBase.Current.Add(instance.transform));
}
if (mode == ES3.ReferenceMode.ByRef)
{
return;
}
}
var es3AutoSave = instance.GetComponent <ES3AutoSave>();
//if(es3AutoSave == null || es3AutoSave.saveLayer)
writer.WriteProperty("layer", instance.layer, ES3Type_int.Instance);
//if(es3AutoSave == null || es3AutoSave.saveTag)
writer.WriteProperty("tag", instance.tag, ES3Type_string.Instance);
//if(es3AutoSave == null || es3AutoSave.saveName)
writer.WriteProperty("name", instance.name, ES3Type_string.Instance);
//if(es3AutoSave == null || es3AutoSave.saveHideFlags)
writer.WriteProperty("hideFlags", instance.hideFlags);
if (es3AutoSave == null || es3AutoSave.saveChildren)
{
writer.WriteProperty("children", GetChildren(instance));
}
var components = new List <Component>();
foreach (var component in instance.GetComponents <Component>())
{
var componentType = component.GetType();
// Only save explicitly-supported Components, /*or those explicitly marked as Serializable*/.
if (ES3TypeMgr.GetES3Type(componentType) != null /*|| ES3Reflection.AttributeIsDefined(componentType, ES3Reflection.serializableAttributeType)*/)
{
components.Add(component);
}
}
writer.WriteProperty("components", components);
}
public virtual void Write(object value, ES3Type type, ES3.ReferenceMode memberReferenceMode = ES3.ReferenceMode.ByRef)
{
// 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);
}
}
public virtual void Write(object value, ES3.ReferenceMode memberReferenceMode = ES3.ReferenceMode.ByRef)
{
if (value == null)
{
WriteNull(); return;
}
var type = ES3TypeMgr.GetOrCreateES3Type(value.GetType());
Write(value, type, memberReferenceMode);
}
public override void Write(object obj, ES3Writer writer, ES3.ReferenceMode memberReferenceMode)
{
var array = (System.Array)obj;
if (elementType == null)
{
throw new ArgumentNullException("ES3Type argument cannot be null.");
}
writer.StartWriteCollection(array.Length);
for (int i = 0; i < array.Length; i++)
{
writer.StartWriteCollectionItem(i);
writer.Write(array.GetValue(i), elementType, memberReferenceMode);
writer.EndWriteCollectionItem(i);
}
writer.EndWriteCollection();
}
public void Write(object obj, ES3Writer writer, ES3.ReferenceMode memberReferenceMode)
{
var dict = (IDictionary)obj;
//writer.StartWriteDictionary(dict.Count);
int i = 0;
foreach (System.Collections.DictionaryEntry kvp in dict)
{
writer.StartWriteDictionaryKey(i);
writer.Write(kvp.Key, keyType, memberReferenceMode);
writer.EndWriteDictionaryKey(i);
writer.StartWriteDictionaryValue(i);
writer.Write(kvp.Value, valueType, memberReferenceMode);
writer.EndWriteDictionaryValue(i);
i++;
}
//writer.EndWriteDictionary();
}
public virtual void Write(object value, ES3Type type, ES3.ReferenceMode memberReferenceMode = ES3.ReferenceMode.ByRef)
{
if (value == null)
{
WriteNull(); return;
}
;
if (type == null)
{
throw new ArgumentNullException("ES3Type argument cannot be null.");
}
if (type.isPrimitive)
{
type.Write(value, this);
}
else if (type.isCollection)
{
((ES3CollectionType)type).Write(value, this, memberReferenceMode);
}
else if (type.isDictionary)
{
((ES3DictionaryType)type).Write(value, this, memberReferenceMode);
}
else
{
StartWriteObject(null);
if (type.isUnityObject)
{
((ES3UnityObjectType)type).WriteObject(value, this, memberReferenceMode);
}
else
{
type.Write(value, this);
}
EndWriteObject(null);
}
}
protected bool WriteUsingDerivedType(object obj, ES3Writer writer, ES3.ReferenceMode mode)
{
var objType = obj.GetType();
if (objType != this.type)
{
writer.WriteType(objType);
var es3Type = ES3TypeMgr.GetOrCreateES3Type(objType);
if (es3Type is ES3UnityObjectType)
{
((ES3UnityObjectType)es3Type).WriteObject(obj, writer, mode);
}
else
{
es3Type.Write(obj, writer);
}
return(true);
}
return(false);
}
/// <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>
/// <param name="memberReferenceMode">Whether we want to write the property by reference, by value, or both.</param>
public override void WriteProperty(string name, object value, ES3.ReferenceMode memberReferenceMode)
{
if (SerializationDepthLimitExceeded())
{
return;
}
StartWriteProperty(name);
using (var ms = new MemoryStream())
{
using (var writer = ES3Writer.Create(ms, new ES3Settings(ES3.EncryptionType.None, ES3.CompressionType.None, ES3.Format.Binary_Alpha), false, false))
{
writer.Write(value, memberReferenceMode);
}
var bytes = ms.ToArray();
Write7BitEncodedInt(bytes.Length);
baseWriter.Write(bytes);
}
EndWriteProperty(name);
}
public virtual void Write(object value, ES3Type type, ES3.ReferenceMode memberReferenceMode = ES3.ReferenceMode.ByRef)
{
// Note that we have to check UnityEngine.Object types for null by casting it first, otherwise
// it will always return false.
if (value == null || (ES3Reflection.IsAssignableFrom(typeof(UnityEngine.Object), value.GetType()) && value as UnityEngine.Object == null))
{
WriteNull();
return;
}
// Deal with System.Objects
if (type == null || type.type == typeof(object))
{
var valueType = value.GetType();
type = ES3TypeMgr.GetOrCreateES3Type(valueType);
if (type == null)
{
throw new NotSupportedException("Types of " + valueType + " are not supported. Please see the Supported Types guide for more information: https://docs.moodkie.com/easy-save-3/es3-supported-types/");
}
if (!type.isCollection && !type.isDictionary)
{
StartWriteObject(null);
WriteType(valueType);
type.Write(value, this);
EndWriteObject(null);
return;
}
}
if (type == null)
{
throw new ArgumentNullException("ES3Type argument cannot be null.");
}
if (type.isUnsupported)
{
if (type.isCollection || type.isDictionary)
{
throw new NotSupportedException(type.type + " is not supported because it's element type is not supported. Please see the Supported Types guide for more information: https://docs.moodkie.com/easy-save-3/es3-supported-types/");
}
else
{
throw new NotSupportedException("Types of " + type.type + " are not supported. Please see the Supported Types guide for more information: https://docs.moodkie.com/easy-save-3/es3-supported-types/");
}
}
if (type.isPrimitive || type.isEnum)
{
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);
}
}
public override void WriteObject(object obj, ES3Writer writer, ES3.ReferenceMode mode)
{
if (WriteUsingDerivedType(obj, writer))
{
return;
}
var instance = (UnityEngine.GameObject)obj;
if (mode != ES3.ReferenceMode.ByValue)
{
writer.WriteRef(instance);
var es3Prefab = instance.GetComponent <ES3Prefab>();
if (es3Prefab != null)
{
writer.WriteProperty(prefabPropertyName, es3Prefab, ES3Type_ES3PrefabInternal.Instance);
}
// Write the ID of this Transform so we can assign it's ID when we load.
writer.WriteProperty(transformPropertyName, ES3ReferenceMgrBase.Current.Add(instance.transform));
if (mode == ES3.ReferenceMode.ByRef)
{
return;
}
}
var es3AutoSave = instance.GetComponent <ES3AutoSave>();
writer.WriteProperty("layer", instance.layer, ES3Type_int.Instance);
writer.WriteProperty("tag", instance.tag, ES3Type_string.Instance);
writer.WriteProperty("name", instance.name, ES3Type_string.Instance);
writer.WriteProperty("hideFlags", instance.hideFlags);
writer.WriteProperty("active", instance.activeSelf);
if (saveChildren || (es3AutoSave != null && es3AutoSave.saveChildren))
{
writer.WriteProperty("children", GetChildren(instance), ES3.ReferenceMode.ByRefAndValue);
}
List <Component> components;
// If there's an ES3AutoSave attached and Components are marked to be saved, save these.
var autoSave = instance.GetComponent <ES3AutoSave>();
if (autoSave != null && autoSave.componentsToSave != null && autoSave.componentsToSave.Count > 0)
{
components = autoSave.componentsToSave;
}
// Otherwise, only save explicitly-supported Components, /*or those explicitly marked as Serializable*/.
else
{
components = new List <Component>();
foreach (var component in instance.GetComponents <Component>())
{
if (component != null && ES3TypeMgr.GetES3Type(component.GetType()) != null)
{
components.Add(component);
}
}
}
writer.WriteProperty("components", components, ES3.ReferenceMode.ByRefAndValue);
}
public virtual void WriteProperty(string name, object value, ES3Type type, ES3.ReferenceMode memberReferenceMode)
{
StartWriteProperty(name); Write(value, type, memberReferenceMode);
}
public abstract void Write(object obj, ES3Writer writer, ES3.ReferenceMode memberReferenceMode);
