pixzig 0.13.0__py3-none-win_amd64.whl

pixzig/__init__.py

@@ -0,0 +1,13 @@
+from ._native import PixzigError
+from .app import PixzigApp
+from .constants import GamepadAxis, GamepadButton, Key, MouseAxis, MouseButton
+
+__all__ = [
+    "PixzigApp",
+    "PixzigError",
+    "Key",
+    "MouseButton",
+    "MouseAxis",
+    "GamepadButton",
+    "GamepadAxis",
+]

pixzig/_native.py

@@ -0,0 +1,221 @@
+"""Low-level ctypes bindings to libpixzig_ffi.
+
+Internal module: game code should use the classes in `pixzig` (App, Sprite,
+shapes, text, input, keyboard/mouse/gamepad, constants) instead of calling
+anything here directly.
+"""
+import ctypes
+import os
+import sys
+
+
+class PixzigError(Exception):
+    """Raised when a pixzig engine call fails."""
+
+
+def _library_filename() -> str:
+    if sys.platform == "darwin":
+        return "libpixzig_ffi.dylib"
+    if sys.platform == "win32":
+        return "pixzig_ffi.dll"
+    return "libpixzig_ffi.so"
+
+
+def _find_library() -> str:
+    name = _library_filename()
+    here = os.path.dirname(os.path.abspath(__file__))
+    candidates = [
+        os.path.join(here, name),
+        os.path.join(here, "..", "..", "zig-out", "python", name),
+    ]
+    for path in candidates:
+        if os.path.exists(path):
+            return path
+    raise OSError(
+        f"Could not find {name}. Build it with 'zig build python-ffi' from "
+        f"the pixzig repo root, or place a copy next to {__file__}."
+    )
+
+
+_lib = ctypes.CDLL(_find_library())
+
+
+class _PzEngine(ctypes.Structure):
+    """Opaque engine handle; never inspected from Python."""
+
+
+PzEnginePtr = ctypes.POINTER(_PzEngine)
+
+
+class _PzSprite(ctypes.Structure):
+    """Opaque sprite handle; never inspected from Python."""
+
+
+PzSpritePtr = ctypes.POINTER(_PzSprite)
+
+
+class _PzCamera(ctypes.Structure):
+    """Opaque camera handle; never inspected from Python."""
+
+
+PzCameraPtr = ctypes.POINTER(_PzCamera)
+
+
+class _PzTilemapRenderer(ctypes.Structure):
+    """Opaque tilemap renderer handle; never inspected from Python."""
+
+
+PzTilemapRendererPtr = ctypes.POINTER(_PzTilemapRenderer)
+
+
+class _PzAssetManifest(ctypes.Structure):
+    """Opaque asset manifest handle; never inspected from Python."""
+
+
+PzAssetManifestPtr = ctypes.POINTER(_PzAssetManifest)
+
+
+class _PzActionMap(ctypes.Structure):
+    """Opaque action map handle; never inspected from Python."""
+
+
+PzActionMapPtr = ctypes.POINTER(_PzActionMap)
+
+
+def _sig(name, argtypes, restype):
+    fn = getattr(_lib, name)
+    fn.argtypes = argtypes
+    fn.restype = restype
+    return fn
+
+
+def last_error() -> str:
+    msg = _lib.pz_last_error()
+    return msg.decode("utf-8") if msg else "unknown error"
+
+
+def check(ok: bool) -> None:
+    """Raises PixzigError with the engine's last error message if `ok` is falsy."""
+    if not ok:
+        raise PixzigError(last_error())
+
+
+c_float = ctypes.c_float
+c_int = ctypes.c_int
+c_int32 = ctypes.c_int32
+c_uint8 = ctypes.c_uint8
+c_bool = ctypes.c_bool
+c_char_p = ctypes.c_char_p
+
+# --- Lifecycle ---------------------------------------------------------
+pz_last_error = _sig("pz_last_error", [], c_char_p)
+pz_init = _sig("pz_init", [c_char_p, c_int32, c_int32], PzEnginePtr)
+pz_deinit = _sig("pz_deinit", [PzEnginePtr], None)
+
+# --- Frame stepping ------------------------------------------------------
+pz_should_close = _sig("pz_should_close", [PzEnginePtr], c_bool)
+pz_poll_events = _sig("pz_poll_events", [PzEnginePtr], None)
+pz_update_input = _sig("pz_update_input", [PzEnginePtr], None)
+pz_swap_buffers = _sig("pz_swap_buffers", [PzEnginePtr], None)
+pz_render_begin = _sig("pz_render_begin", [PzEnginePtr], None)
+pz_render_begin_world = _sig("pz_render_begin_world", [PzEnginePtr, PzCameraPtr], None)
+pz_render_clear = _sig("pz_render_clear", [PzEnginePtr, c_float, c_float, c_float, c_float], None)
+pz_render_end = _sig("pz_render_end", [PzEnginePtr], None)
+
+# --- Input ---------------------------------------------------------------
+pz_key_down = _sig("pz_key_down", [PzEnginePtr, c_int], c_bool)
+pz_key_pressed = _sig("pz_key_pressed", [PzEnginePtr, c_int], c_bool)
+pz_key_released = _sig("pz_key_released", [PzEnginePtr, c_int], c_bool)
+pz_mouse_pos = _sig("pz_mouse_pos", [PzEnginePtr, ctypes.POINTER(c_float), ctypes.POINTER(c_float)], None)
+pz_mouse_button_down = _sig("pz_mouse_button_down", [PzEnginePtr, c_int], c_bool)
+pz_mouse_button_pressed = _sig("pz_mouse_button_pressed", [PzEnginePtr, c_int], c_bool)
+pz_mouse_button_released = _sig("pz_mouse_button_released", [PzEnginePtr, c_int], c_bool)
+pz_gamepad_connected = _sig("pz_gamepad_connected", [PzEnginePtr, c_int], c_bool)
+pz_gamepad_button_down = _sig("pz_gamepad_button_down", [PzEnginePtr, c_int, c_int], c_bool)
+pz_gamepad_button_pressed = _sig("pz_gamepad_button_pressed", [PzEnginePtr, c_int, c_int], c_bool)
+pz_gamepad_button_released = _sig("pz_gamepad_button_released", [PzEnginePtr, c_int, c_int], c_bool)
+pz_gamepad_axis = _sig("pz_gamepad_axis", [PzEnginePtr, c_int, c_int], c_float)
+
+# --- Resources -------------------------------------------------------------
+pz_load_texture = _sig("pz_load_texture", [PzEnginePtr, c_char_p, c_char_p], c_int32)
+pz_texture_sub = _sig("pz_texture_sub", [PzEnginePtr, c_char_p, c_char_p, c_int32, c_int32, c_int32, c_int32], c_int32)
+pz_load_font = _sig("pz_load_font", [PzEnginePtr, c_char_p, c_char_p, c_float], c_int32)
+pz_set_default_font = _sig("pz_set_default_font", [PzEnginePtr, c_char_p], c_int32)
+
+# --- Sprites -----------------------------------------------------------
+pz_sprite_create = _sig("pz_sprite_create", [PzEnginePtr, c_char_p], PzSpritePtr)
+pz_sprite_set_pos = _sig("pz_sprite_set_pos", [PzSpritePtr, c_int32, c_int32], None)
+pz_sprite_get_rect = _sig(
+    "pz_sprite_get_rect",
+    [PzSpritePtr, ctypes.POINTER(c_float), ctypes.POINTER(c_float), ctypes.POINTER(c_float), ctypes.POINTER(c_float)],
+    None,
+)
+pz_sprite_draw = _sig("pz_sprite_draw", [PzSpritePtr], None)
+pz_sprite_destroy = _sig("pz_sprite_destroy", [PzSpritePtr], None)
+
+# --- Camera ----------------------------------------------------------------
+pz_camera_create = _sig("pz_camera_create", [PzEnginePtr], PzCameraPtr)
+pz_camera_destroy = _sig("pz_camera_destroy", [PzCameraPtr], None)
+pz_camera_set_pos = _sig("pz_camera_set_pos", [PzCameraPtr, c_float, c_float], None)
+pz_camera_get_pos = _sig("pz_camera_get_pos", [PzCameraPtr, ctypes.POINTER(c_float), ctypes.POINTER(c_float)], None)
+pz_camera_set_zoom = _sig("pz_camera_set_zoom", [PzCameraPtr, c_float], None)
+pz_camera_get_zoom = _sig("pz_camera_get_zoom", [PzCameraPtr], c_float)
+pz_camera_set_bounds = _sig("pz_camera_set_bounds", [PzCameraPtr, c_float, c_float, c_float, c_float], None)
+pz_camera_clear_bounds = _sig("pz_camera_clear_bounds", [PzCameraPtr], None)
+
+# --- Tilemap -----------------------------------------------------------
+pz_load_tilemap = _sig("pz_load_tilemap", [PzEnginePtr, c_char_p, c_char_p], c_int32)
+pz_tilemap_renderer_create = _sig(
+    "pz_tilemap_renderer_create", [PzEnginePtr, c_char_p, c_char_p], PzTilemapRendererPtr
+)
+pz_tilemap_renderer_destroy = _sig("pz_tilemap_renderer_destroy", [PzTilemapRendererPtr], None)
+pz_tilemap_pixel_size = _sig(
+    "pz_tilemap_pixel_size",
+    [PzTilemapRendererPtr, c_int32, ctypes.POINTER(c_float), ctypes.POINTER(c_float)],
+    None,
+)
+pz_tilemap_render = _sig("pz_tilemap_render", [PzTilemapRendererPtr, PzCameraPtr], None)
+pz_tilemap_render_below = _sig("pz_tilemap_render_below", [PzTilemapRendererPtr, PzCameraPtr, c_float], None)
+pz_tilemap_render_above = _sig("pz_tilemap_render_above", [PzTilemapRendererPtr, PzCameraPtr, c_float], None)
+pz_tilemap_check_reload = _sig("pz_tilemap_check_reload", [PzTilemapRendererPtr], c_bool)
+
+# --- Asset manifests ---------------------------------------------------
+pz_manifest_load = _sig("pz_manifest_load", [PzEnginePtr, c_char_p], PzAssetManifestPtr)
+pz_manifest_load_group = _sig("pz_manifest_load_group", [PzAssetManifestPtr, c_char_p], c_int32)
+pz_manifest_unload_group = _sig("pz_manifest_unload_group", [PzAssetManifestPtr, c_char_p], None)
+pz_manifest_destroy = _sig("pz_manifest_destroy", [PzAssetManifestPtr], None)
+
+# --- Action maps ---------------------------------------------------------
+pz_action_map_create = _sig("pz_action_map_create", [PzEnginePtr], PzActionMapPtr)
+pz_action_map_destroy = _sig("pz_action_map_destroy", [PzActionMapPtr], None)
+pz_action_map_update = _sig("pz_action_map_update", [PzActionMapPtr, ctypes.c_double], None)
+pz_action_bind_key = _sig("pz_action_bind_key", [PzActionMapPtr, c_int32, c_int], c_int32)
+pz_action_bind_mouse_button = _sig("pz_action_bind_mouse_button", [PzActionMapPtr, c_int32, c_int], c_int32)
+pz_action_bind_gamepad_button = _sig("pz_action_bind_gamepad_button", [PzActionMapPtr, c_int32, c_int], c_int32)
+pz_action_bind_axis_buttons = _sig(
+    "pz_action_bind_axis_buttons", [PzActionMapPtr, c_int32, c_int, c_int], c_int32
+)
+pz_action_bind_axis_gamepad = _sig(
+    "pz_action_bind_axis_gamepad", [PzActionMapPtr, c_int32, c_int, c_float], c_int32
+)
+pz_action_bind_axis_mouse = _sig(
+    "pz_action_bind_axis_mouse", [PzActionMapPtr, c_int32, c_int, c_float, c_float], c_int32
+)
+pz_action_up = _sig("pz_action_up", [PzActionMapPtr, c_int32], c_bool)
+pz_action_down = _sig("pz_action_down", [PzActionMapPtr, c_int32], c_bool)
+pz_action_pressed = _sig("pz_action_pressed", [PzActionMapPtr, c_int32], c_bool)
+pz_action_released = _sig("pz_action_released", [PzActionMapPtr, c_int32], c_bool)
+pz_action_axis = _sig("pz_action_axis", [PzActionMapPtr, c_int32], c_float)
+
+# --- Shapes and text -----------------------------------------------------
+pz_draw_filled_rect = _sig(
+    "pz_draw_filled_rect",
+    [PzEnginePtr, c_float, c_float, c_float, c_float, c_float, c_float, c_float, c_float],
+    None,
+)
+pz_draw_rect = _sig(
+    "pz_draw_rect",
+    [PzEnginePtr, c_float, c_float, c_float, c_float, c_float, c_float, c_float, c_float, c_uint8],
+    None,
+)
+pz_draw_string = _sig("pz_draw_string", [PzEnginePtr, c_char_p, c_int32, c_int32], None)

