vraysdk.hpp

#ifndef _VRAY_SDK_HPP_
#define _VRAY_SDK_HPP_
 
#if !defined(_M_AMD64) && !defined(__amd64__) && !defined(_M_ARM64) && !defined(__aarch64__)
    #error "V-Ray supports only 64-bit architectures"
#endif
 
#ifndef VRAY_NOTHROW
    #include "vraythrow.hpp"
#endif
 
#include "errcodes.h"
 
#include <new>
#include <cmath>
#include <utility>
#include <cstdint>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <sstream>
#include <vector>
#include <fstream>
#include <atomic>
 
#include "_vraysdk_utils.hpp"
 
#define VRAY_MINIMUM2(a, b) ((a) < (b) ? (a) : (b))
#define VRAY_MAXIMUM2(a, b) ((a) > (b) ? (a) : (b))
#define VRAY_MAXIMUM3(a, b, c) VRAY_MAXIMUM2(VRAY_MAXIMUM2(a, b), c)
#define VRAY_MAXIMUM4(a, b, c, d) VRAY_MAXIMUM2(VRAY_MAXIMUM3(a, b, c), d)
 
#ifdef APPSDK_QT_NAMESPACE
namespace APPSDK_QT_NAMESPACE {
class QWidget;
} // namespace APPSDK_QT_NAMESPACE
#else
#define APPSDK_QT_NAMESPACE
class QWidget;
#endif // APPSDK_QT_NAMESPACE
 
#if defined(VRAY_ALLOW_UNSAFE_NATIVE_HANDLE) || (!defined(_WIN32) && !defined(__APPLE__))
    typedef void* NativeWindowHandle;
    typedef void* NativeWidgetHandle;
#else
    #ifdef _WIN32
        #ifndef _WINDEF_
            typedef struct HWND__ *HWND;
        #endif
            typedef HWND NativeWindowHandle;
            typedef HWND NativeWidgetHandle;
    #elif __APPLE__
        #ifdef __OBJC__
            #define VRAY_FORWARD_DECLARE_OBJC_CLASS(classname) @class classname
        #else
            #define VRAY_FORWARD_DECLARE_OBJC_CLASS(classname) typedef struct objc_object classname
        #endif
        VRAY_FORWARD_DECLARE_OBJC_CLASS(NSWindow);
        typedef NSWindow *NativeWindowHandle;
        VRAY_FORWARD_DECLARE_OBJC_CLASS(NSView);
        typedef NSView *NativeWidgetHandle;
    #endif
#endif
 
namespace VRay {
 
namespace Internal {
    inline float linear_to_srgb(float x) {
        if (x <= 0.0031308f) {
            x *= 12.92f;
        } else {
            x = 1.055f*powf(x, 1.0f/2.4f)-0.055f;
        }
        return x;
    }
    inline float srgb_to_linear(float x) {
        if (x < 0.04045f) {
            x /= 12.92f;
        } else {
            x = powf((x+0.055f)/1.055f, 2.4f);
        }
        return x;
    }
 
    inline float interpolate(float x, float a, float b) noexcept {
        return (b - a) * x + a;
    }
}
 
#ifdef _MSC_VER
#   pragma warning(push)
#   pragma warning(disable: 4201) // nonstandard extension used : nameless struct/union
#endif // _MSC_VER
 
#ifdef _MSC_VER
#   define VRAY_DEPRECATED(msg) __declspec(deprecated(msg))
#else // unix
// GCC <= 4.4 doesn't support the optional message parameter
#   if defined(__clang__) || COMPILER_VERSION >= 450
#       define VRAY_DEPRECATED(msg) __attribute__((deprecated(msg)))
#   else
#       define VRAY_DEPRECATED(msg) __attribute__((deprecated))
#   endif
#endif // _MSC_VER
 
#ifdef VRAY_SDK_INTEROPERABILITY
    struct Vector;
    struct Color;
    namespace VUtils {
        class Value;
        class CharString;
        struct TraceTransform;
        template<class T> struct PtrArray;
        typedef PtrArray<int> IntRefList;
        typedef PtrArray<float> FloatRefList;
        typedef PtrArray<Vector> VectorRefList;
        typedef PtrArray<Color> ColorRefList;
        typedef PtrArray<TraceTransform> TransformRefList;
        typedef PtrArray<CharString> CharStringRefList;
        typedef PtrArray<Value> ValueRefList;
    }
#endif // VRAY_SDK_INTEROPERABILITY
 
    enum RendererState {
        FATAL_ERROR = -1, 
        IDLE_INITIALIZED, 
        IDLE_STOPPED,     
        IDLE_ERROR,       
        IDLE_FRAME_DONE,  
        IDLE_DONE,        
        PREPARING,        
        RENDERING,        
        RENDERING_PAUSED, 
        RENDERING_AWAITING_CHANGES, 
    };
 
    enum AddHostsResult {
        FAILED_TO_RESOLVE = -2, 
        RENDERER_ERROR = -1, 
        FAILED_TO_CONNECT = 0, 
        SUCCESSFULLY_ADDED = 1, 
        SUCCESS_BUT_NO_WORK = 2, 
    };
 
    enum Type {
 
        // Plugin Property Types
        TYPE_INT = 0,   
        TYPE_FLOAT = 1,   
        TYPE_DOUBLE = 2,   
        TYPE_BOOL = 3,   
        TYPE_VECTOR = 4,   
        TYPE_COLOR = 5,   
        TYPE_ACOLOR = 6,   
        TYPE_MATRIX = 7,   
        TYPE_TRANSFORM = 8,   
 
        TYPE_STRING = 9,   
        TYPE_PLUGIN = 10,   
        TYPE_TEXTURE = 11,   
        TYPE_LIST = 12,   
        TYPE_TEXTUREFLOAT = 13,   
        TYPE_TEXTUREINT = 14,   
        TYPE_TEXTUREVECTOR = 15,   
        TYPE_TEXTUREMATRIX = 16,   
        TYPE_TEXTURETRANSFORM = 17,   
 
        // List types
        TYPE_GENERAL_LIST = TYPE_LIST,
 
        // Typed Lists
        TYPE_TYPED_LIST_BASE = 100,
        TYPE_INT_LIST = TYPE_TYPED_LIST_BASE + TYPE_INT, 
        TYPE_FLOAT_LIST = TYPE_TYPED_LIST_BASE + TYPE_FLOAT, 
        TYPE_DOUBLE_LIST = TYPE_TYPED_LIST_BASE + TYPE_DOUBLE, 
        TYPE_BOOL_LIST = TYPE_TYPED_LIST_BASE + TYPE_BOOL, 
        TYPE_VECTOR_LIST = TYPE_TYPED_LIST_BASE + TYPE_VECTOR, 
        TYPE_COLOR_LIST = TYPE_TYPED_LIST_BASE + TYPE_COLOR, 
        TYPE_ACOLOR_LIST = TYPE_TYPED_LIST_BASE + TYPE_ACOLOR, 
        TYPE_MATRIX_LIST = TYPE_TYPED_LIST_BASE + TYPE_MATRIX, 
        TYPE_TRANSFORM_LIST = TYPE_TYPED_LIST_BASE + TYPE_TRANSFORM, 
        TYPE_STRING_LIST = TYPE_TYPED_LIST_BASE + TYPE_STRING, 
        TYPE_PLUGIN_LIST = TYPE_TYPED_LIST_BASE + TYPE_PLUGIN, 
        TYPE_TEXTURE_LIST = TYPE_TYPED_LIST_BASE + TYPE_TEXTURE, 
        TYPE_TEXTUREFLOAT_LIST = TYPE_TYPED_LIST_BASE + TYPE_TEXTUREFLOAT, 
        TYPE_TEXTUREINT_LIST = TYPE_TYPED_LIST_BASE + TYPE_TEXTUREINT, 
        TYPE_TEXTUREVECTOR_LIST = TYPE_TYPED_LIST_BASE + TYPE_TEXTUREVECTOR, 
        TYPE_TEXTUREMATRIX_LIST = TYPE_TYPED_LIST_BASE + TYPE_TEXTUREMATRIX, 
        TYPE_TEXTURETRANSFORM_LIST = TYPE_TYPED_LIST_BASE + TYPE_TEXTURETRANSFORM, 
 
        // Output (multi-texture) Property Types
        TYPE_OUTPUTTEXTURE = 1000, 
        TYPE_OUTPUTTEXTUREFLOAT = 1001, 
        TYPE_OUTPUTTEXTUREINT = 1002, 
        TYPE_OUTPUTTEXTUREVECTOR = 1003, 
        TYPE_OUTPUTTEXTUREMATRIX = 1004, 
        TYPE_OUTPUTTEXTURETRANSFORM = 1005, 
 
        TYPE_UNSPECIFIED = 10000,
 
        TYPE_ERROR = -1
    };
 
    enum MessageLevel {
        MessageError = 0,
        MessageWarning = 1,
        MessageInfo = 2,
        MessageDebug = 3
    };
 
    enum LicenseUserStatus : int {
        Disabled = 0, 
        QueryFailure = 1, 
        NoActiveUser = 2, 
        ActiveUserPresent = 3, 
    };
 
    enum ImagePassType {
        ImagePass_Final = 0,
        ImagePass_LightCache = 1,
        ImagePass_IrradianceMap = 2,
    };
 
    enum DefaultsPreset {
        quality_draft, 
        quality_low, 
        quality_medium, 
        quality_high, 
        quality_veryHigh, 
    };
 
    enum VFBRenderElementType {
        renderElementType_lightMix=0,
        renderElementType_denoiser,
 
        renderElementType_last
    };
 
    enum VFBMouseButton {
        mouseButton_left = 1,
        mouseButton_right = 2,
    };
 
    struct ImageRegion
    {
        int x0, y0, x1, y1;
 
        ImageRegion(int x = 0, int y = 0, int w = 0, int h = 0) {
            set(x, y, w, h);
        }
 
        void set(int x, int y, int w, int h) {
            x0 = x;
            y0 = y;
            x1 = x + w;
            y1 = y + h;
        }
 
        void setX(int x) {
            x0 = x;
        }
 
        void setY(int y) {
            y0 = y;
        }
 
        void setWidth(int width) {
            x1 = x0 + width;
        }
 
        void setHeight(int height) {
            y1 = y0 + height;
        }
 
        int getX() const {
            return x0;
        }
 
        int getY() const {
            return y0;
        }
 
        int getWidth() const {
            return x1 - x0;
        }
 
        int getHeight() const {
            return y1 - y0;
        }
    };
 
    typedef unsigned long long InstanceId; // FOR INTERNAL USE ONLY
    typedef unsigned long long PluginTypeId; // FOR INTERNAL USE ONLY
    constexpr InstanceId NO_ID = InstanceId(-1);
    constexpr PluginTypeId NO_TYPE_ID = PluginTypeId(-1);
 
    namespace Internal {
        static_assert(sizeof(InstanceId) == 8, "InstanceId should be 8 bytes long");
        static_assert(sizeof(PluginTypeId) == 8, "PluginTypeId should be 8 bytes long");
 
        constexpr int INSTANCE_ID_BITS = 48;
 
        // A helper function to combine InstanceId and PluginTypeId by truncating InstanceId to INSTANCE_ID_BITS (48) bits
        // and combine and set typeIdIdx in the remaining higher (sizeof(InstanceId) - INSTANCE_ID_BITS) (64-48 = 16) bits.
        inline InstanceId combineInstanceIdAndTypeIndex(InstanceId id, int typeIdIdx) {
            return (id & ((InstanceId(1) << INSTANCE_ID_BITS) - 1)) | (InstanceId(typeIdIdx) << INSTANCE_ID_BITS);
        }
    }
 
    typedef int LayerUID; // FOR INTERNAL USE ONLY
    const LayerUID NO_LAYER_ID = -1;
 
    namespace VFBLayerProperty {
        enum Type {
            IntEnum = -1, 
            Bool,
            Int,
            Float,
            Color,
            String,
            Rollout, 
            Double, 
            UInt32, 
            Curve, 
            Image, 
            CustomPopup, 
            MaskItemList, 
            StampFont, 
            StampString, 
            Stream 
        };
 
        enum Flags {
            NoFlags = 0,
            Internal = (1 << 0), 
            Hidden = (1 << 1), 
            EnumRadioButtons = (1 << 2), 
            EnumComboBox = (1 << 3), 
 
            Command = (1 << 4),
 
            HorizontalRolloutControls = (1 << 5),
 
            Transient = (1 << 6), 
            ReadOnly = (1 << 7), 
            CollapsibleVerticalRollout = (1 << 8), 
            ScrollableVerticalRollout = (1 << 9), 
            NoCustomStyleTag = (1 << 10), 
            NonResettable = (1 << 11), 
            NoUndo = (1 << 12), 
            Advanced = 1 << 13, 
 
            HasPipetteTool = 1 << 14, 
 
            Const = 1 << 15,
 
            WithoutLineEdit = 1 << 16,
 
            Stretched = 1 << 17
        };
 
        enum StampFontFamily {
            stampFontFamily_default, 
            stampFontFamily_decorated, 
            stampFontFamily_roman, 
            stampFontFamily_script, 
            stampFontFamily_sansSerif, 
            stampFontFamily_modern, 
            stampFontFamily_monospaced 
        };
 
        enum StampFontStyle {
            stampFontStyle_normal, 
            stampFontStyle_italic, 
        };
 
        enum StampFontWeight {
            stampFontWeight_normal, 
            stampFontWeight_light, 
            stampFontWeight_bold 
        };
 
        struct StampFontDesc {
            int pointSize; 
            StampFontFamily fontFamily; 
            StampFontStyle fontStyle; 
            StampFontWeight fontWeight; 
            char fontFace[100]; 
        };
 
        enum BlendMode {
            BlendMode_Overwrite = 0, 
            BlendMode_Average = 1, 
            BlendMode_Add = 2, 
            BlendMode_Subtract = 3, 
            BlendMode_Darken = 4, 
            BlendMode_Multiply = 5, 
            BlendMode_ColorBurn = 6, 
            BlendMode_LinearBurn = 7, 
            BlendMode_Lighten = 8, 
            BlendMode_Screen = 9, 
            BlendMode_ColorDodge = 10, 
            BlendMode_LinearDodge = 11, 
            BlendMode_Spotlight = 12, 
            BlendMode_SplotlightBlend = 13, 
            BlendMode_Overlay = 14, 
            BlendMode_Softlight = 15, 
            BlendMode_Hardlight = 16, 
            BlendMode_Pinlight = 17, 
            BlendMode_Hardmix = 18, 
            BlendMode_Difference = 19, 
            BlendMode_Exclusion = 20, 
            BlendMode_Hue = 21, 
            BlendMode_Saturation = 22, 
            BlendMode_Color = 23, 
            BlendMode_Value = 24, 
            BlendMode_Divide = 25, 
            BlendMode_Normal = 26, 
            BlendMode_Background = 27, 
            BlendMode_Foreground = 28, 
 
            BlendMode_FgWhiteMask = 29,
 
            BlendMode_Last 
        };
    };
 
    typedef unsigned char byte;
    typedef signed char sbyte;
    typedef int RGB32;
    typedef int Bool;
 
    class VRayRenderer;
    class Value;
    struct Color;
    struct AColor;
    struct Vector;
    struct Transform;
    class Plugin;
 
    typedef std::vector<int>         IntList;
    typedef std::vector<float>       FloatList;
    typedef std::vector<Color>       ColorList;
    typedef std::vector<Vector>      VectorList;
    typedef std::vector<Transform>   TransformList;
    typedef std::vector<Value>       ValueList;
    typedef std::vector<std::string> StringList;
    typedef std::vector<Plugin>      PluginList;
 
    class MemoryBuffer {
 
    protected:
        MemoryBuffer() {}
        MemoryBuffer(const MemoryBuffer&);
 
    public:
        const void* getData() const {
            return static_cast<const void*>(this);
        }
        void* getData() {
            return static_cast<void*>(this);
        }
        void operator delete(void* ptr);
    };
 
    class Png : public MemoryBuffer {};
    class Jpeg : public MemoryBuffer {};
    class VFBState : public MemoryBuffer {};
 
    #pragma pack(push, 1)
 
    struct BitmapFileHeader {
        unsigned short bfType;
        unsigned bfSize;
        unsigned bfReserved;
        unsigned bfOffBits; 
    };
 
    struct BitmapInfoHeader {
        unsigned biSize;
        int      biWidth;
        int      biHeight;
        unsigned short biPlanes;
        unsigned short biBitCount;
        unsigned biCompression;
        unsigned biSizeImage;
        int      biXPelsPerMeter;
        int      biYPelsPerMeter;
        unsigned biClrUsed;
        unsigned biClrImportant;
    };
 
    struct BmpHeader: BitmapFileHeader, BitmapInfoHeader {
        void* getPixels() const {
            return (byte*)this + bfOffBits;
        }
 
        unsigned getRowStride() const {
            return (getWidth()*(biBitCount/8) + 3) & ~3;
        }
 
        int getWidth() const {
            return abs(biWidth);
        }
 
        int getHeight() const {
            return abs(biHeight);
        }
 
        int getBitsPerPixel() const {
            return biBitCount;
        }
    };
 
    class Bmp : public BmpHeader, public MemoryBuffer {};
 
#pragma pack(pop)
 
    struct VRayImage {
        static VRayImage* create(int width, int height);
        void operator delete (void *bmp);
        VRayImage* clone() const;
 
        int getWidth() const;
        int getHeight() const;
        bool getSize(int& width, int& height) const;
 
        VRayImage* getCropped(int x, int y, int width, int height) const;
 
        VRayImage* getResized(int width, int height) const;
 
        VRayImage* getResizedCropped(int srcX, int srcY, int srcWidth, int srcHeight, int dstWidth, int dstHeight) const;
 
        VRayImage* getDownscaled(int width, int height) const;
 
        VRayImage* getDownscaledCropped(int srcX, int srcY, int srcWidth, int srcHeight, int dstWidth, int dstHeight) const;
 
        VRayImage* getFitIn(int width, int height) const;
 
        VRayImage* getFitOut(int width, int height) const;
 
        VRayImage* getCutIn(int width, int height) const;
 
        static VRayImage* createFromBmp(const void* buffer, size_t size = 0);
        static VRayImage* createFromBmp(const VRayRenderer& renderer, const void* buffer, size_t size = 0);
 
        static VRayImage* createFromPng(const void* buffer, size_t size);
        static VRayImage* createFromPng(const VRayRenderer& renderer, const void* buffer, size_t size);
 
        static VRayImage* createFromJpeg(const void* buffer, size_t size);
        static VRayImage* createFromJpeg(const VRayRenderer& renderer, const void* buffer, size_t size);
 
        enum IntList_DataType {
            bgra_byte = 0,  
            rgba_float = 1, 
            rgba_16bit = 3, 
            bgr_byte = 4,   
        };
 
        static VRayImage* createFromRawData(const void* buffer, size_t size, IntList_DataType dataType, int width, int height);
 
        static VRayImage* load(const char* fileName);
        static VRayImage* load(const std::string& fileName);
 
        static void loadSize(const char* fileName, int& width, int& height);
        static void loadSize(const std::string& fileName, int& width, int& height);
 
        bool setGamma(float gamma);
 
        float getGamma() const;
 
        bool changeSRGB(bool apply = true);
 
        bool changeGamma(float gamma);
 
        enum WhiteBalanceMode {
            WHITE_BALANCE_NONE,
            WHITE_BALANCE_AVERAGE,
            WHITE_BALANCE_WEIGHTED_AVERAGE,
            WHITE_BALANCE_HIGHLIGHTS
        };
 
        AColor calculateWhiteBalanceMultiplier(WhiteBalanceMode mode) const;
 
        float calculateDifference(const VRayImage* image) const;
 
        enum DrawMode {
            DRAW_MODE_COPY = 0,     
            DRAW_MODE_BLEND_FAST    
        };
 
        bool draw(const VRayImage* image, int x, int y, DrawMode mode = DRAW_MODE_COPY);
 
        bool addColor(const Color& color);
        bool addColor(const AColor& color);
        bool mulColor(const AColor& color);
        bool changeExposure(float ev);
        bool changeContrast(float contrast);
        bool makeNegative();
 
        bool saveToBmp(const char* fileName, bool preserveAlpha = false, bool swapChannels = false) const;
        bool saveToBmp(const char* fileName, const VRayRenderer& renderer, bool preserveAlpha = false, bool swapChannels = false) const;
        bool saveToBmp(const std::string& fileName, bool preserveAlpha = false, bool swapChannels = false) const;
        bool saveToBmp(const std::string& fileName, const VRayRenderer& renderer, bool preserveAlpha = false, bool swapChannels = false) const;
 
        bool saveToPng(const char* fileName, bool preserveAlpha = false, int bitsPerChannel = 8) const;
        bool saveToPng(const char* fileName, const VRayRenderer& renderer, bool preserveAlpha = false, int bitsPerChannel = 8) const;
        bool saveToPng(const std::string& fileName, bool preserveAlpha = false, int bitsPerChannel = 8) const;
        bool saveToPng(const std::string& fileName, const VRayRenderer& renderer, bool preserveAlpha = false, int bitsPerChannel = 8) const;
 
        bool saveToJpeg(const char* fileName, int quality = 0) const;
        bool saveToJpeg(const char* fileName, const VRayRenderer& renderer, int quality = 0) const;
        bool saveToJpeg(const std::string& fileName, int quality = 0) const;
        bool saveToJpeg(const std::string& fileName, const VRayRenderer& renderer, int quality = 0) const;
 
        bool saveToTiff(const char* fileName, int bitsPerChannel = 16) const;
        bool saveToTiff(const char* fileName, const VRayRenderer& renderer, int bitsPerChannel = 16) const;
        bool saveToTiff(const std::string& fileName, int bitsPerChannel = 16) const;
        bool saveToTiff(const std::string& fileName, const VRayRenderer& renderer, int bitsPerChannel = 16) const;
 
        bool saveToExr(const char* fileName) const;
        bool saveToExr(const char* fileName, const VRayRenderer& renderer) const;
        bool saveToExr(const std::string& fileName) const;
        bool saveToExr(const std::string& fileName, const VRayRenderer& renderer) const;
 
        Bmp* compressToBmp(bool preserveAlpha = false, bool swapChannels = false) const;
        Bmp* compressToBmp(size_t& size, bool preserveAlpha = false, bool swapChannels = false) const;
        Bmp* compressToBmp(const VRayRenderer& renderer, bool preserveAlpha = false, bool swapChannels = false) const;
        Bmp* compressToBmp(size_t& size, const VRayRenderer& renderer, bool preserveAlpha = false, bool swapChannels = false) const;
 
        Png* compressToPng(bool preserveAlpha = false) const;
        Png* compressToPng(size_t& size, bool preserveAlpha = false) const;
        Png* compressToPng(const VRayRenderer& renderer, bool preserveAlpha = false) const;
        Png* compressToPng(size_t& size, const VRayRenderer& renderer, bool preserveAlpha = false) const;
 
        Jpeg* compressToJpeg(int quality = 0) const;
        Jpeg* compressToJpeg(size_t& size, int quality = 0) const;
        Jpeg* compressToJpeg(const VRayRenderer& renderer, int quality = 0) const;
        Jpeg* compressToJpeg(size_t& size, const VRayRenderer& renderer, int quality = 0) const;
 
        MemoryBuffer* toBitmapData(size_t& size, bool preserveAlpha = false, bool swapChannels = false, bool reverseY = false, int stride = 0, int alphaValue = -1) const;
 
        IntList toIntList(IntList_DataType type) const;
 
        AColor* getPixelData();
        AColor* getPixelData(size_t& count);
        const AColor* getPixelData() const;
        const AColor* getPixelData(size_t& count) const;
 
    private:
        VRayImage();
        VRayImage(const VRayImage&);
        VRayImage& operator=(const VRayImage &image);
    };
 
    class LocalVRayImage {
        VRayImage* img;
        LocalVRayImage(const LocalVRayImage& img);
        LocalVRayImage& operator=(const LocalVRayImage& img);
 
    public:
        LocalVRayImage(VRayImage* img) : img(img) {}
 
        operator VRayImage* () {
            return img;
        }
 
        VRayImage* operator->() {
            return img;
        }
 
        VRayImage& operator*() {
            return *img;
        }
 
        LocalVRayImage& operator=(VRayImage* image) {
            delete img;
            img = image;
            return *this;
        }
 
        ~LocalVRayImage() {
            delete img;
        }
    };
 
    struct ImageWriterOptions {
        union ImageWriterFlags {
            int asInt;
 
            struct {
                bool multipleFiles : 1; 
                bool skipAlpha : 1;  
                bool frameNumber : 1;  
                bool noAlpha : 1; 
                bool singleChannel : 1;  
                bool skipRGB : 1; 
                bool writeIntegerIDs : 1; 
                bool velocityZeroBased : 1; 
                bool multiChannel : 1;  
                bool applyColorCorrections : 1; 
                bool writeExifData : 1; 
            };
 
            ImageWriterFlags() : asInt() {}
        } flags;
 
        enum CompressionType {
            DEFAULT,
            NO_COMPRESSION,
            RUN_LENGTH,
            ZIP_SCANLINE,
            ZIP_BLOCK,
            PIZ,
            PXR24,
            B44,
            B44A,
            DWAA,
            DWAB
        } compressionType; 
 
        int bitsPerChannel; 
 
        ImageWriterOptions() : flags(), compressionType(), bitsPerChannel(32) {}
    };
 
    struct Vector {
        union {
            struct { float x, y, z; };
            float f[3];
        };
 
        Vector(const Vector&) noexcept = default;
        Vector(Vector&&) noexcept = default;
        Vector& operator=(const Vector&) noexcept = default;
        Vector& operator=(Vector&&) noexcept = default;
 
        Vector() noexcept : x(), y(), z() {}
 
        template <typename T1, typename T2, typename T3>
        Vector(T1 x, T2 y, T3 z) noexcept : x(float(x)), y(float(y)), z(float(z)) {}
 
        template <typename T>
        explicit Vector(T value) noexcept : x(float(value)), y(float(value)), z(float(value)) {}
 
        std::string toString() const;
 
        template <typename T1, typename T2, typename T3>
        Vector& set(T1 x_, T2 y_, T3 z_) noexcept {
            x = float(x_), y = float(y_), z = float(z_);
            return *this;
        }
 
        Vector& makeZero(void) noexcept {
            z = y = x = 0;
            return *this;
        }
 
        Vector& operator +=(const Vector &other) noexcept {
            x += other.x, y += other.y, z += other.z;
            return *this;
        }
 
        Vector& operator -=(const Vector &other) noexcept {
            x -= other.x, y -= other.y, z -= other.z;
            return *this;
        }
 
        Vector& operator *=(int factor) noexcept {
            x *= float(factor), y *= float(factor), z *= float(factor);
            return *this;
        }
 
        Vector& operator *=(float factor) noexcept {
            x *= factor, y *= factor, z *= factor;
            return *this;
        }
 
        Vector& operator *=(double factor) noexcept {
            x *= float(factor), y *= float(factor), z*=float(factor);
            return *this;
        }
 
        Vector& operator /=(int divisor) noexcept {
            x/=float(divisor); y/=float(divisor); z/=float(divisor);
            return *this;
        }
 
        Vector& operator /=(float divisor) noexcept {
            x/=divisor; y/=divisor; z/=divisor;
            return *this;
        }
 
        Vector& operator /=(double divisor) noexcept {
            x/=float(divisor); y/=float(divisor); z/=float(divisor);
            return *this;
        }
 
        Vector operator -(void) const noexcept {
            return Vector(-x, -y, -z);
        }
 
        float& operator [](const int index) noexcept {
            return f[index];
        }
 
        const float& operator [](const int index) const noexcept {
            return f[index];
        }
 
        float length(void) const noexcept {
            return sqrtf(x*x + y*y + z*z);
        }
 
        float lengthSqr(void) const noexcept {
            return x*x + y*y + z*z;
        }
 
        void rotate(const Vector &axis) noexcept;
    };
 
    inline Vector operator *(const Vector &a, int factor) noexcept {
        Vector res(a);
        res *= factor;
        return res;
    }
 
    inline Vector operator *(const Vector &a, float factor) noexcept {
        Vector res(a);
        res *= factor;
        return res;
    }
 
    inline Vector operator *(const Vector &a, double factor) noexcept {
        Vector res(a);
        res *= factor;
        return res;
    }
 
    inline Vector operator *(int factor, const Vector &a) {
        Vector res(a);
        res *= factor;
        return res;
    }
 
    inline Vector operator *(float factor, const Vector &a) noexcept {
        Vector res(a);
        res *= factor;
        return res;
    }
 
    inline Vector operator *(double factor, const Vector &a) noexcept {
        Vector res(a);
        res *= factor;
        return res;
    }
 
    inline Vector operator /(const Vector &a, int factor) noexcept {
        Vector res(a);
        res /= factor;
        return res;
    }
 
    inline Vector operator /(const Vector &a, float factor) noexcept {
        Vector res(a);
        res /= factor;
        return res;
    }
 
    inline Vector operator /(const Vector &a, double factor) noexcept {
        Vector res(a);
        res /= factor;
        return res;
    }
 
    inline double operator *(const Vector &a, const Vector &b) noexcept {
        return double(a.x)*double(b.x) + double(a.y)*double(b.y) + double(a.z)*double(b.z);
    }
 
    inline Vector operator +(const Vector &a, const Vector &b) noexcept {
        Vector res(a);
        res += b;
        return res;
    }
 
    inline Vector operator -(const Vector &a, const Vector &b) noexcept {
        Vector res(a);
        res -= b;
        return res;
    }
 
    inline Vector operator /(const Vector &a, const Vector &b) noexcept {
        return Vector(a.x/b.x, a.y/b.y, a.z/b.z);
    }
 
    inline Vector mul(const Vector &a, const Vector &b) noexcept {
        return Vector(a.x*b.x, a.y*b.y, a.z*b.z);
    }
 
    inline bool operator !=(const Vector &a, const Vector &b) noexcept {
        return a.x != b.x || a.y != b.y || a.z != b.z;
    }
 
    inline bool operator ==(const Vector &a, const Vector &b) noexcept {
        return a.x == b.x && a.y == b.y && a.z == b.z;
    }
 
    inline Vector operator ^(const Vector &a, const Vector &b) noexcept {
        return Vector(
            double(a.y)*double(b.z) - double(b.y)*double(a.z),
            double(a.z)*double(b.x) - double(b.z)*double(a.x),
            double(a.x)*double(b.y) - double(b.x)*double(a.y)
        );
    }
 
    inline double mixed(const Vector &a, const Vector &b, const Vector &c) noexcept {
        return
            (double(a.y)*double(b.z) - double(b.y)*double(a.z))*double(c.x)+
            (double(a.z)*double(b.x) - double(b.z)*double(a.x))*double(c.y)+
            (double(a.x)*double(b.y) - double(b.x)*double(a.y))*double(c.z);
    }
 
    inline Vector normalize(const Vector &a) noexcept {
        return a/a.length();
    }
 
    inline float length(const Vector &a) noexcept {
        return a.length();
    }
 
    inline float lengthSqr(const Vector &a) noexcept {
        return a.lengthSqr();
    }
 
    inline void Vector::rotate(const Vector &axis) noexcept {
        float oldLen = length();
 
        Vector d = axis ^ (*this);
        d += (*this);
 
        float newLen = d.length();
        if (newLen > 1e-6f)
            (*this) = d*oldLen/newLen;
    }
 
    inline Vector rotate(const Vector &v, const Vector &axis) noexcept {
        Vector r(v);
        r.rotate(axis);
        return r;
    }
 
    inline std::ostream& operator <<(std::ostream& stream, const Vector& vector) {
        stream << "Vector(" << vector.x << ", " <<  vector.y << ", " <<  vector.z << ")";
        return stream;
    }
 
    inline std::string Vector::toString() const {
        std::ostringstream stream;
        stream << *this;
        return stream.str();
    }
 
    struct Matrix;
    struct Color {
        union {
            struct { float r, g, b; };
            float rgb[3];
        };
 
        Color(const Color&) noexcept = default;
        Color(Color&&) noexcept = default;
        Color& operator=(const Color&) noexcept = default;
        Color& operator=(Color&&) noexcept = default;
 
        Color() noexcept : r(), g(), b() {}
 
        template <typename T1, typename T2, typename T3>
        Color(T1 r, T2 g, T3 b) noexcept :  r(float(r)), g(float(g)), b(float(b)) {}
 
        template <typename T>
        explicit Color(const T& value) noexcept : r(float(value)), g(float(value)), b(float(value)) {}
 
        enum RGBColorSpace {
            CIE, sRGB, ACEScg
        };
 
        static Color fromTemperature(float temperature, RGBColorSpace colorSpace = sRGB);
 
        float getClosestTemperature(RGBColorSpace colorSpace = sRGB) const;
 
        float getClosestTemperatureAndColor(Color& closestColor, RGBColorSpace colorSpace = sRGB) const;
 
        static Matrix getRGBtoRGBmatrix(RGBColorSpace srcColorSpace, RGBColorSpace dstColorSpace);
 
        float getIntensity() const noexcept {
            return (r + g + b) * (1.0f / 3.0f);
        }
 
        float getLuminance() const noexcept {
            const float RED_LUMINANCE_COMPONENT = 0.3f;
            const float GREEN_LUMINANCE_COMPONENT = 0.59f;
            const float BLUE_LUMINANCE_COMPONENT = 0.11f;
            return RED_LUMINANCE_COMPONENT * r + GREEN_LUMINANCE_COMPONENT * g + BLUE_LUMINANCE_COMPONENT * b;
        }
 
        float getLengthSquared() const noexcept {
            return r * r + g * g + b * b;
        }
 
        float getLength() const noexcept {
            return sqrtf(r * r + g * g + b * b);
        }
 
        float getPower() const {
            return r + g + b;
        }
 
        void setSaturation(float k) noexcept {
            if (k == 1.0f) return;
            float grey = (r + g + b) / 3.0f;
            r = Internal::interpolate(k, grey, r);
            g = Internal::interpolate(k, grey, g);
            b = Internal::interpolate(k, grey, b);
        }
 
        void setContrast(float k, float middle = 0.5f) noexcept {
            if (k == 1.0f) return;
            r = (r - middle) * k + middle;
            g = (g - middle) * k + middle;
            b = (b - middle) * k + middle;
        }
 
        Color getWhiteComplement() const noexcept {
            return Color(std::fmaxf(0.0f, 1.0f - r), std::fmaxf(0.0f, 1.0f - g), std::fmaxf(0.0f, 1.0f - b));
        }
 
        void makeWhiteComplement() noexcept {
            r = std::fmaxf(0.0f, 1.0f - r);
            g = std::fmaxf(0.0f, 1.0f - g);
            b = std::fmaxf(0.0f, 1.0f - b);
        }
 
        std::string toString() const;
 
        void operator +=(const Color &c) noexcept {
            r += c.r;
            g += c.g;
            b += c.b;
        }
 
        void operator -=(const Color &c) noexcept {
            r -= c.r;
            g -= c.g;
            b -= c.b;
        }
 
        void operator *=(const Color &c) noexcept {
            r *= c.r;
            g *= c.g;
            b *= c.b;
        }
 
