basilisk-engine 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

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

basilisk/generic/quat.py

@@ -1,138 +1,138 @@
-import glm
-import numpy as np
-from .abstract_custom import Custom
-
-
-class Quat(Custom):
-    def __init__(self, *args, callback=None):
-        self.callback = callback
-        self.prev_data = glm.quat(1, 0, 0, 0)
-        
-        if len(args) == 1:
-            
-            if isinstance(args[0], Quat):
-                self.data = glm.quat(args[0].data)
-                self.prev_data = glm.quat(args[0].prev_data)
-                self.callback = args[0].callback
-                
-            elif isinstance(args[0], glm.quat): 
-                self.data = args[0]
-                
-            elif isinstance(args[0], tuple) or isinstance(args[0], list) or isinstance(args[0], np.ndarray): 
-                assert 2 < len(args[0]) < 5, f'Quat: Expected 3 or 4 values from incoming vector, got {len(args[0])}'
-                self.data = glm.quat(args[0])
-                
-            else: 
-                try: self.data = glm.quat(args[0])
-                except: raise ValueError(f'Quat: Unexpected incoming quaternion type {args[0]}')
-            
-        elif 2 < len(args) < 5: self.data = glm.quat(*args)
-        else: raise ValueError(f'Quat: Expected either a vector, quaternion, or 3 or 4 numbers, got {len(args)} values')
-        
-    def apply_function(self, other, func, func_name):
-        quat = glm.quat(self.data)
-        
-        if isinstance(other, (glm.vec3, glm.quat)):
-            quat = func(quat, other)
-            
-        elif isinstance(other, (tuple, list, np.ndarray)):
-            assert 2 < len(other) < 5, f'Quat: Expected 3 or 4 values from incoming vector, got {len(other)}'
-            quat = func(quat, other)
-            
-        elif isinstance(other, Custom):
-            quat = func(quat, other.data)
-            
-        else: 
-            try: quat = func(quat, other)
-            except: raise ValueError(f'Quat: Not an accepted type for {func_name}, got {type(other)}')
-        return Quat(quat)
-
-    # unary operators
-    def __neg__(self):
-        return Quat(-self.data, callback=self.callback)
-    
-    def __abs__(self):
-        return Quat(abs(self.data), callback=self.callback)
-    
-    # accessor functions
-    def __getitem__(self, index): 
-        assert int(index) == index, f'Quat: index must be an int, got {type(index)}' # check if index is a float
-        assert 0 <= index <= 3, f'Quat: index out of bounds, got {index}'
-        return self.data[index]
-    
-    def __setitem__(self, index, value): 
-        assert int(index) == index, f'Quat: index must be an int, got {type(index)}' # check if index is a float
-        assert 0 <= index <= 3, f'Quat: index out of bounds, got {index}'
-        try: self.data[index] = value
-        except: raise ValueError(f'Quat: Invalid element type, got {type(value)}')
-        
-    def __delitem__(self, index): # cannot delete an index from a quaternion, so we set the value to zero instead
-        assert int(index) == index, f'Quat: index must be an int, got {type(index)}' # check if index is a float
-        assert 0 <= index <= 3, f'Quat: index out of bounds, got {index}'
-        self.data[index] = 0
-        
-    def __len__(self):
-        return 4
-    
-    def __iter__(self):
-        return iter(self.data)
-    
-    def __contains__(self, item):
-        return item in self.data
-
-    # override str operators
-    def __repr__(self):
-        return str(self.data)
-
-    def __iter__(self):
-        return iter((self.x, self.y, self.z))
-    
-    @property
-    def data(self): return self._data
-    @property
-    def w(self): return self.data.w
-    @property
-    def x(self): return self.data.x
-    @property
-    def y(self): return self.data.y
-    @property
-    def z(self): return self.data.z
-    
-    @data.setter
-    def data(self, value: glm.vec3 | glm.quat):
-        self._data = glm.quat(value)
-        cur = self._data
-        prev = self.prev_data
-        thresh = 1e-6
-        
-        if self.callback and (abs(cur.w - prev.w) > thresh or abs(cur.x - prev.x) > thresh or abs(cur.y - prev.y) > thresh or abs(cur.z - prev.z) > thresh): 
-            self.prev_data = glm.quat(self._data)            
-            self.callback()
-        
-    @w.setter
-    def w(self, value):
-        self.data.w = value
-        if self.callback and abs(value - self.prev_data.w) > 1e-6: 
-            self.prev_data.w = value
-            self.callback()
-
-    @x.setter
-    def x(self, value):
-        self._data.x = value
-        if self.callback and abs(value - self.prev_data.x) > 1e-6: 
-            self.prev_data.x = value
-            self.callback()
-        
-    @y.setter
-    def y(self, value):
-        self._data.y = value
-        if self.callback and abs(value - self.prev_data.y) > 1e-6: 
-            self.prev_data.y = value
-            self.callback()
-        
-    @z.setter
-    def z(self, value):
-        self._data.z = value
-        if self.callback and abs(value - self.prev_data.z) > 1e-6: 
-            self.prev_data.z = value
+import glm
+import numpy as np
+from .abstract_custom import Custom
+
+
+class Quat(Custom):
+    def __init__(self, *args, callback=None):
+        self.callback = callback
+        self.prev_data = glm.quat(1, 0, 0, 0)
+        
+        if len(args) == 1:
+            
+            if isinstance(args[0], Quat):
+                self.data = glm.quat(args[0].data)
+                self.prev_data = glm.quat(args[0].prev_data)
+                self.callback = args[0].callback
+                
+            elif isinstance(args[0], glm.quat): 
+                self.data = args[0]
+                
+            elif isinstance(args[0], tuple) or isinstance(args[0], list) or isinstance(args[0], np.ndarray): 
+                assert 2 < len(args[0]) < 5, f'Quat: Expected 3 or 4 values from incoming vector, got {len(args[0])}'
+                self.data = glm.quat(args[0])
+                
+            else: 
+                try: self.data = glm.quat(args[0])
+                except: raise ValueError(f'Quat: Unexpected incoming quaternion type {args[0]}')
+            
+        elif 2 < len(args) < 5: self.data = glm.quat(*args)
+        else: raise ValueError(f'Quat: Expected either a vector, quaternion, or 3 or 4 numbers, got {len(args)} values')
+        
+    def apply_function(self, other, func, func_name):
+        quat = glm.quat(self.data)
+        
+        if isinstance(other, (glm.vec3, glm.quat)):
+            quat = func(quat, other)
+            
+        elif isinstance(other, (tuple, list, np.ndarray)):
+            assert 2 < len(other) < 5, f'Quat: Expected 3 or 4 values from incoming vector, got {len(other)}'
+            quat = func(quat, other)
+            
+        elif isinstance(other, Custom):
+            quat = func(quat, other.data)
+            
+        else: 
+            try: quat = func(quat, other)
+            except: raise ValueError(f'Quat: Not an accepted type for {func_name}, got {type(other)}')
+        return Quat(quat)
+
+    # unary operators
+    def __neg__(self):
+        return Quat(-self.data, callback=self.callback)
+    
+    def __abs__(self):
+        return Quat(abs(self.data), callback=self.callback)
+    
+    # accessor functions
+    def __getitem__(self, index): 
+        assert int(index) == index, f'Quat: index must be an int, got {type(index)}' # check if index is a float
+        assert 0 <= index <= 3, f'Quat: index out of bounds, got {index}'
+        return self.data[index]
+    
+    def __setitem__(self, index, value): 
+        assert int(index) == index, f'Quat: index must be an int, got {type(index)}' # check if index is a float
+        assert 0 <= index <= 3, f'Quat: index out of bounds, got {index}'
+        try: self.data[index] = value
+        except: raise ValueError(f'Quat: Invalid element type, got {type(value)}')
+        
+    def __delitem__(self, index): # cannot delete an index from a quaternion, so we set the value to zero instead
+        assert int(index) == index, f'Quat: index must be an int, got {type(index)}' # check if index is a float
+        assert 0 <= index <= 3, f'Quat: index out of bounds, got {index}'
+        self.data[index] = 0
+        
+    def __len__(self):
+        return 4
+    
+    def __iter__(self):
+        return iter(self.data)
+    
+    def __contains__(self, item):
+        return item in self.data
+
+    # override str operators
+    def __repr__(self):
+        return str(self.data)
+
+    def __iter__(self):
+        return iter((self.x, self.y, self.z))
+    
+    @property
+    def data(self): return self._data
+    @property
+    def w(self): return self.data.w
+    @property
+    def x(self): return self.data.x
+    @property
+    def y(self): return self.data.y
+    @property
+    def z(self): return self.data.z
+    
+    @data.setter
+    def data(self, value: glm.vec3 | glm.quat):
+        self._data = glm.quat(value)
+        cur = self._data
+        prev = self.prev_data
+        thresh = 1e-6
+        
+        if self.callback and (abs(cur.w - prev.w) > thresh or abs(cur.x - prev.x) > thresh or abs(cur.y - prev.y) > thresh or abs(cur.z - prev.z) > thresh): 
+            self.prev_data = glm.quat(self._data)            
+            self.callback()
+        
+    @w.setter
+    def w(self, value):
+        self.data.w = value
+        if self.callback and abs(value - self.prev_data.w) > 1e-6: 
+            self.prev_data.w = value
+            self.callback()
+
+    @x.setter
+    def x(self, value):
+        self._data.x = value
+        if self.callback and abs(value - self.prev_data.x) > 1e-6: 
+            self.prev_data.x = value
+            self.callback()
+        
+    @y.setter
+    def y(self, value):
+        self._data.y = value
+        if self.callback and abs(value - self.prev_data.y) > 1e-6: 
+            self.prev_data.y = value
+            self.callback()
+        
+    @z.setter
+    def z(self, value):
+        self._data.z = value
+        if self.callback and abs(value - self.prev_data.z) > 1e-6: 
+            self.prev_data.z = value
             self.callback()

