refactor: switched from universe objects to behaviours on all managers like update, draw & physics etc.

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/ActiveBehaviourCollector.cs

@@ -10,11 +10,11 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
     public Event<IHasUniverse> OnUniverseAssigned { get; } = new();
     public Event<IAssignable>? OnUnassigned { get; } = new();
 
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler cachedOnBehaviourAdded = null!;
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler cachedOnBehaviourRemoved = null!;
-    private readonly Event<IActive, IActive.ActiveChangedArguments>.EventHandler cachedOnBehaviourStateChanged = null!;
-    private readonly Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments>.EventHandler cachedOnUniverseObjectRegistered = null!;
-    private readonly Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments>.EventHandler cachedOnUniverseObjectUnregistered = null!;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAdded = 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);
@@ -22,46 +22,47 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
 
     public IUniverse Universe { get; private set; } = null!;
 
-    private void OnUniverseObjectRegistered(IUniverse manager, IUniverse.UniverseObjectRegisteredArguments arguments)
+    private void OnUniverseObjectRegistered(IUniverse manager, IUniverse.UniverseObjectRegisteredArguments args)
     {
-        IUniverseObject universeObject = arguments.UniverseObjectRegistered;
+        IUniverseObject universeObject = args.UniverseObjectRegistered;
 
-        universeObject.BehaviourController.OnBehaviourAdded.AddListener(cachedOnBehaviourAdded);
-        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(cachedOnBehaviourRemoved);
+        universeObject.BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemoved);
 
         for (int i = 0; i < universeObject.BehaviourController.Count; i++)
             OnBehaviourAdded(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
-    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverse.UniverseObjectUnRegisteredArguments arguments)
+    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverse.UniverseObjectUnRegisteredArguments args)
     {
-        IUniverseObject universeObject = arguments.UniverseObjectUnregistered;
+        IUniverseObject universeObject = args.UniverseObjectUnregistered;
 
-        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(cachedOnBehaviourAdded);
-        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(cachedOnBehaviourRemoved);
+        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemoved);
 
         for (int i = 0; i < universeObject.BehaviourController.Count; i++)
             OnBehaviourRemoved(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
     protected virtual void OnBehaviourAdd(IBehaviour behaviour) { }
-    private void OnBehaviourAdded(IBehaviourController controller, IBehaviourController.BehaviourAddedArguments arguments)
+    private void OnBehaviourAdded(IBehaviourController controller, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (arguments.BehaviourAdded is not T tBehaviour)
+        if (args.BehaviourAdded is not T tBehaviour)
             return;
 
         monitoringBehaviours.Add(tBehaviour);
         monitoringActiveToBehaviour.Add(tBehaviour, tBehaviour);
-        tBehaviour.OnActiveChanged.AddListener(cachedOnBehaviourStateChanged);
+        tBehaviour.OnActiveChanged.AddListener(delegateOnBehaviourStateChanged);
         OnBehaviourStateChanged(tBehaviour, new(!tBehaviour.IsActive));
     }
 
-    private void OnBehaviourStateChanged(IActive sender, IActive.ActiveChangedArguments arguments)
+    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, new(behaviour));
         }
@@ -73,15 +74,15 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
     }
 
     protected virtual void OnBehaviourRemove(IBehaviour behaviour) { }
