Release 260111

system/ui/lib/application.py

@@ -0,0 +1,146 @@
+import atexit
+import os
+import time
+import pyray as rl
+from enum import IntEnum
+from openpilot.common.basedir import BASEDIR
+from openpilot.common.swaglog import cloudlog
+
+DEFAULT_FPS = 60
+FPS_LOG_INTERVAL = 5  # Seconds between logging FPS drops
+FPS_DROP_THRESHOLD = 0.9  # FPS drop threshold for triggering a warning
+FPS_CRITICAL_THRESHOLD = 0.5  # Critical threshold for triggering strict actions
+
+DEBUG_FPS = os.getenv("DEBUG_FPS") == '1'
+STRICT_MODE = os.getenv("STRICT_MODE") == '1'
+
+DEFAULT_TEXT_SIZE = 60
+DEFAULT_TEXT_COLOR = rl.Color(200, 200, 200, 255)
+FONT_DIR = os.path.join(BASEDIR, "selfdrive/assets/fonts")
+
+
+class FontWeight(IntEnum):
+  BLACK = 0
+  BOLD = 1
+  EXTRA_BOLD = 2
+  EXTRA_LIGHT = 3
+  MEDIUM = 4
+  NORMAL = 5
+  SEMI_BOLD = 6
+  THIN = 7
+
+
+class GuiApplication:
+  def __init__(self, width: int, height: int):
+    self._fonts: dict[FontWeight, rl.Font] = {}
+    self._width = width
+    self._height = height
+    self._textures: list[rl.Texture] = []
+    self._target_fps: int = DEFAULT_FPS
+    self._last_fps_log_time: float = time.monotonic()
+
+  def init_window(self, title: str, fps: int=DEFAULT_FPS):
+    atexit.register(self.close)  # Automatically call close() on exit
+
+    rl.set_config_flags(rl.ConfigFlags.FLAG_MSAA_4X_HINT | rl.ConfigFlags.FLAG_VSYNC_HINT)
+    rl.init_window(self._width, self._height, title)
+    rl.set_target_fps(fps)
+
+    self._target_fps = fps
+    self._set_styles()
+    self._load_fonts()
+
+  def load_texture_from_image(self, file_name: str, width: int, height: int):
+    """Load and resize a texture, storing it for later automatic unloading."""
+    image = rl.load_image(file_name)
+    rl.image_resize(image, width, height)
+    texture = rl.load_texture_from_image(image)
+    # Set texture filtering to smooth the result
+    rl.set_texture_filter(texture, rl.TextureFilter.TEXTURE_FILTER_BILINEAR)
+
+    rl.unload_image(image)
+
+    self._textures.append(texture)
+    return texture
+
+  def close(self):
+    if not rl.is_window_ready():
+      return
+
+    for texture in self._textures:
+      rl.unload_texture(texture)
+    self._textures = []
+
+    for font in self._fonts.values():
+      rl.unload_font(font)
+    self._fonts = {}
+
+    rl.close_window()
+
+  def render(self):
+    while not rl.window_should_close():
+      rl.begin_drawing()
+      rl.clear_background(rl.BLACK)
+
+      yield
+
+      if DEBUG_FPS:
+        rl.draw_fps(10, 10)
+
+      rl.end_drawing()
+      self._monitor_fps()
+
+  def font(self, font_weight: FontWeight=FontWeight.NORMAL):
+    return self._fonts[font_weight]
+
+  @property
+  def width(self):
+    return self._width
+
+  @property
+  def height(self):
+    return self._height
+
+  def _load_fonts(self):
+    font_files = (
+      "Inter-Black.ttf",
+      "Inter-Bold.ttf",
+      "Inter-ExtraBold.ttf",
+      "Inter-ExtraLight.ttf",
+      "Inter-Medium.ttf",
+      "Inter-Regular.ttf",
+      "Inter-SemiBold.ttf",
+      "Inter-Thin.ttf"
+      )
+
+    for index, font_file in enumerate(font_files):
+      font = rl.load_font_ex(os.path.join(FONT_DIR, font_file), 120, None, 0)
+      rl.set_texture_filter(font.texture, rl.TextureFilter.TEXTURE_FILTER_BILINEAR)
+      self._fonts[index] = font
+
+    rl.gui_set_font(self._fonts[FontWeight.NORMAL])
+
+  def _set_styles(self):
+    rl.gui_set_style(rl.GuiControl.DEFAULT, rl.GuiControlProperty.BORDER_WIDTH, 0)
+    rl.gui_set_style(rl.GuiControl.DEFAULT, rl.GuiDefaultProperty.TEXT_SIZE, DEFAULT_TEXT_SIZE)
+    rl.gui_set_style(rl.GuiControl.DEFAULT, rl.GuiDefaultProperty.BACKGROUND_COLOR, rl.color_to_int(rl.BLACK))
+    rl.gui_set_style(rl.GuiControl.DEFAULT, rl.GuiControlProperty.TEXT_COLOR_NORMAL, rl.color_to_int(DEFAULT_TEXT_COLOR))
+    rl.gui_set_style(rl.GuiControl.DEFAULT, rl.GuiControlProperty.BASE_COLOR_NORMAL, rl.color_to_int(rl.Color(50, 50, 50, 255)))
+
+  def _monitor_fps(self):
+    fps = rl.get_fps()
+
+    # Log FPS drop below threshold at regular intervals
+    if fps < self._target_fps * FPS_DROP_THRESHOLD:
+      current_time = time.monotonic()
+      if current_time - self._last_fps_log_time >= FPS_LOG_INTERVAL:
+        cloudlog.warning(f"FPS dropped below {self._target_fps}: {fps}")
+        self._last_fps_log_time = current_time
+
+    # Strict mode: terminate UI if FPS drops too much
+    if STRICT_MODE and fps < self._target_fps * FPS_CRITICAL_THRESHOLD:
+      cloudlog.error(f"FPS dropped critically below {fps}. Shutting down UI.")
+      os._exit(1)
+
+
+gui_app = GuiApplication(2160, 1080)

