SnapshotCapture.hpp

#ifndef SNAPSHOTCAPTURE_HPP
#define SNAPSHOTCAPTURE_HPP

#include <Radiant/BGThread.hpp>
#include <MultiWidgets/Widget.hpp>
#include <Valuable/Node.hpp>

namespace Showcase {

  class SaveImageTask : public Radiant::Task, public Valuable::Node {
  public:
    typedef std::function<void (bool)> Callback;

    SaveImageTask(const QString& filename, Nimble::Size size, unsigned char* data, MultiWidgets::Widget& listener);
    SaveImageTask(const QString& filename, Nimble::Size size, unsigned char* data, float downsample, Callback calback);
    ~SaveImageTask();

    void doTask() OVERRIDE;
  private:
    QString        m_filename;
    unsigned char* m_data;
    float          m_downsample;
    Nimble::Size   m_size;
    MultiWidgets::WidgetPtr m_listener;
    Callback       m_callback;
  };
  typedef std::shared_ptr<SaveImageTask> SaveImageTaskPtr;

  class Snapshot {
  public:

    enum SnapshotState {
      CAPTURE_PENDING,
      CAPTURE_INITIALIZED,
      CAPTURE_TAKEN,
      CAPTURE_FINISHED
    };

    Snapshot(const QString& filename, const Nimble::Size size, float scaleFactor = 1.f,
             float downsample = 1.0f);
    ~Snapshot();

    SaveImageTaskPtr saveToFile(MultiWidgets::Widget& listener);
    SaveImageTaskPtr saveToFile(std::function<void (bool)> callback);

    SnapshotState getState() const { return m_state; }

    void initialize();

    void capture(Luminous::RenderContext & r);

    Luminous::FrameBuffer & getRenderTarget() { return m_renderTarget; }

    float getScaleFactor() const { return m_scaleFactor; }

    Nimble::Size getSnapshotSize() const { return m_snapshotSize; }

  private:
    //these could be public methods but m_state would have to be checked and possibly reinitialized:
    void setFrameBufferFormat(const Luminous::PixelFormat & format);
    void setFrameBufferSize(const Nimble::Size& size);

    static const int BYTES_PER_PIXEL = 4;

    Luminous::FrameBuffer m_renderTarget;
    Luminous::Texture m_framebuffer;
    Luminous::RenderBuffer m_depthStencilBuffer;
    Luminous::Program m_program;

    QString m_pathToSave;

    unsigned char * m_snapshotBuffer;
    bool m_deleteBuffer;

    SnapshotState m_state;
    Nimble::Size m_snapshotSize;
    float m_scaleFactor;
    float m_downsample;
  };
  typedef std::shared_ptr<Snapshot> SnapshotPtr;


}

#endif // SNAPSHOTCAPTURE_HPP