fake-bge-module 20250104__py3-none-any.whl → 20250201__py3-none-any.whl

bpy/utils/__init__.pyi

@@ -26,7 +26,9 @@ def app_template_paths(*, path: str | None = None):
     :return: App template paths.
     """
 
-def blend_paths(absolute: bool = False, packed: bool = False, local: bool = False):
+def blend_paths(
+    absolute: bool = False, packed: bool = False, local: bool = False
+) -> list[str]:
     """Returns a list of paths to external files referenced by the loaded .blend file.
 
     :param absolute: When true the paths returned are made absolute.
@@ -36,6 +38,7 @@ def blend_paths(absolute: bool = False, packed: bool = False, local: bool = Fals
     :param local: When true skip linked library paths.
     :type local: bool
     :return: path list.
+    :rtype: list[str]
     """
 
 def escape_identifier(string: str) -> str:
@@ -47,15 +50,23 @@ def escape_identifier(string: str) -> str:
     :rtype: str
     """
 
-def execfile(filepath: str, *, mod=None):
+def execfile(filepath: str, *, mod: None | None = None):
     """Execute a file path as a Python script.
 
     :param filepath: Path of the script to execute.
     :type filepath: str
     :param mod: Optional cached module, the result of a previous execution.
+    :type mod: None | None
     :return: The module which can be passed back in as mod.
     """
 
+def expose_bundled_modules():
+    """For Blender as a Python module, add bundled VFX library python bindings
+    to sys.path. These may be used instead of dedicated packages, to ensure
+    the libraries are compatible with Blender.
+
+    """
+
 def extension_path_user(package: str, *, path: str = "", create: bool = False) -> str:
     """Return a user writable directory associated with an extension.
 
@@ -125,7 +136,9 @@ def load_scripts_extensions(*, reload_scripts: bool = False):
         :type reload_scripts: bool
     """
 
-def make_rna_paths(struct_name: str, prop_name: str, enum_name: str) -> str:
+def make_rna_paths(
+    struct_name: str, prop_name: str, enum_name: str
+) -> tuple[str, str, str]:
     """Create RNA "paths" from given names.
 
         :param struct_name: Name of a RNA struct (like e.g. "Scene").
@@ -137,7 +150,7 @@ def make_rna_paths(struct_name: str, prop_name: str, enum_name: str) -> str:
         :return: A triple of three "RNA paths"
     (most_complete_path, "struct.prop", "struct.prop:'enum'").
     If no enum_name is given, the third element will always be void.
-        :rtype: str
+        :rtype: tuple[str, str, str]
     """
 
 def manual_language_code(default="en") -> str:
@@ -149,7 +162,7 @@ def manual_language_code(default="en") -> str:
     """
 
 def manual_map(): ...
-def modules_from_path(path: str, loaded_modules):
+def modules_from_path(path: str, loaded_modules) -> list:
     """Load all modules in a path and return them as a list.
 
         :param path: this path is scanned for scripts and packages.
@@ -157,30 +170,41 @@ def modules_from_path(path: str, loaded_modules):
         :param loaded_modules: already loaded module names, files matching these
     names will be ignored.
         :return: all loaded modules.
+        :rtype: list
     """
 
 def preset_find(name, preset_path, *, display_name=False, ext=".py"): ...
-def preset_paths(subdir: str):
+def preset_paths(subdir: str) -> list[str]:
     """Returns a list of paths for a specific preset.
 
     :param subdir: preset subdirectory (must not be an absolute path).
     :type subdir: str
     :return: Script paths.
+    :rtype: list[str]
     """
 
 def refresh_script_paths():
     """Run this after creating new script paths to update sys.path"""
 
-def register_class(cls: typing.Any):
+def register_class(
+    cls: type[
+        bpy.types.Panel
+        | bpy.types.UIList
+        | bpy.types.Menu
+        | bpy.types.Header
+        | bpy.types.Operator
+        | bpy.types.KeyingSetInfo
+        | bpy.types.RenderEngine
+        | bpy.types.AssetShelf
+        | bpy.types.FileHandler
+        | bpy.types.PropertyGroup
+        | bpy.types.AddonPreferences
+    ],
+):
     """Register a subclass of a Blender type class.
 
-        :param cls: Blender type class in:
-    `bpy.types.Panel`, `bpy.types.UIList`,
-    `bpy.types.Menu`, `bpy.types.Header`,
-    `bpy.types.Operator`, `bpy.types.KeyingSetInfo`,
-    `bpy.types.RenderEngine`, `bpy.types.AssetShelf`,
-    `bpy.types.FileHandler`
-        :type cls: typing.Any
+    :param cls: Registerable Blender class type.
+    :type cls: type[bpy.types.Panel | bpy.types.UIList | bpy.types.Menu | bpy.types.Header | bpy.types.Operator | bpy.types.KeyingSetInfo | bpy.types.RenderEngine | bpy.types.AssetShelf | bpy.types.FileHandler | bpy.types.PropertyGroup | bpy.types.AddonPreferences]
     """
 
 def register_classes_factory(classes):
@@ -223,8 +247,8 @@ def register_preset_path(path: str) -> bool:
     """
 
 def register_submodule_factory(
-    module_name: str, submodule_names
-) -> collections.abc.Callable:
+    module_name: str, submodule_names: list[str]
+) -> tuple[collections.abc.Callable[None], collections.abc.Callable[None]]:
     """Utility function to create register and unregister functions
     which simply load submodules,
     calling their register & unregister functions.
@@ -232,14 +256,15 @@ def register_submodule_factory(
         :param module_name: The module name, typically __name__.
         :type module_name: str
         :param submodule_names: List of submodule names to load and unload.
+        :type submodule_names: list[str]
         :return: register and unregister functions.
-        :rtype: collections.abc.Callable
+        :rtype: tuple[collections.abc.Callable[None], collections.abc.Callable[None]]
     """
 
 def register_tool(
     tool_cls: bpy.types.WorkSpaceTool,
     *,
-    after=None,
+    after: None | collections.abc.Sequence[str] | None = None,
     separator: bool = False,
     group: bool = False,
 ):
