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

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

@@ -0,0 +1,113 @@
+import glm
+from ..nodes.node import Node
+
+def calculate_collisions(normal:glm.vec3, node1: Node, node2: Node, contact_points:list[glm.vec3], inv_inertia1:glm.mat3x3, inv_inertia2:glm.mat3x3, center1:glm.vec3, center2:glm.vec3) -> None:
+    """
+    Resolve the collisions between two objects with multiple contact points
+    """
+    physics_body1 = node1.physics_body
+    physics_body2 = node2.physics_body
+    collider1 = node1.collider
+    collider2 = node2.collider
+    
+    # determine whether or not the colliders have physics
+    has_physics1, has_physics2 = physics_body1 is not None, physics_body2 is not None
+    
+    # get physics data from valid bodies
+    if has_physics1: inv_mass1 = 1 / physics_body1.mass
+    if has_physics2: inv_mass2 = 1 / physics_body2.mass
+    
+    # gets coefficients
+    elasticity = max(collider1.elasticity, collider2.elasticity)
+    kinetic    = min(collider1.kinetic_friction, collider2.kinetic_friction)
+    static     = min(collider1.static_friction, collider2.static_friction)
+    
+    # calculate impulses from contact points
+    if has_physics1 and has_physics2:
+        for contact_point in contact_points:
+            
+            # 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)
+            
+            # 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)
+            
+            # 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)
+            
+            # 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:
+    """
+    Calculates the impulse from a collision including friction from the impulse
+    """
+    # determine if mass needs to be calculated TODO determine if this is a good check
+    if glm.dot(radius, node.velocity) < 0: return glm.vec3(0, 0, 0)
+    
+    # normal impulse
+    relative_velocity        = node.velocity + glm.cross(omega, radius)
+    relative_normal_velocity = glm.dot(relative_velocity, normal)
+    
+    # calculate denominator
+    denominator = inv_mass + glm.dot(normal, glm.cross(inv_inertia * glm.cross(radius, normal), radius))
+    
+    # calculate normal impulse
+    normal_impulse_magnitude = -(1 + elasticity) * relative_normal_velocity / denominator
+    normal_impulse           = normal_impulse_magnitude * normal
+    
+    # friction impulse
+    rel_tan_vel     = relative_velocity - glm.dot(relative_velocity, normal) * normal
+    rel_tan_vel_len = glm.length(rel_tan_vel)
+    
+    if rel_tan_vel_len < 1e-7:   friction_impulse = glm.vec3(0, 0, 0)                                                   # no friction
+    elif rel_tan_vel_len < 1e-2: friction_impulse = -static * glm.length(normal_impulse) * glm.normalize(rel_tan_vel)   # static friction
+    else:                        friction_impulse = -kinetic * glm.length(normal_impulse) * glm.normalize(rel_tan_vel)  # kinetic friction
+    
+    # return total impulse
+    return normal_impulse + friction_impulse
+    
+def calculate_impulse2(node1: Node, node2: Node, inv_mass1, inv_mass2, omega1, omega2, radius1, radius2, inv_inertia1, inv_inertia2, elasticity, kinetic, static, normal) -> glm.vec3:
+    """
+    Calculates the impulse from a collision including friction from the impulse
+    """
+    # normal impulse
+    relative_velocity = node1.velocity + glm.cross(omega1, radius1) - (node2.velocity + glm.cross(omega2, radius2))
+    relative_normal_velocity = glm.dot(relative_velocity, normal)
+    # calculate denominator
+    term1 = inv_mass1 + inv_mass2
+    term2 = glm.dot(normal, glm.cross(inv_inertia1 * glm.cross(radius1, normal), radius1) + glm.cross(inv_inertia2 * glm.cross(radius2, normal), radius2))
+    # calculate normal impulse
+    normal_impulse = -(1 + elasticity) * relative_normal_velocity / (term1 + term2) * normal
+    
+    # friction impulse
+    rel_tan_vel = relative_velocity - glm.dot(relative_velocity, normal) * normal
+    rel_tan_vel_len = glm.length(rel_tan_vel)
+    if rel_tan_vel_len < 1e-7: friction_impulse = glm.vec3(0, 0, 0)
+    elif rel_tan_vel_len < 1e-2: friction_impulse = -static * glm.length(normal_impulse) * glm.normalize(rel_tan_vel)
+    else: friction_impulse = -kinetic * glm.length(normal_impulse) * glm.normalize(rel_tan_vel)
+    # return total impulse
+    return normal_impulse + friction_impulse
+
+def apply_impulse(radius, impulse_signed, inv_inertia, inv_mass, node: Node) -> None:
+    """
+    Applies the given impulse to the physics body, changing translational and rotational velcoity. 
+    """
+    
+    # Update linear velocity
+    node.velocity += impulse_signed * inv_mass
+    
+    # update rotational velcoity
+    node.rotational_velocity += inv_inertia * glm.cross(radius, impulse_signed)

