spk_collision_mesh_2d.hpp

#pragma once
 
#include "structure/geometry/spk_mesh.hpp"
#include "structure/math/spk_bounding_box_2d.hpp"
#include "structure/math/spk_matrix.hpp"
#include "structure/math/spk_vector2.hpp"
#include "structure/opengl/spk_vertex_buffer_object.hpp"
 
#include <functional>
#include <vector>
 
namespace spk
{
    class Transform2D;

    class CollisionMesh2D : public spk::IMesh<spk::Vector2>
    {
    public:
        using Polygon = spk::IMesh<spk::Vector2>::Polygon;
        using EditionContract = spk::IMesh<spk::Vector2>::EditionContract;

        CollisionMesh2D();
        CollisionMesh2D(const CollisionMesh2D &p_other);
        CollisionMesh2D &operator=(const CollisionMesh2D &p_other);
        CollisionMesh2D(CollisionMesh2D &&p_other) noexcept;
        CollisionMesh2D &operator=(CollisionMesh2D &&p_other) noexcept;

        template <typename TMesh>
        explicit CollisionMesh2D(const TMesh &p_mesh, const std::function<spk::Vector2(const typename TMesh::Vertex &)> &p_positionExtractor) :
            spk::IMesh<spk::Vector2>(),
            _boundingBox([this]() {
                return _computeBoundingBox();
            })
        {
            _subscribeBoundingBoxUpdates();
 
            std::vector<spk::Vector2> points;
            for (const auto &polygon : p_mesh.polygons())
            {
                for (const auto &vertex : polygon.points)
                {
                    points.push_back(p_positionExtractor(vertex));
                }
            }
 
            auto hull = _convexHull(std::move(points));
            if (hull.size() < 3)
            {
                return;
            }
 
            Polygon collisionPolygon;
            collisionPolygon.order = PolygonOrder::TriangleFanFromFirst;
            collisionPolygon.points.reserve(hull.size());
            for (const auto &point : hull)
            {
                collisionPolygon.points.push_back(point);
            }
            append(collisionPolygon);
        }

        bool collideWith(const CollisionMesh2D &p_other, const Transform2D &p_selfTransform, const Transform2D &p_otherTransform) const;
        bool collideWith(const spk::Vector2 &p_worldPoint, const Transform2D &p_selfTransform) const;
        bool collideWith(const CollisionMesh2D &p_other, const spk::Matrix4x4 &p_selfTransform, const spk::Matrix4x4 &p_otherTransform) const;
        bool collideWith(const spk::Vector2 &p_worldPoint, const spk::Matrix4x4 &p_selfTransform) const;
        const spk::BoundingBox2D &boundingBox() const;
 
    protected:
        void _configureBufferSet() const override
        {
            auto &layout = bufferSet()->vbo().layout();
            using Attribute = spk::OpenGL::VertexBufferObject::Layout::Attribute;
            layout.addAttribute({0, Attribute::Type::Vector2});
        }
 
    private:
        static float _cross(const spk::Vector2 &p_origin, const spk::Vector2 &p_a, const spk::Vector2 &p_b);
        static std::vector<spk::Vector2> _convexHull(std::vector<spk::Vector2> p_points);
 
        spk::BoundingBox2D _computeBoundingBox() const;
        void _subscribeBoundingBoxUpdates();
 
        mutable spk::CachedData<spk::BoundingBox2D> _boundingBox;
        EditionContract _onBoundingBoxEditionContract;
    };
}