[#4] Implement collision zones

docs/USAGE.md

@@ -9,6 +9,11 @@ auto rect = std::make_shared<velos::Rectangle>(velos::Vec2{200.f, 200.f}, velos:
 auto entity = std::make_shared<velos::Entity>();
 entity->addShape(rect);
 engine.entityManager()->addEntity(entity);
+
+auto collider = std::make_unique<velos::AABBCollider>();
+entity->addCollider(std::move(collider));
+
+engine.setDebugRender(true); // For debugging collision zones
 ```
 
 ## Moving and Transforming entities

engine/include/velos/app/engine.h

@@ -31,6 +31,8 @@ namespace velos {
         void attachCamera(Entity& entity);
         void detachCamera();
 
+        void setDebugRender(bool state);
+
         static Engine* instance() { return s_instance; }
         Camera* camera() { return m_camera.get(); }
         EntityManager* entityManager() { return m_entityManager.get(); }

engine/include/velos/entity/entity.h

@@ -2,24 +2,32 @@
 #include <vector>
 #include <memory>
 #include "../graphics/shapes/shape.h"
+#include "../physics/collider.h"
 #include "../graphics/renderer.h"
 #include "../math/transform.h"
 
 namespace velos {
     class Entity {
     public:
         Entity() = default;
+        virtual ~Entity() = default;
 
-        virtual void update(float dt) {};
+        virtual void update(float dt) { updateColliders(); }
         virtual void render(Renderer& renderer);
+        void debugRender(Renderer& renderer);
         bool containsPoint(const Vec2& worldPos) const;
 
         void addShape(std::shared_ptr<Shape> shape) { m_shapes.push_back(shape); }
         void move(float dx, float dy);
 
+        void addCollider(std::unique_ptr<Collider> collider);
+        const std::vector<std::unique_ptr<Collider>>& colliders() const;
+        void updateColliders();
+
         Transform& transform() { return m_transform; }
     private:
         Transform m_transform;
         std::vector<std::shared_ptr<Shape>> m_shapes;
+        std::vector<std::unique_ptr<Collider>> m_colliders;
     };
 }

engine/include/velos/entity/entity_manager.h

@@ -10,8 +10,11 @@ namespace velos {
         void update(float dt);
         void render(Renderer& renderer);
 
+        void setDebugRender(bool state);
+
         std::vector<std::shared_ptr<Entity>> entities() { return m_entities; }
     private:
         std::vector<std::shared_ptr<Entity>> m_entities;
+        bool m_debugRender = false;
     };
 }

engine/include/velos/physics/aabb_collider.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "collider.h"
+
+namespace velos {
+    class AABBCollider: public Collider {
+    public:
+        AABBCollider(const Vec2& size, const Vec2& offset = {0.f, 0.f})
+            : m_size(size), m_offset(offset) {}
+
+        ColliderType type() const override;
+        void computeWorld(const Transform& transform) override;
+        bool containsPoint(const Vec2& point) const override;
+
+        void setSize(const Vec2 size);
+        void debugRender(Renderer& renderer) const override;
+
+    private:
+        Vec2 m_size;
+        Vec2 m_offset;
+    };
+}

engine/include/velos/physics/circle_collider.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "collider.h"
+
+namespace velos {
+    class CircleCollider: public Collider {
+    public:
+        CircleCollider(float radius, const Vec2& offset = {0.f, 0.f})
+            : m_radius(radius), m_offset(offset) {}
+
+        ColliderType type() const override;
+        void computeWorld(const Transform& transform) override;
+        bool containsPoint(const Vec2& point) const override;
+
+        void setRadius(float radius);
+        void debugRender(Renderer& renderer) const override;
+
+    private:
+        float m_radius;
+        Vec2 m_offset;
+    };
+}

engine/include/velos/physics/collider.h

@@ -0,0 +1,23 @@
+#pragma once
+#include "../math/transform.h"
+#include "../graphics/renderer.h"
+
+namespace velos {
+    enum class ColliderType {
+        AABB,
+        Circle
+    };
+
+    class Collider {
+    public:
+        virtual ~Collider() = default;
+
+        virtual ColliderType type() const = 0;
+        virtual void computeWorld(const Transform& transform) = 0;
+        virtual bool containsPoint(const Vec2& worldPoint) const = 0;
+
+        virtual void debugRender(Renderer& renderer) const = 0;
+    protected:
+        Vec2 m_worldPosition{0.f, 0.f};
+    };
+}

engine/src/app/engine.cpp

@@ -49,6 +49,7 @@ namespace velos {
         m_running = false;
    }
 
+
     void Engine::addEventListener(EventType type, EventCallback callback) {
         m_eventListeners[type].push_back(std::move(callback));
     }
@@ -101,4 +102,8 @@ namespace velos {
     void Engine::detachCamera() {
         m_camera->unfollow();
     }
+
+    void Engine::setDebugRender(bool state) {
+        entityManager()->setDebugRender(state);
+    }
 }

engine/src/entity/entity.cpp

@@ -6,6 +6,11 @@ namespace velos {
             shape->render(renderer, m_transform);
     }
 
+    void Entity::debugRender(Renderer& renderer) {
+        for (auto& collider: m_colliders)
+            collider->debugRender(renderer);
+    }
+
     bool Entity::containsPoint(const Vec2& worldPos) const {
         for (auto& shape: m_shapes) {
             Vec2 local = m_transform.applyInverse(worldPos);
@@ -19,4 +24,17 @@ namespace velos {
         m_transform.position.x += dx;
         m_transform.position.y += dy;
     }
+
+    void Entity::addCollider(std::unique_ptr<Collider> collider) {
+        m_colliders.push_back(std::move(collider));
+    }
+
+    const std::vector<std::unique_ptr<Collider>>& Entity::colliders() const {
+        return m_colliders;
+    }
+
+    void Entity::updateColliders() {
+        for (auto& collider: m_colliders)
+            collider->computeWorld(m_transform);
+    }
 }

engine/src/entity/entity_manager.cpp

@@ -7,7 +7,15 @@ namespace velos {
     }
 
     void EntityManager::render(Renderer& renderer) {
-        for (auto& entity: m_entities)
+        for (auto& entity: m_entities) {
             entity->render(renderer);
+
+            if (m_debugRender)
+                entity->debugRender(renderer);
+        }
+    }
+
+    void EntityManager::setDebugRender(bool state) {
+        m_debugRender = state;
     }
 }

engine/src/physics/aabb_collider.cpp

@@ -0,0 +1,26 @@
+#include "velos/physics/aabb_collider.h"
+
+namespace velos {
+    ColliderType AABBCollider::type() const {
+        return ColliderType::AABB;
+    }
+
+    void AABBCollider::computeWorld(const Transform& transform) {
+        m_worldPosition = transform.position + m_offset;
+    }
+
+    bool AABBCollider::containsPoint(const Vec2& point) const {
+        return point.x >= m_worldPosition.x &&
+            point.x <= m_worldPosition.x + m_size.x &&
+            point.y >= m_worldPosition.y &&
+            point.y <= m_worldPosition.y + m_size.y;
+    }
+
+    void AABBCollider::setSize(const Vec2 size) {
+        m_size = size;
+    }
+
+    void AABBCollider::debugRender(Renderer& renderer) const {
+        renderer.drawRect(m_worldPosition, m_size, Color{117, 145, 166, 100});
+    }
+}

engine/src/physics/circle_collider.cpp

@@ -0,0 +1,20 @@
+#include "velos/physics/circle_collider.h"
+
+namespace velos {
+    ColliderType CircleCollider::type() const {
+        return ColliderType::Circle;
+    }
+
+    void CircleCollider::computeWorld(const Transform& transform) {
+        m_worldPosition = transform.position + m_offset;
+    }
+
+    bool CircleCollider::containsPoint(const Vec2& point) const {
+        Vec2 delta = point - m_worldPosition;
+        return delta.lengthSquared() <= m_radius * m_radius;
+    }
+
+    void CircleCollider::debugRender(Renderer& renderer) const {
+        renderer.drawCircle(m_worldPosition, m_radius, Color{117, 145, 166, 100});
+    }
+}

examples/sandbox/src/main.cpp

@@ -13,6 +13,7 @@
 #include <velos/entity/entity.h>
 #include <velos/entity/entity_manager.h>
 #include <velos/math/transform.h>
+#include <velos/physics/aabb_collider.h>
 
 int main() {
     velos::EngineConfig config;
@@ -29,6 +30,9 @@ int main() {
     entity->addShape(rect);
     entity->transform().position = {200, 200};
 
+    auto collider = std::make_unique<velos::AABBCollider>(size, velos::Vec2{0.f, 0.f} - size / 2.f);
+    entity->addCollider(std::move(collider));
+
     auto stationary_entity = std::make_shared<velos::Entity>();
     stationary_entity->addShape(circle);
 
@@ -69,5 +73,8 @@ int main() {
     engine.attachCamera(*entity);
     engine.camera()->setFollowMode(velos::CameraFollowMode::Smooth);
 
+    // For debugging collision zones
+    // engine.setDebugRender(true);
+
     engine.run();
 }