basilisk-engine 0.1.34__py3-none-any.whl → 0.1.36__py3-none-any.whl

basilisk/input_output/IO_handler.py

@@ -1,92 +1,92 @@
-import pygame as pg
-from .keys import Keys
-from .mouse import Mouse
-
-
-class IO:
-    keys: Keys=None
-    """Handler for all keyboard inputs""" 
-    mouse: Mouse=None
-    """Handler for all mouse inputs and mouse settings"""
-    events: list=[]
-    """List of all the events in the frame"""
-    event_resize: bool=False
-    """Bool for if a resize event has occured this frame"""
-
-    def __init__(self, engine: ..., grab_mouse: bool=True, caption: bool|None="Basilisk") -> None:
-        """
-        Class to handle all inputs and outputs for the engine. 
-        """
-        
-        # Reference to parent engine
-        self.engine = engine
-
-        # Caption attrib
-        self.caption = caption
-        self.update_caption()
-
-        # Handlers for key and mouse input
-        self.keys = Keys(engine)
-        self.mouse = Mouse(grab=grab_mouse)
-
-        # Expose the mouse on the engine level
-        setattr(self.engine, "mouse", self.mouse)
-
-        # Fill in default values for engine attributes
-        self.set_engine_attribiutes()
-
-        # Update the icon for the window
-        pg.display.set_icon(pg.image.load(self.engine.root + '/bsk_assets/basilisk.png'))
-
-    def update(self) -> None:
-        """
-        Update all inputs and check for events
-        """
-
-        # Get events
-        self.events = pg.event.get()
-
-        # Update the keys and the mouse
-        self.keys.update()
-        self.mouse.update(self.events)
-
-        # Handle events and update attributes
-        self.get_events()
-        self.set_engine_attribiutes()
-        self.update_caption()
-
-    def get_events(self) -> None:
-        """
-        Loop through all pygame events and make updates as needed
-        """
-        
-        # Clear global events
-        self.event_resize = False
-
-
-        for event in self.events:
-            if event.type == pg.QUIT: # Quit the engine
-                self.engine.quit()
-                return
-            if event.type == pg.VIDEORESIZE:
-                # Updates the viewport
-                self.event_resize = True
-                self.engine.win_size = (event.w, event.h)
-                self.engine.ctx.viewport = (0, 0, event.w, event.h)
-                for fbo in self.engine.fbos: fbo.resize()
-
-    def update_caption(self) -> None:
-        """
-        Updates the window caption with either the fps or the window name. Set to 'Basilisk Engine' by default
-        """
-        
-        caption = self.caption if self.caption else f"FPS: {round(self.engine.clock.fps)}"
-        pg.display.set_caption(caption)
-
-    def set_engine_attribiutes(self) -> None:
-        """
-        Updates engine attributes with this instance's attributes for ease of use
-        """
-
-        setattr(self.engine, "events", self.events)
+import pygame as pg
+from .keys import Keys
+from .mouse import Mouse
+
+
+class IO:
+    keys: Keys=None
+    """Handler for all keyboard inputs""" 
+    mouse: Mouse=None
+    """Handler for all mouse inputs and mouse settings"""
+    events: list=[]
+    """List of all the events in the frame"""
+    event_resize: bool=False
+    """Bool for if a resize event has occured this frame"""
+
+    def __init__(self, engine: ..., grab_mouse: bool=True, caption: bool|None="Basilisk") -> None:
+        """
+        Class to handle all inputs and outputs for the engine. 
+        """
+        
+        # Reference to parent engine
+        self.engine = engine
+
+        # Caption attrib
+        self.caption = caption
+        self.update_caption()
+
+        # Handlers for key and mouse input
+        self.keys = Keys(engine)
+        self.mouse = Mouse(grab=grab_mouse)
+
+        # Expose the mouse on the engine level
+        setattr(self.engine, "mouse", self.mouse)
+
+        # Fill in default values for engine attributes
+        self.set_engine_attribiutes()
+
+        # Update the icon for the window
+        pg.display.set_icon(pg.image.load(self.engine.root + '/bsk_assets/basilisk.png'))
+
+    def update(self) -> None:
+        """
+        Update all inputs and check for events
+        """
+
+        # Get events
+        self.events = pg.event.get()
+
+        # Update the keys and the mouse
+        self.keys.update()
+        self.mouse.update(self.events)
+
+        # Handle events and update attributes
+        self.get_events()
+        self.set_engine_attribiutes()
+        self.update_caption()
+
+    def get_events(self) -> None:
+        """
+        Loop through all pygame events and make updates as needed
+        """
+        
+        # Clear global events
+        self.event_resize = False
+
+
+        for event in self.events:
+            if event.type == pg.QUIT: # Quit the engine
+                self.engine.quit()
+                return
+            if event.type == pg.VIDEORESIZE:
+                # Updates the viewport
+                self.event_resize = True
+                self.engine.win_size = (event.w, event.h)
+                self.engine.ctx.viewport = (0, 0, event.w, event.h)
+                for fbo in self.engine.fbos: fbo.resize()
+
+    def update_caption(self) -> None:
+        """
+        Updates the window caption with either the fps or the window name. Set to 'Basilisk Engine' by default
+        """
+        
+        caption = self.caption if self.caption else f"FPS: {round(self.engine.clock.fps)}"
+        pg.display.set_caption(caption)
+
+    def set_engine_attribiutes(self) -> None:
+        """
+        Updates engine attributes with this instance's attributes for ease of use
+        """
+
+        setattr(self.engine, "events", self.events)
         setattr(self.engine, "event_resize", self.event_resize)

