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