-    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments arguments)
+    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments args)
     {
-        if (arguments.BehaviourRemoved is not T tBehaviour)
+        if (args.BehaviourRemoved is not T tBehaviour)
             return;
 
         if (!monitoringBehaviours.Remove(tBehaviour) || !monitoringActiveToBehaviour.Remove(tBehaviour))
             return;
 
-        tBehaviour.OnActiveChanged.RemoveListener(cachedOnBehaviourStateChanged);
+        tBehaviour.OnActiveChanged.RemoveListener(delegateOnBehaviourStateChanged);
         if (activeBehaviours.Remove(tBehaviour))
         {
             OnBehaviourRemove(tBehaviour);
@@ -97,8 +98,8 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
         foreach (IUniverseObject universeObject in universe.UniverseObjects)
             OnUniverseObjectRegistered(universe, new(universeObject));
 
-        universe.OnUniverseObjectRegistered.AddListener(cachedOnUniverseObjectRegistered);
-        universe.OnUniverseObjectUnRegistered.AddListener(cachedOnUniverseObjectUnregistered);
+        universe.OnUniverseObjectRegistered.AddListener(delegateOnUniverseObjectRegistered);
+        universe.OnUniverseObjectUnRegistered.AddListener(delegateOnUniverseObjectUnregistered);
 
         Universe = universe;
         OnUniverseAssigned?.Invoke(this);
@@ -114,8 +115,8 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
         foreach (IUniverseObject universeObject in Universe.UniverseObjects)
             OnUniverseObjectUnregistered(Universe, new(universeObject));
 
-        Universe.OnUniverseObjectRegistered.RemoveListener(cachedOnUniverseObjectRegistered);
-        Universe.OnUniverseObjectUnRegistered.RemoveListener(cachedOnUniverseObjectUnregistered);
+        Universe.OnUniverseObjectRegistered.RemoveListener(delegateOnUniverseObjectRegistered);
+        Universe.OnUniverseObjectUnRegistered.RemoveListener(delegateOnUniverseObjectUnregistered);
 
         Universe = null!;
         OnUnassigned?.Invoke(this);
@@ -127,10 +128,21 @@ public class ActiveBehaviourCollector<T> : IBehaviourCollector<T> where T : clas
 
     public ActiveBehaviourCollector()
     {
-        cachedOnBehaviourAdded = OnBehaviourAdded;
-        cachedOnBehaviourRemoved = OnBehaviourRemoved;
-        cachedOnBehaviourStateChanged = OnBehaviourStateChanged;
-        cachedOnUniverseObjectRegistered = OnUniverseObjectRegistered;
-        cachedOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+        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;
-    public Comparison<T>? SortBy
+    private readonly Event<IBehaviour, IBehaviour.PriorityChangedArguments>.EventHandler delegateOnPriorityChanged = null!;
+
+    private IComparer<T>? _sortBy = null;
+    public IComparer<T>? SortBy
     {
         get => _sortBy;
         set
@@ -17,9 +20,48 @@ public class ActiveBehaviourCollectorSorted<T> : ActiveBehaviourCollector<T> whe
         }
     }
 
+    protected override void AddBehaviour(T behaviour)
+    {
+        if (SortBy is null)
+        {
+            activeBehaviours.Add(behaviour);
+            return;
+        }
+
+        int insertionIndex = activeBehaviours.BinarySearch(behaviour, SortBy);
+
+        if (insertionIndex < 0)
+            insertionIndex = ~insertionIndex;
+
+        activeBehaviours.Insert(insertionIndex, behaviour);
+    }
+
     protected override void OnBehaviourAdd(IBehaviour behaviour)
     {
-        if (SortBy is not null)
-            activeBehaviours.Sort(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/Behaviour.cs

@@ -1,14 +1,9 @@
 namespace Syntriax.Engine.Core;
 
-public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
-    IPreUpdate, IUpdate, IPostUpdate,
-    IPreDraw, IDraw, IPostDraw
+public abstract class Behaviour : BehaviourBase
 {
-    protected IUniverse Universe => BehaviourController.UniverseObject.Universe;
-    protected IUniverseObject UniverseObject => BehaviourController.UniverseObject;
-
-    private readonly Event<IUniverseObject, IUniverseObject.EnteredUniverseArguments>.EventHandler cachedEnteredUniverse = null!;
-    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler cachedExitedUniverse = null!;
+    private readonly Event<IUniverseObject, IUniverseObject.EnteredUniverseArguments>.EventHandler delegateEnteredUniverse = null!;
+    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler delegateExitedUniverse = null!;
 
     public Behaviour()
     {
@@ -16,18 +11,18 @@ public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
         OnFinalized.AddListener(OnFinalize);
         OnUnassigned.AddListener(OnUnassign);
 
-        cachedEnteredUniverse = EnteredUniverse;
-        cachedExitedUniverse = ExitedUniverse;
+        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.AddListener(cachedEnteredUniverse);
-        BehaviourController.UniverseObject.OnExitedUniverse.AddListener(cachedExitedUniverse);
+        BehaviourController.UniverseObject.OnEnteredUniverse.AddListener(delegateEnteredUniverse);
+        BehaviourController.UniverseObject.OnExitedUniverse.AddListener(delegateExitedUniverse);
 
         OnInitialize();
 
@@ -36,10 +31,10 @@ public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
     }
 
     protected virtual void OnFinalize() { }
-    protected virtual void OnFinalize(IInitializable _)
+    protected void OnFinalize(IInitializable _)
     {
-        BehaviourController.UniverseObject.OnEnteredUniverse.RemoveListener(cachedEnteredUniverse);
-        BehaviourController.UniverseObject.OnExitedUniverse.RemoveListener(cachedExitedUniverse);
+        BehaviourController.UniverseObject.OnEnteredUniverse.RemoveListener(delegateEnteredUniverse);
+        BehaviourController.UniverseObject.OnExitedUniverse.RemoveListener(delegateExitedUniverse);
 
         OnFinalize();
 
@@ -47,100 +42,9 @@ public abstract class Behaviour : BehaviourBase, IFirstFrameUpdate,
             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, IUniverseObject.EnteredUniverseArguments arguments) => OnEnteredUniverse(arguments.Universe);
+    protected void EnteredUniverse(IUniverseObject sender, IUniverseObject.EnteredUniverseArguments args) => OnEnteredUniverse(args.Universe);
 
     protected virtual void OnExitedUniverse(IUniverse universe) { }
-    protected virtual void ExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments arguments) => OnExitedUniverse(arguments.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 _)
-    {
-        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, IUniverseObject.EnteredUniverseArguments arguments) => base.EnteredUniverse(sender, arguments);
-    protected sealed override void ExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments arguments) => base.ExitedUniverse(sender, arguments);
+    protected override void OnInitialize() => Transform = BehaviourController.GetRequiredBehaviour<ITransform2D>();
+    protected override void OnFinalize() => Transform = null!;
 }

Engine.Core/BehaviourBase.cs

@@ -7,9 +7,12 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
     public Event<IActive, IActive.ActiveChangedArguments> OnActiveChanged { get; } = new();
     public Event<IHasBehaviourController> OnBehaviourControllerAssigned { get; } = new();
 
-    private readonly Event<IHasUniverseObject>.EventHandler cachedOnUniverseObjectAssigned = null!;
-    private readonly Event<IActive, IActive.ActiveChangedArguments>.EventHandler cachedOnUniverseObjectActiveChanged = null!;
-    private readonly Event<IStateEnable, IStateEnable.EnabledChangedArguments>.EventHandler cachedOnStateEnabledChanged = null!;
+    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;
@@ -40,7 +43,7 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
 
         _behaviourController = behaviourController;
         OnAssign(behaviourController);
-        behaviourController.OnUniverseObjectAssigned.AddListener(cachedOnUniverseObjectAssigned);
+        behaviourController.OnUniverseObjectAssigned.AddListener(delegateOnUniverseObjectAssigned);
         if (behaviourController.UniverseObject is not null)
             OnUniverseObjectAssigned(behaviourController);
         OnBehaviourControllerAssigned?.Invoke(this);
@@ -49,7 +52,7 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
 
     private void OnUniverseObjectAssigned(IHasUniverseObject sender)
     {
-        sender.UniverseObject.OnActiveChanged.AddListener(cachedOnUniverseObjectActiveChanged);
+        sender.UniverseObject.OnActiveChanged.AddListener(delegateOnUniverseObjectActiveChanged);
         UpdateActive();
     }
 
@@ -57,14 +60,14 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
     {
         base.OnAssign(stateEnable);
 
-        stateEnable.OnEnabledChanged.AddListener(cachedOnStateEnabledChanged);
+        stateEnable.OnEnabledChanged.AddListener(delegateOnStateEnabledChanged);
     }
 
     protected override void UnassignInternal()
     {
-        BehaviourController.UniverseObject.OnActiveChanged.RemoveListener(cachedOnUniverseObjectActiveChanged);
-        StateEnable.OnEnabledChanged.RemoveListener(cachedOnStateEnabledChanged);
-        BehaviourController.OnUniverseObjectAssigned.RemoveListener(cachedOnUniverseObjectAssigned);
+        BehaviourController.UniverseObject.OnActiveChanged.RemoveListener(delegateOnUniverseObjectActiveChanged);
+        StateEnable.OnEnabledChanged.RemoveListener(delegateOnStateEnabledChanged);
+        BehaviourController.OnUniverseObjectAssigned.RemoveListener(delegateOnUniverseObjectAssigned);
         base.UnassignInternal();
         _behaviourController = null!;
     }
@@ -75,8 +78,8 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
         Debug.Assert.AssertStateEnableAssigned(this);
     }
 
-    private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments arguments) => UpdateActive();
-    private void OnUniverseObjectActiveChanged(IActive sender, IActive.ActiveChangedArguments arguments) => UpdateActive();
+    private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments args) => UpdateActive();
+    private void OnUniverseObjectActiveChanged(IActive sender, IActive.ActiveChangedArguments args) => UpdateActive();
 
     private void UpdateActive()
     {
@@ -89,8 +92,8 @@ public abstract class BehaviourBase : BaseEntity, IBehaviour
 
     protected BehaviourBase()
     {
-        cachedOnUniverseObjectAssigned = OnUniverseObjectAssigned;
-        cachedOnUniverseObjectActiveChanged = OnUniverseObjectActiveChanged;
-        cachedOnStateEnabledChanged = OnStateEnabledChanged;
+        delegateOnUniverseObjectAssigned = OnUniverseObjectAssigned;
+        delegateOnUniverseObjectActiveChanged = OnUniverseObjectActiveChanged;
+        delegateOnStateEnabledChanged = OnStateEnabledChanged;
     }
 }