basilisk/input_output/clock.py

@@ -1,50 +1,50 @@
-import pygame as pg
-
-
-class Clock:
-    delta_time: float=0
-    """The amount of time that passed between the last and current frame"""
-    time: float=0
-    """Total time that has passed since the start of the program"""
-
-    def __init__(self, engine, max_fps=None) -> None:
-        """
-        Class to keep track of all time and delta time in the program
-        """
-
-        # Reference to the parent engine
-        self.engine = engine
-
-        # Create a pygame clock
-        self.clock = pg.Clock()
-        self.max_fps = max_fps
-
-        # Default values for attributes
-        self.set_engine_attribiutes()
-
-    def update(self) -> None:
-        """Ticks the clock"""
-        
-        # Tick the clock and get delta time in seconds
-        if self.max_fps: self.delta_time = self.clock.tick(self.max_fps) / 1000
-        else: self.delta_time = self.clock.tick() / 1000
-
-        # Increment the total time by time since last frame
-        self.time += self.delta_time
-
-        self.set_engine_attribiutes()
-
-    def set_engine_attribiutes(self) -> None:
-        """
-        Updates engine attributes with this instance's attributes for ease of use
-        """
-        
-        setattr(self.engine, "delta_time", self.delta_time)
-        setattr(self.engine, "dt", self.delta_time)
-        setattr(self.engine, "time", self.time)
-        setattr(self.engine, "fps", self.fps)
-
-
-    @property
-    def fps(self) -> float:
+import pygame as pg
+
+
+class Clock:
+    delta_time: float=0
+    """The amount of time that passed between the last and current frame"""
+    time: float=0
+    """Total time that has passed since the start of the program"""
+
+    def __init__(self, engine, max_fps=None) -> None:
+        """
+        Class to keep track of all time and delta time in the program
+        """
+
+        # Reference to the parent engine
+        self.engine = engine
+
+        # Create a pygame clock
+        self.clock = pg.Clock()
+        self.max_fps = max_fps
+
+        # Default values for attributes
+        self.set_engine_attribiutes()
+
+    def update(self) -> None:
+        """Ticks the clock"""
+        
+        # Tick the clock and get delta time in seconds
+        if self.max_fps: self.delta_time = self.clock.tick(self.max_fps) / 1000
+        else: self.delta_time = self.clock.tick() / 1000
+
+        # Increment the total time by time since last frame
+        self.time += self.delta_time
+
+        self.set_engine_attribiutes()
+
+    def set_engine_attribiutes(self) -> None:
+        """
+        Updates engine attributes with this instance's attributes for ease of use
+        """
+        
+        setattr(self.engine, "delta_time", self.delta_time)
+        setattr(self.engine, "dt", self.delta_time)
+        setattr(self.engine, "time", self.time)
+        setattr(self.engine, "fps", self.fps)
+
+
+    @property
+    def fps(self) -> float:
         return self.clock.get_fps()

