kraken-engine 1.0.0__cp311-cp311-macosx_11_0_arm64.whl → 1.1.0__cp311-cp311-macosx_11_0_arm64.whl

pykraken/_core/collision.pyi

@@ -0,0 +1,235 @@
+"""
+Collision detection functions
+"""
+from __future__ import annotations
+import pykraken._core
+import typing
+__all__: list[str] = ['contains', 'overlap']
+@typing.overload
+def contains(outer: pykraken._core.Rect, inner: pykraken._core.Rect) -> bool:
+    """
+    Checks if one rectangle completely contains another rectangle.
+    
+    Parameters:
+        outer (Rect): The outer rectangle.
+        inner (Rect): The inner rectangle.
+    
+    Returns:
+        bool: Whether the outer rectangle completely contains the inner rectangle.
+    """
+@typing.overload
+def contains(rect: pykraken._core.Rect, circle: pykraken._core.Circle) -> bool:
+    """
+    Checks if a rectangle completely contains a circle.
+    
+    Parameters:
+        rect (Rect): The rectangle.
+        circle (Circle): The circle.
+    
+    Returns:
+        bool: Whether the rectangle completely contains the circle.
+    """
+@typing.overload
+def contains(rect: pykraken._core.Rect, line: pykraken._core.Line) -> bool:
+    """
+    Checks if a rectangle completely contains a line.
+    
+    Parameters:
+        rect (Rect): The rectangle.
+        line (Line): The line.
+    
+    Returns:
+        bool: Whether the rectangle completely contains the line.
+    """
+@typing.overload
+def contains(outer: pykraken._core.Circle, inner: pykraken._core.Circle) -> bool:
+    """
+    Checks if one circle completely contains another circle.
+    
+    Parameters:
+        outer (Circle): The outer circle.
+        inner (Circle): The inner circle.
+    
+    Returns:
+        bool: Whether the outer circle completely contains the inner circle.
+    """
+@typing.overload
+def contains(circle: pykraken._core.Circle, rect: pykraken._core.Rect) -> bool:
+    """
+    Checks if a circle completely contains a rectangle.
+    
+    Parameters:
+        circle (Circle): The circle.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: Whether the circle completely contains the rectangle.
+    """
+@typing.overload
+def contains(circle: pykraken._core.Circle, line: pykraken._core.Line) -> bool:
+    """
+    Checks if a circle completely contains a line.
+    
+    Parameters:
+        circle (Circle): The circle.
+        line (Line): The line.
+    
+    Returns:
+        bool: Whether the circle completely contains the line.
+    """
+@typing.overload
+def overlap(a: pykraken._core.Rect, b: pykraken._core.Rect) -> bool:
+    """
+    Checks if two rectangles overlap.
+    
+    Parameters:
+        a (Rect): The first rectangle.
+        b (Rect): The second rectangle.
+    
+    Returns:
+        bool: Whether the rectangles overlap.
+    """
+@typing.overload
+def overlap(rect: pykraken._core.Rect, circle: pykraken._core.Circle) -> bool:
+    """
+    Checks if a rectangle and a circle overlap.
+    
+    Parameters:
+        rect (Rect): The rectangle.
+        circle (Circle): The circle.
+    
+    Returns:
+        bool: Whether the rectangle and circle overlap.
+    """
+@typing.overload
+def overlap(rect: pykraken._core.Rect, line: pykraken._core.Line) -> bool:
+    """
+    Checks if a rectangle and a line overlap.
+    
+    Parameters:
+        rect (Rect): The rectangle.
+        line (Line): The line.
+    
+    Returns:
+        bool: Whether the rectangle and line overlap.
+    """
+@typing.overload
+def overlap(rect: pykraken._core.Rect, point: pykraken._core.Vec2) -> bool:
+    """
+    Checks if a rectangle contains a point.
+    
+    Parameters:
+        rect (Rect): The rectangle.
+        point (Vec2): The point.
+    
+    Returns:
+        bool: Whether the rectangle contains the point.
+    """
+@typing.overload
+def overlap(a: pykraken._core.Circle, b: pykraken._core.Circle) -> bool:
+    """
+    Checks if two circles overlap.
+    
+    Parameters:
+        a (Circle): The first circle.
+        b (Circle): The second circle.
+    
+    Returns:
+        bool: Whether the circles overlap.
+    """
+@typing.overload
+def overlap(circle: pykraken._core.Circle, rect: pykraken._core.Rect) -> bool:
+    """
+    Checks if a circle and a rectangle overlap.
+    
+    Parameters:
+        circle (Circle): The circle.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: Whether the circle and rectangle overlap.
+    """
+@typing.overload
+def overlap(circle: pykraken._core.Circle, line: pykraken._core.Line) -> bool:
+    """
+    Checks if a circle and a line overlap.
+    
+    Parameters:
+        circle (Circle): The circle.
+        line (Line): The line.
+    
+    Returns:
+        bool: Whether the circle and line overlap.
+    """
+@typing.overload
+def overlap(circle: pykraken._core.Circle, point: pykraken._core.Vec2) -> bool:
+    """
+    Checks if a circle contains a point.
+    
+    Parameters:
+        circle (Circle): The circle.
+        point (Vec2): The point.
+    
+    Returns:
+        bool: Whether the circle contains the point.
+    """
+@typing.overload
+def overlap(a: pykraken._core.Line, b: pykraken._core.Line) -> bool:
+    """
+    Checks if two lines overlap (intersect).
+    
+    Parameters:
+        a (Line): The first line.
+        b (Line): The second line.
+    
+    Returns:
+        bool: Whether the lines intersect.
+    """
+@typing.overload
+def overlap(line: pykraken._core.Line, rect: pykraken._core.Rect) -> bool:
+    """
+    Checks if a line and a rectangle overlap.
+    
+    Parameters:
+        line (Line): The line.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: Whether the line and rectangle overlap.
+    """
+@typing.overload
+def overlap(line: pykraken._core.Line, circle: pykraken._core.Circle) -> bool:
+    """
+    Checks if a line and a circle overlap.
+    
+    Parameters:
+        line (Line): The line.
+        circle (Circle): The circle.
+    
+    Returns:
+        bool: Whether the line and circle overlap.
+    """
+@typing.overload
+def overlap(point: pykraken._core.Vec2, rect: pykraken._core.Rect) -> bool:
+    """
+    Checks if a point is inside a rectangle.
+    
+    Parameters:
+        point (Vec2): The point.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: Whether the point is inside the rectangle.
+    """
+@typing.overload
+def overlap(point: pykraken._core.Vec2, circle: pykraken._core.Circle) -> bool:
+    """
+    Checks if a point is inside a circle.
+    
+    Parameters:
+        point (Vec2): The point.
+        circle (Circle): The circle.
+    
+    Returns:
+        bool: Whether the point is inside the circle.
+    """

