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

sonolus/script/timing.py

@@ -1,42 +1,42 @@
-from sonolus.backend.ops import Op
-from sonolus.script.internal.native import native_function
-
-
-@native_function(Op.BeatToBPM)
-def beat_to_bpm(beat: float) -> float:
-    raise NotImplementedError
-
-
-@native_function(Op.BeatToTime)
-def beat_to_time(beat: float) -> float:
-    raise NotImplementedError
-
-
-@native_function(Op.BeatToStartingBeat)
-def beat_to_starting_beat(beat: float) -> float:
-    raise NotImplementedError
-
-
-@native_function(Op.BeatToStartingTime)
-def beat_to_starting_time(beat: float) -> float:
-    raise NotImplementedError
-
-
-@native_function(Op.TimeToScaledTime)
-def time_to_scaled_time(time: float) -> float:
-    raise NotImplementedError
-
-
-@native_function(Op.TimeToStartingScaledTime)
-def time_to_starting_scaled_time(time: float) -> float:
-    raise NotImplementedError
-
-
-@native_function(Op.TimeToStartingTime)
-def time_to_starting_time(time: float) -> float:
-    raise NotImplementedError
-
-
-@native_function(Op.TimeToTimeScale)
-def time_to_timescale(time: float) -> float:
-    raise NotImplementedError
+from sonolus.backend.ops import Op
+from sonolus.script.internal.native import native_function
+
+
+@native_function(Op.BeatToBPM)
+def beat_to_bpm(beat: float) -> float:
+    raise NotImplementedError
+
+
+@native_function(Op.BeatToTime)
+def beat_to_time(beat: float) -> float:
+    raise NotImplementedError
+
+
+@native_function(Op.BeatToStartingBeat)
+def beat_to_starting_beat(beat: float) -> float:
+    raise NotImplementedError
+
+
+@native_function(Op.BeatToStartingTime)
+def beat_to_starting_time(beat: float) -> float:
+    raise NotImplementedError
+
+
+@native_function(Op.TimeToScaledTime)
+def time_to_scaled_time(time: float) -> float:
+    raise NotImplementedError
+
+
+@native_function(Op.TimeToStartingScaledTime)
+def time_to_starting_scaled_time(time: float) -> float:
+    raise NotImplementedError
+
+
+@native_function(Op.TimeToStartingTime)
+def time_to_starting_time(time: float) -> float:
+    raise NotImplementedError
+
+
+@native_function(Op.TimeToTimeScale)
+def time_to_timescale(time: float) -> float:
+    raise NotImplementedError

sonolus/script/transform.py

@@ -16,93 +16,147 @@ class Transform2d(Record):
     a12: float
     a20: float
     a21: float
+    a22: float
 
     @classmethod
     def new(cls) -> Self:
+        """Create a new identity transform."""
         return cls(
             1, 0, 0,
             0, 1, 0,
-            0, 0,
+            0, 0, 1,
         )
 
     def _compose(self,
         b00: float, b01: float, b02: float,
         b10: float, b11: float, b12: float,
-        b20: float, b21: float,
+        b20: float, b21: float, b22: float,
     ) -> Self:
         """Multiply the matrix with another matrix on the left."""
         a00 = self.a00 * b00 + self.a10 * b01 + self.a20 * b02
         a01 = self.a01 * b00 + self.a11 * b01 + self.a21 * b02
-        a02 = self.a02 * b00 + self.a12 * b01 + b02
+        a02 = self.a02 * b00 + self.a12 * b01 + self.a22 * b02
         a10 = self.a00 * b10 + self.a10 * b11 + self.a20 * b12
         a11 = self.a01 * b10 + self.a11 * b11 + self.a21 * b12
