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

sonolus/script/debug.py

@@ -1,9 +1,11 @@
 from collections.abc import Callable
+from contextvars import ContextVar
 from typing import Any, Never
 
 from sonolus.backend.flow import cfg_to_mermaid
 from sonolus.backend.mode import Mode
 from sonolus.backend.ops import Op
+from sonolus.backend.passes import CompilerPass, run_passes
 from sonolus.backend.simplify import CoalesceFlow
 from sonolus.script.comptime import Comptime
 from sonolus.script.internal.context import GlobalContextState, ctx, set_ctx
@@ -12,6 +14,8 @@ from sonolus.script.internal.native import native_function
 from sonolus.script.num import Num
 from sonolus.script.values import with_default
 
+debug_log_callback = ContextVar[Callable[[Num], None]]("debug_log_callback")
+
 
 @meta_fn
 def error(message: str | None = None) -> None:
@@ -26,9 +30,18 @@ def error(message: str | None = None) -> None:
         raise RuntimeError(message)
 
 
-@native_function(Op.DebugLog)
+@meta_fn
 def debug_log(value: Num):
+    if debug_log_callback.get(None):
+        return debug_log_callback.get()(value)
+    else:
+        return _debug_log(value)
+
+
+@native_function(Op.DebugLog)
+def _debug_log(value: Num):
     print(f"[DEBUG] {value}")
+    return 0
 
 
 @native_function(Op.DebugPause)
@@ -62,9 +75,12 @@ def terminate():
         raise RuntimeError("Terminated")
 
 
-def visualize_cfg(fn: Callable[[], Any]) -> str:
+def visualize_cfg(fn: Callable[[], Any], passes: list[CompilerPass] | None = None) -> str:
     from sonolus.build.compile import callback_to_cfg
 
+    if passes is None:
+        passes = [CoalesceFlow()]
+
     cfg = callback_to_cfg(GlobalContextState(Mode.PLAY), fn, "")
-    cfg = CoalesceFlow().run(cfg)
+    cfg = run_passes(cfg, passes)
     return cfg_to_mermaid(cfg)

sonolus/script/easing.py

