Add basic physics demo

Author: codebycruz

src/components/physics.hpp

@@ -18,4 +18,9 @@ namespace components {
   struct AngularAcceleration {
     glm::vec3 value;
   };
+
+  // Box collider for collision detection
+  struct BoxCollider {
+    glm::vec3 halfExtents;
+  };
 };

src/plugins/physics/physics.cpp

@@ -10,11 +10,42 @@
 #include <glm/gtc/quaternion.hpp>
 #define GLM_ENABLE_EXPERIMENTAL
 #include <glm/gtx/quaternion.hpp>
+#include <vector>
+#include <print>
+
+bool plugins::Physics::checkAABBCollision(const glm::vec3& pos1, const glm::vec3& halfExtents1, const glm::vec3& pos2,
+                                          const glm::vec3& halfExtents2, glm::vec3& penetrationDepth) {
+  // Calculate the distance between centers
+  glm::vec3 distance = pos1 - pos2;
+
+  // Calculate the sum of half extents
+  glm::vec3 totalHalfExtents = halfExtents1 + halfExtents2;
+
+  // Check for overlap on all axes
+  glm::vec3 overlap = totalHalfExtents - glm::abs(distance);
+
+  // If any axis has no overlap, there's no collision
+  if (overlap.x <= 0.0f || overlap.y <= 0.0f || overlap.z <= 0.0f) {
+    return false;
+  }
+
+  // Find the axis with minimum overlap (this is our separation axis)
+  if (overlap.x <= overlap.y && overlap.x <= overlap.z) {
+    penetrationDepth = glm::vec3(overlap.x * (distance.x < 0 ? -1.0f : 1.0f), 0.0f, 0.0f);
+  } else if (overlap.y <= overlap.z) {
+    penetrationDepth = glm::vec3(0.0f, overlap.y * (distance.y < 0 ? -1.0f : 1.0f), 0.0f);
+  } else {
+    penetrationDepth = glm::vec3(0.0f, 0.0f, overlap.z * (distance.z < 0 ? -1.0f : 1.0f));
+  }
+
+  return true;
+}
 
 void plugins::Physics::build(Game& game) {
   game.addSystem(Schedule::Update, [](std::shared_ptr<entt::registry>& registry, resources::Time& time) {
     float deltaTime = time.deltaTime;
 
+    // Update velocities first
     registry->view<components::AngularVelocity, components::AngularAcceleration>().each(
         [&registry, deltaTime](entt::entity entity, auto& angularVelocity, const auto& angularAcceleration) {
           angularVelocity.value += angularAcceleration.value * deltaTime;
@@ -27,6 +58,15 @@ void plugins::Physics::build(Game& game) {
           registry->replace<components::Velocity>(entity, velocity);
         });
 
+    // Store original positions for collision detection
+    auto colliderView = registry->view<components::Position, components::BoxCollider>();
+    std::vector<std::pair<entt::entity, glm::vec3>> originalPositions;
+
+    for (auto entity : colliderView) {
+      auto& pos = colliderView.get<components::Position>(entity);
+      originalPositions.emplace_back(entity, pos.value);
+    }
+
     // Update rotation based on angular velocity
     registry->view<components::Rotation, components::AngularVelocity>().each(
         [&registry, deltaTime](entt::entity entity, auto& rotation, const auto& angularVelocity) {
@@ -41,10 +81,117 @@ void plugins::Physics::build(Game& game) {
           }
         });
 
+    // Update positions based on velocity
     registry->view<components::Position, components::Velocity>().each(
         [&registry, deltaTime](entt::entity entity, auto& position, const auto& velocity) {
           position.value += velocity.value * deltaTime;
           registry->replace<components::Position>(entity, position);
         });
+
+    // Collision detection and response
+    std::vector<plugins::physics::components::CollisionEvent> collisionEvents;
+
+    // Check all pairs of colliders
+    for (auto entity1 : colliderView) {
+      auto& pos1 = colliderView.get<components::Position>(entity1);
+      auto& collider1 = colliderView.get<components::BoxCollider>(entity1);
+
+      for (auto entity2 : colliderView) {
+        // Don't check collision with self
+        if (entity1 >= entity2)
+          continue;
+
+        auto& pos2 = colliderView.get<components::Position>(entity2);
+        auto& collider2 = colliderView.get<components::BoxCollider>(entity2);
+
+        glm::vec3 penetrationDepth;
+        if (checkAABBCollision(pos1.value, collider1.halfExtents, pos2.value, collider2.halfExtents, penetrationDepth)) {
+          // Create collision event
+          plugins::physics::components::CollisionEvent event;
+          event.entity1 = entity1;
+          event.entity2 = entity2;
+          event.penetrationDepth = penetrationDepth;
+          collisionEvents.push_back(event);
+
+          // Improved collision response
+          glm::vec3 collisionNormal = glm::normalize(penetrationDepth);
+          float penetrationMagnitude = glm::length(penetrationDepth);
+
+          // Separate objects by full penetration distance plus small margin
+          glm::vec3 separation = collisionNormal * (penetrationMagnitude + 0.001f);
+
+          // Check if entities have velocity to determine mass-like behavior
+          auto* vel1 = registry->try_get<components::Velocity>(entity1);
+          auto* vel2 = registry->try_get<components::Velocity>(entity2);
+
+          if (vel1 && vel2) {
+            // Both objects can move - split separation
+            pos1.value += separation * 0.5f;
+            pos2.value -= separation * 0.5f;
+
+            // Apply velocity changes for bouncing/energy loss
+            float restitution = 0.3f; // Energy loss factor
+            glm::vec3 relativeVelocity = vel1->value - vel2->value;
+            float velocityAlongNormal = glm::dot(relativeVelocity, collisionNormal);
+
+            if (velocityAlongNormal > 0) {
+              continue; // Objects separating
+            }
+
+            float impulse = -(1 + restitution) * velocityAlongNormal;
+            glm::vec3 impulseVector = impulse * collisionNormal;
+
+            vel1->value += impulseVector * 0.5f;
+            vel2->value -= impulseVector * 0.5f;
+
+            registry->replace<components::Velocity>(entity1, *vel1);
+            registry->replace<components::Velocity>(entity2, *vel2);
+          } else if (vel1) {
+            // Only entity1 can move (entity2 is static)
+            pos1.value += separation;
+            if (glm::dot(vel1->value, collisionNormal) < 0) {
+              // Remove velocity component in collision direction
+              vel1->value -= glm::dot(vel1->value, collisionNormal) * collisionNormal * 1.3f;
+              registry->replace<components::Velocity>(entity1, *vel1);
+            }
+          } else if (vel2) {
+            // Only entity2 can move (entity1 is static)
+            pos2.value -= separation;
+            if (glm::dot(vel2->value, collisionNormal) > 0) {
+              // Remove velocity component in collision direction
+              vel2->value -= glm::dot(vel2->value, collisionNormal) * collisionNormal * 1.3f;
+              registry->replace<components::Velocity>(entity2, *vel2);
+            }
+          } else {
+            // Both are static - just separate
+            pos1.value += separation * 0.5f;
+            pos2.value -= separation * 0.5f;
+          }
+
+          // Update positions in registry
+          registry->replace<components::Position>(entity1, pos1);
+          registry->replace<components::Position>(entity2, pos2);
+        }
+      }
+    }
+
+    // Process collision callbacks
+    for (const auto& event : collisionEvents) {
+      // Check if entities have collision callbacks
+      auto* callback1 = registry->try_get<plugins::physics::components::CollisionCallback>(event.entity1);
+      auto* callback2 = registry->try_get<plugins::physics::components::CollisionCallback>(event.entity2);
+
+      if (callback1 && callback1->onCollisionEnter) {
+        callback1->onCollisionEnter(event);
+      }
+      if (callback2 && callback2->onCollisionEnter) {
+        // Create event from entity2's perspective
+        plugins::physics::components::CollisionEvent reverseEvent = event;
+        reverseEvent.entity1 = event.entity2;
+        reverseEvent.entity2 = event.entity1;
+        reverseEvent.penetrationDepth = -event.penetrationDepth;
+        callback2->onCollisionEnter(reverseEvent);
+      }
+    }
   });
 }

src/plugins/physics/physics.hpp

@@ -2,8 +2,30 @@
 
 class Game;
 
+#include <glm/glm.hpp>
+#include <functional>
+#include <entt/entt.hpp>
+
 namespace plugins {
+  namespace physics::components {
+    struct CollisionEvent {
+      entt::entity entity1;
+      entt::entity entity2;
+      glm::vec3 penetrationDepth;
+    };
+
+    struct CollisionCallback {
+      std::function<void(const CollisionEvent&)> onCollisionEnter;
+      std::function<void(const CollisionEvent&)> onCollisionStay;
+      std::function<void(const CollisionEvent&)> onCollisionExit;
+    };
+  };
+
   struct Physics {
     void build(Game& game);
+
+  private:
+    static bool checkAABBCollision(const glm::vec3& pos1, const glm::vec3& halfExtents1, const glm::vec3& pos2,
+                                   const glm::vec3& halfExtents2, glm::vec3& penetrationDepth);
   };
 };

src/scenes/nfs.cpp

@@ -106,10 +106,27 @@ static void createLightsForEmissiveMaterials(const asset::Asset3D& cityAsset, st
   }
 }
 
