basilisk-engine 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

basilisk/generic/abstract_custom.py

@@ -1,134 +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): 
+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

@@ -1,73 +1,73 @@
-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
-    """
-    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: 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
+    """
+    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: 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,67 +1,67 @@
-import numpy as np
-import glm
-from ..render.image import Image
-
-
-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_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_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_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,7 +1,7 @@
-import glm
-
-def triple_product(vector1, vector2, vector3) -> glm.vec3:
-    """
-    Computes (1 x 2) x 3
-    """
+import glm
+
+def triple_product(vector1, vector2, vector3) -> glm.vec3:
+    """
+    Computes (1 x 2) x 3
+    """
     return glm.cross(glm.cross(vector1, vector2), vector3)

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]