mini-arcade-native-backend 0.2.3__tar.gz → 0.3.1__tar.gz

mini_arcade_native_backend-0.3.1/.changelog_section

@@ -0,0 +1,9 @@
+## [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
+

{mini_arcade_native_backend-0.2.3 → mini_arcade_native_backend-0.3.1}/.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"
+      apt-deps: "libsdl2-dev libsdl2-ttf-dev"
     secrets:
       SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
       SLACK_CHANNEL_ID: ${{ secrets.SLACK_CHANNEL_ID }}

mini_arcade_native_backend-0.3.1/.github/workflows/release-finalize.yml

@@ -0,0 +1,20 @@
+name: Finalize Release
+
+permissions:
+  contents: write
+
+on:
+  workflow_dispatch:
+    inputs:
+      release_branch_suffix:
+        description: "Release suffix (e.g. 0.6 for branch release/0.6)"
+        required: true
+        type: string
+
+jobs:
+  finalize-release:
+    uses: trivox-io/trivox-ci/.github/workflows/finalize-release.yml@main
+    with:
+      release_branch_suffix: ${{ inputs.release_branch_suffix }}
+      main_branch: "main"
+      develop_branch: "develop"

mini_arcade_native_backend-0.3.1/.version_to_tag

@@ -0,0 +1 @@
+0.3.1

mini_arcade_native_backend-0.3.1/.vscode/settings.json

@@ -0,0 +1,53 @@
+{
+    "files.associations": {
+        "system_error": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "cctype": "cpp",
+        "charconv": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "exception": "cpp",
+        "format": "cpp",
+        "initializer_list": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "iterator": "cpp",
+        "limits": "cpp",
+        "locale": "cpp",
+        "memory": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "utility": "cpp",
+        "vector": "cpp",
+        "xfacet": "cpp",
+        "xiosbase": "cpp",
+        "xlocale": "cpp",
+        "xlocbuf": "cpp",
+        "xlocinfo": "cpp",
+        "xlocmes": "cpp",
+        "xlocmon": "cpp",
+        "xlocnum": "cpp",
+        "xloctime": "cpp",
+        "xmemory": "cpp",
+        "xstring": "cpp",
+        "xtr1common": "cpp",
+        "xutility": "cpp"
+    }
+}

{mini_arcade_native_backend-0.2.3 → mini_arcade_native_backend-0.3.1}/CHANGELOG.md

@@ -6,6 +6,24 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [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
+- add text rendering support with SDL2_ttf integration
+
+### Other
+- Merge pull request #7 from alexsc6955/feature/text_support
+- Merge release/0.2 into develop
+
 ## [0.2.3] - 2025-12-04
 
 - Internal changes only.

{mini_arcade_native_backend-0.2.3 → mini_arcade_native_backend-0.3.1}/CMakeLists.txt

@@ -9,6 +9,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 find_package(pybind11 CONFIG REQUIRED)
 find_package(SDL2 CONFIG REQUIRED)
+find_package(SDL2_ttf CONFIG REQUIRED)
 
 set(TARGET_NAME _native)
 
@@ -18,7 +19,7 @@ pybind11_add_module(${TARGET_NAME}
     cpp/engine.cpp
 )
 
-target_link_libraries(${TARGET_NAME} PRIVATE SDL2::SDL2)
+target_link_libraries(${TARGET_NAME} PRIVATE SDL2::SDL2 SDL2_ttf::SDL2_ttf)
 
 # 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.2.3 → mini_arcade_native_backend-0.3.1}/PKG-INFO

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

@@ -25,13 +25,38 @@ PYBIND11_MODULE(_native, m) {
     py::class_<mini::Engine>(m, "Engine")
         .def(py::init<>())
         .def("init", &mini::Engine::init,
-             py::arg("width"), py::arg("height"), py::arg("title"))
+                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("poll_events", &mini::Engine::poll_events);
+                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")
+        )
+        .def("poll_events", &mini::Engine::poll_events)
+
+        .def("capture_frame", &mini::Engine::capture_frame,
+                py::arg("path"));
 }

mini_arcade_native_backend-0.3.1/cpp/engine.cpp

