Removed physics for now.

archive/physics_components/2d/BoxCollider.cpp

@@ -0,0 +1,16 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "BoxCollider.hpp"
+
+using namespace Dawn;
+
+BoxCollider::BoxCollider(std::weak_ptr<SceneItem> item) : Collider2D(item) {
+  
+}
+
+enum Collider2DType BoxCollider::getColliderType() {
+  return COLLIDER2D_TYPE_BOX;
+}

archive/physics_components/2d/BoxCollider.hpp

@@ -0,0 +1,22 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "Collider2D.hpp"
+#include "physics/2d/Box.hpp"
+#include "physics/2d/Physics2D.hpp"
+
+namespace Dawn {
+  class BoxCollider : public Collider2D {
+    public:
+      // @optional
+      glm::vec2 min = glm::vec2(-0.5f, -0.5f);
+      // @optional
+      glm::vec2 max = glm::vec2( 0.5f,  0.5f);
+
+      BoxCollider(std::weak_ptr<SceneItem> item);
+      enum Collider2DType getColliderType() override;
+  };
+}

archive/physics_components/2d/CMakeLists.txt

@@ -0,0 +1,14 @@
+# Copyright (c) 2023 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    BoxCollider.cpp
+    Collider2D.cpp
+    CharacterController2D.cpp
+    SolidController2D.cpp
+    TriggerController2D.cpp
+)

archive/physics_components/2d/CharacterController2D.cpp

@@ -0,0 +1,92 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "CharacterController2D.hpp"
+
+using namespace Dawn;
+
+CharacterController2D::CharacterController2D(std::weak_ptr<SceneItem> i) :
+  SceneItemComponent(i)
+{
+}
+
+void CharacterController2D::onStart() {
+  useEvent([&](float_t delta){
+    // if(velocity == glm::vec2(0, 0)) return;
+
+    // Common variables
+    auto item = this->item.lock();
+    auto myCollider = item->getComponent<Collider2D>();
+
+    // Friction
+    velocity -= velocity * friction * delta;
+
+    // Solid Collision Check
+    glm::vec2 moveAmount;
+    if(myCollider == nullptr) {
+      moveAmount = velocity;
+    } else {
+      // Perform sweep
+      auto allColliders = getScene()->findComponents<SolidController2D>();
+      auto itColliders = allColliders.begin();
+
+      struct CharacterController2DCollisionEventInfo info;
+      bool_t result = false;
+
+      // Check for collisions, definitely not working 100% yet 
+      while(itColliders != allColliders.end()) {
+        auto c = *itColliders;
+        ++itColliders;
+        auto cItem = c->item.lock();
+        if(cItem == item || cItem->isChildOf(item)) continue;
+        result = c->getCollidingResult(
+          velocity,
+          myCollider,
+          info.normal,
+          info.entryTime,
+          info.exitTime,
+          info.entryPoint,
+          info.exitPoint
+        ) && info.entryTime <= delta;
+
+        if(result) {
+          info.collider = c;
+          break;
+        }
+      }
+      
+      if(result) {
+        moveAmount = glm::vec2(0, 0);
+        velocity = glm::vec2(0, 0);
+        this->eventCollision.invoke(info);
+      } else {
+        moveAmount = velocity;
+      }
+    }
+
+    if(moveAmount != glm::vec2(0, 0)) {
+      item->setLocalPosition(
+        item->getLocalPosition() + (glm::vec3(moveAmount.x, 0, moveAmount.y) * delta)
+      );
+    }
+
+    // Now perform trigger collision check
+    auto allTriggers = getScene()->findComponents<TriggerController2D>();
+    auto itTriggers = allTriggers.begin();
+    while(itTriggers != allTriggers.end()) {
+      auto c = *itTriggers;
+      ++itTriggers;
+      auto cItem = c->item.lock();
+      if(cItem == item || cItem->isChildOf(item)) continue;
+      if(c->getCollidingResult(myCollider)) {
+        c->eventTriggerEnter.invoke(this);
+      }
+    }
+
+    // Stop velocity near zero.
+    if(mathAbs<float_t>(velocity.x) <= 0.001f) velocity.x = 0;
+    if(mathAbs<float_t>(velocity.y) <= 0.001f) velocity.y = 0;
+  }, getScene()->eventSceneUpdate);
+}

