physics_types.h

#pragma once
 
#include "pixelbullet/serialization/glm_node.h"
#include "pixelbullet/serialization/node.h"
 
#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;
    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);
    float fraction = 0.0f;
 
    [[nodiscard]] bool operator==(const PhysicsRayHit&) const noexcept = default;
};
 
inline Node& operator<<(Node& node, const ColliderShapeType& value)
{
    switch (value)
    {
    case ColliderShapeType::Box:
        node << "Box";
        break;
    case ColliderShapeType::Sphere:
        node << "Sphere";
        break;
    case ColliderShapeType::Capsule:
        node << "Capsule";
        break;
    }
    return node;
}
 
inline const Node& operator>>(const Node& node, ColliderShapeType& value)
{
    std::string serialized;
    node >> serialized;
    if (serialized == "Sphere")
    {
        value = ColliderShapeType::Sphere;
    }
    else if (serialized == "Capsule")
    {
        value = ColliderShapeType::Capsule;
    }
    else
    {
        value = ColliderShapeType::Box;
    }
    return node;
}
 
inline Node& operator<<(Node& node, const RigidBodyMotionType& value)
{
    switch (value)
    {
    case RigidBodyMotionType::Static:
        node << "Static";
        break;
    case RigidBodyMotionType::Kinematic:
        node << "Kinematic";
        break;
    case RigidBodyMotionType::Dynamic:
        node << "Dynamic";
        break;
    }
    return node;
}
 
inline const Node& operator>>(const Node& node, RigidBodyMotionType& value)
{
    std::string serialized;
    node >> serialized;
    if (serialized == "Kinematic")
    {
        value = RigidBodyMotionType::Kinematic;
    }
    else if (serialized == "Dynamic")
    {
        value = RigidBodyMotionType::Dynamic;
    }
    else
    {
        value = RigidBodyMotionType::Static;
    }
    return node;
}
} // namespace pixelbullet