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

basilisk/generic/collisions.py

@@ -1,71 +1,71 @@
-import glm
-from ..generic.vec3 import Vec3
-from ..generic.quat import Quat
-
-
-def collide_aabb_aabb(top_right1: glm.vec3, bottom_left1: glm.vec3, top_right2: glm.vec3, bottom_left2: glm.vec3, epsilon:float=1e-7) -> bool:
-    """
-    Determines if two aabbs are colliding
-    """
-    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
-    """
-    # based on Smit's algorithm
-    inv_dir = glm.vec3([1 / i if i != 0 else float('inf') for i in forward])
-
-    t1 = (bottom_left - position) * inv_dir
-    t2 = (top_right - position) * inv_dir
-
-    t_min = glm.min(t1, t2)  # entry point along each axis
-    t_max = glm.max(t1, t2)  # exit point along each axis
-
-    t_entry = max(t_min.x, t_min.y, t_min.z)  # furthest entry time
-    t_exit = min(t_max.x, t_max.y, t_max.z)  # earliest exit time
-
-    return t_entry <= t_exit and t_exit >= 0
-
-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: Quat, rotation2: Quat) -> list[glm.vec3]:
-    """
-    Gets the axes for SAT from obb rotation matrices
-    """
-    axes = []
-    axes.extend(glm.transpose(glm.mat3_cast(rotation1.data)))
-    axes.extend(glm.transpose(glm.mat3_cast(rotation2.data)))
-    
-    # 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))
-            
+import glm
+from ..generic.vec3 import Vec3
+from ..generic.quat import Quat
+
+
+def collide_aabb_aabb(top_right1: glm.vec3, bottom_left1: glm.vec3, top_right2: glm.vec3, bottom_left2: glm.vec3, epsilon:float=1e-7) -> bool:
+    """
+    Determines if two aabbs are colliding
+    """
+    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
+    """
+    # based on Smit's algorithm
+    inv_dir = glm.vec3([1 / i if i != 0 else float('inf') for i in forward])
+
+    t1 = (bottom_left - position) * inv_dir
+    t2 = (top_right - position) * inv_dir
+
+    t_min = glm.min(t1, t2)  # entry point along each axis
+    t_max = glm.max(t1, t2)  # exit point along each axis
+
+    t_entry = max(t_min.x, t_min.y, t_min.z)  # furthest entry time
+    t_exit = min(t_max.x, t_max.y, t_max.z)  # earliest exit time
+
+    return t_entry <= t_exit and t_exit >= 0
+
+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: Quat, rotation2: Quat) -> list[glm.vec3]:
+    """
+    Gets the axes for SAT from obb rotation matrices
+    """
+    axes = []
+    axes.extend(glm.transpose(glm.mat3_cast(rotation1.data)))
+    axes.extend(glm.transpose(glm.mat3_cast(rotation2.data)))
+    
+    # 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

basilisk/generic/input_validation.py

