kraken-engine 1.2.1__cp313-cp313-macosx_11_0_arm64.whl

pykraken/_core/window.pyi

@@ -0,0 +1,113 @@
+"""
+Window related functions
+"""
+from __future__ import annotations
+import pykraken._core
+__all__: list[str] = ['close', 'create', 'get_scale', 'get_size', 'get_title', 'is_fullscreen', 'is_open', 'save_screenshot', 'set_fullscreen', 'set_icon', 'set_title']
+def close() -> None:
+    """
+    Close the window.
+    
+    Marks the window as closed, typically used to signal the main loop to exit.
+    This doesn't destroy the window immediately but sets the close flag.
+    """
+def create(title: str, resolution: pykraken._core.Vec2, scaled: bool = False) -> None:
+    """
+    Create a window with specified title and size.
+    
+    Args:
+        title (str): The window title. Must be non-empty and <= 255 characters.
+        resolution (Vec2): The renderer resolution as (width, height).
+        scaled (bool, optional): If True, creates a scaled up window using the
+                                display's usable bounds, retaining the resolution's ratio.
+                                Defaults to False.
+    
+    Raises:
+        RuntimeError: If a window already exists or window creation fails.
+        ValueError: If title is empty, exceeds 255 characters, or size values are <= 0.
+    """
+def get_scale() -> int:
+    """
+    Get the scale of the window relative to the renderer resolution.
+    
+    Returns:
+        int: The window's scale
+    
+    Raises:
+        RuntimeError: If the window is not initialized.
+    """
+def get_size() -> pykraken._core.Vec2:
+    """
+    Get the current size of the window.
+    
+    Returns:
+        tuple[float, float]: The window size as (width, height).
+    
+    Raises:
+        RuntimeError: If the window is not initialized.
+    """
+def get_title() -> str:
+    """
+    Get the current title of the window.
+    
+    Returns:
+        str: The current window title.
+    
+    Raises:
+        RuntimeError: If the window is not initialized.
+    """
+def is_fullscreen() -> bool:
+    """
+    Check if the window is in fullscreen mode.
+    
+    Returns:
+        bool: True if the window is currently in fullscreen mode.
+    
+    Raises:
+        RuntimeError: If the window is not initialized.
+    """
+def is_open() -> bool:
+    """
+    Check if the window is open.
+    
+    Returns:
+        bool: True if the window is open and active.
+    """
+def save_screenshot(path: str) -> None:
+    """
+    Save a screenshot of the current frame to a file.
+    
+    Args:
+        path (str): The path to save the screenshot to.
+    """
+def set_fullscreen(fullscreen: bool) -> None:
+    """
+    Set the fullscreen mode of the window.
+    
+    Args:
+        fullscreen (bool): True to enable fullscreen mode, False for windowed mode.
+    
+    Raises:
+        RuntimeError: If the window is not initialized.
+    """
+def set_icon(path: str) -> None:
+    """
+    Set the window icon from an image file.
+    
+    Args:
+        path (str): The file path to the image to use as the icon.
+    
+    Raises:
+        RuntimeError: If the window is not initialized or icon setting fails.
+    """
+def set_title(title: str) -> None:
+    """
+    Set the title of the window.
+    
+    Args:
+        title (str): The new window title. Must be non-empty and <= 255 characters.
+    
+    Raises:
+        RuntimeError: If the window is not initialized or title setting fails.
+        ValueError: If title is empty or exceeds 255 characters.
+    """

pykraken/shader_uniform.py

@@ -0,0 +1,55 @@
+from pydantic import BaseModel
+import struct
+
+
+class ShaderUniform(BaseModel):
+    """
+    Base class for shader uniform data structures.
+    
+    Inherits from Pydantic's BaseModel to provide type validation and serialization
+    for shader uniform buffers. Subclass this to define your shader's uniform layout,
+    and use `to_bytes()` to convert the data to a binary format suitable for upload
+    to the GPU via `ShaderState.set_uniform()`.
+    
+    Supported field types:
+        - float: Packed as 'f' (4 bytes)
+        - int: Packed as 'i' (4 bytes, signed)
+        - bool: Packed as '?' (1 byte)
+        - tuple/list of 2-4 floats: Packed as vectors (vec2, vec3, vec4)
+    """
+    
+    def to_bytes(self) -> bytes:
+        """
+        Converts the uniform data to a packed binary format.
+        
+        Serializes all fields in the model to a bytes object using Python's struct
+        module, suitable for uploading to GPU uniform buffers. The packing format
+        is automatically determined based on field types.
+        
+        Returns:
+            bytes: The packed binary representation of the uniform data.
+        
+        Raises:
+            ValueError: If a tuple/list field has an invalid length (not 2, 3, or 4).
+            TypeError: If a field has an unsupported type.
+        """
+        fmt = ""
+        values = []
+        
+        for name, value in self.model_dump().items():
+            if isinstance(value, float):
+                fmt += "f"; values.append(value)
+            elif isinstance(value, int):
+                fmt += "i"; values.append(value)
+            elif isinstance(value, bool):
+                fmt += "?"; values.append(value)
+            elif isinstance(value, (tuple, list)):
+                n = len(value)
+                if n not in (2, 3, 4):
+                    raise ValueError(f"Field '{name}' length {n} invalid, must be 2, 3, or 4.")
+                fmt += f"{n}f"
+                values.extend(map(float, value))
+            else:
+                raise TypeError(f"Unsupported uniform field '{name}' of type '{type(value)}'")
+
+        return struct.pack(fmt, *values)

