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

basilisk/nodes/node_handler.py

@@ -1,119 +1,96 @@
-import glm
-from .node import Node
-from ..render.chunk_handler import ChunkHandler
-from ..mesh.mesh import Mesh
-from ..render.material import Material
-
-
-class NodeHandler():
-    scene: ...
-    """Back reference to the scene"""
-    nodes: list[Node]
-    """The list of root nodes in the scene"""
-    
-    def __init__(self, scene):
-        """
-        Contains all the nodes in the scene.
-        Handles chunking and batching of nodes
-        """
-        
-        self.scene = scene
-        self.nodes = []
-        self.chunk_handler = ChunkHandler(scene)
-
-    def update(self):
-        """
-        Updates the nodes and chunks in the scene
-        """
-        for node in self.nodes: 
-            if node.static: continue
-            node.update(self.scene.engine.delta_time)
-        self.chunk_handler.update()
-
-    def render(self):
-        """
-        Updates the node meshes in the scene
-        """
-        
-        self.chunk_handler.render()
-
-    def add(self, node: Node) -> Node:
-        """
-        Adds a new node to the node handler
-        """
-        if node in self.nodes: return
-        
-        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, 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 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, 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 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
-            
+import glm
+from .node import Node
+from .helper import node_is
+from ..render.chunk_handler import ChunkHandler
+from ..mesh.mesh import Mesh
+from ..render.material import Material
+
+
+class NodeHandler():
+    scene: ...
+    """Back reference to the scene"""
+    nodes: list[Node]
+    """The list of root nodes in the scene"""
+    
+    def __init__(self, scene):
+        """
+        Contains all the nodes in the scene.
+        Handles chunking and batching of nodes
+        """
+        
+        self.scene = scene
+        self.nodes = []
+        self.chunk_handler = ChunkHandler(scene)
+
+    def update(self):
+        """
+        Updates the nodes and chunks in the scene
+        """
+        dt = self.scene.engine.delta_time
+        if dt < 0.5:
+            for node in self.nodes: 
+                if not node.static: node.update(dt)
+        self.chunk_handler.update()
+
+    def render(self):
+        """
+        Updates the node meshes in the scene
+        """
+        
+        self.chunk_handler.render()
+
+    def add(self, node: Node) -> Node:
+        """
+        Adds a new node to the node handler
+        """
+        if node in self.nodes: return
+        
+        for n in node.get_all(): # 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 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_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, 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) -> list[Node]:
+        """
+        Returns all nodes with the given traits
+        """
+        nodes = []
+        for node in self.nodes:
+            if 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
+            
         for child in node.children: self.remove(child)

basilisk/particles/particle_handler.py

@@ -1,55 +1,64 @@
-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:
+from .particle_renderer import ParticleRenderer 
+from ..mesh.mesh import Mesh
+from ..render.material import Material
+from ..generic.input_validation import validate_tuple3, validate_float
+
+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: float=1.0, position: tuple|float=0, material: Material=None, scale: float=1.0, velocity: tuple|float=0, acceleration: tuple|float=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)}')
+
+        # Validate the 3-component vectors
+        position     = validate_tuple3('particle', 'add', position)
+        velocity     = validate_tuple3('particle', 'add', velocity)
+        acceleration = validate_tuple3('particle', 'add', acceleration)
+
+        # Validate float inputs
+        life = validate_float('particle', 'add', life)
+        scale = validate_float('particle', 'add', scale)
+
+        # 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

@@ -1,87 +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')
+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')