@@ -0,0 +1,307 @@
+#include "engine.h"
+
+#include <stdexcept>
+#include <iostream>
+
+namespace mini {
+
+    Engine::Engine()
+        : window_(nullptr),
+            renderer_(nullptr),
+            initialized_(false),
+            font_(nullptr),
+            clear_color_{0, 0, 0, 255}
+    {
+    }
+
+    Engine::~Engine()
+    {
+        if (font_ != nullptr) {
+            TTF_CloseFont(font_);
+            font_ = nullptr;
+        }
+
+        if (renderer_ != nullptr) {
+            SDL_DestroyRenderer(renderer_);
+            renderer_ = nullptr;
+        }
+
+        if (window_ != nullptr) {
+            SDL_DestroyWindow(window_);
+            window_ = nullptr;
+        }
+
+        if (initialized_) {
+            SDL_Quit();
+            initialized_ = false;
+        }
+    }
+
+    void Engine::init(int width, int height, const char* title)
+    {
+        if (initialized_) {
+            return; // already initialized
+        }
+
+        if (SDL_Init(SDL_INIT_VIDEO) != 0) {
+            throw std::runtime_error(std::string("SDL_Init Error: ") + SDL_GetError());
+        }
+
+        if (TTF_Init() != 0) {
+            std::string msg = std::string("TTF_Init Error: ") + TTF_GetError();
+            SDL_Quit();
+            throw std::runtime_error(msg);
+        }
+
+        window_ = SDL_CreateWindow(
+            title,
+            SDL_WINDOWPOS_CENTERED,
+            SDL_WINDOWPOS_CENTERED,
+            width,
+            height,
+            SDL_WINDOW_SHOWN
+        );
+
+        if (window_ == nullptr) {
+            std::string msg = std::string("SDL_CreateWindow Error: ") + SDL_GetError();
+            TTF_Quit();
+            SDL_Quit();
+            throw std::runtime_error(msg);
+        }
+
+        renderer_ = SDL_CreateRenderer(
+            window_,
+            -1,
+            SDL_RENDERER_ACCELERATED
+        );
+
+        if (renderer_ == nullptr) {
+            std::string msg = std::string("SDL_CreateRenderer Error: ") + SDL_GetError();
+            SDL_DestroyWindow(window_);
+            window_ = nullptr;
+            TTF_Quit();
+            SDL_Quit();
+            throw std::runtime_error(msg);
+        }
+
+        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;
+        }
+
+        // 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_);
+    }
+
+    void Engine::end_frame()
+    {
+        if (!initialized_ || renderer_ == nullptr) {
+            return;
+        }
+
+        SDL_RenderPresent(renderer_);
+    }
+
+    void Engine::draw_rect(int x, int y, int w, int h, int r, int g, int b)
+    {
+        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)),
+            255
+        );
+        SDL_RenderFillRect(renderer_, &rect);
+
+    }
+
+    void Engine::draw_sprite(int /*texture_id*/, int /*x*/, int /*y*/, int /*w*/, int /*h*/)
+    {
+        // TODO: placeholder for later texture management.
+    }
+
+    // Load a TTF font from file at specified point size.
+    void Engine::load_font(const char* path, int pt_size)
+    {
+        if (!initialized_) {
+            throw std::runtime_error("Engine::init must be called before load_font");
+        }
+
+        if (font_ != nullptr) {
+            TTF_CloseFont(font_);
+            font_ = nullptr;
+        }
+
+        font_ = TTF_OpenFont(path, pt_size);
+        if (!font_) {
+            std::string msg = std::string("TTF_OpenFont Error: ") + TTF_GetError();
+            throw std::runtime_error(msg);
+        }
+    }
+
+    // Draw text at specified position.
+    void Engine::draw_text(const char* text, int x, int y, int r, int g, int b)
+    {
+        if (!initialized_ || renderer_ == nullptr || font_ == nullptr) {
+            return;
+        }
+
+        // clamp a bit to be safe
+        auto clamp = [](int v) {
+            if (v < 0) return 0;
+            if (v > 255) return 255;
+            return v;
+        };
+
+        SDL_Color color = { (Uint8)clamp(r), (Uint8)clamp(g), (Uint8)clamp(b), 255 }; // white text
+        SDL_Surface* surface = TTF_RenderUTF8_Blended(font_, text, color);
+        if (!surface) {
+            std::cerr << "TTF_RenderUTF8_Blended Error: " << TTF_GetError() << std::endl;
+            return;
+        }
+
+        SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer_, surface);
+        if (!texture) {
+            std::cerr << "SDL_CreateTextureFromSurface Error: " << SDL_GetError() << std::endl;
+            SDL_FreeSurface(surface);
+            return;
+        }
+
+        SDL_Rect dstRect;
+        dstRect.x = x;
+        dstRect.y = y;
+        dstRect.w = surface->w;
+        dstRect.h = surface->h;
+
+        SDL_FreeSurface(surface);
+
+        SDL_RenderCopy(renderer_, texture, nullptr, &dstRect);
+        SDL_DestroyTexture(texture);
+    }
+
+    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;
+        SDL_Event sdl_event;
+
+        while (SDL_PollEvent(&sdl_event)) {
+            Event ev;
+            ev.type = EventType::Unknown;
+            ev.key = 0;
+
+            switch (sdl_event.type) {
+            case SDL_QUIT:
+                ev.type = EventType::Quit;
+                break;
+
+            case SDL_KEYDOWN:
+                ev.type = EventType::KeyDown;
+                ev.key = sdl_event.key.keysym.sym;
+                break;
+
+            case SDL_KEYUP:
+                ev.type = EventType::KeyUp;
+                ev.key = sdl_event.key.keysym.sym;
+                break;
+
+            default:
+                ev.type = EventType::Unknown;
+                break;
+            }
+
+            events.push_back(ev);
+        }
+
+        return events;
+    }
+
+} // namespace mini