@@ -0,0 +1,323 @@
+import math
+
+from sonolus.backend.ops import Op
+from sonolus.script.internal.native import native_function
+from sonolus.script.interval import clamp
+
+
+@native_function(Op.EaseInBack)
+def ease_in_back(x: float) -> float:
+    x = clamp(x, 0, 1)
+    c1 = 1.70158
+    c3 = c1 + 1
+    return c3 * x**3 - c1 * x**2
+
+
+@native_function(Op.EaseOutBack)
+def ease_out_back(x: float) -> float:
+    x = clamp(x, 0, 1)
+    c1 = 1.70158
+    c3 = c1 + 1
+    return 1 + c3 * (x - 1) ** 3 + c1 * (x - 1) ** 2
+
+
+@native_function(Op.EaseInOutBack)
+def ease_in_out_back(x: float) -> float:
+    x = clamp(x, 0, 1)
+    c1 = 1.70158
+    c2 = c1 * 1.525
+    if x < 0.5:
+        return ((2 * x) ** 2 * ((c2 + 1) * 2 * x - c2)) / 2
+    else:
+        return ((2 * x - 2) ** 2 * ((c2 + 1) * (2 * x - 2) + c2) + 2) / 2
+
+
+@native_function(Op.EaseInCirc)
+def ease_in_circ(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return 1 - math.sqrt(1 - x**2)
+
+
+@native_function(Op.EaseOutCirc)
+def ease_out_circ(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return math.sqrt(1 - (x - 1) ** 2)
+
+
+@native_function(Op.EaseInOutCirc)
+def ease_in_out_circ(x: float) -> float:
+    x = clamp(x, 0, 1)
+    if x < 0.5:
+        return (1 - math.sqrt(1 - (2 * x) ** 2)) / 2
+    else:
+        return (math.sqrt(1 - (2 * x - 2) ** 2) + 1) / 2
+
+
+@native_function(Op.EaseInCubic)
+def ease_in_cubic(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return x**3
+
+
+@native_function(Op.EaseOutCubic)
+def ease_out_cubic(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return 1 - (1 - x) ** 3
+
+
+@native_function(Op.EaseInOutCubic)
+def ease_in_out_cubic(x: float) -> float:
+    x = clamp(x, 0, 1)
+    if x < 0.5:
+        return 4 * x**3
+    else:
+        return 1 - (-2 * x + 2) ** 3 / 2
+
+
+@native_function(Op.EaseInElastic)
+def ease_in_elastic(x: float) -> float:
+    x = clamp(x, 0, 1)
+    c4 = (2 * math.pi) / 3
+    if x in {0, 1}:
+        return x
+    else:
+        return -(2 ** (10 * x - 10)) * math.sin((x * 10 - 10.75) * c4)
+
+
+@native_function(Op.EaseOutElastic)
+def ease_out_elastic(x: float) -> float:
+    x = clamp(x, 0, 1)
+    c4 = (2 * math.pi) / 3
+    if x in {0, 1}:
+        return x
+    else:
+        return 2 ** (-10 * x) * math.sin((x * 10 - 0.75) * c4) + 1
+
+
+@native_function(Op.EaseInOutElastic)
+def ease_in_out_elastic(x: float) -> float:
+    x = clamp(x, 0, 1)
+    c5 = (2 * math.pi) / 4.5
+    if x in {0, 1}:
+        return x
+    elif x < 0.5:
+        return -(2 ** (20 * x - 10) * math.sin((20 * x - 11.125) * c5)) / 2
+    else:
+        return (2 ** (-20 * x + 10) * math.sin((20 * x - 11.125) * c5)) / 2 + 1
+
+
+@native_function(Op.EaseInExpo)
+def ease_in_expo(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return 0 if x == 0 else 2 ** (10 * x - 10)
+
+
+@native_function(Op.EaseOutExpo)
+def ease_out_expo(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return 1 if x == 1 else 1 - 2 ** (-10 * x)
+
+
+@native_function(Op.EaseInOutExpo)
+def ease_in_out_expo(x: float) -> float:
+    x = clamp(x, 0, 1)
+    if x in {0, 1}:
+        return x
+    elif x < 0.5:
+        return 2 ** (20 * x - 10) / 2
+    else:
+        return (2 - 2 ** (-20 * x + 10)) / 2
+
+
+@native_function(Op.EaseInOutQuad)
+def ease_in_out_quad(x: float) -> float:
+    x = clamp(x, 0, 1)
+    if x < 0.5:
+        return 2 * x**2
+    else:
+        return 1 - (-2 * x + 2) ** 2 / 2
+
+
+@native_function(Op.EaseInOutQuart)
+def ease_in_out_quart(x: float) -> float:
+    x = clamp(x, 0, 1)
+    if x < 0.5:
+        return 8 * x**4
+    else:
+        return 1 - (-2 * x + 2) ** 4 / 2
+
+
+@native_function(Op.EaseInOutQuint)
+def ease_in_out_quint(x: float) -> float:
+    x = clamp(x, 0, 1)
+    if x < 0.5:
+        return 16 * x**5
+    else:
+        return 1 - (-2 * x + 2) ** 5 / 2
+
+
+@native_function(Op.EaseInOutSine)
+def ease_in_out_sine(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return -(math.cos(math.pi * x) - 1) / 2
+
+
+@native_function(Op.EaseInQuad)
+def ease_in_quad(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return x**2
+
+
+@native_function(Op.EaseOutQuad)
+def ease_out_quad(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return 1 - (1 - x) ** 2
+
+
+@native_function(Op.EaseInQuart)
+def ease_in_quart(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return x**4
+
+
+@native_function(Op.EaseOutQuart)
+def ease_out_quart(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return 1 - (1 - x) ** 4
+
+
+@native_function(Op.EaseInQuint)
+def ease_in_quint(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return x**5
+
+
+@native_function(Op.EaseOutQuint)
+def ease_out_quint(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return 1 - (1 - x) ** 5
+
+
+@native_function(Op.EaseInSine)
+def ease_in_sine(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return 1 - math.cos((x * math.pi) / 2)
+
+
+@native_function(Op.EaseOutSine)
+def ease_out_sine(x: float) -> float:
+    x = clamp(x, 0, 1)
+    return math.sin((x * math.pi) / 2)
+
+
+@native_function(Op.EaseOutInBack)
+def ease_out_in_back(x: float) -> float:
+    x = clamp(x, 0, 1)
+    c1 = 1.70158
+    c3 = c1 + 1
+    if x < 0.5:
+        return (1 + c3 * (2 * x - 1) ** 3 + c1 * (2 * x - 1) ** 2) / 2
+    else:
+        return (c3 * (2 * x - 1) ** 3 - c1 * (2 * x - 1) ** 2) / 2 + 0.5
+
+
+@native_function(Op.EaseOutInCirc)
+def ease_out_in_circ(x: float) -> float:
+    x = clamp(x, 0, 1)
+    if x < 0.5:
+        return (math.sqrt(1 - (2 * x - 1) ** 2)) / 2
+    else:
+        return (1 - math.sqrt(1 - (2 * x - 1) ** 2)) / 2 + 0.5
+
+
+@native_function(Op.EaseOutInCubic)
+def ease_out_in_cubic(x: float) -> float:
+    x = clamp(x, 0, 1)
+    if x < 0.5:
+        return (1 - (1 - 2 * x) ** 3) / 2
+    else:
+        return ((2 * x - 1) ** 3) / 2 + 0.5
+
+
+@native_function(Op.EaseOutInElastic)
+def ease_out_in_elastic(x: float) -> float:
+    x = clamp(x, 0, 1)
+    c4 = (2 * math.pi) / 3
+    if x < 0.5:
+        if x == 0:
+            return 0
+        else:
+            return (2 ** (-20 * x + 10) * math.sin((20 * x - 0.75) * c4)) / 2 + 0.5
+    elif x == 1:
+        return 1
+    else:
+        return (-(2 ** (10 * (2 * x - 1) - 10)) * math.sin((20 * x - 10.75) * c4)) / 2 + 0.5
+
+
+@native_function(Op.EaseOutInExpo)
+def ease_out_in_expo(x: float) -> float:
+    x = clamp(x, 0, 1)
+    if x in {0, 1}:
+        return x
+    elif x < 0.5:
+        return (1 - 2 ** (-20 * x)) / 2
+    else:
+        return (2 ** (20 * x - 20)) / 2 + 0.5
+
+
+@native_function(Op.EaseOutInQuad)
+def ease_out_in_quad(x: float) -> float:
+    x = clamp(x, 0, 1)
+    if x < 0.5:
+        return (1 - (1 - 2 * x) ** 2) / 2
+    else:
+        return ((2 * x - 1) ** 2) / 2 + 0.5
+
+
+@native_function(Op.EaseOutInQuart)
+def ease_out_in_quart(x: float) -> float:
+    x = clamp(x, 0, 1)
+    if x < 0.5:
+        return (1 - (1 - 2 * x) ** 4) / 2
+    else:
+        return ((2 * x - 1) ** 4) / 2 + 0.5
+
+
+@native_function(Op.EaseOutInQuint)
+def ease_out_in_quint(x: float) -> float:
+    x = clamp(x, 0, 1)
+    if x < 0.5:
+        return (1 - (1 - 2 * x) ** 5) / 2
+    else:
+        return ((2 * x - 1) ** 5) / 2 + 0.5
+
+
+@native_function(Op.EaseOutInSine)
+def ease_out_in_sine(x: float) -> float:
+    x = clamp(x, 0, 1)
+    if x < 0.5:
+        return (math.sin(math.pi * x)) / 2
+    else:
+        return (1 - math.cos(math.pi * x)) / 2
+
+
+def linstep(x: float) -> float:
+    return clamp(x, 0.0, 1.0)
+
+
+def smoothstep(x: float) -> float:
+    x = clamp(x, 0.0, 1.0)
+    return x * x * (3 - 2 * x)
+
+
+def smootherstep(x: float) -> float:
+    x = clamp(x, 0.0, 1.0)
+    return x * x * x * (x * (x * 6 - 15) + 10)
+
+
+def step_start(x: float) -> float:
+    return 1.0 if x >= 0 else 0.0
+
+
+def step_end(x: float) -> float:
+    return 1.0 if x >= 1 else 0.0

sonolus/script/effect.py

@@ -1,131 +1,131 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Annotated, Any, NewType, dataclass_transform, get_origin
-
-from sonolus.backend.ops import Op
-from sonolus.script.internal.introspection import get_field_specifiers
-from sonolus.script.internal.native import native_function
-from sonolus.script.record import Record
-
-
-class Effect(Record):
-    id: int
-
-    def is_available(self) -> bool:
-        return _has_effect_clip(self.id)
-
-    def play(self, distance: float) -> None:
-        _play(self.id, distance)
-
-    def schedule(self, time: float, distance: float) -> None:
-        _play_scheduled(self.id, time, distance)
-
-    def loop(self) -> LoopedEffectHandle:
-        return LoopedEffectHandle(_play_looped(self.id))
-
-    def schedule_loop(self, start_time: float) -> ScheduledLoopedEffectHandle:
-        return ScheduledLoopedEffectHandle(_play_looped_scheduled(self.id, start_time))
-
-
-class LoopedEffectHandle(Record):
-    id: int
-
-    def stop(self) -> None:
-        _stop_looped(self.id)
-
-
-class ScheduledLoopedEffectHandle(Record):
-    id: int
-
-    def stop(self, end_time: float) -> None:
-        _stop_looped_scheduled(self.id, end_time)
-
-
-@native_function(Op.HasEffectClip)
-def _has_effect_clip(effect_id: int) -> bool:
-    raise NotImplementedError
-
-
-@native_function(Op.Play)
-def _play(effect_id: int, distance: float) -> None:
-    raise NotImplementedError
-
-
-@native_function(Op.PlayLooped)
-def _play_looped(effect_id: int) -> int:
-    raise NotImplementedError
-
-
-@native_function(Op.PlayLoopedScheduled)
-def _play_looped_scheduled(effect_id: int, start_time: float) -> int:
-    raise NotImplementedError
-
-
-@native_function(Op.PlayScheduled)
-def _play_scheduled(effect_id: int, time: float, distance: float) -> None:
-    raise NotImplementedError
-
-
-@native_function(Op.StopLooped)
-def _stop_looped(handle: int) -> None:
-    raise NotImplementedError
-
-
-@native_function(Op.StopLoopedScheduled)
-def _stop_looped_scheduled(handle: int, end_time: float) -> None:
-    raise NotImplementedError
-
-
-@dataclass
-class EffectInfo:
-    name: str
-
-
-def effect(name: str) -> Any:
-    return EffectInfo(name)
-
-
-type Effects = NewType("Effects", Any)
-
-
-@dataclass_transform()
-def effects[T](cls: type[T]) -> T | Effects:
-    if len(cls.__bases__) != 1:
-        raise ValueError("Effects class must not inherit from any class (except object)")
-    instance = cls()
-    names = []
-    for i, (name, annotation) in enumerate(get_field_specifiers(cls).items()):
-        if get_origin(annotation) is not Annotated:
-            raise TypeError(f"Invalid annotation for effects: {annotation}")
-        annotation_type = annotation.__args__[0]
-        annotation_values = annotation.__metadata__
-        if annotation_type is not Effect:
-            raise TypeError(f"Invalid annotation for effects: {annotation}, expected annotation of type Effect")
-        if len(annotation_values) != 1 or not isinstance(annotation_values[0], EffectInfo):
-            raise TypeError(f"Invalid annotation for effects: {annotation}, expected a single string annotation value")
-        effect_name = annotation_values[0].name
-        names.append(effect_name)
-        setattr(instance, name, Effect(i))
-    instance._effects_ = names
-    instance._is_comptime_value_ = True
-    return instance
-
-
-class StandardEffect:
-    MISS = Annotated[Effect, effect("#MISS")]
-    PERFECT = Annotated[Effect, effect("#PERFECT")]
-    GREAT = Annotated[Effect, effect("#GREAT")]
-    GOOD = Annotated[Effect, effect("#GOOD")]
-    HOLD = Annotated[Effect, effect("#HOLD")]
-    MISS_ALTERNATIVE = Annotated[Effect, effect("#MISS_ALTERNATIVE")]
-    PERFECT_ALTERNATIVE = Annotated[Effect, effect("#PERFECT_ALTERNATIVE")]
-    GREAT_ALTERNATIVE = Annotated[Effect, effect("#GREAT_ALTERNATIVE")]
-    GOOD_ALTERNATIVE = Annotated[Effect, effect("#GOOD_ALTERNATIVE")]
-    HOLD_ALTERNATIVE = Annotated[Effect, effect("#HOLD_ALTERNATIVE")]
-    STAGE = Annotated[Effect, effect("#STAGE")]
-
-
-@effects
-class EmptyEffects:
-    pass
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Annotated, Any, NewType, dataclass_transform, get_origin
+
+from sonolus.backend.ops import Op
+from sonolus.script.internal.introspection import get_field_specifiers
+from sonolus.script.internal.native import native_function
+from sonolus.script.record import Record
+
+
+class Effect(Record):
+    id: int
+
+    def is_available(self) -> bool:
+        return _has_effect_clip(self.id)
+
+    def play(self, distance: float) -> None:
+        _play(self.id, distance)
+
+    def schedule(self, time: float, distance: float) -> None:
+        _play_scheduled(self.id, time, distance)
+
+    def loop(self) -> LoopedEffectHandle:
+        return LoopedEffectHandle(_play_looped(self.id))
+
+    def schedule_loop(self, start_time: float) -> ScheduledLoopedEffectHandle:
+        return ScheduledLoopedEffectHandle(_play_looped_scheduled(self.id, start_time))
+
+
+class LoopedEffectHandle(Record):
+    id: int
+
+    def stop(self) -> None:
+        _stop_looped(self.id)
+
+
+class ScheduledLoopedEffectHandle(Record):
+    id: int
+
+    def stop(self, end_time: float) -> None:
+        _stop_looped_scheduled(self.id, end_time)
+
+
+@native_function(Op.HasEffectClip)
+def _has_effect_clip(effect_id: int) -> bool:
+    raise NotImplementedError
+
+
+@native_function(Op.Play)
+def _play(effect_id: int, distance: float) -> None:
+    raise NotImplementedError
+
+
+@native_function(Op.PlayLooped)
+def _play_looped(effect_id: int) -> int:
+    raise NotImplementedError
+
+
+@native_function(Op.PlayLoopedScheduled)
+def _play_looped_scheduled(effect_id: int, start_time: float) -> int:
+    raise NotImplementedError
+
+
+@native_function(Op.PlayScheduled)
+def _play_scheduled(effect_id: int, time: float, distance: float) -> None:
+    raise NotImplementedError
+
+
+@native_function(Op.StopLooped)
+def _stop_looped(handle: int) -> None:
+    raise NotImplementedError
+
+
+@native_function(Op.StopLoopedScheduled)
+def _stop_looped_scheduled(handle: int, end_time: float) -> None:
+    raise NotImplementedError
+
+
+@dataclass
+class EffectInfo:
+    name: str
+
+
+def effect(name: str) -> Any:
+    return EffectInfo(name)
+
+
+type Effects = NewType("Effects", Any)
+
+
+@dataclass_transform()
+def effects[T](cls: type[T]) -> T | Effects:
+    if len(cls.__bases__) != 1:
+        raise ValueError("Effects class must not inherit from any class (except object)")
+    instance = cls()
+    names = []
+    for i, (name, annotation) in enumerate(get_field_specifiers(cls).items()):
+        if get_origin(annotation) is not Annotated:
+            raise TypeError(f"Invalid annotation for effects: {annotation}")
+        annotation_type = annotation.__args__[0]
+        annotation_values = annotation.__metadata__
+        if annotation_type is not Effect:
+            raise TypeError(f"Invalid annotation for effects: {annotation}, expected annotation of type Effect")
+        if len(annotation_values) != 1 or not isinstance(annotation_values[0], EffectInfo):
+            raise TypeError(f"Invalid annotation for effects: {annotation}, expected a single string annotation value")
+        effect_name = annotation_values[0].name
+        names.append(effect_name)
+        setattr(instance, name, Effect(i))
+    instance._effects_ = names
+    instance._is_comptime_value_ = True
+    return instance
+
+
+class StandardEffect:
+    MISS = Annotated[Effect, effect("#MISS")]
+    PERFECT = Annotated[Effect, effect("#PERFECT")]
+    GREAT = Annotated[Effect, effect("#GREAT")]
+    GOOD = Annotated[Effect, effect("#GOOD")]
+    HOLD = Annotated[Effect, effect("#HOLD")]
+    MISS_ALTERNATIVE = Annotated[Effect, effect("#MISS_ALTERNATIVE")]
+    PERFECT_ALTERNATIVE = Annotated[Effect, effect("#PERFECT_ALTERNATIVE")]
+    GREAT_ALTERNATIVE = Annotated[Effect, effect("#GREAT_ALTERNATIVE")]
+    GOOD_ALTERNATIVE = Annotated[Effect, effect("#GOOD_ALTERNATIVE")]
+    HOLD_ALTERNATIVE = Annotated[Effect, effect("#HOLD_ALTERNATIVE")]
+    STAGE = Annotated[Effect, effect("#STAGE")]
+
+
+@effects
+class EmptyEffects:
+    pass