pykraken/_core/renderer.pyi

@@ -4,7 +4,7 @@ Functions for rendering graphics
 from __future__ import annotations
 import pykraken._core
 import typing
-__all__: list[str] = ['clear', 'draw', 'get_res', 'present']
+__all__: list[str] = ['clear', 'draw', 'get_res', 'present', 'read_pixels']
 @typing.overload
 def clear(color: typing.Any = None) -> None:
     """
@@ -30,22 +30,22 @@ def clear(r: typing.SupportsInt, g: typing.SupportsInt, b: typing.SupportsInt, a
 @typing.overload
 def draw(texture: pykraken._core.Texture, dst: pykraken._core.Rect, src: typing.Any = None) -> None:
     """
-        Render a texture with specified destination and source rectangles.
+    Render a texture with specified destination and source rectangles.
     
-        Args:
-            texture (Texture): The texture to render.
-            dst (Rect): The destination rectangle on the renderer.
-            src (Rect, optional): The source rectangle from the texture. Defaults to entire texture if not specified.
+    Args:
+        texture (Texture): The texture to render.
+        dst (Rect): The destination rectangle on the renderer.
+        src (Rect, optional): The source rectangle from the texture. Defaults to entire texture if not specified.
     """
 @typing.overload
 def draw(texture: pykraken._core.Texture, pos: typing.Any = None, anchor: pykraken._core.Anchor = pykraken._core.Anchor.CENTER) -> None:
     """
-        Render a texture at the specified position with anchor alignment.
+    Render a texture at the specified position with anchor alignment.
     
-        Args:
-            texture (Texture): The texture to render.
-            pos (Vec2, optional): The position to draw at. Defaults to (0, 0).
-            anchor (Anchor, optional): The anchor point for positioning. Defaults to CENTER.
+    Args:
+        texture (Texture): The texture to render.
+        pos (Vec2, optional): The position to draw at. Defaults to (0, 0).
+        anchor (Anchor, optional): The anchor point for positioning. Defaults to CENTER.
     """
 def get_res() -> pykraken._core.Vec2:
     """
@@ -61,3 +61,14 @@ def present() -> None:
     This finalizes the current frame and displays it. Should be called after
     all drawing operations for the frame are complete.
     """
+def read_pixels(src: typing.Any = None) -> pykraken._core.PixelArray:
+    """
+    Read pixel data from the renderer within the specified rectangle.
+    
+    Args:
+        src (Rect, optional): The rectangle area to read pixels from. Defaults to entire renderer if None.
+    Returns:
+        PixelArray: An array containing the pixel data.
+    Raises:
+        RuntimeError: If reading pixels fails.
+    """

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:2062985552560', '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.
+        """