basilisk/generic/quat_methods.py

@@ -1,8 +1,8 @@
-import glm
-
-
-def rotate_vec_by_quat(vec: glm.vec3, quat: glm.quat) -> glm.vec3:
-    """
-    Rotates a vector by a quaternion. Probably just dont use this, just a reminder of how glm works with quaternions
-    """
+import glm
+
+
+def rotate_vec_by_quat(vec: glm.vec3, quat: glm.quat) -> glm.vec3:
+    """
+    Rotates a vector by a quaternion. Probably just dont use this, just a reminder of how glm works with quaternions
+    """
     return vec * quat

basilisk/generic/raycast_result.py

@@ -0,0 +1,24 @@
+import glm
+from ..nodes.node import Node
+
+
+class RaycastResult:
+    node: Node | None
+    """The node that the raycast hit. Is None if no object was hit"""
+    position: glm.vec3
+    """The node that the raycast hit"""
+
+    def __init__(self, node: Node | None, position: glm.vec3):
+        """
+        Container for returning raycast results.
+        Contains the node hit and the global position the raycast hit at.
+        """
+        
+        self.node = node
+        self.position = position
+
+    def __bool__(self):
+        return bool(self.node)
+
+    def __repr__(self):
+        return f'<Raycast | Node: {self.node}, Position: {self.position}>'