luma-engine 0.1.0__tar.gz

luma_engine-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: luma-engine
+Version: 0.1.0
+Summary: A lightweight python game engine powered by SDL3
+Author-email: CyzmiX <itzmedigamingx@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Luma
+
+Luma is a lightweight Python game engine powered by SDL3. 

luma_engine-0.1.0/README.md

@@ -0,0 +1,3 @@
+# Luma
+
+Luma is a lightweight Python game engine powered by SDL3. 

luma_engine-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+
+[project]
+version = "0.1.0"
+name = "luma-engine"
+requires-python = ">=3.8"
+description = "A lightweight python game engine powered by SDL3"
+readme = "README.md"
+authors = [
+  { name="CyzmiX", email="itzmedigamingx@gmail.com" },
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]

luma_engine-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

luma_engine-0.1.0/src/luma/__init__.py

@@ -0,0 +1 @@
+from .core.engine import Luma

luma_engine-0.1.0/src/luma/core/engine.py

@@ -0,0 +1,214 @@
+import ctypes
+import os
+from luma.sdl.event import SDL_Event
+from luma.graphics.graphics import Luma_Graphics
+from luma.core.event import Luma_EventManager, DEFAULT_EVENTS_ENUM
+import luma.sdl.keys
+from platform import system
+import sys
+
+
+def get_sdl_path():
+    if getattr(sys, "frozen", False):
+        base = sys._MEIPASS
+    else:
+        base = os.path.dirname(__file__)
+
+    lib_ext = "dll"
+
+    if system() == "Linux":
+        lib_ext = "so"
+    elif system() == "Darwin":
+        lib_ext = "dylib"
+
+    return os.path.join(base, os.path.abspath(f"./src/luma/lib/SDL3.{lib_ext}"))
+
+
+class Luma:
+
+    SDL_INIT_AUDIO = 0x10
+    SDL_INIT_VIDEO = 0x20
+    SDL_INIT_JOYSTICK = 0x200
+    SDL_INIT_HAPTIC = 0x1000
+    SDL_INIT_GAMEPAD = 0x2000
+    SDL_INIT_EVENTS = 0x4000
+    SDL_INIT_SENSOR = 0x8000
+    SDL_INIT_CAMERA = 0x10000
+    SDL_EVENT_QUIT = 0x100
+    SDL_BLENDMODE_BLEND = 0x00000001
+
+    SDL_EVENT_KEY_DOWN = 0x300
+    SDL_EVENT_KEY_UP = 0x301
+
+    KEYS = luma.sdl.keys
+
+    EVENTS = DEFAULT_EVENTS_ENUM
+
+    def __init__(self, sdl_path: str | None = None):
+        self.window = None
+        self.renderer = None
+
+        lib_ext = "dll"
+
+        if system() == "Linux":
+            lib_ext = "so"
+        elif system() == "Darwin":
+            lib_ext = "dylib"
+
+        self.sdl_path = sdl_path or os.path.abspath(f"./src/luma/lib/SDL3.{lib_ext}")
+        self.sdl = ctypes.CDLL(self.sdl_path)
+        self._setup_functions()
+        self.graphics = None
+
+        self.running = True
+        self._draw_method = None
+        self._update_method = None
+        self.event_manager = Luma_EventManager()
+
+        self._keys_pressed = set()
+
+        self.sdl.SDL_Init(Luma.SDL_INIT_VIDEO)
+
+    def _setup_functions(self):
+        self.sdl.SDL_CreateWindow.argtypes = [
+            ctypes.c_char_p,  # title
+            ctypes.c_int,  # w
+            ctypes.c_int,  # h
+            ctypes.c_uint64,  # SDL_WindowFlags
+        ]
+
+        self.sdl.SDL_CreateWindow.restype = ctypes.c_void_p
+
+        self.sdl.SDL_CreateRenderer.argtypes = [
+            ctypes.c_void_p,  # window
+            ctypes.c_char_p,  # renderer name
+        ]
+
+        self.sdl.SDL_CreateRenderer.restype = ctypes.c_void_p
+
+        self.sdl.SDL_RenderClear.argtypes = [
+            ctypes.c_void_p,  # renderer
+        ]
+
+        self.sdl.SDL_RenderClear.restype = ctypes.c_bool
+
+        self.sdl.SDL_RenderPresent.argtypes = [
+            ctypes.c_void_p,  # renderer
+        ]
+
+        self.sdl.SDL_RenderPresent.restype = ctypes.c_bool
+
+        self.sdl.SDL_DestroyRenderer.argtypes = [
+            ctypes.c_void_p,  # renderer
+        ]
+
+        self.sdl.SDL_DestroyRenderer.restype = ctypes.c_void_p
+
+        self.sdl.SDL_DestroyWindow.argtypes = [
+            ctypes.c_void_p,  # window
+        ]
+
+        self.sdl.SDL_DestroyWindow.restype = ctypes.c_void_p
+
+        self.sdl.SDL_PollEvent.argtypes = [ctypes.POINTER(SDL_Event)]
+
+        self.sdl.SDL_PollEvent.restype = ctypes.c_bool
+
+        self.sdl.SDL_GetTicks.restype = ctypes.c_uint64
+
+        self.sdl.SDL_SetRenderDrawBlendMode.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_uint64,
+        ]
+
+        self.sdl.SDL_SetRenderDrawBlendMode.restype = ctypes.c_bool
+
+    def create_window(self, title: str, width: int, height: int, flags: int = 0):
+
+        self.window = self.sdl.SDL_CreateWindow(title.encode(), width, height, flags)
+
+        if self.window is None:
+            self.quit()
+
+        self.renderer = self.sdl.SDL_CreateRenderer(self.window, None)
+
+        if self.renderer is None:
+            self.quit()
+
+        self.sdl.SDL_SetRenderDrawBlendMode(self.renderer, Luma.SDL_BLENDMODE_BLEND)
+
+        self.graphics = Luma_Graphics(self)
+
+    def draw(self, fn):
+        self._draw_method = fn
+
+    def update(self, func):
+        self._update_method = func
+
+    def on(self, event_name: str):
+        def decorator(func):
+            self.event_manager.new_event_callback(event_name, func)
+            return func
+
+        return decorator
+
+    def isKeyHeld(self, key: str):
+        return key in self._keys_pressed
+
+    def run(self):
+        lastTime = self.sdl.SDL_GetTicks()
+        try:
+            while self.running:
+
+                now = self.sdl.SDL_GetTicks()
+
+                dt = float(now - lastTime) / 1000.0
+
+                lastTime = now
+                event = SDL_Event()
+
+                while self.sdl.SDL_PollEvent(ctypes.byref(event)):
+                    if event.type == Luma.SDL_EVENT_QUIT:
+                        self.running = False
+                        break
+
+                    if event.type == Luma.SDL_EVENT_KEY_DOWN:
+
+                        if event.key.key not in self._keys_pressed:
+                            self.event_manager.dispatch(
+                                Luma.EVENTS.KEYPRESS, event.key.key
+                            )
+
+                        self._keys_pressed.add(event.key.key)
+
+                    if event.type == Luma.SDL_EVENT_KEY_UP:
+
+                        self._keys_pressed.discard(event.key.key)
+
+                        self.event_manager.dispatch(Luma.EVENTS.KEYUP, event.key.key)
+
+                if callable(self._update_method):
+                    self._update_method(dt)
+
+                self.sdl.SDL_RenderClear(self.renderer)
+
+                if callable(self._draw_method):
+                    self._draw_method()
+
+                self.sdl.SDL_RenderPresent(self.renderer)
+
+        except Exception as e:
+            print(e)
+
+        finally:
+            self.quit()
+
+    def quit(self):
+        if self.renderer:
+            self.sdl.SDL_DestroyRenderer(self.renderer)
+        if self.window:
+            self.sdl.SDL_DestroyWindow(self.window)
+
+        self.sdl.SDL_Quit()
+
+        self.event_manager.dispatch(Luma.EVENTS.QUIT)

