basilisk-engine 0.1.24__tar.gz → 0.1.26__tar.gz

{basilisk_engine-0.1.24/basilisk_engine.egg-info → basilisk_engine-0.1.26}/PKG-INFO

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

{basilisk_engine-0.1.24 → basilisk_engine-0.1.26}/basilisk/mesh/mesh.py

@@ -30,12 +30,14 @@ class Mesh():
     bvh: NarrowBVH
     """BVH for accessing triangle intersections with a line"""
 
-    def __init__(self, data: str | os.PathLike | np.ndarray) -> None:
+    def __init__(self, data: str | os.PathLike | np.ndarray, custom_format:bool=False) -> None:
         """
         Mesh object containing all the data needed to render an object and perform physics/collisions on it
         Args:
             data: str
                 path to the .obj file of the model or an array of the mesh data
+            custom_format: bool
+                makes expected changes to the given data if false. Leaves data as given if true
         """
         
         # Verify the path type
@@ -59,7 +61,7 @@ class Mesh():
                 self.data = np.hstack([self.data, tangents])
 
         elif isinstance(data, np.ndarray):
-            model = from_data(data)      
+            model = from_data(data, custom_format)      
             self.data = model.vertex_data
             
         else:                                                       # Invalid data type
@@ -70,6 +72,7 @@ class Mesh():
         self.indices = model.point_indices.copy()
 
         self.hash = hash(str(self.data))
+        self.custom = custom_format
 
         # generate edges from faces
         edges = [set() for _ in range(len(self.points))]

{basilisk_engine-0.1.24 → basilisk_engine-0.1.26}/basilisk/mesh/mesh_from_data.py

@@ -2,14 +2,20 @@ import numpy as np
 from .model import Model
 import glm
 
-def from_data(data: np.ndarray) -> Model:
+def from_data(data: np.ndarray, custom_format:bool=False) -> Model:
     """
     Converts data given to a format compatable with basilisk models
+    Args:
+        data: np.ndarray
+            array of the mesh data
+        custom_format: bool
+            makes expected changes to the given data if false. Leaves data as given if true
     """
 
+    if custom_format: return format_raw(data)
+
     # Create an empty model
     model = Model()
-    # Get the shape of the given data
 
     # Get the shape of the given data and check for a valid shape
     shape = data.shape
@@ -128,4 +134,18 @@ def get_points_and_indices(positions: np.ndarray) -> tuple[np.ndarray]:
         for triangle in index_mapping:
             indices[triangle].append(i)
 
-    return np.array(list(points.keys()), dtype='f4'), np.array(indices, dtype='i')
+    return np.array(list(points.keys()), dtype='f4'), np.array(indices, dtype='i')
+
+def format_raw(data: np.ndarray) -> np.ndarray:
+    # Create an empty model
+    model = Model()
+
+    # Get the needed data (assume position is in the first three positions)
+    model.vertex_data = np.array(data, dtype='f4')
+    if model.vertex_data.shape[1] >= 3:
+        model.vertex_points, model.point_indices = get_points_and_indices(model.vertex_data[:,:3])
+    else:
+        model.vertex_points = np.zeros(shape=(1, model.vertex_data.shape[1]))
+        model.point_indices = np.zeros(shape=(1, 3))
+
+    return model

{basilisk_engine-0.1.24 → basilisk_engine-0.1.26}/basilisk/nodes/node.py

@@ -371,13 +371,16 @@ class Node():
         if not per_vertex_mtl: node_data[-1] = self.material.index
 
         # Create an array to hold the node's data
-        data = np.zeros(shape=(mesh_data.shape[0], 25), dtype='f4')
+        width = 25 if not self.mesh.custom else 11 + mesh_data.shape[1]
+        data = np.zeros(shape=(mesh_data.shape[0], width), dtype='f4')
 
 
-        data[:,:14] = mesh_data
-        data[:,14:] = node_data
+        data[:,:mesh_data.shape[1]] = mesh_data
+        data[:,mesh_data.shape[1]:] = node_data
 
