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

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.py

@@ -41,6 +41,10 @@ class Engine():
     """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:
         """
@@ -113,6 +117,7 @@ class Engine():
 
         if self.current_frame_updated: return
 
+        for fbo in self.fbos: fbo.clear()
         self.clock.update()
         self.IO.update()
 

basilisk/input_output/IO_handler.py

@@ -73,8 +73,7 @@ class IO:
                 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()
+                for fbo in self.engine.fbos: fbo.resize()
 
     def update_caption(self) -> None:
         """

basilisk/input_output/mouse.py

@@ -3,10 +3,12 @@ import pygame as pg
 
 class Mouse():
     def __init__(self, grab=True):
-        self.x, self.y = pg.mouse.get_pos()
+        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):
         """
@@ -14,7 +16,8 @@ class Mouse():
         Checks for mouse-related events.
         """
         
-        self.x, self.y = pg.mouse.get_pos()
+        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()
 
@@ -22,17 +25,25 @@ class Mouse():
             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:
+                    self.grab = False
+                    self.visible = True
+            if event.type == pg.MOUSEBUTTONUP and not 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)
+                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
@@ -47,16 +58,33 @@ class Mouse():
     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):
+    def grab(self, value) -> bool:
         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)
+        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/mesh/mesh.py

@@ -30,12 +30,14 @@ class Mesh():
     bvh: NarrowBVH
     """BVH for accessing triangle intersections with a line"""
 
-    def __init__(self, data: str | os.PathLike | np.ndarray) -> None:
+    def __init__(self, data: str | os.PathLike | np.ndarray, custom_format:bool=False) -> None:
         """
         Mesh object containing all the data needed to render an object and perform physics/collisions on it
         Args:
             data: str
                 path to the .obj file of the model or an array of the mesh data
+            custom_format: bool
+                makes expected changes to the given data if false. Leaves data as given if true
         """
         
         # Verify the path type
@@ -59,7 +61,7 @@ class Mesh():
                 self.data = np.hstack([self.data, tangents])
 
         elif isinstance(data, np.ndarray):
-            model = from_data(data)      
+            model = from_data(data, custom_format)      
             self.data = model.vertex_data
             
         else:                                                       # Invalid data type
@@ -70,6 +72,7 @@ class Mesh():
         self.indices = model.point_indices.copy()
 
         self.hash = hash(str(self.data))
+        self.custom = custom_format
 
         # generate edges from faces
         edges = [set() for _ in range(len(self.points))]

basilisk/mesh/mesh_from_data.py

@@ -2,14 +2,20 @@ import numpy as np
 from .model import Model
 import glm
 
-def from_data(data: np.ndarray) -> Model:
+def from_data(data: np.ndarray, custom_format:bool=False) -> Model:
     """
     Converts data given to a format compatable with basilisk models
+    Args:
+        data: np.ndarray
+            array of the mesh data
+        custom_format: bool
+            makes expected changes to the given data if false. Leaves data as given if true
     """
 
+    if custom_format: return format_raw(data)
+
     # Create an empty model
     model = Model()
-    # Get the shape of the given data
 
     # Get the shape of the given data and check for a valid shape
     shape = data.shape
@@ -128,4 +134,18 @@ def get_points_and_indices(positions: np.ndarray) -> tuple[np.ndarray]:
         for triangle in index_mapping:
             indices[triangle].append(i)
 
-    return np.array(list(points.keys()), dtype='f4'), np.array(indices, dtype='i')
+    return np.array(list(points.keys()), dtype='f4'), np.array(indices, dtype='i')
+
+def format_raw(data: np.ndarray) -> np.ndarray:
+    # Create an empty model
+    model = Model()
+
+    # Get the needed data (assume position is in the first three positions)
+    model.vertex_data = np.array(data, dtype='f4')
+    if model.vertex_data.shape[1] >= 3:
+        model.vertex_points, model.point_indices = get_points_and_indices(model.vertex_data[:,:3])
+    else:
+        model.vertex_points = np.zeros(shape=(1, model.vertex_data.shape[1]))
+        model.point_indices = np.zeros(shape=(1, 3))
+
+    return model

basilisk/nodes/node.py

@@ -371,13 +371,16 @@ class Node():
         if not per_vertex_mtl: node_data[-1] = self.material.index
 
         # Create an array to hold the node's data
-        data = np.zeros(shape=(mesh_data.shape[0], 25), dtype='f4')
+        width = 25 if not self.mesh.custom else 11 + mesh_data.shape[1]
+        data = np.zeros(shape=(mesh_data.shape[0], width), dtype='f4')
 
 
-        data[:,:14] = mesh_data
-        data[:,14:] = node_data
+        data[:,:mesh_data.shape[1]] = mesh_data
+        data[:,mesh_data.shape[1]:] = node_data
 
-        if per_vertex_mtl: data[:,24] = self.material
+        if per_vertex_mtl: data[:,-1] = self.material
+
+        if self.shader and not self.mesh.custom: data = np.take(data, self.shader.attribute_indices, axis=1)
 
         return data
 

basilisk/render/batch.py

@@ -1,14 +1,14 @@
 import numpy as np
 import moderngl as mgl
-
+from .shader import Shader
 
 class Batch():
     chunk: ...
     """Reference to the parent chunk of the batch"""
     ctx: mgl.Context
     """Reference to the context of the parent engine"""
-    program: mgl.Program
-    """Reference to the program used by batches"""
+    shader: Shader
+    """Reference to the bsk.Shader used by batches"""
     vao: mgl.VertexArray
     """The vertex array of the batch. Used for rendering"""
     vbo: mgl.Buffer
@@ -23,7 +23,7 @@ class Batch():
         # Back references
         self.chunk = chunk
         self.ctx = chunk.chunk_handler.engine.ctx
-        self.program = self.chunk.get_program()
+        self.shader = self.chunk.get_shader()
 
         # Set intial values
         self.vbo = None
@@ -35,7 +35,7 @@ class Batch():
         Returns True if batch was successful.
         """
 
