Time.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
#include "common/Result.h"
#include "common/StrongUint64.h"
 
#include <compare>
#include <cstdint>
#include <optional>
#include <vector>
 
namespace eve {
 
namespace detail {
struct SimulationTickTag {};
struct FrameIndexTag {};
}  // namespace detail
 
using SimulationTick = detail::StrongUint64<detail::SimulationTickTag>;
 
using FrameIndex = detail::StrongUint64<detail::FrameIndexTag>;
 
class EVENGINE_API_FOUNDATION Duration {
public:
    constexpr Duration() noexcept = default;
 
    explicit constexpr Duration(std::int64_t nanoseconds) noexcept : nanoseconds_(nanoseconds) {}
 
    [[nodiscard]] static constexpr Duration fromNanoseconds(std::int64_t nanoseconds) noexcept {
        return Duration(nanoseconds);
    }
 
    [[nodiscard]] static constexpr Duration zero() noexcept { return {}; }
 
    [[nodiscard]] static Result<Duration> fromSeconds(double seconds);
 
    [[nodiscard]] constexpr std::int64_t nanoseconds() const noexcept { return nanoseconds_; }
 
    [[nodiscard]] double seconds() const noexcept;
 
    [[nodiscard]] constexpr bool isZero() const noexcept { return nanoseconds_ == 0; }
 
    [[nodiscard]] Result<Duration> tryAdd(Duration other) const;
 
    [[nodiscard]] Result<Duration> scaled(double rate) const;
 
    friend constexpr bool operator==(Duration, Duration) noexcept  = default;
    friend constexpr auto operator<=>(Duration, Duration) noexcept = default;
 
private:
    std::int64_t nanoseconds_ = 0;
};
 
class EVENGINE_API_FOUNDATION MonotonicTimestamp {
public:
    constexpr MonotonicTimestamp() noexcept = default;
 
    explicit constexpr MonotonicTimestamp(std::int64_t nanoseconds) noexcept : nanoseconds_(nanoseconds) {}
 
    [[nodiscard]] static constexpr MonotonicTimestamp zero() noexcept { return {}; }
 
    [[nodiscard]] constexpr std::int64_t nanoseconds() const noexcept { return nanoseconds_; }
 
    [[nodiscard]] Result<Duration> since(MonotonicTimestamp earlier) const;
 
    friend constexpr bool operator==(MonotonicTimestamp, MonotonicTimestamp) noexcept  = default;
    friend constexpr auto operator<=>(MonotonicTimestamp, MonotonicTimestamp) noexcept = default;
 
private:
    std::int64_t nanoseconds_ = 0;
};
 
class EVENGINE_API_FOUNDATION_INLINE WallClockTimestamp {
public:
    constexpr WallClockTimestamp() noexcept = default;
 
    explicit constexpr WallClockTimestamp(std::int64_t unixNanoseconds) noexcept : unixNanoseconds_(unixNanoseconds) {}
 
    [[nodiscard]] constexpr std::int64_t unixNanoseconds() const noexcept { return unixNanoseconds_; }
 
    friend constexpr bool operator==(WallClockTimestamp, WallClockTimestamp) noexcept  = default;
    friend constexpr auto operator<=>(WallClockTimestamp, WallClockTimestamp) noexcept = default;
 
private:
    std::int64_t unixNanoseconds_ = 0;
};
 
struct EVENGINE_API_FOUNDATION_INLINE SimulationStep {
    SimulationTick tick = SimulationTick::zero();
    Duration delta = Duration::zero();
};
 
class EVENGINE_API_FOUNDATION_INLINE ITimeSource {
public:
    static constexpr const char* capabilityName = "ITimeSource";
    virtual ~ITimeSource()                      = default;
 
    [[nodiscard]] virtual MonotonicTimestamp monotonicNow() const = 0;
 
    [[nodiscard]] virtual WallClockTimestamp wallClockNow() const = 0;
};
 
class EVENGINE_API_FOUNDATION SimulationClock {
public:
    explicit SimulationClock(ITimeSource& source, Duration fixedStep = Duration::fromNanoseconds(16666667));
 
    [[nodiscard]] Result<std::vector<SimulationStep>> sample();
 
    [[nodiscard]] Result<std::vector<SimulationStep>> advance(Duration realDelta);
 
    [[nodiscard]] Result<void> setFixedStep(Duration fixedStep);
    [[nodiscard]] Result<void> setRate(double rate);
    void setPaused(bool paused) noexcept { paused_ = paused; }
 
    void reset(SimulationTick tick = SimulationTick::zero()) noexcept;
 
    [[nodiscard]] SimulationTick currentTick() const noexcept { return tick_; }
    [[nodiscard]] FrameIndex frameIndex() const noexcept { return frame_; }
    [[nodiscard]] Duration fixedStep() const noexcept { return fixedStep_; }
    [[nodiscard]] double rate() const noexcept { return rate_; }
    [[nodiscard]] bool paused() const noexcept { return paused_; }
    [[nodiscard]] Duration lastFrameDelta() const noexcept { return lastFrameDelta_; }
 
private:
    ITimeSource&                      source_;
    Duration                          fixedStep_;
    Duration                          accumulator_;
    Duration                          lastFrameDelta_;
    double                            rate_   = 1.0;
    SimulationTick                    tick_   = SimulationTick::zero();
    FrameIndex                        frame_  = FrameIndex::zero();
    bool                              paused_ = false;
    std::optional<MonotonicTimestamp> previousSourceTime_;
};
 
}  // namespace eve