体验 pyimgui

# coding: utf-8

from __future__ import annotations

import ctypes as ct
from pathlib import Path
from typing import Any, Callable, Optional, Set, Tuple, Union

import imgui  # type: ignore
import pyglet  # type: ignore
from attrs import define
from imgui.integrations.pyglet import create_renderer  # type: ignore
from PIL import Image
from pyglet import gl

__all__ = ["SimpleWin"]

_Render = Union[
    imgui.integrations.pyglet.PygletFixedPipelineRenderer,
    imgui.integrations.pyglet.PygletProgrammablePipelineRenderer,
]


@define
class SimpleWin:
    window: pyglet.window.Window
    impl: _Render

    @classmethod
    def create(
        cls,
        width: Optional[int] = None,
        height: Optional[int] = None,
        *,
        caption: Optional[str] = None,
        resizable: bool = True,
        fullscreen: bool = False,
        center: bool = True,
    ) -> SimpleWin:
        display = pyglet.canvas.Display()
        screen = display.get_default_screen()
        screen_width = screen.width
        screen_height = screen.height

        if width is None:
            win_width = screen_width
        else:
            win_width = min(width, screen_width)

        if height is None:
            win_height = screen_height
        else:
            win_height = min(height, screen_height)

        window = pyglet.window.Window(
            width=win_width,
            height=win_height,
            resizable=resizable,
            caption=caption,
            fullscreen=fullscreen,
        )

        if center and not fullscreen:
            window.set_location((screen_width - win_width) // 2, (screen_height - win_height) // 2)

        gl.glClearColor(1, 1, 1, 1)
        imgui.create_context()
        impl = create_renderer(window)

        return SimpleWin(window, impl)

    @staticmethod
    def default_screen_size() -> Tuple[int, int]:
        screen = pyglet.canvas.get_display().get_default_screen()
        return screen.width, screen.height

    @staticmethod
    def make_glyph_ranges(characters: Set[str]) -> Any:
        chars = sorted({ord(c) for c in characters})

        # 需要将连续的区域合成一个[begin,end]（注意：inclusive）的区间，最后一个结尾是0

        index_list = (
            [None] + [i for i in range(1, len(chars)) if chars[i] - chars[i - 1] > 1] + [None]
        )
        partitions = [chars[index_list[j - 1] : index_list[j]] for j in range(1, len(index_list))]

        def params():
            for p in partitions:
                yield p[0]
                yield p[-1]
            yield 0

        return imgui.GlyphRanges(list(params()))

    @staticmethod
    def make_glyph_ranges_from_file(path: str) -> Any:
        chars: Set[str] = set()

        src_path = Path(path)
        if src_path.is_dir():
            for f in src_path.rglob("*.py"):
                with open(f, "rt", encoding="utf-8") as fp:
                    chars = chars.union(fp.read())
        else:
            with open(src_path, "rt", encoding="utf-8") as fp:
                chars = chars.union(fp.read())

        return SimpleWin.make_glyph_ranges(chars)

    def load_font(self, font_path: Union[str, Path], font_size: int, glyph_ranges: Any) -> Any:
        io = imgui.get_io()

        path = font_path.as_posix() if isinstance(font_path, Path) else font_path

        font = io.fonts.add_font_from_file_ttf(path, font_size, glyph_ranges=glyph_ranges)
        self.impl.refresh_font_texture()
        return font

    def load_chs_font(
        self, font_path: Union[str, Path], font_size: int, full_chinese: bool = False
    ) -> Any:
        io = imgui.get_io()

        if full_chinese:
            glyph_ranges = io.fonts.get_glyph_ranges_chinese_full()
        else:
            glyph_ranges = io.fonts.get_glyph_ranges_chinese()

        return self.load_font(font_path, font_size, glyph_ranges)

    @staticmethod
    def load_image(
        image_path: Path, width: Optional[int] = None, height: Optional[int] = None
    ) -> object:
        image = Image.open(image_path)
        if width is not None and height is not None:
            image.resize((width, height))
        image_data = image.convert("RGBA").tobytes()
        w = image.width
        h = image.height
        image.close()

        texture = gl.GLuint()
        gl.glGenTextures(1, ct.pointer(texture))
        gl.glActiveTexture(gl.GL_TEXTURE0)
        gl.glBindTexture(gl.GL_TEXTURE_2D, texture)
        gl.glTexImage2D(
            gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, w, h, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, image_data
        )
        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE)
        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE)

        return texture

    @staticmethod
    def quit():
        pyglet.app.exit()

    def run(self, update: Callable[[], None]):
        def draw(_dt):
            self.impl.process_inputs()
            update()
            self.window.clear()
            imgui.render()
            self.impl.render(imgui.get_draw_data())

        pyglet.clock.schedule_interval(draw, 1 / 120.0)
        pyglet.app.run()
        self.impl.shutdown()