basilisk-engine 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

basilisk/physics/physics_body.py

@@ -6,8 +6,8 @@ class PhysicsBody():
     mass: float
     """The mass of the physics body in kg"""
 
-    def __init__(self, physics_engine, mass:float=1.0) -> None:
-        self.physics_engine = physics_engine
+    def __init__(self, mass:float=1.0) -> None:
+        self.physics_engine = None
         self.mass = mass 
         
     def get_delta_velocity(self, dt: float) -> glm.vec3:
@@ -32,5 +32,13 @@ class PhysicsBody():
         # TODO add torques
         return dw
     
+    @property
+    def physics_engine(self): return self._physics_engine
+
+    @physics_engine.setter
+    def physics_engine(self, value): 
+        self._physics_engine = value
+        if value: value.add(self)
+
     def __repr__(self) -> str:
         return f'<Physics Body| {self.mass}>'

basilisk/physics/physics_engine.py

@@ -20,11 +20,10 @@ class PhysicsEngine():
         self.forces = forces if forces else []
         self.torques = torques if torques else []
         
-    def add(self, mass: float) -> PhysicsBody:
+    def add(self, physics_body: PhysicsBody) -> PhysicsBody:
         """
         Adds a physics body to the physics engine and returns it
         """
-        physics_body = PhysicsBody(self, mass)
         self.physics_bodies.append(physics_body)
         return physics_body
     

basilisk/render/batch.py

@@ -23,7 +23,7 @@ class Batch():
         # Back references
         self.chunk = chunk
         self.ctx = chunk.chunk_handler.engine.ctx
-        self.program = chunk.chunk_handler.program
+        self.program = self.chunk.get_program()
 
         # Set intial values
         self.vbo = None
@@ -35,7 +35,7 @@ class Batch():
         Returns True if batch was successful.
         """
 
-        self.program = self.chunk.chunk_handler.program
+        self.program = self.chunk.get_program()
 
         # Empty list to contain all vertex data of models in the chunk
         batch_data = []

basilisk/render/camera.py

@@ -85,6 +85,11 @@ class Camera:
     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}>'
 

basilisk/render/chunk.py

@@ -4,7 +4,7 @@ from .batch import Batch
 class Chunk():
     chunk_handler: ...
     """Back refrence to the parent chunk handler"""
-    chunk_key: tuple
+    position: tuple
     """The position of the chunk. Used as a key in the chunk handler"""
     batch: Batch
     """Batched mesh of the chunk"""
@@ -13,7 +13,7 @@ class Chunk():
     static: bool
     """Type of node that the chunk recognizes"""
 
-    def __init__(self, chunk_handler, chunk_key: tuple, static: bool) -> None:
+    def __init__(self, chunk_handler, position: tuple, static: bool, shader=None) -> None:
         """
         Basilisk chunk object. 
         Contains references to all nodes in the chunk.
@@ -22,9 +22,11 @@ class Chunk():
 
         # Back references
         self.chunk_handler = chunk_handler
-        self.chunk_key = chunk_key
 
+        # Chunk Attrbiutes
+        self.position = position
         self.static = static
+        self.shader = shader
 
         # Create empty batch
         self.batch = Batch(self)
@@ -70,12 +72,25 @@ class Chunk():
         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 __repr__(self) -> str:
-        return f'<Basilisk Chunk | {self.chunk_key}, {len(self.nodes)} nodes, {'static' if self.static else 'dynamic'}>'
+        return f'<Basilisk Chunk | {self.position}, {len(self.nodes)} nodes, {"static" if self.static else "dynamic"}>'
 
     def __del__(self) -> None:
         """

basilisk/render/chunk_handler.py

@@ -15,8 +15,8 @@ class ChunkHandler():
     """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"""
+    updated_chunks: set
+    """Set containing recently updated chunks"""
     
     def __init__(self, scene) -> None:
         # Reference to the scene hadlers and variables
@@ -31,8 +31,9 @@ class ChunkHandler():
         self.program = scene.engine.shader.program
 
         # List for the dynamic and static chunk dictionaries | [dyanmic: dict, static: dict]
-        self.chunks         = [{}   , {}   ]
-        self.updated_chunks = [set(), set()]
+        self.shader_groups = {None : ({}, {})}
+        # self.chunks         = [{}, {}]
+        self.updated_chunks = set()
 
 
     def render(self) -> None:
@@ -47,10 +48,12 @@ class ChunkHandler():
         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()
+        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:           
@@ -63,27 +66,24 @@ class ChunkHandler():
         # Loop through the set of updated chunk keys and update the chunk
         removes = []
 
-        for chunk in self.updated_chunks[0]: 
+        for chunk in self.updated_chunks: 
             if chunk.update(): continue
-            removes.append((0, chunk))
-        for chunk in self.updated_chunks[1]: 
-            if chunk.update(): continue
-            removes.append((1, chunk))
+            removes.append(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]]
+        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 = [set(), set()]
+        self.updated_chunks.clear()
 
     def update_all(self):
         self.program = self.scene.engine.shader.program
-        for chunk in self.chunks[0].values():
-            self.updated_chunks[0].add(chunk)
-        for chunk in self.chunks[1].values():
-            self.updated_chunks[1].add(chunk)
+        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:
         """