-        if per_vertex_mtl: data[:,24] = self.material
+        if per_vertex_mtl: data[:,-1] = self.material
+
+        if self.shader and not self.mesh.custom: data = np.take(data, self.shader.attribute_indices, axis=1)
 
         return data
 

{basilisk_engine-0.1.24 → basilisk_engine-0.1.26}/basilisk/render/batch.py

@@ -1,14 +1,14 @@
 import numpy as np
 import moderngl as mgl
-
+from .shader import Shader
 
 class Batch():
     chunk: ...
     """Reference to the parent chunk of the batch"""
     ctx: mgl.Context
     """Reference to the context of the parent engine"""
-    program: mgl.Program
-    """Reference to the program used by batches"""
+    shader: Shader
+    """Reference to the bsk.Shader used by batches"""
     vao: mgl.VertexArray
     """The vertex array of the batch. Used for rendering"""
     vbo: mgl.Buffer
@@ -23,7 +23,7 @@ class Batch():
         # Back references
         self.chunk = chunk
         self.ctx = chunk.chunk_handler.engine.ctx
-        self.program = self.chunk.get_program()
+        self.shader = self.chunk.get_shader()
 
         # Set intial values
         self.vbo = None
@@ -35,7 +35,7 @@ class Batch():
         Returns True if batch was successful.
         """
 
-        self.program = self.chunk.get_program()
+        self.shader = self.chunk.get_shader()
 
         # Empty list to contain all vertex data of models in the chunk
         batch_data = []
@@ -68,11 +68,9 @@ class Batch():
 
         # Create the vbo and the vao from mesh data
         self.vbo = self.ctx.buffer(batch_data)
-        self.vao = self.ctx.vertex_array(self.program, [(self.vbo, 
-                                                         '3f 2f 3f 3f 3f 3f 4f 3f 1f', 
-                                                         *['in_position', 'in_uv', 'in_normal', 'in_tangent', 'in_bitangent', 'obj_position', 'obj_rotation', 'obj_scale', 'obj_material'])], 
-                                                         skip_errors=True)
-        
+        self.vao = self.ctx.vertex_array(self.shader.program, [(self.vbo, self.shader.fmt, *self.shader.attributes)], skip_errors=True)
+
+
         return True
 
     def swap_shader(self, shader):

{basilisk_engine-0.1.24 → basilisk_engine-0.1.26}/basilisk/render/camera.py

@@ -10,10 +10,6 @@ FOV = 50  # Degrees
 NEAR = 0.1
 FAR = 350
 
-# Camera movement constants
-SPEED = 10
-SENSITIVITY = 0.15/180
-
 class Camera:
     engine: ...
     """Back reference to the parent engine"""
@@ -23,8 +19,12 @@ class Camera:
     """Aspect ratio of the engine window"""
     position: glm.vec3
     """Location of the camera (maters)"""
+    speed: float
+    """The speed that the camera moves in space"""
+    sensitivity: float
+    """The speed at which the camera turns"""
 
-    def __init__(self, position=(0, 0, 20), rotation=(1, 0, 0, 0)) -> None:
+    def __init__(self, position=(0, 0, 20), rotation=(1, 0, 0, 0), speed: float=10, sensitivity: float=2) -> None:
         """
         Camera object to get view and projection matricies. Movement built in
         """
@@ -43,6 +43,9 @@ class Camera:
         self.m_view = self.get_view_matrix()
         # Projection matrix
         self.m_proj = self.get_projection_matrix()
+        # Movement attributes
+        self.speed = speed
+        self.sensitivity = sensitivity
 
     def update(self) -> None:
         """
