diff --git a/SHADE_CSharp/src/Events/CallbackAction.cs b/SHADE_CSharp/src/Events/CallbackAction.cs
new file mode 100644
index 00000000..ec34ca5c
--- /dev/null
+++ b/SHADE_CSharp/src/Events/CallbackAction.cs
@@ -0,0 +1,812 @@
+/************************************************************************************//*!
+\file CallbackAction.cs
+\author Tng Kah Wei, kahwei.tng, 390009620
+\par email: kahwei.tng\@digipen.edu
+\date Oct 23, 2022
+\brief Contains the definition of CallbackAction and related classes.
+
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/
+using System;
+using System.Reflection;
+
+namespace SHADE
+{
+ ///
+ /// Interface for a CallbackAction that all variants inherit from.
+ ///
+ public interface ICallbackAction
+ {
+ ///
+ /// Whether or not this CallbackAction is runtime assigned. If it is, then the
+ /// TargetMethodName and TargetObject properties are invalid.
+ ///
+ bool IsRuntimeAction { get; }
+ ///
+ /// Name of the method that this CallbackAction is using.
+ ///
+ string TargetMethodName { get; }
+ ///
+ /// Object which the specified target method is called on.
+ ///
+ Object TargetObject { get; }
+ }
+
+ ///
+ /// Represents a function call that can be serialised and put togetheer with scripts.
+ /// This variant accepts functions with 1 parameter.
+ ///
+ public class CallbackAction : ICallbackAction
+ {
+ #region Properties ------------------------------------------------------------
+ ///
+ public Object TargetObject { get; private set; }
+ ///
+ public string TargetMethodName => targetMethod == null ? "" : targetMethod.Name;
+ ///
+ public bool IsRuntimeAction => targetAction != null;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private MethodInfo targetMethod;
+ private Action targetAction;
+ private Object[] parameters;
+ #endregion
+
+ #region Constructors ------------------------------------------------------------
+ ///
+ /// Constructs a CallbackAction that represents a call to the specified method on the
+ /// specified target.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ ///
+ /// Thrown if a method that is not compatible with the target is specified. The method's
+ /// source type must match the target's type.
+ ///
+ public CallbackAction(Object target, MethodInfo method)
+ {
+ // Error Checks
+ if (method.DeclaringType != target.GetType())
+ throw new ArgumentException("[CallbackAction] Attempted register an action using an incompatible target object and method.");
+
+ // No errors, assign
+ TargetObject = target;
+ targetMethod = method;
+
+ // Create storage for parameters for calling
+ parameters = new Object[1];
+ }
+ ///
+ /// Constructs a Callback action based on an action.
+ ///
+ ///
+ public CallbackAction(Action action)
+ {
+ targetAction = action;
+ }
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ /// Invokes the CallbackAction's stored method/action with the specified parameters.
+ ///
+ public void Invoke(T1 t1)
+ {
+ if (targetAction != null)
+ {
+ targetAction.Invoke(t1);
+ }
+ else if (TargetObject != null && targetMethod != null)
+ {
+ parameters[0] = t1;
+ _ = targetMethod.Invoke(TargetObject, parameters);
+ }
+ }
+ #endregion
+ }
+ ///
+ /// Represents a function call that can be serialised and put togetheer with scripts.
+ /// This variant accepts functions with 2 parameters.
+ ///
+ public class CallbackAction : ICallbackAction
+ {
+ #region Properties ------------------------------------------------------------
+ ///
+ public Object TargetObject { get; private set; }
+ ///
+ public string TargetMethodName => targetMethod == null ? "" : targetMethod.Name;
+ ///
+ public bool IsRuntimeAction => targetAction != null;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private MethodInfo targetMethod;
+ private Action targetAction;
+ private Object[] parameters;
+ #endregion
+
+ #region Constructors ------------------------------------------------------------
+ ///
+ /// Constructs a CallbackAction that represents a call to the specified method on the
+ /// specified target.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ ///
+ /// Thrown if a method that is not compatible with the target is specified. The method's
+ /// source type must match the target's type.
+ ///
+ public CallbackAction(Object target, MethodInfo method)
+ {
+ // Error Checks
+ if (method.DeclaringType != target.GetType())
+ throw new ArgumentException("[CallbackAction] Attempted register an action using an incompatible target object and method.");
+
+ // No errors, assign
+ TargetObject = target;
+ targetMethod = method;
+
+ // Create storage for parameters for calling
+ parameters = new Object[1];
+ }
+ ///
+ /// Constructs a Callback action based on an action.
+ ///
+ ///
+ public CallbackAction(Action action)
+ {
+ targetAction = action;
+ }
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ /// Invokes the CallbackAction's stored method/action with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2)
+ {
+ if (targetAction != null)
+ {
+ targetAction.Invoke(t1, t2);
+ }
+ else if (TargetObject != null && targetMethod != null)
+ {
+ parameters[0] = t1;
+ parameters[1] = t2;
+ _ = targetMethod.Invoke(TargetObject, parameters);
+ }
+ }
+ #endregion
+ }
+ ///
+ /// Represents a function call that can be serialised and put togetheer with scripts.
+ /// This variant accepts functions with 3 parameters.
+ ///
+ public class CallbackAction : ICallbackAction
+ {
+ #region Properties ------------------------------------------------------------
+ ///
+ public Object TargetObject { get; private set; }
+ ///
+ public string TargetMethodName => targetMethod == null ? "" : targetMethod.Name;
+ ///
+ public bool IsRuntimeAction => targetAction != null;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private MethodInfo targetMethod;
+ private Action targetAction;
+ private Object[] parameters;
+ #endregion
+
+ #region Constructors ------------------------------------------------------------
+ ///
+ /// Constructs a CallbackAction that represents a call to the specified method on the
+ /// specified target.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ ///
+ /// Thrown if a method that is not compatible with the target is specified. The method's
+ /// source type must match the target's type.
+ ///
+ public CallbackAction(Object target, MethodInfo method)
+ {
+ // Error Checks
+ if (method.DeclaringType != target.GetType())
+ throw new ArgumentException("[CallbackAction] Attempted register an action using an incompatible target object and method.");
+
+ // No errors, assign
+ TargetObject = target;
+ targetMethod = method;
+
+ // Create storage for parameters for calling
+ parameters = new Object[1];
+ }
+ ///
+ /// Constructs a Callback action based on an action.
+ ///
+ ///
+ public CallbackAction(Action action)
+ {
+ targetAction = action;
+ }
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ /// Invokes the CallbackAction's stored method/action with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3)
+ {
+ if (targetAction != null)
+ {
+ targetAction.Invoke(t1, t2, t3);
+ }
+ else if (TargetObject != null && targetMethod != null)
+ {
+ parameters[0] = t1;
+ parameters[1] = t2;
+ parameters[2] = t3;
+ _ = targetMethod.Invoke(TargetObject, parameters);
+ }
+ }
+ #endregion
+ }
+ ///
+ /// Represents a function call that can be serialised and put togetheer with scripts.
+ /// This variant accepts functions with 4 parameters.
+ ///
+ public class CallbackAction : ICallbackAction
+ {
+ #region Properties ------------------------------------------------------------
+ ///
+ public Object TargetObject { get; private set; }
+ ///
+ public string TargetMethodName => targetMethod == null ? "" : targetMethod.Name;
+ ///
+ public bool IsRuntimeAction => targetAction != null;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private MethodInfo targetMethod;
+ private Action targetAction;
+ private Object[] parameters;
+ #endregion
+
+ #region Constructors ------------------------------------------------------------
+ ///
+ /// Constructs a CallbackAction that represents a call to the specified method on the
+ /// specified target.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ ///
+ /// Thrown if a method that is not compatible with the target is specified. The method's
+ /// source type must match the target's type.
+ ///
+ public CallbackAction(Object target, MethodInfo method)
+ {
+ // Error Checks
+ if (method.DeclaringType != target.GetType())
+ throw new ArgumentException("[CallbackAction] Attempted register an action using an incompatible target object and method.");
+
+ // No errors, assign
+ TargetObject = target;
+ targetMethod = method;
+
+ // Create storage for parameters for calling
+ parameters = new Object[1];
+ }
+ ///
+ /// Constructs a Callback action based on an action.
+ ///
+ ///
+ public CallbackAction(Action action)
+ {
+ targetAction = action;
+ }
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ /// Invokes the CallbackAction's stored method/action with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4)
+ {
+ if (targetAction != null)
+ {
+ targetAction.Invoke(t1, t2, t3, t4);
+ }
+ else if (TargetObject != null && targetMethod != null)
+ {
+ parameters[0] = t1;
+ parameters[1] = t2;
+ parameters[2] = t3;
+ parameters[3] = t4;
+ _ = targetMethod.Invoke(TargetObject, parameters);
+ }
+ }
+ #endregion
+ }
+ ///
+ /// Represents a function call that can be serialised and put togetheer with scripts.
+ /// This variant accepts functions with 5 parameters.
+ ///
+ public class CallbackAction : ICallbackAction
+ {
+ #region Properties ------------------------------------------------------------
+ ///
+ public Object TargetObject { get; private set; }
+ ///
+ public string TargetMethodName => targetMethod == null ? "" : targetMethod.Name;
+ ///
+ public bool IsRuntimeAction => targetAction != null;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private MethodInfo targetMethod;
+ private Action targetAction;
+ private Object[] parameters;
+ #endregion
+
+ #region Constructors ------------------------------------------------------------
+ ///
+ /// Constructs a CallbackAction that represents a call to the specified method on the
+ /// specified target.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ ///
+ /// Thrown if a method that is not compatible with the target is specified. The method's
+ /// source type must match the target's type.
+ ///
+ public CallbackAction(Object target, MethodInfo method)
+ {
+ // Error Checks
+ if (method.DeclaringType != target.GetType())
+ throw new ArgumentException("[CallbackAction] Attempted register an action using an incompatible target object and method.");
+
+ // No errors, assign
+ TargetObject = target;
+ targetMethod = method;
+
+ // Create storage for parameters for calling
+ parameters = new Object[1];
+ }
+ ///
+ /// Constructs a Callback action based on an action.
+ ///
+ ///
+ public CallbackAction(Action action)
+ {
+ targetAction = action;
+ }
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ /// Invokes the CallbackAction's stored method/action with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
+ {
+ if (targetAction != null)
+ {
+ targetAction.Invoke(t1, t2, t3, t4, t5);
+ }
+ else if (TargetObject != null && targetMethod != null)
+ {
+ parameters[0] = t1;
+ parameters[1] = t2;
+ parameters[2] = t3;
+ parameters[3] = t4;
+ parameters[4] = t5;
+ _ = targetMethod.Invoke(TargetObject, parameters);
+ }
+ }
+ #endregion
+ }
+ ///
+ /// Represents a function call that can be serialised and put togetheer with scripts.
+ /// This variant accepts functions with 6 parameters.
+ ///
+ public class CallbackAction : ICallbackAction
+ {
+ #region Properties ------------------------------------------------------------
+ ///
+ public Object TargetObject { get; private set; }
+ ///
+ public string TargetMethodName => targetMethod == null ? "" : targetMethod.Name;
+ ///
+ public bool IsRuntimeAction => targetAction != null;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private MethodInfo targetMethod;
+ private Action targetAction;
+ private Object[] parameters;
+ #endregion
+
+ #region Constructors ------------------------------------------------------------
+ ///
+ /// Constructs a CallbackAction that represents a call to the specified method on the
+ /// specified target.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ ///
+ /// Thrown if a method that is not compatible with the target is specified. The method's
+ /// source type must match the target's type.
+ ///
+ public CallbackAction(Object target, MethodInfo method)
+ {
+ // Error Checks
+ if (method.DeclaringType != target.GetType())
+ throw new ArgumentException("[CallbackAction] Attempted register an action using an incompatible target object and method.");
+
+ // No errors, assign
+ TargetObject = target;
+ targetMethod = method;
+
+ // Create storage for parameters for calling
+ parameters = new Object[1];
+ }
+ ///
+ /// Constructs a Callback action based on an action.
+ ///
+ ///
+ public CallbackAction(Action action)
+ {
+ targetAction = action;
+ }
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ /// Invokes the CallbackAction's stored method/action with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
+ {
+ if (targetAction != null)
+ {
+ targetAction.Invoke(t1, t2, t3, t4, t5, t6);
+ }
+ else if (TargetObject != null && targetMethod != null)
+ {
+ parameters[0] = t1;
+ parameters[1] = t2;
+ parameters[2] = t3;
+ parameters[3] = t4;
+ parameters[4] = t5;
+ parameters[5] = t6;
+ _ = targetMethod.Invoke(TargetObject, parameters);
+ }
+ }
+ #endregion
+ }
+ ///
+ /// Represents a function call that can be serialised and put togetheer with scripts.
+ /// This variant accepts functions with 7 parameters.
+ ///
+ public class CallbackAction : ICallbackAction
+ {
+ #region Properties ------------------------------------------------------------
+ ///
+ public Object TargetObject { get; private set; }
+ ///
+ public string TargetMethodName => targetMethod == null ? "" : targetMethod.Name;
+ ///
+ public bool IsRuntimeAction => targetAction != null;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private MethodInfo targetMethod;
+ private Action targetAction;
+ private Object[] parameters;
+ #endregion
+
+ #region Constructors ------------------------------------------------------------
+ ///
+ /// Constructs a CallbackAction that represents a call to the specified method on the
+ /// specified target.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ ///
+ /// Thrown if a method that is not compatible with the target is specified. The method's
+ /// source type must match the target's type.
+ ///
+ public CallbackAction(Object target, MethodInfo method)
+ {
+ // Error Checks
+ if (method.DeclaringType != target.GetType())
+ throw new ArgumentException("[CallbackAction] Attempted register an action using an incompatible target object and method.");
+
+ // No errors, assign
+ TargetObject = target;
+ targetMethod = method;
+
+ // Create storage for parameters for calling
+ parameters = new Object[1];
+ }
+ ///
+ /// Constructs a Callback action based on an action.
+ ///
+ ///
+ public CallbackAction(Action action)
+ {
+ targetAction = action;
+ }
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ /// Invokes the CallbackAction's stored method/action with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
+ {
+ if (targetAction != null)
+ {
+ targetAction.Invoke(t1, t2, t3, t4, t5, t6, t7);
+ }
+ else if (TargetObject != null && targetMethod != null)
+ {
+ parameters[0] = t1;
+ parameters[1] = t2;
+ parameters[2] = t3;
+ parameters[3] = t4;
+ parameters[4] = t5;
+ parameters[5] = t6;
+ parameters[6] = t7;
+ _ = targetMethod.Invoke(TargetObject, parameters);
+ }
+ }
+ #endregion
+ }
+ ///
+ /// Represents a function call that can be serialised and put togetheer with scripts.
+ /// This variant accepts functions with 8 parameters.
+ ///
+ public class CallbackAction : ICallbackAction
+ {
+ #region Properties ------------------------------------------------------------
+ ///
+ public Object TargetObject { get; private set; }
+ ///
+ public string TargetMethodName => targetMethod == null ? "" : targetMethod.Name;
+ ///
+ public bool IsRuntimeAction => targetAction != null;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private MethodInfo targetMethod;
+ private Action targetAction;
+ private Object[] parameters;
+ #endregion
+
+ #region Constructors ------------------------------------------------------------
+ ///
+ /// Constructs a CallbackAction that represents a call to the specified method on the
+ /// specified target.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ ///
+ /// Thrown if a method that is not compatible with the target is specified. The method's
+ /// source type must match the target's type.
+ ///
+ public CallbackAction(Object target, MethodInfo method)
+ {
+ // Error Checks
+ if (method.DeclaringType != target.GetType())
+ throw new ArgumentException("[CallbackAction] Attempted register an action using an incompatible target object and method.");
+
+ // No errors, assign
+ TargetObject = target;
+ targetMethod = method;
+
+ // Create storage for parameters for calling
+ parameters = new Object[1];
+ }
+ ///
+ /// Constructs a Callback action based on an action.
+ ///
+ ///
+ public CallbackAction(Action action)
+ {
+ targetAction = action;
+ }
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ /// Invokes the CallbackAction's stored method/action with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
+ {
+ if (targetAction != null)
+ {
+ targetAction.Invoke(t1, t2, t3, t4, t5, t6, t7, t8);
+ }
+ else if (TargetObject != null && targetMethod != null)
+ {
+ parameters[0] = t1;
+ parameters[1] = t2;
+ parameters[2] = t3;
+ parameters[3] = t4;
+ parameters[4] = t5;
+ parameters[5] = t6;
+ parameters[6] = t7;
+ parameters[7] = t8;
+ _ = targetMethod.Invoke(TargetObject, parameters);
+ }
+ }
+ #endregion
+ }
+ ///
+ /// Represents a function call that can be serialised and put togetheer with scripts.
+ /// This variant accepts functions with 9 parameters.
+ ///
+ public class CallbackAction : ICallbackAction
+ {
+ #region Properties ------------------------------------------------------------
+ ///
+ public Object TargetObject { get; private set; }
+ ///
+ public string TargetMethodName => targetMethod == null ? "" : targetMethod.Name;
+ ///
+ public bool IsRuntimeAction => targetAction != null;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private MethodInfo targetMethod;
+ private Action targetAction;
+ private Object[] parameters;
+ #endregion
+
+ #region Constructors ------------------------------------------------------------
+ ///
+ /// Constructs a CallbackAction that represents a call to the specified method on the
+ /// specified target.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ ///
+ /// Thrown if a method that is not compatible with the target is specified. The method's
+ /// source type must match the target's type.
+ ///
+ public CallbackAction(Object target, MethodInfo method)
+ {
+ // Error Checks
+ if (method.DeclaringType != target.GetType())
+ throw new ArgumentException("[CallbackAction] Attempted register an action using an incompatible target object and method.");
+
+ // No errors, assign
+ TargetObject = target;
+ targetMethod = method;
+
+ // Create storage for parameters for calling
+ parameters = new Object[1];
+ }
+ ///
+ /// Constructs a Callback action based on an action.
+ ///
+ ///
+ public CallbackAction(Action action)
+ {
+ targetAction = action;
+ }
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ /// Invokes the CallbackAction's stored method/action with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
+ {
+ if (targetAction != null)
+ {
+ targetAction.Invoke(t1, t2, t3, t4, t5, t6, t7, t8, t9);
+ }
+ else if (TargetObject != null && targetMethod != null)
+ {
+ parameters[0] = t1;
+ parameters[1] = t2;
+ parameters[2] = t3;
+ parameters[3] = t4;
+ parameters[4] = t5;
+ parameters[5] = t6;
+ parameters[6] = t7;
+ parameters[7] = t8;
+ parameters[8] = t9;
+ _ = targetMethod.Invoke(TargetObject, parameters);
+ }
+ }
+ #endregion
+ }
+ ///
+ /// Represents a function call that can be serialised and put togetheer with scripts.
+ /// This variant accepts functions with 10 parameters.
+ ///
+ public class CallbackAction : ICallbackAction
+ {
+ #region Properties ------------------------------------------------------------
+ ///
+ public Object TargetObject { get; private set; }
+ ///
+ public string TargetMethodName => targetMethod == null ? "" : targetMethod.Name;
+ ///
+ public bool IsRuntimeAction => targetAction != null;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private MethodInfo targetMethod;
+ private Action targetAction;
+ private Object[] parameters;
+ #endregion
+
+ #region Constructors ------------------------------------------------------------
+ ///
+ /// Constructs a CallbackAction that represents a call to the specified method on the
+ /// specified target.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ ///
+ /// Thrown if a method that is not compatible with the target is specified. The method's
+ /// source type must match the target's type.
+ ///
+ public CallbackAction(Object target, MethodInfo method)
+ {
+ // Error Checks
+ if (method.DeclaringType != target.GetType())
+ throw new ArgumentException("[CallbackAction] Attempted register an action using an incompatible target object and method.");
+
+ // No errors, assign
+ TargetObject = target;
+ targetMethod = method;
+
+ // Create storage for parameters for calling
+ parameters = new Object[1];
+ }
+ ///
+ /// Constructs a Callback action based on an action.
+ ///
+ ///
+ public CallbackAction(Action action)
+ {
+ targetAction = action;
+ }
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ /// Invokes the CallbackAction's stored method/action with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10)
+ {
+ if (targetAction != null)
+ {
+ targetAction.Invoke(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
+ }
+ else if (TargetObject != null && targetMethod != null)
+ {
+ parameters[0] = t1;
+ parameters[1] = t2;
+ parameters[2] = t3;
+ parameters[3] = t4;
+ parameters[4] = t5;
+ parameters[5] = t6;
+ parameters[6] = t7;
+ parameters[7] = t8;
+ parameters[8] = t9;
+ parameters[9] = t10;
+ _ = targetMethod.Invoke(TargetObject, parameters);
+ }
+ }
+ #endregion
+ }
+}
diff --git a/SHADE_CSharp/src/Events/CallbackAction.tt b/SHADE_CSharp/src/Events/CallbackAction.tt
new file mode 100644
index 00000000..0b1efb83
--- /dev/null
+++ b/SHADE_CSharp/src/Events/CallbackAction.tt
@@ -0,0 +1,128 @@
+<#
+/************************************************************************************//*!
+\file CallbackAction.tt
+\author Tng Kah Wei, kahwei.tng, 390009620
+\par email: kahwei.tng\@digipen.edu
+\date Oct 23, 2022
+\brief Contains the T4 template for the definition of CallbackAction and
+ related classes.
+
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/#>
+<#@ template hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+<# var max = 10; #>
+/************************************************************************************//*!
+\file CallbackAction.cs
+\author Tng Kah Wei, kahwei.tng, 390009620
+\par email: kahwei.tng\@digipen.edu
+\date Oct 23, 2022
+\brief Contains the definition of CallbackAction and related classes.
+
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/
+using System;
+using System.Reflection;
+
+namespace SHADE
+{
+ ///
+ /// Interface for a CallbackAction that all variants inherit from.
+ ///
+ public interface ICallbackAction
+ {
+ ///
+ /// Whether or not this CallbackAction is runtime assigned. If it is, then the
+ /// TargetMethodName and TargetObject properties are invalid.
+ ///
+ bool IsRuntimeAction { get; }
+ ///
+ /// Name of the method that this CallbackAction is using.
+ ///
+ string TargetMethodName { get; }
+ ///
+ /// Object which the specified target method is called on.
+ ///
+ Object TargetObject { get; }
+ }
+
+<# for (int i = 1; i <= max; ++i) { #>
+ ///
+ /// Represents a function call that can be serialised and put togetheer with scripts.
+ /// This variant accepts functions with <#=i#> parameter<# if (i > 1) {#>s<#} #>.
+ ///
+ public class CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> : ICallbackAction
+ {
+ #region Properties ------------------------------------------------------------
+ ///
+ public Object TargetObject { get; private set; }
+ ///
+ public string TargetMethodName => targetMethod == null ? "" : targetMethod.Name;
+ ///
+ public bool IsRuntimeAction => targetAction != null;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private MethodInfo targetMethod;
+ private Action<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> targetAction;
+ private Object[] parameters;
+ #endregion
+
+ #region Constructors ------------------------------------------------------------
+ ///
+ /// Constructs a CallbackAction that represents a call to the specified method on the
+ /// specified target.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ ///
+ /// Thrown if a method that is not compatible with the target is specified. The method's
+ /// source type must match the target's type.
+ ///
+ public CallbackAction(Object target, MethodInfo method)
+ {
+ // Error Checks
+ if (method.DeclaringType != target.GetType())
+ throw new ArgumentException("[CallbackAction] Attempted register an action using an incompatible target object and method.");
+
+ // No errors, assign
+ TargetObject = target;
+ targetMethod = method;
+
+ // Create storage for parameters for calling
+ parameters = new Object[1];
+ }
+ ///
+ /// Constructs a Callback action based on an action.
+ ///
+ ///
+ public CallbackAction(Action<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> action)
+ {
+ targetAction = action;
+ }
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ /// Invokes the CallbackAction's stored method/action with the specified parameters.
+ ///
+ public void Invoke(<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#> t<#=t#><# if (t != i) { #>, <# } #><# } #>)
+ {
+ if (targetAction != null)
+ {
+ targetAction.Invoke(<# for (int t = 1; t < i + 1; ++t) { #>t<#=t#><# if (t != i) { #>, <# } #><# } #>);
+ }
+ else if (TargetObject != null && targetMethod != null)
+ {
+ <# for (int t = 0; t < i; ++t) {#>parameters[<#=t#>] = t<#=t+1#>;
+ <# } #>_ = targetMethod.Invoke(TargetObject, parameters);
+ }
+ }
+ #endregion
+ }
+<# } #>
+}
diff --git a/SHADE_CSharp/src/Events/CallbackEvent.cs b/SHADE_CSharp/src/Events/CallbackEvent.cs
new file mode 100644
index 00000000..7b30a8ec
--- /dev/null
+++ b/SHADE_CSharp/src/Events/CallbackEvent.cs
@@ -0,0 +1,854 @@
+/************************************************************************************//*!
+\file CallbackEvent.cs
+\author Tng Kah Wei, kahwei.tng, 390009620
+\par email: kahwei.tng\@digipen.edu
+\date Oct 23, 2022
+\brief Contains the definition of CallbackEvent and related classes.
+
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using System.Reflection.Metadata.Ecma335;
+
+namespace SHADE
+{
+ ///
+ /// Interface for a CallbackEvent that all variants inherit from.
+ ///
+ public interface ICallbackEvent
+ {
+ ///
+ /// Registers an ICallbackAction with the event such that it will be called in
+ /// future
+ ///
+ /// ICallbackAction to register with.
+ void RegisterAction(ICallbackAction action);
+ ///
+ /// Deregisters an ICallbackAction that was previously added. This should
+ /// only emit a warning if an action that was not previous added was
+ /// provided.
+ ///
+ /// ICallbackAction to remove.
+ void DeregisterAction(ICallbackAction action);
+ ///
+ /// Iterable set of ICallbackActions that were registered to this event.
+ ///
+ IEnumerable Actions { get; }
+ }
+
+ ///
+ /// A container of CallbackActions that is correlated to a specific scenario as
+ /// specified by the user of this class.
+ /// This variant accepts CallbackEvents with 1 generic parameter.
+ ///
+ public class CallbackEvent : ICallbackEvent
+ {
+ #region Properties --------------------------------------------------------------
+ ///
+ public IEnumerable Actions => actions;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private List actions = new List();
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ public void RegisterAction(ICallbackAction action)
+ {
+ // Check if valid action
+ if (action.GetType() != typeof(CallbackAction))
+ {
+ Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+ return;
+ }
+
+ actions.Add(action);
+ }
+ ///
+ /// Adds a CallbackAction into the event.
+ ///
+ /// CallbackAction to add.
+ public void RegisterAction(CallbackAction action)
+ {
+ actions.Add(action);
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// System.Action to add as a CallbackAction.
+ public void RegisterAction(Action action)
+ {
+ actions.Add(new CallbackAction(action));
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ public void RegisterAction(Object target, MethodInfo method)
+ {
+ actions.Add(new CallbackAction(target, method));
+ }
+ ///
+ public void DeregisterAction(ICallbackAction action)
+ {
+ if (!actions.Remove(action))
+ {
+ Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+ }
+ }
+ ///
+ /// Invokes all stored CallbackActions with the specified parameters.
+ ///
+ public void Invoke(T1 t1)
+ {
+ foreach (CallbackAction action in actions)
+ {
+ try
+ {
+ action.Invoke(t1);
+ }
+ catch (Exception e)
+ {
+ Debug.LogException(e, this);
+ }
+ }
+ }
+ #endregion
+ }
+ ///
+ /// A container of CallbackActions that is correlated to a specific scenario as
+ /// specified by the user of this class.
+ /// This variant accepts CallbackEvents with 1 generic parameter.
+ ///
+ public class CallbackEvent : ICallbackEvent
+ {
+ #region Properties --------------------------------------------------------------
+ ///
+ public IEnumerable Actions => actions;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private List actions = new List();
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ public void RegisterAction(ICallbackAction action)
+ {
+ // Check if valid action
+ if (action.GetType() != typeof(CallbackAction))
+ {
+ Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+ return;
+ }
+
+ actions.Add(action);
+ }
+ ///
+ /// Adds a CallbackAction into the event.
+ ///
+ /// CallbackAction to add.
+ public void RegisterAction(CallbackAction action)
+ {
+ actions.Add(action);
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// System.Action to add as a CallbackAction.
+ public void RegisterAction(Action action)
+ {
+ actions.Add(new CallbackAction(action));
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ public void RegisterAction(Object target, MethodInfo method)
+ {
+ actions.Add(new CallbackAction(target, method));
+ }
+ ///
+ public void DeregisterAction(ICallbackAction action)
+ {
+ if (!actions.Remove(action))
+ {
+ Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+ }
+ }
+ ///
+ /// Invokes all stored CallbackActions with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2)
+ {
+ foreach (CallbackAction action in actions)
+ {
+ try
+ {
+ action.Invoke(t1, t2);
+ }
+ catch (Exception e)
+ {
+ Debug.LogException(e, this);
+ }
+ }
+ }
+ #endregion
+ }
+ ///
+ /// A container of CallbackActions that is correlated to a specific scenario as
+ /// specified by the user of this class.
+ /// This variant accepts CallbackEvents with 1 generic parameter.
+ ///
+ public class CallbackEvent : ICallbackEvent
+ {
+ #region Properties --------------------------------------------------------------
+ ///
+ public IEnumerable Actions => actions;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private List actions = new List();
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ public void RegisterAction(ICallbackAction action)
+ {
+ // Check if valid action
+ if (action.GetType() != typeof(CallbackAction))
+ {
+ Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+ return;
+ }
+
+ actions.Add(action);
+ }
+ ///
+ /// Adds a CallbackAction into the event.
+ ///
+ /// CallbackAction to add.
+ public void RegisterAction(CallbackAction action)
+ {
+ actions.Add(action);
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// System.Action to add as a CallbackAction.
+ public void RegisterAction(Action action)
+ {
+ actions.Add(new CallbackAction(action));
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ public void RegisterAction(Object target, MethodInfo method)
+ {
+ actions.Add(new CallbackAction(target, method));
+ }
+ ///
+ public void DeregisterAction(ICallbackAction action)
+ {
+ if (!actions.Remove(action))
+ {
+ Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+ }
+ }
+ ///
+ /// Invokes all stored CallbackActions with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3)
+ {
+ foreach (CallbackAction action in actions)
+ {
+ try
+ {
+ action.Invoke(t1, t2, t3);
+ }
+ catch (Exception e)
+ {
+ Debug.LogException(e, this);
+ }
+ }
+ }
+ #endregion
+ }
+ ///
+ /// A container of CallbackActions that is correlated to a specific scenario as
+ /// specified by the user of this class.
+ /// This variant accepts CallbackEvents with 1 generic parameter.
+ ///
+ public class CallbackEvent : ICallbackEvent
+ {
+ #region Properties --------------------------------------------------------------
+ ///
+ public IEnumerable Actions => actions;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private List actions = new List();
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ public void RegisterAction(ICallbackAction action)
+ {
+ // Check if valid action
+ if (action.GetType() != typeof(CallbackAction))
+ {
+ Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+ return;
+ }
+
+ actions.Add(action);
+ }
+ ///
+ /// Adds a CallbackAction into the event.
+ ///
+ /// CallbackAction to add.
+ public void RegisterAction(CallbackAction action)
+ {
+ actions.Add(action);
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// System.Action to add as a CallbackAction.
+ public void RegisterAction(Action action)
+ {
+ actions.Add(new CallbackAction(action));
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ public void RegisterAction(Object target, MethodInfo method)
+ {
+ actions.Add(new CallbackAction(target, method));
+ }
+ ///
+ public void DeregisterAction(ICallbackAction action)
+ {
+ if (!actions.Remove(action))
+ {
+ Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+ }
+ }
+ ///
+ /// Invokes all stored CallbackActions with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4)
+ {
+ foreach (CallbackAction action in actions)
+ {
+ try
+ {
+ action.Invoke(t1, t2, t3, t4);
+ }
+ catch (Exception e)
+ {
+ Debug.LogException(e, this);
+ }
+ }
+ }
+ #endregion
+ }
+ ///
+ /// A container of CallbackActions that is correlated to a specific scenario as
+ /// specified by the user of this class.
+ /// This variant accepts CallbackEvents with 1 generic parameter.
+ ///
+ public class CallbackEvent : ICallbackEvent
+ {
+ #region Properties --------------------------------------------------------------
+ ///
+ public IEnumerable Actions => actions;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private List actions = new List();
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ public void RegisterAction(ICallbackAction action)
+ {
+ // Check if valid action
+ if (action.GetType() != typeof(CallbackAction))
+ {
+ Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+ return;
+ }
+
+ actions.Add(action);
+ }
+ ///
+ /// Adds a CallbackAction into the event.
+ ///
+ /// CallbackAction to add.
+ public void RegisterAction(CallbackAction action)
+ {
+ actions.Add(action);
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// System.Action to add as a CallbackAction.
+ public void RegisterAction(Action action)
+ {
+ actions.Add(new CallbackAction(action));
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ public void RegisterAction(Object target, MethodInfo method)
+ {
+ actions.Add(new CallbackAction(target, method));
+ }
+ ///
+ public void DeregisterAction(ICallbackAction action)
+ {
+ if (!actions.Remove(action))
+ {
+ Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+ }
+ }
+ ///
+ /// Invokes all stored CallbackActions with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
+ {
+ foreach (CallbackAction action in actions)
+ {
+ try
+ {
+ action.Invoke(t1, t2, t3, t4, t5);
+ }
+ catch (Exception e)
+ {
+ Debug.LogException(e, this);
+ }
+ }
+ }
+ #endregion
+ }
+ ///
+ /// A container of CallbackActions that is correlated to a specific scenario as
+ /// specified by the user of this class.
+ /// This variant accepts CallbackEvents with 1 generic parameter.
+ ///
+ public class CallbackEvent : ICallbackEvent
+ {
+ #region Properties --------------------------------------------------------------
+ ///
+ public IEnumerable Actions => actions;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private List actions = new List();
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ public void RegisterAction(ICallbackAction action)
+ {
+ // Check if valid action
+ if (action.GetType() != typeof(CallbackAction))
+ {
+ Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+ return;
+ }
+
+ actions.Add(action);
+ }
+ ///
+ /// Adds a CallbackAction into the event.
+ ///
+ /// CallbackAction to add.
+ public void RegisterAction(CallbackAction action)
+ {
+ actions.Add(action);
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// System.Action to add as a CallbackAction.
+ public void RegisterAction(Action action)
+ {
+ actions.Add(new CallbackAction(action));
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ public void RegisterAction(Object target, MethodInfo method)
+ {
+ actions.Add(new CallbackAction(target, method));
+ }
+ ///
+ public void DeregisterAction(ICallbackAction action)
+ {
+ if (!actions.Remove(action))
+ {
+ Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+ }
+ }
+ ///
+ /// Invokes all stored CallbackActions with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
+ {
+ foreach (CallbackAction action in actions)
+ {
+ try
+ {
+ action.Invoke(t1, t2, t3, t4, t5, t6);
+ }
+ catch (Exception e)
+ {
+ Debug.LogException(e, this);
+ }
+ }
+ }
+ #endregion
+ }
+ ///
+ /// A container of CallbackActions that is correlated to a specific scenario as
+ /// specified by the user of this class.
+ /// This variant accepts CallbackEvents with 1 generic parameter.
+ ///
+ public class CallbackEvent : ICallbackEvent
+ {
+ #region Properties --------------------------------------------------------------
+ ///
+ public IEnumerable Actions => actions;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private List actions = new List();
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ public void RegisterAction(ICallbackAction action)
+ {
+ // Check if valid action
+ if (action.GetType() != typeof(CallbackAction))
+ {
+ Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+ return;
+ }
+
+ actions.Add(action);
+ }
+ ///
+ /// Adds a CallbackAction into the event.
+ ///
+ /// CallbackAction to add.
+ public void RegisterAction(CallbackAction action)
+ {
+ actions.Add(action);
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// System.Action to add as a CallbackAction.
+ public void RegisterAction(Action action)
+ {
+ actions.Add(new CallbackAction(action));
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ public void RegisterAction(Object target, MethodInfo method)
+ {
+ actions.Add(new CallbackAction(target, method));
+ }
+ ///
+ public void DeregisterAction(ICallbackAction action)
+ {
+ if (!actions.Remove(action))
+ {
+ Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+ }
+ }
+ ///
+ /// Invokes all stored CallbackActions with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
+ {
+ foreach (CallbackAction action in actions)
+ {
+ try
+ {
+ action.Invoke(t1, t2, t3, t4, t5, t6, t7);
+ }
+ catch (Exception e)
+ {
+ Debug.LogException(e, this);
+ }
+ }
+ }
+ #endregion
+ }
+ ///
+ /// A container of CallbackActions that is correlated to a specific scenario as
+ /// specified by the user of this class.
+ /// This variant accepts CallbackEvents with 1 generic parameter.
+ ///
+ public class CallbackEvent : ICallbackEvent
+ {
+ #region Properties --------------------------------------------------------------
+ ///
+ public IEnumerable Actions => actions;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private List actions = new List();
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ public void RegisterAction(ICallbackAction action)
+ {
+ // Check if valid action
+ if (action.GetType() != typeof(CallbackAction))
+ {
+ Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+ return;
+ }
+
+ actions.Add(action);
+ }
+ ///
+ /// Adds a CallbackAction into the event.
+ ///
+ /// CallbackAction to add.
+ public void RegisterAction(CallbackAction action)
+ {
+ actions.Add(action);
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// System.Action to add as a CallbackAction.
+ public void RegisterAction(Action action)
+ {
+ actions.Add(new CallbackAction(action));
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ public void RegisterAction(Object target, MethodInfo method)
+ {
+ actions.Add(new CallbackAction(target, method));
+ }
+ ///
+ public void DeregisterAction(ICallbackAction action)
+ {
+ if (!actions.Remove(action))
+ {
+ Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+ }
+ }
+ ///
+ /// Invokes all stored CallbackActions with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
+ {
+ foreach (CallbackAction action in actions)
+ {
+ try
+ {
+ action.Invoke(t1, t2, t3, t4, t5, t6, t7, t8);
+ }
+ catch (Exception e)
+ {
+ Debug.LogException(e, this);
+ }
+ }
+ }
+ #endregion
+ }
+ ///
+ /// A container of CallbackActions that is correlated to a specific scenario as
+ /// specified by the user of this class.
+ /// This variant accepts CallbackEvents with 1 generic parameter.
+ ///
+ public class CallbackEvent : ICallbackEvent
+ {
+ #region Properties --------------------------------------------------------------
+ ///
+ public IEnumerable Actions => actions;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private List actions = new List();
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ public void RegisterAction(ICallbackAction action)
+ {
+ // Check if valid action
+ if (action.GetType() != typeof(CallbackAction))
+ {
+ Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+ return;
+ }
+
+ actions.Add(action);
+ }
+ ///
+ /// Adds a CallbackAction into the event.
+ ///
+ /// CallbackAction to add.
+ public void RegisterAction(CallbackAction action)
+ {
+ actions.Add(action);
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// System.Action to add as a CallbackAction.
+ public void RegisterAction(Action action)
+ {
+ actions.Add(new CallbackAction(action));
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ public void RegisterAction(Object target, MethodInfo method)
+ {
+ actions.Add(new CallbackAction(target, method));
+ }
+ ///
+ public void DeregisterAction(ICallbackAction action)
+ {
+ if (!actions.Remove(action))
+ {
+ Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+ }
+ }
+ ///
+ /// Invokes all stored CallbackActions with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
+ {
+ foreach (CallbackAction action in actions)
+ {
+ try
+ {
+ action.Invoke(t1, t2, t3, t4, t5, t6, t7, t8, t9);
+ }
+ catch (Exception e)
+ {
+ Debug.LogException(e, this);
+ }
+ }
+ }
+ #endregion
+ }
+ ///
+ /// A container of CallbackActions that is correlated to a specific scenario as
+ /// specified by the user of this class.
+ /// This variant accepts CallbackEvents with 1 generic parameter.
+ ///
+ public class CallbackEvent : ICallbackEvent
+ {
+ #region Properties --------------------------------------------------------------
+ ///
+ public IEnumerable Actions => actions;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private List actions = new List();
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ public void RegisterAction(ICallbackAction action)
+ {
+ // Check if valid action
+ if (action.GetType() != typeof(CallbackAction))
+ {
+ Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+ return;
+ }
+
+ actions.Add(action);
+ }
+ ///
+ /// Adds a CallbackAction into the event.
+ ///
+ /// CallbackAction to add.
+ public void RegisterAction(CallbackAction action)
+ {
+ actions.Add(action);
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// System.Action to add as a CallbackAction.
+ public void RegisterAction(Action action)
+ {
+ actions.Add(new CallbackAction(action));
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ public void RegisterAction(Object target, MethodInfo method)
+ {
+ actions.Add(new CallbackAction(target, method));
+ }
+ ///
+ public void DeregisterAction(ICallbackAction action)
+ {
+ if (!actions.Remove(action))
+ {
+ Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+ }
+ }
+ ///
+ /// Invokes all stored CallbackActions with the specified parameters.
+ ///
+ public void Invoke(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10)
+ {
+ foreach (CallbackAction action in actions)
+ {
+ try
+ {
+ action.Invoke(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
+ }
+ catch (Exception e)
+ {
+ Debug.LogException(e, this);
+ }
+ }
+ }
+ #endregion
+ }
+}
diff --git a/SHADE_CSharp/src/Events/CallbackEvent.tt b/SHADE_CSharp/src/Events/CallbackEvent.tt
new file mode 100644
index 00000000..74fadd08
--- /dev/null
+++ b/SHADE_CSharp/src/Events/CallbackEvent.tt
@@ -0,0 +1,143 @@
+<#
+/************************************************************************************//*!
+\file CallbackEvent.tt
+\author Tng Kah Wei, kahwei.tng, 390009620
+\par email: kahwei.tng\@digipen.edu
+\date Oct 23, 2022
+\brief Contains the T4 template for the definition of CallbackEvent and
+ related classes.
+
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/#>
+<#@ template hostspecific="false" language="C#" #>
+<#@ output extension=".cs" #>
+<# var max = 10; #>
+/************************************************************************************//*!
+\file CallbackEvent.cs
+\author Tng Kah Wei, kahwei.tng, 390009620
+\par email: kahwei.tng\@digipen.edu
+\date Oct 23, 2022
+\brief Contains the definition of CallbackEvent and related classes.
+
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using System.Reflection.Metadata.Ecma335;
+
+namespace SHADE
+{
+ ///
+ /// Interface for a CallbackEvent that all variants inherit from.
+ ///
+ public interface ICallbackEvent
+ {
+ ///
+ /// Registers an ICallbackAction with the event such that it will be called in
+ /// future
+ ///
+ /// ICallbackAction to register with.
+ void RegisterAction(ICallbackAction action);
+ ///
+ /// Deregisters an ICallbackAction that was previously added. This should
+ /// only emit a warning if an action that was not previous added was
+ /// provided.
+ ///
+ /// ICallbackAction to remove.
+ void DeregisterAction(ICallbackAction action);
+ ///
+ /// Iterable set of ICallbackActions that were registered to this event.
+ ///
+ IEnumerable Actions { get; }
+ }
+
+<# for (int i = 1; i <= max; ++i) { #>
+ ///
+ /// A container of CallbackActions that is correlated to a specific scenario as
+ /// specified by the user of this class.
+ /// This variant accepts CallbackEvents with 1 generic parameter.
+ ///
+ public class CallbackEvent<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> : ICallbackEvent
+ {
+ #region Properties --------------------------------------------------------------
+ ///
+ public IEnumerable Actions => actions;
+ #endregion
+
+ #region Fields ------------------------------------------------------------------
+ private List actions = new List();
+ #endregion
+
+ #region Usage Functions ---------------------------------------------------------
+ ///
+ public void RegisterAction(ICallbackAction action)
+ {
+ // Check if valid action
+ if (action.GetType() != typeof(CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>>))
+ {
+ Debug.LogWarning("Attempted to register an invalid CallbackAction type. Ignoring.", this);
+ return;
+ }
+
+ actions.Add(action);
+ }
+ ///
+ /// Adds a CallbackAction into the event.
+ ///
+ /// CallbackAction to add.
+ public void RegisterAction(CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> action)
+ {
+ actions.Add(action);
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// System.Action to add as a CallbackAction.
+ public void RegisterAction(Action<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> action)
+ {
+ actions.Add(new CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>>(action));
+ }
+ ///
+ /// Constructs and adds a CallbackACtion into the event.
+ ///
+ /// Object to call the method on.
+ /// Method to call.
+ public void RegisterAction(Object target, MethodInfo method)
+ {
+ actions.Add(new CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>>(target, method));
+ }
+ ///
+ public void DeregisterAction(ICallbackAction action)
+ {
+ if (!actions.Remove(action))
+ {
+ Debug.LogWarning("Attempted to deregister invalid action. Ignored.", this);
+ }
+ }
+ ///
+ /// Invokes all stored CallbackActions with the specified parameters.
+ ///
+ public void Invoke(<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#> t<#=t#><# if (t != i) { #>, <# } #><# } #>)
+ {
+ foreach (CallbackAction<<# for (int t = 1; t < i + 1; ++t) { #>T<#=t#><# if (t != i) { #>, <# } #><# } #>> action in actions)
+ {
+ try
+ {
+ action.Invoke(<# for (int t = 1; t < i + 1; ++t) { #>t<#=t#><# if (t != i) { #>, <# } #><# } #>);
+ }
+ catch (Exception e)
+ {
+ Debug.LogException(e, this);
+ }
+ }
+ }
+ #endregion
+ }
+<# } #>
+}