bauiv1lib.settings.graphics

  1# Released under the MIT License. See LICENSE for details.
  2#
  3"""Provides UI for graphics settings."""
  4
  5from __future__ import annotations
  6
  7from typing import TYPE_CHECKING, cast, override
  8
  9from bauiv1lib.popup import PopupMenu
 10from bauiv1lib.config import ConfigCheckBox
 11import bauiv1 as bui
 12
 13if TYPE_CHECKING:
 14    from typing import Any
 15
 16
 17class GraphicsSettingsWindow(bui.MainWindow):
 18    """Window for graphics settings."""
 19
 20    def __init__(
 21        self,
 22        transition: str | None = 'in_right',
 23        origin_widget: bui.Widget | None = None,
 24    ):
 25        # pylint: disable=too-many-locals
 26        # pylint: disable=too-many-branches
 27        # pylint: disable=too-many-statements
 28
 29        self._r = 'graphicsSettingsWindow'
 30        app = bui.app
 31        assert app.classic is not None
 32
 33        spacing = 32
 34        self._have_selected_child = False
 35        uiscale = app.ui_v1.uiscale
 36        width = 450.0
 37        height = 302.0
 38        self._max_fps_dirty = False
 39        self._last_max_fps_set_time = bui.apptime()
 40        self._last_max_fps_str = ''
 41
 42        self._show_fullscreen = False
 43        fullscreen_spacing_top = spacing * 0.2
 44        fullscreen_spacing = spacing * 1.2
 45        if bui.fullscreen_control_available():
 46            self._show_fullscreen = True
 47            height += fullscreen_spacing + fullscreen_spacing_top
 48
 49        show_vsync = bui.supports_vsync()
 50        show_tv_mode = not bui.app.env.vr
 51
 52        show_max_fps = bui.supports_max_fps()
 53        if show_max_fps:
 54            height += 50
 55
 56        show_resolution = True
 57        if app.env.vr:
 58            show_resolution = (
 59                app.classic.platform == 'android'
 60                and app.classic.subplatform == 'cardboard'
 61            )
 62
 63        assert bui.app.classic is not None
 64        uiscale = bui.app.ui_v1.uiscale
 65        base_scale = (
 66            1.5
 67            if uiscale is bui.UIScale.SMALL
 68            else 1.3 if uiscale is bui.UIScale.MEDIUM else 1.0
 69        )
 70        popup_menu_scale = base_scale * 1.2
 71        v = height - 50
 72        v -= spacing * 1.15
 73        super().__init__(
 74            root_widget=bui.containerwidget(
 75                size=(width, height),
 76                scale=base_scale,
 77                stack_offset=(
 78                    (0, -10) if uiscale is bui.UIScale.SMALL else (0, 0)
 79                ),
 80                toolbar_visibility=(
 81                    'menu_minimal'
 82                    if uiscale is bui.UIScale.SMALL
 83                    else 'menu_full'
 84                ),
 85            ),
 86            transition=transition,
 87            origin_widget=origin_widget,
 88        )
 89
 90        back_button = bui.buttonwidget(
 91            parent=self._root_widget,
 92            position=(35, height - 50),
 93            # size=(120, 60),
 94            size=(60, 60),
 95            scale=0.8,
 96            text_scale=1.2,
 97            autoselect=True,
 98            label=bui.charstr(bui.SpecialChar.BACK),
 99            button_type='backSmall',
100            on_activate_call=self.main_window_back,
101        )
102
103        bui.containerwidget(edit=self._root_widget, cancel_button=back_button)
104
105        bui.textwidget(
106            parent=self._root_widget,
107            position=(0, height - 44),
108            size=(width, 25),
109            text=bui.Lstr(resource=f'{self._r}.titleText'),
110            color=bui.app.ui_v1.title_color,
111            h_align='center',
112            v_align='top',
113        )
114
115        self._fullscreen_checkbox: bui.Widget | None = None
116        if self._show_fullscreen:
117            v -= fullscreen_spacing_top
118            # Fullscreen control does not necessarily talk to the
119            # app config so we have to wrangle it manually instead of
120            # using a config-checkbox.
121            label = bui.Lstr(resource=f'{self._r}.fullScreenText')
122
123            # Show keyboard shortcut alongside the control if they
124            # provide one.
125            shortcut = bui.fullscreen_control_key_shortcut()
126            if shortcut is not None:
127                label = bui.Lstr(
128                    value='$(NAME) [$(SHORTCUT)]',
129                    subs=[('$(NAME)', label), ('$(SHORTCUT)', shortcut)],
130                )
131            self._fullscreen_checkbox = bui.checkboxwidget(
132                parent=self._root_widget,
133                position=(100, v),
134                value=bui.fullscreen_control_get(),
135                on_value_change_call=bui.fullscreen_control_set,
136                maxwidth=250,
137                size=(300, 30),
138                text=label,
139            )
140
141            if not self._have_selected_child:
142                bui.containerwidget(
143                    edit=self._root_widget,
144                    selected_child=self._fullscreen_checkbox,
145                )
146                self._have_selected_child = True
147            v -= fullscreen_spacing
148
149        self._selected_color = (0.5, 1, 0.5, 1)
150        self._unselected_color = (0.7, 0.7, 0.7, 1)
151
152        # Quality
153        bui.textwidget(
154            parent=self._root_widget,
155            position=(60, v),
156            size=(160, 25),
157            text=bui.Lstr(resource=f'{self._r}.visualsText'),
158            color=bui.app.ui_v1.heading_color,
159            scale=0.65,
160            maxwidth=150,
161            h_align='center',
162            v_align='center',
163        )
164        PopupMenu(
165            parent=self._root_widget,
166            position=(60, v - 50),
167            width=150,
168            scale=popup_menu_scale,
169            choices=['Auto', 'Higher', 'High', 'Medium', 'Low'],
170            choices_disabled=(
171                ['Higher', 'High']
172                if bui.get_max_graphics_quality() == 'Medium'
173                else []
174            ),
175            choices_display=[
176                bui.Lstr(resource='autoText'),
177                bui.Lstr(resource=f'{self._r}.higherText'),
178                bui.Lstr(resource=f'{self._r}.highText'),
179                bui.Lstr(resource=f'{self._r}.mediumText'),
180                bui.Lstr(resource=f'{self._r}.lowText'),
181            ],
182            current_choice=bui.app.config.resolve('Graphics Quality'),
183            on_value_change_call=self._set_quality,
184        )
185
186        # Texture controls
187        bui.textwidget(
188            parent=self._root_widget,
189            position=(230, v),
190            size=(160, 25),
191            text=bui.Lstr(resource=f'{self._r}.texturesText'),
192            color=bui.app.ui_v1.heading_color,
193            scale=0.65,
194            maxwidth=150,
195            h_align='center',
196            v_align='center',
197        )
198        textures_popup = PopupMenu(
199            parent=self._root_widget,
200            position=(230, v - 50),
201            width=150,
202            scale=popup_menu_scale,
203            choices=['Auto', 'High', 'Medium', 'Low'],
204            choices_display=[
205                bui.Lstr(resource='autoText'),
206                bui.Lstr(resource=f'{self._r}.highText'),
207                bui.Lstr(resource=f'{self._r}.mediumText'),
208                bui.Lstr(resource=f'{self._r}.lowText'),
209            ],
210            current_choice=bui.app.config.resolve('Texture Quality'),
211            on_value_change_call=self._set_textures,
212        )
213        bui.widget(
214            edit=textures_popup.get_button(),
215            right_widget=bui.get_special_widget('squad_button'),
216        )
217        v -= 80
218
219        h_offs = 0
220
221        resolution_popup: PopupMenu | None = None
222
223        if show_resolution:
224            bui.textwidget(
225                parent=self._root_widget,
226                position=(h_offs + 60, v),
227                size=(160, 25),
228                text=bui.Lstr(resource=f'{self._r}.resolutionText'),
229                color=bui.app.ui_v1.heading_color,
230                scale=0.65,
231                maxwidth=150,
232                h_align='center',
233                v_align='center',
234            )
235
236            # On standard android we have 'Auto', 'Native', and a few
237            # HD standards.
238            if app.classic.platform == 'android':
239                # on cardboard/daydream android we have a few
240                # render-target-scale options
241                if app.classic.subplatform == 'cardboard':
242                    rawval = bui.app.config.resolve('GVR Render Target Scale')
243                    current_res_cardboard = (
244                        str(min(100, max(10, int(round(rawval * 100.0))))) + '%'
245                    )
246                    resolution_popup = PopupMenu(
247                        parent=self._root_widget,
248                        position=(h_offs + 60, v - 50),
249                        width=120,
250                        scale=popup_menu_scale,
251                        choices=['100%', '75%', '50%', '35%'],
252                        current_choice=current_res_cardboard,
253                        on_value_change_call=self._set_gvr_render_target_scale,
254                    )
255                else:
256                    native_res = bui.get_display_resolution()
257                    assert native_res is not None
258                    choices = ['Auto', 'Native']
259                    choices_display = [
260                        bui.Lstr(resource='autoText'),
261                        bui.Lstr(resource='nativeText'),
262                    ]
263                    for res in [1440, 1080, 960, 720, 480]:
264                        if native_res[1] >= res:
265                            res_str = f'{res}p'
266                            choices.append(res_str)
267                            choices_display.append(bui.Lstr(value=res_str))
268                    current_res_android = bui.app.config.resolve(
269                        'Resolution (Android)'
270                    )
271                    resolution_popup = PopupMenu(
272                        parent=self._root_widget,
273                        position=(h_offs + 60, v - 50),
274                        width=120,
275                        scale=popup_menu_scale,
276                        choices=choices,
277                        choices_display=choices_display,
278                        current_choice=current_res_android,
279                        on_value_change_call=self._set_android_res,
280                    )
281            else:
282                # If we're on a system that doesn't allow setting resolution,
283                # set pixel-scale instead.
284                current_res = bui.get_display_resolution()
285                if current_res is None:
286                    rawval = bui.app.config.resolve('Screen Pixel Scale')
287                    current_res2 = (
288                        str(min(100, max(10, int(round(rawval * 100.0))))) + '%'
289                    )
290                    resolution_popup = PopupMenu(
291                        parent=self._root_widget,
292                        position=(h_offs + 60, v - 50),
293                        width=120,
294                        scale=popup_menu_scale,
295                        choices=['100%', '88%', '75%', '63%', '50%'],
296                        current_choice=current_res2,
297                        on_value_change_call=self._set_pixel_scale,
298                    )
299                else:
300                    raise RuntimeError(
301                        'obsolete code path; discrete resolutions'
302                        ' no longer supported'
303                    )
304        if resolution_popup is not None:
305            bui.widget(
306                edit=resolution_popup.get_button(),
307                left_widget=back_button,
308            )
309
310        vsync_popup: PopupMenu | None = None
311        if show_vsync:
312            bui.textwidget(
313                parent=self._root_widget,
314                position=(230, v),
315                size=(160, 25),
316                text=bui.Lstr(resource=f'{self._r}.verticalSyncText'),
317                color=bui.app.ui_v1.heading_color,
318                scale=0.65,
319                maxwidth=150,
320                h_align='center',
321                v_align='center',
322            )
323            vsync_popup = PopupMenu(
324                parent=self._root_widget,
325                position=(230, v - 50),
326                width=150,
327                scale=popup_menu_scale,
328                choices=['Auto', 'Always', 'Never'],
329                choices_display=[
330                    bui.Lstr(resource='autoText'),
331                    bui.Lstr(resource=f'{self._r}.alwaysText'),
332                    bui.Lstr(resource=f'{self._r}.neverText'),
333                ],
334                current_choice=bui.app.config.resolve('Vertical Sync'),
335                on_value_change_call=self._set_vsync,
336            )
337            if resolution_popup is not None:
338                bui.widget(
339                    edit=vsync_popup.get_button(),
340                    left_widget=resolution_popup.get_button(),
341                )
342
343        if resolution_popup is not None and vsync_popup is not None:
344            bui.widget(
345                edit=resolution_popup.get_button(),
346                right_widget=vsync_popup.get_button(),
347            )
348
349        v -= 90
350        self._max_fps_text: bui.Widget | None = None
351        if show_max_fps:
352            v -= 5
353            bui.textwidget(
354                parent=self._root_widget,
355                position=(155, v + 10),
356                size=(0, 0),
357                text=bui.Lstr(resource=f'{self._r}.maxFPSText'),
358                color=bui.app.ui_v1.heading_color,
359                scale=0.9,
360                maxwidth=90,
361                h_align='right',
362                v_align='center',
363            )
364
365            max_fps_str = str(bui.app.config.resolve('Max FPS'))
366            self._last_max_fps_str = max_fps_str
367            self._max_fps_text = bui.textwidget(
368                parent=self._root_widget,
369                position=(170, v - 5),
370                size=(105, 30),
371                text=max_fps_str,
372                max_chars=5,
373                editable=True,
374                h_align='left',
375                v_align='center',
376                on_return_press_call=self._on_max_fps_return_press,
377            )
378            v -= 45
379
380        if self._max_fps_text is not None and resolution_popup is not None:
381            bui.widget(
382                edit=resolution_popup.get_button(),
383                down_widget=self._max_fps_text,
384            )
385            bui.widget(
386                edit=self._max_fps_text,
387                up_widget=resolution_popup.get_button(),
388            )
389
390        fpsc = ConfigCheckBox(
391            parent=self._root_widget,
392            position=(69, v - 6),
393            size=(210, 30),
394            scale=0.86,
395            configkey='Show FPS',
396            displayname=bui.Lstr(resource=f'{self._r}.showFPSText'),
397            maxwidth=130,
398        )
399        if self._max_fps_text is not None:
400            bui.widget(
401                edit=self._max_fps_text,
402                down_widget=fpsc.widget,
403            )
404            bui.widget(
405                edit=fpsc.widget,
406                up_widget=self._max_fps_text,
407            )
408
409        if show_tv_mode:
410            tvc = ConfigCheckBox(
411                parent=self._root_widget,
412                position=(240, v - 6),
413                size=(210, 30),
414                scale=0.86,
415                configkey='TV Border',
416                displayname=bui.Lstr(resource=f'{self._r}.tvBorderText'),
417                maxwidth=130,
418            )
419            bui.widget(edit=fpsc.widget, right_widget=tvc.widget)
420            bui.widget(edit=tvc.widget, left_widget=fpsc.widget)
421
422        v -= spacing
423
424        # Make a timer to update our controls in case the config changes
425        # under us.
426        self._update_timer = bui.AppTimer(
427            0.25, bui.WeakCall(self._update_controls), repeat=True
428        )
429
430    @override
431    def get_main_window_state(self) -> bui.MainWindowState:
432        # Support recreating our window for back/refresh purposes.
433        cls = type(self)
434        return bui.BasicMainWindowState(
435            create_call=lambda transition, origin_widget: cls(
436                transition=transition, origin_widget=origin_widget
437            )
438        )
439
440    @override
441    def on_main_window_close(self) -> None:
442        self._apply_max_fps()
443
444    def _set_quality(self, quality: str) -> None:
445        cfg = bui.app.config
446        cfg['Graphics Quality'] = quality
447        cfg.apply_and_commit()
448
449    def _set_textures(self, val: str) -> None:
450        cfg = bui.app.config
451        cfg['Texture Quality'] = val
452        cfg.apply_and_commit()
453
454    def _set_android_res(self, val: str) -> None:
455        cfg = bui.app.config
456        cfg['Resolution (Android)'] = val
457        cfg.apply_and_commit()
458
459    def _set_pixel_scale(self, res: str) -> None:
460        cfg = bui.app.config
461        cfg['Screen Pixel Scale'] = float(res[:-1]) / 100.0
462        cfg.apply_and_commit()
463
464    def _set_gvr_render_target_scale(self, res: str) -> None:
465        cfg = bui.app.config
466        cfg['GVR Render Target Scale'] = float(res[:-1]) / 100.0
467        cfg.apply_and_commit()
468
469    def _set_vsync(self, val: str) -> None:
470        cfg = bui.app.config
471        cfg['Vertical Sync'] = val
472        cfg.apply_and_commit()
473
474    def _on_max_fps_return_press(self) -> None:
475        self._apply_max_fps()
476        bui.containerwidget(
477            edit=self._root_widget, selected_child=cast(bui.Widget, 0)
478        )
479
480    def _apply_max_fps(self) -> None:
481        if not self._max_fps_dirty or not self._max_fps_text:
482            return
483
484        val: Any = bui.textwidget(query=self._max_fps_text)
485        assert isinstance(val, str)
486        # If there's a broken value, replace it with the default.
487        try:
488            ival = int(val)
489        except ValueError:
490            ival = bui.app.config.default_value('Max FPS')
491        assert isinstance(ival, int)
492
493        # Clamp to reasonable limits (allow -1 to mean no max).
494        if ival != -1:
495            ival = max(10, ival)
496            ival = min(99999, ival)
497
498        # Store it to the config.
499        cfg = bui.app.config
500        cfg['Max FPS'] = ival
501        cfg.apply_and_commit()
502
503        # Update the display if we changed the value.
504        if str(ival) != val:
505            bui.textwidget(edit=self._max_fps_text, text=str(ival))
506
507        self._max_fps_dirty = False
508
509    def _update_controls(self) -> None:
510        if self._max_fps_text is not None:
511            # Keep track of when the max-fps value changes. Once it
512            # remains stable for a few moments, apply it.
513            val: Any = bui.textwidget(query=self._max_fps_text)
514            assert isinstance(val, str)
515            if val != self._last_max_fps_str:
516                # Oop; it changed. Note the time and the fact that we'll
517                # need to apply it at some point.
518                self._max_fps_dirty = True
519                self._last_max_fps_str = val
520                self._last_max_fps_set_time = bui.apptime()
521            else:
522                # If its been stable long enough, apply it.
523                if (
524                    self._max_fps_dirty
525                    and bui.apptime() - self._last_max_fps_set_time > 1.0
526                ):
527                    self._apply_max_fps()
528
529        if self._show_fullscreen:
530            # Keep the fullscreen checkbox up to date with the current value.
531            bui.checkboxwidget(
532                edit=self._fullscreen_checkbox,
533                value=bui.fullscreen_control_get(),
534            )