luma_engine-0.1.0/src/luma/core/event.py

@@ -0,0 +1,34 @@
+class DEFAULT_EVENTS_ENUM:
+    KEYPRESS = "keypress"
+    KEYUP = "keyup"
+    QUIT = "quit"
+
+
+class Luma_Event:
+    def __init__(self, name: str, callback_=None):
+        self.name = name
+
+        self.callbacks = [callback_]
+
+    def dispatch(self, *args):
+        for c in self.callbacks:
+            if callable(c):
+                c(*args)
+
+
+class Luma_EventManager:
+    def __init__(self):
+        self._events = {}
+
+    def new_event_callback(self, name, callback_):
+        if self._events.get(name):
+            self._events[name].callbacks.append(callback_)
+        else:
+            self._events[name] = Luma_Event(name, callback_)
+
+    def dispatch(self, name, *args):
+        event = self._events.get(name)
+        if not event or not hasattr(event, "callbacks"):
+            return
+
+        event.dispatch(*args)

luma_engine-0.1.0/src/luma/graphics/graphics.py

@@ -0,0 +1,69 @@
+import ctypes
+
+from typing import TYPE_CHECKING
+from luma.sdl.shapes import SDL_Rect
+
+if TYPE_CHECKING:
+    from luma.core.engine import Luma
+
+
+class Luma_Graphics:
+    OPAQUE = 255
+    TRANSPARENT = 0
+    RED = (255, 0, 0, 255)
+    GREEN = (0, 255, 0, 255)
+    BLUE = (0, 0, 255, 255)
+    BLACK = (0, 0, 0, 255)
+    WHITE = (255, 255, 255, 255)
+
+    def __init__(self, sdl: "Luma"):
+        self.engine = sdl
+        self._setup_functions()
+
+    def _setup_functions(self):
+        self.sdl.SDL_SetRenderDrawColor.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_uint8,
+            ctypes.c_uint8,
+            ctypes.c_uint8,
+            ctypes.c_uint8,
+        ]
+
+        self.sdl.SDL_SetRenderDrawColor.restype = ctypes.c_bool
+
+        self.sdl.SDL_RenderRect.argtypes = [ctypes.c_void_p, ctypes.POINTER(SDL_Rect)]
+
+        self.sdl.SDL_RenderRect.restype = ctypes.c_bool
+
+        self.sdl.SDL_RenderFillRect.argtypes = [
+            ctypes.c_void_p,
+            ctypes.POINTER(SDL_Rect),
+        ]
+
+        self.sdl.SDL_RenderFillRect.restype = ctypes.c_bool
+
+    @property
+    def renderer(self):
+        return self.engine.renderer
+
+    @property
+    def sdl(self):
+        return self.engine.sdl
+
+    def setDrawColor(self, *args):
+        if len(args) == 1 and isinstance(args[0], (tuple, list)):
+            args = args[0]
+
+        r, g, b, *alpha = args
+        a = alpha[0] if alpha else 255
+
+        self.sdl.SDL_SetRenderDrawColor(self.renderer, r, g, b, a)
+
+    def resetDrawColor(self):
+        self.sdl.SDL_SetRenderDrawColor(self.renderer, 0, 0, 0, 255)
+
+    def drawRect(self, x, y, w, h, fill: bool = True):
+        if fill:
+            self.sdl.SDL_RenderFillRect(self.renderer, SDL_Rect(x, y, w, h))
+        else:
+            self.sdl.SDL_RenderRect(self.renderer, SDL_Rect(x, y, w, h))