        void operator *=(int factor) noexcept {
            float f = static_cast<float>(factor);
            r *= f;
            g *= f;
            b *= f;
        }
 
        void operator *=(float factor) noexcept {
            r *= factor;
            g *= factor;
            b *= factor;
        }
 
        void operator *=(double factor) noexcept {
            float f = static_cast<float>(factor);
            r *= f;
            g *= f;
            b *= f;
        }
 
        void operator /=(const Color &c) noexcept {
            r /= c.r;
            g /= c.g;
            b /= c.b;
        }
 
        void operator /=(int factor) noexcept {
            float f = static_cast<float>(factor);
            r /= f;
            g /= f;
            b /= f;
        }
 
        void operator /=(float factor) noexcept {
            r /= factor;
            g /= factor;
            b /= factor;
        }
 
        void operator /=(double factor) noexcept {
            float f = static_cast<float>(factor);
            r /= f;
            g /= f;
            b /= f;
        }
 
        float maxComponentValue() const noexcept {
            const float rg = r > g ? r : g;
            return rg > b ? rg : b;
        }
 
        Color fromSRGB() {
            Color color2 = Color(r, g, b);
            color2.r = Internal::srgb_to_linear(color2.r);
            color2.g = Internal::srgb_to_linear(color2.g);
            color2.b = Internal::srgb_to_linear(color2.b);
            return color2;
        }
 
        Color toSRGB() {
            Color color2 = Color(r, g, b);
            color2.r = Internal::linear_to_srgb(color2.r);
            color2.g = Internal::linear_to_srgb(color2.g);
            color2.b = Internal::linear_to_srgb(color2.b);
            return color2;
        }
 
    };
 
    std::ostream& operator <<(std::ostream& stream, const Color& color);
 
    inline Color operator +(const Color& a, const Color& b) noexcept {
        return Color(
            a.r + b.r,
            a.g + b.g,
            a.b + b.b
        );
    }
 
    inline Color operator -(const Color& a, const Color& b) noexcept {
        return Color(
            a.r - b.r,
            a.g - b.g,
            a.b - b.b
        );
    }
 
    inline Color operator *(const Color& a, const Color& b) noexcept {
        return Color(
            a.r * b.r,
            a.g * b.g,
            a.b * b.b
        );
    }
 
    inline Color operator *(const Color& a, int factor) noexcept {
        float f = static_cast<float>(factor);
        return Color(a.r * f, a.g * f, a.b * f);
    }
 
    inline Color operator *(const Color& a, float factor) noexcept {
        return Color(a.r * factor, a.g * factor, a.b * factor);
    }
 
    inline Color operator *(const Color& a, double factor) noexcept {
        float f = static_cast<float>(factor);
        return Color(a.r * f, a.g * f, a.b * f);
    }
 
    inline Color operator *(int factor, const Color& a) noexcept {
        return a * float(factor);
    }
 
    inline Color operator *(float factor, const Color& a) noexcept {
        return a * factor;
    }
 
    inline Color operator *(double factor, const Color& a) noexcept {
        return a * float(factor);
    }
 
    inline Color operator /(const Color& a, const Color& b) noexcept {
        return Color(a.r / b.r, a.g / b.g, a.b / b.b);
    }
 
    inline Color operator /(const Color& a, int factor) noexcept {
        float f = static_cast<float>(factor);
        return Color(a.r / f, a.g / f, a.b / f);
    }
 
    inline Color operator /(const Color& a, float factor) noexcept {
        return Color(a.r / factor, a.g / factor, a.b / factor);
    }
 
    inline Color operator /(const Color& a, double factor) noexcept {
        float f = static_cast<float>(factor);
        return Color(a.r / f, a.g / f, a.b / f);
    }
 
    inline bool operator !=(const Color& a, const Color& b) noexcept {
        return a.r != b.r || a.g != b.g || a.b != b.b;
    }
 
    inline bool operator ==(const Color& a, const Color& b) noexcept {
        return a.r == b.r && a.g == b.g && a.b == b.b;
    }
 
    struct AColor {
        Color color;
        float  alpha;
 
        AColor(const AColor&) noexcept = default;
        AColor(AColor&&) noexcept = default;
        AColor& operator=(const AColor&) noexcept = default;
        AColor& operator=(AColor&&) noexcept = default;
 
        AColor() noexcept : color(), alpha() {}
 
        template <typename T>
        AColor(Color c, T a) noexcept : color(c), alpha(float(a)) {}
 
        template <typename T1, typename T2, typename T3>
        AColor(T1 r, T2 g, T3 b) noexcept :  color(r, g, b), alpha(1.0f) {}
 
        template <typename T1, typename T2, typename T3, typename T4>
        AColor(T1 r, T2 g, T3 b, T4 a) noexcept :  color(r, g, b), alpha(float(a)) {}
 
        template <typename T>
        explicit AColor(const T& value) noexcept : color(value), alpha(1) {}
 
        std::string toString() const ;
 
        void operator +=(const AColor& c) noexcept {
            color += c.color;
            alpha += c.alpha;
        }
 
        void operator -=(const AColor& c) noexcept {
            color -= c.color;
            alpha -= c.alpha;
        }
 
        void operator *=(const AColor& c) noexcept {
            color *= c.color;
            alpha *= c.alpha;
        }
 
        void operator *=(int factor) noexcept {
            color *= float(factor);
            alpha *= float(factor);
        }
 
        void operator *=(float factor) noexcept {
            color *= factor;
            alpha *= factor;
        }
 
        void operator *=(double factor) noexcept {
            color *= float(factor);
            alpha *= float(factor);
        }
 
        void operator /=(const AColor& c) noexcept {
            color /= c.color;
            alpha /= c.alpha;
        }
 
        void operator /=(int factor) noexcept {
            color /= float(factor);
            alpha /= float(factor);
        }
 
        void operator /=(float factor) noexcept {
            color /= factor;
            alpha /= factor;
        }
 
        void operator /=(double factor) noexcept {
            color /= float(factor);
            alpha /= float(factor);
        }
 
        float getLength() const noexcept {
            return sqrtf(color.getLengthSquared() + alpha * alpha);
        }
 
        float getLengthSquared() const noexcept {
            return color.getLengthSquared() + alpha * alpha;
        }
 
        AColor getWhiteComplement() const noexcept {
            return AColor(color.getWhiteComplement(), std::fmaxf(0.0f, 1.0f - alpha));
        }
 
        void makeWhiteComplement() noexcept {
            color.makeWhiteComplement();
            alpha = std::fmaxf(0.0f, 1.0f - alpha);
        }
 
        float maxComponentValue() const noexcept {
            return color.maxComponentValue();
        }
 
        AColor fromSRGB() const noexcept {
            return AColor(
                Internal::srgb_to_linear(color.r),
                Internal::srgb_to_linear(color.g),
                Internal::srgb_to_linear(color.b),
                alpha
            );
        }
 
        AColor toSRGB() const noexcept {
            return AColor(
                Internal::linear_to_srgb(color.r),
                Internal::linear_to_srgb(color.g),
                Internal::linear_to_srgb(color.b),
                alpha
            );
        }
 
    };
 
    inline std::ostream& operator <<(std::ostream& stream, const AColor& acolor) {
        stream << "AColor(" << acolor.color.r << ", " <<  acolor.color.g << ", " <<  acolor.color.b << ", " <<  acolor.alpha << ")";
        return stream;
    }
 
    inline std::string AColor::toString() const {
        std::ostringstream stream;
        stream << *this;
        return stream.str();
    }
 
    inline AColor operator +(const AColor& a, const AColor& b) noexcept {
        return AColor(
            a.color + b.color,
            a.alpha + b.alpha
        );
    }
 
    inline AColor operator -(const AColor& a, const AColor& b) noexcept {
        return AColor(
            a.color - b.color,
            a.alpha - b.alpha
        );
    }
 
    inline AColor operator *(const AColor& a, const AColor& b) noexcept {
        return AColor(
            a.color * b.color,
            a.alpha * b.alpha
        );
    }
 
    inline AColor operator *(const AColor& a, int factor) noexcept {
        return AColor(
            a.color * float(factor),
            a.alpha * float(factor)
        );
    }
 
    inline AColor operator *(const AColor& a, float factor) noexcept {
        return AColor(
            a.color * factor,
            a.alpha * factor
        );
    }
 
    inline AColor operator *(const AColor& a, double factor) noexcept {
        return AColor(
            a.color * float(factor),
            a.alpha * float(factor)
        );
    }
 
    inline AColor operator *(int factor, const AColor& a) noexcept {
        return a * float(factor);
    }
 
    inline AColor operator *(float factor, const AColor& a) noexcept {
        return a * factor;
    }
 
    inline AColor operator *(double factor, const AColor& a) noexcept {
        return a * float(factor);
    }
 
    inline AColor operator /(const AColor& a, const AColor& b) noexcept {
        return AColor(
            a.color / b.color,
            a.alpha / b.alpha
        );
    }
 
    inline AColor operator /(const AColor& a, int factor) noexcept {
        return AColor(
            a.color / float(factor),
            a.alpha / float(factor)
        );
    }
 
    inline AColor operator /(const AColor& a, float factor) noexcept {
        return AColor(
            a.color / factor,
            a.alpha / factor
        );
    }
 
    inline AColor operator /(const AColor& a, double factor) noexcept {
        return AColor(
            a.color / float(factor),
            a.alpha / float(factor)
        );
    }
 
    inline bool operator !=(const AColor& a, const AColor& b) noexcept {
        return a.color != b.color || a.alpha != b.alpha;
    }
 
    inline bool operator ==(const AColor& a, const AColor& b) noexcept {
        return a.color == b.color && a.alpha == b.alpha;
    }
 
    struct Matrix {
        Vector v0, v1, v2;
 
        std::string toString() const;
 
        Vector& operator [](const int index) noexcept {
            return (&v0)[index];
        }
 
        const Vector& operator [](const int index) const noexcept {
            return (&v0)[index];
        }
 
        Matrix() noexcept = default;
 
        Matrix(const Matrix&) noexcept = default;
        Matrix(Matrix&&) noexcept = default;
        Matrix& operator=(const Matrix&) noexcept = default;
        Matrix& operator=(Matrix&&) noexcept = default;
 
        explicit Matrix(float value) noexcept : v0(value, 0, 0), v1(0 ,value, 0), v2(0, 0, value) {}
 
        explicit Matrix(Vector diagonal) noexcept : v0(diagonal.x, 0, 0), v1(0, diagonal.y, 0), v2(0, 0, diagonal.z) {}
 
        Matrix(const Vector &a, const Vector &b, const Vector &c) noexcept : v0(a), v1(b), v2(c) {}
 
        //Matrix(const Matrix& other) noexcept : v0(other.v0), v1(other.v1), v2(other.v2) {}
 
        void set(const Vector &a, const Vector &b, const Vector &c) noexcept {
            v0 = a, v1 = b, v2 = c;
        }
 
        void set(float value) noexcept {
            v0.set(value, 0, 0);
            v1.set(0, value, 0);
            v2.set(0, 0, value);
        }
 
        void set(const Matrix& other) noexcept {
            v0 = other.v0;
            v1 = other.v1;
            v2 = other.v2;
        }
 
        void setCol(const int i, const Vector &a) noexcept {
            (*this)[i] = a;
        }
 
        void setRow(const int i, const Vector &a) noexcept {
            (*this)[0][i] = a.x, (*this)[1][i] = a.y, (*this)[2][i]=a.z;
        }
 
        void makeZero(void) noexcept {
            v0.makeZero();
            v1.makeZero();
            v2.makeZero();
        }
 
        void makeIdentity(void) noexcept {
            v0.set(1.0f, 0.0f, 0.0f);
            v1.set(0.0f, 1.0f, 0.0f);
            v2.set(0.0f, 0.0f, 1.0f);
        }
 
        void makeDiagonal(const Vector &a) noexcept {
            v0.set(a.x, 0.0f, 0.0f);
            v1.set(0.0f, a.y, 0.0f);
            v2.set(0.0f, 0.0f, a.z);
        }
 
        void makeOuterProduct(const Vector &a, const Vector &b) noexcept {
            v0 = a.x*b;
            v1 = a.y*b;
            v2 = a.z*b;
        }
 
        void makeTranspose(void) noexcept {
            float t;
            t = v0[1], v0[1] = v1[0], v1[0] = t;
            t = v0[2], v0[2] = v2[0], v2[0] = t;
            t = v1[2], v1[2] = v2[1], v2[1] = t;
        }
 
        bool makeInverse(void) noexcept {
            Matrix r;
            double d = mixed(v0, v1, v2);
            bool ret = true;
            if (d) {
                r.setRow(0, (v1^v2)/d);
                r.setRow(1, (v2^v0)/d);
                r.setRow(2, (v0^v1)/d);
            } else {
                r.makeZero();
                ret = false;
            }
            *this = r;
            return ret;
        }
 
        void addDiagonal(const Vector &a) noexcept {
            v0[0] += a[0];
            v1[1] += a[1];
            v2[2] += a[2];
        }
 
        void addTranspose(const Matrix &b) noexcept {
            v0[0] += b.v0[0];
            v0[1] += b.v1[0];
            v0[2] += b.v2[0];
 
            v1[0] += b.v0[1];
            v1[1] += b.v1[1];
            v1[2] += b.v2[1];
 
            v2[0] += b.v0[2];
            v2[1] += b.v1[2];
            v2[2] += b.v2[2];
        }
 
        void operator *=(float x) noexcept {
            v0 *= x, v1 *= x, v2 *= x;
        }
 
        void operator /=(float x) noexcept {
            v0 /= x, v1 /= x, v2 /= x;
        }
 
        void operator +=(const Matrix &m) noexcept {
            v0 += m.v0;
            v1 += m.v1;
            v2 += m.v2;
        }
 
        void operator -=(const Matrix &m) noexcept {
            v0-=m.v0;
            v1-=m.v1;
            v2-=m.v2;
        }
 
        void rotate(const Vector &axis) noexcept {
            v0.rotate(axis);
            v1.rotate(axis);
            v2.rotate(axis);
        }
 
        void makeOrthogonal(void) noexcept {
            Matrix t;
            t.v0 = normalize(v0);
            t.v1 = normalize(v2 ^ v0);
            t.v2 = t.v0 ^ t.v1;
            v0 = length(v0) * t.v0;
            v1 = length(v1) * t.v1;
            v2 = length(v2) * t.v2;
        }
 
        void makeOrthonormal(void) noexcept {
            v0 = normalize(v0);
            v1 = normalize(v2 ^ v0);
            v2 = normalize(v0 ^ v1);
        }
    };
 
    inline Matrix inverse(const Matrix &m) noexcept {
        Matrix r;
        double d = m.v0*(m.v1^m.v2);
        r.setRow(0, (m.v1^m.v2)/d);
        r.setRow(1, (m.v2^m.v0)/d);
        r.setRow(2, (m.v0^m.v1)/d);
        return r;
    }
 
    inline Vector operator *(const Vector &a, const Matrix &m) noexcept {
        return Vector(a*m.v0, a*m.v1, a*m.v2);
    }
 
    inline Vector operator *(const Matrix &m, const Vector &a) noexcept {
        return a.x*m.v0 + a.y*m.v1 + a.z*m.v2;
    }
 
    inline Matrix operator ^(const Matrix &m, const Vector &a) noexcept {
        return Matrix(m.v0^a, m.v1^a, m.v2^a);
    }
 
    inline Matrix operator ^(const Vector &a, const Matrix &m) noexcept {
        return Matrix(a^m.v0, a^m.v1, a^m.v2);
    }
 
    inline Matrix operator *(const Matrix &m, float x) noexcept {
        return Matrix(m.v0*x, m.v1*x, m.v2*x);
    }
 
    inline Matrix operator *(float x, const Matrix &m) noexcept {
        return Matrix(x*m.v0, x*m.v1, x*m.v2);
    }
 
    inline Matrix operator /(const Matrix &m, float x) noexcept {
        return Matrix(m.v0/x, m.v1/x, m.v2/x);
    }
 
    inline float operator /(float x, const Matrix &m) noexcept {
        return x / float(m.v0*(m.v1^m.v2));
    }
 
    inline Matrix operator +(const Matrix &a, const Matrix &b) noexcept {
        return Matrix(a.v0 + b.v0, a.v1 + b.v1, a.v2 + b.v2);
    }
 
    inline Matrix operator -(const Matrix &a, const Matrix &b) noexcept {
        return Matrix(a.v0 - b.v0, a.v1 - b.v1, a.v2 - b.v2);
    }
 
    inline Matrix operator *(const Matrix &a, const Matrix &b) noexcept {
        Matrix r(
            Vector(
                a.v0[0]*b.v0[0]+a.v1[0]*b.v0[1]+a.v2[0]*b.v0[2],
                a.v0[1]*b.v0[0]+a.v1[1]*b.v0[1]+a.v2[1]*b.v0[2],
                a.v0[2]*b.v0[0]+a.v1[2]*b.v0[1]+a.v2[2]*b.v0[2]),
            Vector(
                a.v0[0]*b.v1[0]+a.v1[0]*b.v1[1]+a.v2[0]*b.v1[2],
                a.v0[1]*b.v1[0]+a.v1[1]*b.v1[1]+a.v2[1]*b.v1[2],
                a.v0[2]*b.v1[0]+a.v1[2]*b.v1[1]+a.v2[2]*b.v1[2]),
            Vector(
                a.v0[0]*b.v2[0]+a.v1[0]*b.v2[1]+a.v2[0]*b.v2[2],
                a.v0[1]*b.v2[0]+a.v1[1]*b.v2[1]+a.v2[1]*b.v2[2],
                a.v0[2]*b.v2[0]+a.v1[2]*b.v2[1]+a.v2[2]*b.v2[2])
        );
        return r;
    }
 
    inline bool operator !=(const Matrix &a, const Matrix &b) noexcept {
        return a.v0 != b.v0 || a.v1 != b.v1 || a.v2 != b.v2;
    }
 
    inline bool operator ==(const Matrix &a, const Matrix &b) noexcept {
        return a.v0 == b.v0 && a.v1 == b.v1 && a.v2 == b.v2;
    }
 
    inline Matrix operator -(const Matrix &a) noexcept {
        return Matrix(-a.v0, -a.v1, -a.v2);
    }
 
    inline Matrix outerProductMatrix(const Vector &a, const Vector &b) noexcept {
        return Matrix(a.x*b, a.y*b, a.z*b);
    }
 
    inline Matrix transpose(const Matrix &m) noexcept {
        return Matrix(
            Vector(m.v0[0], m.v1[0], m.v2[0]),
            Vector(m.v0[1], m.v1[1], m.v2[1]),
            Vector(m.v0[2], m.v1[2], m.v2[2]));
    }
 
    inline Matrix rotate(const Matrix &m, const Vector &axis) noexcept {
        return Matrix(rotate(m.v0, axis), rotate(m.v1, axis), rotate(m.v2, axis));
    }
 
    inline Matrix normalize(const Matrix &m) noexcept {
        Vector v0 = normalize(m.v0);
        Vector v1 = normalize(m.v2^m.v0);
        return Matrix(v0, v1, v0^v1);
    }
 
    inline Matrix noScale(const Matrix &m) noexcept {
        return Matrix(normalize(m.v0), normalize(m.v1), normalize(m.v2));
    }
 
    inline Vector scale(const Matrix &m) noexcept {
        return Vector(m[0].length(), m[1].length(), m[2].length());
    }
 
    inline Vector rotationAngles(const Matrix& m) noexcept {
        const Matrix mns = noScale(m);
 
        /*the 3x3 matrix, starting from identity and given random rotational angles, x,y and z looks like this:
        |  cy*cz              -cy*sz               sy     |
        |  sx*sy*cz + cx*cz   -sx*sy*sz + cx*cz   -sx*cy  |
        | -cx*sy*cz + sx*sz    cx*sy*sz + sx*cz    cx*cy  |
 
        where the alignment are in V-Ray terms. The Euler angles, with a bit of simplification:
        x = atan(-(-sx*cy)/cx*cy) = atan(-a21/a22)
        y = asin(sy) = asin(a20)
        z = atan(-(-cy*sz)/cy*cz) = atan(-a10/a00)
        */
 
        //atan2 will only raise an error if both arguments are 0, which should never happen
        //equivalent to a scale of zero
        return Vector(
            atan2(-mns[2][1], mns[2][2]),
            asin(mns[2][0]),
            atan2(-mns[1][0], mns[0][0])
        );
    }
 
    inline Matrix makeRotationMatrixX(float xrot) noexcept {
        const float s = sinf(xrot);
        const float c = cosf(xrot);
        return Matrix(Vector(1.0f, 0.0f, 0.0f), Vector(0, c, s), Vector(0, -s, c));
    }
 
    inline Matrix makeRotationMatrixY(float yrot) noexcept {
        const float s = sinf(yrot);
        const float c = cosf(yrot);
        return Matrix(Vector(c, 0, -s), Vector(0.0f, 1.0f, 0.0f), Vector(s, 0, c));
    }
 
    inline Matrix makeRotationMatrixZ(float zrot) noexcept {
        const float s = sinf(zrot);
        const float c = cosf(zrot);
        return Matrix(Vector(c, s, 0), Vector(-s, c, 0), Vector(0.0f, 0.0f, 1.0f));
    }
 
    inline Matrix normalTransformMatrix(const Matrix &m) noexcept {
        return Matrix(m[1]^m[2], m[2]^m[0], m[0]^m[1]);
    }
 
    inline Matrix normalTransformMatrixX(const Matrix &m, bool &DlessThanZero ) noexcept {
        if((m[0]^m[1])*m[2] < 0){
            DlessThanZero = true;
            return Matrix(m[2]^m[1], m[0]^m[2], m[1]^m[0]);
        }
        DlessThanZero = false;
        return Matrix(m[1]^m[2], m[2]^m[0], m[0]^m[1]);
    }
 
    inline std::ostream& operator <<(std::ostream& stream, const Matrix& matrix) {
        stream << "Matrix(" << matrix.v0 << ", " << matrix.v1 << ", " << matrix.v2 << ")";
        return stream;
    }
 
    inline std::string Matrix::toString() const {
        std::ostringstream stream;
        stream << *this;
        return stream.str();
    }
 
    struct Transform {
        Matrix matrix;
        Vector offset;
 
        Transform() noexcept = default;
 
        Transform(const Transform&) noexcept = default;
        Transform(Transform&&) noexcept = default;
        Transform& operator=(const Transform&) noexcept = default;
        Transform& operator=(Transform&&) noexcept = default;
 
        Transform(const Matrix& matrix, const Vector& offset) noexcept : matrix(matrix), offset(offset) {}
 
        Transform(int i) noexcept {
            if (i == 1) makeIdentity();
            if (i == 0) makeZero();
        }
 
        void makeZero(void) noexcept {
            matrix.makeZero();
            offset.makeZero();
        }
 
        void makeIdentity(void) noexcept {
            matrix.makeIdentity();
            offset.makeZero();
        }
 
        void operator *=(float x) noexcept {
            matrix *= x;
            offset *= x;
        }
 
        void operator +=(const Transform &tm) noexcept {
            matrix += tm.matrix;
            offset += tm.offset;
        }
 
        void operator -=(const Transform &tm) noexcept {
            matrix -= tm.matrix;
            offset -= tm.offset;
        }
 
        Vector transformVec(const Vector &a) const noexcept {
            return matrix * a;
        }
 
        void makeInverse(void) noexcept {
            matrix.makeInverse();
            offset = -matrix * offset;
        }
 
        std::string toString() const;
    };
 
    inline bool operator !=(const Transform &a, const Transform &b) noexcept {
        return a.matrix != b.matrix || a.offset != b.offset;
    }
 
    inline bool operator ==(const Transform &a, const Transform &b) noexcept {
        return a.matrix == b.matrix && a.offset == b.offset;
    }
 
    inline Transform operator -(const Transform &tm) noexcept {
        return Transform(-tm.matrix, -tm.offset);
    }
 
    inline Transform operator *(const Transform &tm, float x) noexcept {
        return Transform(tm.matrix * x, tm.offset * x);
    }
 
    inline Transform operator *(float x, const Transform &tm) noexcept {
        return Transform(x * tm.matrix, x * tm.offset);
    }
 
    inline Transform operator /(const Transform &tm, float x) noexcept {
        return Transform(tm.matrix / x, tm.offset / x);
    }
 
    inline Transform operator +(const Transform &a, const Transform &b) noexcept {
        return Transform(a.matrix + b.matrix, a.offset + b.offset);
    }
 
    inline Transform operator -(const Transform &a, const Transform &b) noexcept {
        return Transform(a.matrix - b.matrix, a.offset - b.offset);
    }
 
    inline Transform operator *(const Transform &a, const Transform &b) noexcept {
        return Transform(a.matrix * b.matrix, a.matrix * b.offset + a.offset);
    }
 
    inline Vector operator *(const Transform &tm, const Vector &a) noexcept {
        return tm.matrix * a + tm.offset;
    }
 
    inline Vector inverseTransform(const Vector &a, const Transform &tm) noexcept {
        return (a - tm.offset) * tm.matrix;
    }
 
    inline std::ostream& operator <<(std::ostream& stream, const Transform& transform) {
        stream << "Transform(" << transform.matrix << ", " << transform.offset << ")";
        return stream;
    }
 
    inline std::string Transform::toString() const {
        std::ostringstream stream;
        stream << *this;
        return stream.str();
    }
 
    struct AnimatedTransform {
        std::vector<Transform> transforms; 
        std::vector<int> keyFrames;        
 
        AnimatedTransform() noexcept = default;
        AnimatedTransform(const AnimatedTransform&) = default;
        AnimatedTransform(AnimatedTransform&&) noexcept = default;
        AnimatedTransform& operator=(const AnimatedTransform&) = default;
        AnimatedTransform& operator=(AnimatedTransform&&) noexcept = default;
 
        AnimatedTransform(const std::vector<Transform>& transforms, const std::vector<int>& keyFrames) noexcept
            : transforms(transforms), keyFrames(keyFrames) {}
        AnimatedTransform(std::vector<Transform>&& transforms, std::vector<int>&& keyFrames) noexcept
            : transforms(std::move(transforms)), keyFrames(std::move(keyFrames)) {}
    };
 
    typedef int RGB32;
 
    struct RendererOptions;
    class PluginMeta;
    class PropertyMeta;
    class PropertyRuntimeMeta;
    class UIGuides;
    struct Box;
    struct RenderSizeParams;
 
    namespace Internal {
        const float DEFAULT_FPS = 24.0f;
        const float DEFAULT_POINT_SIZE = 2.2f;
        const long long READ_DATA_STRUCT_VERSION = 5; // added numFrames / hasVelocityChannel / hairVelocities / particleVelocities
        const long long READ_PARAMS_STRUCT_VERSION = 2; // updated struct layout
        const long long CREATE_PARAMS_STRUCT_VERSION = 7; // added bakeTransforms
        const long long GEOM_MESH_DATA_STRUCT_VERSION = 2; // added hair / particles
        const long long ENABLE_DRCLIENT_PARAMS_STRUCT_VERSION = 0; // initial version
        const long long LIVE_LINK_CLIENT_PARAMS_STRUCT_VERSION = 0; // initial version
        const long long SCATTER_READ_PARAMS_STRUCT_VERSION = 0; // initial version
        class VRayRendererNative;
        class BinaryValueParser;
        class BinaryValueBuilder;
        struct MeshFileDataParser;
    }
 
    struct GetImageOptions {
        ImageRegion region; 
        bool doColorCorrect; 
        bool stripAlpha; 
        bool flipImage; 
 
        GetImageOptions()
            : doColorCorrect(false)
            , stripAlpha(false)
            , flipImage(false)
        {}
    };
 
    class RenderElement {
        friend class RenderElements;
 
    public:
        enum Type {
            NONE = -1, 
 
            ATMOSPHERE = 100, 
            DIFFUSE, 
            REFLECT, 
            REFRACT, 
            SELFILLUM, 
            SHADOW, 
            SPECULAR, 
            LIGHTING, 
            GI, 
            CAUSTICS, 
            RAWGI, 
            RAWLIGHT, 
            RAWSHADOW, 
 
            VELOCITY, 
            RENDERID, 
            MTLID, 
            NODEID, 
            ZDEPTH, 
 
            REFLECTION_FILTER, 
            RAW_REFLECTION, 
 
            REFRACTION_FILTER, 
            RAW_REFRACTION, 
 
            REALCOLOR, 
            NORMALS, 
            BACKGROUND, 
 
            ALPHA, 
            COLOR, 
 
            WIRECOLOR, 
            MATTESHADOW, 
 
            TOTALLIGHT, 
            RAWTOTALLIGHT, 
 
            BUMPNORMALS, 
 
            SAMPLERATE, 
 
            SSS, 
 
            DRBUCKET, 
 
            VRMTL_REFLECTGLOSS, 
            VRMTL_REFLECTHIGLOSS, 
            VRMTL_REFRACTGLOSS, 
 
            SHADEMAP_EXPORT, 
            REFLECT_ALPHA, 
 
            VRMTL_REFLECTIOR, 
            MTLRENDERID, 
 
            NOISE_LEVEL, 
            WORLD_POSITION, 
            DENOISED, 
            WORLD_BUMPNORMAL, 
            DEFOCUS_AMOUNT, 
 
            EFFECTS_RESULT = 153, 
            TOON, 
 
            RENDERTIME = 157, 
            CRYPTOMATTE, 
            LIGHTING_ANALYSIS = 160, 
            LIGHT_SELECT = 163, 
 
            VRMTL_METALNESS = 165, 
            LIGHT_MIX = 178, 
 
            TOON_LIGHTING = 180, 
            TOON_SPECULAR = 181, 
 
            VRMTL_SHEEN_COLOR = 183, 
            RAW_SHEEN_REFLECTION = 184, 
            SHEEN_FILTER = 185, 
            VRMTL_SHEEN_GLOSSINESS = 186, 
            SHEEN_REFL_ALPHA = 187, 
            COAT_REFL_ALPHA = 188, 
            VRMTL_COAT_COLOR = 189, 
            RAW_COAT_REFLECTION = 190, 
            COAT_FILTER = 191, 
            VRMTL_COAT_GLOSSINESS = 192, 
            SHEEN_REFLECTION = 194, 
            COAT_REFLECTION = 195, 
 
            LAST, 
 
            USER=1000, 
 
            COVERAGE = USER + 5001, 
            MATERIAL_SELECT = USER + 5003, 
            MULTIMATTE = USER + 5004, 
            MULTIMATTE_ID = USER + 5005, 
            OBJECT_SELECT = USER + 5006, 
            EXTRA_TEX = USER + 5007, 
            EXTRA_TEX_INT = USER + 5008, 
            EXTRA_TEX_FLOAT = USER + 5009, 
            COAT = USER + 5010,
            SHEEN = USER + 5011,
            AMBIENT_OCCLUSION = USER + 5012,
        };
 
        enum BinaryFormat {
            BF_FLOAT  = 1, 
            BF_3FLOAT, 
            BF_2FLOAT, 
            BF_INT, 
            BF_3FLOAT_SIGNED, 
            BF_4FLOAT, 
        };
 
        enum PixelFormat {
            PF_DEFAULT = -1,
            PF_BW_BIT8 = 100, 
            PF_BW_BIT16, 
            PF_BW_BIT32, 
            PF_BW_HALF, 
            PF_BW_FLOAT, 
 
            PF_RGB_BIT8 = 200, 
            PF_RGB_BIT16, 
            PF_RGB_HALF, 
            PF_RGB_FLOAT, 
 
            PF_RGBA_BIT8 = 300, 
            PF_RGBA_BIT16, 
            PF_RGBA_HALF, 
            PF_RGBA_FLOAT, 
        };
 
        enum DataIntent {
            DI_INTENT_DISPLAY = 0,
 
            DI_INTENT_FILE,
 
            DI_INTENT_RAW,
 
            DI_INTENT_FILE_NO_COLOR_CORRECTIONS,
 
            DI_INTENT_FILE_SRGB,
 
            DI_INTENT_VIEWPORT_IPR
        };
 
        struct Info {
            const char *name; 
            BinaryFormat binaryFormat; 
            Type type; 
        };
 
    private:
        const VRayRenderer* renderer;
        InstanceId pluginID;
        std::string name;
        Type type;
        BinaryFormat binaryFormat;
        PixelFormat defaultPixelFormat;
 
        RenderElement(const VRayRenderer* renderer, Type type, const Plugin &plugin);
        static PixelFormat binaryFormatToPixelFormat(BinaryFormat binFormat);
 
        size_t getData_internal(
            int layer,
            InstanceId alphaPluginID,
            void** data,
            PixelFormat format = PF_DEFAULT,
            int intent = DataIntent::DI_INTENT_FILE_NO_COLOR_CORRECTIONS,
            bool rgbOrder = false,
            const ImageRegion* rgn = nullptr
        ) const;
 
    public:
        RenderElement() : renderer(NULL), pluginID(NO_ID), type(NONE), binaryFormat(BF_FLOAT), defaultPixelFormat(PF_DEFAULT) {}
 
        Plugin getPlugin() const;
 
        std::string getName() const {
            return name;
        }
 
        Type getType() const {
            return type;
        }
 
        BinaryFormat getBinaryFormat() const {
            return binaryFormat;
        }
 
        PixelFormat getDefaultPixelFormat() const {
            return defaultPixelFormat;
        }
 
        struct GetDataOptions {
            GetDataOptions()
                : alphaChannelPlugin(NULL)
                , useDefaultAlpha(false)
                , format(PF_DEFAULT)
                , rgbOrder(false)
                , region(nullptr)
                , layerIndex(0)
            {}
 
            Plugin *alphaChannelPlugin; 
            bool useDefaultAlpha; 
            PixelFormat format; 
            bool rgbOrder; 
            ImageRegion* region; 
            int layerIndex; 
            bool flipImage = false; //<! Flip image top-bottom.
            DataIntent intent = DI_INTENT_DISPLAY; 
        };
 
        size_t getData(void** data, const GetDataOptions &options) const;
 
        size_t getDataIntoBuffer(const GetDataOptions &options, void* data) const;
 
        static void releaseData(void* data);
 
        VRayImage* getImage(const ImageRegion* rgn = NULL, int layerIndex = 0) const;
 
        VRayImage* getImage(const GetImageOptions &options, int layerIndex = 0) const;
 
        std::string getMetadata() const;
 
        operator bool () const {
            return pluginID != NO_ID;
        }
    };
 
    class RenderElements {
        friend class VRayRenderer;
 
        VRayRenderer& renderer;
 
        RenderElements(VRayRenderer& renderer);
        RenderElements& operator=(const RenderElements&);
 
    public:
        RenderElement add(RenderElement::Type type, const char* displayName = nullptr, const char* instanceName = nullptr);
 
        RenderElement get(RenderElement::Type type) const;
 
        size_t get(const std::string &name, const RenderElement::GetDataOptions &options, void* buf) const;
 
        std::vector<RenderElement> getAll(RenderElement::Type type) const;
    };
 
    struct SubFileInfo {
        std::string pluginType;
        std::string fileNameSuffix;
    };
 
    struct SubSequenceDesc {
        int start, end, step;
    };
 
    struct ComputeDeviceInfo {
        long long deviceHandle; 
        long long platform; 
 
        std::string name; 
 