Engine.Core/BehaviourCollector.cs

@@ -10,58 +10,59 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
     public Event<IHasUniverse> OnUniverseAssigned { get; } = new();
     public Event<IAssignable>? OnUnassigned { get; } = new();
 
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler cachedOnBehaviourAdded = null!;
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler cachedOnBehaviourRemoved = null!;
-    private readonly Event<IUniverse, IUniverse.UniverseObjectRegisteredArguments>.EventHandler cachedOnUniverseObjectRegistered = null!;
-    private readonly Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments>.EventHandler cachedOnUniverseObjectUnregistered = null!;
+    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler delegateOnBehaviourAdded = 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!;
 
-    private void OnUniverseObjectRegistered(IUniverse manager, IUniverse.UniverseObjectRegisteredArguments arguments)
+    private void OnUniverseObjectRegistered(IUniverse manager, IUniverse.UniverseObjectRegisteredArguments args)
     {
-        IUniverseObject universeObject = arguments.UniverseObjectRegistered;
+        IUniverseObject universeObject = args.UniverseObjectRegistered;
 
-        universeObject.BehaviourController.OnBehaviourAdded.AddListener(cachedOnBehaviourAdded);
-        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(cachedOnBehaviourRemoved);
+        universeObject.BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemoved);
 
         for (int i = 0; i < universeObject.BehaviourController.Count; i++)
             OnBehaviourAdded(universeObject.BehaviourController, new(universeObject.BehaviourController[i]));
     }
 
-    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverse.UniverseObjectUnRegisteredArguments arguments)
+    private void OnUniverseObjectUnregistered(IUniverse manager, IUniverse.UniverseObjectUnRegisteredArguments args)
     {
-        IUniverseObject universeObject = arguments.UniverseObjectUnregistered;
+        IUniverseObject universeObject = args.UniverseObjectUnregistered;
 
-        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(cachedOnBehaviourAdded);
-        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(cachedOnBehaviourRemoved);
+        universeObject.BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAdded);
+        universeObject.BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemoved);
 
         for (int i = 0; i < universeObject.BehaviourController.Count; 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, IBehaviourController.BehaviourAddedArguments arguments)
+    private void OnBehaviourAdded(IBehaviourController controller, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (arguments.BehaviourAdded is not T tBehaviour)
+        if (args.BehaviourAdded is not T tBehaviour)
             return;
 
-        behaviours.Add(tBehaviour);
-        OnBehaviourAdd(arguments.BehaviourAdded);
+        AddBehaviour(tBehaviour);
+        OnBehaviourAdd(args.BehaviourAdded);
         OnCollected?.Invoke(this, new(tBehaviour));
     }
 
     protected virtual void OnBehaviourRemove(IBehaviour behaviour) { }
-    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments arguments)
+    private void OnBehaviourRemoved(IBehaviourController controller, IBehaviourController.BehaviourRemovedArguments args)
     {
-        if (arguments.BehaviourRemoved is not T tBehaviour)
+        if (args.BehaviourRemoved is not T tBehaviour)
             return;
 
         if (!behaviours.Remove(tBehaviour))
             return;
 
-        OnBehaviourRemove(arguments.BehaviourRemoved);
+        OnBehaviourRemove(args.BehaviourRemoved);
         OnRemoved?.Invoke(this, new(tBehaviour));
     }
 
@@ -74,8 +75,8 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
         foreach (IUniverseObject universeObject in universe.UniverseObjects)
             OnUniverseObjectRegistered(universe, new(universeObject));
 
-        universe.OnUniverseObjectRegistered.AddListener(cachedOnUniverseObjectRegistered);
-        universe.OnUniverseObjectUnRegistered.AddListener(cachedOnUniverseObjectUnregistered);
+        universe.OnUniverseObjectRegistered.AddListener(delegateOnUniverseObjectRegistered);
+        universe.OnUniverseObjectUnRegistered.AddListener(delegateOnUniverseObjectUnregistered);
 
         Universe = universe;
         OnAssign(universe);
@@ -92,8 +93,8 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
         foreach (IUniverseObject universeObject in Universe.UniverseObjects)
             OnUniverseObjectUnregistered(Universe, new(universeObject));
 
-        Universe.OnUniverseObjectRegistered.RemoveListener(cachedOnUniverseObjectRegistered);
-        Universe.OnUniverseObjectUnRegistered.RemoveListener(cachedOnUniverseObjectUnregistered);
+        Universe.OnUniverseObjectRegistered.RemoveListener(delegateOnUniverseObjectRegistered);
+        Universe.OnUniverseObjectUnRegistered.RemoveListener(delegateOnUniverseObjectUnregistered);
 
         Universe = null!;
         OnUnassigned?.Invoke(this);
@@ -105,9 +106,19 @@ public class BehaviourCollector<T> : IBehaviourCollector<T> where T : class
 
     public BehaviourCollector()
     {
-        cachedOnBehaviourAdded = OnBehaviourAdded;
-        cachedOnBehaviourRemoved = OnBehaviourRemoved;
-        cachedOnUniverseObjectRegistered = OnUniverseObjectRegistered;
-        cachedOnUniverseObjectUnregistered = OnUniverseObjectUnregistered;
+        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;
-    public Comparison<T>? SortBy
+    private readonly Event<IBehaviour, IBehaviour.PriorityChangedArguments>.EventHandler delegateOnPriorityChanged = null!;
+
+    private IComparer<T>? _sortBy = null;
+    public IComparer<T>? SortBy
     {
         get => _sortBy;
         set
@@ -17,9 +20,48 @@ public class BehaviourCollectorSorted<T> : BehaviourCollector<T> where T : class
         }
     }
 
