basilisk-engine 0.1.13__py3-none-any.whl → 0.1.14__py3-none-any.whl

basilisk/__init__.py

@@ -1,15 +1,15 @@
-import pygame as pg
-from .engine import Engine
-from .scene import Scene
-from .nodes.node import Node
-from .mesh.mesh import Mesh
-from .render.image import Image
-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.sky import Sky
-from .render.post_process import PostProcess
-from .render.framebuffer import Framebuffer
+import pygame as pg
+from .engine import Engine
+from .scene import Scene
+from .nodes.node import Node
+from .mesh.mesh import Mesh
+from .render.image import Image
+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.sky import Sky
+from .render.post_process import PostProcess
+from .render.framebuffer import Framebuffer
 from .audio.sound import Sound

basilisk/audio/sound.py

@@ -1,28 +1,28 @@
-import os
-import pygame as pg
-
-class Sound:
-    def __init__(self, path: str | os.PathLike):
-        """
-        Sound object that can be played
-        """
-
-        if not (isinstance(path, str) or isinstance(path, os.PathLike)):
-            raise ValueError(f'bsk.Sound: Invalid source path type {type(path)}. Expected string or os.PathLike')
-
-        self.source = pg.mixer.Sound(path)
-
-    def play(self, volume: float=1.0):
-        """
-        Play the sound at the given volume level. Full volume if none given
-        """
-
-        self.source.set_volume(volume)
-        self.source.play()
-
-    def stop(self):
-        """
-        Stops the sound
-        """
-
+import os
+import pygame as pg
+
+class Sound:
+    def __init__(self, path: str | os.PathLike):
+        """
+        Sound object that can be played
+        """
+
+        if not (isinstance(path, str) or isinstance(path, os.PathLike)):
+            raise ValueError(f'bsk.Sound: Invalid source path type {type(path)}. Expected string or os.PathLike')
+
+        self.source = pg.mixer.Sound(path)
+
+    def play(self, volume: float=1.0):
+        """
+        Play the sound at the given volume level. Full volume if none given
+        """
+
+        self.source.set_volume(volume)
+        self.source.play()
+
+    def stop(self):
+        """
+        Stops the sound
+        """
+
         self.source.stop()

basilisk/bsk_assets/cube.obj

