CachingArnoldInterface.h

Go to the documentation of this file.

#ifndef _Arnold_CACHE_INTERFACE_H_
#define _Arnold_CACHE_INTERFACE_H_

#pragma once

#include "LumiverseCoreConfig.h"

#ifdef USE_ARNOLD_CACHING

#include "ArnoldInterface.h"

#include "ArnoldParameterVector.h"
#include "Compositor.h"
#include "ToneMapper.h"
#include "EXRLayer.h"
#include <thread>
#include <algorithm>
#include <unordered_map>
#include <set>
#include <thread>
#include <mutex>

namespace Lumiverse {

  class CachingRenderContext
  {
  public:
    CachingRenderContext(Compositor* c, int w, int h);
    ~CachingRenderContext();

    void setSize(int w, int h);
    void render(const set<Device*>& d);

    Compositor* _compositor;
    float* _buffer;
    int _w;
    int _h;
    mutex _inUse;
  };

  class CachingArnoldInterface : public virtual ArnoldInterface
  {
  public:
    CachingArnoldInterface();

    void init();

    void close() override;

    virtual float getPercentage() override;

    int render(const std::set<Device *> &devices, int w, int h, int& cid);

    bool setDims(int w, int h) override;

    void setCacheDims(int w, int h);

    void setSamples(int samples) override;

    void setPath(string path) { _cache_file_path = path; }
    string getPath() { return _cache_file_path; }

#ifdef USE_ARNOLD

    void setOptionParameter(const std::string &paramName, int val) override;
    void setOptionParameter(const std::string &paramName, float val) override;
#endif

    void dumpCache();

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

    float* getBufferForContext(int contextId);

    void closeContext(int contextId);

    virtual JSONNode toJSON() override;

    float getExposure();
    void setExposure(float e);

  protected:

    const static int DEFAULT_WIDTH = 1920;
    const static int DEFAULT_HEIGHT = 980;

    //Compositor compositor;
    ToneMapper tone_mapper;

    Pixel4 *compositor_output;

    int load_exr(string& filename);

    virtual void updateDevicesLayers(const std::set<Device *> &devices);

    const std::unordered_map<std::string, Device*> getDevicesToUpdate(const std::set<Device *> &devices);

    std::unordered_map<std::string, Device*> cached_devices;
    
    bool force_cache_reload = false;
  
    float *m_render_buffer = NULL;

    int _cache_width;

    int _cache_height;

    int _cache_aa_samples;

    string _cache_file_path;

    float _exposure;

    bool optionRequiresCacheReload(const std::string &paramName);

    /*
    * \brief Test whether a device parameter has changed such that its cache
    * basis image should be re-rendered. This can happen on updates to params
    * such as position, rotation, penumbra angle, and distance.
    */
    bool isValidCacheCopy(Device *cached_device, Device *other_device);

    virtual void setHDROutputBuffer();

    void saveLayer(EXRLayer* l);

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

    // Variables for thread safety and parallel rendering of cached images
    map<string, EXRLayer*> _layers;

    vector<CachingRenderContext*> _contexts;

    mutex _updateLock;

    int _maxThreads;
  };
}

#endif // USE_ARNOLD_CACHING

#endif // _Arnold_CACHE_INTERFACE_H_