ArnoldPatch.h

Go to the documentation of this file.

#ifndef _ArnoldPATCH_H_
#define _ArnoldPATCH_H_

#pragma once

#include "LumiverseCoreConfig.h"

#include <iostream>
#include <thread>
#include <algorithm>
#include <cstdio>

#include "SimulationPatch.h"
#include "../lib/libjson/libjson.h"
#include "ArnoldParameterVector.h"
#include "ArnoldInterface.h"
#include "DistributedArnoldInterface.h"
#include "CachingArnoldInterface.h"
#include "DistributedCachingArnoldInterface.h"

namespace Lumiverse {

#ifdef USE_ARNOLD
  struct ArnoldParam;

  struct ArnoldLightRecord : public SimulationLightRecord {
      ArnoldLightRecord()
      : light(NULL), SimulationLightRecord() {}
      ArnoldLightRecord(AtNode *node)
      : light(node) {
      metadata = AiNodeGetName(node);
      rerender_req = true;
    }
      
    virtual void init() {
      rerender_req = true;
      light = NULL;
    }

    virtual void clear() {
      light = NULL;
    }

      AtNode *light;
  };
#endif  

  class ArnoldPatch : public SimulationPatch
  {
  public:
    ArnoldPatch() : m_interface(NULL),
    SimulationPatch() { }

    ArnoldPatch(const JSONNode data);

    virtual ~ArnoldPatch();

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

  virtual void init() override;

  virtual void close() override;

  virtual JSONNode toJSON() override;

    virtual string getType() override { return "ArnoldPatch"; }
      
    virtual int getWidth() { 
    if (!m_interface->isOpen())
      m_interface->init();
    return m_interface->getWidth();
  }

  virtual int getHeight() {
    if (!m_interface->isOpen())
      m_interface->init();
    return m_interface->getHeight();
  }
      
  virtual float *getBufferPointer() { 
    if (!m_interface->isOpen())
      m_interface->init();
    return m_interface->getBufferPointer();
  }
      
    bool setDims(int w, int h) {
      if (w > 0 && h > 0) {
        m_interface->setDims(w, h);
        return true;
      }
      return false;
    }

    size_t getBufferSize() {
      return getWidth() * getHeight() * 4;
    }

    int getSamples() { return m_interface->getSamples(); }
      
    void setSamples(int samples);
      
    virtual void interruptRender() override;

    void forceInterrupt() { m_interface->interrupt(); }
      
    virtual float getPercentage() const { return m_interface->getPercentage(); }

    virtual BucketPositionInfo *getBucketPositionInfo() const { return m_interface->getBucketPositionInfo(); }

    virtual size_t getBucketNumber() const { return m_interface->getBucketNumber(); }

    void setArnoldInterface(ArnoldInterface *arnold_interface) { m_interface = arnold_interface; };

    virtual bool renderLoop(const std::set<Device *> &devices);

    virtual bool renderLoop();

    void setAssFile(std::string assFile) { m_interface->setAssFile(assFile); }
    
    virtual void setOptionParameter(std::string paramName, int val);
    virtual void setOptionParameter(std::string paramName, float val);

    void updateLight(set<Device *> devices);

  protected:

    virtual void loadLight(Device *d_ptr) override;

    void updateLightPredictive(set<Device *> devices);
    
    virtual void loadJSON(const JSONNode data) override;

    ArnoldInterface *m_interface;

  private:
#ifdef USE_ARNOLD
    void setOrientation(AtNode *light_ptr, Device *d_ptr, LumiverseOrientation *pan, LumiverseOrientation *tilt);
    void setOrientation(AtNode *light_ptr, Device *d_ptr, std::string pan_str, std::string tilt_str);
#endif

    void modifyLightColor(Device *d, Eigen::Vector3d white);

    bool useDistributedRendering(JSONNode patch);

    bool m_using_distributed = false;

    bool cacheRendering(const JSONNode data);

    bool m_rendering;

    bool _caching;
  };
}

#endif