spring.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_SPRING_HPP
#define ANTKEEPER_PHYSICS_SPRING_HPP
 
#include <engine/math/numbers.hpp>
#include <engine/physics/frequency.hpp>
 
namespace physics {
 
template <class T, class S>
constexpr void solve_spring(T& x, T& v, const T& xt, S z, S w, S dt) noexcept
{
    const auto ww_dt = w * w * dt;
    const auto ww_dtdt = ww_dt * dt;
    const auto f = z * w * dt * S{2} + S{1};
    const auto inv_det = S{1} / (f + ww_dtdt);
    
    x = (x * f + v * dt + xt * ww_dtdt) * inv_det;
    v = (v + (xt - x) * ww_dt) * inv_det;
}
 
template <class T, class S>
class numeric_spring
{
public:
    using value_type = T;
    
    using scalar_type = S;
    
    inline constexpr void solve(scalar_type dt) noexcept
    {
        solve_spring(m_value, m_velocity, m_target_value, m_damping_ratio, m_angular_frequency, dt);
    }
    
    inline constexpr void set_value(const value_type& value) noexcept
    {
        m_value = value;
    }
    
    inline constexpr void set_target_value(const value_type& value) noexcept
    {
        m_target_value = value;
    }
    
    inline constexpr void set_velocity(const value_type& velocity) noexcept
    {
        m_velocity = velocity;
    }
    
    inline constexpr void set_damping_ratio(scalar_type ratio) noexcept
    {
        m_damping_ratio = ratio;
    }
    
    inline constexpr void set_angular_frequency(scalar_type angular_frequency) noexcept
    {
        m_angular_frequency = angular_frequency;
    }
    
    inline constexpr void set_period(scalar_type period) noexcept
    {
        m_angular_frequency = s_to_rads(period);
    }
    
    inline constexpr void set_frequency(scalar_type frequency) noexcept
    {
        m_angular_frequency = hz_to_rads(frequency);
    }
    
    [[nodiscard]] inline constexpr const value_type& get_value() const noexcept
    {
        return m_value;
    }
    
    [[nodiscard]] inline constexpr const value_type& get_target_value() const noexcept
    {
        return m_target_value;
    }
    
    [[nodiscard]] inline constexpr const value_type& get_velocity() const noexcept
    {
        return m_velocity;
    }
    
    [[nodiscard]] inline constexpr scalar_type get_damping_ratio() const noexcept
    {
        return m_damping_ratio;
    }
    
    [[nodiscard]] inline constexpr scalar_type get_angular_frequency() const noexcept
    {
        return m_angular_frequency;
    }
    
    [[nodiscard]] inline constexpr scalar_type get_period() const noexcept
    {
        return rads_to_s(m_angular_frequency);
    }
    
    [[nodiscard]] inline constexpr scalar_type get_frequency() const noexcept
    {
        return rads_to_hz(m_angular_frequency);
    }
    
private:
    value_type m_value{};
    value_type m_target_value{};
    value_type m_velocity{};
    scalar_type m_damping_ratio{1};
    scalar_type m_angular_frequency{math::two_pi<scalar_type>};
};
 
} // namespace physics
 
#endif // ANTKEEPER_PHYSICS_SPRING_HPP