mini-arcade-native-backend 0.4.3__tar.gz → 0.4.5__tar.gz

{mini_arcade_native_backend-0.4.3 → mini_arcade_native_backend-0.4.5}/CHANGELOG.md

@@ -6,6 +6,22 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.4.5] - 2025-12-16
+
+### Added
+- implement font caching and update draw_text and measure_text methods to support dynamic font sizes
+
+## [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

{mini_arcade_native_backend-0.4.3 → mini_arcade_native_backend-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mini-arcade-native-backend
-Version: 0.4.3
+Version: 0.4.5
 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.3 → mini_arcade_native_backend-0.4.5}/cpp/bindings.cpp

@@ -79,5 +79,11 @@ PYBIND11_MODULE(_native, m) {
         .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.3 → mini_arcade_native_backend-0.4.5}/cpp/engine.cpp

@@ -2,6 +2,8 @@
 
 #include <stdexcept>
 #include <iostream>
+#include <utility>
+#include <cstring>
 
 namespace mini {
 
@@ -381,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.3 → mini_arcade_native_backend-0.4.5}/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 {
@@ -89,6 +90,10 @@ namespace mini {
         // Returns true on success, false on failure.
         bool capture_frame(const char* path);
 
+        // 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.
         SDL_Renderer* renderer_; // The renderer for drawing.

{mini_arcade_native_backend-0.4.3 → mini_arcade_native_backend-0.4.5}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "mini-arcade-native-backend"
-version = "0.4.3"
+version = "0.4.5"
 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.3 → mini_arcade_native_backend-0.4.5}/src/mini_arcade_native_backend/__init__.py

@@ -80,6 +80,33 @@ class NativeBackend(Backend):
         self._font_path = font_path
         self._font_size = font_size
         self._default_font_id: int | None = None
+        self._fonts_by_size: dict[int, int] = {}
+
+    def _get_font_id(self, font_size: int | None) -> int:
+        # No font loaded -> keep current “no-op” behavior
+        if self._font_path is None:
+            return -1
+
+        # Default font
+        if font_size is None:
+            return (
+                self._default_font_id
+                if self._default_font_id is not None
+                else -1
+            )
+
+        if font_size <= 0:
+            raise ValueError(f"font_size must be > 0, got {font_size}")
+
+        # Cached
+        cached = self._fonts_by_size.get(font_size)
+        if cached is not None:
+            return cached
+
+        # Lazily load and cache
+        font_id = self._engine.load_font(self._font_path, int(font_size))
+        self._fonts_by_size[font_size] = font_id
+        return font_id
 
     def init(self, width: int, height: int, title: str):
         """
@@ -101,6 +128,7 @@ class NativeBackend(Backend):
             self._default_font_id = self._engine.load_font(
                 self._font_path, self._font_size
             )
+            self._fonts_by_size[self._font_size] = self._default_font_id
 
     def set_clear_color(self, r: int, g: int, b: int):
         """
@@ -277,14 +305,13 @@ class NativeBackend(Backend):
         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
-
     def draw_text(
         self,
         x: int,
         y: int,
         text: str,
         color: tuple[int, int, int] = (255, 255, 255),
+        font_size: int | None = None,
     ):
         """
         Draw text at the given position using the loaded font.
@@ -303,13 +330,13 @@ class NativeBackend(Backend):
         :type color: tuple[int, int, int]
         """
         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
-        )
+        font_id = self._get_font_id(font_size)
         self._engine.draw_text(
             text, x, y, int(r), int(g), int(b), int(a), font_id
         )
 
+    # pylint: enable=too-many-arguments,too-many-positional-arguments
+
     def capture_frame(self, path: str | None = None) -> bool:
         """
         Capture the current frame.
@@ -324,3 +351,15 @@ class NativeBackend(Backend):
         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, font_size: int | None = None
+    ) -> 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._get_font_id(font_size)
+        w, h = self._engine.measure_text(text, font_id)
+        return int(w), int(h)