basilisk-engine 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

basilisk/draw/draw.py

@@ -0,0 +1,101 @@
+from ..engine import Engine
+from ..render.image import Image
+
+def rect(engine: Engine, color: tuple, rect: tuple) -> None:
+    """
+    Draws a rectagle to the screen
+    Args:
+        engine: bsk.Engine
+            The destination engine for the rectangle
+        color: tuple(r, g, b) | tuple(r, g, b, a)
+            The color value of the rectangle, with int components in range [0, 255]
+        rect: tuple(x, y, w, h)
+            The screen position and size of the rectangle given in pixels
+    """
+    
+    # Get the draw handler from the engine
+    draw_handler = engine.scene.draw_handler
+    if not draw_handler: return
+
+    # Draw the rect
+    draw_handler.draw_rect(color, rect)
+
+
+def circle(engine: Engine, color: tuple, center: tuple, radius: int, resolution: int=20, outer_color: tuple=None) -> None:
+    """
+    Draws a rect between centered on x, y with width and height
+        Args:
+            color: tuple(r, g, b) | tuple(r, g, b, a)
+                The color value of the circle, with int components in range [0, 255]
+            center: tuple (x: float, y: float)
+                Center of the circle, given in pixels
+            radius: float
+                Radius of the circle, given in pixels
+            resolution: float
+                    The number of triangles used to approximate the circle
+    """
+    
+    # Get the draw handler from the engine
+    draw_handler = engine.scene.draw_handler
+    if not draw_handler: return
+
+    # Draw the circle
+    draw_handler.draw_circle(color, center, radius, resolution, outer_color)
+
+def line(engine: Engine, color: tuple, p1: tuple, p2: tuple, thickness: int=1) -> None:
+    """
+    Draws a line between two points
+        Args:
+            color: tuple=(r, g, b) | tuple=(r, g, b, a)
+                Color of the line
+            p1: tuple=((x1, y1), (x2, y2))
+                Starting point of the line. Given in pixels
+            p1: tuple=((x1, y1), (x2, y2))
+                Starting point of the line. Given in pixels
+            thickness: int
+                Size of the line on either side. pixels
+    """
+    
+    # Get the draw handler from the engine
+    draw_handler = engine.scene.draw_handler
+    if not draw_handler: return
+
+    # Draw the line
+    draw_handler.draw_line(color, p1, p2, thickness)
+
+def blit(engine: Engine, image: Image, rect: tuple):
+    """
+    Blits a basilisk image to the engine screen.
+    Args:
+        image: bsk.Image
+            The image to display on the screen
+        rect: tuple(x, y, w, h)
+            The screen position and size of the image given in pixels
+    """
+
+    # Get the draw handler from the engine
+    draw_handler = engine.scene.draw_handler
+    if not draw_handler: return
+
+    engine.scene.material_handler.image_handler.add(image)
+
+    # Blit the image
+    draw_handler.blit(image, rect)
+
+def text(engine: Engine, text: str, position: tuple, scale: float=1.0):
+    """
+    Renders text do the screen
+    USE SPARINGLY, INEFFICIENT IMPLAMENTATION
+    """
+    
+    font_renderer = engine.scene.draw_handler.font_renderer
+
+    # Render the text if it has not been cached
+    if text not in font_renderer.text_renders:
+        surf = font_renderer.render(text).convert_alpha()
+        text_image = Image(surf)
+        font_renderer.text_renders[text] = (text_image, surf.get_rect())
+    
+    # Blit the text image
+    img, rect = font_renderer.text_renders[text]
+    blit(engine, img, (position[0] - rect[2] * scale / 2, position[1] - rect[3] * scale / 2, rect[2] * scale, rect[3] * scale))

basilisk/draw/draw_handler.py