+    protected override void AddBehaviour(T behaviour)
+    {
+        if (SortBy is null)
+        {
+            behaviours.Add(behaviour);
+            return;
+        }
+
+        int insertionIndex = behaviours.BinarySearch(behaviour, SortBy);
+
+        if (insertionIndex < 0)
+            insertionIndex = ~insertionIndex;
+
+        behaviours.Insert(insertionIndex, behaviour);
+    }
+
     protected override void OnBehaviourAdd(IBehaviour behaviour)
     {
-        if (SortBy is not null)
-            behaviours.Sort(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

@@ -27,6 +27,7 @@ public class BehaviourController : BaseEntity, IBehaviourController
 
         if (IsInitialized)
             behaviour.Initialize();
+
         behaviour.OnPriorityChanged.AddListener(OnPriorityChange);
         OnBehaviourAdded?.Invoke(this, new(behaviour));
         return behaviour;
@@ -145,7 +146,7 @@ public class BehaviourController : BaseEntity, IBehaviourController
             behaviours.Add(behaviour);
     }
 
-    private void OnPriorityChange(IBehaviour sender, IBehaviour.PriorityChangedArguments arguments)
+    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
 {
     private readonly List<IEnumerator> enumerators = [];
 
@@ -18,17 +18,17 @@ public class CoroutineManager : UniverseObject
         enumerators.Remove(enumerator);
     }
 
-    protected override void OnEnteringUniverse(IUniverse universe)
+    protected override void OnEnteredUniverse(IUniverse universe)
     {
         universe.OnUpdate.AddListener(OnUpdate);
     }
 
-    protected override void OnExitingUniverse(IUniverse universe)
+    protected override void OnExitedUniverse(IUniverse universe)
     {
         universe.OnUpdate.RemoveListener(OnUpdate);
     }
 
-    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments arguments)
+    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments args)
     {
         for (int i = enumerators.Count - 1; i >= 0; i--)
         {

Engine.Core/Helpers/Event.cs

@@ -3,22 +3,71 @@ using System.Collections.Generic;
 
 namespace Syntriax.Engine.Core;
 
-public class Event<TSender>
+public class Event
 {
-    private readonly List<EventHandler> listeners = new(8);
+    private readonly List<EventHandler> listeners = new(4);
+    private readonly List<EventHandler> onceListeners = new(2);
 
     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 Clear() => listeners.Clear();
-    public void Invoke(TSender argument)
+    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(argument); }
+            try { listeners[i].Invoke(); }
             catch (Exception exception)
             {
-                string methodCallRepresentation = $"{listeners[i].Method.DeclaringType?.FullName}.{listeners[i].Method.Name}({argument})";
+                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 delegate void EventHandler();
+}
+
+public class Event<TSender>
+{
+    private readonly List<EventHandler> listeners = new(4);
+    private readonly List<EventHandler> onceListeners = new(2);
+
+    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 delegate void EventHandler(TSender sender);
@@ -26,21 +75,35 @@ public class Event<TSender>
 
 public class Event<TSender, TArguments>
 {
-    private readonly List<EventHandler> listeners = new(8);
+    private readonly List<EventHandler> listeners = new(4);
+    private readonly List<EventHandler> onceListeners = new(2);
 
     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 Clear() => listeners.Clear();
-    public void Invoke(TSender sender, TArguments arguments)
+    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, arguments); }
+            try { listeners[i].Invoke(sender, args); }
             catch (Exception exception)
             {
-                string methodCallRepresentation = $"{listeners[i].Method.DeclaringType?.FullName}.{listeners[i].Method.Name}({string.Join(", ", sender, arguments)})";
+                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 delegate void EventHandler(TSender sender, TArguments arguments);
+    public delegate void EventHandler(TSender sender, TArguments args);
 }

Engine.Core/Primitives/Shape2D.cs

@@ -256,8 +256,6 @@ public class Shape2D(List<Vector2D> vertices) : IEnumerable<Vector2D>
 
     /// <inheritdoc/>
     IEnumerator IEnumerable.GetEnumerator() => Vertices.GetEnumerator();
-
-    public readonly record struct ShapeUpdatedArguments(Shape2D shape2D);
 }
 
 /// <summary>

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<IDraw> drawEntities = new() { SortBy = SortByPriority() };
-    private readonly ActiveBehaviourCollectorSorted<IPostDraw> postDrawEntities = new() { SortBy = SortByPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IPreDraw> preDrawEntities = new() { SortBy = SortByDescendingPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IDraw> drawEntities = new() { SortBy = SortByDescendingPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IPostDraw> postDrawEntities = new() { SortBy = SortByDescendingPriority() };
 
     private void OnPreDraw(IUniverse sender)
     {
@@ -27,7 +29,7 @@ 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);
@@ -38,7 +40,7 @@ public class DrawManager : UniverseObject
         universe.OnPostDraw.AddListener(OnPostDraw);
     }
 
-    protected override void OnExitingUniverse(IUniverse universe)
+    protected override void OnExitedUniverse(IUniverse universe)
     {
         preDrawEntities.Unassign();
         drawEntities.Unassign();

Engine.Core/Systems/UpdateManager.cs

@@ -1,20 +1,20 @@
-
 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<IPreUpdate> preUpdateEntities = new() { SortBy = SortByPriority() };
-    private readonly ActiveBehaviourCollectorSorted<IUpdate> updateEntities = new() { SortBy = SortByPriority() };
-    private readonly ActiveBehaviourCollectorSorted<IPostUpdate> postUpdateEntities = new() { SortBy = SortByPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IFirstFrameUpdate> firstFrameUpdates = new() { SortBy = SortByAscendingPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IPreUpdate> preUpdateEntities = new() { SortBy = SortByAscendingPriority() };
+    private readonly ActiveBehaviourCollectorSorted<IUpdate> updateEntities = new() { SortBy = SortByAscendingPriority() };
+    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);
@@ -26,7 +26,7 @@ public class UpdateManager : UniverseObject
         universe.OnPostUpdate.AddListener(OnPostUpdate);
     }
 
-    protected override void OnExitingUniverse(IUniverse universe)
+    protected override void OnExitedUniverse(IUniverse universe)
     {
         firstFrameUpdates.Unassign();
         preUpdateEntities.Unassign();
@@ -38,7 +38,7 @@ public class UpdateManager : UniverseObject
         universe.OnPostUpdate.RemoveListener(OnPostUpdate);
     }
 
-    private void OnPreUpdate(IUniverse sender, IUniverse.UpdateArguments arguments)
+    private void OnPreUpdate(IUniverse sender, IUniverse.UpdateArguments args)
     {
         for (int i = toCallFirstFrameUpdates.Count - 1; i >= 0; i--)
         {
@@ -50,21 +50,21 @@ public class UpdateManager : UniverseObject
             preUpdateEntities[i].PreUpdate();
     }
 
-    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments arguments)
+    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, IUniverse.UpdateArguments arguments)
+    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, IBehaviourCollector<IFirstFrameUpdate>.BehaviourCollectedArguments arguments)
+    private void OnFirstFrameCollected(IBehaviourCollector<IFirstFrameUpdate> sender, IBehaviourCollector<IFirstFrameUpdate>.BehaviourCollectedArguments args)
     {
-        toCallFirstFrameUpdates.Add(arguments.BehaviourCollected);
+        toCallFirstFrameUpdates.Add(args.BehaviourCollected);
     }
 
     public UpdateManager()

Engine.Core/Transform2D.cs

@@ -118,17 +118,17 @@ public class Transform2D : Behaviour, ITransform2D
         }
     }
 
