Added some physics stuff

meson.build

@@ -51,5 +51,6 @@ subdir('wren_vk')
 # subdir('wren_gltf')
 # subdir('wren_gui')
 subdir('wren')
+subdir('wren_physics')
 # subdir('wren_ecs')
 subdir('editor')

wren/include/wren/scene/components.hpp

@@ -1,12 +1,21 @@
 #pragma once
 
-#include <functional>
+#include <flecs.h>
 
-#include "scene.hpp"
+namespace wren::scene::components {
 
-namespace wren::scene {
+struct Base {
+  Base() = default;
+  Base(const Base &) = default;
+  Base(Base &&) = delete;
+  auto operator=(const Base &) -> Base & = default;
+  auto operator=(Base &&) -> Base & = delete;
+  virtual ~Base() = default;
+
+  // virtual void init(const flecs::world &world) = 0;
+};
 
 // void iterate_known_components(const Scene& scene, entt::entity entity,
 //                               std::function<void()>);
 
-}
+}  // namespace wren::scene::components

wren/include/wren/scene/components/collider.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <flecs.h>
+
+#include <memory>
+#include <optional>
+#include <wren/math/vector.hpp>
+#include <wren/scene/components/transform.hpp>
+
+#include "../components.hpp"
+
+namespace wren::scene::components {
+
+struct Collider : public Base {
+  using Ptr = std::shared_ptr<Collider>;
+
+  [[nodiscard]] virtual auto raycast(const Transform& transform,
+                                     const math::Vec3f& origin,
+                                     const math::Vec3f& direction) const
+      -> std::optional<math::Vec3f> = 0;
+};
+
+struct BoxCollider2D : public Collider {
+  static void init(const flecs::world& world) {
+    static bool inited = false;
+    if (!inited) {
+      inited = true;
+      world.component<BoxCollider2D::Ptr>().is_a<Collider>();
+    }
+  }
+
+  [[nodiscard]] auto raycast(const Transform& transform,
+                             const math::Vec3f& origin,
+                             const math::Vec3f& direction) const
+      -> std::optional<math::Vec3f> override;
+
+  math::Vec2f size;
+};
+
+}  // namespace wren::scene::components

wren/include/wren/scene/entity.hpp

@@ -2,6 +2,7 @@
 
 #include <flecs.h>
 
