ArnoldInterface.h

Go to the documentation of this file.

#ifndef _ArnoldINTERFACE_H_
#define _ArnoldINTERFACE_H_

#pragma once

#include "LumiverseCoreConfig.h"

#include <algorithm>
#include <cstdio>

#ifdef USE_ARNOLD
  #include "../lib/arnold/include/ai.h"
#endif

#include "../Patch.h"
#include "../lib/libjson/libjson.h"
#include "ArnoldParameterVector.h"
#include <thread>
#include <iostream>
#include <locale>
#include <set>

namespace Lumiverse {
#ifdef USE_ARNOLD

  struct ArnoldParam {
    ArnoldParam()
      : dimension(1), arnoldTypeName("unknown") { }
      
      size_t dimension;
      std::string arnoldTypeName;
  };

  template<typename T>
  union AiNodeSetter {
    void (*AiNodeSetter1D)(AtNode *, const char *, T);
    void (*AiNodeSetter2D)(AtNode *, const char *, T, T);
    void (*AiNodeSetter3D)(AtNode *, const char *, T, T, T);
    void (*AiNodeSetter4D)(AtNode *, const char *, T, T, T, T);
  };
#endif

  struct BucketPositionInfo {
    int bucket_xo;
    int bucket_yo;
    int bucket_size_x;
    int bucket_size_y;

    BucketPositionInfo() :
      bucket_xo(-1), bucket_yo(-1), bucket_size_x(-1), bucket_size_y(-1) { }
  };

  struct ProgressInfo {
    int bucket_sum;
    int bucket_cur;

    ProgressInfo() : bucket_sum(-1), bucket_cur(-1) { }
  };

  class ArnoldInterface
  {
  public:
     ArnoldInterface() : m_buffer(NULL), m_gamma(2.2f), m_samples(-3), m_predictive(false),
       m_bucket_pos(NULL), m_bucket_num(0), m_open(false) { }
      
    virtual ~ArnoldInterface() { 
      delete[] m_buffer; 
      m_buffer = NULL;
      delete[] m_bucket_pos; 
      m_bucket_pos = NULL;
      m_bucket_num = 0; 
    }
      
    virtual void init();

    virtual void init(const JSONNode jsonPatch) { this->init(); }

    virtual void close();

    virtual string getInterfaceType() { return "ArnoldInterface"; }
      
    int getWidth() { return m_width; }
      
    int getHeight() { return m_height; }

    virtual bool setDims(int w, int h);
    
    virtual float *getBufferPointer() { return m_buffer; }

#ifdef USE_ARNOLD

    void setParameter(string lightName, string param, int val);

    void setParameter(string lightName, string param, float val);

    void setParameter(string lightName, string param, Eigen::Matrix3f rot, Eigen::Vector3f trans);

    void setParameter(string lightName, string param, float x, float y, float z);

    void setParameter(AtNode *light_ptr, const std::string &paramName, const std::string &value);
      
    void setArrayParameter(AtNode *light_ptr, const std::string &paramName, const std::string &value);

    virtual void setOptionParameter(const std::string &paramName, int val);
    virtual void setOptionParameter(const std::string &paramName, float val);
      
    int getOptionParameter(const std::string &paramName);

    void loadArnoldParam(const JSONNode data);      
#endif

    void setAssFile(std::string fileName) { m_ass_file = fileName; }
      
    std::string getAssFile() { return m_ass_file; }
      
    void setPluginDirectory(std::string dir) { m_plugin_dir = dir; }
      
    std::string getPluginDirectory() { return m_plugin_dir; }
      
    void setGamma(float gamma) { m_gamma = gamma; }
      
    float getGamma() { return m_gamma; }

    void setPredictive(bool predictive) { m_predictive = predictive; }

    bool getPredictive() { return m_predictive; }
      
    virtual void setSamples(int samples);

    int getSamples() { return m_samples; }
      
    virtual int render();

    virtual int render(const std::set<Device*>& /* devices */) { return this->render(); }
      
    virtual void interrupt();

    virtual JSONNode toJSON();