@@ -1,49 +1,49 @@
-# Blender 4.1.0
-# www.blender.org
-mtllib cube.mtl
-o Cube
-v -1.000000 -1.000000 1.000000
-v -1.000000 1.000000 1.000000
-v -1.000000 -1.000000 -1.000000
-v -1.000000 1.000000 -1.000000
-v 1.000000 -1.000000 1.000000
-v 1.000000 1.000000 1.000000
-v 1.000000 -1.000000 -1.000000
-v 1.000000 1.000000 -1.000000
-vn -1.0000 -0.0000 -0.0000
-vn -0.0000 -0.0000 -1.0000
-vn 1.0000 -0.0000 -0.0000
-vn -0.0000 -0.0000 1.0000
-vn -0.0000 -1.0000 -0.0000
-vn -0.0000 1.0000 -0.0000
-vt 0.002191 0.000000
-vt 0.997809 0.002461
-vt 0.996578 0.998078
-vt 0.002191 0.994387
-vt 0.002191 0.005152
-vt 1.000269 0.001461
-vt 0.996578 0.999539
-vt 0.003422 0.998309
-vt 0.000961 0.000461
-vt 0.999039 -0.004461
-vt 0.996578 0.996078
-vt 0.002191 0.993618
-vt 0.003422 -0.001769
-vt 1.001500 0.001922
-vt 0.996578 0.997539
-vt 0.002191 1.001230
-vt 0.005652 0.000461
-vt 0.997578 0.000461
-vt 0.995117 1.001000
-vt 0.000730 0.998539
-vt 0.001191 -0.000769
-vt 1.000000 0.000000
-vt 0.997479 0.997489
-vt 0.006113 0.997309
-s 0
-f 1/1/1 2/2/1 4/3/1 3/4/1
-f 3/5/2 4/6/2 8/7/2 7/8/2
-f 7/9/3 8/10/3 6/11/3 5/12/3
-f 5/13/4 6/14/4 2/15/4 1/16/4
-f 3/17/5 7/18/5 5/19/5 1/20/5
+# Blender 4.1.0
+# www.blender.org
+mtllib cube.mtl
+o Cube
+v -1.000000 -1.000000 1.000000
+v -1.000000 1.000000 1.000000
+v -1.000000 -1.000000 -1.000000
+v -1.000000 1.000000 -1.000000
+v 1.000000 -1.000000 1.000000
+v 1.000000 1.000000 1.000000
+v 1.000000 -1.000000 -1.000000
+v 1.000000 1.000000 -1.000000
+vn -1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 -1.0000
+vn 1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 1.0000
+vn -0.0000 -1.0000 -0.0000
+vn -0.0000 1.0000 -0.0000
+vt 0.002191 0.000000
+vt 0.997809 0.002461
+vt 0.996578 0.998078
+vt 0.002191 0.994387
+vt 0.002191 0.005152
+vt 1.000269 0.001461
+vt 0.996578 0.999539
+vt 0.003422 0.998309
+vt 0.000961 0.000461
+vt 0.999039 -0.004461
+vt 0.996578 0.996078
+vt 0.002191 0.993618
+vt 0.003422 -0.001769
+vt 1.001500 0.001922
+vt 0.996578 0.997539
+vt 0.002191 1.001230
+vt 0.005652 0.000461
+vt 0.997578 0.000461
+vt 0.995117 1.001000
+vt 0.000730 0.998539
+vt 0.001191 -0.000769
+vt 1.000000 0.000000
+vt 0.997479 0.997489
+vt 0.006113 0.997309
+s 0
+f 1/1/1 2/2/1 4/3/1 3/4/1
+f 3/5/2 4/6/2 8/7/2 7/8/2
+f 7/9/3 8/10/3 6/11/3 5/12/3
+f 5/13/4 6/14/4 2/15/4 1/16/4
+f 3/17/5 7/18/5 5/19/5 1/20/5
 f 8/21/6 4/22/6 2/23/6 6/24/6

basilisk/collisions/broad/broad_aabb.py

