mini-arcade-native-backend 0.3.0__tar.gz → 0.3.2__tar.gz

mini_arcade_native_backend-0.3.2/.changelog_section

@@ -0,0 +1,11 @@
+## [0.3.2] - 2025-12-05
+
+### Added
+- add draw_rect_rgba method to Engine for RGBA rectangle drawing and update Python bindings
+- add capture_frame method to Engine and expose it in Python bindings
+- add clear color customization and update draw_rect method
+
+### Other
+- Merge branch 'release/0.3' of https://github.com/alexsc6955/mini-arcade-native-backend into release/0.3
+- Merge branch 'release/0.3' of https://github.com/alexsc6955/mini-arcade-native-backend into release/0.3
+

mini_arcade_native_backend-0.3.2/.version_to_tag

@@ -0,0 +1 @@
+0.3.2

{mini_arcade_native_backend-0.3.0 → mini_arcade_native_backend-0.3.2}/CHANGELOG.md

@@ -6,6 +6,26 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.3.2] - 2025-12-05
+
+### Added
+- add draw_rect_rgba method to Engine for RGBA rectangle drawing and update Python bindings
+- add capture_frame method to Engine and expose it in Python bindings
+- add clear color customization and update draw_rect method
+
+### Other
+- Merge branch 'release/0.3' of https://github.com/alexsc6955/mini-arcade-native-backend into release/0.3
+- Merge branch 'release/0.3' of https://github.com/alexsc6955/mini-arcade-native-backend into release/0.3
+
+## [0.3.1] - 2025-12-05
+
+### Added
+- add capture_frame method to Engine and expose it in Python bindings
+- add clear color customization and update draw_rect method
+
+### Other
+- Merge branch 'release/0.3' of https://github.com/alexsc6955/mini-arcade-native-backend into release/0.3
+
 ## [0.3.0] - 2025-12-05
 
 ### Added

{mini_arcade_native_backend-0.3.0 → mini_arcade_native_backend-0.3.2}/PKG-INFO

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

{mini_arcade_native_backend-0.3.0 → mini_arcade_native_backend-0.3.2}/cpp/bindings.cpp

@@ -27,15 +27,26 @@ PYBIND11_MODULE(_native, m) {
         .def("init", &mini::Engine::init,
                 py::arg("width"), py::arg("height"), 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("x"), py::arg("y"),
+                py::arg("w"), py::arg("h"),
+                py::arg("r"), py::arg("g"), py::arg("b"))
+
         .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"))
 
@@ -49,5 +60,8 @@ PYBIND11_MODULE(_native, m) {
                 py::arg("g"),
                 py::arg("b")
         )
-        .def("poll_events", &mini::Engine::poll_events);
+        .def("poll_events", &mini::Engine::poll_events)
+
+        .def("capture_frame", &mini::Engine::capture_frame,
+                py::arg("path"));
 }

{mini_arcade_native_backend-0.3.0 → mini_arcade_native_backend-0.3.2}/cpp/engine.cpp

@@ -9,7 +9,8 @@ namespace mini {
         : window_(nullptr),
             renderer_(nullptr),
             initialized_(false),
-            font_(nullptr)
+            font_(nullptr),
+            clear_color_{0, 0, 0, 255}
     {
     }
 
@@ -83,17 +84,40 @@ namespace mini {
             throw std::runtime_error(msg);
         }
 
+        // Enable alpha blending for RGBA drawing
+        SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
+
         initialized_ = true;
     }
 
+    void Engine::set_clear_color(int r, int g, int b)
+    {
+        auto clamp = [](int v) {
+            if (v < 0) return 0;
+            if (v > 255) return 255;
+            return v;
+        };
+
+        clear_color_.r = static_cast<Uint8>(clamp(r));
+        clear_color_.g = static_cast<Uint8>(clamp(g));
+        clear_color_.b = static_cast<Uint8>(clamp(b));
+        clear_color_.a = 255;
+    }
+
     void Engine::begin_frame()
     {
         if (!initialized_ || renderer_ == nullptr) {
             return;
         }
 
-        // Clear to black
-        SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 255);
+        // use stored clear color instead of hard-coded black
+        SDL_SetRenderDrawColor(
+            renderer_,
+            clear_color_.r,
+            clear_color_.g,
+            clear_color_.b,
+            clear_color_.a
+        );
         SDL_RenderClear(renderer_);
     }
 
@@ -106,21 +130,29 @@ namespace mini {
         SDL_RenderPresent(renderer_);
     }
 
-    void Engine::draw_rect(int x, int y, int w, int h)
+    void Engine::draw_rect(int x, int y, int w, int h, int r, int g, int b)
     {
         if (!initialized_ || renderer_ == nullptr) {
             return;
         }
 
-        SDL_Rect rect;
-        rect.x = x;
-        rect.y = y;
-        rect.w = w;
-        rect.h = h;
+        auto clamp = [](int v) {
+            if (v < 0) return 0;
+            if (v > 255) return 255;
+            return v;
+        };
+
+        SDL_Rect rect{ x, y, w, h };
 
-        // White rectangle for now (you can parameterize later).
-        SDL_SetRenderDrawColor(renderer_, 255, 255, 255, 255);
+        SDL_SetRenderDrawColor(
+            renderer_,
+            static_cast<Uint8>(clamp(r)),
+            static_cast<Uint8>(clamp(g)),
+            static_cast<Uint8>(clamp(b)),
+            255
+        );
         SDL_RenderFillRect(renderer_, &rect);
+
     }
 
     void Engine::draw_sprite(int /*texture_id*/, int /*x*/, int /*y*/, int /*w*/, int /*h*/)
