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

basilisk/mesh/mesh_from_data.py

@@ -1,48 +1,133 @@
 import numpy as np
+from .model import Model
+import glm
 
-
-def from_data(data: np.ndarray) -> np.ndarray:
+def from_data(data: np.ndarray) -> Model:
     """
     Converts data given to a format compatable with basilisk models
     """
 
+    # 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
+    if len(shape) == 2: pass
+    elif len(shape) == 3: data = np.reshape(data, (shape[0] * 3, shape[1] * shape[2] // 3)); shape = data.shape
+    else: raise ValueError(f"Could not find valid format for the given model data of shape {shape}")
+
+    # Data to be retraived/generated
+    positions = None
+    uvs       = None
+    normals   = None
+    tangents  = None
 
     if shape[1] == 3:  # Just given position
-        pos_norm_data = get_normals(data)
-        print(pos_norm_data.shape)
-        data = np.zeros(shape=(len(data), 14))
-        data[:,:6] = pos_norm_data
-        return data
+        positions = data[:,:]
+        uvs = get_uvs(positions)
+        normals = get_normals(positions)
+        tangents = get_tangents(normals)
+
+    elif shape[1] == 5:  # Given position and uv, but no normals
+        positions = data[:,:3]
+        uvs = data[:,3:5]
+        normals = get_normals(positions)
+        tangents = get_tangents(normals)
 
     elif shape[1] == 6:  # Given position and normals, but no UV
-        pos_norm_data = data
-        data = np.zeros(shape=(len(data), 14))
-        data[:][:6] = pos_norm_data
-        return data
+        positions = data[:,:3]
+        uvs = get_uvs(positions)
+        normals = data[:,3:6]
+        tangents = get_tangents(normals)
 
     elif shape[1] == 8:  # Given position, normals and UV
-        ...
+        positions = data[:,:3]
+        uvs = data[:,3:5]
+        normals = data[:,5:8]
+        tangents = get_tangents(normals)
 
     elif shape[1] == 14:  #Given position, normals, UV, bitangents, and tangents, no change needed
-        return data
+        positions = data[:,:3]
+        uvs = data[:,3:5]
+        normals = data[:,5:8]
+        tangents = data[:,8:14]
+    
+    else:
+        raise ValueError(f"Could not find valid format for the given model data of shape {shape}")
+
+    model.vertex_data = np.zeros(shape=(shape[0], 14))
+    model.vertex_data[:,:3]   = positions
+    model.vertex_data[:,3:5]  = uvs
+    model.vertex_data[:,5:8]  = normals
+    model.vertex_data[:,8:14] = tangents
+    model.vertex_points, model.point_indices = get_points_and_indices(positions)
 
-    raise ValueError(f"Could not find valid format for the given model data of shape {shape}")
+    print(model.vertex_points, model.point_indices)
+
+    return model
 
 
 def get_normals(positions: np.ndarray) -> np.ndarray:
     """
-    Gets the normals for a position array and returns a concatinated array
+    Gets the normals from the position data
+    Returns a numpy array
     """
     
     # Create empty array for the normals
-    normals = np.zeros(shape=positions.shape)
+    normals = np.zeros(shape=positions.shape, dtype='f4')
 
     # Loop through each triangle and calculate the normal of the surface
     for tri in range(positions.shape[0] // 3):
-        normal = np.cross(positions[tri] - positions[tri + 1], positions[tri] - positions[tri + 2])
-        normals[tri    ] = normal
-        normals[tri + 1] = normal
-        normals[tri + 2] = normal
+        v1 = glm.vec3(positions[tri * 3]) - glm.vec3(positions[tri * 3 + 1])
+        v2 = glm.vec3(positions[tri * 3]) - glm.vec3(positions[tri * 3 + 2])
+        normal = glm.normalize(glm.cross(v1, v2))
+        normals[tri * 3    ] = list(normal.xyz)
+        normals[tri * 3 + 1] = list(normal.xyz)
+        normals[tri * 3 + 2] = list(normal.xyz)
+
+    return normals
+
+def get_uvs(positions: np.ndarray) -> np.ndarray:
+    """
+    Gets the uvs from the position array.
+    Currently assigns each triangle arbitrarily, since there is no standard
+    """
+    uvs = np.array([*[[0, 0], [0, 1], [1, 0]] * (positions.shape[0]//3)])
+    return uvs
+
+def get_tangents(normals: np.array):
+    """
+    Gets the uvs from the normal array.
+    Currently just fills with arbitrary data, since there is no standard
+    """
+
+    # Get linearly independent vectors
+    tangent = np.cross(normals, [1, 1, 0])
+    bitangent = np.cross(normals, tangent)
+
+    # Combine to a single array
+    all_tangents = np.hstack([tangent, bitangent], dtype='f4')
+
+    return all_tangents
+
+
+def get_points_and_indices(positions: np.ndarray) -> tuple[np.ndarray]:
+    """
+    Gets the unique points and indices from the position data.
+    Returns a tuple of numpy arrays: (points, indices)
+    """
+    
+    points = {}
+    indices = [[] for i in range(len(positions) // 3)]
+
+    for i, point in enumerate(positions):
+        point = tuple(point)
+        if point not in points: points[point] = []
+        points[point].append(i // 3)
+
+    for i, index_mapping in enumerate(points.values()):
+        for triangle in index_mapping:
+            indices[triangle].append(i)
 
-    return np.hstack([positions, normals])
+    return np.array(list(points.keys()), dtype='f4'), np.array(indices, dtype='i')

basilisk/mesh/narrow_aabb.py

@@ -1,4 +1,6 @@
 import glm
+
+from basilisk.generic.collisions import collide_aabb_line
 from .narrow_primative import NarrowPrimative
 from ..generic.abstract_bvh import AbstractAABB as AABB
 from ..generic.meshes import get_aabb_line_collision
@@ -78,4 +80,11 @@ class NarrowAABB(AABB):
             aabbs += self.b.get_all_aabbs(layer + 1)
         else: aabbs.append((self.b.top_right, self.b.bottom_left, layer + 1))
         
-        return aabbs
+        return aabbs
+    
+    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[int]:
+        """
+        Returns the colliders that may intersect with the given line
+        """
+        if not collide_aabb_line(self.top_right, self.bottom_left, position, forward): return []
+        return (self.a.get_line_collided(position, forward) if isinstance(self.a, NarrowAABB) else [self.a.index]) + (self.b.get_line_collided(position, forward) if isinstance(self.b, NarrowAABB) else [self.b.index])

basilisk/mesh/narrow_bvh.py

@@ -81,4 +81,12 @@ class NarrowBVH(BVH):
         Returns all AABBs, their extreme points, and their layer
         """
         if isinstance(self.root, NarrowAABB): return self.root.get_all_aabbs(0)
-        return [(self.root.top_right, self.root.bottom_left, 0)]
+        return [(self.root.top_right, self.root.bottom_left, 0)]
+    
+    def get_line_collided(self, position: glm.vec3, forward: glm.vec3) -> list[tuple[int, int, int]]:
+        """
+        Determines which triangles are intersecting with the given line segment. Returns the indices of the triangle contained in the mesh points list
+        """
+        if isinstance(self.root, NarrowAABB): return self.root.get_line_collided(position, forward)
+        return self.root.index
+