        struct {
            int useForRendering; 
            int useForDenoising; 
            int isSupported; 
        };
 
        enum Type {
            deviceType_default = (1 << 0), 
            deviceType_CPU = (1 << 1), 
            deviceType_GPU = (1 << 2), 
            deviceType_ACCEL = (1 << 3), 
        };
 
        Type deviceType; 
        int totalMemoryMB; 
        int numConnectedDisplays; 
        int frequencyMHz; 
        int gFlops; 
        int ccMajor; 
        int ccMinor; 
        int rtCoreVersion; 
 
        int shaderProcessorsCount; 
        int busId; 
        int localIndex; 
        int cudaOrdinalIndex; 
        int tccMode; 
 
        int isCpuEmulation; 
    };
 
    std::vector<ComputeDeviceInfo> getComputeDevicesMetal();
 
    std::vector<ComputeDeviceInfo> getComputeDevicesOptix();
 
    std::vector<ComputeDeviceInfo> getComputeDevicesCUDA();
 
    std::vector<ComputeDeviceInfo> getComputeDevicesDenoiser();
 
    bool setComputeDevicesMetal(const std::vector<int>& indices);
 
    bool setComputeDevicesOptix(const std::vector<int>& indices);
 
    bool setComputeDevicesCUDA(const std::vector<int>& indices);
 
    bool setComputeDevicesDenoiser(const std::vector<int>& indices);
 
    bool setComputeDevicesEnvironmentVariable();
 
    struct InteractiveStatistics {
        double pathsPerSecond; 
        unsigned elapsedTicks; 
        int sampleLevel; 
        int numPasses; 
        float currentNoiseThreshold; 
        float currentProgress; 
 
        struct ComputeDeviceStatistics {
            std::string name; 
            float utilization; 
            float freeMem; 
            float totalMem; 
        };
 
        std::vector<ComputeDeviceStatistics> computeDevices; 
 
        struct ComputeDeviceMemoryType {
            const char* name; 
            unsigned long long usage; 
        };
 
        std::vector<ComputeDeviceMemoryType> computeDevicesMemUsage; 
    };
 
    typedef std::vector<int>            IntList;
    typedef std::vector<float>          FloatList;
    typedef std::vector<Color>          ColorList;
    typedef std::vector<Vector>         VectorList;
    typedef std::vector<Value>          ValueList;
    typedef std::vector<std::string>    StringList;
 
    struct ObjectInfo {
        std::string name; 
        int id;           
        int vBegin;       
        int vEnd;         
    };
 
    struct VoxelInfo {
        Color wireColor;  
        Bool smoothed;    
        Bool flipNormals; 
    };
 
    struct Box {
        Vector pmin; 
        Vector pmax; 
 
        void expand(const Vector& point) {
            pmin = Vector(
                VRAY_MINIMUM2(pmin.x, point.x),
                VRAY_MINIMUM2(pmin.y, point.y),
                VRAY_MINIMUM2(pmin.z, point.z)
            );
            pmax = Vector(
                VRAY_MAXIMUM2(pmax.x, point.x),
                VRAY_MAXIMUM2(pmax.y, point.y),
                VRAY_MAXIMUM2(pmax.z, point.z)
            );
        }
 
        void expand(const Box& box) {
            pmin = Vector(
                VRAY_MINIMUM2(pmin.x, box.pmin.x),
                VRAY_MINIMUM2(pmin.y, box.pmin.y),
                VRAY_MINIMUM2(pmin.z, box.pmin.z)
            );
            pmax = Vector(
                VRAY_MAXIMUM2(pmax.x, box.pmax.x),
                VRAY_MAXIMUM2(pmax.y, box.pmax.y),
                VRAY_MAXIMUM2(pmax.z, box.pmax.z)
            );
        }
 
        std::string toString() const;
    };
 
    inline std::ostream& operator <<(std::ostream& stream, const Box& box) {
        stream << "Box(min: " << box.pmin << ", max: " << box.pmax << ")";
        return stream;
    }
 
    inline std::string Box::toString() const {
        std::ostringstream stream;
        stream << *this;
        return stream.str();
    }
 
    class GaussianReadData {
        friend class GeomUtils;
    public:
        GaussianReadData();
        GaussianReadData(GaussianReadData&& rhs) noexcept;
        GaussianReadData& operator=(GaussianReadData&& rhs) noexcept;
        ~GaussianReadData();
 
        unsigned getGaussianPrimitivesCount() const;
 
        Vector getPosition(unsigned index) const;
 
        Color getAverageColor(unsigned index) const;
 
        const Box& getPreviewBoundingBox() const { return previewBBox; }
 
    private:
        GaussianReadData(const GaussianReadData&) = delete;
        GaussianReadData& operator=(const GaussianReadData&) = delete;
 
        void* handle;
        Box previewBBox;
    };
 
    class ProxyReadData {
    public:
        enum ReadFlags {
            MESH_VERTICES = (1 << 4),
            MESH_NORMALS = (1 << 5),
            MESH_MTLIDS = (1 << 6),
            MESH_VELOCITIES = (1 << 7),
            MESH_UVS = (1 << 8),
            MESH_SHADERS = (1 << 9),
            MESH_OBJECTINFOS = (1 << 10),
            MESH_HAIROBJECTINFOS = (1 << 11),
            MESH_PARTICLEOBJECTINFOS = (1 << 12),
            MESH_HAIRGEOMETRY = (1 << 13),
            MESH_PARTICLESGEOMETRY = (1 << 14),
            MESH_GEOMETRYMESHESBBOXES = (1 << 15),
            MESH_HAIROBJECTBBOXES = (1 << 16),
            MESH_PARTICLEOBJECTBBOXES = (1 << 17),
            MESH_ALL = MESH_VERTICES | MESH_NORMALS | MESH_VELOCITIES | MESH_MTLIDS | MESH_UVS | MESH_SHADERS |
                       MESH_OBJECTINFOS | MESH_HAIROBJECTINFOS | MESH_PARTICLEOBJECTINFOS | MESH_HAIRGEOMETRY | MESH_PARTICLESGEOMETRY |
                       MESH_GEOMETRYMESHESBBOXES | MESH_HAIROBJECTBBOXES | MESH_PARTICLEOBJECTBBOXES,
        };
 
        ProxyReadData(int flags=MESH_ALL);
 
        void setFlags(int flags) { d.flags = flags; }
 
        const std::vector<Vector> &getVertices() const { return vertices; }
 
        const std::vector<int>    &getVertexIndices() const { return indices; }
 
        const std::vector<Vector> &getNormals() const { return normals; }
 
        const std::vector<int>    &getNormalIndices() const { return normalIndices; }
 
        const std::vector<int>    &getMaterialIDs() const { return materialIDs; }
 
        const std::vector<int>    &getEdgeVisibility() const { return edgeVisibility; }
 
        const std::vector<Vector> &getVelocities() const { return velocities; }
 
        int                        getUVSetsCount() const;
 
        std::vector<int>           getUVOriginalIndices() const;
 
        std::string                getUVSetName(int setIndex) const;
 
        size_t                     getUVValuesCount(int setIndex) const;
 
        size_t                     getUVValueIndicesCount(int setIndex) const;
 
        const Vector *             getUVValues(int setIndex) const;
 
        const int *                getUVValueIndices(int setIndex) const;
 
        int                        getShadersCount() const;
 
        std::string                getShaderName(int shaderIndex) const;
 
        int                        getShaderID(int shaderIndex) const;
 
        int                        getMeshObjectInfosCount() const;
 
        ObjectInfo                 getMeshObjectInfo(int meshIndex) const;
 
        int                        getHairObjectInfosCount() const;
 
        ObjectInfo                 getHairObjectInfo(int meshIndex) const;
 
        int                        getParticleObjectInfosCount() const;
 
        ObjectInfo                 getParticleObjectInfo(int meshIndex) const;
 
        VoxelInfo                  getMeshVoxelInfo(int meshIndex) const;
 
        VoxelInfo                  getHairVoxelInfo(int meshIndex) const;
 
        VoxelInfo                  getParticleVoxelInfo(int meshIndex) const;
 
        const std::vector<Vector> &getHairVertices() const { return hairVertices; }
 
        const std::vector<int>    &getHairVerticesPerStrand() const { return hairVerticesPerStrand; }
 
        const std::vector<float>  &getHairWidths() const { return hairWidths; }
 
        const std::vector<Vector> &getParticleVertices() const { return particleVertices; }
 
        const std::vector<float>  &getParticleWidths() const { return particleWidths; }
 
        int                       getGeometryVoxelsCount() const;
 
        int                       getAllVoxelsCount() const;
 
        int                       getNumFrames() const;
 
        Bool                      hasVelocityChannel() const;
 
        std::vector<Vector>       getVoxelVertices(int voxelIndex) const;
 
        std::vector<int>          getVoxelVertexIndices(int voxelIndex) const;
 
        const std::vector<int>    &getVoxelVerticesStartIndices() const { return voxelVerticesStartIndices; }
 
        const std::vector<int>    &getVoxelVertexIndicesStartIndices() const { return voxelVertexIndicesStartIndices; }
 
        std::vector<Vector>       getVoxelNormals(int voxelIndex) const;
 
        std::vector<int>          getVoxelNormalIndices(int voxelIndex) const;
 
        const std::vector<int>    &getVoxelNormalsStartIndices() const { return voxelNormalsStartIndices; }
 
        const std::vector<int>    &getVoxelNormalIndicesStartIndices() const { return voxelNormalIndicesStartIndices; }
 
        std::vector<int>          getVoxelMaterialIDs(int voxelIndex) const;
 
        const std::vector<int>    &getVoxelMaterialIDsStartIndices() const { return voxelMaterialIDsStartIndices; }
 
        std::vector<int>          getVoxelEdgeVisibility(int voxelIndex) const;
 
        std::vector<Vector>       getVoxelVelocities(int voxelIndex) const;
 
        const std::vector<int>    &getVoxelVelocitiesStartIndices() const { return voxelVelocitiesStartIndices; }
 
        std::vector<Vector>       getVoxelUVValues(int voxelIndex, int setIndex) const;
 
        std::vector<int>          getVoxelUVValueIndices(int voxelIndex, int setIndex) const;
 
        const std::vector<int>    &getVoxelUVValuesStartIndices() const { return voxelUVValuesStartIndices; }
 
        const std::vector<int>    &getVoxelUVValueIndicesStartIndices() const { return voxelUVValueIndicesStartIndices; }
 
        const std::vector<Vector> &getUVValues() const { return uvValues; }
 
        const std::vector<int>    &getUVValueIndices() const { return uvValueIndices; }
 
        int                       getHairVoxelsCount() const;
 
        int                       getParticleVoxelsCount() const;
 
        const std::vector<int>    &getHairVerticesStartIndices() const { return hairVerticesStartIndices; }
 
        const std::vector<int>    &getHairVerticesPerStrandStartIndices() const { return hairVerticesPerStrandStartIndices; }
 
        const std::vector<int>    &getHairWidthsStartIndices() const { return hairWidthsStartIndices; }
 
        const std::vector<int>    &getHairVelocitiesStartIndices() const { return hairVelocitiesStartIndices; }
 
        const std::vector<int>    &getParticleVerticesStartIndices() const { return particleVerticesStartIndices; }
 
        const std::vector<int>    &getParticleWidthsStartIndices() const { return particleWidthsStartIndices; }
 
        const std::vector<int>    &getParticleVelocitiesStartIndices() const { return particleVelocitiesStartIndices; }
 
        std::vector<Vector>       getHairVoxelVertices(int hairVoxelIndex) const;
 
        std::vector<int>          getHairVoxelVerticesPerStrand(int hairVoxelIndex) const;
 
        std::vector<float>        getHairVoxelWidths(int hairVoxelIndex) const;
 
        std::vector<Vector>       getHairVoxelVelocities(int hairVoxelIndex) const;
 
        std::vector<Vector>       getParticleVoxelVertices(int particleVoxelIndex) const;
 
        std::vector<float>        getParticleVoxelWidths(int particleVoxelIndex) const;
 
        std::vector<Vector>       getParticleVoxelVelocities(int particleVoxelIndex) const;
 
        std::vector<int>          getArrayOfLengths(const int* startIndices, int elementsCount, int objectCount) const;
 
        std::vector<int>          getArrayOfLengths(const int* startIndices, int elementsCount, int objectCount, int uvSetsCount) const;
 
        int                       getLengthFromStartIndex(int objectIndex, const int* startIndices, int elementsCount, int objectCount) const;
 
        int                       getLengthFromStartIndex(int objectIndex, int setIndex, const int* startIndices, int elementsCount, int objectCount, int uvSetsCount) const;
 
        const std::vector<Box>    &getGeometryVoxelsBBoxes() const { return geometryVoxelsBBoxes; }
 
        const std::vector<Box>    &getHairVoxelsBBoxes() const { return hairVoxelsBBoxes; }
 
        const std::vector<Box>    &getParticleVoxelsBBoxes() const { return particleVoxelsBBoxes; }
 
        Box                       getGeometryVoxelBBox(int voxelIndex) const;
 
        Box                       getHairVoxelBBox(int hairVoxelIndex) const;
 
        Box                       getParticleVoxelBBox(int particleVoxelIndex) const;
 
        const std::vector<Color>  &getVoxelInfoWireColor() const { return voxelInfoWireColor; }
 
        const std::vector<Bool>   &getVoxelInfoSmoothed() const { return voxelInfoSmoothed; }
 
        const std::vector<Bool>   &getVoxelInfoFlipNormals() const { return voxelInfoFlipNormals; }
 
        int                       getVoxelInfoObjectsCount() const;
 
    private:
        friend class VRayRenderer;
        friend class Proxy;
        void allocateArrays();
        std::vector<Vector>   getArrayElement  (int objectIndex, const int* startIndices, const VectorList& list, int elementsCount, size_t objectCount) const;
        std::vector<int>      getArrayElement  (int objectIndex, const int* startIndices, const int* primaryStartIndices, const IntList& list, int elementsCount, size_t objectCount) const;
        std::vector<int>      getArrayElement  (int objectIndex, const int* startIndices, const IntList& list, int elementsCount, size_t objectCount) const;
        std::vector<float>    getArrayElement  (int objectIndex, const int* startIndices, const FloatList& list, int elementsCount, size_t objectCount) const;
        std::vector<Vector>   getArrayElement  (int objectIndex, int setIndex, const int* startIndices, const VectorList& list, int elementsCount, size_t objectCount, size_t uvSetsCount) const;
        std::vector<int>      getArrayElement  (int objectIndex, int setIndex, const int* startIndices, const int* primaryStartIndices, const IntList& list, int elementsCount, int primaryElementsCount, size_t objectCount, size_t uvSetsCount) const;
 
        struct Internal {
            long long version;
            union {
                long long int flags;
                struct {
                    bool maxToMayaTM : 1;
                    bool mayaToMaxTM : 1;
                    bool reserved_bit2 : 1;
                    bool reserved_bit3 : 1;
                    bool use_vertices : 1;
                    bool use_normals : 1;
                    bool use_mtlIDs : 1;
                    bool use_velocities : 1;
                    bool use_UVs : 1;
                    bool use_shaders : 1;
                    bool use_objectInfos : 1;
                    bool use_hairObjectInfos : 1;
                    bool use_particleObjectInfos : 1;
                    bool use_hair : 1;
                    bool use_particles : 1;
                    bool use_geometryVoxelsBBoxes : 1;
                    bool use_hairVoxelsBBoxes : 1;
                    bool use_particleVoxelsBBoxes : 1;
                };
            };
 
            float* vertices;
            size_t vertices_count;                 
            int*   indices;
            size_t indices_count;                  
            float* normals;
            size_t normals_count;                  
            int*   normalIndices;
            size_t normalIndices_count;            
            int*   materialIDs;
            size_t materialIDs_count;              
            float* velocities;
            size_t velocities_count;               
 
            char*  uvSetNames;                     
            float* uvValues;                       
            int*   uvValueIndices;                 
            size_t uvSets_count;                   
            size_t uvSetNames_length;              
            int    uvSetIndices[100];              
            size_t uvValues_counts[100];           
            size_t uvValueIndices_counts[100];     
 
            char*  shaderNames;                    
            int*   shaderIds;                      
            size_t shaders_count;                  
            size_t shaderNames_length;             
 
            char*  objectInfoNames;                
            int*   objectInfoIds;                  
            int*   objectInfoVBegins;              
            int*   objectInfoVEnds;                
            size_t objectInfos_count;              
            size_t objectInfoNames_length;         
 
            char*  hairObjectInfoNames;            
            int*   hairObjectInfoIds;              
            int*   hairObjectInfoVBegins;          
            int*   hairObjectInfoVEnds;            
            size_t hairObjectInfos_count;          
            size_t hairObjectInfoNames_length;     
 
            char*  particleObjectInfoNames;        
            int*   particleObjectInfoIds;          
            int*   particleObjectInfoVBegins;      
            int*   particleObjectInfoVEnds;        
            size_t particleObjectInfos_count;      
            size_t particleObjectInfoNames_length; 
 
            float* hairVertices;                   
            size_t hairVertices_count;             
            int* hairVerticesPerStrand;            
            size_t hairVerticesPerStrand_count;    
            float* particleVertices;               
            size_t particlesVertices_count;        
 
            int* voxelVerticesStartIndices;         
            int* voxelVertexIndicesStartIndices;    
            int* voxelNormalsStartIndices;          
            int* voxelNormalIndicesStartIndices;    
            int* voxelMaterialIDsStartIndices;      
            int* voxelVelocitiesStartIndices;       
            int* voxelUVValuesStartIndices;         
            int* voxelUVValueIndicesStartIndices;   
 
            float* geometryVoxelsBBoxes;           
            float* hairVoxelsBBoxes;               
            float* particleVoxelsBBoxes;           
 
            int* hairVerticesStartIndices;         
            int* hairVerticesPerStrandStartIndices;
            int* particleVerticesStartIndices;     
 
            size_t geometryVoxels_count;           
            size_t hairVoxels_count;               
            size_t particleVoxels_count;           
 
            size_t totalUVvalues;                  
            size_t totalUVindices;                 
 
            int* edgeVisibility;                   
 
            Color* voxelInfoWireColor;             
            int*   voxelInfoSmoothed;              
            int*   voxelInfoFlipNormals;           
            size_t voxelInfoObjects_count;         
 
            float* hairWidths;                     
            size_t hairWidths_count;               
            int*   hairWidthsStartIndices;         
            float* particleWidths;                 
            size_t particleWidths_count;           
            int*   particleWidthsStartIndices;     
 
            int    numFrames;                      
            Bool   hasVelocityChannel;             
 
            float* hairVelocities;                 
            size_t hairVelocities_count;           
            int*   hairVelocitiesStartIndices;     
            float* particleVelocities;             
            size_t particleVelocities_count;       
            int*   particleVelocitiesStartIndices; 
        } d;
 
        std::vector<Vector> vertices;
        std::vector<int> indices;
        std::vector<Vector> normals;
        std::vector<int> normalIndices;
        std::vector<int> materialIDs;
        std::vector<Vector> velocities;
        std::vector<char> uvSetNames;
        std::vector<Vector> uvValues;
        std::vector<int> uvValueIndices;
        std::vector<char> shaderNames;
        std::vector<int> shaderIds;
        std::vector<char> objectInfoNames;
        std::vector<int> objectInfoIds;
        std::vector<int> objectInfoVBegins;
        std::vector<int> objectInfoVEnds;
        std::vector<char> hairObjectInfoNames;
        std::vector<int> hairObjectInfoIds;
        std::vector<int> hairObjectInfoVBegins;
        std::vector<int> hairObjectInfoVEnds;
        std::vector<char> particleObjectInfoNames;
        std::vector<int> particleObjectInfoIds;
        std::vector<int> particleObjectInfoVBegins;
        std::vector<int> particleObjectInfoVEnds;
        std::vector<Vector> hairVertices;
        std::vector<int> hairVerticesPerStrand;
        std::vector<Vector> particleVertices;
        std::vector<int> voxelVerticesStartIndices;
        std::vector<int> voxelVertexIndicesStartIndices;
        std::vector<int> voxelNormalsStartIndices;
        std::vector<int> voxelNormalIndicesStartIndices;
        std::vector<int> voxelMaterialIDsStartIndices;
        std::vector<int> voxelVelocitiesStartIndices;
        std::vector<int> voxelUVValuesStartIndices;
        std::vector<int> voxelUVValueIndicesStartIndices;
        std::vector<Box> geometryVoxelsBBoxes;
        std::vector<Box> hairVoxelsBBoxes;
        std::vector<Box> particleVoxelsBBoxes;
        std::vector<int> hairVerticesStartIndices;
        std::vector<int> hairVerticesPerStrandStartIndices;
        std::vector<int> particleVerticesStartIndices;
        std::vector<int> edgeVisibility;
        std::vector<Color> voxelInfoWireColor;
        std::vector<Bool> voxelInfoSmoothed;
        std::vector<Bool> voxelInfoFlipNormals;
        std::vector<float> hairWidths;
        std::vector<int>   hairWidthsStartIndices;
        std::vector<float> particleWidths;
        std::vector<int>   particleWidthsStartIndices;
        std::vector<Vector> hairVelocities;
        std::vector<int>    hairVelocitiesStartIndices;
        std::vector<Vector> particleVelocities;
        std::vector<int>    particleVelocitiesStartIndices;
    };
 
    union TiMe {
    private:
        int64_t asInt;
        double asDouble;
        explicit TiMe(int64_t time) : asInt(time) {}
    public:
        TiMe() : asInt(-1) {}
        explicit TiMe(double time) : asDouble(time) {}
        operator double() { return asDouble; }
        static double Default() { return TiMe(int64_t(-1)).asDouble; }
        static double None() { return TiMe(int64_t(-2)).asDouble; }
    };
 
    struct ProxyCreateParams {
        enum PreviewTypes {
            SIMPLIFY_FACE_SAMPLING = 0,
            SIMPLIFY_CLUSTERING,
            SIMPLIFY_EDGE_COLLAPSE,
            SIMPLIFY_COMBINED
        };
 
        ProxyCreateParams();
 
        std::string destination;                  
        int elementsPerVoxel;                     
        int previewFaces;                         
        int previewType;                          
        int animOn;                               
        int startFrame;                           
        int endFrame;                             
        int mergeVoxels;                          
 
        std::vector<std::string> objectNames;     
        std::vector<int> objectIDs;               
        std::string customPreviewFile;            
        std::vector<Color> voxelInfoWireColor;    
        std::vector<Bool> voxelInfoSmoothed;      
        std::vector<Bool> voxelInfoFlipNormals;   
 
        Bool exportPointCloud;                    
        float pointSize;                          
        int previewHairs;                         
        int previewParticles;                     
        Bool bakeTransforms;                      
    };
 
    struct ProxyReadParams {
        std::string file;                         
        std::string object_path;                  
        int         compute_normals;              
        int         flip_axis;                    
        int         subdiv_level;                 
        int         subdiv_preserve_map_borders;  
        int         anim_type;                    
        int         num_preview_faces;            
        float       smooth_angle;                 
        float       anim_speed;                   
        float       anim_offset;                  
        float       fps;                          
        bool        use_full_names;               
        bool        compute_bbox;                 
        bool        subdiv_all_meshes;            
        bool        subdiv_uvs;                   
        bool        subdiv_preserve_geom_borders; 
        bool        instancing;                   
        bool        use_alembic_offset;           
        float       hair_width_multiplier;        
        float       particle_width_multiplier;    
 
        ProxyReadParams();
    };
 
    struct ResumableRenderingOptions {
        std::string outputFileName;
 
        bool compressProgressiveFiles;
 
        bool deleteResumableFileOnSuccess;
 
        int progressiveAutoSaveSeconds;
 
        ResumableRenderingOptions() : compressProgressiveFiles(true)
            , deleteResumableFileOnSuccess(), progressiveAutoSaveSeconds(0)
        {}
    };
 
    struct DenoiserOptions {
        enum FlagVal : byte {
            Disabled = 0, 
            Enabled = 1, 
            Default = 0xFF 
        };
 
        FlagVal hideDest; 
        FlagVal panorama; 
        FlagVal skipAlpha; 
        FlagVal optixUpscale; 
        FlagVal allowInSingleChannelFiles; 
        FlagVal skipAuxElementsInFiles; 
 
        DenoiserOptions() : hideDest(Default), panorama(Default), skipAlpha(Default), optixUpscale(Default),
            allowInSingleChannelFiles(Default), skipAuxElementsInFiles(Default) {}
 
        DenoiserOptions(const DenoiserOptions& options) = default;
        DenoiserOptions& operator=(const DenoiserOptions& options) = default;
    };
 
    class LightUtils;
 
    class LuminaireFieldReadPreviewData {
        friend LightUtils;
    public:
        LuminaireFieldReadPreviewData() : luminaireFieldHandle(nullptr) {}
        ~LuminaireFieldReadPreviewData();
 
        bool isValid() const;
        bool useConvexHull() const;
        Box getBoundingBox() const;
        float getScale() const;
        std::vector<Vector> getConvexHullVertices() const;
        std::vector<int> getConvexHullTriangles() const;
    private:
        void* luminaireFieldHandle;
    };
 
    union VersionUnion {
        struct {
            unsigned char  revision;
            unsigned char  minor;
            unsigned short major;
        };
        unsigned allFields;
 
        #ifdef _MSC_VER
        #pragma warning(disable : 4996)
        #endif
        std::string toString() const {
            std::string str;
            str.resize(15);
            int n = std::snprintf(&str[0], str.size() - 1, "%u.%02u.%02u", major, minor, revision);
            str.resize(n);
            return str;
        }
        #ifdef _MSC_VER
        #pragma warning(default : 4996)
        #endif
    };
    typedef VersionUnion VRayVersion;
    typedef VersionUnion APIVersion;
 
    inline std::ostream& operator <<(std::ostream& stream, const VRayVersion& version) {
        stream << version.toString();
        return stream;
    }
 
    struct InstancerParamFlags {
        static const int useParentTimes = (1 << 0);
        static const int useObjectID = (1 << 1);
        static const int usePrimaryVisibility = (1 << 2);
        static const int useUserAttributes = (1 << 3);
        static const int useParentTimesAtleastForGeometry = (1 << 4); 
        static const int useMaterial = (1 << 5); 
        static const int useGeometry = (1 << 6); 
        static const int useMapChannels = (1 << 7); 
        static const int useSkipCryptomatte = (1 << 8); 
        static const int useRenderIDOverride = (1 << 9); 
        static const int useUserAttributesBin = (1 << 10); 
        static const int useObjectProperties = (1<<11); 
    };
 
    struct ScannedMaterialParams;
    struct ScannedMaterialPreset;
 
    struct AutoExposureResult {
        float autoExposure; 
        float autoWhiteBalance; 
        float ISO; 
    };
} // namespace VRay
 
// internal function declarations
#include "_vraysdk_import.hpp"
 
namespace VRay {
    namespace Language {
        constexpr const char* EN_US = "en-US";
        constexpr const char* ZH_CN = "zh-CN";
    }
 
    struct RendererOptions {
 
        enum ThemeStyle {
            ThemeStyleAuto = 0,
            ThemeStyleStandalone,
            ThemeStyle3dsMax,
            ThemeStyle3dsMaxQt,
            ThemeStyleMaya,
        };
 
        ThemeStyle vfbDrawStyle;    
 
        union {
            int flags;
            struct {
                bool enableFrameBuffer : 1;  
                bool showFrameBuffer : 1;    
                bool noRenderLicensePreCheck : 1; 
                bool useDefaultVfbTheme : 1; 
                bool showVfbButtonInteractiveStart : 1; 
                bool previewRenderer : 1; 
                bool allowInvalidCharactersInPluginNames : 1; 
                bool dockFrameBuffer : 1; 
                bool hideToSceneButton : 1; 
                bool useVfbLog : 1; 
                bool enableVfbPlugins : 1; 
                bool showVfbButtonDebugShading : 1; 
                bool showVfbButtonTestResolution : 1; 
                bool showVfbButtonIPRPause : 1; 
                bool showVfbButtonIPRUpdate : 1; 
                bool showVfbButtonCopyToHostFrameBuffer : 1; 
                bool showVfbAddLightMixREToSceneButton : 1; 
                bool showVfbAddDenoiserREToSceneButton : 1; 
                bool forwardProgressToVfbProgressBar : 1; // true to forward progress messages to VFB progress bar
            };
        };
 
        void* parentWindowHandle;
 
        std::string pluginLibraryPath; 
 
        std::string vfbLanguage; 
 
        RendererOptions()
            : vfbDrawStyle(ThemeStyleAuto)
            , flags(0)
            , parentWindowHandle()
        {
            enableFrameBuffer = true;
            showFrameBuffer = true;
            useDefaultVfbTheme = true;
            useVfbLog = true;
        }
 
        RendererOptions(const RendererOptions& options) = default;
        RendererOptions(RendererOptions&& options) = default;
 
        RendererOptions& operator=(const RendererOptions& options) = default;
        RendererOptions& operator=(RendererOptions&& options) = default;
 
        void swap(RendererOptions& options);
    };
 
    struct EnableDRClientParams {
        std::string dispatcher;                       
        std::string httpProxy;                        
        union {
            int flags;
            struct {
                bool localRendering : 1;              
                bool withBroadcastListener : 1;       
                bool pipelinedUpstream : 1;           
                bool enableAssigningWUsAsBackups : 1; 
                bool immediatelyForwardReadySplitBucketSubunits : 1;
            };
        };
        int connectTimeout;                           
        int upstreamChannels;                         
        int verboseLevel;                             
 
        EnableDRClientParams()
            : flags(0)
            , connectTimeout(10)
            , upstreamChannels(3)
            , verboseLevel(3) {
            pipelinedUpstream = true;
            enableAssigningWUsAsBackups = true;
        }
    };
 
    struct LiveLinkClientParameters {
        std::string hosts;                              // can either be an empty string or host[:port]
        std::string vantageFile;                        // absolute path to .vantage file
    };
 
    struct VRayProfilerSettings {
        enum class Mode {
            Off = 0, 
            Simple, 
            Full, 
            Process, 
        };
 
        enum FileType : int {
            FileType_HTML=0, 
            FileType_JSON, 
        };
 
        Mode mode;                    
        int maxDepth;                 
        std::string outputDirectory;  
        std::string htmlTemplatePath; 
        std::string productName;      
        std::string productVersion;   
        std::string sceneName;        
 
        VRayProfilerSettings() {
            mode = Mode::Off;
            maxDepth = 1;
        }
    };
 
 
#if !defined(VRAY_RUNTIME_LOAD_PRIMARY) && !defined(VRAY_RUNTIME_LOAD_SECONDARY)
    class VRayInit {
        VRayInit(VRayInit&);    // copy construction disabled
 
    public:
        VRayInit() {
            Internal::VRay_incrementModuleReferenceCounter();
        }
 
        explicit VRayInit(bool enableFrameBuffer) {
            Internal::VRay_incrementModuleReferenceCounter();
            Internal::VRay_enableFrameBuffer(enableFrameBuffer);
        }
 
#ifdef _WIN32
        void setUseParentEventLoop() {
            Internal::VRay_blendFrameBuffer();
        }
#endif // _WIN32
 
        void setGUIMessageProcessing(bool enableMessageProcessing) {
            Internal::VRay_GUIMessageProcessing(enableMessageProcessing);
        }
 
        void setOSMessageDispatching(bool enableMessageDispatching) {
            Internal::VRay_OSMessageDispatching(enableMessageDispatching);
        }
 
        ~VRayInit() {
            Internal::VRay_LicenseManager_releaseLicense();
        }
    };
 
#elif defined(VRAY_RUNTIME_LOAD_PRIMARY)
    class VRayInit {
        VRayInit(VRayInit&);    // copy construction disabled
 
    public:
        explicit VRayInit(const char* const libraryFileName) {
            initialize(libraryFileName);
            if (Internal::VRay_incrementModuleReferenceCounter) Internal::VRay_incrementModuleReferenceCounter();
        }
 
        VRayInit(const char* const libraryFileName, bool enableFrameBuffer) {
            initialize(libraryFileName);
            if (Internal::VRay_incrementModuleReferenceCounter) Internal::VRay_incrementModuleReferenceCounter();
            if (Internal::VRay_enableFrameBuffer) Internal::VRay_enableFrameBuffer(enableFrameBuffer);
        }
 
#ifdef _WIN32
        void setUseParentEventLoop() {
            Internal::VRay_blendFrameBuffer();
        }
#endif // _WIN32
 
        void setGUIMessageProcessing(bool enableMessageProcessing) {
            Internal::VRay_GUIMessageProcessing(enableMessageProcessing);
        }
 
        void setOSMessageDispatching(bool enableMessageDispatching) {
            Internal::VRay_OSMessageDispatching(enableMessageDispatching);
        }
 
        ~VRayInit() {
            if (Internal::VRay_LicenseManager_releaseLicense)
                Internal::VRay_LicenseManager_releaseLicense();
            release();
        }
 
        operator bool () const {
            return !!hLib;
        }
 
        std::string getSDKLibraryErrorString() const {
            return errString;
        }
 
    protected:
        VRayInit() {}
 
        Internal::HModule hLib;
        std::string errString;
 
#ifdef VRAY_NOTHROW
        void makeError(const std::string &errMsg) {
            errString = errMsg;
            hLib = nullptr;
        }
#endif // VRAY_NOTHROW
 
        void initialize(const char* libraryFileName);
        void importFunctions();
 
        void release() {
            if (hLib)
#ifdef _WIN32
                Internal::FreeLibrary(hLib);
#else
                Internal::dlclose(hLib);
#endif // _WIN32
        }
    };
#endif // #if !defined(VRAY_RUNTIME_LOAD_PRIMARY) && !defined(VRAY_RUNTIME_LOAD_SECONDARY)
 
    inline bool isDR2() {
        return !!Internal::VRay_isDR2();
    }
 
    inline APIVersion getAPIVersion() {
        APIVersion ver;
        ver.allFields = Internal::VRay_getSDKVersion();
        return ver;
    }
 
    inline VRayVersion getVRayVersion() {
        VRayVersion ver;
        ver.allFields = Internal::VRay_getVRayVersion();
        return ver;
    }
 
    inline const char* getVRayVersionDetails() {
        return Internal::VRay_getVRayVersionDetails();
    }
 
    inline const char* getMaterialLibraryPath() {
        return Internal::VRay_getMaterialLibraryPath();
    }
 
    struct LicenseServerSettings {
        std::string serverName; 
        int serverPort; 
        std::string proxyName; 
        int proxyPort;
        std::string username; 
        std::string password; 
 
        std::string serverName1; 
        int serverPort1;
 
        std::string serverName2; 
        int serverPort2;
 
        std::string proxyUserName; 
        std::string proxyPassword; 
 
        LicenseServerSettings(void) {
            serverPort = 0;
            proxyPort = 0;
            serverPort1 = 0;
            serverPort2 = 0;
        }
    };
 
    inline int setLicenseServers(const LicenseServerSettings& settings);
 
    inline void setUSDProvider(const char* usdProvider);
 
    class Error {
 
    protected:
        ErrorCode errorCode;
 
    public:
        Error(int errorCode = SUCCESS) : errorCode(static_cast<ErrorCode>(errorCode)) {
        }
 
        Error(ErrorCode errorCode) : errorCode(errorCode) {
        }
 
