public virtual IEnumerable <string> GetProperties(JsonReader reader, JsonSerializerReader internalReader)
{
if (reader.TokenType != JsonToken.PropertyName)
{
reader.ReadAndMoveToContent();
}
bool finished = false;
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
string memberName = reader.Value.ToString();
if (internalReader.CheckPropertyName(reader, memberName))
{
continue;
}
yield return(memberName);
break;
case JsonToken.EndObject:
finished = true;
break;
case JsonToken.Comment:
// ignore
break;
default:
throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + reader.TokenType);
}
} while (!finished && reader.Read());
}
public JsonSerializerProxy(JsonSerializerReader serializerReader)
{
ValidationUtils.ArgumentNotNull(serializerReader, nameof(serializerReader));
_serializerReader = serializerReader;
_serializer = serializerReader.Serializer;
}
internal virtual object DeserializeInternal(JsonReader reader, Type objectType)
{
ValidationUtils.ArgumentNotNull(reader, "reader");
JsonSerializerReader serializerReader = new JsonSerializerReader(this);
return(serializerReader.Deserialize(reader, objectType));
}
internal virtual void PopulateInternal(JsonReader reader, object target)
{
ValidationUtils.ArgumentNotNull(reader, "reader");
ValidationUtils.ArgumentNotNull(target, "target");
JsonSerializerReader serializerReader = new JsonSerializerReader(this);
serializerReader.Populate(reader, target);
}
public JsonFormatterConverter(JsonSerializerReader reader, JsonISerializableContract contract, JsonProperty member)
{
ValidationUtils.ArgumentNotNull(reader, nameof(reader));
ValidationUtils.ArgumentNotNull(contract, nameof(contract));
_reader = reader;
_contract = contract;
_member = member;
}
public override object Create(JsonReader reader, JsonSerializerReader internalReader, JsonObjectContract objectContract, string id, string unityGuid, Type objectType, out bool exit)
{
string name = reader.ReadProperty <string>();
int lengthSamples = reader.ReadProperty <int>();
int channels = reader.ReadProperty <int>();
int frequency = reader.ReadProperty <int>();
exit = false;
return(AudioClip.Create(name, lengthSamples, channels, frequency, false));
}
public override object Create(JsonReader reader, JsonSerializerReader internalReader, JsonObjectContract objectContract, string id, string unityGuid, Type objectType, out bool exit)
{
Texture2D texture = internalReader.DeserializeProperty <UnityEngine.Texture2D>(reader);
Rect textureRect = internalReader.DeserializeProperty <Rect>(reader);
Vector2 pivot = internalReader.DeserializeProperty <UnityEngine.Vector2>(reader);
float pixelsPerUnit = reader.ReadProperty <float>();
Vector4 border = internalReader.DeserializeProperty <Vector4>(reader);
exit = false;
return(Sprite.Create(texture, textureRect, pivot, pixelsPerUnit, 0, SpriteMeshType.Tight, border));
}
public override object Create(JsonReader reader, JsonSerializerReader internalReader, JsonObjectContract objectContract, string id, string unityGuid, Type objectType, out bool exit)
{
string name = reader.ReadProperty <string>();
exit = false;
Shader shader = Shader.Find(name);
if (shader == null)
{
shader = Shader.Find("Diffuse");
}
return(shader);
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value of object being read.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
return(ReadValue(reader));
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value of object being read.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
if (reader.TokenType != JsonToken.Bytes)
{
throw new JsonSerializationException("Expected Bytes but got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
byte[] value = (byte[])reader.Value;
return(new BsonObjectId(value));
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing property value of the JSON that is being converted.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullable(objectType))
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
return(null);
}
if (reader.TokenType != JsonToken.StartConstructor || !string.Equals(reader.Value.ToString(), "Date", StringComparison.Ordinal))
{
throw JsonSerializationException.Create(reader, "Unexpected token or value when parsing date. Token: {0}, Value: {1}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType, reader.Value));
}
reader.Read();
if (reader.TokenType != JsonToken.Integer)
{
throw JsonSerializationException.Create(reader, "Unexpected token parsing date. Expected Integer, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
long ticks = (long)reader.Value;
DateTime d = DateTimeUtils.ConvertJavaScriptTicksToDateTime(ticks);
reader.Read();
if (reader.TokenType != JsonToken.EndConstructor)
{
throw JsonSerializationException.Create(reader, "Unexpected token parsing date. Expected EndConstructor, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
#if !NET20
Type t = (ReflectionUtils.IsNullableType(objectType))
? Nullable.GetUnderlyingType(objectType)
: objectType;
if (t == typeof(DateTimeOffset))
{
return(new DateTimeOffset(d));
}
#endif
return(d);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
var shouldReplace = internalReader.Serializer.ObjectCreationHandling == ObjectCreationHandling.Replace;
//Return the existing value (or null if it doesn't exist)
if (reader.TokenType == JsonToken.Null)
{
return(shouldReplace ? null : existingValue);
}
//Dynamically create the HashSet
var result = !shouldReplace && existingValue != null
? existingValue
: Activator.CreateInstance(objectType);
var genericType = objectType.GetGenericArguments()[0];
var addMethod = objectType.GetMethod("Add");
var jo = JArray.Load(reader);
for (var i = 0; i < jo.Count; i++)
{
var itemValue = internalReader.Serializer.Deserialize(jo[i].CreateReader(), genericType);
addMethod.Invoke(result, new[] { itemValue });
}
return(result);
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value of object being read.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullableType(objectType))
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to KeyValuePair.");
}
return(null);
}
object key = null;
object value = null;
reader.ReadAndAssert();
Type t = ReflectionUtils.IsNullableType(objectType)
? Nullable.GetUnderlyingType(objectType)
: objectType;
ReflectionObject reflectionObject = ReflectionObjectPerType.Get(t);
while (reader.TokenType == JsonToken.PropertyName)
{
string propertyName = reader.Value.ToString();
if (string.Equals(propertyName, KeyName, StringComparison.OrdinalIgnoreCase))
{
reader.ReadAndAssert();
key = internalReader.Serializer.Deserialize(reader, reflectionObject.GetType(KeyName));
}
else if (string.Equals(propertyName, ValueName, StringComparison.OrdinalIgnoreCase))
{
reader.ReadAndAssert();
value = internalReader.Serializer.Deserialize(reader, reflectionObject.GetType(ValueName));
}
else
{
reader.Skip();
}
reader.ReadAndAssert();
}
return(reflectionObject.Creator(key, value));
}
public override object PopulateMember(string memberName, JsonContract contract, JsonReader reader, Type objectType, object targetObject, JsonSerializerReader internalReader)
{
Material material = (Material)targetObject;
switch (memberName)
{
case "shader":
Shader shader = internalReader.DeserializeProperty <Shader>(reader);
if (material == null)
{
material = new Material(shader);
}
else
{
material.shader = shader;
}
break;
case "name":
material.name = reader.ReadProperty <string>();
break;
case "shaderKeywords":
material.shaderKeywords = internalReader.DeserializeProperty <string[]>(reader);
break;
case "renderQueue":
material.renderQueue = reader.ReadProperty <int>();
break;
case "globalIlluminationFlag":
material.globalIlluminationFlags = internalReader.DeserializeProperty <MaterialGlobalIlluminationFlags>(reader);
break;
case "color":
material.color = internalReader.DeserializeProperty <Color>(reader);
break;
case "doubleSidedGI":
material.doubleSidedGI = reader.ReadProperty <bool>();
break;
case "enableInstancing":
material.enableInstancing = reader.ReadProperty <bool>();
break;
case "mainTexture":
material.mainTexture = internalReader.DeserializeProperty <Texture2D>(reader);
break;
case "mainTextureOffset":
material.mainTextureOffset = internalReader.DeserializeProperty <Vector2>(reader);
break;
case "mainTextureScale":
material.mainTextureScale = internalReader.DeserializeProperty <Vector2>(reader);
break;
case MaterialPropertiesName:
List <JsonSerializedMaterialProperty> serializedProperties = internalReader.DeserializeProperty <List <JsonSerializedMaterialProperty> >(reader);
foreach (JsonSerializedMaterialProperty serializedProperty in serializedProperties)
{
if (serializedProperty.value != null)
{
switch (serializedProperty.type)
{
case RuntimeMaterialPropertyType.Color:
material.SetColor(serializedProperty.name, (Color)serializedProperty.value);
break;
case RuntimeMaterialPropertyType.Vector:
material.SetVector(serializedProperty.name, (Vector4)serializedProperty.value);
break;
case RuntimeMaterialPropertyType.Float:
material.SetFloat(serializedProperty.name, (float)Convert.ChangeType(serializedProperty.value, typeof(float)));
break;
case RuntimeMaterialPropertyType.Range:
material.SetFloat(serializedProperty.name, (float)Convert.ChangeType(serializedProperty.value, typeof(float)));
break;
case RuntimeMaterialPropertyType.Texture:
material.SetTexture(serializedProperty.name, (Texture)serializedProperty.value);
break;
}
}
}
break;
default:
reader.Skip();
break;
}
return(material);
}
public override object Create(JsonReader reader, JsonSerializerReader internalReader, JsonObjectContract objectContract, string id, string unityGuid, Type objectType, out bool exit)
{
exit = false;
return(null);
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value of object being read.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
if (reader.TokenType == JsonToken.StartObject)
{
return(ReadRegexObject(reader, internalReader.Serializer));
}
if (reader.TokenType == JsonToken.String)
{
return(ReadRegexString(reader));
}
throw JsonSerializationException.Create(reader, "Unexpected token when reading Regex.");
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing property value of the JSON that is being converted.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
else
{
if (reader.TokenType == JsonToken.String)
{
try
{
Version v = new Version((string)reader.Value);
return(v);
}
catch (Exception ex)
{
throw JsonSerializationException.Create(reader, "Error parsing version string: {0}".FormatWith(CultureInfo.InvariantCulture, reader.Value), ex);
}
}
else
{
throw JsonSerializationException.Create(reader, "Unexpected token or value when parsing version. Token: {0}, Value: {1}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType, reader.Value));
}
}
}
public override object PopulateMember(string memberName, JsonContract contract, JsonReader reader, Type objectType, object targetObject, JsonSerializerReader internalReader)
{
if (objectType == typeof(Color32))
{
Color32 color = (Color32)targetObject;
switch (memberName)
{
case "a":
color.a = (byte)reader.ReadAsInt32();
break;
case "r":
color.r = (byte)reader.ReadAsInt32();
break;
case "g":
color.g = (byte)reader.ReadAsInt32();
break;
case "b":
color.b = (byte)reader.ReadAsInt32();
break;
default:
reader.Skip();
break;
}
return(color);
}
else
{
Color color = (Color)targetObject;
switch (memberName)
{
case "a":
color.a = (float)reader.ReadAsDecimal();
break;
case "r":
color.r = (float)reader.ReadAsDecimal();
break;
case "g":
color.g = (float)reader.ReadAsDecimal();
break;
case "b":
color.b = (float)reader.ReadAsDecimal();
break;
default:
reader.Skip();
break;
}
return(color);
}
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value of object being read.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
bool nullable = ReflectionUtils.IsNullableType(objectType);
#if !NET20
Type t = (nullable)
? Nullable.GetUnderlyingType(objectType)
: objectType;
#endif
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullableType(objectType))
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
return(null);
}
if (reader.TokenType == JsonToken.Date)
{
#if !NET20
if (t == typeof(DateTimeOffset))
{
return((reader.Value is DateTimeOffset) ? reader.Value : new DateTimeOffset((DateTime)reader.Value));
}
// converter is expected to return a DateTime
if (reader.Value is DateTimeOffset)
{
return(((DateTimeOffset)reader.Value).DateTime);
}
#endif
return(reader.Value);
}
if (reader.TokenType != JsonToken.String)
{
throw JsonSerializationException.Create(reader, "Unexpected token parsing date. Expected String, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
string dateText = reader.Value.ToString();
if (string.IsNullOrEmpty(dateText) && nullable)
{
return(null);
}
#if !NET20
if (t == typeof(DateTimeOffset))
{
if (!string.IsNullOrEmpty(_dateTimeFormat))
{
return(DateTimeOffset.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles));
}
else
{
return(DateTimeOffset.Parse(dateText, Culture, _dateTimeStyles));
}
}
#endif
if (!string.IsNullOrEmpty(_dateTimeFormat))
{
return(DateTime.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles));
}
else
{
return(DateTime.Parse(dateText, Culture, _dateTimeStyles));
}
}
public virtual object Create(JsonReader reader, JsonSerializerReader internalReader, JsonObjectContract objectContract, string id, string unityGuid, Type objectType, out bool exit)
{
return(internalReader.CreateNewObject(reader, objectContract, null, null, id, unityGuid, out exit));
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value of object being read.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullableType(objectType))
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
return(null);
}
bool isNullable = ReflectionUtils.IsNullableType(objectType);
Type t = isNullable ? Nullable.GetUnderlyingType(objectType) : objectType;
try
{
if (reader.TokenType == JsonToken.String)
{
string enumText = reader.Value.ToString();
return(EnumUtils.ParseEnumName(enumText, isNullable, t));
}
if (reader.TokenType == JsonToken.Integer)
{
if (!AllowIntegerValues)
{
throw JsonSerializationException.Create(reader, "Integer value {0} is not allowed.".FormatWith(CultureInfo.InvariantCulture, reader.Value));
}
return(ConvertUtils.ConvertOrCast(reader.Value, CultureInfo.InvariantCulture, t));
}
}
catch (Exception ex)
{
throw JsonSerializationException.Create(reader, "Error converting value {0} to type '{1}'.".FormatWith(CultureInfo.InvariantCulture, MiscellaneousUtils.FormatValueForPrint(reader.Value), objectType), ex);
}
// we don't actually expect to get here.
throw JsonSerializationException.Create(reader, "Unexpected token {0} when parsing enum.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
public virtual object Populate(JsonContract contract, JsonReader reader, Type objectType, object targetObject, JsonSerializerReader internalReader)
{
//JObject obj = (JObject)internalReader.CreateJObject(reader);
//return PopulateJObject(obj, contract, reader, objectType, targetObject, internalReader);
foreach (string propertyName in GetProperties(reader, internalReader))
{
//reader.ReadAndMoveToContent();
targetObject = PopulateMember(propertyName, contract, reader, objectType, targetObject, internalReader);
}
return(targetObject);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
var obj = JObject.Load(reader);
var result = new Resolution
{
height = (int)obj["height"],
width = (int)obj["width"],
refreshRate = (int)obj["refreshRate"]
};
return(result);
}
public override object PopulateMember(string memberName, JsonContract contract, JsonReader reader, Type objectType, object targetObject, JsonSerializerReader internalReader)
{
if (objectType == typeof(Vector2))
{
Vector2 vector = (Vector2)targetObject;
switch (memberName)
{
case "x":
vector.x = (float)reader.ReadAsDecimal();
break;
case "y":
vector.y = (float)reader.ReadAsDecimal();
break;
default:
reader.Skip();
break;
}
return(vector);
}
else if (objectType == typeof(Vector3))
{
Vector3 vector = (Vector3)targetObject;
switch (memberName)
{
case "x":
vector.x = (float)reader.ReadAsDecimal();
break;
case "y":
vector.y = (float)reader.ReadAsDecimal();
break;
case "z":
vector.z = (float)reader.ReadAsDecimal();
break;
default:
reader.Skip();
break;
}
return(vector);
}
else if (objectType == typeof(Vector4))
{
Vector4 vector = (Vector4)targetObject;
switch (memberName)
{
case "x":
vector.x = (float)reader.ReadAsDecimal();
break;
case "y":
vector.y = (float)reader.ReadAsDecimal();
break;
case "z":
vector.z = (float)reader.ReadAsDecimal();
break;
case "w":
vector.w = (float)reader.ReadAsDecimal();
break;
default:
reader.Skip();
break;
}
return(vector);
}
#if UNITY_2017_2_OR_NEWER
else if (objectType == typeof(Vector2Int))
{
Vector2Int vector = (Vector2Int)targetObject;
switch (memberName)
{
case "x":
vector.x = reader.ReadAsInt32().GetValueOrDefault();
break;
case "y":
vector.y = reader.ReadAsInt32().GetValueOrDefault();
break;
default:
reader.Skip();
break;
}
return(vector);
}
else if (objectType == typeof(Vector3Int))
{
Vector3Int vector = (Vector3Int)targetObject;
switch (memberName)
{
case "x":
vector.x = reader.ReadAsInt32().GetValueOrDefault();
break;
case "y":
vector.y = reader.ReadAsInt32().GetValueOrDefault();
break;
case "z":
vector.z = reader.ReadAsInt32().GetValueOrDefault();
break;
default:
reader.Skip();
break;
}
return(vector);
}
#endif
return(targetObject);
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value of object being read.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
EnsureReflectionObject(objectType);
object entityKeyMember = _reflectionObject.Creator();
ReadAndAssertProperty(reader, KeyPropertyName);
reader.ReadAndAssert();
_reflectionObject.SetValue(entityKeyMember, KeyPropertyName, reader.Value.ToString());
ReadAndAssertProperty(reader, TypePropertyName);
reader.ReadAndAssert();
string type = reader.Value.ToString();
Type t = Type.GetType(type);
ReadAndAssertProperty(reader, ValuePropertyName);
reader.ReadAndAssert();
_reflectionObject.SetValue(entityKeyMember, ValuePropertyName, internalReader.Serializer.Deserialize(reader, t));
reader.ReadAndAssert();
return(entityKeyMember);
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value of object being read.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullable(objectType))
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
return(null);
}
byte[] data;
if (reader.TokenType == JsonToken.StartArray)
{
data = ReadByteArray(reader);
}
else if (reader.TokenType == JsonToken.String)
{
// current token is already at base64 string
// unable to call ReadAsBytes so do it the old fashion way
string encodedData = reader.Value.ToString();
data = Convert.FromBase64String(encodedData);
}
else
{
throw JsonSerializationException.Create(reader, "Unexpected token parsing binary. Expected String or StartArray, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
Type t = (ReflectionUtils.IsNullableType(objectType))
? Nullable.GetUnderlyingType(objectType)
: objectType;
#if !NET20
if (t.AssignableToTypeName(BinaryTypeName))
{
EnsureReflectionObject(t);
return(_reflectionObject.Creator(data));
}
#endif
throw JsonSerializationException.Create(reader, "Unexpected object type when writing binary: {0}".FormatWith(CultureInfo.InvariantCulture, objectType));
}
public override object PopulateMember(string memberName, JsonContract contract, JsonReader reader, Type objectType, object targetObject, JsonSerializerReader internalReader)
{
var instance = (UnityEngine.Mesh)targetObject;
switch (memberName)
{
#if UNITY_2017_3
case "indexFormat":
instance.indexFormat = internalReader.DeserializeProperty <UnityEngine.Rendering.IndexFormat>(reader);
break;
#endif
case "bindposes":
instance.bindposes = internalReader.DeserializeProperty <UnityEngine.Matrix4x4[]>(reader);
break;
case "subMeshCount":
instance.subMeshCount = reader.ReadProperty <System.Int32>();
break;
case "bounds":
instance.bounds = internalReader.DeserializeProperty <UnityEngine.Bounds>(reader);
break;
case "vertices":
instance.vertices = internalReader.DeserializeProperty <UnityEngine.Vector3[]>(reader);
break;
case "normals":
instance.normals = internalReader.DeserializeProperty <UnityEngine.Vector3[]>(reader);
break;
case "tangents":
instance.tangents = internalReader.DeserializeProperty <UnityEngine.Vector4[]>(reader);
break;
case "uv":
instance.uv = internalReader.DeserializeProperty <UnityEngine.Vector2[]>(reader);
break;
case "uv2":
instance.uv2 = internalReader.DeserializeProperty <UnityEngine.Vector2[]>(reader);
break;
case "uv3":
instance.uv3 = internalReader.DeserializeProperty <UnityEngine.Vector2[]>(reader);
break;
case "uv4":
instance.uv4 = internalReader.DeserializeProperty <UnityEngine.Vector2[]>(reader);
break;
case "colors":
instance.colors = internalReader.DeserializeProperty <UnityEngine.Color[]>(reader);
break;
case "colors32":
instance.colors32 = internalReader.DeserializeProperty <UnityEngine.Color32[]>(reader);
break;
case "triangles":
var triangles = internalReader.DeserializeProperty <System.Int32[][]>(reader);
for (int i = 0; i < triangles.GetLength(0); i++)
{
instance.SetTriangles(triangles[i], i);
}
break;
case "indices":
var indices = internalReader.DeserializeProperty <SerializedIndices[]>(reader);
for (int i = 0; i < indices.GetLength(0); i++)
{
instance.SetIndices(indices[i].indices, indices[i].meshTopology, i);
}
break;
case "boneWeights":
instance.boneWeights = internalReader.DeserializeProperty <UnityEngine.BoneWeight[]>(reader);
break;
case "name":
instance.name = reader.ReadProperty <System.String>();
break;
case "hideFlags":
instance.hideFlags = internalReader.DeserializeProperty <UnityEngine.HideFlags>(reader);
break;
default:
reader.Skip();
break;
}
return(instance);
}
//public virtual object PopulateJObject(JObject obj, JsonContract contract, JsonReader reader, Type objectType, object targetObject, JsonSerializerReader internalReader)
//{
// throw new NotImplementedException();
//}
public virtual object PopulateMember(string memberName, JsonContract contract, JsonReader reader, Type objectType, object targetObject, JsonSerializerReader internalReader)
{
object populatedObject = internalReader.PopulateObjectProperty(targetObject, reader, null, memberName, (JsonObjectContract)contract);
if (populatedObject == null)
{
return(targetObject);
}
return(populatedObject);
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value of object being read.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
T value = Create(objectType);
if (value == null)
{
throw new JsonSerializationException("No object created.");
}
internalReader.Serializer.Populate(reader, value);
return(value);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializerReader internalReader)
{
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullable(objectType))
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to {0}.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
return(null);
}
if (objectType == null && existingValue != null)
{
objectType = existingValue.GetType();
}
JsonContract contract = internalReader.GetContractSafe(objectType);
UnityEngine.Object unityObject = null;
if (!reader.MoveToContent())
{
throw JsonSerializationException.Create(reader, "No JSON content found.");
}
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
else if (reader.TokenType == JsonToken.StartObject)
{
string id;
string unityGuid;
Type resolvedObjectType = objectType;
if (internalReader.Serializer.MetadataPropertyHandling == MetadataPropertyHandling.Ignore)
{
// don't look for metadata properties
reader.ReadAndAssert();
id = null;
unityGuid = null;
}
else if (internalReader.Serializer.MetadataPropertyHandling == MetadataPropertyHandling.ReadAhead)
{
JTokenReader tokenReader = reader as JTokenReader;
if (tokenReader == null)
{
JToken t = JToken.ReadFrom(reader);
tokenReader = (JTokenReader)t.CreateReader();
tokenReader.Culture = reader.Culture;
tokenReader.DateFormatString = reader.DateFormatString;
tokenReader.DateParseHandling = reader.DateParseHandling;
tokenReader.DateTimeZoneHandling = reader.DateTimeZoneHandling;
tokenReader.FloatParseHandling = reader.FloatParseHandling;
tokenReader.SupportMultipleContent = reader.SupportMultipleContent;
// start
tokenReader.ReadAndAssert();
reader = tokenReader;
}
object newValue;
if (internalReader.ReadMetadataPropertiesToken(tokenReader, ref resolvedObjectType, ref contract, null, null, null, existingValue, out newValue, out id, out unityGuid, out unityObject))
{
if (SceneReferenceResolver.Current != null && !string.IsNullOrEmpty(unityGuid) && !AssetReferenceResolver.Current.Contains(unityGuid))
{
if (SceneReferenceResolver.Current.Contains(unityGuid))
{
SceneReferenceResolver.Current.Set(unityGuid, unityObject);
}
else
{
SceneReferenceResolver.Current.Add(unityGuid, unityObject);
}
}
if (unityObject != null)
{
return(unityObject);
}
return(newValue);
}
}
else
{
reader.ReadAndAssert();
object newValue;
if (internalReader.ReadMetadataProperties(reader, ref resolvedObjectType, ref contract, null, null, null, existingValue, out newValue, out id, out unityGuid, out unityObject))
{
if (SceneReferenceResolver.Current != null && !string.IsNullOrEmpty(unityGuid) && !AssetReferenceResolver.Current.Contains(unityGuid))
{
if (SceneReferenceResolver.Current.Contains(unityGuid))
{
SceneReferenceResolver.Current.Set(unityGuid, unityObject);
}
else
{
SceneReferenceResolver.Current.Add(unityGuid, unityObject);
}
}
if (unityObject != null)
{
return(unityObject);
}
return(newValue);
}
}
if (internalReader.HasNoDefinedType(contract))
{
return(internalReader.CreateJObject(reader));
}
bool createdFromNonDefaultCreator = false;
JsonObjectContract objectContract = (JsonObjectContract)contract;
object targetObject;
// check that if type name handling is being used that the existing value is compatible with the specified type
if (existingValue != null && (resolvedObjectType == objectType || resolvedObjectType.IsAssignableFrom(existingValue.GetType())))
{
targetObject = existingValue;
}
else if (unityObject != null)
{
targetObject = unityObject;
}
else
{
targetObject = Create(reader, internalReader, objectContract, id, unityGuid, objectType, out createdFromNonDefaultCreator);
}
if (SceneReferenceResolver.Current != null && !string.IsNullOrEmpty(unityGuid) && !AssetReferenceResolver.Current.Contains(unityGuid))
{
if (SceneReferenceResolver.Current.Contains(unityGuid))
{
SceneReferenceResolver.Current.Set(unityGuid, (UnityEngine.Object)targetObject);
}
else
{
SceneReferenceResolver.Current.Add(unityGuid, (UnityEngine.Object)targetObject);
}
}
// don't populate if read from non-default creator because the object has already been read
if (createdFromNonDefaultCreator)
{
return(targetObject);
}
internalReader.OnDeserializing(reader, contract, targetObject);
bool referenceAdded = false;
if (id != null && targetObject != null)
{
internalReader.AddReference(reader, id, targetObject);
referenceAdded = true;
}
targetObject = Populate(contract, reader, objectType, targetObject, internalReader);
if (id != null && targetObject != null && !referenceAdded)
{
internalReader.AddReference(reader, id, targetObject);
}
internalReader.OnDeserialized(reader, contract, targetObject);
return(targetObject);
}
else
{
throw JsonSerializationException.Create(reader, "Unexpected initial token '{0}' when populating object. Expected JSON object.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
}
}
