feat: Stride Gamebuilder as an alternative for .NET IOC startup

sources/Directory.Packages.props

@@ -11,6 +11,7 @@
     <PackageVersion Include="DotRecast.Recast.Toolset" Version="2024.3.1" />
     <PackageVersion Include="FFmpeg.AutoGen" Version="3.4.0.2" />
     <PackageVersion Include="K4os.Compression.LZ4.Legacy" Version="1.3.6" />
+    <PackageVersion Include="Microsoft.Extensions.Hosting" Version="9.0.5" />
     <PackageVersion Include="Microsoft.Management.Infrastructure" Version="3.0.0-preview.4" />
     <PackageVersion Include="Microsoft.NETCore.Platforms" Version="7.0.4" />
     <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />

sources/buildengine/Stride.Core.BuildEngine.Common/MicrothreadLocalDatabases.cs

@@ -113,6 +113,11 @@ private static DatabaseFileProvider CreateDatabase(BuildTransaction transaction)
 
     private class MicroThreadLocalProviderService : IDatabaseFileProviderService
     {
-        public DatabaseFileProvider FileProvider => MicroThreadLocalDatabaseFileProvider.Value;
+        public DatabaseFileProvider FileProvider
+        {
+            get => MicroThreadLocalDatabaseFileProvider.Value;
+            set => MicroThreadLocalDatabaseFileProvider.Value = value;
+                //throw new InvalidOperationException($"Can not change the value of a {nameof(MicroThreadLocalProviderService.FileProvider)}");
+        }
     }
 }

sources/core/Stride.Core.Serialization/IO/IDatabaseFileProviderService.cs

@@ -5,5 +5,5 @@ namespace Stride.Core.IO;
 
 public interface IDatabaseFileProviderService
 {
-    DatabaseFileProvider FileProvider { get; }
-}
+    DatabaseFileProvider FileProvider { get; set; }
+}

sources/core/Stride.Core/IServiceRegistry.cs

@@ -47,6 +47,15 @@ public interface IServiceRegistry
     /// <exception cref="ArgumentException">Thrown when a service of the same type is already registered.</exception>
     void AddService<T>(T service) where T : class;
 
+    /// <summary>
+    /// Adds a service to this <see cref="ServiceRegistry"/>.
+    /// </summary>
+    /// <param name="service">The service to add.</param>
+    /// <param name="type">The type to register as.</param>
+    /// <exception cref="ArgumentNullException">Thrown when the provided service is null.</exception>
+    /// <exception cref="ArgumentException">Thrown when a service of the same type is already registered.</exception>
+    void AddService(object service, Type type);
+
     /// <summary>
     /// Gets the service object of the specified type.
     /// </summary>

sources/core/Stride.Core/ServiceRegistry.cs

@@ -76,6 +76,22 @@ public void AddService<T>(T service)
         OnServiceAdded(new ServiceEventArgs(type, service));
     }
 
+    /// <inheritdoc />
+    /// <remarks>
+    /// This implementation triggers the <see cref="ServiceAdded"/> event after a service is successfully added.
+    /// </remarks>
+    public void AddService(object service, Type type)
+    {
+        ArgumentNullException.ThrowIfNull(service);
+
+        lock (registeredService)
+        {
+            if (!registeredService.TryAdd(type, service))
+                throw new ArgumentException("Service is already registered with this type", nameof(type));
+        }
+        OnServiceAdded(new ServiceEventArgs(type, service));
+    }
+
     /// <inheritdoc />
     /// <remarks>
     /// This implementation triggers the <see cref="ServiceRemoved"/> event after a service is successfully removed.

sources/editor/Stride.Assets.Presentation/AssetEditors/EntityHierarchyEditor/Game/EntityHierarchyEditorGame.cs

@@ -48,7 +48,8 @@ public abstract class EntityHierarchyEditorGame : EditorServiceGame
         private Material fallbackColorMaterial;
         private Material fallbackTextureMaterial;
 
