sonolus.py 0.7.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

sonolus/script/particle.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+from collections.abc import Iterable
 from dataclasses import dataclass
 from typing import Annotated, Any, NewType, dataclass_transform, get_origin
 
 from sonolus.backend.ops import Op
+from sonolus.script.array_like import ArrayLike
+from sonolus.script.debug import static_error
 from sonolus.script.internal.introspection import get_field_specifiers
 from sonolus.script.internal.native import native_function
 from sonolus.script.quad import QuadLike, flatten_quad
@@ -52,6 +55,29 @@ class ParticleHandle(Record):
         _destroy_particle_effect(self.id)
 
 
+class ParticleGroup(Record, ArrayLike[Particle]):
+    """A group of particle effects.
+
+    Usage:
+        ```python
+        ParticleGroup(start_id: int, size: int)
+        ```
+    """
+
+    start_id: int
+    size: int
+
+    def __len__(self) -> int:
+        return self.size
+
+    def __getitem__(self, index: int) -> Particle:
+        assert 0 <= index < self.size
+        return Particle(self.start_id + index)
+
+    def __setitem__(self, index: int, value: Particle) -> None:
+        static_error("ParticleGroup is read-only")
+
+
 @native_function(Op.HasParticleEffect)
 def _has_particle_effect(particle_id: int) -> bool:
     raise NotImplementedError
@@ -91,11 +117,21 @@ class _ParticleInfo:
     name: str
 
 
+@dataclass
+class _ParticleGroupInfo:
+    names: list[str]
+
+
 def particle(name: str) -> Any:
     """Define a particle with the given name."""
     return _ParticleInfo(name)
 
 
+def particle_group(names: Iterable[str]) -> Any:
+    """Define a particle group with the given names."""
+    return _ParticleGroupInfo(list(names))
+
+
 type Particles = NewType("Particles", Any)  # type: ignore
 
 
@@ -109,26 +145,49 @@ def particles[T](cls: type[T]) -> T | Particles:
         class Particles:
             tap: StandardParticle.NOTE_CIRCULAR_TAP_RED
             other: Particle = particle("other")
