physics_context.hpp

#pragma once
#include <core/core.hpp>
#include <Jolt/Jolt.h>
#include <drivers/jolt-cpp/jolt_components.hpp>
#include <drivers/jolt-cpp/jolt-imports.hpp>
#include <physics/components.hpp>
#include <core/scene/components.hpp>
#include <flecs.h>
#include <core/event/event_bus.hpp>
 
namespace atlas::physics {
    class physics_context {
    public:
        virtual ~physics_context() = default;
 
        void destroy() { return destroy_bodies(); }
 
        void update(float p_delta_time) {
            return update_simulation(p_delta_time);
        }
 
        void prepare() { return prepare_and_finalize(); }
 
        void add_box_collider(uint32_t p_entity_id,
                              const transform* p_transform,
                              const physics_body* p_body,
                              const box_collider* p_collider) {
            return emplace_box_collider(
              p_entity_id, p_transform, p_body, p_collider);
        }
 
        void add_sphere_collider(uint32_t p_entity_id,
                                 const transform* p_transform,
                                 const physics_body* p_body,
                                 const sphere_collider* p_collider) {
            return emplace_sphere_collider(
              p_entity_id, p_transform, p_body, p_collider);
        }
 
        void add_capsule_collider(uint32_t p_entity_id,
                                  const transform* p_transform,
                                  const physics_body* p_body,
                                  const capsule_collider* p_collider) {
            return emplace_capsule_collider(
              p_entity_id, p_transform, p_body, p_collider);
        }
 
        transform read_transform(uint32_t p_id) {
            return context_read_transform(p_id);
        }
 
        physics_body read_physics_body(uint32_t p_id) {
            return context_read_physics_body(p_id);
        }
 
        void set_linear_velocity(uint64_t p_id,
                                 const glm::vec3& p_linear_velocity) {
            return linear_velocity(p_id, p_linear_velocity);
        }
 
        void set_angular_velocity(uint64_t p_id,
                                  const glm::vec3& p_angular_velocity) {
            return angular_velocity(p_id, p_angular_velocity);
        }
 
        void set_force(uint64_t p_id, const glm::vec3& p_force) {
            return force(p_id, p_force);
        }
 
        void set_force_and_torque(uint64_t p_id,
                                  const glm::vec3& p_force,
                                  const glm::vec3& p_torque) {
            add_force_and_torque(p_id, p_force, p_torque);
        }
 
        void set_impulse(uint64_t p_id, const glm::vec3& p_impulse) {
            add_impulse(p_id, p_impulse);
        }
 
    private:
        virtual void destroy_bodies() = 0;
 
        virtual void emplace_box_collider(uint32_t p_entity_id,
                                          const transform* p_transform,
                                          const physics_body* p_body,
                                          const box_collider* p_collider) = 0;
 
        virtual void emplace_sphere_collider(
          uint32_t p_entity_id,
          const transform* p_transform,
          const physics_body* p_body,
          const sphere_collider* p_collider) = 0;
 
        virtual void emplace_capsule_collider(
          uint32_t p_entity_id,
          const transform* p_transform,
          const physics_body* p_body,
          const capsule_collider* p_collider) = 0;
 
        virtual transform context_read_transform(uint32_t p_id) = 0;
 
        virtual physics_body context_read_physics_body(uint32_t p_id) = 0;
 
        virtual void prepare_and_finalize() = 0;
 
        virtual void update_simulation(float p_delta_time) = 0;
 
        virtual void linear_velocity(uint64_t p_id, const glm::vec3&) = 0;
 
        virtual void angular_velocity(uint64_t p_id, const glm::vec3&) = 0;
 
        virtual void force(uint64_t p_id,
                           const glm::vec3& p_cumulative_force) = 0;
 
        virtual void add_force_and_torque(uint64_t p_id,
                                          const glm::vec3& p_force,
                                          const glm::vec3& p_torque) = 0;
 
        virtual void add_impulse(uint64_t p_id, const glm::vec3& p_impulse) = 0;
    };
 
    ref<physics_context> initialize_physics_context(
      const jolt_settings& p_settings,
      event::event_bus& p_bus);
};