rigid-body.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef ANTKEEPER_PHYSICS_RIGID_BODY_HPP
#define ANTKEEPER_PHYSICS_RIGID_BODY_HPP
 
#include <engine/math/vector.hpp>
#include <engine/math/quaternion.hpp>
#include <engine/physics/kinematics/collider.hpp>
#include <engine/math/transform.hpp>
#include <memory>
 
namespace physics {
 
class rigid_body
{
public:
    inline constexpr void set_transform(const math::transform<float>& transform) noexcept
    {
        m_current_transform = transform;
    }
    
    inline constexpr void set_position(const math::fvec3& position) noexcept
    {
        m_current_transform.translation = position;
    }
    
    inline constexpr void set_orientation(const math::fquat& orientation) noexcept
    {
        m_current_transform.rotation = orientation;
    }
    
    inline constexpr void set_scale(const math::fvec3& scale) noexcept
    {
        m_current_transform.scale = scale;
    }
    inline constexpr void set_scale(float scale) noexcept
    {
        m_current_transform.scale = {scale, scale, scale};
    }
    
    inline constexpr void set_previous_transform(const math::transform<float>& transform) noexcept
    {
        m_previous_transform = transform;
    }
    
    inline constexpr void set_previous_position(const math::fvec3& position) noexcept
    {
        m_previous_transform.translation = position;
    }
    
    inline constexpr void set_previous_orientation(const math::fquat& orientation) noexcept
    {
        m_previous_transform.rotation = orientation;
    }
    
    inline constexpr void set_previous_scale(const math::fvec3& scale) noexcept
    {
        m_previous_transform.scale = scale;
    }
    inline constexpr void set_previous_scale(float scale) noexcept
    {
        m_previous_transform.scale = {scale, scale, scale};
    }
    
    inline constexpr void set_center_of_mass(const math::fvec3& point) noexcept
    {
        m_center_of_mass = point;
    }
    
    inline constexpr void set_mass(float mass) noexcept
    {
        m_mass = mass;
        m_inverse_mass = (mass) ? 1.0f / mass : 0.0f;
    }
    
    inline constexpr void set_inertia(float inertia) noexcept
    {
        m_inertia = inertia;
        m_inverse_inertia = (inertia) ? 1.0f / inertia : 0.0f;
    }
    
    inline void set_collider(std::shared_ptr<collider> collider) noexcept
    {
        m_collider = collider;
    }
    
    inline constexpr void set_linear_damping(float damping) noexcept
    {
        m_linear_damping = damping;
    }
    
    inline constexpr void set_angular_damping(float damping) noexcept
    {
        m_angular_damping = damping;
    }
    
    inline constexpr void set_linear_momentum(const math::fvec3& momentum) noexcept
    {
        m_linear_momentum = momentum;
        m_linear_velocity = m_inverse_mass * m_linear_momentum;
    }
    
    inline constexpr void set_angular_momentum(const math::fvec3& momentum) noexcept
    {
        m_angular_momentum = momentum;
        m_angular_velocity = m_inverse_inertia * m_angular_momentum;
    }
    
    inline constexpr void set_linear_velocity(const math::fvec3& velocity) noexcept
    {
        m_linear_velocity = velocity;
        m_linear_momentum = m_mass * m_linear_velocity;
    }
    
    inline constexpr void set_angular_velocity(const math::fvec3& velocity) noexcept
    {
        m_angular_velocity = velocity;
        m_angular_momentum = m_inertia * m_angular_velocity;
    }
    
    [[nodiscard]] inline constexpr const math::transform<float>& get_transform() const noexcept
    {
        return m_current_transform;
    }
    
    [[nodiscard]] inline constexpr const math::fvec3& get_position() const noexcept
    {
        return m_current_transform.translation;
    }
    
    [[nodiscard]] inline constexpr const math::fquat& get_orientation() const noexcept
    {
        return m_current_transform.rotation;
    }
    
    [[nodiscard]] inline constexpr const math::fvec3& get_scale() const noexcept
    {
        return m_current_transform.scale;
    }
    
    [[nodiscard]] inline constexpr const math::transform<float>& get_previous_transform() const noexcept
    {
        return m_previous_transform;
    }
    
    [[nodiscard]] inline constexpr const math::fvec3& get_previous_position() const noexcept
    {
        return m_previous_transform.translation;
    }
    
    [[nodiscard]] inline constexpr const math::fquat& get_previous_orientation() const noexcept
    {
        return m_previous_transform.rotation;
    }
    
    [[nodiscard]] inline constexpr const math::fvec3& get_previous_scale() const noexcept
    {
        return m_previous_transform.scale;
    }
    
    [[nodiscard]] inline constexpr const math::fvec3& get_center_of_mass() const noexcept
    {
        return m_center_of_mass;
    }
    
