mirror of
https://github.com/tym1116/BH3.git
synced 2025-12-16 16:34:41 +01:00
733 lines
26 KiB
C#
733 lines
26 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using BehaviorDesigner.Runtime;
|
|
using BehaviorDesigner.Runtime.Tasks;
|
|
using UnityEngine;
|
|
|
|
public static class BinaryDeserialization
|
|
{
|
|
private class ObjectFieldMap
|
|
{
|
|
public object obj;
|
|
|
|
public FieldInfo fieldInfo;
|
|
|
|
public ObjectFieldMap(object o, FieldInfo f)
|
|
{
|
|
obj = o;
|
|
fieldInfo = f;
|
|
}
|
|
}
|
|
|
|
private class ObjectFieldMapComparer : IEqualityComparer<ObjectFieldMap>
|
|
{
|
|
public bool Equals(ObjectFieldMap a, ObjectFieldMap b)
|
|
{
|
|
if (object.ReferenceEquals(a, null))
|
|
{
|
|
return false;
|
|
}
|
|
if (object.ReferenceEquals(b, null))
|
|
{
|
|
return false;
|
|
}
|
|
return a.obj.Equals(b.obj) && a.fieldInfo.Equals(b.fieldInfo);
|
|
}
|
|
|
|
public int GetHashCode(ObjectFieldMap a)
|
|
{
|
|
return (a != null) ? (a.obj.ToString().GetHashCode() + a.fieldInfo.ToString().GetHashCode()) : 0;
|
|
}
|
|
}
|
|
|
|
private static GlobalVariables globalVariables;
|
|
|
|
private static Dictionary<ObjectFieldMap, List<int>> taskIDs;
|
|
|
|
public static void Load(BehaviorSource behaviorSource)
|
|
{
|
|
Load(behaviorSource.TaskData, behaviorSource);
|
|
}
|
|
|
|
public static void Load(TaskSerializationData taskData, BehaviorSource behaviorSource)
|
|
{
|
|
behaviorSource.EntryTask = null;
|
|
behaviorSource.RootTask = null;
|
|
behaviorSource.DetachedTasks = null;
|
|
behaviorSource.Variables = null;
|
|
FieldSerializationData fieldSerializationData;
|
|
if (taskData == null || (fieldSerializationData = taskData.fieldSerializationData).byteData == null || fieldSerializationData.byteData.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
fieldSerializationData.byteDataArray = fieldSerializationData.byteData.ToArray();
|
|
taskIDs = null;
|
|
if (taskData.variableStartIndex != null)
|
|
{
|
|
List<SharedVariable> list = new List<SharedVariable>();
|
|
Dictionary<string, int> dictionary = ObjectPool.Get<Dictionary<string, int>>();
|
|
for (int i = 0; i < taskData.variableStartIndex.Count; i++)
|
|
{
|
|
int num = taskData.variableStartIndex[i];
|
|
int num2 = ((i + 1 < taskData.variableStartIndex.Count) ? taskData.variableStartIndex[i + 1] : ((taskData.startIndex == null || taskData.startIndex.Count <= 0) ? fieldSerializationData.startIndex.Count : taskData.startIndex[0]));
|
|
dictionary.Clear();
|
|
for (int j = num; j < num2; j++)
|
|
{
|
|
dictionary.Add(fieldSerializationData.typeName[j], fieldSerializationData.startIndex[j]);
|
|
}
|
|
SharedVariable sharedVariable = BytesToSharedVariable(fieldSerializationData, dictionary, fieldSerializationData.byteDataArray, taskData.variableStartIndex[i], behaviorSource, false, string.Empty);
|
|
if (sharedVariable != null)
|
|
{
|
|
list.Add(sharedVariable);
|
|
}
|
|
}
|
|
ObjectPool.Return(dictionary);
|
|
behaviorSource.Variables = list;
|
|
}
|
|
List<Task> taskList = new List<Task>();
|
|
if (taskData.types != null)
|
|
{
|
|
for (int k = 0; k < taskData.types.Count; k++)
|
|
{
|
|
LoadTask(taskData, fieldSerializationData, ref taskList, ref behaviorSource);
|
|
}
|
|
}
|
|
if (taskData.parentIndex.Count != taskList.Count)
|
|
{
|
|
Debug.LogError("Deserialization Error: parent index count does not match task list count");
|
|
return;
|
|
}
|
|
for (int l = 0; l < taskData.parentIndex.Count; l++)
|
|
{
|
|
if (taskData.parentIndex[l] == -1)
|
|
{
|
|
if (behaviorSource.EntryTask == null)
|
|
{
|
|
behaviorSource.EntryTask = taskList[l];
|
|
continue;
|
|
}
|
|
if (behaviorSource.DetachedTasks == null)
|
|
{
|
|
behaviorSource.DetachedTasks = new List<Task>();
|
|
}
|
|
behaviorSource.DetachedTasks.Add(taskList[l]);
|
|
}
|
|
else if (taskData.parentIndex[l] == 0)
|
|
{
|
|
behaviorSource.RootTask = taskList[l];
|
|
}
|
|
else if (taskData.parentIndex[l] != -1)
|
|
{
|
|
ParentTask parentTask = taskList[taskData.parentIndex[l]] as ParentTask;
|
|
if (parentTask != null)
|
|
{
|
|
int index = ((parentTask.Children != null) ? parentTask.Children.Count : 0);
|
|
parentTask.AddChild(taskList[l], index);
|
|
}
|
|
}
|
|
}
|
|
if (taskIDs == null)
|
|
{
|
|
return;
|
|
}
|
|
foreach (ObjectFieldMap key in taskIDs.Keys)
|
|
{
|
|
List<int> list2 = taskIDs[key];
|
|
Type fieldType = key.fieldInfo.FieldType;
|
|
if (typeof(IList).IsAssignableFrom(fieldType))
|
|
{
|
|
if (fieldType.IsArray)
|
|
{
|
|
Type elementType = fieldType.GetElementType();
|
|
Array array = Array.CreateInstance(elementType, list2.Count);
|
|
for (int m = 0; m < array.Length; m++)
|
|
{
|
|
array.SetValue(taskList[list2[m]], m);
|
|
}
|
|
key.fieldInfo.SetValue(key.obj, array);
|
|
continue;
|
|
}
|
|
Type type = fieldType.GetGenericArguments()[0];
|
|
IList list3 = TaskUtility.CreateInstance(typeof(List<>).MakeGenericType(type)) as IList;
|
|
for (int n = 0; n < list2.Count; n++)
|
|
{
|
|
list3.Add(taskList[list2[n]]);
|
|
}
|
|
key.fieldInfo.SetValue(key.obj, list3);
|
|
}
|
|
else
|
|
{
|
|
key.fieldInfo.SetValue(key.obj, taskList[list2[0]]);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void Load(GlobalVariables globalVariables)
|
|
{
|
|
if (globalVariables == null)
|
|
{
|
|
return;
|
|
}
|
|
globalVariables.Variables = null;
|
|
FieldSerializationData fieldSerializationData;
|
|
if (globalVariables.VariableData == null || (fieldSerializationData = globalVariables.VariableData.fieldSerializationData).byteData == null || fieldSerializationData.byteData.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
VariableSerializationData variableData = globalVariables.VariableData;
|
|
fieldSerializationData.byteDataArray = fieldSerializationData.byteData.ToArray();
|
|
if (variableData.variableStartIndex == null)
|
|
{
|
|
return;
|
|
}
|
|
List<SharedVariable> list = new List<SharedVariable>();
|
|
Dictionary<string, int> dictionary = ObjectPool.Get<Dictionary<string, int>>();
|
|
for (int i = 0; i < variableData.variableStartIndex.Count; i++)
|
|
{
|
|
int num = variableData.variableStartIndex[i];
|
|
int num2 = ((i + 1 >= variableData.variableStartIndex.Count) ? fieldSerializationData.startIndex.Count : variableData.variableStartIndex[i + 1]);
|
|
dictionary.Clear();
|
|
for (int j = num; j < num2; j++)
|
|
{
|
|
dictionary.Add(fieldSerializationData.typeName[j], fieldSerializationData.startIndex[j]);
|
|
}
|
|
SharedVariable sharedVariable = BytesToSharedVariable(fieldSerializationData, dictionary, fieldSerializationData.byteDataArray, variableData.variableStartIndex[i], globalVariables, false, string.Empty);
|
|
if (sharedVariable != null)
|
|
{
|
|
list.Add(sharedVariable);
|
|
}
|
|
}
|
|
ObjectPool.Return(dictionary);
|
|
globalVariables.Variables = list;
|
|
}
|
|
|
|
private static void LoadTask(TaskSerializationData taskSerializationData, FieldSerializationData fieldSerializationData, ref List<Task> taskList, ref BehaviorSource behaviorSource)
|
|
{
|
|
int count = taskList.Count;
|
|
Task task = null;
|
|
Type type = TaskUtility.GetTypeWithinAssembly(taskSerializationData.types[count]);
|
|
if (type == null)
|
|
{
|
|
bool flag = false;
|
|
for (int i = 0; i < taskSerializationData.parentIndex.Count; i++)
|
|
{
|
|
if (count == taskSerializationData.parentIndex[i])
|
|
{
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
type = ((!flag) ? typeof(UnknownTask) : typeof(UnknownParentTask));
|
|
}
|
|
task = TaskUtility.CreateInstance(type) as Task;
|
|
task.Owner = behaviorSource.Owner.GetObject() as Behavior;
|
|
taskList.Add(task);
|
|
int num = taskSerializationData.startIndex[count];
|
|
int num2 = ((count + 1 >= taskSerializationData.startIndex.Count) ? fieldSerializationData.startIndex.Count : taskSerializationData.startIndex[count + 1]);
|
|
Dictionary<string, int> dictionary = ObjectPool.Get<Dictionary<string, int>>();
|
|
dictionary.Clear();
|
|
for (int j = num; j < num2; j++)
|
|
{
|
|
dictionary.Add(fieldSerializationData.typeName[j], fieldSerializationData.startIndex[j]);
|
|
}
|
|
task.ID = (int)LoadField(fieldSerializationData, dictionary, typeof(int), "ID", null);
|
|
task.FriendlyName = (string)LoadField(fieldSerializationData, dictionary, typeof(string), "FriendlyName", null);
|
|
task.IsInstant = (bool)LoadField(fieldSerializationData, dictionary, typeof(bool), "IsInstant", null);
|
|
LoadNodeData(fieldSerializationData, dictionary, taskList[count]);
|
|
if (task.GetType().Equals(typeof(UnknownTask)) || task.GetType().Equals(typeof(UnknownParentTask)))
|
|
{
|
|
if (!task.FriendlyName.Contains("Unknown "))
|
|
{
|
|
task.FriendlyName = string.Format("Unknown {0}", task.FriendlyName);
|
|
}
|
|
if (!task.NodeData.Comment.Contains("Loaded from an unknown type. Was a task renamed or deleted?"))
|
|
{
|
|
task.NodeData.Comment = string.Format("Loaded from an unknown type. Was a task renamed or deleted?{0}", (!task.NodeData.Comment.Equals(string.Empty)) ? string.Format("\0{0}", task.NodeData.Comment) : string.Empty);
|
|
}
|
|
}
|
|
LoadFields(fieldSerializationData, dictionary, taskList[count], string.Empty, behaviorSource);
|
|
ObjectPool.Return(dictionary);
|
|
}
|
|
|
|
private static void LoadNodeData(FieldSerializationData fieldSerializationData, Dictionary<string, int> fieldIndexMap, Task task)
|
|
{
|
|
NodeData nodeData = new NodeData();
|
|
nodeData.Offset = (Vector2)LoadField(fieldSerializationData, fieldIndexMap, typeof(Vector2), "NodeDataOffset", null);
|
|
nodeData.Comment = (string)LoadField(fieldSerializationData, fieldIndexMap, typeof(string), "NodeDataComment", null);
|
|
nodeData.IsBreakpoint = (bool)LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), "NodeDataIsBreakpoint", null);
|
|
nodeData.Disabled = (bool)LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), "NodeDataDisabled", null);
|
|
nodeData.Collapsed = (bool)LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), "NodeDataCollapsed", null);
|
|
object obj = LoadField(fieldSerializationData, fieldIndexMap, typeof(int), "NodeDataColorIndex", null);
|
|
if (obj != null)
|
|
{
|
|
nodeData.ColorIndex = (int)obj;
|
|
}
|
|
obj = LoadField(fieldSerializationData, fieldIndexMap, typeof(List<string>), "NodeDataWatchedFields", null);
|
|
if (obj != null)
|
|
{
|
|
nodeData.WatchedFieldNames = new List<string>();
|
|
nodeData.WatchedFields = new List<FieldInfo>();
|
|
IList list = obj as IList;
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
FieldInfo field = task.GetType().GetField((string)list[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
if (field != null)
|
|
{
|
|
nodeData.WatchedFieldNames.Add(field.Name);
|
|
nodeData.WatchedFields.Add(field);
|
|
}
|
|
}
|
|
}
|
|
task.NodeData = nodeData;
|
|
}
|
|
|
|
private static void LoadFields(FieldSerializationData fieldSerializationData, Dictionary<string, int> fieldIndexMap, object obj, string namePrefix, IVariableSource variableSource)
|
|
{
|
|
FieldInfo[] allFields = TaskUtility.GetAllFields(obj.GetType());
|
|
for (int i = 0; i < allFields.Length; i++)
|
|
{
|
|
if (!TaskUtility.HasAttribute(allFields[i], typeof(NonSerializedAttribute)) && ((!allFields[i].IsPrivate && !allFields[i].IsFamily) || TaskUtility.HasAttribute(allFields[i], typeof(SerializeField))) && (!(obj is ParentTask) || !allFields[i].Name.Equals("children")))
|
|
{
|
|
object obj2 = LoadField(fieldSerializationData, fieldIndexMap, allFields[i].FieldType, namePrefix + allFields[i].Name, variableSource, obj, allFields[i]);
|
|
if (obj2 != null && !object.ReferenceEquals(obj2, null) && !obj2.Equals(null))
|
|
{
|
|
allFields[i].SetValue(obj, obj2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static object LoadField(FieldSerializationData fieldSerializationData, Dictionary<string, int> fieldIndexMap, Type fieldType, string fieldName, IVariableSource variableSource, object obj = null, FieldInfo fieldInfo = null)
|
|
{
|
|
string text = fieldType.Name + fieldName;
|
|
int value;
|
|
if (!fieldIndexMap.TryGetValue(text, out value))
|
|
{
|
|
if (typeof(SharedVariable).IsAssignableFrom(fieldType))
|
|
{
|
|
Type type = TaskUtility.SharedVariableToConcreteType(fieldType);
|
|
if (type == null)
|
|
{
|
|
return null;
|
|
}
|
|
text = type.Name + fieldName;
|
|
if (fieldIndexMap.ContainsKey(text))
|
|
{
|
|
SharedVariable sharedVariable = TaskUtility.CreateInstance(fieldType) as SharedVariable;
|
|
sharedVariable.SetValue(LoadField(fieldSerializationData, fieldIndexMap, type, fieldName, variableSource));
|
|
return sharedVariable;
|
|
}
|
|
}
|
|
if (typeof(SharedVariable).IsAssignableFrom(fieldType))
|
|
{
|
|
return TaskUtility.CreateInstance(fieldType);
|
|
}
|
|
return null;
|
|
}
|
|
object obj2 = null;
|
|
if (typeof(IList).IsAssignableFrom(fieldType))
|
|
{
|
|
int num = BytesToInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
if (fieldType.IsArray)
|
|
{
|
|
Type elementType = fieldType.GetElementType();
|
|
if (elementType == null)
|
|
{
|
|
return null;
|
|
}
|
|
Array array = Array.CreateInstance(elementType, num);
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
object obj3 = LoadField(fieldSerializationData, fieldIndexMap, elementType, text + i, variableSource, obj, fieldInfo);
|
|
array.SetValue((!object.ReferenceEquals(obj3, null) && !obj3.Equals(null)) ? obj3 : null, i);
|
|
}
|
|
obj2 = array;
|
|
}
|
|
else
|
|
{
|
|
Type type2 = fieldType;
|
|
while (!type2.IsGenericType)
|
|
{
|
|
type2 = type2.BaseType;
|
|
}
|
|
Type type3 = type2.GetGenericArguments()[0];
|
|
IList list = ((!fieldType.IsGenericType) ? (TaskUtility.CreateInstance(fieldType) as IList) : (TaskUtility.CreateInstance(typeof(List<>).MakeGenericType(type3)) as IList));
|
|
for (int j = 0; j < num; j++)
|
|
{
|
|
object obj4 = LoadField(fieldSerializationData, fieldIndexMap, type3, text + j, variableSource, obj, fieldInfo);
|
|
list.Add((!object.ReferenceEquals(obj4, null) && !obj4.Equals(null)) ? obj4 : null);
|
|
}
|
|
obj2 = list;
|
|
}
|
|
}
|
|
else if (typeof(Task).IsAssignableFrom(fieldType))
|
|
{
|
|
if (fieldInfo != null && TaskUtility.HasAttribute(fieldInfo, typeof(InspectTaskAttribute)))
|
|
{
|
|
string text2 = BytesToString(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value], GetFieldSize(fieldSerializationData, value));
|
|
if (!string.IsNullOrEmpty(text2))
|
|
{
|
|
Type typeWithinAssembly = TaskUtility.GetTypeWithinAssembly(text2);
|
|
if (typeWithinAssembly != null)
|
|
{
|
|
obj2 = TaskUtility.CreateInstance(typeWithinAssembly);
|
|
LoadFields(fieldSerializationData, fieldIndexMap, obj2, text, variableSource);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (taskIDs == null)
|
|
{
|
|
taskIDs = new Dictionary<ObjectFieldMap, List<int>>(new ObjectFieldMapComparer());
|
|
}
|
|
int item = BytesToInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
ObjectFieldMap key = new ObjectFieldMap(obj, fieldInfo);
|
|
if (taskIDs.ContainsKey(key))
|
|
{
|
|
taskIDs[key].Add(item);
|
|
}
|
|
else
|
|
{
|
|
List<int> list2 = new List<int>();
|
|
list2.Add(item);
|
|
taskIDs.Add(key, list2);
|
|
}
|
|
}
|
|
}
|
|
else if (typeof(SharedVariable).IsAssignableFrom(fieldType))
|
|
{
|
|
obj2 = BytesToSharedVariable(fieldSerializationData, fieldIndexMap, fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value], variableSource, true, text);
|
|
}
|
|
else if (typeof(UnityEngine.Object).IsAssignableFrom(fieldType))
|
|
{
|
|
int index = BytesToInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
obj2 = IndexToUnityObject(index, fieldSerializationData);
|
|
}
|
|
else if (fieldType.Equals(typeof(int)) || fieldType.IsEnum)
|
|
{
|
|
obj2 = BytesToInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(uint)))
|
|
{
|
|
obj2 = BytesToUInt(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(float)))
|
|
{
|
|
obj2 = BytesToFloat(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(double)))
|
|
{
|
|
obj2 = BytesToDouble(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(long)))
|
|
{
|
|
obj2 = BytesToLong(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(bool)))
|
|
{
|
|
obj2 = BytesToBool(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(string)))
|
|
{
|
|
obj2 = BytesToString(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value], GetFieldSize(fieldSerializationData, value));
|
|
}
|
|
else if (fieldType.Equals(typeof(byte)))
|
|
{
|
|
obj2 = BytesToByte(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(Vector2)))
|
|
{
|
|
obj2 = BytesToVector2(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(Vector3)))
|
|
{
|
|
obj2 = BytesToVector3(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(Vector4)))
|
|
{
|
|
obj2 = BytesToVector4(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(Quaternion)))
|
|
{
|
|
obj2 = BytesToQuaternion(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(Color)))
|
|
{
|
|
obj2 = BytesToColor(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(Rect)))
|
|
{
|
|
obj2 = BytesToRect(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(Matrix4x4)))
|
|
{
|
|
obj2 = BytesToMatrix4x4(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(AnimationCurve)))
|
|
{
|
|
obj2 = BytesToAnimationCurve(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.Equals(typeof(LayerMask)))
|
|
{
|
|
obj2 = BytesToLayerMask(fieldSerializationData.byteDataArray, fieldSerializationData.dataPosition[value]);
|
|
}
|
|
else if (fieldType.IsClass || (fieldType.IsValueType && !fieldType.IsPrimitive))
|
|
{
|
|
obj2 = TaskUtility.CreateInstance(fieldType);
|
|
LoadFields(fieldSerializationData, fieldIndexMap, obj2, text, variableSource);
|
|
return obj2;
|
|
}
|
|
return obj2;
|
|
}
|
|
|
|
private static int GetFieldSize(FieldSerializationData fieldSerializationData, int fieldIndex)
|
|
{
|
|
return ((fieldIndex + 1 >= fieldSerializationData.dataPosition.Count) ? fieldSerializationData.byteData.Count : fieldSerializationData.dataPosition[fieldIndex + 1]) - fieldSerializationData.dataPosition[fieldIndex];
|
|
}
|
|
|
|
private static int BytesToInt(byte[] bytes, int dataPosition)
|
|
{
|
|
if (BitConverter.IsLittleEndian)
|
|
{
|
|
Array.Reverse(bytes, dataPosition, 4);
|
|
}
|
|
return BitConverter.ToInt32(bytes, dataPosition);
|
|
}
|
|
|
|
private static uint BytesToUInt(byte[] bytes, int dataPosition)
|
|
{
|
|
if (BitConverter.IsLittleEndian)
|
|
{
|
|
Array.Reverse(bytes, dataPosition, 4);
|
|
}
|
|
return BitConverter.ToUInt32(bytes, dataPosition);
|
|
}
|
|
|
|
private static float BytesToFloat(byte[] bytes, int dataPosition)
|
|
{
|
|
if (BitConverter.IsLittleEndian)
|
|
{
|
|
Array.Reverse(bytes, dataPosition, 4);
|
|
}
|
|
return BitConverter.ToSingle(bytes, dataPosition);
|
|
}
|
|
|
|
private static double BytesToDouble(byte[] bytes, int dataPosition)
|
|
{
|
|
if (BitConverter.IsLittleEndian)
|
|
{
|
|
Array.Reverse(bytes, dataPosition, 8);
|
|
}
|
|
return BitConverter.ToDouble(bytes, dataPosition);
|
|
}
|
|
|
|
private static long BytesToLong(byte[] bytes, int dataPosition)
|
|
{
|
|
if (BitConverter.IsLittleEndian)
|
|
{
|
|
Array.Reverse(bytes, dataPosition, 8);
|
|
}
|
|
return BitConverter.ToInt64(bytes, dataPosition);
|
|
}
|
|
|
|
private static bool BytesToBool(byte[] bytes, int dataPosition)
|
|
{
|
|
return BitConverter.ToBoolean(bytes, dataPosition);
|
|
}
|
|
|
|
private static string BytesToString(byte[] bytes, int dataPosition, int dataSize)
|
|
{
|
|
if (dataSize == 0)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
return Encoding.UTF8.GetString(bytes, dataPosition, dataSize);
|
|
}
|
|
|
|
private static byte BytesToByte(byte[] bytes, int dataPosition)
|
|
{
|
|
return bytes[dataPosition];
|
|
}
|
|
|
|
private static Color BytesToColor(byte[] bytes, int dataPosition)
|
|
{
|
|
Color black = Color.black;
|
|
black.r = BitConverter.ToSingle(bytes, dataPosition);
|
|
black.g = BitConverter.ToSingle(bytes, dataPosition + 4);
|
|
black.b = BitConverter.ToSingle(bytes, dataPosition + 8);
|
|
black.a = BitConverter.ToSingle(bytes, dataPosition + 12);
|
|
return black;
|
|
}
|
|
|
|
private static Vector2 BytesToVector2(byte[] bytes, int dataPosition)
|
|
{
|
|
Vector2 zero = Vector2.zero;
|
|
zero.x = BitConverter.ToSingle(bytes, dataPosition);
|
|
zero.y = BitConverter.ToSingle(bytes, dataPosition + 4);
|
|
return zero;
|
|
}
|
|
|
|
private static Vector3 BytesToVector3(byte[] bytes, int dataPosition)
|
|
{
|
|
Vector3 zero = Vector3.zero;
|
|
zero.x = BitConverter.ToSingle(bytes, dataPosition);
|
|
zero.y = BitConverter.ToSingle(bytes, dataPosition + 4);
|
|
zero.z = BitConverter.ToSingle(bytes, dataPosition + 8);
|
|
return zero;
|
|
}
|
|
|
|
private static Vector4 BytesToVector4(byte[] bytes, int dataPosition)
|
|
{
|
|
Vector4 zero = Vector4.zero;
|
|
zero.x = BitConverter.ToSingle(bytes, dataPosition);
|
|
zero.y = BitConverter.ToSingle(bytes, dataPosition + 4);
|
|
zero.z = BitConverter.ToSingle(bytes, dataPosition + 8);
|
|
zero.w = BitConverter.ToSingle(bytes, dataPosition + 12);
|
|
return zero;
|
|
}
|
|
|
|
private static Quaternion BytesToQuaternion(byte[] bytes, int dataPosition)
|
|
{
|
|
Quaternion identity = Quaternion.identity;
|
|
identity.x = BitConverter.ToSingle(bytes, dataPosition);
|
|
identity.y = BitConverter.ToSingle(bytes, dataPosition + 4);
|
|
identity.z = BitConverter.ToSingle(bytes, dataPosition + 8);
|
|
identity.w = BitConverter.ToSingle(bytes, dataPosition + 12);
|
|
return identity;
|
|
}
|
|
|
|
private static Rect BytesToRect(byte[] bytes, int dataPosition)
|
|
{
|
|
return new Rect
|
|
{
|
|
x = BitConverter.ToSingle(bytes, dataPosition),
|
|
y = BitConverter.ToSingle(bytes, dataPosition + 4),
|
|
width = BitConverter.ToSingle(bytes, dataPosition + 8),
|
|
height = BitConverter.ToSingle(bytes, dataPosition + 12)
|
|
};
|
|
}
|
|
|
|
private static Matrix4x4 BytesToMatrix4x4(byte[] bytes, int dataPosition)
|
|
{
|
|
Matrix4x4 identity = Matrix4x4.identity;
|
|
identity.m00 = BitConverter.ToSingle(bytes, dataPosition);
|
|
identity.m01 = BitConverter.ToSingle(bytes, dataPosition + 4);
|
|
identity.m02 = BitConverter.ToSingle(bytes, dataPosition + 8);
|
|
identity.m03 = BitConverter.ToSingle(bytes, dataPosition + 12);
|
|
identity.m10 = BitConverter.ToSingle(bytes, dataPosition + 16);
|
|
identity.m11 = BitConverter.ToSingle(bytes, dataPosition + 20);
|
|
identity.m12 = BitConverter.ToSingle(bytes, dataPosition + 24);
|
|
identity.m13 = BitConverter.ToSingle(bytes, dataPosition + 28);
|
|
identity.m20 = BitConverter.ToSingle(bytes, dataPosition + 32);
|
|
identity.m21 = BitConverter.ToSingle(bytes, dataPosition + 36);
|
|
identity.m22 = BitConverter.ToSingle(bytes, dataPosition + 40);
|
|
identity.m23 = BitConverter.ToSingle(bytes, dataPosition + 44);
|
|
identity.m30 = BitConverter.ToSingle(bytes, dataPosition + 48);
|
|
identity.m31 = BitConverter.ToSingle(bytes, dataPosition + 52);
|
|
identity.m32 = BitConverter.ToSingle(bytes, dataPosition + 56);
|
|
identity.m33 = BitConverter.ToSingle(bytes, dataPosition + 60);
|
|
return identity;
|
|
}
|
|
|
|
private static AnimationCurve BytesToAnimationCurve(byte[] bytes, int dataPosition)
|
|
{
|
|
AnimationCurve animationCurve = new AnimationCurve();
|
|
int num = BitConverter.ToInt32(bytes, dataPosition);
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
animationCurve.AddKey(new Keyframe
|
|
{
|
|
time = BitConverter.ToSingle(bytes, dataPosition + 4),
|
|
value = BitConverter.ToSingle(bytes, dataPosition + 8),
|
|
inTangent = BitConverter.ToSingle(bytes, dataPosition + 12),
|
|
outTangent = BitConverter.ToSingle(bytes, dataPosition + 16),
|
|
tangentMode = BitConverter.ToInt32(bytes, dataPosition + 20)
|
|
});
|
|
dataPosition += 20;
|
|
}
|
|
animationCurve.preWrapMode = (WrapMode)BitConverter.ToInt32(bytes, dataPosition + 4);
|
|
animationCurve.postWrapMode = (WrapMode)BitConverter.ToInt32(bytes, dataPosition + 8);
|
|
return animationCurve;
|
|
}
|
|
|
|
private static LayerMask BytesToLayerMask(byte[] bytes, int dataPosition)
|
|
{
|
|
return new LayerMask
|
|
{
|
|
value = BytesToInt(bytes, dataPosition)
|
|
};
|
|
}
|
|
|
|
private static UnityEngine.Object IndexToUnityObject(int index, FieldSerializationData activeFieldSerializationData)
|
|
{
|
|
if (index < 0 || index >= activeFieldSerializationData.unityObjects.Count)
|
|
{
|
|
return null;
|
|
}
|
|
return activeFieldSerializationData.unityObjects[index];
|
|
}
|
|
|
|
private static SharedVariable BytesToSharedVariable(FieldSerializationData fieldSerializationData, Dictionary<string, int> fieldIndexMap, byte[] bytes, int dataPosition, IVariableSource variableSource, bool fromField, string namePrefix)
|
|
{
|
|
SharedVariable sharedVariable = null;
|
|
string text = (string)LoadField(fieldSerializationData, fieldIndexMap, typeof(string), namePrefix + "Type", null);
|
|
if (string.IsNullOrEmpty(text))
|
|
{
|
|
return null;
|
|
}
|
|
string name = (string)LoadField(fieldSerializationData, fieldIndexMap, typeof(string), namePrefix + "Name", null);
|
|
bool flag = Convert.ToBoolean(LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), namePrefix + "IsShared", null));
|
|
bool flag2 = Convert.ToBoolean(LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), namePrefix + "IsGlobal", null));
|
|
if (flag && fromField)
|
|
{
|
|
if (!flag2)
|
|
{
|
|
sharedVariable = variableSource.GetVariable(name);
|
|
}
|
|
else
|
|
{
|
|
if (globalVariables == null)
|
|
{
|
|
globalVariables = GlobalVariables.Instance;
|
|
}
|
|
if (globalVariables != null)
|
|
{
|
|
sharedVariable = globalVariables.GetVariable(name);
|
|
}
|
|
}
|
|
}
|
|
Type typeWithinAssembly = TaskUtility.GetTypeWithinAssembly(text);
|
|
if (typeWithinAssembly == null)
|
|
{
|
|
return null;
|
|
}
|
|
bool flag3 = true;
|
|
if (sharedVariable == null || !(flag3 = sharedVariable.GetType().Equals(typeWithinAssembly)))
|
|
{
|
|
sharedVariable = TaskUtility.CreateInstance(typeWithinAssembly) as SharedVariable;
|
|
sharedVariable.Name = name;
|
|
sharedVariable.IsShared = flag;
|
|
sharedVariable.IsGlobal = flag2;
|
|
sharedVariable.NetworkSync = Convert.ToBoolean(LoadField(fieldSerializationData, fieldIndexMap, typeof(bool), namePrefix + "NetworkSync", null));
|
|
if (!flag2)
|
|
{
|
|
sharedVariable.PropertyMapping = (string)LoadField(fieldSerializationData, fieldIndexMap, typeof(string), namePrefix + "PropertyMapping", null);
|
|
if (!string.IsNullOrEmpty(sharedVariable.PropertyMapping) && (variableSource as BehaviorSource).Owner is Behavior)
|
|
{
|
|
sharedVariable.InitializePropertyMapping(variableSource as BehaviorSource);
|
|
}
|
|
}
|
|
if (!flag3)
|
|
{
|
|
sharedVariable.IsShared = true;
|
|
}
|
|
LoadFields(fieldSerializationData, fieldIndexMap, sharedVariable, namePrefix, variableSource);
|
|
}
|
|
return sharedVariable;
|
|
}
|
|
}
|