basilisk-engine 0.1.43__py3-none-any.whl → 0.1.45__py3-none-any.whl

basilisk/collisions/narrow/dataclasses.py

@@ -1,35 +1,35 @@
-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
-# used in creating polytopes for GJK/EPA
-@dataclass(frozen=True)
-class SupportPoint():
-    support_point: glm.vec3
-    
-    index1: int # index of the vertex in the mesh
-    vertex1: glm.vec3 # world space location of the vertex at collision
-    
-    index2: int
-    vertex2: glm.vec3
-    
-# used for generating contact points for the contact manifold
-@dataclass(frozen=True)
-class ContactPoint():
-    index: int
-    vertex: Vec3
-    
-# contact manifold object used in the contact handler list
-@dataclass
-class ContactManifold():
-    normal: glm.vec3
-    contact_points1: dict[int : glm.vec3] # contact point index : collision position
-    contact_points2: dict[int : glm.vec3]
-    
-@dataclass
-class Collision():
-    node: ...
+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
+# used in creating polytopes for GJK/EPA
+@dataclass(frozen=True)
+class SupportPoint():
+    support_point: glm.vec3
+    
+    index1: int # index of the vertex in the mesh
+    vertex1: glm.vec3 # world space location of the vertex at collision
+    
+    index2: int
+    vertex2: glm.vec3
+    
+# used for generating contact points for the contact manifold
+@dataclass(frozen=True)
+class ContactPoint():
+    index: int
+    vertex: Vec3
+    
+# contact manifold object used in the contact handler list
+@dataclass
+class ContactManifold():
+    normal: glm.vec3
+    contact_points1: dict[int : glm.vec3] # contact point index : collision position
+    contact_points2: dict[int : glm.vec3]
+    
+@dataclass
+class Collision():
+    node: ...
     normal: glm.vec3

basilisk/collisions/narrow/deprecated.py

