time.hpp

Go to the documentation of this file.

/*
    Copyright 2021 natinusala
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
 
        http://www.apache.org/licenses/LICENSE-2.0
 
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/
 
#pragma once
 
#include <libretro-common/features/features_cpu.h>
#include <libretro-common/libretro.h>
 
#include <atomic>
#include <ctime>
 
#include <functional>
#include <vector>
 
namespace aurore
{
 
typedef retro_time_t Time;
 
namespace detail
{
    // A negative value: the real clock
    inline std::atomic<Time> simulatedTimeUsec { -1 };
    inline std::atomic<int64_t> simulatedWallTime { -1 };
    inline std::atomic<Time> simulatedWallTimeSetAt { 0 };
}
 
inline Time getCPUTimeUsec()
{
    Time simulated = detail::simulatedTimeUsec.load(std::memory_order_relaxed);
    return simulated >= 0 ? simulated : cpu_features_get_time_usec();
}
 
inline Time getRealTimeUsec()
{
    return cpu_features_get_time_usec();
}
 
inline void setSimulatedTimeUsec(Time usec)
{
    detail::simulatedTimeUsec.store(usec, std::memory_order_relaxed);
}
 
inline bool isTimeSimulated()
{
    return detail::simulatedTimeUsec.load(std::memory_order_relaxed) >= 0;
}
 
inline std::time_t getWallTime()
{
    int64_t start = detail::simulatedWallTime.load(std::memory_order_relaxed);
    if (start < 0)
        return std::time(nullptr);
    return (std::time_t)(start + (getCPUTimeUsec() - detail::simulatedWallTimeSetAt.load(std::memory_order_relaxed)) / 1000000);
}
 
inline void setSimulatedWallTime(int64_t seconds)
{
    detail::simulatedWallTimeSetAt.store(getCPUTimeUsec(), std::memory_order_relaxed);
    detail::simulatedWallTime.store(seconds, std::memory_order_relaxed);
}
 
inline std::tm localTime(std::time_t time)
{
    std::tm result {};
#ifdef _WIN32
    localtime_s(&result, &time);
#else
    localtime_r(&time, &result);
#endif
    return result;
}
 
typedef std::function<void()> TickingGenericCallback;
 
typedef std::function<void(bool)> TickingEndCallback;
typedef TickingGenericCallback TickingTickCallback;
 
// Interface representing something that "ticks" every frame for a certain amount of frames,
// like a timer, an animation, a background task...
// The library manages a list of running tickings. Each ticking is reponsible for managing its own
// lifetime by returning true or false in onUpdate.
class Ticking
{
  public:
    virtual ~Ticking();
 
    void start();
 
    void stop();
 
    void setEndCallback(TickingEndCallback endCallback);
 
    void setTickCallback(TickingTickCallback tickCallback);
 
    bool isRunning();
 
    static void updateTickings();
 
    inline static std::vector<Ticking*> runningTickings;
 
  protected:
    virtual bool onUpdate(Time delta) = 0;
 
    virtual void onStart() {};
 
    virtual void onStop() {};
 
  private:
    void stop(bool finished);
 
    bool running = false;
 
    TickingEndCallback endCallback   = [](bool finished) {};
    TickingTickCallback tickCallback = [] {};
};
 
// Represents a "finite" ticking that runs for a known amount of time
// and can be seek / reset / rewound.
class FiniteTicking : public Ticking
{
  public:
    void rewind();
 
    void reset();
 
  protected:
    virtual void onRewind() {};
 
    virtual void onReset() {};
};
 
} // namespace aurore