luma_engine-0.1.0/src/luma/sdl/event.py

@@ -0,0 +1,10 @@
+import ctypes
+from luma.sdl.keys import SDL_KeyboardEvent
+
+
+class SDL_Event(ctypes.Union):
+    _fields_ = [
+        ("type", ctypes.c_uint32),
+        ("padding", ctypes.c_uint8 * 128),
+        ("key", SDL_KeyboardEvent),
+    ]

luma_engine-0.1.0/src/luma/sdl/keys.py

@@ -0,0 +1,106 @@
+RETURN = 0x0000000D
+ESCAPE = 0x0000001B
+BACKSPACE = 0x00000008
+TAB = 0x00000009
+SPACE = 0x00000020
+EXCLAIM = 0x00000021
+DBLAPOSTROPHE = 0x00000022
+HASH = 0x00000023
+DOLLAR = 0x00000024
+PERCENT = 0x00000025
+AMPERSAND = 0x00000026
+APOSTROPHE = 0x00000027
+LEFTPAREN = 0x00000028
+RIGHTPAREN = 0x00000029
+ASTERISK = 0x0000002A
+PLUS = 0x0000002B
+COMMA = 0x0000002C
+MINUS = 0x0000002D
+PERIOD = 0x0000002E
+SLASH = 0x0000002F
+NUM_0 = 0x00000030
+NUM_1 = 0x00000031
+NUM_2 = 0x00000032
+NUM_3 = 0x00000033
+NUM_4 = 0x00000034
+NUM_5 = 0x00000035
+NUM_6 = 0x00000036
+NUM_7 = 0x00000037
+NUM_8 = 0x00000038
+NUM_9 = 0x00000039
+COLON = 0x0000003A
+SEMICOLON = 0x0000003B
+LESS = 0x0000003C
+EQUALS = 0x0000003D
+GREATER = 0x0000003E
+QUESTION = 0x0000003F
+AT = 0x00000040
+LEFTBRACKET = 0x0000005B
+BACKSLASH = 0x0000005C
+RIGHTBRACKET = 0x0000005D
+CARET = 0x0000005E
+UNDERSCORE = 0x0000005F
+GRAVE = 0x00000060
+A = 0x00000061
+B = 0x00000062
+C = 0x00000063
+D = 0x00000064
+E = 0x00000065
+F = 0x00000066
+G = 0x00000067
+H = 0x00000068
+I = 0x00000069
+J = 0x0000006A
+K = 0x0000006B
+L = 0x0000006C
+M = 0x0000006D
+N = 0x0000006E
+O = 0x0000006F
+P = 0x00000070
+Q = 0x00000071
+R = 0x00000072
+S = 0x00000073
+T = 0x00000074
+U = 0x00000075
+V = 0x00000076
+W = 0x00000077
+X = 0x00000078
+Y = 0x00000079
+Z = 0x0000007A
+LEFTBRACE = 0x0000007B
+PIPE = 0x0000007C
+RIGHTBRACE = 0x0000007D
+TILDE = 0x0000007E
+DELETE = 0x0000007F
+PLUSMINUS = 0x000000B1
+CAPSLOCK = 0x40000039
+F1 = 0x4000003A
+F2 = 0x4000003B
+F3 = 0x4000003C
+F4 = 0x4000003D
+F5 = 0x4000003E
+F6 = 0x4000003F
+F7 = 0x40000040
+F8 = 0x40000041
+F9 = 0x40000042
+F10 = 0x40000043
+F11 = 0x40000044
+F12 = 0x40000045
+
+import ctypes
+
+
+class SDL_KeyboardEvent(ctypes.Structure):
+    _fields_ = [
+        ("type", ctypes.c_uint32),
+        ("reserved", ctypes.c_uint32),
+        ("timestamp", ctypes.c_uint64),
+        ("windowID", ctypes.c_uint32),
+        ("which", ctypes.c_uint32),
+        ("scancode", ctypes.c_uint32),
+        ("key", ctypes.c_uint32),
+        ("mod", ctypes.c_uint32),
+        ("raw", ctypes.c_uint16),
+        ("down", ctypes.c_bool),
+        ("repeat", ctypes.c_bool),
+    ]

