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

basilisk/nodes/node.py

@@ -1,5 +1,6 @@
 import glm
 import numpy as np
+from .helper import node_is
 from ..generic.vec3 import Vec3
 from ..generic.quat import Quat
 from ..generic.matrices import get_model_matrix
@@ -38,9 +39,9 @@ class Node():
     """Allows the node's movement to be affected by the physics engine and collisions"""
     mass: float
     """The mass of the node in kg"""
-    collisions: bool
+    collision: bool
     """Gives the node collision with other nodes in the scene""" 
-    collider: str
+    collider_mesh: str
     """The collider type of the node. Can be either 'box' or 'mesh'"""
     static_friction: float
     """Determines the friction of the node when still: recommended value 0.0 - 1.0"""
@@ -57,7 +58,7 @@ class Node():
     static: bool
     """Objects that don't move should be marked as static"""
     chunk: Chunk
-    """""" # TODO Jonah description
+    """The parent chunk of the node. Used for callbacks to update chunk meshes"""
     children: list
     """List of nodes that this node is a parent of"""
     shader: Shader
@@ -77,12 +78,12 @@ class Node():
             rotational_velocity: glm.vec3=None, 
             physics:             bool=False, 
             mass:                float=None, 
-            collisions:          bool=False, 
-            collider:            str=None, 
+            collision:           bool=False, 
+            collider_mesh:       str|Mesh=None, 
             static_friction:     float=None, 
             kinetic_friction:    float=None, 
             elasticity:          float=None, 
-            collision_group :    float=None, 
+            collision_group:     float=None, 
             name:                str='', 
             tags:                list[str]=None,
             static:              bool=None,
@@ -121,7 +122,7 @@ class Node():
         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)
         
-        self.static = static if static != None else not(physics or any(self.velocity) or any(self.rotational_velocity))
+        self._static = static
 
         # Physics updates
         if physics: self.physics_body = PhysicsBody(mass = mass if mass else 1.0)
@@ -129,16 +130,16 @@ class Node():
         else: self.physics_body = None
         
         # collider
-        if collisions: 
+        if collision: 
             self.collider = Collider(
                 node = self,
-                box_mesh = True if collider == 'box' else False,
+                collider_mesh = collider_mesh,
                 static_friction = static_friction,
                 kinetic_friction = kinetic_friction,
                 elasticity = elasticity,
                 collision_group = collision_group
             )
-        elif collider:         raise ValueError('Node: cannot have collider mesh if it does not allow collisions')
+        elif collider_mesh:         raise ValueError('Node: cannot have collider mesh if it does not allow collisions')
         elif static_friction:  raise ValueError('Node: cannot have static friction if it does not allow collisions')
         elif kinetic_friction: raise ValueError('Node: cannot have kinetic friction if it does not allow collisions')
         elif elasticity:       raise ValueError('Node: cannot have elasticity if it does not allow collisions')
@@ -154,15 +155,11 @@ class Node():
 
         # 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? 
 
         # callback function to be added to the custom Vec3 and Quat classes
         def position_callback():
-            self.chunk.node_update_callback(self)
+            if self.chunk:
+                self.chunk.node_update_callback(self)
             
             # update variables
             self.needs_geometric_center = True
@@ -172,7 +169,8 @@ class Node():
                 self.collider.needs_obb = True
             
         def scale_callback():
-            self.chunk.node_update_callback(self)
+            if self.chunk:
+                self.chunk.node_update_callback(self)
             
             # update variables
             self.needs_model_matrix = True
@@ -182,7 +180,8 @@ class Node():
                 self.collider.needs_half_dimensions = True
             
         def rotation_callback():
-            self.chunk.node_update_callback(self)
+            if self.chunk:
+                self.chunk.node_update_callback(self)
             
             # update variables
             self.needs_model_matrix = True
@@ -244,31 +243,42 @@ class Node():
         
         for child in self.children: child.sync_data()
         
-    def get_nodes(self, 
-            require_mesh: bool=False, 
-            require_collider: bool=False, 
-            require_physics_body: bool=False, 
-            filter_material: Material=None, 
-            filter_tags: list[str]=None
-        ) -> list: 
+    def deep_copy(self) -> ...:
         """
-        Returns the nodes matching the required filters from this branch of the nodes
+        Creates a deep copy of this node and returns it. The new node is not added to the scene.
         """
