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

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():
@@ -17,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
@@ -53,11 +60,16 @@ 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,
+    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, 
@@ -73,7 +85,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. 
@@ -82,32 +95,42 @@ 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
-        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)
+        
+        # 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 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,
@@ -121,63 +144,105 @@ 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 []
-        self.static = static and not (self.physics_body or self.velocity or self.rotational_velocity)
+
         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
         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 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
+        # 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 - 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, 
@@ -203,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)
+        
+        # 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 add_child(self) -> None: # TODO add node constructor
-        ... 
+    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:
         """
@@ -242,16 +327,22 @@ 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
                 
         # 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)
+    
+    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:
         """
@@ -260,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
@@ -284,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
@@ -347,21 +465,25 @@ 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()
+        
+        # # 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):
-        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()
+        
+        # # 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):
@@ -371,66 +493,54 @@ 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
-
+        # # 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):
-        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)
         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):
@@ -493,15 +603,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):
@@ -35,60 +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.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)
+            self.chunk_handler.remove(node)
+            self.nodes.remove(node)
+            node.node_handler = None
+            
+        for child in node.children: self.remove(child)