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

basilisk/render/batch.py

@@ -0,0 +1,85 @@
+import numpy as np
+import moderngl as mgl
+
+
+class Batch():
+    chunk: ...
+    """Reference to the parent chunk of the batch"""
+    ctx: mgl.Context
+    """Reference to the context of the parent engine"""
+    program: mgl.Program
+    """Reference to the program used by batches"""
+    vao: mgl.VertexArray
+    """The vertex array of the batch. Used for rendering"""
+    vbo: mgl.Buffer
+    """Buffer containing all the batch data"""
+
+    def __init__(self, chunk) -> None:
+        """
+        Basilik batch object
+        Contains all the data for a chunk batch to be stored and rendered
+        """
+        
+        # Back references
+        self.chunk = chunk
+        self.ctx = chunk.chunk_handler.engine.ctx
+        self.program = chunk.chunk_handler.program
+
+        # Set intial values
+        self.vbo = None
+        self.vao = None
+
+    def batch(self) -> bool:
+        """
+        Batches all the node meshes in the chunks bounds.
+        Returns True if batch was successful.
+        """
+
+        # Empty list to contain all vertex data of models in the chunk
+        batch_data = []
+
+        # Loop through each node in the chunk, adding the nodes's mesh to batch_data
+        index = 0
+        for node in self.chunk.nodes:
+            # Check that the node should be used
+            if not node.mesh: continue
+            if node.static != self.chunk.static: continue
+
+            # Get the data from the node
+            node_data = node.get_data()
+            # Update the index
+            node.data_index = index
+            index += len(node_data)
+            # Add to the chunk mesh
+            batch_data.append(node_data)
+
+        # Combine all meshes into a single array
+        if len(batch_data) > 1: batch_data = np.vstack(batch_data)
+        else: batch_data = np.array(batch_data, dtype='f4')
+
+
+        # If there are no verticies, delete the chunk
+        if len(batch_data) == 0: return False
+
+        if self.vbo: self.vbo.release()
+        if self.vao: self.vao.release()
+
+        # Create the vbo and the vao from mesh data
+        self.vbo = self.ctx.buffer(batch_data)
+        self.vao = self.ctx.vertex_array(self.program, [(self.vbo, 
+                                                         '3f 2f 3f 3f 3f 3f 4f 3f 1f', 
+                                                         *['in_position', 'in_uv', 'in_normal', 'in_tangent', 'in_bitangent', 'obj_position', 'obj_rotation', 'obj_scale', 'obj_material'])], 
+                                                         skip_errors=True)
+        
+        return True
+
+    def __repr__(self) -> str:
+        return f'<Basilisk Batch | {self.chunk.chunk_key}, {self.vbo.size / 1024  / 1024} mb>'
+
+    def __del__(self) -> None:
+        """
+        Deallocates the mesh vbo and vao
+        """
+        
+        if self.vbo: self.vbo.release()
+        if self.vao: self.vao.release()

basilisk/render/camera.py