        bool error() const {
            return errorCode != SUCCESS;
        }
 
        ErrorCode getCode() const {
            return errorCode;
        }
 
        const char* toString() const {
            return Internal::VRay_getErrorTextStringFromErrorCode(errorCode);
        }
 
        friend inline bool operator==(const Error& err0, const Error& err1) {
            return err0.errorCode == err1.errorCode;
        }
 
        friend inline bool operator!=(const Error& err0, const Error& err1) {
            return err0.errorCode != err1.errorCode;
        }
 
        friend inline bool operator==(const Error& err, ErrorCode errCode) {
            return err.errorCode == errCode;
        }
 
        friend inline bool operator==(ErrorCode errCode, const Error& err) {
            return errCode == err.errorCode;
        }
 
        friend inline bool operator!=(const Error& err, ErrorCode errCode) {
            return err.errorCode != errCode;
        }
 
        friend inline bool operator!=(ErrorCode errCode, const Error& err) {
            return errCode != err.errorCode;
        }
 
    };
 
    inline std::ostream& operator <<(std::ostream& stream, const Error& err) {
        stream << err.toString();
        return stream;
    }
 
    struct ParserError {
        std::string fileName;
        std::string errorText;
        int fileLine;
    };
 
    struct ScannedMaterialLicenseError {
        LicenseError::VRLAuthError errorCode;
 
        ScannedMaterialLicenseError(LicenseError::VRLAuthError errorCode = LicenseError::vrlauth_noError)
            : errorCode(errorCode) {}
 
        bool error() const {
            return errorCode != LicenseError::vrlauth_noError;
        }
 
        const char* toString() const;
    };
 
 
    struct ScannedMaterialParams {
        enum Plain {
            PL_NONE     = 0, 
            PL_HMG      = 1, 
            PL_HMGSYM   = 2, 
            PL_TRIPLANAR = 3  
        };
 
        enum MapChannels {
            VRSM_PAINT  = 0, 
            VRSM_FILTER = 1, 
            VRSM_CCMULT = 2  
        };
 
        enum MapChannelsMask {
            CH_PAINT_MASK  = 1 << VRSM_PAINT,
            CH_FILTER_MASK = 1 << VRSM_FILTER,
            CH_CCMULT_MASK = 1 << VRSM_CCMULT
        };
 
        enum ColorSpace {
            CS_SRGB     = 0, 
            CS_ADOBE    = 1, 
            CS_PP       = 2  
        };
 
        enum Triplanar {
            TP_ENABLED = 1, 
            TP_RNDOFFS = 2, 
            TP_RNDROT  = 4, 
        };
 
        Plain           plain; 
        float           invgamma; 
        float           saturation;
        float           depthMul; 
        int             disablewmap; 
        Color           filter; 
        Transform       uvtrans; 
        int             usemap; 
        float           bumpmul; 
        float           bumpstart; 
        int             nsamples; 
        float           cutoff; 
        int             mapChannel; 
        int             dome; 
        float           multdirect, multrefl, multgi; 
        int             traceDepth; 
        float           scrambleSize; 
        float           sceneScale; 
        float           ccior; 
        int             cchlight; 
        float           ccbump; 
        int             unfRefl; 
        int             twoside; 
        int             displace; 
        int             noPrimGI; 
        float           retrace; 
        int             noTransp; 
        float           transpMul; 
        MapChannelsMask mapChBitmask; 
        float           paintStrength; 
        float           fltStrength; 
        ColorSpace      clrSpace; 
        Bool            noCachedGI; 
        float           ccmetalrefl; 
        float           ccmul; 
        int             triplanar; 
        int             fasttrans; 
        int             BWforGI; 
        float           ccglossy; 
        float           ccglossyvar; 
        float           sssmul; 
 
        ScannedMaterialParams();
    };
 
    bool encodeScannedMaterialParams(const ScannedMaterialParams& mtlParams, IntList& paramBlock);
 
    bool encodeScannedMaterialParams(const ScannedMaterialParams& mtlParams, IntList& paramBlock, ScannedMaterialLicenseError& licError);
 
    unsigned getScannedMaterialUILicense();
 
    unsigned getScannedMaterialUILicense(ScannedMaterialLicenseError& licError);
 
    unsigned releaseScannedMaterialUILicense();
 
    struct ScannedMaterialPreset {
        enum SmoothModelFlags { 
            SMF_FORCE = 1,  
            SMF_PS = 4  
        };
 
        float   ccior; 
        int     plain; 
        float   bumpmul; 
        float   bumpstart; 
        float   depthmul; 
        float   ccbump; 
        float   orggls;
        float   orgglvar;
        int     thumbpos;
        float   free4, free5, free6;
        float   ccmul; 
        float   shdhmul; 
        float   shdmul; 
        int     flakes; 
        int     forcebrdf; 
        float   specbell; 
        float   specmul; 
        float   free7;
        float   scratchdens; 
        float   fuzzy; 
        float   topvLs_A; 
        float   topvLs_B; 
        int     keepflakesuv;
        float   indmul; 
        float   ccmetalrefl;
        float   thickness; 
        int     triplanar; 
        float   transpf; 
        float   lfsizecm; 
 
        ScannedMaterialPreset();
    };
 
    class ScannedMaterialInfo {
        union {
            void* handle;
            int err;
        } u;
 
        void createThis(const char* pluginLibPath);
 
    public:
        enum Error {
            NO_ERR = 0,
            BAD_LIBRARY_FILE = 1,
            SDK_BROKEN = 3
        };
 
        explicit ScannedMaterialInfo(const char* pluginLibPath = NULL);
        explicit ScannedMaterialInfo(const std::string& pluginLibPath);
        ~ScannedMaterialInfo();
 
        Error getError() const;
 
        operator bool() const;
 
        bool operator!() const;
 
        bool getInfo(const char* filename, std::string& info) const;
 
        bool getInfo(const std::string& filename, std::string& info) const;
 
 
        bool getPreset(const char* filename, ScannedMaterialPreset& result) const;
 
        bool getPreset(const std::string& filename, ScannedMaterialPreset& result) const;
    };
 
    namespace VUtils {
        class Value;
    }
    namespace Internal {
        class Access;
        class BinaryValueParser;
    }
 
    enum PluginCategory {
        category_bitmap = 0, 
        category_bsdf, 
        category_geometric_object, 
        category_geometry_source, 
        category_light, 
        category_material, 
        category_render_channel, 
        category_render_view, 
        category_settings, 
        category_texture, 
        category_texture_float, 
        category_texture_int, 
        category_texture_matrix, 
        category_texture_transform, 
        category_texture_vector, 
        category_uvwgen, 
        category_volumetric, 
 
        category_last //used for enumerating all possible plugin categories
    };
 
    struct PluginCategories {
        unsigned long long pluginCategoryField; 
 
        bool operator==(const PluginCategories& categories) const noexcept {
            return pluginCategoryField == categories.pluginCategoryField;
        }
 
        bool operator!=(const PluginCategories& categories) const noexcept {
            return pluginCategoryField != categories.pluginCategoryField;
        }
 
        bool hasBitmapCategory() const noexcept { return (pluginCategoryField & (1ull << category_bitmap)) != 0; }
        void setBitmapCategory() noexcept { pluginCategoryField |= 1ull << category_bitmap; }
        void resetBitmapCategory() noexcept { pluginCategoryField &= ~(1ull << category_bitmap); }
 
        bool hasBsdfCategory() const noexcept { return (pluginCategoryField & (1ull << category_bsdf)) != 0; }
        void setBsdfCategory() noexcept { pluginCategoryField |= 1ull << category_bsdf; }
        void resetBsdfCategory() noexcept { pluginCategoryField &= ~(1ull << category_bsdf); }
 
        bool hasGeometricObjectCategory() const noexcept { return (pluginCategoryField & (1ull << category_geometric_object)) != 0; }
        void setGeometricObjectCategory() noexcept { pluginCategoryField |= 1ull << category_geometric_object; }
        void resetGeometricObjectCategory() noexcept { pluginCategoryField &= ~(1ull << category_geometric_object); }
 
        bool hasGeometrySourceCategory() const noexcept { return (pluginCategoryField & (1ull << category_geometry_source)) != 0; }
        void setGeometrySourceCategory() noexcept { pluginCategoryField |= 1ull << category_geometry_source; }
        void resetGeometrySourceCategory() noexcept { pluginCategoryField &= ~(1ull << category_geometry_source); }
 
        bool hasLightCategory() const noexcept { return (pluginCategoryField & (1ull << category_light)) != 0; }
        void setLightCategory() noexcept { pluginCategoryField |= 1ull << category_light; }
        void resetLightCategory() noexcept { pluginCategoryField &= ~(1ull << category_light); }
 
        bool hasMaterialCategory() const noexcept { return (pluginCategoryField & (1ull << category_material)) != 0; }
        void setMaterialCategory() noexcept { pluginCategoryField |= 1ull << category_material; }
        void resetMaterialCategory() noexcept { pluginCategoryField &= ~(1ull << category_material); }
 
        bool hasRenderChannelCategory() const noexcept { return (pluginCategoryField & (1ull << category_render_channel)) != 0; }
        void setRenderChannelCategory() noexcept { pluginCategoryField |= 1ull << category_render_channel; }
        void resetRenderChannelCategory() noexcept { pluginCategoryField &= ~(1ull << category_render_channel); }
 
        bool hasRenderViewCategory() const noexcept { return (pluginCategoryField & (1ull << category_render_view)) != 0; }
        void setRenderViewCategory() noexcept { pluginCategoryField |= 1ull << category_render_view; }
        void resetRenderViewCategory() noexcept { pluginCategoryField &= ~(1ull << category_render_view); }
 
        bool hasSettingsCategory() const noexcept { return (pluginCategoryField & (1ull << category_settings)) != 0; }
        void setSettingsCategory() noexcept { pluginCategoryField |= 1ull << category_settings; }
        void resetSettingsCategory() noexcept { pluginCategoryField &= ~(1ull << category_settings); }
 
        bool hasTextureCategory() const noexcept { return (pluginCategoryField & (1ull << category_texture)) != 0; }
        void setTextureCategory() noexcept { pluginCategoryField |= 1ull << category_texture; }
        void resetTextureCategory() noexcept { pluginCategoryField &= ~(1ull << category_texture); }
 
        bool hasTextureFloatCategory() const noexcept { return (pluginCategoryField & (1ull << category_texture_float)) != 0; }
        void setTextureFloatCategory() noexcept { pluginCategoryField |= 1ull << category_texture_float; }
        void resetTextureFloatCategory() noexcept { pluginCategoryField &= ~(1ull << category_texture_float); }
 
        bool hasTextureIntCategory() const noexcept { return (pluginCategoryField & (1ull << category_texture_int)) != 0; }
        void setTextureIntCategory() noexcept { pluginCategoryField |= 1ull << category_texture_int; }
        void resetTextureIntCategory() noexcept { pluginCategoryField &= ~(1ull << category_texture_int); }
 
        bool hasTextureMatrixCategory() const noexcept { return (pluginCategoryField & (1ull << category_texture_matrix)) != 0; }
        void setTextureMatrixCategory() noexcept { pluginCategoryField |= 1ull << category_texture_matrix; }
        void resetTextureMatrixCategory() noexcept { pluginCategoryField &= ~(1ull << category_texture_matrix); }
 
        bool hasTextureTransformCategory() const noexcept { return (pluginCategoryField & (1ull << category_texture_transform)) != 0; }
        void setTextureTransformCategory() noexcept { pluginCategoryField |= 1ull << category_texture_transform; }
        void resetTextureTransformCategory() noexcept { pluginCategoryField &= ~(1ull << category_texture_transform); }
 
        bool hasTextureVectorCategory() const noexcept { return (pluginCategoryField & (1ull << category_texture_vector)) != 0; }
        void setTextureVectorCategory() noexcept { pluginCategoryField |= 1ull << category_texture_vector; }
        void resetTextureVectorCategory() noexcept { pluginCategoryField &= ~(1ull << category_texture_vector); }
 
        bool hasUvwgenCategory() const noexcept { return (pluginCategoryField & (1ull << category_uvwgen)) != 0; }
        void setUvwgenCategory() noexcept { pluginCategoryField |= 1ull << category_uvwgen; }
        void resetUvwgenCategory() noexcept { pluginCategoryField &= ~(1ull << category_uvwgen); }
 
        bool hasVolumetricCategory() const noexcept { return (pluginCategoryField & (1ull << category_volumetric)) != 0; }
        void setVolumetricCategory() noexcept { pluginCategoryField |= 1ull << category_volumetric; }
        void resetVolumetricCategory() noexcept { pluginCategoryField &= ~(1ull << category_volumetric); }
 
        PluginCategories() noexcept : pluginCategoryField() {}
 
        explicit PluginCategories(PluginCategory category) noexcept
            : pluginCategoryField(1ull << category) {}
 
        PluginCategories(PluginCategory category0, PluginCategory category1) noexcept
            : pluginCategoryField((1ull << category0) || (1ull << category1)) {}
 
        PluginCategories(PluginCategory category0, PluginCategory category1, PluginCategory category2) noexcept
            : pluginCategoryField((1ull << category0) || (1ull << category1) || (1ull << category2)) {}
 
        PluginCategories(PluginCategory category0, PluginCategory category1, PluginCategory category2, PluginCategory category3) noexcept
            : pluginCategoryField((1ull << category0) || (1ull << category1) || (1ull << category2) || (1ull << category3)) {}
 
        void clear() noexcept { pluginCategoryField = 0; }
 
        bool hasCategory(PluginCategory category) const noexcept {
            return (pluginCategoryField & (1ull << category)) != 0;
        }
 
        void setCategory(PluginCategory category, bool value) noexcept {
            const long long msk = 1ll << category;
            const long long val = -static_cast<long long>(value);
            pluginCategoryField = (pluginCategoryField | (msk & val)) & (~msk | val);
        }
 
        std::vector<PluginCategory> getAll() const;
    };
 
    template<class T>
    class PluginRefT;
 
    class Plugin {
        friend class VRayRenderer;
        friend class PropertyRuntimeMeta;
        friend class VUtils::Value;
        friend class Internal::Access;
        friend class Internal::BinaryValueParser;
        friend class Internal::BinaryValueBuilder;
 
    protected:
        const VRayRenderer* pRenderer;
        InstanceId internalId;
        InstanceId id() const {
            constexpr int shift = sizeof(InstanceId) * 8 - Internal::INSTANCE_ID_BITS;
            return static_cast<signed long long>(internalId << shift) >> shift;
        }
 
        Plugin(VRayRenderer& renderer, const char* name);
        Plugin(VRayRenderer& renderer, InstanceId id) noexcept;
        Plugin(VRayRenderer& renderer, InstanceId id, PluginTypeId typeId) noexcept;
        Plugin(VRayRenderer& renderer, InstanceId id, int typeIdIdx) noexcept;
 
        template<typename T, int TYPE>
        bool setValueAtTimeTemplate(const char* propertyName, const T& value, double time);
 
        template<typename T, int TYPE>
        bool setArrayAtTimeTemplate(const char* propertyName, size_t count, const T& value, double time);
 
        template<typename LengthFn, typename PointerFn>
        bool setStringArrayTemplate(const char *propertyName, size_t count, LengthFn lengthAt, PointerFn pointerAt, double time);
 
    public:
        enum class PropertyState : int {
            Invalid = 0,     
            Default = 1,     
            NotAnimated = 2, 
            Animated = 3     
        };
 
        Plugin() noexcept : pRenderer(), internalId(NO_ID) {}
 
        Plugin(const Plugin &plugin) noexcept;
 
        Plugin& operator=(const Plugin &plugin) noexcept;
 
        bool operator==(const Plugin &plugin) const noexcept;
 
        bool operator!=(const Plugin &plugin) const noexcept;
 
        bool operator<(const Plugin& plugin) const noexcept;
        bool operator<=(const Plugin& plugin) const noexcept;
        bool operator>(const Plugin& plugin) const noexcept;
        bool operator>=(const Plugin& plugin) const noexcept;
 
        void swap(Plugin &plugin) noexcept;
 
        bool isEmpty() const noexcept;
 
        bool isNotEmpty() const noexcept;
 
        bool isValid() const;
 
        VRayRenderer* getRenderer() const noexcept;
 
        unsigned long long getIntegerID() const noexcept;
 
        const char* getName() const;
 
        bool setName(const char* newName);
 
        bool setName(const std::string& newName);
 
        const char* getType() const;
 
        PluginTypeId getTypeId() const noexcept;
 
        std::string toString() const;
 
        PluginMeta getMeta() const;
 
        PluginCategories getCategories() const;
 
        PropertyRuntimeMeta getPropertyRuntimeMeta(const char* propertyName) const;
        PropertyRuntimeMeta getPropertyRuntimeMeta(const std::string& propertyName) const;
 
        std::string getValueAsString(const char* propertyName, double time = TiMe::Default()) const;
        std::string getValueAsString(const std::string& propertyName, double time = TiMe::Default()) const;
 
