basilisk-engine 0.1.26__py3-none-any.whl → 0.1.28__py3-none-any.whl

basilisk/render/shader.py

@@ -1,119 +1,119 @@
-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])
-
-                # Get the number of flots the attribute takes
-                if any(list(map(lambda x: x in tokens, ['float', 'int']))): n = 1
-                elif any(list(map(lambda x: x in tokens, ['vec2']))): n = 2
-                elif any(list(map(lambda x: x in tokens, ['vec3']))): n = 3
-                elif any(list(map(lambda x: x in tokens, ['vec4']))): n = 4
-                else: n = 1
-                self.fmt += f'{n}f '
-
-                if tokens[-1][:-1] in attribute_mappings:
-                    indices = attribute_mappings[tokens[-1][:-1]]
-                else:
-                    indices = [0 for i in range(n)]
-                self.attribute_indices.extend(indices)
-
-        # 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.shader_handler.add(self)
-        self.engine.scene.node_handler.chunk_handler.swap_default(self)
-
-    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])
+
+                # Get the number of flots the attribute takes
+                if any(list(map(lambda x: x in tokens, ['float', 'int']))): n = 1
+                elif any(list(map(lambda x: x in tokens, ['vec2']))): n = 2
+                elif any(list(map(lambda x: x in tokens, ['vec3']))): n = 3
+                elif any(list(map(lambda x: x in tokens, ['vec4']))): n = 4
+                else: n = 1
+                self.fmt += f'{n}f '
+
+                if tokens[-1][:-1] in attribute_mappings:
+                    indices = attribute_mappings[tokens[-1][:-1]]
+                else:
+                    indices = [0 for i in range(n)]
+                self.attribute_indices.extend(indices)
+
+        # 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.shader_handler.add(self)
+        self.engine.scene.node_handler.chunk_handler.swap_default(self)
+
+    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,84 +1,84 @@
-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, engine) -> None:
-        """
-        Handles all the shader programs in a basilisk scene
-        """
-        
-        # Back references
-        self.engine = engine
-        self.ctx    = engine.ctx
-
-        # Initalize dictionaries
-        self.shaders = set()
-
-        # 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:
-        """
-        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.engine.material_handler:
-            self.engine.material_handler.write()
-            self.engine.material_handler.image_handler.write()
-
-        return shader
-
-    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.
-        This is called by write_all_uniforms and update_uniforms, so there is no need to call this manually.
-        """
-        
-        self.uniform_values = {
-            'projectionMatrix' : scene.camera.m_proj,
-            'viewMatrix' : scene.camera.m_view,
-            'cameraPosition' : scene.camera.position,
-            'viewportDimensions' : glm.vec2(self.engine.win_size),
-        }
-
-    def write(self, scene: ...) -> None:
-        """
-        Writes all of the uniforms in every shader program.
-        """
-
-        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
-                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, engine) -> None:
+        """
+        Handles all the shader programs in a basilisk scene
+        """
+        
+        # Back references
+        self.engine = engine
+        self.ctx    = engine.ctx
+
+        # Initalize dictionaries
+        self.shaders = set()
+
+        # 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:
+        """
+        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.engine.material_handler:
+            self.engine.material_handler.write()
+            self.engine.material_handler.image_handler.write()
+
+        return shader
+
+    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.
+        This is called by write_all_uniforms and update_uniforms, so there is no need to call this manually.
+        """
+        
+        self.uniform_values = {
+            'projectionMatrix' : scene.camera.m_proj,
+            'viewMatrix' : scene.camera.m_view,
+            'cameraPosition' : scene.camera.position,
+            'viewportDimensions' : glm.vec2(self.engine.win_size),
+        }
+
+    def write(self, scene: ...) -> None:
+        """
+        Writes all of the uniforms in every shader program.
+        """
+
+        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
+                shader.write(uniform, self.uniform_values[uniform])
+
+    def release(self) -> None:
+        """
+        Releases all shader programs in handler
+        """
+        
         [shader.__del__() for shader in self.shaders]

basilisk/render/sky.py

