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

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
@@ -133,64 +147,74 @@ class Material():
     @color.setter
     def color(self, value: tuple | list | glm.vec3 | np.ndarray):
         self._color = validate_glm_vec3("Material", "color", value)
-        if self.material_handler: self.material_handler.write()
+        if self.material_handler: self.material_handler.write(regenerate=True)
         
     @texture.setter
     def texture(self, value: Image | None):
         self._texture = validate_image("Material", "texture", value)
-        if self.material_handler: self.material_handler.write()
+        if self.material_handler: self.material_handler.write(regenerate=True)
         
     @normal.setter
     def normal(self, value: Image | None):
         self._normal = validate_image("Material", "normal map", value)
-        if self.material_handler: self.material_handler.write()
+        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)
-        if self.material_handler: self.material_handler.write()
+        if self.material_handler: self.material_handler.write(regenerate=True)
 
     @subsurface.setter
     def subsurface(self, value: float | int | glm.float32):
         self._subsurface = validate_float("Material", "subsurface", value)
-        if self.material_handler: self.material_handler.write()
+        if self.material_handler: self.material_handler.write(regenerate=True)
 
     @sheen.setter
     def sheen(self, value: float | int | glm.float32):
         self._sheen = validate_float("Material", "sheen", value)
-        if self.material_handler: self.material_handler.write()
+        if self.material_handler: self.material_handler.write(regenerate=True)
 
     @sheen_tint.setter
     def sheen_tint(self, value: float | int | glm.float32):
         self._sheen_tint = validate_float("Material", "sheen tint", value)
-        if self.material_handler: self.material_handler.write()
+        if self.material_handler: self.material_handler.write(regenerate=True)
 
     @anisotropic.setter
     def anisotropic(self, value: float | int | glm.float32):
         self._anisotropic = validate_float("Material", "anisotropic", value)
-        if self.material_handler: self.material_handler.write()
+        if self.material_handler: self.material_handler.write(regenerate=True)
 
     @specular.setter
     def specular(self, value: float | int | glm.float32):
         self._specular = validate_float("Material", "specular", value)
-        if self.material_handler: self.material_handler.write()
+        if self.material_handler: self.material_handler.write(regenerate=True)
 
     @metallicness.setter
     def metallicness(self, value: float | int | glm.float32):
         self._metallicness = validate_float("Material", "metallicness", value)
-        if self.material_handler: self.material_handler.write()
+        if self.material_handler: self.material_handler.write(regenerate=True)
 
     @specular_tint.setter
     def specular_tint(self, value: float | int | glm.float32):
         self._specular_tint = validate_float("Material", "specular tint", value)
-        if self.material_handler: self.material_handler.write()
+        if self.material_handler: self.material_handler.write(regenerate=True)
     
     @clearcoat.setter
     def clearcoat(self, value: float | int | glm.float32):
         self._clearcoat = validate_float("Material", "clearcoat", value)
-        if self.material_handler: self.material_handler.write()
+        if self.material_handler: self.material_handler.write(regenerate=True)
 
     @clearcoat_gloss.setter
     def clearcoat_gloss(self, value: float | int | glm.float32):
         self._clearcoat_gloss = validate_float("Material", "clearcoat gloss", value)
-        if self.material_handler: self.material_handler.write()
+        if self.material_handler: self.material_handler.write(regenerate=True)

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()
+        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):
@@ -75,17 +84,20 @@ class MaterialHandler():
         material_data = np.ravel(material_data)
         self.data_texture = self.ctx.texture((1, len(material_data)), components=1, dtype='f4', data=material_data)
 
-    def write(self, shader_program: mgl.Program=None) -> None:
+    def write(self, regenerate=False) -> None:
         """
-        Writes all material data to the given shader
+        Writes all material data to relavent shaders
         """
 
-        if shader_program == None: shader_program = self.scene.shader_handler.programs['batch']
+        if regenerate: self.generate_material_texture()
 
-        self.generate_material_texture()
+        if not self.data_texture: return
 
