basilisk-engine 0.0.8__py3-none-any.whl → 0.1.0__py3-none-any.whl

basilisk/__init__.py

@@ -1,10 +1,12 @@
+import pygame as pg
 from .engine import Engine
 from .scene import Scene
 from .nodes.node import Node
 from .mesh.mesh import Mesh
 from .render.image import Image
 from .render.material import Material
+from .render.shader import Shader
 from .render.shader_handler import ShaderHandler
 from .draw import draw
-from .render.camera import FreeCamera, StaticCamera
+from .render.camera import FreeCamera, StaticCamera, FollowCamera, OrbitCamera
 from .render.sky import Sky

basilisk/collisions/broad/broad_bvh.py

@@ -58,7 +58,35 @@ class BroadBVH(BVH):
         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 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:
         """
@@ -99,4 +127,5 @@ class BroadBVH(BVH):
         """
         Returns which objects may be colliding from the BVH
         """
-        return self.root.get_collided(collider)
+        if isinstance(self.root, BroadAABB): return self.root.get_collided(collider)
+        else: return []

basilisk/collisions/collider.py

@@ -39,17 +39,18 @@ class Collider():
         self.collider_handler = collider_handler
         self.node = node
         self.mesh = self.collider_handler.cube if box_mesh else self.node.mesh
-        self.static_friction = static_friction
-        self.kinetic_friction = kinetic_friction
-        self.elasticity = elasticity
+        self.static_friction = static_friction if elasticity else 0.8
+        self.kinetic_friction = kinetic_friction if elasticity else 0.4
+        self.elasticity = elasticity if elasticity else 0.1
         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
+        self.needs_obb = True # pos, scale, rot
+        self.needs_half_dimensions = True # scale, rot
+        self.needs_bvh = True # pos, scale, rot
         
     @property
     def has_collided(self): return bool(self.collisions)

basilisk/collisions/collider_handler.py

@@ -1,11 +1,16 @@
 import glm
-from .narrow.gjk import *
+
+from basilisk.collisions.narrow.graham_scan import graham_scan
+from basilisk.collisions.narrow.sutherland_hodgman import sutherland_hodgman
 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
+from .narrow.contact_manifold import get_contact_manifold, points_to_2d, points_to_3d, project_points
+from .narrow.line_intersections import closest_two_lines, line_poly_intersect
+from ..nodes.node import Node
+from ..generic.collisions import get_sat_axes
+from ..physics.impulse import calculate_collisions
 
 class ColliderHandler():
     scene: ...
@@ -44,9 +49,15 @@ class ColliderHandler():
         """
         # reset collision data
         for collider in self.colliders: collider.collisions = {}
-        # TODO update BVH
+        # update BVH
+        for collider in self.colliders:
+            if collider.needs_bvh:
+                self.bvh.remove(collider)
+                self.bvh.add(collider)
+        
+        # resolve collisions
         broad_collisions = self.resolve_broad_collisions()
-        self.resolve_narrow_collisions(broad_collisions)
+        self.resolve_narrow_collisions(broad_collisions) 
         
     def collide_obb_obb(self, collider1: Collider, collider2: Collider) -> tuple[glm.vec3, float] | None:
         """
@@ -59,7 +70,8 @@ class ColliderHandler():
         # test axes
         small_axis    = None
         small_overlap = 1e10
-        for axis in axes: # TODO add optimization for points on cardinal axis of cuboid
+        small_index = 0
+        for i, axis in enumerate(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]
@@ -69,17 +81,63 @@ class ColliderHandler():
             
             # 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)
+            elif max2 > max1 and min2 < min1: overlap = min(max2 - min1, max1 - min2)
             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
+            small_index   = i
+            
+        return small_axis, small_overlap, small_index
+    
+    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) #TODO precalc orthogonal basis for 2d conversion
+            
+            # 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)
         
-        print(axes.index(small_axis), glm.length(small_axis))
-        print('overlap:', small_overlap)
+        else: # there is an edge edge collision
+            
+            points1 = get_test_points(-axis, points1, 2)
+            points2 = get_test_points(axis, points2, 2)
             
-        return small_axis, small_overlap
+            return closest_two_lines(*points1, *points2)
     
     def collide_obb_obb_decision(self, collider1: Collider, collider2: Collider) -> bool:
         """