@@ -248,6 +273,7 @@ def register_tool(
     :param tool_cls: A tool subclass.
     :type tool_cls: bpy.types.WorkSpaceTool
     :param after: Optional identifiers this tool will be added after.
+    :type after: None | collections.abc.Sequence[str] | None
     :param separator: When true, add a separator before this tool.
     :type separator: bool
     :param group: When true, add a new nested group of tools.
@@ -279,7 +305,7 @@ def script_paths(
     check_all: bool = False,
     use_user: bool = True,
     use_system_environment: bool = True,
-):
+) -> list[str]:
     """Returns a list of valid script paths.
 
     :param subdir: Optional subdir.
@@ -293,6 +319,7 @@ def script_paths(
     :param use_system_environment: Include BLENDER_SYSTEM_SCRIPTS variable path
     :type use_system_environment: bool
     :return: script paths.
+    :rtype: list[str]
     """
 
 def script_paths_pref():
@@ -301,37 +328,42 @@ def script_paths_pref():
 def script_paths_system_environment():
     """Returns a list of system script directories from environment variables."""
 
-def smpte_from_frame(frame, *, fps=None, fps_base=None) -> str:
+def smpte_from_frame(frame: float, *, fps=None, fps_base=None) -> str:
     """Returns an SMPTE formatted string from the frame:
     HH:MM:SS:FF.If fps and fps_base are not given the current scene is used.
 
         :param frame: frame number.
+        :type frame: float
         :return: the frame string.
         :rtype: str
     """
 
-def smpte_from_seconds(time, *, fps=None, fps_base=None) -> str:
+def smpte_from_seconds(time: float, *, fps=None, fps_base=None) -> str:
     """Returns an SMPTE formatted string from the time:
     HH:MM:SS:FF.If fps and fps_base are not given the current scene is used.
 
         :param time: time in seconds.
+        :type time: float
         :return: the frame string.
         :rtype: str
     """
 
-def time_from_frame(frame, *, fps=None, fps_base=None):
+def time_from_frame(frame: float, *, fps=None, fps_base=None):
     """Returns the time from a frame number .If fps and fps_base are not given the current scene is used.
 
     :param frame: number.
+    :type frame: float
     :return: the time in seconds.
     """
 
