diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index 5ef660a76d..523427d0d2 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -357,9 +357,13 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private var drawerDefaultProton by mutableStateOf(null) private val drawerComponentMenu by lazy { ComponentsMenu(this, uiHandler) } private var drawerGameProfileId by mutableStateOf(null) + private var fpsLimit by mutableStateOf(SessionState.fpsLimit) private fun noSteamSession(): Boolean = SessionState.mode == SessionService.MODE_RUN && - SessionState.program in setOf(com.droiddeck.launcher.session.NoSteamLaunch.PROTON_RUN, com.droiddeck.launcher.session.NoSteamLaunch.EPIC) + SessionState.program in setOf( + com.droiddeck.launcher.session.NoSteamLaunch.PROTON_RUN, com.droiddeck.launcher.session.NoSteamLaunch.EPIC, + com.droiddeck.launcher.session.NoSteamLaunch.BATTLENET, + ) private val drawerGameInventory = GameProfileInventoryCache() private var drawerGameInventoryRevision = 0L private var drawerGameFexPresetSaving by mutableStateOf(false) @@ -581,6 +585,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } com.droiddeck.launcher.gpu.SteamVrHealth.begin(this, SessionState.sessionId) window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) + if (!SessionState.running) { + SessionState.fpsLimit = 0 + fpsLimit = 0 + } applyOutputPacing() if (!SessionState.running) SessionState.followScreen = followChoice() applyFollowOrientation(resources.configuration) @@ -1199,6 +1207,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { textureLodBias = it } }, + fpsLimit = fpsLimit, + onFpsLimit = { fps -> + SessionState.fpsLimit = fps + fpsLimit = fps + applyOutputPacing() + }, onFrameGenPick = { mode -> FrameGen.set(this@SessionActivity, mode) readPrefs() @@ -2218,7 +2232,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private fun mirrorRefreshLimit(): Int = GlassesRendering.mirrorRefreshLimit(glassesSettings, glasses, glassesScreen != null) - private fun outputFpsLimit(): Int = SessionPrefs.compositorFpsLimit(mirrorRefreshLimit()) + private fun outputFpsLimit(): Int = SessionPrefs.compositorFpsLimit(mirrorRefreshLimit(), if (noSteamSession()) SessionState.fpsLimit else 0) private fun steamUiLimit(hz: Float): Int = if (steamUiFocused && SessionPrefs.steamUiPacing(this)) SessionPrefs.steamUiFpsLimit(hz) else 0 diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index e8480def09..05f81ce7eb 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -1087,12 +1087,21 @@ object SessionPrefs { /** Compositor frame limit that releases buffers to the game unpaced. */ const val FPS_UNPACED = -1 + /** The drawer's frame limit slider: its first stop is Off. */ + const val FPS_LIMIT_OFF = 15 + const val FPS_LIMIT_MAX = 120 + /** * Buffers go back to the game as soon as they are replaced instead of once per refresh; - * Steam's Frame Limit in the Quick Access menu caps games. Mirroring still follows the glasses' refresh rate. + * Steam's Frame Limit in the Quick Access menu caps Steam games, and the drawer's limit caps games + * launched without Steam. Mirroring still follows the glasses' refresh rate. */ - fun compositorFpsLimit(mirrorRefreshLimit: Int): Int = - if (mirrorRefreshLimit <= 0) FPS_UNPACED else mirrorRefreshLimit + fun compositorFpsLimit(mirrorRefreshLimit: Int, sessionLimit: Int = 0): Int = when { + mirrorRefreshLimit <= 0 && sessionLimit <= 0 -> FPS_UNPACED + mirrorRefreshLimit <= 0 -> sessionLimit + sessionLimit <= 0 -> mirrorRefreshLimit + else -> minOf(mirrorRefreshLimit, sessionLimit) + } private const val STEAM_UI_FPS = 60f diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt index 3bfdd2d53f..7b7dc4fdfd 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -334,6 +334,7 @@ class SessionService : Service() { return START_NOT_STICKY } SessionState.mode = intent?.getStringExtra(EXTRA_MODE) ?: MODE_STEAM + SessionState.fpsLimit = 0 suspendPolicy = SessionPrefs.suspendPolicy(this, SessionState.mode) steamDownloadsInBackground = SessionPrefs.steamDownloadsInBackground(this) activityVisible = true diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt index 2103601d6d..088c8b7d00 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionState.kt @@ -108,6 +108,10 @@ object SessionState { @Volatile var upscaleRatio: Float = 0f + /** Frame limit chosen in the drawer for a game launched without Steam; 0 is off. */ + @Volatile + var fpsLimit: Int = 0 + @Volatile var firstFrameSeen = false diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt index 57949a2f20..c74910bf21 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt @@ -247,6 +247,8 @@ class DrawerActions( val onHudReset: () -> Unit = {}, val onHudExport: () -> Unit = {}, val onFrameGenPick: (FrameGen.Mode) -> Unit, + val fpsLimit: Int = 0, + val onFpsLimit: (Int) -> Unit = {}, val onImportLossless: () -> Unit, val onKeyboard: () -> Unit, val onHardwareKeyboard: () -> Unit, @@ -535,6 +537,7 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont SessionDrawerPage.DISPLAY -> { SettingsGroup(stringResource(R.string.drawer_page_display)) { val fgOpen = host.open == "fg" + val offLabel = stringResource(R.string.frame_gen_off) val fgLabel = FrameGen.label(LocalContext.current, a.frameGen) SettingsRow(stringResource(R.string.frame_gen_title), null, highlighted = fgOpen) { Box { @@ -542,6 +545,13 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont FrameGenMenu(host, a.frameGen, a.lossless, a.onFrameGenPick, a.onImportLossless) } } + if (a.direct) SliderRow( + stringResource(R.string.drawer_frame_limit), stringResource(R.string.drawer_frame_limit_note), + a.fpsLimit.takeIf { it > 0 } ?: SessionPrefs.FPS_LIMIT_OFF, + SessionPrefs.FPS_LIMIT_OFF..SessionPrefs.FPS_LIMIT_MAX, step = 5, + format = { if (it <= SessionPrefs.FPS_LIMIT_OFF) offLabel else it.toString() }, + modifier = focus.track(page, "fps-limit"), + onChange = { a.onFpsLimit(if (it <= SessionPrefs.FPS_LIMIT_OFF) 0 else it) }) } SettingsGroup(stringResource(R.string.display_image_scaling)) { ChoiceRow(host, "upscaler", stringResource(R.string.display_filter), null, diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 202ae96183..8515c297a6 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -642,6 +642,8 @@ Its files are removed from the app. Its files are removed. It\'s in use, so the default takes over. Display + Frame limit + Caps this game. The display switches to a refresh rate the cap divides evenly when it has one; other caps can look uneven. Steam games use Steam\'s Frame Limit in the Quick Access menu. Effects Controls Components diff --git a/app/src/test/java/com/droiddeck/launcher/session/OutputPacingTest.kt b/app/src/test/java/com/droiddeck/launcher/session/OutputPacingTest.kt index bd7dc380f5..824888822a 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/OutputPacingTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/OutputPacingTest.kt @@ -8,6 +8,15 @@ class OutputPacingTest { assertEquals(SessionPrefs.FPS_UNPACED, SessionPrefs.compositorFpsLimit(0)) } + @Test fun sessionLimitPacesThePhone() { + assertEquals(45, SessionPrefs.compositorFpsLimit(0, 45)) + } + + @Test fun sessionLimitNeverExceedsTheGlassesRate() { + assertEquals(60, SessionPrefs.compositorFpsLimit(60, 90)) + assertEquals(30, SessionPrefs.compositorFpsLimit(60, 30)) + } + @Test fun mirroringKeepsTheGlassesRate() { assertEquals(60, SessionPrefs.compositorFpsLimit(60)) }