-    private void RecalculatePosition(ITransform2D _, ITransform2D.PositionChangedArguments arguments)
+    private void RecalculatePosition(ITransform2D _, ITransform2D.PositionChangedArguments args)
     {
         if (parentTransform is null)
             return;
 
         UpdatePosition();
 
-        OnPositionChanged?.Invoke(this, arguments);
+        OnPositionChanged?.Invoke(this, args);
     }
 
-    private void RecalculateScale(ITransform2D _, ITransform2D.ScaleChangedArguments arguments)
+    private void RecalculateScale(ITransform2D _, ITransform2D.ScaleChangedArguments args)
     {
         if (parentTransform is null)
             return;
@@ -138,11 +138,11 @@ public class Transform2D : Behaviour, ITransform2D
         UpdateScale();
         UpdatePosition();
 
-        OnScaleChanged?.Invoke(this, arguments);
+        OnScaleChanged?.Invoke(this, args);
         OnPositionChanged?.Invoke(this, new(previousPosition));
     }
 
-    private void RecalculateRotation(ITransform2D _, ITransform2D.RotationChangedArguments arguments)
+    private void RecalculateRotation(ITransform2D _, ITransform2D.RotationChangedArguments args)
     {
         if (parentTransform is null)
             return;
@@ -152,7 +152,7 @@ public class Transform2D : Behaviour, ITransform2D
         UpdateRotation();
         UpdatePosition();
 
-        OnRotationChanged?.Invoke(this, arguments);
+        OnRotationChanged?.Invoke(this, args);
         OnPositionChanged?.Invoke(this, new(previousPosition));
     }
 
@@ -252,16 +252,16 @@ public class Transform2D : Behaviour, ITransform2D
         OnRotationChanged?.Invoke(this, new(Rotation));
     }
 
-    private void LookForTransform2D(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments arguments)
+    private void LookForTransform2D(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (arguments.BehaviourAdded is not ITransform2D)
+        if (args.BehaviourAdded is not ITransform2D)
             return;
 
         UpdateReferences(UniverseObject.Parent);
     }
 
-    private void OnParentChanged(IUniverseObject sender, IUniverseObject.ParentChangedArguments arguments)
+    private void OnParentChanged(IUniverseObject sender, IUniverseObject.ParentChangedArguments args)
     {
-        UpdateReferences(arguments.CurrentParent);
+        UpdateReferences(args.CurrentParent);
     }
 }

Engine.Core/Universe.cs

@@ -17,16 +17,16 @@ public class Universe : BaseEntity, IUniverse
     public Event<IUniverse, IUniverse.UniverseObjectUnRegisteredArguments> OnUniverseObjectUnRegistered { get; } = new();
     public Event<IUniverse, IUniverse.TimeScaleChangedArguments> OnTimeScaleChanged { get; } = new();
 
-    private readonly Event<IInitializable>.EventHandler cachedOnUniverseObjectFinalize = null!;
-    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler cachedOnUniverseObjectExitedUniverse = null!;
+    private readonly Event<IInitializable>.EventHandler delegateOnUniverseObjectFinalize = null!;
+    private readonly Event<IUniverseObject, IUniverseObject.ExitedUniverseArguments>.EventHandler delegateOnUniverseObjectExitedUniverse = null!;
 
     private readonly List<IUniverseObject> _universeObjects = new(Constants.UNIVERSE_OBJECTS_SIZE_INITIAL);
     private float _timeScale = 1f;
 
     public Universe()
     {
-        cachedOnUniverseObjectFinalize = OnUniverseObjectFinalize;
-        cachedOnUniverseObjectExitedUniverse = OnUniverseObjectExitedUniverse;
+        delegateOnUniverseObjectFinalize = OnUniverseObjectFinalize;
+        delegateOnUniverseObjectExitedUniverse = OnUniverseObjectExitedUniverse;
     }
 
     public IReadOnlyList<IUniverseObject> UniverseObjects => _universeObjects;
@@ -53,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.AddListener(cachedOnUniverseObjectFinalize);
-        universeObject.OnExitedUniverse.AddListener(cachedOnUniverseObjectExitedUniverse);
+        universeObject.OnFinalized.AddListener(delegateOnUniverseObjectFinalize);
+        universeObject.OnExitedUniverse.AddListener(delegateOnUniverseObjectExitedUniverse);
 
         if (!universeObject.Initialize())
             throw new Exception($"{universeObject.Name} can't be initialized");
@@ -88,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.RemoveListener(cachedOnUniverseObjectFinalize);
-        universeObject.OnExitedUniverse.RemoveListener(cachedOnUniverseObjectExitedUniverse);
+        universeObject.OnFinalized.RemoveListener(delegateOnUniverseObjectFinalize);
+        universeObject.OnExitedUniverse.RemoveListener(delegateOnUniverseObjectExitedUniverse);
 
         for (int i = universeObject.Children.Count - 1; i >= 0; i--)
             Remove(universeObject.Children[i]);
@@ -145,7 +145,7 @@ public class Universe : BaseEntity, IUniverse
             Remove(universeObject);
     }
 
-    private void OnUniverseObjectExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments arguments)
+    private void OnUniverseObjectExitedUniverse(IUniverseObject sender, IUniverseObject.ExitedUniverseArguments args)
     {
         if (sender is IUniverseObject universeObject)
             Remove(universeObject);

Engine.Core/UniverseObject.cs

@@ -135,8 +135,8 @@ public class UniverseObject : BaseEntity, IUniverseObject
         stateEnable.OnEnabledChanged.AddListener(OnStateEnabledChanged);
     }
 
