basilisk-engine 0.1.23__tar.gz → 0.1.25__tar.gz

{basilisk_engine-0.1.23 → basilisk_engine-0.1.25}/PKG-INFO

@@ -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 → basilisk_engine-0.1.25}/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.23 → basilisk_engine-0.1.25}/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_engine-0.1.23 → basilisk_engine-0.1.25}/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_engine-0.1.25/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.23 → basilisk_engine-0.1.25}/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_engine-0.1.23 → basilisk_engine-0.1.25}/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_engine-0.1.23 → basilisk_engine-0.1.25}/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_engine-0.1.23 → basilisk_engine-0.1.25}/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_engine-0.1.23 → basilisk_engine-0.1.25}/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_engine-0.1.23 → basilisk_engine-0.1.25}/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_engine-0.1.23 → basilisk_engine-0.1.25}/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:
         """