sonolus.py 0.1.9__py3-none-any.whl → 0.2.0__py3-none-any.whl

sonolus/build/compile.py

@@ -1,11 +1,13 @@
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
+from concurrent.futures import Executor, Future
 
 from sonolus.backend.finalize import cfg_to_engine_node
 from sonolus.backend.ir import IRConst, IRInstr
 from sonolus.backend.mode import Mode
 from sonolus.backend.ops import Op
 from sonolus.backend.optimize.flow import BasicBlock
-from sonolus.backend.optimize.optimize import optimize_and_allocate
+from sonolus.backend.optimize.optimize import STANDARD_PASSES
+from sonolus.backend.optimize.passes import CompilerPass, run_passes
 from sonolus.backend.visitor import compile_and_call
 from sonolus.build.node import OutputNodeGenerator
 from sonolus.script.archetype import _BaseArchetype
@@ -27,16 +29,49 @@ def compile_mode(
     rom: ReadOnlyMemory,
     archetypes: list[type[_BaseArchetype]] | None,
     global_callbacks: list[tuple[CallbackInfo, Callable]] | None,
+    passes: Sequence[CompilerPass] | None = None,
+    thread_pool: Executor | None = None,
 ) -> dict:
+    if passes is None:
+        passes = STANDARD_PASSES
+
     global_state = GlobalContextState(
-        mode, {a: i for i, a in enumerate(archetypes)} if archetypes is not None else None, rom
+        mode,
+        {a: i for i, a in enumerate(archetypes)} if archetypes is not None else None,
+        rom,
     )
     nodes = OutputNodeGenerator()
     results = {}
+
+    def process_callback(
+        cb_info: CallbackInfo,
+        cb: Callable,
+        arch: type[_BaseArchetype] | None = None,
+    ) -> tuple[str, int] | tuple[str, dict]:
+        """Compile a single callback to a node.
+
+        Returns either:
+        - (cb_info.name, node_index) for global callbacks, or
+        - (cb_info.name, {"index": node_index, "order": cb_order}) for archetype callbacks.
+        """
+        cfg = callback_to_cfg(global_state, cb, cb_info.name, arch)
+        cfg = run_passes(cfg, passes)
+        node = cfg_to_engine_node(cfg)
+        node_index = nodes.add(node)
+
+        if arch is not None:
+            cb_order = getattr(cb, "_callback_order_", 0)
+            return cb_info.name, {"index": node_index, "order": cb_order}
+        else:
+            return cb_info.name, node_index
+
+    all_futures = {}
+    archetype_entries = []
+
     if archetypes is not None:
-        archetype_entries = []
         for archetype in archetypes:
             archetype._init_fields()
