sonolus.py 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

sonolus/script/particle.py

@@ -102,54 +102,54 @@ def particles[T](cls: type[T]) -> T | Particles:
 
 
 class StandardParticle:
-    NoteCircularTapNeutral = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_NEUTRAL")]
-    NoteCircularTapRed = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_RED")]
-    NoteCircularTapGreen = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_GREEN")]
-    NoteCircularTapBlue = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_BLUE")]
-    NoteCircularTapYellow = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_YELLOW")]
-    NoteCircularTapPurple = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_PURPLE")]
-    NoteCircularTapCyan = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_CYAN")]
-    NoteCircularAlternativeNeutral = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_NEUTRAL")]
-    NoteCircularAlternativeRed = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_RED")]
-    NoteCircularAlternativeGreen = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_GREEN")]
-    NoteCircularAlternativeBlue = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_BLUE")]
-    NoteCircularAlternativeYellow = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_YELLOW")]
-    NoteCircularAlternativePurple = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_PURPLE")]
-    NoteCircularAlternativeCyan = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_CYAN")]
-    NoteCircularHoldNeutral = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_NEUTRAL")]
-    NoteCircularHoldRed = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_RED")]
-    NoteCircularHoldGreen = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_GREEN")]
-    NoteCircularHoldBlue = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_BLUE")]
-    NoteCircularHoldYellow = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_YELLOW")]
-    NoteCircularHoldPurple = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_PURPLE")]
-    NoteCircularHoldCyan = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_CYAN")]
-    NoteLinearTapNeutral = Annotated[Particle, particle("#NOTE_LINEAR_TAP_NEUTRAL")]
-    NoteLinearTapRed = Annotated[Particle, particle("#NOTE_LINEAR_TAP_RED")]
-    NoteLinearTapGreen = Annotated[Particle, particle("#NOTE_LINEAR_TAP_GREEN")]
-    NoteLinearTapBlue = Annotated[Particle, particle("#NOTE_LINEAR_TAP_BLUE")]
-    NoteLinearTapYellow = Annotated[Particle, particle("#NOTE_LINEAR_TAP_YELLOW")]
-    NoteLinearTapPurple = Annotated[Particle, particle("#NOTE_LINEAR_TAP_PURPLE")]
-    NoteLinearTapCyan = Annotated[Particle, particle("#NOTE_LINEAR_TAP_CYAN")]
-    NoteLinearAlternativeNeutral = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_NEUTRAL")]
-    NoteLinearAlternativeRed = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_RED")]
-    NoteLinearAlternativeGreen = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_GREEN")]
-    NoteLinearAlternativeBlue = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_BLUE")]
-    NoteLinearAlternativeYellow = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_YELLOW")]
-    NoteLinearAlternativePurple = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_PURPLE")]
-    NoteLinearAlternativeCyan = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_CYAN")]
-    NoteLinearHoldNeutral = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_NEUTRAL")]
-    NoteLinearHoldRed = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_RED")]
-    NoteLinearHoldGreen = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_GREEN")]
-    NoteLinearHoldBlue = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_BLUE")]
-    NoteLinearHoldYellow = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_YELLOW")]
-    NoteLinearHoldPurple = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_PURPLE")]
-    NoteLinearHoldCyan = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_CYAN")]
-    LaneCircular = Annotated[Particle, particle("#LANE_CIRCULAR")]
-    LaneLinear = Annotated[Particle, particle("#LANE_LINEAR")]
-    SlotCircular = Annotated[Particle, particle("#SLOT_CIRCULAR")]
-    SlotLinear = Annotated[Particle, particle("#SLOT_LINEAR")]
-    JudgeLineCircular = Annotated[Particle, particle("#JUDGE_LINE_CIRCULAR")]
-    JudgeLineLinear = Annotated[Particle, particle("#JUDGE_LINE_LINEAR")]
+    NOTE_CIRCULAR_TAP_NEUTRAL = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_NEUTRAL")]
+    NOTE_CIRCULAR_TAP_RED = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_RED")]
+    NOTE_CIRCULAR_TAP_GREEN = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_GREEN")]
+    NOTE_CIRCULAR_TAP_BLUE = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_BLUE")]
+    NOTE_CIRCULAR_TAP_YELLOW = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_YELLOW")]
+    NOTE_CIRCULAR_TAP_PURPLE = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_PURPLE")]
+    NOTE_CIRCULAR_TAP_CYAN = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_CYAN")]
+    NOTE_CIRCULAR_ALTERNATIVE_NEUTRAL = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_NEUTRAL")]
+    NOTE_CIRCULAR_ALTERNATIVE_RED = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_RED")]
+    NOTE_CIRCULAR_ALTERNATIVE_GREEN = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_GREEN")]
+    NOTE_CIRCULAR_ALTERNATIVE_BLUE = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_BLUE")]
+    NOTE_CIRCULAR_ALTERNATIVE_YELLOW = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_YELLOW")]
+    NOTE_CIRCULAR_ALTERNATIVE_PURPLE = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_PURPLE")]
+    NOTE_CIRCULAR_ALTERNATIVE_CYAN = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_CYAN")]
+    NOTE_CIRCULAR_HOLD_NEUTRAL = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_NEUTRAL")]
+    NOTE_CIRCULAR_HOLD_RED = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_RED")]
+    NOTE_CIRCULAR_HOLD_GREEN = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_GREEN")]
+    NOTE_CIRCULAR_HOLD_BLUE = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_BLUE")]
+    NOTE_CIRCULAR_HOLD_YELLOW = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_YELLOW")]
+    NOTE_CIRCULAR_HOLD_PURPLE = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_PURPLE")]
+    NOTE_CIRCULAR_HOLD_CYAN = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_CYAN")]
+    NOTE_LINEAR_TAP_NEUTRAL = Annotated[Particle, particle("#NOTE_LINEAR_TAP_NEUTRAL")]
+    NOTE_LINEAR_TAP_RED = Annotated[Particle, particle("#NOTE_LINEAR_TAP_RED")]
+    NOTE_LINEAR_TAP_GREEN = Annotated[Particle, particle("#NOTE_LINEAR_TAP_GREEN")]
+    NOTE_LINEAR_TAP_BLUE = Annotated[Particle, particle("#NOTE_LINEAR_TAP_BLUE")]
+    NOTE_LINEAR_TAP_YELLOW = Annotated[Particle, particle("#NOTE_LINEAR_TAP_YELLOW")]
+    NOTE_LINEAR_TAP_PURPLE = Annotated[Particle, particle("#NOTE_LINEAR_TAP_PURPLE")]
+    NOTE_LINEAR_TAP_CYAN = Annotated[Particle, particle("#NOTE_LINEAR_TAP_CYAN")]
+    NOTE_LINEAR_ALTERNATIVE_NEUTRAL = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_NEUTRAL")]
+    NOTE_LINEAR_ALTERNATIVE_RED = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_RED")]
+    NOTE_LINEAR_ALTERNATIVE_GREEN = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_GREEN")]
+    NOTE_LINEAR_ALTERNATIVE_BLUE = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_BLUE")]
+    NOTE_LINEAR_ALTERNATIVE_YELLOW = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_YELLOW")]
+    NOTE_LINEAR_ALTERNATIVE_PURPLE = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_PURPLE")]
+    NOTE_LINEAR_ALTERNATIVE_CYAN = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_CYAN")]
+    NOTE_LINEAR_HOLD_NEUTRAL = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_NEUTRAL")]
+    NOTE_LINEAR_HOLD_RED = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_RED")]
+    NOTE_LINEAR_HOLD_GREEN = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_GREEN")]
+    NOTE_LINEAR_HOLD_BLUE = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_BLUE")]
+    NOTE_LINEAR_HOLD_YELLOW = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_YELLOW")]
+    NOTE_LINEAR_HOLD_PURPLE = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_PURPLE")]
+    NOTE_LINEAR_HOLD_CYAN = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_CYAN")]
+    LANE_CIRCULAR = Annotated[Particle, particle("#LANE_CIRCULAR")]
+    LANE_LINEAR = Annotated[Particle, particle("#LANE_LINEAR")]
+    SLOT_CIRCULAR = Annotated[Particle, particle("#SLOT_CIRCULAR")]
+    SLOT_LINEAR = Annotated[Particle, particle("#SLOT_LINEAR")]
+    JUDGE_LINE_CIRCULAR = Annotated[Particle, particle("#JUDGE_LINE_CIRCULAR")]
+    JUDGE_LINE_LINEAR = Annotated[Particle, particle("#JUDGE_LINE_LINEAR")]
 
 
 @particles

