ModelViewCapture.h

Go to the documentation of this file.

#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;
    /**--------------------------------------------------------------------------------------------------
    \brief Stores information about a screenshot.
    **/
    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;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Used to capture a 2D image of a DesignObjectLookup from a specific perspective.
    **/
    class QModelViewCapture : public WindowInstance
    {
    public:
        friend class QModelViewCaptureThread;
        explicit QModelViewCapture(const DynamicPointer<GraphicsDevice>& device, QTModelManager* manager);
        virtual ~QModelViewCapture();
        virtual void initialize();
        void setCamera(const UUID& camera) override;
 
        void setSize(const Vector<2, uint04>& size) final override
        {
            WindowInstance::setSize(size);
        }
        virtual void* getSurface() override { return nullptr; }
        void 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_material;
        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;
        bool m_auto_crop;
        ConstPointer<CaptureInfo> info;
        std::function<void(const QImage& image)> m_callback;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief An interface used to manage multiple CaptureRequests and scedule their completion.
    **/
    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<QModelViewCapture*> m_capture_frames;
        mutable Buffer<CaptureCache> m_capture_cache;
        Dictionary<UUID, uint04> m_pending_requests;
        QTModelManager* m_manager;
    };
}