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

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

basilisk/collisions/narrow/line_intersections.py

@@ -1,107 +1,107 @@
-import glm
-from .helper import is_ccw_turn
-
-# intersectionn algorithms for lines
-def line_line_intersect(points1:list[glm.vec2], points2:list[glm.vec2]) -> list[glm.vec2]:
-    """gets the intersection of 2 2d lines. if the lines are parallel, returns the second line"""
-    # orders points from smallest x to greatest x
-    points1 = sorted(points1, key=lambda p: (p.x, p.y))
-    points2 = sorted(points2, key=lambda p: (p.x, p.y))
-    vec1, vec2 = points1[1] - points1[0], points2[1] - points2[0]
-    
-    # if vectors have the same slope return the smallest line
-    if have_same_slope(vec1, vec2): return sorted(points1 + points2, key=lambda p: (p.x, p.y))[1:3]
-    
-    # line - line intersection
-    det = vec1.x * vec2.y - vec1.y * vec2.x
-    if det == 0: return []
-    t = (points2[0].x - points1[0].x) * vec2.y - (points2[0].y - points1[0].y) * vec2.x
-    t /= det
-    return [points1[0] + t * vec1]
-    
-def have_same_slope(vec1:glm.vec2, vec2:glm.vec2, epsilon:float=1e-5) -> bool:
-    """determines if two vectors moving in the positive x direction have the same slope"""
-    return abs(vec1.y * vec2.x - vec2.y * vec1.x) < epsilon
-
-def line_poly_intersect(line:list[glm.vec2], polygon:list[glm.vec2]) -> list[glm.vec2]: #TODO Reseach into faster algorithm < O(2n)
-    """computes which parts of the line clip with the polygon"""
-    # calculate the center of the polygon
-    assert len(polygon) > 2, 'polygon is does not contain engough points'
-    center = glm.vec2(0,0)
-    for point in polygon: center += point
-    center /= len(polygon)
-    orig_line = line[:]
-    # determine which points are in or out of the polygon
-    exterior_points = []
-    for i in range(len(polygon)): # nearest even number below n
-        for line_point in line[:]:
-            if not is_ccw_turn(polygon[i], polygon[(i + 1) % len(polygon)], line_point): # if point is on the outside
-                exterior_points.append((polygon[i], polygon[(i + 1) % len(polygon)], line_point)) # polypoint1, polypoint2, linepoint
-                line.remove(line_point) # removes line point if it is confirmed to be outside
-                
-    # determine what to with line based on number of points found outside
-    if len(exterior_points) == 0:
-        return line
-    if len(exterior_points) == 1:
-        return line_line_intersect(line + [exterior_points[0][2]], exterior_points[0][0:2]) + [line[0]] # [intersecting point, exterior point]
-    if len(exterior_points) == 2: # line must intersect with two edges
-        points = []
-        for i in range(len(polygon)):
-            intersection = line_line_intersect(orig_line, [polygon[i], polygon[(i + 1) % len(polygon)]])
-            if len(intersection) > 0: points += intersection
-            if len(points) > 1: break # exit if two intersections have been found
-        else: return [] # fallback if 0 or one intersections found
-        return points
-    
-def closest_two_lines(p1: glm.vec3, q1: glm.vec3, p2: glm.vec3, q2: glm.vec3, epsilon: float=1e-7) -> tuple[glm.vec3, glm.vec3]:
-    """
-    Determines the closest point on each line segment to the other line segment. 
-    """
-    # create direction vector
-    d1 = q1 - p1
-    d2 = q2 - p2
-    r = p1 - p2
-    
-    # get lengths of line segments
-    a = glm.dot(d1, d1)
-    e = glm.dot(d2, d2)
-    f = glm.dot(d2, r)
-    
-    # check if either or both line segment degenerate into points
-    if a <= epsilon and e <= epsilon:
-        # both segments degenerate
-        return p1, p2
-    
-    if a <= epsilon:
-        s = 0
-        t = glm.clamp(f / e, 0, 1)
-    else: 
-        c = glm.dot(d1, r)
-        if e <= epsilon:
-            # the second line degenerates to a point
-            t = 0
-            s = glm.clamp(-c / a, 0, 1)
-        else:
-            # if neither of them degenerate to a point
-            b = glm.dot(d1, d2)
-            denom = a * e - b ** 2 # this will always be non-negative
-            
-            # if segments are not parallel, compute closest point from l1 to l2
-            s = glm.clamp((b * f - c * e) / denom, 0, 1) if denom else 0
-            
-            # compute closest point from l2 on s1(s)
-            t = (b * s + f) / e
-            
-            # if t is not in [0, 1], clamp and recompute s
-            if t < 0:
-                t = 0
-                s = glm.clamp(-c / a, 0, 1)
-            elif t > 1:
-                t = 1
-                s = glm.clamp((b - c) / a, 0, 1)
-                
-    c1 = p1 + d1 * s
-    c2 = p2 + d2 * t
-    return c1, c2
-                
+import glm
+from .helper import is_ccw_turn
+
+# intersectionn algorithms for lines
+def line_line_intersect(points1:list[glm.vec2], points2:list[glm.vec2]) -> list[glm.vec2]:
+    """gets the intersection of 2 2d lines. if the lines are parallel, returns the second line"""
+    # orders points from smallest x to greatest x
+    points1 = sorted(points1, key=lambda p: (p.x, p.y))
+    points2 = sorted(points2, key=lambda p: (p.x, p.y))
+    vec1, vec2 = points1[1] - points1[0], points2[1] - points2[0]
+    
+    # if vectors have the same slope return the smallest line
+    if have_same_slope(vec1, vec2): return sorted(points1 + points2, key=lambda p: (p.x, p.y))[1:3]
+    
+    # line - line intersection
+    det = vec1.x * vec2.y - vec1.y * vec2.x
+    if det == 0: return []
+    t = (points2[0].x - points1[0].x) * vec2.y - (points2[0].y - points1[0].y) * vec2.x
+    t /= det
+    return [points1[0] + t * vec1]
+    
+def have_same_slope(vec1:glm.vec2, vec2:glm.vec2, epsilon:float=1e-5) -> bool:
+    """determines if two vectors moving in the positive x direction have the same slope"""
+    return abs(vec1.y * vec2.x - vec2.y * vec1.x) < epsilon
+
+def line_poly_intersect(line:list[glm.vec2], polygon:list[glm.vec2]) -> list[glm.vec2]: #TODO Reseach into faster algorithm < O(2n)
+    """computes which parts of the line clip with the polygon"""
+    # calculate the center of the polygon
+    assert len(polygon) > 2, 'polygon is does not contain engough points'
+    center = glm.vec2(0,0)
+    for point in polygon: center += point
+    center /= len(polygon)
+    orig_line = line[:]
+    # determine which points are in or out of the polygon
+    exterior_points = []
+    for i in range(len(polygon)): # nearest even number below n
+        for line_point in line[:]:
+            if not is_ccw_turn(polygon[i], polygon[(i + 1) % len(polygon)], line_point): # if point is on the outside
+                exterior_points.append((polygon[i], polygon[(i + 1) % len(polygon)], line_point)) # polypoint1, polypoint2, linepoint
+                line.remove(line_point) # removes line point if it is confirmed to be outside
+                
+    # determine what to with line based on number of points found outside
+    if len(exterior_points) == 0:
+        return line
+    if len(exterior_points) == 1:
+        return line_line_intersect(line + [exterior_points[0][2]], exterior_points[0][0:2]) + [line[0]] # [intersecting point, exterior point]
+    if len(exterior_points) == 2: # line must intersect with two edges
+        points = []
+        for i in range(len(polygon)):
+            intersection = line_line_intersect(orig_line, [polygon[i], polygon[(i + 1) % len(polygon)]])
+            if len(intersection) > 0: points += intersection
+            if len(points) > 1: break # exit if two intersections have been found
+        else: return [] # fallback if 0 or one intersections found
+        return points
+    
+def closest_two_lines(p1: glm.vec3, q1: glm.vec3, p2: glm.vec3, q2: glm.vec3, epsilon: float=1e-7) -> tuple[glm.vec3, glm.vec3]:
+    """
+    Determines the closest point on each line segment to the other line segment. 
+    """
+    # create direction vector
+    d1 = q1 - p1
+    d2 = q2 - p2
+    r = p1 - p2
+    
+    # get lengths of line segments
+    a = glm.dot(d1, d1)
+    e = glm.dot(d2, d2)
+    f = glm.dot(d2, r)
+    
+    # check if either or both line segment degenerate into points
+    if a <= epsilon and e <= epsilon:
+        # both segments degenerate
+        return p1, p2
+    
+    if a <= epsilon:
+        s = 0
+        t = glm.clamp(f / e, 0, 1)
+    else: 
+        c = glm.dot(d1, r)
+        if e <= epsilon:
+            # the second line degenerates to a point
+            t = 0
+            s = glm.clamp(-c / a, 0, 1)
+        else:
+            # if neither of them degenerate to a point
+            b = glm.dot(d1, d2)
+            denom = a * e - b ** 2 # this will always be non-negative
+            
+            # if segments are not parallel, compute closest point from l1 to l2
+            s = glm.clamp((b * f - c * e) / denom, 0, 1) if denom else 0
+            
+            # compute closest point from l2 on s1(s)
+            t = (b * s + f) / e
+            
+            # if t is not in [0, 1], clamp and recompute s
+            if t < 0:
+                t = 0
+                s = glm.clamp(-c / a, 0, 1)
+            elif t > 1:
+                t = 1
+                s = glm.clamp((b - c) / a, 0, 1)
+                
+    c1 = p1 + d1 * s
+    c2 = p2 + d2 * t
+    return c1, c2
+                
         