    virtual float getPercentage() { 
      if (m_progress.bucket_sum < 0)
        return 0.f;
      return (0.f + m_progress.bucket_cur) / m_progress.bucket_sum * 100.f; 
    }

    BucketPositionInfo *getBucketPositionInfo() const { return m_bucket_pos; }

    size_t getBucketNumber() const { return m_bucket_num; }

#ifdef USE_ARNOLD

    void updateSurfaceColor(Eigen::Vector3d white);
#endif

    void setDefaultPath(std::string def_path) { m_default_path = def_path; }

    std::string getDefaultPath() { return m_default_path; }

    bool isOpen() { return m_open; }

#ifdef USE_ARNOLD
    void addGobo(AtNode *light_ptr, std::string file, float deg, float rot);

    void setLogFileName(string filename, int flags = AI_LOG_ALL);

    map<string, AtNode*> getLights();

    void setDriverFileName(string base, string filename);
#endif

    virtual bool isDistributedOpen();

    bool isUsingCaching() { return m_using_caching; }

    void setUsingCaching(bool usingCaching) { m_using_caching = usingCaching; }

    virtual void loadIfUsingCaching(const set<Device*>& /* devices */) { };

  protected:
#ifdef USE_ARNOLD

    template<size_t D, typename T>
    void setSingleParameter(AtNode *node, const std::string &paramName, const std::string &value,
                            union AiNodeSetter<T> aiNodeSetter) const;
    
    template<size_t D, typename T, class C>
    void setArrayParameter(AtNode *node, const std::string &paramName, const std::string &value,
                           bool (*AiArraySet) (AtArray*, AtUInt32, C, const char*, int), const int AiType) const;
            
    void appendToOutputs(const std::string buffer_output);
#endif

  inline static bool isRelativeFileName(std::string str) {
    // This function is applied to STRING arnold parameters.
    // Right now we only need to handle .ies file.
    // May add more conditions to this line in the future.
    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
    if ((!str.empty() && str[0] == '.') ||
      ((str.find(".ies") != std::string::npos || str.find(".ass") != std::string::npos
      || str.find(".jpg") != std::string::npos) &&
      (str.find("/") == std::string::npos && str.find("\\") == std::string::npos)))
      return true;
    return false;
  }
      
  inline std::string toRelativePath(std::string file);

#ifdef USE_ARNOLD

  map<string, ArnoldParam> m_arnold_params;
#endif    

    std::string m_ass_file;
      
    std::string m_plugin_dir;
      
    float *m_buffer;
    
    int m_width;
      
    int m_height;
      
    float m_gamma;
      
    int m_samples;

    bool m_predictive;

    bool m_open;

    // An array for worker threads.
    BucketPositionInfo *m_bucket_pos;

    // The size of buckets array.
    size_t m_bucket_num;

    // The progress info of the current frame.
    ProgressInfo m_progress;

    // The default path for all passed files (.ass, .ies...)
    std::string m_default_path;

    // Buffer driver name
    string m_bufDriverName;

  bool m_using_caching;
  };

  template<size_t D, typename T>
  static bool parseArnoldParameter(const std::string &value, ArnoldParameterVector<D, T> &vector) {
    T element;
    std::string value_spaceless = value;
    bool ret = true;

    // Removes spaces when the input type is not string
    int count = 0;
    for (char c : value) {
      std::locale loc;
      if (!std::isspace(c, loc)) {
        value_spaceless[count++] = c;
      }
    }
    value_spaceless = value_spaceless.substr(0, count);

    // Format: "v1, v2, ..."
    size_t offset = 0;
    size_t i;
    for (i = 0; i < D; i++) {
      std::istringstream iss(value_spaceless.substr(offset));
      iss >> element;
      vector[i] = element;

      offset = value_spaceless.find(",", offset);

      if (offset == std::string::npos) {
        i++;
        break;
      }

      offset++;
    }

    if (i != D) {
      ret = false;
      Logger::log(WARN, "Input dimension disagrees with vector dimension. Extra elements are left with existing values.");
    }

    return ret;
  }
}

#endif