docs: added ray 2d comments

All delegate events are refactored to use the Event<TSender> and Event<TSender, TArgument> for performance issues regarding delegate events creating garbage, also this gives us better control on event invocation since C# Delegates did also create unnecessary garbage during Delegate.DynamicInvoke

Engine.Core/Abstract/Assignable/IAssignable.cs

@@ -8,7 +8,7 @@ public interface IAssignable
     /// <summary>
     /// Event triggered when the <see cref="IAssignable"/>'s fields are unassigned and completely ready to recycle.
     /// </summary> 
-    event UnassignEventHandler? OnUnassigned;
+    Event<IAssignable>? OnUnassigned { get; }
 
     /// <summary>
     /// Unassign <see cref="IAssignable"/>'s all fields and make it ready to recycle.
@@ -17,6 +17,4 @@ public interface IAssignable
     /// <see cref="true"/>, if the fields are unsigned successfully, <see cref="false"/> if not.
     /// </returns>
     bool Unassign();
-
-    delegate void UnassignEventHandler(IAssignable sender);
 }

Engine.Core/Abstract/Assignable/IHasBehaviourController.cs

@@ -8,7 +8,7 @@ public interface IHasBehaviourController : IAssignable
     /// <summary>
     /// Event triggered when the <see cref="IBehaviourController"/> value has has been assigned a new value.
     /// </summary>
-    event BehaviourControllerAssignedEventHandler? OnBehaviourControllerAssigned;
+    Event<IHasBehaviourController> OnBehaviourControllerAssigned { get; }
 
     /// <inheritdoc cref="IBehaviourController" />
     IBehaviourController BehaviourController { get; }
@@ -21,6 +21,4 @@ public interface IHasBehaviourController : IAssignable
     /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
     /// </returns>
     bool Assign(IBehaviourController behaviourController);
-
-    delegate void BehaviourControllerAssignedEventHandler(IHasBehaviourController sender);
 }

Engine.Core/Abstract/Assignable/IHasEntity.cs

@@ -8,7 +8,7 @@ public interface IHasEntity : IAssignable
     /// <summary>
     /// Event triggered when the <see cref="IEntity"/> value has has been assigned a new value.
     /// </summary>
-    event EntityAssignedEventHandler? OnEntityAssigned;
+    Event<IHasEntity> OnEntityAssigned { get; }
 
     /// <inheritdoc cref="IEntity" />
     IEntity Entity { get; }
@@ -21,6 +21,4 @@ public interface IHasEntity : IAssignable
     /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
     /// </returns>
     bool Assign(IEntity entity);
-
-    delegate void EntityAssignedEventHandler(IHasEntity sender);
 }

Engine.Core/Abstract/Assignable/IHasStateEnable.cs

@@ -8,7 +8,7 @@ public interface IHasStateEnable : IAssignable
     /// <summary>
     /// Event triggered when the <see cref="IStateEnable"/> value has has been assigned a new value.
     /// </summary>
-    event StateEnableAssignedEventHandler? OnStateEnableAssigned;
+    Event<IHasStateEnable> OnStateEnableAssigned { get; }
 
     /// <inheritdoc cref="IStateEnable" />
     IStateEnable StateEnable { get; }
@@ -21,6 +21,4 @@ public interface IHasStateEnable : IAssignable
     /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
     /// </returns>
     bool Assign(IStateEnable stateEnable);
-
-    delegate void StateEnableAssignedEventHandler(IHasStateEnable sender);
 }

Engine.Core/Abstract/Assignable/IHasUniverse.cs

@@ -8,7 +8,7 @@ public interface IHasUniverse : IAssignable
     /// <summary>
     /// Event triggered when the <see cref="IUniverse"/> value has has been assigned a new value.
     /// </summary>
-    event UniverseAssignedEventHandler? OnUniverseAssigned;
+    Event<IHasUniverse> OnUniverseAssigned { get; }
 
     /// <inheritdoc cref="IUniverse" />
     IUniverse Universe { get; }
@@ -21,6 +21,4 @@ public interface IHasUniverse : IAssignable
     /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
     /// </returns>
     bool Assign(IUniverse universe);
-
-    delegate void UniverseAssignedEventHandler(IHasUniverse sender);
 }

Engine.Core/Abstract/Assignable/IHasUniverseObject.cs

@@ -8,7 +8,7 @@ public interface IHasUniverseObject : IAssignable
     /// <summary>
     /// Event triggered when the <see cref="IUniverseObject"/> value has has been assigned a new value.
     /// </summary>
-    event UniverseObjectAssignedEventHandler? OnUniverseObjectAssigned;
+    Event<IHasUniverseObject> OnUniverseObjectAssigned { get; }
 
     /// <inheritdoc cref="IUniverseObject" />
     IUniverseObject UniverseObject { get; }
@@ -21,6 +21,4 @@ public interface IHasUniverseObject : IAssignable
     /// <see cref="true"/>, if the value given assigned successfully assigned, <see cref="false"/> if not.
     /// </returns>
     bool Assign(IUniverseObject universeObject);
-
-    delegate void UniverseObjectAssignedEventHandler(IHasUniverseObject sender);
 }

Engine.Core/Abstract/IActive.cs

@@ -8,12 +8,12 @@ public interface IActive
     /// <summary>
     /// Event triggered when the <see cref="IsActive"/> state of the <see cref="IActive"/> changes.
     /// </summary>
-    event ActiveChangedEventHandler? OnActiveChanged;
+    Event<IActive, ActiveChangedArguments> OnActiveChanged { get; }
 
     /// <summary>
     /// The value indicating whether the <see cref="IActive"/> is enabled.
     /// </summary>
     bool IsActive { get; }
 
-    delegate void ActiveChangedEventHandler(IActive sender, bool previousState);
+    readonly record struct ActiveChangedArguments(bool PreviousState);
 }

Engine.Core/Abstract/IBehaviour.cs

@@ -8,12 +8,12 @@ public interface IBehaviour : IEntity, IActive, IHasBehaviourController, IHasSta
     /// <summary>
     /// Event triggered when the priority of the <see cref="IBehaviour"/> changes.
     /// </summary>
-    event PriorityChangedEventHandler? OnPriorityChanged;
+    Event<IBehaviour, PriorityChangedArguments> OnPriorityChanged { get; }
 
     /// <summary>
     /// The priority of the <see cref="IBehaviour"/>.
     /// </summary>
     int Priority { get; set; }
 
-    delegate void PriorityChangedEventHandler(IBehaviour sender, int previousPriority);
+    readonly record struct PriorityChangedArguments(int PreviousPriority);
 }

Engine.Core/Abstract/IBehaviourCollector.cs

@@ -10,12 +10,12 @@ public interface IBehaviourCollector<T> : IHasUniverse where T : class
     /// <summary>
     /// Event triggered when an object of type <typeparamref name="T"/> is added to the collector.
     /// </summary>
-    event CollectedEventHandler? OnCollected;
+    Event<IBehaviourCollector<T>, BehaviourCollectedArguments> OnCollected { get; }
 
     /// <summary>
     /// Event triggered when an object of type <typeparamref name="T"/> is removed from the collector.
     /// </summary>
-    event RemovedEventHandler? OnRemoved;
+    Event<IBehaviourCollector<T>, BehaviourRemovedArguments> OnRemoved { get; }
 
     /// <summary>
     /// Amount of <typeparamref name="T"/> collected.
@@ -32,12 +32,11 @@ public interface IBehaviourCollector<T> : IHasUniverse where T : class
     /// </summary>
     /// <param name="sender">The instance of the <see cref="IBehaviourCollector{T}"/> that triggered the event.</param>
     /// <param name="behaviourCollected">The object of type <typeparamref name="T"/> that was added to the collector.</param>
-    delegate void CollectedEventHandler(IBehaviourCollector<T> sender, T behaviourCollected);
+    readonly record struct BehaviourCollectedArguments(T BehaviourCollected);
 
     /// <summary>
     /// Delegate for handling the <see cref="OnRemoved"/> event.
     /// </summary>
-    /// <param name="sender">The instance of the <see cref="IBehaviourCollector{T}"/> that triggered the event.</param>
+    /// <param name="BehaviourRemoved">The object of type <typeparamref name="T"/> that was removed from the collector.</param>
-    /// <param name="behaviourRemoved">The object of type <typeparamref name="T"/> that was removed from the collector.</param>
+    readonly record struct BehaviourRemovedArguments(T BehaviourRemoved);
-    delegate void RemovedEventHandler(IBehaviourCollector<T> sender, T behaviourRemoved);
 }

Engine.Core/Abstract/IBehaviourController.cs

@@ -10,12 +10,12 @@ public interface IBehaviourController : IEntity, IHasUniverseObject
     /// <summary>
     /// Event triggered when a <see cref="IBehaviour"/> is added to the <see cref="IBehaviourController"/>.
     /// </summary>
-    event BehaviourAddedEventHandler? OnBehaviourAdded;
+    Event<IBehaviourController, BehaviourAddedArguments> OnBehaviourAdded { get; }
 
     /// <summary>
     /// Event triggered when a <see cref="IBehaviour"/> is removed from the <see cref="IBehaviourController"/>.
     /// </summary>
-    event BehaviourRemovedEventHandler? OnBehaviourRemoved;
+    Event<IBehaviourController, BehaviourRemovedArguments> OnBehaviourRemoved { get; }
 
     /// <summary>
     /// Amount of <see cref="IBehaviour"/> collected.
@@ -78,6 +78,6 @@ public interface IBehaviourController : IEntity, IHasUniverseObject
     /// <param name="behaviour">The <see cref="IBehaviour"/> to remove.</param>
     void RemoveBehaviour<T>(T behaviour) where T : class, IBehaviour;
 
-    delegate void BehaviourAddedEventHandler(IBehaviourController sender, IBehaviour behaviourAdded);
+    readonly record struct BehaviourAddedArguments(IBehaviour BehaviourAdded);
-    delegate void BehaviourRemovedEventHandler(IBehaviourController sender, IBehaviour behaviourRemoved);
+    readonly record struct BehaviourRemovedArguments(IBehaviour BehaviourRemoved);
 }

Engine.Core/Abstract/IEntity.cs

@@ -9,12 +9,12 @@ public interface IEntity : IInitializable, IHasStateEnable
     /// Event triggered when the <see cref="Id"/> of the <see cref="IEntity"/> changes.
     /// The string action parameter is the previous <see cref="Id"/> of the <see cref="IEntity"/>. 
     /// </summary>
-    event IdChangedEventHandler? OnIdChanged;
+    Event<IEntity, IdChangedArguments> OnIdChanged { get; }
 
     /// <summary>
     /// The ID of the <see cref="IEntity"/>.
     /// </summary>
     string Id { get; set; }
 
-    delegate void IdChangedEventHandler(IEntity sender, string previousId);
+    readonly record struct IdChangedArguments(string PreviousId);
 }

Engine.Core/Abstract/IInitializable.cs

@@ -8,12 +8,12 @@ public interface IInitializable
     /// <summary>
     /// Event triggered when the <see cref="Initialize"/> method is called successfully.
     /// </summary>
-    event InitializedEventHandler? OnInitialized;
+    Event<IInitializable> OnInitialized { get; }
 
     /// <summary>
     /// Event triggered when the <see cref="IInitializable"/> method is called successfully.
     /// </summary>
-    event FinalizedEventHandler? OnFinalized;
+    Event<IInitializable> OnFinalized { get; }
 
     /// <summary>
     /// The value indicating whether the entity has been initialized.
@@ -31,7 +31,4 @@ public interface IInitializable
     /// </summary>
     /// <returns><see cref="true"/> if finalization is successful, otherwise <see cref="false"/>.</returns>
     bool Finalize();
-
-    delegate void InitializedEventHandler(IInitializable sender);
-    delegate void FinalizedEventHandler(IInitializable sender);
 }

Engine.Core/Abstract/INameable.cs

@@ -8,12 +8,12 @@ public interface INameable
     /// <summary>
     /// Event triggered when the name of the entity changes.
     /// </summary>
-    event NameChangedEventHandler? OnNameChanged;
+    Event<INameable, NameChangedArguments> OnNameChanged { get; }
 
     /// <summary>
     /// The name of the entity.
     /// </summary>
     string Name { get; set; }
 
-    delegate void NameChangedEventHandler(INameable sender, string previousName);
+    readonly record struct NameChangedArguments(string PreviousName);
 }

Engine.Core/Abstract/IStateEnable.cs

@@ -8,12 +8,12 @@ public interface IStateEnable : IHasEntity
     /// <summary>
     /// Event triggered when the <see cref="Enabled"/> state of the <see cref="IStateEnable"/> changes.
     /// </summary>
-    event EnabledChangedEventHandler? OnEnabledChanged;
+    Event<IStateEnable, EnabledChangedArguments> OnEnabledChanged { get; }
 
     /// <summary>
     /// The value indicating whether the <see cref="IStateEnable"/> is enabled.
     /// </summary>
     bool Enabled { get; set; }
 
-    delegate void EnabledChangedEventHandler(IStateEnable sender, bool previousState);
+    readonly record struct EnabledChangedArguments(bool PreviousState);
 }

Engine.Core/Abstract/ITransform2D.cs

@@ -8,17 +8,37 @@ public interface ITransform2D : IBehaviour
     /// <summary>
     /// Event triggered when the <see cref="Position"/> of the <see cref="ITransform2D"/> changes.
     /// </summary>
-    event PositionChangedEventHandler? OnPositionChanged;
+    Event<ITransform2D, PositionChangedArguments> OnPositionChanged { get; }
 
     /// <summary>
     /// Event triggered when the <see cref="Scale"/> of the <see cref="ITransform2D"/> changes.
     /// </summary>
-    event ScaleChangedEventHandler? OnScaleChanged;
+    Event<ITransform2D, ScaleChangedArguments> OnScaleChanged { get; }
 
     /// <summary>
     /// Event triggered when the <see cref="Rotation"/> of the <see cref="ITransform"/> changes.
     /// </summary>
-    event RotationChangedEventHandler? OnRotationChanged;
+    Event<ITransform2D, RotationChangedArguments> OnRotationChanged { get; }
+
+    /// <summary>
+    /// The <see cref="Vector2D"/> pointing upwards in world space.
+    /// </summary>
+    Vector2D Up { get; }
+
+    /// <summary>
+    /// The <see cref="Vector2D"/> pointing upwards in world space.
+    /// </summary>
+    Vector2D Down { get; }
+
+    /// <summary>
+    /// The <see cref="Vector2D"/> pointing upwards in world space.
+    /// </summary>
+    Vector2D Left { get; }
+
+    /// <summary>
+    /// The <see cref="Vector2D"/> pointing upwards in world space.
+    /// </summary>
+    Vector2D Right { get; }
 
     /// <summary>
     /// The world position of the <see cref="ITransform2D"/> in 2D space.
@@ -51,23 +71,20 @@ public interface ITransform2D : IBehaviour
     float LocalRotation { get; set; }
 
     /// <summary>
-    /// Delegate for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
+    /// Arguments for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
     /// </summary>
-    /// <param name="sender">The <see cref="ITransform2D"/> that the parent has changed.</param>
+    /// <param name="PreviousPosition">The previous <see cref="Position"/> of the <see cref="ITransform2D"/>.</param>
-    /// <param name="previousPosition">The previous <see cref="Position"/> of the <see cref="ITransform2D"/>.</param>
+    readonly record struct PositionChangedArguments(Vector2D PreviousPosition);
-    delegate void PositionChangedEventHandler(ITransform2D sender, Vector2D previousPosition);
 
     /// <summary>
-    /// Delegate for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
+    /// Arguments for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
     /// </summary>
-    /// <param name="sender">The <see cref="ITransform2D"/> that the parent has changed.</param>
+    /// <param name="PreviousScale">The previous <see cref="Scale"/> of the <see cref="ITransform2D"/>.</param>
-    /// <param name="previousScale">The previous <see cref="Scale"/> of the <see cref="ITransform2D"/>.</param>
+    readonly record struct ScaleChangedArguments(Vector2D PreviousScale);
-    delegate void ScaleChangedEventHandler(ITransform2D sender, Vector2D previousScale);
 
     /// <summary>
-    /// Delegate for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
+    /// Arguments for the event triggered when the <see cref="ITransform2D"/>'s rotation changes.
     /// </summary>
-    /// <param name="sender">The <see cref="ITransform2D"/> that the parent has changed.</param>
+    /// <param name="PreviousRotation">The previous <see cref="Rotation"/> of the <see cref="ITransform2D"/>.</param>
-    /// <param name="previousRotation">The previous <see cref="Rotation"/> of the <see cref="ITransform2D"/>.</param>
+    readonly record struct RotationChangedArguments(float PreviousRotation);
-    delegate void RotationChangedEventHandler(ITransform2D sender, float previousRotation);
 }

Engine.Core/Abstract/IUniverse.cs

@@ -10,47 +10,47 @@ public interface IUniverse : IEntity, IEnumerable<IUniverseObject>
     /// <summary>
     /// Event triggered when <see cref="Update(UniverseTime)"/> is about to be called called on the <see cref="IUniverse"/>.
     /// </summary>
-    event UpdateEventHandler? OnPreUpdate;
+    Event<IUniverse, UpdateArguments> OnPreUpdate { get; }
 
     /// <summary>
     /// Event triggered when <see cref="Update(UniverseTime)"/> is called on the <see cref="IUniverse"/>.
     /// </summary>
-    event UpdateEventHandler? OnUpdate;
+    Event<IUniverse, UpdateArguments> OnUpdate { get; }
 
     /// <summary>
     /// Event triggered after <see cref="Update(UniverseTime)"/> is called on the <see cref="IUniverse"/>.
     /// </summary>
-    event UpdateEventHandler? OnPostUpdate;
+    Event<IUniverse, UpdateArguments> OnPostUpdate { get; }
 
     /// <summary>
     /// Event triggered when <see cref="Draw"/> is about to be called called on the <see cref="IUniverse"/>.
     /// </summary>
-    event DrawEventHandler? OnPreDraw;
+    Event<IUniverse> OnPreDraw { get; }
 
     /// <summary>
     /// Event triggered when <see cref="Draw"/> is called on the <see cref="IUniverse"/>.
     /// </summary>
-    event DrawEventHandler? OnDraw;
+    Event<IUniverse> OnDraw { get; }
 
     /// <summary>
     /// Event triggered after <see cref="Draw"/> is called on the <see cref="IUniverse"/>.
     /// </summary>
-    event DrawEventHandler? OnPostDraw;
+    Event<IUniverse> OnPostDraw { get; }
 
     /// <summary>
     /// Event triggered when a <see cref="IUniverseObject"/> is registered to the <see cref="IUniverse"/>.
     /// </summary>
-    event UniverseObjectRegisteredEventHandler? OnUniverseObjectRegistered;
+    Event<IUniverse, UniverseObjectRegisteredArguments> OnUniverseObjectRegistered { get; }
 
     /// <summary>
     /// Event triggered when a <see cref="IUniverseObject"/> is unregistered from the <see cref="IUniverse"/>.
     /// </summary>
-    event UniverseObjectUnRegisteredEventHandler? OnUniverseObjectUnRegistered;
+    Event<IUniverse, UniverseObjectUnRegisteredArguments> OnUniverseObjectUnRegistered { get; }
 
     /// <summary>
     /// Event triggered when <see cref="TimeScale"/> is changed on the <see cref="IUniverse"/>.
     /// </summary>
-    event TimeScaleChangedEventHandler? OnTimeScaleChanged;
+    Event<IUniverse, TimeScaleChangedArguments> OnTimeScaleChanged { get; }
 
     /// <summary>
     /// Current time scale the <see cref="IUniverse"/> operates on.
@@ -103,11 +103,8 @@ public interface IUniverse : IEntity, IEnumerable<IUniverseObject>
     /// </summary>
     void Draw();
 
-    delegate void TimeScaleChangedEventHandler(IUniverse sender, float previousTimeScale);
+    readonly record struct TimeScaleChangedArguments(float PreviousTimeScale);
-
+    readonly record struct UpdateArguments(UniverseTime EngineTime);
-    delegate void UpdateEventHandler(IUniverse sender, UniverseTime engineTime);
+    readonly record struct UniverseObjectRegisteredArguments(IUniverseObject UniverseObjectRegistered);
-    delegate void DrawEventHandler(IUniverse sender);
+    readonly record struct UniverseObjectUnRegisteredArguments(IUniverseObject UniverseObjectUnregistered);
-
-    delegate void UniverseObjectRegisteredEventHandler(IUniverse sender, IUniverseObject universeObjectRegistered);
-    delegate void UniverseObjectUnRegisteredEventHandler(IUniverse sender, IUniverseObject universeObjectUnregistered);
 }

Engine.Core/Abstract/IUniverseObject.cs

@@ -12,27 +12,27 @@ public interface IUniverseObject : IEntity, IActive, INameable, IHasBehaviourCon
     /// <summary>
     /// Event triggered when the <see cref="IUniverseObject"/> enters the universe.
     /// </summary>
-    event EnteredUniverseEventHandler? OnEnteredUniverse;
+    Event<IUniverseObject, EnteredUniverseArguments> OnEnteredUniverse { get; }
 
     /// <summary>
     /// Event triggered when the <see cref="IUniverseObject"/> exits the universe.
     /// </summary>
-    event ExitedUniverseEventHandler? OnExitedUniverse;
+    Event<IUniverseObject, ExitedUniverseArguments> OnExitedUniverse { get; }
 
     /// <summary>
     /// Event triggered when the <see cref="Parent"/> of the <see cref="IUniverseObject"/> changes. The second parameter is the old <see cref="IUniverseObject"/>.
     /// </summary>
-    event ParentChangedEventHandler? OnParentChanged;
+    Event<IUniverseObject, ParentChangedArguments> OnParentChanged { get; }
 
     /// <summary>
     /// Event triggered when a new <see cref="IUniverseObject"/> is added to the <see cref="Children"/>.
     /// </summary>
-    event ChildrenAddedEventHandler? OnChildrenAdded;
+    Event<IUniverseObject, ChildrenAddedArguments> OnChildrenAdded { get; }
 
     /// <summary>
     /// Event triggered when an <see cref="IUniverseObject"/> is removed from the <see cref="Children"/>.
     /// </summary>
-    event ChildrenRemovedEventHandler? OnChildrenRemoved;
+    Event<IUniverseObject, ChildrenRemovedArguments> OnChildrenRemoved { get; }
 
     /// <summary>
     /// Gets the <see cref="IUniverse"/> this <see cref="IUniverseObject"/> is connected to, if any.
@@ -94,38 +94,38 @@ public interface IUniverseObject : IEntity, IActive, INameable, IHasBehaviourCon
     void RemoveChild(IUniverseObject universeObject);
 
     /// <summary>
-    /// EventHandler delegate for the event triggered when the <see cref="IUniverseObject"/> enters the universe of a <see cref="IUniverse">.
+    /// Arguments for the event triggered when the <see cref="IUniverseObject"/> enters the universe of a <see cref="IUniverse">.
     /// </summary>
     /// <param name="sender">The <see cref="IUniverseObject"/> that entered the universe.</param>
     /// <param name="universe">The <see cref="IUniverse"/> that the <see cref="IUniverseObject"/> has entered it's universe.</param>
-    delegate void EnteredUniverseEventHandler(IUniverseObject sender, IUniverse universe);
+    readonly record struct EnteredUniverseArguments(IUniverse Universe);
 
     /// <summary>
-    /// EventHandler delegate for the event triggered when the <see cref="IUniverseObject"/> exits the universe of a <see cref="IUniverse">.
+    /// Arguments for the event triggered when the <see cref="IUniverseObject"/> exits the universe of a <see cref="IUniverse">.
     /// </summary>
     /// <param name="sender">The <see cref="IUniverseObject"/> that exited the universe.</param>
     /// <param name="universe">The <see cref="IUniverse"/> that the <see cref="IUniverseObject"/> has exited it's universe.</param>
-    delegate void ExitedUniverseEventHandler(IUniverseObject sender, IUniverse universe);
+    readonly record struct ExitedUniverseArguments(IUniverse Universe);
 
     /// <summary>
-    /// Delegate for the event triggered when the <see cref="IUniverseObject"/>'s parent changes.
+    /// Arguments for the event triggered when the <see cref="IUniverseObject"/>'s parent changes.
     /// </summary>
     /// <param name="sender">The <see cref="IUniverseObject"/> that the parent has changed.</param>
     /// <param name="previousParent">The previous <see cref="IUniverseObject"/> the sender was a child of.</param>
     /// <param name="newParent">The new and current <see cref="IUniverseObject"/> the sender is a child of.</param>
-    delegate void ParentChangedEventHandler(IUniverseObject sender, IUniverseObject? previousParent, IUniverseObject? newParent);
+    readonly record struct ParentChangedArguments(IUniverseObject? PreviousParent, IUniverseObject? CurrentParent);
 
     /// <summary>
-    /// Delegate for the event triggered when a new <see cref="IUniverseObject"/> added as a child.
+    /// Arguments for the event triggered when a new <see cref="IUniverseObject"/> added as a child.
     /// </summary>
     /// <param name="sender">The parent <see cref="IUniverseObject"/> this event is being called from.</param>
     /// <param name="childrenAdded">The <see cref="IUniverseObject"/> that got removed as a children of the sender <see cref="IUniverseObject"/>.</param>
-    delegate void ChildrenAddedEventHandler(IUniverseObject sender, IUniverseObject childrenAdded);
+    readonly record struct ChildrenAddedArguments(IUniverseObject ChildrenAdded);
 
     /// <summary>
     /// Delegate for the event triggered when a new <see cref="IUniverseObject"/> removed from being a child.
     /// </summary>
     /// <param name="sender">The parent <see cref="IUniverseObject"/> this event is being called from.</param>
     /// <param name="childrenAdded">The <see cref="IUniverseObject"/> that got removed as a children of the sender <see cref="IUniverseObject"/>.</param>
-    delegate void ChildrenRemovedEventHandler(IUniverseObject sender, IUniverseObject childrenRemoved);
+    readonly record struct ChildrenRemovedArguments(IUniverseObject ChildrenRemoved);
 }

Engine.Core/ActiveBehaviourCollector.cs