-    private void OnParentActiveChanged(IActive sender, IActive.ActiveChangedArguments arguments) => UpdateActive();
-    private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments arguments) => UpdateActive();
+    private void OnParentActiveChanged(IActive sender, IActive.ActiveChangedArguments args) => UpdateActive();
+    private void OnStateEnabledChanged(IStateEnable sender, IStateEnable.EnabledChangedArguments args) => UpdateActive();
 
     private void UpdateActive()
     {

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,55 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+using Syntriax.Engine.Core;
+
+namespace Syntriax.Engine.Integration.MonoGame;
+
+public abstract 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()
+    {
+        Preserver.Preserve();
+        Graphics = new GraphicsDeviceManager(this);
+        Content.RootDirectory = "Content";
+        IsMouseVisible = true;
+        Universe = new Universe();
+    }
+
+    protected abstract void PopulateUniverse(IUniverse universe);
+    protected override void Initialize()
+    {
+        Universe.Initialize();
+        Universe.InstantiateUniverseObject().SetUniverseObject("Window Container")
+            .BehaviourController.AddBehaviour<MonoGameWindowContainer>(this);
+
+        PopulateUniverse(Universe);
+
+        base.Initialize();
+    }
+
+    protected override void LoadContent()
+    {
+        // TODO: use this.Content to load your game content here
+    }
+
+    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/Collider2DBehaviourBase.cs

@@ -8,24 +8,24 @@ public abstract class Collider2DBehaviourBase : Behaviour2D, ICollider2D
     public Event<ICollider2D, CollisionDetectionInformation> OnCollisionResolved { get; } = new();
     public Event<ICollider2D, ICollider2D> OnTriggered { get; } = new();
 
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler cachedOnBehaviourAddedToController = null!;
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler cachedOnBehaviourRemovedFromController = null!;
-    private readonly Event<ITransform2D, ITransform2D.PositionChangedArguments>.EventHandler cachedSetNeedsRecalculationFromPosition = null!;
-    private readonly Event<ITransform2D, ITransform2D.RotationChangedArguments>.EventHandler cachedSetNeedsRecalculationFromRotation = null!;
-    private readonly Event<ITransform2D, ITransform2D.ScaleChangedArguments>.EventHandler cachedSetNeedsRecalculationFromScale = null!;
-    private readonly Event<IUniverseObject, IUniverseObject.ParentChangedArguments>.EventHandler cachedUpdateRigidBody2D = null!;
+    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()
     {
-        cachedOnBehaviourAddedToController = OnBehaviourAddedToController;
-        cachedOnBehaviourRemovedFromController = OnBehaviourRemovedFromController;
-        cachedSetNeedsRecalculationFromPosition = SetNeedsRecalculationFromPosition;
-        cachedSetNeedsRecalculationFromRotation = SetNeedsRecalculationFromRotation;
-        cachedSetNeedsRecalculationFromScale = SetNeedsRecalculationFromScale;
-        cachedUpdateRigidBody2D = UpdateRigidBody2D;
+        delegateOnBehaviourAddedToController = OnBehaviourAddedToController;
+        delegateOnBehaviourRemovedFromController = OnBehaviourRemovedFromController;
+        delegateSetNeedsRecalculationFromPosition = SetNeedsRecalculationFromPosition;
+        delegateSetNeedsRecalculationFromRotation = SetNeedsRecalculationFromRotation;
+        delegateSetNeedsRecalculationFromScale = SetNeedsRecalculationFromScale;
+        delegateUpdateRigidBody2D = UpdateRigidBody2D;
     }
 
     public IRigidBody2D? RigidBody2D => _rigidBody2D;
@@ -44,46 +44,50 @@ public abstract class Collider2DBehaviourBase : Behaviour2D, ICollider2D
 
     protected override void OnInitialize()
     {
+        base.OnInitialize();
+
         BehaviourController.TryGetBehaviourInParent(out _rigidBody2D);
 
-        BehaviourController.OnBehaviourAdded.AddListener(cachedOnBehaviourAddedToController);
-        BehaviourController.OnBehaviourRemoved.AddListener(cachedOnBehaviourRemovedFromController);
+        BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAddedToController);
+        BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemovedFromController);
 
-        Transform.OnPositionChanged.AddListener(cachedSetNeedsRecalculationFromPosition);
-        Transform.OnRotationChanged.AddListener(cachedSetNeedsRecalculationFromRotation);
-        Transform.OnScaleChanged.AddListener(cachedSetNeedsRecalculationFromScale);
-        UniverseObject.OnParentChanged.AddListener(cachedUpdateRigidBody2D);
+        Transform.OnPositionChanged.AddListener(delegateSetNeedsRecalculationFromPosition);
+        Transform.OnRotationChanged.AddListener(delegateSetNeedsRecalculationFromRotation);
+        Transform.OnScaleChanged.AddListener(delegateSetNeedsRecalculationFromScale);
+        UniverseObject.OnParentChanged.AddListener(delegateUpdateRigidBody2D);
     }
 
-    private void UpdateRigidBody2D(IUniverseObject sender, IUniverseObject.ParentChangedArguments arguments)
+    private void UpdateRigidBody2D(IUniverseObject sender, IUniverseObject.ParentChangedArguments args)
     {
         BehaviourController.TryGetBehaviourInParent(out _rigidBody2D);
     }
 
-    private void OnBehaviourAddedToController(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments arguments)
+    private void OnBehaviourAddedToController(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (arguments.BehaviourAdded is IRigidBody2D rigidBody)
+        if (args.BehaviourAdded is IRigidBody2D rigidBody)
             _rigidBody2D = rigidBody;
     }
 
-    private void OnBehaviourRemovedFromController(IBehaviourController sender, IBehaviourController.BehaviourRemovedArguments arguments)
+    private void OnBehaviourRemovedFromController(IBehaviourController sender, IBehaviourController.BehaviourRemovedArguments args)
     {
-        if (arguments.BehaviourRemoved is IRigidBody2D)
+        if (args.BehaviourRemoved is IRigidBody2D)
             _rigidBody2D = null;
     }
 
-    private void SetNeedsRecalculationFromPosition(ITransform2D sender, ITransform2D.PositionChangedArguments arguments) => NeedsRecalculation = true;
-    private void SetNeedsRecalculationFromScale(ITransform2D sender, ITransform2D.ScaleChangedArguments arguments) => NeedsRecalculation = true;
-    private void SetNeedsRecalculationFromRotation(ITransform2D sender, ITransform2D.RotationChangedArguments arguments) => NeedsRecalculation = true;
+    private void SetNeedsRecalculationFromPosition(ITransform2D sender, ITransform2D.PositionChangedArguments args) => NeedsRecalculation = true;
+    private void SetNeedsRecalculationFromScale(ITransform2D sender, ITransform2D.ScaleChangedArguments args) => NeedsRecalculation = true;
+    private void SetNeedsRecalculationFromRotation(ITransform2D sender, ITransform2D.RotationChangedArguments args) => NeedsRecalculation = true;
 
     protected override void OnFinalize()
     {
-        BehaviourController.OnBehaviourAdded.RemoveListener(cachedOnBehaviourAddedToController);
-        BehaviourController.OnBehaviourRemoved.RemoveListener(cachedOnBehaviourRemovedFromController);
-        Transform.OnScaleChanged.RemoveListener(cachedSetNeedsRecalculationFromScale);
+        base.OnFinalize();
 
-        Transform.OnPositionChanged.RemoveListener(cachedSetNeedsRecalculationFromPosition);
-        Transform.OnRotationChanged.RemoveListener(cachedSetNeedsRecalculationFromRotation);
+        BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAddedToController);
+        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,9 +5,9 @@ using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Physics2D;
 
-public class PhysicsCoroutineManager : UniverseObject
+public class PhysicsCoroutineManager : Behaviour
 {
-    private readonly Event<IUniverse, IUniverse.UpdateArguments>.EventHandler cachedOnUpdate = null!;
+    private readonly Event<IUniverse, IUniverse.UpdateArguments>.EventHandler delegateOnUpdate = null!;
 
     private readonly List<IEnumerator> enumerators = [];
     private IPhysicsEngine2D? physicsEngine = null;
@@ -23,9 +23,9 @@ public class PhysicsCoroutineManager : UniverseObject
         enumerators.Remove(enumerator);
     }
 