basilisk/input_output/keys.py

@@ -1,44 +1,44 @@
-import pygame as pg
-
-
-class Keys:
-    current_keys: list[bool]
-    """The keys pressed during the current frame""" 
-    previous_keys: list[bool]
-    """The keys pressed in the last frame"""
-
-    def __init__(self, engine: ...) -> None:
-        """
-        Handler for all keyboard inputs. Stores data from current and previous frames
-        """
-        
-        # Reference to the parent engine
-        self.engine = engine
-
-        # Fill in default values for current and previous keys to aviod startup errors
-        self.current_keys = pg.key.get_pressed()
-        self.previous_keys = self.current_keys
-        self.set_engine_attribiutes()
-
-
-    def update(self) -> None:
-        """
-        Gets all keyboard inputs and propogates last frame inputs
-        """
-
-        # Get keyboard input
-        self.previous_keys = self.current_keys
-        # Propogate input to the last frame
-        self.current_keys = pg.key.get_pressed()
-
-        # Expose the attributes on the engine level
-        self.set_engine_attribiutes()
-
-    def set_engine_attribiutes(self) -> None:
-        """
-        Updates engine attributes with this instance's attributes for ease of use
-        """
-
-        setattr(self.engine, "keys", self.current_keys)
-        setattr(self.engine, "previous_keys", self.previous_keys)
+import pygame as pg
+
+
+class Keys:
+    current_keys: list[bool]
+    """The keys pressed during the current frame""" 
+    previous_keys: list[bool]
+    """The keys pressed in the last frame"""
+
+    def __init__(self, engine: ...) -> None:
+        """
+        Handler for all keyboard inputs. Stores data from current and previous frames
+        """
+        
+        # Reference to the parent engine
+        self.engine = engine
+
+        # Fill in default values for current and previous keys to aviod startup errors
+        self.current_keys = pg.key.get_pressed()
+        self.previous_keys = self.current_keys
+        self.set_engine_attribiutes()
+
+
+    def update(self) -> None:
+        """
+        Gets all keyboard inputs and propogates last frame inputs
+        """
+
+        # Get keyboard input
+        self.previous_keys = self.current_keys
+        # Propogate input to the last frame
+        self.current_keys = pg.key.get_pressed()
+
+        # Expose the attributes on the engine level
+        self.set_engine_attribiutes()
+
+    def set_engine_attribiutes(self) -> None:
+        """
+        Updates engine attributes with this instance's attributes for ease of use
+        """
+
+        setattr(self.engine, "keys", self.current_keys)
+        setattr(self.engine, "previous_keys", self.previous_keys)
         setattr(self.engine, "prev_keys", self.previous_keys)

basilisk/input_output/mouse.py

