basilisk-engine 0.1.52__py3-none-any.whl → 0.1.53__py3-none-any.whl

basilisk/engine.py

@@ -1,169 +1,169 @@
-import os
-from sys import platform
-os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
-import pygame as pg
-import moderngl as mgl
-import glcontext  # For packaging (so it isnt a hidden import)
-from .render.shader_handler import ShaderHandler
-from .render.material_handler import MaterialHandler
-from .render.frame import Frame
-from .draw.draw_handler import DrawHandler
-from .config import Config
-from .input_output.mouse import Mouse
-from .input_output.clock import Clock
-from .input_output.IO_handler import IO
-from .mesh.cube import Cube
-
-class Engine():
-    win_size: tuple
-    """Size of the engine window in pixels"""
-    ctx: mgl.Context
-    """ModernGL context used by the engine"""
-    clock: Clock
-    """Basilisk clock used to keep track of time"""
-    shader_handler: ShaderHandler=None
-    """Handler for all shaders used in all scenes of the engine"""
-    material_handler: MaterialHandler=None
-    """Handler for all materials and images in all scenes"""
-    frame: Frame=None
-    """Default render target for all locations. Rendered to the screen at the end of the frame"""
-    config: Config
-    """Object containing all global attributes"""
-    delta_time: float
-    """Time in seconds that passed between the last frame"""
-    time: float
-    """Total time the engine has been running"""
-    running: bool=True
-    """True if the engine is still running"""
-    mouse: Mouse
-    """Object containing information about the user's mouse"""
-    root: str
-    """Path to the root directory containing internal data"""
-    current_frame_updated: bool=False
-    """Flag for if the engine has been updated this frame"""
-    keys: list[bool]
-    """List of all keyboard inputs as booleans"""
-    previous_keys: list[bool]
-    """List of all keyoard inputs from the last frame as booleans"""
-
-    def __init__(self, win_size=(800, 800), title="Basilisk Engine", vsync=None, max_fps=None, grab_mouse=True, headless=False, resizable=True) -> None:
-        """
-        Basilisk Engine Class. Sets up the engine enviornment and allows the user to interact with Basilisk
-        Args:
-            win_size: tuple
-                The initial window size of the engine
-            title: str
-                The title of the engine window
-            vsync: bool
-                Flag for running engine with vsync enabled
-            headless: bool
-                Flag for headless rendering
-        """
-
-        # Save the window size
-        self.win_size = win_size
-
-        # Initialize pygame and set OpenGL attributes
-        pg.init()  
-        pg.display.gl_set_attribute(pg.GL_CONTEXT_MAJOR_VERSION, 3)
-        pg.display.gl_set_attribute(pg.GL_CONTEXT_MINOR_VERSION, 3)
-        pg.display.gl_set_attribute(pg.GL_CONTEXT_PROFILE_MASK, pg.GL_CONTEXT_PROFILE_CORE)
-
-        # Platform settings
-        if platform == 'win32' : self.platform = 'windows'
-        elif  platform == 'darwin': self.platform = 'mac' 
-        else: self.platform = 'linux'
-        if vsync == None: vsync = True if self.platform == 'linux' else False
-
-        # Initializae the pygame display
-        self.headless = headless
-        if headless:
-            pg.display.set_mode((300, 50), vsync=vsync, flags=pg.OPENGL | pg.DOUBLEBUF)
-            pg.display.iconify()
-        else:
-            if resizable: pg.display.set_mode(self.win_size, vsync=vsync, flags=pg.OPENGL | pg.DOUBLEBUF | pg.RESIZABLE)
-            else: pg.display.set_mode(self.win_size, vsync=vsync, flags=pg.OPENGL | pg.DOUBLEBUF)
-                
-        # Initalize pygame sound moduel sound
-        pg.mixer.pre_init(44100, -16, 2, 512)
-        pg.mixer.init()
-        pg.mixer.set_num_channels(64)
-        pg.mixer.music.set_volume(100/100)
-
-        # MGL context setup
-        self.ctx = mgl.create_context()
-        self.ctx.enable(flags=mgl.DEPTH_TEST | mgl.CULL_FACE | mgl.BLEND)
-
-        # Global attributes referenced by the handlers
-        self.config = Config(self)
-        self.root = os.path.dirname(__file__)
-        self.cube = Cube(self)
-        self.fbos = []
-        
-        # Handlers
-        self.clock            = Clock(self, max_fps)
-        self.IO               = IO(self, grab_mouse=grab_mouse, caption=title)
-        self.material_handler = MaterialHandler(self)
-        self.shader_handler   = ShaderHandler(self)
-        self.draw_handler     = DrawHandler(self)
-        self.frame            = Frame(self)
-        self.frames = []
-        self.material_handler.set_base()
-
-    def _update(self) -> None:
-        """
-        Internal engine update.
-        Updates all input, physics, and time variables. Clears the frame.
-        """
-
-        # Used to lock this internal update until user calls engine.update()
-        if self.current_frame_updated: return
-        self.current_frame_updated = True
-
-        # Clear frame data
-        for fbo in self.fbos: fbo.clear()
-        self.frames.clear()
-        self.frame.clear()
-        self.ctx.clear()
-
-        # Update time and IO
-        self.clock.update()
-        self.IO.update()
-
-    def update(self, render=True) -> None:
-        """
-        Calls internal update if needed
-        Renders the draw handler
-        Renders the engine's frame to the screen.
-        """
-
-
-        # Must update the frame
-        self._update()
-        if not self.running: return
-
-        # Clear the screen and render the frame
-        if render:
-            # Render all draw calls from the past frame
-            self.frame.output_buffer.use()
-            self.draw_handler.render()
-            self.frame.render(self.ctx.screen)
-
-        # Even though we may not render here, the user might be rendering in their file, so we need to flip
-        pg.display.flip()
-
-        # Allow for the engine to take in input again
-        self.current_frame_updated = False
-
-    def quit(self) -> None:
-        """
-        Stops the engine and releases all memory
-        """
-
-        pg.quit()
-        self.ctx.release()
-        self.running = False
-
-
-    @property
+import os
+from sys import platform
+os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
+import pygame as pg
+import moderngl as mgl
+import glcontext  # For packaging (so it isnt a hidden import)
+from .render.shader_handler import ShaderHandler
+from .render.material_handler import MaterialHandler
+from .render.frame import Frame
+from .draw.draw_handler import DrawHandler
+from .config import Config
+from .input_output.mouse import Mouse
+from .input_output.clock import Clock
+from .input_output.IO_handler import IO
+from .mesh.cube import Cube
+
+class Engine():
+    win_size: tuple
+    """Size of the engine window in pixels"""
+    ctx: mgl.Context
+    """ModernGL context used by the engine"""
+    clock: Clock
+    """Basilisk clock used to keep track of time"""
+    shader_handler: ShaderHandler=None
+    """Handler for all shaders used in all scenes of the engine"""
+    material_handler: MaterialHandler=None
+    """Handler for all materials and images in all scenes"""
+    frame: Frame=None
+    """Default render target for all locations. Rendered to the screen at the end of the frame"""
+    config: Config
+    """Object containing all global attributes"""
+    delta_time: float
+    """Time in seconds that passed between the last frame"""
+    time: float
+    """Total time the engine has been running"""
+    running: bool=True
+    """True if the engine is still running"""
+    mouse: Mouse
+    """Object containing information about the user's mouse"""
+    root: str
+    """Path to the root directory containing internal data"""
+    current_frame_updated: bool=False
+    """Flag for if the engine has been updated this frame"""
+    keys: list[bool]
+    """List of all keyboard inputs as booleans"""
+    previous_keys: list[bool]
+    """List of all keyoard inputs from the last frame as booleans"""
+
+    def __init__(self, win_size=(800, 800), title="Basilisk Engine", vsync=None, max_fps=None, grab_mouse=True, headless=False, resizable=True) -> None:
+        """
+        Basilisk Engine Class. Sets up the engine enviornment and allows the user to interact with Basilisk
+        Args:
+            win_size: tuple
+                The initial window size of the engine
+            title: str
+                The title of the engine window
+            vsync: bool
+                Flag for running engine with vsync enabled
+            headless: bool
+                Flag for headless rendering
+        """
+
+        # Save the window size
+        self.win_size = win_size
+
+        # Initialize pygame and set OpenGL attributes
+        pg.init()  
+        pg.display.gl_set_attribute(pg.GL_CONTEXT_MAJOR_VERSION, 3)
+        pg.display.gl_set_attribute(pg.GL_CONTEXT_MINOR_VERSION, 3)
+        pg.display.gl_set_attribute(pg.GL_CONTEXT_PROFILE_MASK, pg.GL_CONTEXT_PROFILE_CORE)
+
+        # Platform settings
+        if platform == 'win32' : self.platform = 'windows'
+        elif  platform == 'darwin': self.platform = 'mac' 
+        else: self.platform = 'linux'
+        if vsync == None: vsync = True if self.platform == 'linux' else False
+
+        # Initializae the pygame display
+        self.headless = headless
+        if headless:
+            pg.display.set_mode((300, 50), vsync=vsync, flags=pg.OPENGL | pg.DOUBLEBUF)
+            pg.display.iconify()
+        else:
+            if resizable: pg.display.set_mode(self.win_size, vsync=vsync, flags=pg.OPENGL | pg.DOUBLEBUF | pg.RESIZABLE)
+            else: pg.display.set_mode(self.win_size, vsync=vsync, flags=pg.OPENGL | pg.DOUBLEBUF)
+                
+        # Initalize pygame sound moduel sound
+        pg.mixer.pre_init(44100, -16, 2, 512)
+        pg.mixer.init()
+        pg.mixer.set_num_channels(64)
+        pg.mixer.music.set_volume(100/100)
+
+        # MGL context setup
+        self.ctx = mgl.create_context()
+        self.ctx.enable(flags=mgl.DEPTH_TEST | mgl.CULL_FACE | mgl.BLEND)
+
+        # Global attributes referenced by the handlers
+        self.config = Config(self)
+        self.root = os.path.dirname(__file__)
+        self.cube = Cube(self)
+        self.fbos = []
+        
+        # Handlers
+        self.clock            = Clock(self, max_fps)
+        self.IO               = IO(self, grab_mouse=grab_mouse, caption=title)
+        self.material_handler = MaterialHandler(self)
+        self.shader_handler   = ShaderHandler(self)
+        self.draw_handler     = DrawHandler(self)
+        self.frame            = Frame(self)
+        self.frames = []
+        self.material_handler.set_base()
+
+    def _update(self) -> None:
+        """
+        Internal engine update.
+        Updates all input, physics, and time variables. Clears the frame.
+        """
+
+        # Used to lock this internal update until user calls engine.update()
+        if self.current_frame_updated: return
+        self.current_frame_updated = True
+
+        # Clear frame data
+        for fbo in self.fbos: fbo.clear()
+        self.frames.clear()
+        self.frame.clear()
+        self.ctx.clear()
+
+        # Update time and IO
+        self.clock.update()
+        self.IO.update()
+
+    def update(self, render=True) -> None:
+        """
+        Calls internal update if needed
+        Renders the draw handler
+        Renders the engine's frame to the screen.
+        """
+
+
+        # Must update the frame
+        self._update()
+        if not self.running: return
+
+        # Clear the screen and render the frame
+        if render:
+            # Render all draw calls from the past frame
+            self.frame.output_buffer.use()
+            self.draw_handler.render()
+            self.frame.render(self.ctx.screen)
+
+        # Even though we may not render here, the user might be rendering in their file, so we need to flip
+        pg.display.flip()
+
+        # Allow for the engine to take in input again
+        self.current_frame_updated = False
+
+    def quit(self) -> None:
+        """
+        Stops the engine and releases all memory
+        """
+
+        pg.quit()
+        self.ctx.release()
+        self.running = False
+
+
+    @property
     def shader(self): return self._shader