sonolus/script/pointer.py

@@ -1,7 +1,7 @@
 from sonolus.backend.place import BlockPlace
 from sonolus.script.internal.impl import meta_fn, validate_value
 from sonolus.script.internal.value import Value
-from sonolus.script.num import Num
+from sonolus.script.num import Num, is_num
 
 
 @meta_fn
@@ -14,7 +14,7 @@ def deref[T: Value](block: Num, offset: Num, type_: type[T]) -> T:
         if not isinstance(block, int):
             raise TypeError("block must be an integer")
     else:
-        if not isinstance(block, Num):
+        if not is_num(block):
             raise TypeError("block must be a Num")
         block = block.index()
     if offset._is_py_():
@@ -22,7 +22,7 @@ def deref[T: Value](block: Num, offset: Num, type_: type[T]) -> T:
         if not isinstance(offset, int):
             raise TypeError("offset must be an integer")
     else:
-        if not isinstance(offset, Num):
+        if not is_num(offset):
             raise TypeError("offset must be a Num")
         offset = offset.index()
     if not (isinstance(type_, type) and issubclass(type_, Value)):

sonolus/script/print.py

@@ -0,0 +1,81 @@
+from enum import IntEnum
+
+from sonolus.backend.ops import Op
+from sonolus.script.internal.native import native_function
+from sonolus.script.runtime import HorizontalAlign
+from sonolus.script.vec import Vec2
+
+
+class PrintFormat(IntEnum):
+    NUMBER = 0
+    PERCENTAGE = 1
+    TIME = 10
+    SCORE = 11
+    BPM = 20
+    TIMESCALE = 21
+    BEAT_COUNT = 30
+    MEASURE_COUNT = 31
+    ENTITY_COUNT = 32
+
+
+class PrintColor(IntEnum):
+    THEME = -1
+    NEUTRAL = 0
+    RED = 1
+    GREEN = 2
+    BLUE = 3
+    YELLOW = 4
+    PURPLE = 5
+    CYAN = 6
+
+
+@native_function(Op.Print)
+def _print(
+    value: int | float,
+    format: PrintFormat,  # noqa: A002
+    decimal_places: int,
+    anchor_x: float,
+    anchor_y: float,
+    pivot_x: float,
+    pivot_y: float,
+    width: float,
+    height: float,
+    rotation: float,
+    color: PrintColor,
+    alpha: float,
+    horizontal_align: HorizontalAlign,
+    background: bool,
+):
+    raise NotImplementedError
+
+
+def print_number(
+    value: int | float,
+    *,
+    fmt: PrintFormat,
+    decimal_places: int = 0,
+    anchor: Vec2,
+    pivot: Vec2,
+    dimensions: Vec2,
+    rotation: float = 0,
+    color: PrintColor = PrintColor.THEME,
+    alpha: float = 1,
+    horizontal_align: HorizontalAlign = HorizontalAlign.LEFT,
+    background: bool = False,
+):
+    _print(
+        value,
+        fmt,
+        decimal_places,
+        anchor.x,
+        anchor.y,
+        pivot.x,
+        pivot.y,
+        dimensions.x,
+        dimensions.y,
+        rotation,
+        color,
+        alpha,
+        horizontal_align,
+        background,
+    )

