basilisk-engine 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

basilisk/__init__.py

@@ -9,4 +9,5 @@ from .render.shader import Shader
 from .render.shader_handler import ShaderHandler
 from .draw import draw
 from .render.camera import FreeCamera, StaticCamera, FollowCamera, OrbitCamera
-from .render.sky import Sky
+from .render.sky import Sky
+from .render.post_process import PostProcess

basilisk/collisions/collider.py

@@ -2,6 +2,7 @@ import glm
 from ..generic.abstract_bvh import AbstractAABB as AABB
 from ..generic.meshes import transform_points, get_aabb_surface_area
 from ..mesh.mesh import Mesh
+from .narrow.dataclasses import Collision
 
 class Collider():
     node: ...
@@ -35,22 +36,28 @@ class Collider():
     mesh: Mesh
     """Reference to the colliding mesh"""
 
-    def __init__(self, node, box_mesh: bool=False, static_friction: glm.vec3=0.7, kinetic_friction: glm.vec3=0.3, elasticity: glm.vec3=0.2, collision_group: str=None):
+    def __init__(self, node, collider_mesh: str|Mesh=None, static_friction: glm.vec3=0.7, kinetic_friction: glm.vec3=0.3, elasticity: glm.vec3=0.2, collision_group: str=None):
         self.collider_handler = None
         self.node = node
         self.static_friction = static_friction if elasticity else 0.8 # added checks to prevent floats being set to None. Also done for kinetic and elasticity
-        self.box_mesh = box_mesh
+        self.mesh = collider_mesh
         self.kinetic_friction = kinetic_friction if elasticity else 0.4
         self.elasticity = elasticity if elasticity else 0.1
         self.collision_group = collision_group
         self.collision_velocity = 0
-        self.collisions = {}
+        self.collisions: list[Collision] = []
         self.parent = None
         
         # lazy update variables TODO change to distinguish between static and nonstatic objects
         self.needs_obb = True # pos, scale, rot
         self.needs_half_dimensions = True # scale, rot
         self.needs_bvh = True # pos, scale, rot
+        
+    def get_vertex(self, index: int) -> glm.vec3:
+        """
+        Gets the world space position of a vertex indicated by the index in the mesh
+        """
+        return glm.vec3(self.node.model_matrix * glm.vec4(*self.mesh.points[index], 1))
     
     @property
     def collider_handler(self): return self._collider_handler
@@ -80,5 +87,10 @@ class Collider():
     def collider_handler(self, value):
         self._collider_handler = value
         if not value: return
-        self.mesh = value.cube if self.box_mesh else self.node.mesh
+        if self.mesh is None: self.mesh = self.node.mesh
+        elif isinstance(self.mesh, Mesh): ...
+        elif isinstance(self.mesh, str):
+            if self.mesh =='box': self.mesh = value.cube
+            else: raise ValueError(f'Incorrect built-in mesh type {self.mesh}')
+        else: raise ValueError(f'Unkown type for mesh, got {type(self.mesh)}')
         value.add(self)

basilisk/collisions/collider_handler.py

@@ -5,7 +5,7 @@ from .broad.broad_bvh import BroadBVH
 from .narrow.gjk import collide_gjk
 from .narrow.epa import get_epa_from_gjk
 from .narrow.contact_manifold import get_contact_manifold, separate_polytope
-from .narrow.dataclasses import SupportPoint, ContactPoint, ContactManifold
+from .narrow.dataclasses import ContactPoint, ContactManifold, Collision
 from ..nodes.node import Node
 from ..generic.collisions import get_sat_axes
 from ..physics.impulse import calculate_collisions