@@ -0,0 +1,208 @@
+import moderngl as mgl
+import numpy as np
+import glm
+from math import cos, sin, atan2
+from ..render.image import Image
+from .font_renderer import FontRenderer
+
+class DrawHandler():
+    engine: ...
+    """Back reference to the parent engine"""
+    scene: ...
+    """Back reference to the parent scene"""
+    ctx: mgl.Context
+    """Back reference to the parent context"""
+    program: mgl.Program
+    """2D draw program"""
+    draw_data: list[float]
+    """Temporary buffer for user draw calls"""
+    vbo: mgl.Buffer
+    """Buffer for all 2D draws"""
+    vao: mgl.VertexArray
+    """VAO for rendering all 2D draw calls"""
+    
+    def __init__(self, scene) -> None:
+        # Back references
+        self.scene  = scene
+        self.engine = scene.engine
+        self.ctx    = scene.engine.ctx
+
+        # Get the program
+        self.program = self.scene.shader_handler.programs['draw']
+
+        # Initialize draw data as blank
+        self.draw_data = []
+        self.vbo = None
+        self.vao = None
+
+        self.font_renderer = FontRenderer(self.engine.root)
+
+    def render(self) -> None:
+        """
+        Renders all draw calls from the user since the last frame
+        """
+        
+        if not self.draw_data: return
+
+        # Reverse the draw order, and convert to C-like array
+        self.draw_data.reverse()
+        data = np.array(self.draw_data, dtype='f4')
+        ratio = np.array([2 / self.engine.win_size[0], 2 / self.engine.win_size[1]])
+        data[:,:2] = data[:,:2] * ratio - 1
+
+        # 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)
+
+        # Render the VAO
+        self.ctx.enable(mgl.BLEND)
+        self.ctx.blend_equation = mgl.ADDITIVE_BLENDING
+        self.vao.render()
+
+        # Clera the draw data
+        self.vbo.release()
+        self.vao.release()
+        self.vbo = None
+        self.vao = None
+        self.draw_data.clear()
+
+    def draw_rect(self, color: tuple, rect: tuple) -> None:
+        """
+        Draws a rect to the screen
+        """
+
+        color = validate_color(color)
+        rect  = validate_rect(rect)
+
+        p1 = (rect[0]          , rect[1]          )
+        p2 = (rect[0]          , rect[1] + rect[3])
+        p3 = (rect[0] + rect[2], rect[1]          )
+        p4 = (rect[0] + rect[2], rect[1] + rect[3])
+
+        v1 = (*p1, *color, 0)
+        v2 = (*p2, *color, 0)
+        v3 = (*p3, *color, 0)
+        v4 = (*p4, *color, 0)
+
+        self.draw_data.extend([
+            v1, v3, v2,
+            v2, v3, v4
+        ])
+
+    def draw_circle(self, color: tuple, center: tuple, radius: int, resolution: int=20, outer_color: tuple=None) -> None:
+        """
+        Draws a rect between centered on x, y with width and height
+            Args:
+                color: tuple(r, g, b) | tuple(r, g, b, a)
+                    The color value of the circle, with int components in range [0, 255]
+                center: tuple (x: float, y: float)
+                    Center of the circle, given in pixels
+                radius: float
+                    Radius of the circle, given in pixels
+                resolution: float
+                    The number of triangles used to approximate the circle
+        """
+
+        if not outer_color: outer_color = color
+        color  = validate_color(color)
+        outer_color  = validate_color(outer_color)
+        p1 = validate_point(center)
+
+        v1 = (*p1, *color, 0)
+        theta = 0
+        delta_theta = (2 * 3.1415) / resolution
+
+        for triangle in range(resolution):
+            v2 = (center[0] + radius * cos(theta), center[1] + radius * sin(theta), *outer_color, 0)
+            theta += delta_theta
+            v3 = (center[0] + radius * cos(theta), center[1] + radius * sin(theta), *outer_color, 0)
+            self.draw_data.extend([v1, v2, v3])
+
+    def draw_line(self, color: tuple, p1: tuple, p2: tuple, thickness: int=1):
+        """
+        Draws a line between two points
+            Args:
+                color: tuple=(r, g, b) | tuple=(r, g, b, a)
+                    Color of the line
+                p1: tuple=((x1, y1), (x2, y2))
+                    Starting point of the line. Given in pixels
+                p1: tuple=((x1, y1), (x2, y2))
+                    Starting point of the line. Given in pixels
+                thickness: int
+                    Size of the line on either side. pixels
+        """
+        
+        color = validate_color(color)
+
+        p1 = glm.vec2(validate_point(p1))
+        p2 = glm.vec2(validate_point(p2))
+
+        thickness /= 2
+
+        unit = glm.normalize(p1 - p2) * thickness
+        theta = atan2(*unit)
+        perp_vector = glm.vec2(cos(-theta), sin(-theta)) * thickness
+
+        v1 = (*(p1 - perp_vector), *color, 0)
+        v2 = (*(p1 + perp_vector), *color, 0)
+        v3 = (*(p2 - perp_vector), *color, 0)
+        v4 = (*(p2 + perp_vector), *color, 0)
+        
+        self.draw_data.extend([v1, v3, v4, v2, v1, v4])
+
+    def blit(self, image: Image, rect: tuple):
+        rect  = validate_rect(rect)
+
+        p1 = (rect[0]          , rect[1]          )
+        p2 = (rect[0]          , rect[1] + rect[3])
+        p3 = (rect[0] + rect[2], rect[1]          )
+        p4 = (rect[0] + rect[2], rect[1] + rect[3])
+
+        v1 = (*p1, *image.index, 0, 0, 1)
+        v2 = (*p2, *image.index, 0, 1, 1)
+        v3 = (*p3, *image.index, 1, 0, 1)
+        v4 = (*p4, *image.index, 1, 1, 1)
+
+        self.draw_data.extend([
+            v1, v3, v2,
+            v2, v3, v4
+        ])
+
+    def __del__(self) -> None:
+        """
+        Releases any allocated data
+        """
+        
+        if self.vbo: self.vbo.release()
+        if self.vao: self.vao.release()
+
+
+def validate_color(color):
+    if not (isinstance(color, tuple) or isinstance(color, list) or isinstance(color, np.ndarray)):
+        raise TypeError(f'Invalid color type: {type(color)}. Expected a tuple, list, or numpy array')
+    if len(color) == 4:
+        color = (color[0] / 255.0, color[1] / 255.0, color[2] / 255.0, color[3] / 255.0)
+    elif len(color) == 3:
+        color = (color[0] / 255.0, color[1] / 255.0, color[2] / 255.0, 1.0)
+    else:
+        raise TypeError(f'Invalid number of color values. Expected 3 or 4 values, got {len(color)}')
+    return color
+
+def validate_rect(rect):
+    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):
+    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)
+
+def validate_image(image):
+    if not (isinstance(image, Image)):
+        raise TypeError(f'Invalid imgae type: {type(image)}. Expected a bask.Image.')
+    return image

