ModelViewCapture.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/GraphicsDevice.h>
#include <NDEVR/QModelViewCapture.h>
#include <NDEVR/QCustomImage.h>
#include <NDEVR/CaptureInfo.h>
#include <NDEVR/WindowInstance.h>
namespace NDEVR
{
    class Thread;
    struct CaptureCache : public CaptureInfo
    {
        CaptureCache()
        {}

        CaptureCache(const CaptureInfo& info, const Time& n_time, const QImage& n_image)
            : CaptureInfo(info)
            , time(n_time)
            , image(n_image)
        {}
        bool operator==(const CaptureInfo& info) const
        {
            return (snap == info.snap)
                && (target_object == info.target_object)
                && (included_objects == info.included_objects)
                && (orthographic == info.orthographic)
                && (background == info.background)
                && (auto_crop == info.auto_crop)
                && (reference_size == info.reference_size)
                && (size == info.size);;
        }
        Time time; 
        QImage image; 
    };

    class QModelViewCapture : public WindowInstance
    {
    public:
        friend class QModelViewCaptureThread;
        explicit QModelViewCapture(const DynamicPointer<GraphicsDevice>& device, QTModelManager* manager);
        virtual ~QModelViewCapture();
        virtual void initialize();
        void setCamera(const DynamicPointer<Camera>& camera) override;
 
        void setSize(const Vector<2, uint04>& size) final override
        {
            WindowInstance::setSize(size);
        }
        virtual void* getSurface() override { return nullptr; }
        bool update();

        uint04 getGrabImageSize() final override
        {
            return 1;
        }

        virtual bool shouldExit() const override;
        void setupMaterialModel();
        void addRequest(const ConstPointer<CaptureRequest>& request);
        void executeRequest(const ConstPointer<CaptureRequest>& request);
        void removeRequest(const ConstPointer<CaptureRequest>& request);
        uint04 requestSize() const { return m_requests.size(); }
        void setCacheCallback(const std::function<void(const CaptureCache&)>& function) { m_capture_cache_callback = function; }
        QImage getModelImage(const CaptureInfo& info);

        void requestModelImage(const ConstPointer<CaptureRequest>& request);
        void finishFrame(GraphicsUpdateArguments& args) override;
        Resource<bool> is_running; 
    protected:
        Renderer* getRenderer() { return m_render; };
    private:
        UUID m_current_request_id = Constant<UUID>::Invalid;
        UUID m_material_preview_model;
        DynamicPointer<GraphicsDevice> m_device;
        Buffer<ConstPointer<CaptureRequest>> m_requests;
        std::function<void(const CaptureCache&)> m_capture_cache_callback;
        QCustomImage m_image;
        QTModelManager* m_model_manager;
        Renderer* m_render;
#if NDEVR_SUPPORTS_THREADING
        Thread* m_render_thead;
#endif
        bool m_initiation_failure;
        ConstPointer<CaptureInfo> info;
        std::function<void(const QImage& image)> m_callback;
    };

    class QCaptureManager
    {
    public:
        QCaptureManager(const DynamicPointer<GraphicsDevice>& device, QTModelManager* manager, uint04 size);
        virtual ~QCaptureManager();
        virtual void addCaptureRequest(const ConstPointer<CaptureRequest>& request);
        virtual void removeCaptureRequest(const ConstPointer<CaptureRequest>& request);
        virtual void runCaptureRequest(const ConstPointer<CaptureRequest>& request);
        virtual bool isCached(const CaptureInfo& info) const;
    protected:
        void addToCache(const CaptureCache& cache);
        uint04 searchCache(const CaptureInfo& info) const;
        uint04 getAvailableFrame() const;
        uint04 takeAvailableFrame() const;
    protected:
        DynamicPointer<GraphicsDevice> m_device; 
        Buffer<ConstPointer<CaptureRequest>> m_initial_requests; 
        Buffer<QModelViewCapture*> m_capture_frames; 
        mutable Buffer<CaptureCache> m_capture_cache; 
        QTModelManager* m_manager; 
    };
}