basilisk-engine 0.1.52__py3-none-any.whl → 0.1.53__py3-none-any.whl

basilisk/render/image.py

@@ -1,129 +1,129 @@
-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 = (8, 64, 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"""
-    texture: mgl.Texture | None=None
-    """Texture of the image. Only created and retrived if needed by other module"""
-
-    def __init__(self, path: str | os.PathLike | pg.Surface | mgl.Texture, flip_x: bool=False, flip_y: bool=True) -> 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
-            flip_x: bool=True
-                Flips the image vertically. Should be True for using the internal cube lmao
-            flip_y: bool=True
-                Flips the image vertically. Should be True for blender imports
-        """
-        
-        # Check if the user is loading a pygame surface
-        if isinstance(path, str) or isinstance(path, os.PathLike):
-            return self._from_path(path, flip_x, flip_y)
-        elif isinstance(path, pg.Surface):
-            return self._from_surface(path, flip_x, flip_y)
-        elif isinstance(path, mgl.Texture):
-            return self._from_texture(path, flip_x, flip_y)
-        
-        raise TypeError(f'Invalid path type: {type(path)}. Expected a string or os.PathLike')
-
-    def _from_path(self, path: str | os.PathLike, flip_x: bool=False, flip_y: bool=True) -> None:
-        """
-        Loads a basilisk image from a pygame surface
-        Args:
-        """
-        
-        # Get name from path
-        self.name = path.split('/')[-1].split('\\')[-1].split('.')[0]
-
-        # Load image
-        img = PIL_Image.open(path).convert('RGBA')
-        if flip_x: img = img.transpose(PIL_Image.FLIP_LEFT_RIGHT)
-        if flip_y: img = img.transpose(PIL_Image.FLIP_TOP_BOTTOM)
-        # 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_surface(self, surf: pg.Surface, flip_x: bool=False, flip_y: bool=True) -> None:
-        """
-        Loads a basilisk image from a pygame surface
-        Args:
-        """
-
-        surf = pg.transform.flip(surf, flip_x, flip_y)
-        
-        # 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 _from_texture(self, texture: mgl.Texture, flip_x: bool=False, flip_y: bool=True):
-        """
-        
-        """
-        ...
-
-    def build_texture(self, ctx: mgl.Context) -> mgl.Texture:
-        """
-        Builds a texture from the image data
-        """
-
-        # Release existing memory
-        if self.texture: self.texture.release()
-
-        # Make the texture from image data
-        self.texture = ctx.texture((self.size, self.size), components=4, data=self.data)
-        # Texture formatting
-        self.texture.build_mipmaps()
-        self.texture.filter = (mgl.LINEAR_MIPMAP_LINEAR, mgl.LINEAR)
-        self.texture.anisotropy = 32.0
-        
-        return self.texture
-
-    def use(self, slot: int) -> None:
-        """
-        Use the image at the given slot
-        """
-        
-        if not self.texture:
-            raise LookupError("bsk.Image: cannot use an image without a texture. Use texture.build_texture() before texture.use()")
-
-        # Bind to the given slot
-        self.texture.use(location=slot)
-
-    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>'
-    
-    def __del__(self) -> None:
+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 = (8, 64, 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"""
+    texture: mgl.Texture | None=None
+    """Texture of the image. Only created and retrived if needed by other module"""
+
+    def __init__(self, path: str | os.PathLike | pg.Surface | mgl.Texture, flip_x: bool=False, flip_y: bool=True) -> 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
+            flip_x: bool=True
+                Flips the image vertically. Should be True for using the internal cube lmao
+            flip_y: bool=True
+                Flips the image vertically. Should be True for blender imports
+        """
+        
+        # Check if the user is loading a pygame surface
+        if isinstance(path, str) or isinstance(path, os.PathLike):
+            return self._from_path(path, flip_x, flip_y)
+        elif isinstance(path, pg.Surface):
+            return self._from_surface(path, flip_x, flip_y)
+        elif isinstance(path, mgl.Texture):
+            return self._from_texture(path, flip_x, flip_y)
+        
+        raise TypeError(f'Invalid path type: {type(path)}. Expected a string or os.PathLike')
+
+    def _from_path(self, path: str | os.PathLike, flip_x: bool=False, flip_y: bool=True) -> None:
+        """
+        Loads a basilisk image from a pygame surface
+        Args:
+        """
+        
+        # Get name from path
+        self.name = path.split('/')[-1].split('\\')[-1].split('.')[0]
+
+        # Load image
+        img = PIL_Image.open(path).convert('RGBA')
+        if flip_x: img = img.transpose(PIL_Image.FLIP_LEFT_RIGHT)
+        if flip_y: img = img.transpose(PIL_Image.FLIP_TOP_BOTTOM)
+        # 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_surface(self, surf: pg.Surface, flip_x: bool=False, flip_y: bool=True) -> None:
+        """
+        Loads a basilisk image from a pygame surface
+        Args:
+        """
+
+        surf = pg.transform.flip(surf, flip_x, flip_y)
+        
+        # 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 _from_texture(self, texture: mgl.Texture, flip_x: bool=False, flip_y: bool=True):
+        """
+        
+        """
+        ...
+
+    def build_texture(self, ctx: mgl.Context) -> mgl.Texture:
+        """
+        Builds a texture from the image data
+        """
+
+        # Release existing memory
+        if self.texture: self.texture.release()
+
+        # Make the texture from image data
+        self.texture = ctx.texture((self.size, self.size), components=4, data=self.data)
+        # Texture formatting
+        self.texture.build_mipmaps()
+        self.texture.filter = (mgl.LINEAR_MIPMAP_LINEAR, mgl.LINEAR)
+        self.texture.anisotropy = 32.0
+        
+        return self.texture
+
+    def use(self, slot: int) -> None:
+        """
+        Use the image at the given slot
+        """
+        
+        if not self.texture:
+            raise LookupError("bsk.Image: cannot use an image without a texture. Use texture.build_texture() before texture.use()")
+
+        # Bind to the given slot
+        self.texture.use(location=slot)
+
+    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>'
+    
+    def __del__(self) -> None:
         if self.texture: self.texture.release()

basilisk/render/image_handler.py

@@ -1,121 +1,121 @@
-import moderngl as mgl
-import glm
-import numpy as np
-
-texture_sizes = (8, 64, 512, 1024, 2048)
-
-
-class ImageHandler():
-    engine: ...
-    """Back refernce to the parent engine"""
-    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, engine) -> None:
-        """
-        Container for all the basilisk image objects in the scene.
-        Handles the managment and writting of all image textures.
-        """
-        
-        # Set back references
-        self.engine = engine
-        self.ctx    = 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
-        Uses bind slots [10, 11, 12, 13, 14]
-        """
-
-        if not self.engine.shader_handler: return
-
-        if regenerate: self.generate_texture_array()
-
-        if not self.texture_arrays: return
-
-        for shader in self.engine.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.bind(self.texture_arrays[size], f'textureArrays[{i}].array', i + 10)
-
-    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: ...
+    """Back refernce to the parent engine"""
+    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, engine) -> None:
+        """
+        Container for all the basilisk image objects in the scene.
+        Handles the managment and writting of all image textures.
+        """
+        
+        # Set back references
+        self.engine = engine
+        self.ctx    = 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
+        Uses bind slots [10, 11, 12, 13, 14]
+        """
+
+        if not self.engine.shader_handler: return
+
+        if regenerate: self.generate_texture_array()
+
+        if not self.texture_arrays: return
+
+        for shader in self.engine.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.bind(self.texture_arrays[size], f'textureArrays[{i}].array', i + 10)
+
+    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]