+
             archetype_data = {
                 "name": archetype.name,
                 "hasInput": archetype.is_scored,
@@ -44,36 +79,59 @@ def compile_mode(
             }
             if mode == Mode.PLAY:
                 archetype_data["exports"] = [*archetype._exported_keys_]
-            for cb_name, cb_info in archetype._supported_callbacks_.items():
-                cb = getattr(archetype, cb_name)
-                if cb in archetype._default_callbacks_:
-                    continue
-                cb_order = getattr(cb, "_callback_order_", 0)
-                if not cb_info.supports_order and cb_order != 0:
-                    raise ValueError(f"Callback '{cb_name}' does not support a non-zero order")
-                cfg = callback_to_cfg(global_state, cb, cb_info.name, archetype)
-                cfg = optimize_and_allocate(cfg)
-                node = cfg_to_engine_node(cfg)
-                node_index = nodes.add(node)
-                archetype_data[cb_info.name] = {
-                    "index": node_index,
-                    "order": cb_order,
-                }
+
+            callback_items = [
+                (cb_name, cb_info, getattr(archetype, cb_name))
+                for cb_name, cb_info in archetype._supported_callbacks_.items()
+                if getattr(archetype, cb_name) not in archetype._default_callbacks_
+            ]
+
+            if thread_pool is not None:
+                for cb_name, cb_info, cb in callback_items:
+                    cb_order = getattr(cb, "_callback_order_", 0)
+                    if not cb_info.supports_order and cb_order != 0:
+                        raise ValueError(f"Callback '{cb_name}' does not support a non-zero order")
+                    f: Future = thread_pool.submit(process_callback, cb_info, cb, archetype)
+                    all_futures[f] = ("archetype", archetype_data, cb_name)
+            else:
+                for cb_name, cb_info, cb in callback_items:
+                    cb_order = getattr(cb, "_callback_order_", 0)
+                    if not cb_info.supports_order and cb_order != 0:
+                        raise ValueError(f"Callback '{cb_name}' does not support a non-zero order")
+                    cb_name, result_data = process_callback(cb_info, cb, archetype)
+                    archetype_data[cb_name] = result_data
+
             archetype_entries.append(archetype_data)
-        results["archetypes"] = archetype_entries
-    if global_callbacks is not None:
+
+    if global_callbacks is not None and thread_pool is not None:
+        for cb_info, cb in global_callbacks:
+            f: Future = thread_pool.submit(process_callback, cb_info, cb, None)
+            all_futures[f] = ("global", None, cb_info.name)
+
+    if thread_pool is not None:
+        for f, (callback_type, archetype_data, cb_name) in all_futures.items():
+            cb_name, result_data = f.result()
+            if callback_type == "archetype":
+                archetype_data[cb_name] = result_data
+            else:  # global callback
+                results[cb_name] = result_data
+    elif global_callbacks is not None:
         for cb_info, cb in global_callbacks:
-            cfg = callback_to_cfg(global_state, cb, cb_info.name)
-            cfg = optimize_and_allocate(cfg)
-            node = cfg_to_engine_node(cfg)
-            node_index = nodes.add(node)
-            results[cb_info.name] = node_index
+            cb_name, node_index = process_callback(cb_info, cb, None)
+            results[cb_name] = node_index
+
+    if archetypes is not None:
+        results["archetypes"] = archetype_entries
+
     results["nodes"] = nodes.get()
     return results
 
 
 def callback_to_cfg(
-    global_state: GlobalContextState, callback: Callable, name: str, archetype: type[_BaseArchetype] | None = None
+    global_state: GlobalContextState,
+    callback: Callable,
+    name: str,
+    archetype: type[_BaseArchetype] | None = None,
 ) -> BasicBlock:
     callback_state = CallbackContextState(name)
     context = Context(global_state, callback_state)

sonolus/build/engine.py

@@ -1,8 +1,12 @@
 import gzip
 import json
 import struct
+import sys
 from collections.abc import Callable
+from concurrent.futures import Executor
+from concurrent.futures.thread import ThreadPoolExecutor
 from dataclasses import dataclass
+from os import process_cpu_count
 from pathlib import Path
 
 from sonolus.backend.mode import Mode
@@ -10,7 +14,7 @@ from sonolus.build.compile import compile_mode
 from sonolus.script.archetype import _BaseArchetype
 from sonolus.script.bucket import Buckets
 from sonolus.script.effect import Effects
-from sonolus.script.engine import EngineData
+from sonolus.script.engine import EngineData, empty_play_mode, empty_preview_mode, empty_tutorial_mode, empty_watch_mode
 from sonolus.script.instruction import (
     TutorialInstructionIcons,
     TutorialInstructions,
@@ -24,6 +28,7 @@ from sonolus.script.internal.callbacks import (
 from sonolus.script.internal.context import ReadOnlyMemory
 from sonolus.script.options import Options
 from sonolus.script.particle import Particles
+from sonolus.script.project import BuildConfig
 from sonolus.script.sprite import Skin
 from sonolus.script.ui import UiConfig
 
@@ -48,43 +53,132 @@ class PackagedEngine:
         (path / "EngineTutorialData").write_bytes(self.tutorial_data)
         (path / "EngineRom").write_bytes(self.rom)
 
+    def read(self, path: Path):
+        self.configuration = (path / "EngineConfiguration").read_bytes()
+        self.play_data = (path / "EnginePlayData").read_bytes()
+        self.watch_data = (path / "EngineWatchData").read_bytes()
+        self.preview_data = (path / "EnginePreviewData").read_bytes()
+        self.tutorial_data = (path / "EngineTutorialData").read_bytes()
+        self.rom = (path / "EngineRom").read_bytes()
 
-def package_engine(engine: EngineData):
+
+def no_gil() -> bool:
+    return sys.version_info >= (3, 13) and not sys._is_gil_enabled()
+
+
+def package_engine(
+    engine: EngineData,
+    config: BuildConfig | None = None,
+):
+    config = config or BuildConfig()
     rom = ReadOnlyMemory()
     configuration = build_engine_configuration(engine.options, engine.ui)
-    play_data = build_play_mode(
-        archetypes=engine.play.archetypes,
-        skin=engine.play.skin,
-        effects=engine.play.effects,
-        particles=engine.play.particles,
-        buckets=engine.play.buckets,
-        rom=rom,
-    )
-    watch_data = build_watch_mode(
-        archetypes=engine.watch.archetypes,
-        skin=engine.watch.skin,
-        effects=engine.watch.effects,
-        particles=engine.watch.particles,
-        buckets=engine.watch.buckets,
-        rom=rom,
-        update_spawn=engine.watch.update_spawn,
-    )
-    preview_data = build_preview_mode(
-        archetypes=engine.preview.archetypes,
-        skin=engine.preview.skin,
-        rom=rom,
-    )
-    tutorial_data = build_tutorial_mode(
-        skin=engine.tutorial.skin,
-        effects=engine.tutorial.effects,
-        particles=engine.tutorial.particles,
-        instructions=engine.tutorial.instructions,
-        instruction_icons=engine.tutorial.instruction_icons,
-        preprocess=engine.tutorial.preprocess,
-        navigate=engine.tutorial.navigate,
-        update=engine.tutorial.update,
-        rom=rom,
-    )
+    if no_gil():
+        thread_pool = ThreadPoolExecutor(process_cpu_count() or 1)
+    else:
+        thread_pool = None
+
+    play_mode = engine.play if config.build_play else empty_play_mode()
+    watch_mode = engine.watch if config.build_watch else empty_watch_mode()
+    preview_mode = engine.preview if config.build_preview else empty_preview_mode()
+    tutorial_mode = engine.tutorial if config.build_tutorial else empty_tutorial_mode()
+
+    if thread_pool is not None:
+        futures = {
+            "play": thread_pool.submit(
+                build_play_mode,
+                archetypes=play_mode.archetypes,
+                skin=play_mode.skin,
+                effects=play_mode.effects,
+                particles=play_mode.particles,
+                buckets=play_mode.buckets,
+                rom=rom,
+                config=config,
+                thread_pool=thread_pool,
+            ),
+            "watch": thread_pool.submit(
+                build_watch_mode,
+                archetypes=watch_mode.archetypes,
+                skin=watch_mode.skin,
+                effects=watch_mode.effects,
+                particles=watch_mode.particles,
+                buckets=watch_mode.buckets,
+                rom=rom,
+                update_spawn=watch_mode.update_spawn,
+                config=config,
+                thread_pool=thread_pool,
+            ),
+            "preview": thread_pool.submit(
+                build_preview_mode,
+                archetypes=preview_mode.archetypes,
+                skin=preview_mode.skin,
+                rom=rom,
+                config=config,
+                thread_pool=thread_pool,
+            ),
+            "tutorial": thread_pool.submit(
+                build_tutorial_mode,
+                skin=tutorial_mode.skin,
+                effects=tutorial_mode.effects,
+                particles=tutorial_mode.particles,
+                instructions=tutorial_mode.instructions,
+                instruction_icons=tutorial_mode.instruction_icons,
+                preprocess=tutorial_mode.preprocess,
+                navigate=tutorial_mode.navigate,
+                update=tutorial_mode.update,
+                rom=rom,
+                config=config,
+                thread_pool=thread_pool,
+            ),
+        }
+
+        play_data = futures["play"].result()
+        watch_data = futures["watch"].result()
+        preview_data = futures["preview"].result()
+        tutorial_data = futures["tutorial"].result()
+    else:
+        play_data = build_play_mode(
+            archetypes=play_mode.archetypes,
+            skin=play_mode.skin,
+            effects=play_mode.effects,
+            particles=play_mode.particles,
+            buckets=play_mode.buckets,
+            rom=rom,
+            config=config,
+            thread_pool=None,
+        )
+        watch_data = build_watch_mode(
+            archetypes=watch_mode.archetypes,
+            skin=watch_mode.skin,
+            effects=watch_mode.effects,
+            particles=watch_mode.particles,
+            buckets=watch_mode.buckets,
+            rom=rom,
+            update_spawn=watch_mode.update_spawn,
+            config=config,
+            thread_pool=None,
+        )
+        preview_data = build_preview_mode(
+            archetypes=preview_mode.archetypes,
+            skin=preview_mode.skin,
+            rom=rom,
+            config=config,
+            thread_pool=None,
+        )
+        tutorial_data = build_tutorial_mode(
+            skin=tutorial_mode.skin,
+            effects=tutorial_mode.effects,
+            particles=tutorial_mode.particles,
+            instructions=tutorial_mode.instructions,
+            instruction_icons=tutorial_mode.instruction_icons,
+            preprocess=tutorial_mode.preprocess,
+            navigate=tutorial_mode.navigate,
+            update=tutorial_mode.update,
+            rom=rom,
+            config=config,
+            thread_pool=None,
+        )
+
     return PackagedEngine(
         configuration=package_output(configuration),
         play_data=package_output(play_data),
@@ -112,9 +206,18 @@ def build_play_mode(
     particles: Particles,
     buckets: Buckets,
     rom: ReadOnlyMemory,
+    config: BuildConfig,
+    thread_pool: Executor | None = None,
 ):
     return {
-        **compile_mode(mode=Mode.PLAY, rom=rom, archetypes=archetypes, global_callbacks=None),
+        **compile_mode(
+            mode=Mode.PLAY,
+            rom=rom,
+            archetypes=archetypes,
+            global_callbacks=None,
+            passes=config.passes,
+            thread_pool=thread_pool,
+        ),
         "skin": build_skin(skin),
         "effect": build_effects(effects),
         "particle": build_particles(particles),
@@ -130,10 +233,17 @@ def build_watch_mode(
     buckets: Buckets,
     rom: ReadOnlyMemory,
     update_spawn: Callable[[], float],
+    config: BuildConfig,
+    thread_pool: Executor | None = None,
 ):
     return {
         **compile_mode(
-            mode=Mode.WATCH, rom=rom, archetypes=archetypes, global_callbacks=[(update_spawn_callback, update_spawn)]
+            mode=Mode.WATCH,
+            rom=rom,
+            archetypes=archetypes,
+            global_callbacks=[(update_spawn_callback, update_spawn)],
+            passes=config.passes,
+            thread_pool=thread_pool,
         ),
         "skin": build_skin(skin),
         "effect": build_effects(effects),
@@ -146,9 +256,18 @@ def build_preview_mode(
     archetypes: list[type[_BaseArchetype]],
     skin: Skin,
     rom: ReadOnlyMemory,
+    config: BuildConfig,
+    thread_pool: Executor | None = None,
 ):
     return {
-        **compile_mode(mode=Mode.PREVIEW, rom=rom, archetypes=archetypes, global_callbacks=None),
+        **compile_mode(
+            mode=Mode.PREVIEW,
+            rom=rom,
+            archetypes=archetypes,
+            global_callbacks=None,
+            passes=config.passes,
+            thread_pool=thread_pool,
+        ),
         "skin": build_skin(skin),
     }
 
@@ -160,9 +279,11 @@ def build_tutorial_mode(
     instructions: TutorialInstructions,
     instruction_icons: TutorialInstructionIcons,
     preprocess: Callable[[], None],
-    navigate: Callable[[int], None],
+    navigate: Callable[[], None],
     update: Callable[[], None],
     rom: ReadOnlyMemory,
+    config: BuildConfig,
+    thread_pool: Executor | None = None,
 ):
     return {
         **compile_mode(
@@ -174,6 +295,8 @@ def build_tutorial_mode(
                 (navigate_callback, navigate),
                 (update_callback, update),
             ],
+            passes=config.passes,
+            thread_pool=thread_pool,
         ),
         "skin": build_skin(skin),
         "effect": build_effects(effects),
@@ -183,7 +306,10 @@ def build_tutorial_mode(
 
 
 def build_skin(skin: Skin) -> JsonValue:
-    return {"sprites": [{"name": name, "id": i} for i, name in enumerate(skin._sprites_)]}
+    return {
+        "renderMode": skin.render_mode,
+        "sprites": [{"name": name, "id": i} for i, name in enumerate(skin._sprites_)],
+    }
 
 
 def build_effects(effects: Effects) -> JsonValue:

sonolus/build/node.py

@@ -1,3 +1,4 @@
+from threading import Lock
 from typing import TypedDict
 
 from sonolus.backend.node import ConstantNode, EngineNode, FunctionNode
@@ -15,12 +16,18 @@ class FunctionOutputNode(TypedDict):
 class OutputNodeGenerator:
     nodes: list[ValueOutputNode | FunctionOutputNode]
     indexes: dict[EngineNode, int]
+    lock: Lock
 
     def __init__(self):
         self.nodes = []
         self.indexes = {}
+        self.lock = Lock()
 
     def add(self, node: EngineNode):
+        with self.lock:
+            return self._add(node)
+
+    def _add(self, node: EngineNode):
         if node in self.indexes:
             return self.indexes[node]
 
@@ -31,7 +38,7 @@ class OutputNodeGenerator:
                 self.indexes[node] = index
                 return index
             case FunctionNode(func, args):
-                arg_indexes = [self.add(arg) for arg in args]
+                arg_indexes = [self._add(arg) for arg in args]
                 index = len(self.nodes)
                 self.nodes.append({"func": func.value, "args": arg_indexes})
                 self.indexes[node] = index

sonolus/build/project.py

@@ -5,7 +5,7 @@ from sonolus.build.engine import package_engine
 from sonolus.build.level import package_level_data
 from sonolus.script.engine import Engine
 from sonolus.script.level import Level
-from sonolus.script.project import Project, ProjectSchema
+from sonolus.script.project import BuildConfig, Project, ProjectSchema
 
 BLANK_PNG = (
     b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x01\x00\x00\x00\x007n\xf9$"
@@ -17,24 +17,24 @@ BLANK_AUDIO = (
 )
 
 
-def build_project_to_collection(project: Project):
+def build_project_to_collection(project: Project, config: BuildConfig):
     collection = load_resources_files_to_collection(project.resources)
-    add_engine_to_collection(collection, project, project.engine)
+    add_engine_to_collection(collection, project, project.engine, config)
     for level in project.levels:
         add_level_to_collection(collection, project, level)
     collection.name = f"{project.engine.name}"
     return collection
 
 
-def add_engine_to_collection(collection: Collection, project: Project, engine: Engine):
-    packaged_engine = package_engine(engine.data)
+def add_engine_to_collection(collection: Collection, project: Project, engine: Engine, config: BuildConfig):
+    packaged_engine = package_engine(engine.data, config)
     item = {
         "name": engine.name,
         "version": engine.version,
         "title": engine.title,
         "subtitle": engine.subtitle,
         "author": engine.author,
-        "tags": [],
+        "tags": [tag.as_dict() for tag in engine.tags],
         "skin": collection.get_item("skins", engine.skin) if engine.skin else collection.get_default_item("skins"),
         "background": collection.get_item("backgrounds", engine.background)
         if engine.background
@@ -53,6 +53,8 @@ def add_engine_to_collection(collection: Collection, project: Project, engine: E
         "rom": collection.add_asset(packaged_engine.rom),
         "configuration": collection.add_asset(packaged_engine.configuration),
     }
+    if engine.description is not None:
+        item["description"] = engine.description
     collection.add_item("engines", engine.name, item)
 
 
@@ -65,16 +67,28 @@ def add_level_to_collection(collection: Collection, project: Project, level: Lev
         "title": level.title,
         "artists": level.artists,
         "author": level.author,
-        "tags": [],
+        "tags": [tag.as_dict() for tag in level.tags],
         "engine": collection.get_item("engines", project.engine.name),
-        "useSkin": {"useDefault": True},
-        "useBackground": {"useDefault": True},
-        "useEffect": {"useDefault": True},
-        "useParticle": {"useDefault": True},
+        "useSkin": {"useDefault": True}
+        if level.use_skin is None
+        else {"useDefault": False, "item": collection.get_item("skins", level.use_skin)},
+        "useBackground": {"useDefault": True}
+        if level.use_background is None
+        else {"useDefault": False, "item": collection.get_item("backgrounds", level.use_background)},
+        "useEffect": {"useDefault": True}
+        if level.use_effect is None
+        else {"useDefault": False, "item": collection.get_item("effects", level.use_effect)},
+        "useParticle": {"useDefault": True}
+        if level.use_particle is None
+        else {"useDefault": False, "item": collection.get_item("particles", level.use_particle)},
         "cover": load_resource(collection, level.cover, project.resources, BLANK_PNG),
         "bgm": load_resource(collection, level.bgm, project.resources, BLANK_AUDIO),
         "data": collection.add_asset(packaged_level_data),
     }
+    if level.description is not None:
+        item["description"] = level.description
+    if level.preview is not None:
+        item["preview"] = load_resource(collection, level.preview, project.resources, BLANK_AUDIO)
     collection.add_item("levels", level.name, item)
 
 
@@ -97,6 +111,7 @@ def load_resources_files_to_collection(base_path: Path) -> Collection:
 def get_project_schema(project: Project) -> ProjectSchema:
     by_archetype: dict[str, dict[str, bool]] = {}
     for archetype in project.engine.data.play.archetypes:
+        archetype._init_fields()
         fields = by_archetype.setdefault(archetype.name, {})
         # If a field is exported, we should exclude it if it's imported in watch mode
         for field in archetype._exported_keys_:
@@ -104,11 +119,15 @@ def get_project_schema(project: Project) -> ProjectSchema:
         for field in archetype._imported_keys_:
             fields[field] = True
     for archetype in project.engine.data.watch.archetypes:
+        archetype._init_fields()
         fields = by_archetype.setdefault(archetype.name, {})
         for field in archetype._imported_keys_:
+            if field in {"#ACCURACY", "#JUDGMENT"}:
+                continue
             if field not in fields:
                 fields[field] = True
     for archetype in project.engine.data.preview.archetypes:
+        archetype._init_fields()
         fields = by_archetype.setdefault(archetype.name, {})
         for field in archetype._imported_keys_:
             fields[field] = True