-        shader_program[f'materialsTexture'] = 9
-        self.data_texture.use(location=9)
+        for shader in self.engine.scene.shader_handler.shaders:
+            if 'materialsTexture' not in shader.uniforms: continue
+
+            shader.program['materialsTexture'] = 9
+            self.data_texture.use(location=9)
 
     def get(self, identifier: str | int) -> any:
         """
@@ -113,6 +125,7 @@ class MaterialHandler():
         
         self.base = Material('Base')
         self.materials.append(self.base)
+        self.generate_material_texture()
         self.write()
 
     def __del__(self) -> None:

basilisk/render/shader.py

@@ -0,0 +1,110 @@
+import moderngl as mgl
+import random
+
+attribute_mappings = {
+    'in_position'  : [0, 1, 2],
+    'in_uv'        : [3, 4],
+    'in_normal'    : [5, 6, 7],
+    'in_tangent'   : [8, 9, 10],
+    'in_bitangent' : [11, 12, 13],
+    'obj_position' : [14, 15, 16],
+    'obj_rotation' : [17, 18, 19, 20],
+    'obj_scale'    : [21, 22, 23],
+    'obj_material' : [24],
+}
+
+
+class Shader:
+    program: mgl.Program=None
+    """Shader program for the vertex and fragment shader"""
+    vertex_shader: str
+    """String representation of the vertex shader"""
+    fragment_shader: str
+    """String representation of the vertex shader"""
+    uniforms: list[str]=[]
+    """List containg the names of all uniforms in the shader"""
+    attribute_indices: list[int]
+    """List of indices that map all possible shader attributes to the ones used byu the shader"""
+    fmt: str
+    """String representation of the format for building vaos"""
+    attributes: list[str]
+    """List representation of the attributes for building vaos"""
+
+    def __init__(self, engine, vert: str=None, frag: str=None) -> None:
+        """
+        Basilisk shader object. Contains shader program and shader attrbibute/uniform information
+        Args:
+            vert: str=None
+                Path to the vertex shader. Defaults to internal if none is given
+            frag: str=None
+                Path to the fragment shader. Defaults to internal if none is given    
+        """
+
+        self.engine = engine
+        self.ctx    = engine.ctx
+
+        # Default class attributes values
+        self.uniforms          = []
+        self.attribute_indices = []
+        self.fmt               = ''
+        self.attributes        = []
+
+        # Default vertex and fragment shaders
+        if vert == None: vert = self.engine.root + '/shaders/batch.vert'
+        if frag == None: frag = self.engine.root + '/shaders/batch.frag'
+
+        # Read the shaders
+        with open(vert) as file:
+            self.vertex_shader = file.read()
+        with open(frag) as file:
+            self.fragment_shader = file.read()
+        
+        # Hash value for references
+        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')
+
+        # Parse through shader to find uniforms and attributes
+        for line in lines:
+            tokens = line.strip().split(' ')
+
+            # Add uniforms
+            if tokens[0] == 'uniform' and len(tokens) > 2:
+                self.uniforms.append(tokens[-1][:-1])
+
+            # Add attributes
+            if tokens[0] == 'layout' and len(tokens) > 2 and 'in' in line:
+                self.attributes.append(tokens[-1][:-1])
+
+                if tokens[-1][:-1] not in attribute_mappings: continue
+                indices = attribute_mappings[tokens[-1][:-1]]
+                self.attribute_indices.extend(indices)
+                self.fmt += f'{len(indices)}f '
+
+        # Create a program with shaders
+        self.program = self.ctx.program(vertex_shader=self.vertex_shader, fragment_shader=self.fragment_shader)
+
+    def set_main(self):
+        """
+        Selects a shader for use
+        """
+        
+        self.engine.scene.shader_handler.add(self)
+        self.engine.scene.node_handler.chunk_handler.update_all()
+
+    def write(self, name: str, value) -> None:
+        """
+        Writes a uniform to the shader program
+        """
+        
+        self.program[name].write(value)
+    
+    def __del__(self) -> int:
+        if self.program: self.program.release()
+
+    def __hash__(self) -> int:
+        return self.hash

basilisk/render/shader_handler.py

@@ -1,8 +1,6 @@
 import moderngl as mgl
 import glm
-
-# Predefined uniforms that do not change each frame
-single_frame_uniforms = ['m_proj']
+from .shader import Shader
 
 
 class ShaderHandler:
@@ -12,10 +10,8 @@ class ShaderHandler:
     """Back reference to the parent scene"""
     ctx: mgl.Context
     """Back reference to the parent context"""
-    programs: dict = {}
+    shaders: set
     """Dictionary containing all the shaders"""
-    shader_uniforms: dict = {}
-    """Dictionary all the uniforms present in a shader"""
     uniform_values: dict = {}
     """Dictionary containing uniform values"""    
 
@@ -30,38 +26,27 @@ class ShaderHandler:
         self.ctx    = scene.engine.ctx
 
         # Initalize dictionaries
-        self.programs = {}
-        self.shader_uniforms = {}
-
-        self.load('batch', self.engine.root + '/shaders/batch.vert', self.engine.root + '/shaders/batch.frag')
-        self.load('draw', self.engine.root + '/shaders/draw.vert', self.engine.root + '/shaders/draw.frag')
-        self.load('sky', self.engine.root + '/shaders/sky.vert', self.engine.root + '/shaders/sky.frag')
+        self.shaders = set()
+        self.add(self.engine.shader)
 
-    def load(self, name: str, vert_path: str, frag_path: str) -> 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
         """
 