pykraken/shader_uniform.pyi

@@ -0,0 +1,59 @@
+from __future__ import annotations
+import inspect
+import pydantic._internal._decorators
+import pydantic.main
+from pydantic.main import BaseModel
+import pydantic_core._pydantic_core
+import struct as struct
+import typing
+__all__: list[str] = ['BaseModel', 'ShaderUniform', 'struct']
+class ShaderUniform(pydantic.main.BaseModel):
+    """
+    
+    Base class for shader uniform data structures.
+    
+    Inherits from Pydantic's BaseModel to provide type validation and serialization
+    for shader uniform buffers. Subclass this to define your shader's uniform layout,
+    and use `to_bytes()` to convert the data to a binary format suitable for upload
+    to the GPU via `ShaderState.set_uniform()`.
+    
+    Supported field types:
+        - float: Packed as 'f' (4 bytes)
+        - int: Packed as 'i' (4 bytes, signed)
+        - bool: Packed as '?' (1 byte)
+        - tuple/list of 2-4 floats: Packed as vectors (vec2, vec3, vec4)
+    """
+    __abstractmethods__: typing.ClassVar[frozenset]  # value = frozenset()
+    __class_vars__: typing.ClassVar[set] = set()
+    __private_attributes__: typing.ClassVar[dict] = {}
+    __pydantic_complete__: typing.ClassVar[bool] = True
+    __pydantic_computed_fields__: typing.ClassVar[dict] = {}
+    __pydantic_core_schema__: typing.ClassVar[dict] = {'type': 'model', 'cls': ShaderUniform, 'schema': {'type': 'model-fields', 'fields': {}, 'model_name': 'ShaderUniform', 'computed_fields': list()}, 'custom_init': False, 'root_model': False, 'config': {'title': 'ShaderUniform'}, 'ref': 'pykraken.shader_uniform.ShaderUniform:3103675912064', 'metadata': {'pydantic_js_functions': [pydantic.main.BaseModel.__get_pydantic_json_schema__]}}
+    __pydantic_custom_init__: typing.ClassVar[bool] = False
+    __pydantic_decorators__: typing.ClassVar[pydantic._internal._decorators.DecoratorInfos]  # value = DecoratorInfos(validators={}, field_validators={}, root_validators={}, field_serializers={}, model_serializers={}, model_validators={}, computed_fields={})
+    __pydantic_fields__: typing.ClassVar[dict] = {}
+    __pydantic_generic_metadata__: typing.ClassVar[dict] = {'origin': None, 'args': tuple(), 'parameters': tuple()}
+    __pydantic_parent_namespace__ = None
+    __pydantic_post_init__ = None
+    __pydantic_serializer__: typing.ClassVar[pydantic_core._pydantic_core.SchemaSerializer]  # value = SchemaSerializer(serializer=Model(...
+    __pydantic_setattr_handlers__: typing.ClassVar[dict] = {}
+    __pydantic_validator__: typing.ClassVar[pydantic_core._pydantic_core.SchemaValidator]  # value = SchemaValidator(title="ShaderUniform", validator=Model(...
+    __signature__: typing.ClassVar[inspect.Signature]  # value = <Signature () -> None>
+    _abc_impl: typing.ClassVar[_abc._abc_data]  # value = <_abc._abc_data object>
+    model_config: typing.ClassVar[dict] = {}
+    def to_bytes(self) -> bytes:
+        """
+        
+        Converts the uniform data to a packed binary format.
+        
+        Serializes all fields in the model to a bytes object using Python's struct
+        module, suitable for uploading to GPU uniform buffers. The packing format
+        is automatically determined based on field types.
+        
+        Returns:
+            bytes: The packed binary representation of the uniform data.
+        
+        Raises:
+            ValueError: If a tuple/list field has an invalid length (not 2, 3, or 4).
+            TypeError: If a field has an unsupported type.
+        """