@@ -1,47 +1,47 @@
-    # def sat_manifold(self, points1: list[glm.vec3], points2: list[glm.vec3], axis: glm.vec3, plane_point: glm.vec3, digit: int) -> list[glm.vec3]:
-    #     """
-    #     Returns the contact manifold from an SAT OBB OBB collision
-    #     """
-    #     def get_test_points(contact_plane_normal:glm.vec3, points:list[glm.vec3], count: int):
-    #         test_points = [(glm.dot(contact_plane_normal, p), p) for p in points]
-    #         test_points.sort(key=lambda p: p[0])
-    #         return [p[1] for p in test_points[:count]]
-        
-    #     def get_test_points_unknown(contact_plane_normal:glm.vec3, points:list[glm.vec3]):
-    #         test_points = [(glm.dot(contact_plane_normal, p), p) for p in points]
-    #         test_points.sort(key=lambda p: p[0])
-    #         if test_points[2][0] - test_points[0][0] > 1e-3: return [p[1] for p in test_points[:2]]
-    #         else:                                            return [p[1] for p in test_points[:4]]        
-        
-    #     if digit < 6: # there must be at least one face in the collision
-    #         reference, incident = (get_test_points(-axis, points1, 4), get_test_points_unknown(axis, points2)) if digit < 3 else (get_test_points(axis, points2, 4), get_test_points_unknown(-axis, points1))
-            
-    #         # project vertices onto the 2d plane
-    #         reference = project_points(plane_point, axis, reference)
-    #         incident  = project_points(plane_point, axis, incident)
-            
-    #         # convert points to 2d for intersection algorithms
-    #         reference, u1, v1 = points_to_2d(plane_point, axis, reference)
-    #         incident,  u2, v2 = points_to_2d(plane_point, axis, incident, u1, v1)
-            
-    #         # convert arbitrary points to polygon
-    #         reference = graham_scan(reference)
-    #         if len(incident) == 4:  incident =  graham_scan(incident)
-            
-    #         # run clipping algorithms
-    #         manifold = []
-    #         if len(incident) == 2: manifold = line_poly_intersect(incident, reference)
-    #         else:                  manifold = sutherland_hodgman(reference, incident)
-                
-    #         # # fall back if manifold fails to develope
-    #         assert len(manifold), 'sat did not generate points'
-            
-    #         # # convert inertsection algorithm output to 3d
-    #         return points_to_3d(u1, v1, plane_point, manifold)
-        
-    #     else: # there is an edge edge collision
-            
-    #         points1 = get_test_points(-axis, points1, 2)
-    #         points2 = get_test_points(axis, points2, 2)
-            
+    # def sat_manifold(self, points1: list[glm.vec3], points2: list[glm.vec3], axis: glm.vec3, plane_point: glm.vec3, digit: int) -> list[glm.vec3]:
+    #     """
+    #     Returns the contact manifold from an SAT OBB OBB collision
+    #     """
+    #     def get_test_points(contact_plane_normal:glm.vec3, points:list[glm.vec3], count: int):
+    #         test_points = [(glm.dot(contact_plane_normal, p), p) for p in points]
+    #         test_points.sort(key=lambda p: p[0])
+    #         return [p[1] for p in test_points[:count]]
+        
+    #     def get_test_points_unknown(contact_plane_normal:glm.vec3, points:list[glm.vec3]):
+    #         test_points = [(glm.dot(contact_plane_normal, p), p) for p in points]
+    #         test_points.sort(key=lambda p: p[0])
+    #         if test_points[2][0] - test_points[0][0] > 1e-3: return [p[1] for p in test_points[:2]]
+    #         else:                                            return [p[1] for p in test_points[:4]]        
+        
+    #     if digit < 6: # there must be at least one face in the collision
+    #         reference, incident = (get_test_points(-axis, points1, 4), get_test_points_unknown(axis, points2)) if digit < 3 else (get_test_points(axis, points2, 4), get_test_points_unknown(-axis, points1))
+            
+    #         # project vertices onto the 2d plane
+    #         reference = project_points(plane_point, axis, reference)
+    #         incident  = project_points(plane_point, axis, incident)
+            
+    #         # convert points to 2d for intersection algorithms
+    #         reference, u1, v1 = points_to_2d(plane_point, axis, reference)
+    #         incident,  u2, v2 = points_to_2d(plane_point, axis, incident, u1, v1)
+            
+    #         # convert arbitrary points to polygon
+    #         reference = graham_scan(reference)
+    #         if len(incident) == 4:  incident =  graham_scan(incident)
+            
+    #         # run clipping algorithms
+    #         manifold = []
+    #         if len(incident) == 2: manifold = line_poly_intersect(incident, reference)
+    #         else:                  manifold = sutherland_hodgman(reference, incident)
+                
+    #         # # fall back if manifold fails to develope
+    #         assert len(manifold), 'sat did not generate points'
+            
+    #         # # convert inertsection algorithm output to 3d
+    #         return points_to_3d(u1, v1, plane_point, manifold)
+        
+    #     else: # there is an edge edge collision
+            
+    #         points1 = get_test_points(-axis, points1, 2)
+    #         points2 = get_test_points(axis, points2, 2)
+            
     #         return closest_two_lines(*points1, *points2)

basilisk/collisions/narrow/epa.py