+            group_1: ParticleGroup = particle_group(["one", "two", "three"])
+            group_2: ParticleGroup = particle_group(f"name_{i}" for i in range(10))
         ```
     """
     if len(cls.__bases__) != 1:
         raise ValueError("Particles class must not inherit from any class (except object)")
     instance = cls()
     names = []
-    for i, (name, annotation) in enumerate(get_field_specifiers(cls).items()):
+    i = 0
+    for name, annotation in get_field_specifiers(cls).items():
         if get_origin(annotation) is not Annotated:
-            raise TypeError(f"Invalid annotation for particles: {annotation}")
+            raise TypeError(f"Invalid annotation for particles: {annotation} on field {name}")
         annotation_type = annotation.__args__[0]
         annotation_values = annotation.__metadata__
-        if annotation_type is not Particle:
-            raise TypeError(f"Invalid annotation for particles: {annotation}, expected annotation of type Particle")
-        if len(annotation_values) != 1 or not isinstance(annotation_values[0], _ParticleInfo):
+        if len(annotation_values) != 1:
             raise TypeError(
-                f"Invalid annotation for particles: {annotation}, expected a single string annotation value"
+                f"Invalid annotation for particles: {annotation} on field {name}, too many annotation values"
             )
-        particle_name = annotation_values[0].name
-        names.append(particle_name)
-        setattr(instance, name, Particle(i))
+        particle_info = annotation_values[0]
+        match particle_info:
+            case _ParticleInfo(name=particle_name):
+                if annotation_type is not Particle:
+                    raise TypeError(
+                        f"Invalid annotation for particles: {annotation} on field {name}, expected Particle"
+                    )
+                names.append(particle_name)
+                setattr(instance, name, Particle(i))
+                i += 1
+            case _ParticleGroupInfo(names=particle_names):
+                if annotation_type is not ParticleGroup:
+                    raise TypeError(
+                        f"Invalid annotation for particles: {annotation} on field {name}, expected ParticleGroup"
+                    )
+                start_id = i
+                count = len(particle_names)
+                names.extend(particle_names)
+                setattr(instance, name, ParticleGroup(start_id, count))
+                i += count
+            case _:
+                raise TypeError(
+                    f"Invalid annotation for particles: {annotation} on field {name}, unknown particle info, "
+                    f"expected a particle() or particle_group() specifier"
+                )
     instance._particles_ = names
     instance._is_comptime_value_ = True
     return instance

sonolus/script/project.py

@@ -8,6 +8,7 @@ from typing import ClassVar, TypedDict
 
 from sonolus.backend.optimize import optimize
 from sonolus.backend.optimize.passes import CompilerPass
+from sonolus.build.compile import CompileCache
 from sonolus.script.archetype import ArchetypeSchema
 from sonolus.script.engine import Engine
 from sonolus.script.level import ExternalLevelData, Level, LevelData
@@ -65,8 +66,20 @@ class Project:
         """
         from sonolus.build.cli import build_collection, run_server
 
-        build_collection(self, Path(build_dir), config)
-        run_server(Path(build_dir) / "site", port=port)
+        if config is None:
+            config = BuildConfig()
+
+        cache = CompileCache()
+        build_collection(self, Path(build_dir), config, cache=cache)
+        run_server(
+            Path(build_dir) / "site",
+            port=port,
+            project_module_name=None,
+            core_module_names=None,
+            build_dir=Path(build_dir),
+            config=config,
+            cache=cache,
+        )
 
     def build(self, build_dir: PathLike, config: BuildConfig | None = None):
         """Build the project.

sonolus/script/quad.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-from typing import Protocol
+from typing import Protocol, Self, assert_never, overload
 
+from sonolus.script.internal.impl import perf_meta_fn
 from sonolus.script.record import Record
 from sonolus.script.values import zeros
 from sonolus.script.vec import Vec2, pnpoly
@@ -57,6 +58,26 @@ class Quad(Record):
         """The center of the quad."""
         return (self.bl + self.tr + self.tl + self.br) / 4
 
+    @property
+    def mt(self) -> Vec2:
+        """The midpoint of the top edge of the quad."""
+        return (self.tl + self.tr) / 2
+
+    @property
+    def mr(self) -> Vec2:
+        """The midpoint of the right edge of the quad."""
+        return (self.tr + self.br) / 2
+
+    @property
+    def mb(self) -> Vec2:
+        """The midpoint of the bottom edge of the quad."""
+        return (self.bl + self.br) / 2
+
+    @property
+    def ml(self) -> Vec2:
+        """The midpoint of the left edge of the quad."""
+        return (self.bl + self.tl) / 2
+
     def translate(self, translation: Vec2, /) -> Quad:
         """Translate the quad by the given translation and return a new quad."""
         return Quad(
@@ -212,7 +233,7 @@ class Rect(Record):
     b: float
     """The bottom edge of the rectangle."""
 
-    l: float  # noqa: E741
+    l: float
     """The left edge of the rectangle."""
 
     @classmethod
@@ -225,6 +246,57 @@ class Rect(Record):
             l=center.x - dimensions.x / 2,
         )
 
+    @overload
+    @classmethod
+    def from_margin(cls, trbl: float, /) -> Rect: ...
+
+    @overload
+    @classmethod
+    def from_margin(cls, tb: float, lr: float, /) -> Rect: ...
+
+    @overload
+    @classmethod
+    def from_margin(cls, t: float, lr: float, b: float, /) -> Rect: ...
+
+    @overload
+    @classmethod
+    def from_margin(cls, t: float, r: float, b: float, l: float, /) -> Rect: ...
+
+    @classmethod
+    def from_margin(cls, a: float, b: float | None = None, c: float | None = None, d: float | None = None, /) -> Self:
+        """Create a rectangle based on margins (edge distances) from the origin.
+
+        Compared to the regular [`Rect`][sonolus.script.quad.Rect] constructor, this method negates the bottom and
+        left values, and supports shorthands when fewer than four arguments are provided.
+
+        The following signatures are supported:
+
+        - `from_margin(trbl)`: All margins set to `trbl`.
+        - `from_margin(tb, lr)`: Top and bottom margins set to `tb`, left and right margins set to `lr`.
+        - `from_margin(t, lr, b)`: Top margin set to `t`, left and right margins set to `lr`, bottom margin set to `b`.
+        - `from_margin(t, r, b, l)`: Top, right, bottom, and left margins set to `t`, `r`, `b`, and `l` respectively.
+
+        Usage:
+            ```python
+            Rect.from_margin(1)  # Rect(t=1, r=1, b=-1, l=-1)
+            Rect.from_margin(1, 2)  # Rect(t=1, r=2, b=-1, l=-2)
+            Rect.from_margin(1, 2, 3)  # Rect(t=1, r=2, b=-3, l=-2)
+            Rect.from_margin(1, 2, 3, 4)  # Rect(t=1, r=2, b=-3, l=-4)
+            ```
+        """
+        args = (a, b, c, d)
+        match args:
+            case (a, None, None, None):
+                return cls(t=a, r=a, b=-a, l=-a)
+            case (a, b, None, None):
+                return cls(t=a, r=b, b=-a, l=-b)
+            case (a, b, c, None):
+                return cls(t=a, r=b, b=-c, l=-b)
+            case (a, b, c, d):
+                return cls(t=a, r=b, b=-c, l=-d)
+            case _:
+                assert_never(args)
+
     @property
     def w(self) -> float:
         """The width of the rectangle."""
@@ -260,6 +332,26 @@ class Rect(Record):
         """The center of the rectangle."""
         return Vec2((self.l + self.r) / 2, (self.t + self.b) / 2)
 
+    @property
+    def mt(self) -> Vec2:
+        """The middle-top point of the rectangle."""
+        return Vec2((self.l + self.r) / 2, self.t)
+
+    @property
+    def mr(self) -> Vec2:
+        """The middle-right point of the rectangle."""
+        return Vec2(self.r, (self.t + self.b) / 2)
+
+    @property
+    def mb(self) -> Vec2:
+        """The middle-bottom point of the rectangle."""
+        return Vec2((self.l + self.r) / 2, self.b)
+
+    @property
+    def ml(self) -> Vec2:
+        """The middle-left point of the rectangle."""
+        return Vec2(self.l, (self.t + self.b) / 2)
+
     def as_quad(self) -> Quad:
         """Convert the rectangle to a [`Quad`][sonolus.script.quad.Quad]."""
         return Quad(
@@ -360,6 +452,7 @@ type QuadLike = _QuadLike | Quad
 """A type that can be used as a quad."""
 
 
+@perf_meta_fn
 def flatten_quad(quad: QuadLike) -> tuple[float, float, float, float, float, float, float, float]:
     bl = quad.bl
     tl = quad.tl

sonolus/script/record.py

@@ -171,6 +171,15 @@ class Record(GenericValue, metaclass=RecordMeta):
         result._value_ = kwargs
         return result
 
+    @classmethod
+    def _quick_construct(cls, **kwargs) -> Self:
+        result = object.__new__(cls)
+        for k, v in kwargs.items():
+            if isinstance(v, int | float):
+                kwargs[k] = Num._accept_(v)
+        result._value_ = kwargs
+        return result
+
     @classmethod
     def _size_(cls) -> int:
         return sum(field.type._size_() for field in cls._fields_)

sonolus/script/runtime.py

@@ -30,7 +30,7 @@ from sonolus.script.globals import (
     _watch_runtime_update,
 )
 from sonolus.script.internal.context import ctx
-from sonolus.script.internal.impl import meta_fn
+from sonolus.script.internal.impl import meta_fn, perf_meta_fn
 from sonolus.script.num import Num
 from sonolus.script.quad import Quad, Rect
 from sonolus.script.record import Record
@@ -992,7 +992,7 @@ def time() -> float:
 def offset_adjusted_time() -> float:
     """Get the current time of the game adjusted by the input offset.
 
-    Returns 0 in preview mode and tutorial mode.
+    Returns 0 in preview mode and the current time without adjustment in tutorial mode.
     """
     if not ctx():
         return 0
@@ -1154,9 +1154,10 @@ def canvas() -> _PreviewRuntimeCanvas:
     return _PreviewRuntimeCanvas  # type: ignore
 
 
+@perf_meta_fn
 def screen() -> Rect:
     """Get the screen boundaries as a rectangle."""
-    return Rect(t=1, r=aspect_ratio(), b=-1, l=-aspect_ratio())
+    return Rect._quick_construct(t=1, r=aspect_ratio(), b=-1, l=-aspect_ratio())
 
 
 def level_score() -> _LevelScore:

sonolus/script/sprite.py

@@ -1,8 +1,12 @@
+from collections.abc import Iterable
 from dataclasses import dataclass
 from enum import StrEnum
 from typing import Annotated, Any, NewType, dataclass_transform, get_origin
 
 from sonolus.backend.ops import Op
+from sonolus.script.array_like import ArrayLike
+from sonolus.script.debug import static_error
+from sonolus.script.internal.impl import perf_meta_fn
 from sonolus.script.internal.introspection import get_field_specifiers
 from sonolus.script.internal.native import native_function
 from sonolus.script.quad import QuadLike, flatten_quad
@@ -26,6 +30,7 @@ class Sprite(Record):
         """Check if the sprite is available."""
         return _has_skin_sprite(self.id)
 
+    @perf_meta_fn
     def draw(self, quad: QuadLike, z: float = 0.0, a: float = 1.0):
         """Draw the sprite.
 
@@ -36,6 +41,7 @@ class Sprite(Record):
         """
         _draw(self.id, *flatten_quad(quad), z, a)
 
+    @perf_meta_fn
     def draw_curved_b(self, quad: QuadLike, cp: Vec2, n: float, z: float = 0.0, a: float = 1.0):
         """Draw the sprite with a curved bottom with a quadratic Bézier curve.
 
@@ -48,6 +54,7 @@ class Sprite(Record):
         """
         _draw_curved_b(self.id, *flatten_quad(quad), z, a, n, *cp.tuple)
 
+    @perf_meta_fn
     def draw_curved_t(self, quad: QuadLike, cp: Vec2, n: float, z: float = 0.0, a: float = 1.0):
         """Draw the sprite with a curved top with a quadratic Bézier curve.
 
@@ -60,6 +67,7 @@ class Sprite(Record):
         """
         _draw_curved_t(self.id, *flatten_quad(quad), z, a, n, *cp.tuple)
 
+    @perf_meta_fn
     def draw_curved_l(self, quad: QuadLike, cp: Vec2, n: float, z: float = 0.0, a: float = 1.0):
         """Draw the sprite with a curved left side with a quadratic Bézier curve.
 
@@ -72,6 +80,7 @@ class Sprite(Record):
         """
         _draw_curved_l(self.id, *flatten_quad(quad), z, a, n, *cp.tuple)
 
+    @perf_meta_fn
     def draw_curved_r(self, quad: QuadLike, cp: Vec2, n: float, z: float = 0.0, a: float = 1.0):
         """Draw the sprite with a curved right side with a quadratic Bézier curve.
 
@@ -84,6 +93,7 @@ class Sprite(Record):
         """
         _draw_curved_r(self.id, *flatten_quad(quad), z, a, n, *cp.tuple)
 
+    @perf_meta_fn
     def draw_curved_bt(self, quad: QuadLike, cp1: Vec2, cp2: Vec2, n: float, z: float = 0.0, a: float = 1.0):
         """Draw the sprite with a curved bottom and top with a cubic Bézier curve.
 
@@ -97,6 +107,7 @@ class Sprite(Record):
         """
         _draw_curved_bt(self.id, *flatten_quad(quad), z, a, n, *cp1.tuple, *cp2.tuple)
 
+    @perf_meta_fn
     def draw_curved_lr(self, quad: QuadLike, cp1: Vec2, cp2: Vec2, n: float, z: float = 0.0, a: float = 1.0):
         """Draw the sprite with a curved left and right side with a cubic Bézier curve.
 
@@ -111,6 +122,29 @@ class Sprite(Record):
         _draw_curved_lr(self.id, *flatten_quad(quad), z, a, n, *cp1.tuple, *cp2.tuple)
 
 
+class SpriteGroup(Record, ArrayLike[Sprite]):
+    """A group of sprites.
+
+    Usage:
+        ```python
+        SpriteGroup(start_id: int, size: int)
+        ```
+    """
+
+    start_id: int
+    size: int
+
+    def __len__(self) -> int:
+        return self.size
+
+    def __getitem__(self, index: int) -> Sprite:
+        assert 0 <= index < self.size
+        return Sprite(self.start_id + index)
+
+    def __setitem__(self, index: int, value: Sprite) -> None:
+        static_error("SpriteGroup is read-only")
+
+
 @native_function(Op.HasSkinSprite)
 def _has_skin_sprite(sprite_id: int) -> bool:
     raise NotImplementedError
@@ -262,11 +296,21 @@ class SkinSprite:
     name: str
 
 
+@dataclass
+class SkinSpriteGroup:
+    names: list[str]
+
+
 def sprite(name: str) -> Any:
     """Define a sprite with the given name."""
     return SkinSprite(name)
 
 
+def sprite_group(names: Iterable[str]) -> Any:
+    """Define a sprite group with the given names."""
+    return SkinSpriteGroup(list(names))
+
+
 type Skin = NewType("Skin", Any)  # type: ignore
 
 
@@ -294,25 +338,44 @@ def skin[T](cls: type[T]) -> T | Skin:
             render_mode: RenderMode = RenderMode.LIGHTWEIGHT
 
             note: StandardSprite.NOTE_HEAD_RED
-            other: Sprite = skin_sprite("other")
+            other: Sprite = sprite("other")
+            group_1: SpriteGroup = sprite_group(["one", "two", "three"])
+            group_2: SpriteGroup = sprite_group(f"name_{i}" for i in range(10))
         ```
     """
     if len(cls.__bases__) != 1:
         raise ValueError("Skin class must not inherit from any class (except object)")
     instance = cls()
     names = []
-    for i, (name, annotation) in enumerate(get_field_specifiers(cls, skip={"render_mode"}).items()):
+    i = 0
+    for name, annotation in get_field_specifiers(cls, skip={"render_mode"}).items():
         if get_origin(annotation) is not Annotated:
-            raise TypeError(f"Invalid annotation for skin: {annotation}")
+            raise TypeError(f"Invalid annotation for skin: {annotation} on field {name}")
         annotation_type = annotation.__args__[0]
         annotation_values = annotation.__metadata__
-        if annotation_type is not Sprite:
-            raise TypeError(f"Invalid annotation for skin: {annotation}, expected annotation of type Sprite")
-        if len(annotation_values) != 1 or not isinstance(annotation_values[0], SkinSprite):
-            raise TypeError(f"Invalid annotation for skin: {annotation}, expected a single string annotation value")
-        sprite_name = annotation_values[0].name
-        names.append(sprite_name)
-        setattr(instance, name, Sprite(i))
+        if len(annotation_values) != 1:
+            raise TypeError(f"Invalid annotation for skin: {annotation} on field {name}, too many annotation values")
+        sprite_info = annotation_values[0]
+        match sprite_info:
+            case SkinSprite(name=sprite_name):
+                if annotation_type is not Sprite:
+                    raise TypeError(f"Invalid annotation for skin: {annotation} on field {name}, expected Sprite")
+                names.append(sprite_name)
+                setattr(instance, name, Sprite(i))
+                i += 1
+            case SkinSpriteGroup(names=sprite_names):
+                if annotation_type is not SpriteGroup:
+                    raise TypeError(f"Invalid annotation for skin: {annotation} on field {name}, expected SpriteGroup")
+                start_id = i
+                count = len(sprite_names)
+                names.extend(sprite_names)
+                setattr(instance, name, SpriteGroup(start_id, count))
+                i += count
+            case _:
+                raise TypeError(
+                    f"Invalid annotation for skin: {annotation} on field {name}, unknown sprite info, "
+                    f"expected a skin() or sprite_group() specifier"
+                )
     instance._sprites_ = names
     instance.render_mode = RenderMode(getattr(instance, "render_mode", RenderMode.DEFAULT))
     instance._is_comptime_value_ = True

sonolus/script/vec.py

@@ -1,12 +1,16 @@
 from __future__ import annotations
 
-from math import atan2, cos, sin
-
 from sonolus.script.array import Array
 from sonolus.script.array_like import ArrayLike
+from sonolus.script.internal.impl import perf_meta_fn
+from sonolus.script.internal.math_impls import _atan2, _cos, _sin
 from sonolus.script.num import Num
 from sonolus.script.record import Record
 
+atan2 = _atan2
+sin = _sin
+cos = _cos
+
 
 class Vec2(Record):
     """A 2D vector.
