basilisk-engine 0.0.9__py3-none-any.whl → 0.1.1__py3-none-any.whl

basilisk/collisions/narrow/gjk.py

@@ -1,5 +1,6 @@
 import glm
 from .helper import get_support_point
+from .dataclasses import SupportPoint
 from ...nodes.node import Node
 from ...generic.math import triple_product
 
@@ -11,12 +12,12 @@ def collide_gjk(node1: Node, node2: Node, iterations: int=20) -> tuple: # TODO f
     # 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
+    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[0], dir_vec) < -1e-7: return False, simplex
+        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)
@@ -25,7 +26,7 @@ def collide_gjk(node1: Node, node2: Node, iterations: int=20) -> tuple: # TODO f
         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]]]:
+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
     """
@@ -34,28 +35,28 @@ def handle_simplex(simplex: list) -> tuple[bool, glm.vec3, list[tuple[glm.vec3,
     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]]]:
+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][0] - simplex[0][0]
-    return False, triple_product(vec_ab, -simplex[0][0], vec_ab), simplex
+    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) -> tuple[bool, glm.vec3, list[tuple[glm.vec3, glm.vec3, glm.vec3]]]:
+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][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
+    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, epsilon: float=0) -> tuple[bool, glm.vec3, list[tuple[glm.vec3, glm.vec3, glm.vec3]]]:
+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][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]
+    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:

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

@@ -1,14 +1,14 @@
 import glm
 from ...nodes.node import Node
+from .dataclasses import SupportPoint
 
-
-def get_support_point(node1: Node, node2: Node, dir_vec: glm.vec3) -> tuple[glm.vec3, glm.vec3, glm.vec3]:
+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 = get_furthest_point(node1, dir_vec)
-    vertex2 = get_furthest_point(node2, -dir_vec)
-    return (vertex1 - vertex2, vertex1, vertex2)
+    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:
     """
@@ -16,8 +16,15 @@ def get_furthest_point(node: Node, dir_vec: glm.vec3) -> glm.vec3:
     """
     # 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)
+    index = node.mesh.get_best_dot(node_dir_vec)
+    vertex = node.mesh.points[index]
     vertex = node.model_matrix * glm.vec4(vertex, 1.0)
     
     # transform point to world space
-    return glm.vec3(vertex)
+    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

@@ -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,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])
+        
+#     return subj_poly

basilisk/draw/draw_handler.py

@@ -4,6 +4,7 @@ import glm
 from math import cos, sin, atan2
 from ..render.image import Image
 from .font_renderer import FontRenderer
+from ..render.shader import Shader
 
 class DrawHandler():
     engine: ...
@@ -16,9 +17,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:
@@ -27,8 +28,9 @@ class DrawHandler():
         self.engine = scene.engine
         self.ctx    = scene.engine.ctx
 
-        # Get the program
-        self.program = self.scene.shader_handler.programs['draw']
+        # Get the shader
+        root = self.engine.root
+        self.shader = self.scene.shader_handler.add(Shader(self.engine, root + '/shaders/draw.vert', root + '/shaders/draw.frag'))
 
         # Initialize draw data as blank
         self.draw_data = []
@@ -52,7 +54,7 @@ class DrawHandler():
 
         # Create buffer and VAO
         self.vbo = self.ctx.buffer(data)
-        self.vao = self.ctx.vertex_array(self.program, [(self.vbo, '2f 4f 1i', *['in_position', 'in_color', 'in_uses_image'])], skip_errors=True)
+        self.vao = self.ctx.vertex_array(self.shader.program, [(self.vbo, '2f 4f 1i', *['in_position', 'in_color', 'in_uses_image'])], skip_errors=True)
 
         # Render the VAO
         self.ctx.enable(mgl.BLEND)

basilisk/engine.py

@@ -1,11 +1,13 @@
 import os
+from sys import platform
 os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
 import pygame as pg
 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
@@ -35,7 +37,7 @@ class Engine():
     root: str
     """Path to the root directory containing internal data"""
 
-    def __init__(self, win_size=(800, 800), title="Basilisk Engine", vsync=False, grab_mouse=True, headless=False) -> None:
+    def __init__(self, win_size=(800, 800), title="Basilisk Engine", vsync=None, grab_mouse=True, headless=False) -> None:
         """
         Basilisk Engine Class. Sets up the engine enviornment and allows the user to interact with Basilisk
         Args:
@@ -48,6 +50,11 @@ class Engine():
             headless: bool
                 Flag for headless rendering
         """
+
+        if platform == 'win32' : self.platform = 'windows'
+        elif  platform == 'darwin': self.platform = 'mac' 
+        else: self.platform = 'linux'
+
         # Save the window size
         self.win_size = win_size
 
@@ -56,6 +63,8 @@ class Engine():
         pg.display.gl_set_attribute(pg.GL_CONTEXT_MAJOR_VERSION, 3)
         pg.display.gl_set_attribute(pg.GL_CONTEXT_MINOR_VERSION, 3)
         pg.display.gl_set_attribute(pg.GL_CONTEXT_PROFILE_MASK, pg.GL_CONTEXT_PROFILE_CORE)
+        # Check vsync against platform defaults
+        if vsync == None: vsync = True if platform == 'linux' else False
         # Pygame display init
         if headless:
             pg.display.set_mode((300, 50), vsync=vsync, flags=pg.OPENGL | pg.DOUBLEBUF)
@@ -90,6 +99,10 @@ 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')
+        self.shader.hash = self.shader.hash + hash('engine_shader')
+
         # Set the scene to running
         self.running = True
 
@@ -103,6 +116,9 @@ class Engine():
         self.time += self.delta_time
         pg.display.set_caption(f"FPS: {round(self.clock.get_fps())}")
 
+        # Update the previous input lists for the next frame
+        self.previous_keys = self.keys
+        
         # Get inputs and events
         self.events = pg.event.get()
         self.keys = pg.key.get_pressed()
@@ -126,8 +142,6 @@ class Engine():
         # Render after the scene and engine has been updated
         self.render()
 
-        # Update the previous input lists for the next frame
-        self.previous_keys = self.keys
 
     def render(self) -> None:
         """
@@ -167,8 +181,16 @@ 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)
+
+    @shader.setter
+    def shader(self, value):
+        self._shader = value
+        if self.scene: value.set_main()

basilisk/generic/abstract_custom.py

@@ -0,0 +1,134 @@
+import glm
+import numpy as np
+
+
+class Custom():
+    
+    def normalize(self):
+        """
+        Inplace normalizes the vector
+        """
+        self.data = glm.normalize(self.data)
+        return self
+    
+    def apply_function(): ... # will be overridden by child custom classes
+    
+    # math functions
+    def add(self, other):
+        def func(a, b): return a + b
+        return self.apply_function(other, func, 'addition')
+    
+    def subtract(self, other):
+        def func(a, b): return a - b
+        return self.apply_function(other, func, 'subtraction')
+    
+    def rhs_subtract(self, other):
+        def func(a, b): return b - a
+        return self.apply_function(other, func, 'subtraction')
+    
+    def multiply(self, other):
+        def func(a, b): return a * b
+        return self.apply_function(other, func, 'multiplication')
+    
+    def divide(self, other):
+        def func(a, b): return a / b
+        return self.apply_function(other, func, 'division')
+    
+    def rhs_divide(self, other):
+        def func(a, b): return b / a
+        return self.apply_function(other, func, 'division')
+    
+    def floor_divide(self, other):
+        def func(a, b): return a // b
+        return self.apply_function(other, func, 'division')
+    
+    def rhs_floor_divide(self, other):
+        def func(a, b): return b // a
+        return self.apply_function(other, func, 'division')
+    
+    def mod(self, other):
+        def func(a, b): return a % b
+        return self.apply_function(other, func, 'modulus')
+    
+    def rhs_mod(self, other):
+        def func(a, b): return b % a
+        return self.apply_function(other, func, 'modulus')
+    
+    def pow(self, other):
+        def func(a, b): return a ** b
+        return self.apply_function(other, func, 'power')
+    
+    def rhs_pow(self, other):
+        def func(a, b): return b ** a
+        return self.apply_function(other, func, 'power')
+
+    def __add__(self, other):  return self.add(other) # this + that
+    def __radd__(self, other): return self.add(other) # that + this
+    def __iadd__(self, other): # this += that
+        self = self.add(other) 
+        return self
+    
+    def __sub__(self, other):  return self.subtract(other)
+    def __rsub__(self, other): return self.rhs_subtract(other) # non-commutative
+    def __isub__(self, other): 
+        self = self.subtract(other)
+        return self
+    
+    def __mul__(self, other):  return self.multiply(other)
+    def __rmul__(self, other): return self.multiply(other)
+    def __imul__(self, other): 
+        self = self.multiply(other)
+        return self
+    
+    def __truediv__(self, other):  return self.divide(other)
+    def __rtruediv__(self, other): return self.rhs_divide(other) # non-commutative
+    def __itruediv__(self, other): 
+        self = self.divide(other)
+        return self
+        
+    def __floordiv__(self, other):  return self.floor_divide(other)
+    def __rfloordiv__(self, other): return self.rhs_floor_divide(other) # non-commutative
+    def __ifloordiv__(self, other): 
+        self = self.floor_divide(other)
+        return self
+    
+    def __mod__(self, other):  return self.mod(other)
+    def __rmod__(self, other): return self.rhs_mod(other)
+    def __imod__(self, other):
+        self = self.mod(other)
+        return self
+    
+    def __pow__(self, other):  return self.pow(other)
+    def __rpow__(self, other): return self.rhs_pow(other)
+    def __ipow__(self, other):
+        self = self.pow(other)
+        return self
+    
+    # comparison functions
+    def __eq__(self, other):
+        if isinstance(other, Custom): return self.data == other.data
+        return self.data == other
+    
+    def __ne__(self, other):
+        if isinstance(other, Custom): return self.data != other.data
+        return self.data != other
+    
+    def __lt__(self, other):
+        if isinstance(other, Custom): return self.data < other.data
+        return self.data < other
+    
+    def __gt__(self, other):
+        if isinstance(other, Custom): return self.data > other.data
+        return self.data > other
+    
+    def __le__(self, other):
+        if isinstance(other, Custom): return self.data <= other.data
+        return self.data <= other
+    
+    def __ge__(self, other):
+        if isinstance(other, Custom): return self.data >= other.data
+        return self.data >= other
+    
+    # unary operators
+    def __pos__(self): 
+        return self