@@ -124,8 +182,6 @@ class ColliderHandler():
         """
         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]
@@ -139,7 +195,11 @@ class ColliderHandler():
                 data = self.collide_obb_obb(collider1, collider2)
                 if not data: continue
                 
-                vec, distance = data
+                vec, distance, index = data
+                
+                # TODO replace with own contact algorithm
+                points1 = collider1.obb_points
+                points2 = collider2.obb_points
                 
             else: # use gjk to determine collisions between non-cuboid meshes
                 has_collided, simplex = collide_gjk(node1, node2)
@@ -148,17 +208,20 @@ class ColliderHandler():
                 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
+                # TODO replace with own contact algorithm
+                points1 = [p[1] for p in polytope]
+                points2 = [p[2] for p in polytope]
                 
-            print('\033[92m', vec, distance, '\033[0m')
-            
-            # resolve collision penetration
-            node2.position -= vec * distance
-            
-            collided.append((node1, node2, vec * distance))
+            if glm.dot(vec, node2.position - node1.position) > 0: vec *= -1
             
-            # TODO add penetration resolution
-            # TODO add impulse
+            if node1.physics_body or node2.physics_body:
+                manifold = get_contact_manifold(node1.position - vec, vec, points1, points2)
+                if len(manifold) == 0: 
+                    print('manifold failed to generate')
+                    continue
+                calculate_collisions(vec, node1, node2, manifold, node1.get_inverse_inertia(), node2.get_inverse_inertia(), node1.center_of_mass, node2.center_of_mass)
             
-        return collided
+            # resolve collision penetration
+            multiplier = 0.5 if not (node1.static or node2.static) else 1
+            if not node1.static: node1.position += multiplier * vec * distance
+            if not node2.static: node2.position -= multiplier * vec * distance

basilisk/collisions/narrow/contact_manifold.py

@@ -0,0 +1,92 @@
+import glm
+from random import randint
+from .line_intersections import line_line_intersect, line_poly_intersect
+from .graham_scan import graham_scan
+from .sutherland_hodgman import sutherland_hodgman
+
+# sutherland hodgman clipping algorithm
+def get_contact_manifold(contact_plane_point:glm.vec3, contact_plane_normal:glm.vec3, points1:list[glm.vec3], points2:list[glm.vec3]) -> list[glm.vec3]:
+    """
+    computes the contact manifold for a collision between two nearby polyhedra
+    """
+    # determine the contact points from the collision
+    points1, points2 = separate_polytope(points1, points2, contact_plane_normal)
+    
+    if len(points1) == 0 or len(points2) == 0: return []
+    
+    # project vertices onto the 2d plane
+    points1 = project_points(contact_plane_point, contact_plane_normal, points1)
+    points2 = project_points(contact_plane_point, contact_plane_normal, points2)
+    
+    # check if collsion was on a vertex
+    if len(points1) == 1: return points1
+    if len(points2) == 1: return points2
+    
+    # convert points to 2d for intersection algorithms
+    points1, u1, v1 = points_to_2d(contact_plane_point, contact_plane_normal, points1)
+    points2, u2, v2 = points_to_2d(contact_plane_point, contact_plane_normal, points2, u1, v1) #TODO precalc orthogonal basis for 2d conversion
+    
+    # convert arbitrary points to polygon
+    if len(points1) > 2: points1 = graham_scan(points1)
+    if len(points2) > 2: points2 = graham_scan(points2)
+    
+    # run clipping algorithms
+    manifold = []
+    is_line1, is_line2 = len(points1) == 2, len(points2) == 2
+    if is_line1 and is_line2: manifold = line_line_intersect(points1, points2)
+    else: 
+        if is_line1:   manifold = line_poly_intersect(points1, points2)
+        elif is_line2: manifold = line_poly_intersect(points2, points1)
+        else:          manifold = sutherland_hodgman(points1, points2)
+        
+    # fall back if manifold fails to develope
+    if len(manifold) == 0: return []
+    # convert inertsection algorithm output to 3d
+    return points_to_3d(u1, v1, contact_plane_point, manifold)
+
+def separate_polytope(points1: list[glm.vec3], points2: list[glm.vec3], contact_plane_normal) -> list[glm.vec3]:
+    """
+    Determines the potential contact manifold points of each shape based on their position along the penetrating axis
+    """
+    proj1 = [(glm.dot(point, contact_plane_normal), point) for point in points1]
+    proj2 = [(glm.dot(point, contact_plane_normal), point) for point in points2]
+    
+    # min1 and max2 should be past the collising points of node2 and node1 respectively
+    min1 = min(proj1, key=lambda point: point[0])
+    max2 = max(proj2, key=lambda point: point[0])
+    
+    proj1 = filter(lambda proj: proj < max2, proj1)
+    proj2 = filter(lambda proj: proj > min1, proj2)
+    
+    return [point[1] for point in proj1], [point[1] for point in proj2]
+    
+def distance_to_plane(contact_plane_point:glm.vec3, contact_plane_normal:glm.vec3, point:glm.vec3) -> float:
+    """gets the smallest distance a point is from a plane"""
+    return glm.dot(point - contact_plane_point, contact_plane_normal) #TODO check this formula
+
+def project_points(contact_plane_point:glm.vec3, contact_plane_normal:glm.vec3, points:list[glm.vec3]) -> list[glm.vec3]:
+    """gets the projected positions of the given points onto the given plane"""
+    return [point - glm.dot(point - contact_plane_point, contact_plane_normal) * contact_plane_normal for point in points]
+
+def points_to_2d(contact_plane_point:glm.vec3, contact_plane_normal:glm.vec3, points:list[glm.vec3], u = None, v = None) -> tuple[list[glm.vec2], glm.vec3, glm.vec3]:
+    """converts a list of points on a plane to their 2d representation"""
+    # generate a new basis
+    k = get_noncolinear_vector(contact_plane_normal)
+    u = u if u else glm.normalize(glm.cross(contact_plane_normal, k))
+    v = v if v else glm.cross(contact_plane_normal, u)
+    
+    # convert points to new basis
+    return [glm.vec2(glm.dot(vec := point - contact_plane_point, u), glm.dot(vec, v)) for point in points], u, v
+    
+def points_to_3d(u:glm.vec3, v:glm.vec3, contact_plane_point:glm.vec3, points:list[glm.vec2]) -> list[glm.vec3]:
+    """converts a list of points on a plane to their 3d representation"""
+    return [contact_plane_point + point.x * u + point.y * v for point in points]
+    
+# vector math
+def get_noncolinear_vector(vector:glm.vec3) -> glm.vec3:
+    """generates a non colinear vector based on the given vector"""
+    test_vector = (1, 1, 1)
+    while glm.cross(test_vector, vector) == (0, 0, 0):
+        val = randint(0, 7) # 000 to 111
+        test_vector = (val & 1, val & 2, val & 4) # one random for three digits
+    return test_vector

basilisk/collisions/narrow/epa.py

@@ -7,7 +7,7 @@ from...nodes.node import Node
 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
+def get_epa_from_gjk(node1: Node, node2: Node, polytope: polytope_type, epsilon: float=0) -> tuple: # 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. 
     """