-def time_to_frame(time, *, fps=None, fps_base=None):
+def time_to_frame(time: float, *, fps=None, fps_base=None) -> float:
     """Returns a float frame number from a time given in seconds or
     as a datetime.timedelta object.If fps and fps_base are not given the current scene is used.
 
         :param time: time in seconds.
+        :type time: float
         :return: The frame.
+        :rtype: float
     """
 
 def unescape_identifier(string: str) -> str:
@@ -344,13 +376,27 @@ def unescape_identifier(string: str) -> str:
         :rtype: str
     """
 
-def unregister_class(cls: typing.Any):
+def unregister_class(
+    cls: type[
+        bpy.types.Panel
+        | bpy.types.UIList
+        | bpy.types.Menu
+        | bpy.types.Header
+        | bpy.types.Operator
+        | bpy.types.KeyingSetInfo
+        | bpy.types.RenderEngine
+        | bpy.types.AssetShelf
+        | bpy.types.FileHandler
+        | bpy.types.PropertyGroup
+        | bpy.types.AddonPreferences
+    ],
+):
     """Unload the Python class from blender.
 
         :param cls: Blender type class,
     see `bpy.utils.register_class` for classes which can
     be registered.
-        :type cls: typing.Any
+        :type cls: type[bpy.types.Panel | bpy.types.UIList | bpy.types.Menu | bpy.types.Header | bpy.types.Operator | bpy.types.KeyingSetInfo | bpy.types.RenderEngine | bpy.types.AssetShelf | bpy.types.FileHandler | bpy.types.PropertyGroup | bpy.types.AddonPreferences]
     """
 
 def unregister_cli_command(handle):

bpy/utils/previews/__init__.pyi

@@ -32,7 +32,7 @@ class ImagePreviewCollection:
     def load(
         self,
         name: str | None,
-        filepath,
+        filepath: bytes | str | None,
         filetype: str | None,
         force_reload: bool | None = False,
     ) -> bpy.types.ImagePreview:
@@ -41,6 +41,7 @@ class ImagePreviewCollection:
         :param name: The name (unique id) identifying the preview.
         :type name: str | None
         :param filepath: The file path to generate the preview from.
+        :type filepath: bytes | str | None
         :param filetype: The type of file, needed to generate the preview in ['IMAGE', 'MOVIE', 'BLEND', 'FONT'].
         :type filetype: str | None
         :param force_reload: If True, force running thumbnail manager even if preview already exists in cache.

bpy/utils/units/__init__.pyi

@@ -38,7 +38,7 @@ def to_value(
     unit_system: str | None,
     unit_category: str | None,
     str_input: str | None,
-    str_ref_unit=None,
+    str_ref_unit: None | str | None = None,
 ) -> float:
     """Convert a given input string into a float value.
 
