basilisk-engine 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

basilisk/generic/vec3.py

@@ -1,144 +1,144 @@
-import glm
-import numpy as np
-from .abstract_custom import Custom
-
-class Vec3(Custom):
-    def __init__(self, *args, callback=None):
-        self.callback = callback
-        self.prev_data = glm.vec3(0.0)
-        
-        if len(args) == 1:
-            
-            if isinstance(args[0], Vec3):
-                self.data = glm.vec3(args[0].data)
-                self.prev_data = glm.vec3(args[0].prev_data)
-                self.callback = args[0].callback
-                
-            elif isinstance(args[0], glm.vec3): 
-                self.data = args[0]
-                
-            elif isinstance(args[0], tuple) or isinstance(args[0], list) or isinstance(args[0], np.ndarray): 
-                assert len(args[0]) == 3, f'Vec3: Expected 3 values from incoming vector, got {len(args[0])}'
-                self.data = glm.vec3(args[0])
-                
-            else: 
-                try: self.data = glm.vec3(args[0])
-                except: raise ValueError(f'Vec3: Unexpected incoming vector type {args[0]}')
-            
-        elif len(args) == 3: self.data = glm.vec3(*args)
-        else: raise ValueError(f'Vec3: Expected either 1 vector or 3 numbers, got {len(args)} values')
-       
-    def apply_function(self, other, func, func_name):
-        vec = glm.vec3(self.data)
-        
-        if isinstance(other, (glm.vec3, glm.quat)): 
-            vec = func(vec, other) 
-            
-        elif isinstance(other, tuple) or isinstance(other, list) or isinstance(other, np.ndarray):
-            assert len(other) == 3, f'Vec3: Number of added values must be 3, got {len(other)}'
-            vec = func(vec, other) 
-            
-        elif isinstance(other, Custom): # perserve self.callback over other.callback. this should never be done by the user
-            vec = func(vec, other.data) 
-            
-        else: 
-            try: vec = func(vec, other) 
-            except: raise ValueError(f'Vec3: Not an accepted type for {func_name}, got {type(other)}')
-        return Vec3(vec)
-        
-    # unary operators
-    def __neg__(self):
-        return Vec3(-self.data, callback=self.callback)
-    
-    def __abs__(self):
-        return Vec3(abs(self.data), callback=self.callback)
-    
-    # accessor functions
-    def __getitem__(self, index): 
-        assert int(index) == index, f'Vec3: index must be an int, got {type(index)}' # check if index is a float
-        assert 0 <= index <= 2, f'Vec3: index out of bounds, got {index}'
-        return self.data[index]
-    
-    def __setitem__(self, index, value): 
-        assert int(index) == index, f'Vec3: index must be an int, got {type(index)}' # check if index is a float
-        assert 0 <= index <= 2, f'Vec3: index out of bounds, got {index}'
-        try: self.data[index] = value
-        except: raise ValueError(f'Vec3: Invalid element type, got {type(value)}')
-        
-    def __delitem__(self, index): # index in a vec cannot be deleted, so we default to zero
-        assert int(index) == index, f'Vec3: index must be an int, got {type(index)}' # check if index is a float
-        assert 0 <= index <= 2, f'Vec3: index out of bounds, got {index}'
-        self.data[index] = 0
-        
-    def __len__(self):
-        return 3
-        
-    def __iter__(self):
-        return iter(self.data)
-    
-    def __contains__(self, item):
-        return item in self.data
-    
-    # override str operators
-    def __repr__(self):
-        return 'bsk ' + str(self.data)
-    
-    def __str__(self):
-        return 'bsk ' + str(self.data)
-    
-    @property
-    def data(self): return self._data
-    @property
-    def x(self): return self.data.x
-    @property
-    def y(self): return self.data.y
-    @property
-    def z(self): return self.data.z
-    
-    @data.setter
-    def data(self, value: glm.vec3):
-        self._data = glm.vec3(value)
-        cur = self._data
-        prev = self.prev_data
-        thresh = 1e-6
-        
-        if self.callback and (abs(cur.x - prev.x) > thresh or abs(cur.y - prev.y) > thresh or abs(cur.z - prev.z) > thresh): 
-            self.prev_data = glm.vec3(self._data)
-            self.callback()
-
-    @x.setter
-    def x(self, value):
-        self._data.x = value
-        if self.callback and abs(value - self.prev_data.x) > 1e-6: 
-            self.prev_data.x = value
-            self.callback()
-        
-    @y.setter
-    def y(self, value):
-        self._data.y = value
-        if self.callback and abs(value - self.prev_data.y) > 1e-6: 
-            self.prev_data.y = value
-            self.callback()
-        
-    @z.setter
-    def z(self, value):
-        self._data.z = value
-        if self.callback and abs(value - self.prev_data.z) > 1e-6: 
-            self.prev_data.z = value
-            self.callback()
-        
-class Node():
-    
-    def __init__(self, pos):
-        
-        def callback(): print('calling back')
-        self.pos_callback = callback
-        self._pos = Vec3(pos, callback=self.pos_callback)
-        
-    @property
-    def pos(self): return self._pos
-    
-    @pos.setter
-    def pos(self, value): 
-        if isinstance(value, Vec3): self._pos.data = value.data
+import glm
+import numpy as np
+from .abstract_custom import Custom
+
+class Vec3(Custom):
+    def __init__(self, *args, callback=None):
+        self.callback = callback
+        self.prev_data = glm.vec3(0.0)
+        
+        if len(args) == 1:
+            
+            if isinstance(args[0], Vec3):
+                self.data = glm.vec3(args[0].data)
+                self.prev_data = glm.vec3(args[0].prev_data)
+                self.callback = args[0].callback
+                
+            elif isinstance(args[0], glm.vec3): 
+                self.data = args[0]
+                
+            elif isinstance(args[0], tuple) or isinstance(args[0], list) or isinstance(args[0], np.ndarray): 
+                assert len(args[0]) == 3, f'Vec3: Expected 3 values from incoming vector, got {len(args[0])}'
+                self.data = glm.vec3(args[0])
+                
+            else: 
+                try: self.data = glm.vec3(args[0])
+                except: raise ValueError(f'Vec3: Unexpected incoming vector type {args[0]}')
+            
+        elif len(args) == 3: self.data = glm.vec3(*args)
+        else: raise ValueError(f'Vec3: Expected either 1 vector or 3 numbers, got {len(args)} values')
+       
+    def apply_function(self, other, func, func_name):
+        vec = glm.vec3(self.data)
+        
+        if isinstance(other, (glm.vec3, glm.quat)): 
+            vec = func(vec, other) 
+            
+        elif isinstance(other, tuple) or isinstance(other, list) or isinstance(other, np.ndarray):
+            assert len(other) == 3, f'Vec3: Number of added values must be 3, got {len(other)}'
+            vec = func(vec, other) 
+            
+        elif isinstance(other, Custom): # perserve self.callback over other.callback. this should never be done by the user
+            vec = func(vec, other.data) 
+            
+        else: 
+            try: vec = func(vec, other) 
+            except: raise ValueError(f'Vec3: Not an accepted type for {func_name}, got {type(other)}')
+        return Vec3(vec)
+        
+    # unary operators
+    def __neg__(self):
+        return Vec3(-self.data, callback=self.callback)
+    
+    def __abs__(self):
+        return Vec3(abs(self.data), callback=self.callback)
+    
+    # accessor functions
+    def __getitem__(self, index): 
+        assert int(index) == index, f'Vec3: index must be an int, got {type(index)}' # check if index is a float
+        assert 0 <= index <= 2, f'Vec3: index out of bounds, got {index}'
+        return self.data[index]
+    
+    def __setitem__(self, index, value): 
+        assert int(index) == index, f'Vec3: index must be an int, got {type(index)}' # check if index is a float
+        assert 0 <= index <= 2, f'Vec3: index out of bounds, got {index}'
+        try: self.data[index] = value
+        except: raise ValueError(f'Vec3: Invalid element type, got {type(value)}')
+        
+    def __delitem__(self, index): # index in a vec cannot be deleted, so we default to zero
+        assert int(index) == index, f'Vec3: index must be an int, got {type(index)}' # check if index is a float
+        assert 0 <= index <= 2, f'Vec3: index out of bounds, got {index}'
+        self.data[index] = 0
+        
+    def __len__(self):
+        return 3
+        
+    def __iter__(self):
+        return iter(self.data)
+    
+    def __contains__(self, item):
+        return item in self.data
+    
+    # override str operators
+    def __repr__(self):
+        return 'bsk ' + str(self.data)
+    
+    def __str__(self):
+        return 'bsk ' + str(self.data)
+    
+    @property
+    def data(self): return self._data
+    @property
+    def x(self): return self.data.x
+    @property
+    def y(self): return self.data.y
+    @property
+    def z(self): return self.data.z
+    
+    @data.setter
+    def data(self, value: glm.vec3):
+        self._data = glm.vec3(value)
+        cur = self._data
+        prev = self.prev_data
+        thresh = 1e-6
+        
+        if self.callback and (abs(cur.x - prev.x) > thresh or abs(cur.y - prev.y) > thresh or abs(cur.z - prev.z) > thresh): 
+            self.prev_data = glm.vec3(self._data)
+            self.callback()
+
+    @x.setter
+    def x(self, value):
+        self._data.x = value
+        if self.callback and abs(value - self.prev_data.x) > 1e-6: 
+            self.prev_data.x = value
+            self.callback()
+        
+    @y.setter
+    def y(self, value):
+        self._data.y = value
+        if self.callback and abs(value - self.prev_data.y) > 1e-6: 
+            self.prev_data.y = value
+            self.callback()
+        
+    @z.setter
+    def z(self, value):
+        self._data.z = value
+        if self.callback and abs(value - self.prev_data.z) > 1e-6: 
+            self.prev_data.z = value
+            self.callback()
+        
+class Node():
+    
+    def __init__(self, pos):
+        
+        def callback(): print('calling back')
+        self.pos_callback = callback
+        self._pos = Vec3(pos, callback=self.pos_callback)
+        
+    @property
+    def pos(self): return self._pos
+    
+    @pos.setter
+    def pos(self, value): 
+        if isinstance(value, Vec3): self._pos.data = value.data
         else: self._pos.data = value