sonolus/script/runtime.py

@@ -7,17 +7,25 @@ from sonolus.script.globals import (
     _level_life,
     _level_score,
     _play_runtime_environment,
+    _play_runtime_ui,
+    _play_runtime_ui_configuration,
     _play_runtime_update,
+    _preview_runtime_canvas,
     _preview_runtime_environment,
+    _preview_runtime_ui,
+    _preview_runtime_ui_configuration,
     _runtime_background,
     _runtime_particle_transform,
     _runtime_skin_transform,
     _runtime_touch_array,
-    _runtime_ui,
-    _runtime_ui_configuration,
+    _tutorial_instruction,
     _tutorial_runtime_environment,
+    _tutorial_runtime_ui,
+    _tutorial_runtime_ui_configuration,
     _tutorial_runtime_update,
     _watch_runtime_environment,
+    _watch_runtime_ui,
+    _watch_runtime_ui_configuration,
     _watch_runtime_update,
 )
 from sonolus.script.graphics import Quad, Rect
@@ -83,21 +91,56 @@ class _TutorialRuntimeUpdate:
     navigation_direction: int
 
 
+class ScrollDirection(IntEnum):
+    LEFT_TO_RIGHT = 0
+    TOP_TO_BOTTOM = 1
+    RIGHT_TO_LEFT = 2
+    BOTTOM_TO_TOP = 3
+
+
+@_preview_runtime_canvas
+class _PreviewRuntimeCanvas:
+    scroll_direction: ScrollDirection
+    size: float
+
+
 class RuntimeUiConfig(Record):
     scale: float
     alpha: float
 
 