@@ -87,6 +91,7 @@ class Vec2(Record):
         return Vec2(x=cos(angle), y=sin(angle))
 
     @property
+    @perf_meta_fn
     def magnitude(self) -> float:
         """Calculate the magnitude (length) of the vector.
 
@@ -96,6 +101,7 @@ class Vec2(Record):
         return (self.x**2 + self.y**2) ** 0.5
 
     @property
+    @perf_meta_fn
     def angle(self) -> float:
         """Calculate the angle of the vector in radians from the positive x-axis.
 
@@ -104,6 +110,7 @@ class Vec2(Record):
         """
         return atan2(self.y, self.x)
 
+    @perf_meta_fn
     def dot(self, other: Vec2) -> float:
         """Calculate the dot product of this vector with another vector.
 
@@ -115,6 +122,7 @@ class Vec2(Record):
         """
         return self.x * other.x + self.y * other.y
 
+    @perf_meta_fn
     def rotate(self, angle: float) -> Vec2:
         """Rotate the vector by a given angle in radians and return a new vector.
 
@@ -124,11 +132,12 @@ class Vec2(Record):
         Returns:
             A new vector rotated by the given angle.
         """
-        return Vec2(
+        return Vec2._quick_construct(
             x=self.x * cos(angle) - self.y * sin(angle),
             y=self.x * sin(angle) + self.y * cos(angle),
         )
 
+    @perf_meta_fn
     def rotate_about(self, angle: float, pivot: Vec2) -> Vec2:
         """Rotate the vector about a pivot by a given angle in radians and return a new vector.
 