basilisk/physics/physics_body.py

@@ -6,8 +6,8 @@ class PhysicsBody():
     mass: float
     """The mass of the physics body in kg"""
 
-    def __init__(self, physics_engine, mass:float=1.0) -> None:
-        self.physics_engine = physics_engine
+    def __init__(self, mass:float=1.0) -> None:
+        self.physics_engine = None
         self.mass = mass 
         
     def get_delta_velocity(self, dt: float) -> glm.vec3:
@@ -32,5 +32,13 @@ class PhysicsBody():
         # TODO add torques
         return dw
     
+    @property
+    def physics_engine(self): return self._physics_engine
+
+    @physics_engine.setter
+    def physics_engine(self, value): 
+        self._physics_engine = value
+        if value: value.add(self)
+
     def __repr__(self) -> str:
         return f'<Physics Body| {self.mass}>'

basilisk/physics/physics_engine.py

@@ -15,16 +15,15 @@ class PhysicsEngine():
     
     def __init__(self, accelerations: list[glm.vec3] = None, rotational_accelerations: list[glm.vec3] = None, forces: list[glm.vec3] = None, torques: list[glm.vec3] = None) -> None:
         self.physics_bodies = []
-        self.accelerations = accelerations if accelerations else [glm.vec3(0, -1, 0)]
+        self.accelerations = accelerations if accelerations else [glm.vec3(0, -9.8, 0)]
         self.rotational_accelerations = rotational_accelerations if rotational_accelerations else []
         self.forces = forces if forces else []
         self.torques = torques if torques else []
         
-    def add(self, mass: float) -> PhysicsBody:
+    def add(self, physics_body: PhysicsBody) -> PhysicsBody:
         """
         Adds a physics body to the physics engine and returns it
         """
-        physics_body = PhysicsBody(self, mass)
         self.physics_bodies.append(physics_body)
         return physics_body
     

basilisk/render/batch.py

@@ -23,7 +23,7 @@ class Batch():
         # Back references
         self.chunk = chunk
         self.ctx = chunk.chunk_handler.engine.ctx
-        self.program = chunk.chunk_handler.program
+        self.program = self.chunk.get_program()
 
         # Set intial values
         self.vbo = None
