basilisk-engine 0.1.28__tar.gz → 0.1.29__tar.gz

{basilisk_engine-0.1.28 → basilisk_engine-0.1.29}/PKG-INFO

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

{basilisk_engine-0.1.28 → basilisk_engine-0.1.29}/basilisk/generic/input_validation.py

@@ -3,6 +3,14 @@ import glm
 from ..render.image import Image
 
 
+def validate_int(module: str, name: str, value: int | float | glm.int32) -> float:
+    if isinstance(value, int) or isinstance(value, float):
+        return int(round(value))
+    elif isinstance(value, glm.int32):
+        return int(value.value)
+    else:
+        raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected float.")
+
 def validate_float(module: str, name: str, value: float | int | glm.float32) -> float:
     if isinstance(value, float) or isinstance(value, int):
         return float(value)
@@ -10,7 +18,7 @@ def validate_float(module: str, name: str, value: float | int | glm.float32) ->
         return float(value.value)
     else:
         raise TypeError(f"{module}: Invalid {name} value type {type(value)}. Expected float.")
-    
+
 def validate_glm_vec3(module: str, name: str, value: tuple | list | glm.vec3 | np.ndarray) -> glm.vec3:
     if isinstance(value, tuple) or isinstance(value, list) or isinstance(value, np.ndarray):
         if len(value) != 3: raise ValueError(f"{module}: Invalid number of values for {name}. Expected 3 values, got {len(value)} values")

{basilisk_engine-0.1.28 → basilisk_engine-0.1.29}/basilisk/render/framebuffer.py

@@ -2,6 +2,7 @@ import numpy as np
 import moderngl as mgl
 from PIL import Image
 from ..render.shader import Shader
+from ..generic.input_validation import validate_int
 
 
 class Framebuffer:
@@ -36,7 +37,7 @@ class Framebuffer:
         self._size          = size
         self.scale          = scale
         self.texture_filter = (mgl.LINEAR, mgl.LINEAR) if linear_filter else (mgl.NEAREST, mgl.NEAREST)
-        self.n_attachments    = n_color_attachments
+        self.n_attachments  = n_color_attachments
 
         self.load_pipeline()
         self.generate_fbo()
@@ -59,6 +60,10 @@ class Framebuffer:
         # Create the internal fbo
         self.fbo = self.ctx.framebuffer(self._color_attachments, self._depth_attachment)
 
+        # Set the show attachment to default
+        self._show = -1
+        self.show = 0
+
     def resize(self, new_size: tuple[int]=None) -> None:
         """
         Update set size framebuffers with the given size.
@@ -86,13 +91,18 @@ class Framebuffer:
         self.vbo = self.ctx.buffer(np.array([[-1, -1, 0, 0, 0], [1, -1, 0, 1, 0], [1, 1, 0, 1, 1], [-1, 1, 0, 0, 1], [-1, -1, 0, 0, 0], [1, 1, 0, 1, 1]], dtype='f4'))
         self.vao = self.ctx.vertex_array(self.shader.program, [(self.vbo, '3f 2f', 'in_position', 'in_uv')], skip_errors=True)
 
-    def render(self, render_target=None) -> None:
+    def render(self, render_target=None, show: int=None) -> None:
+        """
+        Render the fbo to the screen
+        If the fbo has multiple attachments, show will specifiy which is shown
+        Depth is considered the last show element
+        """
 
-        target = render_target if render_target else self.engine.frame
+        if not isinstance(show, type(None)): self.show = show
 
+        target = render_target if render_target else self.engine.frame
         target.use()
-        self.shader.program['screenTexture'] = 0
-        self.texture.use(location=0)
+
         self.vao.render()
 
     def use(self) -> None:
@@ -143,13 +153,23 @@ class Framebuffer:
     def data(self) -> bytes:
         """Reads the data from the fbo"""
         return self.fbo.read()
-    
+    @property
+    def show(self) -> int:
+        return self._show
 
     @size.setter
     def size(self, value: tuple[int]=None) -> tuple[int]:
         self.resize(value)
         return self.size
     
+    @show.setter
+    def show(self, value: int) -> None:
+        value = validate_int("Framebuffer", "show", value)
+        if value == self._show: return
+        self._show = value
+        self.shader.program['screenTexture'] = value+1
+        self.color_attachments[value].use(location=value+1)
+
     def __repr__(self) -> str:
         return f'<bsk.Framebuffer | size: {self.size}>' 
 

{basilisk_engine-0.1.28 → basilisk_engine-0.1.29}/basilisk/render/image.py

@@ -19,6 +19,8 @@ class Image():
     """Array of the texture data"""
     size: int
     """The width and height in pixels of the image"""
+    texture: mgl.Texture | None=None
+    """Texture of the image. Only created and retrived if needed by other module"""
 
     def __init__(self, path: str | os.PathLike | pg.Surface | mgl.Texture) -> None:
         """
