forked from cgvr/DeltaVR
371 lines
12 KiB
C#
371 lines
12 KiB
C#
#region License and information
|
|
/* * * * *
|
|
*
|
|
* Unity extension for the SimpleJSON framework. It does only work together with
|
|
* the SimpleJSON.cs
|
|
* It provides several helpers and conversion operators to serialize/deserialize
|
|
* common Unity types such as Vector2/3/4, Rect, RectOffset, Quaternion and
|
|
* Matrix4x4 as JSONObject or JSONArray.
|
|
* This extension will add 3 static settings to the JSONNode class:
|
|
* ( VectorContainerType, QuaternionContainerType, RectContainerType ) which
|
|
* control what node type should be used for serializing the given type. So a
|
|
* Vector3 as array would look like [12,32,24] and {"x":12, "y":32, "z":24} as
|
|
* object.
|
|
*
|
|
*
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2012-2017 Markus Göbel (Bunny83)
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
* * * * */
|
|
|
|
#endregion License and information
|
|
|
|
using UnityEngine;
|
|
|
|
// renaming the namespace to avoid conflict
|
|
namespace OVRSimpleJSON // SimpleJSON
|
|
{
|
|
public enum JSONContainerType { Array, Object }
|
|
public partial class JSONNode
|
|
{
|
|
public static JSONContainerType VectorContainerType = JSONContainerType.Array;
|
|
public static JSONContainerType QuaternionContainerType = JSONContainerType.Array;
|
|
public static JSONContainerType RectContainerType = JSONContainerType.Array;
|
|
private static JSONNode GetContainer(JSONContainerType aType)
|
|
{
|
|
if (aType == JSONContainerType.Array)
|
|
return new JSONArray();
|
|
return new JSONObject();
|
|
}
|
|
|
|
#region implicit conversion operators
|
|
public static implicit operator JSONNode(Vector2 aVec)
|
|
{
|
|
JSONNode n = GetContainer(VectorContainerType);
|
|
n.WriteVector2(aVec);
|
|
return n;
|
|
}
|
|
public static implicit operator JSONNode(Vector3 aVec)
|
|
{
|
|
JSONNode n = GetContainer(VectorContainerType);
|
|
n.WriteVector3(aVec);
|
|
return n;
|
|
}
|
|
public static implicit operator JSONNode(Vector4 aVec)
|
|
{
|
|
JSONNode n = GetContainer(VectorContainerType);
|
|
n.WriteVector4(aVec);
|
|
return n;
|
|
}
|
|
public static implicit operator JSONNode(Quaternion aRot)
|
|
{
|
|
JSONNode n = GetContainer(QuaternionContainerType);
|
|
n.WriteQuaternion(aRot);
|
|
return n;
|
|
}
|
|
public static implicit operator JSONNode(Rect aRect)
|
|
{
|
|
JSONNode n = GetContainer(RectContainerType);
|
|
n.WriteRect(aRect);
|
|
return n;
|
|
}
|
|
public static implicit operator JSONNode(RectOffset aRect)
|
|
{
|
|
JSONNode n = GetContainer(RectContainerType);
|
|
n.WriteRectOffset(aRect);
|
|
return n;
|
|
}
|
|
|
|
public static implicit operator Vector2(JSONNode aNode)
|
|
{
|
|
return aNode.ReadVector2();
|
|
}
|
|
public static implicit operator Vector3(JSONNode aNode)
|
|
{
|
|
return aNode.ReadVector3();
|
|
}
|
|
public static implicit operator Vector4(JSONNode aNode)
|
|
{
|
|
return aNode.ReadVector4();
|
|
}
|
|
public static implicit operator Quaternion(JSONNode aNode)
|
|
{
|
|
return aNode.ReadQuaternion();
|
|
}
|
|
public static implicit operator Rect(JSONNode aNode)
|
|
{
|
|
return aNode.ReadRect();
|
|
}
|
|
public static implicit operator RectOffset(JSONNode aNode)
|
|
{
|
|
return aNode.ReadRectOffset();
|
|
}
|
|
#endregion implicit conversion operators
|
|
|
|
#region Vector2
|
|
public Vector2 ReadVector2(Vector2 aDefault)
|
|
{
|
|
if (IsObject)
|
|
return new Vector2(this["x"].AsFloat, this["y"].AsFloat);
|
|
if (IsArray)
|
|
return new Vector2(this[0].AsFloat, this[1].AsFloat);
|
|
return aDefault;
|
|
}
|
|
public Vector2 ReadVector2(string aXName, string aYName)
|
|
{
|
|
if (IsObject)
|
|
{
|
|
return new Vector2(this[aXName].AsFloat, this[aYName].AsFloat);
|
|
}
|
|
return Vector2.zero;
|
|
}
|
|
|
|
public Vector2 ReadVector2()
|
|
{
|
|
return ReadVector2(Vector2.zero);
|
|
}
|
|
public JSONNode WriteVector2(Vector2 aVec, string aXName = "x", string aYName = "y")
|
|
{
|
|
if (IsObject)
|
|
{
|
|
Inline = true;
|
|
this[aXName].AsFloat = aVec.x;
|
|
this[aYName].AsFloat = aVec.y;
|
|
}
|
|
else if (IsArray)
|
|
{
|
|
Inline = true;
|
|
this[0].AsFloat = aVec.x;
|
|
this[1].AsFloat = aVec.y;
|
|
}
|
|
return this;
|
|
}
|
|
#endregion Vector2
|
|
|
|
#region Vector3
|
|
public Vector3 ReadVector3(Vector3 aDefault)
|
|
{
|
|
if (IsObject)
|
|
return new Vector3(this["x"].AsFloat, this["y"].AsFloat, this["z"].AsFloat);
|
|
if (IsArray)
|
|
return new Vector3(this[0].AsFloat, this[1].AsFloat, this[2].AsFloat);
|
|
return aDefault;
|
|
}
|
|
public Vector3 ReadVector3(string aXName, string aYName, string aZName)
|
|
{
|
|
if (IsObject)
|
|
return new Vector3(this[aXName].AsFloat, this[aYName].AsFloat, this[aZName].AsFloat);
|
|
return Vector3.zero;
|
|
}
|
|
public Vector3 ReadVector3()
|
|
{
|
|
return ReadVector3(Vector3.zero);
|
|
}
|
|
public JSONNode WriteVector3(Vector3 aVec, string aXName = "x", string aYName = "y", string aZName = "z")
|
|
{
|
|
if (IsObject)
|
|
{
|
|
Inline = true;
|
|
this[aXName].AsFloat = aVec.x;
|
|
this[aYName].AsFloat = aVec.y;
|
|
this[aZName].AsFloat = aVec.z;
|
|
}
|
|
else if (IsArray)
|
|
{
|
|
Inline = true;
|
|
this[0].AsFloat = aVec.x;
|
|
this[1].AsFloat = aVec.y;
|
|
this[2].AsFloat = aVec.z;
|
|
}
|
|
return this;
|
|
}
|
|
#endregion Vector3
|
|
|
|
#region Vector4
|
|
public Vector4 ReadVector4(Vector4 aDefault)
|
|
{
|
|
if (IsObject)
|
|
return new Vector4(this["x"].AsFloat, this["y"].AsFloat, this["z"].AsFloat, this["w"].AsFloat);
|
|
if (IsArray)
|
|
return new Vector4(this[0].AsFloat, this[1].AsFloat, this[2].AsFloat, this[3].AsFloat);
|
|
return aDefault;
|
|
}
|
|
public Vector4 ReadVector4()
|
|
{
|
|
return ReadVector4(Vector4.zero);
|
|
}
|
|
public JSONNode WriteVector4(Vector4 aVec)
|
|
{
|
|
if (IsObject)
|
|
{
|
|
Inline = true;
|
|
this["x"].AsFloat = aVec.x;
|
|
this["y"].AsFloat = aVec.y;
|
|
this["z"].AsFloat = aVec.z;
|
|
this["w"].AsFloat = aVec.w;
|
|
}
|
|
else if (IsArray)
|
|
{
|
|
Inline = true;
|
|
this[0].AsFloat = aVec.x;
|
|
this[1].AsFloat = aVec.y;
|
|
this[2].AsFloat = aVec.z;
|
|
this[3].AsFloat = aVec.w;
|
|
}
|
|
return this;
|
|
}
|
|
#endregion Vector4
|
|
|
|
#region Quaternion
|
|
public Quaternion ReadQuaternion(Quaternion aDefault)
|
|
{
|
|
if (IsObject)
|
|
return new Quaternion(this["x"].AsFloat, this["y"].AsFloat, this["z"].AsFloat, this["w"].AsFloat);
|
|
if (IsArray)
|
|
return new Quaternion(this[0].AsFloat, this[1].AsFloat, this[2].AsFloat, this[3].AsFloat);
|
|
return aDefault;
|
|
}
|
|
public Quaternion ReadQuaternion()
|
|
{
|
|
return ReadQuaternion(Quaternion.identity);
|
|
}
|
|
public JSONNode WriteQuaternion(Quaternion aRot)
|
|
{
|
|
if (IsObject)
|
|
{
|
|
Inline = true;
|
|
this["x"].AsFloat = aRot.x;
|
|
this["y"].AsFloat = aRot.y;
|
|
this["z"].AsFloat = aRot.z;
|
|
this["w"].AsFloat = aRot.w;
|
|
}
|
|
else if (IsArray)
|
|
{
|
|
Inline = true;
|
|
this[0].AsFloat = aRot.x;
|
|
this[1].AsFloat = aRot.y;
|
|
this[2].AsFloat = aRot.z;
|
|
this[3].AsFloat = aRot.w;
|
|
}
|
|
return this;
|
|
}
|
|
#endregion Quaternion
|
|
|
|
#region Rect
|
|
public Rect ReadRect(Rect aDefault)
|
|
{
|
|
if (IsObject)
|
|
return new Rect(this["x"].AsFloat, this["y"].AsFloat, this["width"].AsFloat, this["height"].AsFloat);
|
|
if (IsArray)
|
|
return new Rect(this[0].AsFloat, this[1].AsFloat, this[2].AsFloat, this[3].AsFloat);
|
|
return aDefault;
|
|
}
|
|
public Rect ReadRect()
|
|
{
|
|
return ReadRect(new Rect());
|
|
}
|
|
public JSONNode WriteRect(Rect aRect)
|
|
{
|
|
if (IsObject)
|
|
{
|
|
Inline = true;
|
|
this["x"].AsFloat = aRect.x;
|
|
this["y"].AsFloat = aRect.y;
|
|
this["width"].AsFloat = aRect.width;
|
|
this["height"].AsFloat = aRect.height;
|
|
}
|
|
else if (IsArray)
|
|
{
|
|
Inline = true;
|
|
this[0].AsFloat = aRect.x;
|
|
this[1].AsFloat = aRect.y;
|
|
this[2].AsFloat = aRect.width;
|
|
this[3].AsFloat = aRect.height;
|
|
}
|
|
return this;
|
|
}
|
|
#endregion Rect
|
|
|
|
#region RectOffset
|
|
public RectOffset ReadRectOffset(RectOffset aDefault)
|
|
{
|
|
if (this is JSONObject)
|
|
return new RectOffset(this["left"].AsInt, this["right"].AsInt, this["top"].AsInt, this["bottom"].AsInt);
|
|
if (this is JSONArray)
|
|
return new RectOffset(this[0].AsInt, this[1].AsInt, this[2].AsInt, this[3].AsInt);
|
|
return aDefault;
|
|
}
|
|
public RectOffset ReadRectOffset()
|
|
{
|
|
return ReadRectOffset(new RectOffset());
|
|
}
|
|
public JSONNode WriteRectOffset(RectOffset aRect)
|
|
{
|
|
if (IsObject)
|
|
{
|
|
Inline = true;
|
|
this["left"].AsInt = aRect.left;
|
|
this["right"].AsInt = aRect.right;
|
|
this["top"].AsInt = aRect.top;
|
|
this["bottom"].AsInt = aRect.bottom;
|
|
}
|
|
else if (IsArray)
|
|
{
|
|
Inline = true;
|
|
this[0].AsInt = aRect.left;
|
|
this[1].AsInt = aRect.right;
|
|
this[2].AsInt = aRect.top;
|
|
this[3].AsInt = aRect.bottom;
|
|
}
|
|
return this;
|
|
}
|
|
#endregion RectOffset
|
|
|
|
#region Matrix4x4
|
|
public Matrix4x4 ReadMatrix()
|
|
{
|
|
Matrix4x4 result = Matrix4x4.identity;
|
|
if (IsArray)
|
|
{
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
result[i] = this[i].AsFloat;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
public JSONNode WriteMatrix(Matrix4x4 aMatrix)
|
|
{
|
|
if (IsArray)
|
|
{
|
|
Inline = true;
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
this[i].AsFloat = aMatrix[i];
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
#endregion Matrix4x4
|
|
}
|
|
}
|