asyncrenderloop.h

Go to the documentation of this file.

/*
 * Copyright (C) 2025-2025 QuasarApp.
 * Distributed under the lgplv3 software license, see the accompanying
 * Everyone is permitted to copy and distribute verbatim copies
 * of this license document, but changing it is not allowed.
*/
 
#ifndef ASYNCRENDERLOOP_H
#define ASYNCRENDERLOOP_H
 
#include "async.h"
 
namespace QH {

class HEARTSHARED_EXPORT AsyncRenderLoop: public Async
{
 
    Q_OBJECT
public:

    template<typename T>
    class MainSharedPtr {
    public:
        MainSharedPtr() {
            static_assert(std::is_base_of_v<AsyncRenderLoop, T>,
                          "T must be derived from AsyncRenderLoop");
        }
 
        MainSharedPtr(const QSharedPointer<T>& ptr): _ptr(ptr) {
            static_assert(std::is_base_of_v<AsyncRenderLoop, T>,
                          "T must be derived from AsyncRenderLoop");
        }
        ~MainSharedPtr() {
            if (_ptr) {
                _ptr->stop();
            }
        }
 
        T* operator->() const {
            return _ptr.operator->();
        }

        T* get() const {
            return _ptr.get();
        }

        template <typename... Args>
        [[nodiscard]] static MainSharedPtr create(Args && ...arguments) {
            return MainSharedPtr(QSharedPointer<T>::create(std::forward<Args>(arguments)...));
        }

        const QSharedPointer<T>& getShared() const {
            return _ptr;
        }
 
    private:
        QSharedPointer<T> _ptr;
    };
 
 
    AsyncRenderLoop(QThread* thread);
    ~AsyncRenderLoop();

    virtual void run();

    virtual void stop();

    bool isRun() const;

    template<typename Type, typename... Args>
    static MainSharedPtr<Type> createMainPtr(Args && ...arguments) {
        return MainSharedPtr<Type>(QSharedPointer<Type>::create(std::forward<Args>(arguments)...));
    };
 
protected:

    virtual void renderIteration(int mmsec) = 0;
 
private slots:
    void renderLoopPrivate();
 
private:
    bool m_run = false;
    std::chrono::time_point<std::chrono::high_resolution_clock> _lastIterationTime;
 
};
}
 
#endif // ASYNCRENDERLOOP_H