basilisk-engine 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

basilisk/render/framebuffer.py

@@ -7,56 +7,90 @@ from ..render.shader import Shader
 class Framebuffer:
     engine: ...
     """Reference to the parent engine"""
-    fbo: mgl.Framebuffer = None
+    size: tuple[int] | None=None
+    """The dimensions of the framebuffer (x, y). Defaults to window size if None"""
+    scale: float=1.0
+    """Scaling factor applied to the size. Best for use with default size"""
+    texture_filter: tuple[int]=(mgl.NEAREST, mgl.NEAREST)
+    """The filter applied to the texture when rendering"""
+    fbo: mgl.Framebuffer=None
     """The core framebuffer the object provides abstraction for."""
-    texture: mgl.Texture = None
+    texture: mgl.Texture=None
     """The color texture of the framebuffer"""
-    depth: mgl.Texture = None
+    depth: mgl.Texture=None
     """The depth texture of the framebuffer"""
-    size: tuple[int]
-    """The dimensions of the framebuffer (x, y)"""
+    _color_attachments = None
+    """"""
+    _depth_attachment = None
+    """"""
 
-    def __init__(self, engine, size: tuple[int]=None, resolution_scale: float=1.0, components: int=4, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
+    def __init__(self, engine: ..., size: tuple[int]=None, n_color_attachments: int=1, scale: float=1.0, linear_filter: bool=True) -> None:
         """
-        Abstraction to the mgl framebuffer
-        Args:
-            engine: mgl.Engine: 
-                The parent engine
-            size: tuple[int]: 
-                The dimensions of the framebuffer (x, y)
+        Abstraction of the MGL framebuffer.
+        Has the given number of color attachements (4-component) and 1 depth attachment.
+        All textures are of uniform size.
+        """
+
+        self.engine         = engine
+        self.ctx            = engine.ctx
+        self._size          = size
+        self.scale          = scale
+        self.texture_filter = (mgl.LINEAR, mgl.LINEAR) if linear_filter else (mgl.NEAREST, mgl.NEAREST)
+        self.attachments    = n_color_attachments
+
+        self.load_pipeline()
+        self.generate_fbo()
+
+        self.engine.fbos.append(self)
+
+    def generate_fbo(self):
+        """
+        Generates fresh depth texture and color textures and creates an FBO 
+        """
+
+        # Release existing memory
+        self.__del__()
+
+        # Create textures
+        self._color_attachments = [self.ctx.texture(self.size, components=4)]
+        for tex in self._color_attachments: tex.filter = self.texture_filter
+        self._depth_attachment  = self.ctx.depth_texture(self.size)
+
+        # Create the internal fbo
+        self.fbo = self.ctx.framebuffer(self._color_attachments, self._depth_attachment)
+
+    def resize(self, new_size: tuple[int]=None) -> None:
+        """
+        Update set size framebuffers with the given size.
         """
         
-        # Set attributes
-        self.engine = engine
-        self.ctx = engine.ctx
-        self.components = components
-
-        # Set the size
-        self.resolution_scale = resolution_scale
-        self._size = size
-        self.size = self._size if self._size else self.engine.win_size
-        self.size = (int(self.size[0] * resolution_scale), int(self.size[1] * resolution_scale))
-        
-        # 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)
+        # Check that we are not updating the size to the existing size and
+        if self._size and self._size == new_size: return
+
+        # If we have a set size, update with the given size
+        if self._size and new_size: self._size = new_size
+
+        # Update the textures and fbo
+        self.generate_fbo()
+
+    def load_pipeline(self) -> None:
+        """
+        Loads the shader, vbo, and vao used to display the fbo
+        """
 
         # Load Shaders
         self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame.frag')
-        self.engine.scene.shader_handler.add(self.shader)
+        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)
 
-        # Save the filter
-        self.filter = filter
+    def render(self, render_target=None) -> None:
 
-        # Add to the engine for updates
-        self.engine.fbos.append(self)
+        target = render_target if render_target else self.engine.frame
 
-    def render(self) -> None:
+        target.use()
         self.shader.program['screenTexture'] = 0
         self.texture.use(location=0)
         self.vao.render()
@@ -86,46 +120,170 @@ class Framebuffer:
         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:
+
+    @property
+    def size(self) -> tuple[int]:
+        """Size of the textures in the fbo in pixels (x: int, y: int)"""
+        size = self._size if self._size else self.engine.win_size
+        size = tuple(map((lambda x: int(x * self.scale)), size))
+        return size
+    @property
+    def texture(self) -> mgl.Texture:
+        """First color attachment in the fbo"""
+        return self._color_attachments[0]
+    @property
+    def color_attachments(self) -> ...:
+        """List of all color attachments in the fbo"""
+        return self._color_attachments
+    @property
+    def depth(self) -> mgl.Texture:
+        """Depth attachment of the fbo"""
+        return self._depth_attachment
+    @property
+    def data(self) -> bytes:
+        """Reads the data from the fbo"""
+        return self.fbo.read()
+    
+
+    @size.setter
+    def size(self, value: tuple[int]=None) -> tuple[int]:
+        self.resize(value)
+        return self.size
+    
+    def __repr__(self) -> str:
+        return f'<bsk.Framebuffer | size: {self.size}>' 
+
+    def __del__(self) -> None:
         """
-        Resize the buffer to the given size. None for window size
+        Releases all memory used by the fbo
         """
 