@@ -141,15 +150,17 @@ class Vec2(Record):
         """
         return (self - pivot).rotate(angle) + pivot
 
+    @perf_meta_fn
     def normalize(self) -> Vec2:
         """Normalize the vector (set the magnitude to 1) and return a new vector.
 
         Returns:
             A new vector with magnitude 1.
         """
-        magnitude = self.magnitude
-        return Vec2(x=self.x / magnitude, y=self.y / magnitude)
+        magnitude = (self.x**2 + self.y**2) ** 0.5
+        return Vec2._quick_construct(x=self.x / magnitude, y=self.y / magnitude)
 
+    @perf_meta_fn
     def orthogonal(self) -> Vec2:
         """Return a vector orthogonal to this vector.
 
@@ -158,7 +169,7 @@ class Vec2(Record):
         Returns:
             A new vector orthogonal to this vector.
         """
-        return Vec2(x=-self.y, y=self.x)
+        return Vec2._quick_construct(x=-self.y, y=self.x)
 
     @property
     def tuple(self) -> tuple[float, float]:
@@ -169,6 +180,7 @@ class Vec2(Record):
         """
         return self.x, self.y
 
+    @perf_meta_fn
     def __add__(self, other: Vec2) -> Vec2:
         """Add this vector to another vector and return a new vector.
 
@@ -178,8 +190,9 @@ class Vec2(Record):
         Returns:
             A new vector resulting from the addition.
         """