pixzig/action.py

@@ -0,0 +1,120 @@
+"""Action mapping: bind named actions/axes to physical inputs, then query
+them by name instead of checking raw keyboard/mouse/gamepad state directly.
+Create via `PixzigApp.create_action_map()`.
+
+    actions = app.create_action_map()
+    actions.bind_key("jump", Key.SPACE)
+    actions.bind_gamepad_button("jump", GamepadButton.A)
+    actions.bind_axis_buttons("move_x", Key.A, Key.D)
+
+    # once per update tick:
+    actions.update()
+    if actions.pressed("jump"): ...
+    dx = actions.axis("move_x")
+
+Multiple bindings on the same action are OR'ed together; multiple bindings
+on the same axis accumulate (sum). Action/axis names are arbitrary strings
+assigned to internal slots on first use in a `bind_*` call -- there's a
+fixed capacity (64 actions, 32 axes) shared with the underlying engine.
+"""
+from . import _native as _n
+
+
+class ActionMap:
+    def __init__(self, handle):
+        self._handle = handle
+        self._destroyed = False
+        self._action_slots: dict[str, int] = {}
+        self._axis_slots: dict[str, int] = {}
+
+    def _check_alive(self) -> None:
+        if self._destroyed:
+            raise _n.PixzigError("action map already destroyed")
+
+    def _slot_for_bind(self, slots: dict, name: str, max_slots: int, kind: str) -> int:
+        slot = slots.get(name)
+        if slot is not None:
+            return slot
+        if len(slots) >= max_slots:
+            raise _n.PixzigError(f"too many {kind}s bound (max {max_slots})")
+        slot = len(slots)
+        slots[name] = slot
+        return slot
+
+    def _slot_for_query(self, slots: dict, name: str, kind: str) -> int:
+        slot = slots.get(name)
+        if slot is None:
+            raise _n.PixzigError(f"unknown {kind} '{name}' -- bind it before querying")
+        return slot
+
+    # --- Binding -----------------------------------------------------------
+
+    def bind_key(self, action: str, key: int) -> None:
+        self._check_alive()
+        slot = self._slot_for_bind(self._action_slots, action, 64, "action")
+        _n.check(_n.pz_action_bind_key(self._handle, slot, key) == 0)
+
+    def bind_mouse_button(self, action: str, button: int) -> None:
+        self._check_alive()
+        slot = self._slot_for_bind(self._action_slots, action, 64, "action")
+        _n.check(_n.pz_action_bind_mouse_button(self._handle, slot, button) == 0)
+
+    def bind_gamepad_button(self, action: str, button: int) -> None:
+        self._check_alive()
+        slot = self._slot_for_bind(self._action_slots, action, 64, "action")
+        _n.check(_n.pz_action_bind_gamepad_button(self._handle, slot, button) == 0)
+
+    def bind_axis_buttons(self, axis: str, negative_key: int, positive_key: int) -> None:
+        self._check_alive()
+        slot = self._slot_for_bind(self._axis_slots, axis, 32, "axis")
+        _n.check(_n.pz_action_bind_axis_buttons(self._handle, slot, negative_key, positive_key) == 0)
+
+    def bind_axis_gamepad(self, axis: str, gamepad_axis: int, deadzone: float = 0.18) -> None:
+        self._check_alive()
+        slot = self._slot_for_bind(self._axis_slots, axis, 32, "axis")
+        _n.check(_n.pz_action_bind_axis_gamepad(self._handle, slot, gamepad_axis, float(deadzone)) == 0)
+
+    def bind_axis_mouse(self, axis: str, mouse_axis: int, sensitivity: float = 1.0, clamp: float = 1.0) -> None:
+        self._check_alive()
+        slot = self._slot_for_bind(self._axis_slots, axis, 32, "axis")
+        _n.check(
+            _n.pz_action_bind_axis_mouse(self._handle, slot, mouse_axis, float(sensitivity), float(clamp)) == 0
+        )
+
+    # --- Per-tick update -----------------------------------------------------
+
+    def update(self) -> None:
+        self._check_alive()
+        _n.pz_action_map_update(self._handle, 0.0)
+
+    # --- Query -----------------------------------------------------------
+
+    def up(self, action: str) -> bool:
+        self._check_alive()
+        slot = self._slot_for_query(self._action_slots, action, "action")
+        return bool(_n.pz_action_up(self._handle, slot))
+
+    def down(self, action: str) -> bool:
+        self._check_alive()
+        slot = self._slot_for_query(self._action_slots, action, "action")
+        return bool(_n.pz_action_down(self._handle, slot))
+
+    def pressed(self, action: str) -> bool:
+        self._check_alive()
+        slot = self._slot_for_query(self._action_slots, action, "action")
+        return bool(_n.pz_action_pressed(self._handle, slot))
+
+    def released(self, action: str) -> bool:
+        self._check_alive()
+        slot = self._slot_for_query(self._action_slots, action, "action")
+        return bool(_n.pz_action_released(self._handle, slot))
+
+    def axis(self, axis: str) -> float:
+        self._check_alive()
+        slot = self._slot_for_query(self._axis_slots, axis, "axis")
+        return _n.pz_action_axis(self._handle, slot)
+
+    def destroy(self) -> None:
+        if not self._destroyed:
+            _n.pz_action_map_destroy(self._handle)
+            self._destroyed = True

