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

basilisk/render/material_handler.py

@@ -1,136 +1,136 @@
-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"""
+    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
+        """
+
         if self.data_texture: self.data_texture.release()

basilisk/render/shader.py

@@ -1,110 +1,110 @@
-import moderngl as mgl
-import random
-
-attribute_mappings = {
-    'in_position'  : [0, 1, 2],
-    'in_uv'        : [3, 4],
-    'in_normal'    : [5, 6, 7],
-    'in_tangent'   : [8, 9, 10],
-    'in_bitangent' : [11, 12, 13],
-    'obj_position' : [14, 15, 16],
-    'obj_rotation' : [17, 18, 19, 20],
-    'obj_scale'    : [21, 22, 23],
-    'obj_material' : [24],
-}
-
-
-class Shader:
-    program: mgl.Program=None
-    """Shader program for the vertex and fragment shader"""
-    vertex_shader: str
-    """String representation of the vertex shader"""
-    fragment_shader: str
-    """String representation of the vertex shader"""
-    uniforms: list[str]=[]
-    """List containg the names of all uniforms in the shader"""
-    attribute_indices: list[int]
-    """List of indices that map all possible shader attributes to the ones used byu the shader"""
-    fmt: str
-    """String representation of the format for building vaos"""
-    attributes: list[str]
-    """List representation of the attributes for building vaos"""
-
-    def __init__(self, engine, vert: str=None, frag: str=None) -> None:
-        """
-        Basilisk shader object. Contains shader program and shader attrbibute/uniform information
-        Args:
-            vert: str=None
-                Path to the vertex shader. Defaults to internal if none is given
-            frag: str=None
-                Path to the fragment shader. Defaults to internal if none is given    
-        """
-
-        self.engine = engine
-        self.ctx    = engine.ctx
-
-        # Default class attributes values
-        self.uniforms          = []
-        self.attribute_indices = []
-        self.fmt               = ''
-        self.attributes        = []
-
-        # Default vertex and fragment shaders
-        if vert == None: vert = self.engine.root + '/shaders/batch.vert'
-        if frag == None: frag = self.engine.root + '/shaders/batch.frag'
-
-        # Read the shaders
-        with open(vert) as file:
-            self.vertex_shader = file.read()
-        with open(frag) as file:
-            self.fragment_shader = file.read()
-        
-        # Hash value for references
-        if vert == None and frag == None:
-            self.hash = hash((self.vertex_shader, self.fragment_shader, 'default'))
-        else:
-            self.hash = hash((self.vertex_shader, self.fragment_shader))
-
-        # Create a string of all lines in both shaders
-        lines = f'{self.vertex_shader}\n{self.fragment_shader}'.split('\n')
-
-        # Parse through shader to find uniforms and attributes
-        for line in lines:
-            tokens = line.strip().split(' ')
-
-            # Add uniforms
-            if tokens[0] == 'uniform' and len(tokens) > 2:
-                self.uniforms.append(tokens[-1][:-1])
-
-            # Add attributes
-            if tokens[0] == 'layout' and len(tokens) > 2 and 'in' in line:
-                self.attributes.append(tokens[-1][:-1])
-
-                if tokens[-1][:-1] not in attribute_mappings: continue
-                indices = attribute_mappings[tokens[-1][:-1]]
-                self.attribute_indices.extend(indices)
-                self.fmt += f'{len(indices)}f '
-
-        # Create a program with shaders
-        self.program = self.ctx.program(vertex_shader=self.vertex_shader, fragment_shader=self.fragment_shader)
-
-    def set_main(self):
-        """
-        Selects a shader for use
-        """
-        
-        self.engine.scene.shader_handler.add(self)
-        self.engine.scene.node_handler.chunk_handler.update_all()
-
-    def write(self, name: str, value) -> None:
-        """
-        Writes a uniform to the shader program
-        """
-        
-        self.program[name].write(value)
-    
-    def __del__(self) -> int:
-        if self.program: self.program.release()
-
-    def __hash__(self) -> int:
+import moderngl as mgl
+import random
+
+attribute_mappings = {
+    'in_position'  : [0, 1, 2],
+    'in_uv'        : [3, 4],
+    'in_normal'    : [5, 6, 7],
+    'in_tangent'   : [8, 9, 10],
+    'in_bitangent' : [11, 12, 13],
+    'obj_position' : [14, 15, 16],
+    'obj_rotation' : [17, 18, 19, 20],
+    'obj_scale'    : [21, 22, 23],
+    'obj_material' : [24],
+}
+
+
+class Shader:
+    program: mgl.Program=None
+    """Shader program for the vertex and fragment shader"""
+    vertex_shader: str
+    """String representation of the vertex shader"""
+    fragment_shader: str
+    """String representation of the vertex shader"""
+    uniforms: list[str]=[]
+    """List containg the names of all uniforms in the shader"""
+    attribute_indices: list[int]
+    """List of indices that map all possible shader attributes to the ones used byu the shader"""
+    fmt: str
+    """String representation of the format for building vaos"""
+    attributes: list[str]
+    """List representation of the attributes for building vaos"""
+
+    def __init__(self, engine, vert: str=None, frag: str=None) -> None:
+        """
+        Basilisk shader object. Contains shader program and shader attrbibute/uniform information
+        Args:
+            vert: str=None
+                Path to the vertex shader. Defaults to internal if none is given
+            frag: str=None
+                Path to the fragment shader. Defaults to internal if none is given    
+        """
+
+        self.engine = engine
+        self.ctx    = engine.ctx
+
+        # Default class attributes values
+        self.uniforms          = []
+        self.attribute_indices = []
+        self.fmt               = ''
+        self.attributes        = []
+
+        # Default vertex and fragment shaders
+        if vert == None: vert = self.engine.root + '/shaders/batch.vert'
+        if frag == None: frag = self.engine.root + '/shaders/batch.frag'
+
+        # Read the shaders
+        with open(vert) as file:
+            self.vertex_shader = file.read()
+        with open(frag) as file:
+            self.fragment_shader = file.read()
+        
+        # Hash value for references
+        if vert == None and frag == None:
+            self.hash = hash((self.vertex_shader, self.fragment_shader, 'default'))
+        else:
+            self.hash = hash((self.vertex_shader, self.fragment_shader))
+
+        # Create a string of all lines in both shaders
+        lines = f'{self.vertex_shader}\n{self.fragment_shader}'.split('\n')
+
+        # Parse through shader to find uniforms and attributes
+        for line in lines:
+            tokens = line.strip().split(' ')
+
+            # Add uniforms
+            if tokens[0] == 'uniform' and len(tokens) > 2:
+                self.uniforms.append(tokens[-1][:-1])
+
+            # Add attributes
+            if tokens[0] == 'layout' and len(tokens) > 2 and 'in' in line:
+                self.attributes.append(tokens[-1][:-1])
+
+                if tokens[-1][:-1] not in attribute_mappings: continue
+                indices = attribute_mappings[tokens[-1][:-1]]
+                self.attribute_indices.extend(indices)
+                self.fmt += f'{len(indices)}f '
+
+        # Create a program with shaders
+        self.program = self.ctx.program(vertex_shader=self.vertex_shader, fragment_shader=self.fragment_shader)
+
+    def set_main(self):
+        """
+        Selects a shader for use
+        """
+        
+        self.engine.scene.shader_handler.add(self)
+        self.engine.scene.node_handler.chunk_handler.update_all()
+
+    def write(self, name: str, value) -> None:
+        """
+        Writes a uniform to the shader program
+        """
+        
+        self.program[name].write(value)
+    
+    def __del__(self) -> int:
+        if self.program: self.program.release()
+
+    def __hash__(self) -> int:
         return self.hash

