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

basilisk/generic/quat.py

@@ -5,6 +5,7 @@ import numpy as np
 class Quat():
     def __init__(self, *args, callback=None):
         self.callback = callback
+        self.prev_data = glm.quat(1, 0, 0, 0)
         self.set_data(*args)
        
     def normalize(self):
@@ -94,9 +95,16 @@ class Quat():
     def z(self): return self.data.z
     
     @data.setter
-    def data(self, value: glm.quat):
+    def data(self, value: glm.vec3):
         self._data = value
-        if self.callback and all(abs(self.data[i] - value[i]) > 1e-12 for i in range(4)): self.callback()
+        
+        cur = self._data
+        prev = self.prev_data
+        thresh = 1e-6
+        
+        if self.callback and (abs(cur.w - prev.w) > thresh or abs(cur.x - prev.x) > thresh or abs(cur.y - prev.y) > thresh or abs(cur.z - prev.z) > thresh): 
+            self.prev_data = self._data            
+            self.callback()
         
     @w.setter
     def w(self, value):

basilisk/generic/vec3.py

@@ -5,6 +5,7 @@ import numpy as np
 class Vec3():
     def __init__(self, *args, callback=None):
         self.callback = callback
+        self.prev_data = glm.vec3(0.0)
         self.set_data(*args)
        
     def normalize(self):
@@ -94,7 +95,14 @@ class Vec3():
     @data.setter
     def data(self, value: glm.vec3):
         self._data = value
-        if self.callback and all(abs(self.data[i] - value[i]) > 1e-12 for i in range(3)): self.callback()
+        
+        cur = self._data
+        prev = self.prev_data
+        thresh = 1e-6
+        
+        if self.callback and (abs(cur.x - prev.x) > thresh or abs(cur.y - prev.y) > thresh or abs(cur.z - prev.z) > thresh): 
+            self.prev_data = glm.vec3(self._data)
+            self.callback()
 
     @x.setter
     def x(self, value):

basilisk/input/mouse.py

@@ -34,11 +34,11 @@ class Mouse():
         pg.mouse.set_pos(x, y)
 
     @property
-    def click(self): return self.previous_buttons[0] and not self.buttons[0]
+    def click(self): return self.buttons[0] and not self.previous_buttons[0]
     @property
-    def middle_click(self): return self.previous_buttons[1] and not self.buttons[1]
+    def middle_click(self): return self.buttons[1] and not self.previous_buttons[1]
     @property
-    def right_click(self): return self.previous_buttons[2] and not self.buttons[2]
+    def right_click(self): return self.buttons[2] and not self.previous_buttons[2]
     @property
     def left_down(self): return self.buttons[0]
     @property

basilisk/nodes/node.py

@@ -8,6 +8,7 @@ from ..render.material import Material
 from ..physics.physics_body import PhysicsBody
 from ..collisions.collider import Collider
 from ..render.chunk import Chunk
+from ..render.shader import Shader
 
 
 class Node():
@@ -53,6 +54,8 @@ class Node():
     """""" # TODO Jonah description
     children: list
     """List of nodes that this node is a parent of"""