-    protected override void OnEnteringUniverse(IUniverse universe)
+    protected override void OnEnteredUniverse(IUniverse universe)
     {
-        physicsEngine = universe.GetUniverseObject<IPhysicsEngine2D>();
+        physicsEngine = universe.FindRequiredBehaviour<IPhysicsEngine2D>();
         if (physicsEngine is IPhysicsEngine2D foundPhysicsEngine)
             foundPhysicsEngine.OnPhysicsStep.RemoveListener(OnPhysicsStep);
         else
@@ -44,28 +44,28 @@ public class PhysicsCoroutineManager : UniverseObject
         }
     }
 
-    protected override void OnExitingUniverse(IUniverse universe)
+    protected override void OnExitedUniverse(IUniverse universe)
     {
         if (physicsEngine is IPhysicsEngine2D existingPhysicsEngine)
             existingPhysicsEngine.OnPhysicsStep.RemoveListener(OnPhysicsStep);
-        universe.OnUpdate.RemoveListener(OnUpdate);
+        universe.OnUpdate.RemoveListener(delegateOnUpdate);
     }
 
-    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments arguments)
+    private void OnUpdate(IUniverse sender, IUniverse.UpdateArguments args)
     {
         if (Universe is not IUniverse universe)
             return;
 
-        physicsEngine = universe.GetUniverseObject<IPhysicsEngine2D>();
+        physicsEngine = universe.FindRequiredBehaviour<IPhysicsEngine2D>();
         if (physicsEngine is IPhysicsEngine2D foundPhysicsEngine)
         {
             foundPhysicsEngine.OnPhysicsStep.AddListener(OnPhysicsStep);
-            universe.OnUpdate.RemoveListener(OnUpdate);
+            universe.OnUpdate.RemoveListener(delegateOnUpdate);
         }
     }
 
     public PhysicsCoroutineManager()
     {
-        cachedOnUpdate = OnUpdate;
+        delegateOnUpdate = OnUpdate;
     }
 }

Engine.Physics2D/PhysicsEngine2D.cs

@@ -1,13 +1,15 @@
+using System.Collections.Generic;
+
 using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Physics2D;
 
-public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
+public class PhysicsEngine2D : Behaviour, IPhysicsEngine2D
 {
     public Event<IPhysicsEngine2D, float> OnPhysicsIteration { get; } = new();
     public Event<IPhysicsEngine2D, float> OnPhysicsStep { get; } = new();
 
-    private readonly Event<IUniverse, IUniverse.UpdateArguments>.EventHandler cachedOnPreUpdate = null!;
+    private readonly Event<IUniverse, IUniverse.UpdateArguments>.EventHandler delegateOnPreUpdate = null!;
 
     private float physicsTicker = 0f;
     private int _iterationPerStep = 1;
@@ -16,7 +18,7 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
     protected readonly ICollisionDetector2D collisionDetector = null!;
     protected readonly ICollisionResolver2D collisionResolver = 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<IPostPhysicsUpdate> physicsPostUpdateCollector = new() { SortBy = SortByPriority() };
@@ -77,10 +79,10 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
     {
         float intervalDeltaTime = deltaTime / IterationPerStep;
 
-        System.Collections.Generic.List<ICollider2D> childColliders = [];
-        System.Collections.Generic.List<IPrePhysicsUpdate> physicsPreUpdates = [];
-        System.Collections.Generic.List<IPhysicsUpdate> physicsUpdates = [];
-        System.Collections.Generic.List<IPostPhysicsUpdate> physicsPostUpdates = [];
+        List<ICollider2D> childColliders = [];
+        List<IPrePhysicsUpdate> physicsPreUpdates = [];
+        List<IPhysicsUpdate> physicsUpdates = [];
+        List<IPostPhysicsUpdate> physicsPostUpdates = [];
 
         rigidBody.BehaviourController.GetBehavioursInChildren(childColliders);
         rigidBody.BehaviourController.GetBehavioursInChildren(physicsPreUpdates);
@@ -172,7 +174,7 @@ 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);
@@ -183,7 +185,7 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
         universe.OnPreUpdate.AddListener(OnEnginePreUpdate);
     }
 
-    protected override void OnExitingUniverse(IUniverse universe)
+    protected override void OnExitedUniverse(IUniverse universe)
     {
         physicsPreUpdateCollector.Unassign();
         physicsUpdateCollector.Unassign();
@@ -194,9 +196,9 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
         universe.OnPreUpdate.RemoveListener(OnEnginePreUpdate);
     }
 
-    private void OnEnginePreUpdate(IUniverse sender, IUniverse.UpdateArguments arguments)
+    private void OnEnginePreUpdate(IUniverse sender, IUniverse.UpdateArguments args)
     {
-        physicsTicker += arguments.EngineTime.DeltaTime;
+        physicsTicker += args.EngineTime.DeltaTime;
 
         while (physicsTicker >= IterationPeriod)
         {
@@ -210,7 +212,7 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
         collisionDetector = new CollisionDetector2D();
         collisionResolver = new CollisionResolver2D();
 
-        cachedOnPreUpdate = OnEnginePreUpdate;
+        delegateOnPreUpdate = OnEnginePreUpdate;
     }
 
     public PhysicsEngine2D(ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver)
@@ -218,6 +220,6 @@ public class PhysicsEngine2D : UniverseObject, IPhysicsEngine2D
         this.collisionDetector = collisionDetector;
         this.collisionResolver = collisionResolver;
 
-        cachedOnPreUpdate = OnEnginePreUpdate;
+        delegateOnPreUpdate = OnEnginePreUpdate;
     }
 }

Engine.Physics2D/PhysicsEngine2DStandalone.cs

@@ -9,8 +9,8 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
     public Event<IPhysicsEngine2D, float> OnPhysicsIteration { get; } = new();
     public Event<IPhysicsEngine2D, float> OnPhysicsStep { get; } = new();
 
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourAddedArguments>.EventHandler cachedOnBehaviourAdded = null!;
-    private readonly Event<IBehaviourController, IBehaviourController.BehaviourRemovedArguments>.EventHandler cachedOnBehaviourRemoved = null!;
+    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);
@@ -32,16 +32,16 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
         foreach (ICollider2D collider2D in rigidBody.BehaviourController.GetBehaviours<ICollider2D>())
             colliders.Add(collider2D);
 