@@ -18,14 +18,10 @@ def get_epa_from_gjk(node1: Node, node2: Node, polytope: polytope_type, epsilon:
     # 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
+        if new_point in polytope or glm.length(new_point[0]) - faces[0][0] < epsilon: 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]:
+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
     """ 
@@ -43,6 +39,9 @@ def insert_point(polytope: polytope_type, faces: face_type, point: glm.vec3, eps
     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
@@ -59,8 +58,14 @@ def insert_face(polytope: polytope_type, faces: face_type, indices: tuple[int, i
     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
+    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]][0], normal))
     new_face = (distance, normal, center, *indices)
     
     # insert faces into priority queue based on distance from origin

basilisk/collisions/narrow/graham_scan.py

@@ -0,0 +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
+    return atan2(vector.y, vector.x)

basilisk/collisions/narrow/helper.py

@@ -20,4 +20,10 @@ def get_furthest_point(node: Node, dir_vec: glm.vec3) -> glm.vec3:
     vertex = node.model_matrix * glm.vec4(vertex, 1.0)
     
     # transform point to world space
-    return glm.vec3(vertex)
+    return glm.vec3(vertex)
+
+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

@@ -0,0 +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
+                
+        

basilisk/collisions/narrow/sutherland_hodgman.py

@@ -0,0 +1,24 @@
+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

basilisk/draw/draw_handler.py

@@ -16,9 +16,9 @@ class DrawHandler():
     """2D draw program"""
     draw_data: list[float]
     """Temporary buffer for user draw calls"""
-    vbo: mgl.Buffer
+    vbo: mgl.Buffer=None
     """Buffer for all 2D draws"""
-    vao: mgl.VertexArray
+    vao: mgl.VertexArray=None
     """VAO for rendering all 2D draw calls"""
     
     def __init__(self, scene) -> None:
@@ -28,7 +28,7 @@ class DrawHandler():
         self.ctx    = scene.engine.ctx
 
         # Get the program
-        self.program = self.scene.shader_handler.programs['draw']
+        self.program = self.scene.shader_handler.shaders['draw'].program
 
         # Initialize draw data as blank
         self.draw_data = []

basilisk/engine.py

@@ -5,7 +5,8 @@ import moderngl as mgl
 from .config import Config
 from .input.mouse import Mouse
 from .mesh.cube import Cube
-import time
+from .render.shader import Shader
+
 
 class Engine():
     win_size: tuple
@@ -90,6 +91,9 @@ class Engine():
         # Scene being used by the engine
         self.scene = None
 
+        # Load a default shader
+        self.shader = Shader(self, self.root + '/shaders/batch.vert', self.root + '/shaders/batch.frag')
+
         # Set the scene to running
         self.running = True
 
@@ -167,8 +171,17 @@ class Engine():
 
     @property
     def scene(self): return self._scene
-    
+    @property
+    def shader(self): return self._shader
+
     @scene.setter
     def scene(self, value):
         self._scene = value
-        if self._scene: self._scene.set_engine(self)
+        if self._scene: 
+            self._scene.set_engine(self)
+            self.shader.use()
+
+    @shader.setter
+    def shader(self, value):
+        self._shader = value
+        if self.scene: value.use()

basilisk/generic/collisions.py

@@ -14,13 +14,12 @@ def get_sat_axes(rotation1: glm.quat, rotation2: glm.quat) -> list[glm.vec3]:
     axes = []
     axes.extend(glm.transpose(glm.mat3_cast(rotation1)))
     axes.extend(glm.transpose(glm.mat3_cast(rotation2)))
-    # axes.extend(glm.mat3_cast(rotation1))
-    # axes.extend(glm.mat3_cast(rotation2))
     
     # crossed roots
     for i in range(0, 3):
         for j in range(3, 6):
             cross = glm.cross(axes[i], axes[j])
+            if glm.length2(cross) < 1e-6: continue
             axes.append(glm.normalize(cross))
             
     return axes