fake-bge-module 20250312__py3-none-any.whl → 20260203__py3-none-any.whl

bl_ui/utils/__init__.pyi

@@ -1,20 +1,21 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 class PresetPanel:
     bl_label: typing.Any
     bl_region_type: typing.Any
     bl_space_type: typing.Any
 
-    def draw(self, context):
+    def draw(self, context) -> None:
         """
 
         :param context:
         """
 
     @classmethod
-    def draw_menu(cls, layout, text=None):
+    def draw_menu(cls, layout, text=None) -> None:
         """
 
         :param layout:
@@ -22,7 +23,7 @@ class PresetPanel:
         """
 
     @classmethod
-    def draw_panel_header(cls, layout):
+    def draw_panel_header(cls, layout) -> None:
         """
 
         :param layout:

blend_render_info/__init__.pyi

@@ -1,9 +1,11 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 class RawBlendFileReader:
     """Return a file handle to the raw blend file data (abstracting compressed formats)."""
 
-def main(): ...
-def read_blend_rend_chunk(filepath): ...
+def get_render_info_structure(endian_str, size) -> None: ...
+def main() -> None: ...
+def read_blend_rend_chunk(filepath) -> None: ...

blf/__init__.pyi

@@ -9,171 +9,204 @@ need to use the GPU module gpu as well.
 
 ```../examples/blf.py```
 
+
+--------------------
+
+Example showing how text can be draw into an image.
+This can be done by binding an image buffer (imbuf) to the font's ID.
+
+```../examples/blf.1.py```
+
 """
 
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
+import imbuf.types
+
+def ascender(fontid: int) -> float:
+    """Return the max height of the glyphs from the baseline.
 
-def aspect(fontid: int, aspect: float):
+    :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
+    :return: The ascender.
+    """
+
+def aspect(fontid: int, aspect: float) -> None:
     """Set the aspect for drawing text.
 
     :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
-    :type fontid: int
     :param aspect: The aspect ratio for text drawing to use.
-    :type aspect: float
     """
 
-def clipping(fontid: int, xmin: float, ymin: float, xmax: float, ymax: float):
+def bind_imbuf(fontid: int, imbuf: imbuf.types.ImBuf) -> None:
+    """Context manager to draw text into an image buffer instead of the GPUs context.
+
+    :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
+    :param imbuf: The image to draw into.
+    :return: The BLF ImBuf context manager.
+    """
+
+def boundbox(fontid: int, text: str) -> tuple[int, int, int, int]:
+    """Return the bounding box of the text.
+
+    :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
+    :param text: the text to measure.
+    :return: the bounding box (xmin, ymin, xmax, ymax).
+    """
+
+def bounds_max(fontid: int) -> tuple[float, float, float, float]:
+    """Return the maximum bounding box of the font.
+
+    :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
+    :return: the maximum bounding box (xmin, ymin, xmax, ymax).
+    """
+
+def clipping(fontid: int, xmin: float, ymin: float, xmax: float, ymax: float) -> None:
     """Set the clipping, enable/disable using CLIPPING.
 
     :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
-    :type fontid: int
     :param xmin: Clip the drawing area by these bounds.
-    :type xmin: float
     :param ymin: Clip the drawing area by these bounds.
-    :type ymin: float
     :param xmax: Clip the drawing area by these bounds.
-    :type xmax: float
     :param ymax: Clip the drawing area by these bounds.
-    :type ymax: float
     """
 
-def color(fontid: int, r: float, g: float, b: float, a: float):
+def color(fontid: int, r: float, g: float, b: float, a: float) -> None:
     """Set the color for drawing text.
 
     :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
-    :type fontid: int
     :param r: red channel 0.0 - 1.0.
-    :type r: float
     :param g: green channel 0.0 - 1.0.
-    :type g: float
     :param b: blue channel 0.0 - 1.0.
-    :type b: float
     :param a: alpha channel 0.0 - 1.0.
-    :type a: float
+    """
+
+def descender(fontid: int) -> float:
+    """Return the max depth of the glyphs from the baseline.
+
+    :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
+    :return: The descender.
     """
 
 def dimensions(fontid: int, text: str) -> tuple[float, float]:
     """Return the width and height of the text.
 
     :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
-    :type fontid: int
     :param text: the text to draw.
-    :type text: str
     :return: the width and height of the text.
-    :rtype: tuple[float, float]
     """
 
-def disable(fontid: int, option: int):
+def disable(fontid: int, option: int) -> None:
     """Disable option.
 
     :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
-    :type fontid: int
     :param option: One of ROTATION, CLIPPING, SHADOW or KERNING_DEFAULT.
-    :type option: int
     """
 
-def draw(fontid: int, text: str):
+def draw(fontid: int, text: str) -> None:
     """Draw text in the current context.
 
     :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
-    :type fontid: int
     :param text: the text to draw.
-    :type text: str
     """
 
-def enable(fontid: int, option: int):
+def draw_buffer(fontid: int, text: str) -> None:
+    """Draw text into the buffer bound to the fontid.
+
+    :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
+    :param text: the text to draw.
+    """
+
+def enable(fontid: int, option: int) -> None:
     """Enable option.
 
     :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
-    :type fontid: int
     :param option: One of ROTATION, CLIPPING, SHADOW or KERNING_DEFAULT.
-    :type option: int
+    """
+
+def fixed_width(fontid: int) -> float:
+    """Return the fixed width of the font (0.0 if variable width).
+
+    :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
+    :return: The fixed width.
+    """
+
+def glyph_advance(fontid: int, text: str) -> float:
+    """Return the advance width of the first character in the text.
+
+    :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
+    :param text: the text (glyph) to measure.
+    :return: The glyph advance.
+    """
+
+def height_max(fontid: int) -> float:
+    """Return the maximum height of the font (typically ascender - descender).
+
+    :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
+    :return: The maximum height.
     """
 
 def load(filepath: bytes | str) -> int:
     """Load a new font.
 
     :param filepath: the filepath of the font.
-    :type filepath: bytes | str
-    :return: the new font's fontid or -1 if there was an error.
-    :rtype: int
+    :return: the new fonts fontid or -1 if there was an error.
     """
 
