basilisk-engine 0.1.5__tar.gz → 0.1.7__tar.gz

{basilisk_engine-0.1.5/basilisk_engine.egg-info → basilisk_engine-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: basilisk-engine
-Version: 0.1.5
+Version: 0.1.7
 Summary: Python 3D Framework
 Home-page: https://basilisk-website.vercel.app/
 Author: Name
@@ -12,6 +12,7 @@ Requires-Dist: pygame-ce
 Requires-Dist: moderngl
 Requires-Dist: PyGLM
 Requires-Dist: numba
+Requires-Dist: PyOpenAL
 
 # Basilisk Engine
 ![image](https://github.com/user-attachments/assets/5e39445c-e0da-452c-9f18-e590cca948c4)

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/__init__.py

@@ -10,4 +10,6 @@ from .render.shader_handler import ShaderHandler
 from .draw import draw
 from .render.camera import FreeCamera, StaticCamera, FollowCamera, OrbitCamera
 from .render.sky import Sky
-from .render.post_process import PostProcess
+from .render.post_process import PostProcess
+from .render.framebuffer import Framebuffer
+from .audio.sound import Sound

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/collisions/collider_handler.py

@@ -141,7 +141,6 @@ class ColliderHandler():
             for point in incoming:
                 incoming_indices.add(point.index)
                 if point.index not in existing or glm.length2(point.vertex - existing[point.index]) > 1e-5: existing[point.index] = glm.vec3(point.vertex)
-                # if glm.length2(point.vertex - existing[point.index]) != 0: print(point.vertex - existing[point.index])
                     
             # remove changed stored points
             remove_indices = []
@@ -195,7 +194,7 @@ class ColliderHandler():
                 points1 = [ContactPoint(p.index1, p.vertex1) for p in polytope]
                 points2 = [ContactPoint(p.index2, p.vertex2) for p in polytope]
                 
-            if glm.dot(vec, node2.position - node1.position) > 0: vec *= -1
+            if glm.dot(vec, node2.position.data - node1.position.data) > 0: vec *= -1
             
             # add collision data to colliders
             collider1.collisions.append(Collision(node2, vec))
@@ -210,7 +209,7 @@ class ColliderHandler():
                 
                 collider_tuple = (collider1, collider2)
                 manifold = get_contact_manifold(
-                    node1.position - vec, 
+                    node1.position.data - vec, 
                     vec, 
                     self.contact_manifolds[collider_tuple].contact_points1.values(), 
                     self.contact_manifolds[collider_tuple].contact_points2.values()

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/collisions/narrow/contact_manifold.py

@@ -4,6 +4,10 @@ from .line_intersections import line_line_intersect, line_poly_intersect
 from .graham_scan import graham_scan
 from .sutherland_hodgman import sutherland_hodgman
 from .dataclasses import ContactPoint
+from ...generic.vec3 import Vec3
+from ...generic.quat import Quat
+
+
 
 # sutherland hodgman clipping algorithm
 def get_contact_manifold(contact_plane_point:glm.vec3, contact_plane_normal:glm.vec3, points1:list[glm.vec3], points2:list[glm.vec3]) -> list[glm.vec3]:
@@ -47,6 +51,7 @@ def separate_polytope(points1: list[ContactPoint], points2: list[ContactPoint],
     """
     Determines the potential contact manifold points of each shape based on their position along the penetrating axis
     """
+    
     proj1 = [(glm.dot(point.vertex, contact_plane_normal), point) for point in points1]
     proj2 = [(glm.dot(point.vertex, contact_plane_normal), point) for point in points2]
     
@@ -63,7 +68,7 @@ def distance_to_plane(contact_plane_point:glm.vec3, contact_plane_normal:glm.vec
     """gets the smallest distance a point is from a plane"""
     return glm.dot(point - contact_plane_point, contact_plane_normal) #TODO check this formula
 
-def project_points(contact_plane_point:glm.vec3, contact_plane_normal:glm.vec3, points:list[glm.vec3]) -> list[glm.vec3]:
+def project_points(contact_plane_point:glm.vec3, contact_plane_normal:glm.vec3, points:list[Vec3]) -> list[glm.vec3]:
     """gets the projected positions of the given points onto the given plane"""
     return [point - glm.dot(point - contact_plane_point, contact_plane_normal) * contact_plane_normal for point in points]
 

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/collisions/narrow/dataclasses.py

@@ -1,5 +1,7 @@
 import glm
 from dataclasses import dataclass
+
+from basilisk.generic.vec3 import Vec3
 # from ...nodes.node import Node
 
 # frozen because data does not need to be mutable
@@ -18,7 +20,7 @@ class SupportPoint():
 @dataclass(frozen=True)
 class ContactPoint():
     index: int
-    vertex: glm.vec3
+    vertex: Vec3
     
 # contact manifold object used in the contact handler list
 @dataclass

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/collisions/narrow/gjk.py

@@ -10,7 +10,7 @@ def collide_gjk(node1: Node, node2: Node, iterations: int=20) -> tuple: # TODO f
     Determines if two convex polyhedra collide, returns the polytope if there is a collision.
     """
     # generate starting values
-    dir_vec = node1.position - node2.position
+    dir_vec = node1.position.data - node2.position.data
     simplex = [get_support_point(node1, node2, dir_vec)]
     dir_vec = -simplex[0].support_point # set direction to point away from starting simplex point
     

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/collisions/narrow/helper.py

@@ -15,7 +15,7 @@ def get_furthest_point(node: Node, dir_vec: glm.vec3) -> glm.vec3:
     Determines the furthest point in a given direction
     """
     # determine furthest point by using untransformed mesh
-    node_dir_vec = node.rotation * dir_vec # rotate the world space vector to node space
+    node_dir_vec = node.rotation.data * dir_vec # rotate the world space vector to node space
     index = node.collider.mesh.get_best_dot(node_dir_vec)
     vertex = node.collider.mesh.points[index]
     vertex = node.model_matrix * glm.vec4(vertex, 1.0)

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/engine.py

@@ -10,7 +10,8 @@ from .config import Config
 from .input.mouse import Mouse
 from .mesh.cube import Cube
 from .render.shader import Shader
-
+import glcontext
+import openal
 
 class Engine():
     win_size: tuple
@@ -83,10 +84,9 @@ class Engine():
         # Global attributes referenced by the handlers
         self.headless = headless
         self.set_configurations()
-        # self.root = get_root()
-        # self.root = getattr(sys, '_MEIPASS', os.getcwd()) + '/basilisk'
         self.root = os.path.dirname(__file__)
         self.cube = Cube(self)
+        self.fbos = []
 
         # Update the icon
         pg.display.set_icon(pg.image.load(self.root + '/bsk_assets/basilisk.png'))
@@ -111,7 +111,7 @@ class Engine():
         # Set the scene to running
         self.running = True
 
-    def update(self) -> None:
+    def update(self, render=True) -> None:
         """
         Updates all input, physics, and time variables. Renders the current scene.
         """
@@ -132,6 +132,7 @@ class Engine():
         # Loop through all pygame events
         for event in self.events:
             if event.type == pg.QUIT: # Quit the engine
+                openal.oalQuit()
                 self.quit()
                 return
             if event.type == pg.VIDEORESIZE:
@@ -140,12 +141,13 @@ class Engine():
                 self.ctx.viewport = (0, 0, event.w, event.h)
                 self.scene.camera.use()
                 self.scene.frame.resize()
+                for fbo in self.fbos: fbo.resize()
 
 
         # Update the scene if possible
         if self.scene: self.scene.update()
         # Render after the scene and engine has been updated
-        self.render()
+        if render: self.render()
 
 
     def render(self) -> None:

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/generic/abstract_custom.py

@@ -8,7 +8,7 @@ class Custom():
         """
         Inplace normalizes the vector
         """
-        self.data = glm.normalize(self.data)
+        self._data = glm.normalize(self._data)
         return self
     
     def apply_function(): ... # will be overridden by child custom classes

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/generic/collisions.py

@@ -1,4 +1,6 @@
 import glm
+from ..generic.vec3 import Vec3
+from ..generic.quat import Quat
 
 
 def collide_aabb_aabb(top_right1: glm.vec3, bottom_left1: glm.vec3, top_right2: glm.vec3, bottom_left2: glm.vec3, epsilon:float=1e-7) -> bool:
@@ -53,13 +55,13 @@ def moller_trumbore(point:glm.vec3, vec:glm.vec3, triangle:list[glm.vec3], epsil
     if t > epsilon: return point + vec * t
     return None
 
-def get_sat_axes(rotation1: glm.quat, rotation2: glm.quat) -> list[glm.vec3]:
+def get_sat_axes(rotation1: Quat, rotation2: Quat) -> list[glm.vec3]:
     """
     Gets the axes for SAT from obb rotation matrices
     """
     axes = []
-    axes.extend(glm.transpose(glm.mat3_cast(rotation1)))
-    axes.extend(glm.transpose(glm.mat3_cast(rotation2)))
+    axes.extend(glm.transpose(glm.mat3_cast(rotation1.data)))
+    axes.extend(glm.transpose(glm.mat3_cast(rotation2.data)))
     
     # crossed roots
     for i in range(0, 3):

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/generic/matrices.py

@@ -1,14 +1,16 @@
 import glm
+from ..generic.vec3 import Vec3
+from ..generic.quat import Quat
 
 
 # transform matrices
-def get_model_matrix(position: glm.vec3, scale: glm.vec3, rotation: glm.quat) -> glm.mat4x4:
+def get_model_matrix(position: Vec3, scale: Vec3, rotation: Quat) -> glm.mat4x4:
     """
     Gets projection matrix from object data
     """
-    translation_matrix  = glm.translate(glm.mat4(1.0), position)
-    rotation_matrix     = glm.mat4_cast(rotation)
-    scale_matrix        = glm.scale(glm.mat4(1.0), scale)
+    translation_matrix  = glm.translate(glm.mat4(1.0), position.data)
+    rotation_matrix     = glm.mat4_cast(rotation.data)
+    scale_matrix        = glm.scale(glm.mat4(1.0), scale.data)
     model_matrix        = translation_matrix * glm.transpose(rotation_matrix) * scale_matrix
     return model_matrix
 

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/generic/quat.py

@@ -82,10 +82,10 @@ class Quat(Custom):
 
     # override str operators
     def __repr__(self):
-        return str(self.data)
-
-    def __iter__(self):
-        return iter((self.x, self.y, self.z))
+        return 'bsk' + str(self.data)
+    
+    def __str__(self):
+        return 'bsk ' + str(self.data)
     
     @property
     def data(self): return self._data
@@ -108,6 +108,7 @@ class Quat(Custom):
         if self.callback and (abs(cur.w - prev.w) > thresh or abs(cur.x - prev.x) > thresh or abs(cur.y - prev.y) > thresh or abs(cur.z - prev.z) > thresh): 
             self.prev_data = glm.quat(self._data)            
             self.callback()
+        self.normalize()
         
     @w.setter
     def w(self, value):
@@ -115,6 +116,7 @@ class Quat(Custom):
         if self.callback and abs(value - self.prev_data.w) > 1e-6: 
             self.prev_data.w = value
             self.callback()
+        self.normalize()
 
     @x.setter
     def x(self, value):
@@ -122,6 +124,7 @@ class Quat(Custom):
         if self.callback and abs(value - self.prev_data.x) > 1e-6: 
             self.prev_data.x = value
             self.callback()
+        self.normalize()
         
     @y.setter
     def y(self, value):
@@ -129,10 +132,12 @@ class Quat(Custom):
         if self.callback and abs(value - self.prev_data.y) > 1e-6: 
             self.prev_data.y = value
             self.callback()
+        self.normalize()
         
     @z.setter
     def z(self, value):
         self._data.z = value
         if self.callback and abs(value - self.prev_data.z) > 1e-6: 
             self.prev_data.z = value
-            self.callback()
+            self.callback()
+        self.normalize()

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/nodes/node.py

@@ -217,7 +217,7 @@ class Node():
         """
         # update based on physical properties
         if any(self.velocity): self.position += dt * self.velocity
-        if any(self.rotational_velocity): self.rotation = glm.normalize(self.rotation - dt / 2 * self.rotation * glm.quat(0, *self.rotational_velocity))
+        if any(self.rotational_velocity): self.rotation = glm.normalize(self.rotation.data - dt / 2 * self.rotation.data * glm.quat(0, *self.rotational_velocity))
 
         if self.physics_body:
             self.velocity += self.physics_body.get_delta_velocity(dt)
@@ -344,7 +344,7 @@ class Node():
         if self.physics_body: inertia_tensor *= self.physics_body.mass
                 
         # rotation
-        rotation_matrix = glm.mat3_cast(self.rotation)
+        rotation_matrix = glm.mat3_cast(self.rotation.data)
         inertia_tensor  = rotation_matrix * inertia_tensor * glm.transpose(rotation_matrix)
         
         return glm.inverse(inertia_tensor)
@@ -405,11 +405,11 @@ class Node():
         return f'<Bailisk Node | {self.name}, {self.mesh}, ({self.position})>'
     
     @property
-    def position(self): return self.internal_position.data
+    def position(self): return self.internal_position
     @property
-    def scale(self):    return self.internal_scale.data
+    def scale(self):    return self.internal_scale
     @property
-    def rotation(self): return self.internal_rotation.data
+    def rotation(self): return self.internal_rotation
     @property
     def forward(self):  return self._forward
     @property
@@ -492,6 +492,7 @@ class Node():
     @position.setter
     def position(self, value: tuple | list | glm.vec3 | np.ndarray):
         if isinstance(value, glm.vec3): self.internal_position.data = value
+        elif isinstance(value, Vec3): self.internal_position.data = value.data
         elif isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
             if len(value) != 3: raise ValueError(f'Node: Invalid number of values for position. Expected 3, got {len(value)}')
             self.internal_position.data = glm.vec3(value)
@@ -503,6 +504,7 @@ class Node():
     @scale.setter
     def scale(self, value: tuple | list | glm.vec3 | np.ndarray):
         if isinstance(value, glm.vec3): self.internal_scale.data = value
+        elif isinstance(value, Vec3): self.internal_scale.data = value.data
         elif isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
             if len(value) != 3: raise ValueError(f'Node: Invalid number of values for scale. Expected 3, got {len(value)}')
             self.internal_scale.data = glm.vec3(value)
@@ -514,6 +516,7 @@ class Node():
     @rotation.setter
     def rotation(self, value: tuple | list | glm.vec3 | glm.quat | glm.vec4 | np.ndarray):
         if isinstance(value, glm.quat) or isinstance(value, glm.vec4) or isinstance(value, glm.vec3): self.internal_rotation.data = glm.quat(value)
+        elif isinstance(value, Quat): self.internal_rotation.data = value.data
         elif isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
             if len(value) == 3: self.internal_rotation.data = glm.quat(glm.vec3(*value))
             elif len(value) == 4: self.internal_rotation.data = glm.quat(*value)
@@ -677,5 +680,4 @@ class Node():
                 if self.node_handler: self.collider.collider_handler = self.node_handler.scene.collider_handler
         elif not self.collider:
             self.collider = Collider(self)
-            if self.node_handler: self.collider.collider_handler = self.node_handler.scene.collider_handler
-                
+            if self.node_handler: self.collider.collider_handler = self.node_handler.scene.collider_handler

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/render/camera.py

@@ -101,6 +101,8 @@ class Camera:
     def direction(self): return self.forward
     @property
     def horizontal(self): return glm.normalize(self.forward.xz)
+    @property
+    def rotation(self): return glm.conjugate(glm.quatLookAt(self.forward, self.UP))
 
     @scene.setter
     def scene(self, value):

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/render/frame.py

@@ -46,7 +46,7 @@ class Frame:
         """
 
         for process in self.post_processes:
-            process.apply(self.framebuffer, self.ping_pong_buffer)
+            self.ping_pong_buffer = process.apply(self.framebuffer, self.ping_pong_buffer)
             
             temp = self.framebuffer
             self.framebuffer = self.ping_pong_buffer
@@ -64,7 +64,7 @@ class Frame:
         """
         
         self.framebuffer.use()
-        self.framebuffer.clear()
+        self.clear()
 
     def add_post_process(self, post_process: PostProcess) -> PostProcess:
         """
@@ -81,6 +81,9 @@ class Frame:
 
         self.framebuffer.save(destination)
     
+    def clear(self):
+        self.framebuffer.clear()
+
     def resize(self, size: tuple[int]=None) -> None:
         """
         Resize the frame to the given size. None for window size

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/render/framebuffer.py

@@ -1,6 +1,7 @@
+import numpy as np
 import moderngl as mgl
 from PIL import Image
-
+from ..render.shader import Shader
 
 
 class Framebuffer:
@@ -15,7 +16,7 @@ class Framebuffer:
     size: tuple[int]
     """The dimensions of the framebuffer (x, y)"""
 
-    def __init__(self, engine, size: tuple[int]=None, components: int=4, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
+    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:
@@ -28,18 +29,38 @@ class Framebuffer:
         # Set attributes
         self.engine = engine
         self.ctx = engine.ctx
-        self.size = size if size else engine.win_size
         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)
 
-        print()
+        # Load Shaders
+        self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame.frag')
+        self.engine.scene.shader_handler.add(self.shader)
+
+        # 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
@@ -74,7 +95,11 @@ class Framebuffer:
         self.__del__()
 
         # Set/get size attribute
-        self.size = size if size else self.engine.win_size
+        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)

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/render/post_process.py

@@ -80,7 +80,7 @@ class PostProcess:
         """
 
         # Create a blank framebuffer
-        if not detination:
+        if not detination or detination.size != self.size:
             fbo = Framebuffer(self.engine, self.size, self.components)
             old_filter = None
             fbo.texture.filter = self.filter

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk/scene.py

@@ -18,6 +18,7 @@ from .nodes.node import Node
 from .generic.collisions import moller_trumbore
 from .generic.raycast_result import RaycastResult
 from .render.post_process import PostProcess
+from .render.framebuffer import Framebuffer
 
 class Scene():
     engine: any
@@ -54,19 +55,26 @@ class Scene():
         if self.engine.delta_time < 0.5: # TODO this will cause physics to slow down when on low frame rate, this is probabl;y acceptable
             self.collider_handler.resolve_collisions()
 
-    def render(self) -> None:
+    def render(self, render_target: Framebuffer|Frame=None) -> None:
         """
         Renders all the nodes with meshes in the scene
         """
 
-        self.frame.use()
+        if render_target:
+            show = False
+        else:
+            render_target = self.frame
+            show = True
+
+        render_target.use()
+        render_target.clear()
         self.shader_handler.write()
         if self.sky: self.sky.render()
         self.node_handler.render()
         self.particle.render()
         self.draw_handler.render()
 
-        if self.engine.headless: return
+        if self.engine.headless or not show: return
         self.frame.render()
     
     def add(self, *objects: Node | None) -> None | Node | list:

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7/basilisk_engine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: basilisk-engine
-Version: 0.1.5
+Version: 0.1.7
 Summary: Python 3D Framework
 Home-page: https://basilisk-website.vercel.app/
 Author: Name
@@ -12,6 +12,7 @@ Requires-Dist: pygame-ce
 Requires-Dist: moderngl
 Requires-Dist: PyGLM
 Requires-Dist: numba
+Requires-Dist: PyOpenAL
 
 # Basilisk Engine
 ![image](https://github.com/user-attachments/assets/5e39445c-e0da-452c-9f18-e590cca948c4)

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/basilisk_engine.egg-info/requires.txt

@@ -4,3 +4,4 @@ pygame-ce
 moderngl
 PyGLM
 numba
+PyOpenAL

{basilisk_engine-0.1.5 → basilisk_engine-0.1.7}/setup.py

@@ -7,7 +7,7 @@ with open(path.join(working_directory, 'README.md'), encoding='utf-8') as f:
 
 setup(
     name = 'basilisk-engine',  # Name of folder containing scripts and __init__
-    version = '0.1.5',
+    version = '0.1.7',
     url = 'https://basilisk-website.vercel.app/',
     author = 'Name',
     author_email = 'basiliskengine@gmail.com',
@@ -16,5 +16,5 @@ setup(
     long_description_content_type = 'text/markdown',
     packages=find_packages(),
     include_package_data=True,
-    install_requires=['numpy', 'pillow', 'pygame-ce', 'moderngl', 'PyGLM', 'numba'],  # Include all used packages
+    install_requires=['numpy', 'pillow', 'pygame-ce', 'moderngl', 'PyGLM', 'numba', 'PyOpenAL'],  # Include all used packages
 )