basilisk-engine 0.1.40__py3-none-any.whl → 0.1.42__py3-none-any.whl

basilisk/collisions/collider.py

@@ -39,9 +39,9 @@ class Collider():
     def __init__(self, node, collider_mesh: str|Mesh=None, static_friction: glm.vec3=0.7, kinetic_friction: glm.vec3=0.3, elasticity: glm.vec3=0.2, collision_group: str=None):
         self.collider_handler = None
         self.node = node
-        self.static_friction = static_friction if elasticity else 0.8 # added checks to prevent floats being set to None. Also done for kinetic and elasticity
+        self.static_friction = static_friction if static_friction else 0.8 # added checks to prevent floats being set to None. Also done for kinetic and elasticity
         self.mesh = collider_mesh
-        self.kinetic_friction = kinetic_friction if elasticity else 0.4
+        self.kinetic_friction = kinetic_friction if kinetic_friction else 0.4
         self.elasticity = elasticity if elasticity else 0.1
         self.collision_group = collision_group
         self.collision_velocity = 0

basilisk/engine.py

@@ -107,6 +107,7 @@ class Engine():
         self.shader_handler   = ShaderHandler(self)
         self.draw_handler     = DrawHandler(self)
         self.frame            = Frame(self)
+        self.frames = []
         self.material_handler.set_base()
 
     def _update(self) -> None:
@@ -115,16 +116,21 @@ class Engine():
         Updates all input, physics, and time variables. Clears the frame.
         """
 
+        # Used to lock this internal update until user calls engine.update()
         if self.current_frame_updated: return
+        self.current_frame_updated = True
 
+        # Clear frame data
         for fbo in self.fbos: fbo.clear()
+        self.frames.clear()
+        self.frame.clear()
+        self.ctx.clear()
+
+        # Update time and IO
         self.clock.update()
         self.IO.update()
 
-        self.current_frame_updated = True
-
-
-    def update(self) -> None:
+    def update(self, render=True) -> None:
         """
         Calls internal update if needed
         Renders the draw handler
@@ -133,21 +139,21 @@ class Engine():
 
 
         # Must update the frame
-        if not self.current_frame_updated: self._update()
+        self._update()
         if not self.running: return
 
         # Render all draw calls from the past frame
-        self.frame.use()
+        self.ctx.screen.use()
         self.draw_handler.render()
 
         # Clear the screen and render the frame
-        self.ctx.screen.use()
-        self.ctx.clear()
-        self.frame.render()
-        pg.display.flip()
-
-        self.frame.clear()
+        if render:
+            for frame in self.frames:
+                frame.render(self.frame.output_buffer)
+            self.frame.render()
 
+        # Even though we may not render here, the user might be rendering in their file, so we need to flip
+        pg.display.flip()
 
         # Allow for the engine to take in input again
         self.current_frame_updated = False

basilisk/render/bloom.py

@@ -27,13 +27,15 @@ class Bloom:
         GPU downsamples and upsamples the bloom texture to blur it
         """
     
-        if not self.frame.engine.config.bloom_enabled:
-            getattr(self, f'upscale_buffer_0').clear()
-            return
+        self.clear()
 
         n = self.engine.config.bloom_quality
 
-        self.downsample(self.frame.framebuffer.color_attachments[1], getattr(self, f'bloom_buffer_{0}'))
+
+        self.ctx.enable(mgl.BLEND)
+        self.ctx.blend_func = mgl.ADDITIVE_BLENDING
+
+        self.downsample(self.frame.input_buffer.color_attachments[1], getattr(self, f'bloom_buffer_{0}'))
         for i in range(0, n):
             self.downsample(getattr(self, f'bloom_buffer_{i}'), getattr(self, f'bloom_buffer_{i + 1}'))
 
@@ -41,6 +43,8 @@ class Bloom:
         for i in range(n - 1, -1, -1):
             self.upsample(getattr(self, f'upscale_buffer_{i + 1}'), getattr(self, f'bloom_buffer_{i}'), getattr(self, f'upscale_buffer_{i}'))
 
+        self.ctx.disable(mgl.BLEND)
+
     def downsample(self, source: Framebuffer, dest: Framebuffer) -> None:
         """
         
@@ -78,31 +82,43 @@ class Bloom:
         # Render using the upsample vao (3x3 tent filter)
         self.upsample_vao.render()
 
+        return dest
+
     def generate_bloom_buffers(self) -> None:
         """
         Generates n buffers for down/up sampling
         """
 
         n = self.engine.config.bloom_quality
-        size = self.frame.framebuffer.size
+        size = self.frame.input_buffer.size
 
         for i in range(100):
             try:
                 getattr(self, f'bloom_buffer_{i}').__del__()
                 getattr(self, f'upscale_buffer_{i}').__del__()
             except:
-                ...
+                break
 
         for i in range(n + 1):