@@ -35,6 +35,8 @@ class Batch():
         Returns True if batch was successful.
         """
 
+        self.program = self.chunk.get_program()
+
         # Empty list to contain all vertex data of models in the chunk
         batch_data = []
 

basilisk/render/camera.py

@@ -85,6 +85,11 @@ class Camera:
     def get_params(self) -> tuple:
         return self.engine, self.position, self.yaw, self.pitch
     
+    def look_at(self, other) -> None:
+        forward = glm.normalize(other.position - self.position)
+        self.yaw = np.degrees(np.arctan2(forward.z, forward.x))
+        self.pitch = np.degrees(np.arctan2(forward.y, np.sqrt(forward.x ** 2 + forward.z ** 2)))
+
     def __repr__(self):
         return f'<Basilisk Camera | Position: {self.position}, Direction: {self.forward}>'
 
@@ -145,7 +150,7 @@ class FreeCamera(Camera):
         """
         Checks for button presses and updates vectors accordingly. 
         """
-        velocity = SPEED * self.engine.delta_time
+        velocity = (SPEED + self.engine.keys[pg.K_CAPSLOCK] * 10) * self.engine.delta_time
         keys = self.engine.keys
         if keys[pg.K_w]:
             self.position += glm.normalize(glm.vec3(self.forward.x, 0, self.forward.z)) * velocity
@@ -161,6 +166,35 @@ class FreeCamera(Camera):
             self.position -= self.UP * velocity
 
 
+class FollowCamera(FreeCamera):
+    def __init__(self, parent, position=(0, 0, 20), yaw=-90, pitch=0, offset=(0, 0, 0)):
+        super().__init__(position, yaw, pitch)
+        self.parent = parent
+        self.offest = glm.vec3(offset)
+    
+    def move(self) -> None:
+        """
+        Moves the camera to the parent node
+        """
+
+        self.position = self.parent.position + self.offest
+        
+class OrbitCamera(FreeCamera):
+    def __init__(self, parent, position=(0, 0, 20), yaw=-90, pitch=0, distance=5):
+        self.parent = parent
+        self.distance = distance
+        super().__init__(position, yaw, pitch)
+
+    def get_view_matrix(self) -> glm.mat4x4:
+        return glm.lookAt(self.position, self.parent.position, self.up)
+
+    def move(self) -> None:
+        """
+        Moves the camera to the parent node
+        """
+
+        self.position = self.parent.position - glm.normalize(self.forward) * self.distance
+
 class StaticCamera(Camera):
     def __init__(self, position=(0, 0, 20), yaw=-90, pitch=0):
         super().__init__(position, yaw, pitch)

basilisk/render/chunk.py

@@ -4,7 +4,7 @@ from .batch import Batch
 class Chunk():
     chunk_handler: ...
     """Back refrence to the parent chunk handler"""
-    chunk_key: tuple
+    position: tuple
     """The position of the chunk. Used as a key in the chunk handler"""
     batch: Batch
     """Batched mesh of the chunk"""
@@ -13,7 +13,7 @@ class Chunk():
     static: bool
     """Type of node that the chunk recognizes"""
 
-    def __init__(self, chunk_handler, chunk_key: tuple, static: bool) -> None:
+    def __init__(self, chunk_handler, position: tuple, static: bool, shader=None) -> None:
         """
         Basilisk chunk object. 
         Contains references to all nodes in the chunk.
@@ -22,9 +22,11 @@ class Chunk():
 
         # Back references
         self.chunk_handler = chunk_handler
-        self.chunk_key = chunk_key
 
+        # Chunk Attrbiutes
+        self.position = position
         self.static = static
+        self.shader = shader
 
         # Create empty batch
         self.batch = Batch(self)
@@ -70,12 +72,25 @@ class Chunk():
         Removes a node from the chunk
         """
 
+        if node == None: return
+
         self.nodes.remove(node)
+        if self.batch and self.batch.vbo: self.batch.vbo.clear()
 
         return node
 
+    def get_program(self):
+        """
+        Gets the program of the chunks nodes' shader
+        """
+
+        shader = self.shader
+
+        if shader: return shader.program
+        return self.chunk_handler.engine.shader.program
+
     def __repr__(self) -> str:
-        return f'<Basilisk Chunk | {self.chunk_key}, {len(self.nodes)} nodes, {'static' if self.static else 'dynamic'}>'
+        return f'<Basilisk Chunk | {self.position}, {len(self.nodes)} nodes, {"static" if self.static else "dynamic"}>'
 
     def __del__(self) -> None:
         """

basilisk/render/chunk_handler.py

@@ -15,8 +15,8 @@ class ChunkHandler():
     """Reference to the shader program used by batches"""
     chunks: list[dict]
     """List containing two dictionaries for dynamic and static chunks repsectivly"""
-    updated_chunks: list[set]
-    """List containing two dictionaries for recently updated dynamic and static chunks repsectivly"""
+    updated_chunks: set
+    """Set containing recently updated chunks"""
     
     def __init__(self, scene) -> None:
         # Reference to the scene hadlers and variables
@@ -28,11 +28,12 @@ class ChunkHandler():
         self.scene   = scene
         self.engine  = scene.engine
         self.ctx     = scene.engine.ctx
