mini-arcade-native-backend 0.4.6__tar.gz → 0.5.3__tar.gz

{mini_arcade_native_backend-0.4.6 → mini_arcade_native_backend-0.5.3}/.github/workflows/ci.yml

@@ -19,7 +19,7 @@ jobs:
     with:
       project-name: "mini-arcade-native-backend"
       lint-path: "src/mini_arcade_native_backend"
-      apt-deps: "libsdl2-dev libsdl2-ttf-dev"
+      apt-deps: "libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev"
     secrets:
       SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
       SLACK_CHANNEL_ID: ${{ secrets.SLACK_CHANNEL_ID }}

{mini_arcade_native_backend-0.4.6 → mini_arcade_native_backend-0.5.3}/.github/workflows/release-publish.yml

@@ -17,7 +17,7 @@ jobs:
     with:
       release_branch: ${{ inputs.release_branch }}
       version_file: "pyproject.toml"
-      apt-deps: "libsdl2-dev libsdl2-ttf-dev"
+      apt-deps: "libsdl2-dev libsdl2-ttf-dev libsdl2-mixer-dev"
       poetry-build-args: "-f sdist"
       build_wheels: true
     secrets:

{mini_arcade_native_backend-0.4.6 → mini_arcade_native_backend-0.5.3}/CHANGELOG.md

@@ -6,6 +6,46 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.5.3] - 2026-01-23
+
+- Internal changes only.
+
+## [0.5.2] - 2026-01-23
+
+### Added
+- add window resizing and clipping functions to Engine and update bindings
+- add audio management functions to Engine and integrate with NativeBackend
+
+### Fixed
+- update apt dependencies to include libsdl2-mixer-dev for CI and release workflows
+
+### Changed
+- add TODO for backend interface refactoring to improve structure
+
+## [0.5.1] - 2026-01-23
+
+### Added
+- add window resizing and clipping functions to Engine and update bindings
+- add audio management functions to Engine and integrate with NativeBackend
+
+### Fixed
+- update apt dependencies to include libsdl2-mixer-dev for CI and release workflows
+
+### Changed
+- add TODO for backend interface refactoring to improve structure
+
+## [0.5.0] - 2026-01-21
+
+### Added
+- add set_window_title method to Engine and update init method to accept optional title
+
+### Fixed
+- Update dependencies and improve import handling for mini-arcade-core
+- update import statements for Event and SDL_KEYCODE_TO_KEY to improve clarity
+
+### Other
+- Merge branch 'develop' into release/0.5
+
 ## [0.4.6] - 2025-12-26
 
 ### Fixed

{mini_arcade_native_backend-0.4.6 → mini_arcade_native_backend-0.5.3}/CMakeLists.txt

@@ -10,6 +10,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 find_package(pybind11 CONFIG REQUIRED)
 find_package(SDL2 CONFIG REQUIRED)
 find_package(SDL2_ttf CONFIG REQUIRED)
+find_package(SDL2_mixer CONFIG REQUIRED) 
 
 set(TARGET_NAME _native)
 
@@ -19,7 +20,7 @@ pybind11_add_module(${TARGET_NAME}
     cpp/engine.cpp
 )
 
-target_link_libraries(${TARGET_NAME} PRIVATE SDL2::SDL2 SDL2_ttf::SDL2_ttf)
+target_link_libraries(${TARGET_NAME} PRIVATE SDL2::SDL2 SDL2_ttf::SDL2_ttf SDL2_mixer::SDL2_mixer)
 
 # Install the compiled extension into the Python package directory
 # so it ends up as mini_arcade_native_backend/_native.*.pyd