-@_runtime_ui_configuration
-class _RuntimeUiConfigs:
+@_play_runtime_ui_configuration
+class _PlayRuntimeUiConfigs:
     menu: RuntimeUiConfig
     judgment: RuntimeUiConfig
     combo: RuntimeUiConfig
     primary_metric: RuntimeUiConfig
     secondary_metric: RuntimeUiConfig
+
+
+@_watch_runtime_ui_configuration
+class _WatchRuntimeUiConfigs:
+    menu: RuntimeUiConfig
+    judgment: RuntimeUiConfig
+    combo: RuntimeUiConfig
+    primary_metric: RuntimeUiConfig
+    secondary_metric: RuntimeUiConfig
+    progress: RuntimeUiConfig
+
+
+@_preview_runtime_ui_configuration
+class _PreviewRuntimeUiConfigs:
+    menu: RuntimeUiConfig
     progress: RuntimeUiConfig
 
 
+@_tutorial_runtime_ui_configuration
+class _TutorialRuntimeUiConfigs:
+    menu: RuntimeUiConfig
+    navigation: RuntimeUiConfig
+    instruction: RuntimeUiConfig
+
+
 class HorizontalAlign(IntEnum):
     LEFT = -1
     CENTER = 0
@@ -139,8 +182,51 @@ class RuntimeUiLayout(Record):
             self.background = background
 
 
