basilisk-engine 0.1.39__tar.gz → 0.1.41__tar.gz

{basilisk_engine-0.1.39 → basilisk_engine-0.1.41}/PKG-INFO

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

{basilisk_engine-0.1.39 → basilisk_engine-0.1.41}/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_engine-0.1.39 → basilisk_engine-0.1.41}/basilisk/nodes/node.py

@@ -229,8 +229,8 @@ class Node():
         Updates the node's movement variables based on the delta time
         """
         # update based on physical properties
-        if any(self.velocity): self.position.data += dt * self.velocity
-        if any(self.rotational_velocity): self.rotation.data = glm.normalize(self.rotation.data - dt / 2 * self.rotation.data * glm.quat(0, *self.rotational_velocity))
+        if any(self.velocity): self.position += dt * self.velocity # NOTE this should be an external setter, do not change to self.position.data
+        if any(self.rotational_velocity): self.rotation = glm.normalize(self.rotation.data - dt / 2 * self.rotation.data * glm.quat(0, *self.rotational_velocity)) # NOTE see translational velocity note
 
         if self.physics_body:
             self.velocity += self.physics_body.get_delta_velocity(dt)

{basilisk_engine-0.1.39 → basilisk_engine-0.1.41}/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_engine-0.1.39 → basilisk_engine-0.1.41}/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_engine-0.1.39 → basilisk_engine-0.1.41}/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_engine-0.1.39 → basilisk_engine-0.1.41}/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_engine-0.1.39 → basilisk_engine-0.1.41}/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_engine-0.1.39 → basilisk_engine-0.1.41}/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_engine-0.1.39 → basilisk_engine-0.1.41}/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_engine-0.1.39 → basilisk_engine-0.1.41}/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_engine-0.1.39 → basilisk_engine-0.1.41}/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_engine-0.1.39 → basilisk_engine-0.1.41}/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);
 }