@@ -1,83 +1,83 @@
-import numpy as np
-import glm
-from ..render.image import Image
-
-
-def validate_int(module: str, name: str, value: int | float | glm.int32) -> float:
-    if isinstance(value, int) or isinstance(value, float):
-        return int(round(value))
-    elif isinstance(value, glm.int32):
-        return int(value.value)
-    else:
-        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected float.")
-
-def validate_float(module: str, name: str, value: float | int | glm.float32) -> float:
-    if isinstance(value, float) or isinstance(value, int):
-        return float(value)
-    elif isinstance(value, glm.float32):
-        return float(value.value)
-    else:
-        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected float.")
-
-def validate_glm_float(module: str, name: str, value: float | int | glm.float32) -> glm.float32:
-    if isinstance(value, float) or isinstance(value, int):
-        return glm.float32(value)
-    elif isinstance(value, glm.float32):
-        return value
-    else:
-        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected glm.float32 or convertable value.")
-
-def validate_glm_vec3(module: str, name: str, value: tuple | list | glm.vec3 | np.ndarray) -> glm.vec3:
-    if isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
-        if len(value) != 3: raise ValueError(f"{module}: Invalid number of values for {name}. Expected 3 values, got {len(value)} values")
-        return glm.vec3(value)
-    elif isinstance(value, glm.vec3) or isinstance(value, int) or isinstance(value, float):
-        return glm.vec3(value)
-    else:
-        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected glm.vec3")
-
-def validate_tuple3(module: str, name: str, value: tuple | list | glm.vec3 | np.ndarray) -> tuple:
-    if isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
-        if len(value) != 3: raise ValueError(f"{module}: Invalid number of values for {name}. Expected 3 values, got {len(value)} values")
-        return tuple(value)
-    elif isinstance(value, glm.vec3):
-        return (value.x, value.y, value.z)
-    if isinstance(value, int) or isinstance(value, float):
-        return (value, value, value)
-    else:
-        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected tuple of size 3")
-
-def validate_image(module: str, name: str, value: Image | None) -> Image | None:
-    """Accepts none as a value for no image"""
-    if isinstance(value, Image) or isinstance(value, type(None)):
-        return value
-    else:
-        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected bsk.Image or None")
-    
-def validate_color(module: str, name: str, value: tuple | list | np.ndarray | int | float | None) -> tuple:
-    if isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
-        if len(value) == 4:
-            return tuple(map(lambda x: x / 255, value))
-        elif len(value) == 3:
-            return (*tuple(map(lambda x: x / 255, value)), 1.0)
-        else:
-            raise TypeError(f"{module}: Invalid number of values for {name}. Expected 3 or 4 values, got {len(value)} values")
-    elif isinstance(value, int) or isinstance(value, float):
-        v = value / 255
-        return (v, v, v, 1.0)
-    else:
-        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected tuple of size 3 or 4")
-
-def validate_rect(rect) -> tuple:
-    if not (isinstance(rect, tuple) or isinstance(rect, list) or isinstance(rect, np.ndarray)):
-        raise TypeError(f'Invalid rect type: {type(rect)}. Expected a tuple, list, or numpy array')
-    if len(rect) != 4:
-        raise TypeError(f'Invalid number of rect values. Expected 4 values, got {len(rect)}')
-    return list(rect)
-
-def validate_point(point) -> tuple:
-    if not (isinstance(point, tuple) or isinstance(point, list) or isinstance(point, np.ndarray)):
-        raise TypeError(f'Invalid rect type: {type(point)}. Expected a tuple, list, or numpy array')
-    if len(point) != 2:
-        raise TypeError(f'Invalid number of rect values. Expected 2 values, got {len(point)}')
+import numpy as np
+import glm
+from ..render.image import Image
+
+
+def validate_int(module: str, name: str, value: int | float | glm.int32) -> float:
+    if isinstance(value, int) or isinstance(value, float):
+        return int(round(value))
+    elif isinstance(value, glm.int32):
+        return int(value.value)
+    else:
+        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected float.")
+
+def validate_float(module: str, name: str, value: float | int | glm.float32) -> float:
+    if isinstance(value, float) or isinstance(value, int):
+        return float(value)
+    elif isinstance(value, glm.float32):
+        return float(value.value)
+    else:
+        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected float.")
+
+def validate_glm_float(module: str, name: str, value: float | int | glm.float32) -> glm.float32:
+    if isinstance(value, float) or isinstance(value, int):
+        return glm.float32(value)
+    elif isinstance(value, glm.float32):
+        return value
+    else:
+        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected glm.float32 or convertable value.")
+
+def validate_glm_vec3(module: str, name: str, value: tuple | list | glm.vec3 | np.ndarray) -> glm.vec3:
+    if isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
+        if len(value) != 3: raise ValueError(f"{module}: Invalid number of values for {name}. Expected 3 values, got {len(value)} values")
+        return glm.vec3(value)
+    elif isinstance(value, glm.vec3) or isinstance(value, int) or isinstance(value, float):
+        return glm.vec3(value)
+    else:
+        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected glm.vec3")
+
+def validate_tuple3(module: str, name: str, value: tuple | list | glm.vec3 | np.ndarray) -> tuple:
+    if isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
+        if len(value) != 3: raise ValueError(f"{module}: Invalid number of values for {name}. Expected 3 values, got {len(value)} values")
+        return tuple(value)
+    elif isinstance(value, glm.vec3):
+        return (value.x, value.y, value.z)
+    if isinstance(value, int) or isinstance(value, float):
+        return (value, value, value)
+    else:
+        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected tuple of size 3")
+
+def validate_image(module: str, name: str, value: Image | None) -> Image | None:
+    """Accepts none as a value for no image"""
+    if isinstance(value, Image) or isinstance(value, type(None)):
+        return value
+    else:
+        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected bsk.Image or None")
+    
+def validate_color(module: str, name: str, value: tuple | list | np.ndarray | int | float | None) -> tuple:
+    if isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
+        if len(value) == 4:
+            return tuple(map(lambda x: x / 255, value))
+        elif len(value) == 3:
+            return (*tuple(map(lambda x: x / 255, value)), 1.0)
+        else:
+            raise TypeError(f"{module}: Invalid number of values for {name}. Expected 3 or 4 values, got {len(value)} values")
+    elif isinstance(value, int) or isinstance(value, float):
+        v = value / 255
+        return (v, v, v, 1.0)
+    else:
+        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected tuple of size 3 or 4")
+
+def validate_rect(rect) -> tuple:
+    if not (isinstance(rect, tuple) or isinstance(rect, list) or isinstance(rect, np.ndarray)):
+        raise TypeError(f'Invalid rect type: {type(rect)}. Expected a tuple, list, or numpy array')
+    if len(rect) != 4:
+        raise TypeError(f'Invalid number of rect values. Expected 4 values, got {len(rect)}')
+    return list(rect)
+
+def validate_point(point) -> tuple:
+    if not (isinstance(point, tuple) or isinstance(point, list) or isinstance(point, np.ndarray)):
+        raise TypeError(f'Invalid rect type: {type(point)}. Expected a tuple, list, or numpy array')
+    if len(point) != 2:
+        raise TypeError(f'Invalid number of rect values. Expected 2 values, got {len(point)}')
     return list(point)