-        # Read the shaders
-        with open(vert_path) as file:
-            vertex_shader = file.read()
-        with open(frag_path) as file:
-            fragment_shader = file.read()
-            
-        # Create blank list for uniforms
-        self.shader_uniforms[name] = []
-        # Create a list of all lines in both shaders
-        lines = f'{vertex_shader}\n{fragment_shader}'.split('\n')
-        # Parse through shader to find uniform variables
-        for line in lines:
-            tokens = line.strip().split(' ')
-            if tokens[0] == 'uniform' and len(tokens) > 2:
-                self.shader_uniforms[name].append(tokens[2][:-1])
 
-        # Create a program with shaders
-        program = self.ctx.program(vertex_shader=vertex_shader, fragment_shader=fragment_shader)
-        self.programs[name] = program
+        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:
         """
@@ -83,13 +68,13 @@ class ShaderHandler:
 
         self.get_uniforms_values()
         for uniform in self.uniform_values:
-            for program in self.programs:
-                if not uniform in self.shader_uniforms[program]: continue  # Does not write uniforms not in the shader
-                self.programs[program][uniform].write(self.uniform_values[uniform])
+            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])
 
     def release(self) -> None:
         """
         Releases all shader programs in handler
         """
         
-        [program.release() for program in self.programs.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,11 +27,12 @@ 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)
 
-        batch_program = self.scene.shader_handler.programs['batch']
-        batch_program['skyboxTexture'] = 8
+        shader = self.scene.engine.shader
+        if 'skyboxTexture' not in shader.uniforms: return
+        shader.program['skyboxTexture'] = 8
         self.texture_cube.use(location = 8)
 
 
@@ -105,8 +107,9 @@ class Sky:
 
         # Create a renderable vao
         self.vbo     = self.ctx.buffer(vertex_data)
-        self.program = self.scene.shader_handler.programs['sky']
-        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):
         """

basilisk/scene.py

@@ -12,7 +12,9 @@ from .collisions.collider_handler import ColliderHandler
 from .draw.draw_handler import DrawHandler
 from .render.sky import Sky
 from .render.frame import Frame
-
+from .particles.particle_handler import ParticleHandler
+from .nodes.node import Node
+from .generic.collisions import moller_trumbore
 
 class Scene():
     engine: any
@@ -42,8 +44,10 @@ class Scene():
         Updates the physics and in the scene
         """
         
-        self.camera.update()
         self.node_handler.update()
+        self.particle.update()
+        self.camera.update()
+        self.collider_handler.resolve_collisions()
 
     def render(self) -> None:
         """
@@ -52,39 +56,50 @@ class Scene():
 
         self.frame.use()
         self.shader_handler.write()
-        self.sky.render()
+        if self.sky: self.sky.render()
         self.node_handler.render()
+        self.particle.render()
         self.draw_handler.render()
 
         if self.engine.headless: return
         self.frame.render()
     
-    def add_node(self, 
-            position:            glm.vec3=None, 
-            scale:               glm.vec3=None, 
-            rotation:            glm.quat=None, 
-            forward:             glm.vec3=None, 
-            mesh:                Mesh=None, 
-            material:            Material=None, 
-            velocity:            glm.vec3=None, 
-            rotational_velocity: glm.quat=None, 
-            physics:             bool=False, 
-            mass:                float=None, 
-            collisions:          bool=False, 
-            collider:            str=None, 
-            static_friction:     float=None, 
-            kinetic_friction:    float=None, 
-            elasticity:          float=None, 
-            collision_group :    float=None, 
-            name:                str='', 
-            tags:                list[str]=None,
-            static:              bool=True):
+    def add(self, bsk_object: ...) -> ...:
+        """
+        Adds an object to the scene. Can pass in any scene objects:
+        Argument overloads:
+            object: Node - Adds the given node to the scene.
+        """
         
-        if material: self.material_handler.add(material)
-        else: material = self.material_handler.base
+        if isinstance(bsk_object, type(None)):
+            # Considered well defined behavior
+            return
+        elif isinstance(bsk_object, Node):
+            # Add a node to the scene
+            return self.node_handler.add(bsk_object)
+        # Light
+
+        # Mesh
 
-        return self.node_handler.add(position, scale, rotation, forward, mesh, material, velocity, rotational_velocity, physics, mass, collisions, collider, static_friction, kinetic_friction, elasticity, collision_group, name, tags, static)
+        else:
+            raise ValueError(f'scene.add: Incompatable object add type {type(bsk_object)}')
 