basilisk/render/shader_handler.py

@@ -1,80 +1,80 @@
-import moderngl as mgl
-import glm
-from .shader import Shader
-
-
-class ShaderHandler:
-    engine: ...
-    """Back reference to the parent engine"""
-    scene: ...
-    """Back reference to the parent scene"""
-    ctx: mgl.Context
-    """Back reference to the parent context"""
-    shaders: set
-    """Dictionary containing all the shaders"""
-    uniform_values: dict = {}
-    """Dictionary containing uniform values"""    
-
-    def __init__(self, scene) -> None:
-        """
-        Handles all the shader programs in a basilisk scene
-        """
-        
-        # Back references
-        self.scene  = scene
-        self.engine = scene.engine
-        self.ctx    = scene.engine.ctx
-
-        # Initalize dictionaries
-        self.shaders = set()
-        self.add(self.engine.shader)
-
-    def add(self, shader: Shader) -> None:
-        """
-        Creates a shader program from a file name.
-        Parses through shaders to identify uniforms and save for writting
-        """
-
-
-        if not shader: return None
-        if shader in self.shaders: return shader
-
-        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()
-
-        return shader
-
-    def get_uniforms_values(self) -> None:
-        """
-        Gets uniforms from various parts of the scene.
-        These values are stored and used in write_all_uniforms and update_uniforms.
-        This is called by write_all_uniforms and update_uniforms, so there is no need to call this manually.
-        """
-        
-        self.uniform_values = {
-            'projectionMatrix' : self.scene.camera.m_proj,
-            'viewMatrix' : self.scene.camera.m_view,
-            'cameraPosition' : self.scene.camera.position,
-        }
-
-    def write(self) -> None:
-        """
-        Writes all of the uniforms in every shader program.
-        """
-
-        self.get_uniforms_values()
-        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
-                shader.write(uniform, self.uniform_values[uniform])
-
-    def release(self) -> None:
-        """
-        Releases all shader programs in handler
-        """
-        
+import moderngl as mgl
+import glm
+from .shader import Shader
+
+
+class ShaderHandler:
+    engine: ...
+    """Back reference to the parent engine"""
+    scene: ...
+    """Back reference to the parent scene"""
+    ctx: mgl.Context
+    """Back reference to the parent context"""
+    shaders: set
+    """Dictionary containing all the shaders"""
+    uniform_values: dict = {}
+    """Dictionary containing uniform values"""    
+
+    def __init__(self, scene) -> None:
+        """
+        Handles all the shader programs in a basilisk scene
+        """
+        
+        # Back references
+        self.scene  = scene
+        self.engine = scene.engine
+        self.ctx    = scene.engine.ctx
+
+        # Initalize dictionaries
+        self.shaders = set()
+        self.add(self.engine.shader)
+
+    def add(self, shader: Shader) -> None:
+        """
+        Creates a shader program from a file name.
+        Parses through shaders to identify uniforms and save for writting
+        """
+
+
+        if not shader: return None
+        if shader in self.shaders: return shader
+
+        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()
+
+        return shader
+
+    def get_uniforms_values(self) -> None:
+        """
+        Gets uniforms from various parts of the scene.
+        These values are stored and used in write_all_uniforms and update_uniforms.
+        This is called by write_all_uniforms and update_uniforms, so there is no need to call this manually.
+        """
+        
+        self.uniform_values = {
+            'projectionMatrix' : self.scene.camera.m_proj,
+            'viewMatrix' : self.scene.camera.m_view,
+            'cameraPosition' : self.scene.camera.position,
+        }
+
+    def write(self) -> None:
+        """
+        Writes all of the uniforms in every shader program.
+        """
+
+        self.get_uniforms_values()
+        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
+                shader.write(uniform, self.uniform_values[uniform])
+
+    def release(self) -> None:
+        """
+        Releases all shader programs in handler
+        """
+        
         [shader.__del__() for shader in self.shaders]