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