basilisk-engine 0.1.19__py3-none-any.whl → 0.1.20__py3-none-any.whl

basilisk/render/camera.py

@@ -1,222 +1,222 @@
-import pygame as pg
-import glm
-import numpy as np
-from ..generic.vec3 import Vec3
-from ..generic.quat import Quat
-
-
-# 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
-        # fov
-        self.fov = 50
-        # 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(self.fov), self.aspect_ratio, NEAR, FAR)
-    
-    def get_params(self) -> tuple:
-        return self.engine, self.position, self.yaw, self.pitch
-    
-    def look_at(self, other) -> None:
-        forward = glm.normalize(other.position - self.position)
-        self.yaw = np.degrees(np.arctan2(forward.z, forward.x))
-        self.pitch = np.degrees(np.arctan2(forward.y, np.sqrt(forward.x ** 2 + forward.z ** 2)))
-
-    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
-    @property
-    def horizontal(self): return glm.normalize(self.forward.xz)
-    @property
-    def rotation(self): return glm.conjugate(glm.quatLookAt(self.forward, self.UP))
-    @property
-    def fov(self): return self._fov
-
-    @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 | Vec3):
-        if isinstance(value, glm.vec3): self._position = glm.vec3(value)
-        elif isinstance(value, Vec3): self._position = glm.vec3(value.data)
-        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 | Vec3):
-        if isinstance(value, glm.vec3): self.forward = glm.normalize(glm.vec3(value))
-        elif isinstance(value, Vec3): self.forward = glm.normalize(value.data)
-        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)}')
-        
-    @fov.setter
-    def fov(self, value):
-        self._fov = value
-        if self.engine: self.use()
-
-
-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.keys[pg.K_CAPSLOCK] * 10) * 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 FollowCamera(FreeCamera):
-    def __init__(self, parent, position=(0, 0, 20), yaw=-90, pitch=0, offset=(0, 0, 0)):
-        super().__init__(position, yaw, pitch)
-        self.parent = parent
-        self.offest = glm.vec3(offset)
-    
-    def move(self) -> None:
-        """
-        Moves the camera to the parent node
-        """
-
-        self.position = self.parent.position + self.offest
-        
-class OrbitCamera(FreeCamera):
-    def __init__(self, parent, position=(0, 0, 20), yaw=-90, pitch=0, distance=5, offset=(0, 0)):
-        self.parent = parent
-        self.distance = distance
-        self.offset = glm.vec2(offset)
-        super().__init__(position, yaw, pitch)
-
-    def get_view_matrix(self) -> glm.mat4x4:
-        return glm.lookAt(self.position, self.parent.position, self.up)
-
-    def move(self) -> None:
-        """
-        Moves the camera to the parent node
-        """
-
-        self.position = self.parent.position - glm.normalize(self.forward) * self.distance
-
-class StaticCamera(Camera):
-    def __init__(self, position=(0, 0, 20), yaw=-90, pitch=0):
+import pygame as pg
+import glm
+import numpy as np
+from ..generic.vec3 import Vec3
+from ..generic.quat import Quat
+
+
+# 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
+        # fov
+        self.fov = 50
+        # 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(self.fov), self.aspect_ratio, NEAR, FAR)
+    
+    def get_params(self) -> tuple:
+        return self.engine, self.position, self.yaw, self.pitch
+    
+    def look_at(self, other) -> None:
+        forward = glm.normalize(other.position - self.position)
+        self.yaw = np.degrees(np.arctan2(forward.z, forward.x))
+        self.pitch = np.degrees(np.arctan2(forward.y, np.sqrt(forward.x ** 2 + forward.z ** 2)))
+
+    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
+    @property
+    def horizontal(self): return glm.normalize(self.forward.xz)
+    @property
+    def rotation(self): return glm.conjugate(glm.quatLookAt(self.forward, self.UP))
+    @property
+    def fov(self): return self._fov
+
+    @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 | Vec3):
+        if isinstance(value, glm.vec3): self._position = glm.vec3(value)
+        elif isinstance(value, Vec3): self._position = glm.vec3(value.data)
+        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 | Vec3):
+        if isinstance(value, glm.vec3): self.forward = glm.normalize(glm.vec3(value))
+        elif isinstance(value, Vec3): self.forward = glm.normalize(value.data)
+        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)}')
+        
+    @fov.setter
+    def fov(self, value):
+        self._fov = value
+        if self.engine: self.use()
+
+
+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.keys[pg.K_CAPSLOCK] * 10) * 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 FollowCamera(FreeCamera):
+    def __init__(self, parent, position=(0, 0, 20), yaw=-90, pitch=0, offset=(0, 0, 0)):
+        super().__init__(position, yaw, pitch)
+        self.parent = parent
+        self.offest = glm.vec3(offset)
+    
+    def move(self) -> None:
+        """
+        Moves the camera to the parent node
+        """
+
+        self.position = self.parent.position + self.offest
+        
+class OrbitCamera(FreeCamera):
+    def __init__(self, parent, position=(0, 0, 20), yaw=-90, pitch=0, distance=5, offset=(0, 0)):
+        self.parent = parent
+        self.distance = distance
+        self.offset = glm.vec2(offset)
+        super().__init__(position, yaw, pitch)
+
+    def get_view_matrix(self) -> glm.mat4x4:
+        return glm.lookAt(self.position, self.parent.position, self.up)
+
+    def move(self) -> None:
+        """
+        Moves the camera to the parent node
+        """
+
+        self.position = self.parent.position - glm.normalize(self.forward) * self.distance
+
+class StaticCamera(Camera):
+    def __init__(self, position=(0, 0, 20), yaw=-90, pitch=0):
         super().__init__(position, yaw, pitch)