archive/physics_components/2d/CharacterController2D.hpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "SolidController2D.hpp"
+#include "TriggerController2D.hpp"
+
+namespace Dawn {
+  struct CharacterController2DCollisionEventInfo {
+    std::shared_ptr<SolidController2D> collider;
+    glm::vec2 normal;
+    float_t entryTime;
+    float_t exitTime;
+    glm::vec2 entryPoint;
+    glm::vec2 exitPoint;
+  };
+
+  class CharacterController2D : public SceneItemComponent {
+    public:
+      // @optional
+      glm::vec2 velocity = glm::vec2(0, 0);
+      // @optional
+      float_t friction = 12.0f;
+
+      StateEvent<struct CharacterController2DCollisionEventInfo> eventCollision;
+      
+      CharacterController2D(std::weak_ptr<SceneItem> i);
+      void onStart() override;
+  };
+}

archive/physics_components/2d/Collider2D.cpp

@@ -0,0 +1,13 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Collider2D.hpp"
+#include "BoxCollider.hpp"
+
+using namespace Dawn;
+
+Collider2D::Collider2D(std::weak_ptr<SceneItem> i) : SceneItemComponent(i) {
+  
+}

archive/physics_components/2d/Collider2D.hpp

@@ -0,0 +1,34 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/SceneItemComponent.hpp"
+#include "physics/2d/Box.hpp"
+
+namespace Dawn {
+  enum Collider2DType {
+    COLLIDER2D_TYPE_BOX
+  };
+  
+  struct Collider2DAxisAlignedCollidingResult {
+    glm::vec2 normal;
+    float_t entryTime;
+    float_t exitTime;
+    glm::vec2 entryPoint;
+    glm::vec2 exitPoint;
+  };
+
+  class Collider2D : public SceneItemComponent {
+    public:
+      Collider2D(std::weak_ptr<SceneItem> item);
+
+      /**
+       * Returns which type of collider this is.
+       * 
+       * @return The collider type that this is.
+       */
+      virtual enum Collider2DType getColliderType() = 0;
+  };
+}

archive/physics_components/2d/SolidController2D.cpp

@@ -0,0 +1,69 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SolidController2D.hpp"
+
+using namespace Dawn;
+
+SolidController2D::SolidController2D(std::weak_ptr<SceneItem> item) : SceneItemComponent(item) {
+}
+
+std::vector<std::shared_ptr<SceneItemComponent>> SolidController2D::getDependencies() {
+  return {
+    (this->collider = item.lock()->getComponent<Collider2D>())
+  };
+}
+
+bool_t SolidController2D::getCollidingResult(
+  glm::vec2 movement,
+  std::shared_ptr<Collider2D> movingObject,
+  glm::vec2 &normal,
+  float_t &entryTime,
+  float_t &exitTime,
+  glm::vec2 &entryPoint,
+  glm::vec2 &exitPoint
+) {
+  assertNotNull(this->collider, "SolidController2D::getCollidingResult: Collider cannot be null");
+  assertNotNull(movingObject, "SolidController2D::getCollidingResult: Moving object cannot be null");
+  if(movement.x == 0 && movement.y == 0) return false;
+
+  auto myPos = physics3Dto2D(movingObject->item.lock()->getWorldPosition());
+
+  // Check what the moving object is
+  switch(movingObject->getColliderType()) {
+    case COLLIDER2D_TYPE_BOX: {
+      auto box1 = std::static_pointer_cast<BoxCollider>(movingObject);
+      assertNotNull(box1, "SolidController2D::getCollidingResult: Moving object is not a BoxCollider");
+
+      // Box VS (this)?
+      switch(this->collider->getColliderType()) {
+        case COLLIDER2D_TYPE_BOX: {
+          auto box2 = std::static_pointer_cast<BoxCollider>(this->collider);
+          assertNotNull(box2, "SolidController2D::getCollidingResult: Collider is not a BoxCollider");
+          auto otherPos = physics3Dto2D(box2->item.lock()->getWorldPosition());
+
+          return boxCheckCollision(
+            myPos, box1->min, box1->max,
+            otherPos, box2->min, box2->max,
+            movement,
+            normal, entryTime, exitTime, entryPoint, exitPoint
+          );
+        }
+        
+        default: {
+          assertUnreachable("SolidController2D::getCollidingResult: Collider type not implemented");
+        }
+      }
+      break;
+    }
+
+    default: {
+      assertUnreachable("SolidController2D::getCollidingResult: Moving object type not implemented");
+    }
+  }
+  
+  assertUnreachable("SolidController2D::getCollidingResult: Should never reach this point");
+  return false;
+}

