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

basilisk/render/material.py

@@ -133,64 +133,64 @@ 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.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

@@ -50,7 +50,7 @@ class MaterialHandler():
         # Add the material
         self.materials.append(material)
         # Write materials
-        self.write()
+        self.write(regenerate=True)
 
     def generate_material_texture(self) -> None:
         """
@@ -75,17 +75,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.values():
+            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 +116,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
+
+
+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
+        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 use(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.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: list = []
     """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,26 @@ class ShaderHandler:
         self.ctx    = scene.engine.ctx
 
         # Initalize dictionaries
-        self.programs = {}
-        self.shader_uniforms = {}
+        self.shaders = {}
 
-        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')
+        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 load(self, name: str, vert_path: str, frag_path: str) -> None:
+    def add(self, name: str, 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])
+        if shader in self.shaders.values(): return
 
-        # Create a program with shaders
-        program = self.ctx.program(vertex_shader=vertex_shader, fragment_shader=fragment_shader)
-        self.programs[name] = program
+        self.shaders[name] = shader
+        
+        if self.scene.material_handler:
+            self.scene.material_handler.write()
+            self.scene.material_handler.image_handler.write()
 
     def get_uniforms_values(self) -> None:
         """
@@ -83,13 +67,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.values():
+                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.values()]

basilisk/render/sky.py

@@ -29,8 +29,9 @@ class Sky:
         self.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,7 +106,7 @@ class Sky:
 
         # Create a renderable vao
         self.vbo     = self.ctx.buffer(vertex_data)
-        self.program = self.scene.shader_handler.programs['sky']
+        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)
 
     def __del__(self):

basilisk/scene.py

@@ -42,8 +42,9 @@ class Scene():
         Updates the physics and in the scene
         """
         
-        self.camera.update()
         self.node_handler.update()