@@ -1,103 +1,103 @@
-import glm
-from ...generic.abstract_bvh import AbstractAABB as AABB
-from ...generic.collisions import collide_aabb_aabb, collide_aabb_line
-from ...generic.meshes import get_aabb_surface_area
-from ..collider import Collider
-
-
-class BroadAABB(AABB):
-    a: AABB | Collider
-    """The first child of the AABB"""
-    b: AABB | Collider
-    """The second child of the AABB"""
-    top_right: glm.vec3
-    """furthest positive vertex of the AABB"""
-    bottom_left: glm.vec3
-    """furthest negative vertex of the AABB"""
-    parent: AABB
-    """Back reference to the parent AABB"""
-    
-    def __init__(self, a: AABB | Collider, b: AABB | Collider, parent: AABB) -> None:
-        self.a = a
-        self.b = b
-        self.parent = parent
-        
-        # calculate extreme points
-        self.update_points()
-        
-    def update_points(self) -> None:
-        """
-        Updates the extreme points of the AABB based on the children
-        """
-        self.top_right   = glm.max(self.a.top_right, self.b.top_right)
-        self.bottom_left = glm.min(self.a.bottom_left, self.b.bottom_left)
-        
-    def find_sibling(self, collider: Collider, inherited: float) -> tuple[float, AABB | Collider]:
-        """
-        Determines the best sibling for inserting a collider into the BVH
-        """
-        # compute estimate sa
-        top_right   = glm.max(self.top_right, collider.top_right)
-        bottom_left = glm.min(self.bottom_left, collider.bottom_left)
-        union_area  = get_aabb_surface_area(top_right, bottom_left)
-        
-        # compute lowest cost and determine if children are a viable option
-        c_best = union_area + inherited
-        
-        delta_surface_area = union_area - self.surface_area 
-
-        c_low = collider.aabb_surface_area + delta_surface_area + inherited
-        
-        # investigate children
-        best_sibling = self
-        if c_low >= c_best: return c_best, best_sibling
-        
-        for child in (self.a, self.b):
-            if isinstance(child, BroadAABB): child_c, child_aabb = child.find_sibling(collider, inherited + delta_surface_area)
-            else: 
-                # compute cost for child
-                top_right   = glm.max(self.top_right, child.top_right)
-                bottom_left = glm.min(self.bottom_left, child.bottom_left)
-                union_area  = get_aabb_surface_area(top_right, bottom_left)
-
-                child_c, child_aabb = union_area + inherited, child
-            
-            if child_c < c_best: c_best, best_sibling = child_c, child_aabb
-            
-        return c_best, best_sibling
-    
-    def get_collided(self, collider: Collider) -> list[Collider]:
-        """
-        Returns which objects may be colliding from the BVH
-        """
-        if not collide_aabb_aabb(self.top_right, self.bottom_left, collider.top_right, collider.bottom_left): return []
-        
-        # test children
-        possible = []
-        if isinstance(self.a, BroadAABB): possible.extend(self.a.get_collided(collider))
-        elif collide_aabb_aabb(self.a.top_right, self.a.bottom_left, collider.top_right, collider.bottom_left): possible.append(self.a)
-        if isinstance(self.b, BroadAABB): possible.extend(self.b.get_collided(collider))
-        elif collide_aabb_aabb(self.b.top_right, self.b.bottom_left, collider.top_right, collider.bottom_left): possible.append(self.b)
-        return possible
-    
-    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[Collider]:
-        """
-        Returns the colliders that may intersect with the given line
-        """
-        if not collide_aabb_line(self.top_right, self.bottom_left, position, forward): return []
-        return (self.a.get_line_collided(position, forward) if isinstance(self.a, BroadAABB) else [self.a]) + (self.b.get_line_collided(position, forward) if isinstance(self.b, BroadAABB) else [self.b])
-        
-    def get_all_aabbs(self, layer: int) -> list[tuple[glm.vec3, glm.vec3, int]]: # TODO test function
-        """
-        Returns all AABBs, their extreme points, and their layer
-        """
-        aabbs = [(self.top_right, self.bottom_left, layer)]
-        if isinstance(self.a, BroadAABB): aabbs += self.a.get_all_aabbs(layer + 1)
-        else: aabbs.append((self.a.top_right, self.a.bottom_left, layer + 1))
-        if isinstance(self.b, BroadAABB): aabbs += self.b.get_all_aabbs(layer + 1)
-        else: aabbs.append((self.b.top_right, self.b.bottom_left, layer + 1))
-        return aabbs
-        
-    @property
-    def surface_area(self): return get_aabb_surface_area(self.top_right, self.bottom_left)
+import glm
+from ...generic.abstract_bvh import AbstractAABB as AABB
+from ...generic.collisions import collide_aabb_aabb, collide_aabb_line
+from ...generic.meshes import get_aabb_surface_area
+from ..collider import Collider
+
+
+class BroadAABB(AABB):
+    a: AABB | Collider
+    """The first child of the AABB"""
+    b: AABB | Collider
+    """The second child of the AABB"""
+    top_right: glm.vec3
+    """furthest positive vertex of the AABB"""
+    bottom_left: glm.vec3
+    """furthest negative vertex of the AABB"""
+    parent: AABB
+    """Back reference to the parent AABB"""
+    
+    def __init__(self, a: AABB | Collider, b: AABB | Collider, parent: AABB) -> None:
+        self.a = a
+        self.b = b
+        self.parent = parent
+        
+        # calculate extreme points
+        self.update_points()
+        
+    def update_points(self) -> None:
+        """
+        Updates the extreme points of the AABB based on the children
+        """
+        self.top_right   = glm.max(self.a.top_right, self.b.top_right)
+        self.bottom_left = glm.min(self.a.bottom_left, self.b.bottom_left)
+        
+    def find_sibling(self, collider: Collider, inherited: float) -> tuple[float, AABB | Collider]:
+        """
+        Determines the best sibling for inserting a collider into the BVH
+        """
+        # compute estimate sa
+        top_right   = glm.max(self.top_right, collider.top_right)
+        bottom_left = glm.min(self.bottom_left, collider.bottom_left)
+        union_area  = get_aabb_surface_area(top_right, bottom_left)
+        
+        # compute lowest cost and determine if children are a viable option
+        c_best = union_area + inherited
+        
+        delta_surface_area = union_area - self.surface_area 
+
+        c_low = collider.aabb_surface_area + delta_surface_area + inherited
+        
+        # investigate children
+        best_sibling = self
+        if c_low >= c_best: return c_best, best_sibling
+        
+        for child in (self.a, self.b):
+            if isinstance(child, BroadAABB): child_c, child_aabb = child.find_sibling(collider, inherited + delta_surface_area)
+            else: 
+                # compute cost for child
+                top_right   = glm.max(self.top_right, child.top_right)
+                bottom_left = glm.min(self.bottom_left, child.bottom_left)
+                union_area  = get_aabb_surface_area(top_right, bottom_left)
+
+                child_c, child_aabb = union_area + inherited, child
+            
+            if child_c < c_best: c_best, best_sibling = child_c, child_aabb
+            
+        return c_best, best_sibling
+    
+    def get_collided(self, collider: Collider) -> list[Collider]:
+        """
+        Returns which objects may be colliding from the BVH
+        """
+        if not collide_aabb_aabb(self.top_right, self.bottom_left, collider.top_right, collider.bottom_left): return []
+        
+        # test children
+        possible = []
+        if isinstance(self.a, BroadAABB): possible.extend(self.a.get_collided(collider))
+        elif collide_aabb_aabb(self.a.top_right, self.a.bottom_left, collider.top_right, collider.bottom_left): possible.append(self.a)
+        if isinstance(self.b, BroadAABB): possible.extend(self.b.get_collided(collider))
+        elif collide_aabb_aabb(self.b.top_right, self.b.bottom_left, collider.top_right, collider.bottom_left): possible.append(self.b)
+        return possible
+    
+    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[Collider]:
+        """
+        Returns the colliders that may intersect with the given line
+        """
+        if not collide_aabb_line(self.top_right, self.bottom_left, position, forward): return []
+        return (self.a.get_line_collided(position, forward) if isinstance(self.a, BroadAABB) else [self.a]) + (self.b.get_line_collided(position, forward) if isinstance(self.b, BroadAABB) else [self.b])
+        
+    def get_all_aabbs(self, layer: int) -> list[tuple[glm.vec3, glm.vec3, int]]: # TODO test function
+        """
+        Returns all AABBs, their extreme points, and their layer
+        """
+        aabbs = [(self.top_right, self.bottom_left, layer)]
+        if isinstance(self.a, BroadAABB): aabbs += self.a.get_all_aabbs(layer + 1)
+        else: aabbs.append((self.a.top_right, self.a.bottom_left, layer + 1))
+        if isinstance(self.b, BroadAABB): aabbs += self.b.get_all_aabbs(layer + 1)
+        else: aabbs.append((self.b.top_right, self.b.bottom_left, layer + 1))
+        return aabbs
+        
+    @property
+    def surface_area(self): return get_aabb_surface_area(self.top_right, self.bottom_left)
     