    [[nodiscard]] inline constexpr float get_mass() const noexcept
    {
        return m_mass;
    }
    
    [[nodiscard]] inline constexpr float get_inverse_mass() const noexcept
    {
        return m_inverse_mass;
    }
    
    [[nodiscard]] inline constexpr float get_inertia() const noexcept
    {
        return m_inertia;
    }
    
    [[nodiscard]] inline constexpr float get_inverse_inertia() const noexcept
    {
        return m_inverse_inertia;
    }
    
    [[nodiscard]] inline constexpr float get_linear_damping() const noexcept
    {
        return m_linear_damping;
    }
    
    [[nodiscard]] inline constexpr float get_angular_damping() const noexcept
    {
        return m_angular_damping;
    }
    
    [[nodiscard]] inline constexpr const std::shared_ptr<collider>& get_collider() const noexcept
    {
        return m_collider;
    }
    
    [[nodiscard]] inline constexpr const math::fvec3& get_linear_momentum() const noexcept
    {
        return m_linear_momentum;
    }
    
    [[nodiscard]] inline constexpr const math::fvec3& get_angular_momentum() const noexcept
    {
        return m_angular_momentum;
    }
    
    [[nodiscard]] inline constexpr const math::fvec3& get_linear_velocity() const noexcept
    {
        return m_linear_velocity;
    }
    
    [[nodiscard]] inline constexpr const math::fvec3& get_angular_velocity() const noexcept
    {
        return m_angular_velocity;
    }
    
    [[nodiscard]] inline constexpr const math::fvec3& get_applied_force() const noexcept
    {
        return m_applied_force;
    }
    
    [[nodiscard]] inline constexpr const math::fvec3& get_applied_torque() const noexcept
    {
        return m_applied_torque;
    }
    
    [[nodiscard]] inline constexpr math::fvec3 get_point_velocity(const math::fvec3& radius) const noexcept
    {
        return m_linear_velocity + math::cross(m_angular_velocity, radius);
    }
    
    [[nodiscard]] inline constexpr bool is_static() const noexcept
    {
        return (m_mass == 0.0f);
    }
    
    inline constexpr void apply_force(const math::fvec3& force, const math::fvec3& radius) noexcept
    {
        m_applied_force += force;
        m_applied_torque += math::cross(radius, force);
    }
    
    inline constexpr void apply_central_force(const math::fvec3& force) noexcept
    {
        m_applied_force += force;
    }
    
    inline constexpr void apply_torque(const math::fvec3& torque) noexcept
    {
        m_applied_torque += torque;
    }
    
    inline constexpr void apply_impulse(const math::fvec3& impulse, const math::fvec3& radius) noexcept
    {
        m_linear_momentum += impulse;
        m_angular_momentum += math::cross(radius, impulse);
        
        // Update velocities
        m_linear_velocity = m_inverse_mass * m_linear_momentum;
        m_angular_velocity = m_inverse_inertia * m_angular_momentum;
    }
    
    inline constexpr void apply_central_impulse(const math::fvec3& impulse) noexcept
    {
        m_linear_momentum += impulse;
        
        // Update linear velocity
        m_linear_velocity = m_inverse_mass * m_linear_momentum;
    }
    
    inline constexpr void apply_torque_impulse(const math::fvec3& torque) noexcept
    {
        m_angular_momentum += torque;
        
        // Update angular velocity
        m_angular_velocity = m_inverse_inertia * m_angular_momentum;
    }
    
    inline constexpr void clear_applied_forces() noexcept
    {
        m_applied_force = {};
        m_applied_torque = {};
    }
    
    void integrate_forces(float dt) noexcept;
    
    void integrate_velocities(float dt) noexcept;
    
    inline void integrate(float dt) noexcept
    {
        integrate_forces(dt);
        integrate_velocities(dt);
    }
    
    [[nodiscard]] math::transform<float> interpolate(float alpha) const;
    
private:
    math::transform<float> m_current_transform{math::transform<float>::identity()};
    
    math::transform<float> m_previous_transform{math::transform<float>::identity()};
    
    math::fvec3 m_center_of_mass{};
    
    float m_mass{1.0f};
    
    float m_inverse_mass{1.0f};
    
    float m_inertia{1.0f};
    
    float m_inverse_inertia{1.0f};
    
    float m_linear_damping{};
    
    float m_angular_damping{};
    
    std::shared_ptr<collider> m_collider;
    
    math::fvec3 m_linear_momentum{};
    
    math::fvec3 m_angular_momentum{};
    
    math::fvec3 m_linear_velocity{};
    
    math::fvec3 m_angular_velocity{};
    
    math::fvec3 m_applied_force{};
    
    math::fvec3 m_applied_torque{};
};
 
} // namespace physics
 
#endif // ANTKEEPER_PHYSICS_RIGID_BODY_HPP