basilisk-engine 0.1.22__tar.gz → 0.1.24__tar.gz

{basilisk_engine-0.1.22/basilisk_engine.egg-info → basilisk_engine-0.1.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: basilisk-engine
-Version: 0.1.22
+Version: 0.1.24
 Summary: Python 3D Framework
 Home-page: https://basilisk-website.vercel.app/
 Author: Name

{basilisk_engine-0.1.22 → basilisk_engine-0.1.24}/basilisk/__init__.py

@@ -8,7 +8,7 @@ from .render.material import Material
 from .render.shader import Shader
 from .render.shader_handler import ShaderHandler
 from .draw import draw
-from .render.camera import FreeCamera, StaticCamera, FollowCamera, OrbitCamera
+from .render.camera import FreeCamera, StaticCamera, FollowCamera, OrbitCamera, FixedCamera
 from .render.sky import Sky
 from .render.post_process import PostProcess
 from .particles.particle_handler import ParticleHandler

basilisk_engine-0.1.24/basilisk/config.py

@@ -0,0 +1,4 @@
+class Config():
+    def __init__(self) -> None:
+        self.chunk_size = 40
+        self.render_distance = 5

{basilisk_engine-0.1.22 → basilisk_engine-0.1.24}/basilisk/draw/draw.py

@@ -14,7 +14,7 @@ def rect(engine: Engine, color: tuple, rect: tuple) -> None:
     """
     
     # Get the draw handler from the engine
-    draw_handler = engine.scene.draw_handler
+    draw_handler = engine.draw_handler
     if not draw_handler: return
 
     # Draw the rect
@@ -36,7 +36,7 @@ def circle(engine: Engine, color: tuple, center: tuple, radius: int, resolution:
     """
     
     # Get the draw handler from the engine
-    draw_handler = engine.scene.draw_handler
+    draw_handler = engine.draw_handler
     if not draw_handler: return
 
     # Draw the circle
@@ -57,7 +57,7 @@ def line(engine: Engine, color: tuple, p1: tuple, p2: tuple, thickness: int=1) -
     """
     
     # Get the draw handler from the engine
-    draw_handler = engine.scene.draw_handler
+    draw_handler = engine.draw_handler
     if not draw_handler: return
 
     # Draw the line
@@ -74,10 +74,10 @@ def blit(engine: Engine, image: Image, rect: tuple, alpha: float=1.0):
     """
 
     # Get the draw handler from the engine
-    draw_handler = engine.scene.draw_handler
+    draw_handler = engine.draw_handler
     if not draw_handler: return
 
-    engine.scene.material_handler.image_handler.add(image)
+    engine.material_handler.image_handler.add(image)
 
     # Blit the image
     draw_handler.blit(image, rect, alpha)
@@ -88,7 +88,7 @@ def text(engine: Engine, text: str, position: tuple, scale: float=1.0):
     USE SPARINGLY, INEFFICIENT IMPLAMENTATION
     """
     
-    font_renderer = engine.scene.draw_handler.font_renderer
+    font_renderer = engine.draw_handler.font_renderer
 
     # Render the text if it has not been cached
     if text not in font_renderer.text_renders:

{basilisk_engine-0.1.22 → basilisk_engine-0.1.24}/basilisk/draw/draw_handler.py

@@ -9,9 +9,6 @@ from ..generic.input_validation import validate_color, validate_rect, validate_p
 
 class DrawHandler():
     engine: ...
-    """Back reference to the parent engine"""
-    scene: ...
-    """Back reference to the parent scene"""
     ctx: mgl.Context
     """Back reference to the parent context"""
     program: mgl.Program
@@ -23,15 +20,14 @@ class DrawHandler():
     vao: mgl.VertexArray=None
     """VAO for rendering all 2D draw calls"""
     
-    def __init__(self, scene) -> None:
+    def __init__(self, engine) -> None:
         # Back references
-        self.scene  = scene
-        self.engine = scene.engine
-        self.ctx    = scene.engine.ctx
+        self.engine = engine
+        self.ctx    = engine.ctx
 
         # Get the shader
         root = self.engine.root
-        self.shader = self.scene.shader_handler.add(Shader(self.engine, root + '/shaders/draw.vert', root + '/shaders/draw.frag'))
+        self.shader = self.engine.shader_handler.add(Shader(self.engine, root + '/shaders/draw.vert', root + '/shaders/draw.frag'))
 
         # Initialize draw data as blank
         self.draw_data = []

basilisk_engine-0.1.24/basilisk/engine.py

@@ -0,0 +1,170 @@
+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.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.material_handler.set_base()
+
+    def _update(self) -> None:
+        """
+        Internal engine update.
+        Updates all input, physics, and time variables. Clears the frame.
+        """
+
+        if self.current_frame_updated: return
+
+        for fbo in self.fbos: fbo.clear()
+        self.clock.update()
+        self.IO.update()
+
+        self.current_frame_updated = True
+
+
+    def update(self) -> None:
+        """
+        Calls internal update if needed
+        Renders the draw handler
+        Renders the engine's frame to the screen.
+        """
+
+
+        # Must update the frame
+        if not self.current_frame_updated: self._update()
+        if not self.running: return
+
+        # Render all draw calls from the past frame
+        self.frame.use()
+        self.draw_handler.render()
+
+        # Clear the screen and render the frame
+        self.ctx.screen.use()
+        self.ctx.clear()
+        self.frame.render()
+        pg.display.flip()
+
+        self.frame.clear()
+
+
+        # 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
+    @shader.setter
+    def shader(self, value):
+        self._shader = value
+        value.set_main()

basilisk_engine-0.1.24/basilisk/input_output/IO_handler.py

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

basilisk_engine-0.1.24/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_engine-0.1.24/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)

basilisk_engine-0.1.24/basilisk/input_output/mouse.py

@@ -0,0 +1,90 @@
+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)
+        return self._visible

{basilisk_engine-0.1.22 → basilisk_engine-0.1.24}/basilisk/nodes/node.py

@@ -97,9 +97,10 @@ class Node():
         
         # parents
         self.node_handler = None
-        self.scene = None
-        self.chunk = None
-        self.parent = None
+        self.scene        = None
+        self.engine       = None
+        self.chunk        = None
+        self.parent       = None
         
         # lazy update variables
         self.needs_geometric_center = True # pos
@@ -194,18 +195,19 @@ class Node():
         self.internal_scale.callback    = scale_callback
         self.internal_rotation.callback = rotation_callback
     
-    def init_scene(self, scene):
+    def init_scene(self, scene: ...) -> None:
         """
         Updates the scene of the node
         """
         self.scene = scene
+        self.engine = scene.engine
         self.node_handler = scene.node_handler
 
         # Update materials
         self.write_materials()
 
         # Update the mesh
-        self.mesh = self.mesh if self.mesh else self.scene.engine.cube
+        self.mesh = self.mesh if self.mesh else self.engine.cube
 
         # Update physics and collider
         if self.physics_body: self.physics_body.physics_engine = scene.physics_engine
@@ -387,14 +389,14 @@ class Node():
         if isinstance(self.material, list):
             mtl_index_list = []
             for mtl in self._mtl_list:
-                self.node_handler.scene.material_handler.add(mtl)
+                self.engine.material_handler.add(mtl)
                 mtl_index_list.append(mtl.index)
                 mtl_index_list.append(mtl.index)
                 mtl_index_list.append(mtl.index)
             self._material = mtl_index_list
 
         if isinstance(self.material, type(None)):
-            self.material = self.scene.material_handler.base
+            self.material = self.engine.material_handler.base
         
 
     def __repr__(self) -> str:
@@ -555,16 +557,16 @@ class Node():
             else:
                 mtl_index_list = []
                 for mtl in self._mtl_list:
-                    self.node_handler.scene.material_handler.add(mtl)
+                    self.engine.material_handler.add(mtl)
                     mtl_index_list.append(mtl.index)
                     mtl_index_list.append(mtl.index)
                     mtl_index_list.append(mtl.index)
                 self._material = mtl_index_list
         elif isinstance(value, Material): 
             self._material = value
-            if self.node_handler: self.node_handler.scene.material_handler.add(value)
+            if self.node_handler: self.engine.material_handler.add(value)
         elif isinstance(value, type(None)):
-            if self.scene: self._material = self.scene.material_handler.base
+            if self.engine: self._material = self.engine.material_handler.base
             else: self._material = None
 
         else: raise TypeError(f'Node: Invalid material value type {type(value)}')

{basilisk_engine-0.1.22 → basilisk_engine-0.1.24}/basilisk/nodes/node_handler.py

@@ -19,6 +19,7 @@ class NodeHandler():
         """
         
         self.scene = scene
+        self.engine = scene.engine
         self.nodes = []
         self.chunk_handler = ChunkHandler(scene)
 
@@ -49,9 +50,9 @@ class NodeHandler():
         for n in node.get_all(): # gets all nodes including the node to be added
             
             # Update scene Handlers
-            self.scene.shader_handler.add(n.shader)
-            if not n.material: n.material = self.scene.material_handler.base
-            self.scene.material_handler.add(n.material)
+            self.engine.shader_handler.add(n.shader)
+            if not n.material: n.material = self.engine.material_handler.base
+            self.engine.material_handler.add(n.material)
             
             # Update the node attributes
             n.init_scene(self.scene)

{basilisk_engine-0.1.22 → basilisk_engine-0.1.24}/basilisk/particles/particle_handler.py

@@ -43,7 +43,7 @@ class ParticleHandler:
         # Get material ID
         if material == None: material_index = 0
         elif isinstance(material, Material): 
-            self.scene.material_handler.add(material)
+            self.scene.engine.material_handler.add(material)
             material_index = material.index
         else: raise ValueError(f'particle_handler.add: Invalid particle material type: {type(material)}')
 

{basilisk_engine-0.1.22 → basilisk_engine-0.1.24}/basilisk/particles/particle_renderer.py

@@ -31,7 +31,7 @@ class ParticleRenderer:
         root = scene.engine.root
         if shader: self.shader = shader
         else: self.shader = Shader(scene.engine, vert=root + '/shaders/particle.vert', frag=root + '/shaders/particle.frag')
-        scene.shader_handler.add(self.shader)
+        scene.engine.shader_handler.add(self.shader)
 
         self.particle_cube_size = 25