-        # Release old memory
-        self.__del__()
+        if self._color_attachments: [tex.release() for tex in self._color_attachments]
+        if self._depth_attachment: self._depth_attachment.release()
+        if self.fbo: self.fbo.release()
 
-        # Set/get size attribute
-        if size:
-            self.size = size
-        else:
-            self.size = self._size if self._size else self.engine.win_size
-        self.size = (int(self.size[0] * self.resolution_scale), int(self.size[1] * self.resolution_scale))
+# 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)"""
 
-        # 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)
+#     def __init__(self, engine, size: tuple[int]=None, resolution_scale: float=1.0, 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.components = components
 
-        self.filter = self._filter
+#         # Set the size
+#         self.resolution_scale = resolution_scale
+#         self._size = size
+#         self.size = self._size if self._size else self.engine.win_size
+#         self.size = (int(self.size[0] * resolution_scale), int(self.size[1] * resolution_scale))
+        
+#         # 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)
 
-    @property
-    def data(self):
-        return self.fbo.read(components=3, alignment=1)
+#         # Load Shaders
+#         self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame.frag')
+#         self.engine.shader_handler.add(self.shader)
 
-    @property
-    def filter(self):
-        return self.texture.filter
+#         # 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)
+
+#         # Save the filter
+#         self.filter = filter
+
+#         # Add to the engine for updates
+#         self.engine.fbos.append(self)
+
+#     def render(self) -> None:
+#         self.shader.program['screenTexture'] = 0
+#         self.texture.use(location=0)
+#         self.vao.render()
+
+#     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
+#         if size:
+#             self.size = size
+#         else:
+#             self.size = self._size if self._size else self.engine.win_size
+#         self.size = (int(self.size[0] * self.resolution_scale), int(self.size[1] * self.resolution_scale))
+
+#         # 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
+#     @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 __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()
+#     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_handler.py

@@ -2,15 +2,12 @@ import moderngl as mgl
 import glm
 import numpy as np
 
-
 texture_sizes = (8, 64, 512, 1024, 2048)
 
 
 class ImageHandler():
-    engine: any
+    engine: ...
     """Back refernce to the parent engine"""
-    scene: any
-    """Back refernce to the parent scene"""
     ctx: mgl.Context
     """Back reference to the Context used by the scene/engine"""
     images: list
@@ -18,16 +15,15 @@ class ImageHandler():
     texture_arrays: dict
     """Dictionary of textures arrays for writting textures to GPU"""
 
-    def __init__(self, scene) -> None:
+    def __init__(self, engine) -> None:
         """
         Container for all the basilisk image objects in the scene.
         Handles the managment and writting of all image textures.
         """
         
         # Set back references
-        self.scene  = scene
-        self.engine = scene.engine
-        self.ctx    = scene.engine.ctx
+        self.engine = engine
+        self.ctx    = engine.ctx
 
         self.images = []
         self.texture_arrays = {size : [] for size in texture_sizes}
@@ -83,11 +79,13 @@ class ImageHandler():
         Writes all texture arrays to shaders that use images 
         """
 
+        if not self.engine.shader_handler: return
+
         if regenerate: self.generate_texture_array()
 
         if not self.texture_arrays: return
 
-        for shader in self.engine.scene.shader_handler.shaders:
+        for shader in self.engine.shader_handler.shaders:
             if 'textureArrays[5]' not in shader.uniforms: continue
 
             for i, size in enumerate(texture_sizes):

basilisk/render/light_handler.py

@@ -40,7 +40,7 @@ class LightHandler():
 
         # if not program: program = self.engine.shader.program
 
-        for shader in self.scene.shader_handler.shaders:
+        for shader in self.engine.shader_handler.shaders:
             if 'numDirLights' not in shader.uniforms: continue
             
             program = shader.program

basilisk/render/material_handler.py

@@ -7,32 +7,28 @@ import numpy as np
 class MaterialHandler():
     engine: ...
     """Back reference to the parent engine"""
-    scene: ...
-    """Back reference to the parent scene"""
     ctx: mgl.Context
     """Back reference to the parent context"""
     materials: list[Material]
-    """List containing all the materials in the scene"""
+    """List containing all the materials in the engine"""
     data_texture: mgl.Texture
-    """ModernGL texture containing all the material data for materials in the scene"""
+    """ModernGL texture containing all the material data for materials in the engine"""
   
-    def __init__(self, scene) -> None:
+    def __init__(self, engine) -> None:
         """