pixzig/app.py

@@ -0,0 +1,157 @@
+"""PixzigApp: the base class for a pixzig game written in Python.
+
+Subclass it, override `update` and `render`, and call `run()`. The fixed-
+timestep loop below mirrors pixzig's own `PixzigAppRunner.gameLoopCore`
+(src/pixzig/pixzig.zig), just owned by Python instead of Zig.
+"""
+import os
+import time
+
+from . import _native as _n
+from .action import ActionMap
+from .camera import Camera
+from .input import Gamepad, Keyboard, Mouse
+from .manifest import AssetManifest
+from .shapes import Shapes
+from .sprite import Sprite
+from .text import Text
+from .tilemap import TileMapRenderer
+
+
+class PixzigApp:
+    def __init__(self, title: str, width: int = 800, height: int = 480, update_hz: float = 120.0):
+        eng = _n.pz_init(title.encode("utf-8"), int(width), int(height))
+        if not eng:
+            raise _n.PixzigError(_n.last_error())
+        self._eng = eng
+        self._update_step_ms = 1000.0 / update_hz
+        self._lag = 0.0
+        self._curr_time = time.perf_counter() * 1000.0
+        self._running = True
+
+        self.keyboard = Keyboard(eng)
+        self.mouse = Mouse(eng)
+        self.shapes = Shapes(eng)
+        self.text = Text(eng)
+
+    def gamepad(self, index: int) -> Gamepad:
+        return Gamepad(self._eng, index)
+
+    # --- Resources -----------------------------------------------------
+
+    def load_texture(self, name: str, path: str) -> None:
+        _n.check(_n.pz_load_texture(self._eng, name.encode("utf-8"), path.encode("utf-8")) == 0)
+
+    def create_subtexture(self, base_name: str, new_name: str, x: int, y: int, w: int, h: int) -> None:
+        _n.check(
+            _n.pz_texture_sub(
+                self._eng, base_name.encode("utf-8"), new_name.encode("utf-8"), int(x), int(y), int(w), int(h)
+            )
+            == 0
+        )
+
+    def load_sprite(self, texture_name: str) -> Sprite:
+        handle = _n.pz_sprite_create(self._eng, texture_name.encode("utf-8"))
+        if not handle:
+            raise _n.PixzigError(_n.last_error())
+        return Sprite(handle)
+
+    def load_tilemap(self, name: str, path: str) -> None:
+        _n.check(_n.pz_load_tilemap(self._eng, name.encode("utf-8"), path.encode("utf-8")) == 0)
+
+    def create_tilemap_renderer(self, map_name: str, texture_name: str) -> TileMapRenderer:
+        handle = _n.pz_tilemap_renderer_create(self._eng, map_name.encode("utf-8"), texture_name.encode("utf-8"))
+        if not handle:
+            raise _n.PixzigError(_n.last_error())
+        return TileMapRenderer(handle)
+
+    def load_manifest(self, path: str) -> AssetManifest:
+        # A relative path is resolved (by AssetManifest.loadFromFile, Zig
+        # side) against the running executable's own directory -- for a
+        # packaged Zig build that's the game, but under Python it would be
+        # the Python interpreter's install directory. Resolve to an absolute
+        # path against the current working directory here instead, matching
+        # the cwd-relative convention load_texture/load_tilemap already use.
+        abs_path = os.path.abspath(path)
+        handle = _n.pz_manifest_load(self._eng, abs_path.encode("utf-8"))
+        if not handle:
+            raise _n.PixzigError(_n.last_error())
+        return AssetManifest(handle)
+
+    # --- Action mapping ---------------------------------------------------
+
+    def create_action_map(self) -> ActionMap:
+        handle = _n.pz_action_map_create(self._eng)
+        if not handle:
+            raise _n.PixzigError(_n.last_error())
+        return ActionMap(handle)
+
+    # --- Camera ----------------------------------------------------------
+
+    def create_camera(self) -> Camera:
+        handle = _n.pz_camera_create(self._eng)
+        if not handle:
+            raise _n.PixzigError(_n.last_error())
+        return Camera(handle)
+
+    # --- Rendering ---------------------------------------------------------
+    # `render()` must bracket its own drawing with `render_begin()`/`render_end()`
+    # -- there's no implicit pass around it. Call `render_begin()` with no
+    # arguments for screen-space (UI) drawing, or `render_begin(camera)` for
+    # world-space drawing -- e.g. interleaved with
+    # `TileMapRenderer.render_below`/`render_above`:
+    #
+    #   def render(self):
+    #       self.render_begin(self.camera)
+    #       self.tilemap_renderer.render_below(self.camera, 1.0)
+    #       self.player_sprite.draw()
+    #       self.tilemap_renderer.render_above(self.camera, 1.0)
+    #       self.render_end()
+    #       self.render_begin()
+    #       self.text.draw("HUD text", 10, 10)
+    #       self.render_end()
+
+    def render_begin(self, camera: Camera = None) -> None:
+        if camera is None:
+            _n.pz_render_begin(self._eng)
+        else:
+            _n.pz_render_begin_world(self._eng, camera._handle)
+
+    def render_end(self) -> None:
+        _n.pz_render_end(self._eng)
+
+    # --- Overridable hooks -----------------------------------------------
+
+    def update(self, dt_ms: float) -> bool:
+        """Called at a fixed timestep. Return False to quit."""
+        return True
+
+    def render(self) -> None:
+        """Called once per displayed frame, after the screen is cleared."""
+        pass
+
+    # --- Loop --------------------------------------------------------------
+
+    def quit(self) -> None:
+        self._running = False
+
+    def run(self) -> None:
+        try:
+            while self._running and not _n.pz_should_close(self._eng):
+                now = time.perf_counter() * 1000.0
+                self._lag += now - self._curr_time
+                self._curr_time = now
+
+                _n.pz_poll_events(self._eng)
+
+                while self._lag > self._update_step_ms:
+                    self._lag -= self._update_step_ms
+                    _n.pz_update_input(self._eng)
+                    if not self.update(self._update_step_ms):
+                        return
+
+                _n.pz_render_clear(self._eng, 0.0, 0.0, 0.0, 1.0)
+                self.render()
+                _n.pz_swap_buffers(self._eng)
+        finally:
+            _n.pz_deinit(self._eng)

