ContactCallback.hpp

Go to the documentation of this file.

#pragma once
 
#include "FunctionContainer.hpp"
#include "core/Core.hpp"
#include "entity/Entity.hpp"
 
#include <functional>
 
namespace Physics::Utils {
using BaseCallback = FunctionUtils::BaseFunction<void, Engine::Core &, Engine::Entity &, Engine::Entity &>;
template <typename... Components> class ContactCallback : public BaseCallback {
  public:
    using CallbackFunc = std::function<void(Engine::Core &, Engine::Entity &, Engine::Entity &)>;
 
    explicit ContactCallback(CallbackFunc cb) : _callback(std::move(cb)) {}
 
    void operator()(Engine::Core &core, Engine::Entity &a, Engine::Entity &b) const final
    {
        static_assert(sizeof...(Components) <= 2, "ContactCallback can only have up to 2 components.");
 
        if constexpr (sizeof...(Components) == 0)
        {
            _callback(core, a, b);
        }
        else if constexpr (sizeof...(Components) == 1)
        {
            if (hasAllComponents<Components...>(core, a) && hasAllComponents<Components...>(core, b))
            {
                _callback(core, a, b);
            }
        }
        else if constexpr (sizeof...(Components) == 2)
        {
            callIfComponentMatch<Components...>(core, a, b);
        }
    }
 
    FunctionUtils::FunctionID GetID() const final { return _callback.target_type().hash_code(); }
 
  private:
    template <typename... Cs> inline bool hasAllComponents(Engine::Core &core, const Engine::Entity &entity) const
    {
        return ((entity.HasComponents<Cs>(core) && ...));
    }
 
    template <typename C1, typename C2>
    void callIfComponentMatch(Engine::Core &core, Engine::Entity &a, Engine::Entity &b) const
    {
        if ((a.HasComponents<C1>(core) && b.HasComponents<C2>(core)))
        {
            _callback(core, a, b);
        }
        else if ((a.HasComponents<C2>(core) && b.HasComponents<C1>(core)))
        {
            _callback(core, b, a);
        }
    }
 
    CallbackFunc _callback; 
};
} // namespace Physics::Utils