@@ -187,6 +219,83 @@ 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) {
+            return false;
+        }
+
+        int width = 0;
+        int height = 0;
+        if (SDL_GetRendererOutputSize(renderer_, &width, &height) != 0) {
+            std::cerr << "SDL_GetRendererOutputSize Error: " << SDL_GetError() << std::endl;
+            return false;
+        }
+
+        // Create a surface to hold the pixels (32-bit RGBA)
+        SDL_Surface* surface = SDL_CreateRGBSurfaceWithFormat(
+            0,
+            width,
+            height,
+            32,
+            SDL_PIXELFORMAT_ARGB8888
+        );
+
+        if (!surface) {
+            std::cerr << "SDL_CreateRGBSurfaceWithFormat Error: " << SDL_GetError() << std::endl;
+            return false;
+        }
+
+        // Read pixels from the current render target into the surface
+        if (SDL_RenderReadPixels(
+                renderer_,
+                nullptr,                        // whole screen
+                surface->format->format,
+                surface->pixels,
+                surface->pitch) != 0)
+        {
+            std::cerr << "SDL_RenderReadPixels Error: " << SDL_GetError() << std::endl;
+            SDL_FreeSurface(surface);
+            return false;
+        }
+
+        // Save as BMP (simple, no extra dependencies).
+        // Use .bmp extension in the path you pass from Python.
+        if (SDL_SaveBMP(surface, path) != 0) {
+            std::cerr << "SDL_SaveBMP Error: " << SDL_GetError() << std::endl;
+            SDL_FreeSurface(surface);
+            return false;
+        }
+
+        SDL_FreeSurface(surface);
+        return true;
+    }
+
     std::vector<Event> Engine::poll_events()
     {
         std::vector<Event> events;

{mini_arcade_native_backend-0.3.0 → mini_arcade_native_backend-0.3.2}/cpp/engine.h

@@ -30,6 +30,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 clear color for the screen.
+        void set_clear_color(int r, int g, int b);
+
         // Clear the screen to a default color (black) and get ready to draw.
         void begin_frame();
 
@@ -37,7 +40,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);
+        void draw_rect(int x, int y, int w, int h, int r, int g, int b);
 
         // Sprite drawing stub for later.
         void draw_sprite(int texture_id, int x, int y, int w, int h);
@@ -51,11 +54,19 @@ namespace mini {
         // Draw text at specified position.
         void draw_text(const char* text, int x, int y, int r, int g, int b);
 
+        // 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);
+
     private:
         SDL_Window* window_;
         SDL_Renderer* renderer_;
         bool initialized_;
         TTF_Font* font_;
+        SDL_Color clear_color_;
     };
 
 } // namespace mini

{mini_arcade_native_backend-0.3.0 → mini_arcade_native_backend-0.3.2}/pyproject.toml

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

{mini_arcade_native_backend-0.3.0 → mini_arcade_native_backend-0.3.2}/src/mini_arcade_native_backend/__init__.py

@@ -69,6 +69,9 @@ class NativeBackend(Backend):
         if self._font_path is not None:
             self._engine.load_font(self._font_path, self._font_size)
 
+    def set_clear_color(self, r: int, g: int, b: int) -> None:
+        self._engine.set_clear_color(int(r), int(g), int(b))
+
     def poll_events(self) -> list[Event]:
         """
         Poll for events from the backend and return them as a list of Event objects.
@@ -91,7 +94,14 @@ class NativeBackend(Backend):
         """End the current frame for rendering."""
         self._engine.end_frame()
 
-    def draw_rect(self, x: int, y: int, w: int, h: int):
+    def draw_rect(
+        self,
+        x: int,
+        y: int,
+        w: int,
+        h: int,
+        color: tuple[int, ...] = (255, 255, 255),
+    ):
         """
         Draw a rectangle at the specified position with given width and height.
 
@@ -107,7 +117,16 @@ class NativeBackend(Backend):
         :param h: Height of the rectangle.
         :type h: int
         """
-        self._engine.draw_rect(x, y, w, h)
+        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}"
+            )
 
     def draw_text(
         self,
@@ -123,3 +142,6 @@ class NativeBackend(Backend):
         # We rely on C++ side to no-op if font is missing
         r, g, b = color
         self._engine.draw_text(text, x, y, int(r), int(g), int(b))
+
+    def capture_frame(self, path: str) -> bool:
+        return self._engine.capture_frame(path)

mini_arcade_native_backend-0.3.0/.changelog_section

@@ -1,9 +0,0 @@
-## [0.3.0] - 2025-12-05
-
-### Added
-- add text rendering support with SDL2_ttf integration
-
-### Other
-- Merge pull request #7 from alexsc6955/feature/text_support
-- Merge release/0.2 into develop
-

mini_arcade_native_backend-0.3.0/.version_to_tag

@@ -1 +0,0 @@
-0.3.0