+    shader: Shader
+    """Shader that is used to render the node. If none is given, engine default will be used"""
 
     def __init__(self, node_handler,
             position:            glm.vec3=None, 
@@ -73,7 +76,8 @@ class Node():
             collision_group :    float=None, 
             name:                str='', 
             tags:                list[str]=None,
-            static:              bool=True
+            static:              bool=None,
+            shader:              Shader=None
         ) -> None:
         """
         Basilisk node object. 
@@ -86,13 +90,14 @@ class Node():
         self.chunk = None
         
         # lazy update variables
-        self.needs_geometric_center = True
-        self.needs_model_matrix = True
+        self.needs_geometric_center = True # pos
+        self.needs_model_matrix = True # pos, scale, rot
 
         # node data
         self.internal_position: Vec3 = Vec3(position) if position else Vec3(0, 0, 0)
         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)
+        
         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
@@ -106,7 +111,7 @@ class Node():
         
         # collider
         if collisions: 
-            if not mesh: raise ValueError('Node: cannot collide if it doezsnt have a mesh')
+            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(
                 node = self,
                 box_mesh = True if collider == 'box' else False,
@@ -125,31 +130,50 @@ class Node():
         # information and recursion
         self.name = name
         self.tags = tags if tags else []
-        self.static = static and not (self.physics_body or self.velocity or self.rotational_velocity)
+        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 = []
+
+        # Shader given by user or none for default
+        self.shader = shader
         
         # default callback functions for node transform
         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? 
         
-        self.position_updated = False
-        self.scale_updated    = False
-        self.rotation_updated  = False
-        
         # callback function to be added to the custom Vec3 and Quat classes
         def position_callback():
-            print('position')
-            self.position_updated = True
+            self.chunk.node_update_callback(self)
+            
+            # update variables
+            self.needs_geometric_center = True
+            self.needs_model_matrix = True
+            if self.collider:
+                self.collider.needs_bvh = True
+                self.collider.needs_obb = True
             
         def scale_callback():
-            print('scale')
-            self.scale_updated = True
+            self.chunk.node_update_callback(self)
+            
+            # update variables
+            self.needs_model_matrix = True
+            if self.collider:
+                self.collider.needs_bvh = True
+                self.collider.needs_obb = True
+                self.collider.needs_half_dimensions = True
             
         def rotation_callback():
-            print('rotation')
-            self.rotation_updated = True
+            self.chunk.node_update_callback(self)
+            
+            # update variables
+            self.needs_model_matrix = True
+            if self.collider:
+                self.collider.needs_bvh = True
+                self.collider.needs_obb = True
+                self.collider.needs_half_dimensions = True
         
         self.internal_position.callback = position_callback
         self.internal_scale.callback    = scale_callback
@@ -159,18 +183,8 @@ class Node():
         """
         Updates the node's movement variables based on the delta time
         """
-        # update all hard-to-update variables
-        
-        
-        # reset updates
-        self.position_updated = False
-        self.scale_updated    = False
-        self.rotation_updated = False
-        
-        self.position += dt * self.velocity
-        self.rotation += 0.5 * dt * self.rotation * glm.quat(0, *self.rotational_velocity)
-        self.rotation = glm.normalize(self.rotation)
-        self.scale = self.scale
+        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 self.physics_body:
             self.velocity += self.physics_body.get_delta_velocity(dt)
@@ -249,7 +263,7 @@ class Node():
                 
         # rotation
         rotation_matrix = glm.mat3_cast(self.rotation)
-        inertia_tensor = rotation_matrix * inertia_tensor * glm.transpose(rotation_matrix)
+        inertia_tensor  = rotation_matrix * inertia_tensor * glm.transpose(rotation_matrix)
         
         return glm.inverse(inertia_tensor)
 
@@ -347,21 +361,19 @@ class Node():
     
     @position.setter
     def position(self, value: tuple | list | glm.vec3 | np.ndarray):
-        if isinstance(value, glm.vec3): self.internal_position.data = glm.vec3(value)
+        if isinstance(value, glm.vec3): self.internal_position.data = value
         elif isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
             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)}')
-        self.update_position()
     
     @scale.setter
     def scale(self, value: tuple | list | glm.vec3 | np.ndarray):
-        if isinstance(value, glm.vec3): self.internal_scale.data = glm.vec3(value)
+        if isinstance(value, glm.vec3): self.internal_scale.data = value
         elif isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
             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)}')
-        self.update_scale()
 
     @rotation.setter
     def rotation(self, value: tuple | list | glm.vec3 | glm.quat | glm.vec4 | np.ndarray):
@@ -371,51 +383,10 @@ 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)}')
-        self.update_rotation()
-
-    def update_position(self): # TODO Could these be repeated in a Vec3/Quat Callback function? 
-        """
-        Updates the rotation
-        """
-        
-        thresh = 0.01
-        cur  = self.position
-        prev = self.previous_position
-
-        if self.chunk and (abs(cur.x - prev.x) > thresh or abs(cur.y - prev.y) > thresh or abs(cur.z - prev.z) > thresh):
-            self.chunk.node_update_callback(self)
-            self.previous_position = self.position
-
-    def update_scale(self):
-        """
-        Updates the rotation
-        """
-        
-        thresh = 0.01
-        cur  = self.scale
-        prev = self.previous_scale
-
-        if self.chunk and (abs(cur.x - prev.x) > thresh or abs(cur.y - prev.y) > thresh or abs(cur.z - prev.z) > thresh):
-            self.chunk.node_update_callback(self)
-            self.previous_scale = self.scale
-
-    def update_rotation(self):
-        """
-        Updates the rotation 
-        """
-        
-        thresh = 0.01
-        cur  = self.rotation
-        prev = self.previous_rotation
-
-        if self.chunk and (abs(cur.x - prev.x) > thresh or abs(cur.y - prev.y) > thresh or abs(cur.z - prev.z) > thresh or abs(cur.w - prev.w) > thresh):
-            self.chunk.node_update_callback(self)
-            self.previous_rotation = self.rotation
-
 
     @forward.setter
     def forward(self, value: tuple | list | glm.vec3 | np.ndarray):
-        if isinstance(value, glm.vec3): self._forward = glm.vec3(value)
+        if isinstance(value, glm.vec3): self._forward = value
         elif isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
             if len(value) != 3: raise ValueError(f'Node: Invalid number of values for forward. Expected 3, got {len(value)}')
             self._forward = glm.vec3(value)
@@ -493,15 +464,15 @@ class Node():
 
     @x.setter
     def x(self, value: int | float):
-        if isinstance(value, int) or isinstance(value, float): self.internal_position.data.x = value
+        if isinstance(value, int) or isinstance(value, float): self.internal_position.x = value
         else: raise TypeError(f'Node: Invalid positional x value type {type(value)}')
         
     @y.setter
     def y(self, value: int | float):
-        if isinstance(value, int) or isinstance(value, float): self.internal_position.data.y = value
+        if isinstance(value, int) or isinstance(value, float): self.internal_position.y = value
         else: raise TypeError(f'Node: Invalid positional y value type {type(value)}')
         
     @z.setter
     def z(self, value: int | float):
-        if isinstance(value, int) or isinstance(value, float): self.internal_position.data.z = value
+        if isinstance(value, int) or isinstance(value, float): self.internal_position.z = value
         else: raise TypeError(f'Node: Invalid positional z value type {type(value)}')

basilisk/nodes/node_handler.py

@@ -25,7 +25,9 @@ class NodeHandler():
         """
         Updates the nodes and chunks in the scene
         """
-        for node in self.nodes: node.update(self.scene.engine.delta_time)
+        for node in self.nodes: 
+            if node.static: continue
+            node.update(self.scene.engine.delta_time)
         self.chunk_handler.update()
 
     def render(self):
@@ -89,6 +91,8 @@ class NodeHandler():
         Removes a node and all of its children from their handlers
         """
         # TODO add support for recursive nodes