+        return None
+
+    def remove(self, bsk_object):
+        """
+        Removes the given baskilsk object from the scene
+        """
+
+        if isinstance(bsk_object, type(None)):
+            # Considered well defined behavior
+            return
+        elif isinstance(bsk_object, Node):
+            self.node_handler.remove(bsk_object)
+        else:
+            raise ValueError(f'scene.remove: Incompatable object remove type {type(bsk_object)}')
+
+        return None
 
     def set_engine(self, engine: any) -> None:
         """
@@ -96,14 +111,84 @@ class Scene():
 
         self.camera           = FreeCamera()
         self.shader_handler   = ShaderHandler(self)
+        self.material_handler = MaterialHandler(self)
+        self.light_handler    = LightHandler(self)
         self.physics_engine   = PhysicsEngine()
         self.node_handler     = NodeHandler(self)
+        self.particle         = ParticleHandler(self)
         self.collider_handler = ColliderHandler(self)
-        self.material_handler = MaterialHandler(self)
-        self.light_handler    = LightHandler(self)
         self.draw_handler     = DrawHandler(self)
         self.frame            = Frame(self)
         self.sky              = Sky(self.engine)
+        
+    def raycast(self, position: glm.vec3=None, forward: glm.vec3=None, max_distance: float=1e5, has_collisions: bool=None, has_physics: bool=None, tags: list[str]=[]) -> tuple[Node, glm.vec3]:
+        """
+        Ray cast from any posiiton and forward vector and returns the nearest node. If no position or forward is given, uses the scene camera's current position and forward
+        """
+        if not position: position = self.camera.position
+        if not forward: forward = self.camera.forward
+        forward = glm.normalize(forward)
+        
+        # if we are filtering for collisions, use the broad BVH to improve performance
+        if has_collisions: 
+            colliders = self.collider_handler.bvh.get_line_collided(position, forward)
+            nodes = [collider.node for collider in colliders]
+            
+            def is_valid(node: Node) -> bool:
+                return all([
+                    has_collisions is None or bool(node.collider) == has_collisions,
+                    has_physics is None or bool(node.physics_body) == has_physics,
+                    all(tag in node.tags for tag in tags)
+                ])
+                
+            nodes: list[Node] = list(filter(lambda node: is_valid(node), nodes))
+        
+        # if we are not filtering for collisions, filter nodes and 
+        else: nodes = self.node_handler.get_all(collisions=has_collisions, physics=has_physics, tags=tags)
+
+        # determine closest node
+        best_distance, best_point, best_node = max_distance, None, None
+        position_two = position + forward
+        for node in nodes:
+            
+            inv_mat = glm.inverse(node.model_matrix)
+            relative_position = inv_mat * position
+            relative_forward = glm.normalize(inv_mat * position_two - relative_position)
+            
+            triangles = [node.mesh.indices[i] for i in node.mesh.get_line_collided(relative_position, relative_forward)]
+            
+            for triangle in triangles:
+                intersection = moller_trumbore(relative_position, relative_forward, [node.mesh.points[i] for i in triangle])
+                if not intersection: continue
+                intersection = node.model_matrix * intersection
+                distance = glm.length(intersection - position)
+                if distance < best_distance:
+                    best_distance = distance
+                    best_point    = intersection
+                    best_node     = node
+                    
+        return best_node, best_point
+    
+    def raycast_mouse(self, position: tuple[int, int] | glm.vec2, max_distance: float=1e5, has_collisions: bool=None, has_pshyics: bool=None, tags: list[str]=[]) -> tuple[Node, glm.vec3]:
+        """
+        Ray casts from the mouse position with respect to the camera. Returns the nearest node that was clicked, if none was clicked, returns None. 
+        """
+        # derive forward vector from mouse click position
+        position = glm.vec2(position)
+        inv_proj, inv_view = glm.inverse(self.camera.m_proj), glm.inverse(self.camera.m_view)
+        ndc   = glm.vec4(2 * position[0] / self.engine.win_size[0] - 1, 1 - 2 * position[1] / self.engine.win_size[1], 1, 1)
+        point = inv_proj * ndc
+        point /= point.w
+        forward = glm.normalize(glm.vec3(inv_view * glm.vec4(point.x, point.y, point.z, 0)))
+        
+        return self.raycast(
+            position=self.camera.position,
+            forward=forward,
+            max_distance=max_distance,
+            has_collisions=has_collisions,
+            has_physics=has_pshyics,
+            tags=tags
+        )
 
     @property
     def camera(self): return self._camera
@@ -120,9 +205,7 @@ class Scene():
 
     @sky.setter
     def sky(self, value: Sky):
-        if not value: return
-        if not isinstance(value, Sky):
-            raise TypeError(f'Scene: Invalid sky type: {type(value)}. Expected type bsk.Sky')
+        if not isinstance(value, Sky) and not isinstance(value, type(None)):
+            raise TypeError(f'Scene: Invalid sky type: {type(value)}. Expected type bsk.Sky or None')
         self._sky = value
-        self._sky.write()
-
+        if value: self._sky.write()