        std::string getValueAsString(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        std::string getValueAsString(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        bool setValueAsString(const char* propertyName, const char* value);
        bool setValueAsString(const char* propertyName, const std::string& value);
 
        bool setValueAsString(const std::string& propertyName, const char* value);
        bool setValueAsString(const std::string& propertyName, const std::string& value);
 
        bool getBool(const char* propertyName, double time = TiMe::Default()) const;
        bool getBool(const std::string& propertyName, double time = TiMe::Default()) const;
 
        bool getBool(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        bool getBool(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        int getInt(const char* propertyName, double time = TiMe::Default()) const;
        int getInt(const std::string& propertyName, double time = TiMe::Default()) const;
 
        int getInt(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        int getInt(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        float getFloat(const char* propertyName, double time = TiMe::Default()) const;
        float getFloat(const std::string& propertyName, double time = TiMe::Default()) const;
 
        float getFloat(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        float getFloat(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        double getDouble(const char* propertyName, double time = TiMe::Default()) const;
        double getDouble(const std::string& propertyName, double time = TiMe::Default()) const;
 
        double getDouble(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        double getDouble(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        Color getColor(const char* propertyName, double time = TiMe::Default()) const;
        Color getColor(const std::string& propertyName, double time = TiMe::Default()) const;
 
        Color getColor(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        Color getColor(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        AColor getAColor(const char* propertyName, double time = TiMe::Default()) const;
        AColor getAColor(const std::string& propertyName, double time = TiMe::Default()) const;
 
        AColor getAColor(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        AColor getAColor(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        Vector getVector(const char* propertyName, double time = TiMe::Default()) const;
        Vector getVector(const std::string& propertyName, double time = TiMe::Default()) const;
 
        Vector getVector(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        Vector getVector(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        Matrix getMatrix(const char* propertyName, double time = TiMe::Default()) const;
        Matrix getMatrix(const std::string& propertyName, double time = TiMe::Default()) const;
 
        Matrix getMatrix(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        Matrix getMatrix(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        Transform getTransform(const char* propertyName, double time = TiMe::Default()) const;
        Transform getTransform(const std::string& propertyName, double time = TiMe::Default()) const;
 
        Transform getTransform(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        Transform getTransform(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        PluginRefT<Plugin> getPlugin(const char* propertyName, double time = TiMe::Default()) const;
        PluginRefT<Plugin> getPlugin(const std::string& propertyName, double time = TiMe::Default()) const;
 
        PluginRefT<Plugin> getPlugin(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        PluginRefT<Plugin> getPlugin(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        std::string getString(const char* propertyName, double time = TiMe::Default()) const;
        std::string getString(const std::string& propertyName, double time = TiMe::Default()) const;
 
        std::string getString(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        std::string getString(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        IntList getIntList(const char* propertyName, double time = TiMe::Default()) const;
        IntList getIntList(const std::string& propertyName, double time = TiMe::Default()) const;
 
        IntList getIntList(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        IntList getIntList(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        FloatList getFloatList(const char* propertyName, double time = TiMe::Default()) const;
        FloatList getFloatList(const std::string& propertyName, double time = TiMe::Default()) const;
 
        FloatList getFloatList(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        FloatList getFloatList(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        ColorList getColorList(const char* propertyName, double time = TiMe::Default()) const;
        ColorList getColorList(const std::string& propertyName, double time = TiMe::Default()) const;
 
        ColorList getColorList(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        ColorList getColorList(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        VectorList getVectorList(const char* propertyName, double time = TiMe::Default()) const;
        VectorList getVectorList(const std::string& propertyName, double time = TiMe::Default()) const;
 
        VectorList getVectorList(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        VectorList getVectorList(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        TransformList getTransformList(const char* propertyName, double time = TiMe::Default()) const;
        TransformList getTransformList(const std::string& propertyName, double time = TiMe::Default()) const;
 
        TransformList getTransformList(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        TransformList getTransformList(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        ValueList getValueList(const char* propertyName, double time = TiMe::Default()) const;
        ValueList getValueList(const std::string& propertyName, double time = TiMe::Default()) const;
 
        ValueList getValueList(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        ValueList getValueList(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        StringList getStringList(const char* propertyName, double time = TiMe::Default()) const;
        StringList getStringList(const std::string& propertyName, double time = TiMe::Default()) const;
 
        StringList getStringList(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        StringList getStringList(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        PluginList getPluginList(const char* propertyName, double time = TiMe::Default()) const;
        PluginList getPluginList(const std::string& propertyName, double time = TiMe::Default()) const;
 
        PluginList getPluginList(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        PluginList getPluginList(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        Value getValue(const char* propertyName, double time = TiMe::Default()) const;
        Value getValue(const std::string& propertyName, double time = TiMe::Default()) const;
 
        Value getValue(const char* propertyName, bool& ok, double time = TiMe::Default()) const;
        Value getValue(const std::string& propertyName, bool& ok, double time = TiMe::Default()) const;
 
        bool isPropertyAnimated(const char* propertyName) const;
        bool isPropertyAnimated(const std::string& propertyName) const;
 
        PropertyState getPropertyState(const char* propertyName) const;
        PropertyState getPropertyState(const std::string& propertyName) const;
 
        std::vector<double> getKeyframeTimes(const char* propertyName) const;
        std::vector<double> getKeyframeTimes(const std::string& propertyName) const;
 
        std::vector<double> getKeyframeTimes(const char* propertyName, bool& ok) const;
        std::vector<double> getKeyframeTimes(const std::string& propertyName, bool& ok) const;
 
        bool setValue(const char* propertyName, const bool value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const bool value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const int value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const int value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const float value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const float value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const double value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const double value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const Color& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const Color& value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const AColor& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const AColor& value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const Vector& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const Vector& value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const Matrix& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const Matrix& value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const Transform& transform, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const Transform& transform, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const PluginRefT<Plugin>& pluginRef, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const PluginRefT<Plugin>& pluginRef, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const char* str, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const char* str, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const std::string& str, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const std::string& str, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const Value& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const Value& value, double time = TiMe::Default());
        bool setValue(const char* propertyName, Value&& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, Value&& value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const ValueList& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const ValueList& value, double time = TiMe::Default());
        bool setValue(const char* propertyName, ValueList&& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, ValueList&& value, double time = TiMe::Default());
        template<size_t count> bool setValue(const char* propertyName, const Value(&arr)[count], double time = TiMe::Default());
        template<size_t count> bool setValue(const std::string& propertyName, const Value(&arr)[count], double time = TiMe::Default());
        template<size_t count> bool setValue(const char* propertyName, Value(&&arr)[count], double time = TiMe::Default());
        template<size_t count> bool setValue(const std::string& propertyName, Value(&&arr)[count], double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const IntList& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const IntList& value, double time = TiMe::Default());
        bool setValue(const char* propertyName, IntList&& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, IntList&& value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const FloatList& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const FloatList& value, double time = TiMe::Default());
        bool setValue(const char* propertyName, FloatList&& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, FloatList&& value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const VectorList& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const VectorList& value, double time = TiMe::Default());
        bool setValue(const char* propertyName, VectorList&& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, VectorList&& value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const ColorList& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const ColorList& value, double time = TiMe::Default());
        bool setValue(const char* propertyName, ColorList&& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, ColorList&& value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const TransformList& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const TransformList& value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const StringList& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const StringList& value, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const PluginList& value, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const PluginList& value, double time = TiMe::Default());
 
        bool setArray(const char* propertyName, const int data[], size_t count, double time = TiMe::Default());
        bool setArray(const std::string& propertyName, const int data[], size_t count, double time = TiMe::Default());
 
        bool setArray(const char* propertyName, const float data[], size_t count, double time = TiMe::Default());
        bool setArray(const std::string& propertyName, const float data[], size_t count, double time = TiMe::Default());
 
        bool setArray(const char* propertyName, const double data[], size_t count, double time = TiMe::Default());
        bool setArray(const std::string& propertyName, const double data[], size_t count, double time = TiMe::Default());
 
        bool setArray(const char* propertyName, const Vector data[], size_t count, double time = TiMe::Default());
        bool setArray(const std::string& propertyName, const Vector data[], size_t count, double time = TiMe::Default());
 
        bool setArray(const char* propertyName, const Color data[], size_t count, double time = TiMe::Default());
        bool setArray(const std::string& propertyName, const Color data[], size_t count, double time = TiMe::Default());
 
        bool setArray(const char* propertyName, const Transform data[], size_t count, double time = TiMe::Default());
        bool setArray(const std::string& propertyName, const Transform data[], size_t count, double time = TiMe::Default());
 
        bool setArray(const char* propertyName, const std::string data[], size_t count, double time = TiMe::Default());
        bool setArray(const std::string& propertyName, const std::string data[], size_t count, double time = TiMe::Default());
        bool setArray(const char* propertyName, const char* const data[], size_t count, double time = TiMe::Default());
        bool setArray(const std::string& propertyName, const char* const data[], size_t count, double time = TiMe::Default());
 
        bool setArray(const char* propertyName, const Plugin plugins[], size_t count, double time = TiMe::Default());
        bool setArray(const std::string& propertyName, const Plugin plugins[], size_t count, double time = TiMe::Default());
 
        bool setArray(const char* propertyName, const Value values[], size_t count, double time = TiMe::Default());
        bool setArray(const std::string& propertyName, const Value values[], size_t count, double time = TiMe::Default());
 
        bool setArray(const char* propertyName, Value valuesToMove[], size_t count, double time = TiMe::Default());
        bool setArray(const std::string& propertyName, Value valuesToMove[], size_t count, double time = TiMe::Default());
 
        bool setValue(const char* propertyName, const void* data, size_t size, double time = TiMe::Default());
        bool setValue(const std::string& propertyName, const void* data, size_t size, double time = TiMe::Default());
 
        friend std::ostream& operator <<(std::ostream& stream, const Plugin& plugin);
 
#ifdef VRAY_SDK_INTEROPERABILITY
        bool setValueAsStringAtTime(const char* propertyName, const char* value, double time);
        bool setValueAsStringAtTime(const char* propertyName, const std::string& value, double time);
        bool setValueAsStringAtTime(const std::string& propertyName, const char* value, double time);
        bool setValueAsStringAtTime(const std::string& propertyName, const std::string& value, double time);
        bool setValueAtTime(const char* propertyName, const bool value, double time);
        bool setValueAtTime(const std::string& propertyName, const bool value, double time);
        bool setValueAtTime(const char* propertyName, const int value, double time);
        bool setValueAtTime(const std::string& propertyName, const int value, double time);
        bool setValueAtTime(const char* propertyName, const float value, double time);
        bool setValueAtTime(const std::string& propertyName, const float value, double time);
        bool setValueAtTime(const char* propertyName, const double value, double time);
        bool setValueAtTime(const std::string& propertyName, const double value, double time);
        bool setValueAtTime(const char* propertyName, const Color& value, double time);
        bool setValueAtTime(const std::string& propertyName, const Color& value, double time);
        bool setValueAtTime(const char* propertyName, const AColor& value, double time);
        bool setValueAtTime(const std::string& propertyName, const AColor& value, double time);
        bool setValueAtTime(const char* propertyName, const Vector& value, double time);
        bool setValueAtTime(const std::string& propertyName, const Vector& value, double time);
        bool setValueAtTime(const char* propertyName, const Matrix& value, double time);
        bool setValueAtTime(const std::string& propertyName, const Matrix& value, double time);
        bool setValueAtTime(const char* propertyName, const Transform& transform, double time);
        bool setValueAtTime(const std::string& propertyName, const Transform& transform, double time);
        bool setValueAtTime(const char* propertyName, const PluginRefT<Plugin>& pluginRef, double time);
        bool setValueAtTime(const std::string& propertyName, const PluginRefT<Plugin>& pluginRef, double time);
        bool setValueAtTime(const char* propertyName, const char* str, double time);
        bool setValueAtTime(const std::string& propertyName, const char* str, double time);
        bool setValueAtTime(const char* propertyName, const std::string& str, double time);
        bool setValueAtTime(const std::string& propertyName, const std::string& str, double time);
        bool setValueAtTime(const char* propertyName, const Value& value, double time);
        bool setValueAtTime(const std::string& propertyName, const Value& value, double time);
        bool setValueAtTime(const char* propertyName, const ValueList& value, double time);
        bool setValueAtTime(const std::string& propertyName, const ValueList& value, double time);
        bool setValueAtTime(const char* propertyName, const IntList& value, double time);
        bool setValueAtTime(const std::string& propertyName, const IntList& value, double time);
        bool setValueAtTime(const char* propertyName, const FloatList& value, double time);
        bool setValueAtTime(const std::string& propertyName, const FloatList& value, double time);
        bool setValueAtTime(const char* propertyName, const VectorList& value, double time);
        bool setValueAtTime(const std::string& propertyName, const VectorList& value, double time);
        bool setValueAtTime(const char* propertyName, const ColorList& value, double time);
        bool setValueAtTime(const std::string& propertyName, const ColorList& value, double time);
        bool setValueAtTime(const char* propertyName, const PluginList& value, double time);
        bool setValueAtTime(const std::string& propertyName, const PluginList& value, double time);
        bool setValueAtTime(const char* propertyName, const StringList& value, double time);
        bool setValueAtTime(const std::string& propertyName, const StringList& value, double time);
        bool setArrayAtTime(const char* propertyName, const int data[], size_t count, double time);
        bool setArrayAtTime(const std::string& propertyName, const int data[], size_t count, double time);
        bool setArrayAtTime(const char* propertyName, const float data[], size_t count, double time);
        bool setArrayAtTime(const std::string& propertyName, const float data[], size_t count, double time);
        bool setArrayAtTime(const char* propertyName, const double data[], size_t count, double time);
        bool setArrayAtTime(const std::string& propertyName, const double data[], size_t count, double time);
        bool setArrayAtTime(const char* propertyName, const Vector data[], size_t count, double time);
        bool setArrayAtTime(const std::string& propertyName, const Vector data[], size_t count, double time);
        bool setArrayAtTime(const char* propertyName, const Color data[], size_t count, double time);
        bool setArrayAtTime(const std::string& propertyName, const Color data[], size_t count, double time);
        bool setArrayAtTime(const char* propertyName, const Plugin data[], size_t count, double time);
        bool setArrayAtTime(const std::string& propertyName, const Plugin data[], size_t count, double time);
        bool setArrayAtTime(const char* propertyName, const std::string data[], size_t count, double time);
        bool setArrayAtTime(const std::string& propertyName, const std::string data[], size_t count, double time);
        bool setValueAtTime(const char* propertyName, const void* data, size_t size, double time);
        bool setValueAtTime(const std::string& propertyName, const void* data, size_t size, double time);
 
 
        VUtils::IntRefList getIntRefList(const char* propertyName);
        VUtils::IntRefList getIntRefList(const char* propertyName, bool& ok);
        VUtils::IntRefList getIntRefListAtTime(const char* propertyName, double time);
        VUtils::IntRefList getIntRefListAtTime(const char* propertyName, double time, bool& ok);
        VUtils::IntRefList getIntRefList(const std::string& propertyName);
        VUtils::IntRefList getIntRefList(const std::string& propertyName, bool& ok);
        VUtils::IntRefList getIntRefListAtTime(const std::string& propertyName, double time);
        VUtils::IntRefList getIntRefListAtTime(const std::string& propertyName, double time, bool& ok);
 
        VUtils::FloatRefList getFloatRefList(const char* propertyName);
        VUtils::FloatRefList getFloatRefList(const char* propertyName, bool& ok);
        VUtils::FloatRefList getFloatRefListAtTime(const char* propertyName, double time);
        VUtils::FloatRefList getFloatRefListAtTime(const char* propertyName, double time, bool& ok);
        VUtils::FloatRefList getFloatRefList(const std::string& propertyName);
        VUtils::FloatRefList getFloatRefList(const std::string& propertyName, bool& ok);
        VUtils::FloatRefList getFloatRefListAtTime(const std::string& propertyName, double time);
        VUtils::FloatRefList getFloatRefListAtTime(const std::string& propertyName, double time, bool& ok);
 
        VUtils::VectorRefList getVectorRefList(const char* propertyName);
        VUtils::VectorRefList getVectorRefList(const char* propertyName, bool& ok);
        VUtils::VectorRefList getVectorRefListAtTime(const char* propertyName, double time);
        VUtils::VectorRefList getVectorRefListAtTime(const char* propertyName, double time, bool& ok);
        VUtils::VectorRefList getVectorRefList(const std::string& propertyName);
        VUtils::VectorRefList getVectorRefList(const std::string& propertyName, bool& ok);
        VUtils::VectorRefList getVectorRefListAtTime(const std::string& propertyName, double time);
        VUtils::VectorRefList getVectorRefListAtTime(const std::string& propertyName, double time, bool& ok);
 
        VUtils::ColorRefList getColorRefList(const char* propertyName);
        VUtils::ColorRefList getColorRefList(const char* propertyName, bool& ok);
        VUtils::ColorRefList getColorRefListAtTime(const char* propertyName, double time);
        VUtils::ColorRefList getColorRefListAtTime(const char* propertyName, double time, bool& ok);
        VUtils::ColorRefList getColorRefList(const std::string& propertyName);
        VUtils::ColorRefList getColorRefList(const std::string& propertyName, bool& ok);
        VUtils::ColorRefList getColorRefListAtTime(const std::string& propertyName, double time);
        VUtils::ColorRefList getColorRefListAtTime(const std::string& propertyName, double time, bool& ok);
 
        VUtils::ValueRefList getValueRefList(const char* propertyName);
        VUtils::ValueRefList getValueRefList(const char* propertyName, bool& ok);
        VUtils::ValueRefList getValueRefListAtTime(const char* propertyName, double time);
        VUtils::ValueRefList getValueRefListAtTime(const char* propertyName, double time, bool& ok);
        VUtils::ValueRefList getValueRefList(const std::string& propertyName);
        VUtils::ValueRefList getValueRefList(const std::string& propertyName, bool& ok);
        VUtils::ValueRefList getValueRefListAtTime(const std::string& propertyName, double time);
        VUtils::ValueRefList getValueRefListAtTime(const std::string& propertyName, double time, bool& ok);
 
        VUtils::CharStringRefList getStringRefList(const char* propertyName);
        VUtils::CharStringRefList getStringRefList(const char* propertyName, bool& ok);
        VUtils::CharStringRefList getStringRefListAtTime(const char* propertyName, double time);
        VUtils::CharStringRefList getStringRefListAtTime(const char* propertyName, double time, bool& ok);
        VUtils::CharStringRefList getStringRefList(const std::string& propertyName);
        VUtils::CharStringRefList getStringRefList(const std::string& propertyName, bool& ok);
        VUtils::CharStringRefList getStringRefListAtTime(const std::string& propertyName, double time);
        VUtils::CharStringRefList getStringRefListAtTime(const std::string& propertyName, double time, bool& ok);
 
        VUtils::CharString getCharString(const char* propertyName);
        VUtils::CharString getCharString(const char* propertyName, bool& ok);
        VUtils::CharString getCharStringAtTime(const char* propertyName, double time);
        VUtils::CharString getCharStringAtTime(const char* propertyName, double time, bool& ok);
        VUtils::CharString getCharString(const std::string& propertyName);
        VUtils::CharString getCharString(const std::string& propertyName, bool& ok);
        VUtils::CharString getCharStringAtTime(const std::string& propertyName, double time);
        VUtils::CharString getCharStringAtTime(const std::string& propertyName, double time, bool& ok);
 
        bool setValue(const char* propertyName, const VUtils::IntRefList& intList);
        bool setValueAtTime(const char* propertyName, const VUtils::IntRefList& intList, double time);
        bool setValue(const std::string& propertyName, const VUtils::IntRefList& intList);
        bool setValueAtTime(const std::string& propertyName, const VUtils::IntRefList& intList, double time);
 
        bool setValue(const char* propertyName, const VUtils::FloatRefList& floatList);
        bool setValueAtTime(const char* propertyName, const VUtils::FloatRefList& floatList, double time);
        bool setValue(const std::string& propertyName, const VUtils::FloatRefList& floatList);
        bool setValueAtTime(const std::string& propertyName, const VUtils::FloatRefList& floatList, double time);
 
        bool setValue(const char* propertyName, const VUtils::VectorRefList& vectorList);
        bool setValueAtTime(const char* propertyName, const VUtils::VectorRefList& vectorList, double time);
        bool setValue(const std::string& propertyName, const VUtils::VectorRefList& vectorList);
        bool setValueAtTime(const std::string& propertyName, const VUtils::VectorRefList& vectorList, double time);
 
        bool setValue(const char* propertyName, const VUtils::ColorRefList& colorList);
        bool setValueAtTime(const char* propertyName, const VUtils::ColorRefList& colorList, double time);
        bool setValue(const std::string& propertyName, const VUtils::ColorRefList& colorList);
        bool setValueAtTime(const std::string& propertyName, const VUtils::ColorRefList& colorList, double time);
 
        bool setValue(const char* propertyName, const VUtils::TransformRefList& transformList);
        bool setValueAtTime(const char* propertyName, const VUtils::TransformRefList& transformList, double time);
        bool setValue(const std::string& propertyName, const VUtils::TransformRefList& transformList);
        bool setValueAtTime(const std::string& propertyName, const VUtils::TransformRefList& transformList, double time);
 
        bool setValue(const char* propertyName, const VUtils::CharStringRefList& stringList);
        bool setValueAtTime(const char* propertyName, const VUtils::CharStringRefList& stringList, double time);
        bool setValue(const std::string& propertyName, const VUtils::CharStringRefList& stringList);
        bool setValueAtTime(const std::string& propertyName, const VUtils::CharStringRefList& stringList, double time);
 
        bool setValue(const char* propertyName, const VUtils::ValueRefList& valueList);
        bool setValueAtTime(const char* propertyName, const VUtils::ValueRefList& valueList, double time);
        bool setValue(const std::string& propertyName, const VUtils::ValueRefList& valueList);
        bool setValueAtTime(const std::string& propertyName, const VUtils::ValueRefList& valueList, double time);
 
        bool setValue(const char* propertyName, const VUtils::CharString& str);
        bool setValueAtTime(const char* propertyName, const VUtils::CharString& str, double time);
        bool setValue(const std::string& propertyName, const VUtils::CharString& str);
        bool setValueAtTime(const std::string& propertyName, const VUtils::CharString& str, double time);
#endif // VRAY_SDK_INTEROPERABILITY
    };
 
    template<>
    class PluginRefT<Plugin> : public Plugin {
        friend class VRayRenderer;
        template<class T> friend class PluginRefT;
        friend class Value;
        friend class Internal::BinaryValueBuilder;
        friend class UVTextureSampler;
 
        int outPropIdx;
 
    protected:
        PluginRefT(VRayRenderer& renderer, InstanceId id, const char* outPropertyName);
        PluginRefT(VRayRenderer& renderer, InstanceId id, int outPropertyIndex) noexcept;
 
        int getOutputIndex() const noexcept { return outPropIdx; }
 
    public:
        PluginRefT() noexcept : outPropIdx(0) {}
 
        PluginRefT(const Plugin &plugin) noexcept : Plugin(plugin), outPropIdx(0) {}
 
        PluginRefT(const PluginRefT &plugin) noexcept : Plugin(plugin), outPropIdx(plugin.outPropIdx) {}
 
        template<class T>
        PluginRefT(const PluginRefT<T> &plugin) noexcept : Plugin(plugin), outPropIdx(plugin.outPropIdx) {}
 
        PluginRefT(const Plugin &plugin, const char* outPropertyName);
 
        template<class T>
        PluginRefT& operator=(const PluginRefT<T> &plugin) noexcept;
 
        template<class T>
        bool operator==(const PluginRefT<T> &plugin) const noexcept;
 
        bool operator==(const Plugin &plugin) const noexcept;
 
        template<class T> bool operator<(const PluginRefT<T>& plugin) const noexcept;
        template<class T> bool operator<=(const PluginRefT<T>& plugin) const noexcept;
        template<class T> bool operator>(const PluginRefT<T>& plugin) const noexcept;
        template<class T> bool operator>=(const PluginRefT<T>& plugin) const noexcept;
 
        void swap(PluginRefT &plugin) noexcept;
 
        bool isOutputValid() const noexcept {
            return outPropIdx >= 0;
        }
 
        const char* getOutputName() const;
 
        std::string toString() const;
 
        friend std::ostream& operator <<(std::ostream& stream, const PluginRefT& pluginRef);
    };
 
    typedef PluginRefT<Plugin> PluginRef;
 
    template<class T>
    class PluginRefT : public T {
        friend class VRayRenderer;
        friend class PluginRefT<Plugin>;
 
        int outPropIdx;
 
        PluginRefT(VRayRenderer& renderer, InstanceId id, const char* outPropertyName);
 
    public:
        PluginRefT() noexcept : outPropIdx(0) {}
 
        PluginRefT(const T &plugin) noexcept : T(plugin), outPropIdx(0) {}
 
        PluginRefT(const PluginRefT &plugin) noexcept : T(plugin), outPropIdx(plugin.outPropIdx) {}
 
        PluginRefT(const T &plugin, const char* outPropertyName);
 
        template<class X>
        PluginRefT(const PluginRefT<X> &plugin) noexcept : T(static_cast<X>(plugin)), outPropIdx(static_cast<PluginRef>(plugin).outPropIdx) {}
 
        template<class X>
        PluginRefT(const X &plugin) noexcept : T(static_cast<X>(plugin)), outPropIdx(0) {}
 
        PluginRefT& operator=(const PluginRefT &plugin) noexcept;
 
        bool operator==(const PluginRefT &plugin) const noexcept;
 
        bool operator==(const PluginRefT<Plugin> &plugin) const noexcept;
 
        bool operator==(const Plugin &plugin) const noexcept;
 
        bool operator<(const PluginRefT& plugin) const noexcept;
        bool operator<(const PluginRefT<Plugin>& plugin) const noexcept;
        bool operator<=(const PluginRefT& plugin) const noexcept;
        bool operator<=(const PluginRefT<Plugin>& plugin) const noexcept;
        bool operator>(const PluginRefT& plugin) const noexcept;
        bool operator>(const PluginRefT<Plugin>& plugin) const noexcept;
        bool operator>=(const PluginRefT& plugin) const noexcept;
        bool operator>=(const PluginRefT<Plugin>& plugin) const noexcept;
 
        void swap(PluginRefT &plugin) noexcept;
 
        bool isOutputValid() const noexcept {
            return outPropIdx >= 0;
        }
 
        const char* getOutputName() const;
 
        std::string toString() const;
 
        template<class U>
        friend std::ostream& operator <<(std::ostream& stream, const PluginRefT<U>& pluginRef);
    };
 
    class Value {
        friend class Internal::BinaryValueParser;
        friend class Internal::BinaryValueBuilder;
        friend struct Internal::MeshFileDataParser;
        friend std::ostream& operator<<(std::ostream& stream, const Value& value);
 
    protected:
        union {
            char val[VRAY_MAXIMUM4(sizeof(Transform), sizeof(std::string), sizeof(ValueList), sizeof(PluginRef))];
            void* alignment;
        };
        Type type;
 
        explicit Value(Type type) noexcept;
 
        void copyValue(const Value& value);
        void moveValue(Value&& value) noexcept;
        void swapValue(Value& value) noexcept;
        void destroyValue() noexcept;
        template<typename T, Type TYPE> void constructOnly_() noexcept;
        template<typename T, Type TYPE> void constructListWithIterators_(const T* first, const T* last);
        template<typename T, Type TYPE, bool noExcept> void constructWithValue_(T&& value) noexcept(noExcept);
        template<typename T, Type TYPE> void setToValue_(T&& value);
        template<typename T> T& interpretAs_();
        template<typename T> const T& interpretAs_() const;
        template<typename T, Type TYPE> T& viewAs_();
        template<typename T, Type TYPE> const T& viewAs_() const;
        template<typename T, Type TYPE> T getValue_() const;
        Value(VRayRenderer* renderer, InstanceId id, int outIdx) noexcept;
 
    public:
        Value() noexcept;
 
        Value(const Value& value);
        Value(Value&& value) noexcept;
 
        explicit Value(int value) noexcept;
        explicit Value(float value) noexcept;
        explicit Value(double value) noexcept;
        explicit Value(bool value) noexcept;
        explicit Value(const Color& value) noexcept;
        explicit Value(const AColor& value) noexcept;
        explicit Value(const Vector& value) noexcept;
        explicit Value(const Matrix& value) noexcept;
        explicit Value(const Transform& value) noexcept;
        explicit Value(const IntList& value);
        explicit Value(IntList&& value) noexcept;
        explicit Value(const FloatList& value);
        explicit Value(FloatList&& value) noexcept;
        explicit Value(const VectorList& value);
        explicit Value(VectorList&& value) noexcept;
        explicit Value(const ColorList& value);
        explicit Value(ColorList&& value) noexcept;
        explicit Value(TransformList&& value) noexcept;
        explicit Value(const TransformList& value);
        explicit Value(const ValueList& value);
        explicit Value(ValueList&& value) noexcept;
        explicit Value(const StringList& value);
        explicit Value(StringList&& value) noexcept;
        explicit Value(const PluginList& value);
        explicit Value(PluginList&& value) noexcept;
        explicit Value(const char* value);
        explicit Value(const std::string& value);
        explicit Value(std::string&& value) noexcept;
        explicit Value(const PluginRef& value) noexcept;
        Value(const int* values, size_t count);
        Value(const float* values, size_t count);
        Value(const Vector* values, size_t count);
        Value(const Color* values, size_t count);
        Value(const Transform* values, size_t count);
        Value(const Plugin* values, size_t count);
        Value(const Value* values, size_t count);
        template<size_t count> explicit Value(const int(&arr)[count]);
        template<size_t count> explicit Value(const float(&arr)[count]);
        template<size_t count> explicit Value(const Vector(&arr)[count]);
        template<size_t count> explicit Value(const Color(&arr)[count]);
        template<size_t count> explicit Value(const Transform(&arr)[count]);
        template<size_t count> explicit Value(const Plugin(&arr)[count]);
        template<size_t count> explicit Value(const Value(&arr)[count]);
        template<size_t count> explicit Value(Value(&&arr)[count]);
 
        static Value Unspecified() noexcept;
 
        ~Value() noexcept;
 
        void swap(Value& value) noexcept;
 
        Value& operator=(const Value& value);
        Value& operator=(Value&& value) noexcept;
        bool operator==(const Value& value) const noexcept;
        bool operator!=(const Value& value) const noexcept;
 
        Type getType() const noexcept;
 
        size_t getCount() const;
 
        bool isList() const;
 
        void set(int value);
 
        void set(float value);
 
        void set(double value);
 
        void set(bool value);
 
        void set(const Color& value);
 
        void set(const AColor& value);
 
        void set(const Vector& value);
 
        void set(const Matrix& value);
 
        void set(const Transform& value);
 
        void set(const Plugin& value);
 
        void set(const PluginRef& value);
 
        void set(const char* value);
 
        void set(const std::string& value);
 
        void set(std::string&& value);
 
        void set(const IntList& value);
 
        void set(IntList&& value);
 
        void set(const FloatList& value);
 
        void set(FloatList&& value);
 
        void set(const ColorList& value);
 
        void set(ColorList&& value);
 
        void set(const VectorList& value);
 
        void set(VectorList&& value);
 
        void set(const TransformList& value);
 
        void set(TransformList&& value);
 
        void set(const ValueList& value);
 
        void set(ValueList&& value);
 
        void set(const StringList& value);
 
        void set(StringList&& value);
 
        void set(const PluginList& value);
 
        void set(PluginList&& value);
 
        void set(const int* values, size_t count);
 
        void set(const float* values, size_t count);
 
        void set(const Vector* values, size_t count);
 
        void set(const Color* values, size_t count);
 
        void set(const Transform* values, size_t count);
 
        void set(const std::string* values, size_t count);
 
        template<typename T> T& as();
 
        template<typename T> const T& as() const;
 
        template<typename T> T get() const;
 
        int getInt() const;
 
        float getFloat() const;
 
        double getDouble() const;
 
        bool getBool() const;
 
        Color getColor() const;
 
        AColor getAColor() const;
 
        Vector getVector() const;
 
        Matrix getMatrix() const;
 
        Transform getTransform() const;
 
        IntList getIntList() const;
 
        FloatList getFloatList() const;
 
        ColorList getColorList() const;
 
        VectorList getVectorList() const;
 
        TransformList getTransformList() const;
 
        ValueList getValueList() const;
 
        StringList getStringList() const;
 
        PluginList getPluginList() const;
 
        std::string getString() const;
 
        Plugin getPlugin() const;
 
        PluginRef getPluginRef() const;
 
        Value& operator[](int i);
 
        const Value operator[](int i) const;
 
        bool isOK() const;
 
        bool isBad() const;
 
        const char* getStringType() const;
 
        std::string toString() const;
 
    private:
        std::ostream& toString(std::ostream& stream) const;
    };
 
    std::ostream& operator <<(std::ostream& stream, const IntList& list);
    std::ostream& operator <<(std::ostream& stream, const FloatList& list);
    std::ostream& operator <<(std::ostream& stream, const VectorList& list);
    std::ostream& operator <<(std::ostream& stream, const ColorList& list);
    std::ostream& operator <<(std::ostream& stream, const TransformList& list);
    std::ostream& operator <<(std::ostream& stream, const ValueList& list);
    std::ostream& operator <<(std::ostream& stream, const StringList& list);
    std::ostream& operator <<(std::ostream& stream, const PluginList& list);
    std::ostream& operator <<(std::ostream& stream, const Value& value);
 
    struct VRayExportSettings {
        bool compressed; 
        bool hexArrays; 
        bool hexArraysHash; 
        bool hexTransforms; 
        bool renderElementsSeparateFolders; 
        bool printHeader; 
        bool currentFrameOnly; 
        bool incremental; 
        bool appendFrameSuffix; 
        bool stripPaths; 
 
        double leftInterval;
        double rightInterval;
 
        std::vector<SubFileInfo> subFileInfos;
 
        std::vector<Plugin> pluginExportList;
 
        std::vector<std::string> additionalIncludeFiles;
 
        std::string hostAppString;
 
        bool vrdataExport;
        int vrdataSmallBufferSizeLimit;
        int vrdataFileSizeLimitMiB;
 
        int vrfilesExport;
        std::string sceneBasePath;
        int vrfilesComputeHashes;
 
        VRayExportSettings()
            : compressed(true)
            , hexArrays(true)
            , hexArraysHash(false)
            , hexTransforms(false)
            , renderElementsSeparateFolders(false)
            , printHeader(true)
            , currentFrameOnly(false)
            , incremental(false)
            , appendFrameSuffix(false)
            , stripPaths(false)
            , leftInterval(0.0)
            , rightInterval(0.0)
            , vrdataExport(false)
            , vrdataSmallBufferSizeLimit(2048)
            , vrdataFileSizeLimitMiB(0)
            , vrfilesExport(false)
            , vrfilesComputeHashes(false)
        {}
    };
 
    struct MeshFileData {
        ValueList vertices;              
        ValueList faces;                 
        ValueList normals;               
        ValueList faceNormals;           
        ValueList velocities;            
        ValueList faceMtlIDs;            
        ValueList mapChannels;           
        ValueList mapChNames;            
        ValueList shaderNames;           
        ValueList edgeVisibility;        
        ValueList hairVertices;          
        ValueList hairVerticesPerStrand; 
        ValueList hairWidths;            
        ValueList particleVertices;      
        ValueList particleWidths;        
    };
 
    struct PickedPluginInfo {
        Plugin plugin;
        double distance;
        int mtlID;
    };
 
    enum VFBMenuItemType {
        normal,
        checkbox
    };
 
    struct VFBContextMenuItem {
        int id; 
        VFBMenuItemType type; 
        int defaultValue; 
        bool enabled; 
        std::string text; 
    };
 
    struct RenderSizeParams {
        // Crop region
        int bmpWidth; 
        int bmpHeight; 
        float cropRgnLeft; 
        float cropRgnTop; 
        float cropRgnWidth; 
        float cropRgnHeight; 
 
        // Image size
        int imgWidth; 
        int imgHeight; 
 
        // Render region
        int rgnLeft; 
        int rgnTop; 
        int rgnWidth; 
        int rgnHeight; 
 
        enum RenderSizesBitmask {
            RS_NONE = 0,
            RS_IMG_SIZE = 1 << 0,
            RS_RENDER_RGN = 1 << 1,
            RS_CROP_RGN = 1 << 2
        };
        int bitmask; 
    };
 
    struct LightMixChange {
        Plugin plugin; 
        Color colorMult; 
        float intensityMult; 
        bool enabled; 
        mutable bool isApplied; 
    };
 
    namespace Util {
        enum ReasonsForAutoRename {
            NO_AUTO_RENAME = 0,
            NO_OVERWRITE_NO_EXISTING_PLUGIN_BUT_INVALID_PLUGIN_NAME,
            NO_OVERWRITE_BUT_EXISTING_PLUGIN_WITH_NAME,
            OVERWRITE_EXISTING_PLUGIN_WITH_NAME_BUT_DIFFERENT_TYPE
        };
 
        struct PreCreateCallbackOptions {
            std::string name;
 
            bool skipOnlyCurrentPlugin;
 
            bool skipAllSuccessorsOfCurrentPlugin;
 
            bool overwriteExistingPlugin;
 
            PreCreateCallbackOptions() {
                this->skipOnlyCurrentPlugin = false;
                this->skipAllSuccessorsOfCurrentPlugin = false;
                this->overwriteExistingPlugin = false;
            }
 
            PreCreateCallbackOptions(const char* name, const bool skipOnlyCurrentPlugin = false, const bool skipAllSuccessorsOfCurrentPlugin = false, const bool overwriteExistingPlugin = false) {
                if (name) {
                    this->name = name;
                }
                this->skipOnlyCurrentPlugin = skipOnlyCurrentPlugin;
                this->skipAllSuccessorsOfCurrentPlugin = skipAllSuccessorsOfCurrentPlugin;
                this->overwriteExistingPlugin = overwriteExistingPlugin;
            }
 
            PreCreateCallbackOptions(const std::string& name, const bool skipOnlyCurrentPlugin = false, const bool skipAllSuccessorsOfCurrentPlugin = false, const bool overwriteExistingPlugin = false) {
                if (!name.empty()) {
                    this->name = name;
                }
                this->skipOnlyCurrentPlugin = skipOnlyCurrentPlugin;
                this->skipAllSuccessorsOfCurrentPlugin = skipAllSuccessorsOfCurrentPlugin;
                this->overwriteExistingPlugin = overwriteExistingPlugin;
            }
        };
 
        int copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const std::vector<Plugin>& includeListOfPlugins, const std::vector<Plugin>& excludeListOfPlugins,
            Util::PreCreateCallbackOptions(*preCreateCallback)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(*postCreateCallback)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*),
            const void* userData = nullptr);
 
        template<class T, Util::PreCreateCallbackOptions(T::* TMethod)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(T::* TMethod1)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*)>
        int copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const std::vector<Plugin>& includeListOfPlugins, const std::vector<Plugin>& excludeListOfPlugins,
            T& obj,
            const void* userData = nullptr);
 
        int copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const char* pluginType,
            Util::PreCreateCallbackOptions(*preCreateCallback)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(*postCreateCallback)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*),
            const void* userData = nullptr);
 
        int copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const std::string& pluginType,
            Util::PreCreateCallbackOptions(*preCreateCallback)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(*postCreateCallback)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*),
            const void* userData = nullptr);
 
        int copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const PluginTypeId& pluginTypeId,
            Util::PreCreateCallbackOptions(*preCreateCallback)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(*postCreateCallback)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*),
            const void* userData = nullptr);
 
        template<class PluginType>
        int copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            Util::PreCreateCallbackOptions(*preCreateCallback)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(*postCreateCallback)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*),
            const void* userData = nullptr);
 
        template<class T, Util::PreCreateCallbackOptions(T::* TMethod)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(T::* TMethod1)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*)>
        int copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const char* pluginType,
            T& obj,
            const void* userData = nullptr);
 
        template<class T, Util::PreCreateCallbackOptions(T::* TMethod)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(T::* TMethod1)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*)>
        int copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const std::string& pluginType,
            T& obj,
            const void* userData = nullptr);
 
        template<class T, Util::PreCreateCallbackOptions(T::* TMethod)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(T::* TMethod1)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*)>
        int copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const PluginTypeId& pluginTypeId,
            T& obj,
            const void* userData = nullptr);
 
        template<class T, Util::PreCreateCallbackOptions(T::* TMethod)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(T::* TMethod1)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*),
            class PluginType>
        int copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            T& obj,
            const void* userData = nullptr);
    }
 
    class VRayRenderer {
        friend class Plugin;
        template<class P> friend class PluginRefT;
        friend class PluginMeta;
        friend class PropertyMeta;
        friend class PropertyRuntimeMeta;
        friend class UIGuides;
        friend class RenderElement;
        friend class RenderElements;
        friend class LocalPng;
        friend class LocalJpeg;
        friend class LocalBmp;
        friend class Internal::Access;
 
        friend int Util::copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const std::vector<Plugin>& includeListOfPlugins, const std::vector<Plugin>& excludeListOfPlugins,
            Util::PreCreateCallbackOptions(*preCreateCallback)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(*postCreateCallback)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*),
            const void* userData);
 
        template<class T, Util::PreCreateCallbackOptions(T::* TMethod)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(T::* TMethod1)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*)>
        friend int Util::copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const std::vector<Plugin>& includeListOfPlugins, const std::vector<Plugin>& excludeListOfPlugins,
            T& obj,
            const void* userData);
 
        friend int Util::copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const char* pluginType,
            Util::PreCreateCallbackOptions(*preCreateCallback)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(*postCreateCallback)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*),
            const void* userData);
 
        friend int Util::copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const std::string& pluginType,
            Util::PreCreateCallbackOptions(*preCreateCallback)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(*postCreateCallback)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*),
            const void* userData);
 
        friend int Util::copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const PluginTypeId& pluginTypeId,
            Util::PreCreateCallbackOptions(*preCreateCallback)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(*postCreateCallback)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*),
            const void* userData);
 
        template<class PluginType>
        friend int Util::copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            Util::PreCreateCallbackOptions(*preCreateCallback)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(*postCreateCallback)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*),
            const void* userData);
 
        template<class T, Util::PreCreateCallbackOptions(T::* TMethod)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(T::* TMethod1)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*)>
        friend int Util::copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const char* pluginType,
            T& obj,
            const void* userData);
 
        template<class T, Util::PreCreateCallbackOptions(T::* TMethod)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(T::* TMethod1)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*)>
        friend int Util::copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const std::string& pluginType,
            T& obj,
            const void* userData);
 
        template<class T, Util::PreCreateCallbackOptions(T::* TMethod)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(T::* TMethod1)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*)>
        friend int Util::copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            const PluginTypeId& pluginTypeId,
            T& obj,
            const void* userData);
 
        template<class T, Util::PreCreateCallbackOptions(T::* TMethod)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
            void(T::* TMethod1)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*),
            class PluginType>
        friend int Util::copyPlugins(
            VRayRenderer& srcRenderer, VRayRenderer& dstRenderer,
            T& obj,
            const void* userData);
 
        // We need to keep these methods private and they need also access to protected renderer methods
        static void pluginCopyParamsPreCreateCallback(const InstanceId srcPluginID, Internal::PreCreateCallbackOptions* opts, void* info);
        static void pluginCopyParamsPostCreateCallback(
            const InstanceId dstPluginID, const char* srcPluginName,
            Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName,
            void* info);
 
        class PluginCopyParamsCreateDelegate {
            typedef Util::PreCreateCallbackOptions(*tstubPre)(void* pobject, VRayRenderer& dstRenderer, Plugin& srcPlugin, void* userObj);
            typedef Util::PreCreateCallbackOptions(*tfuncPre)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void* userObj);
 
            typedef void (*tstubPost)(void* pobject, Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void* userObj);
            typedef void (*tfuncPost)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void* userObj);
 
            void* pobject;
            union tmethodPre {
                tstubPre pstubPre;
                tfuncPre pfuncPre;
                tmethodPre() : pstubPre() {}
                tmethodPre(tstubPre pstubPre) : pstubPre(pstubPre) {}
                tmethodPre(tfuncPre pfuncPre) : pfuncPre(pfuncPre) {}
            } pmethodPre;
 
            union tmethodPost {
                tstubPost pstubPost;
                tfuncPost pfuncPost;
                tmethodPost() : pstubPost() {}
                tmethodPost(tstubPost pstubPost) : pstubPost(pstubPost) {}
                tmethodPost(tfuncPost pfuncPost) : pfuncPost(pfuncPost) {}
            } pmethodPost;
 
            void* puserObj;
            VRayRenderer* srcRenderer;
            VRayRenderer* dstRenderer;
 
            template <class T, Util::PreCreateCallbackOptions(T::* PreCreateTMethod)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void* puserObj)>
            static Util::PreCreateCallbackOptions method_stubPre(void* pobject, VRayRenderer& dstRenderer, Plugin& srcPlugin, void* puserObj) {
                T* p = static_cast<T*>(pobject);
                return (p->*PreCreateTMethod)(dstRenderer, srcPlugin, puserObj);
            }
 