@@ -0,0 +1,166 @@
+import pygame as pg
+import glm
+import numpy as np
+
+# Camera view constants
+FOV = 50  # Degrees
+NEAR = 0.1
+FAR = 350
+
+# Camera movement constants
+SPEED = 10
+SENSITIVITY = 0.15
+
+class Camera:
+    engine: ...
+    """Back reference to the parent engine"""
+    scene: ...
+    """Back reference to the parent scene"""
+    aspect_ratio: float
+    """Aspect ratio of the engine window"""
+    position: glm.vec3
+    """Location of the camera (maters)"""
+
+    def __init__(self, position=(0, 0, 20), yaw=-90, pitch=0) -> None:
+        """
+        Camera object to get view and projection matricies. Movement built in
+        """
+        # Back references
+        self.scene  = None
+        self.engine = None
+        # The initial aspect ratio of the screen
+        self.aspect_ratio = 1.0
+        # Position
+        self.position = glm.vec3(position)
+        # k vector for vertical movement
+        self.UP = glm.vec3(0, 1, 0)
+        # Movement vectors
+        self.up = glm.vec3(0, 1, 0)
+        self.right = glm.vec3(1, 0, 0)
+        self.forward = glm.vec3(0, 0, -1)
+        # Look directions in degrees
+        self.yaw = yaw
+        self.pitch = pitch
+        # View matrix
+        self.m_view = self.get_view_matrix()
+        # Projection matrix
+        self.m_proj = self.get_projection_matrix()
+
+    def update(self) -> None:
+        """
+        Updates the camera view matrix
+        """
+        
+        self.update_camera_vectors()
+        self.m_view = self.get_view_matrix()
+
+    def update_camera_vectors(self) -> None:
+        """
+        Computes the forward vector based on the pitch and yaw. Computes horizontal and vertical vectors with cross product.
+        """
+        yaw, pitch = glm.radians(self.yaw), glm.radians(self.pitch)
+
+        self.forward.x = glm.cos(yaw) * glm.cos(pitch)
+        self.forward.y = glm.sin(pitch)
+        self.forward.z = glm.sin(yaw) * glm.cos(pitch)
+
+        self.forward = glm.normalize(self.forward)
+        self.right = glm.normalize(glm.cross(self.forward, self.UP))
+        self.up = glm.normalize(glm.cross(self.right, self.forward))
+
+    def use(self):
+        # Updated aspect ratio of the screen
+        self.aspect_ratio = self.engine.win_size[0] / self.engine.win_size[1]
+        # View matrix
+        self.m_view = self.get_view_matrix()
+        # Projection matrix
+        self.m_proj = self.get_projection_matrix()
+
+    def get_view_matrix(self) -> glm.mat4x4:
+        return glm.lookAt(self.position, self.position + self.forward, self.up)
+
+    def get_projection_matrix(self) -> glm.mat4x4:
+        return glm.perspective(glm.radians(FOV), self.aspect_ratio, NEAR, FAR)
+    
+    def get_params(self) -> tuple:
+        return self.engine, self.position, self.yaw, self.pitch
+    
+    def __repr__(self):
+        return f'<Basilisk Camera | Position: {self.position}, Direction: {self.forward}>'
+
+    @property
+    def scene(self): return self._scene
+    @property
+    def position(self): return self._position
+    @property
+    def direction(self): return self.forward
+
+    @scene.setter
+    def scene(self, value):
+        if value == None: return
+        self._scene = value
+        self.engine = self._scene.engine
+        self.use()
+    @position.setter
+    def position(self, value: tuple | list | glm.vec3 | np.ndarray):
+        if isinstance(value, glm.vec3): self._position = glm.vec3(value)
+        elif isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
+            if len(value) != 3: raise ValueError(f'Camera: Invalid number of values for position. Expected 3, got {len(value)}')
+            self._position = glm.vec3(value)
+        else: raise TypeError(f'Camera: Invalid position value type {type(value)}')
+    @direction.setter
+    def direction(self, value: tuple | list | glm.vec3 | np.ndarray):
+        if isinstance(value, glm.vec3): self.direction = glm.normalize(glm.vec3(value))
+        elif isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
+            if len(value) != 3: raise ValueError(f'Camera: Invalid number of values for direction. Expected 3, got {len(value)}')
+            self.forward = glm.normalize(glm.vec3(value))
+        else: raise TypeError(f'Camera: Invalid direction value type {type(value)}')
+
+
+class FreeCamera(Camera):
+    def __init__(self, position=(0, 0, 20), yaw=-90, pitch=0):
+        super().__init__(position, yaw, pitch)
+
+    def update(self) -> None:
+        """
+        Updates the camera position and rotaiton based on user input
+        """
+        
+        self.move()
+        self.rotate()
+        self.update_camera_vectors()
+        self.m_view = self.get_view_matrix()
+
+    def rotate(self) -> None:
+        """
+        Rotates the camera based on the amount of mouse movement.
+        """
+        rel_x, rel_y = pg.mouse.get_rel()
+        self.yaw += rel_x * SENSITIVITY
+        self.pitch -= rel_y * SENSITIVITY
+        self.yaw = self.yaw % 360
+        self.pitch = max(-89, min(89, self.pitch))
+
+    def move(self) -> None:
+        """
+        Checks for button presses and updates vectors accordingly. 
+        """
+        velocity = SPEED * self.engine.delta_time
+        keys = self.engine.keys
+        if keys[pg.K_w]:
+            self.position += glm.normalize(glm.vec3(self.forward.x, 0, self.forward.z)) * velocity
+        if keys[pg.K_s]:
+            self.position -= glm.normalize(glm.vec3(self.forward.x, 0, self.forward.z)) * velocity
+        if keys[pg.K_a]:
+            self.position -= self.right * velocity
+        if keys[pg.K_d]:
+            self.position += self.right * velocity
+        if keys[pg.K_SPACE]:
+            self.position += self.UP * velocity
+        if keys[pg.K_LSHIFT]:
+            self.position -= self.UP * velocity
+
+
+class StaticCamera(Camera):
+    def __init__(self, position=(0, 0, 20), yaw=-90, pitch=0):
+        super().__init__(position, yaw, pitch)

