basilisk-engine 0.1.41__py3-none-any.whl → 0.1.43__py3-none-any.whl

basilisk/mesh/narrow_aabb.py

@@ -1,90 +1,90 @@
-import glm
-
-from basilisk.generic.collisions import collide_aabb_line
-from .narrow_primative import NarrowPrimative
-from ..generic.abstract_bvh import AbstractAABB as AABB
-from ..generic.meshes import get_aabb_line_collision
-
-class NarrowAABB(AABB):
-    top_right: glm.vec3
-    """The furthest positive corner of the AABB"""
-    bottom_left: glm.vec3
-    """The furthest negative corner of the AABB"""
-    geometric_center: glm.vec3
-    """The center of the object calculated from its extreme points"""
-    a: AABB | NarrowPrimative
-    """Child AABB or Collider 1"""
-    b: AABB | NarrowPrimative
-    """Child AABB or Collider 2"""
-
-    def __init__(self, top_right:glm.vec3, bottom_left:glm.vec3, a: AABB, b: AABB) -> None:
-        self.top_right = top_right
-        self.bottom_left = bottom_left
-        self.geometric_center = (top_right + bottom_left) / 2
-        self.a = a
-        self.b = b
-        
-    def get_possible_triangles(self, point: glm.vec3, vec: glm.vec3) -> list[int]:
-        """
-        Determines the closest intersecting on the bvh
-        """
-        indices = []
-        if not get_aabb_line_collision(self.top_right, self.bottom_left, point, vec): return indices
-        
-        for child in (self.a, self.b):
-            
-            # if child is another AABB
-            if isinstance(child, NarrowAABB):
-                indices += child.get_possible_triangles(point, vec)
-                continue
-            
-            # if child is a primative
-            index = child.is_possible_triangle(point, vec)
-            if index == -1: continue
-            indices.append(index)
-        
-        return indices
-    
-    def get_best_dot(self, vec: glm.vec3) -> int:
-        """
-        Returns the best triangle with the highest dot product with the vector from the geometric center to its AABB
-        """
-        c = max(self.a, self.b, key=lambda x: glm.dot(x.geometric_center, vec))
-        if isinstance(c, NarrowAABB): return c.get_best_dot(vec)
-        return c.index
-    
-    def get_all_aabbs(self, layer: int) -> list[tuple[glm.vec3, glm.vec3, int]]:
-        """
-        Returns all AABBs, their extreme points, and their layer
-        """
-        aabbs = [(self.top_right, self.bottom_left, layer)]
-        if isinstance(self.a, NarrowAABB): aabbs += self.a.get_all_aabbs(layer + 1)
-        else: aabbs.append((self.a.top_right, self.a.bottom_left, layer + 1))
-        if isinstance(self.b, NarrowAABB): aabbs += self.b.get_all_aabbs(layer + 1)
-        else: aabbs.append((self.b.top_right, self.b.bottom_left, layer + 1))
-        return aabbs
-    
-    def get_tested_aabbs(self, point: glm.vec3, vec: glm.vec3, layer: int) -> list[tuple[glm.vec3, glm.vec3, int]]:
-        """
-        Returns all AABBs, their extreme points, and their layer
-        """
-        aabbs = [(self.top_right, self.bottom_left, layer)]
-        
-        if isinstance(self.a, NarrowAABB): 
-            
-            aabbs += self.a.get_all_aabbs(layer + 1)
-        else: aabbs.append((self.a.top_right, self.a.bottom_left, layer + 1))
-        
-        if isinstance(self.b, NarrowAABB): 
-            
-            aabbs += self.b.get_all_aabbs(layer + 1)
-        else: aabbs.append((self.b.top_right, self.b.bottom_left, layer + 1))
-        
-        return aabbs
-    
-    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[int]:
-        """
-        Returns the colliders that may intersect with the given line
-        """
-        if not collide_aabb_line(self.top_right, self.bottom_left, position, forward): return []
+import glm
+
+from basilisk.generic.collisions import collide_aabb_line
+from .narrow_primative import NarrowPrimative
+from ..generic.abstract_bvh import AbstractAABB as AABB
+from ..generic.meshes import get_aabb_line_collision
+
+class NarrowAABB(AABB):
+    top_right: glm.vec3
+    """The furthest positive corner of the AABB"""
+    bottom_left: glm.vec3
+    """The furthest negative corner of the AABB"""
+    geometric_center: glm.vec3
+    """The center of the object calculated from its extreme points"""
+    a: AABB | NarrowPrimative
+    """Child AABB or Collider 1"""
+    b: AABB | NarrowPrimative
+    """Child AABB or Collider 2"""
+
+    def __init__(self, top_right:glm.vec3, bottom_left:glm.vec3, a: AABB, b: AABB) -> None:
+        self.top_right = top_right
+        self.bottom_left = bottom_left
+        self.geometric_center = (top_right + bottom_left) / 2
+        self.a = a
+        self.b = b
+        
+    def get_possible_triangles(self, point: glm.vec3, vec: glm.vec3) -> list[int]:
+        """
+        Determines the closest intersecting on the bvh
+        """
+        indices = []
+        if not get_aabb_line_collision(self.top_right, self.bottom_left, point, vec): return indices
+        
+        for child in (self.a, self.b):
+            
+            # if child is another AABB
+            if isinstance(child, NarrowAABB):
+                indices += child.get_possible_triangles(point, vec)
+                continue
+            
+            # if child is a primative
+            index = child.is_possible_triangle(point, vec)
+            if index == -1: continue
+            indices.append(index)
+        
+        return indices
+    
+    def get_best_dot(self, vec: glm.vec3) -> int:
+        """
+        Returns the best triangle with the highest dot product with the vector from the geometric center to its AABB
+        """
+        c = max(self.a, self.b, key=lambda x: glm.dot(x.geometric_center, vec))
+        if isinstance(c, NarrowAABB): return c.get_best_dot(vec)
+        return c.index
+    
+    def get_all_aabbs(self, layer: int) -> list[tuple[glm.vec3, glm.vec3, int]]:
+        """
+        Returns all AABBs, their extreme points, and their layer
+        """
+        aabbs = [(self.top_right, self.bottom_left, layer)]
+        if isinstance(self.a, NarrowAABB): aabbs += self.a.get_all_aabbs(layer + 1)
+        else: aabbs.append((self.a.top_right, self.a.bottom_left, layer + 1))
+        if isinstance(self.b, NarrowAABB): aabbs += self.b.get_all_aabbs(layer + 1)
+        else: aabbs.append((self.b.top_right, self.b.bottom_left, layer + 1))
+        return aabbs
+    
+    def get_tested_aabbs(self, point: glm.vec3, vec: glm.vec3, layer: int) -> list[tuple[glm.vec3, glm.vec3, int]]:
+        """
+        Returns all AABBs, their extreme points, and their layer
+        """
+        aabbs = [(self.top_right, self.bottom_left, layer)]
+        
+        if isinstance(self.a, NarrowAABB): 
+            
+            aabbs += self.a.get_all_aabbs(layer + 1)
+        else: aabbs.append((self.a.top_right, self.a.bottom_left, layer + 1))
+        
+        if isinstance(self.b, NarrowAABB): 
+            
+            aabbs += self.b.get_all_aabbs(layer + 1)
+        else: aabbs.append((self.b.top_right, self.b.bottom_left, layer + 1))
+        
+        return aabbs
+    
+    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[int]:
+        """
+        Returns the colliders that may intersect with the given line
+        """
+        if not collide_aabb_line(self.top_right, self.bottom_left, position, forward): return []
         return (self.a.get_line_collided(position, forward) if isinstance(self.a, NarrowAABB) else [self.a.index]) + (self.b.get_line_collided(position, forward) if isinstance(self.b, NarrowAABB) else [self.b.index])

