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

basilisk/generic/quat.py

@@ -1,81 +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.set_data(*args)
-       
-    def normalize(self):
-        """
-        Inplace normalizes the vector
-        """
-        self.data = glm.normalize(self.data)
+        self.prev_data = glm.quat(1, 0, 0, 0)
         
-    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
+    # unary operators
+    def __neg__(self):
+        return Quat(-self.data, callback=self.callback)
     
-    def __imul__(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 __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
+    # 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)
 
@@ -94,26 +99,40 @@ class Quat():
     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()
+    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: 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()

basilisk/generic/vec3.py

@@ -1,86 +1,90 @@
 import glm
 import numpy as np
+from .abstract_custom import Custom
 
-
-class Vec3():
+class Vec3(Custom):
     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)
+        self.prev_data = glm.vec3(0.0)
         
-    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], Vec3):
                 self.data = glm.vec3(args[0].data)
+                self.prev_data = glm.vec3(args[0].prev_data)
                 self.callback = args[0].callback
-            elif isinstance(args[0], glm.vec3): self.data = glm.vec3(args[0])
+                
+            elif isinstance(args[0], glm.vec3): 
+                self.data = args[0]
+                
             elif isinstance(args[0], tuple) or isinstance(args[0], list) or isinstance(args[0], np.ndarray): 
-                if len(args[0]) != 3: raise ValueError(f'Vec3: Expected 3 values from incoming vector, got {len(args[0])}')
+                assert len(args[0]) == 3, f'Vec3: Expected 3 values from incoming vector, got {len(args[0])}'
                 self.data = glm.vec3(args[0])
-            else: raise ValueError(f'Vec3: Unexpected incoming vector type {args[0]}')
-        elif len(args) == 3: self.data = glm.vec3(args[0], args[1], args[2])
+                
+            else: 
+                try: self.data = glm.vec3(args[0])
+                except: raise ValueError(f'Vec3: Unexpected incoming vector type {args[0]}')
+            
+        elif len(args) == 3: self.data = glm.vec3(*args)
         else: raise ValueError(f'Vec3: Expected either 1 vector or 3 numbers, got {len(args)} values')
-
-    # override _= operators
-    def __iadd__(self, other):
-        if isinstance(other, glm.vec3): self.data += other
-        elif isinstance(other, tuple) or isinstance(other, list) or isinstance(other, np.ndarray):
-            if len(other) != 3: raise ValueError(f'Vec3: Number of added values must be 3, got {len(other)}')
-            self.data += other
-        elif isinstance(other, Vec3): self.data += other.data
-        else: raise ValueError(f'Vec3: Not an accepted type for addition, got {type(other)}')
-        return self
-    
-    def __isub__(self, other):
-        if isinstance(other, glm.vec3): self.data -= other
+       
+    def apply_function(self, other, func, func_name):
+        vec = glm.vec3(self.data)
+        
+        if isinstance(other, (glm.vec3, glm.quat)): 
+            vec = func(vec, other) 
+            
         elif isinstance(other, tuple) or isinstance(other, list) or isinstance(other, np.ndarray):