            template <class T, void(T::* PostCreateTMethod)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void* puserObj)>
            static void method_stubPost(void* pobject, Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void* puserObj) {
                T* p = static_cast<T*>(pobject);
                (p->*PostCreateTMethod)(dstPlugin, srcPluginName, autoRenamedResult, preCreateCallbackReturnedName, puserObj);
            }
 
            PluginCopyParamsCreateDelegate(tfuncPre pfuncPre, tfuncPost pfuncPost, void* puserObj, VRayRenderer* srcRenderer, VRayRenderer* dstRenderer) :
                pobject(), pmethodPre(pfuncPre), pmethodPost(pfuncPost), puserObj(puserObj), srcRenderer(srcRenderer), dstRenderer(dstRenderer) {}
            PluginCopyParamsCreateDelegate(void* pobject, tstubPre pstubPre, tstubPost pstubPost, void* puserObj, VRayRenderer* srcRenderer, VRayRenderer* dstRenderer) :
                pobject(pobject), pmethodPre(pstubPre), pmethodPost(pstubPost), puserObj(puserObj), srcRenderer(srcRenderer), dstRenderer(dstRenderer) {}
 
        public:
            template <class T, Util::PreCreateCallbackOptions(T::* PreCreateTMethod)(VRayRenderer& dstRenderer, Plugin& srcPlugin, void*),
                void(T::* PostCreateTMethod)(Plugin& dstPlugin, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName, void*)>
            static PluginCopyParamsCreateDelegate from_method(T* pobject, void* puserObj, VRayRenderer* srcRenderer, VRayRenderer* dstRenderer) {
                return PluginCopyParamsCreateDelegate(pobject, &method_stubPre<T, PreCreateTMethod>, &method_stubPost<T, PostCreateTMethod>, puserObj, srcRenderer, dstRenderer);
            }
 
            static PluginCopyParamsCreateDelegate from_function(tfuncPre pfuncPre, tfuncPost pfuncPost, void* puserObj, VRayRenderer* srcRenderer, VRayRenderer* dstRenderer) {
                return PluginCopyParamsCreateDelegate(pfuncPre, pfuncPost, puserObj, srcRenderer, dstRenderer);
            }
 
            Util::PreCreateCallbackOptions operator()(const InstanceId& srcPluginID) const {
                Plugin srcPlugin = srcRenderer->getPlugin_internal(srcPluginID);
                return pobject ? (*pmethodPre.pstubPre)(pobject, *dstRenderer, srcPlugin, puserObj) : (*pmethodPre.pfuncPre)(*dstRenderer, srcPlugin, puserObj);
            }
 
            void operator()(const InstanceId& dstPluginID, const char* srcPluginName, Util::ReasonsForAutoRename autoRenamedResult, const char* preCreateCallbackReturnedName) const {
                Plugin dstPlugin = dstRenderer->getPlugin_internal(dstPluginID);
                pobject ? (*pmethodPost.pstubPost)(pobject, dstPlugin, srcPluginName, autoRenamedResult, preCreateCallbackReturnedName, puserObj) :
                    (*pmethodPost.pfuncPost)(dstPlugin, srcPluginName, autoRenamedResult, preCreateCallbackReturnedName, puserObj);
            }
        };
 
        VRayRenderer(const VRayRenderer&);
        VRayRenderer& operator=(const VRayRenderer&);
 
        class PluginFilterDelegate {
            typedef bool (*tstub)(void* pobject, VRayRenderer& renderer, const char* type, std::string& name, void* userObj);
            typedef bool (*tfunc)(VRayRenderer& renderer, const char* type, std::string& name, void* userObj);
 
            void *pobject;
            union tmethod {
                tstub pstub;
                tfunc pfunc;
                tmethod() : pstub() {}
                tmethod(tstub pstub) : pstub(pstub) {}
                tmethod(tfunc pfunc) : pfunc(pfunc) {}
            } pmethod;
            void *puserObj;
            VRayRenderer &renderer;
 
            template <class T, bool (T::*TMethod)(VRayRenderer&, const char* type, std::string& name, void* puserObj)>
            static bool method_stub(void* pobject, VRayRenderer& renderer, const char* type, std::string& name, void *puserObj) {
                T* p = static_cast<T*>(pobject);
                return (p->*TMethod)(renderer, type, name, puserObj);
            }
 
            PluginFilterDelegate(tfunc pfunc, void *puserObj, VRayRenderer& renderer) : pobject(), pmethod(pfunc), puserObj(puserObj), renderer(renderer) {}
            PluginFilterDelegate(void *pobject, tstub pstub, void *puserObj, VRayRenderer& renderer) : pobject(pobject), pmethod(pstub), puserObj(puserObj), renderer(renderer) {}
 
        public:
            template <class T, bool (T::*TMethod)(VRayRenderer&, const char*, std::string&, void*)>
            static PluginFilterDelegate from_method(T* pobject, void *puserObj, VRayRenderer& renderer) {
                return PluginFilterDelegate(pobject, &method_stub<T, TMethod>, puserObj, renderer);
            }
 
            static PluginFilterDelegate from_function(tfunc pfunc, void *puserObj, VRayRenderer& renderer) {
                return PluginFilterDelegate(pfunc, puserObj, renderer);
            }
 
            bool operator()(const char* type, std::string& name) const {
                return pobject ? (*pmethod.pstub)(pobject, renderer, type, name, puserObj) : (*pmethod.pfunc)(renderer, type, name, puserObj);
            }
        };
 
        template<class T, void (T::*TMethod)(VRayRenderer&, RendererState oldState, RendererState newState, double instant, void* userData)>
        static void stateChangedCallbackT(const Internal::StateChangedParams* params);
        static void stateChangedCallback(const Internal::StateChangedParams* params);
 
        template<class T, void (T::*TMethod)(VRayRenderer&, double instant, void* userData)>
        static void rendererCloseCallbackT(const Internal::CallbackParamsBase* params);
        static void rendererCloseCallback(const Internal::CallbackParamsBase* params);
 
        template<class T, void (T::*TMethod)(VRayRenderer&, VRayImage* img, unsigned long long changeIndex, ImagePassType pass, double instant, void* userData)>
        static void progressiveImageUpdatedCallbackT(const Internal::ImageUpdatedParams* params);
        static void progressiveImageUpdatedCallback(const Internal::ImageUpdatedParams* params);
 
        template<class T, void (T::*TMethod)(VRayRenderer& renderer, const char* msg, MessageLevel level, double instant, void* userData)>
        static void logMessageCallbackT(const Internal::LogMessageParams* params);
        static void logMessageCallback(const Internal::LogMessageParams* params);
 
        template<class T, void (T::*TMethod)(VRayRenderer& renderer, const char* msg, int errorCode, LicenseUserStatus userStatus, double instant, void* userData)>
        static void licenseErrorCallbackT(const Internal::LicenseErrorParams* params);
        static void licenseErrorCallback(const Internal::LicenseErrorParams* params);
 
        template<class T, void (T::*TMethod)(VRayRenderer& renderer, int x, int y, int width, int height, const char* host, ImagePassType pass, double instant, void* userData)>
        static void bucketInitCallbackT(const Internal::BucketInitParams* params);
        static void bucketInitCallback(const Internal::BucketInitParams* params);
 
        template<class T, void (T::*TMethod)(VRayRenderer& renderer, int x, int y, const char* host, VRayImage* image, ImagePassType pass, double instant, void* userData)>
        static void bucketReadyCallbackT(const Internal::BucketReadyParams* params);
        template<class T, void (T::*TMethod)(VRayRenderer& renderer, int x, int y, int width, int height, const char* host, ImagePassType pass, double instant, void* userData)>
        static void bucketReadyCallback1T(const Internal::BucketReadyParams* params);
        static void bucketReadyCallback(const Internal::BucketReadyParams* params);
        static void bucketReadyCallback1(const Internal::BucketReadyParams* params);
 
        template<class T, void (T::*TMethod)(VRayRenderer&, const char* msg, int elementNumber, int elementsCount, double instant, void* userData)>
        static void progressCallbackT(const Internal::ProgressParams* params);
        static void progressCallback(const Internal::ProgressParams* params);
 
        template<class T, void (T::*TMethod)(VRayRenderer&, const char* propName, double instant, void* userData)>
        static void renderViewChangedCallbackT(const Internal::RenderViewChangedParams* params);
        static void renderViewChangedCallback(const Internal::RenderViewChangedParams* params);
 
        template<class T, void (T::*TMethod)(VRayRenderer&, bool isRendering, double instant, void* userData)>
        static void vfbRenderLastCallbackT(const Internal::RenderLastParams* params);
        static void vfbRenderLastCallback(const Internal::RenderLastParams* params);
 
        template<class T, void (T::*TMethod)(VRayRenderer&, const char* hostName, double instant, void* userData)>
        static void drHostConnectedCallbackT(const Internal::ConnectParams* params);
        static void drHostConnectedCallback(const Internal::ConnectParams* params);
 
        template<class T, void(T::*TMethod)(VRayRenderer&, int commandId, int x, int y, void* userData)>
        static void vfbContextMenuSelectedCallbackT(const Internal::VFBContextMenuSelectedParams* params);
        static void vfbContextMenuSelectedCallback(const Internal::VFBContextMenuSelectedParams* params);
 
        static char* pluginFilterCallback(const char* pluginType, const char* pluginName, void* userObject);
        static void deleteTempStringCallback(char*, size_t, std::string* str);
 
 
        template<class T, void(T::*TMethod)(VRayRenderer&, VRayImage* img, void* userData)>
        static void manualDenoiseCallbackT(VRayImage* img, void* info);
        static void manualDenoiseCallback(VRayImage* img, void* info);
 
        template<class T, int(T::*TMethod)(VRayRenderer&, const std::vector<LightMixChange>& lightMixChanges, double instant, void* userData)>
        static int lightMixTransferToSceneCallbackT(Internal::LightMixCallbackParams* params);
        static int lightMixTransferToSceneCallback(Internal::LightMixCallbackParams* params);
        void transferToScenePreCallback(std::vector<LightMixChange>& changes, const Internal::LightMixCallbackParams* params);
        void transferToScenePostCallback(const std::vector<LightMixChange>& changes, Internal::LightMixCallbackParams* params);
 
        template<class T, int(T::*TMethod)(VRayRenderer&, const std::vector<std::string>& fileList, double instant, void* userData)>
        static int uploadToCollaborationCallbackT(Internal::UploadToCollaborationParams* params);
        static int uploadToCollaborationCallback(Internal::UploadToCollaborationParams* params);
        void uploadToCollaborationPreCallback(std::vector<std::string>& fileList, const Internal::UploadToCollaborationParams* params);
 
        template<class T, int(T::*TMethod)(VRayRenderer&, const std::vector<std::string>& fileList, double instant, void* userData)>
        static int enhanceOnCollaborationCallbackT(Internal::UploadToCollaborationParams* params);
        static int enhanceOnCollaborationCallback(Internal::UploadToCollaborationParams* params);
        void enhanceOnCollaborationPreCallback(std::vector<std::string>& fileList, const Internal::UploadToCollaborationParams* params);
 
        template<class T, void (T::* TMethod)(VRayRenderer&, int enabled, int mode, int selectionLocked, double instant, void* userData)>
        static void debugShadingCallbackT(const Internal::DebugShadingCallbackParams* params);
        static void debugShadingCallback(const Internal::DebugShadingCallbackParams* params);
 
        template<class T, void(T::*TMethod)(VRayRenderer&, const std::string &outputFile, int fileType, double instant, void* userData)>
        static void vrayProfilerWriteCallbackT(const Internal::VRayProfilerWriteParams* params);
        static void vrayProfilerWriteCallback(const Internal::VRayProfilerWriteParams* params);
 
        template<class T, bool (T::*TMethod)(VRayRenderer&, VFBRenderElementType type, double instant, void* userData)>
        static int vfbAddRenderElementToSceneT(const Internal::AddRenderElementToSceneParams* params);
        static int vfbAddRenderElementToScene(const Internal::AddRenderElementToSceneParams* params);
 
        template<class T, void (T::*TMethod)(VRayRenderer&, VFBMouseButton button, int x, int y, bool ctrl, bool shift, void* userData)>
        static void vfbClickT(const Internal::VFBClickParams* params);
        static void vfbClick(const Internal::VFBClickParams* params);
 
    public:
        typedef void* InstanceHandleType;
 
        class VFB {
            friend class UVTextureSampler;
 
            Internal::VRayRendererNative *rendererNative;
            bool autoCommit;
            friend class VRayRenderer;
            friend class LayerManager;
            friend class HistoryManager;
            friend class ToolbarManager;
            VFB() : autoCommit(true),
                layerManager(*this),
                historyManager(*this),
                toolbarManager(*this) {}
            VFB(const VFB&);
            VFB& operator=(const VFB&);
        public:
            void show(bool show, bool setFocus = true);
 
            bool isShown() const;
 
            void setAlwaysOnTop(bool set);
 
            void enableInteractivity(bool enable = true);
 
            bool isInteractivityEnabled() const;
 
            void enableConfirmation(bool enable = true);
 
            bool isConfirmationEnabled() const;
 
            void setPosition(int x, int y);
 
            void setPositionAndSize(int x, int y, int w, int h);
 
            bool getPositionAndSize(int& x, int& y, int& w, int& h) const;
 
            VFBState* getState(size_t& dataSize, bool includeMain = true, bool includeHistory = true) const;
 
            void setState(const void* vfbStateData, size_t dataSize, bool setMain = true, bool setHistory = true);
 
            std::string getSettings() const;
 
            int setSettings(const char *json);
 
            std::string getLayers() const;
 
            int setLayers(const char *json);
 
            // Forward declaration.
            class LayerManager;
 
            class Layer {
                friend class LayerManager;
            public:
 
                int getIntegerID() const;
 
                LayerManager& getLayerManager() const;
 
                bool isValid() const;
 
                int getUniqueTreePathID(std::string& treePathUID) const;
 
                int getClass(std::string& layerClass) const;
 
                int getEnabled(bool& isEnabled) const;
                int setEnabled(const bool enabled);
 
                int canDelete(bool& isDeletable) const;
 
                Layer getParent() const;
 
                int getUserName(std::string& layerName) const;
 
                int setUserName(const char* layerName);
                int setUserName(const std::string& layerName);
 
                int getChildrenCount(int& childrenCount) const;
                std::vector<Layer> getChildren() const;
                Layer getChild(const int childIndex) const;
 
                int getOpacity(float& opacity) const;
                int setOpacity(const float opacity) const;
 
                int canBlend(bool& isBlendable) const;
                int getBlendMode(VFBLayerProperty::BlendMode& blendMode) const;
                int setBlendMode(const VFBLayerProperty::BlendMode blendMode) const;
 
                int getLayerPropertiesCount(int& propsCount) const;
                int getLayerPropertyNames(std::vector<std::string>& propNames) const;
 
                int getLayerPropertyDisplayName(const char* propName, std::string& displayName) const;
                int getLayerPropertyDisplayName(const std::string& propName, std::string& displayName) const;
 
                int resetLayerPropertyToDefault(const char* propName);
                int resetLayerPropertyToDefault(const std::string& propName);
 
                int getLayerPropertiesReadOnly(std::vector<std::string>& values) const;
 
                int isLayerPropertyReadOnly(const char* propName, bool& isReadOnly) const;
                int isLayerPropertyReadOnly(const std::string& propName, bool& isReadOnly) const;
 
                int getLayerPropertiesOfType(const VFBLayerProperty::Type type, std::vector<std::string>& values) const;
 
                int getLayerPropertyType(const char* propName, VFBLayerProperty::Type& type) const;
                int getLayerPropertyType(const std::string& propName, VFBLayerProperty::Type& type) const;
 
 
                int getLayerPropertyFlags(const char* propName, int& flags) const;
                int getLayerPropertyFlags(const std::string& propName, int& flags) const;
 
 
                int getLayerPropertyBoolValue(const char* propName, bool& value) const;
                int getLayerPropertyBoolValue(const std::string& propName, bool& value) const;
 
                int setLayerPropertyBoolValue(const char* propName, const bool value);
                int setLayerPropertyBoolValue(const std::string& propName, const bool value);
 
                int getLayerPropertyIntValue(const char* propName, int& value) const;
                int getLayerPropertyIntValue(const std::string& propName, int& value) const;
 
                int setLayerPropertyIntValue(const char* propName, const int value);
                int setLayerPropertyIntValue(const std::string& propName, const int value);
 
 
                int getLayerEnumProperties(std::vector<std::string>& values) const;
 
                int getLayerPropertyIntEnumValues(const char* propName, std::vector<std::string>& values) const;
                int getLayerPropertyIntEnumValues(const std::string& propName, std::vector<std::string>& values) const;
 
                int getLayerPropertyIntEnumLabel(const char* propName, std::string& valueLabel) const;
                int getLayerPropertyIntEnumLabel(const std::string& propName, std::string& valueLabel) const;
 
                int setLayerPropertyIntByEnumLabel(const char* propName, const char* label);
                int setLayerPropertyIntByEnumLabel(const char* propName, const std::string& label);
                int setLayerPropertyIntByEnumLabel(const std::string& propName, const char* label);
                int setLayerPropertyIntByEnumLabel(const std::string& propName, const std::string& label);
 
                int getLayerPropertyIntEnumIndex(const char* propName, int& enumIndex) const;
                int getLayerPropertyIntEnumIndex(const std::string& propName, int& enumIndex) const;
 
                int setLayerPropertyIntByEnumIndex(const char* propName, const int enumIndex);
                int setLayerPropertyIntByEnumIndex(const std::string& propName, const int enumIndex);
 
 
                int getLayerPropertyFloatValue(const char* propName, float& value) const;
                int getLayerPropertyFloatValue(const std::string& propName, float& value) const;
 
                int setLayerPropertyFloatValue(const char* propName, const float value);
                int setLayerPropertyFloatValue(const std::string& propName, const float value);
 
                int getLayerPropertyStringValue(const char* propName, std::string& value) const;
                int getLayerPropertyStringValue(const std::string& propName, std::string& value) const;
 
                int setLayerPropertyStringValue(const char* propName, const char* value);
                int setLayerPropertyStringValue(const std::string& propName, const char* value);
 
                int getLayerPropertyColorValue(const char* propName, Color& value) const;
                int getLayerPropertyColorValue(const std::string& propName, Color& value) const;
 
                int setLayerPropertyColorValue(const char* propName, const Color& value);
                int setLayerPropertyColorValue(const std::string& propName, const Color& value);
 
                int getLayerPropertyStampRawStringValue(const char* propName, std::string& value) const;
                int getLayerPropertyStampRawStringValue(const std::string& propName, std::string& value) const;
 
                int setLayerPropertyStampRawStringValue(const char* propName, const char* value);
                int setLayerPropertyStampRawStringValue(const char* propName, const std::string& value);
                int setLayerPropertyStampRawStringValue(const std::string& propName, const char* value);
                int setLayerPropertyStampRawStringValue(const std::string& propName, const std::string& value);
 
                int getLayerPropertyStampFontDescValue(const char* propName, VFBLayerProperty::StampFontDesc& value) const;
                int getLayerPropertyStampFontDescValue(const std::string& propName, VFBLayerProperty::StampFontDesc& value) const;
 
                int setLayerPropertyStampFontDescValue(const char* propName, const VFBLayerProperty::StampFontDesc& value);
                int setLayerPropertyStampFontDescValue(const std::string& propName, const VFBLayerProperty::StampFontDesc& value);
 
                Layer() = delete;
 
                Layer& operator=(const Layer& rhs) {
                    if (this != &rhs) {
                        if (&myLayerManager == &rhs.myLayerManager) {
                            layerUID = rhs.layerUID;
                        }
                    }
                    return *this;
                }
 
                bool operator==(const Layer& rhs) const {
                    return layerUID == rhs.layerUID && &myLayerManager == &rhs.myLayerManager;
                }
            protected:
                Layer(const int& layerUID, const LayerManager& layerManager) :
                    layerUID(layerUID), myLayerManager(layerManager){
                };
 
                void invalidateLayer() const {
                    layerUID = NO_LAYER_ID;
                }
            private:
                const LayerManager& myLayerManager;
                mutable LayerUID layerUID;
            };
 
            class LayerManager {
                friend class Layer;
                friend class VFB;
            public:
 
                VFB& getVFB() const;
 
                void reset();
 
                int getLayersCount() const;
 
                std::vector<Layer> getAllLayersAsLayerObjects() const;
 
                std::vector<std::string> getCreatableLayerClasses() const;
 
                int loadAllLayers(const char* filename);
                int loadAllLayers(const std::string& filename);
 
                int saveAllLayers(const char* filename) const;
                int saveAllLayers(const std::string& filename) const;
 
                int bakeLayersToLUT(const char* filename) const;
                int bakeLayersToLUT(const std::string& filename) const;
 
                std::string getAllLayers() const;
 
                int setAllLayers(const char* json);
                int setAllLayers(const std::string& json);
 
                Layer createLayer(const char* layerClass, const Layer& parent);
                Layer createLayer(const std::string& layerClass, const Layer& parent);
 
                int deleteLayer(Layer& layer);
 
 
                Layer getRootLayer() const;
                Layer getDisplayCorrectionLayer() const;
                Layer getStampLayer() const;
                Layer getSourceLayer() const;
                Layer getDenoiserLayer() const;
                Layer getSharpenBlurLayer() const;
                Layer getLensEffectsLayer() const;
                Layer getLightMixLayer() const;
 
 
                std::vector<Layer> findAllLayersWithLayerClass(const char* layerClass) const;
                std::vector<Layer> findAllLayersWithLayerClass(const std::string& layerClass) const;
 
                std::vector<Layer> findAllLayersWithUserName(const char* userName) const;
                std::vector<Layer> findAllLayersWithUserName(const std::string& userName) const;
 
                std::vector<Layer> getAllEnabledLayers() const;
 
                std::vector<Layer> getAllBlendableLayers() const;
 
 
                void lockLayers();
 
                int tryLockLayers();
 
                void unlockLayers();
 
                LayerManager() = delete;
 
                LayerManager(const LayerManager& rhs) = delete;
 
                LayerManager& operator=(const LayerManager& rhs) = delete;
 
                ~LayerManager() {
                    void* original = errMsgHandle.exchange(nullptr);
                    if (original) {
                        Internal::releaseCharString(&original);
                    }
                }
 
                std::string getLastError() const {
                    void* original = (void*)errMsgHandle;
                    return Internal::getCharStringContent(&original);
                }
            protected:
                LayerManager(VRayRenderer::VFB& vfb) : myVfb(vfb), errMsgHandle(nullptr) {}
 
                Internal::VRayRendererNative* getNativeRenderer() const {
                    return myVfb.rendererNative;
                }
 
#ifndef VRAY_NOTHROW
                void handleError(void*& errorMsgHandlePtr, const bool throwException = true) const {
                    const char* errstr = nullptr;
                    if (throwException) {
                        errstr = Internal::getCharStringContent(&errorMsgHandlePtr);
                    }
                    void* oldErr = errMsgHandle.exchange(errorMsgHandlePtr);
                    Internal::releaseCharString(&oldErr);
                    if (throwException) {
                        throw VFBLayerErr(errstr);
                    }
                }
#else
                void handleError(void*& errorMsgHandlePtr, const bool throwException = false) const {
                    void* oldErr = errMsgHandle.exchange(errorMsgHandlePtr);
                    Internal::releaseCharString(&oldErr);
                }
#endif
 
                void getLayerListAndReleaseIDs(std::vector<Layer>& layers, LayerUID*& layerIDs, const int len) const {
                    layers.reserve(len);
                    for (int i = 0; i < len; i++) {
                        layers.push_back(Layer(layerIDs[i], *this));
                    }
                    Internal::C_memory_free(layerIDs);
                }
 
                static void getStringListAndReleaseCharStars(std::vector<std::string>& words, char*& cStyleWords, const int len) {
                    words.reserve(len);
                    const char* curr = cStyleWords;
                    for (int i = 0; i < len; i++) {
                        words.emplace_back(curr);
                        curr += words[i].size() + 1;
                    }
                    Internal::C_memory_free(cStyleWords);
                }
 
                Layer getCommonLayer(int (*layerLoader)(Internal::VRayRendererNative* renderer, LayerUID* layerID, void** errorMsgHandlePtr)) const {
                    LayerUID layerID = NO_LAYER_ID;
                    void* errorMsgHandlePtr = nullptr;
                    int err = layerLoader(myVfb.rendererNative, &layerID, &errorMsgHandlePtr);
                    if (err != 0) {
                        handleError(errorMsgHandlePtr);
                        return Layer(NO_LAYER_ID, *this);
                    }
                    return Layer(layerID, *this);
                }
 
            private:
                const VRayRenderer::VFB& myVfb;
                mutable std::atomic<void*> errMsgHandle;
            } layerManager;
 
            class HistoryManager {
                friend class VFB;
            public:
                bool getWindowStatus() const;
 
                void setWindowStatus(const bool status);
 
                bool getPanelStatus() const;
 
                void setPanelStatus(const bool status);
 
                int getMaximumSize() const;
 
                void setMaximumSize(const int maxSize);
 
                std::string getTemporaryPath() const;
 
                void setTemporaryPath(const char* path);
                void setTemporaryPath(const std::string& path);
 
                HistoryManager() = delete;
 
                HistoryManager(const HistoryManager& rhs) = delete;
 
                HistoryManager& operator=(const HistoryManager& rhs) = delete;
            protected:
                HistoryManager(VRayRenderer::VFB& vfb) : myVfb(vfb) {}
 
                Internal::VRayRendererNative* getNativeRenderer() const {
                    return myVfb.rendererNative;
                }
            private:
                const VRayRenderer::VFB& myVfb;
            } historyManager;
 
            class ToolbarManager {
                friend class VFB;
            public:
                enum ChannelButton {
                    red = 1,
                    green,
                    blue,
                    alpha,
                    monochrome
                };
 
                enum Resolution {
                    resolution_10p = 0,
                    resolution_25p,
                    resolution_50p,
                    resolution_75p,
                    resolution_100p,
                    resolution_110p,
                    resolution_125p,
                    resolution_150p
                };
 
                bool getChannelButtonStatus(const ChannelButton whichChannel) const;
 
                void setChannelButtonStatus(const ChannelButton whichChannel, const bool status);
 
                bool getTestResolutionButtonStatus() const;
 
                void setTestResolutionButtonStatus(const bool status);
 
                Resolution getTestResolution() const;
 
                void setTestResolution(const Resolution resolution);
 
                bool getTrackMouseButtonStatus() const;
 
                void setTrackMouseButtonStatus(const bool status);
 
                void getBucketLockPoint(int& left, int& top) const;
 
                void setBucketLockPoint(const int left, const int top);
 
                bool getBucketLockButtonStatus() const;
 
                void setBucketLockButtonStatus(const bool status);
 
                StringList getChannelNames() const;
 
                int getCurrentChannel() const;
 
                void setCurrentChannel(const int channelIdx);
 
                bool getRenderRegionButtonStatus() const;
 
                void setRenderRegionButtonStatus(const bool status);
 
                ToolbarManager() = delete;
 
                ToolbarManager(const ToolbarManager& rhs) = delete;
 
                ToolbarManager& operator=(const ToolbarManager& rhs) = delete;
            protected:
                ToolbarManager(VRayRenderer::VFB& vfb) : myVfb(vfb) {}
 
                Internal::VRayRendererNative* getNativeRenderer() const {
                    return myVfb.rendererNative;
                }
            private:
                const VRayRenderer::VFB& myVfb;
            } toolbarManager;
 
            void resetState();
 
            VFBState* getPersistentState(size_t& dataSize) const;
 
            void setPersistentState(const void* vfbPersistentStateData, size_t dataSize);
 
            VRAY_DEPRECATED("getWindowHandle in unsafe and deprecated - use getNativeHandle or getQWidget instead")
            void* getWindowHandle() const;
 
            NativeWidgetHandle getNativeHandle() const;
 
            APPSDK_QT_NAMESPACE::QWidget* getQWidget() const;
 
            VRAY_DEPRECATED("setParentWindow in unsafe and deprecated - use setNativeParentWindow or setQWidgetParent instead")
            void setParentWindow(void* hWnd);
 
            void setNativeParentWindow(NativeWindowHandle handle);
 
            void setQWidgetParent(APPSDK_QT_NAMESPACE::QWidget* parentWidget);
 
            bool getMinimumSize(int& w, int& h) const;
 
            bool loadColorCorrectionsPreset(const char* filename);
 
            bool loadColorCorrectionsPreset(const std::string& filename);
 
            bool saveColorCorrectionsPreset(const char* filename) const;
 
            bool saveColorCorrectionsPreset(const std::string& filename) const;
 
            bool setTitlePrefix(const char* prefix);
 
            bool setTitlePrefix(const std::string& prefix);
 
            bool setProjectPath(const char *projectPath);
 
            bool setProjectPath(const std::string& projectPath);
 
            void enableProgressBar(bool enable = true);
 
            void setProgressText(const char* text);
 
            void setProgressText(const std::string& text);
 
            void setProgressValue(float value = -1.0f);
 
            void setProgressTextAndValue(const char* text, float value);
 
            void setProgressTextAndValue(const std::string& text, float value);
 
            bool fillSettingsVFB(const char* instanceName = NULL);
 
            bool fillSettingsVFB(const std::string& instanceName);
 
            bool applySettingsVFB();
 
            bool loadImage(const char* filename);
 
            bool loadImage(const std::string& filename);
 
            bool saveImage(const char* fileName) const;
 
            bool saveImage(const std::string& fileName) const;
 
            bool saveImage(const char* fileName, const ImageWriterOptions& options) const;
 
            bool saveImage(const std::string& fileName, const ImageWriterOptions& options) const;
 
            void clearImage();
 
            void setUpdateAvailable(bool available);
 
            void logMessage(MessageLevel level, const char* message);
 
            void logMessage(MessageLevel level, const std::string& message);
 
            void appendAdditionalStyleSheet(const char *styleSheet);
 
        } vfb; 
 
        enum RenderMode {
            RENDER_MODE_PRODUCTION = -1,
            RENDER_MODE_INTERACTIVE = 0,
            RENDER_MODE_INTERACTIVE_CUDA = 4,
            RENDER_MODE_INTERACTIVE_OPTIX = 7,
            RENDER_MODE_INTERACTIVE_METAL = 8,
            RENDER_MODE_PRODUCTION_CUDA = 104,
            RENDER_MODE_PRODUCTION_OPTIX = 107,
            RENDER_MODE_PRODUCTION_METAL = 108,
        };
 
        static bool isInactiveState(RendererState value) { return value <= IDLE_DONE; }
 
        static bool isActiveState(RendererState value) { return !isInactiveState(value); }
 
        bool isRenderingInHalfResolution() const {
            return Internal::VRay_VRayRenderer_halfResolutionMode
            (getNativeRenderer());
        }
    private:
        LicenseError licErr;
        PluginTypeId* pluginTypeIds; // PluginTypeId LUT allocated in the VRayRenderer constructor, freed in the VRayRenderer destructor
        int pluginTypeIdsCount; // Number of plugin classes and the size of the pluginTypeIds LUT
 
        void createInstance(const Internal::RendererOptions_internal* options);
        int findPluginIdIndex(PluginTypeId typeId) const;
 
    public:
        VRayRenderer();
 
        VRayRenderer(const RendererOptions &rendererOptions);
 
        explicit VRayRenderer(InstanceHandleType handle);
 
        ~VRayRenderer();
 
        InstanceHandleType getInstanceHandle() const;
 
        operator bool() const;
 
        bool operator!() const;
 
        Error getLastError() const;
 
        void clearLastError();
 
        LicenseError getLicenseError() const;
 
        ParserError getLastParserError() const;
 
        bool setRenderMode(RenderMode mode);
 
        RenderMode getRenderMode() const;
 
        const RendererOptions getOptions() const;
 
        int setBitmapCache(bool onOff);
 
        bool setInteractiveSampleLevel(int samplesPerPixel);
 
        bool setInteractiveNoiseThreshold(float threshold);
 
        bool setInteractiveTimeout(int timeoutMsec);
 
        void setKeepInteractiveRunning(bool keepRunning);
 
        bool getKeepInteractiveRunning() const;
 
        bool serializeScene();
 
        bool clearScene();
 
        bool setDREnabled(bool drEnabled, bool enableBroadcastListener = true);
 
        bool getDREnabled() const;
 
        int getNumThreads() const;
 
        bool setNumThreads(int numThreads);
 
        bool enableDRClient(const EnableDRClientParams& enableParams);
 
        bool disableDRClient();
 
        bool isDRClientEnabled() const;
 
        bool enableLiveLinkClient(const LiveLinkClientParameters& params);
 
        enum UserPropertyType {
            UPType_int = 0,
            UPType_bool = 1,
            UPType_double = 2,
            UPType_float = 3,
            UPType_string = 4,
            UPType_vector = 5,
            UPType_color = 6
        };
 
        struct UserPropertyChanged {
            const char* propName;
            UserPropertyType type;
            union {
                int vint;
                bool vbool;
                double vdouble;
                float vfloat;
                const char* vstring;
                float vvector[3];
            };
        };
 
        // Information passed with userCameraChanged
        struct UserCameraChanged {
            // Name of the VRay plugin whose property was changed. Can be nullptr if
            // the property changed comes from a Vantage default and is not associated
            // with an existing scene plugin, e.g. a scene without a physical camera plugin
            const char* camName;
            // Information about the actual parameter that was changed and its new value
            const UserPropertyChanged* prop;
        };
 
        // Information passed with userLightChanged
        struct UserLightChanged {
            // Name of the VRay plugin whose property was changed. Can be nullptr if
            // the property changed comes from a Vantage default and is not associated
            // with an existing scene plugin
            const char* lightName;
            // Information about the actual parameter that was changed and its new value
            const UserPropertyChanged* prop;
        };
 
        enum UserSceneManipType { USMType_Transform_Set = 0, USMType_Show = 1, USMType_Hide = 2 };
 
        enum UserSceneNodeObjectType { USNOType_Node = 0, USNOType_Camera = 1, USNOType_Light = 2 };
 
        // Information passed with userNodeChanged
        struct UserNodeChanged {
            // Name of the VRay plugin whose property is changed with this operation.
            // This can be one of the light plugins, the render view, one of the camera
            // plugins, or a geometry node
            const char* objName;
            // Type of manipulation that occurred
            UserSceneManipType umt;
            // The general kind of object passed with objName
            UserSceneNodeObjectType objType;
            // If the type of manipulation is transform, the matrix and vector that describe
            // the transformation (i.e. the 'transform' plugin parameter). This should be
            // regarded as an offset to the current position/rotation and is in Vantage
            // world coordinates
            Transform moveTm;
        };
 
        void setUserCameraChangedCB(void(*cb) (const UserCameraChanged* info, void* userData), void* userData);
 
        void setUserLightChangedCB(void(*cb) (const UserLightChanged* info, void* userData), void* userData);
 
        void setUserNodeChangedCB(void(*cb) (const UserNodeChanged* info, void* userData), void* userData);
 
        bool getInProcess() const;
 
        bool setInProcess(bool inProcess);
 
        bool setImprovedDefaultSettings(DefaultsPreset preset=quality_medium);
 
        int getCurrentFrame() const;
 
        bool setCurrentFrame(int frame);
 
        double getCurrentTime() const;
 
        bool setCurrentTime(double time);
 
        bool clearAllPropertyValuesUpToTime(double time);
 
        bool clearPropertyValuesUpToTime(double time, PluginCategories categories);
 
        void useAnimatedValues(bool on);
 
        bool getUseAnimatedValuesState() const;
 
        Box getBoundingBox() const;
 
        Box getBoundingBox(bool& ok) const;
 
        bool setCamera(const Plugin& plugin);
 
        Plugin getCamera() const;
 
        void setCameraName(const char* name);
 
        const char* getCameraName() const;
 
        InteractiveStatistics getInteractiveStatistics() const;
 
        bool pause() const;
 
        bool resume() const;
 
        bool getImageSize(int& width, int& height) const;
 
        bool setImageSize(int width, int height, bool resetCropRegion = true, bool resetRenderRegion = true);
 
        bool getRenderRegion(int& rgnLeft, int& rgnTop, int& rgnWidth, int& rgnHeight) const;
 
        bool setRenderRegion(int rgnLeft, int rgnTop, int rgnWidth, int rgnHeight);
 
        bool getCropRegion(int& srcWidth, int& srcHeight, float& rgnLeft, float& rgnTop, float& rgnWidth, float& rgnHeight) const;
 
        bool setCropRegion(int srcWidth, int srcHeight, float rgnLeft, float rgnTop);
 
        bool setCropRegion(int srcWidth, int srcHeight, float rgnLeft, float rgnTop, float rgnWidth, float rgnHeight);
 
        bool setRenderSizes(const RenderSizeParams& sizes, bool regionButtonState);
 
        bool getRenderSizes(RenderSizeParams& sizes, bool& regionButtonState) const;
 
        int load(const char* fileName);
 
        int load(const std::string& fileName);
 
        int loadAsText(const char* text);
 
        int loadAsText(const std::string& text);
 
        int loadAsText(std::string&& text);
 
        template<typename T = void>
        int loadAsText(const char* text, size_t length, void(*freeFn)(char* text, size_t size, T* holderObject) = NULL, T* holderObject = NULL);
 
        int append(const char* fileName, bool drSendNameOnly = false);
 
        int append(const std::string& fileName, bool drSendNameOnly = false);
 
        int append(const std::vector<const char*> &fileNames);
 
        int append(const std::vector<std::string> &fileNames);
 
        int appendAsText(const char* text);
 
        int appendAsText(const std::string& text);
 
        int appendAsText(std::string&& text);
 
        int appendAsText(const std::vector<const char*> &sceneTexts);
 
        int appendAsText(const std::vector<std::string> &sceneTexts);
 
        template<typename T = void>
        int appendAsText(const char* text, size_t length, void(*freeFn)(char* text, size_t size, T* holderObject) = NULL, T* holderObject = NULL);
 
        int loadFiltered(const char* fileName, bool (*callback)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*), const void* userData = NULL);
 
        int loadFiltered(const std::string& fileName, bool(*callback)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*), const void* userData = NULL);
 
        template<class T, bool (T::*TMethod)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*)>
        int loadFiltered(const char* fileName, T& obj, const void* userData = NULL);
 
        template<class T, bool (T::*TMethod)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*)>
        int loadFiltered(const std::string& fileName, T& obj, const void* userData = NULL);
 
        int appendFiltered(const char* fileName, bool(*callback)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*), const void* userData = NULL);
 
        int appendFiltered(const std::string& fileName, bool(*callback)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*), const void* userData = NULL);
 
        template<class T, bool (T::*TMethod)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*)>
        int appendFiltered(const char* fileName, T& obj, const void* userData = NULL);
 
        template<class T, bool (T::*TMethod)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*)>
        int appendFiltered(const std::string& fileName, T& obj, const void* userData = NULL);
 
        template<class T, bool (T::*TMethod)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*)>
        int appendFiltered(const std::vector<const char*> &fileNames, T& obj, const void* userData = NULL);
 
        template<class T, bool (T::*TMethod)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*)>
        int appendFiltered(const std::vector<std::string> &fileNames, T& obj, const void* userData = NULL);
 
        int appendFiltered(const std::vector<const char*> &fileNames, bool(*callback)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*), const void* userData = NULL);
 
        int appendFiltered(const std::vector<std::string> &fileNames, bool(*callback)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*), const void* userData = NULL);
 
 
        int loadAsTextFiltered(const char* fileName, bool(*callback)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*), const void* userData = NULL);
 
        int loadAsTextFiltered(const std::string& fileName, bool(*callback)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*), const void* userData = NULL);
 
        template<class T, bool (T::*TMethod)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*)>
        int loadAsTextFiltered(const char* fileName, T& obj, const void* userData = NULL);
 
        template<class T, bool (T::*TMethod)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*)>
        int loadAsTextFiltered(const std::string& fileName, T& obj, const void* userData = NULL);
 
        int appendAsTextFiltered(const char* fileName, bool(*callback)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*), const void* userData = NULL);
 
        int appendAsTextFiltered(const std::string& fileName, bool(*callback)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*), const void* userData = NULL);
 
        template<class T, bool (T::*TMethod)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*)>
        int appendAsTextFiltered(const char* fileName, T& obj, const void* userData = NULL);
 
        template<class T, bool (T::*TMethod)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*)>
        int appendAsTextFiltered(const std::string& fileName, T& obj, const void* userData = NULL);
 
        template<class T, bool (T::*TMethod)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*)>
        int appendAsTextFiltered(const std::vector<const char*> &sceneTexts, T& obj, const void* userData = NULL);
 
        template<class T, bool (T::*TMethod)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*)>
        int appendAsTextFiltered(const std::vector<std::string> &sceneTexts, T& obj, const void* userData = NULL);
 
        int appendAsTextFiltered(const std::vector<const char*> &sceneTexts, bool(*callback)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*), const void* userData = NULL);
 
        int appendAsTextFiltered(const std::vector<std::string> &sceneTexts, bool(*callback)(VRayRenderer&, const char* pluginType, std::string& pluginName, void*), const void* userData = NULL);
 
        void start() const;
 
        int startSync() const;
 
        void renderSequence() const;
 
        void renderSequence(SubSequenceDesc descriptions[], size_t count) const;
 
        void continueSequence() const;
 
        void abort() const;
 
        void stop() const;
 
        int exportScene(const char* filePath) const;
 
        int exportScene(const std::string& filePath) const;
 
        int exportScene(const char* filePath, const VRayExportSettings& settings) const;
 
        int exportScene(const std::string& filePath, const VRayExportSettings& settings) const;
 
        std::string exportSceneToBuffer() const;
 
        std::string exportSceneToBuffer(const VRayExportSettings& settings) const;
 
        void bucketRenderNearest(int x, int y) const;
 
        AddHostsResult addHosts(const char* hosts) const;
 
        AddHostsResult addHosts(const std::string& hosts) const;
 
        int removeHosts(const char* hosts) const;
 
        int removeHosts(const std::string& hosts) const;
 
        int resetHosts(const char* hosts = NULL) const;
 
        int resetHosts(const std::string& hosts) const;
 
        std::string getAllHosts() const;
 
        std::string getActiveHosts() const;
 
        std::string getInactiveHosts() const;
 
        unsigned long long commit();
 
        unsigned long long getChangeIndex() const;
 
        void lockScene();
 
        void unlockScene();
 
        bool tryLockScene();
 
        VRayImage* getImage() const;
 
        VRayImage* getImage(const GetImageOptions &options) const;
 
        size_t getImageIntoBuffer(const GetImageOptions &options, void *buf) const;
 
        RendererState getState() const;
 
        bool isRenderEnded() const;
 
        bool isAborted() const;
 
        bool isFrameSkipped() const;
 
        bool isSequenceEnded() const;
 
        enum class WaitTime : int {
            AwaitingOrIdle = -1,
 
            Idle = -2
        };
 
        bool waitForRenderEnd(const WaitTime time = WaitTime::AwaitingOrIdle) const;
 
        bool waitForRenderEnd(const int timeout) const;
 
        bool waitForSequenceEnd() const;
 
        bool waitForSequenceEnd(const int timeout) const;
 
        bool waitForVFBClosed() const;
 
        bool waitForVFBClosed(const int timeout) const;
 
        std::vector<Plugin> getPlugins() const;
 
        template <class T, class RetT = T> std::vector<RetT> getPlugins() const;
 
        std::vector<Plugin> getPlugins(const char* pluginClassName) const;
 
        std::vector<Plugin> getPlugins(const std::string& pluginClassName) const;
 
        std::vector<Plugin> getPluginsOfCategory(PluginCategory category) const;
 
        std::vector<Plugin> getPluginsOfCategories(const PluginCategories& categories) const;
 
        std::vector<Plugin> getPluginsOfCategories(const std::vector<PluginCategories>& categories) const;
 
        std::vector<std::string> getAllPluginTypes() const;
 
        std::vector<std::string> getPluginTypesOfCategory(PluginCategory category) const;
 
        std::vector<std::string> getPluginTypesOfCategories(PluginCategories categories) const;
 
        std::vector<std::string> getPluginTypesOfCategories(const std::vector<PluginCategories>& categories) const;
 
        Plugin getInstanceOf(const char* pluginType) const;
 
        Plugin getInstanceOf(PluginTypeId pluginTypeId) const;
 
        Plugin getInstanceOf(const std::string& pluginType) const;
 
        template<class T> T getInstanceOf() const;
 
        Plugin getInstanceOrCreate(const char* pluginType);
 
        Plugin getInstanceOrCreate(PluginTypeId pluginTypeId);
 
        Plugin getInstanceOrCreate(const std::string& pluginType);
 
        template<class T> T getInstanceOrCreate();
 
        Plugin getInstanceOrCreate(const char* pluginName, const char* pluginType);
 
        Plugin getInstanceOrCreate(const std::string& pluginName, const char* pluginType);
 
        Plugin getInstanceOrCreate(const char* pluginName, const std::string& pluginType);
 
        Plugin getInstanceOrCreate(const std::string& pluginName, const std::string& pluginType);
 
        Plugin getInstanceOrCreate(const char* pluginName, PluginTypeId pluginTypeId);
 
        Plugin getInstanceOrCreate(const std::string& pluginName, PluginTypeId pluginTypeId);
 
        template<class T> T getInstanceOrCreate(const char* pluginName);
 
        template<class T> T getInstanceOrCreate(const std::string& pluginName);
 
        double getCurrentEventTime() const;
 
        void setOnStateChanged(void(*callback)(VRayRenderer&, RendererState oldState, RendererState newState, double instant, void*), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, RendererState oldState, RendererState newState, double instant, void* userData)>
        void setOnStateChanged(T& object, const void* userData = NULL);
 
        void setOnRendererClose(void(*callback)(VRayRenderer&, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, double instant, void* userData)>
        void setOnRendererClose(T& object, const void* userData = NULL);
 
        void setOnProgressiveImageUpdated(void(*callback)(VRayRenderer&, VRayImage* img, unsigned long long changeIndex, ImagePassType pass, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, VRayImage* img, unsigned long long changeIndex, ImagePassType pass, double instant, void* userData)>
        void setOnProgressiveImageUpdated(T& object, const void* userData = NULL);
 
        void setOnLogMessage(void(*callback)(VRayRenderer&, const char* msg, MessageLevel level, double instant, void* userData), MessageLevel minLevel=MessageInfo, const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer& renderer, const char* msg, MessageLevel level, double instant, void* userData)>
        void setOnLogMessage(T& object, MessageLevel minLevel = MessageInfo, const void* userData = NULL);
 
        void setOnLicenseError(void(*callback)(VRayRenderer&, const char* msg, int errorCode, LicenseUserStatus userStatus, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer& renderer, const char* msg, int errorCode, LicenseUserStatus userStatus, double instant, void* userData)>
        void setOnLicenseError(T& object, const void* userData = NULL);
 
        void setOnBucketInit(void(*callback)(VRayRenderer&, int x, int y, int width, int height, const char* host, ImagePassType pass, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, int x, int y, int width, int height, const char* host, ImagePassType pass, double instant, void* userData)>
        void setOnBucketInit(T& object, const void* userData = NULL);
 
        void setOnBucketReady(void(&callback)(VRayRenderer&, int x, int y, const char* host, VRayImage* img, ImagePassType pass, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, int x, int y, const char* host, VRayImage* img, ImagePassType pass, double instant, void* userData)>
        void setOnBucketReady(T& object, const void* userData = NULL);
 
        void setOnBucketReady(void(&callback)(VRayRenderer&, int x, int y, int width, int height, const char* host, ImagePassType pass, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::* TMethod)(VRayRenderer&, int x, int y, int width, int height, const char* host, ImagePassType pass, double instant, void* userData)>
        void setOnBucketReady(T& object, const void* userData = NULL);
        void setOnBucketReady(std::nullptr_t null);
 
        void setOnBucketFailed(void(*callback)(VRayRenderer&, int x, int y, int width, int height, const char* host, ImagePassType pass, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, int x, int y, int width, int height, const char* host, ImagePassType pass, double instant, void* userData)>
        void setOnBucketFailed(T& object, const void* userData = NULL);
 
        void setOnProgress(void(*callback)(VRayRenderer&, const char* msg, int elementNumber, int elementsCount, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, const char* msg, int elementNumber, int elementsCount, double instant, void* userData)>
        void setOnProgress(T& object, const void* userData = NULL);
 
        void setOnRenderViewChanged(void(*callback)(VRayRenderer&, const char* propName, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, const char* propName, double instant, void* userData)>
        void setOnRenderViewChanged(T& object, const void* userData = NULL);
 
        void setOnVFBRenderLast(void(*callback)(VRayRenderer&, bool isRendering, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, bool isRendering, double, void* userData)>
        void setOnVFBRenderLast(T& object, const void* userData = NULL);
 
        void setOnVFBInteractiveStart(void(*callback)(VRayRenderer&, bool isRendering, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, bool isRendering, double instant, void* userData)>
        void setOnVFBInteractiveStart(T& object, const void* userData = NULL);
 
        void setOnVFBClosed(void(*callback)(VRayRenderer&, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, double instant, void* userData)>
        void setOnVFBClosed(T& object, const void* userData = NULL);
 
        void setOnPostEffectsUpdated(void(*callback)(VRayRenderer&, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, double instant, void* userData)>
        void setOnPostEffectsUpdated(T& object, const void* userData = NULL);
 
        void setOnVFBLayersChanged(void(*callback)(VRayRenderer&, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, double instant, void* userData)>
        void setOnVFBLayersChanged(T& object, const void* userData = NULL);
 
        void setOnVFBShowMessagesWindow(void(*callback)(VRayRenderer&, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, double instant, void* userData)>
        void setOnVFBShowMessagesWindow(T& object, const void* userData = NULL);
 
        void setOnHostConnected(void(*callback)(VRayRenderer&, const char* hostName, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, const char* hostName, double instant, void* userData)>
        void setOnHostConnected(T& object, const void* userData = NULL);
 
        void setOnHostDisconnected(void(*callback)(VRayRenderer&, const char* hostName, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, const char* hostName, double instant, void* userData)>
        void setOnHostDisconnected(T& object, const void* userData = NULL);
 
        void setOnVFBOpenUpdateNotify(void(*callback)(VRayRenderer&, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, double instant, void* userData)>
        void setOnVFBOpenUpdateNotify(T& object, const void* userData = NULL);
 
        void setOnVFBSaveSettingsNotify(void(*callback)(VRayRenderer&, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, double instant, void* userData)>
        void setOnVFBSaveSettingsNotify(T& object, const void* userData = NULL);
 
 
        enum class DebugShadingMode : int {
            isolateSelect, 
            globalLighting, 
            globalAO, 
            globalWireframe, 
            globalNormal, 
            globalUV, 
            globalBarycentric, 
        };
 
        void setOnVFBDebugShadingNotify(void(*callback)(VRayRenderer&, int enabled, DebugShadingMode mode, int selectionLocked, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, int enabled, int mode, int selectionLocked, double instant, void* userData)>
        void setOnVFBDebugShadingNotify(T& object, const void* userData = NULL);
 
        void setVFBContextMenuSelectedCallback(void(*callback)(VRayRenderer&, int commandId, int x, int y, void* userData), const void* userData = NULL);
        template<class T, void(T::*TMethod)(VRayRenderer&, int commandId, int x, int y, void* userData)>
        void setVFBContextMenuSelectedCallback(T& object, const void* userData = NULL);
 
        void setOnVFBCopyToHostFrameBufferNotify(void(*callback)(VRayRenderer&, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, double instant, void* userData)>
        void setOnVFBCopyToHostFrameBufferNotify(T& object, const void* userData = NULL);
 
        void setOnLightMixTransferToScene(int(*callback)(VRayRenderer&, const std::vector<LightMixChange>& changes, double instant, void*), const void* userData = NULL);
        template<class T, int(T::*TMethod)(VRayRenderer&, const std::vector<LightMixChange>& lightMixChanges, double instant, void* userData)>
        void setOnLightMixTransferToScene(T& object, const void* userData = NULL);
 
        void setOnUploadToCollaboration(int(*callback)(VRayRenderer&, const std::vector<std::string>& fileList, double instant, void*), const void* userData = NULL);
        template<class T, int(T::*TMethod)(VRayRenderer&, const std::vector<std::string>& fileList, double instant, void* userData)>
        void setOnUploadToCollaboration(T& object, const void* userData = NULL);
 
        void setOnEnhanceOnCollaboration(int(*callback)(VRayRenderer&, const std::vector<std::string>& fileList, double instant, void*), const void* userData = NULL);
        template<class T, int(T::*TMethod)(VRayRenderer&, const std::vector<std::string>& fileList, double instant, void* userData)>
        void setOnEnhanceOnCollaboration(T& object, const void* userData = NULL);
 
        void setOnVFBPauseIPR(void(*callback)(VRayRenderer&, bool isRendering, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, bool isRendering, double instant, void* userData)>
        void setOnVFBPauseIPR(T& object, const void* userData = NULL);
 
        void setOnVFBUpdateIPR(void(*callback)(VRayRenderer&, bool isRendering, double instant, void* userData), const void* userData = NULL);
        template<class T, void (T::*TMethod)(VRayRenderer&, bool isRendering, double instant, void* userData)>
        void setOnVFBUpdateIPR(T& object, const void* userData = NULL);
 
        void setOnVFBAddRenderElementToScene(bool(*callback)(VRayRenderer&, VFBRenderElementType type,  double instant, void* userData), const void* userData = NULL);
        template<class T, bool (T::*TMethod)(VRayRenderer&, VFBRenderElementType type,  double instant, void* userData)>
        void setOnVFBAddRenderElementToScene(T& object, const void* userData = NULL);
 
        void setOnVFBClick(void(*callback)(VRayRenderer&, VFBMouseButton button, int x, int y, bool ctrl, bool shift, void* userData), const void* userData = NULL);
        template<class T, void (T::* TMethod)(VRayRenderer&, VFBMouseButton button, int x, int y, bool ctrl, bool shift, void* userData)>
        void setOnVFBClick(T& object, const void* userData = NULL);
 
 
        void setVFBContextMenuItems(const std::vector<VFBContextMenuItem> &items);
 
        bool getVFBContextMenuItemValue(int commandId, int& value) const;
 
        bool setVFBContextMenuItemValue(int commandId, int value);
 
        float setProgressiveImageUpdateDifference(float difference);
 
        unsigned long setProgressiveImageUpdateTimeout(unsigned long timeout);
 
        void setKeepProgressiveFramesInCallback(bool keep);
 
        void setKeepBucketsInCallback(bool keep);
 
        void setBucketReadyHasBuffer(bool hasBuffer);
 
        bool getBucketReadyHasBuffer() const;
 
        void setProgresiveImageUpdatedHasBuffer(bool hasBuffer);
 
        bool getProgresiveImageUpdatedHasBuffer() const;
 
        void setVisualDebuggerEnabled(bool enable);
 
        bool getVisualDebuggerEnabled() const;
 
        Plugin getPlugin(const char *pluginName) const;
 
        Plugin getPlugin(const std::string &pluginName) const;
 
        template<class T> T getPlugin(const char *pluginName) const;
 
        template<class T> T getPlugin(const std::string &pluginName) const;
 
        PluginMeta getPluginMeta(const char *pluginClassName) const;
 
        PluginMeta getPluginMeta(const std::string& pluginClassName) const;
 
        PluginMeta getPluginMeta(const PluginTypeId pluginTypeId) const;
 
        Plugin newPlugin(const char* pluginName, const char* pluginType);
 
        Plugin newPlugin(const char* pluginName, PluginTypeId pluginTypeId);
 
        Plugin newPlugin(const std::string& pluginName, const std::string& pluginType);
 
        Plugin newPlugin(const char* pluginName, const std::string& pluginType);
 
        Plugin newPlugin(const std::string& pluginName, const char* pluginType);
 
        template<class T> T newPlugin(const char* pluginName);
 
        template<class T> T newPlugin(const std::string& pluginName);
 
        template<class T> T newPlugin();
 
        Plugin newPlugin(const char* pluginType);
 
        Plugin newPlugin(const std::string &pluginType);
 
        Plugin newPlugin(PluginTypeId pluginTypeId);
 
        Plugin getOrCreatePlugin(const char* pluginName, const char* pluginType);
 
        Plugin getOrCreatePlugin(const std::string& pluginName, const char* pluginType);
 
        Plugin getOrCreatePlugin(const char* pluginName, const std::string& pluginType);
 
        Plugin getOrCreatePlugin(const std::string& pluginName, const std::string& pluginType);
 
        Plugin getOrCreatePlugin(const char* pluginName, PluginTypeId pluginTypeId);
 
        Plugin getOrCreatePlugin(const std::string& pluginName, PluginTypeId pluginTypeId);
 
        template<class T> T getOrCreatePlugin(const char* pluginName);
 
        template<class T> T getOrCreatePlugin(const std::string& pluginName);
 
        Plugin pickPlugin(int x, int y) const;
 
        Plugin pickPlugin(int x, int y, int timeout) const;
 
        std::vector<PickedPluginInfo> pickPlugins(double x, double y, int maxcount = 0, int timeout = -1) const;
 
        bool deletePlugin(const Plugin& plugin);
 
        bool deletePlugin(const std::string& pluginName);
 
        bool deletePlugin(const char* pluginName);
 
        bool deletePlugins(const char* names[], size_t namesCount);
 
        bool deletePlugins(const std::vector<std::string> &names);
 
        bool deletePlugins(const std::vector<VRay::Plugin> &plugins);
 
        bool replacePlugin(const Plugin& oldPlugin, const Plugin& newPlugin);
 
        bool optimizeMaterialGraph(const Plugin& topPlugin);
 
        bool getAutoCommit() const;
 
        void setAutoCommit(bool autoCommit);
 
        RenderElements getRenderElements();
 
        size_t getIrradianceMapSize() const;
        bool saveIrradianceMapFile(const std::string &fileName);
        bool saveIrradianceMapFile(const char* fileName);
 
        size_t getLightCacheSize() const;
        bool saveLightCacheFile(const std::string &fileName);
        bool saveLightCacheFile(const char* fileName);
 
        size_t getPhotonMapSize() const;
        bool savePhotonMapFile(const std::string &fileName);
        bool savePhotonMapFile(const char* fileName);
 
        size_t getCausticsSize() const;
        bool saveCausticsFile(const std::string &fileName);
        bool saveCausticsFile(const char* fileName);
 
        std::vector<ComputeDeviceInfo> getComputeDevicesMetal() const;
 
        std::vector<ComputeDeviceInfo> getComputeDevicesOptix() const;
 
        std::vector<ComputeDeviceInfo> getComputeDevicesCUDA() const;
 
        std::vector<ComputeDeviceInfo> getComputeDevicesDenoiser() const;
 
        std::vector<ComputeDeviceInfo> getComputeDevicesCurrentEngine() const;
 
        bool setComputeDevicesMetal(const std::vector<int> &indices);
 
        bool setComputeDevicesOptix(const std::vector<int> &indices);
 
        bool setComputeDevicesCUDA(const std::vector<int> &indices);
 
        bool setComputeDevicesDenoiser(const std::vector<int> &indices);
 
        bool setComputeDevicesEnvironmentVariable();
 
        bool setComputeDevicesCurrentEngine(const std::vector<int> &indices);
 
        bool setResumableRendering(bool enable, const ResumableRenderingOptions* options);
 
        void setDenoiserOptions(const DenoiserOptions& denoiserOptions);
 
        bool denoiseNow(void(*userCb)(VRayRenderer&, VRayImage*, void*) = 0, bool shouldPassImage = true, const void* userData = NULL);
 
        template<class T, void (T::*TMethod)(VRayRenderer&, VRayImage*, void*)>
        bool denoiseNow(T& object, bool shouldPassImage = true, const void* userData = NULL);
 
        bool updateLightingAnalysis();
 
        void setIncludePaths(const char* includePaths, bool overwrite = true);
 
        void setIncludePaths(const std::string &includePaths, bool overwrite = true);
 
        AutoExposureResult getAutoExposureResult() const;
 
        float getIESPrescribedIntensity(const char* iesLightFileName) const;
 
        float getIESPrescribedIntensity(const std::string &iesLightFileName) const;
 
        struct VRayProfiler {
            void initializeManually(const VRayProfilerSettings& settings);
 
            bool isManual();
 
            void writeAndFreeData();
 
            void startDurationEvent(const char* name, int threadIndex = 0);
 
            void endDurationEvent(const char* name, int threadIndex = 0);
 
        private:
            VRayProfiler(VRayRenderer& renderer) : owner(renderer) {}
            VRayRenderer& owner;
            friend class VRayRenderer;
        } profiler{ *this }; 
 
        void setVRayProfiler(const VRayProfilerSettings& settings);
 
        bool addVRayProfilerMetadata(const char* category, const char* key, const char* value);
 
        bool addVRayProfilerMetadata(const std::string& category, const std::string& key, const std::string& value);
 
        void setUserSceneName(const char* sceneName);
 
        void setUserSceneName(const std::string& sceneName);
 
        std::string getUserSceneName();
 
        void setOnVRayProfilerWrite(void(*callback)(VRayRenderer&, const std::string& outputFile, int fileType, double instant, void*), const void* userData = nullptr);
        template<class T, void(T::*TMethod)(VRayRenderer&, const std::string &outputFile, int fileType, double instant, void* userData)>
        void setOnVRayProfilerWrite(T& object, const void* userData = nullptr);
 
        void setDebugShadingSelection(const std::vector<Plugin>& selection);
 
    protected:
        Internal::VRayRendererNative* getNativeRenderer() const;
        static VRayRenderer* getVRayRenderer(void* rendererNative);
 
        InstanceId getPluginId_internal(const char* pluginName, PluginTypeId& outTypeId) const;
        PluginTypeId getPluginTypeId_internal(const char* pluginType) const;
        PluginTypeId getPluginTypeId_internal(InstanceId pluginID) const;
        const char* getPluginTypeString(PluginTypeId pluginTypeId) const;
        Plugin getPlugin_internal(InstanceId pluginID) const;
        template<class T> T getPlugin_internal(InstanceId pluginID) const;
        const char* getPluginName_internal(InstanceId pluginID) const;
        bool pluginExists_internal(InstanceId pluginID) const;
 
        int getPropertyIndexFromName(InstanceId pluginID, const char* propertyName) const;
        const char* getPropertyNameFromIndex(InstanceId pluginID, int idx) const;
        template<class T> static std::vector<T> getPluginsOfType(VRayRenderer& renderer, const char* pluginType);
        template<class T> static std::vector<T> getPluginsOfTypeId(VRayRenderer& renderer, PluginTypeId typeId);
        static std::vector<std::string> getStringVector(void *pvector);
        static std::vector<const char*> getCharPtrVector(const std::vector<std::string> &strVector);
        std::vector<std::string> getPluginPropertyNames(const char* pluginClassName) const; // Returns the names of all properties of a plugin.
        const char* getPluginType(const char* name) const;
        const char* getPluginType(InstanceId pluginID) const;
        bool setPluginName(InstanceId pluginID, const char* name) const;
        Type getPluginPropertyRuntimeType(const char* pluginName, const char* propertyName) const;
        Type getPluginPropertyRuntimeType(InstanceId pluginID, const char* propertyName) const;
        int getPluginPropertyElementsCount(InstanceId pluginID, const char* propertyName) const;
        const void* getPluginPropertyDefinition(const char* pluginName, const char* propertyName) const;
        const void* getPluginPropertyDefinition(InstanceId pluginID, const char* propertyName) const;
        const void* getPluginPropertyDefinitionFromClass(const char* pluginClassName, const char* propertyName) const;
        std::string getPluginPropertyValueAsString(const char* pluginName, const char* propertyName, double time) const;
        std::string getPluginPropertyValueAsString(InstanceId pluginID, const char* propertyName, bool& ok, double time) const;
        bool setPluginPropertyValueAsString(InstanceId pluginID, const char* propertyName, const char* value) const;
        bool setPluginPropertyValueAsStringAtTime(InstanceId pluginID, const char* propertyName, const char* value, double time) const;
        bool getPluginPropertyBool(const char* pluginName, const char* propertyName, bool& ok, double time) const;
        bool getPluginPropertyBool(InstanceId pluginID, const char* propertyName, bool& ok, double time) const;
        int getPluginPropertyInt(const char* pluginName, const char* propertyName, bool& ok, double time) const;
        int getPluginPropertyInt(InstanceId pluginID, const char* propertyName, bool& ok, double time) const;
        float getPluginPropertyFloat(const char* pluginName, const char* propertyName, bool& ok, double time) const;
        float getPluginPropertyFloat(InstanceId pluginID, const char* propertyName, bool& ok, double time) const;
        double getPluginPropertyDouble(InstanceId pluginID, const char* propertyName, bool& ok, double time) const;
        Color getPluginPropertyColor(const char* pluginName, const char* propertyName, bool& ok, double time) const;
        Color getPluginPropertyColor(InstanceId pluginID, const char* propertyName, bool& ok, double time) const;
        AColor getPluginPropertyAColor(const char* pluginName, const char* propertyName, bool& ok, double time) const;
        AColor getPluginPropertyAColor(InstanceId pluginID, const char* propertyName, bool& ok, double time) const;
        Vector getPluginPropertyVector(const char* pluginName, const char* propertyName, bool& ok, double time) const;
        Vector getPluginPropertyVector(InstanceId pluginID, const char* propertyName, bool& ok, double time) const;
        Matrix getPluginPropertyMatrix(const char* pluginName, const char* propertyName, bool& ok, double time) const;
        Matrix getPluginPropertyMatrix(InstanceId pluginID, const char* propertyName, bool& ok, double time) const;
        Transform getPluginPropertyTransform(const char* pluginName, const char* propertyName, bool& ok, double time) const;
        Transform getPluginPropertyTransform(InstanceId pluginID, const char* propertyName, bool& ok, double time) const;
        PluginRef getPluginPropertyPluginRef(InstanceId pluginID, const char* propertyName, bool& ok, double time) const;
        Value getPluginPropertyValue(InstanceId pluginID, const char* propertyName, bool& ok, double time) const;
        template<typename T> T getPluginPropertyTyped(InstanceId pluginID, const char* propertyName, bool& ok, double time) const;
        int getPropertyState(InstanceId pluginID, const char* propertyName) const;
        int getKeyframeTimes(InstanceId pluginID, const char* propertyName, double* &times) const;
        bool setPluginPropertyValueAtTime(InstanceId pluginID, const char* propertyName, const void *pval, double time) const;
        bool setPluginPropertyValueRawAtTime(InstanceId pluginID, const char* propertyName, const void *pval, size_t count, double time) const;
 
#ifdef VRAY_SDK_INTEROPERABILITY
        bool getPluginPropertyValueSDKInterop(InstanceId pluginID, const char* propertyName, void *pval, int type) const;
        bool getPluginPropertyValueAtTimeSDKInterop(InstanceId pluginID, const char* propertyName, void *pval, int type, double time) const;
        bool setPluginPropertyValueSDKInterop(InstanceId pluginID, const char* propertyName, const void* pval, int type) const;
        bool setPluginPropertyValueAtTimeSDKInterop(InstanceId pluginID, const char* propertyName, const void* pval, int type, double time) const;
#endif // VRAY_SDK_INTEROPERABILITY
 
        Plugin newRenderElementPlugin(int type, const char *instanceName, const char *displayName);
        Plugin getRenderElementPlugin(int type) const;
        std::vector<Plugin> getRenderElementPluginsList(int type) const;
        bool getRenderElementInfo(InstanceId pluginID, int type, RenderElement::Info& chInfo) const;
        size_t getRenderElementData(
            InstanceId pluginID,
            InstanceId alphaPluginID,
            int type,
            int layer,
            RenderElement::PixelFormat format,
            int intent,
            bool rgbOrder,
            const ImageRegion* rgn,
            void** buf
        ) const;
        size_t getRenderElementDataIntoBuffer(
            InstanceId pluginID,
            InstanceId alphaPluginID,
            int type,
            int layer,
            RenderElement::PixelFormat format,
            int intent,
            bool rgbOrder,
            const ImageRegion* rgn,
            bool flipImage,
            void *buf
        ) const;
        VRayImage* getRenderElementAsImage(InstanceId pluginID, int type, int layer, const GetImageOptions &options, const bool isDoColorCorrectionsUSerSet = false) const;
        std::string getRenderElementMetadata(InstanceId pluginID, int type) const;
    };
 
    class ProfilerDurationScope {
    public:
        ProfilerDurationScope(VRayRenderer& renderer, std::string eventName, int threadIndex = 0) :
            renderer(renderer),
            eventName(eventName),
            threadIndex(threadIndex) {
            if (renderer.profiler.isManual()) {
                renderer.profiler.startDurationEvent(eventName.c_str(), threadIndex);
            }
        }
 
        ~ProfilerDurationScope() {
            if (renderer.profiler.isManual()) {
                renderer.profiler.endDurationEvent(eventName.c_str(), threadIndex);
            }
 
        }
    private:
        VRayRenderer& renderer;
        std::string eventName;
        int threadIndex;
    };
 
    struct ScatterReadParams {
        std::string fileName;      
        Plugin      scatterPlugin; 
        float       unitRescale;   
        bool        isYAxisUp;     
 
        ScatterReadParams();
    };
 
    class GeomUtils {
    private:
        template<class T, Plugin(T::* TMethod)(VRayRenderer&, const char* assetId, Vector importPosition, void* userData)>
        static InstanceId importScatterPresetCallbackT(const char* assetId, Vector* importPosition, void* info);
        static InstanceId importScatterPresetCallback(const char* assetId, Vector* importPosition, void* info);
 
    public:
        static bool readScatterData(const Plugin& scatterPlugin, std::vector<Transform>& transforms, IntList& topo);
 
        static bool readGaussianData(const Plugin& gaussianPlugin, GaussianReadData& readData);
 
        static bool readGaussianData(const std::string& fileName, GaussianReadData& readData);
 
        static bool readScatterPreset(const ScatterReadParams& params, Plugin(*callback)(VRayRenderer&, const char* assetId, Vector importPosition, void* userData) = 0, const void* userData = nullptr);
        template<class T, Plugin(T::* TMethod)(VRayRenderer&, const char* assetId, Vector importPosition, void* userData)>
        static bool readScatterPreset(const ScatterReadParams& params, T& object, const void* userData = nullptr);
 
        static bool readGeomHairData(const Plugin& nodePlugin, VectorList& vertices, IntList& lengths, int countHint = 0);
    };
 
    class LightUtils {
    public:
        static bool readLuminaireFieldPreviewData(const Plugin& luminairePlugin, LuminaireFieldReadPreviewData& readData);
 
        static bool readLuminaireFieldPreviewData(const std::string& fileName, LuminaireFieldReadPreviewData& readData);
 
        static bool readIESPreviewData(const Plugin& lightPlugin, VectorList& vertices, IntList& indices);
 
        static bool readIESPreviewData(const std::string& fileName, VectorList& vertices, IntList& indices);
    };
 
 
    class Proxy {
    public:
        static bool readPreviewGeometry(const Plugin &proxyPlugin, VectorList &vertices, IntList &indices, int countHint = 0);
 
        static bool readPreviewHair(const Plugin &proxyPlugin, VectorList &vertices, IntList &lengths, int countHint = 0);
 
        static bool readPreviewParticles(const Plugin &proxyPlugin, VectorList &positions, int countHint = 0);
 
        static bool readPreviewData(const Plugin &proxyPlugin, ProxyReadData &readData);
 
        static bool readFullData(const Plugin &proxyPlugin, ProxyReadData &readData);
 
        static bool createMeshFile(const Plugin &geomMeshPlugin, const Transform *transform, const ProxyCreateParams &params);
 
        static bool createMeshFile(const Plugin &geomMeshPlugin, const AnimatedTransform &animTransform, const ProxyCreateParams &params);
 
        static bool createCombinedMeshFile(const std::vector<Plugin> &geomMeshPlugins, const std::vector<Transform> *transforms, const ProxyCreateParams &params);
 
        static bool createCombinedMeshFile(const std::vector<Plugin> &geomMeshPlugins, const std::vector<AnimatedTransform> &animTransforms, const ProxyCreateParams &params);
 
        static bool readPreviewGeometry(const ProxyReadParams &params, VectorList &vertices, IntList &indices, int countHint = 0);
 
        static bool readPreviewHair(const ProxyReadParams &params, VectorList &vertices, IntList &lengths, int countHint = 0);
 
        static bool readPreviewParticles(const ProxyReadParams &params, VectorList &positions, int countHint = 0);
 
        static bool readPreviewData(const ProxyReadParams &params, ProxyReadData &readData);
 
        static bool readFullData(const ProxyReadParams &params, ProxyReadData &readData);
 
        static bool createMeshFile(const MeshFileData &data, const Transform *transform, const ProxyCreateParams &params);
 
        static bool createMeshFile(const MeshFileData &data, const AnimatedTransform &animTransform, const ProxyCreateParams &params);
 
        static bool createCombinedMeshFile(const std::vector<MeshFileData> &data, const std::vector<Transform> *transforms, const ProxyCreateParams &params);
 
        static bool createCombinedMeshFile(const std::vector<MeshFileData> &data, const std::vector<AnimatedTransform> &animTransforms, const ProxyCreateParams &params);
    };
 
    enum GPUParamSupport {
        GPUParamSupport_Full, 
        GPUParamSupport_Partial, 
        GPUParamSupport_None, 
        GPUParamSupport_Unknown, 
    };
 
    inline std::ostream& operator <<(std::ostream& stream, const GPUParamSupport val) {
        switch (val) {
        case GPUParamSupport_Full:
            stream << "Full";
            break;
        case GPUParamSupport_Partial:
            stream << "Partial";
            break;
        case GPUParamSupport_None:
            stream << "None";
            break;
        default:
            stream << "Unknown";
        }
        return stream;
    }
 
    class UIGuides {
        friend class PropertyMeta;
 
    private:
        const void* pParamDef;
 
    protected:
        UIGuides(const void* pParamDef) : pParamDef(pParamDef) {}
 
        const void* getParamDef() const {
            return pParamDef;
        }
 
    public:
        enum GuideType {
            Enum,
            Enable,
            DisplayName,
            MinValue,
            MaxValue,
            SpinStep,
            Units,
            FileAsset,
            Attributes,
            StringEnum,
            FileAssetNames,
            FileAssetOp,
            StartRollout,
            StartTab,
            SoftMinValue,
            SoftMaxValue,
            QuantityType,
            OverridenBy,
            Overrides,
            GPUSupport,
            Tier,
            Hide,
            DefaultValue,
            MaxGuides
        };
 
        enum QuantityTypeEnum {
            Unknown,
            Distance,
            Angle,
            LocalSubdivs
        };
 
        enum UnitsType {
            DefaultUnits,
            Radians,
            Degrees,
            Millimeters,
            Centimeters,
            Meters
        };
 
        enum FileAssetOpType {
            Load,
            Save,
            LoadAndSave
        };
 
        enum AttributesType {
            None = 0,
            ObjectSet = 1,
            TextureSlot = 2,
            LightSet = 4,
            PartOf3dsMaxTriple = 8,
            BitSet = 16,
            Boolean = 32
        };
 
        enum TierType {
            Basic = 0,
            DefaultTier = 1,
            Advanced = 2
        };
 
        UIGuides(const UIGuides& uiGuides) : pParamDef(uiGuides.pParamDef) {}
 
        UIGuides& operator=(const UIGuides& uiGuides) {
            pParamDef = uiGuides.pParamDef;
            return *this;
        }
 
        bool isEnum() const;
 
        bool hasType(const GuideType type) const;
 
        float getFloat(const GuideType type) const;
 
        std::vector<float> getFloats(const GuideType type) const;
 
        std::string getDisplayName() const;
 
        struct EnumItem {
            int value; 
            std::string name; 
        };
 
        std::vector<EnumItem> getEnumStrings() const;
 
        QuantityTypeEnum getQuantityType() const;
 
        UnitsType getUnits() const;
 
        std::vector<std::string> getFileAssetExts() const;
 
        std::vector<std::string> getFileAssetNames() const;
 
        FileAssetOpType getFileAssetOp() const;
 
        bool hasAttribute(const AttributesType attributeType) const;
 
        std::vector<std::string> getStringEnumStrings() const;
 
        bool isStringEnum() const;
 
        std::string getRolloutName() const;
 
        std::string getTabName() const;
 
        bool hasOverriddenBy() const;
 
        std::string getValueOfOverriddenBy() const;
 
        TierType getTier() const;
 
        bool hasOverride() const;
 
        int getCountOfOverrides() const;
 
        std::string getValueOfOverride(const int index) const;
 
        bool hasEnabledCondition() const;
 
        std::vector<std::string> getEnableDepends() const;
 
        GPUParamSupport getGPUSupportStatus() const;
 
        bool hasHiddenCondition() const;
 
        std::vector<std::string> getHideDepends() const;
    };
 
    class RuntimeUIGuides : public UIGuides {
        friend class PropertyRuntimeMeta;
    private:
        const Internal::VRayRendererNative* renderer;
        InstanceId id;
    protected:
        RuntimeUIGuides(const void* pParamDef, const Internal::VRayRendererNative* renderer, InstanceId id) :
            UIGuides(pParamDef), renderer(renderer), id(id) {}
 
    public:
        bool isEnabled() const;
 
        bool isHidden() const;
    };
 
    class PropertyMeta {
        friend class PluginMeta;
 
    protected:
        const void* pParamDef;
        GPUParamSupport gpuSupport;
 
        PropertyMeta(const VRayRenderer *pRenderer, const char* pluginClassName, const char* propertyName)
        {
            pParamDef = pRenderer->getPluginPropertyDefinitionFromClass(pluginClassName, propertyName);
            gpuSupport = (GPUParamSupport)Internal::VRay_PluginUtils_getPropertyGpuSupport(pRenderer->getNativeRenderer(), pluginClassName, pParamDef);
        }
 
    public:
        PropertyMeta(const PropertyMeta &propertyMeta)
            : pParamDef(propertyMeta.pParamDef), gpuSupport(propertyMeta.gpuSupport) {}
 
        PropertyMeta& operator=(const PropertyMeta &propertyMeta) {
            pParamDef = propertyMeta.pParamDef;
            gpuSupport = propertyMeta.gpuSupport;
            return *this;
        }
 
        void swap(PropertyMeta &propertyMeta) {
            std::swap(pParamDef, propertyMeta.pParamDef);
            std::swap(gpuSupport, propertyMeta.gpuSupport);
        }
 
        operator bool () const {
            return !!pParamDef;
        }
 
        int getElementsCount() const {
            return Internal::VRay_PluginUtils_getPropertyElementsCount(pParamDef);
        }
 
        const char* getName() const {
            return Internal::VRay_PluginUtils_getPropertyName(pParamDef);
        }
 
        StringList getAliases() const;
 
        Type getType() const {
            return Internal::VRay_PluginUtils_getPropertyType(pParamDef);
        }
 
        Type getElementType() const {
            return Internal::VRay_PluginUtils_getPropertyElementType(pParamDef);
        }
 
        Value getDefaultValue() const;
 
        std::string getDescription() const {
            const char* const description = Internal::VRay_PluginUtils_getPropertyDescription(pParamDef);
            return description ? description : "";
        }
 
        const char* getDeprecation() const {
            return Internal::VRay_PluginUtils_getPropertyDeprecation(pParamDef);
        }
 
        std::string getUIGuides() const {
            const char* const uiGuides = Internal::VRay_PluginUtils_getPropertyUIGuides(pParamDef);
            return uiGuides ? uiGuides : "";
        }
 
        UIGuides getUIGuidesObject() const {
            return UIGuides(pParamDef);
        }
 
        static const char* typeToString(const Type type);
 
        const char* getTypeAsString() const {
            return typeToString(getType());
        }
 
        GPUParamSupport getGPUSupport() const {
            return gpuSupport;
        }
    };
 
    class PropertyRuntimeMeta : public PropertyMeta {
        friend class Plugin;
 
        const VRayRenderer* renderer;
        InstanceId id;
 
    protected:
        PropertyRuntimeMeta(const Plugin& plugin, const char* propertyName)
            : PropertyMeta(plugin.pRenderer, plugin.getType(), propertyName), renderer(plugin.pRenderer), id(plugin.id()) {
        }
 
    public:
        PropertyRuntimeMeta(const PropertyRuntimeMeta& propertyRuntimeMeta)
            : PropertyMeta(propertyRuntimeMeta), renderer(propertyRuntimeMeta.renderer), id(propertyRuntimeMeta.id) {
        }
 
        PropertyRuntimeMeta& operator=(const PropertyRuntimeMeta &propertyRuntimeMeta) {
            PropertyMeta::operator=(propertyRuntimeMeta);
            renderer = propertyRuntimeMeta.renderer;
            id = propertyRuntimeMeta.id;
            return *this;
        }
 
        int getRuntimeElementsCount() const {
            return renderer->getPluginPropertyElementsCount(id, getName());
        }
 
        Type getRuntimeType() const {
            return renderer->getPluginPropertyRuntimeType(id, getName());
        }
 
        const char* getRuntimeTypeAsString() const {
            return typeToString(getRuntimeType());
        }
 
        void swap(PropertyRuntimeMeta &propertyRuntimeMeta) {
            PropertyMeta::swap(propertyRuntimeMeta);
            std::swap(renderer, propertyRuntimeMeta.renderer);
            std::swap(id, id);
        }
 
        RuntimeUIGuides getRuntimeUIGuidesObject() const {
            return RuntimeUIGuides(pParamDef, renderer->getNativeRenderer(), id);
        }
    };
 
    enum GPUPluginSupport {
        GPUPluginSupport_Full, 
        GPUPluginSupport_Partial, 
        GPUPluginSupport_Bake, 
        GPUPluginSupport_None, 
        GPUPluginSupport_Unknown, 
    };
 
    inline std::ostream& operator <<(std::ostream& stream, const GPUPluginSupport val) {
        switch (val) {
        case GPUPluginSupport_Full:
            stream << "Full";
            break;
        case GPUPluginSupport_Partial:
            stream << "Partial";
            break;
        case GPUPluginSupport_Bake:
            stream << "Bake";
            break;
        case GPUPluginSupport_None:
            stream << "None";
            break;
        default:
            stream << "Unknown";
        }
        return stream;
    }
 
    class PluginMeta {
        friend class VRayRenderer;
        friend class Plugin;
 
        PluginTypeId typeId;
        const char* type;
        const VRayRenderer* pRenderer;
 
    protected:
        PluginMeta(const Plugin& plugin)
            : typeId(plugin.getTypeId())
            , type(plugin.getType())
            , pRenderer(plugin.getRenderer())
        { }
 
        PluginMeta(const VRayRenderer* renderer, const char* typeStr) {
            typeId = renderer->getPluginTypeId_internal(typeStr);
            type = renderer->getPluginTypeString(typeId);
            pRenderer = renderer;
        }
 
        PluginMeta(const VRayRenderer* renderer, PluginTypeId pluginTypeId) {
            typeId = pluginTypeId;
            type = renderer->getPluginTypeString(pluginTypeId);
            pRenderer = renderer;
        }
 
    public:
        PluginMeta(const PluginMeta& pluginMeta) = default;
        PluginMeta& operator=(const PluginMeta& pluginMeta) = default;
 
        bool operator==(const PluginMeta& pluginMeta) const {
            return typeId == pluginMeta.typeId && pRenderer == pluginMeta.pRenderer;
        }
 
        void swap(PluginMeta& pluginMeta) {
            std::swap(typeId, pluginMeta.typeId);
            std::swap(type, pluginMeta.type);
            std::swap(pRenderer, pluginMeta.pRenderer);
        }
 
        bool isValid() const {
            return !!type;
        }
 
        const char* getType() const {
            return type;
        }
 
        PluginTypeId getTypeId() const {
            return typeId;
        }
 
        std::vector<std::string> getPropertyNames() const {
            return pRenderer->getPluginPropertyNames(type);
        }
 
        std::string getDescription() const;
 
        const char* getDeprecation() const;
 
        PropertyMeta getPropertyMeta(const char* propertyName) const {
            return PropertyMeta(pRenderer, type, propertyName);
        }
 
        PropertyMeta getPropertyMeta(const std::string &propertyName) const {
            return PropertyMeta(pRenderer, type, propertyName.c_str());
        }
 
        bool checkPluginUIGuides(std::string& errMsg) const;
 
        GPUPluginSupport getGPUSupport() const;
 
        PluginCategories getCategories() const;
    };
 
    class CompressImage;
 
    namespace Internal {
        class FileSaveWriteHelper {
            friend class VRay::CompressImage;
 
            std::ofstream ofs;
 
            FileSaveWriteHelper(const char* fileName) : ofs(fileName, std::ofstream::binary) {}
 
            ~FileSaveWriteHelper() {
                ofs.close();
            }
        };
    }
 
    class CompressImage {
        CompressImage(const CompressImage& ci);
        CompressImage& operator=(const CompressImage& ci);
 
    protected:
        byte* bufAddr;
        size_t bufSize;
 
        CompressImage() : bufAddr(), bufSize() {}
 
    public:
        void swap(CompressImage& ci);
 
        operator size_t () const {
            return bufSize;
        }
 
        void* getBuf() const {
            return bufAddr;
        }
 
        size_t getLen() const {
            return bufSize;
        }
 
        bool saveToFile(const char* fileName) const;
 
        bool saveToFile(const std::string &fileName) const {
            return saveToFile(fileName.c_str());
        }
 
        ~CompressImage() {
            if (bufSize)
                Internal::C_memory_free(bufAddr);
        }
    };
 
    class LocalJpeg : public CompressImage {
 
    public:
        LocalJpeg(const VRayImage* img, int quality = 0) {
            bufSize = Internal::VRayImage_compressToJpeg(img, quality, &bufAddr, nullptr);
        }
 
        LocalJpeg(const VRayImage* img, const VRayRenderer& renderer, int quality = 0) {
            bufSize = Internal::VRayImage_compressToJpeg(img, quality, &bufAddr, renderer.getNativeRenderer());
        }
    };
 
    class LocalPng : public CompressImage {
 
    public:
        LocalPng(const VRayImage* img, bool preserveAlpha = false) {
            bufSize = Internal::VRayImage_compressToPng(img, preserveAlpha, &bufAddr, nullptr);
        }
 
        LocalPng(const VRayImage* img, const VRayRenderer& renderer, bool preserveAlpha = false) {
            bufSize = Internal::VRayImage_compressToPng(img, preserveAlpha, &bufAddr, renderer.getNativeRenderer());
        }
    };
 
    class LocalBmp : public CompressImage {
 
    public:
        LocalBmp(const VRayImage* img, bool preserveAlpha = false, bool swapChannels = false) {
            bufSize = Internal::VRayImage_convertToBmp(img, preserveAlpha, &bufAddr, NULL, swapChannels ? 1 : 0);
        }
 
        LocalBmp(const VRayImage* img, const VRayRenderer& renderer, bool preserveAlpha = false, bool swapChannels = false) {
            bufSize = Internal::VRayImage_convertToBmp(img, preserveAlpha, &bufAddr, renderer.getNativeRenderer(), swapChannels ? 1 : 0);
        }
    };
 
    template<class T>
    T plugin_cast(Plugin plugin) {
        return *static_cast<T*>(&plugin);
    }
 
    template<class T>
    PluginRefT<T> plugin_cast(PluginRef pluginRef) {
        // won't compile if T doesn't inherit from Plugin
        return *static_cast<PluginRefT<T>*>(static_cast<T*>(static_cast<Plugin*>(&pluginRef)));
    }
 
    template<class T>
    T plugin_checked_cast(Plugin plugin) {
        return plugin_cast<T>(plugin.getTypeId() != T::getTypeId() ? Plugin() : plugin);
    }
 
    template<class T>
    PluginRefT<T> plugin_checked_cast(PluginRef pluginRef) {
        return plugin_cast<T>(pluginRef.getTypeId() != T::getTypeId() ? PluginRef() : pluginRef);
    }
 
    namespace Internal {
        template<typename PluginType>
        inline bool _isPluginOfTypes(PluginTypeId typeId) {
            return typeId == PluginType::getTypeId();
        }
 
        template<typename PluginType0, typename PluginType1, typename... RemainingTypes>
        inline bool _isPluginOfTypes(PluginTypeId typeId) {
            return typeId == PluginType0::getTypeId() || _isPluginOfTypes<PluginType1, RemainingTypes...>(typeId);
        }
    }
 
    template<typename PluginType>
    inline bool isPluginOfType(const Plugin& plugin) {
        return plugin.getTypeId() == PluginType::getTypeId();
    }
 
    template<typename PluginType, typename... Types>
    inline bool isPluginOfTypes(const Plugin& plugin) {
        return Internal::_isPluginOfTypes<PluginType, Types...>(plugin.getTypeId());
    }
 
    inline bool isPluginOfType(const Plugin& plugin, const char* type) {
        return plugin.isNotEmpty() && strcmp(plugin.getType(), type) == 0;
    }
 
    template <size_t N>
    inline bool isPluginOfTypes(const Plugin& plugin, const char* const (&types)[N]) {
        if (plugin.isNotEmpty()) {
            const char* type = plugin.getType();
            for (size_t i = 0; i < N; ++i) {
                if (strcmp(type, types[i]) == 0)
                    return true;
            }
        }
        return false;
    }
 
    template <size_t N>
    inline bool isPluginOfTypes(const Plugin& plugin, const PluginTypeId (&types)[N]) {
        PluginTypeId typeId = plugin.getTypeId();
        for (size_t i = 0; i < N; ++i) {
            if (typeId == types[i])
                return true;
        }
        return false;
    }
 
    namespace OCIO {
        enum SourceMode : int {
            Automatic = 0,
            Environment,
            File,
            Internal,
        };
 
        struct OCIOConfigurationData {
            std::vector<std::string> colorSpaces;
            std::vector<std::string> colorSpaceFamilies;
            std::vector<std::string> roles;
            std::vector<std::string> roleColorSpaces;
            std::vector<std::string> looks;
            std::vector<std::string> devices;
            std::vector<std::string> viewTransforms;
            char familySeparator;
 
            OCIOConfigurationData(const char* fileName = NULL, SourceMode vraySourceType = SourceMode::Automatic)
                : errorCode(OCIOResult::Result_OK) {
 
                Internal::OCIOData internalOCIOData;
                errorCode = (OCIOResult)Internal::VRay_OCIO_initData(&internalOCIOData, fileName, (int)vraySourceType);
                if (errorCode != OCIOResult::Result_OK) {
                    const char* ending = internalOCIOData.status ? internalOCIOData.status : "<unknown>";
                    errorString = std::string("Failed initializing OCIO configuration: ") + ending;
                    Internal::VRay_OCIO_freeData(&internalOCIOData);
#ifndef VRAY_NOTHROW
                    throw VRayException(errorString);
#endif
                    return;
                }
 
                familySeparator = char(internalOCIOData.familySeparator);
 
                convertRawData(colorSpaces, internalOCIOData.colorSpaces, internalOCIOData.colorSpacesCount);
                if (internalOCIOData.colorSpaceFamilies) {
                    convertRawData(colorSpaceFamilies, internalOCIOData.colorSpaceFamilies, internalOCIOData.colorSpacesCount);
                }
                convertRawData(roles, internalOCIOData.roles, internalOCIOData.rolesCount);
                convertRawData(roleColorSpaces, internalOCIOData.roleColorSpaces, internalOCIOData.rolesCount);
 
                convertRawData(looks, internalOCIOData.looks, internalOCIOData.looksCount);
                convertRawData(devices, internalOCIOData.devices, internalOCIOData.devicesCount);
                convertRawData(viewTransforms, internalOCIOData.viewTransforms, internalOCIOData.viewTransformsCount);
 
                Internal::VRay_OCIO_freeData(&internalOCIOData);
            }
 
            std::string getErrorString() const {
                return errorString;
            }
 
        private:
            enum OCIOResult : int {
                Result_OK = 0, 
                Result_FileNotFound, 
                Result_OCIOException, 
                Result_EmptyConfiguration, 
                Result_InternalException = -1 
            } errorCode;
 
            std::string errorString;
 
            void convertRawData(std::vector<std::string>& output, char const* const* input, const int inputCount) {
                output.clear();
                output.reserve(inputCount);
                for (int i = 0; i < inputCount; ++i) {
                    output.emplace_back(input[i]);
                }
            }
        };
    }
 
    bool setEnvVar(const char* name, const char* value);
 
    const char* getEnvVar(const char* name);
 
    enum OSLParameterType {
        OSL_TYPE_UNSUPPORTED, 
        OSL_TYPE_INT, 
        OSL_TYPE_BOOL, 
        OSL_TYPE_FLOAT, 
        OSL_TYPE_STRING, 
        OSL_TYPE_TEXTURE, 
        OSL_TYPE_COLOR, 
        OSL_TYPE_VECTOR, 
        OSL_TYPE_OUTPUT_CLOSURE, 
        OSL_TYPE_OUTPUT_COLOR, 
        OSL_TYPE_OUTPUT_FLOAT, 
        OSL_TYPE_MENU 
    };
 
    struct OSLInputParameter {
        std::string name; 
        OSLParameterType type; 
        Value defaultValue; 
    };
 
    struct OSLParameters {
        std::vector<std::string> outputColorParams; 
        std::vector<std::string> outputFloatParams; 
        std::vector<std::string> outputClosureParams; 
        std::vector<OSLInputParameter> inputParams; 
    };
 
    Error getOSLParameters(const char* fileName, OSLParameters& params);
 
    Error getOSLParameters(const std::string& fileName, OSLParameters& params);
 
    enum OSLSourceType {
        OSL_SOURCE_TYPE_OSL = 1, 
        OSL_SOURCE_TYPE_OSO = 2, 
    };
 
    enum OSLSourceEncoding {
        OSL_SOURCE_ENC_TXT, 
        OSL_SOURCE_ENC_BASE64, 
    };
 
    Error getOSLParameters(const char* src, OSLSourceType type, OSLSourceEncoding encoding, OSLParameters& params);
 
    Error getOSLParameters(const std::string& src, OSLSourceType type, OSLSourceEncoding encoding, OSLParameters& params);
 
    class ScenePreview {
        void* vrsceneDesc;
        void createThis(const char* filename, const void* settings);
        ScenePreview(const ScenePreview&);
 
    public:
        struct Settings;
        class Object;
        struct Particle;
 
        enum ObjectType {
            ObjectTypeAll = 0,
            ObjectTypeNode,
            ObjectTypeNodeParticle,
            ObjectTypeLight,
            ObjectTypeInstancer,
            ObjectTypeVolume,
            ObjectTypeVRayScene,
            ObjectTypeMaterial,
            ObjectTypeDecal,
            ObjectTypeClipper,
        };
 
        enum DataType {
            DataTypeAll = -1,
            DataTypeNoData = 0,
            DataTypeMesh = (1 << 0),
            DataTypeHair = (1 << 1),
            DataTypeParticles = (1 << 2),
            DataTypeVolume = (1 << 3),
            DataTypeInfinitePlane = (1 << 4),
            DataTypeInstancer2 = (1 << 5),
            DataTypeVRayProxy = (1 << 6),
            DataTypeRayserverInstancer = (1 << 7),
            DataTypeStaticMesh = (1 << 8),
            DataTypePerfectSphere = (1 << 9),
            DataTypeGeomInstancer = (1 << 10),
 
            DataTypeHasInstances = DataTypeInstancer2 | DataTypeRayserverInstancer | DataTypeGeomInstancer,
 
            ObjectDataTypeAll = DataTypeAll,
            ObjectDataTypeNoData = DataTypeNoData,
            ObjectDataTypeMesh = DataTypeMesh,
            ObjectDataTypeHair = DataTypeHair,
            ObjectDataTypeParticles = DataTypeParticles,
            ObjectDataTypeVolume = DataTypeVolume,
            ObjectDataTypeInfinitePlane = DataTypeInfinitePlane,
            ObjectDataTypeInstancer2 = DataTypeInstancer2,
            ObjectDataTypeVRayProxy = DataTypeVRayProxy,
            ObjectDataTypeRayserverInstancer = DataTypeRayserverInstancer,
            ObjectDataTypeStaticMesh = DataTypeStaticMesh,
            ObjectDataTypePerfectSphere = DataTypePerfectSphere,
            ObjectDataTypeGeomInstancer = DataTypeGeomInstancer,
 
            ObjectDataTypeHasInstances = DataTypeHasInstances,
        };
 
        enum LightType {
            LightTypeUnsupported = 0,
            LightTypeOmni,
            LightTypeRectangle,
            LightTypeSphere,
            LightTypeDirect,
            LightTypeSpot,
            LightTypeSun,
            LightTypeIES,
            LightTypeDome,
            LightTypeMesh,
        };
 
        enum UpAxis {
            UpAxisUnknown = -1,
            UpAxisZ = 0,
            UpAxisY,
        };
 
        struct Sizes2D {
            float width;
            float length;
        };
 
        struct Sizes3D {
            float width;
            float height;
            float length;
        };
 
        explicit ScenePreview(const char* filename);
 
        ScenePreview(const char* filename, const Settings& settings);
 
        ~ScenePreview();
 
        std::vector<Object> getObjects(ObjectType objectType = ObjectTypeAll, DataType dataType = DataTypeAll) const;
 
        Object getObject(const char* name) const;
 
        operator bool() const {
            return !!vrsceneDesc;
        }
 
        bool operator!() const {
            return !vrsceneDesc;
        }
 
        UpAxis getUpAxis() const;
 
        float getMetersScale() const;
 
        float getPhotometricScale() const;
 
        float getSecondsScale() const;
 
        float getFramesScale() const;
 
        int getFrameStart() const;
 
        int getFrameEnd() const;
 
        int getFPS() const;
 
        size_t getTotalFaces() const;
    };
 
    struct ScenePreview::Settings {
        enum CacheType {
            CacheTypeSingle=0,
            CacheTypeNone=1,
            CacheTypeRam=2
        };
 
        enum CoordinateSystem {
            CoordinateSystemRightHanded=0,
            CoordinateSystemLeftHanded=1
        };
 
        Settings() :
            usePreview(true),
            previewFacesCount(100000),
            minPreviewFaces(64),
            maxPreviewFaces(10000),
            cacheType(CacheType::CacheTypeSingle),
            coordinateSystem(CoordinateSystem::CoordinateSystemRightHanded) {
        }
 
        Bool usePreview;
        int previewFacesCount;
        int minPreviewFaces;
        int maxPreviewFaces;
        CacheType cacheType;
        CoordinateSystem coordinateSystem;
    };
 
    class ScenePreview::Object {
        friend class ScenePreview;
 
        void* objectBase;
 
        static void addDataTypeStringHelperPrivate(std::string& currentString, DataType types, DataType dataType, const char* typeString);
 
        explicit Object(void* objectBase) : objectBase(objectBase) {}
        Object(void* vrsceneDesc, const char* name);
 
    public:
        Object() : objectBase() {}
 
        const char* getName() const;
 
        bool isValid() const {
            return !!objectBase;
        }
 
        ObjectType getType() const;
 
        const char* getTypeAsString() const;
 
        Transform getTransform(double time = 0) const;
 
        bool getVisibility(double time = 0) const;
 
        const char* getNodeDataName() const;
 
        DataType getDataType() const;
 
        std::string getDataTypeAsString() const;
 
        VRay::Box getWorldBoundingBox(double time = 0);
 
        VRay::Box getMeshBoundingBox(double time = 0);
 
#ifndef VRAY_SDK_INTEROPERABILITY
        VectorList getMeshVertices(double time = 0);
 
        IntList getMeshFaces(double time = 0);
 
        VectorList getHairVertices(double time = 0);
 
        IntList getHairNumVertices(double time = 0);
 
        int getMeshVerticesFast(const Vector* &vertices, double time = 0);
 
        int getMeshFacesFast(const int* &faces, double time = 0);
 
        int getHairVerticesFast(const Vector* &vertices, double time = 0);
 
        int getHairNumVerticesFast(const int* &lengths, double time = 0);
#else
        VUtils::VectorRefList getMeshVertices(double time = 0);
 
        VUtils::IntRefList getMeshFaces(double time = 0);
 
        VUtils::VectorRefList getHairVertices(double time = 0);
 
        VUtils::IntRefList getHairNumVertices(double time = 0);
#endif
 
        std::vector<Particle> getInstancerParticles(double time = 0);
 
        Sizes3D getDecalSize(double time = 0);
        Sizes2D getClipperSize(double time = 0);
    };
 
    struct ScenePreview::Particle {
        friend class Object;
 
        Object node;
 
        Transform transform;
 
        Object material;
 
        int particleId;
 
        bool isValid() const {
            return node.isValid();
        }
 
        //char* getUserAttributes() const;
        //~Particle();
    //private:
        //void* userAttributes;
    };
 
    class UVTextureSampler {
        void *internalTextureSampler;
 
    public:
        UVTextureSampler();
        UVTextureSampler(const UVTextureSampler &r) = delete;
        UVTextureSampler& operator=(const UVTextureSampler &rhs) = delete;
        UVTextureSampler(UVTextureSampler &&r) noexcept;
        UVTextureSampler& operator=(UVTextureSampler &&rhs) noexcept;
        ~UVTextureSampler();
 
    public:
        bool setupRenderer(VRayRenderer &renderer);
 
        bool releaseRenderer(VRayRenderer &renderer);
 
        bool sample(const PluginRef &pluginRef, float u, float v, AColor &result);
 
        bool sample(const PluginRef &pluginRef, float u, float v, float &result);
 
        bool sample(const PluginRef &pluginRef, float u, float v, int &result);
 
        VRayImage* sampleArea(const PluginRef &pluginRef, float u_start, float u_end, float v_start, float v_end, int width, int height);
 
        FloatList sampleAreaFloat(const PluginRef &pluginRef, float u_start, float u_end, float v_start, float v_end, int width, int height);
 
        IntList sampleAreaInt(const PluginRef &pluginRef, float u_start, float u_end, float v_start, float v_end, int width, int height);
 
    private:
        template<typename ListType, typename SampleFunction>
        static std::vector<ListType> sampleAreaAsListResult(int width, int height, SampleFunction &&sampleArea);
    };
 
    namespace Util {
 
        struct PluginLink {
            Plugin fromPlugin; 
            std::string fromProperty; 
            PluginRef toPlugin; 
 
            bool operator==(const PluginLink& other) const noexcept {
                return fromPlugin == other.fromPlugin && fromProperty == other.fromProperty && toPlugin == other.toPlugin;
            }
 
            bool operator!=(const PluginLink& other) const noexcept {
                return fromPlugin != other.fromPlugin || fromProperty != other.fromProperty || toPlugin != other.toPlugin;
            }
 
            bool operator<(const PluginLink& other) const noexcept {
                if (fromPlugin != other.fromPlugin)
                    return fromPlugin < other.fromPlugin;
                if (fromProperty != other.fromProperty)
                    return fromProperty < other.fromProperty;
                return toPlugin < other.toPlugin;
            }
 
            bool operator<=(const PluginLink& other) const noexcept {
                if (fromPlugin < other.fromPlugin) return true;
                if (fromPlugin > other.fromPlugin) return false;
                if (fromProperty < other.fromProperty) return true;
                if (fromProperty > other.fromProperty) return false;
                return toPlugin < other.toPlugin;
            }
        };
 
        std::vector<PluginLink> getChildPlugins(Plugin root, bool recursive);
 
        std::vector<PluginLink> getParentPlugins(Plugin child, bool recursive = false);
 
        float getIESPrescribedIntensity(const char* iesLightFileName);
 
        float getIESPrescribedIntensity(const std::string& iesLightFileName);
    }
 
    struct CheckDRHostResult {
        enum Status {
            ErrorMemory = -4,
 
            ErrorResolve = -3,
 
            ErrorConnect = -2,
 
            ErrorTimeout = -1,
 
            ServerReady = 0,
 
            ServerUnknown = 1,
 
            ServerError = 2,
 
            ServerBusy = 3
        } status; 
 
        int cpuCount;
 
        int vrayVersion;
 
        std::string hostResolved;
 
        std::string hostConnectedTo; // valid only if ServerBusy
 
        std::string revisionTime;
    };
 
    CheckDRHostResult checkDRHost(const char* host);
 
    CheckDRHostResult checkDRHost(const std::string& host);
 
    struct BinUserAttributesWriter {
 
        BinUserAttributesWriter() : index() {}
 
        enum BinUserAttributeType : byte {
            binUserAttributeType_int = 0,
            binUserAttributeType_float,
            binUserAttributeType_vector,
            binUserAttributeType_acolor,
            binUserAttributeType_string,
            binUserAttributeType_last,
        };
 
        enum BinUserAttributeTypeFlags : byte {
            binUserAttributeFlag_small = 1 << 3,
 
            binUserAttributeFlag_smallY = 1 << 2,
 
            binUserAttributeFlag_smallZ = 1 << 1,
 
            binUserAttributeFlag_smallA = 1 << 0,
        };
 
        template<size_t count>
        void add(const char(&name)[count], int value) {
            add(name, count - 1, value);
        }
 
        template<size_t count>
        void add(const char(&name)[count], float value) {
            add(name, count - 1, value);
        }
 
        template<size_t count>
        void add(const char(&name)[count], const Vector& value) {
            add(name, count - 1, value);
        }
 
        template<size_t count>
        void add(const char(&name)[count], const AColor& value) {
            add(name, count - 1, value);
        }
 
        template<size_t nameLen>
        void add(const char(&name)[nameLen], const char* value, size_t valueLen) {
            add(name, nameLen - 1, value, valueLen);
        }
 
        template<size_t nameLen, size_t valueLen>
        void add(const char(&name)[nameLen], const char(&value)[valueLen]) {
            add(name, nameLen - 1, value, valueLen - 1);
        }
 
        template<size_t nameLen>
        void add(const char(&name)[nameLen], const std::string& value) {
            add(name, nameLen - 1, value.c_str(), value.length());
        }
 
        void add(const std::string& name, int value) {
            add(name.c_str(), name.length(), value);
        }
 
        void add(const std::string& name, float value) {
            add(name.c_str(), name.length(), value);
        }
 
        void add(const std::string& name, const Vector& value) {
            add(name.c_str(), name.length(), value);
        }
 
        void add(const std::string& name, const AColor& value) {
            add(name.c_str(), name.length(), value);
        }
 
        void add(const std::string& name, const char* value, size_t valueLen) {
            add(name.c_str(), name.length(), value, valueLen);
        }
 
        template<size_t valueLen>
        void add(const std::string& name, const char(&value)[valueLen]) {
            add(name.c_str(), name.length(), value, valueLen - 1);
        }
 
        void add(const std::string& name, const std::string& value) {
            add(name.c_str(), name.length(), value.c_str(), value.length());
        }
 
        void add(const char* name, size_t nameLen, int value) {
            appendString(name, nameLen);
 
            if (value >= -128 && value <= 127) {
                const byte attrType = binUserAttributeType_int | (binUserAttributeFlag_small << 4);
                resize(2);
                write(attrType);
                write(sbyte(value));
            } else {
                resize(1 + sizeof(int));
                write(binUserAttributeType_int);
                write(value);
            }
        }
 
        void add(const char* name, size_t nameLen, float value) {
            appendString(name, nameLen);
 
            byte attrType = binUserAttributeType_float;
            byte writeSize = 1;
 
            const SmallFloat smallValue(value, attrType, binUserAttributeFlag_small, writeSize);
            resize(writeSize);
            write(attrType);
            smallValue.write(*this);
        }
 
        void add(const char* name, size_t nameLen, const Vector& value) {
            appendString(name, nameLen);
 
            byte attrType = binUserAttributeType_vector;
            byte writeSize = sizeof(byte);
 
            const SmallFloat smallX(value.x, attrType, binUserAttributeFlag_small, writeSize);
            const SmallFloat smallY(value.y, attrType, binUserAttributeFlag_smallY, writeSize);
            const SmallFloat smallZ(value.z, attrType, binUserAttributeFlag_smallZ, writeSize);
 
            resize(writeSize);
            write(attrType);
 
            smallX.write(*this);
            smallY.write(*this);
            smallZ.write(*this);
        }
 
        void add(const char* name, size_t nameLen, const AColor& value) {
            appendString(name, nameLen);
 
            byte attrType = binUserAttributeType_acolor;
            byte writeSize = sizeof(byte);
 
            const SmallFloat smallR(value.color.r, attrType, binUserAttributeFlag_small, writeSize);
            const SmallFloat smallG(value.color.g, attrType, binUserAttributeFlag_smallY, writeSize);
            const SmallFloat smallB(value.color.b, attrType, binUserAttributeFlag_smallZ, writeSize);
            const SmallFloat smallA(value.alpha, attrType, binUserAttributeFlag_smallA, writeSize);
 
            resize(writeSize);
 
            write(attrType);
 
            smallR.write(*this);
            smallG.write(*this);
            smallB.write(*this);
            smallA.write(*this);
        }
 
        void add(const char* name, size_t nameLen, const char* value, size_t valueLen) {
            appendString(name, nameLen);
 
            resize(1);
            write(binUserAttributeType_string);
 
            appendString(value, valueLen);
        }
 
        void close() {
            resize(1);
            write('\0');
        }
 
        size_t getNumBytes() const {
            return index;
        }
 
        bool hasData() const {
            // Close will write one termination char '\0'.
            // Having only name also doesn't make sense.
            return index > 2;
        }
 
        IntList toIntList() {
            resize(1);
            write('\0'); // finalize attributes
 
            index = 0;
            IntList temp;
            temp.swap(data);
            return temp;
        }
 
        std::string toString() const {
            const byte* bytes = reinterpret_cast<const byte*>(data.data());
            size_t count = getNumBytes();
            std::string chars(count * 3 + 2, '\0');
 
            for (size_t i = 0; i < count; ++i) {
                byte b = bytes[i];
                chars[3 * i + 0] = getHexChar(b >> 4);
                chars[3 * i + 1] = getHexChar(b & 0xf);
                chars[3 * i + 2] = ' ';
            };
            chars[3 * count + 0] = '0';
            chars[3 * count + 1] = '0';
 
            return chars;
        }
 
    private:
        // If float value could be represented as an int (values like 0.0, 1.0, 42.0)
        // and fits in int8 [SCHAR_MIN, SCHAR_MAX] it'll be written as a single byte
        // setting one of BinUserAttributeTypeFlags "small" flags.
        struct SmallFloat {
            SmallFloat(float value, byte& attrType, byte smallFlag, byte& writeSize)
                : value(value)
                , smallFloat(0)
                , isSmall(false)
            {
                const float roundValue = roundf(value);
                const bool almostInt = std::abs(value - roundValue) < 1e-6f;
                isSmall = almostInt && roundValue >= -128 && roundValue <= 127;
                if (!isSmall) {
                    writeSize += sizeof(float);
                }
                else {
                    smallFloat = sbyte(roundValue);
                    attrType |= (smallFlag << 4);
                    writeSize += sizeof(sbyte);
                }
            }
 
            // Get original float value.
            float getFloat() const { return value; }
 
            // Get value that fits in int8.
            sbyte getSmallFloat() const { return smallFloat; }
 
            // Check if value could be stored as int8.
            bool getIsSmall() const { return isSmall; }
 
            // Write value to buffer.
            void write(BinUserAttributesWriter& buf) const {
                if (isSmall)
                    buf.write(smallFloat);
                else
                    buf.write(value);
            }
 
        private:
            const float value;
            sbyte smallFloat;
            bool isSmall;
        };
 
        inline static char getHexChar(byte b) {
            return b < 10 ? b + '0' : b - 10 + 'A';
        }
 
        // Append string bytes along with null-terminator.
        // @param name String value.
        // @param nameLen String value length (without null-terminator).
        void appendString(const char* name, size_t nameLen) {
            // We'll write name along with '\0' terminator.
            resize(nameLen + 1);
            memcpy(ptr(), name, nameLen);
            index += nameLen;
            *(ptr()) = 0;
            ++index;
        }
 
        // Resize container, write bytes_count bytes, increment index.
        void append(const void* bytes, size_t bytes_count) {
            resize(bytes_count);
            memcpy(ptr(), bytes, bytes_count);
            index += bytes_count;
        }
 
        // Resize container, write data, increment index.
        template<typename T>
        void append(const T& value) {
            resize(sizeof(T));
            write(value);
        }
 
        // Write data, increment index. Container must have been resized beforehand.
        template<typename T>
        void write(const T& value) {
            *reinterpret_cast<T*>(ptr()) = value;
            index += sizeof(T);
        }
 
        // Resize serialization buffer to fit extra bytes.
        // @param bytesToAdd Bytes count to accomodate.
        void resize(size_t bytesToAdd) {
            size_t newSize = index + bytesToAdd;
            if (newSize > data.size() * sizeof(int)) {
                data.resize((newSize + sizeof(int) - 1) / sizeof(int));
            }
        }
 
        // Return the current data byte pointer.
        byte* ptr() {
            return reinterpret_cast<byte*>(data.data()) + index;
        }
 
        // Serialization storage.
        std::vector<int> data;
 
        // Byte index inside data, size in bytes.
        size_t index;
    };
 
    inline std::ostream& operator <<(std::ostream& stream, const BinUserAttributesWriter& writer) {
        stream << writer.toString();
        return stream;
    }
} // namespace VRay
 
#ifdef VRAY_SDK_INTEROPERABILITY
#include "vrayinterop.hpp"
#endif
 
#include "_vraysdk_implementation.hpp"
 
#ifdef _MSC_VER
#   pragma warning(pop) // 4201
#endif // _MSC_VER
 
#endif // _VRAY_SDK_HPP_