archive/physics_components/2d/SolidController2D.hpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "Collider2D.hpp"
+#include "BoxCollider.hpp"
+
+namespace Dawn {
+  class SolidController2D : public SceneItemComponent {
+    public:
+      std::shared_ptr<Collider2D> collider;
+
+      SolidController2D(std::weak_ptr<SceneItem> item);
+      std::vector<std::shared_ptr<SceneItemComponent>> getDependencies() override;
+
+      /**
+       * Gets the result of checking if two collider bodies are intersecting.
+       * This is performed WITH movement to return entry and exit times.
+       * 
+       * @param result Where to store the results of the calculation.
+       * @param movement Movement operation that THIS object is performing.
+       * @param movingObject Moving Object Collider that is being compared.
+       * @param normal Output normal of the intersection.
+       * @param entryTime Output entry time when the two objects will intersect.
+       * @param exitTime Output exit time when the object will pass through.
+       * @param entryPoint Output point in 2D space where object will enter.
+       * @param exitPoint Output point where object will have passed through.
+       * @return True if the two objects will intersect at move otherwise false.
+       */
+      bool_t getCollidingResult(
+        glm::vec2 movement,
+        std::shared_ptr<Collider2D> movingObject,
+        glm::vec2 &normal,
+        float_t &entryTime,
+        float_t &exitTime,
+        glm::vec2 &entryPoint,
+        glm::vec2 &exitPoint
+      );
+  };
+}

archive/physics_components/2d/TriggerController2D.cpp

@@ -0,0 +1,51 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "TriggerController2D.hpp"
+
+using namespace Dawn;
+
+TriggerController2D::TriggerController2D(std::weak_ptr<SceneItem> i) : SceneItemComponent(i) {
+  
+}
+
+std::vector<std::shared_ptr<SceneItemComponent>> TriggerController2D::getDependencies() {
+  return {
+    (this->collider = this->item.lock()->getComponent<Collider2D>())
+  };
+}
+
+bool_t TriggerController2D::getCollidingResult(std::shared_ptr<Collider2D> movingObject) {
+  assertNotNull(this->collider, "TriggerController2D::getCollidingResult: Collider cannot be null");
+  assertNotNull(movingObject, "TriggerController2D::getCollidingResult: Moving object cannot be null");
+
+  switch(movingObject->getColliderType()) {
+    case COLLIDER2D_TYPE_BOX: {
+      auto box1 = std::static_pointer_cast<BoxCollider>(movingObject);
+      assertNotNull(box1, "TriggerController2D::getCollidingResult: Moving object is not a BoxCollider");
+
+      // Box VS ?
+      switch(collider->getColliderType()) {
+        case COLLIDER2D_TYPE_BOX: {
+          auto box2 = std::static_pointer_cast<BoxCollider>(collider);
+          assertNotNull(box2, "TriggerController2D::getCollidingResult: Collider is not a BoxCollider");
+          return boxIsBoxColliding(
+            physics3Dto2D(box1->item.lock()->getWorldPosition()), box1->min, box1->max,
+            physics3Dto2D(box2->item.lock()->getWorldPosition()), box2->min, box2->max
+          );
+        }
+        
+        default: {
+          assertUnreachable("TriggerController2D::getCollidingResult: Collider type not implemented");
+        }
+      }
+    }
+    
+    default: {
+      assertUnreachable("TriggerController2D::getCollidingResult: Moving object type not implemented");
+      return false;
+    }
+  }
+}

archive/physics_components/2d/TriggerController2D.hpp

@@ -0,0 +1,27 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "Collider2D.hpp"
+#include "BoxCollider.hpp"
+
+namespace Dawn {
+  class CharacterController2D;
+  
+  class TriggerController2D : public SceneItemComponent {
+    public:
+      std::shared_ptr<Collider2D> collider;
+      StateEvent<CharacterController2D*> eventTriggerEnter;
+
+      TriggerController2D(std::weak_ptr<SceneItem> i);
+      std::vector<std::shared_ptr<SceneItemComponent>> getDependencies() override;
+
+      /**
+       * Returns whether or not the given moving object is colliding with this
+       * trigger collider.
+       */
+      bool_t getCollidingResult(std::shared_ptr<Collider2D> movingObject);
+  };
+}