feat(engine): add voxel collision shape

core/include/cubos/core/geom/box.hpp

@@ -29,7 +29,7 @@ namespace cubos::core::geom
         }
 
         /// @brief Computes four corners of the box, one for each diagonal.
-        /// @param corners Array to store the three corners in.
+        /// @param corners Array to store the four corners in.
         void corners4(glm::vec3 corners[4]) const
         {
             corners[0] = {halfSize.x, -halfSize.y, -halfSize.z};

core/src/geom/intersections.cpp

@@ -147,7 +147,6 @@ bool cubos::core::geom::intersects(const Box& box1, const glm::mat4& localToWorl
             }
         }
     }
-
     return true;
 }
 

engine/CMakeLists.txt

@@ -73,6 +73,7 @@ set(CUBOS_ENGINE_SOURCE
 	"src/collisions/interface/shapes/box.cpp"
 	"src/collisions/interface/raycast.cpp"
 	"src/collisions/interface/shapes/capsule.cpp"
+	"src/collisions/interface/shapes/voxel.cpp"
 	"src/collisions/broad_phase/plugin.cpp"
 	"src/collisions/broad_phase/sweep_and_prune.cpp"
 	"src/collisions/broad_phase/potentially_colliding_with.cpp"

engine/include/cubos/engine/collisions/shapes/voxel.hpp

@@ -0,0 +1,97 @@
+/// @file
+/// @brief Component @ref cubos::engine::VoxelCollisionShape.
+/// @ingroup collisions-plugin
+
+#pragma once
+
+#include <glm/glm.hpp>
+
+#include <cubos/core/geom/box.hpp>
+#include <cubos/core/log.hpp>
+#include <cubos/core/reflection/external/glm.hpp>
+#include <cubos/core/reflection/reflect.hpp>
+
+#include <cubos/engine/assets/asset.hpp>
+#include <cubos/engine/voxels/grid.hpp>
+
+namespace cubos::engine
+{
+    /// @brief Component which adds a collision shape corresponding to a given voxel grid to an entity, used with a @ref
+    /// Collider component.
+    /// @ingroup collisions-plugin
+    class VoxelCollisionShape
+    {
+
+    public:
+        CUBOS_REFLECT;
+
+        /// @brief Struct which holds a sub-box of the voxel collision shape, and its shift from the center of the
+        /// shape.
+        /// @ingroup collisions-plugin
+        struct BoxShiftPair
+        {
+            cubos::core::geom::Box box;
+            glm::vec3 shift;
+        };
+
+        /// @brief Entities voxel grid.
+        Asset<VoxelGrid> grid;
+
+        /// @brief Constructs voxel shape with no grid.
+        VoxelCollisionShape() = default;
+
+        /// @brief Constructs voxel shape with voxel grid.
+        /// @param grid VoxelGrid given in constructor.
+        VoxelCollisionShape(Asset<VoxelGrid> grid)
+        {
+            setGrid(grid);
+        }
+
+        /// @brief Default destructor.
+        ~VoxelCollisionShape() = default;
+
+        /// @brief Move constructor.
+        /// @param other VoxelCollisionShape to move.
+        VoxelCollisionShape(VoxelCollisionShape&& other) noexcept
+        {
+            this->grid = std::move(other.grid);
+            this->mBoxes = std::move(other.mBoxes);
+        }
+
+        /// @brief Copy constructor.
+        /// @param shape VoxelCollisionSHape to copy.
+        VoxelCollisionShape(const VoxelCollisionShape& shape)
+        {
+            this->grid = shape.grid;
+            this->mBoxes = shape.mBoxes;
+        }
+
+        /// @brief Sets the grid.
+        /// @param grid to set.
+        void setGrid(Asset<VoxelGrid>& grid)
+        {
+            this->grid = grid;
+        }
+
+        /// @brief Inserts a new @ref BoxShiftPair to the list of the class.
+        /// @param box Box to insert.
+        /// @param shift Shift vector of the box.
+        void insertBox(const cubos::core::geom::Box& box, const glm::vec3& shift)
+        {
+            BoxShiftPair pair;
+            pair.box = box;
+            pair.shift = shift;
+            this->mBoxes.push_back(pair);
+        }
+
+        /// @brief Getter for the list of @ref BoxShiftPair of the class.
+        std::vector<BoxShiftPair> getBoxes() const
+        {
+            return this->mBoxes;
+        }
+
+    private:
+        /// @brief List of pairs composing the shape.
+        std::vector<BoxShiftPair> mBoxes; ///< List of boxes.
+    };
+} // namespace cubos::engine

engine/samples/CMakeLists.txt

@@ -42,6 +42,7 @@ make_sample(DIR "render/main" ASSETS)
 make_sample(DIR "render/shadows" ASSETS)
 make_sample(DIR "imgui")
 make_sample(DIR "collisions" ASSETS)
+make_sample(DIR "voxel-shape-collisions" ASSETS)
 make_sample(DIR "scene" ASSETS)
 make_sample(DIR "voxels" ASSETS)
 make_sample(DIR "gizmos")

engine/samples/voxel-shape-collisions/assets/car.grd.meta

@@ -0,0 +1,3 @@
+{
+    "id": "059c16e7-a439-44c7-9bdc-6e069dba0c75"
+}

engine/samples/voxel-shape-collisions/assets/main.pal.meta

@@ -0,0 +1,3 @@
+{
+    "id": "1aa5e234-28cb-4386-99b4-39386b0fc215"
+}

engine/samples/voxel-shape-collisions/main.cpp

@@ -0,0 +1,169 @@
+#include <glm/gtc/random.hpp>
+
+#include <cubos/core/geom/box.hpp>
+#include <cubos/core/log.hpp>
+
+#include <cubos/engine/assets/plugin.hpp>
+#include <cubos/engine/collisions/collider.hpp>
+#include <cubos/engine/collisions/colliding_with.hpp>
+#include <cubos/engine/collisions/plugin.hpp>
+#include <cubos/engine/collisions/shapes/box.hpp>
+#include <cubos/engine/collisions/shapes/capsule.hpp>
+#include <cubos/engine/collisions/shapes/voxel.hpp>
+#include <cubos/engine/defaults/plugin.hpp>
+#include <cubos/engine/fixed_step/plugin.hpp>
+#include <cubos/engine/gizmos/plugin.hpp>
+#include <cubos/engine/gizmos/target.hpp>
+#include <cubos/engine/physics/plugin.hpp>
+#include <cubos/engine/physics/solver/plugin.hpp>
+#include <cubos/engine/render/camera/camera.hpp>
+#include <cubos/engine/render/camera/draws_to.hpp>
+#include <cubos/engine/render/camera/perspective.hpp>
+#include <cubos/engine/render/defaults/plugin.hpp>
+#include <cubos/engine/render/defaults/target.hpp>
+#include <cubos/engine/render/picker/plugin.hpp>
+#include <cubos/engine/render/tone_mapping/plugin.hpp>
+#include <cubos/engine/render/voxels/grid.hpp>
+#include <cubos/engine/render/voxels/palette.hpp>
+#include <cubos/engine/settings/plugin.hpp>
+#include <cubos/engine/settings/settings.hpp>
+#include <cubos/engine/transform/plugin.hpp>
+#include <cubos/engine/voxels/plugin.hpp>
+#include <cubos/engine/window/plugin.hpp>
+
+using cubos::core::geom::Box;
+using cubos::core::io::Key;
+using cubos::core::io::Modifiers;
+using cubos::core::io::MouseButton;
+
+using namespace cubos::engine;
+
+static CUBOS_DEFINE_TAG(collisionsSampleUpdated);
+
+struct State
+{
+    CUBOS_ANONYMOUS_REFLECT(State);
+
+    bool collided = false;
+
+    Entity a;
+    Entity b;
+
+    glm::vec3 aRotationAxis;
+    glm::vec3 bRotationAxis;
+};
+
+/// [Get handles to assets]
+static const Asset<VoxelGrid> CarAsset = AnyAsset("059c16e7-a439-44c7-9bdc-6e069dba0c75");
+static const Asset<VoxelPalette> PaletteAsset = AnyAsset("1aa5e234-28cb-4386-99b4-39386b0fc215");
+/// [Get handles to assets]
+
+int main()
+{
+    auto cubos = Cubos();
+
+    cubos.plugin(defaultsPlugin);
+    cubos.tag(gizmosDrawTag).after(toneMappingTag);
+
+    cubos.resource<State>();
+
+    cubos.startupSystem("setup camera").call([](Commands commands) {
+        auto targetEnt = commands.create().add(RenderTargetDefaults{}).add(GizmosTarget{}).entity();
+        commands.create()
+            .relatedTo(targetEnt, DrawsTo{})
+            .add(Camera{.zNear = 0.1F, .zFar = 100.0F})
+            .add(PerspectiveCamera{.fovY = 60.0F})
+            .add(LocalToWorld{})
+            .add(Position{{-35.0F, 1.5F, 0.0F}})
+            .add(Rotation::lookingAt({3.0F, -1.0F, 0.0F}, glm::vec3{0.0F, 1.0F, 0.0F}));
+    });
+
+    cubos.startupSystem("configure Assets").tagged(settingsTag).call([](Settings& settings) {
+        settings.setString("assets.io.path", SAMPLE_ASSETS_FOLDER);
+    });
+
+    /// [Set palette]
+    cubos.startupSystem("set palette").call([](RenderPalette& palette) { palette.asset = PaletteAsset; });
+    /// [Set palette]
+
+    cubos.startupSystem("create colliders").tagged(assetsTag).call([](State& state, Commands commands, Assets& assets) {
+        auto car = assets.read(CarAsset);
+        glm::vec3 offset = glm::vec3(car->size().x, car->size().y, car->size().z) / -2.0F;
+        state.a = commands.create()
+                      .add(Collider{})
+                      .add(RenderVoxelGrid{CarAsset, offset})
+                      .add(VoxelCollisionShape(CarAsset))
+                      .add(LocalToWorld{})
+                      .add(Position{glm::vec3{0.0F, 0.0F, -30.0F}})
+                      .add(Rotation{})
+                      .add(PhysicsBundle{.mass = 500.0F, .velocity = {0.0F, 0.0F, 1.0F}})
+                      .entity();
+        state.aRotationAxis = glm::sphericalRand(1.0F);
+
+        state.b = commands.create()
+                      .add(Collider{})
+                      .add(RenderVoxelGrid{CarAsset, offset})
+                      .add(VoxelCollisionShape(CarAsset))
+                      .add(LocalToWorld{})
+                      .add(Position{glm::vec3{0.0F, 0.0F, 10.0F}})
+                      .add(Rotation{})
+                      .add(PhysicsBundle{.mass = 500.0F, .velocity = {0.0F, 0.0F, -1.0F}})
+                      .entity();
+        state.bRotationAxis = glm::sphericalRand(1.0F);
+    });
+
+    cubos.system("move colliders")
+        .before(transformUpdateTag)
+        .call([](State& state, Query<Position&, Rotation&, Velocity&> query) {
+            auto [aPos, aRot, aVel] = *query.at(state.a);
+            auto [bPos, bRot, bVel] = *query.at(state.b);
+
+            aRot.quat = glm::rotate(aRot.quat, 0.001F, state.aRotationAxis);
+            aVel.vec += glm::vec3{0.0F, 0.0F, 0.01F};
+
+            bRot.quat = glm::rotate(bRot.quat, 0.001F, state.bRotationAxis);
+            bVel.vec -= glm::vec3{0.0F, 0.0F, 0.01F};
+        });
+
+    cubos.tag(collisionsSampleUpdated);
+
+    cubos.system("render voxel")
+        .after(collisionsSampleUpdated)
+        .call([](Gizmos& gizmos, Query<const LocalToWorld&, const Collider&, const VoxelCollisionShape&> query) {
+            for (auto [localToWorld, collider, shape] : query)
+            {
+                for (const auto box : shape.getBoxes())
+                {
+                    // Get the current position from the localToWorld matrix
+                    glm::mat4 pos = localToWorld.mat; // Store the matrix
+
+                    // Create a translation matrix for the shift
+                    glm::mat4 shiftMatrix = glm::translate(glm::mat4(1.0F), -box.shift);
+
+                    // Combine the matrices (note: order matters)
+                    pos = pos * shiftMatrix;
+                    auto size = box.box.halfSize * 2.0F;
+                    glm::mat4 transform = glm::scale(pos * collider.transform, size);
+                    gizmos.drawWireBox("subboxes", transform);
+                }
+            }
+        });
+
+    cubos.system("render")
+        .after(collisionsSampleUpdated)
+        .call([](Gizmos& gizmos, Query<const LocalToWorld&, const Collider&> query) {
+            for (auto [localToWorld, collider] : query)
+            {
+                auto size = collider.localAABB.box().halfSize * 2.0F;
+                glm::mat4 transform = glm::scale(localToWorld.mat * collider.transform, size);
+                gizmos.color({1.0F, 1.0F, 1.0F});
+                gizmos.drawWireBox("local AABB", transform);
+
+                gizmos.color({1.0F, 0.0F, 0.0F});
+                gizmos.drawWireBox("world AABB", collider.worldAABB.min(), collider.worldAABB.max());
+            }
+        });
+
+    cubos.run();
+    return 0;
+}

engine/src/collisions/interface/plugin.cpp

@@ -5,12 +5,14 @@
 #include <cubos/engine/collisions/contact_manifold.hpp>
 #include <cubos/engine/collisions/shapes/box.hpp>
 #include <cubos/engine/collisions/shapes/capsule.hpp>
+#include <cubos/engine/collisions/shapes/voxel.hpp>
 
 void cubos::engine::interfaceCollisionsPlugin(Cubos& cubos)
 {
     cubos.component<Collider>();
     cubos.component<BoxCollisionShape>();
     cubos.component<CapsuleCollisionShape>();
+    cubos.component<VoxelCollisionShape>();
 
     cubos.relation<CollidingWith>();
     cubos.relation<ContactManifold>();

engine/src/collisions/interface/shapes/voxel.cpp

@@ -0,0 +1,10 @@
+#include <cubos/core/ecs/reflection.hpp>
+
+#include <cubos/engine/collisions/shapes/voxel.hpp>
+
+CUBOS_REFLECT_IMPL(cubos::engine::VoxelCollisionShape)
+{
+    return core::ecs::TypeBuilder<VoxelCollisionShape>("cubos::engine::VoxelCollisionShape")
+        .withField("grid", &VoxelCollisionShape::grid)
+        .build();
+}