basilisk/input/mouse.py

@@ -1,62 +1,62 @@
-import pygame as pg
-
-
-class Mouse():
-    def __init__(self, grab=True):
-        self.x, self.y = pg.mouse.get_pos()
-        self.buttons = pg.mouse.get_pressed()
-        self.previous_buttons = pg.mouse.get_pressed()
-        self.grab = grab
-
-    def update(self, events):
-        """
-        Updates all mouse state variables.
-        Checks for mouse-related events.
-        """
-        
-        self.x, self.y = pg.mouse.get_pos()
-        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
-                    pg.event.set_grab(False)
-                    pg.mouse.set_visible(True)
-            if event.type == pg.MOUSEBUTTONUP and self.grab:
-                # Lock mouse
-                pg.event.set_grab(True)
-                pg.mouse.set_visible(False)
-
-    def set_pos(self, x, y):
-        """Set the mouse position"""
-        pg.mouse.set_pos(x, y)
-
-    @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
-
-    @grab.setter
-    def grab(self, value):
-        self._grab = value
-        if self._grab:
-            pg.event.set_grab(True)
-            pg.mouse.set_visible(False)
-        else:
-            pg.event.set_grab(False)
+import pygame as pg
+
+
+class Mouse():
+    def __init__(self, grab=True):
+        self.x, self.y = pg.mouse.get_pos()
+        self.buttons = pg.mouse.get_pressed()
+        self.previous_buttons = pg.mouse.get_pressed()
+        self.grab = grab
+
+    def update(self, events):
+        """
+        Updates all mouse state variables.
+        Checks for mouse-related events.
+        """
+        
+        self.x, self.y = pg.mouse.get_pos()
+        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
+                    pg.event.set_grab(False)
+                    pg.mouse.set_visible(True)
+            if event.type == pg.MOUSEBUTTONUP and self.grab:
+                # Lock mouse
+                pg.event.set_grab(True)
+                pg.mouse.set_visible(False)
+
+    def set_pos(self, x, y):
+        """Set the mouse position"""
+        pg.mouse.set_pos(x, y)
+
+    @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
+
+    @grab.setter
+    def grab(self, value):
+        self._grab = value
+        if self._grab:
+            pg.event.set_grab(True)
+            pg.mouse.set_visible(False)
+        else:
+            pg.event.set_grab(False)
             pg.mouse.set_visible(True)

basilisk/input/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/input_output/IO_handler.py

@@ -0,0 +1,93 @@
+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)
+                self.engine.frame.resize((event.w, event.h))
+                # for fbo in self.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

@@ -0,0 +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:
+        return self.clock.get_fps()

basilisk/input_output/keys.py

@@ -0,0 +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)
+        setattr(self.engine, "prev_keys", self.previous_keys)