+#include "components.hpp"
 #include "scene.hpp"
 
 namespace wren::scene {
@@ -30,18 +31,28 @@ class Entity {
 
 template <typename T>
 auto Entity::has_component() const -> bool {
-  // return scene_->world().all_of<T>();
+  return entity_.has<T>();
 }
 
 template <typename T>
 auto Entity::get_component() -> T& {
-  return scene_->world().get<T>(entity_);
+  return *entity_.get_mut<T>();
 }
 
+template <typename T>
+concept HasInit = requires() { T::init(); };
+
 template <typename T, typename... Args>
 void Entity::add_component(Args&&... args) {
   entity_.add<T>();
-  entity_.set<T>(T(std::forward<Args>(args)...));
+  if (sizeof...(args) > 0) {
+    T t(std::forward<Args...>(args)...);
+    entity_.set<T>(t);
+  }
+
+  if constexpr (HasInit<T>) {
+    T::init(scene_->world());
+  }
 }
 
 }  // namespace wren::scene

wren/include/wren/scene/scene.hpp

@@ -12,7 +12,7 @@ class Scene : public std::enable_shared_from_this<Scene> {
  public:
   static auto create() { return std::shared_ptr<Scene>(new Scene()); }
 
-  auto create_entity(const std::string& name = "entity") -> flecs::entity;
+  auto create_entity(const std::string& name = "entity") -> Entity;
 
   auto world() const -> const flecs::world& { return ecs_; }
   auto world() -> flecs::world& { return ecs_; }

wren/meson.build

@@ -11,6 +11,7 @@ wren = library(
         'src/render_pass.cpp',
         'src/render_target.cpp',
         'src/renderer.cpp',
+        'src/scene/components/collider.cpp',
         'src/scene/deserialization.cpp',
         'src/scene/scene.cpp',
         'src/scene/serialization.cpp',

wren/src/scene/components/collider.cpp

@@ -0,0 +1,26 @@
+#include "scene/components/collider.hpp"
+
+namespace wren::scene::components {
+
+auto BoxCollider2D::raycast(const Transform& transform,
+                            const math::Vec3f& origin,
+                            const math::Vec3f& direction) const
+    -> std::optional<math::Vec3f> {
+  math::Vec3f normal =
+      math::Quaternionf{transform.rotation}.to_mat() * math::Vec3f{0, 0, 1};
+
+  float denominator = normal.dot(direction);
+  if (std::abs(denominator) < 0.0001) {
+    return {};
+  }
+
+  float t = normal.dot(transform.position - origin) / denominator;
+  if (t < 0) {
+    // Intersection points is behind the ray's origin
+    return {};
+  }
+
+  return origin + direction * t;
+}
+
+}  // namespace wren::scene::components

wren/src/scene/deserialization.cpp

@@ -29,12 +29,12 @@
 
     for (const auto& [key, val] : entity_table) {
       if (key.str() == "transform") {
-        auto& t = *entity.get_mut<components::Transform>();
+        auto& t = entity.get_component<components::Transform>();
         deserialize(*val.as_table(), t);
       } else if (key.str() == "mesh_renderer") {
         components::MeshRenderer mesh_renderer{};
         deserialize(*val.as_table(), project_root, mesh_renderer);
-        entity.emplace<components::MeshRenderer>(mesh_renderer);
+        entity.add_component<components::MeshRenderer>(mesh_renderer);
       }
     }
   }

wren/src/scene/scene.cpp

@@ -6,13 +6,13 @@
 
 namespace wren::scene {
 
-auto Scene::create_entity(const std::string& name) -> flecs::entity {
+auto Scene::create_entity(const std::string& name) -> Entity {
   auto entity = ecs_.entity(name.c_str());
 
   // entity.add_component<components::Tag>(name);
   entity.add<components::Transform>();
 
-  return entity;
+  return {entity, shared_from_this()};
 }
 
 }  // namespace wren::scene

wren_physics/include/wren/physics/ray.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <flecs.h>
+
+#include <wren/math/vector.hpp>
+
+namespace wren::physics {
+
+struct RayHit {
+  bool hit = false;
+  math::Vec3f point;
+};
+
+struct Ray {
+  math::Vec3f origin;
+  math::Vec3f direction;
+};
+
+auto raycast(const flecs::world& world, const Ray& ray, RayHit& hit) -> bool;
+
+}  // namespace wren::physics

wren_physics/meson.build

@@ -0,0 +1,12 @@
+wren_physics = static_library(
+    'wren_physics',
+    'src/ray.cpp',
+    dependencies: [wren_dep, flecs],
+    include_directories: ['include/wren', 'include/wren/physics'],
+)
+wren_physics_dep = declare_dependency(
+    include_directories: 'include',
+    link_with: wren_physics,
+)
+
+subdir('tests')

wren_physics/src/ray.cpp

@@ -0,0 +1,28 @@
+#include "physics/ray.hpp"
+
+#include <wren/scene/components/collider.hpp>
+#include <wren/scene/components/transform.hpp>
+
+namespace wren::physics {
+
+auto raycast(const flecs::world& world, const Ray& ray, RayHit& hit) -> bool {
+  const auto q = world.query<const scene::components::Transform,
+                             const scene::components::Collider::Ptr>();
+
+  q.each([ray, &hit](const scene::components::Transform& transform,
+                     const scene::components::Collider::Ptr& collider) {
+    if (hit.hit) {
+      return;
+    }
+
+    auto pos = collider->raycast(transform, ray.origin, ray.direction);
+    if (pos.has_value()) {
+      hit.hit = true;
+      hit.point = pos.value();
+    }
+  });
+
+  return hit.hit;
+}
+
+}  // namespace wren::physics

wren_physics/tests/meson.build

@@ -0,0 +1,12 @@
+tests = ['raycast']
+foreach test : tests
+    test(
+        'wren_physics_@0@'.format(test),
+        executable(
+            'wren_physics_@0@_test'.format(test),
+            '@[email protected]'.format(test),
+            dependencies: [wren_physics_dep, wren_dep, boost_test],
+            cpp_args: ['-DBOOST_TEST_MODULE=@0@'.format(test)],
+        ),
+    )
+endforeach

wren_physics/tests/raycast.cpp

@@ -0,0 +1,43 @@
+#include <boost/test/unit_test.hpp>
+#include <wren/physics/ray.hpp>
+#include <wren/scene/components.hpp>
+#include <wren/scene/components/collider.hpp>
+#include <wren/scene/components/transform.hpp>
+#include <wren/scene/entity.hpp>
+#include <wren/scene/scene.hpp>
+
+namespace physics = wren::physics;
+namespace components = wren::scene::components;
+namespace math = wren::math;
+
+BOOST_AUTO_TEST_SUITE(raycasting)
+
+BOOST_AUTO_TEST_CASE(RaycastBoxCollider) {
+  const auto scene = wren::scene::Scene::create();
+
+  auto box = scene->create_entity("box");
+
+  box.add_component<components::BoxCollider2D::Ptr>(
+      new components::BoxCollider2D());
+  auto& transform = box.get_component<components::Transform>();
+  transform.position.z(-10);
+  // transform.position.x(1000);
+
+  BOOST_TEST(box.has_component<components::BoxCollider2D::Ptr>());
+
+  const auto q = scene->world().query<const components::Collider::Ptr>();
+  BOOST_TEST(q.count() == 1);
+
+  physics::Ray ray;
+  ray.direction = (transform.position - math::Vec3f(0));
+
+  physics::RayHit hit{};
+  physics::raycast(scene->world(), ray, hit);
+
+  BOOST_TEST(hit.hit);
+
+  const float length = (hit.point - math::Vec3f{0, 0, -10}).length();
+  BOOST_TEST(length <= 0.001);
+}
+
+BOOST_AUTO_TEST_SUITE_END()