basilisk/mesh/narrow_bvh.py

@@ -1,92 +1,92 @@
-import glm
-from .narrow_aabb import NarrowAABB
-from .narrow_primative import NarrowPrimative
-from ..generic.abstract_bvh import AbstractAABB as BVH
-from ..generic.meshes import get_extreme_points_np, get_aabb_surface_area
-
-
-class NarrowBVH(BVH):
-    root: NarrowAABB | NarrowPrimative
-    """Root aabb used for the start of all collisions"""
-    primatives: list[NarrowPrimative]
-    """All of the primatives in the BVH associated with triangles in the mesh"""
-    mesh: ...
-    """Back reference to the parent mesh"""
-    
-    def __init__(self, mesh) -> None:
-        self.mesh       = mesh
-        self.primatives = []
-        for index, triangle in enumerate(self.mesh.indices):
-            points = [self.mesh.points[t] for t in triangle] # TODO check np array accessing
-            top_right, bottom_left = get_extreme_points_np(points)
-            self.primatives.append(NarrowPrimative(top_right, bottom_left, index))
-            
-        top_right   = mesh.geometric_center + mesh.half_dimensions
-        bottom_left = mesh.geometric_center - mesh.half_dimensions
-        self.root   = self.build_bvh(self.primatives, top_right, bottom_left)
-        
-    def build_bvh(self, primatives: list[NarrowPrimative], top_right: glm.vec3, bottom_left: glm.vec3) -> NarrowAABB | NarrowPrimative:
-        """
-        Creates a root node for the BVH with the given primatives and bounds
-        """
-        best_cost  = -1
-        best_split = primatives
-        best_aabb  = []
-        count = len(primatives) // 2
-        
-        # return primative if it is a leaf
-        if not count: return primatives[0]
-        
-        for axis in range(3):
-            # sort primatives along axis and determine if it is lowest cost
-            primatives.sort(key=lambda p: p.geometric_center[axis])
-            aabb = self.calculate_primative_aabb(primatives[:count]) + self.calculate_primative_aabb(primatives[count:])
-            cost = get_aabb_surface_area(aabb[0], aabb[1])  + get_aabb_surface_area(aabb[2], aabb[3])
-            
-            if best_cost < 0 or cost < best_cost:
-                best_cost  = cost
-                best_split = list(primatives) # TODO ensure that this is a shallow copy
-                best_aabb  = aabb        
-        
-        a = self.build_bvh(best_split[:count], best_aabb[0], best_aabb[1])
-        b = self.build_bvh(best_split[count:], best_aabb[2], best_aabb[3])
-        return NarrowAABB(top_right, bottom_left, a, b)
-            
-    def calculate_primative_aabb(self, primatives: list[NarrowPrimative]) -> float:
-        """
-        Computes the aabb surface area of the primatives
-        """
-        points = set()
-        for primative in primatives: 
-            points.update([tuple(self.mesh.points[t]) for t in self.mesh.indices[primative.index]])
-        return list(get_extreme_points_np(list(points)))
-    
-    def get_possible_triangles(self, point: glm.vec3, vec: glm.vec3) -> list[int]:
-        """
-        Determines the closest intersecting on the bvh
-        """
-        if isinstance(self.root, NarrowAABB): return self.root.get_possible_triangles(point, vec)
-        index = self.root.is_possible_triangle(point, vec)
-        return [index] if index != -1 else []
-    
-    def get_best_dot(self, vec: glm.vec3) -> int:
-        """
-        Returns the best triangle with the highest dot product with the vector from the geometric center to its AABB
-        """
-        if isinstance(self.root, NarrowAABB): return self.root.get_best_dot(vec)
-        return self.root.index
-    
-    def get_all_aabbs(self) -> list[tuple[glm.vec3, glm.vec3, int]]:
-        """
-        Returns all AABBs, their extreme points, and their layer
-        """
-        if isinstance(self.root, NarrowAABB): return self.root.get_all_aabbs(0)
-        return [(self.root.top_right, self.root.bottom_left, 0)]
-    
-    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[tuple[int, int, int]]:
-        """
-        Determines which triangles are intersecting with the given line segment. Returns the indices of the triangle contained in the mesh points list
-        """
-        if isinstance(self.root, NarrowAABB): return self.root.get_line_collided(position, forward)
-        return self.root.index
+import glm
+from .narrow_aabb import NarrowAABB
+from .narrow_primative import NarrowPrimative
+from ..generic.abstract_bvh import AbstractAABB as BVH
+from ..generic.meshes import get_extreme_points_np, get_aabb_surface_area
+
+
+class NarrowBVH(BVH):
+    root: NarrowAABB | NarrowPrimative
+    """Root aabb used for the start of all collisions"""
+    primatives: list[NarrowPrimative]
+    """All of the primatives in the BVH associated with triangles in the mesh"""
+    mesh: ...
+    """Back reference to the parent mesh"""
+    
+    def __init__(self, mesh) -> None:
+        self.mesh       = mesh
+        self.primatives = []
+        for index, triangle in enumerate(self.mesh.indices):
+            points = [self.mesh.points[t] for t in triangle] # TODO check np array accessing
+            top_right, bottom_left = get_extreme_points_np(points)
+            self.primatives.append(NarrowPrimative(top_right, bottom_left, index))
+            
+        top_right   = mesh.geometric_center + mesh.half_dimensions
+        bottom_left = mesh.geometric_center - mesh.half_dimensions
+        self.root   = self.build_bvh(self.primatives, top_right, bottom_left)
+        
+    def build_bvh(self, primatives: list[NarrowPrimative], top_right: glm.vec3, bottom_left: glm.vec3) -> NarrowAABB | NarrowPrimative:
+        """
+        Creates a root node for the BVH with the given primatives and bounds
+        """
+        best_cost  = -1
+        best_split = primatives
+        best_aabb  = []
+        count = len(primatives) // 2
+        
+        # return primative if it is a leaf
+        if not count: return primatives[0]
+        
+        for axis in range(3):
+            # sort primatives along axis and determine if it is lowest cost
+            primatives.sort(key=lambda p: p.geometric_center[axis])
+            aabb = self.calculate_primative_aabb(primatives[:count]) + self.calculate_primative_aabb(primatives[count:])
+            cost = get_aabb_surface_area(aabb[0], aabb[1])  + get_aabb_surface_area(aabb[2], aabb[3])
+            
+            if best_cost < 0 or cost < best_cost:
+                best_cost  = cost
+                best_split = list(primatives) # TODO ensure that this is a shallow copy
+                best_aabb  = aabb        
+        
+        a = self.build_bvh(best_split[:count], best_aabb[0], best_aabb[1])
+        b = self.build_bvh(best_split[count:], best_aabb[2], best_aabb[3])
+        return NarrowAABB(top_right, bottom_left, a, b)
+            
+    def calculate_primative_aabb(self, primatives: list[NarrowPrimative]) -> float:
+        """
+        Computes the aabb surface area of the primatives
+        """
+        points = set()
+        for primative in primatives: 
+            points.update([tuple(self.mesh.points[t]) for t in self.mesh.indices[primative.index]])
+        return list(get_extreme_points_np(list(points)))
+    
+    def get_possible_triangles(self, point: glm.vec3, vec: glm.vec3) -> list[int]:
+        """
+        Determines the closest intersecting on the bvh
+        """
+        if isinstance(self.root, NarrowAABB): return self.root.get_possible_triangles(point, vec)
+        index = self.root.is_possible_triangle(point, vec)
+        return [index] if index != -1 else []
+    
+    def get_best_dot(self, vec: glm.vec3) -> int:
+        """
+        Returns the best triangle with the highest dot product with the vector from the geometric center to its AABB
+        """
+        if isinstance(self.root, NarrowAABB): return self.root.get_best_dot(vec)
+        return self.root.index
+    
+    def get_all_aabbs(self) -> list[tuple[glm.vec3, glm.vec3, int]]:
+        """
+        Returns all AABBs, their extreme points, and their layer
+        """
+        if isinstance(self.root, NarrowAABB): return self.root.get_all_aabbs(0)
+        return [(self.root.top_right, self.root.bottom_left, 0)]
+    
+    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[tuple[int, int, int]]:
+        """
+        Determines which triangles are intersecting with the given line segment. Returns the indices of the triangle contained in the mesh points list
+        """
+        if isinstance(self.root, NarrowAABB): return self.root.get_line_collided(position, forward)
+        return self.root.index
         