@@ -93,24 +93,31 @@ class ChunkHandler():
         # 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.chunks[node.static]:
-            self.chunks[node.static][chunk_key] = Chunk(self, chunk_key, node.static)
+        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.chunks[node.static][chunk_key].add(node)
+        self.shader_groups[shader][node.static][chunk_key].add(node)
 
         # Update the chunk
-        self.updated_chunks[node.static].add(self.chunks[node.static][chunk_key])
+        self.updated_chunks.add(self.shader_groups[shader][node.static][chunk_key])
 
         return Node
 
-    def remove(self, node) -> None:
+    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)

basilisk/render/image.py

@@ -7,7 +7,7 @@ import pygame as pg
 from PIL import Image as PIL_Image
 
 
-texture_sizes = (128, 256, 512, 1024, 2048)
+texture_sizes = (8, 64, 512, 1024, 2048)
 
 
 class Image():

basilisk/render/image_handler.py

@@ -3,7 +3,7 @@ import glm
 import numpy as np
 
 
-texture_sizes = (128, 256, 512, 1024, 2048)
+texture_sizes = (8, 64, 512, 1024, 2048)
 
 
 class ImageHandler():
@@ -73,7 +73,8 @@ class ImageHandler():
             self.texture_arrays[size] = self.ctx.texture_array(size=dim, components=4, data=array_data)
             # Texture OpenGl settings
             self.texture_arrays[size].build_mipmaps()
-            self.texture_arrays[size].filter = (mgl.LINEAR_MIPMAP_LINEAR, mgl.LINEAR)
+            if size > 32: self.texture_arrays[size].filter = (mgl.LINEAR_MIPMAP_LINEAR, mgl.LINEAR)
+            else: self.texture_arrays[size].filter = (mgl.NEAREST, mgl.NEAREST)
             self.texture_arrays[size].anisotropy = 32.0
 
     def write(self, regenerate=False) -> None:
@@ -85,7 +86,7 @@ class ImageHandler():
 
         if not self.texture_arrays: return
 
-        for shader in self.engine.scene.shader_handler.shaders.values():
+        for shader in self.engine.scene.shader_handler.shaders:
             if 'textureArrays[5]' not in shader.uniforms: continue
 
             for i, size in enumerate(texture_sizes):

basilisk/render/light_handler.py