-        self.program = self.chunk.get_program()
+        self.shader = self.chunk.get_shader()
 
         # Empty list to contain all vertex data of models in the chunk
         batch_data = []
@@ -68,11 +68,9 @@ class Batch():
 
         # Create the vbo and the vao from mesh data
         self.vbo = self.ctx.buffer(batch_data)
-        self.vao = self.ctx.vertex_array(self.program, [(self.vbo, 
-                                                         '3f 2f 3f 3f 3f 3f 4f 3f 1f', 
-                                                         *['in_position', 'in_uv', 'in_normal', 'in_tangent', 'in_bitangent', 'obj_position', 'obj_rotation', 'obj_scale', 'obj_material'])], 
-                                                         skip_errors=True)
-        
+        self.vao = self.ctx.vertex_array(self.shader.program, [(self.vbo, self.shader.fmt, *self.shader.attributes)], skip_errors=True)
+
+
         return True
 
     def swap_shader(self, shader):

basilisk/render/camera.py

@@ -24,7 +24,7 @@ class Camera:
     position: glm.vec3
     """Location of the camera (maters)"""
 
-    def __init__(self, position=(0, 0, 20), rotation=(1, 0, 0, 0), yaw=-90, pitch=0) -> None:
+    def __init__(self, position=(0, 0, 20), rotation=(1, 0, 0, 0)) -> None:
         """
         Camera object to get view and projection matricies. Movement built in
         """
@@ -52,20 +52,6 @@ class Camera:
         # self.update_camera_vectors()
         self.m_view = self.get_view_matrix()
 
-    # def update_camera_vectors(self) -> None:
-    #     """
-    #     Computes the forward vector based on the pitch and yaw. Computes horizontal and vertical vectors with cross product.
-    #     """
-    #     yaw, pitch = glm.radians(self.yaw), glm.radians(self.pitch)
-
-    #     self.forward.x = glm.cos(yaw) * glm.cos(pitch)
-    #     self.forward.y = glm.sin(pitch)
-    #     self.forward.z = glm.sin(yaw) * glm.cos(pitch)
-
-    #     self.forward = glm.normalize(self.forward)
-    #     self.right = glm.normalize(glm.cross(self.forward, self.UP))
-    #     self.up = glm.normalize(glm.cross(self.right, self.forward))
-
     def use(self):
         # Updated aspect ratio of the screen
         self.aspect_ratio = self.engine.win_size[0] / self.engine.win_size[1]
@@ -186,8 +172,8 @@ class Camera:
 
 
 class FreeCamera(Camera):
