jolt_context.hpp

#pragma once
#include <map>
#include <core/core.hpp>
#include <physics/physics_context.hpp>
#include <drivers/jolt-cpp/jolt_components.hpp>
#include <physics/components.hpp>
#include <drivers/jolt-cpp/jolt_contact_listener.hpp>
#include <drivers/jolt-cpp/jolt_broad_phase.hpp>
 
namespace atlas::physics {
    class jolt_context : public physics_context {
    public:
        jolt_context(const jolt_settings& p_settings, event::event_bus& p_bus);
        ~jolt_context() override = default;
 
    private:
        void destroy_bodies() override;
 
        void prepare_and_finalize() override;
 
        void update_simulation(float p_delta_time) override;
 
    protected:
        void emplace_box_collider(uint32_t p_entity_id,
                                  const transform* p_transform,
                                  const physics_body* p_body,
                                  const box_collider* p_collider) override;
 
        void emplace_sphere_collider(
          uint32_t p_entity_id,
          const transform* p_transform,
          const physics_body* p_body,
          const sphere_collider* p_collider) override;
 
        void emplace_capsule_collider(
          uint32_t p_entity_id,
          const transform* p_transform,
          const physics_body* p_body,
          const capsule_collider* p_collider) override;
 
        // void set_position_rotation(flecs::entity p_entity, const
        // physics_body* p_body, const box_collider* p_collider, const
        // transform* p_transform) override;
        transform context_read_transform(uint32_t p_id) override;
 
        physics_body context_read_physics_body(uint32_t p_id) override;
 
        void linear_velocity(uint64_t p_id,
                             const glm::vec3& p_linear_velocity) override;
 
        void angular_velocity(uint64_t p_id,
                              const glm::vec3& p_angular_velocity) override;
 
        void force(uint64_t p_id, const glm::vec3& p_cumulative_force) override;
 
        void add_force_and_torque(uint64_t p_id,
                                  const glm::vec3& p_force,
                                  const glm::vec3& p_torque) override;
 
        void add_impulse(uint64_t p_id, const glm::vec3& p_impulse) override;
 
    private:
        jolt_settings m_settings;
 
        ref<JPH::TempAllocatorImpl> m_temp_allocator;
 
        scope<JPH::JobSystemThreadPool> m_thread_system;
 
        ref<broad_phase_layer_interface> m_broad_phase_layer_interface;
 
        ref<object_vs_broadphase_layer> m_object_vs_broadphase_filter;
 
        ref<object_layer_pair_filter> m_object_layer_pair_filter;
 
        // ref<contact_listener> m_contact_listener;
        contact_listener m_contact_listener;
 
        ref<JPH::PhysicsSystem> m_physics_system;
 
        std::map<uint32_t, JPH::BodyID> m_cached_body_ids;
    };
};