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

basilisk/nodes/node.py

@@ -97,9 +97,10 @@ class Node():
         
         # parents
         self.node_handler = None
-        self.scene = None
-        self.chunk = None
-        self.parent = None
+        self.scene        = None
+        self.engine       = None
+        self.chunk        = None
+        self.parent       = None
         
         # lazy update variables
         self.needs_geometric_center = True # pos
@@ -194,18 +195,19 @@ class Node():
         self.internal_scale.callback    = scale_callback
         self.internal_rotation.callback = rotation_callback
     
-    def init_scene(self, scene):
+    def init_scene(self, scene: ...) -> None:
         """
         Updates the scene of the node
         """
         self.scene = scene
+        self.engine = scene.engine
         self.node_handler = scene.node_handler
 
         # Update materials
         self.write_materials()
 
         # Update the mesh
-        self.mesh = self.mesh if self.mesh else self.scene.engine.cube
+        self.mesh = self.mesh if self.mesh else self.engine.cube
 
         # Update physics and collider
         if self.physics_body: self.physics_body.physics_engine = scene.physics_engine
@@ -387,14 +389,14 @@ class Node():
         if isinstance(self.material, list):
             mtl_index_list = []
             for mtl in self._mtl_list:
-                self.node_handler.scene.material_handler.add(mtl)
+                self.engine.material_handler.add(mtl)
                 mtl_index_list.append(mtl.index)
                 mtl_index_list.append(mtl.index)
                 mtl_index_list.append(mtl.index)
             self._material = mtl_index_list
 
         if isinstance(self.material, type(None)):
-            self.material = self.scene.material_handler.base
+            self.material = self.engine.material_handler.base
         
 
     def __repr__(self) -> str:
@@ -555,16 +557,16 @@ class Node():
             else:
                 mtl_index_list = []
                 for mtl in self._mtl_list:
-                    self.node_handler.scene.material_handler.add(mtl)
+                    self.engine.material_handler.add(mtl)
                     mtl_index_list.append(mtl.index)
                     mtl_index_list.append(mtl.index)
                     mtl_index_list.append(mtl.index)
                 self._material = mtl_index_list
         elif isinstance(value, Material): 
             self._material = value
-            if self.node_handler: self.node_handler.scene.material_handler.add(value)
+            if self.node_handler: self.engine.material_handler.add(value)
         elif isinstance(value, type(None)):
-            if self.scene: self._material = self.scene.material_handler.base
+            if self.engine: self._material = self.engine.material_handler.base
             else: self._material = None
 
         else: raise TypeError(f'Node: Invalid material value type {type(value)}')

basilisk/nodes/node_handler.py

@@ -19,6 +19,7 @@ class NodeHandler():
         """
         
         self.scene = scene
+        self.engine = scene.engine
         self.nodes = []
         self.chunk_handler = ChunkHandler(scene)
 
@@ -49,9 +50,9 @@ class NodeHandler():
         for n in node.get_all(): # gets all nodes including the node to be added
             
             # Update scene Handlers
-            self.scene.shader_handler.add(n.shader)
-            if not n.material: n.material = self.scene.material_handler.base
-            self.scene.material_handler.add(n.material)
+            self.engine.shader_handler.add(n.shader)
+            if not n.material: n.material = self.engine.material_handler.base
+            self.engine.material_handler.add(n.material)
             
             # Update the node attributes
             n.init_scene(self.scene)

basilisk/particles/particle_handler.py

@@ -43,7 +43,7 @@ class ParticleHandler:
         # Get material ID
         if material == None: material_index = 0
         elif isinstance(material, Material): 
-            self.scene.material_handler.add(material)
+            self.scene.engine.material_handler.add(material)
             material_index = material.index
         else: raise ValueError(f'particle_handler.add: Invalid particle material type: {type(material)}')
 

basilisk/particles/particle_renderer.py

@@ -31,7 +31,7 @@ class ParticleRenderer:
         root = scene.engine.root
         if shader: self.shader = shader
         else: self.shader = Shader(scene.engine, vert=root + '/shaders/particle.vert', frag=root + '/shaders/particle.frag')
-        scene.shader_handler.add(self.shader)
+        scene.engine.shader_handler.add(self.shader)
 
         self.particle_cube_size = 25
 

basilisk/render/camera.py

@@ -12,7 +12,7 @@ FAR = 350
 
 # Camera movement constants
 SPEED = 10
-SENSITIVITY = 0.15
+SENSITIVITY = 0.15/180
 
 class Camera:
     engine: ...
@@ -24,7 +24,7 @@ class Camera:
     position: glm.vec3
     """Location of the camera (maters)"""
 
-    def __init__(self, position=(0, 0, 20), yaw=-90, pitch=0) -> None:
+    def __init__(self, position=(0, 0, 20), rotation=(1, 0, 0, 0)) -> None:
         """
         Camera object to get view and projection matricies. Movement built in
         """
@@ -32,21 +32,13 @@ class Camera:
         # Back references
         self.scene  = None
         self.engine = None
+        # transformations
+        self.rotation = glm.quat(rotation)
+        self.position = glm.vec3(position)
         # 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
@@ -57,23 +49,9 @@ class Camera:
         Updates the camera view matrix
         """
         