system/ui/lib/button.py

@@ -0,0 +1,71 @@
+import pyray as rl
+from enum import IntEnum
+from openpilot.system.ui.lib.application import gui_app, FontWeight
+
+
+class ButtonStyle(IntEnum):
+  NORMAL = 0  # Most common, neutral buttons
+  PRIMARY = 1  # For main actions
+  DANGER = 2  # For critical actions, like reboot or delete
+  TRANSPARENT = 3  # For buttons with transparent background and border
+
+
+DEFAULT_BUTTON_FONT_SIZE = 60
+BUTTON_ENABLED_TEXT_COLOR = rl.Color(228, 228, 228, 255)
+BUTTON_DISABLED_TEXT_COLOR = rl.Color(228, 228, 228, 51)
+
+
+BUTTON_BACKGROUND_COLORS = {
+  ButtonStyle.NORMAL: rl.Color(51, 51, 51, 255),
+  ButtonStyle.PRIMARY: rl.Color(70, 91, 234, 255),
+  ButtonStyle.DANGER: rl.Color(255, 36, 36, 255),
+  ButtonStyle.TRANSPARENT: rl.BLACK,
+}
+
+BUTTON_PRESSED_BACKGROUND_COLORS = {
+  ButtonStyle.NORMAL: rl.Color(74, 74, 74, 255),
+  ButtonStyle.PRIMARY: rl.Color(48, 73, 244, 255),
+  ButtonStyle.DANGER: rl.Color(255, 36, 36, 255),
+  ButtonStyle.TRANSPARENT: rl.BLACK,
+}
+
+
+def gui_button(
+  rect: rl.Rectangle,
+  text: str,
+  font_size: int = DEFAULT_BUTTON_FONT_SIZE,
+  font_weight: FontWeight = FontWeight.MEDIUM,
+  button_style: ButtonStyle = ButtonStyle.NORMAL,
+  is_enabled: bool = True,
+  border_radius: int = 10,  # Corner rounding in pixels
+) -> int:
+  result = 0
+
+  # Set background color based on button type
+  bg_color = BUTTON_BACKGROUND_COLORS[button_style]
+  if is_enabled and rl.check_collision_point_rec(rl.get_mouse_position(), rect):
+    if rl.is_mouse_button_down(rl.MouseButton.MOUSE_BUTTON_LEFT):
+      bg_color = BUTTON_PRESSED_BACKGROUND_COLORS[button_style]
+    elif rl.is_mouse_button_released(rl.MouseButton.MOUSE_BUTTON_LEFT):
+      result = 1
+
+  # Draw the button with rounded corners
+  roundness = border_radius / (min(rect.width, rect.height) / 2)
+  if button_style != ButtonStyle.TRANSPARENT:
+    rl.draw_rectangle_rounded(rect, roundness, 20, bg_color)
+  else:
+    rl.draw_rectangle_rounded(rect, roundness, 20, rl.BLACK)
+    rl.draw_rectangle_rounded_lines_ex(rect, roundness, 20, 2, rl.WHITE)
+
+  font = gui_app.font(font_weight)
+  # Center text in the button
+  text_size = rl.measure_text_ex(font, text, font_size, 0)
+  text_pos = rl.Vector2(
+    rect.x + (rect.width - text_size.x) // 2, rect.y + (rect.height - text_size.y) // 2
+  )
+
+  # Draw the button text
+  text_color = BUTTON_ENABLED_TEXT_COLOR if is_enabled else BUTTON_DISABLED_TEXT_COLOR
+  rl.draw_text_ex(font, text, text_pos, font_size, 0, text_color)
+
+  return result