-        return Vec2(x=self.x + other.x, y=self.y + other.y)
+        return Vec2._quick_construct(x=self.x + other.x, y=self.y + other.y)
 
+    @perf_meta_fn
     def __sub__(self, other: Vec2) -> Vec2:
         """Subtract another vector from this vector and return a new vector.
 
@@ -189,8 +202,9 @@ class Vec2(Record):
         Returns:
             A new vector resulting from the subtraction.
         """
-        return Vec2(x=self.x - other.x, y=self.y - other.y)
+        return Vec2._quick_construct(x=self.x - other.x, y=self.y - other.y)
 
+    @perf_meta_fn
     def __mul__(self, other: Vec2 | float) -> Vec2:
         """Multiply this vector by another vector or a scalar and return a new vector.
 
@@ -202,19 +216,21 @@ class Vec2(Record):
         """
         match other:
             case Vec2(x, y):
-                return Vec2(x=self.x * x, y=self.y * y)
+                return Vec2._quick_construct(x=self.x * x, y=self.y * y)
             case Num(factor):
-                return Vec2(x=self.x * factor, y=self.y * factor)
+                return Vec2._quick_construct(x=self.x * factor, y=self.y * factor)
             case _:
                 return NotImplemented
 
+    @perf_meta_fn
     def __rmul__(self, other):
         match other:
             case Num(factor):