-static std::expected<void, std::string> startup(/* clang-format off */
+static std::expected<void, std::string>
+startup(/* clang-format off */
   std::shared_ptr<entt::registry> registry,
-  std::shared_ptr<Renderer> renderer
-) { /* clang-format on */
+  std::shared_ptr<Renderer> renderer,
+  std::shared_ptr<scenes::nfs::resources::CrateAsset> crateAsset /* clang-format on */
+) {
+  {
+    auto crateResult = asset::loader::Gltf::tryFromFile("resources/CrateBox.glb", *renderer->textureManager3D);
+    if (!crateResult.has_value()) {
+      return std::unexpected{std::format("Failed to load crate asset: {}", util::error::indent(crateResult.error()))};
+    }
+
+    crateAsset->asset = renderer->createAsset3D(crateResult.value());
+  }
+
+  { // baseplate 1000x1000 (invisible)
+    auto baseplateEnt = registry->create();
+    registry->emplace<components::Position>(baseplateEnt, glm::vec3(0.0f, 0.0f, -0.2f));
+    registry->emplace<components::BoxCollider>(baseplateEnt, glm::vec3(500.0f, 500.0f, 0.05f));
+  }
+
   {
     auto asset = asset::loader::Gltf::tryFromFile("resources/CarConcept/CarConcept.gltf", *renderer->textureManager3D);
     if (!asset.has_value()) {
@@ -133,18 +150,19 @@ static std::expected<void, std::string> startup(/* clang-format off */
     registry->emplace<components::Velocity>(ent, glm::vec3(0.0f, 0.0f, 0.0f));
     registry->emplace<components::AngularVelocity>(ent, glm::vec3(0.0f, 0.0f, 0.0f));
     registry->emplace<scenes::nfs::components::Car>(ent); // mark as car entity
+    registry->emplace<components::BoxCollider>(ent, glm::vec3(0.5f, 0.5f, 0.20f));
 
     auto cubeModel = std::make_shared<model::Cube>(glm::vec3(1.0f));
 
     auto cubeEnt = registry->create();
-    registry->emplace<components::Position>(cubeEnt, -constants::WORLD_FORWARD * 5.0f);
+    registry->emplace<components::Position>(cubeEnt, constants::WORLD_RIGHT * 5.0f);
     registry->emplace<components::Child>(cubeEnt, ent); // make it a child of the car
     registry->emplace<components::Model3D>(cubeEnt, cubeModel);
 
     std::vector<entt::entity> carChildren;
     carChildren.push_back(cubeEnt);
 
-    registry->emplace<components::Parent>(ent, carChildren); // make car a parent of the cube
+    registry->emplace<components::Parent>(ent, carChildren);
   }
 
   { // city
@@ -188,10 +206,24 @@ static std::expected<void, std::string> startup(/* clang-format off */
 static std::expected<void, std::string> update(/* clang-format off */
   std::shared_ptr<entt::registry> registry,
   std::shared_ptr<Renderer> renderer,
-  std::shared_ptr<scenes::nfs::components::CameraState> cameraState,
+  std::shared_ptr<scenes::nfs::resources::CameraState> cameraState,
+  std::shared_ptr<scenes::nfs::resources::CrateAsset> crateAsset,
   resources::Time& time
 ) { /* clang-format on */
 
+  if (input::Mouse::wasJustPressed(input::MouseButton::Left)) {
+    auto boxAsset = std::make_shared<model::Cube>(glm::vec3(1.0f));
+
+    // Create the box entity
+    auto boxEntity = registry->create();
+    registry->emplace<components::Position>(boxEntity, glm::vec3(0.0f, 0.0f, 20.0f));
+    // registry->emplace<components::Scale>(boxEntity, glm::vec3(0.03f));
+    registry->emplace<components::Model3D>(boxEntity, boxAsset);
+    registry->emplace<components::Velocity>(boxEntity, glm::vec3(0.0f, 0.0f, 0.0f));
+    registry->emplace<components::Acceleration>(boxEntity, constants::WORLD_GRAVITY);
+    registry->emplace<components::BoxCollider>(boxEntity, glm::vec3(0.5f));
+  }
+
   // Car controller system
   auto carView = registry->view<components::Position, components::Rotation, components::Velocity, components::AngularVelocity,
                                 scenes::nfs::components::Car>();
@@ -361,9 +393,12 @@ static std::expected<void, std::string> update(/* clang-format off */
 }
 
 void scenes::nfs::NFS::build(Game& game) {
-  auto cameraState = std::make_shared<scenes::nfs::components::CameraState>();
+  auto cameraState = std::make_shared<scenes::nfs::resources::CameraState>();
   game.addResource(cameraState);
 
+  auto crateAsset = std::make_shared<scenes::nfs::resources::CrateAsset>();
+  game.addResource(crateAsset);
+
   game.addSystem(Schedule::Startup, startup);
   game.addSystem(Schedule::Update, update);
 }

src/scenes/nfs.hpp

@@ -3,10 +3,14 @@
 
 class Game;
 
+#include "render/model/3d/asset.hpp"
+
 namespace scenes::nfs {
   namespace components {
     struct Car {};
+  };
 
+  namespace resources {
     struct CameraState {
       float yaw = 0.0f;       // Horizontal rotation around the car
       float pitch = -0.1f;    // Vertical angle (looking down slightly at the car)
@@ -24,6 +28,10 @@ namespace scenes::nfs {
       float targetYaw = 0.0f;    // Target yaw (behind the car)
       float targetPitch = -0.1f; // Target pitch (slightly down)
     };
+
+    struct CrateAsset {
+      std::shared_ptr<model::Asset> asset; // The crate 3D model asset
+    };
   };
 
   struct NFS {