1510 lines
55 KiB
C#
1510 lines
55 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Runtime.Serialization.Formatters.Binary;
|
|
using System.Text;
|
|
using UnityEngine;
|
|
|
|
namespace NeoSaveGames.Serialization
|
|
{
|
|
public class SafeDeserializer : INeoDeserializer
|
|
{
|
|
private Stream m_Stream = null;
|
|
private Property m_LastNamedProperty = null;
|
|
private BinaryFormatter m_BinaryFormatter = new BinaryFormatter();
|
|
private Stack<Context> m_ContextStack = new Stack<Context>();
|
|
|
|
public bool isDeserializing
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
public Context currentContext
|
|
{
|
|
get { return m_ContextStack.Peek(); }
|
|
}
|
|
|
|
public class Context
|
|
{
|
|
private Dictionary<int, Property> m_Properties = new Dictionary<int, Property>();
|
|
private Dictionary<int, Context> m_SubContexts = new Dictionary<int, Context>();
|
|
|
|
public int id { get; private set; }
|
|
public SerializationContext contextType { get; private set; }
|
|
|
|
public Dictionary<int, Property> properties
|
|
{
|
|
get { return m_Properties; }
|
|
}
|
|
|
|
public Dictionary<int, Context> subContexts
|
|
{
|
|
get { return m_SubContexts; }
|
|
}
|
|
|
|
public Context(SerializationContext t, int key)
|
|
{
|
|
id = key;
|
|
contextType = t;
|
|
}
|
|
}
|
|
|
|
public class Property
|
|
{
|
|
private List<Property> m_Children = new List<Property>();
|
|
|
|
public PropertyType propertyType { get; private set; }
|
|
public PropertyFlags propertyFlags { get; private set; }
|
|
public object data { get; private set; }
|
|
|
|
public List<Property> children
|
|
{
|
|
get { return m_Children; }
|
|
}
|
|
|
|
public Property(PropertyType t, PropertyFlags f, object o)
|
|
{
|
|
propertyType = t;
|
|
propertyFlags = f;
|
|
data = o;
|
|
}
|
|
|
|
public bool isArray
|
|
{
|
|
get { return (propertyFlags & PropertyFlags.IsArray) != PropertyFlags.None; }
|
|
}
|
|
|
|
public bool isNullOrEmpty
|
|
{
|
|
get { return (propertyFlags & PropertyFlags.NullOrEmpty) != PropertyFlags.None; }
|
|
}
|
|
}
|
|
|
|
public bool ReadFromStream(Stream stream)
|
|
{
|
|
if (stream != null)
|
|
{
|
|
isDeserializing = true;
|
|
m_Stream = stream;
|
|
|
|
var rootContext = new Context(SerializationContext.Root, 0);
|
|
m_ContextStack.Push(rootContext);
|
|
|
|
// Iterate through properties
|
|
while (ReadElement()) ;
|
|
|
|
var closingContext = m_ContextStack.Peek();
|
|
if (closingContext != rootContext)
|
|
Debug.LogError("Unbalanced push/pop for serialization contexts. Deserialization did not end on the root context.");
|
|
|
|
m_Stream = null;
|
|
|
|
/*
|
|
// Get the length of the data
|
|
var totalLengthBytes = new byte[4];
|
|
stream.Read(totalLengthBytes, 0, 4);
|
|
int totalLength = BitConverter.ToInt32(totalLengthBytes, 0);
|
|
|
|
// Read data
|
|
var bytes = new byte[totalLength];
|
|
int totalRead = stream.Read(bytes, 0, totalLength);
|
|
if (totalRead != totalLength)
|
|
{
|
|
Debug.LogError(string.Format("Save data length mismatch. Could not read from stream. Expected: {0}, Read {1}", totalLength, totalRead));
|
|
return false;
|
|
}
|
|
m_Stream = new MemoryStream(bytes, false);
|
|
|
|
Debug.Log("Total bytes: " + totalLength);
|
|
*/
|
|
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public void BeginDeserialization()
|
|
{
|
|
}
|
|
|
|
bool ReadElement()
|
|
{
|
|
var pType = (PropertyType)m_BinaryFormatter.Deserialize(m_Stream);
|
|
if (pType == PropertyType.EndOfData)
|
|
return false;
|
|
|
|
switch (pType)
|
|
{
|
|
case PropertyType.PushContext:
|
|
{
|
|
// Read the relevant context data
|
|
var contextType = (SerializationContext)m_BinaryFormatter.Deserialize(m_Stream);
|
|
var key = (int)m_BinaryFormatter.Deserialize(m_Stream);
|
|
|
|
// Create the new context
|
|
var newContext = new Context(contextType, key);
|
|
|
|
// Add new context to old
|
|
var currentContext = m_ContextStack.Peek();
|
|
if (currentContext.subContexts.ContainsKey(key))
|
|
Debug.LogError("Context key collision: " + key);
|
|
else
|
|
currentContext.subContexts.Add(key, newContext);
|
|
|
|
// Push new context
|
|
m_ContextStack.Push(newContext);
|
|
}
|
|
break;
|
|
case PropertyType.PopContext:
|
|
{
|
|
var contextType = (SerializationContext)m_BinaryFormatter.Deserialize(m_Stream);
|
|
|
|
var popped = m_ContextStack.Pop();
|
|
if (popped.contextType != contextType)
|
|
Debug.LogError("Popped serialization context does not match active context. Your save game might be messed up.");
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
// Get property flags
|
|
var flags = (PropertyFlags)m_BinaryFormatter.Deserialize(m_Stream);
|
|
|
|
// Check if array
|
|
bool isUnnamed = (flags & PropertyFlags.Unnammed) != PropertyFlags.None;
|
|
|
|
// Add the property (to the context or parent depending if named)
|
|
if (isUnnamed)
|
|
{
|
|
if (m_LastNamedProperty == null)
|
|
Debug.LogError("Attempting to read child property when no parent set");
|
|
else
|
|
{
|
|
// Add as a child property of the last named property
|
|
if ((flags & PropertyFlags.NullOrEmpty) != PropertyFlags.None)
|
|
m_LastNamedProperty.children.Add(new Property(pType, flags, null));
|
|
else
|
|
m_LastNamedProperty.children.Add(new Property(pType, flags, m_BinaryFormatter.Deserialize(m_Stream)));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Get the hash
|
|
int hash = (int)m_BinaryFormatter.Deserialize(m_Stream);
|
|
|
|
// Create the property
|
|
if ((flags & PropertyFlags.NullOrEmpty) != PropertyFlags.None)
|
|
m_LastNamedProperty = new Property(pType, flags, null);
|
|
else
|
|
m_LastNamedProperty = new Property(pType, flags, m_BinaryFormatter.Deserialize(m_Stream));
|
|
|
|
// Add to dictionary
|
|
var context = m_ContextStack.Peek();
|
|
if (context.properties.ContainsKey(hash))
|
|
Debug.LogError(string.Format("Key collision: {0}, type: {1}, in context: {2}", hash, pType, context.id));
|
|
else
|
|
context.properties.Add(hash, m_LastNamedProperty);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public void EndDeserialization()
|
|
{
|
|
m_LastNamedProperty = null;
|
|
isDeserializing = false;
|
|
m_ContextStack.Clear();
|
|
}
|
|
|
|
public bool PushContext(SerializationContext context, int id)
|
|
{
|
|
Context c;
|
|
if (m_ContextStack.Peek().subContexts.TryGetValue(id, out c))
|
|
{
|
|
m_ContextStack.Push(c);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public void PopContext(SerializationContext context, int id)
|
|
{
|
|
var activeContext = m_ContextStack.Pop().contextType;
|
|
if (activeContext != context)
|
|
Debug.LogError(string.Format("Popped serialization context does not match active context. Popped: {0}, Active: {1}", context, activeContext));
|
|
}
|
|
|
|
#region READ HELPERS
|
|
|
|
bool TryFetchProperty(int hash, PropertyType t, bool isArray)
|
|
{
|
|
if (m_ContextStack.Peek().properties.TryGetValue(hash, out m_LastNamedProperty) &&
|
|
m_LastNamedProperty.propertyType == t &&
|
|
m_LastNamedProperty.isArray == isArray)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
void ReadList<T>(List<T> output)
|
|
{
|
|
output.Clear();
|
|
if (!m_LastNamedProperty.isNullOrEmpty && m_LastNamedProperty.data != null)
|
|
output.AddRange((List<T>)m_LastNamedProperty.data);
|
|
}
|
|
|
|
T[] ReadArray<T>()
|
|
{
|
|
if (m_LastNamedProperty.isNullOrEmpty || m_LastNamedProperty.data == null)
|
|
{
|
|
return new T[0];
|
|
}
|
|
else
|
|
{
|
|
// Get the serialized collection
|
|
var collection = (List<T>)m_LastNamedProperty.data;
|
|
return collection.ToArray();
|
|
}
|
|
}
|
|
|
|
List<T> ReadIntermediates<T>()
|
|
{
|
|
if (m_LastNamedProperty.isNullOrEmpty || m_LastNamedProperty.data == null)
|
|
return null;
|
|
else
|
|
return (List<T>)m_LastNamedProperty.data;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region SINGLE VALUE READERS
|
|
|
|
public bool TryReadValue(int hash, out bool output, bool defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Bool, false))
|
|
{
|
|
output = (bool)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out byte output, byte defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Byte, false))
|
|
{
|
|
output = (byte)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out sbyte output, sbyte defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.SignedByte, false))
|
|
{
|
|
output = (sbyte)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out char output, char defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Char, false))
|
|
{
|
|
output = (char)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out short output, short defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Short, false))
|
|
{
|
|
output = (short)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out ushort output, ushort defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.UnsignedShort, false))
|
|
{
|
|
output = (ushort)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out int output, int defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Int, false))
|
|
{
|
|
output = (int)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out uint output, uint defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.UnsignedInt, false))
|
|
{
|
|
output = (uint)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out long output, long defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Long, false))
|
|
{
|
|
output = (long)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out ulong output, ulong defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.UnsignedLong, false))
|
|
{
|
|
output = (ulong)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out float output, float defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Float, false))
|
|
{
|
|
output = (float)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out double output, double defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Double, false))
|
|
{
|
|
output = (double)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out string output, string defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.String, false))
|
|
{
|
|
output = (string)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out Vector2 output, Vector2 defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector2, false))
|
|
{
|
|
output = (IntermediateVector2)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out Vector3 output, Vector3 defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector3, false))
|
|
{
|
|
output = (IntermediateVector3)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out Vector4 output, Vector4 defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector4, false))
|
|
{
|
|
output = (IntermediateVector4)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out Vector2Int output, Vector2Int defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector2Int, false))
|
|
{
|
|
output = (IntermediateVector2Int)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out Vector3Int output, Vector3Int defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector3Int, false))
|
|
{
|
|
output = (IntermediateVector3Int)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out Quaternion output, Quaternion defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Quaternion, false))
|
|
{
|
|
output = (IntermediateVector4)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out Color output, Color defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Color, false))
|
|
{
|
|
output = (IntermediateVector4)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out Color32 output, Color32 defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Color32, false))
|
|
{
|
|
output = (IntermediateColor32)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out Guid output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Guid, false))
|
|
{
|
|
output = (Guid)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = new Guid();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValue(int hash, out DateTime output, DateTime defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.DateTime, false))
|
|
{
|
|
output = (DateTime)m_LastNamedProperty.data;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region ARRAY READERS
|
|
|
|
public bool TryReadValues(int hash, out bool[] output, bool[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Bool, true))
|
|
{
|
|
output = ReadArray<bool>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out byte[] output, byte[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Byte, true))
|
|
{
|
|
output = ReadArray<byte>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out sbyte[] output, sbyte[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.SignedByte, true))
|
|
{
|
|
output = ReadArray<sbyte>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out char[] output, char[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Char, true))
|
|
{
|
|
output = ReadArray<char>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out short[] output, short[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Short, true))
|
|
{
|
|
output = ReadArray<short>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out ushort[] output, ushort[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.UnsignedShort, true))
|
|
{
|
|
output = ReadArray<ushort>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out int[] output, int[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Int, true))
|
|
{
|
|
output = ReadArray<int>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out uint[] output, uint[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.UnsignedInt, true))
|
|
{
|
|
output = ReadArray<uint>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out long[] output, long[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Long, true))
|
|
{
|
|
output = ReadArray<long>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out ulong[] output, ulong[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.UnsignedLong, true))
|
|
{
|
|
output = ReadArray<ulong>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out float[] output, float[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Float, true))
|
|
{
|
|
output = ReadArray<float>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out double[] output, double[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Double, true))
|
|
{
|
|
output = ReadArray<double>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out string[] output, string[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.String, true))
|
|
{
|
|
output = ReadArray<string>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out Vector2[] output, Vector2[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector2, true))
|
|
{
|
|
var intermediates = ReadIntermediates<IntermediateVector2>();
|
|
if (intermediates == null)
|
|
output = new Vector2[0];
|
|
else
|
|
{
|
|
// Allocate
|
|
output = new Vector2[intermediates.Count];
|
|
// Transfer across
|
|
int i = 0;
|
|
foreach (var intermediate in intermediates)
|
|
output[i++] = intermediate;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out Vector3[] output, Vector3[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector3, true))
|
|
{
|
|
var intermediates = ReadIntermediates<IntermediateVector3>();
|
|
if (intermediates == null)
|
|
output = new Vector3[0];
|
|
else
|
|
{
|
|
// Allocate
|
|
output = new Vector3[intermediates.Count];
|
|
// Transfer across
|
|
int i = 0;
|
|
foreach (var intermediate in intermediates)
|
|
output[i++] = intermediate;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out Vector4[] output, Vector4[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector4, true))
|
|
{
|
|
var intermediates = ReadIntermediates<IntermediateVector4>();
|
|
if (intermediates == null)
|
|
output = new Vector4[0];
|
|
else
|
|
{
|
|
// Allocate
|
|
output = new Vector4[intermediates.Count];
|
|
// Transfer across
|
|
int i = 0;
|
|
foreach (var intermediate in intermediates)
|
|
output[i++] = intermediate;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out Vector2Int[] output, Vector2Int[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector2Int, true))
|
|
{
|
|
var intermediates = ReadIntermediates<IntermediateVector2Int>();
|
|
if (intermediates == null)
|
|
output = new Vector2Int[0];
|
|
else
|
|
{
|
|
// Allocate
|
|
output = new Vector2Int[intermediates.Count];
|
|
// Transfer across
|
|
int i = 0;
|
|
foreach (var intermediate in intermediates)
|
|
output[i++] = intermediate;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out Vector3Int[] output, Vector3Int[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector3Int, true))
|
|
{
|
|
var intermediates = ReadIntermediates<IntermediateVector3Int>();
|
|
if (intermediates == null)
|
|
output = new Vector3Int[0];
|
|
else
|
|
{
|
|
// Allocate
|
|
output = new Vector3Int[intermediates.Count];
|
|
// Transfer across
|
|
int i = 0;
|
|
foreach (var intermediate in intermediates)
|
|
output[i++] = intermediate;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out Quaternion[] output, Quaternion[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Quaternion, true))
|
|
{
|
|
var intermediates = ReadIntermediates<IntermediateVector4>();
|
|
if (intermediates == null)
|
|
output = new Quaternion[0];
|
|
else
|
|
{
|
|
// Allocate
|
|
output = new Quaternion[intermediates.Count];
|
|
// Transfer across
|
|
int i = 0;
|
|
foreach (var intermediate in intermediates)
|
|
output[i++] = intermediate;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out Color[] output, Color[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Color, true))
|
|
{
|
|
var intermediates = ReadIntermediates<IntermediateVector4>();
|
|
if (intermediates == null)
|
|
output = new Color[0];
|
|
else
|
|
{
|
|
// Allocate
|
|
output = new Color[intermediates.Count];
|
|
// Transfer across
|
|
int i = 0;
|
|
foreach (var intermediate in intermediates)
|
|
output[i++] = intermediate;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out Color32[] output, Color32[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Color32, true))
|
|
{
|
|
var intermediates = ReadIntermediates<IntermediateColor32>();
|
|
if (intermediates == null)
|
|
output = new Color32[0];
|
|
else
|
|
{
|
|
// Allocate
|
|
output = new Color32[intermediates.Count];
|
|
// Transfer across
|
|
int i = 0;
|
|
foreach (var intermediate in intermediates)
|
|
output[i++] = intermediate;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadValues(int hash, out Guid[] output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Guid, true))
|
|
{
|
|
output = ReadArray<Guid>();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = new Guid[0];
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region LIST READERS
|
|
|
|
public bool TryReadValues(int hash, List<bool> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Bool, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<byte> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Byte, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<sbyte> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.SignedByte, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<char> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Char, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<short> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Short, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<ushort> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.UnsignedShort, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<int> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Int, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<uint> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.UnsignedInt, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<long> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Long, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<ulong> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.UnsignedLong, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<float> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Float, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<double> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Double, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<string> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.String, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<Vector2> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector2, true))
|
|
{
|
|
output.Clear();
|
|
var intermediates = ReadIntermediates<IntermediateVector2>();
|
|
if (intermediates != null)
|
|
{
|
|
foreach (var intermediate in intermediates)
|
|
output.Add(intermediate);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<Vector3> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector3, true))
|
|
{
|
|
output.Clear();
|
|
var intermediates = ReadIntermediates<IntermediateVector3>();
|
|
if (intermediates != null)
|
|
{
|
|
foreach (var intermediate in intermediates)
|
|
output.Add(intermediate);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<Vector4> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector4, true))
|
|
{
|
|
output.Clear();
|
|
var intermediates = ReadIntermediates<IntermediateVector4>();
|
|
if (intermediates != null)
|
|
{
|
|
foreach (var intermediate in intermediates)
|
|
output.Add(intermediate);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<Vector2Int> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector2Int, true))
|
|
{
|
|
output.Clear();
|
|
var intermediates = ReadIntermediates<IntermediateVector2Int>();
|
|
if (intermediates != null)
|
|
{
|
|
foreach (var intermediate in intermediates)
|
|
output.Add(intermediate);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<Vector3Int> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Vector3Int, true))
|
|
{
|
|
output.Clear();
|
|
var intermediates = ReadIntermediates<IntermediateVector3Int>();
|
|
if (intermediates != null)
|
|
{
|
|
foreach (var intermediate in intermediates)
|
|
output.Add(intermediate);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<Quaternion> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Quaternion, true))
|
|
{
|
|
output.Clear();
|
|
var intermediates = ReadIntermediates<IntermediateVector4>();
|
|
if (intermediates != null)
|
|
{
|
|
foreach (var intermediate in intermediates)
|
|
output.Add(intermediate);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<Color> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Color, true))
|
|
{
|
|
output.Clear();
|
|
var intermediates = ReadIntermediates<IntermediateVector4>();
|
|
if (intermediates != null)
|
|
{
|
|
foreach (var intermediate in intermediates)
|
|
output.Add(intermediate);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<Color32> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Color32, true))
|
|
{
|
|
output.Clear();
|
|
var intermediates = ReadIntermediates<IntermediateColor32>();
|
|
if (intermediates != null)
|
|
{
|
|
foreach (var intermediate in intermediates)
|
|
output.Add(intermediate);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public bool TryReadValues(int hash, List<Guid> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Guid, true))
|
|
{
|
|
ReadList(output);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region SERIALIZABLES
|
|
|
|
public bool TryReadSerializable<T>(int hash, out T output, T defaultValue)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Serializable, false))
|
|
{
|
|
if (m_LastNamedProperty.isNullOrEmpty)
|
|
output = default(T);
|
|
else
|
|
output = (T)m_BinaryFormatter.Deserialize(m_Stream);
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadSerializables<T>(int hash, out T[] output, T[] defaultValues)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Serializable, true))
|
|
{
|
|
if (m_LastNamedProperty.isNullOrEmpty)
|
|
output = new T[0];
|
|
else
|
|
{
|
|
var collection = (ICollection < T >)m_BinaryFormatter.Deserialize(m_Stream);
|
|
output = new T[collection.Count];
|
|
collection.CopyTo(output, 0);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
output = defaultValues;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool TryReadSerializables<T>(int hash, List<T> output)
|
|
{
|
|
if (TryFetchProperty(hash, PropertyType.Serializable, true))
|
|
{
|
|
output.Clear();
|
|
if (!m_LastNamedProperty.isNullOrEmpty)
|
|
output.AddRange((ICollection<T>)m_BinaryFormatter.Deserialize(m_Stream));
|
|
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region REFERENCES
|
|
|
|
public bool TryReadComponentReference<T>(int hash, out T output, NeoSerializedGameObject pathFrom) where T : class
|
|
{
|
|
return NeoSerializationUtilities.TryReadComponentReference(this, out output, pathFrom, hash);
|
|
}
|
|
|
|
public bool TryReadTransformReference(int hash, out Transform output, NeoSerializedGameObject pathFrom)
|
|
{
|
|
return NeoSerializationUtilities.TryReadTransformReference(this, out output, pathFrom, hash);
|
|
}
|
|
|
|
public bool TryReadGameObjectReference(int hash, out GameObject output, NeoSerializedGameObject pathFrom)
|
|
{
|
|
return NeoSerializationUtilities.TryReadGameObjectReference(this, out output, pathFrom, hash);
|
|
}
|
|
|
|
public bool TryReadNeoSerializedGameObjectReference(int hash, out NeoSerializedGameObject output, NeoSerializedGameObject pathFrom)
|
|
{
|
|
return NeoSerializationUtilities.TryReadNeoSerializedGameObjectReference(this, out output, pathFrom, hash);
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region STRING KEYS
|
|
|
|
public bool TryReadValue(string key, out bool output, bool defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out byte output, byte defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out sbyte output, sbyte defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out char output, char defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out short output, short defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out ushort output, ushort defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out int output, int defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out uint output, uint defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out long output, long defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out ulong output, ulong defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out float output, float defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out double output, double defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out Vector2 output, Vector2 defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out Vector3 output, Vector3 defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out Vector4 output, Vector4 defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out Vector2Int output, Vector2Int defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out Vector3Int output, Vector3Int defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out Quaternion output, Quaternion defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out Color output, Color defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out Color32 output, Color32 defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out Guid output) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output); }
|
|
public bool TryReadValue(string key, out DateTime output, DateTime defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadValue(string key, out string output, string defaultValue) { return TryReadValue(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
|
|
public bool TryReadValues(string key, out bool[] output, bool[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out byte[] output, byte[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out sbyte[] output, sbyte[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out char[] output, char[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out short[] output, short[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out ushort[] output, ushort[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out int[] output, int[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out uint[] output, uint[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out long[] output, long[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out ulong[] output, ulong[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out float[] output, float[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out double[] output, double[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out string[] output, string[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out Vector2[] output, Vector2[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out Vector3[] output, Vector3[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out Vector4[] output, Vector4[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out Vector2Int[] output, Vector2Int[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out Vector3Int[] output, Vector3Int[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out Quaternion[] output, Quaternion[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out Color[] output, Color[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out Color32[] output, Color32[] defaultValues) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadValues(string key, out Guid[] output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), out output); }
|
|
|
|
public bool TryReadValues(string key, List<bool> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<byte> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<sbyte> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<char> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<short> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<ushort> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<int> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<uint> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<long> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<ulong> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<float> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<double> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<string> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<Vector2> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<Vector3> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<Vector4> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<Vector2Int> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<Vector3Int> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<Quaternion> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<Color> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<Color32> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
public bool TryReadValues(string key, List<Guid> output) { return TryReadValues(NeoSerializationUtilities.StringToHash(key), output); }
|
|
|
|
public bool TryReadSerializable<T>(string key, out T output, T defaultValue) { return TryReadSerializable(NeoSerializationUtilities.StringToHash(key), out output, defaultValue); }
|
|
public bool TryReadSerializables<T>(string key, out T[] output, T[] defaultValues) { return TryReadSerializables(NeoSerializationUtilities.StringToHash(key), out output, defaultValues); }
|
|
public bool TryReadSerializables<T>(string key, List<T> output) { return TryReadSerializables(NeoSerializationUtilities.StringToHash(key), output); }
|
|
|
|
public bool TryReadComponentReference<T>(string key, out T output, NeoSerializedGameObject pathFrom) where T : class
|
|
{
|
|
return TryReadComponentReference(NeoSerializationUtilities.StringToHash(key), out output, pathFrom);
|
|
}
|
|
|
|
public bool TryReadTransformReference(string key, out Transform output, NeoSerializedGameObject pathFrom)
|
|
{
|
|
return TryReadTransformReference(NeoSerializationUtilities.StringToHash(key), out output, pathFrom);
|
|
}
|
|
|
|
public bool TryReadGameObjectReference(string key, out GameObject output, NeoSerializedGameObject pathFrom)
|
|
{
|
|
return TryReadGameObjectReference(NeoSerializationUtilities.StringToHash(key), out output, pathFrom);
|
|
}
|
|
|
|
public bool TryReadNeoSerializedGameObjectReference(string key, out NeoSerializedGameObject output, NeoSerializedGameObject pathFrom)
|
|
{
|
|
return TryReadNeoSerializedGameObjectReference(NeoSerializationUtilities.StringToHash(key), out output, pathFrom);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|