@@ -81,8 +83,39 @@ class Image():
         """
         ...
 
+    def build_texture(self, ctx: mgl.Context) -> mgl.Texture:
+        """
+        Builds a texture from the image data
+        """
+
+        # Release existing memory
+        if self.texture: self.texture.release()
+
+        # Make the texture from image data
+        self.texture = ctx.texture((self.size, self.size), components=4, data=self.data)
+        # Texture formatting
+        self.texture.build_mipmaps()
+        self.texture.filter = (mgl.LINEAR_MIPMAP_LINEAR, mgl.LINEAR)
+        self.texture.anisotropy = 32.0
+        
+        return self.texture
+
+    def use(self, slot: int) -> None:
+        """
+        Use the image at the given slot
+        """
+        
+        if not self.texture:
+            raise LookupError("bsk.Image: cannot use an image without a texture. Use texture.build_texture() before texture.use()")
+
+        # Bind to the given slot
+        self.texture.use(location=slot)
+
     def __repr__(self) -> str:
         """
         Returns a string representation of the object
         """
-        return f'<Basilisk Image | {self.name}, ({self.size}x{self.size}), {sys.getsizeof(self.data) / 1024 / 1024:.2} mb>'
+        return f'<Basilisk Image | {self.name}, ({self.size}x{self.size}), {sys.getsizeof(self.data) / 1024 / 1024:.2} mb>'
+    
+    def __del__(self) -> None:
+        if self.texture: self.texture.release()

{basilisk_engine-0.1.28 → basilisk_engine-0.1.29}/basilisk/render/material.py

@@ -152,7 +152,9 @@ class Material():
     @texture.setter
     def texture(self, value: Image | None):
         self._texture = validate_image("Material", "texture", value)
-        if self.material_handler: self.material_handler.write(regenerate=True)
+        if not self.material_handler: return
+        self.material_handler.image_handler.add(value)
+        self.material_handler.write(regenerate=True)
         
     @normal.setter
     def normal(self, value: Image | None):

{basilisk_engine-0.1.28 → basilisk_engine-0.1.29}/basilisk/render/material_handler.py

@@ -13,6 +13,8 @@ class MaterialHandler():
     """List containing all the materials in the engine"""
     data_texture: mgl.Texture
     """ModernGL texture containing all the material data for materials in the engine"""
+    image_handler: ImageHandler=None
+    """Handler for all images in the game"""
   
     def __init__(self, engine) -> None:
         """

{basilisk_engine-0.1.28 → basilisk_engine-0.1.29}/basilisk/render/shader.py

@@ -1,5 +1,5 @@
 import moderngl as mgl