basilisk/draw/font_renderer.py

@@ -0,0 +1,28 @@
+import pygame as pg
+
+class FontRenderer():
+    def __init__(self, root):
+        pg.font.init()
+        self.font = pg.font.Font(root + '/draw/Roboto-Regular.ttf', 48)
+        self.text_renders = {}
+
+    def render(self, text, color=(255, 255, 255), bold=False, underline=False, italic=False):
+        '''
+        Renders any font which has been loaded to the class instance.
+        Args:
+            text::str
+                Text to be rendered
+            color::(int, int, int) =(255, 255, 255)
+                The RGB value of the text
+            bold::bool (=False)
+                Specifies if the text should be rendered in bolded font
+            underline::bool (=False)
+                Specifies if the text should be underlined in bolded font
+            italic::bool (=False)
+                Specifies if the text should be rendered in italicized font
+        '''
+        self.font.set_bold(bold)
+        self.font.set_underline(underline)
+        self.font.set_italic(italic)
+
+        return self.font.render(text, True, color, (0, 0, 0, 0))

basilisk/generic/abstract_bvh.py

@@ -0,0 +1,16 @@
+import glm
+
+
+class AbstractAABB():
+    top_right: glm.vec3
+    """The furthest positive corner of the AABB"""
+    bottom_left: glm.vec3
+    """The furthest negative corner of the AABB"""
+    a: ...
+    """Binary child 1"""
+    b: ...
+    """Binary child 2"""
+        
+class AbstractBVH():
+    root: AbstractAABB
+    """Root aabb used for the start of all collisions"""

basilisk/generic/collisions.py

@@ -0,0 +1,26 @@
+import glm
+
+
+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 get_sat_axes(rotation1: glm.quat, rotation2: glm.quat) -> list[glm.vec3]:
+    """
+    Gets the axes for SAT from obb rotation matrices
+    """
+    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])
+            axes.append(glm.normalize(cross))
+            
+    return axes

basilisk/generic/input_validation.py

@@ -0,0 +1,28 @@
+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):
+        return glm.vec3(value)
+    else:
+        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected glm.vec3")
+
+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")

basilisk/generic/math.py

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