basilisk/mesh/narrow_primative.py

@@ -1,24 +1,24 @@
-import glm
-from ..generic.meshes import get_aabb_line_collision
-
-class NarrowPrimative():
-    top_right: glm.vec3
-    """The furthest positive corner of the AABB"""
-    bottom_left: glm.vec3
-    """The furthest negative corner of the AABB"""
-    geometric_center: glm.vec3
-    """The centroid of the primative"""
-    index: int
-    """the index of the triangle in the mesh"""
-
-    def __init__(self, top_right:glm.vec3, bottom_left:glm.vec3, index: int) -> None:
-        self.top_right        = top_right
-        self.bottom_left      = bottom_left
-        self.geometric_center = (self.top_right + self.bottom_left) / 2
-        self.index = index
-        
-    def is_possible_triangle(self, point: glm.vec3, vec: glm.vec3) -> int:
-        """
-        Determines if this triangle's AABB intersects with the line
-        """
+import glm
+from ..generic.meshes import get_aabb_line_collision
+
+class NarrowPrimative():
+    top_right: glm.vec3
+    """The furthest positive corner of the AABB"""
+    bottom_left: glm.vec3
+    """The furthest negative corner of the AABB"""
+    geometric_center: glm.vec3
+    """The centroid of the primative"""
+    index: int
+    """the index of the triangle in the mesh"""
+
+    def __init__(self, top_right:glm.vec3, bottom_left:glm.vec3, index: int) -> None:
+        self.top_right        = top_right
+        self.bottom_left      = bottom_left
+        self.geometric_center = (self.top_right + self.bottom_left) / 2
+        self.index = index
+        
+    def is_possible_triangle(self, point: glm.vec3, vec: glm.vec3) -> int:
+        """
+        Determines if this triangle's AABB intersects with the line
+        """
         return self.index if get_aabb_line_collision(self.top_right, self.bottom_left, point, vec) else -1