pixzig/camera.py

@@ -0,0 +1,47 @@
+"""2D camera. Create via `PixzigApp.create_camera()`."""
+import ctypes
+
+from . import _native as _n
+
+
+class Camera:
+    def __init__(self, handle):
+        self._handle = handle
+        self._destroyed = False
+
+    def _check_alive(self) -> None:
+        if self._destroyed:
+            raise _n.PixzigError("camera already destroyed")
+
+    def set_pos(self, x: float, y: float) -> None:
+        self._check_alive()
+        _n.pz_camera_set_pos(self._handle, float(x), float(y))
+
+    @property
+    def pos(self):
+        self._check_alive()
+        x, y = ctypes.c_float(), ctypes.c_float()
+        _n.pz_camera_get_pos(self._handle, ctypes.byref(x), ctypes.byref(y))
+        return (x.value, y.value)
+
+    def set_zoom(self, zoom: float) -> None:
+        self._check_alive()
+        _n.pz_camera_set_zoom(self._handle, float(zoom))
+
+    @property
+    def zoom(self) -> float:
+        self._check_alive()
+        return _n.pz_camera_get_zoom(self._handle)
+
+    def set_bounds(self, l: float, t: float, r: float, b: float) -> None:
+        self._check_alive()
+        _n.pz_camera_set_bounds(self._handle, float(l), float(t), float(r), float(b))
+
+    def clear_bounds(self) -> None:
+        self._check_alive()
+        _n.pz_camera_clear_bounds(self._handle)
+
+    def destroy(self) -> None:
+        if not self._destroyed:
+            _n.pz_camera_destroy(self._handle)
+            self._destroyed = True

