physics_types.h

#pragma once
 
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
 
#include <cstdint>
 
namespace pixelbullet
{
enum class ColliderShapeType
{
    Box,
    Sphere,
    Capsule,
};
 
enum class RigidBodyMotionType
{
    Static,
    Kinematic,
    Dynamic,
};
 
struct PhysicsBodyHandle
{
    uint64_t value = 0;
 
    [[nodiscard]] explicit operator bool() const noexcept
    {
        return value != 0;
    }
 
    [[nodiscard]] bool operator==(const PhysicsBodyHandle&) const noexcept = default;
};
 
struct PhysicsBodyPose
{
    glm::vec3 position = glm::vec3(0.0f);
    glm::quat rotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f);
 
    [[nodiscard]] bool operator==(const PhysicsBodyPose&) const noexcept = default;
};
 
struct PhysicsColliderDescription
{
    ColliderShapeType shape = ColliderShapeType::Box;
    glm::vec3 box_half_extents = glm::vec3(0.5f);
    float sphere_radius = 0.5f;
    float capsule_radius = 0.5f;
    // Half-height of the cylindrical capsule section, excluding the hemispherical caps.
    float capsule_half_height = 0.5f;
    glm::vec3 center = glm::vec3(0.0f);
    float friction = 0.5f;
    float restitution = 0.0f;
    bool is_trigger = false;
 
    [[nodiscard]] bool operator==(const PhysicsColliderDescription&) const noexcept = default;
};
 
enum class PhysicsTriggerEventType
{
    Enter,
    Exit,
};
 
struct PhysicsTriggerEvent
{
    PhysicsBodyHandle trigger_body{};
    PhysicsBodyHandle other_body{};
    PhysicsTriggerEventType type = PhysicsTriggerEventType::Enter;
 
    [[nodiscard]] bool operator==(const PhysicsTriggerEvent&) const noexcept = default;
};
 
struct PhysicsBodyCreateInfo
{
    PhysicsBodyPose pose;
    PhysicsColliderDescription collider;
    bool has_rigid_body = false;
    RigidBodyMotionType motion_type = RigidBodyMotionType::Static;
    float mass = 1.0f;
    float linear_damping = 0.05f;
    float angular_damping = 0.05f;
    float gravity_scale = 1.0f;
 
    [[nodiscard]] bool operator==(const PhysicsBodyCreateInfo&) const noexcept = default;
};
 
struct PhysicsSweepHit
{
    PhysicsBodyHandle body{};
    glm::vec3 position = glm::vec3(0.0f);
    glm::vec3 normal = glm::vec3(0.0f, 1.0f, 0.0f);
    float fraction = 0.0f;
    float penetration_depth = 0.0f;
 
    [[nodiscard]] bool operator==(const PhysicsSweepHit&) const noexcept = default;
};
 
struct PhysicsRayHit
{
    PhysicsBodyHandle body{};
    glm::vec3 position = glm::vec3(0.0f);
    glm::vec3 normal = glm::vec3(0.0f, 1.0f, 0.0f);
    float fraction = 0.0f;
 
    [[nodiscard]] bool operator==(const PhysicsRayHit&) const noexcept = default;
};
} // namespace pixelbullet