-        self.update_camera_vectors()
+        # 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]
@@ -104,11 +82,28 @@ class Camera:
     @property
     def position(self): return self._position
     @property
-    def direction(self): return self.forward
+    def rotation(self) -> glm.quat: return self._rotation
+    @property
+    def direction(self): return self.rotation * (0, 0, -1)
+    @property
+    def forward(self): return self.rotation * (0, 0, -1)
+    @property
+    def pitch(self): return glm.pitch(self.rotation)
+    @property
+    def yaw(self): return glm.yaw(self.rotation)
+    @property
+    def roll(self): return glm.roll(self.rotation)
     @property
-    def horizontal(self): return glm.normalize(self.forward.xz)
+    def UP(self): 
+        up = (self.rotation.x, self.rotation.y, self.rotation.z)
+        up = (0, 1, 0) # TODO ensure that this works with all up vectors
+        return glm.normalize(up) if glm.length2(up) > 1e-7 else glm.vec3(0, 1, 0)
     @property
-    def rotation(self): return glm.conjugate(glm.quatLookAt(self.forward, self.UP))
+    def right(self): return glm.normalize(glm.cross(self.forward, self.UP))
+    @property
+    def up(self): return glm.normalize(glm.cross(self.right, self.forward))
+    @property
+    def horizontal(self): return glm.normalize(glm.cross(self.UP, self.right))
     @property
     def fov(self): return self._fov
 
@@ -128,15 +123,48 @@ class Camera:
             self._position = glm.vec3(value)
         else: raise TypeError(f'Camera: Invalid position value type {type(value)}')
         
+    @rotation.setter
+    def rotation(self, value):
+        if isinstance(value, (glm.vec3, glm.quat)): self._rotation = glm.quat(value)
+        elif isinstance(value, (Vec3, Quat)): self._rotation = glm.quat(value.data)
+        elif isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
+            if not (2 < len(value) < 5): raise ValueError(f'Camera: Invalid number of values for rotation. Expected 3 or 4, got {len(value)}')
+            self._position = glm.quat(value)
+        else:
+            try:
+                self._rotation = glm.quat(value)
+            except:
+                raise TypeError(f'Camera: Invalid rotation 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))
+        if isinstance(value, glm.vec3): self.forward = glm.normalize(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))
+            self.forward = glm.normalize(value)
         else: raise TypeError(f'Camera: Invalid direction value type {type(value)}')
         
+    @forward.setter
+    def forward(self, value):
+        self._rotation = glm.quatLookAt(value, self.UP)
+        
+    @pitch.setter
+    def pitch(self, value):
+        self._rotation = glm.quat((value, self.yaw, self.roll))
+    
+    @yaw.setter
+    def yaw(self, value):
+        self._rotation = glm.quat((self.pitch, value, self.roll))
+    
+    @roll.setter
+    def roll(self, value):
+        self._rotation = glm.quat((self.pitch, self.yaw, value))
+    
+    @UP.setter
+    def UP(self, value):
+        self._rotation = glm.quatLookAt(self.forward, value)
+        
     @fov.setter
     def fov(self, value):
         self._fov = value