pixzig/constants.py

@@ -0,0 +1,133 @@
+"""Key, mouse, and gamepad codes. Values match GLFW's own codes exactly, so
+they're plain ints under the hood -- but code should always use these names
+rather than the raw numbers.
+"""
+
+
+class Key:
+    SPACE = 32
+    APOSTROPHE = 39
+    COMMA = 44
+    MINUS = 45
+    PERIOD = 46
+    SLASH = 47
+    ZERO = 48
+    ONE = 49
+    TWO = 50
+    THREE = 51
+    FOUR = 52
+    FIVE = 53
+    SIX = 54
+    SEVEN = 55
+    EIGHT = 56
+    NINE = 57
+    SEMICOLON = 59
+    EQUAL = 61
+    A = 65
+    B = 66
+    C = 67
+    D = 68
+    E = 69
+    F = 70
+    G = 71
+    H = 72
+    I = 73
+    J = 74
+    K = 75
+    L = 76
+    M = 77
+    N = 78
+    O = 79
+    P = 80
+    Q = 81
+    R = 82
+    S = 83
+    T = 84
+    U = 85
+    V = 86
+    W = 87
+    X = 88
+    Y = 89
+    Z = 90
+    LEFT_BRACKET = 91
+    BACKSLASH = 92
+    RIGHT_BRACKET = 93
+    GRAVE_ACCENT = 96
+
+    ESCAPE = 256
+    ENTER = 257
+    TAB = 258
+    BACKSPACE = 259
+    INSERT = 260
+    DELETE = 261
+    RIGHT = 262
+    LEFT = 263
+    DOWN = 264
+    UP = 265
+    PAGE_UP = 266
+    PAGE_DOWN = 267
+    HOME = 268
+    END = 269
+    CAPS_LOCK = 280
+    SCROLL_LOCK = 281
+    NUM_LOCK = 282
+    PRINT_SCREEN = 283
+    PAUSE = 284
+    F1 = 290
+    F2 = 291
+    F3 = 292
+    F4 = 293
+    F5 = 294
+    F6 = 295
+    F7 = 296
+    F8 = 297
+    F9 = 298
+    F10 = 299
+    F11 = 300
+    F12 = 301
+    LEFT_SHIFT = 340
+    LEFT_CONTROL = 341
+    LEFT_ALT = 342
+    LEFT_SUPER = 343
+    RIGHT_SHIFT = 344
+    RIGHT_CONTROL = 345
+    RIGHT_ALT = 346
+    RIGHT_SUPER = 347
+
+
+class MouseButton:
+    LEFT = 0
+    RIGHT = 1
+    MIDDLE = 2
+
+
+class GamepadButton:
+    A = 0
+    B = 1
+    X = 2
+    Y = 3
+    LEFT_BUMPER = 4
+    RIGHT_BUMPER = 5
+    BACK = 6
+    START = 7
+    GUIDE = 8
+    LEFT_THUMB = 9
+    RIGHT_THUMB = 10
+    DPAD_UP = 11
+    DPAD_RIGHT = 12
+    DPAD_DOWN = 13
+    DPAD_LEFT = 14
+
+
+class GamepadAxis:
+    LEFT_X = 0
+    LEFT_Y = 1
+    RIGHT_X = 2
+    RIGHT_Y = 3
+    LEFT_TRIGGER = 4
+    RIGHT_TRIGGER = 5
+
+
+class MouseAxis:
+    X = 0
+    Y = 1