basilisk/generic/math.py

@@ -1,18 +1,18 @@
-import glm
-
-def triple_product(vector1, vector2, vector3) -> glm.vec3:
-    """
-    Computes (1 x 2) x 3
-    """
-    return glm.cross(glm.cross(vector1, vector2), vector3)
-
-def relative_transforms(parent, child) -> tuple[glm.vec3, glm.vec3, glm.quat]:
-    """
-    Calculates the relative transforms for position, scale, and rotation for the parent and child. parent and child are Nodes
-    """
-    relative = glm.inverse(parent.model_matrix) * child.model_matrix
-    position = glm.vec3(relative[3])
-    scale = glm.vec3([glm.length(relative[i]) for i in range(3)])
-    rotation = child.rotation.data * glm.inverse(parent.rotation.data)
-    
+import glm
+
+def triple_product(vector1, vector2, vector3) -> glm.vec3:
+    """
+    Computes (1 x 2) x 3
+    """
+    return glm.cross(glm.cross(vector1, vector2), vector3)
+
+def relative_transforms(parent, child) -> tuple[glm.vec3, glm.vec3, glm.quat]:
+    """
+    Calculates the relative transforms for position, scale, and rotation for the parent and child. parent and child are Nodes
+    """
+    relative = glm.inverse(parent.model_matrix) * child.model_matrix
+    position = glm.vec3(relative[3])
+    scale = glm.vec3([glm.length(relative[i]) for i in range(3)])
+    rotation = child.rotation.data * glm.inverse(parent.rotation.data)
+    
     return position, scale, rotation