{mini_arcade_native_backend-0.4.6 → mini_arcade_native_backend-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mini-arcade-native-backend
-Version: 0.4.6
+Version: 0.5.3
 Summary: Native SDL2 backend for mini-arcade-core using SDL2 + pybind11.
 Author-Email: Santiago Rincon <rincores@gmail.com>
 License: Copyright (c) 2025 Santiago Rincón
@@ -24,7 +24,7 @@ License: Copyright (c) 2025 Santiago Rincón
            SOFTWARE.
          
 Requires-Python: <3.12,>=3.9
-Requires-Dist: mini-arcade-core~=0.10
+Requires-Dist: mini-arcade-core~=1.0
 Provides-Extra: dev
 Requires-Dist: pytest~=8.3; extra == "dev"
 Requires-Dist: pytest-cov~=6.0; extra == "dev"

mini_arcade_native_backend-0.5.3/cpp/bindings.cpp

@@ -0,0 +1,126 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>   // so std::vector<Event> becomes a Python list
+
+#include "engine.h"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(_native, m) {
+        m.doc() = "Mini arcade native SDL2 backend";
+
+        // Bind the EventType enum
+        py::enum_<mini::EventType>(m, "EventType")
+                .value("Unknown", mini::EventType::Unknown)
+                .value("Quit", mini::EventType::Quit)
+                .value("KeyDown", mini::EventType::KeyDown)
+                .value("KeyUp", mini::EventType::KeyUp)
+                .value("MouseMotion", mini::EventType::MouseMotion)
+                .value("MouseButtonDown", mini::EventType::MouseButtonDown)
+                .value("MouseButtonUp", mini::EventType::MouseButtonUp)
+                .value("MouseWheel", mini::EventType::MouseWheel)
+                .value("WindowResized", mini::EventType::WindowResized)
+                .value("TextInput", mini::EventType::TextInput)
+                .export_values();
+
+        // Bind the Event struct
+        py::class_<mini::Event>(m, "Event")
+                .def_readonly("type", &mini::Event::type)
+                .def_readonly("key", &mini::Event::key)
+                .def_readonly("scancode", &mini::Event::scancode)
+                .def_readonly("mod", &mini::Event::mod)
+                .def_readonly("repeat", &mini::Event::repeat)
+                .def_readonly("x", &mini::Event::x)
+                .def_readonly("y", &mini::Event::y)
+                .def_readonly("dx", &mini::Event::dx)
+                .def_readonly("dy", &mini::Event::dy)
+                .def_readonly("button", &mini::Event::button)
+                .def_readonly("wheel_x", &mini::Event::wheel_x)
+                .def_readonly("wheel_y", &mini::Event::wheel_y)
+                .def_readonly("width", &mini::Event::width)
+                .def_readonly("height", &mini::Event::height)
+                .def_readonly("text", &mini::Event::text);
+
+        // Bind the Engine class
+        py::class_<mini::Engine>(m, "Engine")
+                .def(py::init<>())
+                .def("init", &mini::Engine::init,
+                        py::arg("width"), py::arg("height"), py::arg("title"))
+
+
+                .def("set_window_title", &mini::Engine::set_window_title,
+                        py::arg("title"))
+
+                .def("set_clear_color", &mini::Engine::set_clear_color,
+                        py::arg("r"), py::arg("g"), py::arg("b"))
+
+                .def("begin_frame", &mini::Engine::begin_frame)
+                .def("end_frame", &mini::Engine::end_frame)
+
+                .def("draw_rect", &mini::Engine::draw_rect,
+                        py::arg("x"), py::arg("y"),
+                        py::arg("w"), py::arg("h"),
+                        py::arg("r"), py::arg("g"), py::arg("b"), py::arg("a"))
+
+                .def("draw_sprite", &mini::Engine::draw_sprite,
+                        py::arg("texture_id"), py::arg("x"), py::arg("y"),
+                        py::arg("w"), py::arg("h"))
+
+                .def("load_font", &mini::Engine::load_font,
+                        py::arg("path"), py::arg("pt_size"))
+
+                .def(
+                        "draw_text",
+                        &mini::Engine::draw_text,
+                                py::arg("text"),
+                                py::arg("x"),
+                                py::arg("y"),
+                                py::arg("r"),
+                                py::arg("g"),
+                                py::arg("b"),
+                                py::arg("a"),
+                                py::arg("font_id") = -1
+                )
+                .def("poll_events", &mini::Engine::poll_events)
+
+                .def("capture_frame", &mini::Engine::capture_frame,
+                        py::arg("path"))
+                .def(
+                "measure_text",
+                        &mini::Engine::measure_text,
+                        py::arg("text"),
+                        py::arg("font_id") = -1
+                )
+
+                .def("init_audio", &mini::Engine::init_audio,
+                        py::arg("frequency") = 44100,
+                        py::arg("channels") = 2,
+                        py::arg("chunk_size") = 2048)
+
+                .def("shutdown_audio", &mini::Engine::shutdown_audio) 
+
+                .def("load_sound", &mini::Engine::load_sound,
+                        py::arg("sound_id"),
+                        py::arg("path"))
+
+                .def("play_sound", &mini::Engine::play_sound,
+                        py::arg("sound_id"),
+                        py::arg("loops") = 0)
+
+                .def("set_master_volume", &mini::Engine::set_master_volume,
+                        py::arg("volume"))
+
+                .def("set_sound_volume", &mini::Engine::set_sound_volume,
+                        py::arg("sound_id"),
+                        py::arg("volume"))
+
+                .def("stop_all_sounds", &mini::Engine::stop_all_sounds)
+                .def("resize_window", &mini::Engine::resize_window,
+                        py::arg("width"),
+                        py::arg("height"))
+                .def("set_clip_rect", &mini::Engine::set_clip_rect,
+                        py::arg("x"),
+                        py::arg("y"),
+                        py::arg("w"),
+                        py::arg("h"))
+                .def("clear_clip_rect", &mini::Engine::clear_clip_rect);
+}