-def position(fontid: int, x: float, y: float, z: float):
+def position(fontid: int, x: float, y: float, z: float) -> None:
     """Set the position for drawing text.
 
     :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
-    :type fontid: int
     :param x: X axis position to draw the text.
-    :type x: float
     :param y: Y axis position to draw the text.
-    :type y: float
     :param z: Z axis position to draw the text.
-    :type z: float
     """
 
-def rotation(fontid: int, angle: float):
+def rotation(fontid: int, angle: float) -> None:
     """Set the text rotation angle, enable/disable using ROTATION.
 
     :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
-    :type fontid: int
     :param angle: The angle for text drawing to use.
-    :type angle: float
     """
 
-def shadow(fontid: int, level: int, r: float, g: float, b: float, a: float):
+def shadow(fontid: int, level: int, r: float, g: float, b: float, a: float) -> None:
     """Shadow options, enable/disable using SHADOW .
 
     :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
-    :type fontid: int
     :param level: The blur level (0, 3, 5) or outline (6).
-    :type level: int
     :param r: Shadow color (red channel 0.0 - 1.0).
-    :type r: float
     :param g: Shadow color (green channel 0.0 - 1.0).
-    :type g: float
     :param b: Shadow color (blue channel 0.0 - 1.0).
-    :type b: float
     :param a: Shadow color (alpha channel 0.0 - 1.0).
-    :type a: float
     """
 
-def shadow_offset(fontid: int, x: float, y: float):
+def shadow_offset(fontid: int, x: int, y: int) -> None:
     """Set the offset for shadow text.
 
     :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
-    :type fontid: int
-    :param x: Vertical shadow offset value in pixels.
-    :type x: float
-    :param y: Horizontal shadow offset value in pixels.
-    :type y: float
+    :param x: Horizontal shadow offset value in pixels.
+    :param y: Vertical shadow offset value in pixels.
     """
 
-def size(fontid: int, size: float):
+def size(fontid: int, size: float) -> None:
     """Set the size for drawing text.
 
     :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
-    :type fontid: int
     :param size: Point size of the font.
-    :type size: float
     """
 
-def unload(filepath: bytes | str):
+def unload(filepath: bytes | str) -> None:
     """Unload an existing font.
 
     :param filepath: the filepath of the font.
-    :type filepath: bytes | str
     """
 
-def word_wrap(fontid: int, wrap_width: int):
+def word_wrap(fontid: int, wrap_width: int) -> None:
     """Set the wrap width, enable/disable using WORD_WRAP.
 
     :param fontid: The id of the typeface as returned by `blf.load`, for default font use 0.
-    :type fontid: int
     :param wrap_width: The width (in pixels) to wrap words at.
-    :type wrap_width: int
     """
 
 CLIPPING: typing.Any

bmesh/__init__.pyi

@@ -14,6 +14,7 @@ bmesh.geometry.rst
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import bmesh.types
 import bpy.types
 
@@ -26,30 +27,23 @@ def from_edit_mesh(mesh: bpy.types.Mesh) -> bmesh.types.BMesh:
     """Return a BMesh from this mesh, currently the mesh must already be in editmode.
 
     :param mesh: The editmode mesh.
-    :type mesh: bpy.types.Mesh
     :return: the BMesh associated with this mesh.
-    :rtype: bmesh.types.BMesh
     """
 
-def new(use_operators: bool = True) -> bmesh.types.BMesh:
+def new(*, use_operators: bool = True) -> bmesh.types.BMesh:
     """
 
     :param use_operators: Support calling operators in `bmesh.ops` (uses some extra memory per vert/edge/face).
-    :type use_operators: bool
     :return: Return a new, empty BMesh.
-    :rtype: bmesh.types.BMesh
     """
 
 def update_edit_mesh(
-    mesh: bpy.types.Mesh, loop_triangles: bool = True, destructive: bool = True
-):
+    mesh: bpy.types.Mesh, *, loop_triangles: bool = True, destructive: bool = True
+) -> None:
     """Update the mesh after changes to the BMesh in editmode,
     optionally recalculating n-gon tessellation.
 
         :param mesh: The editmode mesh.
-        :type mesh: bpy.types.Mesh
         :param loop_triangles: Option to recalculate n-gon tessellation.
-        :type loop_triangles: bool
         :param destructive: Use when geometry has been added or removed.
-        :type destructive: bool
     """

bmesh/geometry/__init__.pyi

@@ -6,18 +6,16 @@ This module provides access to bmesh geometry evaluation functions.
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import bmesh.types
 import mathutils
 
 def intersect_face_point(
     face: bmesh.types.BMFace, point: collections.abc.Sequence[float] | mathutils.Vector
 ) -> bool:
-    """Tests if the projection of a point is inside a face (using the face's normal).
+    """Tests if the projection of a point is inside a face (using the faces normal).
 
     :param face: The face to test.
-    :type face: bmesh.types.BMFace
     :param point: The point to test.
-    :type point: collections.abc.Sequence[float] | mathutils.Vector
     :return: True when the projection of the point is in the face.
-    :rtype: bool
     """