-        a12 = self.a02 * b10 + self.a12 * b11 + b12
-        a20 = self.a00 * b20 + self.a10 * b21 + b20
-        a21 = self.a01 * b20 + self.a11 * b21 + b21
-        a22 = self.a02 * b20 + self.a12 * b21 + 1
+        a12 = self.a02 * b10 + self.a12 * b11 + self.a22 * b12
+        a20 = self.a00 * b20 + self.a10 * b21 + self.a20 * b22
+        a21 = self.a01 * b20 + self.a11 * b21 + self.a21 * b22
+        a22 = self.a02 * b20 + self.a12 * b21 + self.a22 * b22
         return Transform2d(
-            a00 / a22, a01 / a22, a02 / a22,
-            a10 / a22, a11 / a22, a12 / a22,
-            a20 / a22, a21 / a22,
+            a00, a01, a02,
+            a10, a11, a12,
+            a20, a21, a22,
         )
 
     def translate(self, translation: Vec2, /) -> Self:
+        """Translate along the x and y axes."""
         return self._compose(
             1, 0, translation.x,
             0, 1, translation.y,
-            0, 0,
+            0, 0, 1,
         )
 
     def scale(self, factor: Vec2, /) -> Self:
+        """Scale around the origin."""
         return self._compose(
             factor.x, 0, 0,
             0, factor.y, 0,
-            0, 0,
+            0, 0, 1,
         )
 
-    def rotate(self, angle: float) -> Self:
+    def scale_about(self, factor: Vec2, /, pivot: Vec2) -> Self:
+        """Scale around the pivot."""
+        return self.translate(-pivot).scale(factor).translate(pivot)
+
+    def rotate(self, angle: float, /) -> Self:
+        """Rotate around the origin."""
         c = cos(angle)
         s = sin(angle)
         return self._compose(
             c, -s, 0,
             s, c, 0,
-            0, 0,
+            0, 0, 1,
         )
 
-    def shear_x(self, m: float) -> Self:
+    def rotate_about(self, angle: float, /, pivot: Vec2) -> Self:
+        """Rotate around the pivot."""
+        return self.translate(-pivot).rotate(angle).translate(pivot)
+
+    def shear_x(self, m: float, /) -> Self:
         """Shear along the x-axis."""
         return self._compose(
             1, m, 0,
             0, 1, 0,
-            0, 0,
+            0, 0, 1,
         )
 
-    def shear_y(self, m: float) -> Self:
+    def shear_y(self, m: float, /) -> Self:
         """Shear along the y-axis."""
         return self._compose(
             1, 0, 0,
             m, 1, 0,
-            0, 0,
+            0, 0, 1,
         )
 
-    def perspective_vanish_y(self, y: float) -> Self:
+    def perspective_vanish_y(self, y: float, /) -> Self:
+        """Apply perspective vanish along the y-axis with vanish point at the given y coordinate.
+
+        Note: Conveniently, the inverse can be obtained simply by negating the argument.
+        """
         return self._compose(
             1, 0, 0,
             0, 1, 0,
-            0, 1 / y,
+            0, 1 / y, 1,
+        )
+
+    def perspective(self, foreground_y, vanishing_point: Vec2, /) -> Self:
+        """Apply a perspective transformation.
+
+        When the original y is 0, the transformed x coordinate will be unchanged and the y coordinates will
+        be equal to foreground_y.
+        As the original y coordinate approaches infinity in the direction of the vanishing point,
+        the transformed x and y coordinates will approach the vanishing point.
+        """
+        return (
+            self
+            .perspective_vanish_y(vanishing_point.y - foreground_y)
+            .shear_x(vanishing_point.x / (vanishing_point.y - foreground_y))
+            .translate(Vec2(0, foreground_y))
         )
 
