SimulationAnimationPatch.h

Go to the documentation of this file.

#ifndef _SimulationAnimationPATCH_H_
#define _SimulationAnimationPATCH_H_

#pragma once

#include "LumiverseCoreConfig.h"

#include "../lib/libjson/libjson.h"
#include "SimulationPatch.h"
#include "ArnoldMemoryFrameManager.h"
#include "ArnoldFileFrameManager.h"

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

namespace Lumiverse {
  enum SimulationAnimationMode {
      INTERACTIVE, RECORDING, RENDERING, STOPPED
  };
    
  struct FrameDeviceInfo {
      // The time point of this frame.
      // It's actually the duration counted from the update is first time
      // called.
      time_t time;
      // Copies for devices connected to this patch.
      std::set<Device *> devices;
      SimulationAnimationMode mode;

      FrameDeviceInfo() : time(-1), mode(SimulationAnimationMode::INTERACTIVE) { }

      void clear() {
      time = -1;

      for (Device *d : devices) {
        if (d != NULL)
        delete d;
        d = NULL;
      }
      devices.clear();
      }
      
      void copyByValue(const FrameDeviceInfo &other) {
          time = other.time;
          mode = other.mode;
          for (Device *d : other.devices) {
              devices.insert(new Device(d));
          }
      }
  };
    
  class SimulationAnimationPatch
  {
  public:
    SimulationAnimationPatch() : m_worker(NULL), 
    m_startPoint(std::chrono::system_clock::from_time_t(0)),
#ifdef USE_ARNOLD
      m_mem_frameManager(NULL), m_file_frameManager(NULL),
#endif
    m_mode(SimulationAnimationMode::STOPPED) { }

    SimulationAnimationPatch(const JSONNode data);

    virtual ~SimulationAnimationPatch();

    // Callbacks
    typedef function<void()> FinishedCallbackFunction;
    typedef function<bool(set<Device *>)> IsUpdateRequiredFunction;
    typedef function<void(FrameDeviceInfo&)> CreateFrameInfoBodyFunction;
    typedef function<void()> InterruptFunction;
    typedef function<void()> ClearUpdateFlagsFunction;

    void init();

    virtual void startRecording() { 
#ifdef USE_ARNOLD
      m_mem_frameManager->clear();

      // Overwrite existing frames instead of clearing all
      if (m_file_frameManager)
        m_file_frameManager->reset();

      m_mode = SimulationAnimationMode::RECORDING; 
#endif
    }
    
    virtual void endRecording();
      
  virtual void startInteractive() { m_mode = SimulationAnimationMode::INTERACTIVE; }
      
    virtual SimulationAnimationMode getMode() { return m_mode; }
      
    virtual string getType() { return "SimulationAnimationPatch"; }

  void update(set<Device *> devices, IsUpdateRequiredFunction isUpdateRequired,
    InterruptFunction interruptRender,
    ClearUpdateFlagsFunction clearUpdateFlags);

    void close();

#ifdef USE_ARNOLD

    virtual ArnoldFrameManager *getFrameManager() const;
#endif

  virtual void reset(InterruptFunction interruptRender);
      
  virtual void reset() = 0;

  virtual void stop();
      
    virtual int addFinishedCallback(FinishedCallbackFunction func);
      
  virtual void deleteFinishedCallback(int id);

  protected:

  void loadJSON(const JSONNode data);

  virtual void workerLoop();

  virtual  void onWorkerFinished();

  virtual void onRecording() { }

  virtual void onRendering() { }

  virtual void workerRender(FrameDeviceInfo frame) = 0;

  virtual void createFrameInfoHeader(FrameDeviceInfo &frame);

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

  virtual void enqueueFrameInfo(const FrameDeviceInfo &frame);

    // The worker thread.
    std::thread *m_worker;

    // The lock for the task queue.
    std::mutex m_queue;

    // The task queue.
    std::vector<FrameDeviceInfo> m_queuedFrameDeviceInfo;

    // The start point for time points in FrameDeviceInfo.
    // It's the moment when update function is called for the first
    // time.
    std::chrono::time_point<std::chrono::system_clock> m_startPoint;

#ifdef USE_ARNOLD
    // The ArnoldFrameManager object. Used to store frame buffers.
    ArnoldMemoryFrameManager *m_mem_frameManager;
    ArnoldFileFrameManager *m_file_frameManager;
#endif  

    SimulationAnimationMode m_mode;
      
    map<int, FinishedCallbackFunction> m_onFinishedFunctions;
  };
    
}

#endif