system/ui/lib/label.py

@@ -0,0 +1,57 @@
+import pyray as rl
+from openpilot.system.ui.lib.application import gui_app, FontWeight, DEFAULT_TEXT_SIZE, DEFAULT_TEXT_COLOR
+from openpilot.system.ui.lib.utils import GuiStyleContext
+
+
+def gui_label(
+  rect: rl.Rectangle,
+  text: str,
+  font_size: int = DEFAULT_TEXT_SIZE,
+  color: rl.Color = DEFAULT_TEXT_COLOR,
+  font_weight: FontWeight = FontWeight.NORMAL,
+  alignment: int = rl.GuiTextAlignment.TEXT_ALIGN_LEFT,
+  alignment_vertical: int = rl.GuiTextAlignmentVertical.TEXT_ALIGN_MIDDLE
+):
+  # Set font based on the provided weight
+  font = gui_app.font(font_weight)
+
+  # Measure text size
+  text_size = rl.measure_text_ex(font, text, font_size, 0)
+
+  # Calculate horizontal position based on alignment
+  text_x = rect.x + {
+    rl.GuiTextAlignment.TEXT_ALIGN_LEFT: 0,
+    rl.GuiTextAlignment.TEXT_ALIGN_CENTER: (rect.width - text_size.x) / 2,
+    rl.GuiTextAlignment.TEXT_ALIGN_RIGHT: rect.width - text_size.x,
+  }.get(alignment, 0)
+
+  # Calculate vertical position based on alignment
+  text_y = rect.y + {
+    rl.GuiTextAlignmentVertical.TEXT_ALIGN_TOP: 0,
+    rl.GuiTextAlignmentVertical.TEXT_ALIGN_MIDDLE: (rect.height - text_size.y) / 2,
+    rl.GuiTextAlignmentVertical.TEXT_ALIGN_BOTTOM: rect.height - text_size.y,
+  }.get(alignment_vertical, 0)
+
+  # Draw the text in the specified rectangle
+  rl.draw_text_ex(font, text, rl.Vector2(text_x, text_y), font_size, 0, color)
+
+
+def gui_text_box(
+  rect: rl.Rectangle,
+  text: str,
+  font_size: int = DEFAULT_TEXT_SIZE,
+  color: rl.Color = DEFAULT_TEXT_COLOR,
+  alignment: int = rl.GuiTextAlignment.TEXT_ALIGN_LEFT,
+  alignment_vertical: int = rl.GuiTextAlignmentVertical.TEXT_ALIGN_TOP
+):
+  styles = [
+    (rl.GuiControl.DEFAULT, rl.GuiControlProperty.TEXT_COLOR_NORMAL, rl.color_to_int(color)),
+    (rl.GuiControl.DEFAULT, rl.GuiDefaultProperty.TEXT_SIZE, font_size),
+    (rl.GuiControl.DEFAULT, rl.GuiDefaultProperty.TEXT_LINE_SPACING, font_size),
+    (rl.GuiControl.DEFAULT, rl.GuiControlProperty.TEXT_ALIGNMENT, alignment),
+    (rl.GuiControl.DEFAULT, rl.GuiDefaultProperty.TEXT_ALIGNMENT_VERTICAL, alignment_vertical),
+    (rl.GuiControl.DEFAULT, rl.GuiDefaultProperty.TEXT_WRAP_MODE, rl.GuiTextWrapMode.TEXT_WRAP_WORD)
+  ]
+
+  with GuiStyleContext(styles):
+    rl.gui_label(rect, text)

system/ui/lib/scroll_panel.py