-        rigidBody.BehaviourController.OnBehaviourAdded.AddListener(cachedOnBehaviourAdded);
-        rigidBody.BehaviourController.OnBehaviourRemoved.AddListener(cachedOnBehaviourRemoved);
+        rigidBody.BehaviourController.OnBehaviourAdded.AddListener(delegateOnBehaviourAdded);
+        rigidBody.BehaviourController.OnBehaviourRemoved.AddListener(delegateOnBehaviourRemoved);
     }
 
     public void RemoveRigidBody(IRigidBody2D rigidBody)
     {
         rigidBodies.Remove(rigidBody);
 
-        rigidBody.BehaviourController.OnBehaviourAdded.RemoveListener(cachedOnBehaviourAdded);
-        rigidBody.BehaviourController.OnBehaviourRemoved.RemoveListener(cachedOnBehaviourRemoved);
+        rigidBody.BehaviourController.OnBehaviourAdded.RemoveListener(delegateOnBehaviourAdded);
+        rigidBody.BehaviourController.OnBehaviourRemoved.RemoveListener(delegateOnBehaviourRemoved);
     }
 
     public void Step(float deltaTime)
@@ -178,17 +178,17 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
         rigidBody.Transform.Rotation += rigidBody.AngularVelocity * intervalDeltaTime;
     }
 
-    private void OnBehaviourAdded(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments arguments)
+    private void OnBehaviourAdded(IBehaviourController sender, IBehaviourController.BehaviourAddedArguments args)
     {
-        if (arguments.BehaviourAdded is not ICollider2D collider2D)
+        if (args.BehaviourAdded is not ICollider2D collider2D)
             return;
 
         colliders.Add(collider2D);
     }
 
-    private void OnBehaviourRemoved(IBehaviourController sender, IBehaviourController.BehaviourRemovedArguments arguments)
+    private void OnBehaviourRemoved(IBehaviourController sender, IBehaviourController.BehaviourRemovedArguments args)
     {
-        if (arguments.BehaviourRemoved is not ICollider2D collider2D)
+        if (args.BehaviourRemoved is not ICollider2D collider2D)
             return;
 
         colliders.Remove(collider2D);
@@ -199,8 +199,8 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
         collisionDetector = new CollisionDetector2D();
         collisionResolver = new CollisionResolver2D();
 
-        cachedOnBehaviourAdded = OnBehaviourAdded;
-        cachedOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
     }
 
     public PhysicsEngine2DStandalone(ICollisionDetector2D collisionDetector, ICollisionResolver2D collisionResolver)
@@ -208,7 +208,7 @@ public class PhysicsEngine2DStandalone : IPhysicsEngine2D
         this.collisionDetector = collisionDetector;
         this.collisionResolver = collisionResolver;
 
-        cachedOnBehaviourAdded = OnBehaviourAdded;
-        cachedOnBehaviourRemoved = OnBehaviourRemoved;
+        delegateOnBehaviourAdded = OnBehaviourAdded;
+        delegateOnBehaviourRemoved = OnBehaviourRemoved;
     }
 }

Engine.Systems/StateMachine/StateMachine.cs

@@ -3,17 +3,17 @@ using Syntriax.Engine.Core.Serialization;
 
 namespace Syntriax.Engine.Systems.StateMachine;
 
-public class StateMachine : Behaviour
+public class StateMachine : Behaviour, IUpdate
 {
     public Event<StateMachine, StateChangedArguments> OnStateChanged { get; } = new();
 
-    private readonly Event<IState, IState.StateTransitionReadyArguments>.EventHandler cachedOnStateTransitionReady = null!;
+    private readonly Event<IState, IState.StateTransitionReadyArguments>.EventHandler delegateOnStateTransitionReady = null!;
 
     private IState _state = new State();
 
     public StateMachine()
     {
-        cachedOnStateTransitionReady = OnStateTransitionReady;
+        delegateOnStateTransitionReady = OnStateTransitionReady;
     }
 
     [Serialize]
@@ -26,25 +26,25 @@ public class StateMachine : Behaviour
                 return;
 
             IState previousState = _state;
-            previousState.OnStateTransitionReady.RemoveListener(cachedOnStateTransitionReady);
+            previousState.OnStateTransitionReady.RemoveListener(delegateOnStateTransitionReady);
 
             _state = value;
             previousState.TransitionFrom(value);
             value.TransitionTo(_state);
             OnStateChanged?.Invoke(this, new(value, previousState));
 
-            value.OnStateTransitionReady.AddListener(cachedOnStateTransitionReady);
+            value.OnStateTransitionReady.AddListener(delegateOnStateTransitionReady);
         }
     }
 
-    private void OnStateTransitionReady(IState sender, IState.StateTransitionReadyArguments arguments)
+    private void OnStateTransitionReady(IState sender, IState.StateTransitionReadyArguments args)
     {
-        State = arguments.ToState;
+        State = args.ToState;
         while (State.GetNextState() is IState nextState)
             State = nextState;
     }
 
-    protected override void OnUpdate()
+    public void Update()
     {
         if (State is null)
             return;

Engine.Systems/Time/StopwatchBehaviour.cs

@@ -2,7 +2,7 @@ using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Systems.Time;
 
-public class StopwatchBehaviour : Behaviour, IStopwatch
+public class StopwatchBehaviour : Behaviour, IUpdate, IStopwatch
 {
     public Event<IReadOnlyStopwatch> OnStarted { get; } = new();
     public Event<IReadOnlyStopwatch, IReadOnlyStopwatch.StopwatchDeltaArguments> OnDelta { get; } = new();
@@ -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;

Engine.Systems/Time/TickerBehaviour.cs

@@ -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,7 +2,7 @@ using Syntriax.Engine.Core;
 
 namespace Syntriax.Engine.Systems.Time;
 
-public class TimerBehaviour : Behaviour, ITimer
+public class TimerBehaviour : Behaviour, IUpdate, ITimer
 {
     public Event<IReadOnlyTimer> OnStarted { get; } = new();
     public Event<IReadOnlyTimer, IReadOnlyTimer.TimerDeltaArguments> OnDelta { get; } = new();
@@ -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;

Engine.Systems/Tween/TweenManager.cs

@@ -5,12 +5,12 @@ 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 Queue<Tween> queue = new();
 
     private readonly Dictionary<ITween, IEnumerator> runningCoroutines = [];
+    private readonly Queue<Tween> pool = new();
 
     public ITween StartTween(float duration, ITweenManager.TweenSetCallback? setCallback = null)
     {
@@ -22,7 +22,7 @@ public class TweenManager : UniverseObject, ITweenManager
 
     private Tween Get(float duration)
     {
-        if (!queue.TryDequeue(out Tween? result))
+        if (!pool.TryDequeue(out Tween? result))
             result = new(duration);
 
         result.Duration = duration;
@@ -31,11 +31,11 @@ public class TweenManager : UniverseObject, ITweenManager
 
     private void Return(Tween tween)
     {
-        if (queue.Contains(tween))
+        if (pool.Contains(tween))
             return;
 
         tween.Wipe();
-        queue.Enqueue(tween);
+        pool.Enqueue(tween);
     }
 
     private IEnumerator RunTween(Tween tween)
@@ -70,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