basilisk/generic/collisions.py

@@ -7,6 +7,52 @@ def collide_aabb_aabb(top_right1: glm.vec3, bottom_left1: glm.vec3, top_right2:
     """
     return all(bottom_left1[i] <= top_right2[i] + epsilon and epsilon + top_right1[i] >= bottom_left2[i] for i in range(3))
 
+def collide_aabb_line(top_right: glm.vec3, bottom_left: glm.vec3, position: glm.vec3, forward: glm.vec3) -> bool: # TODO check algorithm
+    """
+    Determines if an infinite line intersects with an AABB
+    """
+    tmin, tmax = -1e10, 1e10
+    for i in range(3):
+        if forward[i]: # if forward[i] is not 0 to avoid division errors
+            
+            deno = 1 / forward[i]
+            tlow   = (bottom_left[i] - position[i]) * deno
+            thigh  = (top_right[i]   - position[i]) * deno
+            if deno < 0: tlow, thigh = thigh, tlow
+            tmin   = max(tmin, tlow)
+            tmax   = min(tmax, thigh)
+            if tmax <= tmin: return False
+            
+        elif position[i] + 1e-7 < bottom_left[i] or position[i] > top_right[i] + 1e-7: return False
+
+    return True
+
+def moller_trumbore(point:glm.vec3, vec:glm.vec3, triangle:list[glm.vec3], epsilon:float=1e-7) -> glm.vec3:
+    """
+    Determines where a line intersects with a triangle and where that intersection occurred
+    """
+    edge1, edge2 = triangle[1] - triangle[0], triangle[2] - triangle[0]
+    ray_cross = glm.cross(vec, edge2)
+    det = glm.dot(edge1, ray_cross)
+    
+    # if the ray is parallel to the triangle
+    if abs(det) < epsilon: return None
+    
+    inv_det = 1 / det
+    s = point - triangle[0]
+    u = glm.dot(s, ray_cross) * inv_det
+    
+    if (u < 0 and abs(u) > epsilon) or (u > 1 and abs(u - 1) > epsilon): return None
+    
+    s_cross = glm.cross(s, edge1)
+    v = glm.dot(vec, s_cross) * inv_det
+    
+    if (v < 0 and abs(v) > epsilon) or (u + v > 1 and abs(u + v - 1) > epsilon): return None
+    
+    t = glm.dot(edge2, s_cross) * inv_det
+    if t > epsilon: return point + vec * t
+    return None
+
 def get_sat_axes(rotation1: glm.quat, rotation2: glm.quat) -> list[glm.vec3]:
     """
     Gets the axes for SAT from obb rotation matrices
@@ -14,13 +60,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