basilisk/collisions/broad/broad_bvh.py

@@ -1,138 +1,138 @@
-import glm
-from .broad_aabb import BroadAABB
-from ..collider import Collider
-from ...generic.abstract_bvh import AbstractBVH as BVH
-from ...generic.meshes import get_aabb_surface_area
-
-class BroadBVH(BVH):
-    root: BroadAABB
-    """The root node of the BVH"""
-    collider_handler: ...
-    """Back reference to the collider ahndler for accessing colliders"""
-    
-    def __init__(self, collider_handler) -> None:
-        self.collider_handler = collider_handler
-        self.root = None
-        
-    def add(self, collider: Collider) -> None:
-        """
-        Adds a single collider to the bvh tree
-        """
-        # test if tree needs to be initiated
-        if not self.root: 
-            self.root = collider # TODO ensure that this is final format for primative
-            return
-        
-        # check if root is primative
-        if isinstance(self.root, Collider): 
-            sibling = self.root
-            self.root      = BroadAABB(sibling, collider, None)
-            sibling.parent = collider.parent = self.root
-            return
-        
-        # find the best sibling (c_best only used during the recursion)
-        c_best, sibling = self.root.find_sibling(collider, 0)
-        old_parent = sibling.parent
-        new_parent = BroadAABB(sibling, collider, old_parent)
-        
-        # if the sibling was not the root
-        if old_parent:
-            if old_parent.a == sibling: old_parent.a = new_parent
-            else:                       old_parent.b = new_parent
-        else: self.root = new_parent
-        
-        sibling.parent = new_parent
-        collider.parent = new_parent
-        
-        # walk back up tree and refit TODO add tree rotations
-        aabb = new_parent
-        while aabb:
-            aabb.update_points()
-            self.rotate(aabb)
-            aabb = aabb.parent
-        
-    def get_all_aabbs(self) -> list[tuple[glm.vec3, glm.vec3, int]]: # TODO test function
-        """
-        Returns all AABBs, their extreme points, and their layer
-        """
-        if isinstance(self.root, BroadAABB): return self.root.get_all_aabbs(0)
-        return [(self.root.top_right, self.root.bottom_left, 0)]
-        
-    def remove(self, collider: Collider) -> None:
-        """
-        Removes a collider from the BVH, refitting the tree and adjusting relations
-        """
-        parent: BroadAABB | None = collider.parent
-        
-        # if collider is the root, remove the root
-        if not parent:
-            self.root = None
-            return
-        
-        # if collider has no grandparent, remove parent and set sibling as root
-        grand   = parent.parent
-        sibling = parent.b if collider == parent.a else parent.a
-        if not grand:
-            self.root = sibling
-            sibling.parent = None
-            return
-    
-        # if grandparent exists
-        if parent == grand.a: grand.a = sibling
-        else:                 grand.b = sibling
-        sibling.parent = grand
-        
-        # move up and refit tree
-        aabb = grand
-        while aabb:
-            aabb.update_points()
-            aabb = aabb.parent
-    
-    def rotate(self, aabb: BroadAABB) -> None:
-        """
-        Rotates the BVH tree to reduce surface area of internal AABBs
-        """
-        # determine if rotation is possible
-        parent: BroadAABB | None = aabb.parent
-        if not parent: return
-        
-        grand = parent.parent
-        if not grand: return
-        
-        # determine if swapping 
-        aunt = grand.b if grand.a == parent else grand.a
-        sibling = parent.b if parent.a == aabb else parent.a
-        
-        top_right   = glm.max(aunt.top_right, sibling.top_right)
-        bottom_left = glm.min(aunt.bottom_left, sibling.bottom_left)
-        aunt_sibling_area = get_aabb_surface_area(top_right, bottom_left)
-        
-        if aunt_sibling_area > parent.surface_area: return
-        
-        # rotate tree if necessary
-        if grand.a == aunt: grand.a = aabb
-        else:               grand.b = aabb
-        
-        if parent.a == aabb: parent.a = aunt
-        else:                parent.b = aunt
-        
-        # reset parents and update points to resize AABBs
-        aunt.parent = parent
-        aabb.parent = grand
-        
-        parent.update_points()
-        grand.update_points()
-        
-    def get_collided(self, collider: Collider) -> list[Collider]:
-        """
-        Returns which objects may be colliding from the BVH
-        """
-        if isinstance(self.root, BroadAABB): return self.root.get_collided(collider)
-        else: return [] # if there is only one collider in the scene then there is nothing to collide with
-        
-    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[Collider]:
-        """
-        Returns the colliders that may intersect with the given line
-        """
-        if isinstance(self.root, BroadAABB): return self.root.get_line_collided(position, forward)
+import glm
+from .broad_aabb import BroadAABB
+from ..collider import Collider
+from ...generic.abstract_bvh import AbstractBVH as BVH
+from ...generic.meshes import get_aabb_surface_area
+
+class BroadBVH(BVH):
+    root: BroadAABB
+    """The root node of the BVH"""
+    collider_handler: ...
+    """Back reference to the collider ahndler for accessing colliders"""
+    
+    def __init__(self, collider_handler) -> None:
+        self.collider_handler = collider_handler
+        self.root = None
+        
+    def add(self, collider: Collider) -> None:
+        """
+        Adds a single collider to the bvh tree
+        """
+        # test if tree needs to be initiated
+        if not self.root: 
+            self.root = collider # TODO ensure that this is final format for primative
+            return
+        
+        # check if root is primative
+        if isinstance(self.root, Collider): 
+            sibling = self.root
+            self.root      = BroadAABB(sibling, collider, None)
+            sibling.parent = collider.parent = self.root
+            return
+        
+        # find the best sibling (c_best only used during the recursion)
+        c_best, sibling = self.root.find_sibling(collider, 0)
+        old_parent = sibling.parent
+        new_parent = BroadAABB(sibling, collider, old_parent)
+        
+        # if the sibling was not the root
+        if old_parent:
+            if old_parent.a == sibling: old_parent.a = new_parent
+            else:                       old_parent.b = new_parent
+        else: self.root = new_parent
+        
+        sibling.parent = new_parent
+        collider.parent = new_parent
+        
+        # walk back up tree and refit TODO add tree rotations
+        aabb = new_parent
+        while aabb:
+            aabb.update_points()
+            self.rotate(aabb)
+            aabb = aabb.parent
+        
+    def get_all_aabbs(self) -> list[tuple[glm.vec3, glm.vec3, int]]: # TODO test function
+        """
+        Returns all AABBs, their extreme points, and their layer
+        """
+        if isinstance(self.root, BroadAABB): return self.root.get_all_aabbs(0)
+        return [(self.root.top_right, self.root.bottom_left, 0)]
+        
+    def remove(self, collider: Collider) -> None:
+        """
+        Removes a collider from the BVH, refitting the tree and adjusting relations
+        """
+        parent: BroadAABB | None = collider.parent
+        
+        # if collider is the root, remove the root
+        if not parent:
+            self.root = None
+            return
+        
+        # if collider has no grandparent, remove parent and set sibling as root
+        grand   = parent.parent
+        sibling = parent.b if collider == parent.a else parent.a
+        if not grand:
+            self.root = sibling
+            sibling.parent = None
+            return
+    
+        # if grandparent exists
+        if parent == grand.a: grand.a = sibling
+        else:                 grand.b = sibling
+        sibling.parent = grand
+        
+        # move up and refit tree
+        aabb = grand
+        while aabb:
+            aabb.update_points()
+            aabb = aabb.parent
+    
+    def rotate(self, aabb: BroadAABB) -> None:
+        """
+        Rotates the BVH tree to reduce surface area of internal AABBs
+        """
+        # determine if rotation is possible
+        parent: BroadAABB | None = aabb.parent
+        if not parent: return
+        
+        grand = parent.parent
+        if not grand: return
+        
+        # determine if swapping 
+        aunt = grand.b if grand.a == parent else grand.a
+        sibling = parent.b if parent.a == aabb else parent.a
+        
+        top_right   = glm.max(aunt.top_right, sibling.top_right)
+        bottom_left = glm.min(aunt.bottom_left, sibling.bottom_left)
+        aunt_sibling_area = get_aabb_surface_area(top_right, bottom_left)
+        
+        if aunt_sibling_area > parent.surface_area: return
+        
+        # rotate tree if necessary
+        if grand.a == aunt: grand.a = aabb
+        else:               grand.b = aabb
+        
+        if parent.a == aabb: parent.a = aunt
+        else:                parent.b = aunt
+        
+        # reset parents and update points to resize AABBs
+        aunt.parent = parent
+        aabb.parent = grand
+        
+        parent.update_points()
+        grand.update_points()
+        
+    def get_collided(self, collider: Collider) -> list[Collider]:
+        """
+        Returns which objects may be colliding from the BVH
+        """
+        if isinstance(self.root, BroadAABB): return self.root.get_collided(collider)
+        else: return [] # if there is only one collider in the scene then there is nothing to collide with
+        
+    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[Collider]:
+        """
+        Returns the colliders that may intersect with the given line
+        """
+        if isinstance(self.root, BroadAABB): return self.root.get_line_collided(position, forward)
         return [self.root]