@@ -38,17 +38,22 @@ class LightHandler():
         Writes all the lights in a scene to the given shader program
         """
 
-        if not program: program = self.engine.shader.program
+        # if not program: program = self.engine.shader.program
 
-        if directional and self.directional_lights and 'numDirLights' in self.engine.shader.uniforms:
+        for shader in self.scene.shader_handler.shaders:
+            if 'numDirLights' not in shader.uniforms: continue
+            
+            program = shader.program
 
-            program['numDirLights'].write(glm.int32(len(self.directional_lights)))
+            if directional and self.directional_lights and 'numDirLights' in self.engine.shader.uniforms:
 
-            for i, light in enumerate(self.directional_lights):
-                program[f'dirLights[{i}].direction'].write(light.direction)
-                program[f'dirLights[{i}].intensity'].write(glm.float32(light.intensity))
-                program[f'dirLights[{i}].color'    ].write(light.color / 255.0)
-                program[f'dirLights[{i}].ambient'  ].write(glm.float32(light.ambient))
-        
-        if point:
-            ...
+                program['numDirLights'].write(glm.int32(len(self.directional_lights)))
+
+                for i, light in enumerate(self.directional_lights):
+                    program[f'dirLights[{i}].direction'].write(light.direction)
+                    program[f'dirLights[{i}].intensity'].write(glm.float32(light.intensity))
+                    program[f'dirLights[{i}].color'    ].write(light.color / 255.0)
+                    program[f'dirLights[{i}].ambient'  ].write(glm.float32(light.ambient))
+            
+            if point:
+                ...

basilisk/render/material.py

@@ -41,7 +41,7 @@ class Material():
     clearcoat_gloss: float
     """The glossiness of the clearcoat layer. 0 For a satin appearance, 1 for a gloss appearance"""
 
-    def __init__(self, name: str=None, color: tuple=(255.0, 255.0, 255.0), texture: Image=None, normal: Image=None, 
+    def __init__(self, name: str=None, color: tuple=(255.0, 255.0, 255.0), texture: Image=None, normal: Image=None, roughness_map: Image=None, ao_map: Image=None, 
                  roughness: float=0.7, subsurface: float=0.2, sheen: float=0.5, sheen_tint: float=0.5,
                  anisotropic: float=0.0, specular: float=1.0, metallicness: float=0.0, specular_tint: float=0.0,
                  clearcoat: float=0.5, clearcoat_gloss: float=0.25) -> None:
@@ -67,6 +67,8 @@ class Material():
         self.color           = color
         self.texture         = texture
         self.normal          = normal
+        self.roughness_map   = roughness_map
+        self.ao_map          = ao_map
         self.roughness       = roughness
         self.subsurface      = subsurface
         self.sheen           = sheen
@@ -96,6 +98,14 @@ class Material():
         if self.normal: data.extend([1, self.normal.index.x, self.normal.index.y])
         else: data.extend([0, 0, 0])
 
+        # Add roughness data
+        if self.roughness_map: data.extend([1, self.roughness_map.index.x, self.roughness_map.index.y])
+        else: data.extend([0, 0, 0])
+
+        # Add ao data
+        if self.ao_map: data.extend([1, self.ao_map.index.x, self.ao_map.index.y])
+        else: data.extend([0, 0, 0])
+
         return data
 
     def __repr__(self) -> str:
@@ -109,6 +119,10 @@ class Material():
     @property
     def normal(self):          return self._normal
     @property
+    def roughness_map(self):   return self._roughness_map
+    @property
+    def ao_map(self):          return self._ao_map
+    @property
     def roughness(self):       return self._roughness
     @property
     def subsurface(self):      return self._subsurface
@@ -145,6 +159,16 @@ class Material():
         self._normal = validate_image("Material", "normal map", value)
         if self.material_handler: self.material_handler.write(regenerate=True)
 
+    @roughness_map.setter
+    def roughness_map(self, value: Image | None):
+        self._roughness_map = validate_image("Material", "roughness_map", value)
+        if self.material_handler: self.material_handler.write(regenerate=True)
+        
+    @ao_map.setter
+    def ao_map(self, value: Image | None):
+        self._ao_map = validate_image("Material", "ao_map map", value)
+        if self.material_handler: self.material_handler.write(regenerate=True)
+
     @roughness.setter
     def roughness(self, value: float | int | glm.float32):
         self._roughness = validate_float("Material", "roughness", value)

basilisk/render/material_handler.py

@@ -39,18 +39,27 @@ class MaterialHandler():
         Adds the given material to the handler if it is not already present
         """
         
-        # Check that the material is not already in the scene
-        if material in self.materials: return None
-        # Update the material's handler
-        material.material_handler = self
-        # Add images
-        if material.texture: self.image_handler.add(material.texture)
-        if material.normal:  self.image_handler.add(material.normal)
-
-        # Add the material
-        self.materials.append(material)
+        write = False
+
+        if isinstance(material, Material): material = [material]
+
+        for mtl in material:
+            # Check that the material is not already in the scene
+            if mtl in self.materials: continue
+            # Update the material's handler
+            mtl.material_handler = self
+            # Add images
+            if mtl.texture: self.image_handler.add(mtl.texture)
+            if mtl.normal:  self.image_handler.add(mtl.normal)
+
+            # Add the material
+            self.materials.append(mtl)
+
+            write = True
+
+        
         # Write materials
