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

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

@@ -6,6 +6,26 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.4.4] - 2025-12-16
+
+### Added
+- add measure_text method to Engine and expose it in NativeBackend
+- add alpha handling methods and refactor color extraction in NativeBackend
+- update draw_rect and draw_text methods to support alpha channel in color
+
+### Other
+- Merge branch 'release/0.4' of https://github.com/alexsc6955/mini-arcade-native-backend into release/0.4
+- Merge branch 'release/0.4' of https://github.com/alexsc6955/mini-arcade-native-backend into release/0.4
+
+## [0.4.3] - 2025-12-16
+
+### Added
+- add alpha handling methods and refactor color extraction in NativeBackend
+- update draw_rect and draw_text methods to support alpha channel in color
+
+### Other
+- Merge branch 'release/0.4' of https://github.com/alexsc6955/mini-arcade-native-backend into release/0.4
+
 ## [0.4.2] - 2025-12-16
 
 ### Added

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mini-arcade-native-backend
-Version: 0.4.2
+Version: 0.4.4
 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

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

@@ -55,17 +55,12 @@ PYBIND11_MODULE(_native, m) {
         .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("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("draw_rect_rgba", &mini::Engine::draw_rect_rgba,
-                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("load_font", &mini::Engine::load_font,
                 py::arg("path"), py::arg("pt_size"))
 
@@ -78,10 +73,17 @@ PYBIND11_MODULE(_native, m) {
                 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"));
+                py::arg("path"))
+        .def(
+        "measure_text",
+                &mini::Engine::measure_text,
+                py::arg("text"),
+                py::arg("font_id") = -1
+        );
 }

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

@@ -2,6 +2,8 @@
 
 #include <stdexcept>
 #include <iostream>
+#include <utility>
+#include <cstring>
 
 namespace mini {
 
@@ -11,7 +13,8 @@ namespace mini {
             initialized_(false),
             font_(nullptr),
             clear_color_{0, 0, 0, 255},
-            default_font_id_(-1)
+            default_font_id_(-1),
+            default_alpha_(255)
     {
     }
 
@@ -36,6 +39,15 @@ namespace mini {
             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)
@@ -133,7 +145,7 @@ namespace mini {
         SDL_RenderPresent(renderer_);
     }
 
-    void Engine::draw_rect(int x, int y, int w, int h, int r, int g, int b)
+    void Engine::draw_rect(int x, int y, int w, int h, int r, int g, int b, int a)
     {
         if (!initialized_ || renderer_ == nullptr) {
             return;
@@ -147,12 +159,15 @@ namespace mini {
 
         SDL_Rect rect{ x, y, w, h };
 
+        // alpha or default alpha
+        a = (a < 0) ? default_alpha_ : a;
+
         SDL_SetRenderDrawColor(
             renderer_,
             static_cast<Uint8>(clamp(r)),
             static_cast<Uint8>(clamp(g)),
             static_cast<Uint8>(clamp(b)),
-            255
+            static_cast<Uint8>(clamp(a))
         );
         SDL_RenderFillRect(renderer_, &rect);
 
@@ -187,7 +202,7 @@ namespace mini {
     }
 
     // Draw text at specified position.
-    void Engine::draw_text(const char* text, int x, int y, int r, int g, int b, int font_id)
+    void Engine::draw_text(const char* text, int x, int y, int r, int g, int b, int a, int font_id)
     {
         if (!initialized_ || renderer_ == nullptr) return;
 
@@ -202,7 +217,10 @@ namespace mini {
             return v;
         };
 
-        SDL_Color color = { (Uint8)clamp(r), (Uint8)clamp(g), (Uint8)clamp(b), 255 };
+
+        // alpha or default alpha
+        a = (a < 0) ? default_alpha_ : a;
+        SDL_Color color = { (Uint8)clamp(r), (Uint8)clamp(g), (Uint8)clamp(b), static_cast<Uint8>(clamp(a)) };
 
         SDL_Surface* surface = TTF_RenderUTF8_Blended(font, text, color);
         if (!surface) {
@@ -217,6 +235,9 @@ namespace mini {
             return;
         }
 
+        SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+        SDL_SetTextureAlphaMod(texture, static_cast<Uint8>(clamp(a)));
+
         SDL_Rect dstRect{ x, y, surface->w, surface->h };
         SDL_FreeSurface(surface);
 
@@ -224,30 +245,6 @@ namespace mini {
         SDL_DestroyTexture(texture);
     }
 
-    void Engine::draw_rect_rgba(int x, int y, int w, int h, int r, int g, int b, int a)
-    {
-        if (!initialized_ || renderer_ == nullptr) {
-            return;
-        }
-
-        auto clamp = [](int v) {
-            if (v < 0) return 0;
-            if (v > 255) return 255;
-            return v;
-        };
-
-        SDL_Rect rect{ x, y, w, h };
-
-        SDL_SetRenderDrawColor(
-            renderer_,
-            static_cast<Uint8>(clamp(r)),
-            static_cast<Uint8>(clamp(g)),
-            static_cast<Uint8>(clamp(b)),
-            static_cast<Uint8>(clamp(a))
-        );
-        SDL_RenderFillRect(renderer_, &rect);
-    }
-
     bool Engine::capture_frame(const char* path)
     {
         if (!initialized_ || renderer_ == nullptr) {
@@ -386,4 +383,26 @@ namespace mini {
         return events;
     }
 
+    std::pair<int, int> Engine::measure_text(const char* text, int font_id)
+    {
+        if (!initialized_) return {0, 0};
+
+        int idx = (font_id >= 0) ? font_id : default_font_id_;
+        if (idx < 0 || idx >= (int)fonts_.size() || fonts_[idx] == nullptr) return {0, 0};
+
+        if (text == nullptr || text[0] == '\0') return {0, 0};
+
+        int w = 0;
+        int h = 0;
+
+        // TTF_SizeUTF8 returns 0 on success, -1 on error
+        if (TTF_SizeUTF8(fonts_[idx], text, &w, &h) != 0) {
+            // Optional: log error
+            // std::cerr << "TTF_SizeUTF8 Error: " << TTF_GetError() << std::endl;
+            return {0, 0};
+        }
+
+        return {w, h};
+    }
+
 } // namespace mini

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

@@ -4,6 +4,7 @@
 #include <SDL_ttf.h>
 #include <vector>
 #include <string>
+#include <utility>
 
 // A minimal 2D graphics engine binding for Python using SDL.
 namespace mini {
@@ -71,7 +72,7 @@ namespace mini {
         void end_frame();
 
         // Draw a simple filled rectangle (we'll use a fixed color for now).
-        void draw_rect(int x, int y, int w, int h, int r, int g, int b);
+        void draw_rect(int x, int y, int w, int h, int r, int g, int b, int a);
 
         // Sprite drawing stub for later.
         void draw_sprite(int texture_id, int x, int y, int w, int h);
@@ -83,14 +84,15 @@ namespace mini {
         int load_font(const char* path, int pt_size);
 
         // Draw text at specified position.
-        void draw_text(const char* text, int x, int y, int r, int g, int b, int font_id = -1);
+        void draw_text(const char* text, int x, int y, int r, int g, int b, int a, int font_id = -1);
 
         // Capture the current frame into an image file (BMP for now).
         // Returns true on success, false on failure.
         bool capture_frame(const char* path);
 
-        // Draw a filled rectangle with RGBA color (supports transparency).
-        void draw_rect_rgba(int x, int y, int w, int h, int r, int g, int b, int a);
+        // Measure text (UTF-8) using a loaded font.
+        // 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);
 
     private:
         SDL_Window* window_; // The main application window.
@@ -100,6 +102,7 @@ namespace mini {
         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.
     };
 
 } // namespace mini

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

@@ -8,7 +8,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "mini-arcade-native-backend"
-version = "0.4.2"
+version = "0.4.4"
 description = "Native SDL2 backend for mini-arcade-core using SDL2 + pybind11."
 authors = [
   { name = "Santiago Rincon", email = "rincores@gmail.com" },

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

@@ -7,6 +7,7 @@ from __future__ import annotations
 import os
 import sys
 from pathlib import Path
+from typing import Union
 
 # --- 1) Make sure Windows can find SDL2.dll when using vcpkg ------------------
 
@@ -48,6 +49,7 @@ from . import _native as native
 
 __all__ = ["NativeBackend", "native"]
 
+Alpha = Union[float, int]
 
 _NATIVE_TO_CORE = {
     native.EventType.Unknown: EventType.UNKNOWN,
@@ -208,6 +210,43 @@ class NativeBackend(Backend):
         """End the current frame for rendering."""
         self._engine.end_frame()
 
+    @staticmethod
+    def _alpha_to_u8(alpha: Alpha | None) -> int:
+        """Convert CSS-like alpha (0..1) to uint8 (0..255)."""
+        if alpha is None:
+            return 255
+
+        # disallow booleans (since bool is a subclass of int)
+        if isinstance(alpha, bool):
+            raise TypeError("alpha must be a float in [0,1], not bool")
+
+        a = float(alpha)
+
+        # Enforce “percentage only”
+        if a < 0.0 or a > 1.0:
+            raise ValueError(f"alpha must be in [0, 1], got {alpha!r}")
+
+        return int(round(a * 255))
+
+    @staticmethod
+    def _get_color_values(color: tuple[int, ...]) -> int:
+        """
+        Extract alpha value from color tuple (r,g,b) or (r,g,b,a).
+        If missing, returns default.
+        """
+        if len(color) == 3:
+            r, g, b = color
+            a_u8 = 255
+        elif len(color) == 4:
+            r, g, b, a = color
+            a_u8 = NativeBackend._alpha_to_u8(a)
+        else:
+            raise ValueError(
+                f"Color must be (r,g,b) or (r,g,b,a), got {color!r}"
+            )
+
+        return (int(r), int(g), int(b), a_u8)
+
     # pylint: disable=too-many-arguments,too-many-positional-arguments
     def draw_rect(
         self,
@@ -235,16 +274,8 @@ class NativeBackend(Backend):
         :param color: Color of the rectangle as (r, g, b) or (r, g, b, a).
         :type color: tuple[int, ...]
         """
-        if len(color) == 3:
-            r, g, b = color
-            self._engine.draw_rect(x, y, w, h, r, g, b)
-        elif len(color) == 4:
-            r, g, b, a = color
-            self._engine.draw_rect_rgba(x, y, w, h, r, g, b, a)
-        else:
-            raise ValueError(
-                f"Color must be (r,g,b) or (r,g,b,a), got {color!r}"
-            )
+        r, g, b, a = self._get_color_values(color)
+        self._engine.draw_rect(x, y, w, h, r, g, b, a)
 
     # pylint: enable=too-many-arguments,too-many-positional-arguments
 
@@ -271,12 +302,13 @@ class NativeBackend(Backend):
         :param color: Color of the text as (r, g, b).
         :type color: tuple[int, int, int]
         """
-        # We rely on C++ side to no-op if font is missing
-        r, g, b = color
+        r, g, b, a = self._get_color_values(color)
         font_id = (
             self._default_font_id if self._default_font_id is not None else -1
         )
-        self._engine.draw_text(text, x, y, int(r), int(g), int(b), font_id)
+        self._engine.draw_text(
+            text, x, y, int(r), int(g), int(b), int(a), font_id
+        )
 
     def capture_frame(self, path: str | None = None) -> bool:
         """
@@ -289,4 +321,18 @@ class NativeBackend(Backend):
             False otherwise.
         :rtype: bool
         """
+        if path is None:
+            raise ValueError("Path must be provided to capture frame.")
         return self._engine.capture_frame(path)
+
+    def measure_text(self, text: str) -> tuple[int, int]:
+        """
+        Measure text size (width, height) in pixels for the active font.
+
+        Returns (0,0) if no font is loaded (matches draw_text no-op behavior).
+        """
+        font_id = (
+            self._default_font_id if self._default_font_id is not None else -1
+        )
+        w, h = self._engine.measure_text(text, font_id)
+        return int(w), int(h)

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

@@ -94,8 +94,8 @@ def setup_fake_core_and_native(monkeypatch):
         def end_frame(self):
             self.frames.append("end")
 
-        def draw_rect(self, x, y, w, h, r, g, b):
-            self.rects.append((x, y, w, h, r, g, b))
+        def draw_rect(self, x, y, w, h, r, g, b, a):
+            self.rects.append((x, y, w, h, r, g, b, a))
 
     fake_native.EventType = FakeNativeEventType
     fake_native.Engine = FakeEngine
@@ -248,7 +248,7 @@ def test_nativebackend_draw_rect_delegates_to_engine(backend_module):
     backend = pkg.NativeBackend()
     backend.draw_rect(10, 20, 30, 40, color=(255, 0, 0))
 
-    assert backend._engine.rects == [(10, 20, 30, 40, 255, 0, 0)]
+    assert backend._engine.rects == [(10, 20, 30, 40, 255, 0, 0, 255)]
 
 
 def test_poll_events_maps_native_events_to_core_events_and_keys(