-                return Vec2(x=self.x * factor, y=self.y * factor)
+                return Vec2._quick_construct(x=self.x * factor, y=self.y * factor)
             case _:
                 return NotImplemented
 
+    @perf_meta_fn
     def __truediv__(self, other: Vec2 | float) -> Vec2:
         """Divide this vector by another vector or a scalar and return a new vector.
 
@@ -226,19 +242,20 @@ class Vec2(Record):
         """
         match other:
             case Vec2(x, y):
-                return Vec2(x=self.x / x, y=self.y / y)
+                return Vec2._quick_construct(x=self.x / x, y=self.y / y)
             case Num(factor):
-                return Vec2(x=self.x / factor, y=self.y / factor)
+                return Vec2._quick_construct(x=self.x / factor, y=self.y / factor)
             case _:
                 return NotImplemented
 
+    @perf_meta_fn
     def __neg__(self) -> Vec2:
         """Negate the vector (invert the direction) and return a new vector.
 
         Returns:
             A new vector with inverted direction.
         """
-        return Vec2(x=-self.x, y=-self.y)
+        return Vec2._quick_construct(x=-self.x, y=-self.y)
 
 
 def pnpoly(vertices: ArrayLike[Vec2] | tuple[Vec2, ...], test: Vec2) -> bool:

{sonolus_py-0.7.1.dist-info → sonolus_py-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.7.1
+Version: 0.9.0
 Summary: Sonolus engine development in Python
 License-File: LICENSE
 Requires-Python: >=3.12