-    def __init__(self, position=(0, 0, 20), rotation=(1, 0, 0, 0), yaw=-90, pitch=0):
-        super().__init__(position, rotation, yaw, pitch)
+    def __init__(self, position=(0, 0, 20), rotation=(1, 0, 0, 0)):
+        super().__init__(position, rotation)
 
     def update(self) -> None:
         """
@@ -203,7 +189,7 @@ class FreeCamera(Camera):
         """
         Rotates the camera based on the amount of mouse movement.
         """
-        rel_x, rel_y = pg.mouse.get_rel()
+        rel_x, rel_y = self.engine.mouse.relative
         
         yaw_rotation = glm.angleAxis(SENSITIVITY * rel_x, -self.UP)
         pitch_rotation = glm.angleAxis(SENSITIVITY * rel_y, -self.right)
@@ -231,11 +217,16 @@ class FreeCamera(Camera):
             self.position += self.UP * velocity
         if keys[pg.K_LSHIFT]:
             self.position -= self.UP * velocity
+            
+class FixedCamera(FreeCamera):
+    def __init__(self, position=(0, 0, 20), rotation=(1, 0, 0, 0)):
+        super().__init__(position, rotation)
 
+    def move(self): pass
 
 class FollowCamera(FreeCamera):
-    def __init__(self, parent, position=(0, 0, 20), rotation=(1, 0, 0, 0), yaw=-90, pitch=0, offset=(0, 0, 0)):
-        super().__init__(position, rotation, yaw, pitch)
+    def __init__(self, parent, position=(0, 0, 20), rotation=(1, 0, 0, 0), offset=(0, 0, 0)):
+        super().__init__(position, rotation)
         self.parent = parent
         self.offest = glm.vec3(offset)
     
@@ -247,11 +238,11 @@ class FollowCamera(FreeCamera):
         self.position = self.parent.position + self.offest
         
 class OrbitCamera(FreeCamera):
-    def __init__(self, parent, position=(0, 0, 20), rotation=(1, 0, 0, 0), yaw=-90, pitch=0, distance=5, offset=(0, 0)):
+    def __init__(self, parent, position=(0, 0, 20), rotation=(1, 0, 0, 0), distance=5, offset=(0, 0)):
         self.parent = parent
         self.distance = distance
         self.offset = glm.vec2(offset)
-        super().__init__(position, rotation, yaw, pitch)
+        super().__init__(position, rotation)
 
     def get_view_matrix(self) -> glm.mat4x4:
         return glm.lookAt(self.position, self.parent.position, self.up)
@@ -263,5 +254,5 @@ class OrbitCamera(FreeCamera):
         self.position = self.parent.position - glm.normalize(self.forward) * self.distance
 
 class StaticCamera(Camera):
-    def __init__(self, position=(0, 0, 20), rotation=(1, 0, 0, 0), yaw=-90, pitch=0):
-        super().__init__(position, rotation, yaw, pitch)
+    def __init__(self, position=(0, 0, 20), rotation=(1, 0, 0, 0)):
+        super().__init__(position, rotation)

basilisk/render/chunk.py

@@ -79,15 +79,15 @@ class Chunk():
 
         return node
 
-    def get_program(self):
+    def get_shader(self):
         """
-        Gets the program of the chunks nodes' shader
+        Gets the bsk.Shader of the chunks nodes' shader
         """
 
         shader = self.shader
 
-        if shader: return shader.program
-        return self.chunk_handler.engine.shader.program
+        if shader: return shader
+        return self.chunk_handler.engine.shader
 
     def swap_shader(self, shader):
         """

basilisk/render/frame.py

@@ -11,7 +11,7 @@ class Frame:
     vao: mgl.VertexArray=None
     framebuffer: mgl.Framebuffer=None
 