-        Handles all the materials introduced to a scene. 
+        Handles all the materials introduced to an engine. 
         Writes material information to the GPU
         """
         
         # Back references
-        self.scene  = scene
-        self.engine = scene.engine
-        self.ctx    = scene.engine.ctx
+        self.engine = engine
+        self.ctx    = engine.ctx
 
         # Initialize data
         self.materials = []
         self.data_texture = None
-        self.set_base()
 
-        self.image_handler = ImageHandler(scene)
+        self.image_handler = ImageHandler(engine)
 
     def add(self, material: Material) -> None:
         """
@@ -93,7 +89,7 @@ class MaterialHandler():
 
         if not self.data_texture: return
 
-        for shader in self.engine.scene.shader_handler.shaders:
+        for shader in self.engine.shader_handler.shaders:
             if 'materialsTexture' not in shader.uniforms: continue
 
             shader.program['materialsTexture'] = 9

basilisk/render/shader.py

@@ -93,8 +93,7 @@ class Shader:
         Selects a shader for use
         """
         
-        self.engine.scene.shader_handler.add(self)
-        # self.engine.scene.node_handler.chunk_handler.update_all()
+        self.engine.shader_handler.add(self)
         self.engine.scene.node_handler.chunk_handler.swap_default(self)
 
     def write(self, name: str, value) -> None:

basilisk/render/shader_handler.py

@@ -15,19 +15,23 @@ class ShaderHandler:
     uniform_values: dict = {}
     """Dictionary containing uniform values"""    
 
-    def __init__(self, scene) -> None:
+    def __init__(self, engine) -> None:
         """
         Handles all the shader programs in a basilisk scene
         """
         
         # Back references
-        self.scene  = scene
-        self.engine = scene.engine
-        self.ctx    = scene.engine.ctx
+        self.engine = engine
+        self.ctx    = engine.ctx
 
         # Initalize dictionaries
         self.shaders = set()
-        self.add(self.engine.shader)
+
+        # Load a default shader
+        self.default_shader = Shader(self, self.engine.root + '/shaders/batch.vert', self.engine.root + '/shaders/batch.frag')
+        self.default_shader.hash = self.default_shader.hash + hash('engine_shader')
+        self.add(self.default_shader)
+        setattr(self.engine, "_shader", self.default_shader)
 
     def add(self, shader: Shader) -> None:
         """
@@ -41,14 +45,13 @@ class ShaderHandler:
 
         self.shaders.add(shader)
         
-        if self.scene.material_handler:
-            self.scene.light_handler.write()
-            self.scene.material_handler.write()
-            self.scene.material_handler.image_handler.write()
+        if self.engine.material_handler:
+            self.engine.material_handler.write()
+            self.engine.material_handler.image_handler.write()
 
         return shader
 
-    def get_uniforms_values(self) -> None:
+    def get_uniforms_values(self, scene: ...) -> None:
         """
         Gets uniforms from various parts of the scene.
         These values are stored and used in write_all_uniforms and update_uniforms.
@@ -56,18 +59,18 @@ class ShaderHandler:
         """
         
         self.uniform_values = {
-            'projectionMatrix' : self.scene.camera.m_proj,
-            'viewMatrix' : self.scene.camera.m_view,
-            'cameraPosition' : self.scene.camera.position,
+            'projectionMatrix' : scene.camera.m_proj,
+            'viewMatrix' : scene.camera.m_view,
+            'cameraPosition' : scene.camera.position,
             'viewportDimensions' : glm.vec2(self.engine.win_size),
         }
 
-    def write(self) -> None:
+    def write(self, scene: ...) -> None:
         """
         Writes all of the uniforms in every shader program.
         """
 
-        self.get_uniforms_values()
+        self.get_uniforms_values(scene)
         for uniform in self.uniform_values:
             for shader in self.shaders:
                 if not uniform in shader.uniforms: continue  # Does not write uniforms not in the shader

basilisk/render/sky.py

@@ -11,7 +11,7 @@ class Sky:
         Handler for all skybox rendering
         """
         
-        self.scene = engine.scene
+        self.engine = engine
         self.ctx   = engine.ctx
         
         if not sky_texture: sky_texture = engine.root + '/bsk_assets/skybox.png'
@@ -30,7 +30,7 @@ class Sky:
         self.shader.program['skyboxTexture']  = 8
         self.texture_cube.use(location = 8)
 
-        shader = self.scene.engine.shader
+        shader = self.engine.shader
         if 'skyboxTexture' not in shader.uniforms: return
         shader.program['skyboxTexture'] = 8
         self.texture_cube.use(location = 8)
@@ -107,8 +107,8 @@ class Sky:
 
         # Create a renderable vao
         self.vbo     = self.ctx.buffer(vertex_data)
-        root = self.scene.engine.root
-        self.shader = self.scene.shader_handler.add(Shader(self.scene.engine, root + '/shaders/sky.vert', root + '/shaders/sky.frag'))
+        root = self.engine.root
+        self.shader = self.engine.shader_handler.add(Shader(self.engine, root + '/shaders/sky.vert', root + '/shaders/sky.frag'))
         self.vao     = self.ctx.vertex_array(self.shader.program, [(self.vbo, '3f', 'in_position')], skip_errors=True)
 
     def __del__(self):