-        if node.physics_body: self.scene.physics_engine.remove(node.physics_body)
-        if node.collider: self.scene.collider_handler.remove(node.collider)
-        node.node_handler = None
+        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)
+            node.node_handler = None
+            self.nodes.remove(node)

basilisk/physics/impulse.py

@@ -0,0 +1,119 @@
+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)
+    num_points = len(contact_points)
+    
+    total_impulse = glm.vec3(0, 0, 0)
+    
+    # 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)
+            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)
+            
+    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)
+            
+    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)
+    
+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_engine.py

@@ -15,7 +15,7 @@ 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 []

basilisk/render/batch.py

@@ -35,6 +35,8 @@ class Batch():
         Returns True if batch was successful.
         """
 
+        self.program = self.chunk.chunk_handler.program
+
         # Empty list to contain all vertex data of models in the chunk
         batch_data = []
 

basilisk/render/camera.py

@@ -145,7 +145,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 +161,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_handler.py

@@ -28,7 +28,7 @@ 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         = [{}   , {}   ]
@@ -58,6 +58,8 @@ 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 = []
 
@@ -76,6 +78,13 @@ class ChunkHandler():
         # Clears the set of updated chunks so that they are not updated unless they are updated again
         self.updated_chunks = [set(), set()]
 
+    def update_all(self):
+        self.program = self.scene.engine.shader.program
+        for chunk in self.chunks[0].values():
+            self.updated_chunks[0].add(chunk)
+        for chunk in self.chunks[1].values():
+            self.updated_chunks[1].add(chunk)
+
     def add(self, node: Node) -> Node:
         """
         Adds an existing node to its chunk. Updates the node's chunk reference

basilisk/render/frame.py

@@ -88,9 +88,9 @@ class Frame:
         """
 
         # Read the shaders
-        with open(f'basilisk/shaders/{vert}.vert') as file:
+        with open(self.engine.root + f'/shaders/{vert}.vert') as file:
             vertex_shader = file.read()
-        with open(f'basilisk/shaders/{frag}.frag') as file:
+        with open(self.engine.root + f'/shaders/{frag}.frag') as file:
             fragment_shader = file.read()
 
         # Create the program

basilisk/render/image_handler.py

@@ -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:
         """
@@ -77,20 +76,23 @@ class ImageHandler():
             self.texture_arrays[size].filter = (mgl.LINEAR_MIPMAP_LINEAR, mgl.LINEAR)
             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.values():
+            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,9 +38,9 @@ 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:
+        if directional and self.directional_lights and 'numDirLights' in self.engine.shader.uniforms:
 
             program['numDirLights'].write(glm.int32(len(self.directional_lights)))