-        self.program = scene.shader_handler.programs['batch']
+        self.program = scene.engine.shader.program
 
         # List for the dynamic and static chunk dictionaries | [dyanmic: dict, static: dict]
-        self.chunks         = [{}   , {}   ]
-        self.updated_chunks = [set(), set()]
+        self.shader_groups = {None : ({}, {})}
+        # self.chunks         = [{}, {}]
+        self.updated_chunks = set()
 
 
     def render(self) -> None:
@@ -47,10 +48,12 @@ class ChunkHandler():
         chunk_keys = [(x, y, z) for x in range(*render_range_x) for y in range(*render_range_y) for z in range(*render_range_z)]
 
         # Loop through all chunks in view and render
-        for chunk in chunk_keys:
-            # Render the chunk if it exists
-            if chunk in self.chunks[0]: self.chunks[0][chunk].render()
-            if chunk in self.chunks[1]: self.chunks[1][chunk].render()
+        for shader, group in self.shader_groups.items():
+            if shader == None: shader = self.engine.shader            
+            for chunk in chunk_keys:
+                # Render the chunk if it exists
+                if chunk in group[0]: group[0][chunk].render()
+                if chunk in group[1]: group[1][chunk].render()
 
 
     def update(self) -> None:           
@@ -58,23 +61,29 @@ class ChunkHandler():
         Updates all the chunks that have been updated since the last frame. 
         """ 
 
+        self.program = self.scene.engine.shader.program
+
         # Loop through the set of updated chunk keys and update the chunk
         removes = []
 
-        for chunk in self.updated_chunks[0]: 
-            if chunk.update(): continue
-            removes.append((0, chunk))
-        for chunk in self.updated_chunks[1]: 
+        for chunk in self.updated_chunks: 
             if chunk.update(): continue
-            removes.append((1, chunk))
+            removes.append(chunk)
 
         # Remove any empty chunks
-        for chunk_tuple in removes:
-            if chunk_tuple[1] not in self.chunks[chunk_tuple[0]]: continue
-            del self.chunks[chunk_tuple[0]][chunk_tuple[1]]
+        for chunk in removes:
+            del self.shader_groups[chunk.shader][chunk.static][chunk.position]
 
         # Clears the set of updated chunks so that they are not updated unless they are updated again
-        self.updated_chunks = [set(), set()]
+        self.updated_chunks.clear()
+
+    def update_all(self):
+        self.program = self.scene.engine.shader.program
+        for shader in self.shader_groups.values():
+            for chunk in shader[0].values():
+                self.updated_chunks.add(chunk)
+            for chunk in shader[1].values():
+                self.updated_chunks.add(chunk)
 
     def add(self, node: Node) -> Node:
         """