-    def __init__(self, engine, resolution=1, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
+    def __init__(self, engine, scale: float=1.0, linear_filter: bool=False) -> None:
         """
         Basilisk render destination. 
         Can be used to render to the screen or for headless rendering
@@ -21,11 +21,8 @@ class Frame:
         self.ctx    = engine.ctx
 
         # Load framebuffer
-        self.resolution = resolution
-        self.filter = filter
-        size = tuple(map(lambda x: int(x * self.resolution), self.engine.win_size))
-        self.framebuffer = Framebuffer(self.engine, size=size, filter=self.filter)
-        self.ping_pong_buffer = Framebuffer(self.engine, size=size, filter=self.filter)
+        self.framebuffer = Framebuffer(self.engine, scale=scale, linear_filter=linear_filter)
+        self.ping_pong_buffer = Framebuffer(self.engine, scale=scale, linear_filter=linear_filter)
 
         # Load Shaders
         self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame.frag')
@@ -87,9 +84,8 @@ class Frame:
         Resize the frame to the given size. None for window size
         """
 
-        size = tuple(map(lambda x: int(x * self.resolution), self.engine.win_size))
-        self.framebuffer.resize(size)
-        self.ping_pong_buffer.resize(size)
+        self.framebuffer.resize()
+        self.ping_pong_buffer.resize()
 
     def __del__(self) -> None:
         """

basilisk/render/framebuffer.py

@@ -7,40 +7,76 @@ from ..render.shader import Shader
 class Framebuffer:
     engine: ...
     """Reference to the parent engine"""
-    fbo: mgl.Framebuffer = None
+    size: tuple[int] | None=None
+    """The dimensions of the framebuffer (x, y). Defaults to window size if None"""
+    scale: float=1.0
+    """Scaling factor applied to the size. Best for use with default size"""
+    texture_filter: tuple[int]=(mgl.NEAREST, mgl.NEAREST)
+    """The filter applied to the texture when rendering"""
+    fbo: mgl.Framebuffer=None
     """The core framebuffer the object provides abstraction for."""
-    texture: mgl.Texture = None
+    texture: mgl.Texture=None
     """The color texture of the framebuffer"""
-    depth: mgl.Texture = None
+    depth: mgl.Texture=None
     """The depth texture of the framebuffer"""
-    size: tuple[int]
-    """The dimensions of the framebuffer (x, y)"""
+    _color_attachments = None
+    """"""
+    _depth_attachment = None
+    """"""
 
-    def __init__(self, engine, size: tuple[int]=None, resolution_scale: float=1.0, components: int=4, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
+    def __init__(self, engine: ..., size: tuple[int]=None, n_color_attachments: int=1, scale: float=1.0, linear_filter: bool=True) -> None:
         """
-        Abstraction to the mgl framebuffer
-        Args:
-            engine: mgl.Engine: 
-                The parent engine
-            size: tuple[int]: 
-                The dimensions of the framebuffer (x, y)
+        Abstraction of the MGL framebuffer.
+        Has the given number of color attachements (4-component) and 1 depth attachment.
+        All textures are of uniform size.
+        """
+
+        self.engine         = engine
+        self.ctx            = engine.ctx
+        self._size          = size
+        self.scale          = scale
+        self.texture_filter = (mgl.LINEAR, mgl.LINEAR) if linear_filter else (mgl.NEAREST, mgl.NEAREST)
+        self.attachments    = n_color_attachments
+
+        self.load_pipeline()
+        self.generate_fbo()
+
+        self.engine.fbos.append(self)
+
+    def generate_fbo(self):
+        """
+        Generates fresh depth texture and color textures and creates an FBO 
+        """
+
+        # Release existing memory
+        self.__del__()
+
+        # Create textures
+        self._color_attachments = [self.ctx.texture(self.size, components=4)]
+        for tex in self._color_attachments: tex.filter = self.texture_filter
+        self._depth_attachment  = self.ctx.depth_texture(self.size)
+
+        # Create the internal fbo
+        self.fbo = self.ctx.framebuffer(self._color_attachments, self._depth_attachment)
+
+    def resize(self, new_size: tuple[int]=None) -> None:
+        """
+        Update set size framebuffers with the given size.
         """
         
-        # Set attributes
-        self.engine = engine
-        self.ctx = engine.ctx
-        self.components = components
-
-        # Set the size
-        self.resolution_scale = resolution_scale
-        self._size = size
-        self.size = self._size if self._size else self.engine.win_size
-        self.size = (int(self.size[0] * resolution_scale), int(self.size[1] * resolution_scale))
-        
-        # Create the fbo
-        self.texture = self.ctx.texture(self.size, components=self.components)
-        self.depth = self.ctx.depth_texture(self.size)
-        self.fbo   = self.ctx.framebuffer([self.texture], self.depth)
+        # Check that we are not updating the size to the existing size and
+        if self._size and self._size == new_size: return
+
+        # If we have a set size, update with the given size
+        if self._size and new_size: self._size = new_size
+
+        # Update the textures and fbo
+        self.generate_fbo()
+
+    def load_pipeline(self) -> None:
+        """
+        Loads the shader, vbo, and vao used to display the fbo
+        """
 
         # Load Shaders
         self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame.frag')
@@ -50,13 +86,11 @@ class Framebuffer:
         self.vbo = self.ctx.buffer(np.array([[-1, -1, 0, 0, 0], [1, -1, 0, 1, 0], [1, 1, 0, 1, 1], [-1, 1, 0, 0, 1], [-1, -1, 0, 0, 0], [1, 1, 0, 1, 1]], dtype='f4'))
         self.vao = self.ctx.vertex_array(self.shader.program, [(self.vbo, '3f 2f', 'in_position', 'in_uv')], skip_errors=True)
 
-        # Save the filter
-        self.filter = filter
+    def render(self, render_target=None) -> None:
 
-        # Add to the engine for updates
-        self.engine.fbos.append(self)
+        target = render_target if render_target else self.engine.frame
 
-    def render(self) -> None:
+        target.use()
         self.shader.program['screenTexture'] = 0
         self.texture.use(location=0)
         self.vao.render()
@@ -86,47 +120,170 @@ class Framebuffer:
         img = Image.frombytes('RGB', self.size, data).transpose(Image.FLIP_TOP_BOTTOM)
         img.save(f'{path}.png')
 
-    def resize(self, size: tuple[int]=None) -> None:
+
+    @property
+    def size(self) -> tuple[int]:
+        """Size of the textures in the fbo in pixels (x: int, y: int)"""
+        size = self._size if self._size else self.engine.win_size
+        size = tuple(map((lambda x: int(x * self.scale)), size))
+        return size
+    @property
+    def texture(self) -> mgl.Texture:
+        """First color attachment in the fbo"""
+        return self._color_attachments[0]
+    @property
+    def color_attachments(self) -> ...:
+        """List of all color attachments in the fbo"""
+        return self._color_attachments
+    @property
+    def depth(self) -> mgl.Texture:
+        """Depth attachment of the fbo"""
+        return self._depth_attachment
+    @property
+    def data(self) -> bytes:
+        """Reads the data from the fbo"""
+        return self.fbo.read()
+    
+
+    @size.setter
+    def size(self, value: tuple[int]=None) -> tuple[int]:
+        self.resize(value)
+        return self.size
+    
+    def __repr__(self) -> str:
+        return f'<bsk.Framebuffer | size: {self.size}>' 
+
+    def __del__(self) -> None:
         """
-        Resize the buffer to the given size. None for window size
+        Releases all memory used by the fbo
         """
 
-        # Release old memory
-        self.__del__()
+        if self._color_attachments: [tex.release() for tex in self._color_attachments]
+        if self._depth_attachment: self._depth_attachment.release()
+        if self.fbo: self.fbo.release()
 
-        # Set/get size attribute
-        if size:
-            self.size = size
-        else:
-            self.size = self._size if self._size else self.engine.win_size
-        self.size = (int(self.size[0] * self.resolution_scale), int(self.size[1] * self.resolution_scale))
+# class Framebuffer:
+#     engine: ...
+#     """Reference to the parent engine"""
+#     fbo: mgl.Framebuffer = None
+#     """The core framebuffer the object provides abstraction for."""
+#     texture: mgl.Texture = None
+#     """The color texture of the framebuffer"""
+#     depth: mgl.Texture = None
+#     """The depth texture of the framebuffer"""
+#     size: tuple[int]
+#     """The dimensions of the framebuffer (x, y)"""
 
-        # Create the fbo
-        print(self.size)
-        self.texture = self.ctx.texture(self.size, components=self.components)
-        self.depth = self.ctx.depth_texture(self.size)
-        self.fbo   = self.ctx.framebuffer([self.texture], self.depth)
+#     def __init__(self, engine, size: tuple[int]=None, resolution_scale: float=1.0, components: int=4, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
+#         """
+#         Abstraction to the mgl framebuffer
+#         Args:
+#             engine: mgl.Engine: 
+#                 The parent engine
+#             size: tuple[int]: 
+#                 The dimensions of the framebuffer (x, y)
+#         """
+        
+#         # Set attributes
+#         self.engine = engine
+#         self.ctx = engine.ctx
+#         self.components = components
 
-        self.filter = self._filter
+#         # Set the size
+#         self.resolution_scale = resolution_scale
+#         self._size = size
+#         self.size = self._size if self._size else self.engine.win_size
+#         self.size = (int(self.size[0] * resolution_scale), int(self.size[1] * resolution_scale))
+        
+#         # Create the fbo
+#         self.texture = self.ctx.texture(self.size, components=self.components)
+#         self.depth   = self.ctx.depth_texture(self.size)
+#         self.fbo     = self.ctx.framebuffer([self.texture], self.depth)
 
-    @property
-    def data(self):
-        return self.fbo.read(components=3, alignment=1)
+#         # Load Shaders
+#         self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame.frag')
+#         self.engine.shader_handler.add(self.shader)
 
-    @property
-    def filter(self):
-        return self.texture.filter
+#         # Load VAO
+#         self.vbo = self.ctx.buffer(np.array([[-1, -1, 0, 0, 0], [1, -1, 0, 1, 0], [1, 1, 0, 1, 1], [-1, 1, 0, 0, 1], [-1, -1, 0, 0, 0], [1, 1, 0, 1, 1]], dtype='f4'))
+#         self.vao = self.ctx.vertex_array(self.shader.program, [(self.vbo, '3f 2f', 'in_position', 'in_uv')], skip_errors=True)
+
+#         # Save the filter
+#         self.filter = filter
+
+#         # Add to the engine for updates
+#         self.engine.fbos.append(self)
+
+#     def render(self) -> None:
+#         self.shader.program['screenTexture'] = 0
+#         self.texture.use(location=0)
+#         self.vao.render()
+
+#     def use(self) -> None:
+#         """
+#         Select this framebuffer for use
+#         """
+
+#         self.fbo.use()
+
+#     def clear(self) -> None:
+#         """
+#         Clear all data currently in the textures (set to black)        
+#         """
+
+#         self.fbo.clear()
+
+#     def save(self, destination: str=None) -> None:
+#         """
+#         Saves the frame as an image to the given file destination
+#         """
+
+#         path = destination if destination else 'screenshot'
+
+#         data = self.fbo.read(components=3, alignment=1)
+#         img = Image.frombytes('RGB', self.size, data).transpose(Image.FLIP_TOP_BOTTOM)
+#         img.save(f'{path}.png')
+
+#     def resize(self, size: tuple[int]=None) -> None:
+#         """
+#         Resize the buffer to the given size. None for window size
+#         """
+
+#         # Release old memory
+#         self.__del__()
+
+#         # Set/get size attribute
+#         if size:
+#             self.size = size
+#         else:
+#             self.size = self._size if self._size else self.engine.win_size
+#         self.size = (int(self.size[0] * self.resolution_scale), int(self.size[1] * self.resolution_scale))
+
+#         # Create the fbo
+#         self.texture = self.ctx.texture(self.size, components=self.components)
+#         self.depth = self.ctx.depth_texture(self.size)
+#         self.fbo   = self.ctx.framebuffer([self.texture], self.depth)
+
+#         self.filter = self._filter
+
+#     @property
+#     def data(self):
+#         return self.fbo.read(components=3, alignment=1)
+
+#     @property
+#     def filter(self):
+#         return self.texture.filter
     
-    @filter.setter
-    def filter(self, value):
-        self._filter = value
-        self.texture.filter = value
+#     @filter.setter
+#     def filter(self, value):
+#         self._filter = value
+#         self.texture.filter = value
 
-    def __repr__(self) -> str:
-        return f'<bsk.Framebuffer | size: {self.size}>' 
+#     def __repr__(self) -> str:
+#         return f'<bsk.Framebuffer | size: {self.size}>' 
 
-    def __del__(self) -> None:
-        # Release any existing memory in case of a resize
-        if self.texture: self.texture.release()
-        if self.depth: self.depth.release()
-        if self.fbo:   self.fbo.release()
+#     def __del__(self) -> None:
+#         # Release any existing memory in case of a resize
+#         if self.texture: self.texture.release()
+#         if self.depth: self.depth.release()
+#         if self.fbo:   self.fbo.release()

basilisk/render/shader.py

@@ -80,10 +80,19 @@ class Shader:
             if tokens[0] == 'layout' and len(tokens) > 2 and 'in' in line:
                 self.attributes.append(tokens[-1][:-1])
 
-                if tokens[-1][:-1] not in attribute_mappings: continue
-                indices = attribute_mappings[tokens[-1][:-1]]
+                # Get the number of flots the attribute takes
+                if any(list(map(lambda x: x in tokens, ['float', 'int']))): n = 1
+                elif any(list(map(lambda x: x in tokens, ['vec2']))): n = 2
+                elif any(list(map(lambda x: x in tokens, ['vec3']))): n = 3
+                elif any(list(map(lambda x: x in tokens, ['vec4']))): n = 4
+                else: n = 1
+                self.fmt += f'{n}f '
+
+                if tokens[-1][:-1] in attribute_mappings:
+                    indices = attribute_mappings[tokens[-1][:-1]]
+                else:
+                    indices = [0 for i in range(n)]
                 self.attribute_indices.extend(indices)
-                self.fmt += f'{len(indices)}f '
 
         # Create a program with shaders
         self.program = self.ctx.program(vertex_shader=self.vertex_shader, fragment_shader=self.fragment_shader)

{basilisk_engine-0.1.23.dist-info → basilisk_engine-0.1.25.dist-info}/METADATA

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

{basilisk_engine-0.1.23.dist-info → basilisk_engine-0.1.25.dist-info}/RECORD

@@ -1,6 +1,6 @@
-basilisk/__init__.py,sha256=ayBAMFHfcEYSmXpAYNCfcSPKrsq-phXY8AAESlZiLfI,587
+basilisk/__init__.py,sha256=JclirSjufIEfEPaQhOhf5NzWoUkO60Ay4dacNeUSGRw,600
 basilisk/config.py,sha256=FC0tTQy8jcSZSlriro1SFN2sLw-KLfYQM63Jq6YPHjk,109
-basilisk/engine.py,sha256=JJLNombtFEGg68gefpBImWjIOPVo9fgipwsaCpJ9YJc,5608
+basilisk/engine.py,sha256=rrMrQutN_mJEJyzG_w86TUTEYbE8cu9kncMjXMZjiLo,5820
 basilisk/scene.py,sha256=FVKm6MDmGYxf5OElbDlMMqagsGTnLDbj5UHrdcGtuW4,11888
 basilisk/audio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/audio/sound.py,sha256=h2dQ3IKb_SRKNZqNuk-fdNg_Xfz0P7sqEXA33qiBXG4,692
@@ -41,26 +41,23 @@ basilisk/generic/quat.py,sha256=gEqvQvNwx5K7e0zqY0TFTAFtNFSkOatleoP9HQQ-xyk,5102
 basilisk/generic/quat_methods.py,sha256=SO18ush7pfeGUmncPy4i5nsab1e_zkQkY6zT1bAsSDY,234
 basilisk/generic/raycast_result.py,sha256=waVmS9fYhLoz_G_DU2Mj7896rF0Xy_59JVGALq-kD7g,783
 basilisk/generic/vec3.py,sha256=AtPSz2S1ZqAm-sZUz4phB09hgFxMIsJnQdU1wmxiOBw,5137
-basilisk/input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-basilisk/input/mouse.py,sha256=waXJLIyka4IVe3W2WH5SNNxiOQRouYo3NxafP3fg0qg,1937
-basilisk/input/path.py,sha256=GpFYe3Uu6VZAuKh9Q2nQM1H8immiCp_snznLG9FKcvU,441
-basilisk/input_output/IO_handler.py,sha256=f20Z3Uf48WSTN7A_DaSXGfil1AuBR-recVFCQNNHwB8,2878
+basilisk/input_output/IO_handler.py,sha256=DDQEjmIHzWo99rk1riT_QJKGQ5F8-lOilmchRXeQuYI,2822
 basilisk/input_output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/input_output/clock.py,sha256=GHTagpPyPlLjWyonaHV8M-nPCcdHcHL4JobbuUOxYf0,1462
 basilisk/input_output/keys.py,sha256=rMTqYnp3yST6YKSGeP7WFzIlJAwDMhCoBqeWxoOocJw,1368
-basilisk/input_output/mouse.py,sha256=waXJLIyka4IVe3W2WH5SNNxiOQRouYo3NxafP3fg0qg,1937
+basilisk/input_output/mouse.py,sha256=gE--Uhk8bhuQzEkC-LdVsTUexx9TrYo6psGnsCjFNrI,2899
 basilisk/input_output/path.py,sha256=GpFYe3Uu6VZAuKh9Q2nQM1H8immiCp_snznLG9FKcvU,441
 basilisk/mesh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/mesh/cube.py,sha256=PN6JvW3T8LzPYRnaGo6wsisRK0QI-ZbvMYDT9xs7iN8,1044
-basilisk/mesh/mesh.py,sha256=h646NvI8GTnIJ908znoezhq46t4i1lAfJ-jHtNlz4bo,9552
-basilisk/mesh/mesh_from_data.py,sha256=NEYCWgJVmF5d0i-_8g94ezWF6q8skLDZiK6Y51vFC7Q,4240
+basilisk/mesh/mesh.py,sha256=eEBCOSl8fn_VAHowojlkwzckZ7qAyDdneYSJHa2Lk48,9757
+basilisk/mesh/mesh_from_data.py,sha256=puRa8ycBjX2LbQB-ZOjJiXuNHh16laWgSqbgjHdlhcQ,4988
 basilisk/mesh/model.py,sha256=qm1lo23nBjkR-JxXvHzIO3DLa2bNWsMRX4Ilm_5uemY,11722
 basilisk/mesh/narrow_aabb.py,sha256=oMB_djlWOxpLAsuxeA8_KQafSOcRkDMCu5okvPYuLMQ,3779
 basilisk/mesh/narrow_bvh.py,sha256=29VLfEKa6BE6UDY1HJWlcM5TMR7ayg4loZ6S61PpLJM,4260
 basilisk/mesh/narrow_primative.py,sha256=Dlw0jnFewPwAvT0Ap9IxAh05tgjZAdjAyuiRy1DXOm4,930
 basilisk/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/nodes/helper.py,sha256=GZ2-TY_4PDEfxBGp7ddktYoDDMOogPMbDeRPqsrPu1A,2069
-basilisk/nodes/node.py,sha256=yldg6kemDLx8ei7aiiLVCK-5VMSmWIsFWxN1lNNmpDo,31951
+basilisk/nodes/node.py,sha256=6RoDC0YxBJiOolfRdOad3VpnTxTIelv_wTZweu8kJMI,32168
 basilisk/nodes/node_handler.py,sha256=IFEcEefVzlMbYR0O6OtM2qPcoZFrLYugiwAqEQMoTqo,4106
 basilisk/particles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/particles/particle_handler.py,sha256=PtWn8-qwfkD0r8CXcATvDEFstrKG86KVBH0j1ybEv58,2928
@@ -70,12 +67,12 @@ basilisk/physics/impulse.py,sha256=a_Ks-4LrjaN3siMmVwGp92_iyr9a-G1lb5Q-J7g6ipA,5
 basilisk/physics/physics_body.py,sha256=-iqo3YyCfMzpBVNA2I34JbfN7Z6phj5nnGHN-S8lBgs,1465
 basilisk/physics/physics_engine.py,sha256=C30oGb8rODdXORJJWjOWBPwlScnTHrp6CTPHSNcbgp0,1700
 basilisk/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-basilisk/render/batch.py,sha256=dmE7aGVxJBSBFL1_mQgJDDLQm-EnWWzxRqxLuUPoh2c,3670
-basilisk/render/camera.py,sha256=dRhvDy-TaDxFL8f_VyVb_voOFEenrNOh7MX_X7uFi2I,9985
-basilisk/render/chunk.py,sha256=YvvlKFLD3RUUu2wcROeOQsgnKWpDRpaO4LGKKnmoJU8,2718
+basilisk/render/batch.py,sha256=1ULXwzcs7v9ze1IDZDJXcaydRjwdgHH9TkyXxcadNiM,3396
+basilisk/render/camera.py,sha256=9yxgie-RYmgEzSLySI3SeUKTRX77nmt5II2nS2Gp9Qk,9411
+basilisk/render/chunk.py,sha256=4_jZ-nw0q5XMgyfxSgAMR7KzzEo0nKPwvyDLB4oqUsI,2704
 basilisk/render/chunk_handler.py,sha256=PJNGWv3DURm8rYKb3WlGVx6CJ5arbaIiMwA1UN-G480,6332
-basilisk/render/frame.py,sha256=PTIoDPn2w42sRYH9FlNvr1VYf5nSqBLskC2vw64whmU,3139
-basilisk/render/framebuffer.py,sha256=agG2nbM3mXYNYYCAp7uSo3AutJb4o6njly1za-N6210,4319
+basilisk/render/frame.py,sha256=v7EuQ7FRXzxyeS7QFlqyz-jzveAkQkglxhHVjv6zAFY,2917
+basilisk/render/framebuffer.py,sha256=JXBKmnujDraAl5swG2NgAyegUKHsIumQG3-RfpgVwiE,9884
 basilisk/render/image.py,sha256=HotYV1bUCJ71bJLfdertz2AKKh0q5k268Ph_tbzP9ss,2873
 basilisk/render/image_handler.py,sha256=DNb-AiouziLVQu3NkoG1F90YZTHHWyhFYhaWJ9uiUOU,4175
 basilisk/render/light.py,sha256=SOOh5zAGUCgQdJjWb5MlJgtvdxkEV8AWqQ4P93bJj2g,3783
@@ -83,7 +80,7 @@ basilisk/render/light_handler.py,sha256=gvg4OhDMy8dZg5XNcOZB4_1G2uE1gBFRxlBeoG3l
 basilisk/render/material.py,sha256=RdZDy-pqxlpBW8n8JOsxETmd5XjXu6cxrCd5_6_DOww,9436
 basilisk/render/material_handler.py,sha256=CG_a_cV4V_1iYdhCjn7etFxIbAXyRgVicR135rim0oA,3983
 basilisk/render/post_process.py,sha256=iDQ05SUXUUmVcCq4m6c16m0yfWxQjM3NB9vciorJnV0,4959
-basilisk/render/shader.py,sha256=cx2CiIECK4Y3G1Rv6HYX782yMqiO4FDNvj2PhI6CEYc,3804
+basilisk/render/shader.py,sha256=PQ0XwE4ZtekQBdVUKwLsXbbTlsI_yuUVsJM1Iy4MPsc,4259
 basilisk/render/shader_handler.py,sha256=w1bGwVXm61_dDVlX9WgU8CKOMdqTjcooNlMsdN9lVnc,2738
 basilisk/render/sky.py,sha256=orTtgkU35AHZTUGk9IevSXwVs6tktoDP52yEUM5Rg0E,4768
 basilisk/shaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -103,7 +100,7 @@ basilisk/shaders/particle.frag,sha256=JXhPDvgd7JDw0-PCZtCOjHTTw2DMeeSaBvTr5fHuIy
 basilisk/shaders/particle.vert,sha256=bJv3hsWjWYb-g0mgdCV9eH-TVRwpCzhA3wsgSUI3WEM,2943
 basilisk/shaders/sky.frag,sha256=KG8ablNdaJ5E2Gf1ZpfP3ih252fY8ZNjign_fwjN6V4,169
 basilisk/shaders/sky.vert,sha256=oAnrknEgsd9MawE_zx8P0u9nUSFEBYBg5ykBmWpqZ_g,332
-basilisk_engine-0.1.23.dist-info/METADATA,sha256=5D17pbGYywQa3FGIekT2OIM7BI_-TKw48fhXDyh-cbw,1261
-basilisk_engine-0.1.23.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-basilisk_engine-0.1.23.dist-info/top_level.txt,sha256=enlSYSf7CUyAly1jmUCNNGInTbaFUjGk4SKwyckZQkw,9
-basilisk_engine-0.1.23.dist-info/RECORD,,
+basilisk_engine-0.1.25.dist-info/METADATA,sha256=wi8e1bEHIgaea5pF5GyK8VsQvvUttrC645vv54H7mt4,1261
+basilisk_engine-0.1.25.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+basilisk_engine-0.1.25.dist-info/top_level.txt,sha256=enlSYSf7CUyAly1jmUCNNGInTbaFUjGk4SKwyckZQkw,9
+basilisk_engine-0.1.25.dist-info/RECORD,,

basilisk/input/mouse.py

@@ -1,62 +0,0 @@
-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 +0,0 @@
-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'