pixzig/input.py

@@ -0,0 +1,61 @@
+"""Keyboard, mouse, and gamepad state, read each frame from the engine."""
+import ctypes
+
+from . import _native as _n
+
+
+class Keyboard:
+    def __init__(self, eng):
+        self._eng = eng
+
+    def down(self, key: int) -> bool:
+        return bool(_n.pz_key_down(self._eng, key))
+
+    def pressed(self, key: int) -> bool:
+        return bool(_n.pz_key_pressed(self._eng, key))
+
+    def released(self, key: int) -> bool:
+        return bool(_n.pz_key_released(self._eng, key))
+
+
+class Mouse:
+    def __init__(self, eng):
+        self._eng = eng
+
+    @property
+    def pos(self):
+        x = ctypes.c_float()
+        y = ctypes.c_float()
+        _n.pz_mouse_pos(self._eng, ctypes.byref(x), ctypes.byref(y))
+        return (x.value, y.value)
+
+    def down(self, button: int) -> bool:
+        return bool(_n.pz_mouse_button_down(self._eng, button))
+
+    def pressed(self, button: int) -> bool:
+        return bool(_n.pz_mouse_button_pressed(self._eng, button))
+
+    def released(self, button: int) -> bool:
+        return bool(_n.pz_mouse_button_released(self._eng, button))
+
+
+class Gamepad:
+    def __init__(self, eng, index: int):
+        self._eng = eng
+        self.index = index
+
+    @property
+    def connected(self) -> bool:
+        return bool(_n.pz_gamepad_connected(self._eng, self.index))
+
+    def down(self, button: int) -> bool:
+        return bool(_n.pz_gamepad_button_down(self._eng, self.index, button))
+
+    def pressed(self, button: int) -> bool:
+        return bool(_n.pz_gamepad_button_pressed(self._eng, self.index, button))
+
+    def released(self, button: int) -> bool:
+        return bool(_n.pz_gamepad_button_released(self._eng, self.index, button))
+
+    def axis(self, axis: int) -> float:
+        return _n.pz_gamepad_axis(self._eng, self.index, axis)