-        # adds self to nodes list if it matches the criteria
-        nodes = []
+        
+        copy = Node(
+            position = self.position,
+            scale = self.scale,
+            rotation = self.rotation,
+            relative_position = bool(self.relative_position),
+            relative_scale = bool(self.relative_scale),
+            relative_rotation = bool(self.relative_rotation),
+            forward = glm.vec3(self.forward),
+            mesh = self.mesh,
+            material = self.material,
+            velocity = glm.vec3(self.velocity),
+            rotational_velocity = glm.vec3(self.rotational_velocity),
+            physics = bool(self.physics_body),
+            mass = self.mass if self.physics_body else None,
+            collision = bool(self.collider),
+            static_friction = self.static_friction if self.collider else None,
+            kinetic_friction = self.kinetic_friction if self.collider else None,
+            elasticity = self.elasticity if self.collider else None,
+            collision_group = self.collision_group if self.collider else None,
+            name = self.name,
+            tags = [tag for tag in self.tags], # deep copy tags list
+            static = self.static,
+            shader = self.shader
+        )
+        
+        return copy
     
-        if all([
-            (not require_mesh or self.mesh),
-            (not require_collider or self.collider),
-            (not require_physics_body or self.physics_body),
-            (not filter_material or self.material == filter_material),
-            (not filter_tags or all([tag in self.tags for tag in filter_tags]))
-        ]): 
-            nodes.append(self)
-        
-        # 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 nodes 
+    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:
+        nodes = [self] if node_is(self, position, scale, rotation, forward, mesh, material, velocity, rotational_velocity, physics, mass, collisions, static_friction, kinetic_friction, elasticity, collision_group, name, tags, static) else []
+        for node in self.children: nodes += node.get_all(position, scale, rotation, forward, mesh, material, velocity, rotational_velocity, physics, mass, collisions, static_friction, kinetic_friction, elasticity, collision_group, name, tags, static)
+        return nodes
         
     # tree functions for managing children 
     def add(self, child: ..., relative_position: bool=None, relative_scale: bool=None, relative_rotation: glm.vec3=None) -> None:
@@ -308,7 +318,7 @@ class Node():
         """
         # translation
         assert self.physics_body, 'Node: Cannot apply a force to a node that doesn\'t have a physics body'
-        self.velocity = force / self.mass * dt
+        self.velocity += force / self.mass * dt
         
         # rotation
         torque = glm.cross(offset, force)
@@ -326,8 +336,9 @@ 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) / 2
+        if not ((self.mesh or (self.collider and self.collider.mesh)) and self.physics_body): return None 
+        mesh = self.collider.mesh if self.collider else self.mesh
+        inertia_tensor = mesh.get_inertia_tensor(self.scale) / 2
     
         # mass
         if self.physics_body: inertia_tensor *= self.physics_body.mass
@@ -434,6 +445,9 @@ class Node():
     @property
     def tags(self): return self._tags
     @property
+    def static(self):
+        return self._static if self._static is not None else not(self.physics or any(self.velocity) or any(self.rotational_velocity))
+    @property
     def x(self): return self.internal_position.data.x
     @property
     def y(self): return self.internal_position.data.y
@@ -463,6 +477,18 @@ class Node():
         if not self.mesh: raise RuntimeError('Node: Cannot retrieve volume if node does not have mesh')
         return self.mesh.volume * self.scale.x * self.scale.y * self.scale.z
     
+    @property
+    def physics(self):
+        return bool(self.physics_body)
+    @property
+    def collision(self):
+        return bool(self.collider)
+    
+    @property
+    def collisions(self):
+        assert self.collision, 'Node: Cannot access collision data without collisions enabled on Node'
+        return self.collider.collisions
+    
     @position.setter
     def position(self, value: tuple | list | glm.vec3 | np.ndarray):
         if isinstance(value, glm.vec3): self.internal_position.data = value
@@ -585,7 +611,7 @@ class Node():
     @collision_group.setter
     def collision_group(self, value: str):
         if not self.collider: raise RuntimeError('Node: Cannot set the collision gruop of a node that has no physics body')
-        if isinstance(value, str): self.collider.collision_group = value
+        if isinstance(value, (str, type(None))): self.collider.collision_group = value
         else: raise TypeError(f'Node: Invalid collision group value type {type(value)}')
         
     @name.setter
@@ -600,6 +626,10 @@ class Node():
                 if not isinstance(tag, str): raise TypeError(f'Node: Invalid tag value in tags list of type {type(tag)}')
             self._tags = value
         else: raise TypeError(f'Node: Invalid tags value type {type(value)}')
+        
+    @static.setter
+    def static(self, value: bool):
+        self._static = value
 
     @x.setter
     def x(self, value: int | float):
@@ -614,4 +644,38 @@ class Node():
     @z.setter
     def z(self, value: int | float):
         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)}')
+        else: raise TypeError(f'Node: Invalid positional z value type {type(value)}')
+        
+    @physics.setter
+    def physics(self, value: bool | PhysicsBody):
+        if not value and self.physics: # remove physics body from self and scene
+            if self.node_handler: self.node_handler.scene.physics_engine.remove(self.physics_body)
+            self.physics_body = None
+        elif isinstance(value, PhysicsBody): # deep copy physics body
+            if self.physics: 
+                self.mass = value.mass
+            else: 
+                self.physics_body = PhysicsBody(value.mass)
+                if self.node_handler: self.physics_body.physics_engine = self.node_handler.scene.physics_engine
+        elif not self.physics:
+            self.physics_body = PhysicsBody(mass = 1)
+            if self.node_handler: self.physics_body.physics_engine = self.node_handler.scene.physics_engine
+
+            
+    @collision.setter
+    def collision(self, value: bool | PhysicsBody):
+        if not value and self.collision:
+            if self.node_handler: self.node_handler.scene.collider_handler.remove(self.collider)
+            self.collider = None
+        elif isinstance(value, Collider):
+            if self.collision:
+                self.kinetic_friction = value.kinetic_friction
+                self.elasticity = value.elasticity
+                self.static_friction = value.static_friction
+            else:
+                self.collider = Collider(self, value.mesh, value.static_friction, value.kinetic_friction, value.elasticity, value.collision_group)
+                if self.node_handler: self.collider.collider_handler = self.node_handler.scene.collider_handler
+        elif not self.collider:
+            self.collider = Collider(self)
+            if self.node_handler: self.collider.collider_handler = self.node_handler.scene.collider_handler
+                

basilisk/nodes/node_handler.py

@@ -1,5 +1,6 @@
 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
@@ -25,9 +26,10 @@ class NodeHandler():
         """
         Updates the nodes and chunks in the scene
         """
-        for node in self.nodes: 
-            if node.static: continue
-            node.update(self.scene.engine.delta_time)
+        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):
@@ -43,7 +45,7 @@ class NodeHandler():
         """
         if node in self.nodes: return
         