@@ -1,121 +1,121 @@
-import numpy as np
-from PIL import Image as PIL_Image
-from .shader import Shader
-
-class Sky:
-    texture_cube=None
-    vbo          = None
-    vao          = None
-    def __init__(self, engine, sky_texture: str | list=None):
-        """
-        Handler for all skybox rendering
-        """
-        
-        self.engine = engine
-        self.ctx   = engine.ctx
-        
-        if not sky_texture: sky_texture = engine.root + '/bsk_assets/skybox.png'
-
-        self.set_renderer()
-        self.set_texture(sky_texture)
-
-    def render(self):
-        """
-        Render the skybox to current render destination
-        """
-        self.vao.render()
-
-    def write(self):
-        # Write the texture cube to the sky shader
-        self.shader.program['skyboxTexture']  = 8
-        self.texture_cube.use(location = 8)
-
-        shader = self.engine.shader
-        if 'skyboxTexture' not in shader.uniforms: return
-        shader.program['skyboxTexture'] = 8
-        self.texture_cube.use(location = 8)
-
-
-    def set_texture(self, skybox_images: list):
-        """
-        Sets the skybox texture. Can either be set with 6 images for each skybox side or a single skybox image.
-        List items should be string paths.
-        The six images should be should be in the following order: right, left, top, bottom, front, back
-        """
-
-        # Release any existing memory
-        if self.texture_cube: self.texture_cube.release()
-
-        # Function-Scoped data
-        images = None
-
-        # Given a sinlge image for the skybox        
-        if isinstance(skybox_images, str) or ((isinstance(skybox_images, list) or isinstance(skybox_images, tuple)) and len(skybox_images) == 1):
-            path = skybox_images if isinstance(skybox_images, str) else skybox_images[0]
-            
-            # Verify the path type
-            if not isinstance(path, str): raise ValueError(f"Skybox: Invalid image path type {type(path)}")
-
-            image = PIL_Image.open(path).convert('RGB')
-            width, height = image.size[0] // 4, image.size[1] // 3
-
-            images = [image.crop((x * width, y * height, (x + 1) * width, (y + 1) * height)) for x, y in [(2, 1), (0, 1), (1, 0), (1, 2), (1, 1), (3, 1)]]
-
-        # Given a list of images for the skybox
-        elif isinstance(skybox_images, list) or isinstance(skybox_images, tuple):
-            # Verify the correct number of images was given
-            if len(skybox_images) != 6: raise ValueError("Skybox: Invalid number of images for skybox. Expected 1 or 6")
-            # Verify the all image path types            
-            if not all([isinstance(path, str) for path in skybox_images]): raise ValueError(f"Skybox: Invalid image path type {type(path)}")
-
-            images = [PIL_Image.open(path).convert('RGB') for path in skybox_images]
-
-        else:
-            raise ValueError(f"Skybox: Invalid skybox type {type(skybox_images)}. Expected list of string paths or a single image")
-        
-        # Create a texture map from the images
-        size = min(images[0].size)
-        size = (size, size)
-        images = [img.resize(size) for img in images]
-        images = [img.tobytes() for img in images]
-        self.texture_cube = self.ctx.texture_cube(size=size, components=3, data=None)
-        for i, data in enumerate(images):
-            self.texture_cube.write(face=i, data=data)
-
-    def set_renderer(self):
-        """
-        
-        """
-        
-        # Release any existing memory
-        if self.vbo: self.vbo.release()
-        if self.vao: self.vao.release()
-        
-        # Get the cube vertex data
-        vertices = [(-1, -1, 1), ( 1, -1,  1), (1,  1,  1), (-1, 1,  1),
-                    (-1, 1, -1), (-1, -1, -1), (1, -1, -1), ( 1, 1, -1)]
-
-        indices = [(0, 2, 3), (0, 1, 2),
-                   (1, 7, 2), (1, 6, 7),
-                   (6, 5, 4), (4, 7, 6),
-                   (3, 4, 5), (3, 5, 0),
-                   (3, 7, 4), (3, 2, 7),
-                   (0, 6, 1), (0, 5, 6)]
-        
-        vertex_data = np.array([vertices[ind] for trigangle in indices for ind in trigangle], dtype='f4')
-        vertex_data = np.flip(vertex_data, 1).copy(order='C')
-
-        # Create a renderable vao
-        self.vbo     = self.ctx.buffer(vertex_data)
-        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):
-        """
-        Releases all data used by the skybox
-        """
-        
-        if self.texture_cube: self.texture_cube.release()
-        if self.vbo: self.vbo.release()
+import numpy as np
+from PIL import Image as PIL_Image
+from .shader import Shader
+
+class Sky:
+    texture_cube=None
+    vbo          = None
+    vao          = None
+    def __init__(self, engine, sky_texture: str | list=None):
+        """
+        Handler for all skybox rendering
+        """
+        
+        self.engine = engine
+        self.ctx   = engine.ctx
+        
+        if not sky_texture: sky_texture = engine.root + '/bsk_assets/skybox.png'
+
+        self.set_renderer()
+        self.set_texture(sky_texture)
+
+    def render(self):
+        """
+        Render the skybox to current render destination
+        """
+        self.vao.render()
+
+    def write(self):
+        # Write the texture cube to the sky shader
+        self.shader.program['skyboxTexture']  = 8
+        self.texture_cube.use(location = 8)
+
+        shader = self.engine.shader
+        if 'skyboxTexture' not in shader.uniforms: return
+        shader.program['skyboxTexture'] = 8
+        self.texture_cube.use(location = 8)
+
+
+    def set_texture(self, skybox_images: list):
+        """
+        Sets the skybox texture. Can either be set with 6 images for each skybox side or a single skybox image.
+        List items should be string paths.
+        The six images should be should be in the following order: right, left, top, bottom, front, back
+        """
+
+        # Release any existing memory
+        if self.texture_cube: self.texture_cube.release()
+
+        # Function-Scoped data
+        images = None
+
+        # Given a sinlge image for the skybox        
+        if isinstance(skybox_images, str) or ((isinstance(skybox_images, list) or isinstance(skybox_images, tuple)) and len(skybox_images) == 1):
+            path = skybox_images if isinstance(skybox_images, str) else skybox_images[0]
+            
+            # Verify the path type
+            if not isinstance(path, str): raise ValueError(f"Skybox: Invalid image path type {type(path)}")
+
+            image = PIL_Image.open(path).convert('RGB')
+            width, height = image.size[0] // 4, image.size[1] // 3
+
+            images = [image.crop((x * width, y * height, (x + 1) * width, (y + 1) * height)) for x, y in [(2, 1), (0, 1), (1, 0), (1, 2), (1, 1), (3, 1)]]
+
+        # Given a list of images for the skybox
+        elif isinstance(skybox_images, list) or isinstance(skybox_images, tuple):
+            # Verify the correct number of images was given
+            if len(skybox_images) != 6: raise ValueError("Skybox: Invalid number of images for skybox. Expected 1 or 6")
+            # Verify the all image path types            
+            if not all([isinstance(path, str) for path in skybox_images]): raise ValueError(f"Skybox: Invalid image path type {type(path)}")
+
+            images = [PIL_Image.open(path).convert('RGB') for path in skybox_images]
+
+        else:
+            raise ValueError(f"Skybox: Invalid skybox type {type(skybox_images)}. Expected list of string paths or a single image")
+        
+        # Create a texture map from the images
+        size = min(images[0].size)
+        size = (size, size)
+        images = [img.resize(size) for img in images]
+        images = [img.tobytes() for img in images]
+        self.texture_cube = self.ctx.texture_cube(size=size, components=3, data=None)
+        for i, data in enumerate(images):
+            self.texture_cube.write(face=i, data=data)
+
+    def set_renderer(self):
+        """
+        
+        """
+        
+        # Release any existing memory
+        if self.vbo: self.vbo.release()
+        if self.vao: self.vao.release()
+        
+        # Get the cube vertex data
+        vertices = [(-1, -1, 1), ( 1, -1,  1), (1,  1,  1), (-1, 1,  1),
+                    (-1, 1, -1), (-1, -1, -1), (1, -1, -1), ( 1, 1, -1)]
+
+        indices = [(0, 2, 3), (0, 1, 2),
+                   (1, 7, 2), (1, 6, 7),
+                   (6, 5, 4), (4, 7, 6),
+                   (3, 4, 5), (3, 5, 0),
+                   (3, 7, 4), (3, 2, 7),
+                   (0, 6, 1), (0, 5, 6)]
+        
+        vertex_data = np.array([vertices[ind] for trigangle in indices for ind in trigangle], dtype='f4')
+        vertex_data = np.flip(vertex_data, 1).copy(order='C')
+
+        # Create a renderable vao
+        self.vbo     = self.ctx.buffer(vertex_data)
+        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):
+        """
+        Releases all data used by the skybox
+        """
+        
+        if self.texture_cube: self.texture_cube.release()
+        if self.vbo: self.vbo.release()
         if self.vao: self.vao.release()