@@ -1,15 +1,20 @@
-using System.Collections;
+using System;
 using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
 public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : class, IBehaviour
 {
-    public event IAssignable.UnassignEventHandler? OnUnassigned = null;
+    public Event<IBehaviourCollector<T>, IBehaviourCollector<T>.BehaviourCollectedArguments> OnCollected { get; } = new();
-    public event IHasUniverse.UniverseAssignedEventHandler? OnUniverseAssigned = null;
+    public Event<IBehaviourCollector<T>, IBehaviourCollector<T>.BehaviourRemovedArguments> OnRemoved { get; } = new();
+    public Event<IHasUniverse> OnUniverseAssigned { get; } = new();
+    public Event<IAssignable>? OnUnassigned { get; } = new();
 
-    public event IBehaviourCollector<T>.CollectedEventHandler? OnCollected = null;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAdded = null!;
-    public event IBehaviourCollector<T>.RemovedEventHandler? OnRemoved = null;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler delegateOnBehaviourRemoved = null!;
+    private readonly Event<IActive, IActive.ActiveChangedArguments>.EventHandler delegateOnBehaviourStateChanged = null!;
+    private readonly Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments>.EventHandler delegateOnUniverseObjectRegistered = null!;
+    private readonly Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments>.EventHandler delegateOnUniverseObjectUnregistered = null!;
 
     private readonly List<T> monitoringBehaviours = new(32);
     protected readonly List<T> activeBehaviours = new(32);
@@ -17,69 +22,71 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
 
     public IUniverse Universe { get; private set; } = null!;
 
-    public ActiveBehaviourCollector() { }
+    private void OnUniverseObjectRegistered(IUniverse manager, IUniverse.UniverseObjectRegisteredArguments args)
-    public ActiveBehaviourCollector(IUniverse universe) => Assign(universe);
-
-    private void OnUniverseObjectRegistered(IUniverse manager, IUniverseObject universeObject)
     {
-        universeObject.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
+        IUniverseObject universeObject = args.UniverseObjectRegistered;
-        universeObject.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
+
+        universeObject.BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemoved);
 
         for (int i = 0; i < universeObject.BehaviourController.Count; i++)
-            OnBehaviourAdded(universeObject.BehaviourController, universeObject.BehaviourController[i]);
+            OnBehaviourAdded(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
-    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverseObject universeObject)
+    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverse.UniverseObjectUnRegisteredArguments args)
     {
-        universeObject.BehaviourController.OnBehaviourAdded -= OnBehaviourAdded;
+        IUniverseObject universeObject = args.UniverseObjectUnregistered;
-        universeObject.BehaviourController.OnBehaviourRemoved -= OnBehaviourRemoved;
+
+        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemoved);
 
         for (int i = 0; i < universeObject.BehaviourController.Count; i++)
-            OnBehaviourRemoved(universeObject.BehaviourController, universeObject.BehaviourController[i]);
+            OnBehaviourRemoved(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
     protected virtual void OnBehaviourAdd(IBehaviour behaviour) { }
-    private void OnBehaviourAdded(IBehaviourController controller, IBehaviour behaviour)
+    private void OnBehaviourAdded(IBehaviourController controller, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (behaviour is not T tBehaviour)
+        if (args.BehaviourAdded is not T tBehaviour)
             return;
 
         monitoringBehaviours.Add(tBehaviour);
         monitoringActiveToBehaviour.Add(tBehaviour, tBehaviour);
-        tBehaviour.OnActiveChanged += OnBehaviourStateChanged;
+        tBehaviour.OnActiveChanged.AddListener(delegateOnBehaviourStateChanged);
-        OnBehaviourStateChanged(tBehaviour, !tBehaviour.IsActive);
+        OnBehaviourStateChanged(tBehaviour, new(!tBehaviour.IsActive));
     }
 
-    private void OnBehaviourStateChanged(IActive sender, bool previousState)
+    protected virtual void AddBehaviour(T behaviour) => activeBehaviours.Add(behaviour);
+    private void OnBehaviourStateChanged(IActive sender, IActive.ActiveChangedArguments args)
     {
         T behaviour = monitoringActiveToBehaviour[sender];
         if (sender.IsActive)
         {
-            activeBehaviours.Add(behaviour);
+            AddBehaviour(behaviour);
             OnBehaviourAdd(behaviour);
-            OnCollected?.Invoke(this, behaviour);
+            OnCollected?.Invoke(this, new(behaviour));
         }
         else if (activeBehaviours.Remove(behaviour))
         {
             OnBehaviourRemove(behaviour);
-            OnRemoved?.Invoke(this, behaviour);
+            OnRemoved?.Invoke(this, new(behaviour));
         }
     }
 
     protected virtual void OnBehaviourRemove(IBehaviour behaviour) { }
-    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviour behaviour)
+    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments args)
     {
-        if (behaviour is not T tBehaviour)
+        if (args.BehaviourRemoved is not T tBehaviour)
             return;
 
         if (!monitoringBehaviours.Remove(tBehaviour) || !monitoringActiveToBehaviour.Remove(tBehaviour))
             return;
 
-        tBehaviour.OnActiveChanged -= OnBehaviourStateChanged;
+        tBehaviour.OnActiveChanged.RemoveListener(delegateOnBehaviourStateChanged);
         if (activeBehaviours.Remove(tBehaviour))
         {
             OnBehaviourRemove(tBehaviour);
-            OnRemoved?.Invoke(this, tBehaviour);
+            OnRemoved?.Invoke(this, new(tBehaviour));
         }
     }
 
@@ -89,10 +96,10 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
             return false;
 
         foreach (IUniverseObject universeObject in universe.UniverseObjects)
-            OnUniverseObjectRegistered(universe, universeObject);
+            OnUniverseObjectRegistered(universe, new(universeObject));
 
-        universe.OnUniverseObjectRegistered += OnUniverseObjectRegistered;
+        universe.OnUniverseObjectRegistered.AddListener(delegateOnUniverseObjectRegistered);
-        universe.OnUniverseObjectUnRegistered += OnUniverseObjectUnregistered;
+        universe.OnUniverseObjectUnRegistered.AddListener(delegateOnUniverseObjectUnregistered);
 
         Universe = universe;
         OnUniverseAssigned?.Invoke(this);
@@ -106,10 +113,10 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
             return false;
 
         foreach (IUniverseObject universeObject in Universe.UniverseObjects)
-            OnUniverseObjectUnregistered(Universe, universeObject);
+            OnUniverseObjectUnregistered(Universe, new(universeObject));
 
-        Universe.OnUniverseObjectRegistered -= OnUniverseObjectRegistered;
+        Universe.OnUniverseObjectRegistered.RemoveListener(delegateOnUniverseObjectRegistered);
-        Universe.OnUniverseObjectUnRegistered -= OnUniverseObjectUnregistered;
+        Universe.OnUniverseObjectUnRegistered.RemoveListener(delegateOnUniverseObjectUnregistered);
 
         Universe = null!;
         OnUnassigned?.Invoke(this);
@@ -117,5 +124,25 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
     }
 
     public int Count => activeBehaviours.Count;
-    public T this[System.Index index] => activeBehaviours[index];
+    public T this[Index index] => activeBehaviours[index];
+
+    public ActiveBehaviourCollector()
+    {
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnBehaviourStateChanged = OnBehaviourStateChanged;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+    }
+
+    public ActiveBehaviourCollector(IUniverse universe)
+    {
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnBehaviourStateChanged = OnBehaviourStateChanged;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+
+        Assign(universe);
+    }
 }

Engine.Core/ActiveBehaviourCollectorSorted.cs

@@ -1,11 +1,14 @@
 using System;
+using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
 public class ActiveBehaviourCollectorSorted<T> : ActiveBehaviourCollector<T> where T : class, IBehaviour
 {
-    private Comparison<T>? _sortBy = null;
+    private readonly Event<IBehaviour, IBehaviour.PriorityChangedArguments>.EventHandler delegateOnPriorityChanged = null!;
-    public Comparison<T>? SortBy
+
+    private IComparer<T>? _sortBy = null;
+    public IComparer<T>? SortBy
     {
         get => _sortBy;
         set
@@ -17,12 +20,48 @@ public class ActiveBehaviourCollectorSorted<T> : ActiveBehaviourCollector<T> whe
         }
     }
 
-    protected override void OnBehaviourAdd(IBehaviour behaviour)
+    protected override void AddBehaviour(T behaviour)
     {
-        if (SortBy is not null)
+        if (SortBy is null)
-            activeBehaviours.Sort(SortBy);
+        {
+            activeBehaviours.Add(behaviour);
+            return;
+        }
+
+        int insertionIndex = activeBehaviours.BinarySearch(behaviour, SortBy);
+
+        if (insertionIndex < 0)
+            insertionIndex = ~insertionIndex;
+
+        activeBehaviours.Insert(insertionIndex, behaviour);
     }
 
-    public ActiveBehaviourCollectorSorted() { }
+    protected override void OnBehaviourAdd(IBehaviour behaviour)
-    public ActiveBehaviourCollectorSorted(IUniverse universe, Comparison<T> sortBy) : base(universe) => SortBy = sortBy;
+    {
+        behaviour.OnPriorityChanged.AddListener(delegateOnPriorityChanged);
+    }
+
+    protected override void OnBehaviourRemove(IBehaviour behaviour)
+    {
+        behaviour.OnPriorityChanged.RemoveListener(delegateOnPriorityChanged);
+    }
+
+    private void OnPriorityChanged(IBehaviour sender, IBehaviour.PriorityChangedArguments args)
+    {
+        T behaviour = (T)sender;
+        activeBehaviours.Remove(behaviour);
+        AddBehaviour(behaviour);
+    }
+
+    public ActiveBehaviourCollectorSorted()
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+    }
+
+    public ActiveBehaviourCollectorSorted(IUniverse universe, Comparison<T> sortBy) : base(universe)
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+
+        SortBy = Comparer<T>.Create(sortBy);
+    }
 }

Engine.Core/BaseEntity.cs

@@ -4,13 +4,11 @@ namespace Syntriax.Engine.Core;
 
 public abstract class BaseEntity : IEntity
 {
-    public event IEntity.IdChangedEventHandler? OnIdChanged = null;
+    public Event<IEntity, IEntity.IdChangedArguments> OnIdChanged { get; } = new();
-
+    public Event<IInitializable> OnInitialized { get; } = new();
-    public event IInitializable.InitializedEventHandler? OnInitialized = null;
+    public Event<IInitializable> OnFinalized { get; } = new();
-    public event IInitializable.FinalizedEventHandler? OnFinalized = null;
+    public Event<IHasStateEnable> OnStateEnableAssigned { get; } = new();
-
+    public Event<IAssignable> OnUnassigned { get; } = new();
-    public event IHasStateEnable.StateEnableAssignedEventHandler? OnStateEnableAssigned = null;
-    public event IAssignable.UnassignEventHandler? OnUnassigned = null;
 
     private IStateEnable _stateEnable = null!;
 
@@ -33,7 +31,7 @@ public abstract class BaseEntity : IEntity
             string previousId = _id;
 
             _id = value;
-            OnIdChanged?.Invoke(this, previousId);
+            OnIdChanged?.Invoke(this, new(previousId));
         }
     }
 

Engine.Core/Behaviour.cs

@@ -1,140 +1,50 @@
 namespace Syntriax.Engine.Core;
 
-public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
+public abstract class Behaviour : BehaviourBase
-    IPreUpdate, IUpdate, IPostUpdate,
-    IPreDraw, IDraw, IPostDraw
 {
-    protected IUniverse Universe => BehaviourController.UniverseObject.Universe;
+    private readonly Event<IUniverseObject, IUniverseObject.EnteredUniverseArguments>.EventHandler delegateEnteredUniverse = null!;
-    protected IUniverseObject UniverseObject => BehaviourController.UniverseObject;
+    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler delegateExitedUniverse = null!;
 
     public Behaviour()
     {
-        OnInitialized += OnInitialize;
+        OnInitialized.AddListener(OnInitialize);
-        OnFinalized += OnFinalize;
+        OnFinalized.AddListener(OnFinalize);
-        OnUnassigned += OnUnassign;
+        OnUnassigned.AddListener(OnUnassign);
+
+        delegateEnteredUniverse = EnteredUniverse;
+        delegateExitedUniverse = ExitedUniverse;
     }
 
     protected virtual void OnUnassign() { }
-    protected virtual void OnUnassign(IAssignable assignable) => OnUnassign();
+    protected void OnUnassign(IAssignable assignable) => OnUnassign();
 
     protected virtual void OnInitialize() { }
-    protected virtual void OnInitialize(IInitializable _)
+    protected void OnInitialize(IInitializable _)
     {
-        BehaviourController.UniverseObject.OnEnteredUniverse += EnteredUniverse;
+        BehaviourController.UniverseObject.OnEnteredUniverse.AddListener(delegateEnteredUniverse);
-        BehaviourController.UniverseObject.OnExitedUniverse += ExitedUniverse;
+        BehaviourController.UniverseObject.OnExitedUniverse.AddListener(delegateExitedUniverse);
 
         OnInitialize();
 
         if (UniverseObject.IsInUniverse)
-            EnteredUniverse(UniverseObject, Universe);
+            EnteredUniverse(UniverseObject, new(Universe));
     }
 
     protected virtual void OnFinalize() { }
-    protected virtual void OnFinalize(IInitializable _)
+    protected void OnFinalize(IInitializable _)
     {
-        BehaviourController.UniverseObject.OnEnteredUniverse -= EnteredUniverse;
+        BehaviourController.UniverseObject.OnEnteredUniverse.RemoveListener(delegateEnteredUniverse);
-        BehaviourController.UniverseObject.OnExitedUniverse -= ExitedUniverse;
+        BehaviourController.UniverseObject.OnExitedUniverse.RemoveListener(delegateExitedUniverse);
 
         OnFinalize();
 
         if (UniverseObject.IsInUniverse)
-            ExitedUniverse(UniverseObject, Universe);
+            ExitedUniverse(UniverseObject, new(Universe));
-    }
-
-    protected virtual void OnFirstActiveFrame() { }
-    void IFirstFrameUpdate.FirstActiveFrame()
-    {
-        Debug.Assert.AssertInitialized(this);
-        OnFirstActiveFrame();
-    }
-
-    protected virtual void OnPreUpdatePreActiveCheck() { }
-    protected virtual void OnPreUpdate() { }
-    void IPreUpdate.PreUpdate()
-    {
-        Debug.Assert.AssertInitialized(this);
-
-        OnPreUpdatePreActiveCheck();
-
-        if (!IsActive)
-            return;
-
-        OnPreUpdate();
-    }
-
-    protected virtual void OnUpdatePreActiveCheck() { }
-    protected virtual void OnUpdate() { }
-    void IUpdate.Update()
-    {
-        Debug.Assert.AssertInitialized(this);
-
-        OnUpdatePreActiveCheck();
-
-        if (!IsActive)
-            return;
-
-        OnUpdate();
-    }
-
-    protected virtual void OnPostUpdatePreActiveCheck() { }
-    protected virtual void OnPostUpdate() { }
-    void IPostUpdate.PostUpdate()
-    {
-        Debug.Assert.AssertInitialized(this);
-
-        OnPostUpdatePreActiveCheck();
-
-        if (!StateEnable.Enabled)
-            return;
-
-        OnPostUpdate();
-    }
-
-    protected virtual void OnPreDrawPreActiveCheck() { }
-    protected virtual void OnPreDraw() { }
-    void IPreDraw.PreDraw()
-    {
-        Debug.Assert.AssertInitialized(this);
-
-        OnPreDrawPreActiveCheck();
-
-        if (!StateEnable.Enabled)
-            return;
-
-        OnPreDraw();
-    }
-
-    protected virtual void OnDrawPreActiveCheck() { }
-    protected virtual void OnDraw() { }
-    void IDraw.Draw()
-    {
-        Debug.Assert.AssertInitialized(this);
-
-        OnDrawPreActiveCheck();
-
-        if (!StateEnable.Enabled)
-            return;
-
-        OnDraw();
-    }
-
-    protected virtual void OnPostDrawPreActiveCheck() { }
-    protected virtual void OnPostDraw() { }
-    void IPostDraw.PostDraw()
-    {
-        Debug.Assert.AssertInitialized(this);
-
-        OnPostDrawPreActiveCheck();
-
-        if (!StateEnable.Enabled)
-            return;
-
-        OnPostDraw();
     }
 
     protected virtual void OnEnteredUniverse(IUniverse universe) { }
-    protected virtual void EnteredUniverse(IUniverseObject sender, IUniverse universe) => OnEnteredUniverse(universe);
+    protected void EnteredUniverse(IUniverseObject sender, IUniverseObject.EnteredUniverseArguments args) => OnEnteredUniverse(args.Universe);
 
     protected virtual void OnExitedUniverse(IUniverse universe) { }
-    protected virtual void ExitedUniverse(IUniverseObject sender, IUniverse universe) => OnExitedUniverse(universe);
+    protected void ExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments args) => OnExitedUniverse(args.Universe);
 }

Engine.Core/Behaviour2D.cs

@@ -4,19 +4,6 @@ public abstract class Behaviour2D : Behaviour, IBehaviour2D
 {
     public ITransform2D Transform { get; private set; } = null!;
 
-    protected sealed override void OnInitialize(IInitializable _)
+    protected override void OnInitialize() => Transform = BehaviourController.GetRequiredBehaviour<ITransform2D>();
-    {
+    protected override void OnFinalize() => Transform = null!;
-        Transform = BehaviourController.GetRequiredBehaviour<ITransform2D>();
-        base.OnInitialize(_);
-    }
-
-    protected sealed override void OnFinalize(IInitializable _)
-    {
-        Transform = null!;
-        base.OnFinalize(_);
-    }
-
-    protected sealed override void OnUnassign(IAssignable assignable) => base.OnUnassign(assignable);
-    protected sealed override void EnteredUniverse(IUniverseObject sender, IUniverse universe) => base.EnteredUniverse(sender, universe);
-    protected sealed override void ExitedUniverse(IUniverseObject sender, IUniverse universe) => base.ExitedUniverse(sender, universe);
 }

Engine.Core/BehaviourBase.cs

@@ -3,9 +3,16 @@ namespace Syntriax.Engine.Core;
 [System.Diagnostics.DebuggerDisplay("{GetType().Name, nq}, Priority: {Priority}, Initialized: {Initialized}")]
 public abstract class BehaviourBase : BaseEntity, IBehaviour
 {
-    public event IHasBehaviourController.BehaviourControllerAssignedEventHandler? OnBehaviourControllerAssigned = null;
+    public Event<IBehaviour, IBehaviour.PriorityChangedArguments> OnPriorityChanged { get; } = new();
-    public event IBehaviour.PriorityChangedEventHandler? OnPriorityChanged = null;
+    public Event<IActive, IActive.ActiveChangedArguments> OnActiveChanged { get; } = new();
-    public event IActive.ActiveChangedEventHandler? OnActiveChanged = null;
+    public Event<IHasBehaviourController> OnBehaviourControllerAssigned { get; } = new();
+
+    private readonly Event<IHasUniverseObject>.EventHandler delegateOnUniverseObjectAssigned = null!;
+    private readonly Event<IActive, IActive.ActiveChangedArguments>.EventHandler delegateOnUniverseObjectActiveChanged = null!;
+    private readonly Event<IStateEnable, IStateEnable.EnabledChangedArguments>.EventHandler delegateOnStateEnabledChanged = null!;
+
+    public IUniverse Universe => BehaviourController.UniverseObject.Universe;
+    public IUniverseObject UniverseObject => BehaviourController.UniverseObject;
 
     private IBehaviourController _behaviourController = null!;
     public IBehaviourController BehaviourController => _behaviourController;
@@ -21,7 +28,7 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
 
             int previousPriority = _priority;
             _priority = value;
-            OnPriorityChanged?.Invoke(this, previousPriority);
+            OnPriorityChanged?.Invoke(this, new(previousPriority));
         }
     }
 
@@ -36,7 +43,7 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
 
         _behaviourController = behaviourController;
         OnAssign(behaviourController);
-        behaviourController.OnUniverseObjectAssigned += OnUniverseObjectAssigned;
+        behaviourController.OnUniverseObjectAssigned.AddListener(delegateOnUniverseObjectAssigned);
         if (behaviourController.UniverseObject is not null)
             OnUniverseObjectAssigned(behaviourController);
         OnBehaviourControllerAssigned?.Invoke(this);
@@ -45,7 +52,7 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
 
     private void OnUniverseObjectAssigned(IHasUniverseObject sender)
     {
-        sender.UniverseObject.OnActiveChanged += OnUniverseObjectActiveChanged;
+        sender.UniverseObject.OnActiveChanged.AddListener(delegateOnUniverseObjectActiveChanged);
         UpdateActive();
     }
 
@@ -53,13 +60,14 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
     {
         base.OnAssign(stateEnable);
 
-        stateEnable.OnEnabledChanged += OnStateEnabledChanged;
+        stateEnable.OnEnabledChanged.AddListener(delegateOnStateEnabledChanged);
     }
 
     protected override void UnassignInternal()
     {
-        StateEnable.OnEnabledChanged -= OnStateEnabledChanged;
+        BehaviourController.UniverseObject.OnActiveChanged.RemoveListener(delegateOnUniverseObjectActiveChanged);
-        BehaviourController.OnUniverseObjectAssigned -= OnUniverseObjectAssigned;
+        StateEnable.OnEnabledChanged.RemoveListener(delegateOnStateEnabledChanged);
+        BehaviourController.OnUniverseObjectAssigned.RemoveListener(delegateOnUniverseObjectAssigned);
         base.UnassignInternal();
         _behaviourController = null!;
     }
@@ -70,8 +78,8 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
         Debug.Assert.AssertStateEnableAssigned(this);
     }
 
-    private void OnStateEnabledChanged(IStateEnable sender, bool previousState) => UpdateActive();
+    private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments args) => UpdateActive();
-    private void OnUniverseObjectActiveChanged(IActive sender, bool previousState) => UpdateActive();
+    private void OnUniverseObjectActiveChanged(IActive sender, IActive.ActiveChangedArguments args) => UpdateActive();
 
     private void UpdateActive()
     {
@@ -79,6 +87,13 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
         _isActive = StateEnable.Enabled && _behaviourController.UniverseObject.IsActive;
 
         if (previousActive != IsActive)
-            OnActiveChanged?.Invoke(this, previousActive);
+            OnActiveChanged?.Invoke(this, new(previousActive));
+    }
+
+    protected BehaviourBase()
+    {
+        delegateOnUniverseObjectAssigned = OnUniverseObjectAssigned;
+        delegateOnUniverseObjectActiveChanged = OnUniverseObjectActiveChanged;
+        delegateOnStateEnabledChanged = OnStateEnabledChanged;
     }
 }

Engine.Core/BehaviourCollector.cs

@@ -1,63 +1,69 @@
-using System.Collections;
+using System;
 using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
 public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
 {
-    public event IAssignable.UnassignEventHandler? OnUnassigned = null;
+    public Event<IBehaviourCollector<T>, IBehaviourCollector<T>.BehaviourCollectedArguments> OnCollected { get; } = new();
-    public event IHasUniverse.UniverseAssignedEventHandler? OnUniverseAssigned = null;
+    public Event<IBehaviourCollector<T>, IBehaviourCollector<T>.BehaviourRemovedArguments> OnRemoved { get; } = new();
+    public Event<IHasUniverse> OnUniverseAssigned { get; } = new();
+    public Event<IAssignable>? OnUnassigned { get; } = new();
 
-    public event IBehaviourCollector<T>.CollectedEventHandler? OnCollected = null;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAdded = null!;
-    public event IBehaviourCollector<T>.RemovedEventHandler? OnRemoved = null;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler delegateOnBehaviourRemoved = null!;
+    private readonly Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments>.EventHandler delegateOnUniverseObjectRegistered = null!;
+    private readonly Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments>.EventHandler delegateOnUniverseObjectUnregistered = null!;
 
     protected readonly List<T> behaviours = new(32);
 
     public IUniverse Universe { get; private set; } = null!;
 
-    public BehaviourCollector() { }
+    private void OnUniverseObjectRegistered(IUniverse manager, IUniverse.UniverseObjectRegisteredArguments args)
-    public BehaviourCollector(IUniverse universe) => Assign(universe);
-
-    private void OnUniverseObjectRegistered(IUniverse manager, IUniverseObject universeObject)
     {
-        universeObject.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
+        IUniverseObject universeObject = args.UniverseObjectRegistered;
-        universeObject.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
+
+        universeObject.BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemoved);
 
         for (int i = 0; i < universeObject.BehaviourController.Count; i++)
-            OnBehaviourAdded(universeObject.BehaviourController, universeObject.BehaviourController[i]);
+            OnBehaviourAdded(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
-    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverseObject universeObject)
+    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverse.UniverseObjectUnRegisteredArguments args)
     {
-        universeObject.BehaviourController.OnBehaviourAdded -= OnBehaviourAdded;
+        IUniverseObject universeObject = args.UniverseObjectUnregistered;
-        universeObject.BehaviourController.OnBehaviourRemoved -= OnBehaviourRemoved;
+
+        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemoved);
 
         for (int i = 0; i < universeObject.BehaviourController.Count; i++)
-            OnBehaviourRemoved(universeObject.BehaviourController, universeObject.BehaviourController[i]);
+            OnBehaviourRemoved(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
+    protected virtual void AddBehaviour(T behaviour) => behaviours.Add(behaviour);
     protected virtual void OnBehaviourAdd(IBehaviour behaviour) { }
-    private void OnBehaviourAdded(IBehaviourController controller, IBehaviour behaviour)
+    private void OnBehaviourAdded(IBehaviourController controller, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (behaviour is not T tBehaviour)
+        if (args.BehaviourAdded is not T tBehaviour)
             return;
 
-        behaviours.Add(tBehaviour);
+        AddBehaviour(tBehaviour);
-        OnBehaviourAdd(behaviour);
+        OnBehaviourAdd(args.BehaviourAdded);
-        OnCollected?.Invoke(this, tBehaviour);
+        OnCollected?.Invoke(this, new(tBehaviour));
     }
 
     protected virtual void OnBehaviourRemove(IBehaviour behaviour) { }
-    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviour behaviour)
+    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments args)
     {
-        if (behaviour is not T tBehaviour)
+        if (args.BehaviourRemoved is not T tBehaviour)
             return;
 
         if (!behaviours.Remove(tBehaviour))
             return;
 
-        OnBehaviourRemove(behaviour);
+        OnBehaviourRemove(args.BehaviourRemoved);
-        OnRemoved?.Invoke(this, tBehaviour);
+        OnRemoved?.Invoke(this, new(tBehaviour));
     }
 
     protected virtual void OnAssign(IUniverse universe) { }
