basilisk-engine 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

basilisk/render/image_handler.py

@@ -1,123 +1,123 @@
-import moderngl as mgl
-import glm
-import numpy as np
-
-
-texture_sizes = (8, 64, 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(regenerate=True)
-
-    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:
-            # Check that there are textures in the bucket
-            if not len(self.texture_arrays[size]): continue
-            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()
-            if size > 32: self.texture_arrays[size].filter = (mgl.LINEAR_MIPMAP_LINEAR, mgl.LINEAR)
-            else: self.texture_arrays[size].filter = (mgl.NEAREST, mgl.NEAREST)
-            self.texture_arrays[size].anisotropy = 32.0
-
-    def write(self, regenerate=False) -> None:
-        """
-        Writes all texture arrays to shaders that use images 
-        """
-
-        if regenerate: self.generate_texture_array()
-
-        if not self.texture_arrays: return
-
-        for shader in self.engine.scene.shader_handler.shaders:
-            if 'textureArrays[5]' not in shader.uniforms: continue
-
-            for i, size in enumerate(texture_sizes):
-                if not size in self.texture_arrays: continue
-                if not self.texture_arrays[size]: 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
-        """
-        
+import moderngl as mgl
+import glm
+import numpy as np
+
+
+texture_sizes = (8, 64, 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(regenerate=True)
+
+    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:
+            # Check that there are textures in the bucket
+            if not len(self.texture_arrays[size]): continue
+            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()
+            if size > 32: self.texture_arrays[size].filter = (mgl.LINEAR_MIPMAP_LINEAR, mgl.LINEAR)
+            else: self.texture_arrays[size].filter = (mgl.NEAREST, mgl.NEAREST)
+            self.texture_arrays[size].anisotropy = 32.0
+
+    def write(self, regenerate=False) -> None:
+        """
+        Writes all texture arrays to shaders that use images 
+        """
+
+        if regenerate: self.generate_texture_array()
+
+        if not self.texture_arrays: return
+
+        for shader in self.engine.scene.shader_handler.shaders:
+            if 'textureArrays[5]' not in shader.uniforms: continue
+
+            for i, size in enumerate(texture_sizes):
+                if not size in self.texture_arrays: continue
+                if not self.texture_arrays[size]: 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

@@ -1,97 +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")
+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

@@ -1,59 +1,59 @@
-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.engine.shader.program
-
-        for shader in self.scene.shader_handler.shaders:
-            if 'numDirLights' not in shader.uniforms: continue
-            
-            program = shader.program
-
-            if directional and self.directional_lights and 'numDirLights' in self.engine.shader.uniforms:
-
-                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:
+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.engine.shader.program
+
+        for shader in self.scene.shader_handler.shaders:
+            if 'numDirLights' not in shader.uniforms: continue
+            
+            program = shader.program
+
+            if directional and self.directional_lights and 'numDirLights' in self.engine.shader.uniforms:
+
+                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:
                 ...