basilisk/generic/matrices.py

@@ -1,36 +1,36 @@
-import glm
-from ..generic.vec3 import Vec3
-from ..generic.quat import Quat
-
-
-# transform matrices
-def get_model_matrix(position: Vec3, scale: Vec3, rotation: Quat) -> glm.mat4x4:
-    """
-    Gets projection matrix from object data
-    """
-    translation_matrix  = glm.translate(glm.mat4(1.0), position.data)
-    rotation_matrix     = glm.mat4_cast(rotation.data)
-    scale_matrix        = glm.scale(glm.mat4(1.0), scale.data)
-    model_matrix        = translation_matrix * glm.transpose(rotation_matrix) * scale_matrix
-    return model_matrix
-
-def get_scale_matrix(scale: glm.vec3) -> glm.mat3x3:
-    """
-    Gets the scaling matrix from a scale vector
-    """
-    return glm.mat3x3(
-        scale.x, 0, 0,
-        0, scale.y, 0,
-        0, 0, scale.z
-    )
-
-# inertia tensors
-def compute_inertia_moment(t:list[glm.vec3], i:int) -> float:
-    return t[0][i] ** 2 + t[1][i] * t[2][i] + \
-           t[1][i] ** 2 + t[0][i] * t[2][i] + \
-           t[2][i] ** 2 + t[0][i] * t[1][i]
-           
-def compute_inertia_product(t:list[glm.vec3], i:int, j:int) -> float:
-    return 2 * t[0][i] * t[0][j] + t[1][i] * t[2][j] + t[2][i] * t[1][j] + \
-           2 * t[1][i] * t[1][j] + t[0][i] * t[2][j] + t[2][i] * t[0][j] + \
+import glm
+from ..generic.vec3 import Vec3
+from ..generic.quat import Quat
+
+
+# transform matrices
+def get_model_matrix(position: Vec3, scale: Vec3, rotation: Quat) -> glm.mat4x4:
+    """
+    Gets projection matrix from object data
+    """
+    translation_matrix  = glm.translate(glm.mat4(1.0), position.data)
+    rotation_matrix     = glm.mat4_cast(rotation.data)
+    scale_matrix        = glm.scale(glm.mat4(1.0), scale.data)
+    model_matrix        = translation_matrix * glm.transpose(rotation_matrix) * scale_matrix
+    return model_matrix
+
+def get_scale_matrix(scale: glm.vec3) -> glm.mat3x3:
+    """
+    Gets the scaling matrix from a scale vector
+    """
+    return glm.mat3x3(
+        scale.x, 0, 0,
+        0, scale.y, 0,
+        0, 0, scale.z
+    )
+
+# inertia tensors
+def compute_inertia_moment(t:list[glm.vec3], i:int) -> float:
+    return t[0][i] ** 2 + t[1][i] * t[2][i] + \
+           t[1][i] ** 2 + t[0][i] * t[2][i] + \
+           t[2][i] ** 2 + t[0][i] * t[1][i]
+           
+def compute_inertia_product(t:list[glm.vec3], i:int, j:int) -> float:
+    return 2 * t[0][i] * t[0][j] + t[1][i] * t[2][j] + t[2][i] * t[1][j] + \
+           2 * t[1][i] * t[1][j] + t[0][i] * t[2][j] + t[2][i] * t[0][j] + \
            2 * t[2][i] * t[2][j] + t[0][i] * t[1][j] + t[1][i] * t[0][j]

basilisk/generic/meshes.py