{mini_arcade_native_backend-0.4.6 → mini_arcade_native_backend-0.5.3}/cpp/engine.cpp

@@ -11,7 +11,6 @@ namespace mini {
         : window_(nullptr),
             renderer_(nullptr),
             initialized_(false),
-            font_(nullptr),
             clear_color_{0, 0, 0, 255},
             default_font_id_(-1),
             default_alpha_(255)
@@ -20,10 +19,12 @@ namespace mini {
 
     Engine::~Engine()
     {
-        if (font_ != nullptr) {
-            TTF_CloseFont(font_);
-            font_ = nullptr;
+        shutdown_audio();
+
+        for (TTF_Font* f : fonts_) {
+            if (f) TTF_CloseFont(f);
         }
+        fonts_.clear();
 
         if (renderer_ != nullptr) {
             SDL_DestroyRenderer(renderer_);
@@ -35,19 +36,14 @@ namespace mini {
             window_ = nullptr;
         }
 
+        SDL_StopTextInput();
+
         if (initialized_) {
+            TTF_Quit();
             SDL_Quit();
             initialized_ = false;
         }
 
-        for (TTF_Font* f : fonts_) {
-            if (f) TTF_CloseFont(f);
-        }
-        fonts_.clear();
-
-        TTF_Quit();
-        SDL_StopTextInput();
-
     }
 
     void Engine::init(int width, int height, const char* title)
@@ -72,7 +68,7 @@ namespace mini {
             SDL_WINDOWPOS_CENTERED,
             width,
             height,
-            SDL_WINDOW_SHOWN
+            SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_RESIZABLE
         );
 
         if (window_ == nullptr) {
@@ -87,6 +83,7 @@ namespace mini {
             -1,
             SDL_RENDERER_ACCELERATED
         );
+        // SDL_RenderSetLogicalSize(renderer_, width, height);
 
         if (renderer_ == nullptr) {
             std::string msg = std::string("SDL_CreateRenderer Error: ") + SDL_GetError();
@@ -105,6 +102,12 @@ namespace mini {
         initialized_ = true;
     }
 
+    void Engine::set_window_title(const char* title)
+    {
+        if (!initialized_ || !window_) return;
+        SDL_SetWindowTitle(window_, title ? title : "");
+    }
+
     void Engine::set_clear_color(int r, int g, int b)
     {
         auto clamp = [](int v) {
@@ -302,6 +305,21 @@ namespace mini {
         std::vector<Event> events;
         SDL_Event sdl_event;
 
+        auto scale_mouse = [&](int &x, int &y, int &dx, int &dy) {
+            int ww=0, wh=0, rw=0, rh=0;
+            SDL_GetWindowSize(window_, &ww, &wh);
+            SDL_GetRendererOutputSize(renderer_, &rw, &rh);
+
+            if (ww > 0 && wh > 0) {
+                float sx = (float)rw / (float)ww;
+                float sy = (float)rh / (float)wh;
+                x  = (int)lroundf(x  * sx);
+                y  = (int)lroundf(y  * sy);
+                dx = (int)lroundf(dx * sx);
+                dy = (int)lroundf(dy * sy);
+            }
+        };
+
         while (SDL_PollEvent(&sdl_event)) {
             Event ev;
 
@@ -332,6 +350,7 @@ namespace mini {
                 ev.y = sdl_event.motion.y;
                 ev.dx = sdl_event.motion.xrel;
                 ev.dy = sdl_event.motion.yrel;
+                scale_mouse(ev.x, ev.y, ev.dx, ev.dy);
                 break;
 
             case SDL_MOUSEBUTTONDOWN:
@@ -346,6 +365,7 @@ namespace mini {
                 ev.button = (int)sdl_event.button.button;
                 ev.x = sdl_event.button.x;
                 ev.y = sdl_event.button.y;
+                scale_mouse(ev.x, ev.y, ev.dx, ev.dy);
                 break;
 
             case SDL_MOUSEWHEEL:
@@ -365,8 +385,14 @@ namespace mini {
                     sdl_event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
                 {
                     ev.type = EventType::WindowResized;
-                    ev.width = sdl_event.window.data1;
-                    ev.height = sdl_event.window.data2;
+                    int rw=0, rh=0;
+                    if (renderer_ && SDL_GetRendererOutputSize(renderer_, &rw, &rh) == 0) {
+                        ev.width = rw;
+                        ev.height = rh;
+                    } else {
+                        ev.width = sdl_event.window.data1;
+                        ev.height = sdl_event.window.data2;
+                    }
                 } else {
                     continue; // ignore other window events
                 }
@@ -405,4 +431,140 @@ namespace mini {
         return {w, h};
     }
 
+    void Engine::init_audio(int frequency, int channels, int chunk_size)
+    {
+        if (audio_initialized_) return;
+
+        // Make sure SDL audio subsystem is enabled
+        if ((SDL_WasInit(SDL_INIT_AUDIO) & SDL_INIT_AUDIO) == 0) {
+            if (SDL_InitSubSystem(SDL_INIT_AUDIO) != 0) {
+                throw std::runtime_error(std::string("SDL_InitSubSystem(AUDIO) Error: ") + SDL_GetError());
+            }
+        }
+
+        if (Mix_OpenAudio(frequency, MIX_DEFAULT_FORMAT, channels, chunk_size) != 0) {
+            throw std::runtime_error(std::string("Mix_OpenAudio Error: ") + Mix_GetError());
+        }
+
+        // Optional: allow OGG/MP3 decoding if you want
+        // Mix_Init(MIX_INIT_OGG | MIX_INIT_MP3);
+
+        Mix_AllocateChannels(16);           // plenty for pong
+        Mix_Volume(-1, master_volume_);     // -1 = all channels
+
+        audio_initialized_ = true;
+    }
+
+    void Engine::shutdown_audio()
+    {
+        if (!audio_initialized_) return;
+
+        stop_all_sounds();
+
+        for (auto& kv : sounds_) {
+            if (kv.second) {
+                Mix_FreeChunk(kv.second);
+            }
+        }
+        sounds_.clear();
+
+        Mix_CloseAudio();
+        // Mix_Quit(); // if you used Mix_Init
+
+        audio_initialized_ = false;
+    }
+
+    void Engine::load_sound(const std::string& sound_id, const std::string& path)
+    {
+        if (!audio_initialized_) {
+            // auto-init so Python doesn't need to care
+            init_audio();
+        }
+
+        if (sound_id.empty()) {
+            throw std::runtime_error("load_sound: sound_id is empty");
+        }
+
+        // If already loaded, free it first (support hot reload)
+        auto it = sounds_.find(sound_id);
+        if (it != sounds_.end() && it->second) {
+            Mix_FreeChunk(it->second);
+            it->second = nullptr;
+        }
+
+        Mix_Chunk* chunk = Mix_LoadWAV(path.c_str());
+        if (!chunk) {
+            throw std::runtime_error(std::string("Mix_LoadWAV Error: ") + Mix_GetError());
+        }
+
+        sounds_[sound_id] = chunk;
+    }
+
+    void Engine::play_sound(const std::string& sound_id, int loops)
+    {
+        if (!audio_initialized_) {
+            init_audio();
+        }
+
+        auto it = sounds_.find(sound_id);
+        if (it == sounds_.end() || it->second == nullptr) {
+            // be forgiving: if not preloaded, just do nothing
+            // (or throw if you want strict behavior)
+            return;
+        }
+
+        Mix_Chunk* chunk = it->second;
+
+        // -1 channel = pick first free channel
+        Mix_PlayChannel(-1, chunk, loops);
+    }
+
+    void Engine::set_master_volume(int volume)
+    {
+        if (volume < 0) volume = 0;
+        if (volume > MIX_MAX_VOLUME) volume = MIX_MAX_VOLUME;
+
+        master_volume_ = volume;
+        Mix_Volume(-1, master_volume_); // all channels
+    }
+
+    void Engine::set_sound_volume(const std::string& sound_id, int volume)
+    {
+        if (volume < 0) volume = 0;
+        if (volume > MIX_MAX_VOLUME) volume = MIX_MAX_VOLUME;
+
+        auto it = sounds_.find(sound_id);
+        if (it == sounds_.end() || it->second == nullptr) return;
+
+        Mix_VolumeChunk(it->second, volume);
+    }
+
+    void Engine::stop_all_sounds()
+    {
+        Mix_HaltChannel(-1);
+    }
+
+    void Engine::resize_window(int width, int height)
+    {
+        if (!initialized_ || !window_) return;
+        SDL_SetWindowSize(window_, width, height);
+
+        // if (renderer_) {
+        //     SDL_RenderSetLogicalSize(renderer_, width, height);
+        // }
+    }
+
+    void Engine::set_clip_rect(int x, int y, int w, int h)
+    {
+        if (!initialized_ || renderer_ == nullptr) return;
+        SDL_Rect r{ x, y, w, h };
+        SDL_RenderSetClipRect(renderer_, &r);
+    }
+
+    void Engine::clear_clip_rect()
+    {
+        if (!initialized_ || renderer_ == nullptr) return;
+        SDL_RenderSetClipRect(renderer_, nullptr);
+    }
+
 } // namespace mini

{mini_arcade_native_backend-0.4.6 → mini_arcade_native_backend-0.5.3}/cpp/engine.h

@@ -2,6 +2,8 @@
 
 #include <SDL.h>
 #include <SDL_ttf.h>
+#include <SDL_mixer.h>
+#include <unordered_map>
 #include <vector>
 #include <string>
 #include <utility>
@@ -62,6 +64,9 @@ namespace mini {
         // Initialize the engine with a window of given width, height, and title.
         void init(int width, int height, const char* title);
 
+        // Set the window title.
+        void set_window_title(const char* title);
+
         // Set the clear color for the screen.
         void set_clear_color(int r, int g, int b);
 
@@ -94,15 +99,41 @@ namespace mini {
         // Returns (width, height) in pixels. Returns (0,0) if no valid font or error.
         std::pair<int, int> measure_text(const char* text, int font_id = -1);
 
+        // --- Audio ---
+        // Initialize audio subsystem.
+        void init_audio(int frequency = 44100, int channels = 2, int chunk_size = 2048);
+        // Shutdown audio subsystem.
+        void shutdown_audio();
+
+        // Load, play, and manage sounds.
+        void load_sound(const std::string& sound_id, const std::string& path);
+        // Play a loaded sound by its ID.
+        void play_sound(const std::string& sound_id, int loops = 0);
+        // Set the volume for a specific sound (0..128).
+        void set_sound_volume(const std::string& sound_id, int volume); // 0..128
+        // Set the master volume for all sounds (0..128).
+        void set_master_volume(int volume); // 0..128
+        // Stop all currently playing sounds.
+        void stop_all_sounds();
+
+        // Resize the application window.
+        void resize_window(int width, int height);
+        // Set clipping rectangle for rendering.
+        void set_clip_rect(int x, int y, int w, int h);
+        // Clear clipping rectangle (disable clipping).
+        void clear_clip_rect();
+
     private:
         SDL_Window* window_; // The main application window.
         SDL_Renderer* renderer_; // The renderer for drawing.
         bool initialized_; // Whether the engine has been initialized.
-        TTF_Font* font_; // The current font for text rendering.
         SDL_Color clear_color_; // The clear color for the screen.
         std::vector<TTF_Font*> fonts_; // Loaded fonts.
         int default_font_id_; // Default font index.
         int default_alpha_; // Default alpha value for drawing.
+        bool audio_initialized_ = false; // Whether audio subsystem is initialized.
+        int master_volume_ = MIX_MAX_VOLUME; // 128 is max volume
+        std::unordered_map<std::string, Mix_Chunk*> sounds_; // Audio data
     };
 
 } // namespace mini