crimsonland 0.1.0.dev11__py3-none-any.whl → 0.1.0.dev13__py3-none-any.whl

crimson/frontend/panels/controls.py

@@ -9,11 +9,13 @@ from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
 from ..menu import (
     MENU_PANEL_OFFSET_X,
     MENU_PANEL_OFFSET_Y,
+    MENU_PANEL_HEIGHT,
     MENU_PANEL_WIDTH,
     MenuView,
     _draw_menu_cursor,
 )
 from ..transitions import _draw_screen_fade
+from ...ui.menu_panel import draw_classic_menu_panel
 from .base import PANEL_TIMELINE_END_MS, PANEL_TIMELINE_START_MS, PanelMenuView
 from ...input_codes import config_keybinds, input_code_name, player_move_fire_binds
 
@@ -21,20 +23,46 @@ if TYPE_CHECKING:
     from ...game import GameState
 
 
+# Measured from ui_render_trace_oracle_1024x768.json (state_3:Configure for:, timeline=300).
+CONTROLS_LEFT_PANEL_POS_X = -165.0
+CONTROLS_LEFT_PANEL_POS_Y = 200.0
+CONTROLS_RIGHT_PANEL_POS_X = 590.0
+CONTROLS_RIGHT_PANEL_POS_Y = 110.0
+CONTROLS_RIGHT_PANEL_HEIGHT = 378.0
+CONTROLS_BACK_POS_X = -155.0
+CONTROLS_BACK_POS_Y = 420.0
+
+
 class ControlsMenuView(PanelMenuView):
     def __init__(self, state: GameState) -> None:
-        super().__init__(state, title="Controls", back_action="open_options")
+        super().__init__(
+            state,
+            title="Controls",
+            back_action="open_options",
+            panel_pos_x=CONTROLS_LEFT_PANEL_POS_X,
+            panel_pos_y=CONTROLS_LEFT_PANEL_POS_Y,
+            back_pos_x=CONTROLS_BACK_POS_X,
+            back_pos_y=CONTROLS_BACK_POS_Y,
+        )
         self._small_font: SmallFontData | None = None
-        self._lines: list[str] = []
+        self._text_controls: rl.Texture2D | None = None
+        self._drop_off: rl.Texture2D | None = None
+        self._check_on: rl.Texture2D | None = None
+        self._check_off: rl.Texture2D | None = None
+
+        self._config_player = 1
 
     def open(self) -> None:
         super().open()
-        self._lines = self._build_lines()
+        cache = self._ensure_cache()
+        # UI elements used by the classic controls screen.
+        self._text_controls = cache.get_or_load("ui_textControls", "ui/ui_textControls.jaz").texture
+        self._drop_off = cache.get_or_load("ui_dropOff", "ui/ui_dropDownOff.jaz").texture
+        self._check_on = cache.get_or_load("ui_checkOn", "ui/ui_checkOn.jaz").texture
+        self._check_off = cache.get_or_load("ui_checkOff", "ui/ui_checkOff.jaz").texture
 
     def draw(self) -> None:
-        rl.clear_background(rl.BLACK)
-        if self._ground is not None:
-            self._ground.draw(0.0, 0.0)
+        self._draw_background()
         _draw_screen_fade(self._state)
         assets = self._assets
         entry = self._entry
@@ -53,9 +81,17 @@ class ControlsMenuView(PanelMenuView):
         self._small_font = load_small_font(self._state.assets_dir, missing_assets)
         return self._small_font
 
-    def _content_layout(self) -> dict[str, float]:
-        panel_scale, _local_shift = self._menu_item_scale(0)
+    def _draw_panel(self) -> None:
+        assets = self._assets
+        if assets is None or assets.panel is None:
+            return
+        panel = assets.panel
+
+        fx_detail = bool(self._state.config.data.get("fx_detail_0", 0))
+        panel_scale, _local_y_shift = self._menu_item_scale(0)
         panel_w = MENU_PANEL_WIDTH * panel_scale