@@ -47,8 +47,7 @@ class ColliderHandler():
         Resets collider collision values and resolves all collisions in the scene
         """
         # reset collision data
-        for collider in self.colliders: collider.collisions = {}
-        
+        for collider in self.colliders: collider.collisions = []
         
         # update BVH
         for collider in self.colliders:
@@ -122,7 +121,7 @@ class ColliderHandler():
             # traverse bvh to find aabb aabb collisions
             colliding = self.bvh.get_collided(collider1)
             for collider2 in colliding:
-                if collider1 is collider2: continue
+                if collider1 is collider2 or (collider1.collision_group is not None and collider1.collision_group == collider2.collision_group): continue
                 if ((collider1, collider2) if id(collider1) < id(collider2) else (collider2, collider1)) in collisions: continue
                 
                 # run broad collision for specified mesh types
@@ -148,7 +147,7 @@ class ColliderHandler():
             remove_indices = []
             for index, vertex in existing.items():
                 if index in incoming_indices: continue
-                if glm.length2(node.get_vertex(index) - vertex) > 1e-5: remove_indices.append(index) # check to see if point has moved
+                if glm.length2(node.collider.get_vertex(index) - vertex) > 1e-5: remove_indices.append(index) # check to see if point has moved
             
             # remove unused and moved points
             for index in remove_indices: del existing[index]
@@ -198,6 +197,10 @@ class ColliderHandler():
                 
             if glm.dot(vec, node2.position - node1.position) > 0: vec *= -1
             
+            # add collision data to colliders
+            collider1.collisions.append(Collision(node2, vec))
+            collider2.collisions.append(Collision(node1, -vec))
+            
             # apply impulse if a collider has a physic body
             if node1.physics_body or node2.physics_body:
                 
@@ -205,10 +208,7 @@ class ColliderHandler():
                 points1, points2 = separate_polytope(points1, points2, vec)
                 self.merge_contact_points(vec, collider1, collider2, points1, points2)
                 
-                # for manifold in self.contact_manifolds.values(): print(list(manifold.contact_points1.values()) + list(manifold.contact_points2.values()))
-                
                 collider_tuple = (collider1, collider2)
-                # print(self.contact_manifolds[collider_tuple])
                 manifold = get_contact_manifold(
                     node1.position - vec, 
                     vec, 
@@ -219,9 +219,6 @@ class ColliderHandler():
                 collision_normal = node1.velocity - node2.velocity
                 collision_normal = vec if glm.length2(collision_normal) < 1e-12 else glm.normalize(collision_normal)
                 calculate_collisions(collision_normal, node1, node2, manifold, node1.get_inverse_inertia(), node2.get_inverse_inertia(), node1.center_of_mass, node2.center_of_mass)
-
-                # for i, point in enumerate(manifold):
-                #     self.scene.add(Node(position = point, scale = (0.1, 0.1, 0.1)))
             
             # resolve collision penetration
             multiplier = 0.5 if not (node1.static or node2.static) else 1

basilisk/collisions/narrow/dataclasses.py

@@ -1,5 +1,6 @@
 import glm
 from dataclasses import dataclass
+# from ...nodes.node import Node
 
 # frozen because data does not need to be mutable
 # used in creating polytopes for GJK/EPA
@@ -24,4 +25,9 @@ class ContactPoint():
 class ContactManifold():
     normal: glm.vec3
     contact_points1: dict[int : glm.vec3] # contact point index : collision position
-    contact_points2: dict[int : glm.vec3]
+    contact_points2: dict[int : glm.vec3]
+    
+@dataclass
+class Collision():
+    node: ...
+    normal: glm.vec3

basilisk/collisions/narrow/helper.py

@@ -16,8 +16,8 @@ def get_furthest_point(node: Node, dir_vec: glm.vec3) -> glm.vec3:
     """
     # determine furthest point by using untransformed mesh
     node_dir_vec = node.rotation * dir_vec # rotate the world space vector to node space
-    index = node.mesh.get_best_dot(node_dir_vec)
-    vertex = node.mesh.points[index]
+    index = node.collider.mesh.get_best_dot(node_dir_vec)
+    vertex = node.collider.mesh.points[index]
     vertex = node.model_matrix * glm.vec4(vertex, 1.0)
     
     # transform point to world space

basilisk/draw/draw_handler.py

@@ -5,6 +5,7 @@ from math import cos, sin, atan2
 from ..render.image import Image
 from .font_renderer import FontRenderer
 from ..render.shader import Shader
+from ..generic.input_validation import validate_color, validate_rect, validate_point
 
 class DrawHandler():
     engine: ...
