basilisk-engine 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

basilisk/render/image.py

@@ -0,0 +1,76 @@
+import os
+import sys
+import numpy as np
+import moderngl as mgl
+import glm
+import pygame as pg
+from PIL import Image as PIL_Image
+
+
+texture_sizes = (128, 256, 512, 1024, 2048)
+
+
+class Image():
+    name: str
+    """Name of the image"""   
+    index: glm.ivec2
+    """Location of the image in the texture arrays"""
+    data: np.ndarray
+    """Array of the texture data"""
+    size: int
+    """The width and height in pixels of the image"""
+
+    def __init__(self, path: str | os.PathLike | pg.Surface) -> None:
+        """
+        A basilisk image object that contains a moderngl texture
+        Args:
+            path: str | os.PathLike | pg.Surface
+                The string path to the image. Can also read a pygame surface
+        """
+        
+        # Check if the user is loading a pygame surface
+        if isinstance(path, pg.Surface):
+            self.from_pg_surface(path)
+            return
+
+        # Verify the path type
+        if not isinstance(path, str) and not isinstance(path, os.PathLike):
+            raise TypeError(f'Invalid path type: {type(path)}. Expected a string or os.PathLike')
+
+        # Get name from path
+        self.name = path.split('/')[-1].split('\\')[-1].split('.')[0]
+
+        # Set the texture
+        # Load image
+        img = PIL_Image.open(path).convert('RGBA')
+        # Set the size in one of the size buckets
+        size_buckets = texture_sizes
+        self.size = size_buckets[np.argmin(np.array([abs(size - img.size[0]) for size in size_buckets]))]
+        img = img.resize((self.size, self.size)) 
+        # Get the image data
+        self.data = img.tobytes()
+
+        # Default index value (to be set by image handler)
+        self.index = glm.ivec2(1, 1)
+
+    def from_pg_surface(self, surf: pg.Surface) -> None:
+        """
+        Loads a basilisk image from a pygame surface
+        Args:
+        """
+        
+        # Set the size in one of the size buckets
+        size_buckets = texture_sizes
+        self.size = size_buckets[np.argmin(np.array([abs(size - surf.get_size()[0]) for size in size_buckets]))]
+        surf = pg.transform.scale(surf, (self.size, self.size)).convert_alpha()
+        # Get image data
+        self.data = pg.image.tobytes(surf, 'RGBA')
+
+        # Default index value (to be set by image handler)
+        self.index = glm.ivec2(1, 1)
+
+    def __repr__(self) -> str:
+        """
+        Returns a string representation of the object
+        """
+        return f'<Basilisk Image | {self.name}, ({self.size}x{self.size}), {sys.getsizeof(self.data) / 1024 / 1024:.2} mb>'

basilisk/render/image_handler.py