+
+        # Left (controls options) panel: standard 254px height => a single quad.
         _angle_rad, slide_x = MenuView._ui_element_anim(
             self,
             index=1,
@@ -63,23 +99,93 @@ class ControlsMenuView(PanelMenuView):
             end_ms=PANEL_TIMELINE_END_MS,
             width=panel_w,
         )
-        panel_x = self._panel_pos_x + slide_x
-        panel_y = self._panel_pos_y + self._widescreen_y_shift
-        origin_x = -(MENU_PANEL_OFFSET_X * panel_scale)
-        origin_y = -(MENU_PANEL_OFFSET_Y * panel_scale)
-        panel_left = panel_x - origin_x
-        panel_top = panel_y - origin_y
-        base_x = panel_left + 212.0 * panel_scale
-        base_y = panel_top + 32.0 * panel_scale
-        label_x = base_x + 8.0 * panel_scale
-        return {
-            "base_x": base_x,
-            "base_y": base_y,
-            "label_x": label_x,
-            "scale": panel_scale,
-        }
-
-    def _build_lines(self) -> list[str]:
+        left_x0 = self._panel_pos_x + slide_x + MENU_PANEL_OFFSET_X * panel_scale
+        left_y0 = self._panel_pos_y + self._widescreen_y_shift + MENU_PANEL_OFFSET_Y * panel_scale
+        left_h = MENU_PANEL_HEIGHT * panel_scale
+        draw_classic_menu_panel(panel, dst=rl.Rectangle(left_x0, left_y0, panel_w, left_h), tint=rl.WHITE, shadow=fx_detail)
+
+        # Right (configured bindings) panel: tall 378px panel rendered as 3 vertical slices.
+        _angle_rad, slide_x = MenuView._ui_element_anim(
+            self,
+            index=3,
+            start_ms=PANEL_TIMELINE_START_MS,
+            end_ms=PANEL_TIMELINE_END_MS,
+            width=panel_w,
+            direction_flag=1,
+        )
+        right_x0 = CONTROLS_RIGHT_PANEL_POS_X + slide_x + MENU_PANEL_OFFSET_X * panel_scale
+        right_y0 = CONTROLS_RIGHT_PANEL_POS_Y + self._widescreen_y_shift + MENU_PANEL_OFFSET_Y * panel_scale
+        right_h = float(CONTROLS_RIGHT_PANEL_HEIGHT) * panel_scale
+        draw_classic_menu_panel(panel, dst=rl.Rectangle(right_x0, right_y0, panel_w, right_h), tint=rl.WHITE, shadow=fx_detail)
+
+    def _draw_contents(self) -> None:
+        # Positions are expressed relative to the panel top-left corners and scaled with the panel scale.
+        panel_scale, _local_y_shift = self._menu_item_scale(0)
+
+        left_x0 = self._panel_pos_x + MENU_PANEL_OFFSET_X * panel_scale
+        left_y0 = self._panel_pos_y + self._widescreen_y_shift + MENU_PANEL_OFFSET_Y * panel_scale
+        right_x0 = CONTROLS_RIGHT_PANEL_POS_X + MENU_PANEL_OFFSET_X * panel_scale
+        right_y0 = CONTROLS_RIGHT_PANEL_POS_Y + self._widescreen_y_shift + MENU_PANEL_OFFSET_Y * panel_scale
+
+        font = self._ensure_small_font()
+        text_color = rl.Color(255, 255, 255, 255)
+
+        # --- Left panel: "Configure for" + method selectors (state_3 in trace) ---
+        if self._text_controls is not None:
+            MenuView._draw_ui_quad(
+                texture=self._text_controls,
+                src=rl.Rectangle(0.0, 0.0, float(self._text_controls.width), float(self._text_controls.height)),
+                dst=rl.Rectangle(left_x0 + 206.0 * panel_scale, left_y0 + 44.0 * panel_scale, 128.0 * panel_scale, 32.0 * panel_scale),
+                origin=rl.Vector2(0.0, 0.0),
+                rotation_deg=0.0,
+                tint=rl.WHITE,
+            )
+
+        draw_small_text(font, "Configure for:", left_x0 + 339.0 * panel_scale, left_y0 + 41.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, f"Player {int(self._config_player)}", left_x0 + 344.0 * panel_scale, left_y0 + 57.0 * panel_scale, 1.0 * panel_scale, text_color)
+
+        draw_small_text(font, "Aiming method:", left_x0 + 213.0 * panel_scale, left_y0 + 86.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Mouse", left_x0 + 218.0 * panel_scale, left_y0 + 103.0 * panel_scale, 1.0 * panel_scale, text_color)
+
+        draw_small_text(font, "Moving method:", left_x0 + 213.0 * panel_scale, left_y0 + 128.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Static", left_x0 + 218.0 * panel_scale, left_y0 + 145.0 * panel_scale, 1.0 * panel_scale, text_color)
+
+        check_tex = self._check_on
+        if check_tex is not None:
+            MenuView._draw_ui_quad(
+                texture=check_tex,
+                src=rl.Rectangle(0.0, 0.0, float(check_tex.width), float(check_tex.height)),
+                dst=rl.Rectangle(left_x0 + 213.0 * panel_scale, left_y0 + 174.0 * panel_scale, 16.0 * panel_scale, 16.0 * panel_scale),
+                origin=rl.Vector2(0.0, 0.0),
+                rotation_deg=0.0,
+                tint=rl.WHITE,
+            )
+        draw_small_text(
+            font,
+            "Show direction arrow",
+            left_x0 + 235.0 * panel_scale,
+            left_y0 + 175.0 * panel_scale,
+            1.0 * panel_scale,
+            text_color,
+        )
+
+        drop_tex = self._drop_off
+        if drop_tex is not None:
+            for ox, oy in (
+                (418.0, 56.0),  # player dropdown
+                (336.0, 102.0),  # aiming dropdown
+                (336.0, 144.0),  # moving dropdown
+            ):
+                MenuView._draw_ui_quad(
+                    texture=drop_tex,
+                    src=rl.Rectangle(0.0, 0.0, float(drop_tex.width), float(drop_tex.height)),
+                    dst=rl.Rectangle(left_x0 + ox * panel_scale, left_y0 + oy * panel_scale, 16.0 * panel_scale, 16.0 * panel_scale),
+                    origin=rl.Vector2(0.0, 0.0),
+                    rotation_deg=0.0,
+                    tint=rl.WHITE,
+                )
+
+        # --- Right panel: configured bindings list ---
         config = self._state.config
         pick_perk_key = int(config.data.get("keybind_pick_perk", 0x101) or 0x101)
         reload_key = int(config.data.get("keybind_reload", 0x102) or 0x102)
@@ -89,44 +195,25 @@ class ControlsMenuView(PanelMenuView):
             keybinds = (0x11, 0x1F, 0x1E, 0x20, 0x100) + (0x17E,) * 11 + (0xC8, 0xD0, 0xCB, 0xCD, 0x9D)
 
         p1_up, p1_down, p1_left, p1_right, p1_fire = player_move_fire_binds(keybinds, 0)
-        p2_up, p2_down, p2_left, p2_right, p2_fire = player_move_fire_binds(keybinds, 1)
-
-        return [
-            f"Level up: {input_code_name(pick_perk_key)} / Space / KeyPad+",
-            f"Reload: {input_code_name(reload_key)}",
-            "",
-            "Player 1:",
-            f"  Up: {input_code_name(p1_up)}",
-            f"  Down: {input_code_name(p1_down)}",
-            f"  Left: {input_code_name(p1_left)}",
-            f"  Right: {input_code_name(p1_right)}",
-            f"  Fire: {input_code_name(p1_fire)}",
-            "",
-            "Player 2:",
-            f"  Up: {input_code_name(p2_up)}",
-            f"  Down: {input_code_name(p2_down)}",
-            f"  Left: {input_code_name(p2_left)}",
-            f"  Right: {input_code_name(p2_right)}",
-            f"  Fire: {input_code_name(p2_fire)}",
-        ]
 
-    def _draw_contents(self) -> None:
-        layout = self._content_layout()
-        base_x = layout["base_x"]
-        base_y = layout["base_y"]
-        label_x = layout["label_x"]
-        scale = layout["scale"]
-
-        font = self._ensure_small_font()
-        title_scale = 1.2 * scale
-        text_scale = 1.0 * scale
-
-        title_color = rl.Color(255, 255, 255, 255)
-        text_color = rl.Color(255, 255, 255, int(255 * 0.8))
-
-        draw_small_text(font, "CONTROLS", base_x, base_y, title_scale, title_color)
-        line_y = base_y + 44.0 * scale
-        line_step = (font.cell_size + 4.0) * scale
-        for line in self._lines:
-            draw_small_text(font, line, label_x, line_y, text_scale, text_color)
-            line_y += line_step
+        draw_small_text(font, "Configured controls", right_x0 + 120.0 * panel_scale, right_y0 + 38.0 * panel_scale, 1.0 * panel_scale, text_color)
+
+        draw_small_text(font, "Aiming", right_x0 + 44.0 * panel_scale, right_y0 + 64.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Fire:", right_x0 + 52.0 * panel_scale, right_y0 + 82.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(p1_fire), right_x0 + 180.0 * panel_scale, right_y0 + 82.0 * panel_scale, 1.0 * panel_scale, text_color)
+
+        draw_small_text(font, "Moving", right_x0 + 44.0 * panel_scale, right_y0 + 106.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Move Up:", right_x0 + 52.0 * panel_scale, right_y0 + 124.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(p1_up), right_x0 + 180.0 * panel_scale, right_y0 + 124.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Move Down:", right_x0 + 52.0 * panel_scale, right_y0 + 140.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(p1_down), right_x0 + 180.0 * panel_scale, right_y0 + 140.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Move Left:", right_x0 + 52.0 * panel_scale, right_y0 + 156.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(p1_left), right_x0 + 180.0 * panel_scale, right_y0 + 156.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Move Right:", right_x0 + 52.0 * panel_scale, right_y0 + 172.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(p1_right), right_x0 + 180.0 * panel_scale, right_y0 + 172.0 * panel_scale, 1.0 * panel_scale, text_color)
+
+        draw_small_text(font, "Misc", right_x0 + 44.0 * panel_scale, right_y0 + 196.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Level Up:", right_x0 + 52.0 * panel_scale, right_y0 + 214.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(pick_perk_key), right_x0 + 180.0 * panel_scale, right_y0 + 214.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Reload:", right_x0 + 52.0 * panel_scale, right_y0 + 230.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(reload_key), right_x0 + 180.0 * panel_scale, right_y0 + 230.0 * panel_scale, 1.0 * panel_scale, text_color)

crimson/frontend/panels/credits.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pyray as rl
+
+from grim.audio import play_sfx, update_audio
+from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
+
+from ...ui.menu_panel import draw_classic_menu_panel
+from ...ui.perk_menu import UiButtonState, UiButtonTextureSet, button_draw, button_update, button_width
+from ..assets import MenuAssets, _ensure_texture_cache, load_menu_assets
+from ..menu import (
+    MENU_PANEL_OFFSET_X,
+    MENU_PANEL_OFFSET_Y,
+    MENU_PANEL_WIDTH,
+    MENU_SCALE_SMALL_THRESHOLD,
+    MENU_SIGN_HEIGHT,
+    MENU_SIGN_OFFSET_X,
+    MENU_SIGN_OFFSET_Y,
+    MENU_SIGN_POS_X_PAD,
+    MENU_SIGN_POS_Y,
+    MENU_SIGN_POS_Y_SMALL,
+    MENU_SIGN_WIDTH,
+    UI_SHADOW_OFFSET,
+    MenuView,
+    _draw_menu_cursor,
+    ensure_menu_ground,
+)
+from ..transitions import _draw_screen_fade
+
+if TYPE_CHECKING:
+    from ...game import GameState
+    from grim.terrain_render import GroundRenderer
+
+
+# Measured from ui_render_trace_oracle_1024x768.json (state_17:credits, timeline=300).
+CREDITS_PANEL_POS_X = -119.0
+CREDITS_PANEL_POS_Y = 185.0
+CREDITS_PANEL_HEIGHT = 378.0
+
+# Child layout inside the panel (relative to panel top-left).
+_TITLE_X = 202.0
+_TITLE_Y = 46.0
+
+_BACK_BUTTON_X = 298.0
+_BACK_BUTTON_Y = 310.0
+
+
+class CreditsView:
+    def __init__(self, state: GameState) -> None:
+        self._state = state
+        self._assets: MenuAssets | None = None
+        self._ground: GroundRenderer | None = None
+        self._small_font: SmallFontData | None = None
+        self._button_textures: UiButtonTextureSet | None = None
+
+        self._cursor_pulse_time = 0.0
+        self._widescreen_y_shift = 0.0
+        self._action: str | None = None
+
+        self._back_button = UiButtonState("Back", force_wide=False)
+
+    def open(self) -> None:
+        layout_w = float(self._state.config.screen_width)
+        self._widescreen_y_shift = MenuView._menu_widescreen_y_shift(layout_w)
+        self._assets = load_menu_assets(self._state)
+        self._ground = None if self._state.pause_background is not None else ensure_menu_ground(self._state)
+        self._small_font = None
+        self._cursor_pulse_time = 0.0
+        self._action = None
+
+        cache = _ensure_texture_cache(self._state)
+        button_md = cache.get_or_load("ui_buttonMd", "ui/ui_button_128x32.jaz").texture
+        button_sm = cache.get_or_load("ui_buttonSm", "ui/ui_button_64x32.jaz").texture
+        self._button_textures = UiButtonTextureSet(button_sm=button_sm, button_md=button_md)
+        self._back_button = UiButtonState("Back", force_wide=False)
+
+        if self._state.audio is not None:
+            play_sfx(self._state.audio, "sfx_ui_panelclick", rng=self._state.rng)
+
+    def close(self) -> None:
+        if self._small_font is not None:
+            rl.unload_texture(self._small_font.texture)
+            self._small_font = None
+        self._button_textures = None
+        self._assets = None
+        self._ground = None
+        self._action = None
+
+    def take_action(self) -> str | None:
+        action = self._action
+        self._action = None
+        return action
+
+    def _ensure_small_font(self) -> SmallFontData:
+        if self._small_font is not None:
+            return self._small_font
+        missing_assets: list[str] = []
+        self._small_font = load_small_font(self._state.assets_dir, missing_assets)
+        return self._small_font
+
+    def _panel_top_left(self, *, scale: float) -> tuple[float, float]:
+        x0 = CREDITS_PANEL_POS_X + MENU_PANEL_OFFSET_X * scale
+        y0 = CREDITS_PANEL_POS_Y + self._widescreen_y_shift + MENU_PANEL_OFFSET_Y * scale
+        return float(x0), float(y0)
+
+    def update(self, dt: float) -> None:
+        if self._state.audio is not None:
+            update_audio(self._state.audio, dt)
+        if self._ground is not None:
+            self._ground.process_pending()
+        self._cursor_pulse_time += min(float(dt), 0.1) * 1.1
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
+            if self._state.audio is not None:
+                play_sfx(self._state.audio, "sfx_ui_buttonclick", rng=self._state.rng)
+            self._action = "back_to_previous"
+            return
+
+        textures = self._button_textures
+        if textures is None or (textures.button_md is None and textures.button_sm is None):
+            return
+
+        scale = 0.9 if float(self._state.config.screen_width) < 641.0 else 1.0
+        panel_x0, panel_y0 = self._panel_top_left(scale=scale)
+
+        mouse = rl.get_mouse_position()
+        click = rl.is_mouse_button_pressed(rl.MOUSE_BUTTON_LEFT)
+        dt_ms = min(float(dt), 0.1) * 1000.0
+
+        w = button_width(None, self._back_button.label, scale=scale, force_wide=self._back_button.force_wide)
+        if button_update(
+            self._back_button,
+            x=panel_x0 + _BACK_BUTTON_X * scale,
+            y=panel_y0 + _BACK_BUTTON_Y * scale,
+            width=w,
+            dt_ms=dt_ms,
+            mouse=mouse,
+            click=click,
+        ):
+            if self._state.audio is not None:
+                play_sfx(self._state.audio, "sfx_ui_buttonclick", rng=self._state.rng)
+            self._action = "back_to_previous"
+
+    def draw(self) -> None:
+        rl.clear_background(rl.BLACK)
+        pause_background = self._state.pause_background
+        if pause_background is not None:
+            pause_background.draw_pause_background()
+        elif self._ground is not None:
+            self._ground.draw(0.0, 0.0)
+        _draw_screen_fade(self._state)
+
+        assets = self._assets
+        if assets is None or assets.panel is None:
+            return
+
+        scale = 0.9 if float(self._state.config.screen_width) < 641.0 else 1.0
+        panel_x0, panel_y0 = self._panel_top_left(scale=scale)
+        dst = rl.Rectangle(panel_x0, panel_y0, MENU_PANEL_WIDTH * scale, CREDITS_PANEL_HEIGHT * scale)
+        fx_detail = bool(self._state.config.data.get("fx_detail_0", 0))
+        draw_classic_menu_panel(assets.panel, dst=dst, tint=rl.WHITE, shadow=fx_detail)
+
+        font = self._ensure_small_font()
+        draw_small_text(
+            font,
+            "credits",
+            panel_x0 + _TITLE_X * scale,
+            panel_y0 + _TITLE_Y * scale,
+            1.0 * scale,
+            rl.Color(255, 255, 255, 255),
+        )
+
+        textures = self._button_textures
+        if textures is not None and (textures.button_md is not None or textures.button_sm is not None):
+            back_w = button_width(None, self._back_button.label, scale=scale, force_wide=self._back_button.force_wide)
+            button_draw(
+                textures,
+                font,
+                self._back_button,
+                x=panel_x0 + _BACK_BUTTON_X * scale,
+                y=panel_y0 + _BACK_BUTTON_Y * scale,
+                width=back_w,
+                scale=scale,
+            )
+
+        self._draw_sign()
+        _draw_menu_cursor(self._state, pulse_time=self._cursor_pulse_time)
+
+    def _draw_sign(self) -> None:
+        assets = self._assets
+        if assets is None or assets.sign is None:
+            return
+        sign = assets.sign
+        screen_w = float(self._state.config.screen_width)
+        sign_scale, shift_x = MenuView._sign_layout_scale(int(screen_w))
+        pos_x = screen_w + MENU_SIGN_POS_X_PAD
+        pos_y = MENU_SIGN_POS_Y if screen_w > MENU_SCALE_SMALL_THRESHOLD else MENU_SIGN_POS_Y_SMALL
+        sign_w = MENU_SIGN_WIDTH * sign_scale
+        sign_h = MENU_SIGN_HEIGHT * sign_scale
+        offset_x = MENU_SIGN_OFFSET_X * sign_scale + shift_x
+        offset_y = MENU_SIGN_OFFSET_Y * sign_scale
+        rotation_deg = 0.0
+        fx_detail = bool(self._state.config.data.get("fx_detail_0", 0))
+        if fx_detail:
+            MenuView._draw_ui_quad_shadow(
+                texture=sign,
+                src=rl.Rectangle(0.0, 0.0, float(sign.width), float(sign.height)),
+                dst=rl.Rectangle(pos_x + UI_SHADOW_OFFSET, pos_y + UI_SHADOW_OFFSET, sign_w, sign_h),
+                origin=rl.Vector2(-offset_x, -offset_y),
+                rotation_deg=rotation_deg,
+            )
+        MenuView._draw_ui_quad(
+            texture=sign,
+            src=rl.Rectangle(0.0, 0.0, float(sign.width), float(sign.height)),
+            dst=rl.Rectangle(pos_x, pos_y, sign_w, sign_h),
+            origin=rl.Vector2(-offset_x, -offset_y),
+            rotation_deg=rotation_deg,
+            tint=rl.WHITE,
+        )