-import random
+from .image import Image
 
 attribute_mappings = {
     'in_position'  : [0, 1, 2],
@@ -48,6 +48,7 @@ class Shader:
         self.attribute_indices = []
         self.fmt               = ''
         self.attributes        = []
+        self.bindings = 1
 
         # Default vertex and fragment shaders
         if vert == None: vert = self.engine.root + '/shaders/batch.vert'
@@ -112,6 +113,21 @@ class Shader:
         
         self.program[name].write(value)
     
+    def bind(self, sampler: mgl.Texture | mgl.TextureArray | mgl.TextureCube | Image, name: str, slot: int=None) -> None:
+        """
+        Binds the given sampler to the next availible slot
+        """
+
+        # Use the next slot if no slot is given
+        if not slot: slot = self.bindings; self.bindings+=1
+
+        if isinstance(sampler, Image,): sampler = sampler.build_texture(self.ctx)
+
+        # Use the sampler
+        self.program[name] = slot
+        sampler.use(location=slot)
+        
+
     def __del__(self) -> int:
         if self.program: self.program.release()
 

{basilisk_engine-0.1.28 → basilisk_engine-0.1.29}/basilisk_engine.egg-info/PKG-INFO

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

{basilisk_engine-0.1.28 → basilisk_engine-0.1.29}/basilisk_engine.egg-info/SOURCES.txt

@@ -154,4 +154,8 @@ tests/sphere.obj
 tests/wedge.obj
 tests/wheel_eight.obj
 tests/shaders/custom_format.frag
-tests/shaders/custom_format.vert
+tests/shaders/custom_format.vert
+tests/shaders/image_test.frag
+tests/shaders/image_test.vert
+tests/shaders/multi_render_test.frag
+tests/shaders/multi_render_test.vert

{basilisk_engine-0.1.28 → basilisk_engine-0.1.29}/setup.py

@@ -7,7 +7,7 @@ with open(path.join(working_directory, 'README.md'), encoding='utf-8') as f:
 
 setup(
     name = 'basilisk-engine',  # Name of folder containing scripts and __init__
-    version = '0.1.28',
+    version = '0.1.29',
     url = 'https://basilisk-website.vercel.app/',
     author = 'Name',
     author_email = 'basiliskengine@gmail.com',

basilisk_engine-0.1.29/tests/shaders/image_test.frag

@@ -0,0 +1,12 @@
+#version 330 core
+
+out vec4 fragColor;
+
+in vec2 uv;
+
+uniform sampler2D image;
+
+void main()
+{ 
+    fragColor = vec4(texture(image, uv).rgb, 1.0);
+}

basilisk_engine-0.1.29/tests/shaders/image_test.vert

@@ -0,0 +1,50 @@
+#version 330 core
+
+layout (location = 0) in vec3 in_position;
+layout (location = 1) in vec2 in_uv;
+
+layout (location = 2) in vec3  obj_position;
+layout (location = 3) in vec4  obj_rotation;
+layout (location = 4) in vec3  obj_scale;
+layout (location = 5) in float obj_material;
+
+
+out vec2 uv;
+
+// 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);
+
+    // Pass the uv
+    uv = in_uv;
+
+    // Set the fragment position
+    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(in_position, 1.0);
+}

basilisk_engine-0.1.29/tests/shaders/multi_render_test.frag

@@ -0,0 +1,24 @@
+#version 330 core
+
+layout (location = 0) out vec4 gSolid;
+layout (location = 1) out vec4 gPosition;
+layout (location = 2) out vec4 gUV;
+layout (location = 3) out vec4 gNormal;
+layout (location = 4) out vec4 gTangent;
+layout (location = 5) out vec4 gBitangent;
+
+
+in vec2 uv;
+in vec3 position;
+in mat3 TBN;
+
+
+void main()
+{ 
+    gSolid      = vec4(1.0);
+    gPosition   = vec4(position, 1.0);
+    gUV         = vec4(uv, 0.0, 1.0);
+    gNormal     = vec4(TBN[2], 1.0);
+    gTangent    = vec4(TBN[0], 1.0);
+    gBitangent  = vec4(TBN[1], 1.0);
+}

basilisk_engine-0.1.29/tests/shaders/multi_render_test.vert

@@ -0,0 +1,65 @@
+#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;
+
+// Variables passed on to the fragment shader
+out vec2 uv;
+out vec3 position;
+out mat3 TBN;
+
+
+// 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;
+}
+
+// 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
+    position = (modelMatrix * vec4(in_position, 1.0)).xyz;
+    TBN      = getTBN(modelMatrix, in_normal, in_tangent, in_bitangent);
+    uv       = in_uv;
+
+    // Set the fragment position
+    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(in_position, 1.0);
+}