basilisk-engine 0.0.1__tar.gz → 0.0.2__tar.gz

{basilisk_engine-0.0.1 → basilisk_engine-0.0.2}/PKG-INFO

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

basilisk_engine-0.0.2/basilisk/collisions/broad/broad_aabb.py

@@ -0,0 +1,96 @@
+import glm
+from ...generic.abstract_bvh import AbstractAABB as AABB
+from ...generic.collisions import collide_aabb_aabb
+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_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_engine-0.0.2/basilisk/collisions/broad/broad_bvh.py

@@ -0,0 +1,102 @@
+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: ...
+    
+    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
+        """
+        return self.root.get_collided(collider)

basilisk_engine-0.0.2/basilisk/collisions/collider.py

@@ -0,0 +1,75 @@
+import glm
+from ..generic.abstract_bvh import AbstractAABB as AABB
+from ..generic.meshes import transform_points, get_aabb_surface_area
+from ..mesh.cube import cube
+from ..mesh.mesh import Mesh
+
+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, collider_handler, node, box_mesh: bool=False, static_friction: glm.vec3=0.7, kinetic_friction: glm.vec3=0.3, elasticity: glm.vec3=0.1, collision_group: str=None):
+        self.collider_handler = collider_handler
+        self.node = node
+        self.mesh = cube if box_mesh else self.node.mesh
+        self.static_friction = static_friction
+        self.kinetic_friction = kinetic_friction
+        self.elasticity = elasticity
+        self.collision_group = collision_group
+        self.collision_velocity = 0
+        self.collisions = {}
+        self.parent = None
+        
+        # lazy update variables TODO change to distinguish between static and nonstatic objects
+        self.needs_obb = True
+        self.needs_half_dimensions = True
+        
+    @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

basilisk_engine-0.0.2/basilisk/collisions/collider_handler.py

@@ -0,0 +1,163 @@
+import glm
+from .narrow.gjk import *
+from .collider import Collider
+from .broad.broad_bvh import BroadBVH
+from ..mesh.cube import cube
+from ..generic.collisions import get_sat_axes
+from .narrow.gjk import collide_gjk
+from .narrow.epa import get_epa_from_gjk
+
+class ColliderHandler():
+    scene: ...
+    """Back reference to scene"""
+    colliders: list[Collider]
+    """Main list of collders contained in the scene"""
+    bvh: BroadBVH
+    """Broad bottom up BVH containing all colliders in the scene"""
+    
+    def __init__(self, scene) -> None:
+        self.scene = scene
+        self.colliders = []
+        self.bvh = BroadBVH(self)
+        
+    def add(self, node, box_mesh: bool=False, static_friction: glm.vec3=0.7, kinetic_friction: glm.vec3=0.3, elasticity: glm.vec3=0.1, collision_group: str=None) -> Collider:
+        """
+        Creates a collider and adds it to the collider list
+        """
+        collider = Collider(self, node, box_mesh, static_friction, kinetic_friction, elasticity, collision_group)
+        self.colliders.append(collider)
+        self.bvh.add(collider)
+        return collider
+    
+    def remove(self, collider: Collider) -> None:
+        """
+        Removes a collider from the main branch and BVH
+        """
+        if collider in self.colliders: self.colliders.remove(collider)
+        self.bvh.remove(collider)
+        collider.collider_handler = None
+    
+    def resolve_collisions(self) -> None:
+        """
+        Resets collider collision values and resolves all collisions in the scene
+        """
+        # reset collision data
+        for collider in self.colliders: collider.collisions = {}
+        # TODO update BVH
+        broad_collisions = self.resolve_broad_collisions()
+        self.resolve_narrow_collisions(broad_collisions)
+        
+    def collide_obb_obb(self, collider1: Collider, collider2: Collider) -> tuple[glm.vec3, float] | None:
+        """
+        Finds the minimal penetrating vector for an obb obb collision, return None if not colliding. Uses SAT. 
+        """
+        axes = get_sat_axes(collider1.node.rotation, collider2.node.rotation) # axes are normaized
+        points1 = collider1.obb_points # TODO remove once oobb points are lazy updated, switch to just using property
+        points2 = collider2.obb_points
+                
+        # test axes
+        small_axis    = None
+        small_overlap = 1e10
+        for axis in axes: # TODO add optimization for points on cardinal axis of cuboid
+            # "project" points
+            proj1 = [glm.dot(p, axis) for p in points1]
+            proj2 = [glm.dot(p, axis) for p in points2]
+            max1, min1 = max(proj1), min(proj1)
+            max2, min2 = max(proj2), min(proj2)
+            if max1 < min2 or max2 < min1: return None
+            
+            # if lines are not intersecting
+            if   max1 > max2 and min1 < min2: overlap = min(max1 - min2, max2 - min1)
+            elif max2 > max1 and min2 < min1: overlap = min(max1 - min2, max2 - min1)
+            else:                             overlap = min(max1, max2) - max(min1, min2) # TODO check if works with containment
+            
+            if abs(overlap) > abs(small_overlap): continue
+            small_overlap = overlap
+            small_axis    = axis
+        
+        print(axes.index(small_axis), glm.length(small_axis))
+        print('overlap:', small_overlap)
+            
+        return small_axis, small_overlap
+    
+    def collide_obb_obb_decision(self, collider1: Collider, collider2: Collider) -> bool:
+        """
+        Determines if two obbs are colliding Uses SAT. 
+        """
+        axes = get_sat_axes(collider1.node.rotation, collider2.node.rotation)     
+        points1 = collider1.obb_points # TODO remove once oobb points are lazy updated, switch to just using property
+        points2 = collider2.obb_points
+                
+        # test axes
+        for axis in axes: # TODO add optimization for points on cardinal axis of cuboid
+            # "project" points
+            proj1 = [glm.dot(p, axis) for p in points1]
+            proj2 = [glm.dot(p, axis) for p in points2]
+            max1, min1 = max(proj1), min(proj1)
+            max2, min2 = max(proj2), min(proj2)
+            if max1 < min2 or max2 < min1: return False
+            
+        return True
+    
+    def resolve_broad_collisions(self) -> set[tuple[Collider, Collider]]:
+        """
+        Determines which colliders collide with each other from the BVH
+        """
+        collisions = set()
+        for collider1 in self.colliders:
+            
+            # traverse bvh to find aabb aabb collisions
+            colliding = self.bvh.get_collided(collider1)
+            for collider2 in colliding:
+                if collider1 == collider2: continue
+                if (collider1, collider2) in collisions or (collider2, collider1) in collisions: continue # TODO find a secure way for ordering colliders
+                
+                # run broad collision for specified mesh types
+                if max(len(collider1.mesh.points), len(collider2.mesh.points)) > 250 and not self.collide_obb_obb_decision(collider1, collider2): continue # contains at least one "large" mesh TODO write heuristic algorithm for determining large meshes
+                
+                collisions.add((collider1, collider2)) # TODO find a secure way for ordering colliders
+                
+        return collisions
+    
+    def resolve_narrow_collisions(self, broad_collisions: list[tuple[Collider, Collider]]) -> None:
+        """
+        Determines if two colliders are colliding, if so resolves their penetration and applies impulse
+        """
+        collided = []
+        
+        for collision in broad_collisions: # assumes that broad collisions are unique
+            collider1 = collision[0]
+            collider2 = collision[1]
+            node1: Node = collider1.node
+            node2: Node = collider2.node
+            
+            # get peneration data or quit early if no collision is found
+            if collider1.mesh == cube and collider2.mesh == cube: # obb-obb collision
+                
+                # run SAT for obb-obb (includes peneration)
+                data = self.collide_obb_obb(collider1, collider2)
+                if not data: continue
+                
+                vec, distance = data
+                
+            else: # use gjk to determine collisions between non-cuboid meshes
+                has_collided, simplex = collide_gjk(node1, node2)
+                if not has_collided: continue
+                
+                face, polytope = get_epa_from_gjk(node1, node2, simplex)
+                vec, distance  = face[1], face[0]
+                
+            if glm.dot(vec, node2.position - node1.position) > 0:
+                vec *= -1
+                
+            print('\033[92m', vec, distance, '\033[0m')
+            
+            # resolve collision penetration
+            node2.position -= vec * distance
+            
+            collided.append((node1, node2, vec * distance))
+            
+            # TODO add penetration resolution
+            # TODO add impulse
+            
+        return collided

basilisk_engine-0.0.2/basilisk/collisions/narrow/epa.py

@@ -0,0 +1,86 @@
+import glm
+from .helper import get_support_point
+from...nodes.node import Node
+
+
+# TODO change these to structs when converting to C++
+face_type     = list[tuple[float, glm.vec3, glm.vec3, int, int, int]] # distance, normal, center, index 1, index 2, index 3
+polytope_type = list[tuple[glm.vec3, glm.vec3, glm.vec3]] # polytope vertex, node1 vertex, node2 vertex
+
+def get_epa_from_gjk(node1: Node, node2: Node, polytope: polytope_type, epsilon: float=1e-7) -> tuple: # TODO determine the return type of get_epa_from_gjk
+    """
+    Determines the peneration vector from a collision using EPA. The returned face normal is normalized but the rest are not guarunteed to be. 
+    """
+    # orient faces to point normals counter clockwise
+    faces: face_type = []
+    for indices in [(0, 1, 2), (0, 1, 3), (0, 2, 3), (1, 2, 3)]: faces = insert_face(polytope, faces, indices)
+    
+    # develope the polytope until the nearest real face has been found, within epsilon
+    while True:
+        new_point = get_support_point(node1, node2, faces[0][1])
+        if new_point in polytope or glm.length(new_point[0]) - faces[0][0] < epsilon: 
+            faces[0] = list(faces[0])
+            faces[0][0] = glm.sqrt(faces[0][0]) # square root distance squared to get real distance
+            faces[0][1] = glm.normalize(faces[0][1])
+            return faces[0], polytope
+        faces, polytope = insert_point(polytope, faces, new_point)
+
+def insert_point(polytope: polytope_type, faces: face_type, point: glm.vec3, epsilon: float=1e-7) -> tuple[face_type, polytope_type]:
+    """
+    Inserts a point into the polytope sorting by distance from the origin
+    """ 
+    # determine which faces are facing the new point
+    polytope.append(point)
+    support_index = len(polytope) - 1
+    visible_faces = [
+        face for face in faces
+        if glm.dot(face[1], polytope[support_index][0]) >= epsilon and # if the normal of a face is pointing towards the added point
+           glm.dot(face[1], polytope[support_index][0] - face[2]) >= epsilon # TODO check if this ever occurs
+    ]
+    
+    # generate new edges
+    edges = []
+    for face in visible_faces:
+        for p1, p2 in get_face_edges(face):
+            if (p2, p1) in edges: edges.remove((p2, p1)) # edges can only be shared by two faces, running opposite to each other. 
+            else: edges.append((p1, p2))
+    
+    # remove visible faces
+    for face in sorted(visible_faces, reverse = True): faces.remove(face)
+    
+    # add new faces
+    new_face_indices = [orient_face(polytope, (edge[0], edge[1], support_index)) for edge in edges] # edge[0], edge[1] is already ccw
+    for indices in new_face_indices: faces = insert_face(polytope, faces, indices)
+    
+    return faces, polytope
+
+def insert_face(polytope: polytope_type, faces: face_type, indices: tuple[int, int, int]) -> face_type:
+    """
+    Inserts a face into the face priority queue based on the indices given in the polytope
+    """
+    center   = (polytope[indices[0]][0] + polytope[indices[1]][0] + polytope[indices[2]][0]) / 3
+    distance = glm.length2(center) # TODO face distance is length squared to reduce calculations
+    normal   = glm.cross(polytope[indices[1]][0] - polytope[indices[0]][0], polytope[indices[2]][0] - polytope[indices[0]][0]) # closest face normal will be normalized once returned to avoid square roots and division
+    new_face = (distance, normal, center, *indices)
+    
+    # insert faces into priority queue based on distance from origin
+    for i, face in enumerate(faces):
+        if face[0] < distance: continue
+        faces.insert(i, new_face)
+        break
+    else: faces.append(new_face)
+    
+    return faces
+
+def orient_face(polytope: polytope_type, indices: tuple[int, int, int]) -> tuple[int, int, int]: # TODO finish this
+    """
+    Orients the face indices to have a counter clockwise normal
+    """
+    if glm.dot(glm.cross(polytope[indices[1]][0], polytope[indices[2]][0]), polytope[indices[0]][0]) < 0: return (indices[2], indices[1], indices[0])
+    return indices
+    
+def get_face_edges(face: tuple[float, glm.vec3, glm.vec3, int, int, int]) -> list[tuple[int, int]]:
+    """
+    Permutes a tuple of three unique numbers (a, b, c) into 3 pairs (x, y), preserving order
+    """
+    return [(face[3], face[4]), (face[4], face[5]), (face[5], face[3])]

basilisk_engine-0.0.2/basilisk/collisions/narrow/gjk.py

@@ -0,0 +1,66 @@
+import glm
+from .helper import get_support_point
+from ...nodes.node import Node
+from ...generic.math import triple_product
+
+
+def collide_gjk(node1: Node, node2: Node, iterations: int=20) -> tuple: # TODO figure out return data type
+    """
+    Determines if two convex polyhedra collide, returns the polytope if there is a collision.
+    """
+    # generate starting values
+    dir_vec = node1.position - node2.position
+    simplex = [get_support_point(node1, node2, dir_vec)]
+    dir_vec = -simplex[0][0] # set direction to point away from starting simplex point
+    
+    for _ in range(iterations):
+        # gets support point and checks if its across the origin
+        test_point = get_support_point(node1, node2, dir_vec)
+        if glm.dot(test_point[0], dir_vec) < -1e-7: return False, simplex
+        
+        # add point and find new direction vector
+        simplex.append(test_point)
+        check, dir_vec, simplex = handle_simplex(simplex)
+        
+        if check: return True, simplex
+    return False, simplex # timeout due to too many checks, usually float errors
+        
+def handle_simplex(simplex: list) -> tuple[bool, glm.vec3, list[tuple[glm.vec3, glm.vec3, glm.vec3]]]:
+    """
+    Call proper function based on number of support points
+    """
+    num = len(simplex) # not using match case to support Python < 3.10
+    if num == 2: return handle_simplex_line(simplex)
+    if num == 3: return handle_simplex_triangle(simplex)
+    return handle_simplex_tetrahedron(simplex) # simplex must be 4 points 
+
+def handle_simplex_line(simplex: list) -> tuple[bool, glm.vec3, list[tuple[glm.vec3, glm.vec3, glm.vec3]]]:
+    """
+    Returns the perpendicular vector to the simplex line
+    """
+    vec_ab = simplex[1][0] - simplex[0][0]
+    return False, triple_product(vec_ab, -simplex[0][0], vec_ab), simplex
+    
+def handle_simplex_triangle(simplex: list) -> tuple[bool, glm.vec3, list[tuple[glm.vec3, glm.vec3, glm.vec3]]]:
+    """
+    Returns the normal vector of the triangoe pointed towards the origin
+    """
+    dir_vec = glm.cross(simplex[1][0] - simplex[0][0], simplex[2][0] - simplex[0][0])
+    return False, -dir_vec if glm.dot(dir_vec, -simplex[0][0]) < 0 else dir_vec, simplex
+    
+def handle_simplex_tetrahedron(simplex: list, epsilon: float=0) -> tuple[bool, glm.vec3, list[tuple[glm.vec3, glm.vec3, glm.vec3]]]:
+    """
+    Perform collision check and remove support point if no collision is found
+    """
+    vec_da = simplex[3][0] - simplex[0][0]
+    vec_db = simplex[3][0] - simplex[1][0]
+    vec_dc = simplex[3][0] - simplex[2][0]
+    vec_do = -simplex[3][0]
+    
+    vectors = [(glm.cross(vec_da, vec_db), 2), (glm.cross(vec_dc, vec_da), 1), (glm.cross(vec_db, vec_dc), 0)] # TODO determine if this is the best way to do this
+    for normal_vec, index in vectors:
+        dot_product = glm.dot(normal_vec, vec_do)
+        if dot_product > epsilon:
+            simplex.pop(index)
+            return False, normal_vec, simplex
+    return True, None, simplex

basilisk_engine-0.0.2/basilisk/collisions/narrow/helper.py

@@ -0,0 +1,23 @@
+import glm
+from ...nodes.node import Node
+
+
+def get_support_point(node1: Node, node2: Node, dir_vec: glm.vec3) -> tuple[glm.vec3, glm.vec3, glm.vec3]:
+    """
+    Outputs the best support point to be added to the polytop based on the direction vector.
+    """
+    vertex1 = get_furthest_point(node1, dir_vec)
+    vertex2 = get_furthest_point(node2, -dir_vec)
+    return (vertex1 - vertex2, vertex1, vertex2)
+    
+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
+    vertex = node.mesh.get_best_dot(node_dir_vec)
+    vertex = node.model_matrix * glm.vec4(vertex, 1.0)
+    
+    # transform point to world space
+    return glm.vec3(vertex)