basilisk-engine 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

basilisk/render/material_handler.py

@@ -1,136 +1,132 @@
-import moderngl as mgl
-from ..render.image_handler import ImageHandler
-from ..render.material import Material
-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"""
-    data_texture: mgl.Texture
-    """ModernGL texture containing all the material data for materials in the scene"""
-  
-    def __init__(self, scene) -> None:
-        """
-        Handles all the materials introduced to a scene. 
-        Writes material information to the GPU
-        """
-        
-        # Back references
-        self.scene  = scene
-        self.engine = scene.engine
-        self.ctx    = scene.engine.ctx
-
-        # Initialize data
-        self.materials = []
-        self.data_texture = None
-        self.set_base()
-
-        self.image_handler = ImageHandler(scene)
-
-    def add(self, material: Material) -> None:
-        """
-        Adds the given material to the handler if it is not already present
-        """
-        
-        write = False
-
-        if isinstance(material, Material): material = [material]
-
-        for mtl in material:
-            # Check that the material is not already in the scene
-            if mtl in self.materials: continue
-            # Update the material's handler
-            mtl.material_handler = self
-            # Add images
-            if mtl.texture: self.image_handler.add(mtl.texture)
-            if mtl.normal:  self.image_handler.add(mtl.normal)
-
-            # Add the material
-            self.materials.append(mtl)
-
-            write = True
-
-        
-        # Write materials
-        if write: self.write(regenerate=True)
-
-    def generate_material_texture(self) -> None:
-        """
-        Generates the texture that is used to write material data to the GPU
-        """
-
-        # Check that there are materials to write
-        if len(self.materials) == 0: return
-
-        # Release existing data texture
-        if self.data_texture: self.data_texture.release()
-
-        # Create empty texture data
-        material_data = np.zeros(shape=(len(self.materials), 25), dtype="f4")
-
-        # Get data from the materials
-        for i, mtl in enumerate(self.materials):
-            mtl.index = i
-            material_data[i] = mtl.get_data()
-
-        # Create texture from data
-        material_data = np.ravel(material_data)
-        self.data_texture = self.ctx.texture((1, len(material_data)), components=1, dtype='f4', data=material_data)
-
-    def write(self, regenerate=False) -> None:
-        """
-        Writes all material data to relavent shaders
-        """
-
-        if regenerate: self.generate_material_texture()
-
-        if not self.data_texture: return
-
-        for shader in self.engine.scene.shader_handler.shaders:
-            if 'materialsTexture' not in shader.uniforms: continue
-
-            shader.program['materialsTexture'] = 9
-            self.data_texture.use(location=9)
-
-    def get(self, identifier: str | int) -> any:
-        """
-        Gets the basilisk material with the given name or index
-        Args:
-            identifier: str | int
-                The name string or index of the desired material
-        """
-
-        # Simply use index if given
-        if isinstance(identifier, int): return self.materials[identifier]
-
-        # Else, search the list for an image material the given name
-        for material in self.materials:
-            if material.name != identifier: continue
-            return material
-        
-        # No matching material found
-        return None
-    
-    def set_base(self):
-        """
-        Creates a base material
-        """
-        
-        self.base = Material('Base')
-        self.materials.append(self.base)
-        self.generate_material_texture()
-        self.write()
-
-    def __del__(self) -> None:
-        """
-        Releases the material data texture
-        """
-
+import moderngl as mgl
+from ..render.image_handler import ImageHandler
+from ..render.material import Material
+import numpy as np
+
+
+class MaterialHandler():
+    engine: ...
+    """Back reference to the parent engine"""
+    ctx: mgl.Context
+    """Back reference to the parent context"""
+    materials: list[Material]
+    """List containing all the materials in the engine"""
+    data_texture: mgl.Texture
+    """ModernGL texture containing all the material data for materials in the engine"""
+  
+    def __init__(self, engine) -> None:
+        """
+        Handles all the materials introduced to an engine. 
+        Writes material information to the GPU
+        """
+        
+        # Back references
+        self.engine = engine
+        self.ctx    = engine.ctx
+
+        # Initialize data
+        self.materials = []
+        self.data_texture = None
+
+        self.image_handler = ImageHandler(engine)
+
+    def add(self, material: Material) -> None:
+        """
+        Adds the given material to the handler if it is not already present
+        """
+        
+        write = False
+
+        if isinstance(material, Material): material = [material]
+
+        for mtl in material:
+            # Check that the material is not already in the scene
+            if mtl in self.materials: continue
+            # Update the material's handler
+            mtl.material_handler = self
+            # Add images
+            if mtl.texture: self.image_handler.add(mtl.texture)
+            if mtl.normal:  self.image_handler.add(mtl.normal)
+
+            # Add the material
+            self.materials.append(mtl)
+
+            write = True
+
+        
+        # Write materials
+        if write: self.write(regenerate=True)
+
+    def generate_material_texture(self) -> None:
+        """
+        Generates the texture that is used to write material data to the GPU
+        """
+
+        # Check that there are materials to write
+        if len(self.materials) == 0: return
+
+        # Release existing data texture
+        if self.data_texture: self.data_texture.release()
+
+        # Create empty texture data
+        material_data = np.zeros(shape=(len(self.materials), 25), dtype="f4")
+
+        # Get data from the materials
+        for i, mtl in enumerate(self.materials):
+            mtl.index = i
+            material_data[i] = mtl.get_data()
+
+        # Create texture from data
+        material_data = np.ravel(material_data)
+        self.data_texture = self.ctx.texture((1, len(material_data)), components=1, dtype='f4', data=material_data)
+
+    def write(self, regenerate=False) -> None:
+        """
+        Writes all material data to relavent shaders
+        """
+
+        if regenerate: self.generate_material_texture()
+
+        if not self.data_texture: return
+
+        for shader in self.engine.shader_handler.shaders:
+            if 'materialsTexture' not in shader.uniforms: continue
+
+            shader.program['materialsTexture'] = 9
+            self.data_texture.use(location=9)
+
+    def get(self, identifier: str | int) -> any:
+        """
+        Gets the basilisk material with the given name or index
+        Args:
+            identifier: str | int
+                The name string or index of the desired material
+        """
+
+        # Simply use index if given
+        if isinstance(identifier, int): return self.materials[identifier]
+
+        # Else, search the list for an image material the given name
+        for material in self.materials:
+            if material.name != identifier: continue
+            return material
+        
+        # No matching material found
+        return None
+    
+    def set_base(self):
+        """
+        Creates a base material
+        """
+        
+        self.base = Material('Base')
+        self.materials.append(self.base)
+        self.generate_material_texture()
+        self.write()
+
+    def __del__(self) -> None:
+        """
+        Releases the material data texture
+        """
+
         if self.data_texture: self.data_texture.release()

basilisk/render/post_process.py

@@ -1,140 +1,140 @@
-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 resize(self, size: tuple=None):
-        """
-        Resize the post process
-        """
-        
-        self.size = size if size else self.engine.win_size
-
-    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 or detination.size != self.size:
-            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()
+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 resize(self, size: tuple=None):
+        """
+        Resize the post process
+        """
+        
+        self.size = size if size else self.engine.win_size
+
+    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 or detination.size != self.size:
+            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