@@ -67,10 +73,10 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
             return false;
 
         foreach (IUniverseObject universeObject in universe.UniverseObjects)
-            OnUniverseObjectRegistered(universe, universeObject);
+            OnUniverseObjectRegistered(universe, new(universeObject));
 
-        universe.OnUniverseObjectRegistered += OnUniverseObjectRegistered;
+        universe.OnUniverseObjectRegistered.AddListener(delegateOnUniverseObjectRegistered);
-        universe.OnUniverseObjectUnRegistered += OnUniverseObjectUnregistered;
+        universe.OnUniverseObjectUnRegistered.AddListener(delegateOnUniverseObjectUnregistered);
 
         Universe = universe;
         OnAssign(universe);
@@ -85,10 +91,10 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
             return false;
 
         foreach (IUniverseObject universeObject in Universe.UniverseObjects)
-            OnUniverseObjectUnregistered(Universe, universeObject);
+            OnUniverseObjectUnregistered(Universe, new(universeObject));
 
-        Universe.OnUniverseObjectRegistered -= OnUniverseObjectRegistered;
+        Universe.OnUniverseObjectRegistered.RemoveListener(delegateOnUniverseObjectRegistered);
-        Universe.OnUniverseObjectUnRegistered -= OnUniverseObjectUnregistered;
+        Universe.OnUniverseObjectUnRegistered.RemoveListener(delegateOnUniverseObjectUnregistered);
 
         Universe = null!;
         OnUnassigned?.Invoke(this);
@@ -96,5 +102,23 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
     }
 
     public int Count => behaviours.Count;
-    public T this[System.Index index] => behaviours[index];
+    public T this[Index index] => behaviours[index];
+
+    public BehaviourCollector()
+    {
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+    }
+
+    public BehaviourCollector(IUniverse universe)
+    {
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnUniverseObjectRegistered = OnUniverseObjectRegistered;
+        delegateOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+
+        Assign(universe);
+    }
 }

Engine.Core/BehaviourCollectorSorted.cs

@@ -1,11 +1,14 @@
 using System;
+using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
 public class BehaviourCollectorSorted<T> : BehaviourCollector<T> where T : class
 {
-    private Comparison<T>? _sortBy = null;
+    private readonly Event<IBehaviour, IBehaviour.PriorityChangedArguments>.EventHandler delegateOnPriorityChanged = null!;
-    public Comparison<T>? SortBy
+
+    private IComparer<T>? _sortBy = null;
+    public IComparer<T>? SortBy
     {
         get => _sortBy;
         set
@@ -17,12 +20,48 @@ public class BehaviourCollectorSorted<T> : BehaviourCollector<T> where T : class
         }
     }
 
-    protected override void OnBehaviourAdd(IBehaviour behaviour)
+    protected override void AddBehaviour(T behaviour)
     {
-        if (SortBy is not null)
+        if (SortBy is null)
-            behaviours.Sort(SortBy);
+        {
+            behaviours.Add(behaviour);
+            return;
+        }
+
+        int insertionIndex = behaviours.BinarySearch(behaviour, SortBy);
+
+        if (insertionIndex < 0)
+            insertionIndex = ~insertionIndex;
+
+        behaviours.Insert(insertionIndex, behaviour);
     }
 
-    public BehaviourCollectorSorted() { }
+    protected override void OnBehaviourAdd(IBehaviour behaviour)
-    public BehaviourCollectorSorted(IUniverse universe, Comparison<T> sortBy) : base(universe) => SortBy = sortBy;
+    {
+        behaviour.OnPriorityChanged.AddListener(delegateOnPriorityChanged);
+    }
+
+    protected override void OnBehaviourRemove(IBehaviour behaviour)
+    {
+        behaviour.OnPriorityChanged.RemoveListener(delegateOnPriorityChanged);
+    }
+
+    private void OnPriorityChanged(IBehaviour sender, IBehaviour.PriorityChangedArguments args)
+    {
+        T behaviour = (T)sender;
+        behaviours.Remove(behaviour);
+        AddBehaviour(behaviour);
+    }
+
+    public BehaviourCollectorSorted()
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+    }
+
+    public BehaviourCollectorSorted(IUniverse universe, Comparison<T> sortBy) : base(universe)
+    {
+        delegateOnPriorityChanged = OnPriorityChanged;
+
+        SortBy = Comparer<T>.Create(sortBy);
+    }
 }

Engine.Core/BehaviourController.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -8,11 +7,11 @@ namespace Syntriax.Engine.Core;
 [System.Diagnostics.DebuggerDisplay("Behaviour Count: {behaviours.Count}")]
 public class BehaviourController : BaseEntity, IBehaviourController
 {
-    public event IBehaviourController.BehaviourAddedEventHandler? OnBehaviourAdded = null;
+    public Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments> OnBehaviourAdded { get; } = new();
-    public event IBehaviourController.BehaviourRemovedEventHandler? OnBehaviourRemoved = null;
+    public Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments> OnBehaviourRemoved { get; } = new();
-    public event IHasUniverseObject.UniverseObjectAssignedEventHandler? OnUniverseObjectAssigned = null;
+    public Event<IHasUniverseObject> OnUniverseObjectAssigned { get; } = new();
 
-    private readonly IList<IBehaviour> behaviours = new List<IBehaviour>(Constants.BEHAVIOURS_SIZE_INITIAL);
+    private readonly List<IBehaviour> behaviours = new(Constants.BEHAVIOURS_SIZE_INITIAL);
 
     private IUniverseObject _universeObject = null!;
 
@@ -28,8 +27,9 @@ public class BehaviourController : BaseEntity, IBehaviourController
 
         if (IsInitialized)
             behaviour.Initialize();
-        behaviour.OnPriorityChanged += OnPriorityChange;
+
-        OnBehaviourAdded?.Invoke(this, behaviour);
+        behaviour.OnPriorityChanged.AddListener(OnPriorityChange);
+        OnBehaviourAdded?.Invoke(this, new(behaviour));
         return behaviour;
     }
 
@@ -94,10 +94,10 @@ public class BehaviourController : BaseEntity, IBehaviourController
         if (!behaviours.Contains(behaviour))
             throw new Exception($"{behaviour.GetType().Name} does not exist in {UniverseObject.Name}'s {nameof(IBehaviourController)}.");
 
-        behaviour.OnPriorityChanged -= OnPriorityChange;
+        behaviour.OnPriorityChanged.RemoveListener(OnPriorityChange);
         behaviour.Finalize();
         behaviours.Remove(behaviour);
-        OnBehaviourRemoved?.Invoke(this, behaviour);
+        OnBehaviourRemoved?.Invoke(this, new(behaviour));
     }
 
     protected virtual void OnAssign(IUniverseObject universeObject) { }
@@ -146,7 +146,7 @@ public class BehaviourController : BaseEntity, IBehaviourController
             behaviours.Add(behaviour);
     }
 
-    private void OnPriorityChange(IBehaviour sender, int previousPriority)
+    private void OnPriorityChange(IBehaviour sender, IBehaviour.PriorityChangedArguments args)
     {
         behaviours.Remove(sender);
         InsertBehaviourByPriority(sender);

Engine.Core/CoroutineManager.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
-public class CoroutineManager : UniverseObject
+public class CoroutineManager : Behaviour, IUpdate
 {
     private readonly List<IEnumerator> enumerators = [];
 
@@ -18,17 +18,7 @@ public class CoroutineManager : UniverseObject
         enumerators.Remove(enumerator);
     }
 
-    protected override void OnEnteringUniverse(IUniverse universe)
+    void IUpdate.Update()
-    {
-        universe.OnUpdate += OnUpdate;
-    }
-
-    protected override void OnExitingUniverse(IUniverse universe)
-    {
-        universe.OnUpdate -= OnUpdate;
-    }
-
-    private void OnUpdate(IUniverse sender, UniverseTime time)
     {
         for (int i = enumerators.Count - 1; i >= 0; i--)
         {
@@ -39,4 +29,6 @@ public class CoroutineManager : UniverseObject
                 enumerators.RemoveAt(i);
         }
     }
+
+    public CoroutineManager() => Priority = int.MinValue;
 }

Engine.Core/Helpers/DelegateExtensions.cs

@@ -1,18 +0,0 @@
-using System;
-
-namespace Syntriax.Engine.Core;
-
-public static class DelegateExtensions
-{
-    [Obsolete($"{nameof(InvokeSafe)} causes memory allocation, please use Invoke() instead.")]
-    public static void InvokeSafe(this Delegate @delegate, params object?[] args)
-    {
-        foreach (Delegate invocation in Delegate.EnumerateInvocationList(@delegate))
-            try { invocation.DynamicInvoke(args); }
-            catch (Exception exception)
-            {
-                string methodCallRepresentation = $"{invocation.Method.DeclaringType?.FullName}.{invocation.Method.Name}({string.Join(", ", args)})";
-                Console.WriteLine($"Unexpected exception on invocation of method {methodCallRepresentation}:{Environment.NewLine}{exception.InnerException}");
-            }
-    }
-}

Engine.Core/Helpers/Event.cs

@@ -0,0 +1,145 @@
+using System;
+using System.Collections.Generic;
+
+namespace Syntriax.Engine.Core;
+
+public class Event
+{
+    private readonly List<EventHandler> listeners = null!;
+    private readonly List<EventHandler> onceListeners = null!;
+
+    public void AddListener(EventHandler listener) => listeners.Add(listener);
+    public void AddOnceListener(EventHandler listener) => onceListeners.Add(listener);
+    public void RemoveListener(EventHandler listener) => listeners.Remove(listener);
+    public void RemoveOnceListener(EventHandler listener) => onceListeners.Remove(listener);
+    public void Clear() { listeners.Clear(); onceListeners.Clear(); }
+    public void Invoke()
+    {
+        for (int i = 0; i < listeners.Count; i++)
+            try { listeners[i].Invoke(); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{listeners[i].Method.DeclaringType?.FullName}.{listeners[i].Method.Name}()";
+                Console.WriteLine($"Unexpected exception on invocation of method {methodCallRepresentation}:{Environment.NewLine}{exception.InnerException}");
+            }
+
+        for (int i = onceListeners.Count - 1; i >= 0; i--)
+        {
+            try { onceListeners[i].Invoke(); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{onceListeners[i].Method.DeclaringType?.FullName}.{onceListeners[i].Method.Name}()";
+                Console.WriteLine($"Unexpected exception on invocation of method {methodCallRepresentation}:{Environment.NewLine}{exception.InnerException}");
+            }
+            onceListeners.RemoveAt(i);
+        }
+    }
+
+    public Event(int initialListenerCount = 4, int initialOnceListenerCount = 2)
+    {
+        listeners = new(initialListenerCount);
+        onceListeners = new(initialOnceListenerCount);
+    }
+
+    public Event()
+    {
+        listeners = new(4);
+        onceListeners = new(2);
+    }
+
+    public delegate void EventHandler();
+}
+
+public class Event<TSender>
+{
+    private readonly List<EventHandler> listeners = null!;
+    private readonly List<EventHandler> onceListeners = null!;
+
+    public void AddListener(EventHandler listener) => listeners.Add(listener);
+    public void AddOnceListener(EventHandler listener) => onceListeners.Add(listener);
+    public void RemoveListener(EventHandler listener) => listeners.Remove(listener);
+    public void RemoveOnceListener(EventHandler listener) => onceListeners.Remove(listener);
+    public void Clear() { listeners.Clear(); onceListeners.Clear(); }
+    public void Invoke(TSender sender)
+    {
+        for (int i = 0; i < listeners.Count; i++)
+            try { listeners[i].Invoke(sender); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{listeners[i].Method.DeclaringType?.FullName}.{listeners[i].Method.Name}({sender})";
+                Console.WriteLine($"Unexpected exception on invocation of method {methodCallRepresentation}:{Environment.NewLine}{exception.InnerException}");
+            }
+
+        for (int i = onceListeners.Count - 1; i >= 0; i--)
+        {
+            try { onceListeners[i].Invoke(sender); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{onceListeners[i].Method.DeclaringType?.FullName}.{onceListeners[i].Method.Name}({sender})";
+                Console.WriteLine($"Unexpected exception on invocation of method {methodCallRepresentation}:{Environment.NewLine}{exception.InnerException}");
+            }
+            onceListeners.RemoveAt(i);
+        }
+    }
+
+    public Event(int initialListenerCount = 4, int initialOnceListenerCount = 2)
+    {
+        listeners = new(initialListenerCount);
+        onceListeners = new(initialOnceListenerCount);
+    }
+
+    public Event()
+    {
+        listeners = new(4);
+        onceListeners = new(2);
+    }
+
+    public delegate void EventHandler(TSender sender);
+}
+
+public class Event<TSender, TArguments>
+{
+    private readonly List<EventHandler> listeners = null!;
+    private readonly List<EventHandler> onceListeners = null!;
+
+    public void AddListener(EventHandler listener) => listeners.Add(listener);
+    public void AddOnceListener(EventHandler listener) => onceListeners.Add(listener);
+    public void RemoveListener(EventHandler listener) => listeners.Remove(listener);
+    public void RemoveOnceListener(EventHandler listener) => onceListeners.Remove(listener);
+    public void Clear() { listeners.Clear(); onceListeners.Clear(); }
+    public void Invoke(TSender sender, TArguments args)
+    {
+        for (int i = 0; i < listeners.Count; i++)
+            try { listeners[i].Invoke(sender, args); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{listeners[i].Method.DeclaringType?.FullName}.{listeners[i].Method.Name}({string.Join(", ", sender, args)})";
+                Console.WriteLine($"Unexpected exception on invocation of method {methodCallRepresentation}:{Environment.NewLine}{exception.InnerException}");
+            }
+
+        for (int i = onceListeners.Count - 1; i >= 0; i--)
+        {
+            try { onceListeners[i].Invoke(sender, args); }
+            catch (Exception exception)
+            {
+                string methodCallRepresentation = $"{onceListeners[i].Method.DeclaringType?.FullName}.{onceListeners[i].Method.Name}({string.Join(", ", sender, args)})";
+                Console.WriteLine($"Unexpected exception on invocation of method {methodCallRepresentation}:{Environment.NewLine}{exception.InnerException}");
+            }
+            onceListeners.RemoveAt(i);
+        }
+    }
+
+    public Event(int initialListenerCount = 4, int initialOnceListenerCount = 2)
+    {
+        listeners = new(initialListenerCount);
+        onceListeners = new(initialOnceListenerCount);
+    }
+
+    public Event()
+    {
+        listeners = new(4);
+        onceListeners = new(2);
+    }
+
+    public delegate void EventHandler(TSender sender, TArguments args);
+}

Engine.Core/Helpers/IPool.cs

@@ -0,0 +1,10 @@
+namespace Syntriax.Engine.Core;
+
+public interface IPool<T>
+{
+    Event<IPool<T>, T> OnRemoved { get; }
+    Event<IPool<T>, T> OnReturned { get; }
+
+    T Get();
+    void Return(T item);
+}

Engine.Core/Helpers/ListPool.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+
+namespace Syntriax.Engine.Core;
+
+public class ListPool<T> : IPool<List<T>>
+{
+    public Event<IPool<List<T>>, List<T>> OnReturned { get; } = new();
+    public Event<IPool<List<T>>, List<T>> OnRemoved { get; } = new();
+
+    private readonly Func<List<T>> generator = null!;
+    private readonly Queue<List<T>> queue = new();
+
+    public List<T> Get()
+    {
+        if (!queue.TryDequeue(out List<T>? result))
+            result = generator();
+
+        result.Clear();
+        OnRemoved?.Invoke(this, result);
+        return result;
+    }
+
+    public void Return(List<T> list)
+    {
+        if (queue.Contains(list))
+            return;
+
+        list.Clear();
+        queue.Enqueue(list);
+        OnReturned?.Invoke(this, list);
+    }
+
+    public ListPool(int initialListCount = 1, int initialListCapacity = 32)
+    {
+        generator = () => new(initialListCapacity);
+        for (int i = 0; i < initialListCount; i++)
+            queue.Enqueue(generator());
+    }
+}

Engine.Core/Helpers/Pool.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+
+namespace Syntriax.Engine.Core;
+
+public class Pool<T> : IPool<T>
+{
+    public Event<IPool<T>, T> OnRemoved { get; } = new();
+    public Event<IPool<T>, T> OnReturned { get; } = new();
+
+    private readonly Func<T> generator = null!;
+    private readonly Queue<T> queue = new();
+
+    public T Get()
+    {
+        if (!queue.TryDequeue(out T? result))
+            result = generator();
+
+        OnRemoved?.Invoke(this, result);
+        return result;
+    }
+
+    public void Return(T item)
+    {
+        if (queue.Contains(item))
+            return;
+
+        queue.Enqueue(item);
+        OnReturned?.Invoke(this, item);
+    }
+
+    public Pool(Func<T> generator, int initialCapacity = 1)
+    {
+        this.generator = generator;
+        for (int i = 0; i < initialCapacity; i++)
+            queue.Enqueue(generator());
+    }
+}

Engine.Core/Helpers/Progression/IReadOnlyProgressionTracker.cs

@@ -2,12 +2,11 @@ namespace Syntriax.Engine.Core;
 
 public interface IReadOnlyProgressionTracker
 {
-    event ProgressionUpdatedEventHandler? OnUpdated;
+    Event<IReadOnlyProgressionTracker, ProgressionUpdatedArguments> OnUpdated { get; }
-    event ProgressionEndedEventHandler? OnEnded;
+    Event<IReadOnlyProgressionTracker> OnEnded { get; }
 
     float Progression { get; }
     string Status { get; }
 
-    delegate void ProgressionUpdatedEventHandler(IReadOnlyProgressionTracker sender, float previousProgression, string previousStatus);
+    readonly record struct ProgressionUpdatedArguments(float PreviousProgression, string PreviousStatus);
-    delegate void ProgressionEndedEventHandler(IReadOnlyProgressionTracker sender);
 }

Engine.Core/Helpers/Progression/ProgressionTracker.cs

@@ -2,8 +2,8 @@ namespace Syntriax.Engine.Core;
 
 public class ProgressionTracker : IProgressionTracker
 {
-    public event IReadOnlyProgressionTracker.ProgressionUpdatedEventHandler? OnUpdated = null;
+    public Event<IReadOnlyProgressionTracker, IReadOnlyProgressionTracker.ProgressionUpdatedArguments> OnUpdated { get; } = new();
-    public event IReadOnlyProgressionTracker.ProgressionEndedEventHandler? OnEnded = null;
+    public Event<IReadOnlyProgressionTracker> OnEnded { get; } = new();
 
     public float Progression { get; private set; } = 0f;
     public string Status { get; private set; } = "Default";
@@ -19,7 +19,7 @@ public class ProgressionTracker : IProgressionTracker
         Progression = progression.Clamp(Progression, 1f);
         Status = status;
 
-        OnUpdated?.Invoke(this, previousProgression, previousStatus);
+        OnUpdated?.Invoke(this, new(previousProgression, previousStatus));
 
         if (progression >= 1f)
             OnEnded?.Invoke(this);
@@ -30,7 +30,7 @@ public class ProgressionTracker : IProgressionTracker
         Progression = 0f;
         Status = "Default";
 
-        OnUpdated = null;
+        OnUpdated.Clear();
-        OnEnded = null;
+        OnEnded.Clear();
     }
 }

Engine.Core/Primitives/Line2D.cs

@@ -167,17 +167,14 @@ public readonly struct Line2D(Vector2D from, Vector2D to)
     /// </summary>
     public static Vector2D ClosestPointTo(Line2D line, Vector2D point)
     {
-        Vector2D edgeVector = line.From.FromTo(line.To);
+        Vector2D lineRelativeVector = line.From.FromTo(line.To);
-        Vector2D pointVector = point - line.From;
 
-        float t = (pointVector.X * edgeVector.X + pointVector.Y * edgeVector.Y) / (edgeVector.X * edgeVector.X + edgeVector.Y * edgeVector.Y);
+        Vector2D lineDirection = lineRelativeVector.Normalized;
+        Vector2D pointVector = line.From.FromTo(point);
 
-        t = Math.Max(0, Math.Min(1, t));
+        float dot = lineDirection.Dot(pointVector).Clamp(0f, lineRelativeVector.Magnitude);
 
-        float closestX = line.From.X + t * edgeVector.X;
+        return lineDirection * dot;
-        float closestY = line.From.Y + t * edgeVector.Y;
-
-        return new Vector2D((float)closestX, (float)closestY);
     }
 
     /// <summary>
@@ -205,6 +202,9 @@ public static class Line2DExtensions
     /// <inheritdoc cref="Line2D.Intersects(Line2D, Vector2D)" />
     public static bool Intersects(this Line2D line, Vector2D point) => Line2D.Intersects(line, point);
 
+    /// <inheritdoc cref="Line2D.IntersectionPoint(Line2D, Line2D)" />
+    public static Vector2D IntersectionPoint(this Line2D left, Line2D right) => Line2D.IntersectionPoint(left, right);
+
     /// <inheritdoc cref="Line2D.GetT(Line2D, Vector2D)" />
     public static float GetT(this Line2D line, Vector2D point) => Line2D.GetT(line, point);
 
@@ -214,6 +214,9 @@ public static class Line2DExtensions
     /// <inheritdoc cref="Line2D.Intersects(Line2D, Line2D, out Vector2D?)" />
     public static bool Intersects(this Line2D left, Line2D right, [NotNullWhen(returnValue: true)] out Vector2D? point) => Line2D.Intersects(left, right, out point);
 
+    /// <inheritdoc cref="Line2D.ClosestPointTo(Line2D, Vector2D)" />
+    public static Vector2D ClosestPointTo(this Line2D line, Vector2D point) => Line2D.ClosestPointTo(line, point);
+
     /// <inheritdoc cref="Line2D.ApproximatelyEquals(Line2D, Line2D, float)" />
     public static bool ApproximatelyEquals(this Line2D left, Line2D right, float epsilon = float.Epsilon) => Line2D.ApproximatelyEquals(left, right, epsilon);
 }

Engine.Core/Primitives/Ray2D.cs

@@ -0,0 +1,71 @@
+namespace Syntriax.Engine.Core;
+
+/// <summary>
+/// Represents an infinite ray in 2D space.
+/// </summary>
+/// <param name="Origin">The <see cref="Vector2D"/> in 2D space where the ray starts from.</param>
+/// <param name="Direction">Normalized <see cref="Vector2D"/> indicating the ray's is direction.</param> 
+public readonly struct Ray2D(Vector2D Origin, Vector2D Direction)
+{
+    /// <summary>
+    /// The starting point of the <see cref="Ray2D"/>.
+    /// </summary>
+    public readonly Vector2D Origin = Origin;
+
+    /// <summary>
+    /// The direction in which the <see cref="Ray2D"/> points. Should be a normalized vector.
+    /// </summary>
+    public readonly Vector2D Direction = Direction;
+
+    /// <summary>
+    /// Gets a <see cref="Ray2D"/> with the same origin but with the direction reversed.
+    /// </summary>
+    public readonly Ray2D Reversed => new(Origin, -Direction);
+
+    public static implicit operator Ray2D(Line2D line) => new(line.From, line.From.FromTo(line.To).Normalized);
+
+    /// <summary>
+    /// Constructs a <see cref="Line2D"/> from a <see cref="Ray2D"/>, extending from its origin in the <see cref="Ray2D"/>'s direction for a given distance.
+    /// </summary>
+    /// <param name="ray">The source <see cref="Ray2D"/>.</param>
+    /// <param name="distance">The length of the line segment to create from the <see cref="Ray2D"/>.</param>
+    /// <returns>A <see cref="Line2D"/> representing the segment of the <see cref="Ray2D"/>.</returns>
+    public static Line2D GetLine(Ray2D ray, float distance)
+        => new(ray.Origin, ray.Origin + ray.Direction * distance);
+
+    /// <summary>
+    /// Evaluates the point on the <see cref="Ray2D"/> at a specified distance from its origin.
+    /// </summary>
+    /// <param name="ray">The <see cref="Ray2D"/> to evaluate.</param>
+    /// <param name="distanceFromOrigin">The distance from the origin along the <see cref="Ray2D"/>'s direction.</param>
+    /// <returns>A <see cref="Vector2D"/> representing the point at the given distance on the <see cref="Ray2D"/>.</returns>
+    public static Vector2D Evaluate(Ray2D ray, float distanceFromOrigin)
+        => ray.Origin + ray.Direction * distanceFromOrigin;
+
+    /// <summary>
+    /// Calculates the closest point on the <see cref="Ray2D"/> to the specified point.
+    /// </summary>
+    public static Vector2D ClosestPointTo(Ray2D ray, Vector2D point)
+    {
+        Vector2D originToPoint = ray.Origin.FromTo(point);
+
+        float dot = ray.Direction.Dot(originToPoint);
+
+        return ray.Origin + ray.Direction * dot;
+    }
+}
+
+/// <summary>
+/// Provides extension methods for the <see cref="Ray2D"/> struct.
+/// </summary>
+public static class Ray2DExtensions
+{
+    /// <inheritdoc cref="Ray2D.GetLine(Ray2D, float) />
+    public static Line2D ToLine(this Ray2D ray, float distance) => Ray2D.GetLine(ray, distance);
+
+    /// <inheritdoc cref="Ray2D.Evaluate(Ray2D, float) />
+    public static Vector2D Evaluate(this Ray2D ray, float distanceFromOrigin) => Ray2D.Evaluate(ray, distanceFromOrigin);
+
+    /// <inheritdoc cref="Ray2D.ClosestPointTo(Ray2D, Vector2D) />
+    public static Vector2D ClosestPointTo(this Ray2D ray, Vector2D point) => Ray2D.ClosestPointTo(ray, point);
+}

Engine.Core/Primitives/Shape2D.cs

@@ -18,7 +18,7 @@ public class Shape2D(List<Vector2D> vertices) : IEnumerable<Vector2D>
     public static Shape2D Pentagon => CreateNgon(5, Vector2D.Up);
     public static Shape2D Hexagon => CreateNgon(6, Vector2D.Right);
 
-    public event ShapeUpdatedEventHandler? OnShapeUpdated = null;
+    public Event<Shape2D> OnShapeUpdated { get; } = new();
 
     private List<Vector2D> _vertices = vertices;
 
@@ -256,8 +256,6 @@ public class Shape2D(List<Vector2D> vertices) : IEnumerable<Vector2D>
 
     /// <inheritdoc/>
     IEnumerator IEnumerable.GetEnumerator() => Vertices.GetEnumerator();
