physics_component.h

Go to the documentation of this file.

#pragma once
#include <engine/engine_export.h>
 
#include <engine/ecs/components/basic_component.h>
#include <engine/physics/physics_material.h>
#include <engine/layers/layer_mask.h>
#include <engine/assets/asset_handle.h>
#include <hpp/variant.hpp>
#include <math/math.h>
 
 
#include <bitset>
 
namespace unravel
{
class mesh;
 
struct physics_box_shape
{
    friend auto operator==(const physics_box_shape& lhs, const physics_box_shape& rhs) -> bool = default;
 
    math::vec3 center{};                  
    math::vec3 extends{1.0f, 1.0f, 1.0f}; 
};
 
struct physics_sphere_shape
{
    friend auto operator==(const physics_sphere_shape& lhs, const physics_sphere_shape& rhs) -> bool = default;
 
    math::vec3 center{}; 
    float radius{0.5f};  
};
 
struct physics_capsule_shape
{
    friend auto operator==(const physics_capsule_shape& lhs, const physics_capsule_shape& rhs) -> bool = default;
 
    math::vec3 center{}; 
    float radius{0.5f};  
    float length{1.0f};  
};
 
struct physics_cylinder_shape
{
    friend auto operator==(const physics_cylinder_shape& lhs, const physics_cylinder_shape& rhs) -> bool = default;
 
    math::vec3 center{}; 
    float radius{0.5f};  
    float length{1.0f};  
};
 
enum class mesh_collision_type : uint8_t
{
    convex,  
    concave  
};
 
struct physics_mesh_shape
{
    friend auto operator==(const physics_mesh_shape& lhs, const physics_mesh_shape& rhs) -> bool = default;
 
    math::vec3 center{};                                    
    asset_handle<mesh> mesh_asset{};                        
    mesh_collision_type collision_type{mesh_collision_type::concave}; 
};
 
struct physics_compound_shape
{
    friend auto operator==(const physics_compound_shape& lhs, const physics_compound_shape& rhs) -> bool = default;
 
    using shape_t =
        hpp::variant<physics_box_shape, physics_sphere_shape, physics_capsule_shape, physics_cylinder_shape, physics_mesh_shape>;
 
    shape_t shape; 
};
 
enum class physics_property : uint8_t
{
    gravity,
    kind,
    mass,
    material,
    shape,
    sensor,
    constraints,
    velocity,
    angular_velocity,
    layer,
    count
};
 
enum class force_mode : uint8_t
{
    // Interprets the input as torque (measured in Newton-metres), and changes the angular velocity by the value of
    // torque * DT / mass. The effect depends on the simulation step length and the mass of the body.
    force,
 
    // Interprets the parameter as angular acceleration (measured in degrees per second squared), and changes the
    // angular velocity by the value of torque * DT. The effect depends on the simulation step length but does not
    // depend on the mass of the body.
    acceleration,
 
    // Interprets the parameter as an angular momentum (measured in kilogram-meters-squared per second), and changes the
    // angular velocity by the value of torque / mass. The effect depends on the mass of the body but doesn't depend on
    // the simulation step length.
    impulse,
 
    //: Interprets the parameter as a direct angular velocity change (measured in degrees per second), and changes the
    //: angular velocity by the value of torque. The effect doesn't depend on the mass of the body and the simulation
    //: step length.
    velocity_change,
};
 
struct manifold_point
{
    math::vec3 a{};
    math::vec3 b{};
    math::vec3 normal_on_a{};
    math::vec3 normal_on_b{};
    float distance{};
    float impulse{};
};
 
struct raycast_hit
{
    entt::entity entity{};
    math::vec3 point{};
    math::vec3 normal{};
    float distance{};
};
 
class physics_component : public component_crtp<physics_component, owned_component>
{
public:
    static void on_create_component(entt::registry& r, entt::entity e);
 
    static void on_destroy_component(entt::registry& r, entt::entity e);
 
    void set_is_using_gravity(bool use_gravity);
 
    auto is_using_gravity() const noexcept -> bool;
 
    void set_is_kinematic(bool kinematic);
 
    auto is_kinematic() const noexcept -> bool;
 
    void set_is_autoscaled(bool autoscaled);
 
    auto is_autoscaled() const noexcept -> bool;
 
    void set_mass(float mass);
 
    auto get_mass() const noexcept -> float;
 
    void set_is_sensor(bool sensor);
 
    auto is_sensor() const noexcept -> bool;
 
    auto is_dirty(uint8_t id) const noexcept -> bool;
 
    void set_dirty(uint8_t id, bool dirty) noexcept;
 
    auto is_property_dirty(physics_property prop) const noexcept -> bool;
 
    auto are_any_properties_dirty() const noexcept -> bool;
 
    auto are_all_properties_dirty() const noexcept -> bool;
 
    void set_property_dirty(physics_property prop, bool dirty) noexcept;
 
    auto get_shapes_count() const -> size_t;
 
    auto get_shape_by_index(size_t index) const -> const physics_compound_shape&;
 
    void set_shape_by_index(size_t index, const physics_compound_shape& shape);
 
    auto get_shapes() const -> const std::vector<physics_compound_shape>&;
 
    void set_shapes(const std::vector<physics_compound_shape>& shape);
 
    auto get_material() const -> const asset_handle<physics_material>&;
 
    void set_material(const asset_handle<physics_material>& material);
 
    void apply_explosion_force(float explosion_force,
                               const math::vec3& explosion_position,
                               float explosion_radius,
                               float upwards_modifier = 0.0f,
                               force_mode mode = force_mode::force);
 
    void apply_force(const math::vec3& force, force_mode mode = force_mode::force);
 
    void apply_torque(const math::vec3& torque, force_mode mode = force_mode::force);
 
    void set_freeze_rotation(const math::bvec3& xyz);
    void set_freeze_position(const math::bvec3& xyz);
 
    auto get_freeze_rotation() const -> const math::bvec3&;
    auto get_freeze_position() const -> const math::bvec3&;
 
    auto get_velocity() const -> const math::vec3&;
    void set_velocity(const math::vec3& velocity);
 
    auto get_angular_velocity() const -> const math::vec3&;
    void set_angular_velocity(const math::vec3& velocity);
 
    auto get_collision_include_mask() const -> layer_mask;
    void set_collision_include_mask(layer_mask group);
 
    auto get_collision_exclude_mask() const -> layer_mask;
    void set_collision_exclude_mask(layer_mask group);
 
    auto get_collision_mask() const -> layer_mask;
 
    void clear_kinematic_velocities();
 
private:
    void on_change_gravity();
 
    void on_change_mass();
 
    void on_change_kind();
 
    void on_change_shape();
 
    void on_change_material();
 
    void on_change_sensor();
 
    bool is_kinematic_{};
    bool is_using_gravity_{};
    bool is_sensor_{};
    bool is_autoscaled_{true};
    float mass_{1};
 
    layer_mask collision_include_mask_{layer_reserved::everything_layer};
 
    layer_mask collision_exclude_mask_{layer_reserved::nothing_layer};
 
    math::vec3 velocity_{};
 
    math::vec3 angular_velocity_{};
 
    math::bvec3 freeze_position_xyz_{};
 
    math::bvec3 freeze_rotation_xyz_{};
 
    asset_handle<physics_material> material_{};
 
    std::vector<physics_compound_shape> compound_shape_{};
 
    using underlying_t = std::underlying_type_t<physics_property>;
    std::bitset<static_cast<underlying_t>(physics_property::count)> dirty_properties_;
 
    std::bitset<8> dirty_;
};
 
} // namespace unravel