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

basilisk/nodes/node.py

@@ -18,6 +18,12 @@ class Node():
     """The scale of the node in meters in each direction"""
     rotation: Quat
     """The rotation of the node"""
+    position_relative: bool
+    """The position of this node relative to the parent node"""
+    scale_relative: bool
+    """The scale of this node relative to the parent node"""
+    rotation_relative: bool
+    """The rotation of this node relative to the parent node"""
     forward: glm.vec3
     """The forward facing vector of the node"""
     mesh: Mesh
@@ -57,10 +63,13 @@ class Node():
     shader: Shader
     """Shader that is used to render the node. If none is given, engine default will be used"""
 
-    def __init__(self, node_handler,
+    def __init__(self,
             position:            glm.vec3=None, 
             scale:               glm.vec3=None, 
             rotation:            glm.quat=None, 
+            relative_position:   bool=True,
+            relative_scale:      bool=True,
+            relative_rotation:   bool=True,
             forward:             glm.vec3=None, 
             mesh:                Mesh=None, 
             material:            Material=None, 
@@ -86,8 +95,10 @@ class Node():
         """
         
         # parents
-        self.node_handler = node_handler
+        self.node_handler = None
+        self.scene = None
         self.chunk = None
+        self.parent = None
         
         # lazy update variables
         self.needs_geometric_center = True # pos
@@ -98,21 +109,28 @@ class Node():
         self.internal_scale   : Vec3 = Vec3(scale)    if scale    else Vec3(1, 1, 1)
         self.internal_rotation: Quat = Quat(rotation) if rotation else Quat(1, 0, 0, 0)
         
+        # relative transformations
+        self.relative_position = glm.vec3(0, 0, 0)    if relative_position else None
+        self.relative_scale    = glm.vec3(0, 0, 0)    if relative_scale    else None
+        self.relative_rotation = glm.quat(1, 0, 0, 0) if relative_rotation else None
+        
         self.forward  = forward  if forward  else glm.vec3(1, 0, 0)
-        self.mesh     = mesh     if mesh     else self.node_handler.scene.engine.cube
-        self.material = material if material else None # TODO add default base material
+        self.mesh     = mesh
+        self._mtl_list = material if isinstance(material, list) else [material]
+        self.material = material if material else None
         self.velocity = velocity if velocity else glm.vec3(0, 0, 0)
         self.rotational_velocity = rotational_velocity if rotational_velocity else glm.vec3(0, 0, 0)
         
-        # physics body
-        if physics: self.physics_body: PhysicsBody = self.node_handler.scene.physics_engine.add(mass = mass if mass else 1.0)
+        self.static = static if static != None else not(physics or any(self.velocity) or any(self.rotational_velocity))
+
+        # Physics updates
+        if physics: self.physics_body = PhysicsBody(mass = mass if mass else 1.0)
         elif mass: raise ValueError('Node: cannot have mass if it does not have physics')
         else: self.physics_body = None
         
         # collider
         if collisions: 
-            if not self.mesh: raise ValueError('Node: cannot collide if it doezsnt have a mesh')
-            self.collider: Collider = self.node_handler.scene.collider_handler.add(
+            self.collider = Collider(
                 node = self,
                 box_mesh = True if collider == 'box' else False,
                 static_friction = static_friction,
@@ -126,13 +144,11 @@ class Node():
         elif elasticity:       raise ValueError('Node: cannot have elasticity if it does not allow collisions')
         elif collision_group:  raise ValueError('Node: cannot have collider group if it does not allow collisions')
         else: self.collider = None
-        
+
         # information and recursion
         self.name = name
         self.tags = tags if tags else []
-        if static == None:
-            self.static = not(physics or any(self.velocity) or any(self.rotational_velocity))
-        else: self.static = static
+
         self.data_index = 0
         self.children = []
 
@@ -143,7 +159,7 @@ class Node():
         self.previous_position: Vec3 = Vec3(position) if position else Vec3(0, 0, 0)
         self.previous_scale   : Vec3 = Vec3(scale)    if scale    else Vec3(1, 1, 1)
         self.previous_rotation: Quat = Quat(rotation) if rotation else Quat(1, 0, 0, 0) # TODO Do these need to be the callback class or can they just be glm? 
-        
+
         # callback function to be added to the custom Vec3 and Quat classes
         def position_callback():
             self.chunk.node_update_callback(self)
@@ -178,20 +194,55 @@ class Node():
         self.internal_position.callback = position_callback
         self.internal_scale.callback    = scale_callback
         self.internal_rotation.callback = rotation_callback
-        
+    
+    def init_scene(self, scene):
+        """
+        Updates the scene of the node
+        """
+        self.scene = scene
+        self.node_handler = scene.node_handler
+
+        # Update materials
+        self.write_materials()
+
+        # Update the mesh
+        self.mesh = self.mesh if self.mesh else self.scene.engine.cube
+
+        # Update physics and collider
+        if self.physics_body: self.physics_body.physics_engine = scene.physics_engine
+        if self.collider: self.collider.collider_handler = scene.collider_handler
+
     def update(self, dt: float) -> None:
         """
         Updates the node's movement variables based on the delta time
         """
+        # update based on physical properties
         if any(self.velocity): self.position += dt * self.velocity
-        if any(self.rotational_velocity): self.rotation = glm.normalize(self.rotation - 0.5 * dt * self.rotation * glm.quat(0, *self.rotational_velocity))
+        if any(self.rotational_velocity): self.rotation = glm.normalize(self.rotation - dt / 2 * self.rotation * glm.quat(0, *self.rotational_velocity))
 
         if self.physics_body:
             self.velocity += self.physics_body.get_delta_velocity(dt)
             self.rotational_velocity += self.physics_body.get_delta_rotational_velocity(dt)
+            
+        # update children transforms
+        for child in self.children: child.sync_data()
         
-    def sync_data(self, dt: float) -> None: # TODO only needed for child nodes now
-        ...
+    def sync_data(self) -> None:
+        """
+        Syncronizes this node with the parent node based on its relative positioning
+        """
+        # calculate transform matrix with the given input
+        transform = glm.mat4x4()
+        if self.relative_position: transform  = glm.translate(transform, self.parent.position)
+        if self.relative_rotation: transform *= glm.transpose(glm.mat4_cast(self.parent.rotation))
+        if self.relative_scale:    transform  = glm.scale(transform, self.parent.scale)
+        
+        # set this node's transforms based on the parent
+        self.position = transform * self.relative_position
+        self.scale = self.relative_scale * self.parent.scale
+        self.rotation = self.relative_rotation * self.parent.rotation
+        
+        for child in self.children: child.sync_data()
         
     def get_nodes(self, 
             require_mesh: bool=False, 
@@ -217,13 +268,33 @@ class Node():
         
         # adds children to nodes list if they match the criteria
         for node in self.children: nodes.extend(node.get_nodes(require_mesh, require_collider, require_physics_body, filter_material, filter_tags))
-        return node 
+        return nodes 
         
-    def adopt_child(self, node) -> None: # TODO determine the best way for the user to do this through the scene
-        ...
+    # tree functions for managing children 
+    def add(self, child: ..., relative_position: bool=None, relative_scale: bool=None, relative_rotation: glm.vec3=None) -> None:
+        """
+        Adopts a node as a child. Relative transforms can be changed, if left bank they will not be chnaged from the current child nodes settings.
+        """
+        if child in self.children: return
+        
+        # compute relative transformations
+        if relative_position or (relative_position is None and child.relative_position): child.relative_position = child.position - self.position
+        if relative_scale    or (relative_scale    is None and child.relative_scale):    child.relative_scale    = child.scale / self.scale
+        if relative_rotation or (relative_rotation is None and child.relative_rotation): child.relative_rotation = child.rotation * glm.inverse(self.rotation)
         
-    def add_child(self) -> None: # TODO add node constructor
-        ... 
+        # add as a child to by synchronized and controlled
+        if self.node_handler: self.node_handler.add(child)
+        child.parent = self
+        self.children.append(child)
+        
+    def remove(self, child: ...) -> None:
+        """
+        Removes a child node from this nodes chlid list.
+        """
+        if child in self.children: 
+            if self.node_handler: self.node_handler.remove(child)
+            child.parent = None
+            self.children.remove(child)
         
     def apply_force(self, force: glm.vec3, dt: float) -> None:
         """
@@ -256,7 +327,7 @@ class Node():
         Transforms the mesh inertia tensor and inverts it
         """
         if not (self.mesh and self.physics_body): return None 
-        inertia_tensor = self.mesh.get_inertia_tensor(self.scale)
+        inertia_tensor = self.mesh.get_inertia_tensor(self.scale) / 2
     
         # mass
         if self.physics_body: inertia_tensor *= self.physics_body.mass
@@ -266,6 +337,12 @@ class Node():
         inertia_tensor  = rotation_matrix * inertia_tensor * glm.transpose(rotation_matrix)
         
         return glm.inverse(inertia_tensor)
+    
+    def get_vertex(self, index) -> glm.vec3:
+        """
+        Gets the world space position of a vertex indicated by the index in the mesh
+        """
+        return glm.vec3(self.model_matrix * glm.vec4(*self.mesh.points[index], 1))
 
     def get_data(self) -> np.ndarray:
         """
@@ -274,15 +351,41 @@ class Node():
         
         # Get data from the mesh node
         mesh_data = self.mesh.data
-        node_data = np.array([*self.position, *self.rotation, *self.scale, self.material.index])
+        node_data = np.array([*self.position, *self.rotation, *self.scale, 0])
+
+        per_vertex_mtl = isinstance(self.material, list)
+
+        if not per_vertex_mtl: node_data[-1] = self.material.index
 
         # Create an array to hold the node's data
         data = np.zeros(shape=(mesh_data.shape[0], 25), dtype='f4')
+
+
         data[:,:14] = mesh_data
         data[:,14:] = node_data
 
+        if per_vertex_mtl: data[:,24] = self.material
+
         return data
 
+    def write_materials(self):
+        """
+        Internal function to write the material list to the material handler and get the material ids
+        """
+
+        if isinstance(self.material, list):
+            mtl_index_list = []
+            for mtl in self._mtl_list:
+                self.node_handler.scene.material_handler.add(mtl)
+                mtl_index_list.append(mtl.index)
+                mtl_index_list.append(mtl.index)
+                mtl_index_list.append(mtl.index)
+            self._material = mtl_index_list
+
+        if isinstance(self.material, type(None)):
+            self.material = self.scene.material_handler.base
+        
+
     def __repr__(self) -> str:
         """
         Returns a string representation of the node
@@ -298,7 +401,8 @@ class Node():
     def rotation(self): return self.internal_rotation.data
     @property
     def forward(self):  return self._forward
-    # TODO add property for Mesh
+    @property
+    def mesh(self):     return self._mesh
     @property
     def material(self): return self._material
     @property
@@ -366,6 +470,9 @@ class Node():
             if len(value) != 3: raise ValueError(f'Node: Invalid number of values for position. Expected 3, got {len(value)}')
             self.internal_position.data = glm.vec3(value)
         else: raise TypeError(f'Node: Invalid position value type {type(value)}')
+        
+        # # compute relative position if all cases passed
+        # if self.parent and self.relative_position: self.relative_position = self.internal_position.data - self.parent.position
     
     @scale.setter
     def scale(self, value: tuple | list | glm.vec3 | np.ndarray):
@@ -374,6 +481,9 @@ class Node():
             if len(value) != 3: raise ValueError(f'Node: Invalid number of values for scale. Expected 3, got {len(value)}')
             self.internal_scale.data = glm.vec3(value)
         else: raise TypeError(f'Node: Invalid scale value type {type(value)}')
+        
+        # # compute relative scale
+        # if self.parent and self.relative_scale: self.relative_scale = self.internal_scale.data / self.parent.scale
 
     @rotation.setter
     def rotation(self, value: tuple | list | glm.vec3 | glm.quat | glm.vec4 | np.ndarray):
@@ -383,6 +493,9 @@ class Node():
             elif len(value) == 4: self.internal_rotation.data = glm.quat(*value)
             else: raise ValueError(f'Node: Invalid number of values for rotation. Expected 3 or 4, got {len(value)}')
         else: raise TypeError(f'Node: Invalid rotation value type {type(value)}')
+        
+        # # compute relative rotation
+        # if self.parent and self.relative_rotation: self.relative_rotation = self.rotation * glm.inverse(self.parent.rotation)
 
     @forward.setter
     def forward(self, value: tuple | list | glm.vec3 | np.ndarray):
@@ -392,16 +505,42 @@ class Node():
             self._forward = glm.vec3(value)
         else: raise TypeError(f'Node: Invalid forward value type {type(value)}')
         
-    # TODO add setter for Mesh
+    @mesh.setter
+    def mesh(self, value: Mesh | None):
+        if isinstance(value, Mesh):
+            self._mesh = value
+            if self.chunk: self.chunk.update()
+        elif isinstance(value, type(None)):
+            self._mesh = None
+            if not self.chunk: return
+            self.chunk.remove(self)
+            self.chunk.update()
+        else: raise TypeError(f'Node: Invalid mesh value type {type(value)}')
     
     @material.setter
     def material(self, value: Material):
-        if isinstance(value, Material): 
+        if isinstance(value, list):
+            self._mtl_list = value
+            if not self.node_handler: 
+                self._material = value
+            else:
+                mtl_index_list = []
+                for mtl in self._mtl_list:
+                    self.node_handler.scene.material_handler.add(mtl)
+                    mtl_index_list.append(mtl.index)
+                    mtl_index_list.append(mtl.index)
+                    mtl_index_list.append(mtl.index)
+                self._material = mtl_index_list
+        elif isinstance(value, Material): 
             self._material = value
-            self.node_handler.scene.material_handler.add(value)
-            if not self.chunk: return
-            self.chunk.node_update_callback(self)
+            if self.node_handler: self.node_handler.scene.material_handler.add(value)
+        elif isinstance(value, type(None)):
+            if self.scene: self._material = self.scene.material_handler.base
+            else: self._material = None
+
         else: raise TypeError(f'Node: Invalid material value type {type(value)}')
+        if not self.chunk: return
+        self.chunk.node_update_callback(self)
     
     @velocity.setter
     def velocity(self, value: tuple | list | glm.vec3 | np.ndarray):

basilisk/nodes/node_handler.py

@@ -37,62 +37,83 @@ class NodeHandler():
         
         self.chunk_handler.render()
 
-    def add(self, 
-            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=False, 
-            mass:                float=None, 
-            collisions:          bool=False, 
-            collider:            str=None, 
-            static_friction:     float=None, 
-            kinetic_friction:    float=None, 
-            elasticity:          float=None, 
-            collision_group :    float=None, 
-            name:                str='', 
-            tags:                list[str]=None,
-            static:              bool=True
-        ) -> Node:
+    def add(self, node: Node) -> Node:
         """
         Adds a new node to the node handler
         """
+        if node in self.nodes: return
         
-        node = Node(self, position, scale, rotation, forward, mesh, material, velocity, rotational_velocity, physics, mass, collisions, collider, static_friction, kinetic_friction, elasticity, collision_group, name, tags, static)
-
-        self.nodes.append(node)
-        self.chunk_handler.add(node)
+        for n in node.get_nodes(): # gets all nodes including the node to be added
+            
+            # Update scene Handlers
+            self.scene.shader_handler.add(n.shader)
+            if not n.material: n.material = self.scene.material_handler.base
+            self.scene.material_handler.add(n.material)
+            
+            # Update the node attributes
+            n.init_scene(self.scene)
+            
+            # Add the node to internal data
+            self.nodes.append(n)
+            self.chunk_handler.add(n)
 
         return node
+    
+    def node_is(self, node: 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
+            ])
         
-    def get(self, name: str) -> Node: # TODO switch to full filter and adapt to search roots
+    def get(self, 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) -> Node:
         """
         Returns the first node with the given traits
         """
         for node in self.nodes:
-            if node.name == name: return node
+            if self.node_is(node, position, scale, rotation, forward, mesh, material, velocity, rotational_velocity, physics, mass, collisions, static_friction, kinetic_friction, elasticity, collision_group, name, tags, static): return node
         return None
     
-    def get_all(self, name: str) -> Node:
+    def get_all(self, 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) -> Node:
         """
         Returns all nodes with the given traits
         """
         nodes = []
         for node in self.nodes:
-            if node.name == name: nodes.append(node)
+            if self.node_is(node, position, scale, rotation, forward, mesh, material, velocity, rotational_velocity, physics, mass, collisions, static_friction, kinetic_friction, elasticity, collision_group, name, tags, static): nodes.append(node)
         return nodes
     
     def remove(self, node: Node) -> None: 
         """
         Removes a node and all of its children from their handlers
         """
+
+        if node == None: return
+
         # TODO add support for recursive nodes
         if node in self.nodes:
             if node.physics_body: self.scene.physics_engine.remove(node.physics_body)
             if node.collider: self.scene.collider_handler.remove(node.collider)
+            self.chunk_handler.remove(node)
+            self.nodes.remove(node)
             node.node_handler = None
-            self.nodes.remove(node)
+            
+        for child in node.children: self.remove(child)

basilisk/particles/particle_handler.py

@@ -0,0 +1,55 @@
+from .particle_renderer import ParticleRenderer 
+from ..mesh.mesh import Mesh
+from ..render.material import Material
+
+
+class ParticleHandler:
+    def __init__(self, scene):
+        """
+        A handler for all particles in a scene
+        """
+        
+        self.scene = scene
+        self.cube = Mesh(scene.engine.root + '/bsk_assets/cube.obj')
+        self.particle_renderers = {self.cube : ParticleRenderer(scene, self.cube)}
+
+
+    def add(self, mesh: Mesh=None, life=1.0, position=(0, 0, 0), material: Material=None, scale=1.0, velocity=(0, 3, 0), acceleration=(0, -10, 0)) -> bool:
+        """
+        Add a new particle to the scene
+        Args:
+            mesh: Mesh
+                The basilisk mesh of the particle
+            life: float
+                The duration of the particle in seconds
+            position: tuple (x, y, z)
+                The initial position of the particle
+            color: tuple (r, g, b) (components out of 255) 
+                The color of the particle
+            scale: float
+                The overall scale factor of the particle
+            velocity: tuple (x, y, z)
+                The inital velocity of the particle as a vector
+            acceleration: tuple (x, y, z)
+                The permanent acceleration of the particle as a vector
+        """
+
+        # Get the mesh and make a new particle renderer if the mesh is new
+        if mesh == None: mesh = self.cube
+        elif not isinstance(mesh, Mesh): raise ValueError(f'particle_handler.add: invlaid mesh type for particle: {type(mesh)}')
+        if mesh not in self.particle_renderers: self.particle_renderers[mesh] = ParticleRenderer(self.scene, mesh)
+
+        # Get material ID
+        if material == None: material_index = 0
+        elif isinstance(material, Material): 
+            self.scene.material_handler.add(material)
+            material_index = material.index
+        else: raise ValueError(f'particle_handler.add: Invalid particle material type: {type(material)}')
+
+        # Add the particle to the renderer
+        self.particle_renderers[mesh].add(life, position, material_index, scale, velocity, acceleration)
+
+    def render(self) -> None:
+        for renderer in self.particle_renderers.values(): renderer.render()
+    def update(self) -> None:
+        for renderer in self.particle_renderers.values(): renderer.update()

basilisk/particles/particle_renderer.py

@@ -0,0 +1,87 @@
+import numpy as np
+from ..render.shader import Shader
+from ..mesh.mesh import Mesh
+from ..render.material import Material
+from numba import njit
+
+
+@njit
+def update_particle_matrix(particle_instances, dt):
+    particle_instances[:,6:9] += particle_instances[:,9:12] * dt
+    particle_instances[:,:3] += particle_instances[:,6:9] * dt
+    particle_instances[:,5] -= dt/3
+    return particle_instances
+
+@njit
+def get_alive(particles):
+    return particles[particles[:, 5] >= 0]
+
+update_particle_matrix(np.zeros(shape=(2, 12), dtype='f4'), 1)
+get_alive(np.zeros(shape=(2, 12), dtype='f4'))
+
+
+class ParticleRenderer:
+    def __init__(self, scene: ..., mesh: Mesh) -> None:
+        """
+        Handels and renders the particles of a single mesh type
+        """
+        
+        self.scene = scene
+        self.ctx = scene.ctx
+        root = scene.engine.root
+        self.shader = Shader(scene.engine, vert=root + '/shaders/particle.vert', frag=root + '/shaders/particle.frag')
+        scene.shader_handler.add(self.shader)
+
+        self.particle_cube_size = 25
+
+        self.particle_instances = np.zeros(shape=(1, 12), dtype='f4')
+        self.instance_buffer = self.ctx.buffer(reserve=(12 * 3) * (self.particle_cube_size ** 3))
+        
+        self.vao = self.ctx.vertex_array( self.shader.program, 
+                                        [(self.ctx.buffer(mesh.data), '3f 2f 3f 3f 3f', *['in_position', 'in_uv', 'in_normal', 'in_tangent', 'in_bitangent']), 
+                                         (self.instance_buffer, '3f 1f 1f 1f /i', 'in_instance_pos', 'in_instance_mtl', 'scale', 'life')], 
+                                          skip_errors=True)
+
+    def render(self) -> None:
+        """
+        Renders the alive particles in the scene
+        """
+        
+        # Get the current particles
+        alive_particles = get_alive(self.particle_instances)
+        n = len(alive_particles)
+
+        # Write and render
+        self.instance_buffer.write(np.array(alive_particles[:,:6], order='C'))
+        self.vao.render(instances=n)
+
+    def update(self) -> None:
+        """
+        Updates the particle positions based on their given properties
+        """
+        
+        self.particle_instances = get_alive(self.particle_instances)
+        self.particle_instances = update_particle_matrix(self.particle_instances, self.scene.engine.delta_time)
+
+    def add(self, life=1.0, position=(0, 0, 0), material: int=0, scale=1.0, velocity=(0, 3, 0), acceleration=(0, -10, 0)) -> bool:
+        """
+        Add a new particle to the scene
+        Args:
+            life: float
+                The duration of the particle in seconds
+            position: tuple (x, y, z)
+                The initial position of the particle
+            color: tuple (r, g, b) (components out of 255) 
+                The color of the particle
+            scale: float
+                The overall scale factor of the particle
+            velocity: tuple (x, y, z)
+                The inital velocity of the particle as a vector
+            acceleration: tuple (x, y, z)
+                The permanent acceleration of the particle as a vector
+        """
+        # Check if there is already the max number of particles
+        if len(self.particle_instances) >= (self.particle_cube_size ** 3): return False
+        # Create and add the particle to the scene
+        new_particle = np.array([*position, material, scale, life, *velocity, *acceleration])
+        self.particle_instances = np.vstack([new_particle, self.particle_instances], dtype='f4')

basilisk/physics/impulse.py

@@ -21,9 +21,6 @@ def calculate_collisions(normal:glm.vec3, node1: Node, node2: Node, contact_poin
     elasticity = max(collider1.elasticity, collider2.elasticity)
     kinetic    = min(collider1.kinetic_friction, collider2.kinetic_friction)
     static     = min(collider1.static_friction, collider2.static_friction)
-    num_points = len(contact_points)
-    
-    total_impulse = glm.vec3(0, 0, 0)
     
     # calculate impulses from contact points
     if has_physics1 and has_physics2:
@@ -32,29 +29,26 @@ def calculate_collisions(normal:glm.vec3, node1: Node, node2: Node, contact_poin
             # apply impulse based reduced by total points
             radius1, radius2 = contact_point - center1, contact_point - center2
             impulse = calculate_impulse2(node1, node2, inv_mass1, inv_mass2, node1.rotational_velocity, node2.rotational_velocity, radius1, radius2, inv_inertia1, inv_inertia2, elasticity, kinetic, static, normal)
-            total_impulse += impulse / num_points
             
-        # apply impulses
-        apply_impulse(radius1, total_impulse, inv_inertia1, inv_mass1, node1)
-        apply_impulse(radius2, -total_impulse, inv_inertia2, inv_mass2, node2)
+            # apply impulses
+            apply_impulse(radius1, impulse, inv_inertia1, inv_mass1, node1)
+            apply_impulse(radius2, -impulse, inv_inertia2, inv_mass2, node2)
             
     elif has_physics1:
         for contact_point in contact_points:
             radius = contact_point - center1
             impulse = calculate_impluse1(node1, inv_mass1, node1.rotational_velocity, radius, inv_inertia1, elasticity, kinetic, static, normal)
-            total_impulse += impulse / num_points
             
-        # apply impulses
-        apply_impulse(radius, total_impulse, inv_inertia1, inv_mass1, node1)
+            # apply impulses
+            apply_impulse(radius, impulse, inv_inertia1, inv_mass1, node1)
             
     else: # only physics body 2
         for contact_point in contact_points:
             radius = contact_point - center2
             impulse = calculate_impluse1(node2, inv_mass2, node2.rotational_velocity, radius, inv_inertia2, elasticity, kinetic, static, normal)
-            total_impulse += impulse / num_points
             
-        # apply impulse
-        apply_impulse(radius, total_impulse, inv_inertia2, inv_mass2, node2)
+            # apply impulse
+            apply_impulse(radius, impulse, inv_inertia2, inv_mass2, node2)
     
 def calculate_impluse1(node: Node, inv_mass, omega, radius, inv_inertia, elasticity, kinetic, static, normal) -> glm.vec3:
     """