{mini_arcade_native_backend-0.2.3 → mini_arcade_native_backend-0.3.1}/cpp/engine.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <SDL.h>
+#include <SDL_ttf.h>
 #include <vector>
 
 // A minimal 2D graphics engine binding for Python using SDL.
@@ -29,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();
 
@@ -36,18 +40,30 @@ 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);
 
         // Poll all pending events and return them.
         std::vector<Event> poll_events();
+        
+        // Load a TTF font from file at specified point size.
+        void 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);
+
+        // Capture the current frame into an image file (BMP for now).
+        // Returns true on success, false on failure.
+        bool capture_frame(const char* path);
 
     private:
         SDL_Window* window_;
         SDL_Renderer* renderer_;
         bool initialized_;
+        TTF_Font* font_;
+        SDL_Color clear_color_;
     };
 
 } // namespace mini

{mini_arcade_native_backend-0.2.3 → mini_arcade_native_backend-0.3.1}/pyproject.toml

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

{mini_arcade_native_backend-0.2.3 → mini_arcade_native_backend-0.3.1}/src/mini_arcade_native_backend/__init__.py

@@ -45,8 +45,10 @@ _NATIVE_TO_CORE = {
 class NativeBackend(Backend):
     """Adapter that makes the C++ Engine usable as a mini-arcade backend."""
 
-    def __init__(self):
+    def __init__(self, font_path: str | None = None, font_size: int = 24):
         self._engine = native.Engine()
+        self._font_path = font_path
+        self._font_size = font_size
 
     def init(self, width: int, height: int, title: str):
         """
@@ -63,6 +65,13 @@ class NativeBackend(Backend):
         """
         self._engine.init(width, height, title)
 
+        # Load font if provided
+        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.
@@ -85,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, int, int] = (255, 255, 255),
+    ):
         """
         Draw a rectangle at the specified position with given width and height.
 
@@ -101,4 +117,23 @@ class NativeBackend(Backend):
         :param h: Height of the rectangle.
         :type h: int
         """
-        self._engine.draw_rect(x, y, w, h)
+        r, g, b = color
+        self._engine.draw_rect(x, y, w, h, int(r), int(g), int(b))
+
+    def draw_text(
+        self,
+        x: int,
+        y: int,
+        text: str,
+        color: tuple[int, int, int] = (255, 255, 255),
+    ) -> None:
+        """
+        Draw text at the given position using the loaded font.
+        If no font is loaded, this is a no-op.
+        """
+        # 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.2.3/.changelog_section

@@ -1,4 +0,0 @@
-## [0.2.3] - 2025-12-04
-
-- Internal changes only.
-

mini_arcade_native_backend-0.2.3/.version_to_tag

@@ -1 +0,0 @@
-0.2.3

mini_arcade_native_backend-0.2.3/.vscode/settings.json