+        self.camera.update()
+        self.collider_handler.resolve_collisions()
 
     def render(self) -> None:
         """
@@ -78,7 +79,7 @@ class Scene():
             collision_group :    float=None, 
             name:                str='', 
             tags:                list[str]=None,
-            static:              bool=True):
+            static:              bool=None):
         
         if material: self.material_handler.add(material)
         else: material = self.material_handler.base

basilisk/shaders/geometry.frag

@@ -0,0 +1,9 @@
+#version 330 core
+
+layout (location = 0) out vec4 fragColor;
+
+
+void main() {
+    // Output fragment color
+    fragColor = vec4(1.0, 1.0, 1.0, 1.0);
+}

basilisk/shaders/geometry.vert

@@ -0,0 +1,42 @@
+#version 330 core
+
+layout (location = 0) in vec3 in_position;
+
+layout (location = 5) in vec3  obj_position;
+layout (location = 6) in vec4  obj_rotation;
+layout (location = 7) in vec3  obj_scale;
+
+// Uniforms
+uniform mat4 projectionMatrix;
+uniform mat4 viewMatrix;
+
+// Function to get the model matrix from node position, rotation, and scale
+mat4 getModelMatrix(vec3 pos, vec4 rot, vec3 scl) {
+    mat4 translation = mat4(
+        1    , 0    , 0    , 0,
+        0    , 1    , 0    , 0,
+        0    , 0    , 1    , 0,
+        pos.x, pos.y, pos.z, 1
+    );
+    mat4 rotation = mat4(
+        1 - 2 * (rot.z * rot.z + rot.w * rot.w), 2 * (rot.y * rot.z - rot.w * rot.x), 2 * (rot.y * rot.w + rot.z * rot.x), 0,
+        2 * (rot.y * rot.z + rot.w * rot.x), 1 - 2 * (rot.y * rot.y + rot.w * rot.w), 2 * (rot.z * rot.w - rot.y * rot.x), 0,
+        2 * (rot.y * rot.w - rot.z * rot.x), 2 * (rot.z * rot.w + rot.y * rot.x), 1 - 2 * (rot.y * rot.y + rot.z * rot.z), 0,
+        0, 0, 0, 1
+    );
+    mat4 scale = mat4(
+        scl.x, 0    , 0    , 0,
+        0    , scl.y, 0    , 0,
+        0    , 0    , scl.z, 0,
+        0    , 0    , 0    , 1
+    );
+    return translation * rotation * scale;
+}
+
+
+void main() {
+    // Set the model matrix
+    mat4 modelMatrix = getModelMatrix(obj_position, obj_rotation, obj_scale);
+    // Set the fragment position
+    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(in_position, 1.0);
+}

basilisk/shaders/normal.frag

@@ -0,0 +1,60 @@
+#version 330 core
+
+layout (location = 0) out vec4 fragColor;
+
+// Structs needed for the shader
+struct textArray {
+    sampler2DArray array;
+};
+
+struct Material {
+    vec3  color;
+    float roughness;
+    float subsurface;
+    float sheen;
+    float sheenTint;
+    float anisotropic;
+    float specular;
+    float metallicness;
+    float specularTint;
+    float clearcoat;
+    float clearcoatGloss;
+    
+    int   hasAlbedoMap;
+    vec2  albedoMap;
+    int   hasNormalMap;
+    vec2  normalMap;
+};
+
+in vec2 uv;
+in mat3 TBN;
+
+// Material attributes
+flat in Material mtl;
+
+// Uniforms
+uniform      textArray textureArrays[5];
+
+
+vec3 getNormal(Material mtl, mat3 TBN){
+    // Isolate the normal vector from the TBN basis
+    vec3 normal = TBN[2];
+    // Apply normal map if the material has one
+    if (bool(mtl.hasNormalMap)) {
+        normal = texture(textureArrays[int(round(mtl.normalMap.x))].array, vec3(uv, round(mtl.normalMap.y))).rgb * 2.0 - 1.0;
+        normal = normalize(TBN * normal); 
+    }
+    // Return vector
+    return normal;
+}
+
+void main() {
+    // Get lighting vectors
+    vec3 normal    = getNormal(mtl, TBN);
+
+    // Lighting variables
+    vec3 N = normalize(normal);
+
+    // Output fragment color
+    fragColor = vec4(normal, 1.0);
+}

basilisk/shaders/normal.vert

@@ -0,0 +1,92 @@
+#version 330 core
+
+layout (location = 0) in vec3 in_position;
+layout (location = 1) in vec2 in_uv;
+layout (location = 2) in vec3 in_normal;
+layout (location = 3) in vec3 in_tangent;
+layout (location = 4) in vec3 in_bitangent;
+
+layout (location = 5) in vec3  obj_position;
+layout (location = 6) in vec4  obj_rotation;
+layout (location = 7) in vec3  obj_scale;
+layout (location = 8) in float obj_material;
+
+// Variables passed on to the fragment shader
+out vec2 uv;
+out mat3 TBN;
+
+// Material struct sent to fragment shader
+struct Material {
+    vec3  color;
+    float roughness;
+    float subsurface;
+    float sheen;
+    float sheenTint;
+    float anisotropic;
+    float specular;
+    float metallicness;
+    float specularTint;
+    float clearcoat;
+    float clearcoatGloss;
+    
+    int   hasAlbedoMap;
+    vec2  albedoMap;
+    int   hasNormalMap;
+    vec2  normalMap;
+};
+flat out Material mtl;
+
+// Uniforms
+uniform mat4 projectionMatrix;
+uniform mat4 viewMatrix;
+uniform sampler2D materialsTexture;
+
+// Function to get the model matrix from node position, rotation, and scale
+mat4 getModelMatrix(vec3 pos, vec4 rot, vec3 scl) {
+    mat4 translation = mat4(
+        1    , 0    , 0    , 0,
+        0    , 1    , 0    , 0,
+        0    , 0    , 1    , 0,
+        pos.x, pos.y, pos.z, 1
+    );
+    mat4 rotation = mat4(
+        1 - 2 * (rot.z * rot.z + rot.w * rot.w), 2 * (rot.y * rot.z - rot.w * rot.x), 2 * (rot.y * rot.w + rot.z * rot.x), 0,
+        2 * (rot.y * rot.z + rot.w * rot.x), 1 - 2 * (rot.y * rot.y + rot.w * rot.w), 2 * (rot.z * rot.w - rot.y * rot.x), 0,
+        2 * (rot.y * rot.w - rot.z * rot.x), 2 * (rot.z * rot.w + rot.y * rot.x), 1 - 2 * (rot.y * rot.y + rot.z * rot.z), 0,
+        0, 0, 0, 1
+    );
+    mat4 scale = mat4(
+        scl.x, 0    , 0    , 0,
+        0    , scl.y, 0    , 0,
+        0    , 0    , scl.z, 0,
+        0    , 0    , 0    , 1
+    );
+    return translation * rotation * scale;
+}
+
+// Function to get the TBN matrix for normal mapping
+mat3 getTBN(mat4 modelMatrix, vec3 normal, vec3 tangent, vec3 bitangent){
+    vec3 T = normalize(vec3(modelMatrix * vec4(tangent,   0.0)));
+    vec3 B = normalize(vec3(modelMatrix * vec4(bitangent, 0.0)));
+    vec3 N = normalize(vec3(modelMatrix * vec4(normal,    0.0)));
+    return mat3(T, B, N);
+}
+
+void main() {
+    // Set the model matrix
+    mat4 modelMatrix = getModelMatrix(obj_position, obj_rotation, obj_scale);
+
+    // Set out variables
+    TBN      = getTBN(modelMatrix, in_normal, in_tangent, in_bitangent);
+    uv       = in_uv;
+    
+    // Get the material
+    int mtl_size = 19;
+    int materialID     = int(obj_material);
+    
+    mtl.hasNormalMap   = int(texelFetch(materialsTexture,  ivec2(0, 16  + materialID * mtl_size), 0).r);
+    mtl.normalMap      = vec2(texelFetch(materialsTexture, ivec2(0, 17  + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 18 + materialID * mtl_size), 0).r);    
+
+    // Set the fragment position
+    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(in_position, 1.0);
+}

{basilisk_engine-0.0.8.dist-info → basilisk_engine-0.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: basilisk-engine
-Version: 0.0.8
+Version: 0.1.0
 Summary: Python 3D Framework
 Home-page: https://basilisk-website.vercel.app/
 Author: Name