And simple setup for basic game class woot

FinalEngine.ECS/EntityWorld.cs

@@ -9,15 +9,20 @@ namespace FinalEngine.ECS;
 using System.Reflection;
 using FinalEngine.ECS.Attributes;
 using FinalEngine.ECS.Exceptions;
+using FinalEngine.ECS.Resolving;
 
-public class EntityWorld : IEntityWorld
+internal sealed class EntityWorld : IEntityWorld
 {
     private readonly List<Entity> entities;
 
+    private readonly IEntitySystemResolver resolver;
+
     private readonly List<EntitySystemBase> systems;
 
-    public EntityWorld()
+    public EntityWorld(IEntitySystemResolver resolver)
     {
+        this.resolver = resolver ?? throw new ArgumentNullException(nameof(resolver));
+
         this.entities = [];
         this.systems = [];
     }
@@ -61,6 +66,12 @@ public void AddSystem(EntitySystemBase system)
         this.systems.Add(system);
     }
 
+    public void AddSystem<TSystem>()
+        where TSystem : EntitySystemBase
+    {
+        this.AddSystem(this.resolver.GetEntitySystem<TSystem>());
+    }
+
     public void ProcessAll(GameLoopType type)
     {
         foreach (var system in this.systems)

FinalEngine.ECS/Extensions/ServiceCollectionExtensions.cs

@@ -0,0 +1,22 @@
+// <copyright file="ServiceCollectionExtensions.cs" company="Software Antics">
+// Copyright (c) Software Antics. All rights reserved.
+// </copyright>
+
+namespace FinalEngine.ECS.Extensions;
+
+using System;
+using FinalEngine.ECS.Resolving;
+using Microsoft.Extensions.DependencyInjection;
+
+public static class ServiceCollectionExtensions
+{
+    public static IServiceCollection AddECS(this IServiceCollection services)
+    {
+        ArgumentNullException.ThrowIfNull(services, nameof(services));
+
+        services.AddTransient<IEntityWorld, EntityWorld>();
+        services.AddSingleton<IEntitySystemResolver, EntitySystemResolver>();
+
+        return services;
+    }
+}

FinalEngine.ECS/FinalEngine.ECS.csproj

@@ -24,6 +24,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="8.0.1" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.118">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

FinalEngine.ECS/IEntityWorld.cs

@@ -10,6 +10,9 @@ public interface IEntityWorld
 {
     void AddEntity(Entity entity);
 
+    void AddSystem<TSystem>()
+            where TSystem : EntitySystemBase;
+
     void AddSystem(EntitySystemBase system);
 
     void ProcessAll(GameLoopType type);

FinalEngine.ECS/Resolving/EntitySystemResolver.cs

@@ -0,0 +1,24 @@
+// <copyright file="EntitySystemResolver.cs" company="Software Antics">
+// Copyright (c) Software Antics. All rights reserved.
+// </copyright>
+
+namespace FinalEngine.ECS.Resolving;
+
+using System;
+using Microsoft.Extensions.DependencyInjection;
+
+internal sealed class EntitySystemResolver : IEntitySystemResolver
+{
+    private readonly IServiceProvider serviceProvider;
+
+    public EntitySystemResolver(IServiceProvider serviceProvider)
+    {
+        this.serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
+    }
+
+    public TSystem GetEntitySystem<TSystem>()
+        where TSystem : EntitySystemBase
+    {
+        return this.serviceProvider.GetRequiredService<TSystem>();
+    }
+}

FinalEngine.ECS/Resolving/IEntitySystemResolver.cs

@@ -0,0 +1,11 @@
+// <copyright file="IEntitySystemResolver.cs" company="Software Antics">
+// Copyright (c) Software Antics. All rights reserved.
+// </copyright>
+
+namespace FinalEngine.ECS.Resolving;
+
+internal interface IEntitySystemResolver
+{
+    TSystem GetEntitySystem<TSystem>()
+        where TSystem : EntitySystemBase;
+}

FinalEngine.Editor.Common/Models/Scenes/IScene.cs

@@ -14,7 +14,13 @@ public interface IScene
 
     void AddEntity(string tag, Guid uniqueID);
 
+    void AddSystem<TSystem>()
+        where TSystem : EntitySystemBase;
+
     void RemoveEntity(Guid uniqueIdentifier);
 
+    void RemoveSystem<TSystem>()
+        where TSystem : EntitySystemBase;
+
     void Render();
 }

FinalEngine.Editor.Common/Models/Scenes/Scene.cs

@@ -55,6 +55,12 @@ public void AddEntity(string tag, Guid uniqueID)
         this.logger.LogInformation($"Added {nameof(Entity)} to {nameof(Scene)} with ID: '{uniqueID}'.");
     }
 
+    public void AddSystem<TSystem>()
+        where TSystem : EntitySystemBase
+    {
+        this.world.AddSystem<TSystem>();
+    }
+
     public void RemoveEntity(Guid uniqueIdentifier)
     {
         this.logger.LogInformation($"Removing {nameof(Entity)} from {nameof(Scene)} with ID: '{uniqueIdentifier}'.");
@@ -76,6 +82,12 @@ public void RemoveEntity(Guid uniqueIdentifier)
         this.logger.LogInformation($"Removed {nameof(Entity)} from {nameof(Scene)} with ID: '{uniqueIdentifier}'.");
     }
 
+    public void RemoveSystem<TSystem>()
+        where TSystem : EntitySystemBase
+    {
+        this.world.RemoveSystem(typeof(TSystem));
+    }
+
     public void Render()
     {
         this.world.ProcessAll(GameLoopType.Render);

FinalEngine.Editor.Common/Services/Scenes/ISceneManager.cs

@@ -9,4 +9,6 @@ namespace FinalEngine.Editor.Common.Services.Scenes;
 public interface ISceneManager
 {
     IScene ActiveScene { get; }
+
+    void Initialize();
 }

FinalEngine.Editor.Common/Services/Scenes/SceneManager.cs

@@ -6,13 +6,28 @@ namespace FinalEngine.Editor.Common.Services.Scenes;
 
 using System;
 using FinalEngine.Editor.Common.Models.Scenes;
+using FinalEngine.Rendering;
 
 public sealed class SceneManager : ISceneManager
 {
-    public SceneManager(IScene scene)
+    private static bool isInitialized;
+
+    private readonly IRenderPipeline renderPipeline;
+
+    public SceneManager(IScene scene, IRenderPipeline renderPipeline)
     {
+        this.renderPipeline = renderPipeline ?? throw new ArgumentNullException(nameof(renderPipeline));
         this.ActiveScene = scene ?? throw new ArgumentNullException(nameof(scene));
     }
 
     public IScene ActiveScene { get; }
+
+    public void Initialize()
+    {
+        if (!isInitialized)
+        {
+            this.renderPipeline.Initialize();
+            isInitialized = true;
+        }
+    }
 }