basilisk/collisions/narrow/sutherland_hodgman.py

@@ -1,76 +1,76 @@
-import glm
-from .helper import is_ccw_turn
-from .line_intersections import line_line_intersect
-
-def sutherland_hodgman(subject:list[glm.vec2], clip:list[glm.vec2]) -> list[glm.vec2]:
-    """determines the clipped polygon vertices from ccw oriented polygons"""
-    output_poly = subject
-    
-    for i in range(len(clip)):
-        input_poly = output_poly
-        output_poly = []
-        
-        edge_start, edge_end = clip[i], clip[(i + 1) % len(clip)]
-        for j in range(len(input_poly)):
-            prev_point, curr_point = input_poly[j - 1], input_poly[j]
-
-            if is_ccw_turn(curr_point, edge_start, edge_end):
-                if not is_ccw_turn(prev_point, edge_start, edge_end):
-                    output_poly += line_line_intersect([edge_end, edge_start], [prev_point, curr_point])
-                output_poly.append(curr_point)
-            elif is_ccw_turn(prev_point, edge_start, edge_end):
-                output_poly += line_line_intersect([edge_end, edge_start], [prev_point, curr_point])
-                
-    return output_poly
-
-# def get_intersect(one: glm.vec2, two: glm.vec2, thr: glm.vec2, fou: glm.vec2) -> glm.vec2:
-#     """
-#     Gets the intersection point between two lines
-#     """
-#     deno = (one.x - two.x) * (thr.y - fou.y) - (one.y - two.y) * (thr.x - fou.x)
-#     if deno == 0: # TODO determine if this happens
-#         print('sutherland-hodgman line intersection had zero denominator')
-#         return None
-#     x_num = (one.x * two.y - one.y * two.x) * (thr.x - fou.x) - (one.x - two.x) * (thr.x * fou.y - thr.y * fou.x)
-#     y_num = (one.x * two.y - one.y * two.x) * (thr.y - fou.y) - (one.y - two.y) * (thr.x * fou.y - thr.y * fou.x)
-#     return glm.vec2(x_num / deno, y_num / deno)
-
-# def clip(poly: list[glm.vec2], one: glm.vec2, two: glm.vec2) -> list[glm.vec2]:
-#     """
-#     Clip all edges of polygon with one of the clipping edges
-#     """
-#     num_points = len(poly)
-#     new_points = []
-    
-#     for i in range(num_points):
-#         k    = (i + 1) % num_points
-#         veci = poly[i]
-#         veck = poly[k]
-        
-#         posi = (two.x - one.x) * (veci.y - one.y) - (two.y - one.y) * (veci.x - one.x)
-#         posk = (two.x - one.x) * (veck.y - one.y) - (two.y - one.y) * (veck.x - one.x)
-        
-#         if posi < 0 and posk < 0: new_points.append(veck)
-#         elif posi >= 0 and posk < 0: 
-            
-#             new_points.append(get_intersect(one, two, veci, veck))
-#             new_points.append(veck)
-            
-#         elif posi < 0 and posk >= 0:
-            
-#             new_points.append(get_intersect(one, two, veci, veck))
-        
-#     return new_points
-
-# def sutherland_hodgman(subj_poly:list[glm.vec2], clip_poly:list[glm.vec2]) -> list[glm.vec2]:
-#     """
-#     Determines the clipped polygon vertices from ccw oriented polygons.
-#     """
-#     num_clip = len(clip_poly)
-    
-#     for i in range(num_clip):
-#         k = (i + 1) % num_clip
-        
-#         subj_poly = clip(subj_poly, clip_poly[i], clip_poly[k])
-        
+import glm
+from .helper import is_ccw_turn
+from .line_intersections import line_line_intersect
+
+def sutherland_hodgman(subject:list[glm.vec2], clip:list[glm.vec2]) -> list[glm.vec2]:
+    """determines the clipped polygon vertices from ccw oriented polygons"""
+    output_poly = subject
+    
+    for i in range(len(clip)):
+        input_poly = output_poly
+        output_poly = []
+        
+        edge_start, edge_end = clip[i], clip[(i + 1) % len(clip)]
+        for j in range(len(input_poly)):
+            prev_point, curr_point = input_poly[j - 1], input_poly[j]
+
+            if is_ccw_turn(curr_point, edge_start, edge_end):
+                if not is_ccw_turn(prev_point, edge_start, edge_end):
+                    output_poly += line_line_intersect([edge_end, edge_start], [prev_point, curr_point])
+                output_poly.append(curr_point)
+            elif is_ccw_turn(prev_point, edge_start, edge_end):
+                output_poly += line_line_intersect([edge_end, edge_start], [prev_point, curr_point])
+                
+    return output_poly
+
+# def get_intersect(one: glm.vec2, two: glm.vec2, thr: glm.vec2, fou: glm.vec2) -> glm.vec2:
+#     """
+#     Gets the intersection point between two lines
+#     """
+#     deno = (one.x - two.x) * (thr.y - fou.y) - (one.y - two.y) * (thr.x - fou.x)
+#     if deno == 0: # TODO determine if this happens
+#         print('sutherland-hodgman line intersection had zero denominator')
+#         return None
+#     x_num = (one.x * two.y - one.y * two.x) * (thr.x - fou.x) - (one.x - two.x) * (thr.x * fou.y - thr.y * fou.x)
+#     y_num = (one.x * two.y - one.y * two.x) * (thr.y - fou.y) - (one.y - two.y) * (thr.x * fou.y - thr.y * fou.x)
+#     return glm.vec2(x_num / deno, y_num / deno)
+
+# def clip(poly: list[glm.vec2], one: glm.vec2, two: glm.vec2) -> list[glm.vec2]:
+#     """
+#     Clip all edges of polygon with one of the clipping edges
+#     """
+#     num_points = len(poly)
+#     new_points = []
+    
+#     for i in range(num_points):
+#         k    = (i + 1) % num_points
+#         veci = poly[i]
+#         veck = poly[k]
+        
+#         posi = (two.x - one.x) * (veci.y - one.y) - (two.y - one.y) * (veci.x - one.x)
+#         posk = (two.x - one.x) * (veck.y - one.y) - (two.y - one.y) * (veck.x - one.x)
+        
+#         if posi < 0 and posk < 0: new_points.append(veck)
+#         elif posi >= 0 and posk < 0: 
+            
+#             new_points.append(get_intersect(one, two, veci, veck))
+#             new_points.append(veck)
+            
+#         elif posi < 0 and posk >= 0:
+            
+#             new_points.append(get_intersect(one, two, veci, veck))
+        
+#     return new_points
+
+# def sutherland_hodgman(subj_poly:list[glm.vec2], clip_poly:list[glm.vec2]) -> list[glm.vec2]:
+#     """
+#     Determines the clipped polygon vertices from ccw oriented polygons.
+#     """
+#     num_clip = len(clip_poly)
+    
+#     for i in range(num_clip):
+#         k = (i + 1) % num_clip
+        
+#         subj_poly = clip(subj_poly, clip_poly[i], clip_poly[k])
+        
 #     return subj_poly

basilisk/config.py

@@ -1,3 +1,3 @@
-class Config():
-    def __init__(self) -> None:
+class Config():
+    def __init__(self) -> None:
         ...