@@ -191,8 +194,8 @@ class FreeCamera(Camera):
         """
         rel_x, rel_y = self.engine.mouse.relative
         
-        yaw_rotation = glm.angleAxis(SENSITIVITY * rel_x, -self.UP)
-        pitch_rotation = glm.angleAxis(SENSITIVITY * rel_y, -self.right)
+        yaw_rotation = glm.angleAxis(self.sensitivity / 1000 * rel_x, -self.UP)
+        pitch_rotation = glm.angleAxis(self.sensitivity / 1000 * rel_y, -self.right)
         new_rotation = yaw_rotation * pitch_rotation * self.rotation
         
         v_new = new_rotation * self.UP
@@ -203,7 +206,7 @@ class FreeCamera(Camera):
         """
         Checks for button presses and updates vectors accordingly. 
         """
-        velocity = (SPEED + self.engine.keys[pg.K_CAPSLOCK] * 10) * self.engine.delta_time
+        velocity = (self.speed + self.engine.keys[pg.K_CAPSLOCK] * 10) * self.engine.delta_time
         keys = self.engine.keys
         if keys[pg.K_w]:
             self.position += glm.normalize(glm.vec3(self.forward.x, 0, self.forward.z)) * velocity

{basilisk_engine-0.1.24 → basilisk_engine-0.1.26}/basilisk/render/chunk.py

@@ -55,7 +55,7 @@ class Chunk():
         if not self.batch.vbo: return
         
         data = node.get_data()
-        self.batch.vbo.write(data, node.data_index * 25 * 4)
+        self.batch.vbo.write(data, node.data_index * data.shape[1] * 4)
 
     def add(self, node):
         """
@@ -79,15 +79,15 @@ class Chunk():
 
         return node
 
-    def get_program(self):
+    def get_shader(self):
         """
-        Gets the program of the chunks nodes' shader
+        Gets the bsk.Shader of the chunks nodes' shader
         """
 
         shader = self.shader
 
-        if shader: return shader.program
-        return self.chunk_handler.engine.shader.program
+        if shader: return shader
+        return self.chunk_handler.engine.shader
 
     def swap_shader(self, shader):
         """

{basilisk_engine-0.1.24 → basilisk_engine-0.1.26}/basilisk/render/shader.py

@@ -80,10 +80,19 @@ class Shader:
             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]]
+                # Get the number of flots the attribute takes
+                if any(list(map(lambda x: x in tokens, ['float', 'int']))): n = 1
+                elif any(list(map(lambda x: x in tokens, ['vec2']))): n = 2
+                elif any(list(map(lambda x: x in tokens, ['vec3']))): n = 3
+                elif any(list(map(lambda x: x in tokens, ['vec4']))): n = 4
+                else: n = 1
+                self.fmt += f'{n}f '
+
+                if tokens[-1][:-1] in attribute_mappings:
+                    indices = attribute_mappings[tokens[-1][:-1]]
+                else:
+                    indices = [0 for i in range(n)]
                 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)

{basilisk_engine-0.1.24 → basilisk_engine-0.1.26/basilisk_engine.egg-info}/PKG-INFO

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

{basilisk_engine-0.1.24 → basilisk_engine-0.1.26}/basilisk_engine.egg-info/SOURCES.txt

@@ -142,4 +142,6 @@ tests/mud.png
 tests/mud_normal.png
 tests/oak_tree.obj
 tests/skybox.png
-tests/sphere.obj
+tests/sphere.obj
+tests/shaders/custom_format.frag
+tests/shaders/custom_format.vert

{basilisk_engine-0.1.24 → basilisk_engine-0.1.26}/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.24',
+    version = '0.1.26',
     url = 'https://basilisk-website.vercel.app/',
     author = 'Name',
     author_email = 'basiliskengine@gmail.com',

basilisk_engine-0.1.26/tests/shaders/custom_format.frag

@@ -0,0 +1,10 @@
+#version 330 core
+
+out vec4 fragColor;
+
+in vec3 color;
+
+void main()
+{ 
+    fragColor = vec4(color, 1.0);
+}

basilisk_engine-0.1.26/tests/shaders/custom_format.vert

@@ -0,0 +1,55 @@
+#version 330 core
+
+layout (location = 0) in vec3 in_position;
+layout (location = 1) in float in_custom_val;
+
+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 vec3 color;
+
+
+// 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);
+
+    if (round(in_custom_val) == 1) {
+        color = vec3(1, 0, 0);
+    }
+    else {
+        color = vec3(0, 1, 0);
+    }
+
+    // Set the fragment position
+    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(in_position, 1.0);
+}