basilisk/nodes/helper.py

@@ -1,29 +1,29 @@
-import glm
-# from .node import Node
-from ..mesh.mesh import Mesh
-from ..render.material import Material
-
-def node_is(node, position: glm.vec3=None, scale: glm.vec3=None, rotation: glm.quat=None, forward: glm.vec3=None, mesh: Mesh=None, material: Material=None, velocity: glm.vec3=None, rotational_velocity: glm.quat=None, physics: bool=None, mass: float=None, collisions: bool=None, static_friction: float=None, kinetic_friction: float=None, elasticity: float=None, collision_group: float=None, name: str=None, tags: list[str]=None,static: bool=None) -> bool:
-    """
-    Determine if a node meets the requirements given by the parameters. If a parameter is None, then the filter is not applied.
-    """
-    return all([
-            position is None or position == node.position,
-            scale    is None or scale    == node.scale,
-            rotation is None or rotation == node.rotation,
-            forward  is None or forward  == node.forward,
-            mesh     is None or mesh     == node.mesh,
-            material is None or material == node.material,
-            velocity is None or velocity == node.velocity,
-            rotational_velocity is None or rotational_velocity == node.rotational_velocity,
-            physics    is None or bool(node.physics_body) == physics,
-            mass       is None or (node.physics_body and mass == node.physics_body.mass),
-            collisions is None or bool(node.collider) == collisions,
-            static_friction  is None or (node.collider and node.collider.static_friction  == static_friction),
-            kinetic_friction is None or (node.collider and node.collider.kinetic_friction == kinetic_friction),
-            elasticity       is None or (node.collider and node.collider.elasticity       == elasticity),
-            collision_group  is None or (node.collider and node.collider.collision_group  == collision_group),
-            name   is None or node.name == name,
-            tags   is None or all([tag in node.tags for tag in tags]),
-            static is None or node.static == static
+import glm
+# from .node import Node
+from ..mesh.mesh import Mesh
+from ..render.material import Material
+
+def node_is(node, position: glm.vec3=None, scale: glm.vec3=None, rotation: glm.quat=None, forward: glm.vec3=None, mesh: Mesh=None, material: Material=None, velocity: glm.vec3=None, rotational_velocity: glm.quat=None, physics: bool=None, mass: float=None, collisions: bool=None, static_friction: float=None, kinetic_friction: float=None, elasticity: float=None, collision_group: float=None, name: str=None, tags: list[str]=None,static: bool=None) -> bool:
+    """
+    Determine if a node meets the requirements given by the parameters. If a parameter is None, then the filter is not applied.
+    """
+    return all([
+            position is None or position == node.position,
+            scale    is None or scale    == node.scale,
+            rotation is None or rotation == node.rotation,
+            forward  is None or forward  == node.forward,
+            mesh     is None or mesh     == node.mesh,
+            material is None or material == node.material,
+            velocity is None or velocity == node.velocity,
+            rotational_velocity is None or rotational_velocity == node.rotational_velocity,
+            physics    is None or bool(node.physics_body) == physics,
+            mass       is None or (node.physics_body and mass == node.physics_body.mass),
+            collisions is None or bool(node.collider) == collisions,
+            static_friction  is None or (node.collider and node.collider.static_friction  == static_friction),
+            kinetic_friction is None or (node.collider and node.collider.kinetic_friction == kinetic_friction),
+            elasticity       is None or (node.collider and node.collider.elasticity       == elasticity),
+            collision_group  is None or (node.collider and node.collider.collision_group  == collision_group),
+            name   is None or node.name == name,
+            tags   is None or all([tag in node.tags for tag in tags]),
+            static is None or node.static == static
         ])