basilisk-engine 0.1.43__py3-none-any.whl → 0.1.44__py3-none-any.whl

basilisk/physics/impulse.py

@@ -1,113 +1,113 @@
-import glm
-from ..nodes.node import Node
-
-def calculate_collisions(normal:glm.vec3, node1: Node, node2: Node, contact_points:list[glm.vec3], inv_inertia1:glm.mat3x3, inv_inertia2:glm.mat3x3, center1:glm.vec3, center2:glm.vec3) -> None:
-    """
-    Resolve the collisions between two objects with multiple contact points
-    """
-    physics_body1 = node1.physics_body
-    physics_body2 = node2.physics_body
-    collider1 = node1.collider
-    collider2 = node2.collider
-    
-    # determine whether or not the colliders have physics
-    has_physics1, has_physics2 = physics_body1 is not None, physics_body2 is not None
-    
-    # get physics data from valid bodies
-    if has_physics1: inv_mass1 = 1 / physics_body1.mass
-    if has_physics2: inv_mass2 = 1 / physics_body2.mass
-    
-    # gets coefficients
-    elasticity = max(collider1.elasticity, collider2.elasticity)
-    kinetic    = min(collider1.kinetic_friction, collider2.kinetic_friction)
-    static     = min(collider1.static_friction, collider2.static_friction)
-    
-    # calculate impulses from contact points
-    if has_physics1 and has_physics2:
-        for contact_point in contact_points:
-            
-            # apply impulse based reduced by total points
-            radius1, radius2 = contact_point - center1, contact_point - center2
-            impulse = calculate_impulse2(node1, node2, inv_mass1, inv_mass2, node1.rotational_velocity, node2.rotational_velocity, radius1, radius2, inv_inertia1, inv_inertia2, elasticity, kinetic, static, normal)
-            
-            # apply impulses
-            apply_impulse(radius1, impulse, inv_inertia1, inv_mass1, node1)
-            apply_impulse(radius2, -impulse, inv_inertia2, inv_mass2, node2)
-            
-    elif has_physics1:
-        for contact_point in contact_points:
-            radius = contact_point - center1
-            impulse = calculate_impluse1(node1, inv_mass1, node1.rotational_velocity, radius, inv_inertia1, elasticity, kinetic, static, normal)
-            
-            # apply impulses
-            apply_impulse(radius, impulse, inv_inertia1, inv_mass1, node1)
-            
-    else: # only physics body 2
-        for contact_point in contact_points:
-            radius = contact_point - center2
-            impulse = calculate_impluse1(node2, inv_mass2, node2.rotational_velocity, radius, inv_inertia2, elasticity, kinetic, static, normal)
-            
-            # apply impulse
-            apply_impulse(radius, impulse, inv_inertia2, inv_mass2, node2)
-    
-def calculate_impluse1(node: Node, inv_mass, omega, radius, inv_inertia, elasticity, kinetic, static, normal) -> glm.vec3:
-    """
-    Calculates the impulse from a collision including friction from the impulse
-    """
-    # determine if mass needs to be calculated TODO determine if this is a good check
-    if glm.dot(radius, node.velocity) < 0: return glm.vec3(0, 0, 0)
-    
-    # normal impulse
-    relative_velocity        = node.velocity + glm.cross(omega, radius)
-    relative_normal_velocity = glm.dot(relative_velocity, normal)
-    
-    # calculate denominator
-    denominator = inv_mass + glm.dot(normal, glm.cross(inv_inertia * glm.cross(radius, normal), radius))
-    
-    # calculate normal impulse
-    normal_impulse_magnitude = -(1 + elasticity) * relative_normal_velocity / denominator
-    normal_impulse           = normal_impulse_magnitude * normal
-    
-    # friction impulse
-    rel_tan_vel     = relative_velocity - glm.dot(relative_velocity, normal) * normal
-    rel_tan_vel_len = glm.length(rel_tan_vel)
-    
-    if rel_tan_vel_len < 1e-7:   friction_impulse = glm.vec3(0, 0, 0)                                                   # no friction
-    elif rel_tan_vel_len < 1e-2: friction_impulse = -static * glm.length(normal_impulse) * glm.normalize(rel_tan_vel)   # static friction
-    else:                        friction_impulse = -kinetic * glm.length(normal_impulse) * glm.normalize(rel_tan_vel)  # kinetic friction
-    
-    # return total impulse
-    return normal_impulse + friction_impulse
-    
-def calculate_impulse2(node1: Node, node2: Node, inv_mass1, inv_mass2, omega1, omega2, radius1, radius2, inv_inertia1, inv_inertia2, elasticity, kinetic, static, normal) -> glm.vec3:
-    """
-    Calculates the impulse from a collision including friction from the impulse
-    """
-    # normal impulse
-    relative_velocity = node1.velocity + glm.cross(omega1, radius1) - (node2.velocity + glm.cross(omega2, radius2))
-    relative_normal_velocity = glm.dot(relative_velocity, normal)
-    # calculate denominator
-    term1 = inv_mass1 + inv_mass2
-    term2 = glm.dot(normal, glm.cross(inv_inertia1 * glm.cross(radius1, normal), radius1) + glm.cross(inv_inertia2 * glm.cross(radius2, normal), radius2))
-    # calculate normal impulse
-    normal_impulse = -(1 + elasticity) * relative_normal_velocity / (term1 + term2) * normal
-    
-    # friction impulse
-    rel_tan_vel = relative_velocity - glm.dot(relative_velocity, normal) * normal
-    rel_tan_vel_len = glm.length(rel_tan_vel)
-    if rel_tan_vel_len < 1e-7: friction_impulse = glm.vec3(0, 0, 0)
-    elif rel_tan_vel_len < 1e-2: friction_impulse = -static * glm.length(normal_impulse) * glm.normalize(rel_tan_vel)
-    else: friction_impulse = -kinetic * glm.length(normal_impulse) * glm.normalize(rel_tan_vel)
-    # return total impulse
-    return normal_impulse + friction_impulse
-
-def apply_impulse(radius, impulse_signed, inv_inertia, inv_mass, node: Node) -> None:
-    """
-    Applies the given impulse to the physics body, changing translational and rotational velcoity. 
-    """
-    
-    # Update linear velocity
-    node.velocity += impulse_signed * inv_mass
-    
-    # update rotational velcoity
+import glm
+from ..nodes.node import Node
+
+def calculate_collisions(normal:glm.vec3, node1: Node, node2: Node, contact_points:list[glm.vec3], inv_inertia1:glm.mat3x3, inv_inertia2:glm.mat3x3, center1:glm.vec3, center2:glm.vec3) -> None:
+    """
+    Resolve the collisions between two objects with multiple contact points
+    """
+    physics_body1 = node1.physics_body
+    physics_body2 = node2.physics_body
+    collider1 = node1.collider
+    collider2 = node2.collider
+    
+    # determine whether or not the colliders have physics
+    has_physics1, has_physics2 = physics_body1 is not None, physics_body2 is not None
+    
+    # get physics data from valid bodies
+    if has_physics1: inv_mass1 = 1 / physics_body1.mass
+    if has_physics2: inv_mass2 = 1 / physics_body2.mass
+    
+    # gets coefficients
+    elasticity = max(collider1.elasticity, collider2.elasticity)
+    kinetic    = min(collider1.kinetic_friction, collider2.kinetic_friction)
+    static     = min(collider1.static_friction, collider2.static_friction)
+    
+    # calculate impulses from contact points
+    if has_physics1 and has_physics2:
+        for contact_point in contact_points:
+            
+            # apply impulse based reduced by total points
+            radius1, radius2 = contact_point - center1, contact_point - center2
+            impulse = calculate_impulse2(node1, node2, inv_mass1, inv_mass2, node1.rotational_velocity, node2.rotational_velocity, radius1, radius2, inv_inertia1, inv_inertia2, elasticity, kinetic, static, normal)
+            
+            # apply impulses
+            apply_impulse(radius1, impulse, inv_inertia1, inv_mass1, node1)
+            apply_impulse(radius2, -impulse, inv_inertia2, inv_mass2, node2)
+            
+    elif has_physics1:
+        for contact_point in contact_points:
+            radius = contact_point - center1
+            impulse = calculate_impluse1(node1, inv_mass1, node1.rotational_velocity, radius, inv_inertia1, elasticity, kinetic, static, normal)
+            
+            # apply impulses
+            apply_impulse(radius, impulse, inv_inertia1, inv_mass1, node1)
+            
+    else: # only physics body 2
+        for contact_point in contact_points:
+            radius = contact_point - center2
+            impulse = calculate_impluse1(node2, inv_mass2, node2.rotational_velocity, radius, inv_inertia2, elasticity, kinetic, static, normal)
+            
+            # apply impulse
+            apply_impulse(radius, impulse, inv_inertia2, inv_mass2, node2)
+    
+def calculate_impluse1(node: Node, inv_mass, omega, radius, inv_inertia, elasticity, kinetic, static, normal) -> glm.vec3:
+    """
+    Calculates the impulse from a collision including friction from the impulse
+    """
+    # determine if mass needs to be calculated TODO determine if this is a good check
+    if glm.dot(radius, node.velocity) < 0: return glm.vec3(0, 0, 0)
+    
+    # normal impulse
+    relative_velocity        = node.velocity + glm.cross(omega, radius)
+    relative_normal_velocity = glm.dot(relative_velocity, normal)
+    
+    # calculate denominator
+    denominator = inv_mass + glm.dot(normal, glm.cross(inv_inertia * glm.cross(radius, normal), radius))
+    
+    # calculate normal impulse
+    normal_impulse_magnitude = -(1 + elasticity) * relative_normal_velocity / denominator
+    normal_impulse           = normal_impulse_magnitude * normal
+    
+    # friction impulse
+    rel_tan_vel     = relative_velocity - glm.dot(relative_velocity, normal) * normal
+    rel_tan_vel_len = glm.length(rel_tan_vel)
+    
+    if rel_tan_vel_len < 1e-7:   friction_impulse = glm.vec3(0, 0, 0)                                                   # no friction
+    elif rel_tan_vel_len < 1e-2: friction_impulse = -static * glm.length(normal_impulse) * glm.normalize(rel_tan_vel)   # static friction
+    else:                        friction_impulse = -kinetic * glm.length(normal_impulse) * glm.normalize(rel_tan_vel)  # kinetic friction
+    
+    # return total impulse
+    return normal_impulse + friction_impulse
+    
+def calculate_impulse2(node1: Node, node2: Node, inv_mass1, inv_mass2, omega1, omega2, radius1, radius2, inv_inertia1, inv_inertia2, elasticity, kinetic, static, normal) -> glm.vec3:
+    """
+    Calculates the impulse from a collision including friction from the impulse
+    """
+    # normal impulse
+    relative_velocity = node1.velocity + glm.cross(omega1, radius1) - (node2.velocity + glm.cross(omega2, radius2))
+    relative_normal_velocity = glm.dot(relative_velocity, normal)
+    # calculate denominator
+    term1 = inv_mass1 + inv_mass2
+    term2 = glm.dot(normal, glm.cross(inv_inertia1 * glm.cross(radius1, normal), radius1) + glm.cross(inv_inertia2 * glm.cross(radius2, normal), radius2))
+    # calculate normal impulse
+    normal_impulse = -(1 + elasticity) * relative_normal_velocity / (term1 + term2) * normal
+    
+    # friction impulse
+    rel_tan_vel = relative_velocity - glm.dot(relative_velocity, normal) * normal
+    rel_tan_vel_len = glm.length(rel_tan_vel)
+    if rel_tan_vel_len < 1e-7: friction_impulse = glm.vec3(0, 0, 0)
+    elif rel_tan_vel_len < 1e-2: friction_impulse = -static * glm.length(normal_impulse) * glm.normalize(rel_tan_vel)
+    else: friction_impulse = -kinetic * glm.length(normal_impulse) * glm.normalize(rel_tan_vel)
+    # return total impulse
+    return normal_impulse + friction_impulse
+
+def apply_impulse(radius, impulse_signed, inv_inertia, inv_mass, node: Node) -> None:
+    """
+    Applies the given impulse to the physics body, changing translational and rotational velcoity. 
+    """
+    
+    # Update linear velocity
+    node.velocity += impulse_signed * inv_mass
+    
+    # update rotational velcoity
     node.rotational_velocity += inv_inertia * glm.cross(radius, impulse_signed)

