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

basilisk/render/framebuffer.py

@@ -0,0 +1,106 @@
+import moderngl as mgl
+from PIL import Image
+
+
+
+class Framebuffer:
+    engine: ...
+    """Reference to the parent engine"""
+    fbo: mgl.Framebuffer = None
+    """The core framebuffer the object provides abstraction for."""
+    texture: mgl.Texture = None
+    """The color texture of the framebuffer"""
+    depth: mgl.Texture = None
+    """The depth texture of the framebuffer"""
+    size: tuple[int]
+    """The dimensions of the framebuffer (x, y)"""
+
+    def __init__(self, engine, size: tuple[int]=None, components: int=4, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
+        """
+        Abstraction to the mgl framebuffer
+        Args:
+            engine: mgl.Engine: 
+                The parent engine
+            size: tuple[int]: 
+                The dimensions of the framebuffer (x, y)
+        """
+        
+        # Set attributes
+        self.engine = engine
+        self.ctx = engine.ctx
+        self.size = size if size else engine.win_size
+        self.components = components
+
+        # Create the fbo
+        self.texture = self.ctx.texture(self.size, components=self.components)
+        self.depth = self.ctx.depth_texture(self.size)
+        self.fbo   = self.ctx.framebuffer([self.texture], self.depth)
+
+        print()
+
+        self.filter = filter
+
+    def use(self) -> None:
+        """
+        Select this framebuffer for use
+        """
+
+        self.fbo.use()
+
+    def clear(self) -> None:
+        """
+        Clear all data currently in the textures (set to black)        
+        """
+
+        self.fbo.clear()
+
+    def save(self, destination: str=None) -> None:
+        """
+        Saves the frame as an image to the given file destination
+        """
+
+        path = destination if destination else 'screenshot'
+
+        data = self.fbo.read(components=3, alignment=1)
+        img = Image.frombytes('RGB', self.size, data).transpose(Image.FLIP_TOP_BOTTOM)
+        img.save(f'{path}.png')
+
+    def resize(self, size: tuple[int]=None) -> None:
+        """
+        Resize the buffer to the given size. None for window size
+        """
+
+        # Release old memory
+        self.__del__()
+
+        # Set/get size attribute
+        self.size = size if size else self.engine.win_size
+
+        # Create the fbo
+        self.texture = self.ctx.texture(self.size, components=self.components)
+        self.depth = self.ctx.depth_texture(self.size)
+        self.fbo   = self.ctx.framebuffer([self.texture], self.depth)
+
+        self.filter = self._filter
+
+    @property
+    def data(self):
+        return self.fbo.read(components=3, alignment=1)
+
+    @property
+    def filter(self):
+        return self.texture.filter
+    
+    @filter.setter
+    def filter(self, value):
+        self._filter = value
+        self.texture.filter = value
+
+    def __repr__(self) -> str:
+        return f'<bsk.Framebuffer | size: {self.size}>' 
+
+    def __del__(self) -> None:
+        # Release any existing memory in case of a resize
+        if self.texture: self.texture.release()
+        if self.depth: self.depth.release()
+        if self.fbo:   self.fbo.release()

basilisk/render/image.py

@@ -20,7 +20,7 @@ class Image():
     size: int
     """The width and height in pixels of the image"""
 
-    def __init__(self, path: str | os.PathLike | pg.Surface) -> None:
+    def __init__(self, path: str | os.PathLike | pg.Surface | mgl.Texture) -> None:
         """
         A basilisk image object that contains a moderngl texture
         Args:
@@ -29,18 +29,24 @@ class Image():
         """
         
         # Check if the user is loading a pygame surface
-        if isinstance(path, pg.Surface):
-            self.from_pg_surface(path)
-            return
-
-        # Verify the path type
-        if not isinstance(path, str) and not isinstance(path, os.PathLike):
-            raise TypeError(f'Invalid path type: {type(path)}. Expected a string or os.PathLike')
+        if isinstance(path, str) or isinstance(path, os.PathLike):
+            return self._from_path(path)
+        elif isinstance(path, pg.Surface):
+            return self._from_surfaces(path)
+        elif isinstance(path, mgl.Texture):
+            return self._from_texture(path)
+        
+        raise TypeError(f'Invalid path type: {type(path)}. Expected a string or os.PathLike')
 
+    def _from_path(self, path: str | os.PathLike) -> None:
+        """
+        Loads a basilisk image from a pygame surface
+        Args:
+        """
+        
         # Get name from path
         self.name = path.split('/')[-1].split('\\')[-1].split('.')[0]
 
-        # Set the texture
         # Load image
         img = PIL_Image.open(path).convert('RGBA')
         # Set the size in one of the size buckets
@@ -53,7 +59,7 @@ class Image():
         # Default index value (to be set by image handler)
         self.index = glm.ivec2(1, 1)
 
-    def from_pg_surface(self, surf: pg.Surface) -> None:
+    def _from_surface(self, surf: pg.Surface) -> None:
         """
         Loads a basilisk image from a pygame surface
         Args:
@@ -69,6 +75,12 @@ class Image():
         # Default index value (to be set by image handler)
         self.index = glm.ivec2(1, 1)
 
+    def _from_texture(self, texture: mgl.Texture):
+        """
+        
+        """
+        ...
+
     def __repr__(self) -> str:
         """
         Returns a string representation of the object

basilisk/render/post_process.py

@@ -0,0 +1,133 @@
+import numpy as np
+import moderngl as mgl
+from .shader import Shader
+from .image import Image
+from .framebuffer import Framebuffer
+
+
+class PostProcess:
+    engine: ...
+    """Reference to the parent engine"""
+    ctx: mgl.Context
+    """Reference to the parent context"""
+    shader: Shader
+    """Shader object used by the post process"""
+    vao: mgl.VertexArray
+    """Screenspace render vao"""
+
+    def __init__(self, engine, shader_path: str=None, size: tuple=None, components: int=4, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
+        """
+        Object to apply post processing to a texture
+        """
+        
+        # Reference attributes
+        self.engine = engine
+        self.ctx = engine.ctx
+
+        # Size of the destination
+        self.size = size if size else engine.win_size
+        self.components = components
+
+        # Load default fragment if none given
+        if not (isinstance(shader_path, str) or isinstance(shader_path, type(None))): 
+            raise ValueError(f'PostProces.apply: Invalid post process source type {type(shader_path)}. Expected string path destination of fragment shader.')
+        frag = shader_path if shader_path else self.engine.root + f'/shaders/frame.frag'
+
+        # Load Shaders
+        self.shader = Shader(self.engine, self.engine.root + f'/shaders/frame.vert', frag)
+        self.engine.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)
+
+        # Temporary render destination
+        self.fbo = Framebuffer(engine, self.size, components)
+
+        # Filter settings
+        self.filter = filter
+        self.fbo.texture.filter = self.filter
+
+
+    def apply(self, source: mgl.Texture | Image | Framebuffer, destination: mgl.Texture | Image | Framebuffer=None) -> mgl.Texture | Image | Framebuffer:
+        """
+        Applies a post process shader to a texture source.
+        Returns the modified texture or renders to the destination if given
+        """
+
+        if isinstance(source, Framebuffer):   return self._apply_to_framebuffer(source, destination)
+        elif isinstance(source, mgl.Texture): return self._apply_to_texture(source, destination)
+        elif isinstance(source, Image):       return self._apply_to_image(source, destination)
+        
+        raise ValueError(f'PostProces.apply: Invalid postprocess source type {type(source)}')
+
+    def _render_post_process(self, source: mgl.Texture):
+        # Clear and use the fbo as a render target
+        self.fbo.use()
+        self.fbo.clear()
+
+        # Load the source texture to the shader
+        self.shader.program['screenTexture'] = 0
+        source.use(location=0)
+
+        # Apply the post process
+        self.vao.render()
+
+
+    def _apply_to_framebuffer(self, source: Framebuffer, detination: Framebuffer=None) -> Framebuffer:
+        """
+        Applies a post process to a bsk.Framebuffer
+        """
+
+        # Create a blank framebuffer
+        if not detination:
+            fbo = Framebuffer(self.engine, self.size, self.components)
+            old_filter = None
+            fbo.texture.filter = self.filter
+        else:
+            fbo = detination
+            old_filter = fbo.filter
+            fbo.texture.filter = self.filter
+
+        # Load the source texture to the shader
+        self.shader.program['screenTexture'] = 0
+        source.texture.use(location=0)
+
+        fbo.use()
+        fbo.clear()
+        # Apply the post process
+        self.vao.render()
+
+        # Reset filter if needed
+        if old_filter: fbo.texture.filter = old_filter
+
+        # Return the fbo for the user
+        return fbo
+
+    def _apply_to_texture(self, source: mgl.Texture, destination: mgl.Texture) -> mgl.Texture:
+        """
+        Applies a post process to a mgl.Texture
+        """
+
+        # Render the post processs with the given texture
+        self._render_post_process(source)
+
+        # Make a deep copy of the modified texture
+        texture = self.ctx.texture(self.fbo.size, self.fbo.components, self.fbo.data)
+
+        return texture
+    
+    def _apply_to_image(self, source: Image, destination: Image) -> Image:
+        """
+        Applies a post process to a bsk.Image
+        """
+
+        # Create a texture from the image data
+        texture = self.ctx.texture(self.fbo.size, self.fbo.components, source.data)
+
+        # Render the post processs with the given texture
+        self._render_post_process(source)
+
+        # Make an image from the texture
+        image = Image()
+        return image

basilisk/scene.py

@@ -1,8 +1,9 @@
 import moderngl as mgl
 import glm
-from .render.shader_handler import ShaderHandler
+
 from .mesh.mesh import Mesh
 from .render.material import Material
+from .render.shader_handler import ShaderHandler
 from .render.material_handler import MaterialHandler
 from .render.light_handler import LightHandler
 from .render.camera import Camera, FreeCamera
@@ -15,6 +16,8 @@ from .render.frame import Frame
 from .particles.particle_handler import ParticleHandler
 from .nodes.node import Node
 from .generic.collisions import moller_trumbore
+from .generic.raycast_result import RaycastResult
+from .render.post_process import PostProcess
 
 class Scene():
     engine: any
@@ -43,11 +46,13 @@ class Scene():
         """
         Updates the physics and in the scene
         """
-        
-        self.node_handler.update()
         self.particle.update()
         self.camera.update()
-        self.collider_handler.resolve_collisions()
+        
+        
+        self.node_handler.update()
+        if self.engine.delta_time < 0.5: # TODO this will cause physics to slow down when on low frame rate, this is probabl;y acceptable
+            self.collider_handler.resolve_collisions()
 
     def render(self) -> None:
         """
@@ -64,42 +69,68 @@ class Scene():
         if self.engine.headless: return
         self.frame.render()
     
-    def add(self, bsk_object: ...) -> ...:
+    def add(self, *objects: Node | None) -> None | Node | list:
         """
-        Adds an object to the scene. Can pass in any scene objects:
+        Adds the given object(s) to the scene. Can pass in any scene objects:
         Argument overloads:
             object: Node - Adds the given node to the scene.
         """
         
-        if isinstance(bsk_object, type(None)):
-            # Considered well defined behavior
-            return
-        elif isinstance(bsk_object, Node):
-            # Add a node to the scene
-            return self.node_handler.add(bsk_object)
-        # Light
+        # List of all return values for the added objects
+        returns = []
+
+        # Loop through all objects passed in
+        for bsk_object in objects:
 
-        # Mesh
+            # Considered well defined behavior to add None
+            if isinstance(bsk_object, type(None)):
+                continue
 
-        else:
-            raise ValueError(f'scene.add: Incompatable object add type {type(bsk_object)}')
+            # Add a node to the scene
+            elif isinstance(bsk_object, Node):
+                returns.append(self.node_handler.add(bsk_object)); continue
+            
+            # Add a node to the scene
+            elif isinstance(bsk_object, PostProcess):
+                returns.append(self.frame.add_post_process(bsk_object)); continue
+            
+            
+            # Recived incompatable type
+            else:
+                raise ValueError(f'scene.add: Incompatable object add type {type(bsk_object)}')
 
-        return None
+        # Return based on what the user passed in
+        if not returns: return None
+        if len(returns) == 1: return returns[0]
+        return returns
 
-    def remove(self, bsk_object):
+    def remove(self, *objects: Node | None) -> None | Node | list:
         """
         Removes the given baskilsk object from the scene
         """
 
-        if isinstance(bsk_object, type(None)):
-            # Considered well defined behavior
-            return
-        elif isinstance(bsk_object, Node):
-            self.node_handler.remove(bsk_object)
-        else:
-            raise ValueError(f'scene.remove: Incompatable object remove type {type(bsk_object)}')
+        # List of all return values for the added objects
+        returns = []
+
+        # Loop through all objects passed in
+        for bsk_object in objects:
+
+            # Considered well defined behavior to remove None
+            if isinstance(bsk_object, type(None)):
+                continue
 
-        return None
+            # Remove a node from the scene
+            elif isinstance(bsk_object, Node):
+                returns.append(self.node_handler.remove(bsk_object)); continue
+
+            # Recived incompatable type
+            else:
+                raise ValueError(f'scene.remove: Incompatable object remove type {type(bsk_object)}')
+
+        # Return based on what the user passed in
+        if not returns: return None
+        if len(returns) == 1: return returns[0]
+        return returns
 
     def set_engine(self, engine: any) -> None:
         """
@@ -121,9 +152,10 @@ class Scene():
         self.frame            = Frame(self)
         self.sky              = Sky(self.engine)
         
-    def raycast(self, position: glm.vec3=None, forward: glm.vec3=None, max_distance: float=1e5, has_collisions: bool=None, has_physics: bool=None, tags: list[str]=[]) -> tuple[Node, glm.vec3]:
+    def raycast(self, position: glm.vec3=None, forward: glm.vec3=None, max_distance: float=1e5, has_collisions: bool=None, has_physics: bool=None, tags: list[str]=[]) -> RaycastResult:
         """
-        Ray cast from any posiiton and forward vector and returns the nearest node. If no position or forward is given, uses the scene camera's current position and forward
+        Ray cast from any posiiton and forward vector and returns a RaycastResult eith the nearest node. 
+        If no position or forward is given, uses the scene camera's current position and forward
         """
         if not position: position = self.camera.position
         if not forward: forward = self.camera.forward
@@ -167,9 +199,9 @@ class Scene():
                     best_point    = intersection
                     best_node     = node
                     
-        return best_node, best_point
+        return RaycastResult(best_node, best_point)
     
-    def raycast_mouse(self, position: tuple[int, int] | glm.vec2, max_distance: float=1e5, has_collisions: bool=None, has_pshyics: bool=None, tags: list[str]=[]) -> tuple[Node, glm.vec3]:
+    def raycast_mouse(self, position: tuple[int, int] | glm.vec2, max_distance: float=1e5, has_collisions: bool=None, has_pshyics: bool=None, tags: list[str]=[]) -> RaycastResult:
         """
         Ray casts from the mouse position with respect to the camera. Returns the nearest node that was clicked, if none was clicked, returns None. 
         """
@@ -189,11 +221,25 @@ class Scene():
             has_physics=has_pshyics,
             tags=tags
         )