@@ -1,90 +1,91 @@
-import pygame as pg
-
-
-class Mouse():
-    def __init__(self, grab=True):
-        self._position = list(pg.mouse.get_pos())
-        self._relative = [0, 0]
-        self.buttons = pg.mouse.get_pressed()
-        self.previous_buttons = pg.mouse.get_pressed()
-        self.grab = grab
-        self.visible = not self.grab
-
-    def update(self, events):
-        """
-        Updates all mouse state variables.
-        Checks for mouse-related events.
-        """
-        
-        self._position = list(pg.mouse.get_pos())
-        self._relative = list(pg.mouse.get_rel())
-        self.previous_buttons = self.buttons
-        self.buttons = pg.mouse.get_pressed()
-
-        for event in events:
-            if event.type == pg.KEYUP:
-                if event.key == pg.K_ESCAPE and self.grab:
-                    # Unlock mouse
-                    self.grab = False
-                    self.visible = True
-            if event.type == pg.MOUSEBUTTONUP and not self.grab:
-                # Lock mouse
-                self.grab = True
-                self.visible = False
-
-    @property
-    def position(self): return self._position
-    @property
-    def x(self): return self._position[0]
-    @property
-    def y(self): return self._position[1]
-    @property
-    def relative(self): return self._relative
-    @property
-    def relative_x(self): return self._relative[0]
-    @property
-    def relative_y(self): return self._relative[1]
-    @property
-    def click(self): return self.buttons[0] and not self.previous_buttons[0]
-    @property
-    def left_click(self): return self.buttons[0] and not self.previous_buttons[0]
-    @property
-    def middle_click(self): return self.buttons[1] and not self.previous_buttons[1]
-    @property
-    def right_click(self): return self.buttons[2] and not self.previous_buttons[2]
-    @property
-    def left_down(self): return self.buttons[0]
-    @property
-    def middle_down(self): return self.buttons[1]
-    @property
-    def right_down(self): return self.buttons[2]
-    @property
-    def grab(self): return self._grab
-    @property
-    def visible(self): return self._visable
-
-    @position.setter
-    def position(self, value: tuple[int]) -> tuple[int]:
-        self._position = value
-        pg.mouse.set_pos(self._position)
-        return self._position
-    @x.setter
-    def x(self, value: int) -> int:
-        self._position[0] = value
-        pg.mouse.set_pos(self._position)
-        return self._position
-    @y.setter
-    def y(self, value: int) -> int:
-        self._position[1] = value
-        pg.mouse.set_pos(self._position)
-        return self._position
-    @grab.setter
-    def grab(self, value) -> bool:
-        self._grab = value
-        pg.event.set_grab(self._grab)
-        return self._grab
-    @visible.setter
-    def visible(self, value) -> bool:
-        self._visible = value
-        pg.mouse.set_visible(self._visible)
+import pygame as pg
+
+
+class Mouse():
+    def __init__(self, grab=True):
+        self._position = list(pg.mouse.get_pos())
+        self._relative = [0, 0]
+        self.buttons = pg.mouse.get_pressed()
+        self.previous_buttons = pg.mouse.get_pressed()
+        self.initial_grab = grab
+        self.grab = grab
+        self.visible = not self.grab
+
+    def update(self, events):
+        """
+        Updates all mouse state variables.
+        Checks for mouse-related events.
+        """
+        
+        self._position = list(pg.mouse.get_pos())
+        self._relative = list(pg.mouse.get_rel())
+        self.previous_buttons = self.buttons
+        self.buttons = pg.mouse.get_pressed()
+
+        for event in events:
+            if event.type == pg.KEYUP:
+                if event.key == pg.K_ESCAPE and self.grab and self.initial_grab:
+                    # Unlock mouse
+                    self.grab = False
+                    self.visible = True
+            if event.type == pg.MOUSEBUTTONUP and not self.grab and self.initial_grab:
+                # Lock mouse
+                self.grab = True
+                self.visible = False
+
+    @property
+    def position(self): return self._position
+    @property
+    def x(self): return self._position[0]
+    @property
+    def y(self): return self._position[1]
+    @property
+    def relative(self): return self._relative
+    @property
+    def relative_x(self): return self._relative[0]
+    @property
+    def relative_y(self): return self._relative[1]
+    @property
+    def click(self): return self.buttons[0] and not self.previous_buttons[0]
+    @property
+    def left_click(self): return self.buttons[0] and not self.previous_buttons[0]
+    @property
+    def middle_click(self): return self.buttons[1] and not self.previous_buttons[1]
+    @property
+    def right_click(self): return self.buttons[2] and not self.previous_buttons[2]
+    @property
+    def left_down(self): return self.buttons[0]
+    @property
+    def middle_down(self): return self.buttons[1]
+    @property
+    def right_down(self): return self.buttons[2]
+    @property
+    def grab(self): return self._grab
+    @property
+    def visible(self): return self._visable
+
+    @position.setter
+    def position(self, value: tuple[int]) -> tuple[int]:
+        self._position = value
+        pg.mouse.set_pos(self._position)
+        return self._position
+    @x.setter
+    def x(self, value: int) -> int:
+        self._position[0] = value
+        pg.mouse.set_pos(self._position)
+        return self._position
+    @y.setter
+    def y(self, value: int) -> int:
+        self._position[1] = value
+        pg.mouse.set_pos(self._position)
+        return self._position
+    @grab.setter
+    def grab(self, value) -> bool:
+        self._grab = value
+        pg.event.set_grab(self._grab)
+        return self._grab
+    @visible.setter
+    def visible(self, value) -> bool:
+        self._visible = value
+        pg.mouse.set_visible(self._visible)
         return self._visible