basilisk/physics/physics_body.py

@@ -1,44 +1,44 @@
-import glm
-
-class PhysicsBody():
-    physics_engine: ...
-    """Back reference to the parent physics engine"""
-    mass: float
-    """The mass of the physics body in kg"""
-
-    def __init__(self, mass:float=1.0) -> None:
-        self.physics_engine = None
-        self.mass = mass 
-        
-    def get_delta_velocity(self, dt: float) -> glm.vec3:
-        """
-        Returns the chnage in translational velocity from constant accelerations and forces
-        """
-        if not self.physics_engine: return None
-        
-        dv = glm.vec3(0, 0, 0)
-        for acceleration in self.physics_engine.accelerations: dv += acceleration * dt
-        for force in self.physics_engine.forces: dv += force / self.mass * dt
-        return dv
-        
-    def get_delta_rotational_velocity(self, dt: float) -> glm.quat:
-        """
-        Returns the delta rotation quaternion from constant accelerations and forces
-        """
-        if not self.physics_engine: return None
-        
-        dw = glm.vec3(0, 0, 0)
-        for rotational_acceleration in self.physics_engine.rotational_accelerations: dw += rotational_acceleration * dt
-        # TODO add torques
-        return dw
-    
-    @property
-    def physics_engine(self): return self._physics_engine
-
-    @physics_engine.setter
-    def physics_engine(self, value): 
-        self._physics_engine = value
-        if value: value.add(self)
-
-    def __repr__(self) -> str:
+import glm
+
+class PhysicsBody():
+    physics_engine: ...
+    """Back reference to the parent physics engine"""
+    mass: float
+    """The mass of the physics body in kg"""
+
+    def __init__(self, mass:float=1.0) -> None:
+        self.physics_engine = None
+        self.mass = mass 
+        
+    def get_delta_velocity(self, dt: float) -> glm.vec3:
+        """
+        Returns the chnage in translational velocity from constant accelerations and forces
+        """
+        if not self.physics_engine: return None
+        
+        dv = glm.vec3(0, 0, 0)
+        for acceleration in self.physics_engine.accelerations: dv += acceleration * dt
+        for force in self.physics_engine.forces: dv += force / self.mass * dt
+        return dv
+        
+    def get_delta_rotational_velocity(self, dt: float) -> glm.quat:
+        """
+        Returns the delta rotation quaternion from constant accelerations and forces
+        """
+        if not self.physics_engine: return None
+        
+        dw = glm.vec3(0, 0, 0)
+        for rotational_acceleration in self.physics_engine.rotational_accelerations: dw += rotational_acceleration * dt
+        # TODO add torques
+        return dw
+    
+    @property
+    def physics_engine(self): return self._physics_engine
+
+    @physics_engine.setter
+    def physics_engine(self, value): 
+        self._physics_engine = value
+        if value: value.add(self)
+
+    def __repr__(self) -> str:
         return f'<Physics Body| {self.mass}>'