-        for n in node.get_nodes(): # gets all nodes including the node to be added
+        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)
@@ -58,47 +60,22 @@ class NodeHandler():
             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
+            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) -> 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) -> list[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)
+            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: 

basilisk/particles/particle_handler.py

@@ -1,7 +1,7 @@
 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):
@@ -14,7 +14,7 @@ class ParticleHandler:
         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:
+    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:
@@ -46,6 +46,15 @@ class ParticleHandler:
             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)
 

basilisk/render/camera.py

@@ -99,6 +99,8 @@ class Camera:
     def position(self): return self._position
     @property
     def direction(self): return self.forward
+    @property
+    def horizontal(self): return glm.normalize(self.forward.xz)
 
     @scene.setter
     def scene(self, value):
@@ -106,6 +108,7 @@ class Camera:
         self._scene = value
         self.engine = self._scene.engine
         self.use()
+        
     @position.setter
     def position(self, value: tuple | list | glm.vec3 | np.ndarray):
         if isinstance(value, glm.vec3): self._position = glm.vec3(value)
@@ -113,6 +116,7 @@ class Camera:
             if len(value) != 3: raise ValueError(f'Camera: Invalid number of values for position. Expected 3, got {len(value)}')
             self._position = glm.vec3(value)
         else: raise TypeError(f'Camera: Invalid position value type {type(value)}')
+        
     @direction.setter
     def direction(self, value: tuple | list | glm.vec3 | np.ndarray):
         if isinstance(value, glm.vec3): self.direction = glm.normalize(glm.vec3(value))
@@ -180,9 +184,10 @@ class FollowCamera(FreeCamera):
         self.position = self.parent.position + self.offest
         
 class OrbitCamera(FreeCamera):
-    def __init__(self, parent, position=(0, 0, 20), yaw=-90, pitch=0, distance=5):
+    def __init__(self, parent, position=(0, 0, 20), yaw=-90, pitch=0, distance=5, offset=(0, 0)):
         self.parent = parent
         self.distance = distance
+        self.offset = glm.vec2(offset)
         super().__init__(position, yaw, pitch)
 
     def get_view_matrix(self) -> glm.mat4x4:

basilisk/render/frame.py

@@ -1,21 +1,17 @@
 import numpy as np
 import moderngl as mgl