-    def compose(self, other: Self) -> Self:
+    def inverse_perspective(self, foreground_y, vanishing_point: Vec2, /) -> Self:
+        """Apply the inverse of a perspective transformation."""
+        return (
+            self
+            .translate(Vec2(0, -foreground_y))
+            .shear_x(-vanishing_point.x / (vanishing_point.y - foreground_y))
+            .perspective_vanish_y(-vanishing_point.y + foreground_y)
+        )
+
+    def normalize(self):
+        """Normalize the transform to have a 1 in the bottom right corner."""
+        return Transform2d(
+            self.a00 / self.a22, self.a01 / self.a22, self.a02 / self.a22,
+            self.a10 / self.a22, self.a11 / self.a22, self.a12 / self.a22,
+            self.a20 / self.a22, self.a21 / self.a22, 1,
+        )
+
+    def compose(self, other: Self, /) -> Self:
+        """Compose with another transform which is applied after this transform."""
         return self._compose(
             other.a00, other.a01, other.a02,
             other.a10, other.a11, other.a12,
-            other.a20, other.a21,
+            other.a20, other.a21, other.a22,
         )
 
+    def compose_before(self, other: Self, /) -> Self:
+        """Compose with another transform which is applied before this transform."""
+        return other.compose(self)
+
     def transform_vec(self, v: Vec2) -> Vec2:
         x = self.a00 * v.x + self.a01 * v.y + self.a02
         y = self.a10 * v.x + self.a11 * v.y + self.a12
-        w = self.a20 * v.x + self.a21 * v.y + 1
+        w = self.a20 * v.x + self.a21 * v.y + self.a22
         return Vec2(x / w, y / w)
 
     def transform_quad(self, quad: QuadLike) -> Quad:

sonolus/script/ui.py

