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

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
@@ -43,6 +45,7 @@ class Scene():
         """
         
         self.node_handler.update()
+        self.particle.update()
         self.camera.update()
         self.collider_handler.resolve_collisions()
 
@@ -53,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=None):
+    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
+
+        else:
+            raise ValueError(f'scene.add: Incompatable object add type {type(bsk_object)}')
+
+        return None
 
-        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)
+    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:
         """
@@ -97,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
@@ -121,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()

basilisk/shaders/batch.frag

@@ -31,6 +31,10 @@ struct Material {
     vec2  albedoMap;
     int   hasNormalMap;
     vec2  normalMap;
+    int   hasRoughnessMap;
+    vec2  roughnessMap;
+    int   hasAoMap;
+    vec2  aoMap;
 };
 
 struct LightResult {
@@ -92,7 +96,7 @@ float AnisotropicSmithGGX(float ndots, float sdotx, float sdoty, float ax, float
 
 // Diffuse model as outlined by Burley: https://media.disneyanimation.com/uploads/production/publication_asset/48/asset/s2012_pbs_disney_brdf_notes_v3.pdf
 // Much help from Acerola's video on the topic: https://www.youtube.com/watch?v=KkOkx0FiHDA&t=570s
-LightResult PrincipledDiffuse(DirectionalLight light, Material mtl, vec3 albedo, vec3 N, vec3 V, vec3 X, vec3 Y) {
+LightResult PrincipledDiffuse(DirectionalLight light, Material mtl, vec3 albedo, float roughness, vec3 N, vec3 V, vec3 X, vec3 Y) {
 
     LightResult result;
 
@@ -123,7 +127,7 @@ LightResult PrincipledDiffuse(DirectionalLight light, Material mtl, vec3 albedo,
     // Diffuse
     float FL = SchlickFresnel(cos_theta_l);
     float FV = SchlickFresnel(cos_theta_V);
-    float Fss90 = cos_theta_D * cos_theta_D * mtl.roughness;
+    float Fss90 = cos_theta_D * cos_theta_D * roughness;
     float Fd90 = 0.5 + 2.0 * Fss90;
 
     float Fd = mix(1.0, Fd90, FL) * mix(1.0, Fd90, FV);
@@ -133,7 +137,7 @@ LightResult PrincipledDiffuse(DirectionalLight light, Material mtl, vec3 albedo,
     float ss = 1.25 * (Fss * ((1 / (cos_theta_l + cos_theta_V)) - 0.5) + 0.5);
 
     // Specular
-    float alpha = mtl.roughness * mtl.roughness;
+    float alpha = roughness * roughness;
     float aspect = sqrt(1.0 - 0.9 * mtl.anisotropic);
     float alpha_x = max(0.001, alpha / aspect);
     float alpha_y = max(0.001, alpha * aspect);
@@ -143,7 +147,7 @@ LightResult PrincipledDiffuse(DirectionalLight light, Material mtl, vec3 albedo,
     float Ds = AnisotropicGTR2(ndoth, hdotx, hdoty, alpha_x, alpha_y);
 
     // Geometric Attenuation
-    float GalphaSquared = pow(0.5 + mtl.roughness * 0.5, 2);
+    float GalphaSquared = pow(0.5 + roughness * 0.5, 2);
     float GalphaX = max(0.001, GalphaSquared / aspect);
     float GalphaY = max(0.001, GalphaSquared * aspect);
     float G = AnisotropicSmithGGX(cos_theta_l, ldotx, ldoty, GalphaX, GalphaY);
@@ -192,15 +196,39 @@ vec3 getNormal(Material mtl, mat3 TBN){
     return normal;
 }
 
+float getAo(Material mtl, vec2 uv) {
+    float ao;
+    if (bool(mtl.hasAoMap)){
+        ao = texture(textureArrays[int(round(mtl.aoMap.x))].array, vec3(uv, round(mtl.aoMap.y))).a;
+    }
+    else {
+        ao = 1.0;
+    }
+    return ao;
+}
+
+float getRoughness(Material mtl, vec2 uv) {
+    float roughness;
+    if (bool(mtl.hasRoughnessMap)){
+        roughness = texture(textureArrays[int(round(mtl.roughnessMap.x))].array, vec3(uv, round(mtl.roughnessMap.y))).a;
+    }
+    else {
+        roughness = mtl.roughness;
+    }
+    return roughness;
+}
+
 void main() {
     float gamma = 2.2;
     vec3 viewDir = vec3(normalize(cameraPosition - position));
 
     // Get lighting vectors
-    vec3 albedo    = getAlbedo(mtl, uv, gamma);
-    vec3 normal    = getNormal(mtl, TBN);
-    vec3 tangent   = TBN[0];
-    vec3 bitangent = TBN[1];
+    vec3 albedo     = getAlbedo(mtl, uv, gamma);
+    vec3 normal     = getNormal(mtl, TBN);
+    float ao        = getAo(mtl, uv);
+    float roughness = getRoughness(mtl, uv);
+    vec3 tangent    = TBN[0];
+    vec3 bitangent  = TBN[1];
 
     // Orthogonalize the tangent and bitangent according to the mapped normal vector
     tangent = tangent - dot(normal, tangent) * normal;
@@ -224,17 +252,18 @@ void main() {
     // Add result from each directional light in the scene
     for (int i = 0; i < numDirLights; i++) {
         // Caculate the light for the directional light
-        LightResult dirLightResult = PrincipledDiffuse(dirLights[i], mtl, albedo, N, V, X, Y);
+        LightResult dirLightResult = PrincipledDiffuse(dirLights[i], mtl, albedo, roughness, N, V, X, Y);
         vec3 lightFactor = dirLights[i].intensity * dirLights[i].color;
         // Add each lobe
-        lightResult.diffuse   += dirLightResult.diffuse * lightFactor;
-        lightResult.specular  += dirLightResult.specular * lightFactor;
+        lightResult.diffuse   += dirLightResult.diffuse   * lightFactor;
+        lightResult.specular  += dirLightResult.specular  * lightFactor;
         lightResult.clearcoat += dirLightResult.clearcoat * lightFactor;
     }
 
     lightResult.specular =  min(vec3(1.0), lightResult.specular);
     lightResult.specular *= mix(vec3(1.0), reflect_sky, mtl.metallicness) * luminance(reflect_sky);
     lightResult.diffuse  *= mix(vec3(1.0), ambient_sky, 0.25);
+    lightResult.diffuse  *= ao;
 
     vec3 finalColor = albedo * 0.3 * mix(vec3(1.0), reflect_sky, mtl.metallicness);
     finalColor += (lightResult.diffuse + lightResult.specular + lightResult.clearcoat);

basilisk/shaders/batch.vert

@@ -34,6 +34,10 @@ struct Material {
     vec2  albedoMap;
     int   hasNormalMap;
     vec2  normalMap;
+    int   hasRoughnessMap;
+    vec2  roughnessMap;
+    int   hasAoMap;
+    vec2  aoMap;
 };
 flat out Material mtl;
 
@@ -83,11 +87,10 @@ void main() {
     uv       = in_uv;
     
     // Get the material
-    int mtl_size = 19;
+    int mtl_size = 25;
     int materialID     = int(obj_material);
+
     mtl.color          = vec3(texelFetch(materialsTexture, ivec2(0, 0 + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 1  + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 2  + materialID * mtl_size), 0).r);
-    
-    
     mtl.roughness      = texelFetch(materialsTexture, ivec2(0, 3 + materialID * mtl_size), 0).r;
     mtl.subsurface     = texelFetch(materialsTexture, ivec2(0, 4 + materialID * mtl_size), 0).r;
     mtl.sheen          = texelFetch(materialsTexture, ivec2(0, 5 + materialID * mtl_size), 0).r;
@@ -99,10 +102,14 @@ void main() {
     mtl.clearcoat      = texelFetch(materialsTexture, ivec2(0, 11 + materialID * mtl_size), 0).r;
     mtl.clearcoatGloss = texelFetch(materialsTexture, ivec2(0, 12 + materialID * mtl_size), 0).r;
     
-    mtl.hasAlbedoMap   = int(texelFetch(materialsTexture,  ivec2(0, 13  + materialID * mtl_size), 0).r);
-    mtl.albedoMap      = vec2(texelFetch(materialsTexture, ivec2(0, 14  + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 15  + materialID * mtl_size), 0).r);
-    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);    
+    mtl.hasAlbedoMap    = int(texelFetch(materialsTexture,  ivec2(0, 13  + materialID * mtl_size), 0).r);
+    mtl.albedoMap       = vec2(texelFetch(materialsTexture, ivec2(0, 14  + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 15  + materialID * mtl_size), 0).r);
+    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);    
+    mtl.hasRoughnessMap = int(texelFetch(materialsTexture,  ivec2(0, 19  + materialID * mtl_size), 0).r);
+    mtl.roughnessMap    = vec2(texelFetch(materialsTexture, ivec2(0, 20  + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 21 + materialID * mtl_size), 0).r);    
+    mtl.hasAoMap        = int(texelFetch(materialsTexture,  ivec2(0, 22  + materialID * mtl_size), 0).r);
+    mtl.aoMap           = vec2(texelFetch(materialsTexture, ivec2(0, 23  + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 24 + materialID * mtl_size), 0).r);    
 
     // Set the fragment position
     gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(in_position, 1.0);

basilisk/shaders/normal.frag

@@ -24,8 +24,11 @@ struct Material {
     vec2  albedoMap;
     int   hasNormalMap;
     vec2  normalMap;
+    int   hasRoughnessMap;
+    vec2  roughnessMap;
+    int   hasAoMap;
+    vec2  aoMap;
 };
-
 in vec2 uv;
 in mat3 TBN;
 
@@ -33,7 +36,7 @@ in mat3 TBN;
 flat in Material mtl;
 
 // Uniforms
-uniform      textArray textureArrays[5];
+uniform textArray textureArrays[5];
 
 
 vec3 getNormal(Material mtl, mat3 TBN){
@@ -52,9 +55,6 @@ 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

@@ -33,6 +33,10 @@ struct Material {
     vec2  albedoMap;
     int   hasNormalMap;
     vec2  normalMap;
+    int   hasRoughnessMap;
+    vec2  roughnessMap;
+    int   hasAoMap;
+    vec2  aoMap;
 };
 flat out Material mtl;
 
@@ -81,11 +85,12 @@ void main() {
     uv       = in_uv;
     
     // Get the material
-    int mtl_size = 19;
+    int mtl_size = 25;
+    mtl = Material(vec3(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, vec2(0), 0, vec2(0), 0, vec2(0), 0, vec2(0));
     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);    
+    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/shaders/particle.frag

@@ -0,0 +1,72 @@
+#version 330 core
+out vec4 fragColor;
+
+in vec2 uv;
+in vec3 position;
+in mat3 TBN;
+
+struct textArray {
+    sampler2DArray array;
+};
+uniform textArray textureArrays[5];
+
+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;
+    int   hasRoughnessMap;
+    vec2  roughnessMap;
+    int   hasAoMap;
+    vec2  aoMap;
+};
+flat in Material mtl;
+
+
+vec3 getColor(Material mtl, vec2 uv, float gamma) {
+    vec3 albedo = mtl.color;
+    if (bool(mtl.hasAlbedoMap)){
+        albedo *= pow(texture(textureArrays[int(round(mtl.albedoMap.x))].array, vec3(uv, round(mtl.albedoMap.y))).rgb, vec3(gamma));
+    }
+    return albedo;
+}
+
+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()
+{   
+    // Texture and normal data
+    float gamma = 2.2;
+    vec3 color  = getColor(mtl, uv, gamma);
+    vec3 normal = getNormal(mtl, TBN);
+
+    // Simple light calculations
+    vec3 light = normalize(vec3(1.5, 2, 1));
+    float diff = abs(dot(normal, light));
+
+    // Get color and gamma correction
+    fragColor = vec4(color * (.2 + diff), 1.0);
+    fragColor.rgb = pow(fragColor.rgb, vec3(1.0/gamma));
+}

basilisk/shaders/particle.vert

@@ -0,0 +1,85 @@
+#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;
+
+
+in vec3  in_instance_pos;
+in float in_instance_mtl;
+in float scale;
+in float life;
+
+out vec2 uv;
+out mat3 TBN;
+
+uniform mat4 projectionMatrix;
+uniform mat4 viewMatrix;
+uniform sampler2D materialsTexture;
+
+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;
+    int   hasRoughnessMap;
+    vec2  roughnessMap;
+    int   hasAoMap;
+    vec2  aoMap;
+};
+flat out Material mtl;
+
+// Function to get the model matrix from node position, rotation, and scale
+mat4 getModelMatrix(vec3 pos, float scale) {
+    mat4 translation = mat4(
+        scale, 0    , 0    , 0,
+        0    , scale, 0    , 0,
+        0    , 0    , scale, 0,
+        pos.x, pos.y, pos.z, 1
+    );
+    return translation;
+}
+
+// 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(in_instance_pos, scale * life);
+
+    // Set out variables
+    TBN      = getTBN(modelMatrix, in_normal, in_tangent, in_bitangent);
+    uv       = in_uv;
+
+    // Material Data
+    int mtl_size = 25;
+    int materialID      = int(in_instance_mtl);
+    mtl = Material(vec3(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, vec2(0), 0, vec2(0), 0, vec2(0), 0, vec2(0));
+    mtl.color           = vec3(texelFetch(materialsTexture, ivec2(0, 0 + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 1  + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 2  + materialID * mtl_size), 0).r);
+    mtl.hasAlbedoMap    = int(texelFetch(materialsTexture,  ivec2(0, 13  + materialID * mtl_size), 0).r);
+    mtl.albedoMap       = vec2(texelFetch(materialsTexture, ivec2(0, 14  + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 15  + materialID * mtl_size), 0).r);
+    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);    
+
+    // Send position to the frag
+    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(in_position, 1.0);
+}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: basilisk-engine
-Version: 0.1.0
+Version: 0.1.1
 Summary: Python 3D Framework
 Home-page: https://basilisk-website.vercel.app/
 Author: Name
@@ -24,10 +24,10 @@ Basilisk Engine is a Python package for effortless 3D rendering and simulation.
 Basilisk Engine uses a versatile and efficient physically based rendering pipeline, allowing for photorealistic and stylized rendering in real-time.
 
 <p align="center">
-    <img src="mud.png" alt="mud" width="400"/>
-    <img src="foil.png" alt="foil" width="400"/>
-    <img src="cloth.png" alt="mud" width="400"/>
-    <img src="floor.png" alt="mud" width="400"/>
+    <img src="images/mud.png" alt="mud" width="400"/>
+    <img src="images/foil.png" alt="foil" width="400"/>
+    <img src="images/cloth.png" alt="mud" width="400"/>
+    <img src="images/floor.png" alt="mud" width="400"/>
 </p>
 
 ## Physics