-
-    public delegate void ShapeUpdatedEventHandler(Shape2D shape2D);
 }
 
 /// <summary>

Engine.Core/Primitives/Vector2D.cs

@@ -31,6 +31,11 @@ public readonly struct Vector2D(float x, float y)
     /// </summary>
     public float MagnitudeSquared => LengthSquared(this);
 
+    /// <summary>
+    /// Gets a <see cref="Vector2D"/> with the direction reversed.
+    /// </summary>
+    public readonly Vector2D Reversed => -this;
+
     /// <summary>
     /// The normalized form of the <see cref="Vector2D"/> (a <see cref="Vector2D"/> with the same direction and a magnitude of 1).
     /// </summary>

Engine.Core/Serialization/EntityRegistry.cs

@@ -5,7 +5,7 @@ namespace Syntriax.Engine.Core.Serialization;
 
 public class EntityRegistry
 {
-    public event EntityRegisteredEventHandler? OnEntityRegistered = null!;
+    public Event<EntityRegistry, EntityRegisteredArguments> OnEntityRegistered = null!;
 
     private readonly Dictionary<string, Action<IEntity>?> assignCallbacks = [];
     private readonly Dictionary<string, IEntity> registeredEntities = [];
@@ -14,7 +14,7 @@ public class EntityRegistry
     public void Add(IEntity entity)
     {
         if (registeredEntities.TryAdd(entity.Id, entity))
-            OnEntityRegistered?.Invoke(this, entity);
+            OnEntityRegistered?.Invoke(this, new(entity));
     }
 
     public void QueueAssign(string id, Action<IEntity> setMethod)
@@ -35,5 +35,5 @@ public class EntityRegistry
         registeredEntities.Clear();
     }
 
-    public delegate void EntityRegisteredEventHandler(EntityRegistry sender, IEntity entity);
+    public readonly record struct EntityRegisteredArguments(IEntity Entity);
 }

Engine.Core/StateEnable.cs

@@ -2,9 +2,9 @@ namespace Syntriax.Engine.Core;
 
 public class StateEnable : IStateEnable
 {
-    public event IAssignable.UnassignEventHandler? OnUnassigned = null;
+    public Event<IStateEnable, IStateEnable.EnabledChangedArguments> OnEnabledChanged { get; } = new();
-    public event IHasEntity.EntityAssignedEventHandler? OnEntityAssigned = null;
+    public Event<IHasEntity> OnEntityAssigned { get; } = new();
-    public event IStateEnable.EnabledChangedEventHandler? OnEnabledChanged = null;
+    public Event<IAssignable>? OnUnassigned { get; } = new();
 
     private bool _enabled = true;
     private IEntity _entity = null!;
@@ -21,7 +21,7 @@ public class StateEnable : IStateEnable
 
             bool previousState = _enabled;
             _enabled = value;
-            OnEnabledChanged?.Invoke(this, previousState);
+            OnEnabledChanged?.Invoke(this, new(previousState));
         }
     }
 

Engine.Core/Systems/DrawManager.cs

@@ -1,13 +1,15 @@
+using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
-public class DrawManager : UniverseObject
+public class DrawManager : Behaviour
 {
-    private static System.Comparison<IBehaviour> SortByPriority() => (x, y) => y.Priority.CompareTo(x.Priority);
+    // We use Descending order because draw calls are running from last to first
+    private static Comparer<IBehaviour> SortByDescendingPriority() => Comparer<IBehaviour>.Create((x, y) => y.Priority.CompareTo(x.Priority));
 
-    private readonly ActiveBehaviourCollectorSorted<IPreDraw> preDrawEntities = new() { SortBy = SortByPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IPreDraw> preDrawEntities = new() { SortBy = SortByDescendingPriority() };
-    private readonly ActiveBehaviourCollectorSorted<IDraw> drawEntities = new() { SortBy = SortByPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IDraw> drawEntities = new() { SortBy = SortByDescendingPriority() };
-    private readonly ActiveBehaviourCollectorSorted<IPostDraw> postDrawEntities = new() { SortBy = SortByPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IPostDraw> postDrawEntities = new() { SortBy = SortByDescendingPriority() };
 
     private void OnPreDraw(IUniverse sender)
     {
@@ -27,25 +29,25 @@ public class DrawManager : UniverseObject
             postDrawEntities[i].PostDraw();
     }
 
-    protected override void OnEnteringUniverse(IUniverse universe)
+    protected override void OnEnteredUniverse(IUniverse universe)
     {
         preDrawEntities.Assign(universe);
         drawEntities.Assign(universe);
         postDrawEntities.Assign(universe);
 
-        universe.OnPreDraw += OnPreDraw;
+        universe.OnPreDraw.AddListener(OnPreDraw);
-        universe.OnDraw += OnDraw;
+        universe.OnDraw.AddListener(OnDraw);
-        universe.OnPostDraw += OnPostDraw;
+        universe.OnPostDraw.AddListener(OnPostDraw);
     }
 
-    protected override void OnExitingUniverse(IUniverse universe)
+    protected override void OnExitedUniverse(IUniverse universe)
     {
         preDrawEntities.Unassign();
         drawEntities.Unassign();
         postDrawEntities.Unassign();
 
-        universe.OnPreDraw -= OnPreDraw;
+        universe.OnPreDraw.RemoveListener(OnPreDraw);
-        universe.OnDraw -= OnDraw;
+        universe.OnDraw.RemoveListener(OnDraw);
-        universe.OnPostDraw -= OnPostDraw;
+        universe.OnPostDraw.RemoveListener(OnPostDraw);
     }
 }

Engine.Core/Systems/UpdateManager.cs

@@ -1,44 +1,44 @@
-
 using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
-public class UpdateManager : UniverseObject
+public class UpdateManager : Behaviour
 {
-    private static System.Comparison<IBehaviour> SortByPriority() => (x, y) => y.Priority.CompareTo(x.Priority);
+    // We use Ascending order because draw calls are running from last to first
+    private static Comparer<IBehaviour> SortByAscendingPriority() => Comparer<IBehaviour>.Create((x, y) => x.Priority.CompareTo(y.Priority));
 
-    private readonly ActiveBehaviourCollectorSorted<IFirstFrameUpdate> firstFrameUpdates = new() { SortBy = SortByPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IFirstFrameUpdate> firstFrameUpdates = new() { SortBy = SortByAscendingPriority() };
-    private readonly ActiveBehaviourCollectorSorted<IPreUpdate> preUpdateEntities = new() { SortBy = SortByPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IPreUpdate> preUpdateEntities = new() { SortBy = SortByAscendingPriority() };
-    private readonly ActiveBehaviourCollectorSorted<IUpdate> updateEntities = new() { SortBy = SortByPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IUpdate> updateEntities = new() { SortBy = SortByAscendingPriority() };
-    private readonly ActiveBehaviourCollectorSorted<IPostUpdate> postUpdateEntities = new() { SortBy = SortByPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IPostUpdate> postUpdateEntities = new() { SortBy = SortByAscendingPriority() };
 
     private readonly List<IFirstFrameUpdate> toCallFirstFrameUpdates = new(32);
 
-    protected override void OnEnteringUniverse(IUniverse universe)
+    protected override void OnEnteredUniverse(IUniverse universe)
     {
         firstFrameUpdates.Assign(universe);
         preUpdateEntities.Assign(universe);
         updateEntities.Assign(universe);
         postUpdateEntities.Assign(universe);
 
-        universe.OnPreUpdate += OnPreUpdate;
+        universe.OnPreUpdate.AddListener(OnPreUpdate);
-        universe.OnUpdate += OnUpdate;
+        universe.OnUpdate.AddListener(OnUpdate);
-        universe.OnPostUpdate += OnPostUpdate;
+        universe.OnPostUpdate.AddListener(OnPostUpdate);
     }
 
-    protected override void OnExitingUniverse(IUniverse universe)
+    protected override void OnExitedUniverse(IUniverse universe)
     {
         firstFrameUpdates.Unassign();
         preUpdateEntities.Unassign();
         updateEntities.Unassign();
         postUpdateEntities.Unassign();
 
-        universe.OnPreUpdate -= OnPreUpdate;
+        universe.OnPreUpdate.RemoveListener(OnPreUpdate);
-        universe.OnUpdate -= OnUpdate;
+        universe.OnUpdate.RemoveListener(OnUpdate);
-        universe.OnPostUpdate -= OnPostUpdate;
+        universe.OnPostUpdate.RemoveListener(OnPostUpdate);
     }
 
-    private void OnPreUpdate(IUniverse sender, UniverseTime engineTime)
+    private void OnPreUpdate(IUniverse sender, IUniverse.UpdateArguments args)
     {
         for (int i = toCallFirstFrameUpdates.Count - 1; i >= 0; i--)
         {
@@ -50,25 +50,25 @@ public class UpdateManager : UniverseObject
             preUpdateEntities[i].PreUpdate();
     }
 
-    private void OnUpdate(IUniverse sender, UniverseTime engineTime)
+    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments args)
     {
         for (int i = updateEntities.Count - 1; i >= 0; i--)
             updateEntities[i].Update();
     }
 
-    private void OnPostUpdate(IUniverse sender, UniverseTime engineTime)
+    private void OnPostUpdate(IUniverse sender, IUniverse.UpdateArguments args)
     {
         for (int i = postUpdateEntities.Count - 1; i >= 0; i--)
             postUpdateEntities[i].PostUpdate();
     }
 
-    private void OnFirstFrameCollected(IBehaviourCollector<IFirstFrameUpdate> sender, IFirstFrameUpdate behaviourCollected)
+    private void OnFirstFrameCollected(IBehaviourCollector<IFirstFrameUpdate> sender, IBehaviourCollector<IFirstFrameUpdate>.BehaviourCollectedArguments args)
     {
-        toCallFirstFrameUpdates.Add(behaviourCollected);
+        toCallFirstFrameUpdates.Add(args.BehaviourCollected);
     }
 
     public UpdateManager()
     {
-        firstFrameUpdates.OnCollected += OnFirstFrameCollected;
+        firstFrameUpdates.OnCollected.AddListener(OnFirstFrameCollected);
     }
 }

Engine.Core/Transform2D.cs

@@ -5,9 +5,9 @@ namespace Syntriax.Engine.Core;
 [System.Diagnostics.DebuggerDisplay("Name: {UniverseObject.Name, nq} Position: {Position.ToString(), nq}, Scale: {Scale.ToString(), nq}, Rotation: {Rotation}")]
 public class Transform2D : Behaviour, ITransform2D
 {
-    public event ITransform2D.PositionChangedEventHandler? OnPositionChanged = null;
+    public Event<ITransform2D, ITransform2D.PositionChangedArguments> OnPositionChanged { get; } = new();
-    public event ITransform2D.ScaleChangedEventHandler? OnScaleChanged = null;
+    public Event<ITransform2D, ITransform2D.ScaleChangedArguments> OnScaleChanged { get; } = new();
-    public event ITransform2D.RotationChangedEventHandler? OnRotationChanged = null;
+    public Event<ITransform2D, ITransform2D.RotationChangedArguments> OnRotationChanged { get; } = new();
 
     private Vector2D _position = Vector2D.Zero;
     private Vector2D _scale = Vector2D.One;
@@ -19,6 +19,11 @@ public class Transform2D : Behaviour, ITransform2D
 
     private ITransform2D? parentTransform = null;
 
+    public Vector2D Up => Vector2D.Up.Rotate(Rotation * Math.DegreeToRadian);
+    public Vector2D Down => Vector2D.Down.Rotate(Rotation * Math.DegreeToRadian);
+    public Vector2D Left => Vector2D.Left.Rotate(Rotation * Math.DegreeToRadian);
+    public Vector2D Right => Vector2D.Right.Rotate(Rotation * Math.DegreeToRadian);
+
     public Vector2D Position
     {
         get => _position;
@@ -31,7 +36,7 @@ public class Transform2D : Behaviour, ITransform2D
             _position = value;
 
             UpdateLocalPosition();
-            OnPositionChanged?.Invoke(this, previousPosition);
+            OnPositionChanged?.Invoke(this, new(previousPosition));
         }
     }
 
@@ -47,7 +52,7 @@ public class Transform2D : Behaviour, ITransform2D
             _scale = value;
 
             UpdateLocalScale();
-            OnScaleChanged?.Invoke(this, previousScale);
+            OnScaleChanged?.Invoke(this, new(previousScale));
         }
     }
 
@@ -63,7 +68,7 @@ public class Transform2D : Behaviour, ITransform2D
             _rotation = value;
 
             UpdateLocalRotation();
-            OnRotationChanged?.Invoke(this, previousRotation);
+            OnRotationChanged?.Invoke(this, new(previousRotation));
         }
     }
 
@@ -79,7 +84,7 @@ public class Transform2D : Behaviour, ITransform2D
             _localPosition = value;
 
             UpdatePosition();
-            OnPositionChanged?.Invoke(this, previousPosition);
+            OnPositionChanged?.Invoke(this, new(previousPosition));
         }
     }
 
@@ -97,8 +102,8 @@ public class Transform2D : Behaviour, ITransform2D
 
             UpdateScale();
             UpdatePosition();
-            OnScaleChanged?.Invoke(this, previousScale);
+            OnScaleChanged?.Invoke(this, new(previousScale));
-            OnPositionChanged?.Invoke(this, previousPosition);
+            OnPositionChanged?.Invoke(this, new(previousPosition));
         }
     }
 
@@ -114,21 +119,21 @@ public class Transform2D : Behaviour, ITransform2D
             _localRotation = value;
 
             UpdateRotation();
-            OnRotationChanged?.Invoke(this, previousRotation);
+            OnRotationChanged?.Invoke(this, new(previousRotation));
         }
     }
 
-    private void RecalculatePosition(ITransform2D _, Vector2D previousPosition)
+    private void RecalculatePosition(ITransform2D _, ITransform2D.PositionChangedArguments args)
     {
         if (parentTransform is null)
             return;
 
         UpdatePosition();
 
-        OnPositionChanged?.Invoke(this, previousPosition);
+        OnPositionChanged?.Invoke(this, args);
     }
 
-    private void RecalculateScale(ITransform2D _, Vector2D previousScale)
+    private void RecalculateScale(ITransform2D _, ITransform2D.ScaleChangedArguments args)
     {
         if (parentTransform is null)
             return;
@@ -138,11 +143,11 @@ public class Transform2D : Behaviour, ITransform2D
         UpdateScale();
         UpdatePosition();
 
-        OnScaleChanged?.Invoke(this, previousScale);
+        OnScaleChanged?.Invoke(this, args);
-        OnPositionChanged?.Invoke(this, previousPosition);
+        OnPositionChanged?.Invoke(this, new(previousPosition));
     }
 
-    private void RecalculateRotation(ITransform2D _, float previousRotation)
+    private void RecalculateRotation(ITransform2D _, ITransform2D.RotationChangedArguments args)
     {
         if (parentTransform is null)
             return;
@@ -152,8 +157,8 @@ public class Transform2D : Behaviour, ITransform2D
         UpdateRotation();
         UpdatePosition();
 
-        OnRotationChanged?.Invoke(this, previousRotation);
+        OnRotationChanged?.Invoke(this, args);
-        OnPositionChanged?.Invoke(this, previousPosition);
+        OnPositionChanged?.Invoke(this, new(previousPosition));
     }
 
     private void UpdateLocalPosition()
@@ -207,12 +212,12 @@ public class Transform2D : Behaviour, ITransform2D
     protected override void InitializeInternal()
     {
         UpdateReferences(UniverseObject.Parent);
-        UniverseObject.OnParentChanged += OnParentChanged;
+        UniverseObject.OnParentChanged.AddListener(OnParentChanged);
     }
 
     protected override void FinalizeInternal()
     {
-        UniverseObject.OnParentChanged -= OnParentChanged;
+        UniverseObject.OnParentChanged.RemoveListener(OnParentChanged);
     }
 
     private void UpdateReferences(IUniverseObject? parent)
@@ -220,48 +225,48 @@ public class Transform2D : Behaviour, ITransform2D
         ITransform2D? previousParent = parentTransform;
         if (previousParent is not null)
         {
-            previousParent.OnPositionChanged -= RecalculatePosition;
+            previousParent.OnPositionChanged.RemoveListener(RecalculatePosition);
-            previousParent.OnScaleChanged -= RecalculateScale;
+            previousParent.OnScaleChanged.RemoveListener(RecalculateScale);
-            previousParent.OnRotationChanged -= RecalculateRotation;
+            previousParent.OnRotationChanged.RemoveListener(RecalculateRotation);
-            previousParent.BehaviourController.UniverseObject.OnParentChanged -= OnParentChanged;
+            previousParent.BehaviourController.UniverseObject.OnParentChanged.RemoveListener(OnParentChanged);
-            previousParent.BehaviourController.OnBehaviourAdded -= LookForTransform2D;
+            previousParent.BehaviourController.OnBehaviourAdded.RemoveListener(LookForTransform2D);
         }
 
         parentTransform = parent?.BehaviourController.GetBehaviour<ITransform2D>();
 
         if (parentTransform is not null)
         {
-            parentTransform.OnPositionChanged += RecalculatePosition;
+            parentTransform.OnPositionChanged.AddListener(RecalculatePosition);
-            parentTransform.OnScaleChanged += RecalculateScale;
+            parentTransform.OnScaleChanged.AddListener(RecalculateScale);
-            parentTransform.OnRotationChanged += RecalculateRotation;
+            parentTransform.OnRotationChanged.AddListener(RecalculateRotation);
-            parentTransform.BehaviourController.UniverseObject.OnParentChanged += OnParentChanged;
+            parentTransform.BehaviourController.UniverseObject.OnParentChanged.AddListener(OnParentChanged);
 
             UpdatePosition();
             UpdateScale();
             UpdateRotation();
         }
         else if (UniverseObject.Parent is not null)
-            UniverseObject.Parent.BehaviourController.OnBehaviourAdded += LookForTransform2D;
+            UniverseObject.Parent.BehaviourController.OnBehaviourAdded.AddListener(LookForTransform2D);
 
         UpdateLocalPosition();
         UpdateLocalScale();
         UpdateLocalRotation();
 
-        OnPositionChanged?.Invoke(this, Position);
+        OnPositionChanged?.Invoke(this, new(Position));
-        OnScaleChanged?.Invoke(this, Scale);
+        OnScaleChanged?.Invoke(this, new(Scale));
-        OnRotationChanged?.Invoke(this, Rotation);
+        OnRotationChanged?.Invoke(this, new(Rotation));
     }
 
-    private void LookForTransform2D(IBehaviourController sender, IBehaviour behaviourAdded)
+    private void LookForTransform2D(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (behaviourAdded is not ITransform2D transform2D)
+        if (args.BehaviourAdded is not ITransform2D)
             return;
 
         UpdateReferences(UniverseObject.Parent);
     }
 
-    private void OnParentChanged(IUniverseObject sender, IUniverseObject? previousParent, IUniverseObject? newParent)
+    private void OnParentChanged(IUniverseObject sender, IUniverseObject.ParentChangedArguments args)
     {
-        UpdateReferences(newParent);
+        UpdateReferences(args.CurrentParent);
     }
 }

Engine.Core/Universe.cs

@@ -7,21 +7,28 @@ namespace Syntriax.Engine.Core;
 [System.Diagnostics.DebuggerDisplay("UniverseObject Count: {_universeObjects.Count}")]
 public class Universe : BaseEntity, IUniverse
 {
-    public event IUniverse.UpdateEventHandler? OnPreUpdate = null;
+    public Event<IUniverse, IUniverse.UpdateArguments> OnPreUpdate { get; } = new();
-    public event IUniverse.UpdateEventHandler? OnUpdate = null;
+    public Event<IUniverse, IUniverse.UpdateArguments> OnUpdate { get; } = new();
-    public event IUniverse.UpdateEventHandler? OnPostUpdate = null;
+    public Event<IUniverse, IUniverse.UpdateArguments> OnPostUpdate { get; } = new();
-    public event IUniverse.DrawEventHandler? OnPreDraw = null;
+    public Event<IUniverse> OnPreDraw { get; } = new();
-    public event IUniverse.DrawEventHandler? OnDraw = null;
+    public Event<IUniverse> OnDraw { get; } = new();
-    public event IUniverse.DrawEventHandler? OnPostDraw = null;
+    public Event<IUniverse> OnPostDraw { get; } = new();
+    public Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments> OnUniverseObjectRegistered { get; } = new();
+    public Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments> OnUniverseObjectUnRegistered { get; } = new();
+    public Event<IUniverse, IUniverse.TimeScaleChangedArguments> OnTimeScaleChanged { get; } = new();
 
-    public event IUniverse.UniverseObjectRegisteredEventHandler? OnUniverseObjectRegistered = null;
+    private readonly Event<IInitializable>.EventHandler delegateOnUniverseObjectFinalize = null!;
-    public event IUniverse.UniverseObjectUnRegisteredEventHandler? OnUniverseObjectUnRegistered = null;
+    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler delegateOnUniverseObjectExitedUniverse = null!;
-
-    public event IUniverse.TimeScaleChangedEventHandler? OnTimeScaleChanged = null;
 
     private readonly List<IUniverseObject> _universeObjects = new(Constants.UNIVERSE_OBJECTS_SIZE_INITIAL);
     private float _timeScale = 1f;
 
+    public Universe()
+    {
+        delegateOnUniverseObjectFinalize = OnUniverseObjectFinalize;
+        delegateOnUniverseObjectExitedUniverse = OnUniverseObjectExitedUniverse;
+    }
+
     public IReadOnlyList<IUniverseObject> UniverseObjects => _universeObjects;
 
     public UniverseTime Time { get; private set; } = new();
@@ -37,7 +44,7 @@ public class Universe : BaseEntity, IUniverse
 
             float previousTimeScale = _timeScale;
             _timeScale = value;
-            OnTimeScaleChanged?.Invoke(this, previousTimeScale);
+            OnTimeScaleChanged?.Invoke(this, new(previousTimeScale));
         }
     }
 
@@ -46,8 +53,8 @@ public class Universe : BaseEntity, IUniverse
         if (_universeObjects.Contains(universeObject))
             throw new Exception($"{nameof(IUniverseObject)} named {universeObject.Name} is already registered to the {nameof(Universe)}.");
 
-        universeObject.OnFinalized += OnUniverseObjectFinalize;
+        universeObject.OnFinalized.AddListener(delegateOnUniverseObjectFinalize);
-        universeObject.OnExitedUniverse += OnUniverseObjectExitedUniverse;
+        universeObject.OnExitedUniverse.AddListener(delegateOnUniverseObjectExitedUniverse);
 
         if (!universeObject.Initialize())
             throw new Exception($"{universeObject.Name} can't be initialized");
@@ -60,7 +67,7 @@ public class Universe : BaseEntity, IUniverse
         if (!universeObject.EnterUniverse(this))
             throw new Exception($"{universeObject.Name} can't enter the universe");
 
-        OnUniverseObjectRegistered?.Invoke(this, universeObject);
+        OnUniverseObjectRegistered?.Invoke(this, new(universeObject));
     }
 
     public T InstantiateUniverseObject<T>(params object?[]? args) where T : class, IUniverseObject
@@ -81,8 +88,8 @@ public class Universe : BaseEntity, IUniverse
         if (!_universeObjects.Contains(universeObject))
             throw new Exception($"{nameof(IUniverseObject)} named {universeObject.Name} is not registered to the {nameof(Universe)}.");
 
-        universeObject.OnFinalized -= OnUniverseObjectFinalize;
+        universeObject.OnFinalized.RemoveListener(delegateOnUniverseObjectFinalize);
-        universeObject.OnExitedUniverse -= OnUniverseObjectExitedUniverse;
+        universeObject.OnExitedUniverse.RemoveListener(delegateOnUniverseObjectExitedUniverse);
 
         for (int i = universeObject.Children.Count - 1; i >= 0; i--)
             Remove(universeObject.Children[i]);
@@ -95,7 +102,7 @@ public class Universe : BaseEntity, IUniverse
         if (!universeObject.Finalize())
             throw new Exception($"{universeObject.Name} can't be finalized");
 
-        OnUniverseObjectUnRegistered?.Invoke(this, universeObject);
+        OnUniverseObjectUnRegistered?.Invoke(this, new(universeObject));
     }
 
     protected override void InitializeInternal()
@@ -118,9 +125,9 @@ public class Universe : BaseEntity, IUniverse
         UnscaledTime = engineTime;
         Time = new(TimeSpan.FromTicks((long)(Time.TimeSinceStart.Ticks + engineTime.DeltaSpan.Ticks * TimeScale)), TimeSpan.FromTicks((long)(engineTime.DeltaSpan.Ticks * TimeScale)));
 
-        OnPreUpdate?.Invoke(this, Time);
+        OnPreUpdate?.Invoke(this, new(Time));
-        OnUpdate?.Invoke(this, Time);
+        OnUpdate?.Invoke(this, new(Time));
-        OnPostUpdate?.Invoke(this, Time);
+        OnPostUpdate?.Invoke(this, new(Time));
     }
 
     public void Draw()
@@ -138,7 +145,7 @@ public class Universe : BaseEntity, IUniverse
             Remove(universeObject);
     }
 
-    private void OnUniverseObjectExitedUniverse(IUniverseObject sender, IUniverse universe)
+    private void OnUniverseObjectExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments args)
     {
         if (sender is IUniverseObject universeObject)
             Remove(universeObject);

Engine.Core/UniverseObject.cs

@@ -6,14 +6,15 @@ namespace Syntriax.Engine.Core;
 [System.Diagnostics.DebuggerDisplay("Name: {Name}, Initialized: {Initialized}")]
 public class UniverseObject : BaseEntity, IUniverseObject
 {
-    public event IUniverseObject.EnteredUniverseEventHandler? OnEnteredUniverse = null;
+    public Event<IUniverseObject, IUniverseObject.EnteredUniverseArguments> OnEnteredUniverse { get; } = new();
-    public event IUniverseObject.ExitedUniverseEventHandler? OnExitedUniverse = null;
+    public Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments> OnExitedUniverse { get; } = new();
-    public event IUniverseObject.ParentChangedEventHandler? OnParentChanged = null;
+    public Event<IUniverseObject, IUniverseObject.ParentChangedArguments> OnParentChanged { get; } = new();
-    public event IUniverseObject.ChildrenAddedEventHandler? OnChildrenAdded = null;
+    public Event<IUniverseObject, IUniverseObject.ChildrenAddedArguments> OnChildrenAdded { get; } = new();
-    public event IUniverseObject.ChildrenRemovedEventHandler? OnChildrenRemoved = null;
+    public Event<IUniverseObject, IUniverseObject.ChildrenRemovedArguments> OnChildrenRemoved { get; } = new();
-    public event IHasBehaviourController.BehaviourControllerAssignedEventHandler? OnBehaviourControllerAssigned = null;
+
-    public event INameable.NameChangedEventHandler? OnNameChanged = null;
+    public Event<IActive, IActive.ActiveChangedArguments> OnActiveChanged { get; } = new();
-    public event IActive.ActiveChangedEventHandler? OnActiveChanged = null;
+    public Event<INameable, INameable.NameChangedArguments> OnNameChanged { get; } = new();
+    public Event<IHasBehaviourController> OnBehaviourControllerAssigned { get; } = new();
 
     private string _name = nameof(UniverseObject);
     private IUniverse _universe = null!;
@@ -37,7 +38,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
 
             string previousName = _name;
             _name = value;
-            OnNameChanged?.Invoke(this, previousName);
+            OnNameChanged?.Invoke(this, new(previousName));
         }
     }
 