basilisk/render/chunk.py

@@ -0,0 +1,85 @@
+from .batch import Batch
+
+
+class Chunk():
+    chunk_handler: ...
+    """Back refrence to the parent chunk handler"""
+    chunk_key: tuple
+    """The position of the chunk. Used as a key in the chunk handler"""
+    batch: Batch
+    """Batched mesh of the chunk"""
+    nodes: set
+    """Set conaining references to all nodes in the chunk"""
+    static: bool
+    """Type of node that the chunk recognizes"""
+
+    def __init__(self, chunk_handler, chunk_key: tuple, static: bool) -> None:
+        """
+        Basilisk chunk object. 
+        Contains references to all nodes in the chunk.
+        Handles batching for its own nodes
+        """
+
+        # Back references
+        self.chunk_handler = chunk_handler
+        self.chunk_key = chunk_key
+
+        self.static = static
+
+        # Create empty batch
+        self.batch = Batch(self)
+
+        # Create empty set for chunk's nodes
+        self.nodes = set()
+
+    def render(self) -> None:
+        """
+        Renders the chunk mesh
+        """
+
+        if self.batch.vao: self.batch.vao.render()
+
+    def update(self) -> bool:
+        """
+        Batches all the node meshes in the chunk        
+        """
+
+        # Check if there are no nodes in the chunk
+        if not self.nodes: return False
+        # Batch the chunk nodes, return success bit
+        return self.batch.batch()
+
+    def node_update_callback(self, node):
+        if not self.batch.vbo: return
+        
+        data = node.get_data()
+        self.batch.vbo.write(data, node.data_index * 25 * 4)
+
+    def add(self, node):
+        """
+        Adds an existing node to the chunk. Updates the node's chunk reference
+        """
+
+        self.nodes.add(node)
+        node.chunk = self
+
+        return node
+
+    def remove(self, node):
+        """
+        Removes a node from the chunk
+        """
+
+        self.nodes.remove(node)
+
+        return node
+
+    def __repr__(self) -> str:
+        return f'<Basilisk Chunk | {self.chunk_key}, {len(self.nodes)} nodes, {'static' if self.static else 'dynamic'}>'
+
+    def __del__(self) -> None:
+        """
+        Deletes the batch if this chunk is deleted
+        """
+        
+        del self.batch

basilisk/render/chunk_handler.py

@@ -0,0 +1,139 @@
+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: list[set]
+    """List containing two dictionaries for recently updated dynamic and static chunks repsectivly"""
+    
+    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.shader_handler.programs['batch']
+
+        # List for the dynamic and static chunk dictionaries | [dyanmic: dict, static: dict]
+        self.chunks         = [{}   , {}   ]
+        self.updated_chunks = [set(), 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 chunk in chunk_keys:
+            # Render the chunk if it exists
+            if chunk in self.chunks[0]: self.chunks[0][chunk].render()
+            if chunk in self.chunks[1]: self.chunks[1][chunk].render()
+
+
+    def update(self) -> None:           
+        """
+        Updates all the chunks that have been updated since the last frame. 
+        """ 
+
+        # Loop through the set of updated chunk keys and update the chunk
+        removes = []
+
+        for chunk in self.updated_chunks[0]: 
+            if chunk.update(): continue
+            removes.append((0, chunk))
+        for chunk in self.updated_chunks[1]: 
+            if chunk.update(): continue
+            removes.append((1, chunk))
+
+        # Remove any empty chunks
+        for chunk_tuple in removes:
+            if chunk_tuple[1] not in self.chunks[chunk_tuple[0]]: continue
+            del self.chunks[chunk_tuple[0]][chunk_tuple[1]]
+
+        # Clears the set of updated chunks so that they are not updated unless they are updated again
+        self.updated_chunks = [set(), set()]
+
+    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))
+
+        # Ensure that the chunk exists
+        if chunk_key not in self.chunks[node.static]:
+            self.chunks[node.static][chunk_key] = Chunk(self, chunk_key, node.static)
+
+        # Add the node to the chunk
+        self.chunks[node.static][chunk_key].add(node)
+
+        # Update the chunk
+        self.updated_chunks[node.static].add(self.chunks[node.static][chunk_key])
+
+        return Node
+
+    def remove(self, node) -> None:
+        """
+        Removes a node from the its chunk
+        """
+
+        # 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

@@ -0,0 +1,182 @@
+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(f'basilisk/shaders/{vert}.vert') as file:
+            vertex_shader = file.read()
+        with open(f'basilisk/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()