@@ -0,0 +1,75 @@
+import pyray as rl
+from enum import IntEnum
+
+MOUSE_WHEEL_SCROLL_SPEED = 30
+INERTIA_FRICTION = 0.95  # The rate at which the inertia slows down
+MIN_VELOCITY = 0.1  # Minimum velocity before stopping the inertia
+
+
+class ScrollState(IntEnum):
+  IDLE = 0
+  DRAGGING_CONTENT = 1
+  DRAGGING_SCROLLBAR = 2
+
+
+class GuiScrollPanel:
+  def __init__(self, show_vertical_scroll_bar: bool = False):
+    self._scroll_state: ScrollState = ScrollState.IDLE
+    self._last_mouse_y: float = 0.0
+    self._offset = rl.Vector2(0, 0)
+    self._view = rl.Rectangle(0, 0, 0, 0)
+    self._show_vertical_scroll_bar: bool = show_vertical_scroll_bar
+    self._velocity_y = 0.0  # Velocity for inertia
+
+  def handle_scroll(self, bounds: rl.Rectangle, content: rl.Rectangle) -> rl.Vector2:
+    mouse_pos = rl.get_mouse_position()
+
+    # Handle dragging logic
+    if rl.check_collision_point_rec(mouse_pos, bounds) and rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT):
+      if self._scroll_state == ScrollState.IDLE:
+        self._scroll_state = ScrollState.DRAGGING_CONTENT
+        if self._show_vertical_scroll_bar:
+          scrollbar_width = rl.gui_get_style(rl.GuiControl.LISTVIEW, rl.GuiListViewProperty.SCROLLBAR_WIDTH)
+          scrollbar_x = bounds.x + bounds.width - scrollbar_width
+          if mouse_pos.x >= scrollbar_x:
+            self._scroll_state = ScrollState.DRAGGING_SCROLLBAR
+
+        self._last_mouse_y = mouse_pos.y
+        self._velocity_y = 0.0  # Reset velocity when drag starts
+
+    if self._scroll_state != ScrollState.IDLE:
+      if rl.is_mouse_button_down(rl.MouseButton.MOUSE_BUTTON_LEFT):
+        delta_y = mouse_pos.y - self._last_mouse_y
+
+        if self._scroll_state == ScrollState.DRAGGING_CONTENT:
+          self._offset.y += delta_y
+        else:
+          delta_y = -delta_y
+
+        self._last_mouse_y = mouse_pos.y
+        self._velocity_y = delta_y  # Update velocity during drag
+      else:
+        self._scroll_state = ScrollState.IDLE
+
+    # Handle mouse wheel scrolling
+    wheel_move = rl.get_mouse_wheel_move()
+    if self._show_vertical_scroll_bar:
+      self._offset.y += wheel_move * (MOUSE_WHEEL_SCROLL_SPEED - 20)
+      rl.gui_scroll_panel(bounds, rl.ffi.NULL, content, self._offset, self._view)
+    else:
+      self._offset.y += wheel_move * MOUSE_WHEEL_SCROLL_SPEED
+
+    # Apply inertia (continue scrolling after mouse release)
+    if self._scroll_state == ScrollState.IDLE:
+      self._offset.y += self._velocity_y
+      self._velocity_y *= INERTIA_FRICTION  # Slow down velocity over time
+
+      # Stop scrolling when velocity is low
+      if abs(self._velocity_y) < MIN_VELOCITY:
+        self._velocity_y = 0.0
+
+    # Ensure scrolling doesn't go beyond bounds
+    max_scroll_y = max(content.height - bounds.height, 0)
+    self._offset.y = max(min(self._offset.y, 0), -max_scroll_y)
+
+    return self._offset

system/ui/lib/utils.py

@@ -0,0 +1,18 @@
+import pyray as rl
+
+
+class GuiStyleContext:
+  def __init__(self, styles: list[tuple[int, int, int]]):
+    """styles is a list of tuples (control, prop, new_value)"""
+    self.styles = styles
+    self.prev_styles: list[tuple[int, int, int]] = []
+
+  def __enter__(self):
+    for control, prop, new_value in self.styles:
+      prev_value = rl.gui_get_style(control, prop)
+      self.prev_styles.append((control, prop, prev_value))
+      rl.gui_set_style(control, prop, new_value)
+
+  def __exit__(self, exc_type, exc_value, traceback):
+    for control, prop, prev_value in self.prev_styles:
+      rl.gui_set_style(control, prop, prev_value)