// UltEvents // Copyright 2020 Kybernetik //
using System;
using UnityEngine;
using Object = UnityEngine.Object;
namespace UltEvents
{
/// <summary>The type identifier of a <see cref="PersistentArgument"/>.</summary>
public enum PersistentArgumentType
{
/// <summary>Type not set.</summary>
None,
// Uses _Int 0 or 1 as bool.
/// <summary><see cref="bool"/>.</summary>
Bool,
// Uses _String.
/// <summary><see cref="string"/>.</summary>
String,
// Uses _Int.
/// <summary><see cref="int"/>.</summary>
Int,
// Uses _Int for the value and _String for the assembly qualified name of the type.
/// <summary>Any kind of <see cref="System.Enum"/>.</summary>
Enum,
// Uses _X.
/// <summary><see cref="float"/>.</summary>
Float,
// Uses _X and _Y.
/// <summary><see cref="UnityEngine.Vector2"/>.</summary>
Vector2,
// Uses _X, _Y, and _Z.
/// <summary><see cref="UnityEngine.Vector3"/>.</summary>
Vector3,
// Uses _X, _Y, _Z, and _W.
/// <summary><see cref="UnityEngine.Vector4"/>.</summary>
Vector4,
// Uses _X, _Y, and _Z to store the euler angles.
/// <summary><see cref="UnityEngine.Quaternion"/>.</summary>
Quaternion,
// Uses _X, _Y, _Z, and _W as RGBA.
/// <summary><see cref="UnityEngine.Color"/>.</summary>
Color,
// Uses _Int to hold the RGBA bytes.
/// <summary><see cref="UnityEngine.Color32"/>.</summary>
Color32,
// Uses _X, _Y, _Z, and _W as X, Y, Width, Height.
/// <summary><see cref="UnityEngine.Rect"/>.</summary>
Rect,
// Uses _Object for the value and _String for the assembly qualified name of the type.
/// <summary><see cref="UnityEngine.Object"/>.</summary>
Object,
// Uses _Int for the index of the target parameter.
// If the type is a simple PersistentArgumentType (not Object or Enum), it is casted to a float and stored in _X.
// Otherwise the assembly qualified name of the type is stored in _String.
/// <summary>The value of a parameter passed to the event.</summary>
Parameter,
// Uses _Int for the index of the target call.
// If the type is a simple PersistentArgumentType (not Object or Enum), it is casted to a float and stored in _X.
// Otherwise the assembly qualified name of the type is stored in _String.
/// <summary>The return value by a previous <see cref="PersistentCall"/>.</summary>
ReturnValue,
}
/// <summary>
/// Encapsulates a variable so it can be serialized for <see cref="UltEventBase"/>.
/// </summary>
[Serializable]
public sealed class PersistentArgument
{
/************************************************************************************************************************/
#region Fields
/************************************************************************************************************************/
[SerializeField]
internal PersistentArgumentType _Type;
[SerializeField]
internal int _Int;
[SerializeField]
internal string _String;
[SerializeField]
internal float _X, _Y, _Z, _W;
[SerializeField]
internal Object _Object;
/************************************************************************************************************************/
[NonSerialized]
private Type _SystemType;
[NonSerialized]
internal bool _HasSystemType;
[NonSerialized]
private object _Value;
/************************************************************************************************************************/
/// <summary>Constructs a new <see cref="PersistentArgument"/> with default values.</summary>
public PersistentArgument() { }
/// <summary>Constructs a new <see cref="PersistentArgument"/> with the specified `type`.</summary>
public PersistentArgument(Type type)
{
_Type = GetArgumentType(type, out _String, out _Int);
_SystemType = type;
_HasSystemType = true;
}
/************************************************************************************************************************/
#endregion
/************************************************************************************************************************/
#region Properties
/************************************************************************************************************************/
/// <summary>The type identifier of this argument.</summary>
public PersistentArgumentType Type
{
get { return _Type; }
internal set
{
_Int = 0;
_X = _Y = _Z = _W = 0;
_String = "";
_Object = null;
_Type = value;
_HasSystemType = false;
_Value = null;
}
}
/************************************************************************************************************************/
/// <summary>
/// The <see cref="System.Type"/> of this argument.
/// </summary>
public Type SystemType
{
get
{
#if !UNITY_EDITOR// Ignore cache in the editor since it complicates the inspector GUI code.
if (!_HasSystemType)
#endif
{
_SystemType = GetArgumentType(_Type, _X, _String);
_HasSystemType = true;
}
return _SystemType;
}
internal set
{
// Can't pass _String and _Int in directly because setting the Type clears them.
string assemblyQualifiedName;
int linkIndex;
Type = GetArgumentType(value, out assemblyQualifiedName, out linkIndex);
_String = assemblyQualifiedName;
_Int = linkIndex;
_HasSystemType = true;
_SystemType = value;
_Value = null;
}
}
/************************************************************************************************************************/
/// <summary>The <see cref="bool"/> value of this argument.</summary>
public bool Bool
{
get
{
AssertType(PersistentArgumentType.Bool);
return _Int != 0;
}
set
{
AssertType(PersistentArgumentType.Bool);
_Int = value ? 1 : 0;
_Value = null;
}
}
/************************************************************************************************************************/
/// <summary>The <see cref="string"/> value of this argument.</summary>
public string String
{
get
{
AssertType(PersistentArgumentType.String);
return _String;
}
set
{
AssertType(PersistentArgumentType.String);
_String = value ?? "";
_Value = value;
}
}
/************************************************************************************************************************/
/// <summary>The <see cref="int"/> value of this argument.</summary>
public int Int
{
get
{
AssertType(PersistentArgumentType.Int);
return _Int;
}
set
{
AssertType(PersistentArgumentType.Int);
_Int = value;
_Value = null;
}
}
/************************************************************************************************************************/
/// <summary>The <see cref="System.Enum"/> value of this argument.</summary>
public object Enum
{
get
{
AssertType(PersistentArgumentType.Enum);
return System.Enum.ToObject(SystemType, _Int);
}
set
{
AssertType(PersistentArgumentType.Enum);
_Int = (int)value;
_Value = value;
}
}
/************************************************************************************************************************/
/// <summary>The <see cref="float"/> value of this argument.</summary>
public float Float
{
get
{
AssertType(PersistentArgumentType.Float);
return _X;
}
set
{
AssertType(PersistentArgumentType.Float);
_X = value;
_Value = null;
}
}
/// <summary>The <see cref="UnityEngine.Vector2"/> value of this argument.</summary>
public Vector2 Vector2
{
get
{
AssertType(PersistentArgumentType.Vector2);
return new Vector2(_X, _Y);
}
set
{
AssertType(PersistentArgumentType.Vector2);
_X = value.x;
_Y = value.y;
_Value = null;
}
}
/// <summary>The <see cref="UnityEngine.Vector3"/> value of this argument.</summary>
public Vector3 Vector3
{
get
{
AssertType(PersistentArgumentType.Vector3);
return new Vector3(_X, _Y, _Z);
}
set
{
AssertType(PersistentArgumentType.Vector3);
_X = value.x;
_Y = value.y;
_Z = value.z;
_Value = null;
}
}
/// <summary>The <see cref="UnityEngine.Vector4"/> value of this argument.</summary>
public Vector4 Vector4
{
get
{
AssertType(PersistentArgumentType.Vector4);
return new Vector4(_X, _Y, _Z, _W);
}
set
{
AssertType(PersistentArgumentType.Vector4);
_X = value.x;
_Y = value.y;
_Z = value.z;
_W = value.w;
_Value = null;
}
}
/************************************************************************************************************************/
/// <summary>The <see cref="UnityEngine.Quaternion"/> value of this argument.</summary>
public Quaternion Quaternion
{
// It would be better to store the components of the Quaternion directly instead of the euler angles,
// but floating point imprecision when converting between them to show the euler angles in the inspector
// means that changes to any one axis will have a small effect on the other axes as well.
// This could be handled like the [Euler] attribute, but that still leads to small inaccuracies in the
// displayed values when they are deserialized so storing the euler angles directly is more user-friendly.
get
{
AssertType(PersistentArgumentType.Quaternion);
return Quaternion.Euler(_X, _Y, _Z);
}
set
{
AssertType(PersistentArgumentType.Quaternion);
var euler = value.eulerAngles;
_X = euler.x;
_Y = euler.y;
_Z = euler.z;
_Value = null;
}
}
/************************************************************************************************************************/
/// <summary>The <see cref="UnityEngine.Color"/> value of this argument.</summary>
public Color Color
{
get
{
AssertType(PersistentArgumentType.Color);
return new Color(_X, _Y, _Z, _W);
}
set
{
AssertType(PersistentArgumentType.Color);
_X = value.r;
_Y = value.g;
_Z = value.b;
_W = value.a;
_Value = null;
}
}
/// <summary>The <see cref="UnityEngine.Color32"/> value of this argument.</summary>
public Color32 Color32
{
get
{
AssertType(PersistentArgumentType.Color32);
return new Color32((byte)(_Int), (byte)(_Int >> 8), (byte)(_Int >> 16), (byte)(_Int >> 24));
}
set
{
AssertType(PersistentArgumentType.Color32);
_Int = value.r | (value.g << 8) | (value.b << 16) | (value.a << 24);
_Value = null;
}
}
/************************************************************************************************************************/
/// <summary>The <see cref="UnityEngine.Rect"/> value of this argument.</summary>
public Rect Rect
{
get
{
AssertType(PersistentArgumentType.Rect);
return new Rect(_X, _Y, _Z, _W);
}
set
{
AssertType(PersistentArgumentType.Rect);
_X = value.x;
_Y = value.y;
_Z = value.width;
_W = value.height;
_Value = null;
}
}
/************************************************************************************************************************/
/// <summary>The <see cref="UnityEngine.Object"/> value of this argument.</summary>
public Object Object
{
get
{
AssertType(PersistentArgumentType.Object);
// Unity's fake nulls cause problems if the argument is a child type of UnityEngine.Object.
// For example, when invoking a MonoBehaviour parameter a fake null Object would fail to convert to MonoBehaviour.
// So we make sure to return actual null instead of any fake value.
if (_Object == null)
return null;
else
return _Object;
}
set
{
AssertType(PersistentArgumentType.Object);
_Object = value;
_String = value != null ? value.GetType().AssemblyQualifiedName : "";
_Value = value;
}
}
/************************************************************************************************************************/
/// <summary>The value of a parameter passed into the <see cref="PersistentCall"/> (see <see cref="ParameterIndex"/>.</summary>
public object Parameter
{
get
{
AssertType(PersistentArgumentType.Parameter);
return UltEventBase.GetParameterValue(_Int);
}
}
/// <summary>The index of the parameter passed into the <see cref="PersistentCall"/>.</summary>
public int ParameterIndex
{
get
{
AssertType(PersistentArgumentType.Parameter);
return _Int;
}
set
{
AssertType(PersistentArgumentType.Parameter);
_Int = value;
_Value = null;
}
}
/************************************************************************************************************************/
/// <summary>The value returned by a previous <see cref="PersistentCall"/> (see <see cref="ReturnedValueIndex"/>.</summary>
public object ReturnedValue
{
get
{
AssertType(PersistentArgumentType.ReturnValue);
return UltEventBase.GetReturnedValue(_Int);
}
}
/// <summary>The index of the <see cref="PersistentCall"/> which returns the value for this argument.</summary>
public int ReturnedValueIndex
{
get
{
AssertType(PersistentArgumentType.ReturnValue);
return _Int;
}
set
{
AssertType(PersistentArgumentType.ReturnValue);
_Int = value;
_Value = null;
}
}
/************************************************************************************************************************/
/// <summary>The value of this argument.</summary>
public object Value
{
get
{
if (_Value == null)
{
switch (_Type)
{
case PersistentArgumentType.Bool: _Value = Bool; break;
case PersistentArgumentType.String: _Value = String; break;
case PersistentArgumentType.Int: _Value = Int; break;
case PersistentArgumentType.Enum: _Value = Enum; break;
case PersistentArgumentType.Float: _Value = Float; break;
case PersistentArgumentType.Vector2: _Value = Vector2; break;
case PersistentArgumentType.Vector3: _Value = Vector3; break;
case PersistentArgumentType.Vector4: _Value = Vector4; break;
case PersistentArgumentType.Quaternion: _Value = Quaternion; break;
case PersistentArgumentType.Color: _Value = Color; break;
case PersistentArgumentType.Color32: _Value = Color32; break;
case PersistentArgumentType.Rect: _Value = Rect; break;
case PersistentArgumentType.Object: _Value = Object; break;
// Don't cache parameters or returned values.
case PersistentArgumentType.Parameter: return Parameter;
case PersistentArgumentType.ReturnValue: return ReturnedValue;
default:
throw new InvalidOperationException(
"Invalid " + Names.PersistentArgument.Full.Type + ": " + _Type);
}
}
return _Value;
}
set
{
switch (_Type)
{
case PersistentArgumentType.Bool: Bool = (bool)value; break;
case PersistentArgumentType.String: String = (string)value; break;
case PersistentArgumentType.Int: Int = (int)value; break;
case PersistentArgumentType.Enum: Enum = value; break;
case PersistentArgumentType.Float: Float = (float)value; break;
case PersistentArgumentType.Vector2: Vector2 = (Vector2)value; break;
case PersistentArgumentType.Vector3: Vector3 = (Vector3)value; break;
case PersistentArgumentType.Vector4: Vector4 = (Vector4)value; break;
case PersistentArgumentType.Quaternion: Quaternion = (Quaternion)value; break;
case PersistentArgumentType.Color: Color = (Color)value; break;
case PersistentArgumentType.Color32: Color32 = (Color32)value; break;
case PersistentArgumentType.Rect: Rect = (Rect)value; break;
case PersistentArgumentType.Object: Object = (Object)value; break;
// Don't cache parameters or returned values.
case PersistentArgumentType.Parameter: ParameterIndex = (int)value; return;
case PersistentArgumentType.ReturnValue: ReturnedValueIndex = (int)value; return;
default:
throw new InvalidOperationException(
"Invalid " + Names.PersistentArgument.Full.Type + ": " + _Type);
}
_Value = value;
}
}
/************************************************************************************************************************/
#endregion
/************************************************************************************************************************/
#region Methods
/************************************************************************************************************************/
[System.Diagnostics.Conditional("UNITY_EDITOR")]
private void AssertType(PersistentArgumentType type)
{
if (_Type != type)
throw new InvalidOperationException(Names.PersistentArgument.Full.Type + " is " + _Type + " but should be " + type);
}
/************************************************************************************************************************/
#if UNITY_EDITOR
internal void ClearCache()
{
_Value = null;
}
#endif
/************************************************************************************************************************/
/// <summary>
/// Returns the <see cref="System.Type"/> associated with the specified <see cref="PersistentArgumentType"/>.
/// <para></para>
/// If the `type` can be inherited (such as an Enum or Object), the `assemblyQualifiedName` will be used to get the type.
/// </summary>
public static Type GetArgumentType(PersistentArgumentType type, float secondaryType, string assemblyQualifiedName)
{
switch (type)
{
case PersistentArgumentType.Bool: return typeof(bool);
case PersistentArgumentType.String: return typeof(string);
case PersistentArgumentType.Int: return typeof(int);
case PersistentArgumentType.Float: return typeof(float);
case PersistentArgumentType.Vector2: return typeof(Vector2);
case PersistentArgumentType.Vector3: return typeof(Vector3);
case PersistentArgumentType.Vector4: return typeof(Vector4);
case PersistentArgumentType.Quaternion: return typeof(Quaternion);
case PersistentArgumentType.Color: return typeof(Color);
case PersistentArgumentType.Color32: return typeof(Color32);
case PersistentArgumentType.Rect: return typeof(Rect);
case PersistentArgumentType.Enum:
case PersistentArgumentType.Object:
default:
if (!string.IsNullOrEmpty(assemblyQualifiedName))
return System.Type.GetType(assemblyQualifiedName);
else
return null;
case PersistentArgumentType.Parameter:
case PersistentArgumentType.ReturnValue:
if (!string.IsNullOrEmpty(assemblyQualifiedName))
return System.Type.GetType(assemblyQualifiedName);
else
return GetArgumentType((PersistentArgumentType)secondaryType, -1, null);
case PersistentArgumentType.None:
return null;
}
}
/// <summary>
/// Returns the <see cref="PersistentArgumentType"/> associated with the specified <see cref="System.Type"/>.
/// <para></para>
/// If the `type` can be inherited (such as an Enum or Object), the `assemblyQualifiedName` will be assigned as well (otherwise null).
/// </summary>
public static PersistentArgumentType GetArgumentType(Type type, out string assemblyQualifiedName, out int linkIndex)
{
linkIndex = 0;
assemblyQualifiedName = null;
if (type == typeof(bool)) return PersistentArgumentType.Bool;
else if (type == typeof(string)) return PersistentArgumentType.String;
else if (type == typeof(int)) return PersistentArgumentType.Int;
else if (type == typeof(float)) return PersistentArgumentType.Float;
else if (type == typeof(Vector2)) return PersistentArgumentType.Vector2;
else if (type == typeof(Vector3)) return PersistentArgumentType.Vector3;
else if (type == typeof(Vector4)) return PersistentArgumentType.Vector4;
else if (type == typeof(Quaternion)) return PersistentArgumentType.Quaternion;
else if (type == typeof(Color)) return PersistentArgumentType.Color;
else if (type == typeof(Color32)) return PersistentArgumentType.Color32;
else if (type == typeof(Rect)) return PersistentArgumentType.Rect;
else if (type.IsEnum)
{
if (System.Enum.GetUnderlyingType(type) == typeof(int))
{
assemblyQualifiedName = type.AssemblyQualifiedName;
return PersistentArgumentType.Enum;
}
else return PersistentArgumentType.None;
}
else if (type == typeof(Object) || type.IsSubclassOf(typeof(Object)))
{
assemblyQualifiedName = type.AssemblyQualifiedName;
return PersistentArgumentType.Object;
}
else
{
assemblyQualifiedName = type.AssemblyQualifiedName;
#if UNITY_EDITOR
PersistentArgumentType linkType;
if (Editor.DrawerState.Current.TryGetLinkable(type, out linkIndex, out linkType))
return linkType;
#endif
return PersistentArgumentType.ReturnValue;
}
}
/************************************************************************************************************************/
/// <summary>Creates an exact copy of this argument.</summary>
public PersistentArgument Clone()
{
#pragma warning disable IDE0017 // Simplify object initialization
var clone = new PersistentArgument();
#pragma warning restore IDE0017 // Simplify object initialization
clone._Type = _Type;
clone._Int = _Int;
clone._String = _String;
clone._X = _X;
clone._Y = _Y;
clone._Z = _Z;
clone._W = _W;
clone._Object = _Object;
clone._SystemType = _SystemType;
clone._HasSystemType = _HasSystemType;
clone._Value = _Value;
return clone;
}
/************************************************************************************************************************/
/// <summary>Returns a string which describes this argument.</summary>
public override string ToString()
{
switch (_Type)
{
case PersistentArgumentType.None:
return Names.PersistentArgument.Class + ": Type=None";
case PersistentArgumentType.Bool:
case PersistentArgumentType.String:
case PersistentArgumentType.Int:
case PersistentArgumentType.Enum:
case PersistentArgumentType.Float:
case PersistentArgumentType.Vector2:
case PersistentArgumentType.Vector3:
case PersistentArgumentType.Vector4:
case PersistentArgumentType.Quaternion:
case PersistentArgumentType.Color:
case PersistentArgumentType.Color32:
case PersistentArgumentType.Rect:
case PersistentArgumentType.Object:
return Names.PersistentArgument.Class + ": SystemType=" + SystemType + ", Value=" + Value;
case PersistentArgumentType.Parameter:
return Names.PersistentArgument.Class + ": SystemType=" + SystemType + ", Value=Parameter" + ParameterIndex;
case PersistentArgumentType.ReturnValue:
return Names.PersistentArgument.Class + ": SystemType=" + SystemType + ", Value=ReturnValue" + ReturnedValueIndex;
default:
Debug.LogWarning("Unhandled " + Names.PersistentArgumentType);
return base.ToString();
}
}
/************************************************************************************************************************/
#endregion
/************************************************************************************************************************/
}
}