+        
+    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
+        """
+        self.node_handler.get(position, scale, rotation, forward, mesh, material, velocity, rotational_velocity, physics, mass, collisions, static_friction, kinetic_friction, elasticity, collision_group, name, tags, static)
+    
+    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
+        """
+        self.node_handler.get_all(position, scale, rotation, forward, mesh, material, velocity, rotational_velocity, physics, mass, collisions, static_friction, kinetic_friction, elasticity, collision_group, name, tags, static)
 
     @property
     def camera(self): return self._camera
     @property
     def sky(self): return self._sky
+    @property
+    def nodes(self): return self.node_handler.nodes
 
     @camera.setter
     def camera(self, value: Camera):

basilisk/shaders/crt.frag

@@ -0,0 +1,32 @@
+#version 330 core
+
+out vec4 fragColor;
+
+in vec2 uv;
+
+uniform sampler2D screenTexture;
+
+float warp = 0.75; // simulate curvature of CRT monitor
+float scan = 0.75; // simulate darkness between scanlines
+
+void main(){
+    // squared distance from center
+    vec2 crt_uv = uv;
+    vec2 dc = abs(0.5-uv);
+    dc *= dc;
+    
+    // warp the fragment coordinates
+    crt_uv.x -= 0.5; crt_uv.x *= 1.0+(dc.y*(0.3*warp)); crt_uv.x += 0.5;
+    crt_uv.y -= 0.5; crt_uv.y *= 1.0+(dc.x*(0.4*warp)); crt_uv.y += 0.5;
+
+    // sample inside boundaries, otherwise set to black
+    if (crt_uv.y > 1.0 || crt_uv.x < 0.0 || crt_uv.x > 1.0 || crt_uv.y < 0.0) {
+        fragColor = vec4(0.0, 0.0, 0.0, 1.0);
+    }
+    else {
+        // determine if we are drawing in a scanline
+        float apply = abs(sin(crt_uv.y * 300)*0.5*scan);
+        //sample the texture
+    	fragColor = vec4(mix(texture(screenTexture, crt_uv).rgb,vec3(0.0), apply), 1.0);
+    }
+}