@@ -50,6 +50,7 @@ def to_value(
         :param str_input: The string to convert to a float value.
         :type str_input: str | None
         :param str_ref_unit: A reference string from which to extract a default unit, if none is found in str_input.
+        :type str_ref_unit: None | str | None
         :return: The converted/interpreted value.
         :rtype: float
     """

bpy_extras/anim_utils/__init__.pyi

@@ -63,21 +63,25 @@ class KeyframesCo:
                 :type action_group_name: str
         """
 
-def bake_action(obj: bpy.types.Object, *, action, frames: int, bake_options):
+def bake_action(
+    obj: bpy.types.Object, *, action: None | bpy.types.Action, frames: int, bake_options
+) -> None | bpy.types.Action:
     """
 
         :param obj: Object to bake.
         :type obj: bpy.types.Object
         :param action: An action to bake the data into, or None for a new action
     to be created.
+        :type action: None | bpy.types.Action
         :param frames: Frames to bake.
         :type frames: int
         :param bake_options: Options for baking.
         :return: Action or None.
+        :rtype: None | bpy.types.Action
     """
 
 def bake_action_iter(
-    obj: bpy.types.Object, *, action, bake_options
+    obj: bpy.types.Object, *, action: None | bpy.types.Action, bake_options
 ) -> bpy.types.Action:
     """An coroutine that bakes action for a single object.
 
@@ -85,17 +89,21 @@ def bake_action_iter(
         :type obj: bpy.types.Object
         :param action: An action to bake the data into, or None for a new action
     to be created.
+        :type action: None | bpy.types.Action
         :param bake_options: Boolean options of what to include into the action bake.
         :return: an action or None
         :rtype: bpy.types.Action
     """
 
-def bake_action_objects(object_action_pairs, *, frames, bake_options):
+def bake_action_objects(
+    object_action_pairs, *, frames, bake_options
+) -> collections.abc.Sequence[bpy.types.Action]:
     """A version of `bake_action_objects_iter` that takes frames and returns the output.
 
     :param frames: Frames to bake.
     :param bake_options: Options for baking.
     :return: A sequence of Action or None types (aligned with object_action_pairs)
+    :rtype: collections.abc.Sequence[bpy.types.Action]
     """
 
 def bake_action_objects_iter(object_action_pairs, bake_options):

bpy_extras/bmesh_utils/__init__.pyi

@@ -2,12 +2,13 @@ import typing
 import collections.abc
 import typing_extensions
 
-def bmesh_linked_uv_islands(bm, uv_layer):
+def bmesh_linked_uv_islands(bm, uv_layer) -> list[list[int]]:
     """Returns lists of faces connected by UV islands.For meshes use `bpy.types.Mesh.mesh_linked_uv_islands` instead.
 
     :param bm: the bmesh used to group with.
     :param uv_layer: the UV layer to source UVs from.
     :return: list of lists containing polygon indices
+    :rtype: list[list[int]]
     """
 
 def match_uv(face, vert, uv, uv_layer): ...

bpy_extras/image_utils/__init__.pyi

@@ -1,6 +1,7 @@
 import typing
 import collections.abc
 import typing_extensions
+import bpy.types
 
 def load_image(
     imagepath,
@@ -10,10 +11,10 @@ def load_image(
     ncase_cmp: bool = True,
     convert_callback: typing.Any | None = None,
     verbose=False,
-    relpath=None,
+    relpath: None | str | None = None,
     check_existing: bool = False,
     force_reload: bool = False,
-):
+) -> None | bpy.types.Image:
     """Return an image from the file path with options to search multiple paths
     and return a placeholder if its not found.
 
@@ -36,6 +37,7 @@ def load_image(
     For formats blender can read, simply return the path that is given.
         :type convert_callback: typing.Any | None
         :param relpath: If not None, make the file relative to this path.
+        :type relpath: None | str | None
         :param check_existing: If true,
     returns already loaded image datablock if possible
     (based on file path).
@@ -45,4 +47,5 @@ def load_image(
     is also enabled).
         :type force_reload: bool
         :return: an image or None
+        :rtype: None | bpy.types.Image
     """

bpy_extras/io_utils/__init__.pyi

@@ -2,6 +2,7 @@ import typing
 import collections.abc
 import typing_extensions
 import bpy.types
+import mathutils
 
 class ExportHelper:
     def check(self, _context):
@@ -60,14 +61,18 @@ def axis_conversion_ensure(
         :rtype: bool
     """
 
-def create_derived_objects(depsgraph: bpy.types.Depsgraph, objects):
+def create_derived_objects(
+    depsgraph: bpy.types.Depsgraph, objects: collections.abc.Sequence[bpy.types.Object]
+) -> dict[bpy.types.Object, list[tuple[bpy.types.Object, mathutils.Matrix]]]:
     """This function takes a sequence of objects, returning their instances.
 
         :param depsgraph: The evaluated depsgraph.
         :type depsgraph: bpy.types.Depsgraph
         :param objects: A sequencer of objects.
+        :type objects: collections.abc.Sequence[bpy.types.Object]
         :return: A dictionary where each key is an object from objects,
     values are lists of (object, matrix) tuples representing instances.
+        :rtype: dict[bpy.types.Object, list[tuple[bpy.types.Object, mathutils.Matrix]]]
     """
 
 def orientation_helper(axis_forward="Y", axis_up="Z"):
@@ -83,7 +88,7 @@ def path_reference(
     mode: str = "AUTO",
     copy_subdir: str = "",
     copy_set=None,
-    library=None,
+    library: None | bpy.types.Library | None = None,
 ) -> str:
     """Return a filepath relative to a destination directory, for use with
     exporters.
@@ -105,16 +110,17 @@ def path_reference(
         :param copy_set: collect from/to pairs when mode='COPY',
     pass to path_reference_copy when exporting is done.
         :param library: The library this path is relative to.
+        :type library: None | bpy.types.Library | None
         :return: the new filepath.
         :rtype: str
     """
 
-def path_reference_copy(copy_set, report: collections.abc.Callable = print):
+def path_reference_copy(copy_set, report: collections.abc.Callable[str, None] = print):
     """Execute copying files of path_reference
 
     :param copy_set: set of (from, to) pairs to copy.
     :param report: function used for reporting warnings, takes a string argument.
-    :type report: collections.abc.Callable
+    :type report: collections.abc.Callable[str, None]
     """
 
 def poll_file_object_drop(context):
@@ -124,7 +130,7 @@ def poll_file_object_drop(context):
     """
 
 def unique_name(
-    key,
+    key: typing.Any,
     name: str,
     name_dict: dict,
     name_max=-1,
@@ -138,6 +144,7 @@ def unique_name(
     when available.
     This can be the object, mesh, material, etc instance itself.
     Any hashable object associated with the name.
+        :type key: typing.Any
         :param name: The name used to create a unique value in name_dict.
         :type name: str
         :param name_dict: This is used to cache namespace to ensure no collisions

bpy_extras/mesh_utils/__init__.pyi

@@ -2,17 +2,20 @@ import typing
 import collections.abc
 import typing_extensions
 import bpy.types
+import mathutils
 
-def edge_face_count(mesh):
+def edge_face_count(mesh) -> list[int]:
     """
 
     :return: list face users for each item in mesh.edges.
+    :rtype: list[int]
     """
 
-def edge_face_count_dict(mesh):
+def edge_face_count_dict(mesh) -> dict[tuple[int, int], int]:
     """
 
     :return: Dictionary of edge keys with their value set to the number of faces using each edge.
+    :rtype: dict[tuple[int, int], int]
     """
 
 def edge_loops_from_edges(mesh, edges=None):
@@ -21,43 +24,61 @@ def edge_loops_from_edges(mesh, edges=None):
 
     """
 
-def mesh_linked_triangles(mesh: bpy.types.Mesh):
+def mesh_linked_triangles(
+    mesh: bpy.types.Mesh,
+) -> list[list[bpy.types.MeshLoopTriangle]]:
     """Splits the mesh into connected triangles, use this for separating cubes from
     other mesh elements within 1 mesh data-block.
 
         :param mesh: the mesh used to group with.
         :type mesh: bpy.types.Mesh
         :return: Lists of lists containing triangles.
+        :rtype: list[list[bpy.types.MeshLoopTriangle]]
     """
 
-def mesh_linked_uv_islands(mesh: bpy.types.Mesh):
+def mesh_linked_uv_islands(mesh: bpy.types.Mesh) -> list[list[int]]:
     """Returns lists of polygon indices connected by UV islands.
 
     :param mesh: the mesh used to group with.
     :type mesh: bpy.types.Mesh
     :return: list of lists containing polygon indices
+    :rtype: list[list[int]]
     """
 
-def ngon_tessellate(from_data, indices, fix_loops: bool = True, debug_print=True):
+def ngon_tessellate(
+    from_data: bpy.types.Mesh
+    | list[collections.abc.Sequence[float]]
+    | tuple[collections.abc.Sequence[float]],
+    indices: list[int],
+    fix_loops: bool = True,
+    debug_print=True,
+):
     """Takes a poly-line of indices (ngon) and returns a list of face
     index lists. Designed to be used for importers that need indices for an
     ngon to create from existing verts.
 
         :param from_data: Either a mesh, or a list/tuple of 3D vectors.
+        :type from_data: bpy.types.Mesh | list[collections.abc.Sequence[float]] | tuple[collections.abc.Sequence[float]]
         :param indices: a list of indices to use this list
     is the ordered closed poly-line
     to fill, and can be a subset of the data given.
+        :type indices: list[int]
         :param fix_loops: If this is enabled poly-lines
     that use loops to make multiple
     poly-lines are dealt with correctly.
         :type fix_loops: bool
     """
 
-def triangle_random_points(num_points: int, loop_triangles):
+def triangle_random_points(
+    num_points: int,
+    loop_triangles: collections.abc.Sequence[bpy.types.MeshLoopTriangle],
+) -> list[mathutils.Vector]:
     """Generates a list of random points over mesh loop triangles.
 
     :param num_points: The number of random points to generate on each triangle.
     :type num_points: int
     :param loop_triangles: Sequence of the triangles to generate points on.
+    :type loop_triangles: collections.abc.Sequence[bpy.types.MeshLoopTriangle]
     :return: List of random points over all triangles.
+    :rtype: list[mathutils.Vector]
     """

bpy_extras/object_utils/__init__.pyi

@@ -12,12 +12,12 @@ class AddObjectHelper:
         """
 
 def add_object_align_init(
-    context: bpy.types.Context | None, operator: bpy.types.Operator
+    context: bpy.types.Context, operator: bpy.types.Operator
 ) -> mathutils.Matrix:
     """Return a matrix using the operator settings and view context.
 
     :param context: The context to use.
-    :type context: bpy.types.Context | None
+    :type context: bpy.types.Context
     :param operator: The operator, checked for location and rotation properties.
     :type operator: bpy.types.Operator
     :return: the matrix from the context and settings.
@@ -34,8 +34,8 @@ def object_add_grid_scale_apply_operator(operator, context):
     """Scale an operators distance values by the grid size."""
 
 def object_data_add(
-    context: bpy.types.Context | None,
-    obdata,
+    context: bpy.types.Context,
+    obdata: None | bpy.types.ID,
     operator: bpy.types.Operator | None = None,
     name: str | None = None,
 ) -> bpy.types.Object:
@@ -43,8 +43,9 @@ def object_data_add(
     location, rotation and layer.
 
         :param context: The context to use.
-        :type context: bpy.types.Context | None
+        :type context: bpy.types.Context
         :param obdata: Valid object data to used for the new object or None.
+        :type obdata: None | bpy.types.ID
         :param operator: The operator, checked for location and rotation properties.
         :type operator: bpy.types.Operator | None
         :param name: Optional name

bpy_extras/view3d_utils/__init__.pyi

@@ -10,7 +10,7 @@ def location_3d_to_region_2d(
     coord: collections.abc.Sequence[float] | mathutils.Vector,
     *,
     default=None,
-):
+) -> mathutils.Vector | typing.Any:
     """Return the region relative 2d location of a 3d position.
 
         :param region: region of the 3D viewport, typically bpy.context.region.
@@ -22,6 +22,7 @@ def location_3d_to_region_2d(
         :param default: Return this value if coord
     is behind the origin of a perspective view.
         :return: 2d location
+        :rtype: mathutils.Vector | typing.Any
     """
 
 def region_2d_to_location_3d(
@@ -48,7 +49,11 @@ def region_2d_to_location_3d(
     """
 
 def region_2d_to_origin_3d(
-    region: bpy.types.Region, rv3d: bpy.types.RegionView3D, coord, *, clamp=None
+    region: bpy.types.Region,
+    rv3d: bpy.types.RegionView3D,
+    coord: collections.abc.Sequence[float],
+    *,
+    clamp: None | float | None = None,
 ) -> mathutils.Vector:
     """Return the 3d view origin from the region relative 2d coords.
 
@@ -58,8 +63,10 @@ def region_2d_to_origin_3d(
         :type rv3d: bpy.types.RegionView3D
         :param coord: 2D coordinates relative to the region;
     (event.mouse_region_x, event.mouse_region_y) for example.
+        :type coord: collections.abc.Sequence[float]
         :param clamp: Clamp the maximum far-clip value used.
     (negative value will move the offset away from the view_location)
+        :type clamp: None | float | None
         :return: The origin of the viewpoint in 3d space.
         :rtype: mathutils.Vector
     """

{fake_bge_module-20250104.dist-info → fake_bge_module-20250201.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: fake-bge-module
-Version: 20250104
+Version: 20250201
 Summary: Collection of the fake Blender Game Engine (BGE) Python API module for the code completion.
 Author: nutti
 Author-email: nutti.metro@gmail.com
@@ -21,7 +21,7 @@ Classifier: Topic :: Text Editors :: Integrated Development Environments (IDE)
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.12
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 
 # Fake Blender Game Engine (BGE) Python API module collection: fake-bge-module