@@ -50,7 +51,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
         _universe = universe;
         UpdateActive();
         OnEnteringUniverse(universe);
-        OnEnteredUniverse?.Invoke(this, universe);
+        OnEnteredUniverse?.Invoke(this, new(universe));
         return true;
     }
 
@@ -62,7 +63,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
 
         OnExitingUniverse(universe);
         _universe = null!;
-        OnExitedUniverse?.Invoke(this, universe);
+        OnExitedUniverse?.Invoke(this, new(universe));
         return true;
     }
 
@@ -78,7 +79,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
         if (previousParent is not null)
         {
             previousParent.RemoveChild(this);
-            previousParent.OnActiveChanged -= OnParentActiveChanged;
+            previousParent.OnActiveChanged.RemoveListener(OnParentActiveChanged);
         }
 
         Parent = parent;
@@ -89,11 +90,11 @@ public class UniverseObject : BaseEntity, IUniverseObject
                 parent.Universe.Register(this);
 
             parent.AddChild(this);
-            parent.OnActiveChanged += OnParentActiveChanged;
+            parent.OnActiveChanged.AddListener(OnParentActiveChanged);
         }
 
         UpdateActive();
-        OnParentChanged?.Invoke(this, previousParent, parent);
+        OnParentChanged?.Invoke(this, new(previousParent, parent));
     }
 
     public void AddChild(IUniverseObject parent)
@@ -103,7 +104,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
 
         _children.Add(parent);
         parent.SetParent(this);
-        OnChildrenAdded?.Invoke(this, parent);
+        OnChildrenAdded?.Invoke(this, new(parent));
     }
 
     public void RemoveChild(IUniverseObject child)
@@ -112,7 +113,7 @@ public class UniverseObject : BaseEntity, IUniverseObject
             return;
 
         child.SetParent(null);
-        OnChildrenRemoved?.Invoke(this, child);
+        OnChildrenRemoved?.Invoke(this, new(child));
     }
 
     protected virtual void OnAssign(IBehaviourController behaviourController) { }
@@ -131,11 +132,11 @@ public class UniverseObject : BaseEntity, IUniverseObject
     {
         base.OnAssign(stateEnable);
 
-        stateEnable.OnEnabledChanged += OnStateEnabledChanged;
+        stateEnable.OnEnabledChanged.AddListener(OnStateEnabledChanged);
     }
 
-    private void OnParentActiveChanged(IActive sender, bool previousState) => UpdateActive();
+    private void OnParentActiveChanged(IActive sender, IActive.ActiveChangedArguments args) => UpdateActive();
-    private void OnStateEnabledChanged(IStateEnable sender, bool previousState) => UpdateActive();
+    private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments args) => UpdateActive();
 
     private void UpdateActive()
     {
@@ -143,13 +144,13 @@ public class UniverseObject : BaseEntity, IUniverseObject
         _isActive = StateEnable.Enabled && (Parent?.IsActive ?? true);
 
         if (previousActive != IsActive)
-            OnActiveChanged?.Invoke(this, previousActive);
+            OnActiveChanged?.Invoke(this, new(previousActive));
     }
 
     protected override void UnassignInternal()
     {
         base.UnassignInternal();
-        StateEnable.OnEnabledChanged -= OnStateEnabledChanged;
+        StateEnable.OnEnabledChanged.RemoveListener(OnStateEnabledChanged);
     }
 
     protected override void InitializeInternal()

Engine.Integration/Engine.Integration.MonoGame/Abstract/IDrawableSprite.cs

@@ -0,0 +1,8 @@
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public interface IDrawableSprite : IBehaviour
+{
+    void Draw(ISpriteBatch spriteBatch);
+}

Engine.Integration/Engine.Integration.MonoGame/Abstract/IDrawableTriangle.cs

@@ -0,0 +1,8 @@
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public interface IDrawableTriangle : IBehaviour
+{
+    void Draw(ITriangleBatch triangleBatch);
+}

Engine.Integration/Engine.Integration.MonoGame/Abstract/ISpriteBatch.cs

@@ -0,0 +1,29 @@
+using System.Text;
+
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public interface ISpriteBatch
+{
+    void Begin(SpriteSortMode sortMode = SpriteSortMode.Deferred, BlendState? blendState = null, SamplerState? samplerState = null, DepthStencilState? depthStencilState = null, RasterizerState? rasterizerState = null, Effect? effect = null, Matrix? transformMatrix = null);
+    void Draw(Texture2D texture, Vector2D position, AABB? sourceAABB, Color color, float rotation, Vector2D origin, Vector2D scale, SpriteEffects effects, float layerDepth);
+    void Draw(Texture2D texture, Vector2D position, AABB? sourceAABB, Color color, float rotation, Vector2D origin, float scale, SpriteEffects effects, float layerDepth);
+    void Draw(Texture2D texture, AABB destinationAABB, AABB? sourceAABB, Color color, float rotation, Vector2D origin, SpriteEffects effects, float layerDepth);
+    void Draw(Texture2D texture, Vector2D position, AABB? sourceAABB, Color color);
+    void Draw(Texture2D texture, AABB destinationAABB, AABB? sourceAABB, Color color);
+    void Draw(Texture2D texture, Vector2D position, Color color);
+    void Draw(Texture2D texture, AABB destinationAABB, Color color);
+    void DrawString(SpriteFont spriteFont, string text, Vector2D position, Color color);
+    void DrawString(SpriteFont spriteFont, string text, Vector2D position, Color color, float rotation, Vector2D origin, float scale, SpriteEffects effects, float layerDepth);
+    void DrawString(SpriteFont spriteFont, string text, Vector2D position, Color color, float rotation, Vector2D origin, Vector2D scale, SpriteEffects effects, float layerDepth);
+    void DrawString(SpriteFont spriteFont, string text, Vector2D position, Color color, float rotation, Vector2D origin, Vector2D scale, SpriteEffects effects, float layerDepth, bool rtl);
+    void DrawString(SpriteFont spriteFont, StringBuilder text, Vector2D position, Color color);
+    void DrawString(SpriteFont spriteFont, StringBuilder text, Vector2D position, Color color, float rotation, Vector2D origin, float scale, SpriteEffects effects, float layerDepth);
+    void DrawString(SpriteFont spriteFont, StringBuilder text, Vector2D position, Color color, float rotation, Vector2D origin, Vector2D scale, SpriteEffects effects, float layerDepth);
+    void DrawString(SpriteFont spriteFont, StringBuilder text, Vector2D position, Color color, float rotation, Vector2D origin, Vector2D scale, SpriteEffects effects, float layerDepth, bool rtl);
+    void End();
+}

Engine.Integration/Engine.Integration.MonoGame/Abstract/ITriangleBatch.cs

@@ -0,0 +1,12 @@
+using Microsoft.Xna.Framework;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public interface ITriangleBatch
+{
+    void Begin(Matrix? view = null, Matrix? projection = null);
+    void Draw(Triangle triangle, ColorRGBA colorRGBA);
+    void End();
+}

Engine.Integration/Engine.Integration.MonoGame/Behaviours/DrawableShapeBehaviour.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public class DrawableShapeBehaviour : Behaviour2D, IDrawableTriangle, IPreDraw
+{
+    private readonly Shape2D shape = new([]);
+    private readonly List<Triangle> worldTriangles = [];
+    private readonly Shape2D worldShape = new([]);
+    protected ColorRGB color = new(255, 255, 255);
+
+    public void PreDraw() => UpdateWorldShape();
+
+    public void Draw(ITriangleBatch triangleBatch)
+    {
+        worldShape.ToTrianglesConvex(worldTriangles);
+
+        foreach (Triangle triangle in worldTriangles)
+            triangleBatch.Draw(new(triangle.C, triangle.B, triangle.A), color);
+    }
+
+    protected void UpdateWorldShape() => shape.Transform(Transform, worldShape);
+
+    public DrawableShapeBehaviour() => shape = Shape2D.Triangle;
+    public DrawableShapeBehaviour(Shape2D shape) => this.shape = shape;
+    public DrawableShapeBehaviour(Shape2D shape, ColorRGB color) { this.shape = shape; this.color = color; }
+}

Engine.Integration/Engine.Integration.MonoGame/Behaviours/KeyboardInputsBehaviour.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+
+using Microsoft.Xna.Framework.Input;
+
+using Syntriax.Engine.Core;
+using Syntriax.Engine.Systems.Input;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public class KeyboardInputsBehaviour : Behaviour, IButtonInputs<Keys>, IUpdate
+{
+    public Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments> OnAnyButtonPressed { get; } = new();
+    public Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments> OnAnyButtonReleased { get; } = new();
+
+    private readonly Dictionary<Keys, Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments>> OnPressed = new(256);
+    private readonly Dictionary<Keys, Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments>> OnReleased = new(256);
+
+    private int cachePressedCurrentlyCount = 0;
+    private readonly Keys[] cachePressedCurrently = new Keys[256];
+
+    private int cachePressedPreviouslyCount = 0;
+    private readonly Keys[] cachePressedPreviously = new Keys[256];
+
+    public void RegisterOnPress(Keys key, Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments>.EventHandler callback)
+    {
+        if (!OnPressed.TryGetValue(key, out Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments>? delegateCallback))
+        {
+            delegateCallback = new();
+            OnPressed.Add(key, delegateCallback);
+        }
+
+        delegateCallback.AddListener(callback);
+    }
+
+    public void UnregisterOnPress(Keys key, Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments>.EventHandler callback)
+    {
+        if (OnPressed.TryGetValue(key, out Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments>? delegateCallback))
+            delegateCallback.RemoveListener(callback);
+    }
+
+    public void RegisterOnRelease(Keys key, Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments>.EventHandler callback)
+    {
+        if (!OnReleased.TryGetValue(key, out Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments>? delegateCallback))
+        {
+            delegateCallback = new();
+            OnReleased.Add(key, delegateCallback);
+        }
+
+        delegateCallback.AddListener(callback);
+    }
+
+    public void UnregisterOnRelease(Keys key, Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments>.EventHandler callback)
+    {
+        if (OnReleased.TryGetValue(key, out Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments>? delegateCallback))
+            delegateCallback.RemoveListener(callback);
+    }
+
+    public void Update()
+    {
+        KeyboardState keyboardState = Keyboard.GetState();
+        keyboardState.GetPressedKeys(cachePressedCurrently);
+        cachePressedCurrentlyCount = keyboardState.GetPressedKeyCount();
+
+        for (int i = 0; i < cachePressedCurrentlyCount; i++)
+        {
+            Keys currentlyPressedKey = cachePressedCurrently[i];
+
+            if (WasPressed(currentlyPressedKey))
+                continue;
+
+            if (OnPressed.TryGetValue(currentlyPressedKey, out Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments>? callback))
+                callback?.Invoke(this, new(currentlyPressedKey));
+
+            OnAnyButtonPressed?.Invoke(this, new(currentlyPressedKey));
+        }
+
+        for (int i = 0; i < cachePressedPreviouslyCount; i++)
+        {
+            Keys previouslyPressedKey = cachePressedPreviously[i];
+
+            if (IsPressed(previouslyPressedKey))
+                continue;
+
+            if (OnReleased.TryGetValue(previouslyPressedKey, out Event<IButtonInputs<Keys>, IButtonInputs<Keys>.ButtonCallbackArguments>? callback))
+                callback?.Invoke(this, new(previouslyPressedKey));
+
+            OnAnyButtonReleased?.Invoke(this, new(previouslyPressedKey));
+        }
+
+        Array.Copy(cachePressedCurrently, cachePressedPreviously, cachePressedCurrentlyCount);
+        cachePressedPreviouslyCount = cachePressedCurrentlyCount;
+    }
+
+    public bool IsPressed(Keys key)
+    {
+        for (int i = 0; i < cachePressedCurrentlyCount; i++)
+            if (cachePressedCurrently[i] == key)
+                return true;
+        return false;
+    }
+
+    private bool WasPressed(Keys key)
+    {
+        for (int i = 0; i < cachePressedPreviouslyCount; i++)
+            if (cachePressedPreviously[i] == key)
+                return true;
+        return false;
+    }
+}

Engine.Integration/Engine.Integration.MonoGame/Behaviours/MonoGameCamera2DBehaviour.cs

@@ -0,0 +1,109 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public class MonoGameCamera2DBehaviour : BehaviourBase, ICamera2D, IFirstFrameUpdate, IPreDraw
+{
+    public event MatrixTransformChangedArguments? OnMatrixTransformChanged = null;
+    public event ViewportChangedArguments? OnViewportChanged = null;
+    public event ZoomChangedArguments? OnZoomChanged = null;
+
+    private Matrix _matrixTransform = Matrix.Identity;
+
+    private Viewport _viewport = default;
+    private float _zoom = 1f;
+
+    public GraphicsDeviceManager Graphics { get; private set; } = null!;
+    public ITransform2D Transform { get; private set; } = null!;
+
+    public Matrix MatrixTransform
+    {
+        get => _matrixTransform;
+        set
+        {
+            if (_matrixTransform == value)
+                return;
+
+            _matrixTransform = value;
+            OnMatrixTransformChanged?.Invoke(this);
+        }
+    }
+
+    public Vector2D Position
+    {
+        get => Transform.Position;
+        set => Transform.Position = value;
+    }
+
+    public Viewport Viewport
+    {
+        get => _viewport;
+        set
+        {
+            if (_viewport.Equals(value))
+                return;
+
+            _viewport = value;
+            OnViewportChanged?.Invoke(this);
+        }
+    }
+
+    public float Zoom
+    {
+        get => _zoom;
+        set
+        {
+            float newValue = Syntriax.Engine.Core.Math.Max(0.1f, value);
+
+            if (_zoom == newValue)
+                return;
+
+            _zoom = newValue;
+            OnZoomChanged?.Invoke(this);
+        }
+    }
+
+    public float Rotation
+    {
+        get => Transform.Rotation;
+        set => Transform.Rotation = value;
+    }
+
+    // TODO This causes delay since OnPreDraw calls assuming this is called in in Update 
+    public Vector2D ScreenToWorldPosition(Vector2D screenPosition)
+    {
+        Vector2D worldPosition = Vector2.Transform(screenPosition.ToVector2(), Matrix.Invert(MatrixTransform)).ToVector2D();
+        return worldPosition.Scale(EngineConverterExtensions.screenScale);
+    }
+    public Vector2D WorldToScreenPosition(Vector2D worldPosition)
+    {
+        Vector2D screenPosition = Vector2.Transform(worldPosition.ToVector2(), MatrixTransform).ToVector2D();
+        return screenPosition.Scale(EngineConverterExtensions.screenScale);
+    }
+
+    public void FirstActiveFrame()
+    {
+        Graphics = BehaviourController.UniverseObject.Universe.FindRequiredBehaviour<MonoGameWindowContainer>().Window.Graphics;
+        Viewport = Graphics.GraphicsDevice.Viewport;
+    }
+
+    public void PreDraw()
+    {
+        MatrixTransform =
+            Matrix.CreateTranslation(new Vector3(-Position.X, Position.Y, 0f)) *
+            Matrix.CreateRotationZ(Rotation * Syntriax.Engine.Core.Math.DegreeToRadian) *
+            Matrix.CreateScale(Transform.Scale.X.Max(Transform.Scale.Y)) *
+            Matrix.CreateScale(Zoom) *
+            Matrix.CreateTranslation(new Vector3(_viewport.Width * .5f, _viewport.Height * .5f, 0f));
+    }
+
+    protected sealed override void InitializeInternal() => Transform = BehaviourController.GetRequiredBehaviour<ITransform2D>();
+    protected sealed override void FinalizeInternal() => Transform = null!;
+
+    public delegate void MatrixTransformChangedArguments(MonoGameCamera2DBehaviour sender);
+    public delegate void ViewportChangedArguments(MonoGameCamera2DBehaviour sender);
+    public delegate void ZoomChangedArguments(MonoGameCamera2DBehaviour sender);
+}

Engine.Integration/Engine.Integration.MonoGame/Behaviours/SpriteBatchWrapper.cs

@@ -0,0 +1,64 @@
+using System.Text;
+
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public class SpriteBatchWrapper(GraphicsDevice graphicsDevice) : ISpriteBatch
+{
+    private readonly SpriteBatch spriteBatch = new(graphicsDevice);
+
+    public void Begin(SpriteSortMode sortMode = SpriteSortMode.Deferred, BlendState? blendState = null, SamplerState? samplerState = null, DepthStencilState? depthStencilState = null, RasterizerState? rasterizerState = null, Effect? effect = null, Matrix? transformMatrix = null)
+        => spriteBatch.Begin(sortMode, blendState, samplerState, depthStencilState, rasterizerState, effect, transformMatrix);
+
+    public void Draw(Texture2D texture, Vector2D position, AABB? sourceAABB, Color color, float rotation, Vector2D origin, Vector2D scale, SpriteEffects effects, float layerDepth)
+        => spriteBatch.Draw(texture, position.ToDisplayVector2(), sourceAABB?.ToRectangle(), color, rotation, origin.ToDisplayVector2(), scale.ToDisplayVector2(), effects, layerDepth);
+
+    public void Draw(Texture2D texture, Vector2D position, AABB? sourceAABB, Color color, float rotation, Vector2D origin, float scale, SpriteEffects effects, float layerDepth)
+        => spriteBatch.Draw(texture, position.ToDisplayVector2(), sourceAABB?.ToRectangle(), color, rotation, origin.ToDisplayVector2(), scale, effects, layerDepth);
+
+    public void Draw(Texture2D texture, AABB destinationAABB, AABB? sourceAABB, Color color, float rotation, Vector2D origin, SpriteEffects effects, float layerDepth)
+        => spriteBatch.Draw(texture, destinationAABB.ToRectangle(), sourceAABB?.ToRectangle(), color, rotation, origin.ToDisplayVector2(), effects, layerDepth);
+
+    public void Draw(Texture2D texture, Vector2D position, AABB? sourceAABB, Color color)
+        => spriteBatch.Draw(texture, position.ToDisplayVector2(), sourceAABB?.ToRectangle(), color);
+
+    public void Draw(Texture2D texture, AABB destinationAABB, AABB? sourceAABB, Color color)
+        => spriteBatch.Draw(texture, destinationAABB.ToRectangle(), sourceAABB?.ToRectangle(), color);
+
+    public void Draw(Texture2D texture, Vector2D position, Color color)
+        => spriteBatch.Draw(texture, position.ToDisplayVector2(), color);
+
+    public void Draw(Texture2D texture, AABB destinationAABB, Color color)
+        => spriteBatch.Draw(texture, destinationAABB.ToRectangle(), color);
+
+    public void DrawString(SpriteFont spriteFont, string text, Vector2D position, Color color)
+        => spriteBatch.DrawString(spriteFont, text, position.ToDisplayVector2(), color);
+
+    public void DrawString(SpriteFont spriteFont, string text, Vector2D position, Color color, float rotation, Vector2D origin, float scale, SpriteEffects effects, float layerDepth)
+        => spriteBatch.DrawString(spriteFont, text, position.ToDisplayVector2(), color, rotation, origin.ToDisplayVector2(), scale, effects, layerDepth);
+
+    public void DrawString(SpriteFont spriteFont, string text, Vector2D position, Color color, float rotation, Vector2D origin, Vector2D scale, SpriteEffects effects, float layerDepth)
+        => spriteBatch.DrawString(spriteFont, text, position.ToDisplayVector2(), color, rotation, origin.ToDisplayVector2(), scale.ToDisplayVector2(), effects, layerDepth);
+
+    public void DrawString(SpriteFont spriteFont, string text, Vector2D position, Color color, float rotation, Vector2D origin, Vector2D scale, SpriteEffects effects, float layerDepth, bool rtl)
+        => spriteBatch.DrawString(spriteFont, text, position.ToDisplayVector2(), color, rotation, origin.ToDisplayVector2(), scale.ToDisplayVector2(), effects, layerDepth, rtl);
+
+    public void DrawString(SpriteFont spriteFont, StringBuilder text, Vector2D position, Color color)
+        => spriteBatch.DrawString(spriteFont, text, position.ToDisplayVector2(), color);
+
+    public void DrawString(SpriteFont spriteFont, StringBuilder text, Vector2D position, Color color, float rotation, Vector2D origin, float scale, SpriteEffects effects, float layerDepth)
+        => spriteBatch.DrawString(spriteFont, text, position.ToDisplayVector2(), color, rotation, origin.ToDisplayVector2(), scale, effects, layerDepth);
+
+    public void DrawString(SpriteFont spriteFont, StringBuilder text, Vector2D position, Color color, float rotation, Vector2D origin, Vector2D scale, SpriteEffects effects, float layerDepth)
+        => spriteBatch.DrawString(spriteFont, text, position.ToDisplayVector2(), color, rotation, origin.ToDisplayVector2(), scale.ToDisplayVector2(), effects, layerDepth);
+
+    public void DrawString(SpriteFont spriteFont, StringBuilder text, Vector2D position, Color color, float rotation, Vector2D origin, Vector2D scale, SpriteEffects effects, float layerDepth, bool rtl)
+        => spriteBatch.DrawString(spriteFont, text, position.ToDisplayVector2(), color, rotation, origin.ToDisplayVector2(), scale.ToDisplayVector2(), effects, layerDepth, rtl);
+
+    public void End()
+        => spriteBatch.End();
+}

Engine.Integration/Engine.Integration.MonoGame/Behaviours/SpriteBatcher.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public class SpriteBatcher : BehaviourBase, IFirstFrameUpdate, IDraw
+{
+    private static Comparer<IBehaviour> SortByPriority() => Comparer<IBehaviour>.Create((x, y) => y.Priority.CompareTo(x.Priority));
+
+    private ISpriteBatch spriteBatch = null!;
+    private MonoGameCamera2DBehaviour camera2D = null!;
+
+    private readonly ActiveBehaviourCollectorSorted<IDrawableSprite> drawableSprites = new() { SortBy = SortByPriority() };
+
+    public void FirstActiveFrame()
+    {
+        MonoGameWindowContainer windowContainer = Universe.FindRequiredBehaviour<MonoGameWindowContainer>();
+        camera2D = Universe.FindRequiredBehaviour<MonoGameCamera2DBehaviour>();
+
+        spriteBatch = new SpriteBatchWrapper(windowContainer.Window.GraphicsDevice);
+        drawableSprites.Unassign();
+        drawableSprites.Assign(Universe);
+    }
+
+    public void Draw()
+    {
+        spriteBatch.Begin(transformMatrix: camera2D.MatrixTransform);
+        for (int i = 0; i < drawableSprites.Count; i++)
+            drawableSprites[i].Draw(spriteBatch);
+        spriteBatch.End();
+    }
+}

Engine.Integration/Engine.Integration.MonoGame/Behaviours/TriangleBatcher.cs

@@ -0,0 +1,38 @@
+using System.Collections.Generic;
+
+using Microsoft.Xna.Framework;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public class TriangleBatcher : BehaviourBase, ITriangleBatch, IFirstFrameUpdate, IDraw
+{
+    private static Comparer<IBehaviour> SortByAscendingPriority() => Comparer<IBehaviour>.Create((x, y) => x.Priority.CompareTo(y.Priority));
+
+    private TriangleBatch triangleBatch = null!;
+    private MonoGameCamera2DBehaviour camera2D = null!;
+    private readonly ActiveBehaviourCollectorSorted<IDrawableTriangle> drawableShapes = new() { SortBy = SortByAscendingPriority() };
+
+    public void FirstActiveFrame()
+    {
+        MonoGameWindowContainer windowContainer = BehaviourController.UniverseObject.Universe.FindRequiredBehaviour<MonoGameWindowContainer>();
+        camera2D = BehaviourController.UniverseObject.Universe.FindRequiredBehaviour<MonoGameCamera2DBehaviour>();
+
+        triangleBatch = new(windowContainer.Window.GraphicsDevice);
+        drawableShapes.Unassign();
+        drawableShapes.Assign(BehaviourController.UniverseObject.Universe);
+    }
+
+    public void Draw()
+    {
+        triangleBatch.Begin(camera2D.MatrixTransform);
+        for (int i = 0; i < drawableShapes.Count; i++)
+            drawableShapes[i].Draw(triangleBatch);
+        triangleBatch.End();
+    }
+
+    public void Begin(Matrix? view = null, Matrix? projection = null) => triangleBatch.Begin(view, projection);
+    public void Draw(Triangle triangle, ColorRGBA colorRGBA) => triangleBatch.Draw(triangle, colorRGBA);
+    public void End() => triangleBatch.End();
+}

Engine.Integration/Engine.Integration.MonoGame/Engine.Integration.MonoGame.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>disable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <RootNamespace>Syntriax.Engine.Integration.MonoGame</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="MonoGame.Framework.DesktopGL" Version="3.8.2.1105">
+      <PrivateAssets>All</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Engine\Engine.csproj" />
+  </ItemGroup>
+</Project>

Engine.Integration/Engine.Integration.MonoGame/EngineConverter.cs

