mini-arcade-native-backend 0.4.0__tar.gz → 0.4.2__tar.gz

{mini_arcade_native_backend-0.4.0 → mini_arcade_native_backend-0.4.2}/CHANGELOG.md

@@ -6,6 +6,35 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.4.2] - 2025-12-16
+
+### Added
+- enhance event handling by adding key_code to event mapping in NativeBackend
+
+## [0.4.1] - 2025-12-15
+
+### Added
+- extend event handling with additional mouse and window events in engine and bindings
+- enhance font handling by returning font ID and updating draw_text signature
+
+### Fixed
+- update mini-arcade-core dependency version to ensure compatibility
+
+### Other
+- Merge release/0.3 into develop
+
+## [0.4.0] - 2025-12-15
+
+### Added
+- extend event handling with additional mouse and window events in engine and bindings
+- enhance font handling by returning font ID and updating draw_text signature
+
+### Fixed
+- update mini-arcade-core dependency version to ensure compatibility
+
+### Other
+- Merge release/0.3 into develop
+
 ## [0.3.3] - 2025-12-05
 
 ### Other

{mini_arcade_native_backend-0.4.0 → mini_arcade_native_backend-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mini-arcade-native-backend
-Version: 0.4.0
+Version: 0.4.2
 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.2.3
+Requires-Dist: mini-arcade-core~=0.9
 Provides-Extra: dev
 Requires-Dist: pytest~=8.3; extra == "dev"
 Requires-Dist: pytest-cov~=6.0; extra == "dev"

{mini_arcade_native_backend-0.4.0 → mini_arcade_native_backend-0.4.2}/cpp/bindings.cpp

@@ -14,12 +14,31 @@ PYBIND11_MODULE(_native, m) {
         .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("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")

{mini_arcade_native_backend-0.4.0 → mini_arcade_native_backend-0.4.2}/cpp/engine.cpp

@@ -10,7 +10,8 @@ namespace mini {
             renderer_(nullptr),
             initialized_(false),
             font_(nullptr),
-            clear_color_{0, 0, 0, 255}
+            clear_color_{0, 0, 0, 255},
+            default_font_id_(-1)
     {
     }
 
@@ -87,6 +88,8 @@ namespace mini {
         // Enable alpha blending for RGBA drawing
         SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
 
+        SDL_StartTextInput();   // <--- needed for SDL_TEXTINPUT
+
         initialized_ = true;
     }
 
@@ -245,7 +248,6 @@ namespace mini {
         SDL_RenderFillRect(renderer_, &rect);
     }
 
-
     bool Engine::capture_frame(const char* path)
     {
         if (!initialized_ || renderer_ == nullptr) {
@@ -305,8 +307,6 @@ namespace mini {
 
         while (SDL_PollEvent(&sdl_event)) {
             Event ev;
-            ev.type = EventType::Unknown;
-            ev.key = 0;
 
             switch (sdl_event.type) {
             case SDL_QUIT:
@@ -316,11 +316,63 @@ namespace mini {
             case SDL_KEYDOWN:
                 ev.type = EventType::KeyDown;
                 ev.key = sdl_event.key.keysym.sym;
+                ev.scancode = (int)sdl_event.key.keysym.scancode;
+                ev.mod = (int)sdl_event.key.keysym.mod;
+                ev.repeat = (int)sdl_event.key.repeat;
                 break;
 
             case SDL_KEYUP:
                 ev.type = EventType::KeyUp;
                 ev.key = sdl_event.key.keysym.sym;
+                ev.scancode = (int)sdl_event.key.keysym.scancode;
+                ev.mod = (int)sdl_event.key.keysym.mod;
+                ev.repeat = 0;
+                break;
+
+            case SDL_MOUSEMOTION:
+                ev.type = EventType::MouseMotion;
+                ev.x = sdl_event.motion.x;
+                ev.y = sdl_event.motion.y;
+                ev.dx = sdl_event.motion.xrel;
+                ev.dy = sdl_event.motion.yrel;
+                break;
+
+            case SDL_MOUSEBUTTONDOWN:
+                ev.type = EventType::MouseButtonDown;
+                ev.button = (int)sdl_event.button.button;
+                ev.x = sdl_event.button.x;
+                ev.y = sdl_event.button.y;
+                break;
+
+            case SDL_MOUSEBUTTONUP:
+                ev.type = EventType::MouseButtonUp;
+                ev.button = (int)sdl_event.button.button;
+                ev.x = sdl_event.button.x;
+                ev.y = sdl_event.button.y;
+                break;
+
+            case SDL_MOUSEWHEEL:
+                ev.type = EventType::MouseWheel;
+                ev.wheel_x = sdl_event.wheel.x;
+                ev.wheel_y = sdl_event.wheel.y;
+                // If you want "natural" direction handling, you can flip based on sdl_event.wheel.direction
+                break;
+
+            case SDL_TEXTINPUT:
+                ev.type = EventType::TextInput;
+                ev.text = sdl_event.text.text; // UTF-8
+                break;
+
+            case SDL_WINDOWEVENT:
+                if (sdl_event.window.event == SDL_WINDOWEVENT_RESIZED ||
+                    sdl_event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
+                {
+                    ev.type = EventType::WindowResized;
+                    ev.width = sdl_event.window.data1;
+                    ev.height = sdl_event.window.data2;
+                } else {
+                    continue; // ignore other window events
+                }
                 break;
 
             default:
@@ -328,7 +380,7 @@ namespace mini {
                 break;
             }
 
-            events.push_back(ev);
+            events.push_back(std::move(ev));
         }
 
         return events;

{mini_arcade_native_backend-0.4.0 → mini_arcade_native_backend-0.4.2}/cpp/engine.h

@@ -3,6 +3,7 @@
 #include <SDL.h>
 #include <SDL_ttf.h>
 #include <vector>
+#include <string>
 
 // A minimal 2D graphics engine binding for Python using SDL.
 namespace mini {
@@ -11,14 +12,44 @@ namespace mini {
     enum class EventType {
         Unknown = 0,
         Quit,
+
         KeyDown,
-        KeyUp
+        KeyUp,
+
+        MouseMotion,
+        MouseButtonDown,
+        MouseButtonUp,
+        MouseWheel,
+
+        WindowResized,
+        TextInput
     };
 
     // A simple event structure to pass events to Python.
     struct Event {
-        EventType type;
-        int key;  // SDL key code (e.g., 27 for ESC). 0 if not applicable.
+        EventType type = EventType::Unknown;
+
+        // Keyboard
+        int key = 0;       // SDL_Keycode
+        int scancode = 0;  // SDL_Scancode
+        int mod = 0;       // SDL_Keymod bitmask
+        int repeat = 0;    // 1 if key repeat, else 0
+
+        // Mouse
+        int x = 0;
+        int y = 0;
+        int dx = 0;        // motion relative
+        int dy = 0;
+        int button = 0;    // SDL_BUTTON_LEFT etc.
+        int wheel_x = 0;
+        int wheel_y = 0;
+
+        // Window
+        int width = 0;
+        int height = 0;
+
+        // Text input
+        std::string text;
     };
 
     // The main engine class that wraps SDL functionality.

{mini_arcade_native_backend-0.4.0 → mini_arcade_native_backend-0.4.2}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "mini-arcade-native-backend"
-version = "0.4.0"
+version = "0.4.2"
 description = "Native SDL2 backend for mini-arcade-core using SDL2 + pybind11."
 authors = [
   { name = "Santiago Rincon", email = "rincores@gmail.com" },
@@ -17,7 +17,7 @@ readme = "README.md"
 requires-python = ">=3.9,<3.12"
 license = { file = "LICENSE" }
 dependencies = [
-  "mini-arcade-core>=0.2.3",
+  "mini-arcade-core~=0.9",
 ]
 
 [project.optional-dependencies]

{mini_arcade_native_backend-0.4.0 → mini_arcade_native_backend-0.4.2}/src/mini_arcade_native_backend/__init__.py

@@ -37,6 +37,7 @@ if sys.platform == "win32":
 # Justification: Need to import core after setting DLL path on Windows
 # pylint: disable=wrong-import-position
 from mini_arcade_core import Backend, Event, EventType
+from mini_arcade_core.keymaps.sdl import SDL_KEYCODE_TO_KEY
 
 # Justification: Importing the native extension module
 # pylint: disable=import-self,no-name-in-module
@@ -53,6 +54,12 @@ _NATIVE_TO_CORE = {
     native.EventType.Quit: EventType.QUIT,
     native.EventType.KeyDown: EventType.KEYDOWN,
     native.EventType.KeyUp: EventType.KEYUP,
+    native.EventType.MouseMotion: EventType.MOUSEMOTION,
+    native.EventType.MouseButtonDown: EventType.MOUSEBUTTONDOWN,
+    native.EventType.MouseButtonUp: EventType.MOUSEBUTTONUP,
+    native.EventType.MouseWheel: EventType.MOUSEWHEEL,
+    native.EventType.WindowResized: EventType.WINDOWRESIZED,
+    native.EventType.TextInput: EventType.TEXTINPUT,
 }
 
 
@@ -108,6 +115,8 @@ class NativeBackend(Backend):
         """
         self._engine.set_clear_color(int(r), int(g), int(b))
 
+    # Justification: Many local variables needed for event mapping
+    # pylint: disable=too-many-locals
     def poll_events(self) -> list[Event]:
         """
         Poll for events from the backend and return them as a list of Event objects.
@@ -115,12 +124,81 @@ class NativeBackend(Backend):
         :return: List of Event objects representing the polled events.
         :rtype: list[Event]
         """
-        events: list[Event] = []
+        out: list[Event] = []
         for ev in self._engine.poll_events():
-            core_type = _NATIVE_TO_CORE.get(ev.type, EventType.UNKNOWN)
-            key = ev.key if getattr(ev, "key", 0) != 0 else None
-            events.append(Event(type=core_type, key=key))
-        return events
+            etype = _NATIVE_TO_CORE.get(ev.type, EventType.UNKNOWN)
+
+            key = None
+            key_code = None
+            scancode = None
+            mod = None
+            repeat = None
+
+            x = y = dx = dy = None
+            button = None
+            wheel = None
+            size = None
+            text = None
+
+            if etype in (EventType.KEYDOWN, EventType.KEYUP):
+                raw_key = int(getattr(ev, "key", 0) or 0)
+                key_code = raw_key if raw_key != 0 else None
+                key = SDL_KEYCODE_TO_KEY.get(raw_key) if raw_key != 0 else None
+
+                scancode = (
+                    int(ev.scancode) if getattr(ev, "scancode", 0) else None
+                )
+                mod = int(ev.mod) if getattr(ev, "mod", 0) else None
+
+                rep = int(getattr(ev, "repeat", 0) or 0)
+                repeat = bool(rep) if etype == EventType.KEYDOWN else None
+
+            elif etype == EventType.MOUSEMOTION:
+                x = int(ev.x)
+                y = int(ev.y)
+                dx = int(ev.dx)
+                dy = int(ev.dy)
+
+            elif etype in (EventType.MOUSEBUTTONDOWN, EventType.MOUSEBUTTONUP):
+                button = int(ev.button) if ev.button else None
+                x = int(ev.x)
+                y = int(ev.y)
+
+            elif etype == EventType.MOUSEWHEEL:
+                wx = int(ev.wheel_x)
+                wy = int(ev.wheel_y)
+                wheel = (wx, wy) if (wx or wy) else None
+
+            elif etype == EventType.WINDOWRESIZED:
+                w = int(ev.width)
+                h = int(ev.height)
+                size = (w, h) if (w and h) else None
+
+            elif etype == EventType.TEXTINPUT:
+                t = getattr(ev, "text", "")
+                text = t if t else None
+
+            out.append(
+                Event(
+                    type=etype,
+                    key=key,
+                    key_code=key_code,
+                    scancode=scancode,
+                    mod=mod,
+                    repeat=repeat,
+                    x=x,
+                    y=y,
+                    dx=dx,
+                    dy=dy,
+                    button=button,
+                    wheel=wheel,
+                    size=size,
+                    text=text,
+                )
+            )
+        return out
+
+    # pylint: enable=too-many-locals
 
     def begin_frame(self):
         """Begin a new frame for rendering."""

{mini_arcade_native_backend-0.4.0 → mini_arcade_native_backend-0.4.2}/tests/test_init.py

@@ -18,18 +18,34 @@ def setup_fake_core_and_native(monkeypatch):
     class FakeBackend:
         """Minimal base class just to satisfy inheritance."""
 
-        pass
-
     class FakeCoreEventType:
         UNKNOWN = "core_unknown"
         QUIT = "core_quit"
         KEYDOWN = "core_keydown"
         KEYUP = "core_keyup"
+        MOUSEMOTION = "core_mousemotion"
+        MOUSEBUTTONDOWN = "core_mousebuttondown"
+        MOUSEBUTTONUP = "core_mousebuttonup"
+        MOUSEWHEEL = "core_mousewheel"
+        WINDOWRESIZED = "core_windowresized"
+        TEXTINPUT = "core_textinput"
 
     @dataclass
     class FakeEvent:
         type: object
         key: object = None
+        key_code: object = None
+        x: object = None
+        y: object = None
+        dx: object = None
+        dy: object = None
+        button: object = None
+        wheel: object = None
+        size: object = None
+        text: object = None
+        scancode: object = None
+        mod: object = None
+        repeat: object = None
 
     fake_core.Backend = FakeBackend
     fake_core.Event = FakeEvent
@@ -37,6 +53,13 @@ def setup_fake_core_and_native(monkeypatch):
 
     sys.modules["mini_arcade_core"] = fake_core
 
+    fake_keymaps = types.ModuleType("mini_arcade_core.keymaps")
+    fake_sdl = types.ModuleType("mini_arcade_core.keymaps.sdl")
+    fake_sdl.SDL_KEYCODE_TO_KEY = {}  # or mapping your test expects
+
+    sys.modules["mini_arcade_core.keymaps"] = fake_keymaps
+    sys.modules["mini_arcade_core.keymaps.sdl"] = fake_sdl
+
     # --- Fake native extension: mini_arcade_native_backend._native -------------
     fake_native = types.ModuleType("mini_arcade_native_backend._native")
 
@@ -45,6 +68,12 @@ def setup_fake_core_and_native(monkeypatch):
         Quit = "native_quit"
         KeyDown = "native_keydown"
         KeyUp = "native_keyup"
+        MouseMotion = "native_mousemotion"
+        MouseButtonDown = "native_mousebuttondown"
+        MouseButtonUp = "native_mousebuttonup"
+        MouseWheel = "native_mousewheel"
+        WindowResized = "native_windowresized"
+        TextInput = "native_textinput"
 
     class FakeEngine:
         def __init__(self):
@@ -226,36 +255,85 @@ def test_poll_events_maps_native_events_to_core_events_and_keys(
     backend_module,
 ):
     pkg, fake_core, fake_native = backend_module
-
     backend = pkg.NativeBackend()
 
-    # Create fake native events
     @dataclass
     class FakeNativeEvent:
         type: object
         key: int = 0
+        key_code: int = 0
+        x: int = 0
+        y: int = 0
+        dx: int = 0
+        dy: int = 0
+        button: int = 0
+        wheel_x: int = 0
+        wheel_y: int = 0
+        width: int = 0
+        height: int = 0
+        text: str = ""
+        scancode: int = 0
+        mod: int = 0
+        repeat: int = 0
 
     engine = backend._engine
     engine._events_to_return = [
-        FakeNativeEvent(fake_native.EventType.Quit, 0),  # -> QUIT, key=None
+        FakeNativeEvent(fake_native.EventType.Quit),  # -> QUIT
         FakeNativeEvent(
-            fake_native.EventType.KeyDown, 32
+            fake_native.EventType.KeyDown, key=32
         ),  # -> KEYDOWN, key=32
-        FakeNativeEvent("something_unknown", 10),  # -> UNKNOWN, key=10
+        FakeNativeEvent(
+            fake_native.EventType.MouseMotion, x=10, y=20, dx=1, dy=-2
+        ),
+        FakeNativeEvent(
+            fake_native.EventType.MouseButtonDown, x=5, y=6, button=1
+        ),
+        FakeNativeEvent(
+            fake_native.EventType.MouseWheel, wheel_x=0, wheel_y=-1
+        ),
+        FakeNativeEvent(
+            fake_native.EventType.WindowResized, width=800, height=600
+        ),
+        FakeNativeEvent(fake_native.EventType.TextInput, text="á"),
+        FakeNativeEvent("something_unknown", key=10),  # -> UNKNOWN, key=10
     ]
 
     events = backend.poll_events()
+    assert len(events) == 8
 
-    assert len(events) == 3
-
-    # 1) Quit event, key==0 -> key should become None
+    # Quit: key 0 -> None
     assert events[0].type == fake_core.EventType.QUIT
     assert events[0].key is None
 
-    # 2) KeyDown, key!=0 passes through
+    # KeyDown: key passes through
     assert events[1].type == fake_core.EventType.KEYDOWN
-    assert events[1].key == 32
-
-    # 3) Unknown type -> UNKNOWN
-    assert events[2].type == fake_core.EventType.UNKNOWN
-    assert events[2].key == 10
+    assert events[1].key_code == 32
+
+    # MouseMotion: x/y/dx/dy mapped (0 becomes None; here non-zero)
+    assert events[2].type == fake_core.EventType.MOUSEMOTION
+    assert events[2].x == 10
+    assert events[2].y == 20
+    assert events[2].dx == 1
+    assert events[2].dy == -2
+
+    # MouseButtonDown
+    assert events[3].type == fake_core.EventType.MOUSEBUTTONDOWN
+    assert events[3].x == 5
+    assert events[3].y == 6
+    assert events[3].button == 1
+
+    # MouseWheel -> wheel tuple
+    assert events[4].type == fake_core.EventType.MOUSEWHEEL
+    assert events[4].wheel == (0, -1)
+
+    # WindowResized -> size tuple
+    assert events[5].type == fake_core.EventType.WINDOWRESIZED
+    assert events[5].size == (800, 600)
+
+    # TextInput -> text
+    assert events[6].type == fake_core.EventType.TEXTINPUT
+    assert events[6].text == "á"
+
+    # Unknown
+    assert events[7].type == fake_core.EventType.UNKNOWN
+    assert events[7].key_code is None