-from PIL import Image
+from .shader import Shader
+from .framebuffer import Framebuffer
 
+from .post_process import PostProcess
 
 class Frame:
-    program: mgl.Program=None
+    shader: Shader=None
     vbo: mgl.Buffer=None
     vao: mgl.VertexArray=None
-    frame_texture: mgl.Texture=None
-    depth_texture: mgl.Texture=None
     framebuffer: mgl.Framebuffer=None
-    pingpong_frame_texture: mgl.Texture=None
-    pingpong_depth_texture: mgl.Texture=None
-    pingpong_framebuffer: mgl.Framebuffer=None
-    postprocess: dict=None
 
-    def __init__(self, scene) -> None:
+    def __init__(self, scene, resolution=1, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
         """
         Basilisk render destination. 
         Can be used to render to the screen or for headless rendering
@@ -25,27 +21,44 @@ class Frame:
         self.engine = scene.engine
         self.ctx    = scene.ctx
 
-        
-        self.load_program()
-        self.set_textures()
-        self.set_renderer()
+        # Load framebuffer
+        self.resolution = resolution
+        self.filter = filter
+        size = tuple(map(lambda x: int(x * self.resolution), self.engine.win_size))
+        self.framebuffer = Framebuffer(self.engine, size=size, filter=self.filter)
+        self.ping_pong_buffer = Framebuffer(self.engine, size=size, filter=self.filter)
+
+        # Load Shaders
+        self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame.frag')
+        self.scene.shader_handler.add(self.shader)
+
+        # Load VAO
+        self.vbo = self.ctx.buffer(np.array([[-1, -1, 0, 0, 0], [1, -1, 0, 1, 0], [1, 1, 0, 1, 1], [-1, 1, 0, 0, 1], [-1, -1, 0, 0, 0], [1, 1, 0, 1, 1]], dtype='f4'))
+        self.vao = self.ctx.vertex_array(self.shader.program, [(self.vbo, '3f 2f', 'in_position', 'in_uv')], skip_errors=True)
+
+        # TEMP TESTING
+        self.post_processes = []
 
-        self.postprocess = {}
-        self.load_post_shader('frame', 'filter')
 
-    def render(self):
+    def render(self) -> None:
         """
         Renders the current frame to the screen
         """
 
-        # self.apply_postprocess('filter')
+        for process in self.post_processes:
+            process.apply(self.framebuffer, self.ping_pong_buffer)
+            
+            temp = self.framebuffer
+            self.framebuffer = self.ping_pong_buffer
+            self.ping_pong_buffer = temp
         
         self.ctx.screen.use()
-        self.program['screenTexture'] = 0
-        self.framebuffer.color_attachments[0].use(location=0)
+        self.shader.program['screenTexture'] = 0
+        self.framebuffer.texture.use(location=0)
         self.vao.render()
 
-    def use(self):
+
+    def use(self) -> None:
         """
         Uses the frame as a render target
         """
@@ -53,130 +66,34 @@ class Frame:
         self.framebuffer.use()
         self.framebuffer.clear()
 
-    def save(self, destination: str=None):
+    def add_post_process(self, post_process: PostProcess) -> PostProcess:
         """
-        Saves the frame as an image to the given file destination
+        Add a post process to the frames post process stack
         """
 
-        path = destination if destination else 'screenshot'
-
-        data = self.framebuffer.read(components=3, alignment=1)
-        img = Image.frombytes('RGB', self.framebuffer.size, data).transpose(Image.FLIP_TOP_BOTTOM)
-        img.save(f'{path}.png')
-
+        self.post_processes.append(post_process)
+        return post_process
 
-    def load_program(self) -> None:
-        """
-        Loads the frame shaders
-        """
-
-        # Release any existing memory
-        if self.program: self.program.release()
-        
-        # Read the shaders
-        with open(self.engine.root + '/shaders/frame.vert') as file:
-            vertex_shader = file.read()
-        with open(self.engine.root + '/shaders/frame.frag') as file:
-            fragment_shader = file.read()
-
-        # Create the program
-        self.program = self.ctx.program(vertex_shader=vertex_shader, fragment_shader=fragment_shader)
-
-    def load_post_shader(self, vert: str, frag: str) -> None:
-        """
-        Loads a post processing shader
+    def save(self, destination: str=None) -> None:
         """
-
-        # Read the shaders
-        with open(self.engine.root + f'/shaders/{vert}.vert') as file:
-            vertex_shader = file.read()
-        with open(self.engine.root + f'/shaders/{frag}.frag') as file:
-            fragment_shader = file.read()
-
-        # Create the program
-        program = self.ctx.program(vertex_shader=vertex_shader, fragment_shader=fragment_shader)
-        self.postprocess[frag] = self.ctx.vertex_array(program, [(self.vbo, '3f 2f', 'in_position', 'in_uv')], skip_errors=True)
-
-    def apply_postprocess(self, shader: str):
-        self.pingpong_framebuffer.use()
-        self.pingpong_framebuffer.clear()
-        self.postprocess[shader].program['screenTexture'] = 0
-        self.framebuffer.color_attachments[0].use(location=0)
-        self.postprocess[shader].render()
-        
-
-        temp = self.framebuffer
-        self.framebuffer = self.pingpong_framebuffer
-        self.pingpong_framebuffer = temp
-
-        # self.use()
-        # self.postprocess[shader].program['screenTexture'] = 0
-        # self.pingpong_frame_texture.use(location=0)
-        # self.vao.render()
-
-        
-    def set_textures(self, viewport: tuple=None) -> None:
-        """
-        Sets the framebuffer textures
+        Saves the frame as an image to the given file destination
         """
 
-        # Release any existing memory in case of a resize
-        if self.frame_texture: self.frame_texture.release()
-        if self.depth_texture: self.depth_texture.release()
-        if self.framebuffer:   self.framebuffer.release()
-        if self.pingpong_frame_texture: self.pingpong_frame_texture.release()
-        if self.pingpong_depth_texture: self.pingpong_depth_texture.release()
-        if self.pingpong_framebuffer:   self.pingpong_framebuffer.release()
-
-        # Get the size from the engine window if the not specified by the function call
-        size = viewport if viewport else self.engine.win_size
-
-        # Create textures and frame buffer object
-        self.frame_texture = self.ctx.texture(size, components=4)
-        self.depth_texture = self.ctx.depth_texture(size)
-        self.framebuffer   = self.ctx.framebuffer([self.frame_texture], self.depth_texture)
-        self.pingpong_frame_texture = self.ctx.texture(size, components=4)
-        self.pingpong_depth_texture = self.ctx.depth_texture(size)
-        self.pingpong_framebuffer   = self.ctx.framebuffer([self.pingpong_frame_texture], self.pingpong_depth_texture)
-
-    def set_renderer(self) -> None:
+        self.framebuffer.save(destination)
+    
+    def resize(self, size: tuple[int]=None) -> None:
         """
-        Sets the vertex data and vao for the frame
+        Resize the frame to the given size. None for window size
         """
-        
-        # Release any existing memory
-        if self.vbo: self.vbo.release()
-        if self.vao: self.vao.release()
 
-        # Vertex and index info for the frame
-        verticies = [[-1, -1, 0], [ 1, -1, 0], [ 1, 1, 0], [-1, 1, 0]]
-        indicies  = [(3, 0, 1), (2, 3, 1)]
-        uv_verticies = [(0, 0), (1, 0), (1, 1), (0, 1)]
-        uv_indicies  = [(3, 0, 1),(2, 3, 1)]
-        
-        # Format the data
-        vertex_data = [verticies[ind] for triangle in indicies for ind in triangle]
-        vertex_data = np.array(vertex_data, dtype='f4')
-        uv_data     = [uv_verticies[ind] for triangle in uv_indicies for ind in triangle]
-        uv_data     = np.array(uv_data, dtype='f4')
+        size = tuple(map(lambda x: int(x * self.resolution), self.engine.win_size))
+        self.framebuffer.resize(size)
+        self.ping_pong_buffer.resize(size)
 
-        vertex_data = np.hstack([vertex_data, uv_data])
-
-        # Create moderngl objects
-        self.vbo = self.ctx.buffer(vertex_data)
-        self.vao = self.ctx.vertex_array(self.program, [(self.vbo, '3f 2f', 'in_position', 'in_uv')], skip_errors=True)
-        
     def __del__(self) -> None:
         """
         Releases memory used by the frame
         """
         
-        if self.program:       self.program.release()
-        if self.vbo:           self.vbo.release()
-        if self.vao:           self.vao.release()
-        if self.frame_texture: self.frame_texture.release()
-        if self.depth_texture: self.depth_texture.release()
-        if self.framebuffer:   self.framebuffer.release()
-        if self.pingpong_frame_texture: self.frame_texture.release()
-        if self.pingpong_depth_texture: self.depth_texture.release()
-        if self.pingpong_framebuffer:   self.framebuffer.release()
+        if self.vbo: self.vbo.release()
+        if self.vao: self.vao.release()