accumulator.hpp

 
#pragma once
#include "physics_settings.hpp"
 
#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <toast/log.hpp>
#include <toast/time.hpp>
#include <tracy/Tracy.hpp>
 
namespace physics {
 
struct StepResult {
  unsigned steps = 0;
  double alpha = 0.0;
  bool dropped_time = false;

  bool time_budget_reached = false;
};
 
class Accumulator {
public:
  [[nodiscard]]
  static auto fixedDelta() -> double {
    return tunables().fixedDelta();
  }
 
  [[nodiscard]]
  static auto maxSteps() -> unsigned {
    return std::max(tunables().max_substeps, 1u);
  }
 
  template<typename Fn>
  auto tick(double dt, Fn&& fn) -> StepResult {
    ZoneScopedN("physics::Accumulator");
 
    m_accumulator += dt;
 
    StepResult result;
    const double fixed_delta = fixedDelta();
    const unsigned max_steps = maxSteps();
    const auto burst_start = std::chrono::steady_clock::now();
 
    while (m_accumulator >= fixed_delta && result.steps < max_steps) {
      if (result.steps > 0) {
        const auto elapsed = std::chrono::duration<double>(std::chrono::steady_clock::now() - burst_start).count();
        if (elapsed >= tunables().max_burst_seconds) {
          result.time_budget_reached = true;
          break;
        }
      }
 
      fn();
 
      m_accumulator -= fixed_delta;
      ++result.steps;
    }
 
    if (m_accumulator >= fixed_delta) {
      TOAST_WARN("Physics", "Accumulator overflow: {} seconds of physics time dropped", m_accumulator);
      m_accumulator = std::fmod(m_accumulator, fixed_delta);
      result.dropped_time = true;
    }
 
    result.alpha = m_accumulator / fixed_delta;
    return result;
  }
 
  [[nodiscard]]
  auto alpha() const noexcept -> double {
    return m_accumulator / fixedDelta();
  }
 
  [[nodiscard]]
  auto value() const noexcept -> double {
    return m_accumulator;
  }
 
  void reset() noexcept { m_accumulator = 0.0; }
 
private:
  double m_accumulator = 0.0;
};
 
}