pyglet 2.1.2__py3-none-any.whl → 2.1.4__py3-none-any.whl

pyglet/font/harfbuzz/__init__.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import TYPE_CHECKING
+from ctypes import c_void_p, c_uint16, c_uint32, string_at, create_string_buffer, py_object, cast, POINTER
+import sys
+
+from pyglet.font.base import GlyphPosition
+
+if TYPE_CHECKING:
+    from pyglet.font.freetype import FreeTypeFont
+    from pyglet.font.dwrite import Win32DirectWriteFont
+    from pyglet.font.quartz import QuartzFont
+    from pyglet.font.base import Font, Glyph
+
+from .harfbuzz_lib import hb_lib
+_available = False
+
+if hb_lib:
+    _available = True
+
+from .harfbuzz_lib import HB_MEMORY_MODE_READONLY, HB_DIRECTION_LTR
+
+
+def harfbuzz_available() -> bool:
+    """Return if the Harfbuzz library is available to use."""
+    return _available
+
+
+_hb_cache: dict[tuple[str, str, bool, str | bool], _HarfbuzzResources] = {}
+
+
+def _add_utf16_buffer(text: str, buffer: c_void_p) -> None:
+    txt_utf16 = text.encode("utf-16-le")  # HarfBuzz expects little-endian UTF-16
+    length = len(txt_utf16) // 2
+    txt_array = (c_uint16 * length).from_buffer_copy(txt_utf16)
+    hb_lib.hb_buffer_add_utf16(buffer, txt_array, length, 0, length)
+
+def _add_utf32_buffer(text: str, buffer: c_void_p) -> None:
+    txt_utf32 = text.encode("utf-32-le")
+    char_ct = (len(txt_utf32) // 4)
+    txt_array = (c_uint32 * char_ct).from_buffer_copy(txt_utf32)
+    hb_lib.hb_buffer_add_utf32(buffer, txt_array,char_ct, 0, char_ct)
+
+
+# Set which unicode python is using for the strings.
+if sys.maxunicode == 0x10FFFF:  # UTF-32
+    set_buffer_string = _add_utf32_buffer
+elif sys.maxunicode == 0xFFFF:  # UTF-16
+    set_buffer_string = _add_utf16_buffer
+
+def get_resource_from_ct_font(font: QuartzFont):
+    """Get a harfbuzz resource object from a CoreText (Mac) font."""
+    key = (font.name, font.weight, font.italic, font.stretch)
+    if key in _hb_cache:
+        return _hb_cache[key]
+
+    resource = _HarfbuzzResources()
+    hb_face = font._get_hb_face()
+    resource.load_from_tabled_face(hb_face)
+    _hb_cache[key] = resource
+    return resource
+
+
+def get_resource_from_dw_font(font: Win32DirectWriteFont) -> _HarfbuzzResources:
+    """Get a harfbuzz resource object from a DirectWrite (Windows) font."""
+    key = (font.name, font.weight, font.italic, font.stretch)
+    if key in _hb_cache:
+        return _hb_cache[key]
+
+    data = font.get_font_data()
+    if data:
+        resource = _HarfbuzzResources()
+        resource.load_from_memory(data)
+        _hb_cache[key] = resource
+        return resource
+
+    raise Exception("Font data could not be read.")
+
+def get_resource_from_ft_font(font: FreeTypeFont) -> _HarfbuzzResources:
+    """Get a harfbuzz resource object from a FreeType (Linux) font."""
+    key = (font.name, font.weight, font.italic, font.stretch)
+    if key in _hb_cache:
+        return _hb_cache[key]
+
+    stream = font.face.ft_face.contents.stream.contents
+    data = string_at(stream.base, stream.size)
+    resource = _HarfbuzzResources()
+    resource.load_from_memory(data)
+    _hb_cache[key] = resource
+    return resource
+
+
+def get_resource_from_path(font_path: str):
+    with open(font_path, "rb") as f:
+        data = f.read()
+
+    resource = _HarfbuzzResources()
+    resource.load_from_memory(data)
+    return resource
+
+def _get_fallback_glyph_shape(font: Font, text: str) -> tuple[list[Glyph], list[GlyphPosition]]:
+    glyphs = []
+    offsets = []
+    pystr_len = len(text)
+    for fallback in font.fallbacks:
+        glyph_info = fallback.hb_resource.shape_text(text, fallback.pixel_size)
+
+        indices = [glyph_data["codepoint"] for glyph_data in glyph_info]
+        fallback.render_glyph_indices(indices)
+
+        for glyph_data in glyph_info:
+            glyph = fallback.glyphs[glyph_data["codepoint"]]
+            glyphs.append(glyph)
+            offset =  GlyphPosition(glyph_data["x_advance"]-glyph.advance, glyph_data["y_advance"],
+                                         glyph_data["x_offset"], glyph_data["y_offset"])
+            offsets.append(offset)
+
+    diff = pystr_len - len(glyphs)
+    if diff > 0:
+        for i in range(diff):
+            glyphs.append(font._zero_glyph)
+            offsets.append(GlyphPosition(0, 0, 0, 0))
+
+    return glyphs, offsets
+
+def get_harfbuzz_shaped_glyphs(font: Font, text: str) -> tuple[list[Glyph], list[GlyphPosition]]:
+    glyph_info = font.hb_resource.shape_text(text, font.pixel_size)
+    clusters = [glyph_data["cluster"] for glyph_data in glyph_info]
+    cluster_map = defaultdict(list)
+
+    # Find any clusters that have empty indices.
+    empty_clusters = {}
+    indices = []
+    for glyph_data in glyph_info:
+        # If any clusters have no codepoint, determine the size to pass to fallback.
+        cluster_num = glyph_data["cluster"]
+        glyph_index = glyph_data["codepoint"]
+        if glyph_index == 0 and cluster_num not in empty_clusters:
+            empty_clusters[cluster_num] = clusters.count(cluster_num)
+
+        if cluster_num not in cluster_map:
+            cluster_map[cluster_num] = []
+
+        cluster_map[cluster_num].append(glyph_data)
+        indices.append(glyph_index)
+
+    font.render_glyph_indices(indices)
+
+    # If a cluster is missing and had 0 indices.
+    missing_glyphs = {}
+    for cluster_id, cluster_ct in empty_clusters.items():
+        missing_text = text[cluster_id:cluster_id + cluster_ct]
+        if missing_text not in font.glyphs:
+            if missing_text == '\n':
+                fb_glyph_info = ([font._zero_glyph], [GlyphPosition(0, 0, 0, 0)])
+            else:
+                # Get glyphs from fallback, since we need the fallback to actually render it.
+                fb_glyph_info = _get_fallback_glyph_shape(font, missing_text)
+            font.glyphs[missing_text] = fb_glyph_info  # Cache by string to prevent future fallback paths.
+        missing_glyphs[cluster_id] = font.glyphs[missing_text]
+
+    glyphs = []
+    offsets = []
+    for i in range(len(text)):
+        cluster_glyph_info = cluster_map[i]
+
+        # Cluster has data, check if it's part of the missing glyphs.
+        if i in missing_glyphs:
+            _glyphs, _offsets = missing_glyphs[i]
+            glyphs.extend(_glyphs)
+            offsets.extend(_offsets)
+
+        # If this cluster is missing, add some zero glyphs until count matches.
+        elif len(cluster_glyph_info) == 0:
+            while len(glyphs) - 1 < i:
+                glyphs.append(font._zero_glyph)
+                offsets.append(GlyphPosition(0, 0, 0, 0))
+        else:
+            for glyph_info in cluster_glyph_info:
+                glyph = font.glyphs[glyph_info["codepoint"]]
+                glyphs.append(glyph)
+
+                offsets.append(
+                    GlyphPosition(glyph_info["x_advance"] - glyph.advance, glyph_info["y_advance"],
+                                  glyph_info["x_offset"], glyph_info["y_offset"])
+                )
+
+    return glyphs, offsets
+
+
+class _HarfbuzzResources:
+    def __init__(self) -> None:
+        self.blob = None
+        self.face = None
+        self.font = None
+
+    def load_from_tabled_face(self, hb_face: c_void_p) -> None:
+        self.blob = None
+        self.face = hb_face
+        self.font = hb_lib.hb_font_create(self.face)
+
+    def load_from_memory(self, data: bytes) -> None:
+        data_len = len(data)
+        data_buf = create_string_buffer(data, data_len)
+        self.blob = hb_lib.hb_blob_create(data_buf, data_len, HB_MEMORY_MODE_READONLY, None, None)
+        self.face = hb_lib.hb_face_create(self.blob, 0)
+        self.font = hb_lib.hb_font_create(self.face)
+
+    def shape_text(self, text: str, pixel_size: int, direction: int=HB_DIRECTION_LTR):
+        """Shapes the given string using the provided hb_font.
+        Returns a list of dictionaries for each glyph containing:
+          - codepoint: the glyph index
+          - cluster: the index into the original string
+          - x_advance, y_advance: the advances (including kerning adjustments)
+          - x_offset, y_offset: the offsets (shaped adjustments)
+        """
+        # Create a new buffer.
+        buf = hb_lib.hb_buffer_create()
+
+        # hb_lib.hb_buffer_set_cluster_level(buf, HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS)
+        set_buffer_string(text, buf)
+
+        scale = int(pixel_size * 64)
+        hb_lib.hb_font_set_scale(self.font, scale, scale)
+
+        hb_lib.hb_buffer_guess_segment_properties(buf)
+
+        # Set text direction (LTR, RTL, etc.).
+        hb_lib.hb_buffer_set_direction(buf, direction)
+
+        # Perform shaping.
+        hb_lib.hb_shape(self.font, buf, None, 0)
+
+        # Retrieve the number of glyphs.
+        length = hb_lib.hb_buffer_get_length(buf)
+
+        # Get pointers to the glyph info and position arrays.
+        infos = hb_lib.hb_buffer_get_glyph_infos(buf, None)
+        positions = hb_lib.hb_buffer_get_glyph_positions(buf, None)
+
+        # Collect glyph metrics.
+        glyphs = []
+        for i in range(length):
+            info = infos[i]
+            pos = positions[i]
+            glyphs.append({
+                "codepoint": info.codepoint,
+                "cluster": info.cluster,
+                "x_advance": pos.x_advance / 64.0,
+                "y_advance": pos.y_advance / 64.0,
+                "x_offset": pos.x_offset / 64.0,
+                "y_offset": pos.y_offset / 64.0,
+            })
+
+        # Clean up the buffer.
+        hb_lib.hb_buffer_destroy(buf)
+
+        return glyphs
+
+    def __del__(self):
+        self.destroy()
+
+    def destroy(self):
+        if self.font:
+            hb_lib.hb_font_destroy(self.font)
+            self.font = None
+
+        if self.face:
+            hb_lib.hb_face_destroy(self.face)
+            self.face = None
+
+        if self.blob:
+            hb_lib.hb_blob_destroy(self.blob)
+            self.blob = None

pyglet/font/harfbuzz/harfbuzz_lib.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import contextlib
+from ctypes import (
+    CFUNCTYPE,
+    POINTER,
+    Structure,
+    Union,
+    c_char_p,
+    c_int,
+    c_int8,
+    c_int16,
+    c_int32,
+    c_size_t,
+    c_uint,
+    c_uint8,
+    c_uint16,
+    c_uint32,
+    c_void_p,
+)
+
+import pyglet
+
+# Harfbuzz DLL depends on libglib and libintl (for Windows)
+hb_lib = None
+with contextlib.suppress(ImportError):
+    hb_lib = pyglet.lib.load_library("harfbuzz", win32='libharfbuzz-0.dll', darwin='libharfbuzz.0.dylib')
+
+
+HB_MEMORY_MODE_READONLY = 0  # for read-only font data
+
+HB_DIRECTION_INVALID = 0
+HB_DIRECTION_LTR = 4
+HB_DIRECTION_RTL = 5
+HB_DIRECTION_TTB = 6
+HB_DIRECTION_BTT = 7
+
+HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES = 0
+HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS = 1
+HB_BUFFER_CLUSTER_LEVEL_CHARACTERS = 2
+HB_BUFFER_CLUSTER_LEVEL_DEFAULT = HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES
+
+HB_GLYPH_FLAG_UNSAFE_TO_BREAK = 0x00000001
+HB_GLYPH_FLAG_UNSAFE_TO_CONCAT = 0x00000002
+HB_GLYPH_FLAG_SAFE_TO_INSERT_TATWEEL = 0x00000004
+
+HB_GLYPH_FLAG_DEFINED = 0x00000007  # OR of all defined flags
+
+hb_buffer_cluster_level_t = c_uint
+
+
+class hb_var_int_t(Union):
+    _fields_ = [
+        ("u32", c_uint32),
+        ("i32", c_int32),
+        ("u16", c_uint16 * 2),
+        ("i16", c_int16 * 2),
+        ("u8", c_uint8 * 4),
+        ("i8", c_int8 * 4),
+    ]
+
+
+hb_codepoint_t = c_uint32
+hb_mask_t = c_uint32
+
+
+class hb_glyph_info_t(Structure):
+    _fields_ = [
+        ("codepoint", hb_codepoint_t),  # glyph index
+        ("mask", hb_mask_t),
+        ("cluster", c_uint32),  # index in the original text
+        ("var1", hb_var_int_t),
+        ("var2", hb_var_int_t)
+    ]
+
+    def __repr__(self) -> str:
+        return f"hb_glyph_info_t(codepoint={self.codepoint}, cluster={self.cluster}, flag={self.mask & HB_GLYPH_FLAG_DEFINED})"
+
+
+hb_position_t = c_int32
+
+
+# The glyph position structure contains advances and offsets.
+class hb_glyph_position_t(Structure):
+    _fields_ = [
+        ("x_advance", hb_position_t),  # includes kerning
+        ("y_advance", hb_position_t),
+        ("x_offset", hb_position_t),  # adjustments to the glyph's drawing position
+        ("y_offset", hb_position_t),
+        ('var', hb_var_int_t),  # Private, do not use, but must be included for proper reading.
+    ]
+
+
+if hb_lib:
+    hb_lib.hb_blob_create.argtypes = [
+        c_char_p,  # pointer to the font data  const char *data
+        c_size_t,  # length of the data
+        c_uint,  # memory mode (e.g., HB_MEMORY_MODE_READONLY)  hb_memory_mode_t
+        c_void_p,  # user data (None here)  void *user_data
+        c_void_p  # destroy callback (None here)  hb_destroy_func_t
+    ]
+    hb_lib.hb_blob_create.restype = c_void_p
+
+    hb_blob_t = c_void_p
+    hb_lib.hb_face_create.argtypes = [
+        c_void_p,  # hb_blob_t *blob
+        c_uint  # font index in the blob (usually 0)  index
+    ]
+    hb_lib.hb_face_create.restype = c_void_p
+
+    hb_reference_table_func_t = CFUNCTYPE(c_void_p, c_void_p, c_uint32, c_void_p)
+    hb_destroy_func_t = CFUNCTYPE(None, c_void_p)
+
+    hb_lib.hb_face_create_for_tables.argtypes = [
+        hb_reference_table_func_t,  # table func
+        c_void_p,  # user data ptr
+        hb_destroy_func_t  # free memory function
+    ]
+    hb_lib.hb_face_create_for_tables.restype = c_void_p
+
+    hb_lib.hb_font_create.argtypes = [c_void_p]  # hb_face_t *face
+    hb_lib.hb_font_create.restype = c_void_p
+
+    hb_lib.hb_face_get_upem.argtypes = [c_void_p]  # hb_face_t *face
+    hb_lib.hb_face_get_upem.restype = c_uint
+
+    hb_lib.hb_font_set_scale.argtypes = [
+        c_void_p,  # b_font_t *font
+        c_int,  # x_scale
+        c_int  # y_scale
+    ]
+    hb_lib.hb_font_set_scale.restype = None
+
+    hb_lib.hb_buffer_create.argtypes = []
+    hb_lib.hb_buffer_create.restype = c_void_p
+
+    hb_lib.hb_buffer_add_utf8.argtypes = [
+        c_void_p,  # b_buffer_t *buffer
+        c_char_p,  # UTF-8 text  const char *text
+        c_int,  # text length (number of bytes)
+        c_uint,  # item offset (usually 0)
+        c_int  # item length (often the same as text_length)
+    ]
+    hb_lib.hb_buffer_add_utf8.restype = None
+
+    hb_lib.hb_buffer_set_cluster_level.argtypes = [c_void_p, hb_buffer_cluster_level_t]
+    hb_lib.hb_buffer_set_cluster_level.restype = None
+
+    hb_lib.hb_buffer_add_utf16.argtypes = [
+        c_void_p,  # hb_buffer_t *buffer
+        POINTER(c_uint16),  # UTF-16 text  onst char *text
+        c_int,  # text length (number of bytes)
+        c_uint,  # item offset (usually 0)
+        c_int  # item length (often the same as text_length)
+    ]
+    hb_lib.hb_buffer_add_utf16.restype = None
+
+    hb_lib.hb_buffer_add_utf32.argtypes = [
+        c_void_p,  # hb_buffer_t *buffer
+        POINTER(c_uint32),  # UTF-32 text  const char *text
+        c_int,  # text length (number of bytes)
+        c_uint,  # item offset (usually 0)
+        c_int  # item length (often the same as text_length)
+    ]
+    hb_lib.hb_buffer_add_utf32.restype = None
+
+    hb_lib.hb_buffer_set_direction.argtypes = [
+        c_void_p,  # hb_buffer_t *buffer
+        c_int  # direction (e.g., HB_DIRECTION_LTR)  hb_direction_t
+    ]
+    hb_lib.hb_buffer_set_direction.restype = None
+
+    hb_lib.hb_shape.argtypes = [
+        c_void_p,  # hb_font_t *font
+        c_void_p,  # hb_buffer_t *buffer
+        c_void_p,  # hb_feature_t *features (None if not used)
+        c_uint  # number of features (0 if features is None)
+    ]
+    hb_lib.hb_shape.restype = None
+
+    hb_lib.hb_buffer_guess_segment_properties.argtypes = [c_void_p]
+    hb_lib.hb_buffer_guess_segment_properties.restype = None
+
+    hb_lib.hb_buffer_get_length.argtypes = [c_void_p]  # hb_buffer_t *buffer
+    hb_lib.hb_buffer_get_length.restype = c_uint
+
+    hb_lib.hb_buffer_get_glyph_infos.argtypes = [
+        c_void_p,  # hb_buffer_t *buffer,
+        POINTER(c_uint)  # pointer for length (can be None)
+    ]
+    hb_lib.hb_buffer_get_glyph_infos.restype = POINTER(hb_glyph_info_t)
+
+    hb_lib.hb_buffer_get_glyph_positions.argtypes = [
+        c_void_p,  # hb_buffer_t *buffer
+        POINTER(c_uint)  # pointer for length (can be None)
+    ]
+    hb_lib.hb_buffer_get_glyph_positions.restype = POINTER(hb_glyph_position_t)
+
+    hb_lib.hb_blob_destroy.argtypes = [c_void_p]  # b_blob_t *blob)
+    hb_lib.hb_blob_destroy.restype = None
+
+    hb_lib.hb_face_destroy.argtypes = [c_void_p]  # hb_face_t *face
+    hb_lib.hb_face_destroy.restype = None
+
+    hb_lib.hb_font_destroy.argtypes = [c_void_p]  # hb_font_t *font
+    hb_lib.hb_font_destroy.restype = None
+
+    hb_lib.hb_buffer_destroy.argtypes = [c_void_p]  # hb_buffer_t *buffer
+    hb_lib.hb_buffer_destroy.restype = None
+
+    hb_lib.hb_buffer_normalize_glyphs.argtypes = [c_void_p]
+    hb_lib.hb_buffer_normalize_glyphs.restype = None