pixzig/manifest.py

@@ -0,0 +1,46 @@
+"""Asset manifests. Load via `PixzigApp.load_manifest(path)`.
+
+A manifest is a JSON file describing named assets (textures, atlases, fonts,
+tilemaps) grouped into named groups, e.g.:
+
+    {
+      "root": "assets",
+      "groups": { "boot": ["ui"], "level1": ["tiles", "level1_map"] },
+      "assets": [
+        { "id": "ui", "kind": "atlas", "path": "ui" },
+        { "id": "tiles", "kind": "texture", "path": "mario_grassish2.png" },
+        { "id": "level1_map", "kind": "tilemap", "path": "level1a.tmx" }
+      ]
+    }
+
+A group named "boot" is loaded automatically as soon as the manifest is
+opened. Loading a group registers its assets in the engine's resource
+manager under their manifest id, so they're then usable directly by id with
+`PixzigApp.load_sprite`, `PixzigApp.create_tilemap_renderer`, and
+`Text.set_font` -- no separate step needed to "get" an asset out of the
+manifest.
+"""
+from . import _native as _n
+
+
+class AssetManifest:
+    def __init__(self, handle):
+        self._handle = handle
+        self._destroyed = False
+
+    def _check_alive(self) -> None:
+        if self._destroyed:
+            raise _n.PixzigError("asset manifest already destroyed")
+
+    def load_group(self, name: str) -> None:
+        self._check_alive()
+        _n.check(_n.pz_manifest_load_group(self._handle, name.encode("utf-8")) == 0)
+
+    def unload_group(self, name: str) -> None:
+        self._check_alive()
+        _n.pz_manifest_unload_group(self._handle, name.encode("utf-8"))
+
+    def destroy(self) -> None:
+        if not self._destroyed:
+            _n.pz_manifest_destroy(self._handle)
+            self._destroyed = True

pixzig/shapes.py

@@ -0,0 +1,24 @@
+"""Rectangle drawing. Colors are (r, g, b) or (r, g, b, a) tuples, 0-255."""
+from . import _native as _n
+
+
+def _normalize_color(color):
+    if len(color) == 3:
+        r, g, b = color
+        a = 255
+    else:
+        r, g, b, a = color
+    return r / 255.0, g / 255.0, b / 255.0, a / 255.0
+
+
+class Shapes:
+    def __init__(self, eng):
+        self._eng = eng
+
+    def filled_rect(self, x, y, w, h, color) -> None:
+        r, g, b, a = _normalize_color(color)
+        _n.pz_draw_filled_rect(self._eng, x, y, w, h, r, g, b, a)
+
+    def rect(self, x, y, w, h, color, line_width: int = 1) -> None:
+        r, g, b, a = _normalize_color(color)
+        _n.pz_draw_rect(self._eng, x, y, w, h, r, g, b, a, line_width)

pixzig/sprite.py

@@ -0,0 +1,47 @@
+"""Sprites. Create via `PixzigApp.load_sprite(texture_name)`."""
+import ctypes
+
+from . import _native as _n
+
+
+class Sprite:
+    def __init__(self, handle):
+        self._handle = handle
+        self._destroyed = False
+
+    def _check_alive(self) -> None:
+        if self._destroyed:
+            raise _n.PixzigError("sprite already destroyed")
+
+    def set_pos(self, x: int, y: int) -> None:
+        self._check_alive()
+        _n.pz_sprite_set_pos(self._handle, int(x), int(y))
+
+    @property
+    def rect(self):
+        self._check_alive()
+        x, y, w, h = ctypes.c_float(), ctypes.c_float(), ctypes.c_float(), ctypes.c_float()
+        _n.pz_sprite_get_rect(self._handle, ctypes.byref(x), ctypes.byref(y), ctypes.byref(w), ctypes.byref(h))
+        return (x.value, y.value, w.value, h.value)
+
+    @property
+    def pos(self):
+        x, y, _, _ = self.rect
+        return (x, y)
+
+    @property
+    def width(self) -> float:
+        return self.rect[2]
+
+    @property
+    def height(self) -> float:
+        return self.rect[3]
+
+    def draw(self) -> None:
+        self._check_alive()
+        _n.pz_sprite_draw(self._handle)
+
+    def destroy(self) -> None:
+        if not self._destroyed:
+            _n.pz_sprite_destroy(self._handle)
+            self._destroyed = True

pixzig/text.py

@@ -0,0 +1,16 @@
+"""TrueType text rendering."""
+from . import _native as _n
+
+
+class Text:
+    def __init__(self, eng):
+        self._eng = eng
+
+    def load_font(self, name: str, ttf_path: str, size: float) -> None:
+        _n.check(_n.pz_load_font(self._eng, name.encode("utf-8"), ttf_path.encode("utf-8"), float(size)) == 0)
+
+    def set_font(self, name: str) -> None:
+        _n.check(_n.pz_set_default_font(self._eng, name.encode("utf-8")) == 0)
+
+    def draw(self, text: str, x: int, y: int) -> None:
+        _n.pz_draw_string(self._eng, text.encode("utf-8"), int(x), int(y))

