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

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: ...
@@ -27,8 +28,9 @@ class DrawHandler():
         self.engine = scene.engine
         self.ctx    = scene.engine.ctx
 
-        # Get the program
-        self.program = self.scene.shader_handler.shaders['draw'].program
+        # 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,4 +1,5 @@
 import os
+from sys import platform
 os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
 import pygame as pg
 import moderngl as mgl
@@ -36,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:
@@ -49,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
 
@@ -57,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)
@@ -93,6 +101,7 @@ class Engine():
 
         # 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
@@ -107,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()
@@ -130,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:
         """
@@ -179,9 +189,8 @@ class Engine():
         self._scene = value
         if self._scene: 
             self._scene.set_engine(self)
-            self.shader.use()
 
     @shader.setter
     def shader(self, value):
         self._shader = value
-        if self.scene: value.use()
+        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

basilisk/generic/quat.py

@@ -1,82 +1,86 @@
 import glm
 import numpy as np
+from .abstract_custom import Custom
 
 
-class Quat():
+class Quat(Custom):
     def __init__(self, *args, callback=None):
         self.callback = callback
         self.prev_data = glm.quat(1, 0, 0, 0)
-        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.prev_data = glm.quat(args[0].prev_data)
                 self.callback = args[0].callback
-            elif isinstance(args[0], glm.quat): self.data = glm.quat(args[0])
+                
+            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): 
-                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])}')
+                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: 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')
+                
+            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)
 
-    # 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
+    # unary operators
+    def __neg__(self):
+        return Quat(-self.data, callback=self.callback)
     
-    def __idiv__(self, other): 
-        # TODO add checks for number types
-        self.data /= other
-        return self
+    def __abs__(self):
+        return Quat(abs(self.data), callback=self.callback)
     
-    def __ifloordiv__(self, other): 
-        # TODO add checks for number types
-        self.data //= other
-        return self
-    
-    # override [_] accessor
+    # accessor functions
     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}')
+        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): 
-        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}')
+        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)
 
@@ -95,33 +99,40 @@ class Quat():
     def z(self): return self.data.z
     
     @data.setter
-    def data(self, value: glm.vec3):
-        self._data = value
-        
+    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 = self._data            
+            self.prev_data = glm.quat(self._data)            
             self.callback()
         
     @w.setter
     def w(self, value):
         self.data.w = value
-        if self.callback: self.callback()
+        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: self.callback()
+        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: self.callback()
+        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: self.callback()
+        self._data.z = value
+        if self.callback and abs(value - self.prev_data.z) > 1e-6: 
+            self.prev_data.z = value
+            self.callback()