basilisk/physics/physics_engine.py

@@ -1,36 +1,36 @@
-import glm
-from .physics_body import PhysicsBody
-
-class PhysicsEngine():
-    physics_bodies: list[PhysicsBody]
-    """Contains all the physics bodies controlled by this physics engine"""
-    accelerations: list[glm.vec3]
-    """Contains constant accelerations to be applied to physics bodies"""
-    rotational_accelerations: list[glm.vec3]
-    """Contains constant rotational accelerations to be applied to physics bodies"""
-    forces: list[glm.vec3]
-    """Contains constant forces to be applied to physics bodies"""
-    torques: list[glm.vec3]
-    """Contains constant rotational accelerations to be applied to physics bodies"""
-    
-    def __init__(self, accelerations: list[glm.vec3] = None, rotational_accelerations: list[glm.vec3] = None, forces: list[glm.vec3] = None, torques: list[glm.vec3] = None) -> None:
-        self.physics_bodies = []
-        self.accelerations = accelerations if accelerations else [glm.vec3(0, -9.8, 0)]
-        self.rotational_accelerations = rotational_accelerations if rotational_accelerations else []
-        self.forces = forces if forces else []
-        self.torques = torques if torques else []
-        
-    def add(self, physics_body: PhysicsBody) -> PhysicsBody:
-        """
-        Adds a physics body to the physics engine and returns it
-        """
-        self.physics_bodies.append(physics_body)
-        return physics_body
-    
-    def remove(self, physics_body: PhysicsBody) -> None:
-        """
-        Removes the physics body from the physics engine and disconnects it from the engine
-        """
-        if physics_body in self.physics_bodies: 
-            self.physics_bodies.remove(physics_body)
+import glm
+from .physics_body import PhysicsBody
+
+class PhysicsEngine():
+    physics_bodies: list[PhysicsBody]
+    """Contains all the physics bodies controlled by this physics engine"""
+    accelerations: list[glm.vec3]
+    """Contains constant accelerations to be applied to physics bodies"""
+    rotational_accelerations: list[glm.vec3]
+    """Contains constant rotational accelerations to be applied to physics bodies"""
+    forces: list[glm.vec3]
+    """Contains constant forces to be applied to physics bodies"""
+    torques: list[glm.vec3]
+    """Contains constant rotational accelerations to be applied to physics bodies"""
+    
+    def __init__(self, accelerations: list[glm.vec3] = None, rotational_accelerations: list[glm.vec3] = None, forces: list[glm.vec3] = None, torques: list[glm.vec3] = None) -> None:
+        self.physics_bodies = []
+        self.accelerations = accelerations if accelerations else [glm.vec3(0, -9.8, 0)]
+        self.rotational_accelerations = rotational_accelerations if rotational_accelerations else []
+        self.forces = forces if forces else []
+        self.torques = torques if torques else []
+        
+    def add(self, physics_body: PhysicsBody) -> PhysicsBody:
+        """
+        Adds a physics body to the physics engine and returns it
+        """
+        self.physics_bodies.append(physics_body)
+        return physics_body
+    
+    def remove(self, physics_body: PhysicsBody) -> None:
+        """
+        Removes the physics body from the physics engine and disconnects it from the engine
+        """
+        if physics_body in self.physics_bodies: 
+            self.physics_bodies.remove(physics_body)
             physics_body.physics_engine = None

