ArnoldAnimationPatch.h

Go to the documentation of this file.

#ifndef _ArnoldAnimationPATCH_H_
#define _ArnoldAnimationPATCH_H_

#pragma once

#include "LumiverseCoreConfig.h"

#include "../lib/libjson/libjson.h"
#include "SimulationAnimationPatch.h"
#include "ArnoldPatch.h"
#include "ArnoldMemoryFrameManager.h"
#include "ArnoldFileFrameManager.h"
#include "imageio.h"
#include "../lib/libpng/png.h"

#include <thread>
#include <chrono>
#include <iostream>

namespace Lumiverse {
  enum SimulationAnimationMode;
    
  struct FrameDeviceInfo;
    
  class ArnoldAnimationPatch : public SimulationAnimationPatch,
                public ArnoldPatch
  {
  public:
    ArnoldAnimationPatch() : SimulationAnimationPatch(),
      m_preview_samples(m_interface->getSamples()),
      m_render_samples(m_interface->getSamples()) { }

    ArnoldAnimationPatch(ArnoldInterface* itf);

    ArnoldAnimationPatch(const JSONNode data);

    virtual ~ArnoldAnimationPatch();

    virtual void init() override;

    virtual string getType() override { return "ArnoldAnimationPatch"; }

    virtual void update(set<Device *> devices) override;

    virtual void rerender();

    virtual void interruptRender();

    virtual void close() override;

    void setPreviewSamples(int preview);

    void setRenderSamples(int render);

    int getPreviewSamples() { return m_preview_samples; }

    int getRenderSamples() { return m_render_samples; }
      
    // Callbacks
    typedef function<void()> FinishedCallbackFunction;
      
    virtual float getPercentage() const override;

    virtual void reset();

    ArnoldInterface* getArnoldInterface() { return m_interface; }

    void disableContinuousRenderMode();

    void enableContinuousRenderMode();

    void renderSingleFrame(const set<Device *>& devices, string basepath, string filename);

    void renderSingleFrameToBuffer(const set<Device*>& devices, unsigned char* buff, int w = -1, int h = -1);

    void getPositionFromAss(const set<Device*>& devices);

    void getBeamPropsFromAss(const set<Device*>& devices);

  protected:
    virtual void onRecording() override { setSamples(m_preview_samples); }

    virtual void onRendering() override { setSamples(m_render_samples); }
    virtual void loadJSON(const JSONNode data) override;

    virtual void workerRender(FrameDeviceInfo frame);

    virtual void createFrameInfoBody(set<Device *> devices, FrameDeviceInfo &frame, bool forceUpdate = false);

  private:
    int m_preview_samples;

    int m_render_samples;

  };
    
}

#endif