-            fbo = Framebuffer(self.engine, (max(size[0] // (2 ** (i)), 1), max(size[1] // (2 ** (i)), 1)))
+            fbo = Framebuffer(self.engine, size=(max(size[0] // (2 ** (i)), 1), max(size[1] // (2 ** (i)), 1)))
             fbo.texture.repeat_x = False
             fbo.texture.repeat_y = False
             setattr(self, f'bloom_buffer_{i}', fbo)
 
-            fbo = Framebuffer(self.engine, (max(size[0] // (2 ** (i)), 1), max(size[1] // (2 ** (i)), 1)))
+            fbo = Framebuffer(self.engine, size=(max(size[0] // (2 ** (i)), 1), max(size[1] // (2 ** (i)), 1)))
             fbo.texture.repeat_x = False
             fbo.texture.repeat_y = False
             setattr(self, f'upscale_buffer_{i}', fbo)
 
+    def clear(self):
+        for i in range(100):
+            try:
+                getattr(self, f'bloom_buffer_{i}').clear()
+                getattr(self, f'upscale_buffer_{i}').clear()
+            except:
+                break
+
+    @property
+    def texture(self): return getattr(self, f'upscale_buffer_0').texture
     @property
-    def texture(self): return getattr(self, f'upscale_buffer_0').texture
+    def fbo(self): return getattr(self, f'upscale_buffer_0')

basilisk/render/frame.py

@@ -1,6 +1,7 @@
 import numpy as np
 import moderngl as mgl
 from .shader import Shader
+from .image import Image
 from .framebuffer import Framebuffer
 from .post_process import PostProcess
 from .bloom import Bloom
@@ -10,7 +11,6 @@ class Frame:
     shader: Shader=None
     vbo: mgl.Buffer=None
     vao: mgl.VertexArray=None
-    framebuffer: mgl.Framebuffer=None
 
     def __init__(self, engine, scale: float=1.0, linear_filter: bool=False) -> None:
         """
@@ -22,15 +22,12 @@ class Frame:
         self.ctx    = engine.ctx
 
         # Load framebuffer
-        self.framebuffer = Framebuffer(self.engine, scale=scale, n_color_attachments=2, linear_filter=linear_filter)
-        self.ping_pong_buffer = Framebuffer(self.engine, scale=scale, n_color_attachments=2, linear_filter=linear_filter)
-
-        self.framebuffer.texture.repeat_x = False
-        self.framebuffer.texture.repeat_y = False
+        self.output_buffer = Framebuffer(self.engine, scale=scale, n_color_attachments=2, linear_filter=linear_filter)
+        self.input_buffer = Framebuffer(self.engine, scale=scale, n_color_attachments=3, linear_filter=linear_filter)
+        self.ping_pong_buffer = Framebuffer(self.engine, scale=scale, n_color_attachments=3, linear_filter=linear_filter)
 
         # Load Shaders
-        self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/bloom_frame.frag')
-        self.engine.shader_handler.add(self.shader)
+        self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame_hdr.frag')
 
         # 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'))
@@ -42,38 +39,41 @@ class Frame:
         self.post_processes = []
 
 
-    def render(self) -> None:
+    def scene_render(self, target=None) -> None:
         """
-        Renders the current frame to the screen
+        Renders the current frame to the screen or the given target
         """
 
-        self.ctx.enable(mgl.BLEND)
-        self.ctx.blend_func = mgl.ADDITIVE_BLENDING
-
         if self.engine.event_resize: self.bloom.generate_bloom_buffers()
 
-        self.bloom.render()
         
-        for process in self.post_processes:
-            self.ping_pong_buffer = process.apply([('screenTexture', self.framebuffer)], self.ping_pong_buffer)
+        # for process in self.post_processes:
+        #     self.ping_pong_buffer = process.apply([('screenTexture', self.input_buffer)], self.ping_pong_buffer)
             
-            temp = self.framebuffer
-            self.framebuffer = self.ping_pong_buffer
-            self.ping_pong_buffer = temp
+        #     temp = self.input_buffer
+        #     self.input_buffer = self.ping_pong_buffer
+        #     self.ping_pong_buffer = temp
         
-        self.ctx.screen.use()
-        self.shader.bind(self.framebuffer.texture, 'screenTexture', 0)
+
+        self.bloom.render()
+        target.use() if target else self.output_buffer.use()
+        self.shader.bind(self.input_buffer.texture, 'screenTexture', 0)
         self.shader.bind(self.bloom.texture, 'bloomTexture', 1)
         self.vao.render()
 
-        self.ctx.disable(mgl.BLEND)
+    def render(self, target=None) -> None:
+        """
+        Renders the current frame to the screen or the given target
+        """
+
+        self.output_buffer.render(target=target)
 
     def use(self) -> None:
         """
         Uses the frame as a render target
         """
         
-        self.framebuffer.use()
+        self.input_buffer.use()
 
     def add_post_process(self, post_process: PostProcess) -> PostProcess:
         """
@@ -88,17 +88,30 @@ class Frame:
         Saves the frame as an image to the given file destination
         """
 
-        self.framebuffer.save(destination)
+        self.output_buffer.save(destination)
     
     def clear(self):
-        self.framebuffer.clear()
+        """
+        Clears the framebuffer of the frame
+        """
+        
+        self.input_buffer.clear()
+        self.output_buffer.clear()
+        self.bloom.clear()
+
+    def bind(self, sampler: mgl.Texture | mgl.TextureArray | mgl.TextureCube | Image, name: str, slot: int=None):
+        """
+        Binds a texture to the fbo's shader
+        """
+        
+        self.shader.bind(sampler, name, slot)
 
     def resize(self) -> None:
         """
         Resize the frame to the given size. None for window size
         """
 
-        self.framebuffer.resize()
+        self.input_buffer.resize()
         self.ping_pong_buffer.resize()
         self.generate_bloom_buffers()
 
@@ -108,4 +121,9 @@ class Frame:
         """
         
         if self.vbo: self.vbo.release()
-        if self.vao: self.vao.release()
+        if self.vao: self.vao.release()
+
+    @property
+    def texture(self): return self.output_buffer.texture
+    @property
+    def depth(self): return self.output_buffer.depth

basilisk/render/framebuffer.py

@@ -25,7 +25,7 @@ class Framebuffer:
     _depth_attachment = None
     """"""
 
-    def __init__(self, engine: ..., size: tuple[int]=None, n_color_attachments: int=1, scale: float=1.0, linear_filter: bool=True) -> None:
+    def __init__(self, engine: ..., shader: Shader=None, size: tuple[int]=None, n_color_attachments: int=1, scale: float=1.0, linear_filter: bool=True) -> None:
         """
         Abstraction of the MGL framebuffer.
         Has the given number of color attachements (4-component) and 1 depth attachment.
@@ -36,6 +36,7 @@ class Framebuffer:
         self.ctx            = engine.ctx
         self._size          = size
         self.scale          = scale
+        self.shader         = shader
         self.texture_filter = (mgl.LINEAR, mgl.LINEAR) if linear_filter else (mgl.NEAREST, mgl.NEAREST)
         self.n_attachments  = n_color_attachments
 
@@ -50,20 +51,21 @@ class Framebuffer:
         """
 
         # Release existing memory
-        self.__del__()
+        if self._color_attachments: [tex.release() for tex in self._color_attachments]
+        if self._depth_attachment: self._depth_attachment.release()
 
         # Create textures
         self._color_attachments = [self.ctx.texture(self.size, components=4, dtype='f4') for i in range(self.n_attachments)]
-        for tex in self._color_attachments: tex.filter = self.texture_filter
+        for tex in self._color_attachments: 
+            tex.filter = self.texture_filter
+            tex.repeat_x = False
+            tex.repeat_y = False
+
         self._depth_attachment  = self.ctx.depth_texture(self.size)
 
         # Create the internal fbo
         self.fbo = self.ctx.framebuffer(self._color_attachments, self._depth_attachment)
 
-        # Texture attributes
-        self.texture.repeat_x = False
-        self.texture.repeat_y = False
-
         # Set the show attachment to default
         self._show = -1
         self.show = 0
@@ -88,27 +90,28 @@ class Framebuffer:
         """
 
         # Load Shaders
-        self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame.frag')
+        if not self.shader: self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame.frag')
         self.engine.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)
 
-    def render(self, render_target=None, show: int=None) -> None:
+    def render(self, target=None, color_attachment: int=0, auto_bind=True) -> None:
         """
         Render the fbo to the screen
         If the fbo has multiple attachments, show will specifiy which is shown
         Depth is considered the last show element
         """
 
-        if not isinstance(show, type(None)): self.show = show
+        # if not isinstance(show, type(None)): self.show = show
 
-        target = render_target if render_target else self.engine.frame
-        target.use()
+        target.use() if target else self.ctx.screen.use()
 
+        if auto_bind: self.bind(self.color_attachments[min(color_attachment, len(self.color_attachments) - 1)], 'screenTexture', 0)
         self.vao.render()
 
+
     def use(self) -> None:
         """
         Select this framebuffer for use
@@ -116,13 +119,20 @@ class Framebuffer:
 
         self.fbo.use()
 
-    def clear(self) -> None:
+    def clear(self, color: tuple=(0, 0, 0, 0)) -> None:
         """
         Clear all data currently in the textures (set to black)        
         """
 
         self.fbo.clear()
 
+    def bind(self, sampler: mgl.Texture | mgl.TextureArray | mgl.TextureCube , name: str, slot: int=None):
+        """
+        Binds a texture to the fbo's shader
+        """
+        
+        self.shader.bind(sampler, name, slot)
+
     def save(self, destination: str=None) -> None:
         """
         Saves the frame as an image to the given file destination
@@ -180,7 +190,7 @@ class Framebuffer:
         self._show = value
 
         # Bind the correct texture
-        self.shader.program['screenTexture'] = value+1
+        # self.shader.program['screenTexture'] = value+1
         src.use(location=value+1)
 
     def __repr__(self) -> str:

basilisk/render/post_process.py

@@ -4,7 +4,6 @@ from .shader import Shader
 from .image import Image
 from .framebuffer import Framebuffer
 
-
 class PostProcess:
     engine: ...
     """Reference to the parent engine"""
@@ -14,6 +13,7 @@ class PostProcess:
     """Shader object used by the post process"""
     vao: mgl.VertexArray
     """Screenspace render vao"""
+    fbo: Framebuffer=None
 
     def __init__(self, engine, shader_path: str=None, size: tuple=None, components: int=4, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
         """
@@ -49,17 +49,33 @@ class PostProcess:
         self.fbo.texture.filter = self.filter
 
 
-    def apply(self, source: list[tuple[str, mgl.Texture]] | list[tuple[str, Image]] | list[tuple[str, Framebuffer]], destination: mgl.Texture | Image | Framebuffer=None) -> mgl.Texture | Image | Framebuffer:
+    def apply(self, sources: list[tuple[str, mgl.Texture]] | list[tuple[str, Image]] | list[tuple[str, 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[0][1], Framebuffer): return self._apply_to_framebuffer(source, destination)
-        elif isinstance(source[0][1], mgl.Texture): return self._apply_to_texture(source, destination)
-        elif isinstance(source[0][1], Image):       return self._apply_to_image(source, destination)
-        
-        raise ValueError(f'PostProces.apply: Invalid postprocess source type {type(source)}')
+        # Write all the given sources to the GPU
+        self._write_sources(sources)
+
+        # Get the redner target
+        if isinstance(destination, Framebuffer) or isinstance(destination, type(self.engine.frame)): fbo = destination
+        elif isinstance(destination, mgl.Texture): fbo = self.ctx.framebuffer([destination], None)
+        elif isinstance(destination, Image): fbo = self.ctx.framebuffer([destination.texture], None)
+
+        # Apply the post process
+        fbo.use()
+        fbo.clear()
+        self.vao.render()
+
+        # Simply return the given fbo if provided
+        if isinstance(destination, Framebuffer) or isinstance(destination, type(self.engine.frame)): return destination
+
+        # Else, need to release the data and return the texture
+        texture = fbo.color_attachments[0]
+        fbo.release()
+        return texture
+
 
     def resize(self, size: tuple=None):
         """
@@ -68,6 +84,24 @@ class PostProcess:
         
         self.size = size if size else self.engine.win_size
 
+    def _write_sources(self, sources: list[tuple[str, mgl.Texture]] | list[tuple[str, Image]] | list[tuple[str, Framebuffer]]):
+        """
+        Writes all given source images to the GPU
+        """
+        
+        for i, source in enumerate(sources):
+            # Get the name and data
+            name, data = source
+
+            # Extract the needed data
+            if   isinstance(data, mgl.Texture): texture = data
+            elif isinstance(data, Image) or isinstance(data, Framebuffer) or isinstance(data, type(self.engine.frame)): texture = data.texture
+            else: raise ValueError(f'PostProces.apply: Invalid postprocess source type {type(source)}')
+
+            # Write the texture
+            self.shader.program[name] = i
+            texture.use(location=i)
+
     def _render_post_process(self, source: mgl.Texture):
         # Clear and use the fbo as a render target
         self.fbo.use()
@@ -144,4 +178,4 @@ class PostProcess:
     def __del__(self):
         if self.vao: self.vao.release()
         if self.vbo: self.vbo.release()
-        if self.fbo: self.fbo.release()
+        if self.fbo: self.fbo.__del__()

basilisk/render/shader_handler.py

@@ -3,6 +3,12 @@ import glm
 from .shader import Shader
 
 
+# Camera view constants
+FOV = 50  # Degrees
+NEAR = 0.1
+FAR = 350
+
+
 class ShaderHandler:
     engine: ...
     """Back reference to the parent engine"""
@@ -64,7 +70,10 @@ class ShaderHandler:
             'cameraPosition' : scene.camera.position,
             'viewportDimensions' : glm.vec2(self.engine.win_size),
             'gamma' : self.engine.config.gamma,
-            'exposure' : self.engine.config.exposure
+            'exposure' : self.engine.config.exposure,
+            'near' : glm.float32(NEAR),
+            'far' : glm.float32(FAR),
+            'FOV' : glm.float32(FOV)
         }
 
     def write(self, scene: ...) -> None:

basilisk/render/sky.py

@@ -6,15 +6,16 @@ class Sky:
     texture_cube=None
     vbo          = None
     vao          = None
-    def __init__(self, engine, sky_texture: str | list=None):
+    def __init__(self, scene, sky_texture: str | list=None):
         """
         Handler for all skybox rendering
         """
         
-        self.engine = engine
-        self.ctx   = engine.ctx
+        self.scene  = scene
+        self.engine = scene.engine
+        self.ctx    = scene.ctx
         
-        if not sky_texture: sky_texture = engine.root + '/bsk_assets/skybox.png'
+        if not sky_texture: sky_texture = self.engine.root + '/bsk_assets/skybox.png'
 
         self.set_renderer()
         self.set_texture(sky_texture)

basilisk/scene.py

@@ -47,7 +47,8 @@ class Scene():
         self.node_handler     = NodeHandler(self)
         self.particle         = ParticleHandler(self)
         self.collider_handler = ColliderHandler(self)
-        self.sky              = Sky(self.engine)
+        self.sky              = Sky(self)
+        self.frame            = Frame(self.engine)
 
 
     def update(self, render: bool=True, nodes: bool=True, particles: bool=True, collisions: bool=True) -> None:
@@ -55,45 +56,42 @@ class Scene():
         Updates the physics and in the scene
         """
         
-        # Check that the engine is still running
+        # Call the internal engine update (for IO and time)
         self.engine._update()
+
+        # Check that the engine is still running
         if not self.engine.running: return
 
         # Update based on the given parameters
         if nodes: self.node_handler.update()
         if particles: self.particle.update()
-        if self.engine.event_resize: self.camera.use()
+
+        # Update the camera
         self.camera.update()
+        if self.engine.event_resize: self.camera.use()
         
         if collisions and 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()
 
-        # Render by default to the engine frame
-        if not render: return
+        # Render by default to the scene frame
+        if render: self.render()
 
-        # Check if the user is giving a destination
-        if not isinstance(render, bool): self.render(renders)
-        else: self.render()
-
-    def render(self, render_target: Framebuffer|Frame=None) -> None:
+    def render(self, target=None) -> None:
         """
         Renders all the nodes with meshes in the scene
         """
 
-        if render_target:
-            show = False
-        else:
-            render_target = self.engine.frame
-            show = True
-
-        render_target.use()
+        target.use() if target else self.frame.use(); self.frame.clear()
         self.engine.shader_handler.write(self)
-        self.node_handler.render()
         self.particle.render()
+        self.node_handler.render()
         if self.sky: self.sky.render()
 
+        if target: return
+        # This will show the frame to screen on engine.update()
+        self.frame.scene_render(target)
+        self.engine.frames.append(self.frame)
 
-        if self.engine.headless or not show: return
 
 
     def add(self, *objects: Node | None) -> None | Node | list:

basilisk/shaders/batch.frag

@@ -2,6 +2,8 @@
 
 layout (location = 0) out vec4 fragColor;
 layout (location = 1) out vec4 bloomColor;
+layout (location = 2) out vec4 normalTexture;
+
 
 // Structs needed for the shader
 struct textArray {
@@ -276,15 +278,17 @@ void main() {
     // finalColor = pow(finalColor, vec3(1.0/gamma));
 
     // Output fragment color
-    float brightness = dot(fragColor.rgb, vec3(0.2126, 0.7152, 0.0722)) + dot(mtl.emissiveColor, vec3(1));
+    float brightness = dot(fragColor.rgb, vec3(0.2126, 0.7152, 0.0722)) + dot(lightResult.specular, vec3(.2)) + dot(mtl.emissiveColor, vec3(1));
     fragColor = vec4(finalColor + mtl.emissiveColor, 1.0);
 
-    // Filter out bright pixels for bloom
-    // bloomColor = vec4(0.0, 0.0, 0.0, 1.0);
+    normalTexture = vec4(abs(N), 1.0);
+
+    // // Filter out bright pixels for bloom
     if (brightness > 0.5) {
         bloomColor = vec4(fragColor.rgb, 1.0);
     }
     else{
         bloomColor = vec4(0.0, 0.0, 0.0, 1.0);
     }
+
 }

basilisk/shaders/crt.frag

@@ -1,6 +1,7 @@
 #version 330 core
 
-out vec4 fragColor;
+layout (location = 0) out vec4 fragColor;
+layout (location = 1) out vec4 bloomColor;
 
 in vec2 uv;
 
@@ -29,4 +30,6 @@ void main(){
         //sample the texture
     	fragColor = vec4(mix(texture(screenTexture, crt_uv).rgb,vec3(0.0), apply), 1.0);
     }
+
+    bloomColor = vec4(0.0, 0.0, 0.0, 0.0);
 }

basilisk/shaders/draw.frag

@@ -2,6 +2,7 @@
 
 layout (location = 0) out vec4 fragColor;
 layout (location = 1) out vec4 bloomColor;
+layout (location = 2) out vec4 normalTexture;
 
 
 in vec4     color;
@@ -22,5 +23,6 @@ void main() {
     else {
         fragColor = color;
     }
+    normalTexture = vec4(0.0);
     bloomColor = vec4(0.0);
 }

basilisk/shaders/frame.frag

@@ -1,6 +1,6 @@
 #version 330 core
 
-out vec4 fragColor;
+layout (location = 0) out vec4 fragColor;
 
 in vec2 uv;
 
@@ -9,5 +9,6 @@ uniform sampler2D screenTexture;
 
 void main()
 { 
-    fragColor = texture(screenTexture, uv);
+    vec4 color = texture(screenTexture, uv);
+    fragColor = color;
 }

basilisk/shaders/frame_hdr.frag

@@ -0,0 +1,28 @@
+#version 330 core
+
+layout (location = 0) out vec4 fragColor;
+
+in vec2 uv;
+
+uniform sampler2D screenTexture;
+uniform sampler2D bloomTexture;
+
+
+
+void main()
+{ 
+    const float gamma = 2.2;
+    const float exposure = 1.2;
+
+    // Sammple from textures
+    vec4 color = texture(screenTexture, uv);
+    vec4 bloom = texture(bloomTexture, uv);
+
+    vec3 hdrColor = color.rgb + bloom.rgb / 2;
+    // exposure tone mapping
+    vec3 mapped = vec3(1.0) - exp(-hdrColor * exposure);
+    // gamma correction 
+    mapped = pow(mapped, vec3(1.0 / gamma));
+  
+    fragColor = vec4(mapped, color.a);
+}

basilisk/shaders/particle.frag

@@ -2,6 +2,8 @@
 
 layout (location = 0) out vec4 fragColor;
 layout (location = 1) out vec4 bloomColor;
+layout (location = 2) out vec4 normalTexture;
+
 
 in vec2 uv;
 in vec3 position;
@@ -73,5 +75,8 @@ void main()
     fragColor = vec4(color * (.2 + diff), 1.0);
     fragColor.rgb = pow(fragColor.rgb, vec3(1.0/gamma));
 
+    normalTexture = vec4(abs(normal), 1.0);
+
     bloomColor = vec4(mtl.emissiveColor, 1.0);
+
 }

{basilisk_engine-0.1.40.dist-info → basilisk_engine-0.1.42.dist-info}/METADATA

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

{basilisk_engine-0.1.40.dist-info → basilisk_engine-0.1.42.dist-info}/RECORD

@@ -1,7 +1,7 @@
 basilisk/__init__.py,sha256=23OM1kiXMU44J2TVp66efVSrbQAeiuTDmcdhNAftFfY,1134
 basilisk/config.py,sha256=Ajm3BjCryuX5bmJglqRZDR1SjE0sDjTbulta5GZ67hA,1712
-basilisk/engine.py,sha256=74ErjbThT7kGrAhayA6p3QxUOX1ff4rwsoYj8-A-2aE,5722
-basilisk/scene.py,sha256=NSIpvYsZsvxKVkjZTeCHq6cL-wJQETEIjPu-d4xdzbc,12260
+basilisk/engine.py,sha256=_SPTyqrOkn7GSMdjIPbk2m2HVLpePU236I1KA1qgtjw,6083
+basilisk/scene.py,sha256=9iWy86exN5Y48fHCJEOS0gL_yQ0VEceXALo98EqTy4c,12260
 basilisk/audio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/audio/sound.py,sha256=h2dQ3IKb_SRKNZqNuk-fdNg_Xfz0P7sqEXA33qiBXG4,692
 basilisk/bsk_assets/Roboto-Regular.ttf,sha256=kqYnZjMRQMpbyLulIChCLSdgYa1XF8GsUIoRi2Gcauw,168260
@@ -10,7 +10,7 @@ basilisk/bsk_assets/basilisk.png,sha256=1xePD8qDycxlRQ7hjEmfuw900BRykhRyumJePi6h
 basilisk/bsk_assets/cube.obj,sha256=r_pjU5ZT0QuemKPKeFxEsZjNps90iTXuHK7W5wk2Hig,1141
 basilisk/bsk_assets/skybox.png,sha256=0C9MvWUwNzewyiMtWLKrZJzAcLC1Ce72T3-Lq4hJZu0,1206153
 basilisk/collisions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-basilisk/collisions/collider.py,sha256=RoA-RnBmy5OiBj6qLFA4WBL27EdRuLYSaf8tHc_MvN4,4478
+basilisk/collisions/collider.py,sha256=5s5WI7_sctbgM1MmGdDds__8ZQ_N8-Xeba2rV-Qs3Ag,4489
 basilisk/collisions/collider_handler.py,sha256=iyFb4cQFrrYt9kRa8PZf3jih59-JgcB1MLZqMRELiYU,11231
 basilisk/collisions/broad/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/collisions/broad/broad_aabb.py,sha256=gI4bq89WnJ0Za2k6U2VGedjJ9aWvKua9tCUwBFl5h1U,4606
@@ -71,44 +71,45 @@ basilisk/physics/physics_body.py,sha256=-iqo3YyCfMzpBVNA2I34JbfN7Z6phj5nnGHN-S8l
 basilisk/physics/physics_engine.py,sha256=C30oGb8rODdXORJJWjOWBPwlScnTHrp6CTPHSNcbgp0,1700
 basilisk/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/render/batch.py,sha256=1ULXwzcs7v9ze1IDZDJXcaydRjwdgHH9TkyXxcadNiM,3396
-basilisk/render/bloom.py,sha256=hE9JJJ8MIqJ7kXO9jaBmDcc0kSzwLyU578F65pjbMXI,4077
+basilisk/render/bloom.py,sha256=jjkUtg3SaP1by7FGR9E4780u6Xer0GK6y6XPH66vftw,4435
 basilisk/render/camera.py,sha256=pOM5sVSHl_joHwsBLd8Y7CzLUL-16XBBQfgsnM8jc6Q,9649
 basilisk/render/chunk.py,sha256=UPfldvGjIF--sg35Lst69ORZ2xTet-ejWg3kde9-ae8,2758
 basilisk/render/chunk_handler.py,sha256=-Hozyus67mgJ8fTWx3fsLezFVt3W4d-I0I1ai29odWA,6405
-basilisk/render/frame.py,sha256=9QfhbVitXXiL1ag_3qRcFuFR6zbc_4A1SLPs09KuPKc,3446
-basilisk/render/framebuffer.py,sha256=_LdsUTOsOwfeQ3Z7vKURwmNZPwBOKQ50MbOB1fbZvNI,7007
+basilisk/render/frame.py,sha256=I1M5eDzbnjo5_9U3QL02WPGUHw6X-VmGvGtE7O5ILCo,4065
+basilisk/render/framebuffer.py,sha256=4QO5QyX7tCwHysaUV9S2v5rGgg8xhmMzJ6ukjyboQKE,7570
 basilisk/render/image.py,sha256=d-5RGr-TlsGqvI-GQ8_pV-FNdmTzD0mlk2K3K4XNuwQ,3984
 basilisk/render/image_handler.py,sha256=DNb-AiouziLVQu3NkoG1F90YZTHHWyhFYhaWJ9uiUOU,4175
 basilisk/render/light.py,sha256=SOOh5zAGUCgQdJjWb5MlJgtvdxkEV8AWqQ4P93bJj2g,3783
 basilisk/render/light_handler.py,sha256=gvg4OhDMy8dZg5XNcOZB4_1G2uE1gBFRxlBeoG3l3vM,2104
 basilisk/render/material.py,sha256=K2w2pdNI_ZKc0DZqhcGhlj0kQcpSLSlhbPTk-xaisU4,10072
 basilisk/render/material_handler.py,sha256=b9mf35P54CUzSxBgCkteHEY7AMJ623Ct083Xu2fHBHI,4065
-basilisk/render/post_process.py,sha256=ZDj03c23Zw8ewgz0uQN5UIRCOm-7rjbI6ta9ofYAieY,5261
+basilisk/render/post_process.py,sha256=QAIwNccycEJqA1UVGKUqwVus11sJX9qm3Mjl0gdGYSo,6519
 basilisk/render/shader.py,sha256=3_jMKzlwLLWPsZiIjVG8bYLu4CddXrnmCk3ECTD6oZE,4820
-basilisk/render/shader_handler.py,sha256=rj4zbhVOyYBdxcmB6BHE4pynSMk3VtIk4Qo2z_8JVf4,2846
-basilisk/render/sky.py,sha256=orTtgkU35AHZTUGk9IevSXwVs6tktoDP52yEUM5Rg0E,4768
+basilisk/render/shader_handler.py,sha256=eMEvtUYr7bg7PMzmJb0HByWsK1l_xlcfjDrB3ZIqX4I,3029
+basilisk/render/sky.py,sha256=e_x5h59cHevJFAprItBo_M3s1BqNI-1g1pgIsdeCuMw,4806
 basilisk/render/tempCodeRunnerFile.py,sha256=ep1eVZzUd30SDCNE5l3OJsqp2fW2LEXrjYGW31AMWgw,10
 basilisk/shaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-basilisk/shaders/batch.frag,sha256=zyKxzNlPOwAYYeRQCOl-mwGS_hZMesh5JkGcUJIVtf0,9541
+basilisk/shaders/batch.frag,sha256=1U2neL5t6TSMXHgwnEoOjLmG4WNNTLJAkUSIzd4x6lE,9624
 basilisk/shaders/batch.vert,sha256=LYzcqcwCyCpnxF5V-ilx79HU2cYz66hylBmZChcVmos,5555
 basilisk/shaders/bloom_downsample.frag,sha256=0ncVnEfiPYxKnQ95seLTnbm8NXjMSYUIIrDE8owLUKU,1524
 basilisk/shaders/bloom_frame.frag,sha256=Y0m8DnQKz3G9FKq7VjCGrVXZw2vSigyGX7-tlxZN0lE,567
 basilisk/shaders/bloom_upsample.frag,sha256=Pe1AupjM2OCMieW7oEYHoEx2LhbPtbpwcylruF5Ntm4,1156
-basilisk/shaders/crt.frag,sha256=NsFtziQb5KnhjLcSI7UnxF2Jk7mLt2Fw2v4NDwhE_xE,934
-basilisk/shaders/draw.frag,sha256=Beel4sjY-cwbUCUULRjT2BzXfVA-rr12Abz1HxG6inw,528
+basilisk/shaders/crt.frag,sha256=ss6xhXwwOH9bXEhqyim--K4o1BOo1Wwq6tGAwjpRHEQ,1043
+basilisk/shaders/draw.frag,sha256=rcPmGMh850M1ypcFNlJCyFWxfZ739lVNl6OPTxPIYIE,605
 basilisk/shaders/draw.vert,sha256=Rpi6bDsLEiFmuLRCL3yMgmBOR_WWYHQ7LLUUA787cxs,596
 basilisk/shaders/filter.frag,sha256=N4o6429d3azn1CoN0gsLD1v8bG51tdUcmxRTj8R5jg8,562
-basilisk/shaders/frame.frag,sha256=efR8q-iLFVwXuYIpKHr6OKfbG7BwKvmhc-83w42elgY,148
+basilisk/shaders/frame.frag,sha256=_fXX2C233URDvNtOgMocs6ZnEum_kaLZVIa5qc6QNz4,194
 basilisk/shaders/frame.vert,sha256=l2--IIGeRIbfuSyQksguVj3GHZKK-0tsQ6euQ83roUA,214
+basilisk/shaders/frame_hdr.frag,sha256=Jd4ggkZQ6ZkqnfRmjJPoBN3wTpe0m8xoqNL_hS2epcY,585
 basilisk/shaders/geometry.frag,sha256=mTBMWqw7x9r65wNRqHMZeG4wBHmleOD8zAXYy2hcsU0,220
 basilisk/shaders/geometry.vert,sha256=v1Vb7s-D7GDgroGCi-um7ITD7LBlJgGsTtbhwjSYGdI,1432
 basilisk/shaders/normal.frag,sha256=RGI8wORa5x5ZI9YYB56qrZDgbp4qnEWKywHWRVhv_aM,1346
 basilisk/shaders/normal.vert,sha256=Q3t9NjdLcyUggh72Jxi990QtM5Ud2egvOUIBdr9PWqI,3224
-basilisk/shaders/particle.frag,sha256=dQ-TFurL7Dj5Xw_ySF3DpDXUegBnE4mf_vXl7dzbjpg,1884
+basilisk/shaders/particle.frag,sha256=IskhyXelHs9GqABKwTYSwooWL0nP-nkmXl6a5iT6Q3A,1977
 basilisk/shaders/particle.vert,sha256=oiBz6S_2dzqioAhyzVYT1ZKOED4h4R6IoP-UJ8KRHhU,3227
 basilisk/shaders/sky.frag,sha256=dJRdSbg16aZYYjxdoG1spVQRIVBGNVdyX0rqp4ER6v8,556
 basilisk/shaders/sky.vert,sha256=oAnrknEgsd9MawE_zx8P0u9nUSFEBYBg5ykBmWpqZ_g,332
-basilisk_engine-0.1.40.dist-info/METADATA,sha256=G933y6W4DHYC8733l-Lj161v2Yw2QBFDdgRYX22PTnY,3793
-basilisk_engine-0.1.40.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-basilisk_engine-0.1.40.dist-info/top_level.txt,sha256=enlSYSf7CUyAly1jmUCNNGInTbaFUjGk4SKwyckZQkw,9
-basilisk_engine-0.1.40.dist-info/RECORD,,
+basilisk_engine-0.1.42.dist-info/METADATA,sha256=TWa8kZNEEc5aTKupEbwuEOQsPheWfIaIeO0lQqtqa2k,3793
+basilisk_engine-0.1.42.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+basilisk_engine-0.1.42.dist-info/top_level.txt,sha256=enlSYSf7CUyAly1jmUCNNGInTbaFUjGk4SKwyckZQkw,9
+basilisk_engine-0.1.42.dist-info/RECORD,,