-        protected EntityHierarchyEditorGame(TaskCompletionSource<bool> gameContentLoadedTaskSource, IEffectCompiler effectCompiler, string effectLogPath)
+        protected EntityHierarchyEditorGame(TaskCompletionSource<bool> gameContentLoadedTaskSource, IEffectCompiler effectCompiler, string effectLogPath, GameContext context = null)
+            : base(context)
         {
             this.gameContentLoadedTaskSource = gameContentLoadedTaskSource;
             this.effectCompiler = effectCompiler;

sources/editor/Stride.Editor/EditorGame/Game/EditorServiceGame.cs

@@ -99,6 +99,11 @@ public bool IsEditorHidden
 
         public event EventHandler<ExceptionThrownEventArgs> ExceptionThrown;
 
+        public EditorServiceGame(GameContext context) : base(context)
+        {
+
+        }
+
         /// <summary>
         /// Calculates and returns the position of the mouse in the scene.
         /// </summary>

sources/editor/Stride.Editor/Engine/EmbeddedGame.cs

@@ -3,6 +3,7 @@
 
 using Stride.Core.Diagnostics;
 using Stride.Engine;
+using Stride.Games;
 using Stride.Graphics;
 
 namespace Stride.Editor.Engine
@@ -17,7 +18,7 @@ public class EmbeddedGame : Game
         /// </summary>
         public static bool DebugMode { get; set; }
 
-        public EmbeddedGame()
+        public EmbeddedGame(GameContext context) : base(context)
         {
             GraphicsDeviceManager.PreferredGraphicsProfile = new [] { GraphicsProfile.Level_11_0, GraphicsProfile.Level_10_1, GraphicsProfile.Level_10_0 };
             GraphicsDeviceManager.PreferredBackBufferWidth = 64;

sources/editor/Stride.Editor/Preview/GameStudioPreviewService.cs

@@ -137,8 +137,8 @@ private void StrideUIThread()
 
             initializationSignal.Set();
 
-            PreviewGame = new PreviewGame(AssetBuilderService.EffectCompiler);
             var context = new GameContextWinforms(gameForm) { InitializeDatabase = false };
+            PreviewGame = new PreviewGame(AssetBuilderService.EffectCompiler, context);
 
             // Wait for shaders to be loaded
             AssetBuilderService.WaitForShaders();

sources/editor/Stride.Editor/Preview/PreviewGame.cs

@@ -2,15 +2,16 @@
 // Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
 using System;
 using System.Threading.Tasks;
-using Stride.Core.BuildEngine;
-using Stride.Core;
-using Stride.Core.Diagnostics;
-using Stride.Core.Mathematics;
 using Stride.Assets;
 using Stride.Assets.SpriteFont;
 using Stride.Assets.SpriteFont.Compiler;
+using Stride.Core;
+using Stride.Core.BuildEngine;
+using Stride.Core.Diagnostics;
+using Stride.Core.Mathematics;
 using Stride.Engine;
 using Stride.Engine.Design;
+using Stride.Games;
 using Stride.Graphics;
 using Stride.Rendering.Compositing;
 using Stride.Shaders.Compiler;
@@ -43,7 +44,7 @@ public class PreviewGame : EditorGame.Game.EditorServiceGame
 
         private Scene previewScene;
 
-        public PreviewGame(IEffectCompiler effectCompiler)
+        public PreviewGame(IEffectCompiler effectCompiler, GameContext context) : base(context)
         {
             this.effectCompiler = effectCompiler;
         }

sources/engine/Stride.Engine/Engine/Builder/GameBuilder.cs

@@ -0,0 +1,125 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.DependencyInjection;
+using Stride.Core;
+using Stride.Core.Diagnostics;
+using Stride.Core.IO;
+using Stride.Games;
+using Stride.Input;
+
+namespace Stride.Engine.Builder;
+
+/// <summary>
+/// Helps build the game and preps it to be able to run after built.
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public class GameBuilder : IGameBuilder
+{
+    public Dictionary<Type, object> Services { get; internal set; } = [];
+
+    public IServiceCollection DiServices { get; internal set; } = new ServiceCollection();
+
+    public GameSystemCollection GameSystems { get; internal set; }
+
+    public List<LogListener> LogListeners { get; internal set; } = [];
+
+    public List<IInputSource> InputSources { get; internal set; } = [];
+
+    public DatabaseFileProvider DatabaseFileProvider { get; set; }
+
+    public GameBase Game { get; set; }
+
+    public GameContext Context { get; set; }
+
+    internal GameBuilder()
+    {
+        Game = new MinimalGame(null);
+        GameSystems = Game.GameSystems;
+        DiServices.AddSingleton<IServiceRegistry>(Game.Services);
+        Services.Add(typeof(IServiceRegistry), Game.Services);
+    }
+
+    public static GameBuilder Create()
+    {
+        return new GameBuilder();
+    }
+
+    public virtual GameBase Build()
+    {
+
+        foreach (var logListener in LogListeners)
+        {
+            GlobalLogger.GlobalMessageLogged += logListener;
+        }
+
+        var provider = DiServices.BuildServiceProvider();
+        foreach (var service in Services)
+        {
+            if (service.Key == typeof(IServiceRegistry) || service.Key == typeof(IServiceProvider))
+                continue;
+
+            try
+            {
+                if (service.Value == null)
+                {
+                    var instance = provider.GetService(service.Key);
+
+                    if(instance == null)
+                    {
+                        //check if the type is inherited from another instance in the services.
+                        foreach (var kvp in Services)
+                        {
+                            if (kvp.Key.IsAssignableFrom(service.Key) && kvp.Value != null)
+                            {
+                                instance = provider.GetService(kvp.Key);
+                                if(instance is not null)
+                                    break;
+                            }
+                        }
+                    }
+
+                    Game.Services.AddService(instance, service.Key);
+                    Services[service.Key] = instance;
+                }
+                else
+                {
+                    Game.Services.AddService(service.Value, service.Key);
+                }
+            }
+            catch (Exception ex)
+            {
+                // TODO: check if service is already registered first.'
+                GlobalLogger.GetLogger("GameBuilder").Error($"Failed to register service {service.Key.Name}.\n\n", ex);
+            }
+        }
+
+        // Add all game systems to the game.
+        foreach (var service in Services)
+        {
+            var system = provider.GetService(service.Key);
+            if (system is IGameSystemBase gameSystem && !Game.GameSystems.Contains(gameSystem))
+            {
+                Game.GameSystems.Add(gameSystem);
+            }
+        }
+
+        if (Context != null)
+        {
+            Game.SetGameContext(Context);
+        }
+
+        if(InputSources.Count > 0)
+        {
+            var inputManager = Game.Services.GetService<InputManager>() ?? throw new InvalidOperationException("InputManager is not registered in the service registry.");
+            foreach (var inputSource in InputSources)
+            {
+                inputManager.Sources.Add(inputSource);
+            }
+        }
+
+        var dataBase = Game.Services.GetService<IDatabaseFileProviderService>();
+        dataBase.FileProvider = DatabaseFileProvider;
+
+        return Game; 
+    }
+}