Port libtcod direct SDL rendering functions.

Allow access to the fancy SDL classes from tcod contexts.

Author: HexDecimal

tcod/context.py

@@ -58,6 +58,8 @@
 
 import tcod
 import tcod.event
+import tcod.sdl.render
+import tcod.sdl.video
 import tcod.tileset
 from tcod._internal import _check, _check_warn, pending_deprecate
 from tcod.loader import ffi, lib
@@ -351,6 +353,24 @@ def toggle_fullscreen(context: tcod.context.Context) -> None:
         '''  # noqa: E501
         return lib.TCOD_context_get_sdl_window(self._context_p)
 
+    @property
+    def sdl_window(self) -> Optional[tcod.sdl.video.Window]:
+        """Return a tcod.sdl.video.Window referencing this contexts SDL window if it exists.
+
+        .. versionadded:: 13.4
+        """
+        p = self.sdl_window_p
+        return tcod.sdl.video.Window(p) if p else None
+
+    @property
+    def sdl_renderer(self) -> Optional[tcod.sdl.render.Renderer]:
+        """Return a tcod.sdl.render.Renderer referencing this contexts SDL renderer if it exists.
+
+        .. versionadded:: 13.4
+        """
+        p = lib.TCOD_context_get_sdl_renderer(self._context_p)
+        return tcod.sdl.render.Renderer(p) if p else None
+
     def __reduce__(self) -> NoReturn:
         """Contexts can not be pickled, so this class will raise
         :class:`pickle.PicklingError`.

tcod/render.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import tcod.console
+import tcod.sdl.render
+import tcod.tileset
+from tcod._internal import _check, _check_p
+from tcod.loader import ffi, lib
+
+
+class SDLTilesetAtlas:
+    """Prepares a tileset for rendering using SDL."""
+
+    def __init__(self, renderer: tcod.sdl.render.Renderer, tileset: tcod.tileset.Tileset) -> None:
+        self._renderer = renderer
+        self.tileset = tileset
+        self.p = ffi.gc(_check_p(lib.TCOD_sdl2_atlas_new(renderer.p, tileset._tileset_p)), lib.TCOD_sdl2_atlas_delete)
+
+
+class SDLConsoleRender:
+    """Holds an internal cache console and texture which are used to optimized console rendering."""
+
+    def __init__(self, atlas: SDLTilesetAtlas) -> None:
+        self._atlas = atlas
+        self._renderer = atlas._renderer
+        self._cache_console: Optional[tcod.console.Console] = None
+        self._texture: Optional[tcod.sdl.render.Texture] = None
+
+    def render(self, console: tcod.console.Console) -> tcod.sdl.render.Texture:
+        """Render a console to a cached Texture and then return the Texture.
+
+        You should not draw onto the returned Texture as only changed parts of it will be updated on the next call.
+
+        This function requires the SDL renderer to have target texture support.
+        It will also change the SDL target texture for the duration of the call.
+        """
+        if self._cache_console and (
+            self._cache_console.width != console.width or self._cache_console.height != console.height
+        ):
+            self._cache_console = None
+            self._texture = None
+        if self._cache_console is None or self._texture is None:
+            self._cache_console = tcod.console.Console(console.width, console.height)
+            self._texture = self._renderer.new_texture(
+                self._atlas.tileset.tile_width * console.width,
+                self._atlas.tileset.tile_height * console.height,
+                format=int(lib.SDL_PIXELFORMAT_RGBA32),
+                access=int(lib.SDL_TEXTUREACCESS_TARGET),
+            )
+        _check(
+            lib.TCOD_sdl2_render_texture(
+                self._atlas.p, console.console_c, self._cache_console.console_c, self._texture.p
+            )
+        )
+        return self._texture

tcod/sdl/render.py

@@ -116,7 +116,7 @@ def upload_texture(
             elif pixels.shape[2] == 3:
                 format = int(lib.SDL_PIXELFORMAT_RGB32)
             else:
-                assert False
+                raise TypeError(f"Can't determine the format required for an array of shape {pixels.shape}.")
 
         texture = self.new_texture(pixels.shape[1], pixels.shape[0], format=format, access=access)
         if not pixels[0].flags["C_CONTIGUOUS"]:

tcod/sdl/video.py

@@ -114,8 +114,17 @@ def size(self, xy: Tuple[int, int]) -> None:
         x, y = xy
         lib.SDL_SetWindowSize(self.p, x, y)
 
+    @property
+    def title(self) -> str:
+        """The title of the window.  You may set this attribute to change it."""
+        return str(ffi.string(lib.SDL_GetWindowtitle(self.p)), encoding="utf-8")
+
+    @title.setter
+    def title(self, value: str) -> None:
+        lib.SDL_SetWindowtitle(self.p, value.encode("utf-8"))
+
 
-def get_active_window() -> Window:
+def _get_active_window() -> Window:
     """Return the SDL2 window current managed by libtcod.
 
     Will raise an error if libtcod does not currently have a window.