@@ -1,5 +0,0 @@
-{
-    "files.associations": {
-        "system_error": "cpp"
-    }
-}

mini_arcade_native_backend-0.2.3/cpp/engine.cpp

@@ -1,153 +0,0 @@
-#include "engine.h"
-
-#include <stdexcept>
-#include <iostream>
-
-namespace mini {
-
-    Engine::Engine()
-        : window_(nullptr),
-          renderer_(nullptr),
-          initialized_(false)
-    {
-    }
-
-    Engine::~Engine()
-    {
-        if (renderer_ != nullptr) {
-            SDL_DestroyRenderer(renderer_);
-            renderer_ = nullptr;
-        }
-
-        if (window_ != nullptr) {
-            SDL_DestroyWindow(window_);
-            window_ = nullptr;
-        }
-
-        if (initialized_) {
-            SDL_Quit();
-            initialized_ = false;
-        }
-    }
-
-    void Engine::init(int width, int height, const char* title)
-    {
-        if (initialized_) {
-            return; // already initialized
-        }
-
-        if (SDL_Init(SDL_INIT_VIDEO) != 0) {
-            throw std::runtime_error(std::string("SDL_Init Error: ") + SDL_GetError());
-        }
-
-        window_ = SDL_CreateWindow(
-            title,
-            SDL_WINDOWPOS_CENTERED,
-            SDL_WINDOWPOS_CENTERED,
-            width,
-            height,
-            SDL_WINDOW_SHOWN
-        );
-
-        if (window_ == nullptr) {
-            std::string msg = std::string("SDL_CreateWindow Error: ") + SDL_GetError();
-            SDL_Quit();
-            throw std::runtime_error(msg);
-        }
-
-        renderer_ = SDL_CreateRenderer(
-            window_,
-            -1,
-            SDL_RENDERER_ACCELERATED
-        );
-
-        if (renderer_ == nullptr) {
-            std::string msg = std::string("SDL_CreateRenderer Error: ") + SDL_GetError();
-            SDL_DestroyWindow(window_);
-            window_ = nullptr;
-            SDL_Quit();
-            throw std::runtime_error(msg);
-        }
-
-        initialized_ = true;
-    }
-
-    void Engine::begin_frame()
-    {
-        if (!initialized_ || renderer_ == nullptr) {
-            return;
-        }
-
-        // Clear to black
-        SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 255);
-        SDL_RenderClear(renderer_);
-    }
-
-    void Engine::end_frame()
-    {
-        if (!initialized_ || renderer_ == nullptr) {
-            return;
-        }
-
-        SDL_RenderPresent(renderer_);
-    }
-
-    void Engine::draw_rect(int x, int y, int w, int h)
-    {
-        if (!initialized_ || renderer_ == nullptr) {
-            return;
-        }
-
-        SDL_Rect rect;
-        rect.x = x;
-        rect.y = y;
-        rect.w = w;
-        rect.h = h;
-
-        // White rectangle for now (you can parameterize later).
-        SDL_SetRenderDrawColor(renderer_, 255, 255, 255, 255);
-        SDL_RenderFillRect(renderer_, &rect);
-    }
-
-    void Engine::draw_sprite(int /*texture_id*/, int /*x*/, int /*y*/, int /*w*/, int /*h*/)
-    {
-        // TODO: placeholder for later texture management.
-    }
-
-    std::vector<Event> Engine::poll_events()
-    {
-        std::vector<Event> events;
-        SDL_Event sdl_event;
-
-        while (SDL_PollEvent(&sdl_event)) {
-            Event ev;
-            ev.type = EventType::Unknown;
-            ev.key = 0;
-
-            switch (sdl_event.type) {
-            case SDL_QUIT:
-                ev.type = EventType::Quit;
-                break;
-
-            case SDL_KEYDOWN:
-                ev.type = EventType::KeyDown;
-                ev.key = sdl_event.key.keysym.sym;
-                break;
-
-            case SDL_KEYUP:
-                ev.type = EventType::KeyUp;
-                ev.key = sdl_event.key.keysym.sym;
-                break;
-
-            default:
-                ev.type = EventType::Unknown;
-                break;
-            }
-
-            events.push_back(ev);
-        }
-
-        return events;
-    }
-
-} // namespace mini