basilisk-engine 0.1.51__py3-none-any.whl → 0.1.53__py3-none-any.whl

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]

basilisk/collisions/collider.py

@@ -1,96 +1,96 @@
-import glm
-from ..generic.abstract_bvh import AbstractAABB as AABB
-from ..generic.meshes import transform_points, get_aabb_surface_area
-from ..mesh.mesh import Mesh
-from .narrow.dataclasses import Collision
-
-class Collider():
-    node: ...
-    """Back reference to the node"""
-    collider_handler: ...
-    """Back reference to the collider handler"""
-    half_dimensions: glm.vec3
-    """The axis aligned dimensions of the transformed mesh"""
-    static_friction: float = 0.8 # input from node constructor
-    """Determines the friction of the node when still: recommended 0 - 1"""  
-    kinetic_friction: float = 0.3 # input from node constructor
-    """Determines the friction of the node when moving: recommended 0 - 1"""
-    elasticity: float = 0.1 # input from node constructor
-    """Determines how bouncy an object is: recommended 0 - 1"""  
-    collision_group: str # input from node constructor
-    """Nodes of the same collision group do not collide with each other"""
-    has_collided: bool
-    """Stores whether or not the collider has been collided with in the last frame"""  
-    collision_velocity: float
-    """Stores the highest velocity from a collision on this collider from the last frame"""  
-    collisions: dict # {node : (normal, velocity, depth)} TODO determine which variables need to be stored
-    """Stores data from collisions in the previous frame"""
-    top_right: glm.vec3
-    """AABB most positive corner"""
-    bottom_left: glm.vec3
-    """AABB most negative corner"""
-    aabb_surface_area: float
-    """The surface area of the collider's AABB"""
-    parent: AABB
-    """Reference to the parent AABB in the broad BVH"""
-    mesh: Mesh
-    """Reference to the colliding mesh"""
-
-    def __init__(self, node, collider_mesh: str|Mesh=None, static_friction: glm.vec3=0.7, kinetic_friction: glm.vec3=0.3, elasticity: glm.vec3=0.2, collision_group: str=None):
-        self.collider_handler = None
-        self.node = node
-        self.static_friction = static_friction if static_friction else 0.8 # added checks to prevent floats being set to None. Also done for kinetic and elasticity
-        self.mesh = collider_mesh
-        self.kinetic_friction = kinetic_friction if kinetic_friction else 0.4
-        self.elasticity = elasticity if elasticity else 0.1
-        self.collision_group = collision_group
-        self.collision_velocity = 0
-        self.collisions: list[Collision] = []
-        self.parent = None
-        
-        # lazy update variables TODO change to distinguish between static and nonstatic objects
-        self.needs_obb = True # pos, scale, rot
-        self.needs_half_dimensions = True # scale, rot
-        self.needs_bvh = True # pos, scale, rot
-        
-    def get_vertex(self, index: int) -> glm.vec3:
-        """
-        Gets the world space position of a vertex indicated by the index in the mesh
-        """
-        return glm.vec3(self.node.model_matrix * glm.vec4(*self.mesh.points[index], 1))
-    
-    @property
-    def collider_handler(self): return self._collider_handler
-    @property
-    def has_collided(self): return bool(self.collisions)
-    @property
-    def half_dimensions(self): # TODO look for optimization
-        if self.needs_half_dimensions: 
-            top_right = glm.max(self.obb_points)
-            self._half_dimensions = top_right - self.node.geometric_center
-            self.needs_half_dimensions = False
-        return self._half_dimensions
-    @property
-    def bottom_left(self): return self.node.geometric_center - self.half_dimensions
-    @property
-    def top_right(self): return self.node.geometric_center + self.half_dimensions
-    @property
-    def aabb_surface_area(self): return get_aabb_surface_area(self.top_right, self.bottom_left)
-    @property
-    def obb_points(self): 
-        if self.needs_obb: 
-            self._obb_points = transform_points(self.mesh.aabb_points, self.node.model_matrix)
-            self.needs_obb = False
-        return self._obb_points
-    
-    @collider_handler.setter
-    def collider_handler(self, value):
-        self._collider_handler = value
-        if not value: return
-        if self.mesh is None: self.mesh = self.node.mesh
-        elif isinstance(self.mesh, Mesh): ...
-        elif isinstance(self.mesh, str):
-            if self.mesh =='box': self.mesh = value.cube
-            else: raise ValueError(f'Incorrect built-in mesh type {self.mesh}')
-        else: raise ValueError(f'Unkown type for mesh, got {type(self.mesh)}')
+import glm
+from ..generic.abstract_bvh import AbstractAABB as AABB
+from ..generic.meshes import transform_points, get_aabb_surface_area
+from ..mesh.mesh import Mesh
+from .narrow.dataclasses import Collision
+
+class Collider():
+    node: ...
+    """Back reference to the node"""
+    collider_handler: ...
+    """Back reference to the collider handler"""
+    half_dimensions: glm.vec3
+    """The axis aligned dimensions of the transformed mesh"""
+    static_friction: float = 0.8 # input from node constructor
+    """Determines the friction of the node when still: recommended 0 - 1"""  
+    kinetic_friction: float = 0.3 # input from node constructor
+    """Determines the friction of the node when moving: recommended 0 - 1"""
+    elasticity: float = 0.1 # input from node constructor
+    """Determines how bouncy an object is: recommended 0 - 1"""  
+    collision_group: str # input from node constructor
+    """Nodes of the same collision group do not collide with each other"""
+    has_collided: bool
+    """Stores whether or not the collider has been collided with in the last frame"""  
+    collision_velocity: float
+    """Stores the highest velocity from a collision on this collider from the last frame"""  
+    collisions: dict # {node : (normal, velocity, depth)} TODO determine which variables need to be stored
+    """Stores data from collisions in the previous frame"""
+    top_right: glm.vec3
+    """AABB most positive corner"""
+    bottom_left: glm.vec3
+    """AABB most negative corner"""
+    aabb_surface_area: float
+    """The surface area of the collider's AABB"""
+    parent: AABB
+    """Reference to the parent AABB in the broad BVH"""
+    mesh: Mesh
+    """Reference to the colliding mesh"""
+
+    def __init__(self, node, collider_mesh: str|Mesh=None, static_friction: glm.vec3=0.7, kinetic_friction: glm.vec3=0.3, elasticity: glm.vec3=0.2, collision_group: str=None):
+        self.collider_handler = None
+        self.node = node
+        self.static_friction = static_friction if static_friction else 0.8 # added checks to prevent floats being set to None. Also done for kinetic and elasticity
+        self.mesh = collider_mesh
+        self.kinetic_friction = kinetic_friction if kinetic_friction else 0.4
+        self.elasticity = elasticity if elasticity else 0.1
+        self.collision_group = collision_group
+        self.collision_velocity = 0
+        self.collisions: list[Collision] = []
+        self.parent = None
+        
+        # lazy update variables TODO change to distinguish between static and nonstatic objects
+        self.needs_obb = True # pos, scale, rot
+        self.needs_half_dimensions = True # scale, rot
+        self.needs_bvh = True # pos, scale, rot
+        
+    def get_vertex(self, index: int) -> glm.vec3:
+        """
+        Gets the world space position of a vertex indicated by the index in the mesh
+        """
+        return glm.vec3(self.node.model_matrix * glm.vec4(*self.mesh.points[index], 1))
+    
+    @property
+    def collider_handler(self): return self._collider_handler
+    @property
+    def has_collided(self): return bool(self.collisions)
+    @property
+    def half_dimensions(self): # TODO look for optimization
+        if self.needs_half_dimensions: 
+            top_right = glm.max(self.obb_points)
+            self._half_dimensions = top_right - self.node.geometric_center
+            self.needs_half_dimensions = False
+        return self._half_dimensions
+    @property
+    def bottom_left(self): return self.node.geometric_center - self.half_dimensions
+    @property
+    def top_right(self): return self.node.geometric_center + self.half_dimensions
+    @property
+    def aabb_surface_area(self): return get_aabb_surface_area(self.top_right, self.bottom_left)
+    @property
+    def obb_points(self): 
+        if self.needs_obb: 
+            self._obb_points = transform_points(self.mesh.aabb_points, self.node.model_matrix)
+            self.needs_obb = False
+        return self._obb_points
+    
+    @collider_handler.setter
+    def collider_handler(self, value):
+        self._collider_handler = value
+        if not value: return
+        if self.mesh is None: self.mesh = self.node.mesh
+        elif isinstance(self.mesh, Mesh): ...
+        elif isinstance(self.mesh, str):
+            if self.mesh =='box': self.mesh = value.cube
+            else: raise ValueError(f'Incorrect built-in mesh type {self.mesh}')
+        else: raise ValueError(f'Unkown type for mesh, got {type(self.mesh)}')
         value.add(self)