About to implement physics

src/dawn/physics/3d/AABB3D.cpp

@@ -15,18 +15,18 @@ bool_t Dawn::aabb3dIntersect(struct AABB3D cube1, struct AABB3D cube2) {
   );
 }
 
-bool aabbSweep(
+bool_t aabb3dSweep(
-  const glm::vec3& pos1, const glm::vec3& size1, const glm::vec3& vel1,
+  struct AABB3D cube1, glm::vec3 velocity1,
-  const glm::vec3& pos2, const glm::vec3& size2, const glm::vec3& vel2,
+  struct AABB3D cube2, glm::vec3 velocity2,
-  float& fraction
+  glm::vec3 *normal
 ) {
   glm::vec3 relVel = vel1 - vel2;
   glm::vec3 relPos = pos1 - pos2;
 
   // If the relative velocity is zero, the cubes are already intersecting
-  i (glm::length2(relVel) == 0.0f) {
+  if(glm::length2(relVel) == 0.0f) {
-      fraction = 0.0f;
+    fraction = 0.0f;
-      return true;
+    return true;
   }
 
   // Expand the size of the cubes by the magnitude of the relative velocity
@@ -34,29 +34,29 @@ bool aabbSweep(
   glm::vec3 size2exp = size2 + glm::abs(relVel);
 
   // Compute the times at which the cubes first and last overlap on each axis
-  float tminx = (size1exp.x + size2exp.x - glm::abs(relPos.x)) / glm::abs(relVel.x);
+  float_t tminx = (size1exp.x + size2exp.x - glm::abs(relPos.x)) / glm::abs(relVel.x);
-  float tmaxx = (size1.x + size2.x - glm::abs(relPos.x)) / glm::abs(relVel.x);
+  float_t tmaxx = (size1.x + size2.x - glm::abs(relPos.x)) / glm::abs(relVel.x);
-  float tminy = (size1exp.y + size2exp.y - glm::abs(relPos.y)) / glm::abs(relVel.y);
+  float_t tminy = (size1exp.y + size2exp.y - glm::abs(relPos.y)) / glm::abs(relVel.y);
-  float tmaxy = (size1.y + size2.y - glm::abs(relPos.y)) / glm::abs(relVel.y);
+  float_t tmaxy = (size1.y + size2.y - glm::abs(relPos.y)) / glm::abs(relVel.y);
-  float tminz = (size1exp.z + size2exp.z - glm::abs(relPos.z)) / glm::abs(relVel.z);
+  float_t tminz = (size1exp.z + size2exp.z - glm::abs(relPos.z)) / glm::abs(relVel.z);
-  float tmaxz = (size1.z + size2.z - glm::abs(relPos.z)) / glm::abs(relVel.z);
+  float_t tmaxz = (size1.z + size2.z - glm::abs(relPos.z)) / glm::abs(relVel.z);
 
   // Find the earliest and latest times of overlap
-  float tmin = glm::max(glm::max(glm::min(tminx, tmaxx), glm::min(tminy, tmaxy)), glm::min(tminz, tmaxz));
+  float_t tmin = glm::max(glm::max(glm::min(tminx, tmaxx), glm::min(tminy, tmaxy)), glm::min(tminz, tmaxz));
-  float tmax = glm::min(glm::min(glm::max(tminx, tmaxx), glm::max(tminy, tmaxy)), glm::max(tminz, tmaxz));
+  float_t tmax = glm::min(glm::min(glm::max(tminx, tmaxx), glm::max(tminy, tmaxy)), glm::max(tminz, tmaxz));
 
   // If the earliest time of overlap is greater than the length of the timestep, the cubes
   // will not collide during the timestep
   if (tmin > 1.0f) {
-      fraction = 1.0f;
+    fraction = 1.0f;
-      return false;
+    return false;
   }
 
   // If the latest time of overlap is less than or equal to zero, the cubes are already
   // colliding and will collide throughout the timestep
-  if (tmax <= 0.0f) {
+  if(tmax <= 0.0f) {
-      fraction = 0.0f;
+    fraction = 0.0f;
-      return true;
+    return true;
   }
 
   // Compute the fraction of the timestep at which the collision occurs

src/dawn/physics/3d/AABB3D.hpp

@@ -22,4 +22,9 @@ namespace Dawn {
   bool_t aabb3dIntersect(struct AABB3D cube1, struct AABB3D cube2);
 
   
+  bool_t aabb3dSweep(
+    glm::vec3 pos1, glm::vec3 size1, glm::vec3 vel1,
+    glm::vec3 pos2, glm::vec3 size2, glm::vec3 vel2,
+    float_t& fraction
+  );
 }

src/dawn/physics/3d/Ray3D.cpp

@@ -29,7 +29,6 @@ bool_t Dawn::raytestSphere(
   *normal = glm::normalize(*hit - sphere.center);
   *distance = t0;
 
-
   return true;
 }
 

src/dawn/scene/components/physics/3d/CMakeLists.txt

@@ -10,4 +10,5 @@ target_sources(${DAWN_TARGET_NAME}
     CubeCollider.cpp
     CapsuleCollider.cpp
     SphereCollider.cpp
+    CharacterController3D.cpp
 )

src/dawn/scene/components/physics/3d/CharacterController3D.cpp

@@ -0,0 +1,35 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "CharacterController3D.hpp"
+
+using namespace Dawn;
+
+CharacterController3D::CharacterController3D(SceneItem *item) :
+  SceneItemComponent(item)
+{
+
+}
+
+void CharacterController3D::onStart() {
+  useEvent([&](float_t delta){
+    // Friction
+    velocity -= glm::vec3(velocity.x, 0, velocity.z) * friction * delta;
+
+    // Gravity
+    velocity += this->gravity * delta;
+
+    auto myCollider = item->getComponent<Collider3D>();
+    auto colliders = getScene()->findComponents<Collider3D>();
+    auto itCollider = colliders.begin();
+    while(itCollider != colliders.end()) {
+      (*itCollider)->
+      ++itCollider;
+    }
+
+    // Move / Update
+    transform->setLocalPosition(transform->getLocalPosition() + (velocity * delta));
+  }, getScene()->eventSceneUpdate);
+}

src/dawn/scene/components/physics/3d/CharacterController3D.hpp

@@ -0,0 +1,20 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "Collider3D.hpp"
+
+namespace Dawn {
+  class CharacterController3D : public SceneItemComponent {
+    public:
+      glm::vec3 velocity = glm::vec3(0, 0, 0);
+      glm::vec3 gravity = glm::vec3(0, -1, 0);
+      float_t friction = 12.0f;
+
+      CharacterController3D(SceneItem *item);
+
+      void onStart() override;
+  };
+}

src/dawnrose/scene/components/PlayerController.cpp

@@ -14,13 +14,18 @@ PlayerController::PlayerController(SceneItem *item) : SceneItemComponent(item) {
 
 }
 
-void PlayerController::onStart() {
+std::vector<SceneItemComponent*> PlayerController::getDependencies() {
-  useEvent([&](float_t delta){
+  return {
-    auto camera = getScene()->findComponent<Camera>();
+    (this->characterController = item->getComponent<CharacterController3D>())
-    assertNotNull(camera);
+  };
+}
 
-    // Friction
+void PlayerController::onStart() {
-    velocity -= velocity * friction * delta;
+  assertNotNull(this->characterController);
+
+  useEvent([&](float_t delta){
+    // auto camera = getScene()->findComponent<Camera>();
+    // assertNotNull(camera);
 
     // Movement
     auto inputMove = getGame()->inputManager.getAxis2D(
@@ -31,40 +36,7 @@ void PlayerController::onStart() {
     if(inputMove.x != 0 || inputMove.y != 0) {
       float_t angle = atan2(inputMove.y, inputMove.x);
       glm::vec3 movement = glm::vec3(cos(angle), 0, sin(angle));
-      velocity += movement * delta * moveSpeed;
+      characterController->velocity += movement * delta * moveSpeed;
     }
-
-    // Move / Update
-    transform->setLocalPosition(transform->getLocalPosition() + (velocity * delta));
-
-
-    // tEST
-    auto collider = item->getComponent<Collider3D>();
-    assertNotNull(collider);
-    Collider3DRayResult result;
-
-    struct Ray3D ray;
-    ray.origin = glm::vec3(0, 0.0f, 5);
-    ray.direction = glm::vec3(0, 0.0f, -4);
-
-    struct Color color = COLOR_MAGENTA;
-
-    if(collider->raycast(&result, ray)) {
-      // std::cout << "Collide!" << std::endl;
-      color = COLOR_WHITE;
-
-      getScene()->debugRay({
-        .start = result.point,
-        .direction = result.normal,
-        .color = COLOR_GREEN
-      });
-    }
-
-    getScene()->debugRay({
-      .start = ray.origin,
-      .direction = ray.direction,
-      .color = color
-    });
-
   }, getScene()->eventSceneUpdate);
 }

src/dawnrose/scene/components/PlayerController.hpp

@@ -4,17 +4,20 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "scene/SceneItemComponent.hpp"
+#include "scene/components/physics/3d/CharacterController3D.hpp"
 
 namespace Dawn {
   class PlayerController : public SceneItemComponent {
+    protected:
+      CharacterController3D *characterController;
+
     public:
-      glm::vec3 velocity;
       float_t moveSpeed = 40.0f;
-      float_t friction = 12.0f;
 
       PlayerController(SceneItem *item);
 
+      std::vector<SceneItemComponent*> getDependencies() override;
+
       void onStart() override;
   };
 }

src/dawnrose/scenes/HelloWorldScene.hpp

@@ -14,7 +14,9 @@
 #include "scene/components/example/ExampleSpin.hpp"
 #include "scene/components/physics/3d/SphereCollider.hpp"
 #include "scene/components/physics/3d/CubeCollider.hpp"
+#include "scene/components/physics/3d/CapsuleCollider.hpp"
 #include "display/mesh/SphereMesh.hpp"
+#include "display/mesh/CapsuleMesh.hpp"
 
 namespace Dawn {
   class HelloWorldScene : public Scene {
@@ -28,16 +30,19 @@ namespace Dawn {
         playerItem->addComponent<MeshRenderer>();
         auto meshHost = playerItem->addComponent<MeshHost>();
         playerItem->addComponent<SimpleTexturedMaterial>();
-        auto hitbox = playerItem->addComponent<SphereCollider>();
+        auto hitbox = playerItem->addComponent<CapsuleCollider>();
-        SphereMesh::createSphere(&meshHost->mesh, hitbox->radius, 32, 32);
+        playerItem->addComponent<CharacterController3D>();
+        CapsuleMesh::create(&meshHost->mesh, hitbox->radius, hitbox->height);
+
+        playerItem->transform.setLocalPosition(glm::vec3(0, 4, 0));
 
         auto wall = this->createSceneItem();
         auto wallHitbox = wall->addComponent<CubeCollider>();
-        wall->transform.setLocalPosition(glm::vec3(-10, 0, 0));
+        // wall->transform.setLocalPosition(glm::vec3(-5, -1, -5));
-        wallHitbox->min = -(wallHitbox->max = glm::vec3(1, 1, 5));
+        wallHitbox->min = -(wallHitbox->max = glm::vec3(5, 0.25f, 5));
 
         camera = Camera::create(this);
-        camera->transform->lookAt(glm::vec3(4, 4, 4), glm::vec3(0, 0, 0));
+        camera->transform->lookAt(glm::vec3(10, 10, 10), glm::vec3(0, 0, 0));
         // auto gameCamera = camera->item->addComponent<GameCamera>();
         // gameCamera->player = player;
       }