@@ -84,24 +93,31 @@ class ChunkHandler():
         # The key of the chunk the node will be added to
         chunk_size = self.engine.config.chunk_size
         chunk_key = (int(node.x // chunk_size), int(node.y // chunk_size), int(node.z // chunk_size))
+        shader = node.shader
+
+        if shader not in self.shader_groups:
+            self.shader_groups[shader] = ({}, {})
 
         # Ensure that the chunk exists
-        if chunk_key not in self.chunks[node.static]:
-            self.chunks[node.static][chunk_key] = Chunk(self, chunk_key, node.static)
+        if chunk_key not in self.shader_groups[shader][node.static]:
+            chunk = Chunk(self, chunk_key, node.static, shader)
+            self.shader_groups[shader][node.static][chunk_key] = chunk
 
         # Add the node to the chunk
-        self.chunks[node.static][chunk_key].add(node)
+        self.shader_groups[shader][node.static][chunk_key].add(node)
 
         # Update the chunk
-        self.updated_chunks[node.static].add(self.chunks[node.static][chunk_key])
+        self.updated_chunks.add(self.shader_groups[shader][node.static][chunk_key])
 
         return Node
 
-    def remove(self, node) -> None:
+    def remove(self, node: Node) -> None:
         """
         Removes a node from the its chunk
         """
 
+        if node == None: return
+
         # Remove the node
         chunk = node.chunk
         chunk.remove(node)

basilisk/render/image.py

@@ -7,7 +7,7 @@ import pygame as pg
 from PIL import Image as PIL_Image
 
 
-texture_sizes = (128, 256, 512, 1024, 2048)
+texture_sizes = (8, 64, 512, 1024, 2048)
 
 
 class Image():

basilisk/render/image_handler.py

@@ -3,7 +3,7 @@ import glm
 import numpy as np
 
 
-texture_sizes = (128, 256, 512, 1024, 2048)
+texture_sizes = (8, 64, 512, 1024, 2048)
 
 
 class ImageHandler():
@@ -43,8 +43,7 @@ class ImageHandler():
         if image in self.images: return
 
         self.images.append(image)
-        self.write(self.scene.shader_handler.programs['batch'])
-        self.write(self.scene.shader_handler.programs['draw'])
+        self.write(regenerate=True)
 
     def generate_texture_array(self) -> None:
         """
@@ -74,23 +73,27 @@ class ImageHandler():
             self.texture_arrays[size] = self.ctx.texture_array(size=dim, components=4, data=array_data)
             # Texture OpenGl settings
             self.texture_arrays[size].build_mipmaps()
-            self.texture_arrays[size].filter = (mgl.LINEAR_MIPMAP_LINEAR, mgl.LINEAR)
+            if size > 32: self.texture_arrays[size].filter = (mgl.LINEAR_MIPMAP_LINEAR, mgl.LINEAR)
+            else: self.texture_arrays[size].filter = (mgl.NEAREST, mgl.NEAREST)
             self.texture_arrays[size].anisotropy = 32.0
 
-    def write(self, shader_program: mgl.Program) -> None:
+    def write(self, regenerate=False) -> None:
         """
-        Writes all texture arrays to the given shader program
-        Args:
-            shader_program: mgl.Program:
-                Destination of the texture array write
+        Writes all texture arrays to shaders that use images 
         """
 
-        self.generate_texture_array()
+        if regenerate: self.generate_texture_array()
+
+        if not self.texture_arrays: return
+
+        for shader in self.engine.scene.shader_handler.shaders:
+            if 'textureArrays[5]' not in shader.uniforms: continue
 
-        for i, size in enumerate(texture_sizes):
-            if not size in self.texture_arrays: continue
-            shader_program[f'textureArrays[{i}].array'] = i + 3
-            self.texture_arrays[size].use(location=i+3)
+            for i, size in enumerate(texture_sizes):
+                if not size in self.texture_arrays: continue
+                if not self.texture_arrays[size]: continue
+                shader.program[f'textureArrays[{i}].array'] = i + 3
+                self.texture_arrays[size].use(location=i+3)
 
     def get(self, identifier: str | int) -> any:
         """

basilisk/render/light_handler.py

@@ -38,17 +38,22 @@ class LightHandler():
         Writes all the lights in a scene to the given shader program
         """
 
-        if not program: program = self.scene.shader_handler.programs['batch']
+        # if not program: program = self.engine.shader.program
 
-        if directional and self.directional_lights:
+        for shader in self.scene.shader_handler.shaders:
+            if 'numDirLights' not in shader.uniforms: continue
+            
+            program = shader.program
 
-            program['numDirLights'].write(glm.int32(len(self.directional_lights)))
+            if directional and self.directional_lights and 'numDirLights' in self.engine.shader.uniforms:
 
-            for i, light in enumerate(self.directional_lights):
-                program[f'dirLights[{i}].direction'].write(light.direction)
-                program[f'dirLights[{i}].intensity'].write(glm.float32(light.intensity))
-                program[f'dirLights[{i}].color'    ].write(light.color / 255.0)
-                program[f'dirLights[{i}].ambient'  ].write(glm.float32(light.ambient))
-        
-        if point:
-            ...
+                program['numDirLights'].write(glm.int32(len(self.directional_lights)))
+
+                for i, light in enumerate(self.directional_lights):
+                    program[f'dirLights[{i}].direction'].write(light.direction)
+                    program[f'dirLights[{i}].intensity'].write(glm.float32(light.intensity))
+                    program[f'dirLights[{i}].color'    ].write(light.color / 255.0)
+                    program[f'dirLights[{i}].ambient'  ].write(glm.float32(light.ambient))
+            
+            if point:
+                ...