collider_component.h

#pragma once
 
#include "pixelbullet/physics/physics_types.h"
#include "pixelbullet/serialization/glm_node.h"
#include "pixelbullet/serialization/node.h"
 
namespace pixelbullet
{
struct ColliderComponent
{
    bool enabled = true;
    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 ColliderComponent&) const noexcept = default;
};
 
inline Node& operator<<(Node& node, const ColliderComponent& component)
{
    node["enabled"] << component.enabled;
    std::string shape = "Box";
    if (component.shape == ColliderShapeType::Sphere)
    {
        shape = "Sphere";
    }
    else if (component.shape == ColliderShapeType::Capsule)
    {
        shape = "Capsule";
    }
    node["shape"] << shape;
    node["boxHalfExtents"] << component.box_half_extents;
    node["sphereRadius"] << component.sphere_radius;
    node["capsuleRadius"] << component.capsule_radius;
    node["capsuleHalfHeight"] << component.capsule_half_height;
    node["center"] << component.center;
    node["friction"] << component.friction;
    node["restitution"] << component.restitution;
    node["isTrigger"] << component.is_trigger;
    return node;
}
 
inline const Node& operator>>(const Node& node, ColliderComponent& component)
{
    if (node.HasProperty("enabled"))
    {
        node["enabled"] >> component.enabled;
    }
    if (node.HasProperty("shape"))
    {
        std::string serialized_shape;
        node["shape"] >> serialized_shape;
        if (serialized_shape == "Sphere")
        {
            component.shape = ColliderShapeType::Sphere;
        }
        else if (serialized_shape == "Capsule")
        {
            component.shape = ColliderShapeType::Capsule;
        }
        else
        {
            component.shape = ColliderShapeType::Box;
        }
    }
    if (node.HasProperty("boxHalfExtents"))
    {
        node["boxHalfExtents"] >> component.box_half_extents;
    }
    if (node.HasProperty("sphereRadius"))
    {
        node["sphereRadius"] >> component.sphere_radius;
    }
    if (node.HasProperty("capsuleRadius"))
    {
        node["capsuleRadius"] >> component.capsule_radius;
    }
    if (node.HasProperty("capsuleHalfHeight"))
    {
        node["capsuleHalfHeight"] >> component.capsule_half_height;
    }
    if (node.HasProperty("center"))
    {
        node["center"] >> component.center;
    }
    if (node.HasProperty("friction"))
    {
        node["friction"] >> component.friction;
    }
    if (node.HasProperty("restitution"))
    {
        node["restitution"] >> component.restitution;
    }
    if (node.HasProperty("isTrigger"))
    {
        node["isTrigger"] >> component.is_trigger;
    }
    else
    {
        component.is_trigger = false;
    }
    return node;
}
} // namespace pixelbullet