luma_engine-0.1.0/src/luma/sdl/shapes.py

@@ -0,0 +1,10 @@
+import ctypes
+
+
+class SDL_Rect(ctypes.Structure):
+    _fields_ = [
+        ("x", ctypes.c_float),
+        ("y", ctypes.c_float),
+        ("w", ctypes.c_float),
+        ("h", ctypes.c_float),
+    ]

luma_engine-0.1.0/src/luma_engine.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: luma-engine
+Version: 0.1.0
+Summary: A lightweight python game engine powered by SDL3
+Author-email: CyzmiX <itzmedigamingx@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Luma
+
+Luma is a lightweight Python game engine powered by SDL3. 

luma_engine-0.1.0/src/luma_engine.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+src/luma/__init__.py
+src/luma/consts.py
+src/luma/core/engine.py
+src/luma/core/event.py
+src/luma/graphics/graphics.py
+src/luma/sdl/event.py
+src/luma/sdl/keys.py
+src/luma/sdl/shapes.py
+src/luma_engine.egg-info/PKG-INFO
+src/luma_engine.egg-info/SOURCES.txt
+src/luma_engine.egg-info/dependency_links.txt
+src/luma_engine.egg-info/top_level.txt

luma_engine-0.1.0/src/luma_engine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

luma_engine-0.1.0/src/luma_engine.egg-info/top_level.txt

@@ -0,0 +1 @@
+luma