@@ -1,160 +1,160 @@
-from dataclasses import dataclass, field
-from typing import Literal
-
-UiMetric = Literal[
-    "arcade",
-    "arcadePercentage",
-    "accuracy",
-    "accuracyPercentage",
-    "life",
-    "perfect",
-    "perfectPercentage",
-    "greatGoodMiss",
-    "greatGoodMissPercentage",
-    "miss",
-    "missPercentage",
-    "errorHeatmap",
-]
-
-UiJudgmentErrorStyle = Literal[
-    "none",
-    "plus",
-    "minus",
-    "arrowUp",
-    "arrowDown",
-    "arrowLeft",
-    "arrowRight",
-    "triangleUp",
-    "triangleDown",
-    "triangleLeft",
-    "triangleRight",
-]
-
-UiJudgmentErrorPlacement = Literal["both", "left", "right"]
-
-EaseType = Literal[
-    "linear",
-    "none",
-    "inSine",
-    "inQuad",
-    "inCubic",
-    "inQuart",
-    "inQuint",
-    "inExpo",
-    "inCirc",
-    "inBack",
-    "inElastic",
-    "outSine",
-    "outQuad",
-    "outCubic",
-    "outQuart",
-    "outQuint",
-    "outExpo",
-    "outCirc",
-    "outBack",
-    "outElastic",
-    "inOutSine",
-    "inOutQuad",
-    "inOutCubic",
-    "inOutQuart",
-    "inOutQuint",
-    "inOutExpo",
-    "inOutCirc",
-    "inOutBack",
-    "inOutElastic",
-    "outInSine",
-    "outInQuad",
-    "outInCubic",
-    "outInQuart",
-    "outInQuint",
-    "outInExpo",
-    "outInCirc",
-    "outInBack",
-    "outInElastic",
-]
-
-
-@dataclass
-class UiAnimationTween:
-    start: float
-    end: float
-    duration: float
-    ease: EaseType
-
-    def to_dict(self):
-        return {
-            "from": self.start,
-            "to": self.end,
-            "duration": self.duration,
-            "ease": self.ease,
-        }
-
-
-@dataclass
-class UiAnimation:
-    scale: UiAnimationTween = field(default_factory=lambda: UiAnimationTween(1, 1, 0, "none"))
-    alpha: UiAnimationTween = field(default_factory=lambda: UiAnimationTween(1, 0, 0.2, "outCubic"))
-
-    def to_dict(self):
-        return {
-            "scale": self.scale.to_dict(),
-            "alpha": self.alpha.to_dict(),
-        }
-
-
-@dataclass
-class UiVisibility:
-    scale: float = 1.0
-    alpha: float = 1.0
-
-    def to_dict(self):
-        return {
-            "scale": self.scale,
-            "alpha": self.alpha,
-        }
-
-
-@dataclass
-class UiConfig:
-    scope: str | None = None
-    primary_metric: UiMetric = "arcade"
-    secondary_metric: UiMetric = "life"
-    menu_visibility: UiVisibility = field(default_factory=UiVisibility)
-    judgment_visibility: UiVisibility = field(default_factory=UiVisibility)
-    combo_visibility: UiVisibility = field(default_factory=UiVisibility)
-    primary_metric_visibility: UiVisibility = field(default_factory=UiVisibility)
-    secondary_metric_visibility: UiVisibility = field(default_factory=UiVisibility)
-    progress_visibility: UiVisibility = field(default_factory=UiVisibility)
-    tutorial_navigation_visibility: UiVisibility = field(default_factory=UiVisibility)
-    tutorial_instruction_visibility: UiVisibility = field(default_factory=UiVisibility)
-    judgment_animation: UiAnimation = field(default_factory=UiAnimation)
-    combo_animation: UiAnimation = field(
-        default_factory=lambda: UiAnimation(
-            scale=UiAnimationTween(1.2, 1, 0.2, "inCubic"), alpha=UiAnimationTween(1, 1, 0, "none")
-        )
-    )
-    judgment_error_style: UiJudgmentErrorStyle = "none"
-    judgment_error_placement: UiJudgmentErrorPlacement = "both"
-    judgment_error_min: float = 0.0
-
-    def to_dict(self):
-        data = {
-            "primaryMetric": self.primary_metric,
-            "secondaryMetric": self.secondary_metric,
-            "menuVisibility": self.menu_visibility.to_dict(),
-            "judgmentVisibility": self.judgment_visibility.to_dict(),
-            "comboVisibility": self.combo_visibility.to_dict(),
-            "primaryMetricVisibility": self.primary_metric_visibility.to_dict(),
-            "secondaryMetricVisibility": self.secondary_metric_visibility.to_dict(),
-            "progressVisibility": self.progress_visibility.to_dict(),
-            "tutorialNavigationVisibility": self.tutorial_navigation_visibility.to_dict(),
-            "tutorialInstructionVisibility": self.tutorial_instruction_visibility.to_dict(),
-            "judgmentAnimation": self.judgment_animation.to_dict(),
-            "comboAnimation": self.combo_animation.to_dict(),
-            "judgmentErrorStyle": self.judgment_error_style,
-            "judgmentErrorPlacement": self.judgment_error_placement,
-            "judgmentErrorMin": self.judgment_error_min,
-        }
-        if self.scope is not None:
-            data["scope"] = self.scope
-        return data
+from dataclasses import dataclass, field
+from typing import Literal
+
+UiMetric = Literal[
+    "arcade",
+    "arcadePercentage",
+    "accuracy",
+    "accuracyPercentage",
+    "life",
+    "perfect",
+    "perfectPercentage",
+    "greatGoodMiss",
+    "greatGoodMissPercentage",
+    "miss",
+    "missPercentage",
+    "errorHeatmap",
+]
+
+UiJudgmentErrorStyle = Literal[
+    "none",
+    "plus",
+    "minus",
+    "arrowUp",
+    "arrowDown",
+    "arrowLeft",
+    "arrowRight",
+    "triangleUp",
+    "triangleDown",
+    "triangleLeft",
+    "triangleRight",
+]
+
+UiJudgmentErrorPlacement = Literal["both", "left", "right"]
+
+EaseType = Literal[
+    "linear",
+    "none",
+    "inSine",
+    "inQuad",
+    "inCubic",
+    "inQuart",
+    "inQuint",
+    "inExpo",
+    "inCirc",
+    "inBack",
+    "inElastic",
+    "outSine",
+    "outQuad",
+    "outCubic",
+    "outQuart",
+    "outQuint",
+    "outExpo",
+    "outCirc",
+    "outBack",
+    "outElastic",
+    "inOutSine",
+    "inOutQuad",
+    "inOutCubic",
+    "inOutQuart",
+    "inOutQuint",
+    "inOutExpo",
+    "inOutCirc",
+    "inOutBack",
+    "inOutElastic",
+    "outInSine",
+    "outInQuad",
+    "outInCubic",
+    "outInQuart",
+    "outInQuint",
+    "outInExpo",
+    "outInCirc",
+    "outInBack",
+    "outInElastic",
+]
+
+
+@dataclass
+class UiAnimationTween:
+    start: float
+    end: float
+    duration: float
+    ease: EaseType
+
+    def to_dict(self):
+        return {
+            "from": self.start,
+            "to": self.end,
+            "duration": self.duration,
+            "ease": self.ease,
+        }
+
+
+@dataclass
+class UiAnimation:
+    scale: UiAnimationTween = field(default_factory=lambda: UiAnimationTween(1, 1, 0, "none"))
+    alpha: UiAnimationTween = field(default_factory=lambda: UiAnimationTween(1, 0, 0.2, "outCubic"))
+
+    def to_dict(self):
+        return {
+            "scale": self.scale.to_dict(),
+            "alpha": self.alpha.to_dict(),
+        }
+
+
+@dataclass
+class UiVisibility:
+    scale: float = 1.0
+    alpha: float = 1.0
+
+    def to_dict(self):
+        return {
+            "scale": self.scale,
+            "alpha": self.alpha,
+        }
+
+
+@dataclass
+class UiConfig:
+    scope: str | None = None
+    primary_metric: UiMetric = "arcade"
+    secondary_metric: UiMetric = "life"
+    menu_visibility: UiVisibility = field(default_factory=UiVisibility)
+    judgment_visibility: UiVisibility = field(default_factory=UiVisibility)
+    combo_visibility: UiVisibility = field(default_factory=UiVisibility)
+    primary_metric_visibility: UiVisibility = field(default_factory=UiVisibility)
+    secondary_metric_visibility: UiVisibility = field(default_factory=UiVisibility)
+    progress_visibility: UiVisibility = field(default_factory=UiVisibility)
+    tutorial_navigation_visibility: UiVisibility = field(default_factory=UiVisibility)
+    tutorial_instruction_visibility: UiVisibility = field(default_factory=UiVisibility)
+    judgment_animation: UiAnimation = field(default_factory=UiAnimation)
+    combo_animation: UiAnimation = field(
+        default_factory=lambda: UiAnimation(
+            scale=UiAnimationTween(1.2, 1, 0.2, "inCubic"), alpha=UiAnimationTween(1, 1, 0, "none")
+        )
+    )
+    judgment_error_style: UiJudgmentErrorStyle = "none"
+    judgment_error_placement: UiJudgmentErrorPlacement = "both"
+    judgment_error_min: float = 0.0
+
+    def to_dict(self):
+        data = {
+            "primaryMetric": self.primary_metric,
+            "secondaryMetric": self.secondary_metric,
+            "menuVisibility": self.menu_visibility.to_dict(),
+            "judgmentVisibility": self.judgment_visibility.to_dict(),
+            "comboVisibility": self.combo_visibility.to_dict(),
+            "primaryMetricVisibility": self.primary_metric_visibility.to_dict(),
+            "secondaryMetricVisibility": self.secondary_metric_visibility.to_dict(),
+            "progressVisibility": self.progress_visibility.to_dict(),
+            "tutorialNavigationVisibility": self.tutorial_navigation_visibility.to_dict(),
+            "tutorialInstructionVisibility": self.tutorial_instruction_visibility.to_dict(),
+            "judgmentAnimation": self.judgment_animation.to_dict(),
+            "comboAnimation": self.combo_animation.to_dict(),
+            "judgmentErrorStyle": self.judgment_error_style,
+            "judgmentErrorPlacement": self.judgment_error_placement,
+            "judgmentErrorMin": self.judgment_error_min,
+        }
+        if self.scope is not None:
+            data["scope"] = self.scope
+        return data