cz.xprees.scene-management 1.0.1

package/.github/workflows/deploy.yml

@@ -0,0 +1,32 @@
+name: Publish to NPM registry
+
+on:
+  push:
+    branches:
+      - master
+      - release/*
+
+jobs:
+  publish-gpr:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    environment: Production
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - name: Version Patcher
+        uses: justalemon/VersionPatcher@v0.8
+        with:
+          version: 1.0.${{ github.run_number }}
+          npm-files: 'package.json'
+      - uses: JS-DevTools/npm-publish@v3
+        with:
+          token: ${{ secrets.NPM_AUTH_TOKEN }}
+          access: public
+          tag: ${{ github.ref_name }}
+          ignore-scripts: true
+

package/Editor/EditorSceneLoader.cs

@@ -0,0 +1,43 @@
+using UnityEditor.SceneManagement;
+using UnityEngine.SceneManagement;
+using Xprees.SceneManagement.ScriptableObjects;
+
+namespace Xprees.SceneManagement.Editor
+{
+    public static class EditorSceneLoader
+    {
+        public static void OpenScene(SceneSO scene)
+        {
+            lock (scene) scene.IsBeingProcessed = true;
+
+            EditorSceneManager.OpenScene(scene.GetScenePath(), OpenSceneMode.Additive);
+
+            lock (scene) scene.IsBeingProcessed = false;
+            scene.IsLoaded = true;
+        }
+
+        public static void CloseScene(SceneSO scene)
+        {
+            lock (scene) scene.IsBeingProcessed = true;
+            var sceneByPath = SceneManager.GetSceneByPath(scene.GetScenePath());
+            if (sceneByPath.isDirty)
+            {
+                EditorSceneManager.SaveModifiedScenesIfUserWantsTo(new[] { sceneByPath });
+            }
+
+            var loadedSceneCount = SceneManager.sceneCount;
+            // Try to open initialization scene if no other scene is loaded
+            if (loadedSceneCount <= 1)
+            {
+                var initialScene = SceneManager.GetSceneByBuildIndex(0);
+                if (!initialScene.IsValid()) initialScene = SceneManager.GetSceneByPath("Assets/Scenes/Initialization.unity");
+                if (initialScene.IsValid()) EditorSceneManager.OpenScene(initialScene.path, OpenSceneMode.Single);
+            }
+
+            EditorSceneManager.CloseScene(sceneByPath, true);
+
+            lock (scene) scene.IsBeingProcessed = false;
+            scene.IsLoaded = false;
+        }
+    }
+}

package/Editor/EditorSceneLoader.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e44b9de3e7de4f2c967ff29697c70223
+timeCreated: 1691927953

package/Editor/EditorSceneTracker.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine.SceneManagement;
+using Xprees.SceneManagement.ScriptableObjects;
+
+namespace Xprees.SceneManagement.Editor
+{
+    public class EditorSceneTracker
+    {
+        private string[] scenePaths;
+        private List<Tuple<SceneSO, bool>> scenesTracked;
+
+        public IEnumerable<SceneSO> Scenes => scenesTracked?.Select(tuple => tuple.Item1);
+
+        public EditorSceneTracker()
+        {
+            InitScenesList();
+        }
+
+        public bool? IsSceneOpen(SceneSO scene) => IsSceneOpen(scene.GetScenePath());
+
+        private bool IsSceneOpen(string scenePath)
+        {
+            if (scenePath == null) return false;
+
+            for (var i = 0; i < SceneManager.sceneCount; i++)
+            {
+                var currentScene = SceneManager.GetSceneAt(i);
+                if (currentScene.path == scenePath) return true;
+            }
+
+            return false;
+        }
+
+        private void InitScenesList()
+        {
+            scenePaths = GetAllScenePaths().ToArray();
+            var scenes = scenePaths.Select(AssetDatabase.LoadAssetAtPath<SceneSO>);
+            scenesTracked = scenes
+                .Select(scene => new Tuple<SceneSO, bool?>(scene, IsSceneOpen(scene)))
+                .Where(tuple => tuple.Item2 != null)
+                .Select(tuple => new Tuple<SceneSO, bool>(tuple.Item1, tuple.Item2!.Value))
+                .ToList();
+        }
+
+        private static IEnumerable<string> GetAllScenePaths() =>
+            AssetDatabase.FindAssets($"t:{nameof(SceneSO)}")
+                .Select(AssetDatabase.GUIDToAssetPath);
+    }
+}

package/Editor/EditorSceneTracker.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0ae03e579faa440d962d3fd43204a8a5
+timeCreated: 1691927286

package/Editor/SceneDropdownEditor.cs

@@ -0,0 +1,64 @@
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityToolbarExtender;
+using Xprees.SceneManagement.ScriptableObjects;
+
+namespace Xprees.SceneManagement.Editor
+{
+    [InitializeOnLoad]
+    public static class SceneDropdownEditor
+    {
+        private readonly static EditorSceneTracker sceneTracker;
+
+        static SceneDropdownEditor()
+        {
+            sceneTracker = new EditorSceneTracker();
+            ToolbarExtender.LeftToolbarGUI.Add(OnToolbarGUI);
+        }
+
+        #region GUI
+
+        private static void OnToolbarGUI()
+        {
+            GUILayout.Space(5);
+
+            // Create the dropdown button
+            if (GUILayout.Button(GetTitle(), EditorStyles.toolbarDropDown))
+            {
+                var menu = new GenericMenu();
+
+                foreach (var scene in sceneTracker.Scenes.OrderByDescending(scene => scene.sceneType))
+                {
+                    var isSceneOpenOrPresent = sceneTracker.IsSceneOpen(scene);
+                    if (isSceneOpenOrPresent == null) continue;
+
+                    menu.AddItem(new GUIContent($"{scene.sceneName} ({scene.sceneType})"), isSceneOpenOrPresent!.Value, MenuFunction);
+                    continue;
+
+                    void MenuFunction() => ProcessScene(scene);
+                }
+
+                menu.ShowAsContext();
+            }
+
+            GUILayout.FlexibleSpace();
+        }
+
+        private static GUIContent GetTitle() =>
+            new("Scenes", EditorGUIUtility.IconContent("BuildSettings.Editor").image);
+
+        #endregion
+
+        private static void ProcessScene(SceneSO scene)
+        {
+            if (sceneTracker.IsSceneOpen(scene) ?? false)
+            {
+                EditorSceneLoader.CloseScene(scene);
+                return;
+            }
+
+            EditorSceneLoader.OpenScene(scene);
+        }
+    }
+}

package/Editor/SceneDropdownEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 93815d5238d848d0949d91b718287ee0
+timeCreated: 1691915811

package/Editor/SceneSOExtensions.cs

@@ -0,0 +1,26 @@
+using UnityEditor;
+using UnityEditor.AddressableAssets;
+using UnityEngine;
+using Xprees.SceneManagement.ScriptableObjects;
+
+namespace Xprees.SceneManagement.Editor
+{
+    public static class SceneSOExtensions
+    {
+        public static string GetScenePath(this SceneSO scene)
+        {
+            var settings = AddressableAssetSettingsDefaultObject.Settings;
+            if (settings == null)
+            {
+                Debug.LogError("AddressableAssetSettings not found.");
+                return null;
+            }
+
+            var entry = settings.FindAssetEntry(scene.sceneReference.AssetGUID);
+            if (entry != null) return AssetDatabase.GUIDToAssetPath(entry.guid);
+
+            Debug.LogWarning($"Asset entry for \"{scene.name}\" not found.");
+            return null;
+        }
+    }
+}

package/Editor/SceneSOExtensions.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9dab6ca2a57f41c58fd6b1e0f0e3d3b0
+timeCreated: 1692134336

package/Editor/cz.xprees.scene-management.editor.asmdef

@@ -0,0 +1,24 @@
+{
+  "name": "cz.xprees.scene-management.editor",
+  "rootNamespace": "Xprees.SceneManagement",
+  "references": [
+    "GUID:9e24947de15b9834991c9d8411ea37cf",
+    "GUID:69448af7b92c7f342b298e06a37122aa",
+    "GUID:84651a3751eca9349aac36a66bba901b",
+    "GUID:0a0471484b079be408cb3a0d7fe94736",
+    "GUID:f88fb04354076c646a4107a491394033",
+    "GUID:999c2ca78ab34358a1222750376a501c",
+    "GUID:8abb55218ac46bd4397b3429181cd212"
+  ],
+  "includePlatforms": [
+    "Editor"
+  ],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "precompiledReferences": [],
+  "autoReferenced": true,
+  "defineConstraints": [],
+  "versionDefines": [],
+  "noEngineReferences": false
+}

package/Editor/cz.xprees.scene-management.editor.asmdef.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8b99555fa7214f4fa3ce9c3de43bc9e0
+timeCreated: 1691914996

package/Editor.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 37744e6193814716a9af6dfbdbe049f3
+timeCreated: 1691914989

package/Runtime/Events/ScriptableObjects/SceneEventChannelSO.cs

@@ -0,0 +1,14 @@
+using UnityEngine;
+using Xprees.Events.ScriptableObjects.Base;
+using Xprees.SceneManagement.ScriptableObjects;
+
+namespace Xprees.SceneManagement.Events.ScriptableObjects
+{
+    [CreateAssetMenu(menuName = "Events/Scene Event", fileName = "SceneEvent")]
+    public class SceneEventChannelSO : EventChannelBaseSO<SceneSO, bool, bool>
+    {
+        // this method is hiding the base method, but it's not overriding it -> for better readability of parameters
+        public new void RaiseEvent(SceneSO scene, bool showTransitionScreen, bool showLoading) =>
+            base.RaiseEvent(scene, showTransitionScreen, showLoading);
+    }
+}

package/Runtime/Events/ScriptableObjects/SceneEventChannelSO.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: acc117d6a8d540b8904ddb61c5b342b8
+timeCreated: 1679000647

package/Runtime/Events/ScriptableObjects.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b54aca5ce2c44a79afff9caaf4d4a1cd
+timeCreated: 1679516331

package/Runtime/Events.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0056a236c6abc6f4b89b6387539af308
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Extensions/SceneInstanceExtensions.cs

@@ -0,0 +1,16 @@
+using UnityEngine.ResourceManagement.ResourceProviders;
+using UnityEngine.SceneManagement;
+
+namespace Xprees.SceneManagement.Extensions
+{
+    public static class SceneInstanceExtensions
+    {
+        /// Sets the scene as active scene. If the scene is not valid, nothing happens.
+        public static void SetAsActiveScene(this SceneInstance scene)
+        {
+            if (!scene.Scene.IsValid()) return;
+            SceneManager.SetActiveScene(scene.Scene);
+        }
+
+    }
+}

package/Runtime/Extensions/SceneInstanceExtensions.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c7726e1a9dd0485abcf004d2ac44f049
+timeCreated: 1705855402

package/Runtime/Extensions.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4a72f092a99b4ad0a9d7c071a04403f4
+timeCreated: 1705855393

package/Runtime/Initialization/InitializationHandlers/AbstractInitializationHandlerSO.cs

@@ -0,0 +1,44 @@
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+using Xprees.Core;
+
+namespace Xprees.SceneManagement.Initialization.InitializationHandlers
+{
+    /// <warning>: All references in this script must be Addressables to avoid duplication in build,
+    /// therefore ScriptableObjects won't be duplicated in player build and in addressables build and shared logic will work</warning>
+    public abstract class AbstractInitializationHandlerSO : DescriptionBaseSO, IInitializationHandler
+    {
+        [Header("Activation")]
+        [Tooltip("Is this initialization handler active? If not, it will be skipped.")]
+        [SerializeField] private bool isActive = true;
+
+        // used to restore IsActive state in OnDisable if it was changed in OnEnable (Editor doesn't reset this value)
+        private bool _isActiveOnEnable;
+
+        /// Is this initialization handler active? If not, it will be skipped.
+        public virtual bool IsActive
+        {
+            get => isActive;
+            set => isActive = value;
+        }
+
+        /// Always call base.OnEnable() in derived classes
+        protected virtual void OnEnable() => _isActiveOnEnable = IsActive;
+
+        /// Always call base.OnDisable() in derived classes
+        protected virtual void OnDisable() => IsActive = _isActiveOnEnable;
+
+        /// This method is called by InitializationLoader before InitAsync is called for all handlers.
+        /// Put here all checks, etc. Use this to set IsActive to false if this handler should be skipped.
+        public virtual UniTask InitializeHandlerAsync(CancellationToken cancellationToken = default) => UniTask.CompletedTask;
+
+        /// This method is called by InitializationLoader only for Active handlers.
+        /// when it's time to initialize this handler and is this handler active.
+        public abstract UniTask TriggerInitializationAsync(CancellationToken cancellationToken = default);
+
+
+        /// This method is called by InitializationLoader on all handlers when unloading them.
+        public abstract UniTask UnloadHandlerAsync(CancellationToken cancellationToken = default);
+    }
+}

package/Runtime/Initialization/InitializationHandlers/AbstractInitializationHandlerSO.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a50545f770f4430eac108edecaf9b1bb
+timeCreated: 1700046039

package/Runtime/Initialization/InitializationHandlers/DesktopInitializationHandlerSO.cs

@@ -0,0 +1,91 @@
+using System.Collections.Generic;
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+using Xprees.SceneManagement.Events.ScriptableObjects;
+using Xprees.SceneManagement.ScriptableObjects;
+
+namespace Xprees.SceneManagement.Initialization.InitializationHandlers
+{
+    [CreateAssetMenu(menuName = "CF/Initialization/Desktop Initializer", fileName = "DesktopInitializationHandler")]
+    public class DesktopInitializationHandlerSO : AbstractInitializationHandlerSO
+    {
+        [Header("Scene References")]
+        [Tooltip("Asset reference to the menu sceneData (SceneSO)")]
+        [SerializeField] private AssetReferenceT<SceneSO> menuToLoadSceneDataReference;
+
+        [Space]
+        [Tooltip("Asset references to the any additional scenes to load for dektop mode.")]
+        [SerializeField] private List<AssetReferenceT<SceneSO>> additionalScenesToLoad;
+
+        [Header("Broadcasting on")]
+        [Tooltip("Reference to the event raised when menu should be loaded.")]
+        [SerializeField] private AssetReferenceT<SceneEventChannelSO> loadMenuEventAssetReference;
+
+        [Space]
+        [Tooltip("Reference to the event raised when additional scenes should be loaded.")]
+        [SerializeField] private AssetReferenceT<SceneEventChannelSO> loadAdditionalSceneEventReference;
+
+        private SceneSO _menuToLoad;
+
+        public override async UniTask TriggerInitializationAsync(CancellationToken cancellationToken = default)
+        {
+            await LoadMenu(cancellationToken);
+            await WaitUntilMenuIsLoaded(cancellationToken);
+            await LoadAdditionalScenes(cancellationToken);
+        }
+
+        public override UniTask UnloadHandlerAsync(CancellationToken cancellationToken = default)
+        {
+            _menuToLoad = null;
+            return UniTask.CompletedTask;
+        }
+
+        protected override void OnDisable()
+        {
+            base.OnDisable();
+            _menuToLoad = null;
+        }
+
+        private async UniTask LoadMenu(CancellationToken cancellationToken = default)
+        {
+            var loadMenuEventChannel = await loadMenuEventAssetReference.LoadAssetAsync<SceneEventChannelSO>()
+                .ToUniTask(cancellationToken: cancellationToken);
+            _menuToLoad = await menuToLoadSceneDataReference.LoadAssetAsync<SceneSO>()
+                .ToUniTask(cancellationToken: cancellationToken);
+
+            RaiseLoadMenuEvent(loadMenuEventChannel, _menuToLoad);
+        }
+
+        private async UniTask LoadAdditionalScenes(CancellationToken cancellationToken)
+        {
+            var loadAdditionalSceneEventChannel = await loadAdditionalSceneEventReference
+                .LoadAssetAsync<SceneEventChannelSO>().ToUniTask(cancellationToken: cancellationToken);
+
+            foreach (var sceneRef in additionalScenesToLoad)
+            {
+                var scene = await sceneRef.LoadAssetAsync<SceneSO>().ToUniTask(cancellationToken: cancellationToken);
+                RaiseLoadMenuEvent(loadAdditionalSceneEventChannel, scene);
+            }
+
+            // We don't need to wait for additional scenes to load - Don't care
+        }
+
+        private void RaiseLoadMenuEvent(SceneEventChannelSO loadMenuEventChannel, SceneSO menuToLoad)
+        {
+            if (loadMenuEventChannel == null)
+            {
+                Debug.LogError("Menu load event channel is null. Cannot load menu.");
+                return;
+            }
+
+            loadMenuEventChannel.RaiseEvent(menuToLoad, true, false);
+        }
+
+        private UniTask WaitUntilMenuIsLoaded(CancellationToken cancellationToken = default) =>
+            UniTask.WaitUntil(IsMenuLoaded, cancellationToken: cancellationToken).SuppressCancellationThrow();
+
+        private bool IsMenuLoaded() => _menuToLoad != null && _menuToLoad.IsLoaded && _menuToLoad.sceneInstance.HasValue;
+    }
+}

package/Runtime/Initialization/InitializationHandlers/DesktopInitializationHandlerSO.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 28b27e60545f4be1b4af615545fce7a9
+timeCreated: 1700049572

package/Runtime/Initialization/InitializationHandlers/IInitializationHandler.cs

@@ -0,0 +1,27 @@
+using System.Threading;
+using Cysharp.Threading.Tasks;
+
+namespace Xprees.SceneManagement.Initialization.InitializationHandlers
+{
+    /// This interface defines the contract for initialization handlers.
+    /// Their lifecycle is managed by InitializationLoader.
+    /// First InitializeHandlerAsync is called on all handlers.
+    /// Second TriggerInitializationAsync is called on all active handlers.
+    /// Finally on scene unload UnloadHandlerAsync is called on all handlers.
+    public interface IInitializationHandler
+    {
+        /// Is this initialization handler active? If not, it will be skipped.
+        bool IsActive { get; set; }
+
+        /// This method is called by InitializationLoader before InitAsync is called.
+        /// Put here all checks, etc. Use this to set IsActive to false if this handler should be skipped.
+        UniTask InitializeHandlerAsync(CancellationToken cancellationToken = default);
+
+        /// This method is called by InitializationLoader
+        /// when it's time to initialize this handler and is this handler active.
+        UniTask TriggerInitializationAsync(CancellationToken cancellationToken = default);
+
+        /// This method is called by InitializationLoader when unloading this handler.
+        UniTask UnloadHandlerAsync(CancellationToken cancellationToken = default);
+    }
+}

package/Runtime/Initialization/InitializationHandlers/IInitializationHandler.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bc8414810c1f4d88a6f0acbd44a54174
+timeCreated: 1700052480

package/Runtime/Initialization/InitializationHandlers.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4fc415230998452a8fb70e96fa4d449d
+timeCreated: 1700087663

package/Runtime/Initialization/InitializationLoader.cs

@@ -0,0 +1,122 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+using UnityEngine.SceneManagement;
+using Xprees.Events.ScriptableObjects.Base;
+using Xprees.SceneManagement.Extensions;
+using Xprees.SceneManagement.Initialization.InitializationHandlers;
+using Xprees.SceneManagement.ScriptableObjects;
+
+namespace Xprees.SceneManagement.Initialization
+{
+    public class InitializationLoader : MonoBehaviour
+    {
+        // Warning: References must be Addressables to avoid duplication in build,
+        // otherwise assets copies will be included one in player build and one in addressables build
+        [Header("Scene References")]
+        [Tooltip("Asset reference to the persistent managers sceneData (SceneSO)")]
+        [SerializeField] private AssetReferenceT<SceneSO> managersSceneDataReference;
+
+        [Header("Listening to")]
+        [SerializeField] private AssetReferenceT<VoidEventChannelSO> startHandlersInitializationEventRef;
+
+        [Header("Additional Initialization Handlers")]
+        [SerializeField] private List<AbstractInitializationHandlerSO> initializationHandlers;
+
+        private IEnumerable<AbstractInitializationHandlerSO> ActiveHandlers => initializationHandlers.Where(handler => handler.IsActive);
+
+
+        private VoidEventChannelSO _startHandlersInitializationEvent;
+
+        private async void Awake()
+        {
+            var token = this.GetCancellationTokenOnDestroy();
+
+            // Managers scene must be loaded first and in Awake
+            // to have all PersistentManagers ready for calls from the other scripts on Start
+            await LoadManagersScene(token)
+                .SuppressCancellationThrow();
+            CheckActiveHandlers();
+        }
+
+        private void OnDisable()
+        {
+            _startHandlersInitializationEvent.onEventRaised -= StartHandlersInitialization;
+        }
+
+        private async void StartHandlersInitialization()
+        {
+            var token = this.GetCancellationTokenOnDestroy();
+
+            await InitializeHandlers(token);
+
+            await TriggerInitHandlers(token);
+
+            await UnloadHandlers(token);
+
+            UnloadInitializationScene().Forget(); // Will also unload this script we don't need to wait for that :-)
+        }
+
+        private async UniTask InitializeHandlers(CancellationToken cancellationToken)
+        {
+            var initTasks = initializationHandlers
+                .Select(handler => handler.InitializeHandlerAsync(cancellationToken))
+                .ToList();
+
+            await UniTask.WhenAll(initTasks).SuppressCancellationThrow();
+        }
+
+        private async UniTask TriggerInitHandlers(CancellationToken cancellationToken)
+        {
+            var triggerTasks = ActiveHandlers
+                .Select(handler => handler.TriggerInitializationAsync(cancellationToken))
+                .ToList();
+
+            await UniTask.WhenAll(triggerTasks).SuppressCancellationThrow();
+        }
+
+        private async UniTask UnloadHandlers(CancellationToken cancellationToken)
+        {
+            var unloadTasks = initializationHandlers
+                .Select(handler => handler.UnloadHandlerAsync(cancellationToken))
+                .ToList();
+
+            await UniTask.WhenAll(unloadTasks).SuppressCancellationThrow();
+        }
+
+        private async UniTask LoadManagersScene(CancellationToken cancellationToken)
+        {
+            _startHandlersInitializationEvent = await startHandlersInitializationEventRef.LoadAssetAsync<VoidEventChannelSO>()
+                .ToUniTask(cancellationToken: cancellationToken);
+
+            _startHandlersInitializationEvent.onEventRaised += StartHandlersInitialization;
+
+            var managersScene = await managersSceneDataReference.LoadAssetAsync<SceneSO>()
+                .ToUniTask(cancellationToken: cancellationToken);
+
+            var managersSceneInstance = await managersScene.sceneReference.LoadSceneAsync(LoadSceneMode.Additive, true)
+                .ToUniTask(cancellationToken: cancellationToken);
+            // Set as active to make sure if there are any created objects they are in the right scene and initialization scene
+            managersSceneInstance.SetAsActiveScene();
+
+            await UniTask.WaitUntil(IsManagersSceneReady, cancellationToken: cancellationToken);
+            return;
+
+            bool IsManagersSceneReady() => managersScene.sceneInstance.HasValue && managersScene.IsLoaded;
+        }
+
+        private UniTask UnloadInitializationScene() => SceneManager.UnloadSceneAsync(0).ToUniTask(); // only scene in build settings
+
+        private void CheckActiveHandlers()
+        {
+            if (!ActiveHandlers.Any())
+            {
+                Debug.LogWarning($"{nameof(InitializationLoader)} has {initializationHandlers.Count} initialization handlers. " +
+                                 $"Only {ActiveHandlers.Count()} are active.");
+            }
+        }
+    }
+}

package/Runtime/Initialization/InitializationLoader.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a132bc1c96429fd4aa5f0a4acdbd0e69
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Initialization.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 18984d09c39a45cb94d6fc92be878e6f
+timeCreated: 1700045952