basilisk-engine 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

basilisk/render/chunk_handler.py

@@ -1,155 +1,155 @@
-import numpy as np
-import moderngl as mgl
-from .chunk import Chunk
-from ..nodes.node import Node
-
-
-class ChunkHandler():
-    engine: ...
-    """Back reference to the parent engine"""
-    scene: ...
-    """Back reference to the parent scene"""
-    ctx: mgl.Context
-    """Back reference to the parent context"""
-    program: mgl.Program
-    """Reference to the shader program used by batches"""
-    chunks: list[dict]
-    """List containing two dictionaries for dynamic and static chunks repsectivly"""
-    updated_chunks: set
-    """Set containing recently updated chunks"""
-    
-    def __init__(self, scene) -> None:
-        # Reference to the scene hadlers and variables
-        """
-        Handles all the chunking of all the nodes in the scene
-        """
-        
-        # Back references
-        self.scene   = scene
-        self.engine  = scene.engine
-        self.ctx     = scene.engine.ctx
-        self.program = scene.engine.shader.program
-
-        # List for the dynamic and static chunk dictionaries | [dyanmic: dict, static: dict]
-        self.shader_groups = {None : ({}, {})}
-        # self.chunks         = [{}, {}]
-        self.updated_chunks = set()
-
-
-    def render(self) -> None:
-        """
-        Renders all the chunk batches in the camera's range
-        Includes some view culling, but not frustum culling. 
-        """
-        
-        # Gets a rectanglur prism of chunks in the cameras view
-        render_range_x, render_range_y, render_range_z = self.get_render_range()
-
-        chunk_keys = [(x, y, z) for x in range(*render_range_x) for y in range(*render_range_y) for z in range(*render_range_z)]
-
-        # Loop through all chunks in view and render
-        for shader, group in self.shader_groups.items():
-            if shader == None: shader = self.engine.shader            
-            for chunk in chunk_keys:
-                # Render the chunk if it exists
-                if chunk in group[0]: group[0][chunk].render()
-                if chunk in group[1]: group[1][chunk].render()
-
-
-    def update(self) -> None:           
-        """
-        Updates all the chunks that have been updated since the last frame. 
-        """ 
-
-        self.program = self.scene.engine.shader.program
-
-        # Loop through the set of updated chunk keys and update the chunk
-        removes = []
-
-        for chunk in self.updated_chunks: 
-            if chunk.update(): continue
-            removes.append(chunk)
-
-        # Remove any empty chunks
-        for chunk in removes:
-            del self.shader_groups[chunk.shader][chunk.static][chunk.position]
-
-        # Clears the set of updated chunks so that they are not updated unless they are updated again
-        self.updated_chunks.clear()
-
-    def update_all(self):
-        self.program = self.scene.engine.shader.program
-        for shader in self.shader_groups.values():
-            for chunk in shader[0].values():
-                self.updated_chunks.add(chunk)
-            for chunk in shader[1].values():
-                self.updated_chunks.add(chunk)
-
-    def add(self, node: Node) -> Node:
-        """
-        Adds an existing node to its chunk. Updates the node's chunk reference
-        """
-
-        # The key of the chunk the node will be added to
-        chunk_size = self.engine.config.chunk_size
-        chunk_key = (int(node.x // chunk_size), int(node.y // chunk_size), int(node.z // chunk_size))
-        shader = node.shader
-
-        if shader not in self.shader_groups:
-            self.shader_groups[shader] = ({}, {})
-
-        # Ensure that the chunk exists
-        if chunk_key not in self.shader_groups[shader][node.static]:
-            chunk = Chunk(self, chunk_key, node.static, shader)
-            self.shader_groups[shader][node.static][chunk_key] = chunk
-
-        # Add the node to the chunk
-        self.shader_groups[shader][node.static][chunk_key].add(node)
-
-        # Update the chunk
-        self.updated_chunks.add(self.shader_groups[shader][node.static][chunk_key])
-
-        return Node
-
-    def remove(self, node: Node) -> None:
-        """
-        Removes a node from the its chunk
-        """
-
-        if node == None: return
-
-        # Remove the node
-        chunk = node.chunk
-        chunk.remove(node)
-        node.chunk = None
-
-        # Update the chunk
-        self.updated_chunks.add(chunk)
-
-    def get_render_range(self) -> tuple:
-        """
-        Returns a rectangluar prism of chunks that are in the camera's view.
-        Tuple return is in form ((x1, x2), (y1, y2), (z1, z2))
-        """
-        
-        cam_position = self.scene.camera.position  # glm.vec3(x, y, z)
-        fov = 40  # The range in which a direction will not be culled
-
-        # Default to a cube of chunks around the camera extending view_distance chunks in each direction
-        chunk_size = self.engine.config.chunk_size
-        render_distance = self.engine.config.render_distance
-        render_range_x = [int(cam_position.x // chunk_size - render_distance), int(cam_position.x // chunk_size + render_distance + 1)]
-        render_range_y = [int(cam_position.y // chunk_size - render_distance), int(cam_position.y // chunk_size + render_distance + 1)]
-        render_range_z = [int(cam_position.z // chunk_size - render_distance), int(cam_position.z // chunk_size + render_distance + 1)]
-
-        # Remove chunks that the camera is facing away from
-        render_range_x[1] -= render_distance * (180 - fov < self.scene.camera.yaw < 180 + fov) - 1
-        render_range_x[0] += render_distance * (-fov < self.scene.camera.yaw < fov or self.scene.camera.yaw > 360 - fov) - 1
-
-        render_range_y[0] += render_distance * (self.scene.camera.pitch > 25) - 1
-        render_range_y[1] -= render_distance * (self.scene.camera.pitch < -25) - 1
-
-        render_range_z[1] -= render_distance * (270 - fov < self.scene.camera.yaw < 270 + fov) - 1
-        render_range_z[0] += render_distance * (90 - fov < self.scene.camera.yaw < 90 + fov) - 1
-
+import numpy as np
+import moderngl as mgl
+from .chunk import Chunk
+from ..nodes.node import Node
+
+
+class ChunkHandler():
+    engine: ...
+    """Back reference to the parent engine"""
+    scene: ...
+    """Back reference to the parent scene"""
+    ctx: mgl.Context
+    """Back reference to the parent context"""
+    program: mgl.Program
+    """Reference to the shader program used by batches"""
+    chunks: list[dict]
+    """List containing two dictionaries for dynamic and static chunks repsectivly"""
+    updated_chunks: set
+    """Set containing recently updated chunks"""
+    
+    def __init__(self, scene) -> None:
+        # Reference to the scene hadlers and variables
+        """
+        Handles all the chunking of all the nodes in the scene
+        """
+        
+        # Back references
+        self.scene   = scene
+        self.engine  = scene.engine
+        self.ctx     = scene.engine.ctx
+        self.program = scene.engine.shader.program
+
+        # List for the dynamic and static chunk dictionaries | [dyanmic: dict, static: dict]
+        self.shader_groups = {None : ({}, {})}
+        # self.chunks         = [{}, {}]
+        self.updated_chunks = set()
+
+
+    def render(self) -> None:
+        """
+        Renders all the chunk batches in the camera's range
+        Includes some view culling, but not frustum culling. 
+        """
+        
+        # Gets a rectanglur prism of chunks in the cameras view
+        render_range_x, render_range_y, render_range_z = self.get_render_range()
+
+        chunk_keys = [(x, y, z) for x in range(*render_range_x) for y in range(*render_range_y) for z in range(*render_range_z)]
+
+        # Loop through all chunks in view and render
+        for shader, group in self.shader_groups.items():
+            if shader == None: shader = self.engine.shader            
+            for chunk in chunk_keys:
+                # Render the chunk if it exists
+                if chunk in group[0]: group[0][chunk].render()
+                if chunk in group[1]: group[1][chunk].render()
+
+
+    def update(self) -> None:           
+        """
+        Updates all the chunks that have been updated since the last frame. 
+        """ 
+
+        self.program = self.scene.engine.shader.program
+
+        # Loop through the set of updated chunk keys and update the chunk
+        removes = []
+
+        for chunk in self.updated_chunks: 
+            if chunk.update(): continue
+            removes.append(chunk)
+
+        # Remove any empty chunks
+        for chunk in removes:
+            del self.shader_groups[chunk.shader][chunk.static][chunk.position]
+
+        # Clears the set of updated chunks so that they are not updated unless they are updated again
+        self.updated_chunks.clear()
+
+    def update_all(self):
+        self.program = self.scene.engine.shader.program
+        for shader in self.shader_groups.values():
+            for chunk in shader[0].values():
+                self.updated_chunks.add(chunk)
+            for chunk in shader[1].values():
+                self.updated_chunks.add(chunk)
+
+    def add(self, node: Node) -> Node:
+        """
+        Adds an existing node to its chunk. Updates the node's chunk reference
+        """
+
+        # The key of the chunk the node will be added to
+        chunk_size = self.engine.config.chunk_size
+        chunk_key = (int(node.x // chunk_size), int(node.y // chunk_size), int(node.z // chunk_size))
+        shader = node.shader
+
+        if shader not in self.shader_groups:
+            self.shader_groups[shader] = ({}, {})
+
+        # Ensure that the chunk exists
+        if chunk_key not in self.shader_groups[shader][node.static]:
+            chunk = Chunk(self, chunk_key, node.static, shader)
+            self.shader_groups[shader][node.static][chunk_key] = chunk
+
+        # Add the node to the chunk
+        self.shader_groups[shader][node.static][chunk_key].add(node)
+
+        # Update the chunk
+        self.updated_chunks.add(self.shader_groups[shader][node.static][chunk_key])
+
+        return Node
+
+    def remove(self, node: Node) -> None:
+        """
+        Removes a node from the its chunk
+        """
+
+        if node == None: return
+
+        # Remove the node
+        chunk = node.chunk
+        chunk.remove(node)
+        node.chunk = None
+
+        # Update the chunk
+        self.updated_chunks.add(chunk)
+
+    def get_render_range(self) -> tuple:
+        """
+        Returns a rectangluar prism of chunks that are in the camera's view.
+        Tuple return is in form ((x1, x2), (y1, y2), (z1, z2))
+        """
+        
+        cam_position = self.scene.camera.position  # glm.vec3(x, y, z)
+        fov = 40  # The range in which a direction will not be culled
+
+        # Default to a cube of chunks around the camera extending view_distance chunks in each direction
+        chunk_size = self.engine.config.chunk_size
+        render_distance = self.engine.config.render_distance
+        render_range_x = [int(cam_position.x // chunk_size - render_distance), int(cam_position.x // chunk_size + render_distance + 1)]
+        render_range_y = [int(cam_position.y // chunk_size - render_distance), int(cam_position.y // chunk_size + render_distance + 1)]
+        render_range_z = [int(cam_position.z // chunk_size - render_distance), int(cam_position.z // chunk_size + render_distance + 1)]
+
+        # Remove chunks that the camera is facing away from
+        render_range_x[1] -= render_distance * (180 - fov < self.scene.camera.yaw < 180 + fov) - 1
+        render_range_x[0] += render_distance * (-fov < self.scene.camera.yaw < fov or self.scene.camera.yaw > 360 - fov) - 1
+
+        render_range_y[0] += render_distance * (self.scene.camera.pitch > 25) - 1
+        render_range_y[1] -= render_distance * (self.scene.camera.pitch < -25) - 1
+
+        render_range_z[1] -= render_distance * (270 - fov < self.scene.camera.yaw < 270 + fov) - 1
+        render_range_z[0] += render_distance * (90 - fov < self.scene.camera.yaw < 90 + fov) - 1
+
         return (render_range_x, render_range_y, render_range_z)

basilisk/render/frame.py

@@ -1,182 +1,99 @@
-import numpy as np
-import moderngl as mgl
-from PIL import Image
-
-
-class Frame:
-    program: mgl.Program=None
-    vbo: mgl.Buffer=None
-    vao: mgl.VertexArray=None
-    frame_texture: mgl.Texture=None
-    depth_texture: mgl.Texture=None
-    framebuffer: mgl.Framebuffer=None
-    pingpong_frame_texture: mgl.Texture=None
-    pingpong_depth_texture: mgl.Texture=None
-    pingpong_framebuffer: mgl.Framebuffer=None
-    postprocess: dict=None
-
-    def __init__(self, scene) -> 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
-
-        
-        self.load_program()
-        self.set_textures()
-        self.set_renderer()
-
-        self.postprocess = {}
-        self.load_post_shader('frame', 'filter')
-
-    def render(self):
-        """
-        Renders the current frame to the screen
-        """
-
-        # self.apply_postprocess('filter')
-        
-        self.ctx.screen.use()
-        self.program['screenTexture'] = 0
-        self.framebuffer.color_attachments[0].use(location=0)
-        self.vao.render()
-
-    def use(self):
-        """
-        Uses the frame as a render target
-        """
-        
-        self.framebuffer.use()
-        self.framebuffer.clear()
-
-    def save(self, destination: str=None):
-        """
-        Saves the frame as an image to the given file destination
-        """
-
-        path = destination if destination else 'screenshot'
-
-        data = self.framebuffer.read(components=3, alignment=1)
-        img = Image.frombytes('RGB', self.framebuffer.size, data).transpose(Image.FLIP_TOP_BOTTOM)
-        img.save(f'{path}.png')
-
-
-    def load_program(self) -> None:
-        """
-        Loads the frame shaders
-        """
-
-        # Release any existing memory
-        if self.program: self.program.release()
-        
-        # Read the shaders
-        with open(self.engine.root + '/shaders/frame.vert') as file:
-            vertex_shader = file.read()
-        with open(self.engine.root + '/shaders/frame.frag') as file:
-            fragment_shader = file.read()
-
-        # Create the program
-        self.program = self.ctx.program(vertex_shader=vertex_shader, fragment_shader=fragment_shader)
-
-    def load_post_shader(self, vert: str, frag: str) -> None:
-        """
-        Loads a post processing shader
-        """
-
-        # Read the shaders
-        with open(self.engine.root + f'/shaders/{vert}.vert') as file:
-            vertex_shader = file.read()
-        with open(self.engine.root + f'/shaders/{frag}.frag') as file:
-            fragment_shader = file.read()
-
-        # Create the program
-        program = self.ctx.program(vertex_shader=vertex_shader, fragment_shader=fragment_shader)
-        self.postprocess[frag] = self.ctx.vertex_array(program, [(self.vbo, '3f 2f', 'in_position', 'in_uv')], skip_errors=True)
-
-    def apply_postprocess(self, shader: str):
-        self.pingpong_framebuffer.use()
-        self.pingpong_framebuffer.clear()
-        self.postprocess[shader].program['screenTexture'] = 0
-        self.framebuffer.color_attachments[0].use(location=0)
-        self.postprocess[shader].render()
-        
-
-        temp = self.framebuffer
-        self.framebuffer = self.pingpong_framebuffer
-        self.pingpong_framebuffer = temp
-
-        # self.use()
-        # self.postprocess[shader].program['screenTexture'] = 0
-        # self.pingpong_frame_texture.use(location=0)
-        # self.vao.render()
-
-        
-    def set_textures(self, viewport: tuple=None) -> None:
-        """
-        Sets the framebuffer textures
-        """
-
-        # Release any existing memory in case of a resize
-        if self.frame_texture: self.frame_texture.release()
-        if self.depth_texture: self.depth_texture.release()
-        if self.framebuffer:   self.framebuffer.release()
-        if self.pingpong_frame_texture: self.pingpong_frame_texture.release()
-        if self.pingpong_depth_texture: self.pingpong_depth_texture.release()
-        if self.pingpong_framebuffer:   self.pingpong_framebuffer.release()
-
-        # Get the size from the engine window if the not specified by the function call
-        size = viewport if viewport else self.engine.win_size
-
-        # Create textures and frame buffer object
-        self.frame_texture = self.ctx.texture(size, components=4)
-        self.depth_texture = self.ctx.depth_texture(size)
-        self.framebuffer   = self.ctx.framebuffer([self.frame_texture], self.depth_texture)
-        self.pingpong_frame_texture = self.ctx.texture(size, components=4)
-        self.pingpong_depth_texture = self.ctx.depth_texture(size)
-        self.pingpong_framebuffer   = self.ctx.framebuffer([self.pingpong_frame_texture], self.pingpong_depth_texture)
-
-    def set_renderer(self) -> None:
-        """
-        Sets the vertex data and vao for the frame
-        """
-        
-        # Release any existing memory
-        if self.vbo: self.vbo.release()
-        if self.vao: self.vao.release()
-
-        # Vertex and index info for the frame
-        verticies = [[-1, -1, 0], [ 1, -1, 0], [ 1, 1, 0], [-1, 1, 0]]
-        indicies  = [(3, 0, 1), (2, 3, 1)]
-        uv_verticies = [(0, 0), (1, 0), (1, 1), (0, 1)]
-        uv_indicies  = [(3, 0, 1),(2, 3, 1)]
-        
-        # Format the data
-        vertex_data = [verticies[ind] for triangle in indicies for ind in triangle]
-        vertex_data = np.array(vertex_data, dtype='f4')
-        uv_data     = [uv_verticies[ind] for triangle in uv_indicies for ind in triangle]
-        uv_data     = np.array(uv_data, dtype='f4')
-
-        vertex_data = np.hstack([vertex_data, uv_data])
-
-        # Create moderngl objects
-        self.vbo = self.ctx.buffer(vertex_data)
-        self.vao = self.ctx.vertex_array(self.program, [(self.vbo, '3f 2f', 'in_position', 'in_uv')], skip_errors=True)
-        
-    def __del__(self) -> None:
-        """
-        Releases memory used by the frame
-        """
-        
-        if self.program:       self.program.release()
-        if self.vbo:           self.vbo.release()
-        if self.vao:           self.vao.release()
-        if self.frame_texture: self.frame_texture.release()
-        if self.depth_texture: self.depth_texture.release()
-        if self.framebuffer:   self.framebuffer.release()
-        if self.pingpong_frame_texture: self.frame_texture.release()
-        if self.pingpong_depth_texture: self.depth_texture.release()
-        if self.pingpong_framebuffer:   self.framebuffer.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, 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:
+            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.framebuffer.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 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()