@@ -0,0 +1,119 @@
+import moderngl as mgl
+import glm
+import numpy as np
+
+
+texture_sizes = (128, 256, 512, 1024, 2048)
+
+
+class ImageHandler():
+    engine: any
+    """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
+    """List of basilisk Images containing all the loaded images given to the scene"""
+    texture_arrays: dict
+    """Dictionary of textures arrays for writting textures to GPU"""
+
+    def __init__(self, scene) -> 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.images = []
+        self.texture_arrays = {size : [] for size in texture_sizes}
+
+    def add(self, image: any) -> None:
+        """
+        Adds an existing basilisk image object to the handler for writting
+        Args:
+            image: bsk.Image
+                The existing image that is to be added to the scene.
+        """
+        
+        if image in self.images: return
+
+        self.images.append(image)
+        self.write(self.scene.shader_handler.programs['batch'])
+        self.write(self.scene.shader_handler.programs['draw'])
+
+    def generate_texture_array(self) -> None:
+        """
+        Generates texutre arrays for all the images. Updates the index of the image instance
+        """
+
+        # Release any existsing texture arrays
+        for texture_array in self.texture_arrays.values():
+            if not texture_array: continue
+            texture_array.release()
+
+        self.texture_arrays = {size : [] for size in texture_sizes}
+
+        for image in self.images:
+            # Add the image data to the array
+            self.texture_arrays[image.size].append(image.data)
+            # Update the image index
+            image.index = glm.ivec2(texture_sizes.index(image.size), len(self.texture_arrays[image.size]) - 1)
+
+
+        for size in self.texture_arrays:
+            # Get the rray data and attributes
+            array_data = np.array(self.texture_arrays[size])
+            dim = (size, size, len(self.texture_arrays[size]))
+
+            # Make the array
+            self.texture_arrays[size] = self.ctx.texture_array(size=dim, components=4, data=array_data)
+            # Texture OpenGl settings
+            self.texture_arrays[size].build_mipmaps()
+            self.texture_arrays[size].filter = (mgl.LINEAR_MIPMAP_LINEAR, mgl.LINEAR)
+            self.texture_arrays[size].anisotropy = 32.0
+
+    def write(self, shader_program: mgl.Program) -> None:
+        """
+        Writes all texture arrays to the given shader program
+        Args:
+            shader_program: mgl.Program:
+                Destination of the texture array write
+        """
+
+        self.generate_texture_array()
+
+        for i, size in enumerate(texture_sizes):
+            if not size in self.texture_arrays: continue
+            shader_program[f'textureArrays[{i}].array'] = i + 3
+            self.texture_arrays[size].use(location=i+3)
+
+    def get(self, identifier: str | int) -> any:
+        """
+        Gets the basilisk image with the given name or index
+        Args:
+            identifier: str | int
+                The name string or index of the desired image
+        """
+
+        # Simply use index if given
+        if isinstance(identifier, int): return self.images[identifier]
+
+        # Else, search the list for an image with the given name
+        for image in self.images:
+            if image.name != identifier: continue
+            return image
+        
+        # No matching image found
+        return None
+    
+    def __del__(self):
+        """
+        Deallocates all texture arrays
+        """
+        
+        # [texture_array.release() for texture_array in self.texture_arrays]

basilisk/render/light.py

@@ -0,0 +1,97 @@
+import glm
+import numpy as np
+
+
+class Light():
+    light_handler: ...
+    """Back reference to the parent light handler"""
+    intensity: float
+    """The brightness of the light"""
+    color: glm.vec3
+    """The color of the light"""
+
+    def __init__(self, light_handler, intensity: float=1.0, color: tuple=(255, 255, 255)):
+        """
+        Abstract light class for Basilisk Engine.
+        Cannot be added to a scene.
+        """
+
+        # Back References
+        self.light_handler = light_handler
+
+        # Light attributes
+        self.intensity = intensity
+        self.color = color
+
+    @property 
+    def intensity(self): return self._intensity
+    @property
+    def color(self):     return self._color
+
+    @intensity.setter
+    def intensity(self, value: float | int):
+        if isinstance(value, float) or isinstance(value, int):
+            self._intensity = value
+        else:
+            raise TypeError(f"Light: Invalid intensity value type {type(value)}. Expected float or int")
+        self.light_handler.write()
+
+    @color.setter
+    def color(self, value: tuple | list | glm.vec3 | np.ndarray):
+        if isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
+            if len(value) != 3: raise ValueError(f"Light: Invalid number of values for color. Expected 3 values, got {len(value)} values")
+            self._color = glm.vec3(value)
+        elif isinstance(value, glm.vec3):
+            self._color = glm.vec3(value)
+        else:
+            raise TypeError(f"Light: Invalid color value type {type(value)}. Expected tuple, list, glm.vec3, or numpy array")
+        self.light_handler.write()
+
+class DirectionalLight(Light):
+    direction: glm.vec3
+    """The direction that the light is applied to objects"""
+    ambient: float
+    """Base value of light that is applied at all locations, regardless of direction"""
+
+    def __init__(self, light_handler, direction: tuple=(1.5, -2.0, 1.0), intensity:float=1.0, color: tuple=(255, 255, 255), ambient: float=0.0):
+        """
+        Diractional/Global light for Basilisk Engine.
+        Has same intensity and direction everywhere.
+        Args:
+            direction: tuple
+                The direction that the light is applied to objects
+            intensity: float
+                The brightness of the light
+            color: tuple
+                The color of the light
+            ambient: float
+                Base value of light that is applied at all locations, regardless of direction
+        """
+        
+        super().__init__(light_handler, intensity, color)
+        self.direction = direction
+        self.ambient = ambient
+
+    @property
+    def direction(self): return self._direction
+    @property
+    def ambient(self):   return self._ambient
+
+    @direction.setter
+    def direction(self, value: tuple | list | glm.vec3 | np.ndarray):
+        if isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
+            if len(value) != 3: raise ValueError(f"Light: Invalid number of values for direction. Expected 3 values, got {len(value)} values")
+            self._direction = glm.normalize(glm.vec3(value))
+        elif isinstance(value, glm.vec3):
+            self._direction = glm.normalize(glm.vec3(value))
+        else:
+            raise TypeError(f"Light: Invalid direction value type {type(value)}. Expected tuple, list, glm.vec3, or numpy array")
+        self.light_handler.write()
+        
+    @ambient.setter
+    def ambient(self, value: float | int):
+        if isinstance(value, float) or isinstance(value, int):
+            self._ambient = value
+        else:
+            raise TypeError(f"Light: Invalid ambient value type {type(value)}. Expected float or int")
+        self.light_handler.write()

basilisk/render/light_handler.py

@@ -0,0 +1,54 @@
+import moderngl as mgl
+import glm
+from ..render.light import DirectionalLight
+
+
+class LightHandler():
+    engine: ...
+    """Back reference to the parent engine"""
+    scene: ...
+    """Back reference to the parent scene"""
+    ctx: mgl.Context
+    """Back reference to the parent context"""
+    directional_light: DirectionalLight
+    """The directional light of the scene"""
+    point_lights: list
+    """List of all the point lights in the scene"""
+
+    def __init__(self, scene) -> None:
+        """
+        Handles all the lights in a Basilisk scene.
+        """
+
+        # Back references
+        self.scene  = scene
+        self.engine = scene.engine
+        self.ctx    = scene.engine.ctx
+
+        # Intialize light variables
+        self.directional_lights = None
+        self.directional_lights = [DirectionalLight(self, direction=dir, intensity=intensity) for dir, intensity in zip(((1, -1, 1), (-.1, 3, -.1)), (1, .05))]
+        self.point_lights       = []
+
+        # Initalize uniforms
+        self.write()
+
+    def write(self, program: mgl.Program=None, directional=True, point=False) -> None:
+        """
+        Writes all the lights in a scene to the given shader program
+        """
+
+        if not program: program = self.scene.shader_handler.programs['batch']
+
+        if directional and self.directional_lights:
+
+            program['numDirLights'].write(glm.int32(len(self.directional_lights)))
+
+            for i, light in enumerate(self.directional_lights):
+                program[f'dirLights[{i}].direction'].write(light.direction)
+                program[f'dirLights[{i}].intensity'].write(glm.float32(light.intensity))
+                program[f'dirLights[{i}].color'    ].write(light.color / 255.0)
+                program[f'dirLights[{i}].ambient'  ].write(glm.float32(light.ambient))
+        
+        if point:
+            ...

basilisk/render/material.py

@@ -0,0 +1,196 @@
+import glm
+import numpy as np
+from ..render.image import Image
+from ..generic.input_validation import *
+
+class Material():
+    material_handler: ...
+    """Back reference to the parent material handler"""
+    name: str = None
+    """Name of the material"""  
+    index: 0
+    """Index of the material in the material uniform"""
+    
+    # Base Material Attributes
+    color: glm.vec3 = glm.vec3(255.0, 255.0, 255.0)
+    """Color multiplier of the material"""   
+    texture: Image = None
+    """Key/name of the texture image in the image handler. If the image given does not exist, it must be loaded"""
+    normal: Image = None
+    """Key/name of the normal image in the image handler. If the image given does not exist, it must be loaded"""
+    
+    # PBR Material Attributes
+    roughness: float
+    """The roughness of the material, controlls both the specular and diffuse response"""
+    subsurface: float
+    """Amount of subsurface scattering the material exhibits. Value in range [0, 1]. Lerps between diffuse and subsurface lobes"""
+    sheen: float
+    """Amount of sheen the material exhibits. Additive lobe"""
+    sheen_tint: float
+    """Amount that the sheen is tinted to the base color. Set to white by default"""
+    anisotropic: float
+    """The amount of anisotropic behaviour the materials specular lobe exhibits"""
+    specular: float
+    """The strength of the specular lobe of the material"""
+    metallicness: float
+    """The metallicness of the material, which dictates how much light the surfaces diffuses"""
+    specular_tint: float
+    """Amount that the specular is tinted to the base color. Set to white by default"""
+    clearcoat: float
+    """Amount of clearcoat the material exhibits. Additive lobe"""
+    clearcoat_gloss: float
+    """The glossiness of the clearcoat layer. 0 For a satin appearance, 1 for a gloss appearance"""
+
+    def __init__(self, name: str=None, color: tuple=(255.0, 255.0, 255.0), texture: Image=None, normal: Image=None, 
+                 roughness: float=0.7, subsurface: float=0.2, sheen: float=0.5, sheen_tint: float=0.5,
+                 anisotropic: float=0.0, specular: float=1.0, metallicness: float=0.0, specular_tint: float=0.0,
+                 clearcoat: float=0.5, clearcoat_gloss: float=0.25) -> None:
+        """
+        Basilisk Material object. Contains the data and images references used by the material.
+        Args:
+            name: str
+                Identifier to be used by user
+            color: tuple
+                Base color of the material. Applies to textures as well
+            texture: Basilisk Image
+                The albedo map (color texture) of the material
+            normal: Basilisk Image
+                The normal map of the material.
+        """
+
+        # Set handler only when used by a scene
+        self.material_handler = None
+        
+        self.index = 0
+        
+        self.name            = name if name else ''
+        self.color           = color
+        self.texture         = texture
+        self.normal          = normal
+        self.roughness       = roughness
+        self.subsurface      = subsurface
+        self.sheen           = sheen
+        self.sheen_tint      = sheen_tint
+        self.anisotropic     = anisotropic
+        self.specular        = specular
+        self.metallicness    = metallicness
+        self.specular_tint   = specular_tint
+        self.clearcoat       = clearcoat
+        self.clearcoat_gloss = clearcoat_gloss
+
+    def get_data(self) -> list:
+        """
+        Returns a list containing all the gpu data in the material.
+        Used by the material handler
+        """
+
+        # Add color and PBR data
+        data = [self.color.x         / 255.0, self.color.y         / 255.0, self.color.z         / 255.0, self.roughness,   self.subsurface, self.sheen,
+                self.sheen_tint, self.anisotropic, self.specular,   self.metallicness, self.specular_tint, self.clearcoat,   self.clearcoat_gloss]
+        
+        # Add texture data
+        if self.texture: data.extend([1, self.texture.index.x, self.texture.index.y])
+        else: data.extend([0, 0, 0])
+
+        # Add normal data
+        if self.normal: data.extend([1, self.normal.index.x, self.normal.index.y])
+        else: data.extend([0, 0, 0])
+
+        return data
+
+    def __repr__(self) -> str:
+        return f'<Basilisk Material | {self.name}, ({self.color.x}, {self.color.y}, {self.color.z}), {self.texture}>'
+
+
+    @property
+    def color(self):           return self._color
+    @property
+    def texture(self):         return self._texture
+    @property
+    def normal(self):          return self._normal
+    @property
+    def roughness(self):       return self._roughness
+    @property
+    def subsurface(self):      return self._subsurface
+    @property
+    def sheen(self):           return self._sheen
+    @property
+    def sheen_tint(self):      return self._sheen_tint
+    @property
+    def anisotropic(self):     return self._anisotropic
+    @property
+    def specular(self):        return self._specular
+    @property
+    def metallicness(self):    return self._metallicness
+    @property
+    def specular_tint(self):   return self._specular_tint
+    @property
+    def clearcoat(self):       return self._clearcoat
+    @property
+    def clearcoat_gloss(self): return self._clearcoat_gloss
+
+
+    @color.setter
+    def color(self, value: tuple | list | glm.vec3 | np.ndarray):
+        self._color = validate_glm_vec3("Material", "color", value)
+        if self.material_handler: self.material_handler.write()
+        
+    @texture.setter
+    def texture(self, value: Image | None):
+        self._texture = validate_image("Material", "texture", value)
+        if self.material_handler: self.material_handler.write()
+        
+    @normal.setter
+    def normal(self, value: Image | None):
+        self._normal = validate_image("Material", "normal map", value)
+        if self.material_handler: self.material_handler.write()
+
+    @roughness.setter
+    def roughness(self, value: float | int | glm.float32):
+        self._roughness = validate_float("Material", "roughness", value)
+        if self.material_handler: self.material_handler.write()
+
+    @subsurface.setter
+    def subsurface(self, value: float | int | glm.float32):
+        self._subsurface = validate_float("Material", "subsurface", value)
+        if self.material_handler: self.material_handler.write()
+
+    @sheen.setter
+    def sheen(self, value: float | int | glm.float32):
+        self._sheen = validate_float("Material", "sheen", value)
+        if self.material_handler: self.material_handler.write()
+
+    @sheen_tint.setter
+    def sheen_tint(self, value: float | int | glm.float32):
+        self._sheen_tint = validate_float("Material", "sheen tint", value)
+        if self.material_handler: self.material_handler.write()
+
+    @anisotropic.setter
+    def anisotropic(self, value: float | int | glm.float32):
+        self._anisotropic = validate_float("Material", "anisotropic", value)
+        if self.material_handler: self.material_handler.write()
+
+    @specular.setter
+    def specular(self, value: float | int | glm.float32):
+        self._specular = validate_float("Material", "specular", value)
+        if self.material_handler: self.material_handler.write()
+
+    @metallicness.setter
+    def metallicness(self, value: float | int | glm.float32):
+        self._metallicness = validate_float("Material", "metallicness", value)
+        if self.material_handler: self.material_handler.write()
+
+    @specular_tint.setter
+    def specular_tint(self, value: float | int | glm.float32):
+        self._specular_tint = validate_float("Material", "specular tint", value)
+        if self.material_handler: self.material_handler.write()
+    
+    @clearcoat.setter
+    def clearcoat(self, value: float | int | glm.float32):
+        self._clearcoat = validate_float("Material", "clearcoat", value)
+        if self.material_handler: self.material_handler.write()
+
+    @clearcoat_gloss.setter
+    def clearcoat_gloss(self, value: float | int | glm.float32):
+        self._clearcoat_gloss = validate_float("Material", "clearcoat gloss", value)
+        if self.material_handler: self.material_handler.write()

basilisk/render/material_handler.py

@@ -0,0 +1,123 @@
+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
+        """
+        
+        # Check that the material is not already in the scene
+        if material in self.materials: return None
+        # Update the material's handler
+        material.material_handler = self
+        # Add images
+        if material.texture: self.image_handler.add(material.texture)
+        if material.normal:  self.image_handler.add(material.normal)
+
+        # Add the material
+        self.materials.append(material)
+        # Write materials
+        self.write()
+
+    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), 19), 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, shader_program: mgl.Program=None) -> None:
+        """
+        Writes all material data to the given shader
+        """
+
+        if shader_program == None: shader_program = self.scene.shader_handler.programs['batch']
+
+        self.generate_material_texture()
+
+        shader_program[f'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.write()
+
+    def __del__(self) -> None:
+        """
+        Releases the material data texture
+        """
+
+        if self.data_texture: self.data_texture.release()