@@ -144,8 +172,8 @@ class Camera:
 
 
 class FreeCamera(Camera):
-    def __init__(self, position=(0, 0, 20), yaw=-90, pitch=0):
-        super().__init__(position, yaw, pitch)
+    def __init__(self, position=(0, 0, 20), rotation=(1, 0, 0, 0)):
+        super().__init__(position, rotation)
 
     def update(self) -> None:
         """
@@ -154,18 +182,22 @@ class FreeCamera(Camera):
         
         self.move()
         self.rotate()
-        self.update_camera_vectors()
+        # 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))
+        rel_x, rel_y = self.engine.mouse.relative
+        
+        yaw_rotation = glm.angleAxis(SENSITIVITY * rel_x, -self.UP)
+        pitch_rotation = glm.angleAxis(SENSITIVITY * rel_y, -self.right)
+        new_rotation = yaw_rotation * pitch_rotation * self.rotation
+        
+        v_new = new_rotation * self.UP
+        pitch_angle = glm.degrees(glm.acos(glm.clamp(glm.dot(v_new, self.UP), -1.0, 1.0)))
+        self.rotation = new_rotation if pitch_angle < 89 else yaw_rotation * self.rotation
 
     def move(self) -> None:
         """
@@ -185,11 +217,16 @@ class FreeCamera(Camera):
             self.position += self.UP * velocity
         if keys[pg.K_LSHIFT]:
             self.position -= self.UP * velocity
+            
+class FixedCamera(FreeCamera):
+    def __init__(self, position=(0, 0, 20), rotation=(1, 0, 0, 0)):
+        super().__init__(position, rotation)
 
+    def move(self): pass
 
 class FollowCamera(FreeCamera):
-    def __init__(self, parent, position=(0, 0, 20), yaw=-90, pitch=0, offset=(0, 0, 0)):
-        super().__init__(position, yaw, pitch)
+    def __init__(self, parent, position=(0, 0, 20), rotation=(1, 0, 0, 0), offset=(0, 0, 0)):
+        super().__init__(position, rotation)
         self.parent = parent
         self.offest = glm.vec3(offset)
     
@@ -201,11 +238,11 @@ class FollowCamera(FreeCamera):
         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)):
+    def __init__(self, parent, position=(0, 0, 20), rotation=(1, 0, 0, 0), distance=5, offset=(0, 0)):
         self.parent = parent
         self.distance = distance
         self.offset = glm.vec2(offset)
-        super().__init__(position, yaw, pitch)
+        super().__init__(position, rotation)
 
     def get_view_matrix(self) -> glm.mat4x4:
         return glm.lookAt(self.position, self.parent.position, self.up)
@@ -214,9 +251,8 @@ class OrbitCamera(FreeCamera):
         """
         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)
+    def __init__(self, position=(0, 0, 20), rotation=(1, 0, 0, 0)):
+        super().__init__(position, rotation)

basilisk/render/frame.py

@@ -11,26 +11,22 @@ class Frame:
     vao: mgl.VertexArray=None
     framebuffer: mgl.Framebuffer=None
 
-    def __init__(self, scene, resolution=1, filter=(mgl.LINEAR, mgl.LINEAR)) -> None:
+    def __init__(self, engine, scale: float=1.0, linear_filter: bool=False) -> 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.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)
+        self.framebuffer = Framebuffer(self.engine, scale=scale, linear_filter=linear_filter)
+        self.ping_pong_buffer = Framebuffer(self.engine, scale=scale, linear_filter=linear_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)
+        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'))
@@ -64,7 +60,6 @@ class Frame:
         """
         
         self.framebuffer.use()
-        self.clear()
 
     def add_post_process(self, post_process: PostProcess) -> PostProcess:
         """
@@ -89,9 +84,8 @@ class Frame:
         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)
+        self.framebuffer.resize()
+        self.ping_pong_buffer.resize()
 
     def __del__(self) -> None:
         """