basilisk-engine 0.1.22__py3-none-any.whl → 0.1.23__py3-none-any.whl

basilisk/render/frame.py

@@ -1,102 +1,100 @@
-import numpy as np
-import moderngl as mgl
-from .shader import Shader
-from .framebuffer import Framebuffer
-
-from .post_process import PostProcess
-
-class Frame:
-    shader: Shader=None
-    vbo: mgl.Buffer=None
-    vao: mgl.VertexArray=None
-    framebuffer: mgl.Framebuffer=None
-
-    def __init__(self, scene, resolution=1, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
-        """
-        Basilisk render destination. 
-        Can be used to render to the screen or for headless rendering
-        """
-
-        self.scene  = scene
-        self.engine = scene.engine
-        self.ctx    = scene.ctx
-
-        # Load framebuffer
-        self.resolution = resolution
-        self.filter = filter
-        size = tuple(map(lambda x: int(x * self.resolution), self.engine.win_size))
-        self.framebuffer = Framebuffer(self.engine, size=size, filter=self.filter)
-        self.ping_pong_buffer = Framebuffer(self.engine, size=size, filter=self.filter)
-
-        # Load Shaders
-        self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame.frag')
-        self.scene.shader_handler.add(self.shader)
-
-        # Load VAO
-        self.vbo = self.ctx.buffer(np.array([[-1, -1, 0, 0, 0], [1, -1, 0, 1, 0], [1, 1, 0, 1, 1], [-1, 1, 0, 0, 1], [-1, -1, 0, 0, 0], [1, 1, 0, 1, 1]], dtype='f4'))
-        self.vao = self.ctx.vertex_array(self.shader.program, [(self.vbo, '3f 2f', 'in_position', 'in_uv')], skip_errors=True)
-
-        # TEMP TESTING
-        self.post_processes = []
-
-
-    def render(self) -> None:
-        """
-        Renders the current frame to the screen
-        """
-
-        for process in self.post_processes:
-            self.ping_pong_buffer = process.apply(self.framebuffer, self.ping_pong_buffer)
-            
-            temp = self.framebuffer
-            self.framebuffer = self.ping_pong_buffer
-            self.ping_pong_buffer = temp
-        
-        self.ctx.screen.use()
-        self.shader.program['screenTexture'] = 0
-        self.framebuffer.texture.use(location=0)
-        self.vao.render()
-
-
-    def use(self) -> None:
-        """
-        Uses the frame as a render target
-        """
-        
-        self.framebuffer.use()
-        self.clear()
-
-    def add_post_process(self, post_process: PostProcess) -> PostProcess:
-        """
-        Add a post process to the frames post process stack
-        """
-
-        self.post_processes.append(post_process)
-        return post_process
-
-    def save(self, destination: str=None) -> None:
-        """
-        Saves the frame as an image to the given file destination
-        """
-
-        self.framebuffer.save(destination)
-    
-    def clear(self):
-        self.framebuffer.clear()
-
-    def resize(self, size: tuple[int]=None) -> None:
-        """
-        Resize the frame to the given size. None for window size
-        """
-
-        size = tuple(map(lambda x: int(x * self.resolution), self.engine.win_size))
-        self.framebuffer.resize(size)
-        self.ping_pong_buffer.resize(size)
-
-    def __del__(self) -> None:
-        """
-        Releases memory used by the frame
-        """
-        
-        if self.vbo: self.vbo.release()
+import numpy as np
+import moderngl as mgl
+from .shader import Shader
+from .framebuffer import Framebuffer
+
+from .post_process import PostProcess
+
+class Frame:
+    shader: Shader=None
+    vbo: mgl.Buffer=None
+    vao: mgl.VertexArray=None
+    framebuffer: mgl.Framebuffer=None
+
+    def __init__(self, engine, resolution=1, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
+        """
+        Basilisk render destination. 
+        Can be used to render to the screen or for headless rendering
+        """
+
+        self.engine = engine
+        self.ctx    = engine.ctx
+
+        # Load framebuffer
+        self.resolution = resolution
+        self.filter = filter
+        size = tuple(map(lambda x: int(x * self.resolution), self.engine.win_size))
+        self.framebuffer = Framebuffer(self.engine, size=size, filter=self.filter)
+        self.ping_pong_buffer = Framebuffer(self.engine, size=size, filter=self.filter)
+
+        # Load Shaders
+        self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame.frag')
+        self.engine.shader_handler.add(self.shader)
+
+        # Load VAO
+        self.vbo = self.ctx.buffer(np.array([[-1, -1, 0, 0, 0], [1, -1, 0, 1, 0], [1, 1, 0, 1, 1], [-1, 1, 0, 0, 1], [-1, -1, 0, 0, 0], [1, 1, 0, 1, 1]], dtype='f4'))
+        self.vao = self.ctx.vertex_array(self.shader.program, [(self.vbo, '3f 2f', 'in_position', 'in_uv')], skip_errors=True)
+
+        # TEMP TESTING
+        self.post_processes = []
+
+
+    def render(self) -> None:
+        """
+        Renders the current frame to the screen
+        """
+
+        for process in self.post_processes:
+            self.ping_pong_buffer = process.apply(self.framebuffer, self.ping_pong_buffer)
+            
+            temp = self.framebuffer
+            self.framebuffer = self.ping_pong_buffer
+            self.ping_pong_buffer = temp
+        
+        self.ctx.screen.use()
+        self.shader.program['screenTexture'] = 0
+        self.framebuffer.texture.use(location=0)
+        self.vao.render()
+
+
+    def use(self) -> None:
+        """
+        Uses the frame as a render target
+        """
+        
+        self.framebuffer.use()
+
+    def add_post_process(self, post_process: PostProcess) -> PostProcess:
+        """
+        Add a post process to the frames post process stack
+        """
+
+        self.post_processes.append(post_process)
+        return post_process
+
+    def save(self, destination: str=None) -> None:
+        """
+        Saves the frame as an image to the given file destination
+        """
+
+        self.framebuffer.save(destination)
+    
+    def clear(self):
+        self.framebuffer.clear()
+
+    def resize(self, size: tuple[int]=None) -> None:
+        """
+        Resize the frame to the given size. None for window size
+        """
+
+        size = tuple(map(lambda x: int(x * self.resolution), self.engine.win_size))
+        self.framebuffer.resize(size)
+        self.ping_pong_buffer.resize(size)
+
+    def __del__(self) -> None:
+        """
+        Releases memory used by the frame
+        """
+        
+        if self.vbo: self.vbo.release()
         if self.vao: self.vao.release()

basilisk/render/framebuffer.py

@@ -1,131 +1,132 @@
-import numpy as np
-import moderngl as mgl
-from PIL import Image
-from ..render.shader import Shader
-
-
-class Framebuffer:
-    engine: ...
-    """Reference to the parent engine"""
-    fbo: mgl.Framebuffer = None
-    """The core framebuffer the object provides abstraction for."""
-    texture: mgl.Texture = None
-    """The color texture of the framebuffer"""
-    depth: mgl.Texture = None
-    """The depth texture of the framebuffer"""
-    size: tuple[int]
-    """The dimensions of the framebuffer (x, y)"""
-
-    def __init__(self, engine, size: tuple[int]=None, resolution_scale: float=1.0, components: int=4, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
-        """
-        Abstraction to the mgl framebuffer
-        Args:
-            engine: mgl.Engine: 
-                The parent engine
-            size: tuple[int]: 
-                The dimensions of the framebuffer (x, y)
-        """
-        
-        # Set attributes
-        self.engine = engine
-        self.ctx = engine.ctx
-        self.components = components
-
-        # Set the size
-        self.resolution_scale = resolution_scale
-        self._size = size
-        self.size = self._size if self._size else self.engine.win_size
-        self.size = (int(self.size[0] * resolution_scale), int(self.size[1] * resolution_scale))
-        
-        # Create the fbo
-        self.texture = self.ctx.texture(self.size, components=self.components)
-        self.depth = self.ctx.depth_texture(self.size)
-        self.fbo   = self.ctx.framebuffer([self.texture], self.depth)
-
-        # Load Shaders
-        self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame.frag')
-        self.engine.scene.shader_handler.add(self.shader)
-
-        # Load VAO
-        self.vbo = self.ctx.buffer(np.array([[-1, -1, 0, 0, 0], [1, -1, 0, 1, 0], [1, 1, 0, 1, 1], [-1, 1, 0, 0, 1], [-1, -1, 0, 0, 0], [1, 1, 0, 1, 1]], dtype='f4'))
-        self.vao = self.ctx.vertex_array(self.shader.program, [(self.vbo, '3f 2f', 'in_position', 'in_uv')], skip_errors=True)
-
-        # Save the filter
-        self.filter = filter
-
-        # Add to the engine for updates
-        self.engine.fbos.append(self)
-
-    def render(self) -> None:
-        self.shader.program['screenTexture'] = 0
-        self.texture.use(location=0)
-        self.vao.render()
-
-    def use(self) -> None:
-        """
-        Select this framebuffer for use
-        """
-
-        self.fbo.use()
-
-    def clear(self) -> None:
-        """
-        Clear all data currently in the textures (set to black)        
-        """
-
-        self.fbo.clear()
-
-    def save(self, destination: str=None) -> None:
-        """
-        Saves the frame as an image to the given file destination
-        """
-
-        path = destination if destination else 'screenshot'
-
-        data = self.fbo.read(components=3, alignment=1)
-        img = Image.frombytes('RGB', self.size, data).transpose(Image.FLIP_TOP_BOTTOM)
-        img.save(f'{path}.png')
-
-    def resize(self, size: tuple[int]=None) -> None:
-        """
-        Resize the buffer to the given size. None for window size
-        """
-
-        # Release old memory
-        self.__del__()
-
-        # Set/get size attribute
-        if size:
-            self.size = size
-        else:
-            self.size = self._size if self._size else self.engine.win_size
-        self.size = (int(self.size[0] * self.resolution_scale), int(self.size[1] * self.resolution_scale))
-
-        # Create the fbo
-        self.texture = self.ctx.texture(self.size, components=self.components)
-        self.depth = self.ctx.depth_texture(self.size)
-        self.fbo   = self.ctx.framebuffer([self.texture], self.depth)
-
-        self.filter = self._filter
-
-    @property
-    def data(self):
-        return self.fbo.read(components=3, alignment=1)
-
-    @property
-    def filter(self):
-        return self.texture.filter
-    
-    @filter.setter
-    def filter(self, value):
-        self._filter = value
-        self.texture.filter = value
-
-    def __repr__(self) -> str:
-        return f'<bsk.Framebuffer | size: {self.size}>' 
-
-    def __del__(self) -> None:
-        # Release any existing memory in case of a resize
-        if self.texture: self.texture.release()
-        if self.depth: self.depth.release()
+import numpy as np
+import moderngl as mgl
+from PIL import Image
+from ..render.shader import Shader
+
+
+class Framebuffer:
+    engine: ...
+    """Reference to the parent engine"""
+    fbo: mgl.Framebuffer = None
+    """The core framebuffer the object provides abstraction for."""
+    texture: mgl.Texture = None
+    """The color texture of the framebuffer"""
+    depth: mgl.Texture = None
+    """The depth texture of the framebuffer"""
+    size: tuple[int]
+    """The dimensions of the framebuffer (x, y)"""
+
+    def __init__(self, engine, size: tuple[int]=None, resolution_scale: float=1.0, components: int=4, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
+        """
+        Abstraction to the mgl framebuffer
+        Args:
+            engine: mgl.Engine: 
+                The parent engine
+            size: tuple[int]: 
+                The dimensions of the framebuffer (x, y)
+        """
+        
+        # Set attributes
+        self.engine = engine
+        self.ctx = engine.ctx
+        self.components = components
+
+        # Set the size
+        self.resolution_scale = resolution_scale
+        self._size = size
+        self.size = self._size if self._size else self.engine.win_size
+        self.size = (int(self.size[0] * resolution_scale), int(self.size[1] * resolution_scale))
+        
+        # Create the fbo
+        self.texture = self.ctx.texture(self.size, components=self.components)
+        self.depth = self.ctx.depth_texture(self.size)
+        self.fbo   = self.ctx.framebuffer([self.texture], self.depth)
+
+        # Load Shaders
+        self.shader = Shader(self.engine, self.engine.root + '/shaders/frame.vert', self.engine.root + '/shaders/frame.frag')
+        self.engine.shader_handler.add(self.shader)
+
+        # Load VAO
+        self.vbo = self.ctx.buffer(np.array([[-1, -1, 0, 0, 0], [1, -1, 0, 1, 0], [1, 1, 0, 1, 1], [-1, 1, 0, 0, 1], [-1, -1, 0, 0, 0], [1, 1, 0, 1, 1]], dtype='f4'))
+        self.vao = self.ctx.vertex_array(self.shader.program, [(self.vbo, '3f 2f', 'in_position', 'in_uv')], skip_errors=True)
+
+        # Save the filter
+        self.filter = filter
+
+        # Add to the engine for updates
+        self.engine.fbos.append(self)
+
+    def render(self) -> None:
+        self.shader.program['screenTexture'] = 0
+        self.texture.use(location=0)
+        self.vao.render()
+
+    def use(self) -> None:
+        """
+        Select this framebuffer for use
+        """
+
+        self.fbo.use()
+
+    def clear(self) -> None:
+        """
+        Clear all data currently in the textures (set to black)        
+        """
+
+        self.fbo.clear()
+
+    def save(self, destination: str=None) -> None:
+        """
+        Saves the frame as an image to the given file destination
+        """
+
+        path = destination if destination else 'screenshot'
+
+        data = self.fbo.read(components=3, alignment=1)
+        img = Image.frombytes('RGB', self.size, data).transpose(Image.FLIP_TOP_BOTTOM)
+        img.save(f'{path}.png')
+
+    def resize(self, size: tuple[int]=None) -> None:
+        """
+        Resize the buffer to the given size. None for window size
+        """
+
+        # Release old memory
+        self.__del__()
+
+        # Set/get size attribute
+        if size:
+            self.size = size
+        else:
+            self.size = self._size if self._size else self.engine.win_size
+        self.size = (int(self.size[0] * self.resolution_scale), int(self.size[1] * self.resolution_scale))
+
+        # Create the fbo
+        print(self.size)
+        self.texture = self.ctx.texture(self.size, components=self.components)
+        self.depth = self.ctx.depth_texture(self.size)
+        self.fbo   = self.ctx.framebuffer([self.texture], self.depth)
+
+        self.filter = self._filter
+
+    @property
+    def data(self):
+        return self.fbo.read(components=3, alignment=1)
+
+    @property
+    def filter(self):
+        return self.texture.filter
+    
+    @filter.setter
+    def filter(self, value):
+        self._filter = value
+        self.texture.filter = value
+
+    def __repr__(self) -> str:
+        return f'<bsk.Framebuffer | size: {self.size}>' 
+
+    def __del__(self) -> None:
+        # Release any existing memory in case of a resize
+        if self.texture: self.texture.release()
+        if self.depth: self.depth.release()
         if self.fbo:   self.fbo.release()

basilisk/render/image.py

@@ -1,88 +1,88 @@
-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"""
-
-    def __init__(self, path: str | os.PathLike | pg.Surface | mgl.Texture) -> 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, str) or isinstance(path, os.PathLike):
-            return self._from_path(path)
-        elif isinstance(path, pg.Surface):
-            return self._from_surface(path)
-        elif isinstance(path, mgl.Texture):
-            return self._from_texture(path)
-        
-        raise TypeError(f'Invalid path type: {type(path)}. Expected a string or os.PathLike')
-
-    def _from_path(self, path: str | os.PathLike) -> 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')
-        # 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) -> 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 _from_texture(self, texture: mgl.Texture):
-        """
-        
-        """
-        ...
-
-    def __repr__(self) -> str:
-        """
-        Returns a string representation of the object
-        """
+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"""
+
+    def __init__(self, path: str | os.PathLike | pg.Surface | mgl.Texture) -> 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, str) or isinstance(path, os.PathLike):
+            return self._from_path(path)
+        elif isinstance(path, pg.Surface):
+            return self._from_surface(path)
+        elif isinstance(path, mgl.Texture):
+            return self._from_texture(path)
+        
+        raise TypeError(f'Invalid path type: {type(path)}. Expected a string or os.PathLike')
+
+    def _from_path(self, path: str | os.PathLike) -> 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')
+        # 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) -> 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 _from_texture(self, texture: mgl.Texture):
+        """
+        
+        """
+        ...
+
+    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>'