-@_runtime_ui
-class _RuntimeUi:
+class BasicRuntimeUiLayout(Record):
+    anchor: Vec2
+    pivot: Vec2
+    dimensions: Vec2
+    rotation: float
+    alpha: float
+    background: bool
+
+    def update(
+        self,
+        anchor: Vec2 | None = None,
+        pivot: Vec2 | None = None,
+        dimensions: Vec2 | None = None,
+        rotation: float | None = None,
+        alpha: float | None = None,
+        background: bool | None = None,
+    ):
+        if anchor is not None:
+            self.anchor = anchor
+        if pivot is not None:
+            self.pivot = pivot
+        if dimensions is not None:
+            self.dimensions = dimensions
+        if rotation is not None:
+            self.rotation = rotation
+        if alpha is not None:
+            self.alpha = alpha
+        if background is not None:
+            self.background = background
+
+
+@_play_runtime_ui
+class _PlayRuntimeUi:
+    menu: RuntimeUiLayout
+    judgment: RuntimeUiLayout
+    combo_value: RuntimeUiLayout
+    combo_text: RuntimeUiLayout
+    primary_metric_bar: RuntimeUiLayout
+    primary_metric_value: RuntimeUiLayout
+    secondary_metric_bar: RuntimeUiLayout
+    secondary_metric_value: RuntimeUiLayout
+
+
+@_watch_runtime_ui
+class _WatchRuntimeUi:
     menu: RuntimeUiLayout
     judgment: RuntimeUiLayout
     combo_value: RuntimeUiLayout
@@ -152,6 +238,20 @@ class _RuntimeUi:
     progress: RuntimeUiLayout
 
 
+@_preview_runtime_ui
+class _PreviewRuntimeUi:
+    menu: BasicRuntimeUiLayout
+    progress: BasicRuntimeUiLayout
+
+
+@_tutorial_runtime_ui
+class _TutorialRuntimeUi:
+    menu: BasicRuntimeUiLayout
+    previous: BasicRuntimeUiLayout
+    next: BasicRuntimeUiLayout
+    instruction: BasicRuntimeUiLayout
+
+
 class Touch(Record):
     id: int
     started: bool
@@ -324,18 +424,23 @@ class _LevelLife:
             self.consecutive_good_step = consecutive_good_step
 
 
+@_tutorial_instruction
+class _TutorialInstruction:
+    text_id: int
+
+
 @meta_fn
 def is_debug() -> bool:
     if not ctx():
         return False
     match ctx().global_state.mode:
-        case Mode.Play:
+        case Mode.PLAY:
             return _PlayRuntimeEnvironment.is_debug
-        case Mode.Watch:
+        case Mode.WATCH:
             return _WatchRuntimeEnvironment.is_debug
-        case Mode.Preview:
+        case Mode.PREVIEW:
             return _PreviewRuntimeEnvironment.is_debug
-        case Mode.Tutorial:
+        case Mode.TUTORIAL:
             return _TutorialRuntimeEnvironment.is_debug
         case _:
             return False
@@ -346,13 +451,13 @@ def aspect_ratio() -> float:
     if not ctx():
         return 16 / 9
     match ctx().global_state.mode:
-        case Mode.Play:
+        case Mode.PLAY:
             return _PlayRuntimeEnvironment.aspect_ratio
-        case Mode.Watch:
+        case Mode.WATCH:
             return _WatchRuntimeEnvironment.aspect_ratio
-        case Mode.Preview:
+        case Mode.PREVIEW:
             return _PreviewRuntimeEnvironment.aspect_ratio
-        case Mode.Tutorial:
+        case Mode.TUTORIAL:
             return _TutorialRuntimeEnvironment.aspect_ratio
 
 
@@ -361,11 +466,11 @@ def audio_offset() -> float:
     if not ctx():
         return 0
     match ctx().global_state.mode:
-        case Mode.Play:
+        case Mode.PLAY:
             return _PlayRuntimeEnvironment.audio_offset
-        case Mode.Watch:
+        case Mode.WATCH:
             return _WatchRuntimeEnvironment.audio_offset
-        case Mode.Tutorial:
+        case Mode.TUTORIAL:
             return _TutorialRuntimeEnvironment.audio_offset
         case _:
             return 0
@@ -376,9 +481,9 @@ def input_offset() -> float:
     if not ctx():
         return 0
     match ctx().global_state.mode:
-        case Mode.Play:
+        case Mode.PLAY:
             return _PlayRuntimeEnvironment.input_offset
-        case Mode.Watch:
+        case Mode.WATCH:
             return _WatchRuntimeEnvironment.input_offset
         case _:
             return 0