@@ -73,7 +74,7 @@ class DrawHandler():
         Draws a rect to the screen
         """
 
-        color = validate_color(color)
+        color = validate_color('draw', 'color', color)
         rect  = validate_rect(rect)
 
         p1 = (rect[0]          , rect[1]          )
@@ -106,8 +107,8 @@ class DrawHandler():
         """
 
         if not outer_color: outer_color = color
-        color  = validate_color(color)
-        outer_color  = validate_color(outer_color)
+        color  = validate_color('draw', 'color', color)
+        outer_color  = validate_color('draw', 'color', outer_color)
         p1 = validate_point(center)
 
         v1 = (*p1, *color, 0)
@@ -134,7 +135,7 @@ class DrawHandler():
                     Size of the line on either side. pixels
         """
         
-        color = validate_color(color)
+        color = validate_color('draw', 'color', color)
 
         p1 = glm.vec2(validate_point(p1))
         p2 = glm.vec2(validate_point(p2))
@@ -176,35 +177,4 @@ class DrawHandler():
         """
         
         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
+        if self.vao: self.vao.release()

basilisk/engine.py

@@ -1,5 +1,8 @@
 import os
 from sys import platform
+import sys
+import glcontext
+from .input.path import get_root
 os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
 import pygame as pg
 import moderngl as mgl
@@ -80,7 +83,8 @@ class Engine():
         # Global attributes referenced by the handlers
         self.headless = headless
         self.set_configurations()
-        self.root = os.path.dirname(__file__)
+        # self.root = get_root()
+        self.root = getattr(sys, '_MEIPASS', os.getcwd()) + '/basilisk'
         self.cube = Cube(self)
 
         # Update the icon
@@ -134,7 +138,7 @@ class Engine():
                 self.win_size = (event.w, event.h)
                 self.ctx.viewport = (0, 0, event.w, event.h)
                 self.scene.camera.use()
-                self.scene.frame.set_textures()
+                self.scene.frame.resize()
 
 
         # Update the scene if possible

basilisk/generic/input_validation.py

@@ -15,14 +15,53 @@ def validate_glm_vec3(module: str, name: str, value: tuple | list | glm.vec3 | n
     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):
+    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")
+        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/raycast_result.py

@@ -0,0 +1,24 @@
+import glm
+from ..nodes.node import Node
+
+
+class RaycastResult:
+    node: Node | None
+    """The node that the raycast hit. Is None if no object was hit"""
+    position: glm.vec3
+    """The node that the raycast hit"""
+
+    def __init__(self, node: Node | None, position: glm.vec3):
+        """
+        Container for returning raycast results.
+        Contains the node hit and the global position the raycast hit at.
+        """
+        
+        self.node = node
+        self.position = position
+
+    def __bool__(self):
+        return bool(self.node)
+
+    def __repr__(self):
+        return f'<Raycast | Node: {self.node}, Position: {self.position}>'

basilisk/input/mouse.py

@@ -36,6 +36,8 @@ class Mouse():
     @property
     def click(self): return self.buttons[0] and not self.previous_buttons[0]
     @property
+    def left_click(self): return self.buttons[0] and not self.previous_buttons[0]
+    @property
     def middle_click(self): return self.buttons[1] and not self.previous_buttons[1]
     @property
     def right_click(self): return self.buttons[2] and not self.previous_buttons[2]

basilisk/input/path.py

@@ -0,0 +1,14 @@
+import os
+import sys
+
+
+# Credit for function: https://stackoverflow.com/questions/7674790/bundling-data-files-with-pyinstaller-onefile
+def get_root():
+    """ Get absolute path to resource, works for dev and for PyInstaller """
+    try:
+        # PyInstaller creates a temp folder and stores path in _MEIPASS
+        base_path = sys._MEIPASS
+    except Exception:
+        base_path = os.path.abspath(".")
+
+    return base_path + '/basilisk'

basilisk/mesh/mesh_from_data.py

@@ -63,8 +63,6 @@ def from_data(data: np.ndarray) -> Model:
     model.vertex_data[:,8:14] = tangents
     model.vertex_points, model.point_indices = get_points_and_indices(positions)
 
-    print(model.vertex_points, model.point_indices)
-
     return model
 
 

basilisk/nodes/helper.py

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