basilisk/render/batch.py

@@ -1,104 +1,104 @@
-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"""
-    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
-    """Buffer containing all the batch data"""
-
-    def __init__(self, chunk) -> None:
-        """
-        Basilik batch object
-        Contains all the data for a chunk batch to be stored and rendered
-        """
-        
-        # Back references
-        self.chunk = chunk
-        self.ctx = chunk.chunk_handler.engine.ctx
-        self.shader = self.chunk.get_shader()
-
-        # Set intial values
-        self.vbo = None
-        self.vao = None
-
-    def batch(self) -> bool:
-        """
-        Batches all the node meshes in the chunks bounds.
-        Returns True if batch was successful.
-        """
-
-        self.shader = self.chunk.get_shader()
-
-        # Empty list to contain all vertex data of models in the chunk
-        batch_data = []
-
-        # Loop through each node in the chunk, adding the nodes's mesh to batch_data
-        index = 0
-        for node in self.chunk.nodes:
-            # Check that the node should be used
-            if not node.mesh: continue
-            if node.static != self.chunk.static: continue
-
-            # Get the data from the node
-            node_data = node.get_data()
-            # Update the index
-            node.data_index = index
-            index += len(node_data)
-            # Add to the chunk mesh
-            batch_data.append(node_data)
-
-        # Combine all meshes into a single array
-        if len(batch_data) > 1: batch_data = np.vstack(batch_data)
-        else: batch_data = np.array(batch_data, dtype='f4')
-
-
-        # If there are no verticies, delete the chunk
-        if len(batch_data) == 0: return False
-
-        if self.vbo: self.vbo.release()
-        if self.vao: self.vao.release()
-
-        # Create the vbo and the vao from mesh data
-        self.vbo = self.ctx.buffer(batch_data)
-        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):
-        """
-        Swap the shader without rebatching
-        """
-        
-        # Check there is actually something to swap
-        if not self.vao: return
-        
-        # Release old data
-        self.vao.release()
-
-        # Make new vao with old data
-        self.program = shader.program
-        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)
-
-
-    def __repr__(self) -> str:
-        return f'<Basilisk Batch | {self.chunk.chunk_key}, {self.vbo.size / 1024  / 1024} mb>'
-
-    def __del__(self) -> None:
-        """
-        Deallocates the mesh vbo and vao
-        """
-        
-        if self.vbo: self.vbo.release()
+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"""
+    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
+    """Buffer containing all the batch data"""
+
+    def __init__(self, chunk) -> None:
+        """
+        Basilik batch object
+        Contains all the data for a chunk batch to be stored and rendered
+        """
+        
+        # Back references
+        self.chunk = chunk
+        self.ctx = chunk.chunk_handler.engine.ctx
+        self.shader = self.chunk.get_shader()
+
+        # Set intial values
+        self.vbo = None
+        self.vao = None
+
+    def batch(self) -> bool:
+        """
+        Batches all the node meshes in the chunks bounds.
+        Returns True if batch was successful.
+        """
+
+        self.shader = self.chunk.get_shader()
+
+        # Empty list to contain all vertex data of models in the chunk
+        batch_data = []
+
+        # Loop through each node in the chunk, adding the nodes's mesh to batch_data
+        index = 0
+        for node in self.chunk.nodes:
+            # Check that the node should be used
+            if not node.mesh: continue
+            if node.static != self.chunk.static: continue
+
+            # Get the data from the node
+            node_data = node.get_data()
+            # Update the index
+            node.data_index = index
+            index += len(node_data)
+            # Add to the chunk mesh
+            batch_data.append(node_data)
+
+        # Combine all meshes into a single array
+        if len(batch_data) > 1: batch_data = np.vstack(batch_data)
+        else: batch_data = np.array(batch_data, dtype='f4')
+
+
+        # If there are no verticies, delete the chunk
+        if len(batch_data) == 0: return False
+
+        if self.vbo: self.vbo.release()
+        if self.vao: self.vao.release()
+
+        # Create the vbo and the vao from mesh data
+        self.vbo = self.ctx.buffer(batch_data)
+        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):
+        """
+        Swap the shader without rebatching
+        """
+        
+        # Check there is actually something to swap
+        if not self.vao: return
+        
+        # Release old data
+        self.vao.release()
+
+        # Make new vao with old data
+        self.program = shader.program
+        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)
+
+
+    def __repr__(self) -> str:
+        return f'<Basilisk Batch | {self.chunk.chunk_key}, {self.vbo.size / 1024  / 1024} mb>'
+
+    def __del__(self) -> None:
+        """
+        Deallocates the mesh vbo and vao
+        """
+        
+        if self.vbo: self.vbo.release()
         if self.vao: self.vao.release()