basilisk/render/chunk.py

@@ -1,107 +1,107 @@
-from .batch import Batch
-
-
-class Chunk():
-    chunk_handler: ...
-    """Back refrence to the parent chunk handler"""
-    position: 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, position: tuple, static: bool, shader=None) -> 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
-
-        # Chunk Attrbiutes
-        self.position = position
-        self.static = static
-        self.shader = shader
-
-        # 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
-        """
-
-        if node == None: return
-
-        self.nodes.remove(node)
-        if self.batch and self.batch.vbo: self.batch.vbo.clear()
-
-        return node
-
-    def get_program(self):
-        """
-        Gets the program of the chunks nodes' shader
-        """
-
-        shader = self.shader
-
-        if shader: return shader.program
-        return self.chunk_handler.engine.shader.program
-
-    def swap_shader(self, shader):
-        """
-        Swaps the batches shader to the given shader
-        """
-        
-        self.batch.swap_shader(shader)
-
-    def __repr__(self) -> str:
-        return f'<Basilisk Chunk | {self.position}, {len(self.nodes)} nodes, {"static" if self.static else "dynamic"}>'
-
-    def __del__(self) -> None:
-        """
-        Deletes the batch if this chunk is deleted
-        """
-        
+from .batch import Batch
+
+
+class Chunk():
+    chunk_handler: ...
+    """Back refrence to the parent chunk handler"""
+    position: 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, position: tuple, static: bool, shader=None) -> 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
+
+        # Chunk Attrbiutes
+        self.position = position
+        self.static = static
+        self.shader = shader
+
+        # 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
+        """
+
+        if node == None: return
+
+        self.nodes.remove(node)
+        if self.batch and self.batch.vbo: self.batch.vbo.clear()
+
+        return node
+
+    def get_program(self):
+        """
+        Gets the program of the chunks nodes' shader
+        """
+
+        shader = self.shader
+
+        if shader: return shader.program
+        return self.chunk_handler.engine.shader.program
+
+    def swap_shader(self, shader):
+        """
+        Swaps the batches shader to the given shader
+        """
+        
+        self.batch.swap_shader(shader)
+
+    def __repr__(self) -> str:
+        return f'<Basilisk Chunk | {self.position}, {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