| """Pillow renderer used by the Tkinter window.""" |
|
|
| from __future__ import annotations |
|
|
| from collections.abc import Iterable |
| from pathlib import Path |
|
|
| from PIL import Image, ImageDraw, ImageFont |
|
|
| from .actions import Position |
| from .character import CharacterSprite |
| from .config import EngineConfig |
| from .dialogue import DialogueState |
|
|
|
|
| class SceneRenderer: |
| def __init__(self, config: EngineConfig) -> None: |
| self.config = config |
| self._stage_cache_key: tuple[object, ...] | None = None |
| self._stage_cache_image: Image.Image | None = None |
| self._font_cache: dict[tuple[int, bool], ImageFont.ImageFont] = {} |
|
|
| def compose( |
| self, |
| size: tuple[int, int], |
| background: Image.Image | None, |
| characters: Iterable[CharacterSprite], |
| dialogue: DialogueState, |
| ) -> Image.Image: |
| width, height = size |
| frame = self._stage(size, background, tuple(characters)).copy() |
| self._draw_dialogue(frame, dialogue) |
| return frame.convert("RGB") |
|
|
| def _stage( |
| self, |
| size: tuple[int, int], |
| background: Image.Image | None, |
| characters: tuple[CharacterSprite, ...], |
| ) -> Image.Image: |
| width, height = size |
| key = ( |
| width, |
| height, |
| id(background), |
| tuple((char.tag, id(char.image), char.position) for char in characters), |
| ) |
| if key == self._stage_cache_key and self._stage_cache_image is not None: |
| return self._stage_cache_image |
|
|
| frame = Image.new("RGBA", size, (19, 21, 26, 255)) |
| if background is not None: |
| frame.alpha_composite(self._cover(background, size), (0, 0)) |
|
|
| for character in characters: |
| self._paste_character(frame, character) |
|
|
| self._stage_cache_key = key |
| self._stage_cache_image = frame |
| return frame |
|
|
| def _cover(self, image: Image.Image, size: tuple[int, int]) -> Image.Image: |
| width, height = size |
| scale = max(width / image.width, height / image.height) |
| new_size = (max(1, int(image.width * scale)), max(1, int(image.height * scale))) |
| resized = image.resize(new_size, Image.Resampling.LANCZOS) |
| left = (resized.width - width) // 2 |
| top = (resized.height - height) // 2 |
| return resized.crop((left, top, left + width, top + height)) |
|
|
| def _paste_character(self, frame: Image.Image, character: CharacterSprite) -> None: |
| width, height = frame.size |
| max_height = int(height * self.config.character_max_height_ratio) |
| max_width = int(width * self.config.character_max_width_ratio) |
| scale = min(max_height / character.image.height, max_width / character.image.width) |
| new_size = ( |
| max(1, int(character.image.width * scale)), |
| max(1, int(character.image.height * scale)), |
| ) |
| sprite = character.image.resize(new_size, Image.Resampling.LANCZOS) |
| anchor_x = self._position_to_x(character.position, width) |
| left = int(anchor_x - sprite.width / 2) |
| left = max(-sprite.width // 3, min(width - sprite.width * 2 // 3, left)) |
| top = height - sprite.height |
| frame.alpha_composite(sprite, (left, top)) |
|
|
| @staticmethod |
| def _position_to_x(position: Position, width: int) -> float: |
| if isinstance(position, float): |
| return width * position |
| if position == "left": |
| return width * 0.28 |
| if position == "right": |
| return width * 0.72 |
| return width * 0.5 |
|
|
| def _draw_dialogue(self, frame: Image.Image, dialogue: DialogueState) -> None: |
| if dialogue.mode not in {"say", "input", "loading"}: |
| return |
|
|
| draw = ImageDraw.Draw(frame, "RGBA") |
| width, height = frame.size |
| margin = min(self.config.dialogue_margin, max(8, width // 30)) |
| panel_height = min(self.config.dialogue_height, height - margin * 2) |
| left = margin |
| top = height - panel_height - margin |
| right = width - margin |
| bottom = height - margin |
|
|
| draw.rounded_rectangle( |
| (left, top, right, bottom), |
| radius=self.config.dialogue_radius, |
| fill=(0, 0, 0, self.config.dialogue_alpha), |
| ) |
|
|
| name_font = self._font(self.config.name_font_size, bold=True) |
| text_font = self._font(self.config.text_font_size, bold=False) |
| prompt_font = self._font(self.config.prompt_font_size, bold=False) |
| pad_x = self.config.dialogue_padding_x |
| pad_y = self.config.dialogue_padding_y |
| text_left = left + pad_x |
| text_right = right - pad_x |
| name_y = top + pad_y |
| body_y = name_y + self.config.name_font_size + 14 |
|
|
| if dialogue.speaker: |
| draw.text((text_left, name_y), dialogue.speaker, font=name_font, fill=(142, 220, 255, 255)) |
|
|
| if dialogue.mode == "input": |
| if dialogue.prompt: |
| prompt_bottom = self._draw_wrapped( |
| draw, |
| dialogue.prompt, |
| prompt_font, |
| (232, 237, 243, 235), |
| (text_left, body_y, text_right, bottom - 62), |
| ) |
| else: |
| prompt_bottom = body_y |
| self._draw_wrapped( |
| draw, |
| dialogue.display_input_with_caret(), |
| text_font, |
| (255, 255, 255, 255), |
| (text_left, prompt_bottom + 12, text_right, bottom - pad_y), |
| ) |
| return |
|
|
| if dialogue.mode == "loading": |
| self._draw_wrapped( |
| draw, |
| dialogue.visible_text, |
| text_font, |
| (255, 255, 255, 255), |
| (text_left, body_y, text_right, bottom - pad_y), |
| ) |
| return |
|
|
| self._draw_wrapped( |
| draw, |
| dialogue.visible_text, |
| text_font, |
| (255, 255, 255, 255), |
| (text_left, body_y, text_right, bottom - pad_y), |
| ) |
|
|
| if dialogue.is_complete and not self.config.auto_advance: |
| indicator_font = self._font(24, bold=True) |
| draw.text((right - 48, bottom - 42), ">", font=indicator_font, fill=(255, 255, 255, 220)) |
|
|
| def _draw_wrapped( |
| self, |
| draw: ImageDraw.ImageDraw, |
| text: str, |
| font: ImageFont.ImageFont, |
| fill: tuple[int, int, int, int], |
| box: tuple[int, int, int, int], |
| ) -> int: |
| left, top, right, bottom = box |
| line_height = self._line_height(font) + self.config.line_spacing |
| lines = self._wrap_text(draw, text, font, max(1, right - left)) |
| max_lines = max(1, (bottom - top) // line_height) |
| if len(lines) > max_lines: |
| lines = lines[-max_lines:] |
|
|
| y = top |
| for line in lines: |
| if y + line_height > bottom + self.config.line_spacing: |
| break |
| draw.text((left, y), line, font=font, fill=fill) |
| y += line_height |
| return y |
|
|
| def _wrap_text( |
| self, |
| draw: ImageDraw.ImageDraw, |
| text: str, |
| font: ImageFont.ImageFont, |
| max_width: int, |
| ) -> list[str]: |
| if not text: |
| return [""] |
|
|
| lines: list[str] = [] |
| for raw_line in text.splitlines() or [""]: |
| words = raw_line.split(" ") |
| current = "" |
| for word in words: |
| candidate = word if not current else f"{current} {word}" |
| if self._text_width(draw, candidate, font) <= max_width: |
| current = candidate |
| continue |
| if current: |
| lines.append(current) |
| current = self._break_long_word(draw, word, font, max_width, lines) |
| lines.append(current) |
| return lines |
|
|
| def _break_long_word( |
| self, |
| draw: ImageDraw.ImageDraw, |
| word: str, |
| font: ImageFont.ImageFont, |
| max_width: int, |
| lines: list[str], |
| ) -> str: |
| current = "" |
| for char in word: |
| candidate = current + char |
| if self._text_width(draw, candidate, font) <= max_width: |
| current = candidate |
| else: |
| if current: |
| lines.append(current) |
| current = char |
| return current |
|
|
| @staticmethod |
| def _text_width(draw: ImageDraw.ImageDraw, text: str, font: ImageFont.ImageFont) -> int: |
| bbox = draw.textbbox((0, 0), text, font=font) |
| return bbox[2] - bbox[0] |
|
|
| @staticmethod |
| def _line_height(font: ImageFont.ImageFont) -> int: |
| bbox = font.getbbox("Ag") |
| return bbox[3] - bbox[1] |
|
|
| def _font(self, size: int, bold: bool) -> ImageFont.ImageFont: |
| key = (size, bold) |
| if key in self._font_cache: |
| return self._font_cache[key] |
|
|
| font_names = ( |
| ("segoeuib.ttf", "arialbd.ttf") if bold else ("segoeui.ttf", "arial.ttf") |
| ) |
| candidates: list[str | Path] = [] |
| windows_fonts = Path("C:/Windows/Fonts") |
| for name in font_names: |
| candidates.append(name) |
| candidates.append(windows_fonts / name) |
|
|
| for candidate in candidates: |
| try: |
| font = ImageFont.truetype(str(candidate), size=size) |
| self._font_cache[key] = font |
| return font |
| except OSError: |
| continue |
|
|
| font = ImageFont.load_default() |
| self._font_cache[key] = font |
| return font |
|
|