@@ -0,0 +1,52 @@
+using System.Runtime.CompilerServices;
+
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public static class EngineConverterExtensions
+{
+    public readonly static Vector2D screenScale = Vector2D.Down + Vector2D.Right;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static UniverseTime ToEngineTime(this GameTime gameTime) => new(gameTime.TotalGameTime, gameTime.ElapsedGameTime);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector2D ToVector2D(this Vector2 vector) => new(vector.X, vector.Y);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Color ToColor(this ColorRGBA rgba) => new(rgba.R, rgba.G, rgba.B, rgba.A);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector2D ToVector2D(this Point point) => new(point.X, point.Y);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector2 ToVector2(this Vector2D vector) => new(vector.X, vector.Y);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector2 ToDisplayVector2(this Vector2D vector) => vector.Scale(screenScale).ToVector2();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector2D ApplyDisplayScale(this Vector2D vector) => vector.Scale(screenScale);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rectangle ToDisplayRectangle(this Rectangle rectangle, DisplayMode displayMode) => new()
+    {
+        X = rectangle.X,
+        Y = displayMode.Height - rectangle.Y - rectangle.Height,
+        Width = rectangle.Width,
+        Height = rectangle.Height
+    };
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Rectangle ToRectangle(this AABB aabb) => new()
+    {
+        X = (int)(aabb.LowerBoundary.X * screenScale.X),
+        Y = (int)(aabb.LowerBoundary.Y * screenScale.Y),
+        Width = (int)(aabb.UpperBoundary.X - aabb.LowerBoundary.X),
+        Height = (int)(aabb.UpperBoundary.Y - aabb.LowerBoundary.Y)
+    };
+}

Engine.Integration/Engine.Integration.MonoGame/MonoGameWindow.cs

@@ -0,0 +1,48 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public class MonoGameWindow : Game
+{
+    public GraphicsDeviceManager Graphics { get; protected set; } = null!;
+    public IUniverse Universe { get; protected set; } = null!;
+    public ColorRGB BackgroundColor { get; set; } = new ColorRGB(35, 20, 35);
+
+    public MonoGameWindow(IUniverse? universe = null)
+    {
+        Preserver.Preserve();
+        Graphics = new GraphicsDeviceManager(this);
+        Content.RootDirectory = "Content";
+        IsMouseVisible = true;
+        Universe = universe ?? new Universe();
+
+        Universe.InstantiateUniverseObject().SetUniverseObject("Window Container")
+            .BehaviourController.AddBehaviour<MonoGameWindowContainer>(this);
+    }
+
+    protected override void Initialize()
+    {
+        Universe.Initialize();
+
+        base.Initialize();
+    }
+
+    protected override void Update(GameTime gameTime)
+    {
+        Universe.Update(gameTime.ToEngineTime());
+
+        base.Update(gameTime);
+    }
+
+    protected override void Draw(GameTime gameTime)
+    {
+        GraphicsDevice.Clear(((ColorRGBA)BackgroundColor).ToColor());
+
+        Universe.Draw();
+
+        base.Draw(gameTime);
+    }
+}

Engine.Integration/Engine.Integration.MonoGame/TriangleBatch.cs

@@ -0,0 +1,74 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public class TriangleBatch : ITriangleBatch
+{
+    private readonly GraphicsDevice graphicsDevice;
+    private VertexBuffer vertexBuffer = default!;
+    private readonly VertexPositionColor[] vertices = new VertexPositionColor[1024];
+    private int verticesIndex = 0;
+    private Matrix _view;
+    private Matrix _projection;
+    private readonly BasicEffect basicEffect;
+
+    public TriangleBatch(GraphicsDevice graphicsDevice)
+    {
+        this.graphicsDevice = graphicsDevice;
+        this.graphicsDevice.RasterizerState = new RasterizerState() { CullMode = CullMode.None };
+        basicEffect = new(graphicsDevice);
+        basicEffect.VertexColorEnabled = true;
+    }
+
+    public void Draw(Triangle triangle, ColorRGBA colorRGBA)
+    {
+        if (verticesIndex + 3 >= vertices.Length)
+            Flush();
+
+        Vector2 A = triangle.A.ToDisplayVector2();
+        Vector2 B = triangle.B.ToDisplayVector2();
+        Vector2 C = triangle.C.ToDisplayVector2();
+        Color color = colorRGBA.ToColor();
+
+        vertices[verticesIndex++] = new(new(A.X, A.Y, 0f), color);
+        vertices[verticesIndex++] = new(new(B.X, B.Y, 0f), color);
+        vertices[verticesIndex++] = new(new(C.X, C.Y, 0f), color);
+    }
+
+    public void Begin(Matrix? view = null, Matrix? projection = null)
+    {
+        if (view != null)
+            _view = view.Value;
+        else
+            _view = Matrix.Identity;
+
+        if (projection != null)
+            _projection = projection.Value;
+        else
+        {
+            Viewport viewport = graphicsDevice.Viewport;
+            _projection = Matrix.CreateOrthographicOffCenter(viewport.X, viewport.Width, viewport.Height, viewport.Y, 0, 1);
+        }
+    }
+
+    public void End() => Flush();
+
+    private void Flush()
+    {
+        basicEffect.Projection = _projection;
+        basicEffect.View = _view;
+        vertexBuffer = new VertexBuffer(graphicsDevice, typeof(VertexPositionColor), 1024, BufferUsage.WriteOnly);
+        vertexBuffer.SetData(vertices);
+
+        graphicsDevice.SetVertexBuffer(vertexBuffer);
+
+        foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes)
+            pass.Apply();
+        graphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, 0, verticesIndex / 3);
+
+        verticesIndex = 0;
+    }
+}

Engine.Integration/Engine.Integration.MonoGame/UniverseObjects/MonoGameWindowContainer.cs

@@ -0,0 +1,10 @@
+using Syntriax.Engine.Core;
+using Syntriax.Engine.Core.Serialization;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+[IgnoreSerialization]
+public class MonoGameWindowContainer(MonoGameWindow GameWindow) : BehaviourBase
+{
+    public MonoGameWindow Window { get; } = GameWindow;
+}

Engine.Physics2D/Abstract/ICollider2D.cs

@@ -10,17 +10,17 @@ public interface ICollider2D : IBehaviour
     /// <summary>
     /// Event triggered when a collision is detected.
     /// </summary>
-    event CollisionDetectedEventHandler? OnCollisionDetected;
+    Event<ICollider2D, CollisionDetectionInformation> OnCollisionDetected { get; }
 
     /// <summary>
     /// Event triggered when a collision is resolved.
     /// </summary>
-    event CollisionResolvedEventHandler? OnCollisionResolved;
+    Event<ICollider2D, CollisionDetectionInformation> OnCollisionResolved { get; }
 
     /// <summary>
     /// Event triggered when another <see cref="ICollider2D"/> triggers this <see cref="ICollider2D"/>.
     /// </summary>
-    event TriggeredEventHandler? OnTriggered;
+    Event<ICollider2D, ICollider2D> OnTriggered { get; }
 
     /// <inheritdoc cref="ITransform2D" />
     ITransform2D Transform { get; }
@@ -44,7 +44,7 @@ public interface ICollider2D : IBehaviour
     void Resolve(CollisionDetectionInformation collisionDetectionInformation);
     void Trigger(ICollider2D initiator);
 
-    delegate void CollisionDetectedEventHandler(ICollider2D sender, CollisionDetectionInformation collisionDetectionInformation);
+    readonly record struct CollisionDetectedArguments(ICollider2D Sender, CollisionDetectionInformation CollisionDetectionInformation);
-    delegate void CollisionResolvedEventHandler(ICollider2D sender, CollisionDetectionInformation collisionDetectionInformation);
+    readonly record struct CollisionResolvedArguments(ICollider2D Sender, CollisionDetectionInformation CollisionDetectionInformation);
-    delegate void TriggeredEventHandler(ICollider2D sender, ICollider2D initiatorCollider);
+    readonly record struct TriggeredArguments(ICollider2D Sender, ICollider2D InitiatorCollider);
 }

Engine.Physics2D/Abstract/IPhysicsEngine2D.cs

@@ -1,3 +1,7 @@
+using System.Collections.Generic;
+
+using Syntriax.Engine.Core;
+
 namespace Syntriax.Engine.Physics2D;
 
 /// <summary>
@@ -8,12 +12,12 @@ public interface IPhysicsEngine2D
     /// <summary>
     /// Event triggered when the <see cref="IPhysicsEngine2D"/> has done a single physics iteration.
     /// </summary>
-    event PhysicsIterationEventHandler? OnPhysicsIteration;
+    Event<IPhysicsEngine2D, float> OnPhysicsIteration { get; }
 
     /// <summary>
     /// Event triggered when the <see cref="IPhysicsEngine2D"/> has done a full physics step/>.
     /// </summary>
-    event PhysicsStepEventHandler? OnPhysicsStep;
+    Event<IPhysicsEngine2D, float> OnPhysicsStep { get; }
 
     /// <summary>
     /// The number of iterations the <see cref="IPhysicsEngine2D"/> performs per step.
@@ -33,6 +37,26 @@ public interface IPhysicsEngine2D
     /// <param name="deltaTime">The time step.</param>
     void StepIndividual(IRigidBody2D rigidBody, float deltaTime);
 
-    delegate void PhysicsIterationEventHandler(IPhysicsEngine2D sender, float iterationDeltaTime);
+    /// <summary>
-    delegate void PhysicsStepEventHandler(IPhysicsEngine2D sender, float stepDeltaTime);
+    /// Casts a <see cref="Ray2D"/> into the scene and returns the closest <see cref="RaycastResult"/> it hits, if any.
+    /// </summary>
+    /// <param name="ray">The <see cref="Ray2D"/> to cast.</param>
+    /// <param name="length">The maximum distance to check for intersections. Defaults to <see cref="float.MaxValue"/>.</param>
+    /// <returns>
+    /// A <see cref="RaycastResult"/> containing information about the hit, or <see cref="null"/> if no hit was detected.
+    /// </returns>
+    RaycastResult? Raycast(Ray2D ray, float length = float.MaxValue);
+
+    /// <summary>
+    /// Casts a <see cref="Ray2D"/> into the scene and stores all hit results in the provided list.
+    /// </summary>
+    /// <param name="ray">The <see cref="Ray2D"/> to cast.</param>
+    /// <param name="results">
+    /// A list to which all <see cref="RaycastResult"/>s will be added. The list will be populated with zero or more <see cref="RaycastResult"/> objects.
+    /// </param>
+    /// <param name="length">The maximum distance to check for intersections. Defaults to <see cref="float.MaxValue"/>.</param>
+    void Raycast(Ray2D ray, IList<RaycastResult> results, float length = float.MaxValue);
+
+    readonly record struct PhysicsIterationArguments(IPhysicsEngine2D Sender, float IterationDeltaTime);
+    readonly record struct PhysicsStepArguments(IPhysicsEngine2D Sender, float StepDeltaTime);
 }

Engine.Physics2D/Abstract/IRaycastResolver2D.cs

@@ -0,0 +1,23 @@
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Physics2D;
+
+/// <summary>
+/// Represents a 2D raycast resolver.
+/// </summary>
+public interface IRaycastResolver2D
+{
+    /// <summary>
+    /// Casts a <see cref="Ray2D"/> against a specific <see cref="ICollider2D"/> shape and returns the first hit, if any.
+    /// </summary>
+    /// <typeparam name="T">The type of the <see cref="ICollider2D"/>, which must implement <see cref="ICollider2D"/>.</typeparam>
+    /// <param name="shape">The <see cref="ICollider2D"/> shape to test against.</param>
+    /// <param name="ray">The <see cref="Ray2D"/> to cast.</param>
+    /// <param name="length">
+    /// The maximum distance to check along the <see cref="Ray2D"/>. Defaults to <see cref="float.MaxValue"/>.
+    /// </param>
+    /// <returns>
+    /// A <see cref="RaycastResult"/> containing information about the intersection, or <see cref="null"/> if there was no hit.
+    /// </returns>
+    RaycastResult? RaycastAgainst<T>(T shape, Ray2D ray, float length = float.MaxValue) where T : ICollider2D;
+}

Engine.Physics2D/Abstract/RaycastResult.cs

@@ -0,0 +1,14 @@
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Physics2D;
+
+public readonly struct RaycastResult(Ray2D ray, ICollider2D collider2D, Vector2D position, Vector2D normal)
+{
+    public readonly Ray2D Ray = ray;
+
+    public readonly Vector2D Position = position;
+    public readonly Vector2D Normal = normal;
+
+    public readonly ICollider2D Collider2D = collider2D;
+    public readonly RigidBody2D? RigidBody2D = collider2D.BehaviourController.GetBehaviourInParent<RigidBody2D>();
+}

Engine.Physics2D/Abstract/Updates/IPhysicsIteration.cs

@@ -0,0 +1,15 @@
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Physics2D;
+
+/// <summary>
+/// Represents a <see cref="IBehaviour"/> that listens to physics simulation update phase.
+/// </summary>
+public interface IPhysicsIteration : IBehaviour
+{
+    /// <summary>
+    /// Iterates the physics state of the object based on the elapsed time since the last iteration.
+    /// </summary>
+    /// <param name="delta">The time elapsed since the last physics iteration.</param>
+    void PhysicsIterate(float delta);
+}

Engine.Physics2D/Abstract/Updates/IPhysicsUpdate.cs

@@ -10,6 +10,6 @@ public interface IPhysicsUpdate : IBehaviour
     /// <summary>
     /// Updates the physics state of the object based on the elapsed time since the last update.
     /// </summary>
-    /// <param name="delta">The time elapsed since the last physics update, typically in seconds.</param>
+    /// <param name="delta">The time elapsed since the last physics update.</param>
     void PhysicsUpdate(float delta);
 }

Engine.Physics2D/Abstract/Updates/IPostPhysicsUpdate.cs

@@ -10,6 +10,6 @@ public interface IPostPhysicsUpdate : IBehaviour
     /// <summary>
     /// Execute logic that should occur after the physics simulation has been updated.
     /// </summary>
-    /// <param name="delta">The time elapsed since the last physics update, typically in seconds.</param>
+    /// <param name="delta">The time elapsed since the last physics update.</param>
     void PostPhysicsUpdate(float delta);
 }

Engine.Physics2D/Abstract/Updates/IPrePhysicsUpdate.cs

@@ -10,6 +10,6 @@ public interface IPrePhysicsUpdate : IBehaviour
     /// <summary>
     /// Execute logic that should occur before the physics simulation is updated.
     /// </summary>
-    /// <param name="delta">The time elapsed since the last physics update, typically in seconds.</param>
+    /// <param name="delta">The time elapsed since the last physics update.</param>
     void PrePhysicsUpdate(float delta);
 }

Engine.Physics2D/Collider2DBehaviourBase.cs

@@ -4,13 +4,30 @@ namespace Syntriax.Engine.Physics2D;
 
 public abstract class Collider2DBehaviourBase : Behaviour2D, ICollider2D
 {
-    public event ICollider2D.CollisionDetectedEventHandler? OnCollisionDetected = null;
+    public Event<ICollider2D, CollisionDetectionInformation> OnCollisionDetected { get; } = new();
-    public event ICollider2D.CollisionResolvedEventHandler? OnCollisionResolved = null;
+    public Event<ICollider2D, CollisionDetectionInformation> OnCollisionResolved { get; } = new();
-    public event ICollider2D.TriggeredEventHandler? OnTriggered = null;
+    public Event<ICollider2D, ICollider2D> OnTriggered { get; } = new();
+
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAddedToController = null!;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler delegateOnBehaviourRemovedFromController = null!;
+    private readonly Event<ITransform2D, ITransform2D.PositionChangedArguments>.EventHandler delegateSetNeedsRecalculationFromPosition = null!;
+    private readonly Event<ITransform2D, ITransform2D.RotationChangedArguments>.EventHandler delegateSetNeedsRecalculationFromRotation = null!;
+    private readonly Event<ITransform2D, ITransform2D.ScaleChangedArguments>.EventHandler delegateSetNeedsRecalculationFromScale = null!;
+    private readonly Event<IUniverseObject, IUniverseObject.ParentChangedArguments>.EventHandler delegateUpdateRigidBody2D = null!;
 
     protected bool NeedsRecalculation { get; set; } = true;
     protected IRigidBody2D? _rigidBody2D = null;
 
+    protected Collider2DBehaviourBase()
+    {
+        delegateOnBehaviourAddedToController = OnBehaviourAddedToController;
+        delegateOnBehaviourRemovedFromController = OnBehaviourRemovedFromController;
+        delegateSetNeedsRecalculationFromPosition = SetNeedsRecalculationFromPosition;
+        delegateSetNeedsRecalculationFromRotation = SetNeedsRecalculationFromRotation;
+        delegateSetNeedsRecalculationFromScale = SetNeedsRecalculationFromScale;
+        delegateUpdateRigidBody2D = UpdateRigidBody2D;
+    }
+
     public IRigidBody2D? RigidBody2D => _rigidBody2D;
     public bool IsTrigger { get; set; } = false;
 
@@ -27,46 +44,50 @@ public abstract class Collider2DBehaviourBase : Behaviour2D, ICollider2D
 
     protected override void OnInitialize()
     {
+        base.OnInitialize();
+
         BehaviourController.TryGetBehaviourInParent(out _rigidBody2D);
 
-        BehaviourController.OnBehaviourAdded += OnBehaviourAddedToController;
+        BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAddedToController);
-        BehaviourController.OnBehaviourRemoved += OnBehaviourRemovedFromController;
+        BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemovedFromController);
 
-        Transform.OnPositionChanged += SetNeedsRecalculationFromPosition;
+        Transform.OnPositionChanged.AddListener(delegateSetNeedsRecalculationFromPosition);
-        Transform.OnRotationChanged += SetNeedsRecalculationFromRotation;
+        Transform.OnRotationChanged.AddListener(delegateSetNeedsRecalculationFromRotation);
-        Transform.OnScaleChanged += SetNeedsRecalculationFromScale;
+        Transform.OnScaleChanged.AddListener(delegateSetNeedsRecalculationFromScale);
-        UniverseObject.OnParentChanged += UpdateRigidBody2D;
+        UniverseObject.OnParentChanged.AddListener(delegateUpdateRigidBody2D);
     }
 
-    private void UpdateRigidBody2D(IUniverseObject sender, IUniverseObject? previousParent, IUniverseObject? newParent)
+    private void UpdateRigidBody2D(IUniverseObject sender, IUniverseObject.ParentChangedArguments args)
     {
         BehaviourController.TryGetBehaviourInParent(out _rigidBody2D);
     }
 
-    private void OnBehaviourAddedToController(IBehaviourController _, IBehaviour behaviour)
+    private void OnBehaviourAddedToController(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (behaviour is IRigidBody2D rigidBody)
+        if (args.BehaviourAdded is IRigidBody2D rigidBody)
             _rigidBody2D = rigidBody;
     }
 
-    private void OnBehaviourRemovedFromController(IBehaviourController _, IBehaviour behaviour)
+    private void OnBehaviourRemovedFromController(IBehaviourController sender, IBehaviourController.BehaviourRemovedArguments args)
     {
-        if (behaviour is IRigidBody2D _)
+        if (args.BehaviourRemoved is IRigidBody2D)
             _rigidBody2D = null;
     }
 
-    private void SetNeedsRecalculationFromScale(ITransform2D sender, Vector2D previousScale) => NeedsRecalculation = true;
+    private void SetNeedsRecalculationFromPosition(ITransform2D sender, ITransform2D.PositionChangedArguments args) => NeedsRecalculation = true;
-    private void SetNeedsRecalculationFromPosition(ITransform2D sender, Vector2D previousPosition) => NeedsRecalculation = true;
+    private void SetNeedsRecalculationFromScale(ITransform2D sender, ITransform2D.ScaleChangedArguments args) => NeedsRecalculation = true;
-    private void SetNeedsRecalculationFromRotation(ITransform2D sender, float previousRotation) => NeedsRecalculation = true;
+    private void SetNeedsRecalculationFromRotation(ITransform2D sender, ITransform2D.RotationChangedArguments args) => NeedsRecalculation = true;
 
     protected override void OnFinalize()
     {
-        BehaviourController.OnBehaviourAdded -= OnBehaviourAddedToController;
+        base.OnFinalize();
-        BehaviourController.OnBehaviourRemoved -= OnBehaviourRemovedFromController;
-        Transform.OnScaleChanged -= SetNeedsRecalculationFromScale;
 
-        Transform.OnPositionChanged -= SetNeedsRecalculationFromPosition;
+        BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAddedToController);
-        Transform.OnRotationChanged -= SetNeedsRecalculationFromRotation;
+        BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemovedFromController);
+        Transform.OnScaleChanged.RemoveListener(delegateSetNeedsRecalculationFromScale);
+
+        Transform.OnPositionChanged.RemoveListener(delegateSetNeedsRecalculationFromPosition);
+        Transform.OnRotationChanged.RemoveListener(delegateSetNeedsRecalculationFromRotation);
     }
 
     public void Detect(CollisionDetectionInformation collisionDetectionInformation) => OnCollisionDetected?.Invoke(this, collisionDetectionInformation);

Engine.Physics2D/PhysicsCoroutineManager.cs

@@ -5,10 +5,9 @@ using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Physics2D;
 
-public class PhysicsCoroutineManager : UniverseObject
+public class PhysicsCoroutineManager : Behaviour, IPhysicsUpdate
 {
     private readonly List<IEnumerator> enumerators = [];
-    private IPhysicsEngine2D? physicsEngine = null;
 
     public IEnumerator CreateCoroutine(IEnumerator enumerator)
     {
@@ -21,16 +20,7 @@ public class PhysicsCoroutineManager : UniverseObject
         enumerators.Remove(enumerator);
     }
 
-    protected override void OnEnteringUniverse(IUniverse universe)
+    public void PhysicsUpdate(float delta)
-    {
-        physicsEngine = universe.GetUniverseObject<IPhysicsEngine2D>();
-        if (physicsEngine is IPhysicsEngine2D foundPhysicsEngine)
-            foundPhysicsEngine.OnPhysicsStep += OnPhysicsStep;
-        else
-            universe.OnUpdate += OnUpdate;
-    }
-
-    private void OnPhysicsStep(IPhysicsEngine2D sender, float stepDeltaTime)
     {
         for (int i = enumerators.Count - 1; i >= 0; i--)
         {
@@ -42,23 +32,5 @@ public class PhysicsCoroutineManager : UniverseObject
         }
     }
 
-    protected override void OnExitingUniverse(IUniverse universe)
+    public PhysicsCoroutineManager() => Priority = int.MinValue;
-    {
-        if (physicsEngine is IPhysicsEngine2D existingPhysicsEngine)
-            existingPhysicsEngine.OnPhysicsStep -= OnPhysicsStep;
-        universe.OnUpdate -= OnUpdate;
-    }
-
-    private void OnUpdate(IUniverse sender, UniverseTime engineTime)
-    {
-        if (Universe is not IUniverse universe)
-            return;
-
-        physicsEngine = universe.GetUniverseObject<IPhysicsEngine2D>();
-        if (physicsEngine is IPhysicsEngine2D foundPhysicsEngine)
-        {
-            foundPhysicsEngine.OnPhysicsStep += OnPhysicsStep;
-            universe.OnUpdate -= OnUpdate;
-        }
-    }
 }

Engine.Physics2D/PhysicsEngine2D.cs

@@ -1,11 +1,13 @@
+using System.Collections.Generic;
+
 using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Physics2D;
 