@@ -1,92 +1,92 @@
-import glm
-from .helper import get_support_point
-from .dataclasses import SupportPoint
-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[SupportPoint] # polytope vertex, node1 vertex, node2 vertex
-
-def get_epa_from_gjk(node1: Node, node2: Node, polytope: polytope_type, epsilon: float=0) -> tuple[face_type, polytope_type]: # TODO determine the return type of get_epa_from_gjk and if epsilon is good value
-    """
-    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.support_point) - faces[0][0] < epsilon: return faces, polytope
-        faces, polytope = insert_point(polytope, faces, new_point)
-
-def insert_point(polytope: polytope_type, faces: face_type, point: glm.vec3, epsilon: float=0) -> 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].support_point) >= epsilon and # if the normal of a face is pointing towards the added point
-           glm.dot(face[1], polytope[support_index].support_point - 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. 
-            elif (p1, p2) in edges: # TODO remove this
-                edges.remove((p1, p2))
-                # print('not reversed')
-            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]].support_point + polytope[indices[1]].support_point + polytope[indices[2]].support_point) / 3
-    normal   = glm.cross(polytope[indices[1]].support_point - polytope[indices[0]].support_point, polytope[indices[2]].support_point - polytope[indices[0]].support_point) # closest face normal will be normalized once returned to avoid square roots and division
-    if glm.dot(center, normal) < 0: 
-        normal *= -1
-        indices = (indices[2], indices[1], indices[0])
-
-    # TODO solve cases where face may contain origin
-    normal = glm.normalize(normal)
-    distance = abs(glm.dot(polytope[indices[0]].support_point, normal))
-    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]:
-    """
-    Orients the face indices to have a counter clockwise normal
-    """
-    if glm.dot(glm.cross(polytope[indices[1]].support_point, polytope[indices[2]].support_point), polytope[indices[0]].support_point) < 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
-    """
+import glm
+from .helper import get_support_point
+from .dataclasses import SupportPoint
+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[SupportPoint] # polytope vertex, node1 vertex, node2 vertex
+
+def get_epa_from_gjk(node1: Node, node2: Node, polytope: polytope_type, epsilon: float=0) -> tuple[face_type, polytope_type]: # TODO determine the return type of get_epa_from_gjk and if epsilon is good value
+    """
+    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.support_point) - faces[0][0] < epsilon: return faces, polytope
+        faces, polytope = insert_point(polytope, faces, new_point)
+
+def insert_point(polytope: polytope_type, faces: face_type, point: glm.vec3, epsilon: float=0) -> 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].support_point) >= epsilon and # if the normal of a face is pointing towards the added point
+           glm.dot(face[1], polytope[support_index].support_point - 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. 
+            elif (p1, p2) in edges: # TODO remove this
+                edges.remove((p1, p2))
+                # print('not reversed')
+            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]].support_point + polytope[indices[1]].support_point + polytope[indices[2]].support_point) / 3
+    normal   = glm.cross(polytope[indices[1]].support_point - polytope[indices[0]].support_point, polytope[indices[2]].support_point - polytope[indices[0]].support_point) # closest face normal will be normalized once returned to avoid square roots and division
+    if glm.dot(center, normal) < 0: 
+        normal *= -1
+        indices = (indices[2], indices[1], indices[0])
+
+    # TODO solve cases where face may contain origin
+    normal = glm.normalize(normal)
+    distance = abs(glm.dot(polytope[indices[0]].support_point, normal))
+    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]:
+    """
+    Orients the face indices to have a counter clockwise normal
+    """
+    if glm.dot(glm.cross(polytope[indices[1]].support_point, polytope[indices[2]].support_point), polytope[indices[0]].support_point) < 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/collisions/narrow/gjk.py

@@ -1,67 +1,67 @@
-import glm
-from .helper import get_support_point
-from .dataclasses import SupportPoint
-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.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
-    
-    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.support_point, 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[SupportPoint]) -> 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[SupportPoint]) -> tuple[bool, glm.vec3, list[tuple[glm.vec3, glm.vec3, glm.vec3]]]:
-    """
-    Returns the perpendicular vector to the simplex line
-    """
-    vec_ab = simplex[1].support_point - simplex[0].support_point
-    return False, triple_product(vec_ab, -simplex[0].support_point, vec_ab), simplex
-    
-def handle_simplex_triangle(simplex: list[SupportPoint]) -> 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].support_point - simplex[0].support_point, simplex[2].support_point - simplex[0].support_point)
-    return False, -dir_vec if glm.dot(dir_vec, -simplex[0].support_point) < 0 else dir_vec, simplex
-    
-def handle_simplex_tetrahedron(simplex: list[SupportPoint], 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].support_point - simplex[0].support_point
-    vec_db = simplex[3].support_point - simplex[1].support_point
-    vec_dc = simplex[3].support_point - simplex[2].support_point
-    vec_do = -simplex[3].support_point
-    
-    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
+import glm
+from .helper import get_support_point
+from .dataclasses import SupportPoint
+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.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
+    
+    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.support_point, 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[SupportPoint]) -> 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[SupportPoint]) -> tuple[bool, glm.vec3, list[tuple[glm.vec3, glm.vec3, glm.vec3]]]:
+    """
+    Returns the perpendicular vector to the simplex line
+    """
+    vec_ab = simplex[1].support_point - simplex[0].support_point
+    return False, triple_product(vec_ab, -simplex[0].support_point, vec_ab), simplex
+    
+def handle_simplex_triangle(simplex: list[SupportPoint]) -> 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].support_point - simplex[0].support_point, simplex[2].support_point - simplex[0].support_point)
+    return False, -dir_vec if glm.dot(dir_vec, -simplex[0].support_point) < 0 else dir_vec, simplex
+    
+def handle_simplex_tetrahedron(simplex: list[SupportPoint], 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].support_point - simplex[0].support_point
+    vec_db = simplex[3].support_point - simplex[1].support_point
+    vec_dc = simplex[3].support_point - simplex[2].support_point
+    vec_do = -simplex[3].support_point
+    
+    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/collisions/narrow/graham_scan.py

@@ -1,25 +1,25 @@
-import glm
-from math import atan2
-from .helper import is_ccw_turn
-
-def graham_scan(points:list[glm.vec2]) -> None:
-    """converts list of arbitrary points into polygon sorted ccw"""
-    # get pivot point
-    pivot = min(points, key=lambda p: (p.y, p.x))
-    points.remove(pivot)
-    
-    # sort points by polar angle and start hull
-    points = sorted(points, key=lambda p: (get_polar_angle(pivot, p), glm.length(pivot - p)))
-    hull = [pivot, points.pop(0)]
-    
-    for point in points:
-        while len(hull) > 1 and not is_ccw_turn(hull[-2], hull[-1], point):
-            hull.pop()
-        hull.append(point)
-    
-    return hull
-    
-def get_polar_angle(pivot:glm.vec2, point:glm.vec2) -> float:
-    """gets the polar angle between two points from the horizontal"""
-    vector = point - pivot
+import glm
+from math import atan2
+from .helper import is_ccw_turn
+
+def graham_scan(points:list[glm.vec2]) -> None:
+    """converts list of arbitrary points into polygon sorted ccw"""
+    # get pivot point
+    pivot = min(points, key=lambda p: (p.y, p.x))
+    points.remove(pivot)
+    
+    # sort points by polar angle and start hull
+    points = sorted(points, key=lambda p: (get_polar_angle(pivot, p), glm.length(pivot - p)))
+    hull = [pivot, points.pop(0)]
+    
+    for point in points:
+        while len(hull) > 1 and not is_ccw_turn(hull[-2], hull[-1], point):
+            hull.pop()
+        hull.append(point)
+    
+    return hull
+    
+def get_polar_angle(pivot:glm.vec2, point:glm.vec2) -> float:
+    """gets the polar angle between two points from the horizontal"""
+    vector = point - pivot
     return atan2(vector.y, vector.x)

basilisk/collisions/narrow/helper.py

@@ -1,30 +1,30 @@
-import glm
-from ...nodes.node import Node
-from .dataclasses import SupportPoint
-
-def get_support_point(node1: Node, node2: Node, dir_vec: glm.vec3) -> SupportPoint:
-    """
-    Outputs the best support point to be added to the polytop based on the direction vector.
-    """
-    vertex1, index1 = get_furthest_point(node1, dir_vec)
-    vertex2, index2 = get_furthest_point(node2, -dir_vec)
-    return SupportPoint(vertex1 - vertex2, index1, vertex1, index2, 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.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)
-    
-    # transform point to world space
-    return glm.vec3(vertex), index
-
-def is_ccw_turn(a:glm.vec2, b:glm.vec2, c:glm.vec2) -> bool:
-    """
-    Determines if the series of points results in a left hand turn
-    """
+import glm
+from ...nodes.node import Node
+from .dataclasses import SupportPoint
+
+def get_support_point(node1: Node, node2: Node, dir_vec: glm.vec3) -> SupportPoint:
+    """
+    Outputs the best support point to be added to the polytop based on the direction vector.
+    """
+    vertex1, index1 = get_furthest_point(node1, dir_vec)
+    vertex2, index2 = get_furthest_point(node2, -dir_vec)
+    return SupportPoint(vertex1 - vertex2, index1, vertex1, index2, 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.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)
+    
+    # transform point to world space
+    return glm.vec3(vertex), index
+
+def is_ccw_turn(a:glm.vec2, b:glm.vec2, c:glm.vec2) -> bool:
+    """
+    Determines if the series of points results in a left hand turn
+    """
     return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x) > 0 # TODO check formula