-            if len(other) != 3: raise ValueError(f'Vec3: Number of added values must be 3, got {len(other)}')
-            self.data -= other
-        elif isinstance(other, Vec3): self.data -= other.data
-        else: raise ValueError(f'Vec3: 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
+            assert len(other) == 3, f'Vec3: Number of added values must be 3, got {len(other)}'
+            vec = func(vec, other) 
+            
+        elif isinstance(other, Custom): # perserve self.callback over other.callback. this should never be done by the user
+            vec = func(vec, other.data) 
+            
+        else: 
+            try: vec = func(vec, other) 
+            except: raise ValueError(f'Vec3: Not an accepted type for {func_name}, got {type(other)}')
+        return Vec3(vec)
+        
+    # unary operators
+    def __neg__(self):
+        return Vec3(-self.data, callback=self.callback)
     
-    def __ifloordiv__(self, other): 
-        # TODO add checks for number types
-        self.data //= other
-        return self
+    def __abs__(self):
+        return Vec3(abs(self.data), callback=self.callback)
     
-    # override [_] accessor
+    # accessor functions
     def __getitem__(self, index): 
-        if int(index) != index: raise IndexError(f'Vec3: index must be an int, got {type(index)}') # check if index is a float
-        if index < 0 or index > 2: raise IndexError(f'Vec3: index out of bounds, got {index}')
+        assert int(index) == index, f'Vec3: index must be an int, got {type(index)}' # check if index is a float
+        assert 0 <= index <= 2, f'Vec3: index out of bounds, got {index}'
         return self.data[index]
     
     def __setitem__(self, index, value): 
-        if int(index) != index: raise IndexError(f'Vec3: index must be an int, got {type(index)}') # check if index is a float
-        if index < 0 or index > 2: raise IndexError(f'Vec3: index out of bounds, got {index}')
+        assert int(index) == index, f'Vec3: index must be an int, got {type(index)}' # check if index is a float
+        assert 0 <= index <= 2, f'Vec3: index out of bounds, got {index}'
         try: self.data[index] = value
         except: raise ValueError(f'Vec3: Invalid element type, got {type(value)}')
         
-    def __repr__(self):
-        return str(self.data)
-
+    def __delitem__(self, index): # index in a vec cannot be deleted, so we default to zero
+        assert int(index) == index, f'Vec3: index must be an int, got {type(index)}' # check if index is a float
+        assert 0 <= index <= 2, f'Vec3: index out of bounds, got {index}'
+        self.data[index] = 0
+        
+    def __len__(self):
+        return 3
+        
     def __iter__(self):
-        return iter((self.x, self.y, self.z))
+        return iter(self.data)
+    
+    def __contains__(self, item):
+        return item in self.data
+    
+    # override str operators
+    def __repr__(self):
+        return 'bsk ' + str(self.data)
+    
+    def __str__(self):
+        return 'bsk ' + str(self.data)
     
     @property
     def data(self): return self._data
@@ -93,20 +97,48 @@ class Vec3():
     
     @data.setter
     def data(self, value: glm.vec3):
-        self._data = value
-        if self.callback and all(abs(self.data[i] - value[i]) > 1e-12 for i in range(3)): self.callback()
+        self._data = glm.vec3(value)
+        cur = self._data
+        prev = self.prev_data
+        thresh = 1e-6
+        
+        if self.callback and (abs(cur.x - prev.x) > thresh or abs(cur.y - prev.y) > thresh or abs(cur.z - prev.z) > thresh): 
+            self.prev_data = glm.vec3(self._data)
+            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()
+        
+class Node():
+    
+    def __init__(self, pos):
+        
+        def callback(): print('calling back')
+        self.pos_callback = callback
+        self._pos = Vec3(pos, callback=self.pos_callback)
+        
+    @property
+    def pos(self): return self._pos
+    
+    @pos.setter
+    def pos(self, value): 
+        if isinstance(value, Vec3): self._pos.data = value.data
+        else: self._pos.data = value

basilisk/input/mouse.py

@@ -34,11 +34,11 @@ class Mouse():
         pg.mouse.set_pos(x, y)
 
     @property
-    def click(self): return self.previous_buttons[0] and not self.buttons[0]
+    def click(self): return self.buttons[0] and not self.previous_buttons[0]
     @property
-    def middle_click(self): return self.previous_buttons[1] and not self.buttons[1]
+    def middle_click(self): return self.buttons[1] and not self.previous_buttons[1]
     @property
-    def right_click(self): return self.previous_buttons[2] and not self.buttons[2]
+    def right_click(self): return self.buttons[2] and not self.previous_buttons[2]
     @property
     def left_down(self): return self.buttons[0]
     @property

basilisk/mesh/cube.py

@@ -8,9 +8,27 @@ class Cube(Mesh):
         # built-in cube mesh with custom functions
         path = engine.root + '/bsk_assets/cube.obj'
         super().__init__(path)
+        
+        self.dot_indices = [0 for _ in range(8)]
+        for i, point in enumerate(self.points):
+            index = 0 
+            if point[0] > 0: index += 4
+            if point[1] > 0: index += 2
+            if point[2] > 0: index += 1
+            self.dot_indices[index] = i
 
-    def get_best_dot(self, vec: glm.vec3) -> glm.vec3:
+    def get_best_dot(self, vec: glm.vec3) -> int:
         """
         Gets the best dot point of a cube
         """
-        return glm.vec3([-1 if v < 0 else 1 for v in vec])
+        index = 0
+        if vec[0] > 0: index += 4
+        if vec[1] > 0: index += 2
+        if vec[2] > 0: index += 1
+        return self.dot_indices[index]
+    
+    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[int]:
+        """
+        Returns all the faces on the cube since the AABB degenerates on the cube mesh
+        """
+        return [i for i in range(12)]

basilisk/mesh/mesh.py

@@ -7,6 +7,7 @@ from .narrow_bvh import NarrowBVH
 from ..generic.matrices import compute_inertia_moment, compute_inertia_product
 from ..generic.meshes import get_extreme_points_np, moller_trumbore
 from .mesh_from_data import from_data
+import time
 
 
 class Mesh():
@@ -40,31 +41,44 @@ class Mesh():
         # Verify the path type
         if isinstance(data, str) or isinstance(data, os.PathLike):  # Load the model from file
             model = load_model(data, calculate_tangents=True)
-        elif isinstance(data, np.ndarray):                          # Load the model from array of data
-            model = from_data(data)
+
+             # Get the vertex data
+            if len(model.vertex_data[0]) == 8:
+                self.data = model.vertex_data.copy()
+            else:
+                self.data = np.zeros(shape=(len(model.vertex_data), 8))
+                self.data[:,:3] = model.vertex_data[:,:3]
+                self.data[:,5:] = model.vertex_data[:,3:]
+            
+            # Get tangent data
+            if len(model.tangent_data[0]) == 6:
+                self.data = np.hstack([self.data, model.tangent_data])
+            else:
+                tangents = np.zeros(shape=(len(self.data), 6))
+                tangents[:,:] += [1.0, 0.0, 0.0, 0.0, 1.0, 0.0]
+                self.data = np.hstack([self.data, tangents])
+
+        elif isinstance(data, np.ndarray):
+            model = from_data(data)      
+            self.data = model.vertex_data
+            
         else:                                                       # Invalid data type
             raise TypeError(f'Invalid path type: {type(data)}. Expected a string or os.path')
-
-        # Get the vertex data
-        if len(model.vertex_data[0]) == 8:
-            self.data = model.vertex_data.copy()
-        else:
-            self.data = np.zeros(shape=(len(model.vertex_data), 8))
-            self.data[:,:3] = model.vertex_data[:,:3]
-            self.data[:,5:] = model.vertex_data[:,3:]
         
-        # Get tangent data
-        if len(model.tangent_data[0]) == 6:
-            self.data = np.hstack([self.data, model.tangent_data])
-        else:
-            tangents = np.zeros(shape=(len(self.data), 6))
-            tangents[:,:] += [1.0, 0.0, 0.0, 0.0, 1.0, 0.0]
-            self.data = np.hstack([self.data, tangents])
-
         # Mesh points and triangles used for physics/collisions
         self.points = model.vertex_points.copy()
         self.indices = model.point_indices.copy()
 
+        self.hash = hash(str(self.data))
+
+        # generate edges from faces
+        edges = [set() for _ in range(len(self.points))]
+        for face in self.indices:
+            
+            # add points to the dictionary since each point on a face is adjacent to the others
+            for i in range(3): edges[face[i]].update([int(face[(i + 1) % 3]), int(face[(i + 2) % 3])])
+        self.edges = [tuple(adjacent) for adjacent in edges]
+
         # Model will no longer be used
         del model
         
@@ -127,6 +141,12 @@ class Mesh():
             -icp, -iap, ic
         )
         