@@ -389,7 +494,7 @@ def is_multiplayer() -> bool:
     if not ctx():
         return False
     match ctx().global_state.mode:
-        case Mode.Play:
+        case Mode.PLAY:
             return _PlayRuntimeEnvironment.is_multiplayer
         case _:
             return False
@@ -400,7 +505,7 @@ def is_replay() -> bool:
     if not ctx():
         return False
     match ctx().global_state.mode:
-        case Mode.Watch:
+        case Mode.WATCH:
             return _WatchRuntimeEnvironment.is_replay
         case _:
             return False
@@ -411,11 +516,11 @@ def time() -> float:
     if not ctx():
         return 0
     match ctx().global_state.mode:
-        case Mode.Play:
+        case Mode.PLAY:
             return _PlayRuntimeUpdate.time
-        case Mode.Watch:
+        case Mode.WATCH:
             return _WatchRuntimeUpdate.time
-        case Mode.Tutorial:
+        case Mode.TUTORIAL:
             return _TutorialRuntimeUpdate.time
         case _:
             return 0
@@ -426,11 +531,11 @@ def delta_time() -> float:
     if not ctx():
         return 0
     match ctx().global_state.mode:
-        case Mode.Play:
+        case Mode.PLAY:
             return _PlayRuntimeUpdate.delta_time
-        case Mode.Watch:
+        case Mode.WATCH:
             return _WatchRuntimeUpdate.delta_time
-        case Mode.Tutorial:
+        case Mode.TUTORIAL:
             return _TutorialRuntimeUpdate.delta_time
         case _:
             return 0
@@ -441,11 +546,11 @@ def scaled_time() -> float:
     if not ctx():
         return 0
     match ctx().global_state.mode:
-        case Mode.Play:
+        case Mode.PLAY:
             return _PlayRuntimeUpdate.scaled_time
-        case Mode.Watch:
+        case Mode.WATCH:
             return _WatchRuntimeUpdate.scaled_time
-        case Mode.Tutorial:
+        case Mode.TUTORIAL:
             return _TutorialRuntimeUpdate.time
         case _:
             return 0
@@ -456,7 +561,7 @@ def touches() -> VarArray[Touch, 999]:
     if not ctx():
         return VarArray(0, Array[Touch, 0]())
     match ctx().global_state.mode:
-        case Mode.Play:
+        case Mode.PLAY:
             return VarArray(_PlayRuntimeUpdate.touch_count, _TouchArray.touches)
         case _:
             return VarArray(0, Array[Touch, 0]())
@@ -467,7 +572,7 @@ def is_skip() -> bool:
     if not ctx():
         return False
     match ctx().global_state.mode:
-        case Mode.Watch:
+        case Mode.WATCH:
             return _WatchRuntimeUpdate.is_skip
         case _:
             return False
@@ -478,7 +583,7 @@ def navigation_direction() -> int:
     if not ctx():
         return 0
     match ctx().global_state.mode:
-        case Mode.Tutorial:
+        case Mode.TUTORIAL:
             return _TutorialRuntimeUpdate.navigation_direction
         case _:
             return 0
@@ -510,8 +615,18 @@ def set_background(value: Quad):
     _Background.value = value
 
 
-runtime_ui = _RuntimeUi
-runtime_ui_configs = _RuntimeUiConfigs
+play_ui = _PlayRuntimeUi
+play_ui_configs = _PlayRuntimeUiConfigs
+watch_ui = _WatchRuntimeUi
+watch_ui_configs = _WatchRuntimeUiConfigs
+preview_ui = _PreviewRuntimeUi
+preview_ui_configs = _PreviewRuntimeUiConfigs
+tutorial_ui = _TutorialRuntimeUi
+tutorial_ui_configs = _TutorialRuntimeUiConfigs
+
+
+def canvas() -> _PreviewRuntimeCanvas:
+    return _PreviewRuntimeCanvas
 
 
 def screen() -> Rect: