void UpdateSceneContentsChanged(Hash128 buildSettingGUID)
        {
#if UNITY_EDITOR
            Entities.With(m_ResolvedScenes).ForEach((Entity sceneEntity, ref SceneReference scene, ref ResolvedSceneHash resolvedScene) =>
            {
                LogResolving("Queuing UpdateSceneContentsChanged", scene.SceneGUID);
                var hash = EntityScenesPaths.GetSubSceneArtifactHash(scene.SceneGUID, buildSettingGUID, UnityEditor.Experimental.AssetDatabaseExperimental.ImportSyncMode.Queue);
                if ((hash != default) && (hash != resolvedScene.ArtifactHash))
                {
                    NotifySceneContentsHasChanged(scene.SceneGUID);
                }
            });
#endif

            if (m_ChangedScenes.Length != 0)
            {
                var sceneSystem = World.GetExistingSystem <SceneSystem>();
                foreach (var scene in m_ChangedScenes)
                {
                    var sceneEntity = sceneSystem.GetSceneEntity(scene);

                    // Don't touch it if the scene is under live link control (@Todo: SubSceneStreamingSystem.IgnoreTag could be live link specific?)
                    if (sceneEntity != Entity.Null && !EntityManager.HasComponent <DisableSceneResolveAndLoad>(sceneEntity))
                    {
                        var unloadFlags = SceneSystem.UnloadParameters.DestroySectionProxyEntities | SceneSystem.UnloadParameters.DontRemoveRequestSceneLoaded;
                        sceneSystem.UnloadScene(sceneEntity, unloadFlags);
                    }
                }
                m_ChangedScenes.Clear();
            }
        }
        //@TODO: What happens if we change source assets between queuing a request for the first time and it being resolved?

        protected override void OnUpdate()
        {
            //TODO: How can we disable systems in specific builds?
#if !UNITY_EDITOR
            Enabled = !LiveLinkUtility.LiveLinkEnabled;
            if (!Enabled)
            {
                return;
            }
#else
            SceneWithBuildConfigurationGUIDs.ValidateBuildSettingsCache();
#endif
            var buildConfigurationGUID = World.GetExistingSystem <SceneSystem>().BuildConfigurationGUID;

            UpdateSceneContentsChanged(buildConfigurationGUID);

#if UNITY_EDITOR && !USE_SUBSCENE_EDITORBUNDLES
            Entities.With(m_ImportingScenes).ForEach((Entity sceneEntity, ref SceneReference scene, ref RequestSceneLoaded requestSceneLoaded) =>
            {
                var hash = EntityScenesPaths.GetSubSceneArtifactHash(scene.SceneGUID, buildConfigurationGUID, ImportMode.NoImport);
                if (hash.IsValid)
                {
                    LogResolving("Polling Importing (completed)", scene.SceneGUID);
                    ResolveScene(sceneEntity, ref scene, requestSceneLoaded, hash);
                }
                else
                {
                    LogResolving("Polling Importing (not complete)", scene.SceneGUID);
                }
            });
#endif


            //@TODO: Temporary workaround to prevent crash after build player
            if (m_ScenesToRequest.IsEmptyIgnoreFilter)
            {
                return;
            }

            // We are seeing this scene for the first time, so we need to schedule a request.
            Entities.With(m_ScenesToRequest).ForEach((Entity sceneEntity, ref SceneReference scene, ref RequestSceneLoaded requestSceneLoaded) =>
            {
#if UNITY_EDITOR && !USE_SUBSCENE_EDITORBUNDLES
                var blocking   = (requestSceneLoaded.LoadFlags & SceneLoadFlags.BlockOnImport) != 0;
                var importMode = blocking ? ImportMode.Synchronous : ImportMode.Asynchronous;

                var hash = EntityScenesPaths.GetSubSceneArtifactHash(scene.SceneGUID, buildConfigurationGUID, importMode);
                if (hash.IsValid)
                {
                    LogResolving(blocking ? "Blocking import (completed)" : "Queue not yet requested (completed)", scene.SceneGUID);
                    ResolveScene(sceneEntity, ref scene, requestSceneLoaded, hash);
                }
                else
                {
                    LogResolving(blocking ? "Blocking import (failed)" : "Queue not yet requested (not complete)", scene.SceneGUID);
                }
#else
                ResolveScene(sceneEntity, ref scene, requestSceneLoaded, new Hash128());
#endif
            });
            EntityManager.AddComponent(m_ScenesToRequest, ComponentType.ReadWrite <ResolvedSectionEntity>());
        }