basilisk/input_output/path.py

@@ -1,14 +1,14 @@
-import os
-import sys
-
-
-# Credit for function: https://stackoverflow.com/questions/7674790/bundling-data-files-with-pyinstaller-onefile
-def get_root():
-    """ Get absolute path to resource, works for dev and for PyInstaller """
-    try:
-        # PyInstaller creates a temp folder and stores path in _MEIPASS
-        base_path = sys._MEIPASS
-    except Exception:
-        base_path = os.path.abspath(".")
-
-    return base_path + '/basilisk'
+import os
+import sys
+
+
+# Credit for function: https://stackoverflow.com/questions/7674790/bundling-data-files-with-pyinstaller-onefile
+def get_root():
+    """ Get absolute path to resource, works for dev and for PyInstaller """
+    try:
+        # PyInstaller creates a temp folder and stores path in _MEIPASS
+        base_path = sys._MEIPASS
+    except Exception:
+        base_path = os.path.abspath(".")
+
+    return base_path + '/basilisk'

basilisk/mesh/cube.py

@@ -1,34 +1,34 @@
-import glm
-import os
-from .mesh import Mesh
-
-    
-class Cube(Mesh):
-    def __init__(self, engine) -> None:
-        # built-in cube mesh with custom functions
-        path = engine.root + '/bsk_assets/cube.obj'
-        super().__init__(path)
-        
-        self.dot_indices = [0 for _ in range(8)]
-        for i, point in enumerate(self.points):
-            index = 0 
-            if point[0] > 0: index += 4
-            if point[1] > 0: index += 2
-            if point[2] > 0: index += 1
-            self.dot_indices[index] = i
-
-    def get_best_dot(self, vec: glm.vec3) -> int:
-        """
-        Gets the best dot point of a cube
-        """
-        index = 0
-        if vec[0] > 0: index += 4
-        if vec[1] > 0: index += 2
-        if vec[2] > 0: index += 1
-        return self.dot_indices[index]
-    
-    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[int]:
-        """
-        Returns all the faces on the cube since the AABB degenerates on the cube mesh
-        """
+import glm
+import os
+from .mesh import Mesh
+
+    
+class Cube(Mesh):
+    def __init__(self, engine) -> None:
+        # built-in cube mesh with custom functions
+        path = engine.root + '/bsk_assets/cube.obj'
+        super().__init__(path)
+        
+        self.dot_indices = [0 for _ in range(8)]
+        for i, point in enumerate(self.points):
+            index = 0 
+            if point[0] > 0: index += 4
+            if point[1] > 0: index += 2
+            if point[2] > 0: index += 1
+            self.dot_indices[index] = i
+
+    def get_best_dot(self, vec: glm.vec3) -> int:
+        """
+        Gets the best dot point of a cube
+        """
+        index = 0
+        if vec[0] > 0: index += 4
+        if vec[1] > 0: index += 2
+        if vec[2] > 0: index += 1
+        return self.dot_indices[index]
+    
+    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[int]:
+        """
+        Returns all the faces on the cube since the AABB degenerates on the cube mesh
+        """
         return [i for i in range(12)]