pixzig/tilemap.py

@@ -0,0 +1,52 @@
+"""Tiled map loading and chunked rendering. Load a map with
+`PixzigApp.load_tilemap(name, path)`, then create a renderer for it with
+`PixzigApp.create_tilemap_renderer(map_name, texture_name)`.
+"""
+import ctypes
+
+from . import _native as _n
+from .camera import Camera
+
+
+class TileMapRenderer:
+    def __init__(self, handle):
+        self._handle = handle
+        self._destroyed = False
+
+    def _check_alive(self) -> None:
+        if self._destroyed:
+            raise _n.PixzigError("tilemap renderer already destroyed")
+
+    def pixel_size(self, layer_index: int):
+        """Returns the (width, height) of `layer_index` in pixels, useful for
+        setting a camera's bounds to the map's extents."""
+        self._check_alive()
+        w, h = ctypes.c_float(), ctypes.c_float()
+        _n.pz_tilemap_pixel_size(self._handle, int(layer_index), ctypes.byref(w), ctypes.byref(h))
+        return (w.value, h.value)
+
+    def render(self, camera: Camera) -> None:
+        self._check_alive()
+        _n.pz_tilemap_render(self._handle, camera._handle)
+
+    def render_below(self, camera: Camera, z: float) -> None:
+        """Renders layers with z < `z_threshold`, for background layers."""
+        self._check_alive()
+        _n.pz_tilemap_render_below(self._handle, camera._handle, float(z))
+
+    def render_above(self, camera: Camera, z: float) -> None:
+        """Renders layers with z >= `z_threshold`, for foreground layers."""
+        self._check_alive()
+        _n.pz_tilemap_render_above(self._handle, camera._handle, float(z))
+
+    def check_reload(self) -> bool:
+        """Call once per frame; reloads the renderer if the underlying map
+        file changed on disk (debug builds only). Returns whether it reloaded,
+        so callers know to re-read `pixel_size` for camera bounds."""
+        self._check_alive()
+        return bool(_n.pz_tilemap_check_reload(self._handle))
+
+    def destroy(self) -> None:
+        if not self._destroyed:
+            _n.pz_tilemap_renderer_destroy(self._handle)
+            self._destroyed = True

pixzig-0.13.0.dist-info/METADATA

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: pixzig
+Version: 0.13.0
+Summary: Python bindings for the pixzig game engine
+License-Expression: MIT
+Requires-Python: >=3.9

pixzig-0.13.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+pixzig/__init__.py,sha256=XY9bJzerb1dwcLhrpj5RVVhtgA15zJg5VUOVKIUh8-Y,277
+pixzig/_native.py,sha256=uBXdcac3oXU8vDs5n4A71aNEYtiRnILZs89G_7MIV5w,9581
+pixzig/action.py,sha256=uegG3NRUi1DdrEQgx6PMRgwvzpztH3GvnOiOxaIuXJg,4963
+pixzig/app.py,sha256=8fRP-f0_SMMKLHMprgv9Ippu_WhDAlvT3Pe1zqM7Px4,6072
+pixzig/camera.py,sha256=J34vDN8dA8cA-KUvnFk43xnlISXQ-U59mFovvw6t_LU,1404
+pixzig/constants.py,sha256=nDiRSlr21PCyS-ie8cuNh6qeM-cE9n_3yxEsDagdGHc,1987
+pixzig/input.py,sha256=wbznD_02b2tU9gmV4rblnzWkvMvewlxzUAzZ6NlvS6w,1774
+pixzig/manifest.py,sha256=sCg1GxtBHsGbpjCErXYHtfbjuWuUKnStzKTGvsoGw8c,1627
+pixzig/pixzig_ffi.dll,sha256=PuH-l_QdYftRMraWZ7quj9CSSsNusJziwKK8rWPdi7U,3640832
+pixzig/shapes.py,sha256=5ks7wK-_Vw_--C_1_6Xv0KBX1kNXvg2k-WPBFzTHGLY,711
+pixzig/sprite.py,sha256=8tdk6vw2jWdFYmytAIVTjaKfutPpd42elOQUU69-izU,1275
+pixzig/text.py,sha256=SLrRMEgSOjZcuCC9pCt7KLzS1rMsx7bO6NHDlQw8nuU,564
+pixzig/tilemap.py,sha256=4xFX69SQX4adMw9Lc6E-qJYeKWyxznLJAoQOfLnHm6U,2042
+pixzig-0.13.0.dist-info/METADATA,sha256=itYbplXv8DjKhefaZoLOiwfFlgdVisTcqhPpZMwaM4Q,150
+pixzig-0.13.0.dist-info/WHEEL,sha256=3I5VVWZdsFlU417aCS2bMRuerS8wsfvBq99MyatBV3A,97
+pixzig-0.13.0.dist-info/top_level.txt,sha256=jToTQIaL9xiFlr6Kfo3zKe2aH2-aCB3slYhdqedGiNI,7
+pixzig-0.13.0.dist-info/RECORD,,

pixzig-0.13.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-win_amd64
+

pixzig-0.13.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pixzig