@@ -1,73 +1,73 @@
-import glm
-import numpy as np
-
-
-# transformations
-def transform_points(points: np.ndarray, model_matrix: glm.mat4x4) -> list[glm.vec3]:
-    """
-    Transforms the mesh points to world space
-    """
-    return [model_matrix * pt for pt in points]
-
-# bvh
-def get_aabb_surface_area(top_right: glm.vec3, bottom_left: glm.vec3) -> float:
-    """
-    Returns the surface area of the AABB
-    """
-    diagonal = top_right - bottom_left
-    return 2 * (diagonal.x * diagonal.y + diagonal.y * diagonal.z + diagonal.x * diagonal.z)
-
-def get_extreme_points_np(points: np.ndarray) -> tuple[glm.vec3, glm.vec3]:
-    """
-    Returns the top right and bottom left points of the aabb encapsulating the points
-    """
-    top_right   = glm.vec3(-1e10)
-    bottom_left = glm.vec3(1e10)
-    for pt in points:
-        for i in range(3):
-            if top_right[i] < pt[i]: top_right[i] = pt[i]
-            if bottom_left[i] > pt[i]: bottom_left[i] = pt[i]
-    return top_right, bottom_left
-
-def get_aabb_line_collision(top_right:glm.vec3, bottom_left:glm.vec3, point:glm.vec3, vec:glm.vec3) -> bool:
-    """
-    Determines if a line has collided with an aabb
-    """
-    tmin, tmax = -1e10, 1e10
-    for i in range(3):
-        if vec[i] != 0:
-            inv_dir = 1.0 / vec[i]
-            t1 = (bottom_left[i] - point[i]) * inv_dir
-            t2 = (top_right[i]   - point[i]) * inv_dir
-            t1, t2 = min(t1, t2), max(t1, t2)
-            tmin   = max(tmin, t1)
-            tmax   = min(tmax, t2)
-            if tmin > tmax: return False
-        elif point[i] < bottom_left[i] or point[i] > top_right[i]: return False
-    return tmax >= 0 and tmin <= 1
-
-def moller_trumbore(point:glm.vec3, vec:glm.vec3, triangle:list[glm.vec3], epsilon:float=1e-7) -> glm.vec3 | None:
-    """
-    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
+import glm
+import numpy as np
+
+
+# transformations
+def transform_points(points: np.ndarray, model_matrix: glm.mat4x4) -> list[glm.vec3]:
+    """
+    Transforms the mesh points to world space
+    """
+    return [model_matrix * pt for pt in points]
+
+# bvh
+def get_aabb_surface_area(top_right: glm.vec3, bottom_left: glm.vec3) -> float:
+    """
+    Returns the surface area of the AABB
+    """
+    diagonal = top_right - bottom_left
+    return 2 * (diagonal.x * diagonal.y + diagonal.y * diagonal.z + diagonal.x * diagonal.z)
+
+def get_extreme_points_np(points: np.ndarray) -> tuple[glm.vec3, glm.vec3]:
+    """
+    Returns the top right and bottom left points of the aabb encapsulating the points
+    """
+    top_right   = glm.vec3(-1e10)
+    bottom_left = glm.vec3(1e10)
+    for pt in points:
+        for i in range(3):
+            if top_right[i] < pt[i]: top_right[i] = pt[i]
+            if bottom_left[i] > pt[i]: bottom_left[i] = pt[i]
+    return top_right, bottom_left
+
+def get_aabb_line_collision(top_right:glm.vec3, bottom_left:glm.vec3, point:glm.vec3, vec:glm.vec3) -> bool:
+    """
+    Determines if a line has collided with an aabb
+    """
+    tmin, tmax = -1e10, 1e10
+    for i in range(3):
+        if vec[i] != 0:
+            inv_dir = 1.0 / vec[i]
+            t1 = (bottom_left[i] - point[i]) * inv_dir
+            t2 = (top_right[i]   - point[i]) * inv_dir
+            t1, t2 = min(t1, t2), max(t1, t2)
+            tmin   = max(tmin, t1)
+            tmax   = min(tmax, t2)
+            if tmin > tmax: return False
+        elif point[i] < bottom_left[i] or point[i] > top_right[i]: return False
+    return tmax >= 0 and tmin <= 1
+
+def moller_trumbore(point:glm.vec3, vec:glm.vec3, triangle:list[glm.vec3], epsilon:float=1e-7) -> glm.vec3 | None:
+    """
+    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