{basilisk_engine-0.1.2.dist-info → basilisk_engine-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: basilisk-engine
-Version: 0.1.2
+Version: 0.1.4
 Summary: Python 3D Framework
 Home-page: https://basilisk-website.vercel.app/
 Author: Name

{basilisk_engine-0.1.2.dist-info → basilisk_engine-0.1.4.dist-info}/RECORD

@@ -1,58 +1,61 @@
-basilisk/__init__.py,sha256=FF8VVbZ74c3pj8Yg4rGmuAeuFGc00-MdCeic7lx5R8E,422
+basilisk/__init__.py,sha256=NuCTELN2mKVpKCqDt6n2ZEVnNYawRRT_a2-TyUERrRQ,468
 basilisk/config.py,sha256=ynTRlX633DGoEtZOeAK8KNJF6offV3k3XFD7cia3Keg,61
-basilisk/engine.py,sha256=0tMlCyNhAZPm7Lq5vXCJmyv--lvOReeIh61KCdQMrD0,6551
-basilisk/scene.py,sha256=vSXCv-wc6OLO3vax03RLB7Gt6xaoCr_S5TZVxefRMp4,8324
+basilisk/engine.py,sha256=7eIPyyLiZqL74j4zjCW2XBiHtrrSXte88HIYLD_yRys,6669
+basilisk/scene.py,sha256=i0PCBN40mpQlKjCNqpv0e-YooVbn0h36tlG3fidfJQI,11337
 basilisk/bsk_assets/Roboto-Regular.ttf,sha256=kqYnZjMRQMpbyLulIChCLSdgYa1XF8GsUIoRi2Gcauw,168260
 basilisk/bsk_assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/bsk_assets/basilisk.png,sha256=1xePD8qDycxlRQ7hjEmfuw900BRykhRyumJePi6hxi8,21299
 basilisk/bsk_assets/cube.obj,sha256=rLm2nNcfj1zPZUx-VSF5CxqnToteHjzXQNxfRNq5iKU,1189
 basilisk/bsk_assets/skybox.png,sha256=0C9MvWUwNzewyiMtWLKrZJzAcLC1Ce72T3-Lq4hJZu0,1206153
 basilisk/collisions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-basilisk/collisions/collider.py,sha256=pg1oVzxrtOkp-rO0ltBKzBY6jXrbi7MS7fIfsyJskFI,3945
-basilisk/collisions/collider_handler.py,sha256=dPC11sznqHDK2UmXNXrcq6UP7qngeRJER-XnQqn6Hmk,11616
+basilisk/collisions/collider.py,sha256=PTb14D2ppia3zdHRVlMvsXhRHBJJZyxUv5diLbQ59K8,4573
+basilisk/collisions/collider_handler.py,sha256=dEaIcpV6596P9clbgMFOJnnr_VYXiHSEl48oUZZ0BYk,11519
 basilisk/collisions/broad/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/collisions/broad/broad_aabb.py,sha256=cyBCFFFkMY0yNDqBUY0HZ711m3QSSzoW2Ao9f8cFshE,4708
 basilisk/collisions/broad/broad_bvh.py,sha256=M7sMYRzxAwjIu_nkYKrL8HW3YxzBvfrSN1qKClNY568,5127
 basilisk/collisions/narrow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/collisions/narrow/contact_manifold.py,sha256=rBqFAKvCR8ksYs54GkjZf8GVzN7hoJ6ZLbjd4bDd39Q,4819
-basilisk/collisions/narrow/dataclasses.py,sha256=RFMwSy2q5VGtN36qMT0Qn6LeNEwBrp28aogGQExAyeQ,803
+basilisk/collisions/narrow/dataclasses.py,sha256=IbRJFCJl4atJjDv1ub_OMZt7OdzwTt1s4tTKdFhfNCM,912
 basilisk/collisions/narrow/deprecated.py,sha256=yQh6VOoVcwYENU4TThk_pXPSmwT3EfxMKILVR43sEDI,2751
 basilisk/collisions/narrow/epa.py,sha256=kzKRs62kpTDqIqPz7Te1SV6OGWmfFb9Z7kZ1PqAMEwQ,4711
 basilisk/collisions/narrow/gjk.py,sha256=lncqQ4ZkmSa-wPlAUpkdzdSdbiJjiYKDTqqGSr9xRGc,3338
 basilisk/collisions/narrow/graham_scan.py,sha256=4cpsK2qbvLPw09LGXZp779Z536B-bpQciF-atZ4ngEI,862
-basilisk/collisions/narrow/helper.py,sha256=n_ZPGxKhkbubam5ya-OiUiLLejRVl9kdKbN19-_IiKY,1238
+basilisk/collisions/narrow/helper.py,sha256=SyLuxBLlgoLAQ1Wk6eC-7BubNsjx3Nd3-Aek73R9Bm4,1256
 basilisk/collisions/narrow/line_intersections.py,sha256=CGtttZ6n51u4l8JtQXzkClgZ_uvgx9IyrrGqli6JDbI,4629
 basilisk/collisions/narrow/sutherland_hodgman.py,sha256=SUjSU5y7AuzIDiljMcTXxlGuFHT5IwtrOJ_k5HS1S2Y,3140
 basilisk/draw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/draw/draw.py,sha256=S1eMkuOiM2M0GQTxb1LgFMX7OCDn3YsUCkNc6-t-ClU,3631
-basilisk/draw/draw_handler.py,sha256=kWIvocGY6-1gnqx-yEIGDEVSPURcLzfGYZs4WS7s0oY,7629
+basilisk/draw/draw_handler.py,sha256=cqgjm8HXR9XcL723XSHhTSxYPz9Awhw2q4gmW7Oi6uY,6278
 basilisk/draw/font_renderer.py,sha256=gyI59fW3DUswIcSg5VJLLcJti3OLTMdXNQrYJaw18dE,1092
 basilisk/generic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/generic/abstract_bvh.py,sha256=iQ6HjcI8Msw34dZ3YuDAhWSqEc4NTBHAaGqAZZAoLL8,383
 basilisk/generic/abstract_custom.py,sha256=EPE2_2OxXyrx1YYO3niSxQ05ocxXnbAmFo7fr121Zxk,4537
 basilisk/generic/collisions.py,sha256=N0A2eShH4wkXXvYQcFB_dTTouYxQs51qb3CpWDyxiak,2659
-basilisk/generic/input_validation.py,sha256=-N2q1S1MMsrwBR9617waBe2VTVx4G3hkfVrN7bVB60o,1325
+basilisk/generic/input_validation.py,sha256=0e0H7EOAMgSfxctfh8ITfnY2xglqpO44SLqi2-i0BNA,3577
 basilisk/generic/math.py,sha256=_MfMdu1t0JIdGplGnU9_Tj4ECuxhSNmauLg8zw1zcNs,176
 basilisk/generic/matrices.py,sha256=NNvD0m6Y8lZLa5m6TeXI9k_pMJH0Bo2recL8eVqKjvo,1254
 basilisk/generic/meshes.py,sha256=0Zq5EkWEtqz-2V-kEQt-R3JZvUS5RTqflih8Mj9vL4o,2639
 basilisk/generic/quat.py,sha256=2yXZ5x1GjWQRCui0XDFITGWl9cf3W1KxTtMYfNMbU64,5110
 basilisk/generic/quat_methods.py,sha256=FFqS2Iy1OLH6oJf1elhH9RbWiE_KMXe5eO95ayrEhbc,241
+basilisk/generic/raycast_result.py,sha256=KHolRJkYZagnw_0GhYMfsS05q03n9ng3GJlRY0k4Ndo,675
 basilisk/generic/vec3.py,sha256=n_OAVVFtzH-ctqU8Pqhs2426MQ0WOgBbq2Lfo3Nt498,5280
 basilisk/input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-basilisk/input/mouse.py,sha256=ReFzNjGpmmNnoyypLZXlG1TV380Y1tpQMqtKXfrxYcY,1900
+basilisk/input/mouse.py,sha256=K2An-VI3r3VZLEx9bChKp2U2jHfSdxrvHtmyBu4yzCE,1998
+basilisk/input/path.py,sha256=GiO1OS1UGujnl3KdIB7fGzI5BgIg7RHyI8LxsGWskcs,455
 basilisk/mesh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/mesh/cube.py,sha256=UAwjEmaoWfUdtSKjxATU6vUbksDYj7_bBIr1k1xDsYc,1077
 basilisk/mesh/mesh.py,sha256=vujJ0VxwCvvIKBAScPzo8nWWAouyRzE97M4-JVpqco0,9782
-basilisk/mesh/mesh_from_data.py,sha256=uP7acL2jLELHCVCPgXMKzbSuluZL6azgJyn_VDanjM4,4425
+basilisk/mesh/mesh_from_data.py,sha256=P3cjtRbH1aNv0o9yeJXPu_TCp7IdZ4rVQG8kLIizlgs,4370
 basilisk/mesh/model.py,sha256=uVnYm_XYSoZslNWmOego59Ku-gqKxZHpta_dHi65X1s,11993
 basilisk/mesh/narrow_aabb.py,sha256=0lc06JgdfhUbzxUnCz4dcbEYSB3xjAf7DY7ec2096is,3868
 basilisk/mesh/narrow_bvh.py,sha256=jLQhmUNi6mFyU2wVwB_SOf4PIaOAygBTtcnQIyaMOGg,4351
 basilisk/mesh/narrow_primative.py,sha256=vWpIeo8I9le-EAvcr9rFUQlbl9mi6eYroqCSMK-m9eY,953
 basilisk/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-basilisk/nodes/node.py,sha256=ZrXv8bsM8Q_7CTuhRoRFXmVn3ZPsmvMgvLo-VxbcnYc,28529
-basilisk/nodes/node_handler.py,sha256=CWSD5aE7WeqkmTtd1zdObfpp1OlOzptLi705mWUt_nY,6148
+basilisk/nodes/helper.py,sha256=VdlGuEaMtLa992_8yNOB-QIgz4Izr5wNMSm8H6KftKE,2097
+basilisk/nodes/node.py,sha256=knKs9ttO7kfMBBsRgvPZ3xe4OUIHplEeQkbSZskpsNk,32076
+basilisk/nodes/node_handler.py,sha256=zN7z_XhgJhxcKHq137h5xAcF8RqRD1mjQjkYgnC8Fpk,4097
 basilisk/particles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-basilisk/particles/particle_handler.py,sha256=NlgY8pC3lEOfCqouLOJ4mRUBTGbBmCyDiFAp2hlcB2I,2413
+basilisk/particles/particle_handler.py,sha256=8TXVE4drKwwErqgFzWLyQgU-kk97cABsEMitrfSY4SA,2916
 basilisk/particles/particle_renderer.py,sha256=3OpkKLw4NUik4stORqMkCx1vqibXkdYVq0NDDjigAdo,3623
 basilisk/physics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/physics/impulse.py,sha256=zv6MoGTSlu8qVbsbe2QxERGeyQZYbtzR_WVSqVLsmhw,5873
@@ -60,22 +63,25 @@ basilisk/physics/physics_body.py,sha256=_mi-AVMgQqUsC3bQIca5tgk2xWXTIUw0D_uC4DcQ
 basilisk/physics/physics_engine.py,sha256=IPMshr4j5TII5JdcRqiULc6BfkeCLPxdICKqQeZGAtY,1735
 basilisk/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/render/batch.py,sha256=Vmsm7zA2xi2xE4KKutxkasYfhnRNfyF8CI_HBIZNBIc,2998
-basilisk/render/camera.py,sha256=2LykskC-Xk6gXwYk0SWnzl0jzQxJCvPOWXYNASx9Ykk,7332
+basilisk/render/camera.py,sha256=PDWOToHe1qgS3f3-FD1myq1JaAFQvPv8gb9N1megyAI,7487
 basilisk/render/chunk.py,sha256=YNtoXrZN175u0USSCkpO3_0FiMrBIoaqMZl9XAoJLAA,2656
 basilisk/render/chunk_handler.py,sha256=-vlrlEDqZIoBom2YK8c1yu9sGb7AHH-IbkI4IWYYd5Y,6168
-basilisk/render/frame.py,sha256=OwgDtBK3EtXTD8e6o8chAl0Wu3fg-KwTEYQg1-r21y8,6728
-basilisk/render/image.py,sha256=_VB9e_2iRrjIQGS9cQa9V0xJ42x29AtYsu6GHSWLRRQ,2625
+basilisk/render/frame.py,sha256=iHc792gKR8GCTDVKzxfAcO1TTwaKscTLaS1rbPuEplE,3222
+basilisk/render/framebuffer.py,sha256=aSdnqkht4OihEHxIDuRjLf1rrLNeMEY6tChkFaAr7mk,3166
+basilisk/render/image.py,sha256=e5EDImMdqkdSeK76cPiTPH9TRdIfUZ_HljiP4EQMedo,2961
 basilisk/render/image_handler.py,sha256=6limLZvLznUK_l1UdEBsQ3XEPnnrCLzmBzSyifbV81M,4351
 basilisk/render/light.py,sha256=hFqODv9iK4GEDZeDyBHxOWwwd4v8Pm089_xoScBMjVY,3879
 basilisk/render/light_handler.py,sha256=Le5InqqjgglSXUu7MwkVVsb7WbNJeRkRKldYDQGr6kg,2161
 basilisk/render/material.py,sha256=JmmwCxSYkPLHw73bH-7SzPo5ewzbU3QPTIvI_2pInXQ,9655
 basilisk/render/material_handler.py,sha256=dbfQs0u7qkEan0e0FsnqPpxbmkSNAQmH2B9jv4vx-bs,4242
+basilisk/render/post_process.py,sha256=xq5Iad2J_WxECG_ee472IJeFRiGsITRSQeCFLZS_h5k,4894
 basilisk/render/shader.py,sha256=uFV1gv-MiWRG-nvv2akB0K2SrADWQ54vBYqHeJoy0PY,3913
 basilisk/render/shader_handler.py,sha256=YDl4XGsAUrA_JavmsG2nuoo6k8WyzKNsx20App-RVSk,2511
 basilisk/render/sky.py,sha256=TwLJ_6dYWCOAb06HZocrRdBzlbR6mQ0ojmmJgCC6im4,4910
 basilisk/shaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/shaders/batch.frag,sha256=658z5GLegHDarroeqUpoiWDCCT2FHMr0ZHnYJ21qMhQ,9339
 basilisk/shaders/batch.vert,sha256=nUZKd5uBTFJm1aOG0auQRxE2ElhcAGf1YmepyzWeG8g,5403
+basilisk/shaders/crt.frag,sha256=7o0SoHAzi3-PYMVO8DpwhfAzRP0-P-OG1LCKgBM2AOc,965
 basilisk/shaders/draw.frag,sha256=XV7dcVm-RhZXs6e6ddJhesR6BAmVWEHZqQgEJQEA77Q,450
 basilisk/shaders/draw.vert,sha256=UQtceYDIUfrluXZSb_Y_L8_-Ky_bjAj9Uyvuu8KkpeE,509
 basilisk/shaders/filter.frag,sha256=m_egR4yiFRmIHGwCCfpcdvGXQi1w1Ago_iABlbnX80c,584
@@ -89,7 +95,7 @@ basilisk/shaders/particle.frag,sha256=Cv8cWQpVVQvhZeWj3NqL0D5nLtSO3EWV0VzOU-ZVL4
 basilisk/shaders/particle.vert,sha256=ElXzT7ywiZ0SjrFcUistVDBi4wOobQ7_J5O7XVxrsVs,3027
 basilisk/shaders/sky.frag,sha256=vTmZ1Xsd601_gmeBRfLYodHuBoBDI-M_1IybRt0ZDFk,178
 basilisk/shaders/sky.vert,sha256=v_BSdnMiljSJGPqno-J_apAiom38IrBzbDoxM7pIgwI,345
-basilisk_engine-0.1.2.dist-info/METADATA,sha256=f2o57SAmYiM3Mx6GT0Xq2I3G1FS0jrCEfEYbepAyZqo,1146
-basilisk_engine-0.1.2.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-basilisk_engine-0.1.2.dist-info/top_level.txt,sha256=enlSYSf7CUyAly1jmUCNNGInTbaFUjGk4SKwyckZQkw,9
-basilisk_engine-0.1.2.dist-info/RECORD,,
+basilisk_engine-0.1.4.dist-info/METADATA,sha256=QVZ6ZqjIialwVSIreprtYro1yCIxxTbZ9W84Xk6WTJY,1146
+basilisk_engine-0.1.4.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+basilisk_engine-0.1.4.dist-info/top_level.txt,sha256=enlSYSf7CUyAly1jmUCNNGInTbaFUjGk4SKwyckZQkw,9
+basilisk_engine-0.1.4.dist-info/RECORD,,