-public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
+public class PhysicsEngine2D : Behaviour, IPreUpdate, IPhysicsEngine2D
 {
-    public event IPhysicsEngine2D.PhysicsIterationEventHandler? OnPhysicsIteration = null;
+    public Event<IPhysicsEngine2D, float> OnPhysicsIteration { get; } = new();
-    public event IPhysicsEngine2D.PhysicsStepEventHandler? OnPhysicsStep = null;
+    public Event<IPhysicsEngine2D, float> OnPhysicsStep { get; } = new();
 
     private float physicsTicker = 0f;
     private int _iterationPerStep = 1;
@@ -13,17 +15,54 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
 
     protected readonly ICollisionDetector2D collisionDetector = null!;
     protected readonly ICollisionResolver2D collisionResolver = null!;
+    protected readonly IRaycastResolver2D raycastResolver = null!;
 
-    private static System.Comparison<IBehaviour> SortByPriority() => (x, y) => y.Priority.CompareTo(x.Priority);
+    private static Comparer<IBehaviour> SortByPriority() => Comparer<IBehaviour>.Create((x, y) => y.Priority.CompareTo(x.Priority));
     protected ActiveBehaviourCollectorSorted<IPrePhysicsUpdate> physicsPreUpdateCollector = new() { SortBy = SortByPriority() };
     protected ActiveBehaviourCollectorSorted<IPhysicsUpdate> physicsUpdateCollector = new() { SortBy = SortByPriority() };
+    protected ActiveBehaviourCollectorSorted<IPhysicsIteration> physicsIterationCollector = new() { SortBy = SortByPriority() };
     protected ActiveBehaviourCollectorSorted<IPostPhysicsUpdate> physicsPostUpdateCollector = new() { SortBy = SortByPriority() };
     protected BehaviourCollector<IRigidBody2D> rigidBodyCollector = new();
     protected BehaviourCollector<ICollider2D> colliderCollector = new();
 
+    private readonly ListPool<ICollider2D> colliderPool = new();
+    private readonly ListPool<IPrePhysicsUpdate> prePhysicsUpdatePool = new();
+    private readonly ListPool<IPhysicsUpdate> physicsUpdatePool = new();
+    private readonly ListPool<IPhysicsIteration> physicsIterationPool = new();
+    private readonly ListPool<IPostPhysicsUpdate> postPhysicsUpdatePool = new();
+
     public int IterationPerStep { get => _iterationPerStep; set => _iterationPerStep = value < 1 ? 1 : value; }
     public float IterationPeriod { get => _iterationPeriod; set => _iterationPeriod = value.Max(0.0001f); }
 
+    public RaycastResult? Raycast(Ray2D ray, float length = float.MaxValue)
+    {
+        RaycastResult? closestResult = null;
+        float closestDistance = float.MaxValue;
+
+        for (int i = 0; i < colliderCollector.Count; i++)
+            if (raycastResolver.RaycastAgainst(colliderCollector[i], ray, length) is RaycastResult raycastResult)
+            {
+                float magnitudeSquared = raycastResult.Position.FromTo(ray.Origin).MagnitudeSquared;
+
+                if (magnitudeSquared > closestDistance)
+                    continue;
+
+                closestDistance = magnitudeSquared;
+                closestResult = raycastResult;
+            }
+
+        return closestResult;
+    }
+
+    public void Raycast(Ray2D ray, IList<RaycastResult> results, float length = float.MaxValue)
+    {
+        results.Clear();
+
+        for (int i = 0; i < colliderCollector.Count; i++)
+            if (raycastResolver.RaycastAgainst(colliderCollector[i], ray, length) is RaycastResult raycastResult)
+                results.Add(raycastResult);
+    }
+
     public void Step(float deltaTime)
     {
         float intervalDeltaTime = deltaTime / IterationPerStep;
@@ -36,6 +75,9 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
 
         for (int iterationIndex = 0; iterationIndex < IterationPerStep; iterationIndex++)
         {
+            for (int i = physicsIterationCollector.Count - 1; i >= 0; i--)
+                physicsIterationCollector[i].PhysicsIterate(intervalDeltaTime);
+
             // Can Parallel
             for (int i = rigidBodyCollector.Count - 1; i >= 0; i--)
                 StepRigidBody(rigidBodyCollector[i], intervalDeltaTime);
@@ -75,24 +117,29 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
     {
         float intervalDeltaTime = deltaTime / IterationPerStep;
 
-        System.Collections.Generic.List<ICollider2D> childColliders = [];
+        List<ICollider2D> childColliders = colliderPool.Get();
-        System.Collections.Generic.List<IPrePhysicsUpdate> physicsPreUpdates = [];
+        List<IPrePhysicsUpdate> physicsPreUpdates = prePhysicsUpdatePool.Get();
-        System.Collections.Generic.List<IPhysicsUpdate> physicsUpdates = [];
+        List<IPhysicsUpdate> physicsUpdates = physicsUpdatePool.Get();
-        System.Collections.Generic.List<IPostPhysicsUpdate> physicsPostUpdates = [];
+        List<IPhysicsIteration> physicsIterations = physicsIterationPool.Get();
+        List<IPostPhysicsUpdate> physicsPostUpdates = postPhysicsUpdatePool.Get();
 
         rigidBody.BehaviourController.GetBehavioursInChildren(childColliders);
         rigidBody.BehaviourController.GetBehavioursInChildren(physicsPreUpdates);
         rigidBody.BehaviourController.GetBehavioursInChildren(physicsUpdates);
+        rigidBody.BehaviourController.GetBehavioursInChildren(physicsIterations);
         rigidBody.BehaviourController.GetBehavioursInChildren(physicsPostUpdates);
 
-        foreach (IPrePhysicsUpdate physicsPreUpdate in physicsPreUpdates)
+        for (int i = physicsPreUpdates.Count - 1; i >= 0; i--)
-            physicsPreUpdate.PrePhysicsUpdate(deltaTime);
+            physicsPreUpdates[i].PrePhysicsUpdate(deltaTime);
 
-        foreach (IPhysicsUpdate physicsUpdate in physicsUpdates)
+        for (int i = physicsUpdates.Count - 1; i >= 0; i--)
-            physicsUpdate.PhysicsUpdate(deltaTime);
+            physicsUpdates[i].PhysicsUpdate(deltaTime);
 
         for (int iterationIndex = 0; iterationIndex < IterationPerStep; iterationIndex++)
         {
+            for (int i = physicsIterations.Count - 1; i >= 0; i--)
+                physicsIterations[i].PhysicsIterate(intervalDeltaTime);
+
             StepRigidBody(rigidBody, intervalDeltaTime);
 
             for (int i = childColliders.Count - 1; i >= 0; i--)
@@ -116,8 +163,14 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
             }
         }
 
-        foreach (IPostPhysicsUpdate physicsPostUpdate in physicsPostUpdates)
+        for (int i = physicsPostUpdates.Count - 1; i >= 0; i--)
-            physicsPostUpdate.PostPhysicsUpdate(deltaTime);
+            physicsPostUpdates[i].PostPhysicsUpdate(deltaTime);
+
+        colliderPool.Return(childColliders);
+        prePhysicsUpdatePool.Return(physicsPreUpdates);
+        physicsUpdatePool.Return(physicsUpdates);
+        physicsIterationPool.Return(physicsIterations);
+        postPhysicsUpdatePool.Return(physicsPostUpdates);
     }
 
     private void ResolveColliders(ICollider2D colliderX, ICollider2D colliderY)
@@ -170,31 +223,29 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
         rigidBody.Transform.Rotation += rigidBody.AngularVelocity * intervalDeltaTime;
     }
 
-    protected override void OnEnteringUniverse(IUniverse universe)
+    protected override void OnEnteredUniverse(IUniverse universe)
     {
         physicsPreUpdateCollector.Assign(universe);
         physicsUpdateCollector.Assign(universe);
+        physicsIterationCollector.Assign(universe);
         physicsPostUpdateCollector.Assign(universe);
         colliderCollector.Assign(universe);
         rigidBodyCollector.Assign(universe);
-
-        universe.OnPreUpdate += OnEnginePreUpdate;
     }
 
-    protected override void OnExitingUniverse(IUniverse universe)
+    protected override void OnExitedUniverse(IUniverse universe)
     {
         physicsPreUpdateCollector.Unassign();
         physicsUpdateCollector.Unassign();
+        physicsIterationCollector.Unassign();
         physicsPostUpdateCollector.Unassign();
         colliderCollector.Unassign();
         rigidBodyCollector.Unassign();
-
-        universe.OnPreUpdate -= OnEnginePreUpdate;
     }
 
-    private void OnEnginePreUpdate(IUniverse sender, UniverseTime engineTime)
+    void IPreUpdate.PreUpdate()
     {
-        physicsTicker += engineTime.DeltaTime;
+        physicsTicker += Universe.Time.DeltaTime;
 
         while (physicsTicker >= IterationPeriod)
         {
@@ -207,11 +258,15 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
     {
         collisionDetector = new CollisionDetector2D();
         collisionResolver = new CollisionResolver2D();
+        raycastResolver = new RaycastResolver2D();
+        Priority = int.MaxValue;
     }
 
-    public PhysicsEngine2D(ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver)
+    public PhysicsEngine2D(ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver, IRaycastResolver2D raycastResolver)
     {
         this.collisionDetector = collisionDetector;
         this.collisionResolver = collisionResolver;
+        this.raycastResolver = raycastResolver;
+        Priority = int.MaxValue;
     }
 }

Engine.Physics2D/PhysicsEngine2DStandalone.cs

@@ -6,8 +6,11 @@ namespace Syntriax.Engine.Physics2D;
 
 public class PhysicsEngine2DStandalone : IPhysicsEngine2D
 {
-    public event IPhysicsEngine2D.PhysicsIterationEventHandler? OnPhysicsIteration = null;
+    public Event<IPhysicsEngine2D, float> OnPhysicsIteration { get; } = new();
-    public event IPhysicsEngine2D.PhysicsStepEventHandler? OnPhysicsStep = null;
+    public Event<IPhysicsEngine2D, float> OnPhysicsStep { get; } = new();
+
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAdded = null!;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler delegateOnBehaviourRemoved = null!;
 
     private readonly List<IRigidBody2D> rigidBodies = new(32);
     private readonly List<ICollider2D> colliders = new(64);
@@ -16,6 +19,13 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
 
     private readonly ICollisionDetector2D collisionDetector = null!;
     private readonly ICollisionResolver2D collisionResolver = null!;
+    private readonly IRaycastResolver2D raycastResolver = null!;
+
+    private readonly ListPool<ICollider2D> colliderPool = new();
+    private readonly ListPool<IPrePhysicsUpdate> prePhysicsUpdatePool = new();
+    private readonly ListPool<IPhysicsUpdate> physicsUpdatePool = new();
+    private readonly ListPool<IPhysicsIteration> physicsIterationPool = new();
+    private readonly ListPool<IPostPhysicsUpdate> postPhysicsUpdatePool = new();
 
     public int IterationPerStep { get => _iterationCount; set => _iterationCount = value < 1 ? 1 : value; }
 
@@ -29,13 +39,44 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
         foreach (ICollider2D collider2D in rigidBody.BehaviourController.GetBehaviours<ICollider2D>())
             colliders.Add(collider2D);
 
-        rigidBody.BehaviourController.OnBehaviourAdded += OnBehaviourAdded;
+        rigidBody.BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAdded);
-        rigidBody.BehaviourController.OnBehaviourRemoved += OnBehaviourRemoved;
+        rigidBody.BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemoved);
     }
 
     public void RemoveRigidBody(IRigidBody2D rigidBody)
     {
         rigidBodies.Remove(rigidBody);
+
+        rigidBody.BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAdded);
+        rigidBody.BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemoved);
+    }
+    public RaycastResult? Raycast(Ray2D ray, float length = float.MaxValue)
+    {
+        RaycastResult? closestResult = null;
+        float closestDistance = float.MaxValue;
+
+        for (int i = 0; i < colliders.Count; i++)
+            if (raycastResolver.RaycastAgainst(colliders[i], ray, length) is RaycastResult raycastResult)
+            {
+                float magnitudeSquared = raycastResult.Position.FromTo(ray.Origin).MagnitudeSquared;
+
+                if (magnitudeSquared > closestDistance)
+                    continue;
+
+                closestDistance = magnitudeSquared;
+                closestResult = raycastResult;
+            }
+
+        return closestResult;
+    }
+
+    public void Raycast(Ray2D ray, IList<RaycastResult> results, float length = float.MaxValue)
+    {
+        results.Clear();
+
+        for (int i = 0; i < colliders.Count; i++)
+            if (raycastResolver.RaycastAgainst(colliders[i], ray, length) is RaycastResult raycastResult)
+                results.Add(raycastResult);
     }
 
     public void Step(float deltaTime)
@@ -77,28 +118,33 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
     {
         float intervalDeltaTime = deltaTime / IterationPerStep;
 
-        List<ICollider2D> childColliders = [];
+        List<ICollider2D> childColliders = colliderPool.Get();
-        List<IPrePhysicsUpdate> physicsPreUpdates = [];
+        List<IPrePhysicsUpdate> physicsPreUpdates = prePhysicsUpdatePool.Get();
-        List<IPhysicsUpdate> physicsUpdates = [];
+        List<IPhysicsUpdate> physicsUpdates = physicsUpdatePool.Get();
-        List<IPostPhysicsUpdate> physicsPostUpdates = [];
+        List<IPhysicsIteration> physicsIterations = physicsIterationPool.Get();
+        List<IPostPhysicsUpdate> physicsPostUpdates = postPhysicsUpdatePool.Get();
 
         rigidBody.BehaviourController.GetBehavioursInChildren(childColliders);
         rigidBody.BehaviourController.GetBehavioursInChildren(physicsPreUpdates);
         rigidBody.BehaviourController.GetBehavioursInChildren(physicsUpdates);
+        rigidBody.BehaviourController.GetBehavioursInChildren(physicsIterations);
         rigidBody.BehaviourController.GetBehavioursInChildren(physicsPostUpdates);
 
-        foreach (IPrePhysicsUpdate physicsPreUpdate in physicsPreUpdates)
+        for (int i = physicsPreUpdates.Count - 1; i >= 0; i--)
-            physicsPreUpdate.PrePhysicsUpdate(deltaTime);
+            physicsPreUpdates[i].PrePhysicsUpdate(deltaTime);
 
-        foreach (IPhysicsUpdate physicsUpdate in physicsUpdates)
+        for (int i = physicsUpdates.Count - 1; i >= 0; i--)
-            physicsUpdate.PhysicsUpdate(deltaTime);
+            physicsUpdates[i].PhysicsUpdate(deltaTime);
 
         for (int iterationIndex = 0; iterationIndex < IterationPerStep; iterationIndex++)
         {
+            for (int i = physicsIterations.Count - 1; i >= 0; i--)
+                physicsIterations[i].PhysicsIterate(intervalDeltaTime);
+
             StepRigidBody(rigidBody, intervalDeltaTime);
 
-            foreach (ICollider2D collider in childColliders)
+            for (int i = childColliders.Count - 1; i >= 0; i--)
-                collider.Recalculate();
+                childColliders[i].Recalculate();
 
             for (int x = 0; x < childColliders.Count; x++)
             {
@@ -118,8 +164,14 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
             }
         }
 
-        foreach (IPostPhysicsUpdate physicsPostUpdate in physicsPostUpdates)
+        for (int i = physicsPostUpdates.Count - 1; i >= 0; i--)
-            physicsPostUpdate.PostPhysicsUpdate(deltaTime);
+            physicsPostUpdates[i].PostPhysicsUpdate(deltaTime);
+
+        colliderPool.Return(childColliders);
+        prePhysicsUpdatePool.Return(physicsPreUpdates);
+        physicsUpdatePool.Return(physicsUpdates);
+        physicsIterationPool.Return(physicsIterations);
+        postPhysicsUpdatePool.Return(physicsPostUpdates);
     }
 
     private void ResolveColliders(ICollider2D colliderX, ICollider2D colliderY)
@@ -172,17 +224,17 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
         rigidBody.Transform.Rotation += rigidBody.AngularVelocity * intervalDeltaTime;
     }
 
-    private void OnBehaviourAdded(IBehaviourController controller, IBehaviour behaviour)
+    private void OnBehaviourAdded(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (behaviour is not ICollider2D collider2D)
+        if (args.BehaviourAdded is not ICollider2D collider2D)
             return;
 
         colliders.Add(collider2D);
     }
 
-    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviour behaviour)
+    private void OnBehaviourRemoved(IBehaviourController sender, IBehaviourController.BehaviourRemovedArguments args)
     {
-        if (behaviour is not ICollider2D collider2D)
+        if (args.BehaviourRemoved is not ICollider2D collider2D)
             return;
 
         colliders.Remove(collider2D);
@@ -192,11 +244,19 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
     {
         collisionDetector = new CollisionDetector2D();
         collisionResolver = new CollisionResolver2D();
+        raycastResolver = new RaycastResolver2D();
+
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
     }
 
-    public PhysicsEngine2DStandalone(ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver)
+    public PhysicsEngine2DStandalone(ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver, IRaycastResolver2D raycastResolver)
     {
         this.collisionDetector = collisionDetector;
         this.collisionResolver = collisionResolver;
+        this.raycastResolver = raycastResolver;
+
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
     }
 }

Engine.Physics2D/RaycastResolver2D.cs

@@ -0,0 +1,100 @@
+using System.Collections.Generic;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Physics2D;
+
+public class RaycastResolver2D : IRaycastResolver2D
+{
+    private readonly ListPool<Line2D> lineCacheQueue = new(initialListCapacity: 4);
+
+    RaycastResult? IRaycastResolver2D.RaycastAgainst<T>(T shape, Ray2D ray, float length)
+    {
+        if (shape is IShapeCollider2D shapeCollider)
+            return RaycastAgainstShape(shapeCollider, ray, length);
+        else if (shape is ICircleCollider2D circleCollider)
+            return RaycastAgainstCircle(circleCollider, ray, length);
+
+        throw new System.NotSupportedException($"{shape.GetType().FullName} is not supported by {GetType().FullName}. Please implement a {nameof(IRaycastResolver2D)} and use it as the raycast resolver.");
+    }
+
+    public RaycastResult? RaycastAgainstShape(IShapeCollider2D shapeCollider, Ray2D ray, float length)
+    {
+        List<Line2D> line2Ds = lineCacheQueue.Get();
+
+        RaycastResult? raycastResult = null;
+        float closestRaycastResultSquared = float.MaxValue;
+
+        shapeCollider.ShapeWorld.ToLines(line2Ds);
+
+        Line2D rayLine = ray.ToLine(length);
+
+        foreach (Line2D line in line2Ds)
+        {
+            if (line.Intersects(rayLine))
+            {
+                Vector2D hitPosition = line.IntersectionPoint(rayLine);
+
+                float hitDistanceSquared = ray.Origin.FromTo(hitPosition).MagnitudeSquared;
+
+                if (closestRaycastResultSquared < hitDistanceSquared)
+                    continue;
+
+                closestRaycastResultSquared = hitDistanceSquared;
+
+                Vector2D lineDirection = line.Direction;
+
+                Vector2D normal1 = lineDirection.Perpendicular();
+                Vector2D normal2 = -lineDirection.Perpendicular();
+
+                float normalDot1 = rayLine.Direction.Dot(normal1);
+                float normalDot2 = rayLine.Direction.Dot(normal2);
+
+                Vector2D hitNormal = normalDot1 < normalDot2 ? normal1 : normal2;
+
+                if (shapeCollider.ShapeWorld.Overlaps(ray.Origin))
+                    hitNormal = hitNormal.Reversed;
+
+                raycastResult = new(ray, shapeCollider, hitPosition, hitNormal);
+            }
+        }
+
+        lineCacheQueue.Return(line2Ds);
+
+        return raycastResult;
+    }
+
+    public RaycastResult? RaycastAgainstCircle(ICircleCollider2D circleCollider, Ray2D ray, float length)
+    {
+        Circle circle = circleCollider.CircleWorld;
+
+        if (circle.Overlaps(ray.Origin, out _, out float depth))
+        {
+            Vector2D insideNormal = circle.Center.FromTo(ray.Origin).Normalized;
+            Vector2D insidePosition = circle.Center + insideNormal * circle.Radius;
+
+            return new(ray, circleCollider, insidePosition, insideNormal);
+        }
+
+        Vector2D originToCircle = ray.Origin.FromTo(circle.Center);
+        float distanceToClosest = ray.Direction.Dot(originToCircle);
+
+        Vector2D closestPoint = ray.Origin + ray.Direction * distanceToClosest;
+        Vector2D closestPointToCircle = closestPoint.FromTo(circle.Center);
+
+        float closestToCircleDistanceSquared = closestPointToCircle.MagnitudeSquared;
+
+        if (closestToCircleDistanceSquared > circle.RadiusSquared)
+            return null;
+
+        float distanceToHit = distanceToClosest - (circle.Radius - closestToCircleDistanceSquared.Sqrt());
+
+        if (distanceToHit > length || distanceToHit < 0f)
+            return null;
+
+        Vector2D hitPosition = ray.Evaluate(distanceToHit);
+        Vector2D hitNormal = circle.Center.FromTo(hitPosition).Normalized;
+
+        return new(ray, circleCollider, hitPosition, hitNormal);
+    }
+}

Engine.Systems/Input/IButtonInputs.cs

@@ -4,15 +4,15 @@ namespace Syntriax.Engine.Systems.Input;
 
 public interface IButtonInputs<T> : IHasStateEnable
 {
-    event ButtonCallbackEventHandler? OnAnyButtonPressed;
+    Event<IButtonInputs<T>, ButtonCallbackArguments> OnAnyButtonPressed { get; }
-    event ButtonCallbackEventHandler? OnAnyButtonReleased;
+    Event<IButtonInputs<T>, ButtonCallbackArguments> OnAnyButtonReleased { get; }
 
-    void RegisterOnPress(T button, ButtonCallbackEventHandler callback);
+    void RegisterOnPress(T button, Event<IButtonInputs<T>, ButtonCallbackArguments>.EventHandler callback);
-    void UnregisterOnPress(T button, ButtonCallbackEventHandler callback);
+    void UnregisterOnPress(T button, Event<IButtonInputs<T>, ButtonCallbackArguments>.EventHandler callback);
-    void RegisterOnRelease(T button, ButtonCallbackEventHandler callback);
+    void RegisterOnRelease(T button, Event<IButtonInputs<T>, ButtonCallbackArguments>.EventHandler callback);
-    void UnregisterOnRelease(T button, ButtonCallbackEventHandler callback);
+    void UnregisterOnRelease(T button, Event<IButtonInputs<T>, ButtonCallbackArguments>.EventHandler callback);
 
     bool IsPressed(T button);
 
-    delegate void ButtonCallbackEventHandler(IButtonInputs<T> buttonInputs, T button);
+    readonly record struct ButtonCallbackArguments(T Button);
 }

Engine.Systems/StateMachine/IState.cs

@@ -4,10 +4,10 @@ namespace Syntriax.Engine.Systems.StateMachine;
 
 public interface IState : IEntity, INameable
 {
-    event StateUpdateEventHandler? OnStateUpdate;
+    Event<IState> OnStateUpdate { get; }
-    event StateTransitionedFromEventHandler? OnStateTransitionedFrom;
+    Event<IState, StateTransitionedFromArguments> OnStateTransitionedFrom { get; }
-    event StateTransitionedToEventHandler? OnStateTransitionedTo;
+    Event<IState, StateTransitionedToArguments> OnStateTransitionedTo { get; }
-    event StateTransitionReadyEventHandler? OnStateTransitionReady;
+    Event<IState, StateTransitionReadyArguments> OnStateTransitionReady { get; }
 
     IState? GetNextState();
 
@@ -15,8 +15,7 @@ public interface IState : IEntity, INameable
     void TransitionTo(IState from);
     void TransitionFrom(IState to);
 
-    delegate void StateUpdateEventHandler(IState sender);
+    readonly record struct StateTransitionedFromArguments(IState ToState);
-    delegate void StateTransitionedFromEventHandler(IState sender, IState toState);
+    readonly record struct StateTransitionedToArguments(IState FromState);
-    delegate void StateTransitionedToEventHandler(IState sender, IState fromState);
+    readonly record struct StateTransitionReadyArguments(IState ToState);
-    delegate void StateTransitionReadyEventHandler(IState sender, IState toState);
 }

Engine.Systems/StateMachine/State.cs

@@ -6,11 +6,11 @@ namespace Syntriax.Engine.Systems.StateMachine;
 
 public class State : BaseEntity, IState
 {
-    public event IState.StateUpdateEventHandler? OnStateUpdate = null;
+    public Event<IState> OnStateUpdate { get; } = new();
-    public event IState.StateTransitionedFromEventHandler? OnStateTransitionedFrom = null;
+    public Event<IState, IState.StateTransitionedFromArguments> OnStateTransitionedFrom { get; } = new();
-    public event IState.StateTransitionedToEventHandler? OnStateTransitionedTo = null;
+    public Event<IState, IState.StateTransitionedToArguments> OnStateTransitionedTo { get; } = new();
-    public event IState.StateTransitionReadyEventHandler? OnStateTransitionReady = null;
+    public Event<IState, IState.StateTransitionReadyArguments> OnStateTransitionReady { get; } = new();
-    public event INameable.NameChangedEventHandler? OnNameChanged = null;
+    public Event<INameable, INameable.NameChangedArguments> OnNameChanged { get; } = new();
 
     private readonly List<StateTransition> transitions = [];
     private readonly Dictionary<string, StateTransition> possibleTransitions = [];
@@ -28,7 +28,7 @@ public class State : BaseEntity, IState
 
             string previousName = _name;
             _name = value;
-            OnNameChanged?.Invoke(this, previousName);
+            OnNameChanged?.Invoke(this, new(previousName));
         }
     }
 
@@ -53,12 +53,12 @@ public class State : BaseEntity, IState
     public void Update()
     {
         if (GetNextState() is IState transitionState)
-            OnStateTransitionReady?.Invoke(this, transitionState);
+            OnStateTransitionReady?.Invoke(this, new(transitionState));
         OnStateUpdate?.Invoke(this);
     }
 
-    public void TransitionTo(IState from) => OnStateTransitionedTo?.Invoke(this, from);
+    public void TransitionTo(IState from) => OnStateTransitionedTo?.Invoke(this, new(from));
-    public void TransitionFrom(IState to) => OnStateTransitionedFrom?.Invoke(this, to);
+    public void TransitionFrom(IState to) => OnStateTransitionedFrom?.Invoke(this, new(to));
 
     public IState? GetNextState()
     {

Engine.Systems/StateMachine/StateBehaviourBase.cs

@@ -4,12 +4,11 @@ namespace Syntriax.Engine.Systems.StateMachine;
 
 public abstract class StateBehaviourBase : Behaviour, IState
 {
-    public event IState.StateUpdateEventHandler? OnStateUpdate = null;
+    public Event<IState> OnStateUpdate { get; } = new();
-    public event IState.StateTransitionedFromEventHandler? OnStateTransitionedFrom = null;
+    public Event<IState, IState.StateTransitionedFromArguments> OnStateTransitionedFrom { get; } = new();
-    public event IState.StateTransitionedToEventHandler? OnStateTransitionedTo = null;
+    public Event<IState, IState.StateTransitionedToArguments> OnStateTransitionedTo { get; } = new();
-    public event INameable.NameChangedEventHandler? OnNameChanged = null;
+    public Event<IState, IState.StateTransitionReadyArguments> OnStateTransitionReady { get; } = new();
-
+    public Event<INameable, INameable.NameChangedArguments> OnNameChanged { get; } = new();
-    public abstract event IState.StateTransitionReadyEventHandler? OnStateTransitionReady;
 
     private string _name = string.Empty;
     public string Name
@@ -22,7 +21,7 @@ public abstract class StateBehaviourBase : Behaviour, IState
 
             string previousName = _name;
             _name = value;
-            OnNameChanged?.Invoke(this, previousName);
+            OnNameChanged?.Invoke(this, new(previousName));
         }
     }
 
@@ -37,14 +36,14 @@ public abstract class StateBehaviourBase : Behaviour, IState
     public void TransitionTo(IState from)
     {
         OnTransitionedToState(from);
-        OnStateTransitionedTo?.Invoke(this, from);
+        OnStateTransitionedTo?.Invoke(this, new(from));
     }
 
     protected virtual void OnTransitionedFromState(IState to) { }
     public void TransitionFrom(IState to)
     {
         OnTransitionedFromState(to);
-        OnStateTransitionedFrom?.Invoke(this, to);
+        OnStateTransitionedFrom?.Invoke(this, new(to));
     }
 
     public abstract IState? GetNextState();

Engine.Systems/StateMachine/StateMachine.cs

@@ -3,11 +3,19 @@ using Syntriax.Engine.Core.Serialization;
 
 namespace Syntriax.Engine.Systems.StateMachine;
 
-public class StateMachine : Behaviour
+public class StateMachine : Behaviour, IUpdate
 {
-    public event StateChangedEventHandler? OnStateChanged = null;
+    public Event<StateMachine, StateChangedArguments> OnStateChanged { get; } = new();
+
+    private readonly Event<IState, IState.StateTransitionReadyArguments>.EventHandler delegateOnStateTransitionReady = null!;
 
     private IState _state = new State();
+
+    public StateMachine()
+    {
+        delegateOnStateTransitionReady = OnStateTransitionReady;
+    }
+
     [Serialize]
     public IState State
     {
@@ -18,25 +26,25 @@ public class StateMachine : Behaviour
                 return;
 
             IState previousState = _state;
-            previousState.OnStateTransitionReady -= OnStateTransitionReady;
+            previousState.OnStateTransitionReady.RemoveListener(delegateOnStateTransitionReady);
 
             _state = value;
             previousState.TransitionFrom(value);
             value.TransitionTo(_state);
-            OnStateChanged?.Invoke(this, previousState, value);
+            OnStateChanged?.Invoke(this, new(value, previousState));
 
-            value.OnStateTransitionReady += OnStateTransitionReady;
+            value.OnStateTransitionReady.AddListener(delegateOnStateTransitionReady);
         }
     }
 