basilisk/generic/abstract_bvh.py

@@ -1,16 +1,16 @@
-import glm
-
-
-class AbstractAABB():
-    top_right: glm.vec3
-    """The furthest positive corner of the AABB"""
-    bottom_left: glm.vec3
-    """The furthest negative corner of the AABB"""
-    a: ...
-    """Binary child 1"""
-    b: ...
-    """Binary child 2"""
-        
-class AbstractBVH():
-    root: AbstractAABB
+import glm
+
+
+class AbstractAABB():
+    top_right: glm.vec3
+    """The furthest positive corner of the AABB"""
+    bottom_left: glm.vec3
+    """The furthest negative corner of the AABB"""
+    a: ...
+    """Binary child 1"""
+    b: ...
+    """Binary child 2"""
+        
+class AbstractBVH():
+    root: AbstractAABB
     """Root aabb used for the start of all collisions"""

basilisk/generic/abstract_custom.py

@@ -1,134 +1,134 @@
-import glm
-import numpy as np
-
-
-class Custom():
-    
-    def normalize(self):
-        """
-        Inplace normalizes the vector
-        """
-        self._data = glm.normalize(self._data)
-        return self
-    
-    def apply_function(): ... # will be overridden by child custom classes
-    
-    # math functions
-    def add(self, other):
-        def func(a, b): return a + b
-        return self.apply_function(other, func, 'addition')
-    
-    def subtract(self, other):
-        def func(a, b): return a - b
-        return self.apply_function(other, func, 'subtraction')
-    
-    def rhs_subtract(self, other):
-        def func(a, b): return b - a
-        return self.apply_function(other, func, 'subtraction')
-    
-    def multiply(self, other):
-        def func(a, b): return a * b
-        return self.apply_function(other, func, 'multiplication')
-    
-    def divide(self, other):
-        def func(a, b): return a / b
-        return self.apply_function(other, func, 'division')
-    
-    def rhs_divide(self, other):
-        def func(a, b): return b / a
-        return self.apply_function(other, func, 'division')
-    
-    def floor_divide(self, other):
-        def func(a, b): return a // b
-        return self.apply_function(other, func, 'division')
-    
-    def rhs_floor_divide(self, other):
-        def func(a, b): return b // a
-        return self.apply_function(other, func, 'division')
-    
-    def mod(self, other):
-        def func(a, b): return a % b
-        return self.apply_function(other, func, 'modulus')
-    
-    def rhs_mod(self, other):
-        def func(a, b): return b % a
-        return self.apply_function(other, func, 'modulus')
-    
-    def pow(self, other):
-        def func(a, b): return a ** b
-        return self.apply_function(other, func, 'power')
-    
-    def rhs_pow(self, other):
-        def func(a, b): return b ** a
-        return self.apply_function(other, func, 'power')
-
-    def __add__(self, other):  return self.add(other) # this + that
-    def __radd__(self, other): return self.add(other) # that + this
-    def __iadd__(self, other): # this += that
-        self = self.add(other) 
-        return self
-    
-    def __sub__(self, other):  return self.subtract(other)
-    def __rsub__(self, other): return self.rhs_subtract(other) # non-commutative
-    def __isub__(self, other): 
-        self = self.subtract(other)
-        return self
-    
-    def __mul__(self, other):  return self.multiply(other)
-    def __rmul__(self, other): return self.multiply(other)
-    def __imul__(self, other): 
-        self = self.multiply(other)
-        return self
-    
-    def __truediv__(self, other):  return self.divide(other)
-    def __rtruediv__(self, other): return self.rhs_divide(other) # non-commutative
-    def __itruediv__(self, other): 
-        self = self.divide(other)
-        return self
-        
-    def __floordiv__(self, other):  return self.floor_divide(other)
-    def __rfloordiv__(self, other): return self.rhs_floor_divide(other) # non-commutative
-    def __ifloordiv__(self, other): 
-        self = self.floor_divide(other)
-        return self
-    
-    def __mod__(self, other):  return self.mod(other)
-    def __rmod__(self, other): return self.rhs_mod(other)
-    def __imod__(self, other):
-        self = self.mod(other)
-        return self
-    
-    def __pow__(self, other):  return self.pow(other)
-    def __rpow__(self, other): return self.rhs_pow(other)
-    def __ipow__(self, other):
-        self = self.pow(other)
-        return self
-    
-    # comparison functions
-    def __eq__(self, other):
-        if isinstance(other, Custom): return self.data == other.data
-        return self.data == other
-    
-    def __ne__(self, other):
-        if isinstance(other, Custom): return self.data != other.data
-        return self.data != other
-    
-    def __lt__(self, other):
-        if isinstance(other, Custom): return self.data < other.data
-        return self.data < other
-    
-    def __gt__(self, other):
-        if isinstance(other, Custom): return self.data > other.data
-        return self.data > other
-    
-    def __le__(self, other):
-        if isinstance(other, Custom): return self.data <= other.data
-        return self.data <= other
-    
-    def __ge__(self, other):
-        if isinstance(other, Custom): return self.data >= other.data
-        return self.data >= other
-    
-    # unary operators
-    def __pos__(self): 
+import glm
+import numpy as np
+
+
+class Custom():
+    
+    def normalize(self):
+        """
+        Inplace normalizes the vector
+        """
+        self._data = glm.normalize(self._data)
+        return self
+    
+    def apply_function(): ... # will be overridden by child custom classes
+    
+    # math functions
+    def add(self, other):
+        def func(a, b): return a + b
+        return self.apply_function(other, func, 'addition')
+    
+    def subtract(self, other):
+        def func(a, b): return a - b
+        return self.apply_function(other, func, 'subtraction')
+    
+    def rhs_subtract(self, other):
+        def func(a, b): return b - a
+        return self.apply_function(other, func, 'subtraction')
+    
+    def multiply(self, other):
+        def func(a, b): return a * b
+        return self.apply_function(other, func, 'multiplication')
+    
+    def divide(self, other):
+        def func(a, b): return a / b
+        return self.apply_function(other, func, 'division')
+    
+    def rhs_divide(self, other):
+        def func(a, b): return b / a
+        return self.apply_function(other, func, 'division')
+    
+    def floor_divide(self, other):
+        def func(a, b): return a // b
+        return self.apply_function(other, func, 'division')
+    
+    def rhs_floor_divide(self, other):
+        def func(a, b): return b // a
+        return self.apply_function(other, func, 'division')
+    
+    def mod(self, other):
+        def func(a, b): return a % b
+        return self.apply_function(other, func, 'modulus')
+    
+    def rhs_mod(self, other):
+        def func(a, b): return b % a
+        return self.apply_function(other, func, 'modulus')
+    
+    def pow(self, other):
+        def func(a, b): return a ** b
+        return self.apply_function(other, func, 'power')
+    
+    def rhs_pow(self, other):
+        def func(a, b): return b ** a
+        return self.apply_function(other, func, 'power')
+
+    def __add__(self, other):  return self.add(other) # this + that
+    def __radd__(self, other): return self.add(other) # that + this
+    def __iadd__(self, other): # this += that
+        self = self.add(other) 
+        return self
+    
+    def __sub__(self, other):  return self.subtract(other)
+    def __rsub__(self, other): return self.rhs_subtract(other) # non-commutative
+    def __isub__(self, other): 
+        self = self.subtract(other)
+        return self
+    
+    def __mul__(self, other):  return self.multiply(other)
+    def __rmul__(self, other): return self.multiply(other)
+    def __imul__(self, other): 
+        self = self.multiply(other)
+        return self
+    
+    def __truediv__(self, other):  return self.divide(other)
+    def __rtruediv__(self, other): return self.rhs_divide(other) # non-commutative
+    def __itruediv__(self, other): 
+        self = self.divide(other)
+        return self
+        
+    def __floordiv__(self, other):  return self.floor_divide(other)
+    def __rfloordiv__(self, other): return self.rhs_floor_divide(other) # non-commutative
+    def __ifloordiv__(self, other): 
+        self = self.floor_divide(other)
+        return self
+    
+    def __mod__(self, other):  return self.mod(other)
+    def __rmod__(self, other): return self.rhs_mod(other)
+    def __imod__(self, other):
+        self = self.mod(other)
+        return self
+    
+    def __pow__(self, other):  return self.pow(other)
+    def __rpow__(self, other): return self.rhs_pow(other)
+    def __ipow__(self, other):
+        self = self.pow(other)
+        return self
+    
+    # comparison functions
+    def __eq__(self, other):
+        if isinstance(other, Custom): return self.data == other.data
+        return self.data == other
+    
+    def __ne__(self, other):
+        if isinstance(other, Custom): return self.data != other.data
+        return self.data != other
+    
+    def __lt__(self, other):
+        if isinstance(other, Custom): return self.data < other.data
+        return self.data < other
+    
+    def __gt__(self, other):
+        if isinstance(other, Custom): return self.data > other.data
+        return self.data > other
+    
+    def __le__(self, other):
+        if isinstance(other, Custom): return self.data <= other.data
+        return self.data <= other
+    
+    def __ge__(self, other):
+        if isinstance(other, Custom): return self.data >= other.data
+        return self.data >= other
+    
+    # unary operators
+    def __pos__(self): 
         return self