Add minimap to tcod samples.

Update changelog.

Add context atlas access.

Refactor Texture attributes.

Author: HexDecimal

.vscode/launch.json

@@ -9,8 +9,7 @@
             "type": "python",
             "request": "launch",
             "program": "${file}",
-            "console": "integratedTerminal",
-            "preLaunchTask": "develop python-tcod",
+            "console": "internalConsole",
         },
         {
             // Run the Python samples.
@@ -20,8 +19,7 @@
             "request": "launch",
             "program": "${workspaceFolder}/examples/samples_tcod.py",
             "cwd": "${workspaceFolder}/examples",
-            "console": "integratedTerminal",
-            "preLaunchTask": "develop python-tcod",
+            "console": "internalConsole",
         },
         {
             "name": "Python: Run tests",

CHANGELOG.md

@@ -4,13 +4,19 @@ Changes relevant to the users of python-tcod are documented here.
 This project adheres to [Semantic Versioning](https://semver.org/) since version `2.0.0`.
 
 ## [Unreleased]
+### Added
+- `tcod.sdl.audio`, a new module exposing SDL audio devices.  This does not include an audio mixer yet.
+- `tcod.sdl.mouse`, for SDL mouse and cursor handing.
+- `Context.sdl_atlas`, which provides the relevant `SDLTilesetAtlas` when one is being used by the context.
+- Several missing features were added to `tcod.sdl.render`.
+- `Window.mouse_rect` added to SDL windows to set the mouse confinement area.
 ### Changed
 - `Texture.access` and `Texture.blend_mode` properties now return enum instances.
-  You can still set them with `int` but Mypy will complain.
+  You can still set `blend_mode` with `int` but Mypy will complain.
 
 ## [13.4.0] - 2022-02-04
 ### Added
-- Adds `sdl_window` and `sdl_renderer` to tcod contexts.
+- Adds `sdl_window` and `sdl_renderer` properties to tcod contexts.
 - Adds `tcod.event.add_watch` and `tcod.event.remove_watch` to handle SDL events via callback.
 - Adds the `tcod.sdl.video` module to handle SDL windows.
 - Adds the `tcod.sdl.render` module to handle SDL renderers.

examples/samples_tcod.py

@@ -19,6 +19,7 @@
 import numpy as np
 import tcod
 import tcod.render
+import tcod.sdl.render
 from numpy.typing import NDArray
 
 if not sys.warnoptions:
@@ -50,6 +51,8 @@ def get_data(path: str) -> str:
 # Mutable global names.
 context: tcod.context.Context
 tileset: tcod.tileset.Tileset
+console_render: tcod.render.SDLConsoleRender  # Optional SDL renderer.
+sample_minimap: tcod.sdl.render.Texture  # Optional minimap texture.
 root_console = tcod.Console(80, 50, order="F")
 sample_console = tcod.console.Console(SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT, order="F")
 cur_sample = 0  # Current selected sample.
@@ -68,7 +71,7 @@ def on_draw(self) -> None:
         pass
 
     def ev_keydown(self, event: tcod.event.KeyDown) -> None:
-        global cur_sample, context
+        global cur_sample
         if event.sym == tcod.event.K_DOWN:
             cur_sample = (cur_sample + 1) % len(SAMPLES)
             SAMPLES[cur_sample].on_enter()
@@ -91,8 +94,7 @@ def ev_keydown(self, event: tcod.event.KeyDown) -> None:
             raise SystemExit()
         elif event.sym in RENDERER_KEYS:
             # Swap the active context for one with a different renderer.
-            context.close()
-            context = init_context(RENDERER_KEYS[event.sym])
+            init_context(RENDERER_KEYS[event.sym])
 
     def ev_quit(self, event: tcod.event.Quit) -> None:
         raise SystemExit()
@@ -541,7 +543,7 @@ def __init__(self) -> None:
         self.player_y = 10
         self.torch = False
         self.light_walls = True
-        self.algo_num = 0
+        self.algo_num = tcod.FOV_SYMMETRIC_SHADOWCAST
         self.noise = tcod.noise.Noise(1)  # 1D noise for the torch flickering.
 
         map_shape = (SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT)
@@ -582,7 +584,7 @@ def on_draw(self) -> None:
         self.draw_ui()
         sample_console.print(self.player_x, self.player_y, "@")
         # Draw windows.
-        sample_console.tiles_rgb["ch"][SAMPLE_MAP == "="] = tcod.CHAR_DHLINE
+        sample_console.tiles_rgb["ch"][SAMPLE_MAP == "="] = 0x2550  # BOX DRAWINGS DOUBLE HORIZONTAL
         sample_console.tiles_rgb["fg"][SAMPLE_MAP == "="] = BLACK
 
         # Get a 2D boolean array of visible cells.
@@ -1394,34 +1396,48 @@ def on_draw(self) -> None:
 )
 
 
-def init_context(renderer: int) -> tcod.context.Context:
-    """Return a new context with common parameters set.
+def init_context(renderer: int) -> None:
+    """Setup or reset a global context with common parameters set.
 
     This function exists to more easily switch between renderers.
     """
+    global context, console_render, sample_minimap
+    if "context" in globals():
+        context.close()
     libtcod_version = "%i.%i.%i" % (
         tcod.lib.TCOD_MAJOR_VERSION,
         tcod.lib.TCOD_MINOR_VERSION,
         tcod.lib.TCOD_PATCHLEVEL,
     )
-    return tcod.context.new(
+    context = tcod.context.new(
         columns=root_console.width,
         rows=root_console.height,
         title=f"python-tcod samples" f" (python-tcod {tcod.__version__}, libtcod {libtcod_version})",
         renderer=renderer,
         vsync=False,  # VSync turned off since this is for benchmarking.
         tileset=tileset,
     )
+    if context.sdl_renderer:  # If this context supports SDL rendering.
+        # Start by setting the logical size so that window resizing doesn't break anything.
+        context.sdl_renderer.logical_size = (
+            tileset.tile_width * root_console.width,
+            tileset.tile_height * root_console.height,
+        )
+        assert context.sdl_atlas
+        # Generate the console renderer and minimap.
+        console_render = tcod.render.SDLConsoleRender(context.sdl_atlas)
+        sample_minimap = context.sdl_renderer.new_texture(
+            SAMPLE_SCREEN_WIDTH,
+            SAMPLE_SCREEN_HEIGHT,
+            format=tcod.lib.SDL_PIXELFORMAT_RGB24,
+            access=tcod.sdl.render.TextureAccess.STREAMING,  # Updated every frame.
+        )
 
 
 def main() -> None:
     global context, tileset
     tileset = tcod.tileset.load_tilesheet(FONT, 32, 8, tcod.tileset.CHARMAP_TCOD)
-    context = init_context(tcod.RENDERER_SDL2)
-    sdl_renderer = context.sdl_renderer
-    assert sdl_renderer
-    atlas = tcod.render.SDLTilesetAtlas(sdl_renderer, tileset)
-    console_render = tcod.render.SDLConsoleRender(atlas)
+    init_context(tcod.RENDERER_SDL2)
     try:
         SAMPLES[cur_sample].on_enter()
 
@@ -1434,9 +1450,25 @@ def main() -> None:
             SAMPLES[cur_sample].on_draw()
             sample_console.blit(root_console, SAMPLE_SCREEN_X, SAMPLE_SCREEN_Y)
             draw_stats()
-            # context.present(root_console)
-            sdl_renderer.copy(console_render.render(root_console))
-            sdl_renderer.present()
+            if context.sdl_renderer:
+                # SDL renderer support, upload the sample console background to a minimap texture.
+                sample_minimap.update(sample_console.rgb.T["bg"])
+                # Render the root_console normally, this is the drawing step of context.present without presenting.
+                context.sdl_renderer.copy(console_render.render(root_console))
+                # Render the minimap to the screen.
+                context.sdl_renderer.copy(
+                    sample_minimap,
+                    dest=(
+                        tileset.tile_width * 24,
+                        tileset.tile_height * 36,
+                        SAMPLE_SCREEN_WIDTH * 3,
+                        SAMPLE_SCREEN_HEIGHT * 3,
+                    ),
+                )
+                context.sdl_renderer.present()
+            else:  # No SDL renderer, just use plain context rendering.
+                context.present(root_console)
+
             handle_time()
             handle_events()
     finally:

tcod/context.py

@@ -58,6 +58,7 @@
 
 import tcod
 import tcod.event
+import tcod.render
 import tcod.sdl.render
 import tcod.sdl.video
 import tcod.tileset
@@ -371,6 +372,17 @@ def sdl_renderer(self) -> Optional[tcod.sdl.render.Renderer]:
         p = lib.TCOD_context_get_sdl_renderer(self._context_p)
         return tcod.sdl.render.Renderer(p) if p else None
 
+    @property
+    def sdl_atlas(self) -> Optional[tcod.render.SDLTilesetAtlas]:
+        """Return a :any:`tcod.render.SDLTilesetAtlas` referencing libtcod's SDL texture atlas if it exists.
+
+        .. versionadded:: unreleased
+        """
+        if self._context_p.type not in (lib.TCOD_RENDERER_SDL, lib.TCOD_RENDERER_SDL2):
+            return None
+        context_data = ffi.cast("struct TCOD_RendererSDL2*", self._context_p.contextdata_)
+        return tcod.render.SDLTilesetAtlas._from_ref(context_data.renderer, context_data.atlas)
+
     def __reduce__(self) -> NoReturn:
         """Contexts can not be pickled, so this class will raise
         :class:`pickle.PicklingError`.

tcod/render.py

@@ -29,7 +29,7 @@
 
 from __future__ import annotations
 
-from typing import Optional
+from typing import Any, Optional
 
 import tcod.console
 import tcod.sdl.render
@@ -46,6 +46,14 @@ def __init__(self, renderer: tcod.sdl.render.Renderer, tileset: tcod.tileset.Til
         self.tileset = tileset
         self.p = ffi.gc(_check_p(lib.TCOD_sdl2_atlas_new(renderer.p, tileset._tileset_p)), lib.TCOD_sdl2_atlas_delete)
 
+    @classmethod
+    def _from_ref(cls, renderer_p: Any, atlas_p: Any) -> SDLTilesetAtlas:
+        self = object.__new__(cls)
+        self._renderer = tcod.sdl.render.Renderer(renderer_p)
+        self.tileset = tcod.tileset.Tileset._from_ref(atlas_p.tileset)
+        self.p = atlas_p
+        return self
+
 
 class SDLConsoleRender:
     """Holds an internal cache console and texture which are used to optimized console rendering."""

tcod/sdl/render.py

@@ -9,6 +9,7 @@
 
 import numpy as np
 from numpy.typing import NDArray
+from typing_extensions import Final
 
 import tcod.sdl.video
 from tcod.loader import ffi, lib
@@ -142,11 +143,27 @@ def compose_blend_mode(
 
 
 class Texture:
-    """SDL hardware textures."""
+    """SDL hardware textures.
+
+    Create a new texture using :any:`Renderer.new_texture` or :any:`Renderer.upload_texture`.
+    """
 
     def __init__(self, sdl_texture_p: Any, sdl_renderer_p: Any = None) -> None:
         self.p = sdl_texture_p
         self._sdl_renderer_p = sdl_renderer_p  # Keep alive.
+        query = self._query()
+        self.format: Final[int] = query[0]
+        """Texture format, read only."""
+        self.access: Final[TextureAccess] = TextureAccess(query[1])
+        """Texture access mode, read only.
+
+        .. versionchanged:: unreleased
+            Attribute is now a :any:`TextureAccess` value.
+        """
+        self.width: Final[int] = query[2]
+        """Texture pixel width, read only."""
+        self.height: Final[int] = query[3]
+        """Texture pixel height, read only."""
 
     def __eq__(self, other: Any) -> bool:
         return bool(self.p == getattr(other, "p", None))
@@ -156,7 +173,7 @@ def _query(self) -> Tuple[int, int, int, int]:
         format = ffi.new("uint32_t*")
         buffer = ffi.new("int[3]")
         lib.SDL_QueryTexture(self.p, format, buffer, buffer + 1, buffer + 2)
-        return int(format), int(buffer[0]), int(buffer[1]), int(buffer[2])
+        return int(format[0]), int(buffer[0]), int(buffer[1]), int(buffer[2])
 
     def update(self, pixels: NDArray[Any], rect: Optional[Tuple[int, int, int, int]] = None) -> None:
         """Update the pixel data of this texture.
@@ -165,42 +182,11 @@ def update(self, pixels: NDArray[Any], rect: Optional[Tuple[int, int, int, int]]
         """
         if rect is None:
             rect = (0, 0, self.width, self.height)
-        assert pixels.shape[:2] == rect[3], rect[2]
-        assert pixels[0].flags.c_contiguous
+        assert pixels.shape[:2] == (self.height, self.width)
+        if not pixels[0].flags.c_contiguous:
+            pixels = np.ascontiguousarray(pixels)
         _check(lib.SDL_UpdateTexture(self.p, (rect,), ffi.cast("void*", pixels.ctypes.data), pixels.strides[0]))
 
-    @property
-    def format(self) -> int:
-        """Texture format, read only."""
-        buffer = ffi.new("uint32_t*")
-        lib.SDL_QueryTexture(self.p, buffer, ffi.NULL, ffi.NULL, ffi.NULL)
-        return int(buffer[0])
-
-    @property
-    def access(self) -> TextureAccess:
-        """Texture access mode, read only.
-
-        .. versionchanged:: unreleased
-            Property now returns a TextureAccess instance.
-        """
-        buffer = ffi.new("int*")
-        lib.SDL_QueryTexture(self.p, ffi.NULL, buffer, ffi.NULL, ffi.NULL)
-        return TextureAccess(buffer[0])
-
-    @property
-    def width(self) -> int:
-        """Texture pixel width, read only."""
-        buffer = ffi.new("int*")
-        lib.SDL_QueryTexture(self.p, ffi.NULL, ffi.NULL, buffer, ffi.NULL)
-        return int(buffer[0])
-
-    @property
-    def height(self) -> int:
-        """Texture pixel height, read only."""
-        buffer = ffi.new("int*")
-        lib.SDL_QueryTexture(self.p, ffi.NULL, ffi.NULL, ffi.NULL, buffer)
-        return int(buffer[0])
-
     @property
     def alpha_mod(self) -> int:
         """Texture alpha modulate value, can be set to 0 - 255."""

tcod/tileset.py

@@ -40,12 +40,18 @@ def __init__(self, tile_width: int, tile_height: int) -> None:
     @classmethod
     def _claim(cls, cdata: Any) -> Tileset:
         """Return a new Tileset that owns the provided TCOD_Tileset* object."""
-        self: Tileset = object.__new__(cls)
+        self = object.__new__(cls)
         if cdata == ffi.NULL:
             raise RuntimeError("Tileset initialized with nullptr.")
         self._tileset_p = ffi.gc(cdata, lib.TCOD_tileset_delete)
         return self
 
+    @classmethod
+    def _from_ref(cls, tileset_p: Any) -> Tileset:
+        self = object.__new__(cls)
+        self._tileset_p = tileset_p
+        return self
+
     @property
     def tile_width(self) -> int:
         """The width of the tile in pixels."""