physics_world_internal.h

#pragma once
 
#include "pixelbullet/physics/physics_world.h"
 
#include <Jolt/Jolt.h>
 
#include <Jolt/Core/JobSystemSingleThreaded.h>
#include <Jolt/Core/TempAllocator.h>
#include <Jolt/Physics/Body/BodyID.h>
#include <Jolt/Physics/Body/MotionType.h>
#include <Jolt/Physics/Collision/BroadPhase/BroadPhaseLayer.h>
#include <Jolt/Physics/Collision/ContactListener.h>
#include <Jolt/Physics/Collision/ObjectLayer.h>
#include <Jolt/Physics/Collision/Shape/Shape.h>
#include <Jolt/Physics/PhysicsSystem.h>
 
#include <glm/gtc/quaternion.hpp>
 
#include <cstdint>
#include <memory>
#include <optional>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace pixelbullet
{
namespace physics_internal
{
class JoltRuntime
{
public:
    JoltRuntime();
    ~JoltRuntime();
};
 
namespace object_layers
{
constexpr JPH::ObjectLayer k_non_moving = 0;
constexpr JPH::ObjectLayer k_moving = 1;
} // namespace object_layers
 
namespace broad_phase_layers
{
constexpr JPH::BroadPhaseLayer k_non_moving(0);
constexpr JPH::BroadPhaseLayer k_moving(1);
constexpr uint32_t k_count = 2;
} // namespace broad_phase_layers
 
class BroadPhaseLayerInterfaceImpl final : public JPH::BroadPhaseLayerInterface
{
public:
    [[nodiscard]] JPH::uint GetNumBroadPhaseLayers() const override;
    [[nodiscard]] JPH::BroadPhaseLayer GetBroadPhaseLayer(JPH::ObjectLayer layer) const override;
};
 
class ObjectLayerPairFilterImpl final : public JPH::ObjectLayerPairFilter
{
public:
    [[nodiscard]] bool ShouldCollide(JPH::ObjectLayer layer1, JPH::ObjectLayer layer2) const override;
};
 
class ObjectVsBroadPhaseLayerFilterImpl final : public JPH::ObjectVsBroadPhaseLayerFilter
{
public:
    [[nodiscard]] bool ShouldCollide(JPH::ObjectLayer layer1, JPH::BroadPhaseLayer layer2) const override;
};
 
[[nodiscard]] JPH::Quat ToJoltQuat(const glm::quat& rotation);
[[nodiscard]] JPH::RVec3 ToJoltRVec3(const glm::vec3& value);
[[nodiscard]] JPH::Vec3 ToJoltVec3(const glm::vec3& value);
template <typename TVector>
[[nodiscard]] glm::vec3 ToGlmVec3(const TVector& value)
{
    return glm::vec3(static_cast<float>(value.GetX()), static_cast<float>(value.GetY()), static_cast<float>(value.GetZ()));
}
[[nodiscard]] glm::quat ToGlmQuat(const JPH::Quat& value);
[[nodiscard]] JPH::EMotionType ToJoltMotionType(RigidBodyMotionType type);
[[nodiscard]] JPH::ObjectLayer ResolveObjectLayer(const PhysicsBodyCreateInfo& create_info);
[[nodiscard]] uint32_t BuildBodyKey(JPH::BodyID body_id);
 
[[nodiscard]] std::optional<PhysicsBodyPose> SanitizePose(const PhysicsBodyPose& pose);
[[nodiscard]] bool IsValidColliderDescription(const PhysicsColliderDescription& collider);
[[nodiscard]] bool IsValidBodyCreateInfo(const PhysicsBodyCreateInfo& create_info);
[[nodiscard]] JPH::ShapeRefC CreateShape(const PhysicsColliderDescription& collider);
} // namespace physics_internal
 
struct PhysicsWorldImpl;
 
class PhysicsWorldContactListener final : public JPH::ContactListener
{
public:
    explicit PhysicsWorldContactListener(PhysicsWorldImpl& owner);
 
    void OnContactAdded(const JPH::Body& body1, const JPH::Body& body2, const JPH::ContactManifold&, JPH::ContactSettings&) override;
    void OnContactRemoved(const JPH::SubShapeIDPair& sub_shape_pair) override;
 
private:
    PhysicsWorldImpl& owner_;
};
 
struct PhysicsWorldImpl
{
    struct Slot
    {
        JPH::BodyID body_id;
        uint32_t generation = 0;
        bool occupied = false;
        bool is_trigger = false;
    };
 
    PhysicsWorldImpl();
 
    [[nodiscard]] bool ValidateHandle(PhysicsBodyHandle handle, uint32_t& slot_index) const;
    [[nodiscard]] PhysicsBodyHandle MakeHandle(uint32_t slot_index) const;
    [[nodiscard]] std::optional<uint32_t> FindSlotIndex(JPH::BodyID body_id) const;
    void QueueDirectedTriggerEvent(uint32_t trigger_slot_index, uint32_t other_slot_index, PhysicsTriggerEventType type);
    void QueueTriggerEvents(JPH::BodyID body1, JPH::BodyID body2, PhysicsTriggerEventType type);
    void QueueTriggerExitEventsForSlot(uint32_t slot_index);
    [[nodiscard]] uint32_t AcquireSlot(JPH::BodyID body_id, bool is_trigger);
    void ReleaseSlot(uint32_t slot_index);
    void ResetAfterClear();
 
    physics_internal::JoltRuntime runtime;
    physics_internal::BroadPhaseLayerInterfaceImpl broad_phase_layer_interface;
    physics_internal::ObjectLayerPairFilterImpl object_layer_pair_filter;
    physics_internal::ObjectVsBroadPhaseLayerFilterImpl object_vs_broad_phase_filter;
    JPH::PhysicsSystem physics_system;
    JPH::TempAllocatorMalloc temp_allocator;
    JPH::JobSystemSingleThreaded job_system;
    PhysicsWorldContactListener contact_listener;
    std::vector<Slot> slots;
    std::vector<uint32_t> free_slots;
    std::unordered_map<uint32_t, uint32_t> body_keys_to_slots;
    std::unordered_set<uint64_t> active_trigger_overlaps;
    std::vector<PhysicsTriggerEvent> pending_trigger_events;
};
} // namespace pixelbullet