-        self.write(regenerate=True)
+        if write: self.write(regenerate=True)
 
     def generate_material_texture(self) -> None:
         """
@@ -64,7 +73,7 @@ class MaterialHandler():
         if self.data_texture: self.data_texture.release()
 
         # Create empty texture data
-        material_data = np.zeros(shape=(len(self.materials), 19), dtype="f4")
+        material_data = np.zeros(shape=(len(self.materials), 25), dtype="f4")
 
         # Get data from the materials
         for i, mtl in enumerate(self.materials):
@@ -84,7 +93,7 @@ class MaterialHandler():
 
         if not self.data_texture: return
 
-        for shader in self.engine.scene.shader_handler.shaders.values():
+        for shader in self.engine.scene.shader_handler.shaders:
             if 'materialsTexture' not in shader.uniforms: continue
 
             shader.program['materialsTexture'] = 9

basilisk/render/shader.py

@@ -1,5 +1,5 @@
 import moderngl as mgl
-
+import random
 
 attribute_mappings = {
     'in_position'  : [0, 1, 2],
@@ -60,7 +60,10 @@ class Shader:
             self.fragment_shader = file.read()
         
         # Hash value for references
-        self.hash = hash((self.vertex_shader, self.fragment_shader))
+        if vert == None and frag == None:
+            self.hash = hash((self.vertex_shader, self.fragment_shader, 'default'))
+        else:
+            self.hash = hash((self.vertex_shader, self.fragment_shader))
 
         # Create a string of all lines in both shaders
         lines = f'{self.vertex_shader}\n{self.fragment_shader}'.split('\n')
@@ -85,15 +88,12 @@ class Shader:
         # Create a program with shaders
         self.program = self.ctx.program(vertex_shader=self.vertex_shader, fragment_shader=self.fragment_shader)
 
-    def use(self):
+    def set_main(self):
         """
         Selects a shader for use
         """
         
-        self.engine.scene.shader_handler.add('default', self)
-        self.engine.scene.light_handler.write()
-        self.engine.scene.material_handler.write()
-        self.engine.scene.sky.write()
+        self.engine.scene.shader_handler.add(self)
         self.engine.scene.node_handler.chunk_handler.update_all()
 
     def write(self, name: str, value) -> None:

basilisk/render/shader_handler.py

@@ -10,7 +10,7 @@ class ShaderHandler:
     """Back reference to the parent scene"""
     ctx: mgl.Context
     """Back reference to the parent context"""
-    shaders: list = []
+    shaders: set
     """Dictionary containing all the shaders"""
     uniform_values: dict = {}
     """Dictionary containing uniform values"""    
@@ -26,27 +26,28 @@ class ShaderHandler:
         self.ctx    = scene.engine.ctx
 
         # Initalize dictionaries
-        self.shaders = {}
+        self.shaders = set()
+        self.add(self.engine.shader)
 
-        root = self.engine.root
-        self.add('default', self.engine.shader)
-        self.add('draw',    Shader(self.engine, root + '/shaders/draw.vert' , root + '/shaders/draw.frag' ))
-        self.add('sky',     Shader(self.engine, root + '/shaders/sky.vert'  , root + '/shaders/sky.frag'  ))
-
-    def add(self, name: str, shader: Shader) -> None:
+    def add(self, shader: Shader) -> None:
         """
         Creates a shader program from a file name.
         Parses through shaders to identify uniforms and save for writting
         """
 
-        if shader in self.shaders.values(): return
 
-        self.shaders[name] = shader
+        if not shader: return None
+        if shader in self.shaders: return shader
+
+        self.shaders.add(shader)
         
         if self.scene.material_handler:
+            self.scene.light_handler.write()
             self.scene.material_handler.write()
             self.scene.material_handler.image_handler.write()
 
+        return shader
+
     def get_uniforms_values(self) -> None:
         """
         Gets uniforms from various parts of the scene.
@@ -67,7 +68,7 @@ class ShaderHandler:
 
         self.get_uniforms_values()
         for uniform in self.uniform_values:
-            for shader in self.shaders.values():
+            for shader in self.shaders:
                 if not uniform in shader.uniforms: continue  # Does not write uniforms not in the shader
                 shader.write(uniform, self.uniform_values[uniform])
 
@@ -76,4 +77,4 @@ class ShaderHandler:
         Releases all shader programs in handler
         """
         
-        [shader.__del__() for shader in self.shaders.values()]
+        [shader.__del__() for shader in self.shaders]

basilisk/render/sky.py

@@ -1,5 +1,6 @@
 import numpy as np
 from PIL import Image as PIL_Image
+from .shader import Shader
 
 class Sky:
     texture_cube=None
@@ -26,7 +27,7 @@ class Sky:
 
     def write(self):
         # Write the texture cube to the sky shader
-        self.program['skyboxTexture']  = 8
+        self.shader.program['skyboxTexture']  = 8
         self.texture_cube.use(location = 8)
 
         shader = self.scene.engine.shader
@@ -106,8 +107,9 @@ class Sky:
 
         # Create a renderable vao
         self.vbo     = self.ctx.buffer(vertex_data)
-        self.program = self.scene.shader_handler.shaders['sky'].program
-        self.vao     = self.ctx.vertex_array(self.program, [(self.vbo, '3f', 'in_position')], skip_errors=True)
+        root = self.scene.engine.root
+        self.shader = self.scene.shader_handler.add(Shader(self.scene.engine, root + '/shaders/sky.vert', root + '/shaders/sky.frag'))
+        self.vao     = self.ctx.vertex_array(self.shader.program, [(self.vbo, '3f', 'in_position')], skip_errors=True)
 
     def __del__(self):
         """