@@ -0,0 +1,34 @@
+import glm
+
+
+# transform matrices
+def get_model_matrix(position: glm.vec3, scale: glm.vec3, rotation: glm.quat) -> glm.mat4x4:
+    """
+    Gets projection matrix from object data
+    """
+    translation_matrix  = glm.translate(glm.mat4(1.0), position)
+    rotation_matrix     = glm.mat4_cast(rotation)
+    scale_matrix        = glm.scale(glm.mat4(1.0), scale)
+    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

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

basilisk/generic/quat.py

@@ -0,0 +1,119 @@
+import glm
+import numpy as np
+
+
+class Quat():
+    def __init__(self, *args, callback=None):
+        self.callback = callback
+        self.set_data(*args)
+       
+    def normalize(self):
+        """
+        Inplace normalizes the vector
+        """
+        self.data = glm.normalize(self.data)
+        
+    def set_data(self, *args):
+        """
+        Sets the internal vector inplace
+        """
+        # overload constructor TODO nvernest this, definitely possible
+        if len(args) == 1:
+            if isinstance(args[0], Quat):
+                self.data = glm.quat(args[0].data)
+                self.callback = args[0].callback
+            elif isinstance(args[0], glm.quat): self.data = glm.quat(args[0])
+            elif isinstance(args[0], tuple) or isinstance(args[0], list) or isinstance(args[0], np.ndarray): 
+                if len(args[0]) != 4 and len(args[0]) != 3: raise ValueError(f'Quat: Expected 3 or 4 values from incoming vector, got {len(args[0])}')
+                self.data = glm.quat(args[0])
+            else: raise ValueError(f'Quat: Unexpected incoming vector type {args[0]}')
+        elif len(args) == 4: self.data = glm.quat(*args)
+        else: raise ValueError(f'Quat: Expected either 1 vector or 4 numbers, got {len(args)} values')
+
+    # override _= operators
+    def __iadd__(self, other):
+        if isinstance(other, glm.quat): self.data += other
+        elif isinstance(other, tuple) or isinstance(other, list) or isinstance(other, np.ndarray):
+            if len(other) != 4 and len(other) != 3: raise ValueError(f'Quat: Number of added values must be 3 or 4, got {len(other)}')
+            self.data += other
+        elif isinstance(other, Quat): self.data += other.data
+        else: raise ValueError(f'Quat: Not an accepted type for addition, got {type(other)}')
+        return self
+    
+    def __isub__(self, other):
+        if isinstance(other, glm.quat): self.data -= other
+        elif isinstance(other, tuple) or isinstance(other, list) or isinstance(other, np.ndarray):
+            if len(other) != 4 and len(other) != 3: raise ValueError(f'Quat: Number of added values must be 3 or 4, got {len(other)}')
+            self.data -= other
+        elif isinstance(other, Quat): self.data -= other.data
+        else: raise ValueError(f'Quat: Not an accepted type for addition, got {type(other)}')
+        return self
+    
+    def __imul__(self, other):
+        # TODO add checks for number types
+        self.data *= other
+        return self
+    
+    def __idiv__(self, other): 
+        # TODO add checks for number types
+        self.data /= other
+        return self
+    
+    def __ifloordiv__(self, other): 
+        # TODO add checks for number types
+        self.data //= other
+        return self
+    
+    # override [_] accessor
+    def __getitem__(self, index): 
+        if int(index) != index: raise IndexError(f'Quat: index must be an int, got {type(index)}') # check if index is a float
+        if index < 0 or index > 3: raise IndexError(f'Quat: index out of bounds, got {index}')
+        return self.data[index]
+    
+    def __setitem__(self, index, value): 
+        if int(index) != index: raise IndexError(f'Quat: index must be an int, got {type(index)}') # check if index is a float
+        if index < 0 or index > 3: raise IndexError(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 __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.quat):
+        self._data = value
+        if self.callback and all(abs(self.data[i] - value[i]) > 1e-12 for i in range(4)): self.callback()
+        
+    @w.setter
+    def w(self, value):
+        self.data.w = value
+        if self.callback: self.callback()
+
+    @x.setter
+    def x(self, value):
+        self.data.x = value
+        if self.callback: self.callback()
+        
+    @y.setter
+    def y(self, value):
+        self.data.y = value
+        if self.callback: self.callback()
+        
+    @z.setter
+    def z(self, value):
+        self.data.z = value
+        if self.callback: self.callback()

basilisk/generic/quat_methods.py

@@ -0,0 +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
+    """
+    return vec * quat