-    private void OnStateTransitionReady(IState sender, IState toState)
+    private void OnStateTransitionReady(IState sender, IState.StateTransitionReadyArguments args)
     {
-        State = toState;
+        State = args.ToState;
         while (State.GetNextState() is IState nextState)
             State = nextState;
     }
 
-    protected override void OnUpdate()
+    public void Update()
     {
         if (State is null)
             return;
@@ -47,5 +55,5 @@ public class StateMachine : Behaviour
         State.Update();
     }
 
-    public delegate void StateChangedEventHandler(StateMachine sender, IState previousState, IState newState);
+    public readonly record struct StateChangedArguments(IState CurrentState, IState PreviousState);
 }

Engine.Systems/Time/IReadOnlyStopwatch.cs

@@ -1,18 +1,19 @@
+using Syntriax.Engine.Core;
+
 namespace Syntriax.Engine.Systems.Time;
 
 public interface IReadOnlyStopwatch
 {
-    event StopwatchEventHandler? OnStarted;
+    Event<IReadOnlyStopwatch> OnStarted { get; }
-    event StopwatchDeltaEventHandler? OnDelta;
+    Event<IReadOnlyStopwatch, StopwatchDeltaArguments> OnDelta { get; }
-    event StopwatchEventHandler? OnStopped;
+    Event<IReadOnlyStopwatch> OnStopped { get; }
 
     double Time { get; }
 
     TimerState State { get; }
 
-    event StopwatchEventHandler? OnPaused;
+    Event<IReadOnlyStopwatch> OnPaused { get; }
-    event StopwatchEventHandler? OnResumed;
+    Event<IReadOnlyStopwatch> OnResumed { get; }
 
-    delegate void StopwatchEventHandler(IReadOnlyStopwatch sender);
+    readonly record struct StopwatchDeltaArguments(double Delta);
-    delegate void StopwatchDeltaEventHandler(IReadOnlyStopwatch sender, double delta);
 }

Engine.Systems/Time/IReadOnlyTicker.cs

@@ -1,11 +1,11 @@
+using Syntriax.Engine.Core;
+
 namespace Syntriax.Engine.Systems.Time;
 
 public interface IReadOnlyTicker : IReadOnlyStopwatch
 {
-    event TickerTickEventHandler? OnTick;
+    Event<IReadOnlyTicker> OnTick { get; }
 
     int TickCounter { get; }
     double TickPeriod { get; set; }
-
-    delegate void TickerTickEventHandler(IReadOnlyTicker sender);
 }

Engine.Systems/Time/IReadOnlyTimer.cs

@@ -1,13 +1,15 @@
+using Syntriax.Engine.Core;
+
 namespace Syntriax.Engine.Systems.Time;
 
 public interface IReadOnlyTimer
 {
-    event TimerEventHandler? OnStarted;
+    Event<IReadOnlyTimer> OnStarted { get; }
-    event TimerDeltaEventHandler? OnDelta;
+    Event<IReadOnlyTimer, TimerDeltaArguments> OnDelta { get; }
-    event TimerEventHandler? OnStopped;
+    Event<IReadOnlyTimer> OnStopped { get; }
 
-    event TimerEventHandler? OnPaused;
+    Event<IReadOnlyTimer> OnPaused { get; }
-    event TimerEventHandler? OnResumed;
+    Event<IReadOnlyTimer> OnResumed { get; }
 
     double StartTime { get; }
     double Remaining { get; }
@@ -16,7 +18,6 @@ public interface IReadOnlyTimer
 
     TimerState State { get; }
 
-    delegate void TimerEventHandler(IReadOnlyTimer sender);
+    readonly record struct TimerDeltaArguments(double Delta);
-    delegate void TimerDeltaEventHandler(IReadOnlyTimer sender, double delta);
 
 }

Engine.Systems/Time/ITicker.cs

@@ -1,11 +1,11 @@
+using Syntriax.Engine.Core;
+
 namespace Syntriax.Engine.Systems.Time;
 
 public interface ITicker : IStopwatch
 {
-    event TickerTickEventHandler? OnTick;
+    Event<ITicker> OnTick { get; }
 
     int TickCounter { get; }
     double Period { get; set; }
-
-    delegate void TickerTickEventHandler(ITicker sender);
 }

Engine.Systems/Time/StopwatchBehaviour.cs

@@ -2,13 +2,13 @@ using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Systems.Time;
 
-public class StopwatchBehaviour : Behaviour, IStopwatch
+public class StopwatchBehaviour : Behaviour, IUpdate, IStopwatch
 {
-    public event IReadOnlyStopwatch.StopwatchEventHandler? OnStarted = null;
+    public Event<IReadOnlyStopwatch> OnStarted { get; } = new();
-    public event IReadOnlyStopwatch.StopwatchDeltaEventHandler? OnDelta = null;
+    public Event<IReadOnlyStopwatch, IReadOnlyStopwatch.StopwatchDeltaArguments> OnDelta { get; } = new();
-    public event IReadOnlyStopwatch.StopwatchEventHandler? OnStopped = null;
+    public Event<IReadOnlyStopwatch> OnStopped { get; } = new();
-    public event IReadOnlyStopwatch.StopwatchEventHandler? OnPaused = null;
+    public Event<IReadOnlyStopwatch> OnPaused { get; } = new();
-    public event IReadOnlyStopwatch.StopwatchEventHandler? OnResumed = null;
+    public Event<IReadOnlyStopwatch> OnResumed { get; } = new();
 
     public double Time { get; protected set; } = 0f;
     public TimerState State { get; protected set; } = TimerState.Idle;
@@ -38,7 +38,7 @@ public class StopwatchBehaviour : Behaviour, IStopwatch
         OnStopped?.Invoke(this);
     }
 
-    protected override void OnUpdate()
+    public virtual void Update()
     {
         if (State is not TimerState.Ticking)
             return;
@@ -46,7 +46,7 @@ public class StopwatchBehaviour : Behaviour, IStopwatch
         double delta = Universe.Time.DeltaSpan.TotalSeconds;
 
         Time += delta;
-        OnDelta?.Invoke(this, delta);
+        OnDelta?.Invoke(this, new(delta));
     }
 
     protected override void OnEnteredUniverse(IUniverse universe)

Engine.Systems/Time/TickerBehaviour.cs

@@ -4,7 +4,7 @@ namespace Syntriax.Engine.Systems.Time;
 
 public class TickerBehaviour : StopwatchBehaviour, ITicker
 {
-    public event ITicker.TickerTickEventHandler? OnTick = null;
+    public Event<ITicker> OnTick { get; } = new();
 
     public double Period { get; set; } = 1f;
     public int TickCounter { get; private set; } = 0;
@@ -18,9 +18,9 @@ public class TickerBehaviour : StopwatchBehaviour, ITicker
         nextTick = Time + Period;
     }
 
-    protected override void OnUpdate()
+    public override void Update()
     {
-        base.OnUpdate();
+        base.Update();
 
         while (Time > nextTick)
         {

Engine.Systems/Time/TimerBehaviour.cs

@@ -2,13 +2,13 @@ using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Systems.Time;
 
-public class TimerBehaviour : Behaviour, ITimer
+public class TimerBehaviour : Behaviour, IUpdate, ITimer
 {
-    public event IReadOnlyTimer.TimerEventHandler? OnStarted = null;
+    public Event<IReadOnlyTimer> OnStarted { get; } = new();
-    public event IReadOnlyTimer.TimerDeltaEventHandler? OnDelta = null;
+    public Event<IReadOnlyTimer, IReadOnlyTimer.TimerDeltaArguments> OnDelta { get; } = new();
-    public event IReadOnlyTimer.TimerEventHandler? OnStopped = null;
+    public Event<IReadOnlyTimer> OnStopped { get; } = new();
-    public event IReadOnlyTimer.TimerEventHandler? OnPaused = null;
+    public Event<IReadOnlyTimer> OnPaused { get; } = new();
-    public event IReadOnlyTimer.TimerEventHandler? OnResumed = null;
+    public Event<IReadOnlyTimer> OnResumed { get; } = new();
 
     public TimerState State { get; protected set; } = TimerState.Idle;
     public double StartTime { get; protected set; } = 0f;
@@ -53,7 +53,7 @@ public class TimerBehaviour : Behaviour, ITimer
         OnStopped?.Invoke(this);
     }
 
-    protected override void OnUpdate()
+    public void Update()
     {
         if (State is not TimerState.Ticking)
             return;
@@ -61,7 +61,7 @@ public class TimerBehaviour : Behaviour, ITimer
         double delta = Universe.Time.DeltaSpan.TotalSeconds;
 
         Remaining -= delta;
-        OnDelta?.Invoke(this, delta);
+        OnDelta?.Invoke(this, new(delta));
 
         if (Remaining <= .0f)
             Stop();

Engine.Systems/Tween/ITween.cs

@@ -1,16 +1,18 @@
+using Syntriax.Engine.Core;
+
 namespace Syntriax.Engine.Systems.Tween;
 
 public interface ITween
 {
-    event TweenEventHandler? OnStarted;
+    Event<ITween> OnStarted { get; }
-    event TweenEventHandler? OnPaused;
+    Event<ITween> OnPaused { get; }
-    event TweenEventHandler? OnResumed;
+    Event<ITween> OnResumed { get; }
-    event TweenEventHandler? OnCancelled;
+    Event<ITween> OnCancelled { get; }
-    event TweenEventHandler? OnCompleted;
+    Event<ITween> OnCompleted { get; }
-    event TweenEventHandler? OnEnded;
+    Event<ITween> OnEnded { get; }
 
-    event TweenEventHandler? OnUpdated;
+    Event<ITween> OnUpdated { get; }
-    event TweenDeltaEventHandler? OnDeltaUpdated;
+    Event<ITween, TweenDeltaArguments> OnDeltaUpdated { get; }
 
     TweenState State { get; set; }
 
@@ -19,7 +21,6 @@ public interface ITween
     float Progress { get; }
     float Value { get; }
 
-    delegate void TweenEventHandler(ITween sender);
+    readonly record struct TweenDeltaArguments(float Delta);
-    delegate void TweenDeltaEventHandler(ITween sender, float delta);
 }
 

Engine.Systems/Tween/Tween.cs

@@ -4,14 +4,14 @@ namespace Syntriax.Engine.Systems.Tween;
 
 internal class Tween : ITween
 {
-    public event ITween.TweenEventHandler? OnStarted = null;
+    public Event<ITween> OnStarted { get; } = new();
-    public event ITween.TweenEventHandler? OnPaused = null;
+    public Event<ITween> OnPaused { get; } = new();
-    public event ITween.TweenEventHandler? OnResumed = null;
+    public Event<ITween> OnResumed { get; } = new();
-    public event ITween.TweenEventHandler? OnCancelled = null;
+    public Event<ITween> OnCancelled { get; } = new();
-    public event ITween.TweenEventHandler? OnCompleted = null;
+    public Event<ITween> OnCompleted { get; } = new();
-    public event ITween.TweenEventHandler? OnEnded = null;
+    public Event<ITween> OnEnded { get; } = new();
-    public event ITween.TweenEventHandler? OnUpdated = null;
+    public Event<ITween> OnUpdated { get; } = new();
-    public event ITween.TweenDeltaEventHandler? OnDeltaUpdated = null;
+    public Event<ITween, ITween.TweenDeltaArguments> OnDeltaUpdated { get; } = new();
 
     private TweenState _state = TweenState.Idle;
     public TweenState State
@@ -60,7 +60,7 @@ internal class Tween : ITween
             Progress = Counter / Duration;
             OnUpdated?.Invoke(this);
 
-            OnDeltaUpdated?.Invoke(this, Easing.Evaluate(Progress) - Easing.Evaluate(previousProgress));
+            OnDeltaUpdated?.Invoke(this, new(Easing.Evaluate(Progress) - Easing.Evaluate(previousProgress)));
 
             if (_counter >= Duration)
                 State = TweenState.Completed;
@@ -74,6 +74,22 @@ internal class Tween : ITween
         State = TweenState.Idle;
     }
 
+    internal void Wipe()
+    {
+        OnStarted.Clear();
+        OnPaused.Clear();
+        OnResumed.Clear();
+        OnCancelled.Clear();
+        OnCompleted.Clear();
+        OnEnded.Clear();
+        OnUpdated.Clear();
+        OnDeltaUpdated.Clear();
+
+        Easing = EaseLinear.Instance;
+
+        Reset();
+    }
+
     public Tween() { }
     public Tween(float duration)
     {

Engine.Systems/Tween/TweenExtensions.cs

@@ -1,7 +1,5 @@
 using System;
 
-using Syntriax.Engine.Core;
-
 namespace Syntriax.Engine.Systems.Tween;
 
 public static class TweenExtensions
@@ -11,14 +9,14 @@ public static class TweenExtensions
         Tween tweenConcrete = (Tween)tween;
         int counter = count;
 
-        tweenConcrete.OnCompleted += _ =>
+        tweenConcrete.OnCompleted.AddListener(_ =>
         {
             if (counter-- <= 0)
                 return;
 
             tweenConcrete.Reset();
             tweenConcrete.State = TweenState.Playing;
-        };
+        });
 
         return tween;
     }
@@ -26,11 +24,11 @@ public static class TweenExtensions
     public static ITween LoopInfinitely(this ITween tween)
     {
         Tween tweenConcrete = (Tween)tween;
-        tweenConcrete.OnCompleted += _ =>
+        tweenConcrete.OnCompleted.AddListener(_ =>
         {
             tweenConcrete.Reset();
             tweenConcrete.State = TweenState.Playing;
-        };
+        });
 
         return tween;
     }
@@ -45,57 +43,49 @@ public static class TweenExtensions
 
     public static ITween OnStart(this ITween tween, Action callback)
     {
-        Tween tweenConcrete = (Tween)tween;
+        tween.OnStarted.AddListener(_ => callback.Invoke());
-        tweenConcrete.OnStarted += _ => callback.Invoke();
         return tween;
     }
 
     public static ITween OnPause(this ITween tween, Action callback)
     {
-        Tween tweenConcrete = (Tween)tween;
+        tween.OnPaused.AddListener(_ => callback.Invoke());
-        tweenConcrete.OnPaused += _ => callback.Invoke();
         return tween;
     }
 
     public static ITween OnResume(this ITween tween, Action callback)
     {
-        Tween tweenConcrete = (Tween)tween;
+        tween.OnResumed.AddListener(_ => callback.Invoke());
-        tweenConcrete.OnResumed += _ => callback.Invoke();
         return tween;
     }
 
     public static ITween OnCancel(this ITween tween, Action callback)
     {
-        Tween tweenConcrete = (Tween)tween;
+        tween.OnCancelled.AddListener(_ => callback.Invoke());
-        tweenConcrete.OnCancelled += _ => callback.Invoke();
         return tween;
     }
 
     public static ITween OnComplete(this ITween tween, Action callback)
     {
-        Tween tweenConcrete = (Tween)tween;
+        tween.OnCompleted.AddListener(_ => callback.Invoke());
-        tweenConcrete.OnCompleted += _ => callback.Invoke();
         return tween;
     }
 
     public static ITween OnEnd(this ITween tween, Action callback)
     {
-        Tween tweenConcrete = (Tween)tween;
+        tween.OnEnded.AddListener(_ => callback.Invoke());
-        tweenConcrete.OnEnded += _ => callback.Invoke();
         return tween;
     }
 
     public static ITween OnUpdate(this ITween tween, Action callback)
     {
-        Tween tweenConcrete = (Tween)tween;
+        tween.OnUpdated.AddListener(_ => callback.Invoke());
-        tweenConcrete.OnUpdated += _ => callback.Invoke();
         return tween;
     }
 
     public static ITween OnDeltaUpdate(this ITween tween, Action<float> callback)
     {
-        Tween tweenConcrete = (Tween)tween;
+        tween.OnDeltaUpdated.AddListener((_, arguments) => callback.Invoke(arguments.Delta));
-        tweenConcrete.OnDeltaUpdated += (_, delta) => callback.Invoke(delta);
         return tween;
     }
 }

Engine.Systems/Tween/TweenManager.cs

@@ -5,20 +5,39 @@ using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Systems.Tween;
 
-public class TweenManager : UniverseObject, ITweenManager
+public class TweenManager : Behaviour, ITweenManager
 {
     private CoroutineManager coroutineManager = null!;
 
     private readonly Dictionary<ITween, IEnumerator> runningCoroutines = [];
+    private readonly Queue<Tween> pool = new();
 
     public ITween StartTween(float duration, ITweenManager.TweenSetCallback? setCallback = null)
     {
-        Tween tween = new(duration);
+        Tween tween = Get(duration);
-        tween.OnUpdated += tween => setCallback?.Invoke(tween.Value);
+        tween.OnUpdated.AddListener(tween => setCallback?.Invoke(tween.Value));
         runningCoroutines.Add(tween, coroutineManager.StartCoroutine(RunTween(tween)));
         return tween;
     }
 
+    private Tween Get(float duration)
+    {
+        if (!pool.TryDequeue(out Tween? result))
+            result = new(duration);
+
+        result.Duration = duration;
+        return result;
+    }
+
+    private void Return(Tween tween)
+    {
+        if (pool.Contains(tween))
+            return;
+
+        tween.Wipe();
+        pool.Enqueue(tween);
+    }
+
     private IEnumerator RunTween(Tween tween)
     {
         tween.State = TweenState.Playing;
@@ -40,6 +59,7 @@ public class TweenManager : UniverseObject, ITweenManager
         }
 
         runningCoroutines.Remove(tween);
+        Return(tween);
     }
 
     public void CancelTween(ITween tween)
@@ -50,14 +70,15 @@ public class TweenManager : UniverseObject, ITweenManager
         tween.State = TweenState.Cancelled;
         coroutineManager.StopCoroutine(runningCoroutine);
         runningCoroutines.Remove(tween);
+        Return((Tween)tween);
     }
 
-    protected override void OnEnteringUniverse(IUniverse universe)
+    protected override void OnEnteredUniverse(IUniverse universe)
     {
-        coroutineManager = universe.GetRequiredUniverseObject<CoroutineManager>();
+        coroutineManager = universe.FindRequiredBehaviour<CoroutineManager>();
     }
 
-    protected override void OnExitingUniverse(IUniverse universe)
+    protected override void OnExitedUniverse(IUniverse universe)
     {
         coroutineManager = null!;
     }

Engine.sln

@@ -17,36 +17,104 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Engine.Serializers.Yaml", "
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "YamlDotNet", "Engine.Serializers\YamlDotNet\YamlDotNet\YamlDotNet.csproj", "{3D852C92-BC14-4893-AEF2-50612DAFCD8F}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Integration", "Integration", "{823D4020-332D-2C13-F261-6F510F11A57E}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MonoGame", "Engine.Integration\Engine.Integration.MonoGame\Engine.Integration.MonoGame.csproj", "{C3438D33-0879-44E4-9DF0-D29F5621C44C}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
 		Release|Any CPU = Release|Any CPU
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{71719EAD-1B6B-4229-B39E-E53A2E8BFAB1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{71719EAD-1B6B-4229-B39E-E53A2E8BFAB1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{71719EAD-1B6B-4229-B39E-E53A2E8BFAB1}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{71719EAD-1B6B-4229-B39E-E53A2E8BFAB1}.Debug|x64.Build.0 = Debug|Any CPU
+		{71719EAD-1B6B-4229-B39E-E53A2E8BFAB1}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{71719EAD-1B6B-4229-B39E-E53A2E8BFAB1}.Debug|x86.Build.0 = Debug|Any CPU
 		{71719EAD-1B6B-4229-B39E-E53A2E8BFAB1}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{71719EAD-1B6B-4229-B39E-E53A2E8BFAB1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{71719EAD-1B6B-4229-B39E-E53A2E8BFAB1}.Release|x64.ActiveCfg = Release|Any CPU
+		{71719EAD-1B6B-4229-B39E-E53A2E8BFAB1}.Release|x64.Build.0 = Release|Any CPU
+		{71719EAD-1B6B-4229-B39E-E53A2E8BFAB1}.Release|x86.ActiveCfg = Release|Any CPU
+		{71719EAD-1B6B-4229-B39E-E53A2E8BFAB1}.Release|x86.Build.0 = Release|Any CPU
 		{3B3C3332-07E3-4A00-9898-0A5410BCB08C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{3B3C3332-07E3-4A00-9898-0A5410BCB08C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3B3C3332-07E3-4A00-9898-0A5410BCB08C}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{3B3C3332-07E3-4A00-9898-0A5410BCB08C}.Debug|x64.Build.0 = Debug|Any CPU
+		{3B3C3332-07E3-4A00-9898-0A5410BCB08C}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{3B3C3332-07E3-4A00-9898-0A5410BCB08C}.Debug|x86.Build.0 = Debug|Any CPU
 		{3B3C3332-07E3-4A00-9898-0A5410BCB08C}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{3B3C3332-07E3-4A00-9898-0A5410BCB08C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3B3C3332-07E3-4A00-9898-0A5410BCB08C}.Release|x64.ActiveCfg = Release|Any CPU
+		{3B3C3332-07E3-4A00-9898-0A5410BCB08C}.Release|x64.Build.0 = Release|Any CPU
+		{3B3C3332-07E3-4A00-9898-0A5410BCB08C}.Release|x86.ActiveCfg = Release|Any CPU
+		{3B3C3332-07E3-4A00-9898-0A5410BCB08C}.Release|x86.Build.0 = Release|Any CPU
 		{8452323D-99EF-43B1-8E7B-123E02279674}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{8452323D-99EF-43B1-8E7B-123E02279674}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8452323D-99EF-43B1-8E7B-123E02279674}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{8452323D-99EF-43B1-8E7B-123E02279674}.Debug|x64.Build.0 = Debug|Any CPU
+		{8452323D-99EF-43B1-8E7B-123E02279674}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{8452323D-99EF-43B1-8E7B-123E02279674}.Debug|x86.Build.0 = Debug|Any CPU
 		{8452323D-99EF-43B1-8E7B-123E02279674}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{8452323D-99EF-43B1-8E7B-123E02279674}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8452323D-99EF-43B1-8E7B-123E02279674}.Release|x64.ActiveCfg = Release|Any CPU
+		{8452323D-99EF-43B1-8E7B-123E02279674}.Release|x64.Build.0 = Release|Any CPU
+		{8452323D-99EF-43B1-8E7B-123E02279674}.Release|x86.ActiveCfg = Release|Any CPU
+		{8452323D-99EF-43B1-8E7B-123E02279674}.Release|x86.Build.0 = Release|Any CPU
 		{58AE79C1-9203-44AE-8022-AA180F0A71DC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{58AE79C1-9203-44AE-8022-AA180F0A71DC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{58AE79C1-9203-44AE-8022-AA180F0A71DC}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{58AE79C1-9203-44AE-8022-AA180F0A71DC}.Debug|x64.Build.0 = Debug|Any CPU
+		{58AE79C1-9203-44AE-8022-AA180F0A71DC}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{58AE79C1-9203-44AE-8022-AA180F0A71DC}.Debug|x86.Build.0 = Debug|Any CPU
 		{58AE79C1-9203-44AE-8022-AA180F0A71DC}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{58AE79C1-9203-44AE-8022-AA180F0A71DC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{58AE79C1-9203-44AE-8022-AA180F0A71DC}.Release|x64.ActiveCfg = Release|Any CPU
+		{58AE79C1-9203-44AE-8022-AA180F0A71DC}.Release|x64.Build.0 = Release|Any CPU
+		{58AE79C1-9203-44AE-8022-AA180F0A71DC}.Release|x86.ActiveCfg = Release|Any CPU
+		{58AE79C1-9203-44AE-8022-AA180F0A71DC}.Release|x86.Build.0 = Release|Any CPU
 		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176}.Debug|x64.Build.0 = Debug|Any CPU
+		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176}.Debug|x86.Build.0 = Debug|Any CPU
 		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176}.Release|x64.ActiveCfg = Release|Any CPU
+		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176}.Release|x64.Build.0 = Release|Any CPU
+		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176}.Release|x86.ActiveCfg = Release|Any CPU
+		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176}.Release|x86.Build.0 = Release|Any CPU
 		{3D852C92-BC14-4893-AEF2-50612DAFCD8F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{3D852C92-BC14-4893-AEF2-50612DAFCD8F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3D852C92-BC14-4893-AEF2-50612DAFCD8F}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{3D852C92-BC14-4893-AEF2-50612DAFCD8F}.Debug|x64.Build.0 = Debug|Any CPU
+		{3D852C92-BC14-4893-AEF2-50612DAFCD8F}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{3D852C92-BC14-4893-AEF2-50612DAFCD8F}.Debug|x86.Build.0 = Debug|Any CPU
 		{3D852C92-BC14-4893-AEF2-50612DAFCD8F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{3D852C92-BC14-4893-AEF2-50612DAFCD8F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3D852C92-BC14-4893-AEF2-50612DAFCD8F}.Release|x64.ActiveCfg = Release|Any CPU
+		{3D852C92-BC14-4893-AEF2-50612DAFCD8F}.Release|x64.Build.0 = Release|Any CPU
+		{3D852C92-BC14-4893-AEF2-50612DAFCD8F}.Release|x86.ActiveCfg = Release|Any CPU
+		{3D852C92-BC14-4893-AEF2-50612DAFCD8F}.Release|x86.Build.0 = Release|Any CPU
+		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Debug|x64.Build.0 = Debug|Any CPU
+		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Debug|x86.Build.0 = Debug|Any CPU
+		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Release|x64.ActiveCfg = Release|Any CPU
+		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Release|x64.Build.0 = Release|Any CPU
+		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Release|x86.ActiveCfg = Release|Any CPU
+		{C3438D33-0879-44E4-9DF0-D29F5621C44C}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -54,5 +122,6 @@ Global
 	GlobalSection(NestedProjects) = preSolution
 		{E9D1CDC3-5BFF-4C87-AFEB-6CE372709176} = {F88E129A-9A47-4D27-96EE-6EC02F79594B}
 		{3D852C92-BC14-4893-AEF2-50612DAFCD8F} = {F88E129A-9A47-4D27-96EE-6EC02F79594B}
+		{C3438D33-0879-44E4-9DF0-D29F5621C44C} = {823D4020-332D-2C13-F261-6F510F11A57E}
 	EndGlobalSection
 EndGlobal