+        # return glm.mat3x3(
+        #     ic, -iap, -icp,
+        #     -iap, ib, -ibp,
+        #     -ibp, -iap, ia
+        # )
+        
     def get_best_triangle(self, point: glm.vec3, vec: glm.vec3) -> int:
         """
         Gets the triangle with the closest intersection, -1 if no intersection is found
@@ -155,51 +175,43 @@ class Mesh():
                 best_index = triangle
                 
         return best_index
+        
+    def get_best_dot(self, vec: glm.vec3) -> int:
+        """
+        Gets the point with the highest normalized dot product to the given vector
+        """
+        triangle = self.bvh.get_best_dot(vec)
+        if triangle == -1: return None
+        index = max(self.indices[triangle], key=lambda t: glm.dot(glm.normalize(self.points[t]), vec))
+        return index
     
-    def get_best_triangle_brute(self, point: glm.vec3, vec: glm.vec3) -> int:
+    def get_best_dot_hill_climbing(self, vec: glm.vec3) -> int:
         """
-        Gets the triangle with the closest intersection, -1 if no intersection is found. Uses a brute force method
+        Gets the point with the highest dot product to the given vector using a hill climbing algorithm. This function is only effective for convex models.
         """
-        best_distance = -1
-        best_index = -1
-        
-        point = glm.vec3(point)
-        vec = glm.vec3(vec)
+        best_index = 0
+        best_dot = glm.dot(self.points[best_index], vec)
         
-        for index, triangle in enumerate(self.indices):
-            
-            # check if triangle intersects
-            intersection = moller_trumbore(point, vec, [self.points[t] for t in triangle])
-            if not intersection: continue
+        while True:
             
-            # check if triangle is on correct side of line
-            difference = intersection - self.geometric_center
-            if glm.dot(difference, vec) < 0: continue
-            
-            # determine best distance
-            distance = glm.length(difference)
-            if best_distance < 0 or distance < best_distance: 
-                best_distance = distance
-                best_index = index
+            best_changed = False
+            for index in self.edges[best_index]:
                 
-        return best_index
+                dot = glm.dot(self.points[index], vec)
+                if dot > best_dot:
+                    best_dot = dot
+                    best_changed = True
+                    best_index = index
+                    
+            if not best_changed: break
         
-    def get_best_dot(self, vec: glm.vec3) -> glm.vec3:
+        return best_index
+    
+    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[tuple[int, int, int]]:
         """
-        Gets the point with the highest normalized dot product to the given vector
+        Determines which triangles are intersecting with the given line segment. Returns the indices of the triangle contained in the mesh points list
         """
-        triangle = self.bvh.get_best_dot(vec)
-        if triangle == -1: return None
-        index = max(self.indices[triangle], key=lambda t: glm.dot(glm.normalize(self.points[t]), vec))
-        return glm.vec3(self.points[index])
-    
-    def get_best_dot_old(self, vec):
-        best_dot = -1e10
-        best = None
-        for point in self.points:
-            dot = glm.dot(glm.normalize(point), vec)
-            if dot > best_dot: best_dot, best = dot, glm.vec3(point)
-        return best
+        return self.bvh.get_line_collided(position, forward)
 
     def __repr__(self) -> str:
         size = (self.data.nbytes + self.points.nbytes + self.indices.nbytes) / 1024 / 1024
@@ -214,3 +226,6 @@ class Mesh():
         x1, y1, z1 = self.top_right
         x2, y2, z2 = self.bottom_left
         return [glm.vec3(x, y, z) for z in (z1, z2) for y in (y1, y2) for x in (x1, x2)]
+
+    def __hash__(self):
+        return self.hash