vraysrv.hpp

#ifndef _VRAY_SRV_HPP_
#define _VRAY_SRV_HPP_
 
#ifndef VRAY_NOTHROW
#include "vraythrow.hpp"
#endif
 
#include <cstdint>
#include <cstdlib>
#include <ostream>
#include <cstring>
#include <string>
 
#include "_vraysdk_utils.hpp"
 
namespace VRay {
 
    class VRayServerNative;
    class VRayServer;
    class VRayLiveLinkServerNative;
    class VRayLiveLinkServer;
 
    enum MessageLevel {
        MessageError = 0,
        MessageWarning = 1,
        MessageInfo = 2,
        MessageDebug = 3
    };
 
    enum ExportSceneFlags {
        ExportSceneFlags_Full = 0, 
        ExportSceneFlags_Changes = 1 << 0, 
        ExportSceneFlags_Deleted = 1 << 1, 
    };
 
    enum SceneUpdateActionCode {
        AC_PLUGIN_DELETED,
        AC_PLUGIN_RESTORED,  // deprecated, don't use
        AC_NEW_PLUGIN,
        AC_PARAMVALUE_CHANGED,
        AC_RECOMPILE_GEOMETRY,
        AC_CLEAR_SCENE,
        AC_SCENE_SENT,
        AC_PLUGIN_REPLACED,
        AC_CHANGE_COMPLETE, // Completed a batch of changes to the scene; multiple AC_CHANGE_COMPLETE messages should be compressed into one.
        AC_NOP, // Ignore this change.
        AC_APPEND_FILE, // Read and append the plugins from the specified .vrscene file
        AC_APPEND_STREAM, // Read and append the plugins from the specified stream(e.g .vrscene file, text)
        AC_RENAME_PLUGIN,
 
        AC_BEGIN_CHANGE = 100,
        AC_PREAPPLY_CHANGE = 101,
        AC_END_CHANGE = 102,
    };
 
    struct ServerOptions {
        int portNumber;                               
        int numThreads;                               
        std::string remoteScenePath;                  
        std::string pluginLibraryPath;                
        std::string includePaths;                     
        union {
            int flags;
            struct {
                bool noRenderLicensePreCheck : 1;     
                bool changeCurrentDirectory : 1;      
                bool keepSceneInMemory : 1;           
                bool overwriteLocalCacheSettings : 1; 
                bool runAsLiveLink : 1;               
            };
        };
        enum AssetCacheLimit {
            CACHE_NO_LIMIT = 0,
            CACHE_HOUR_LIMIT = 1,
            CACHE_GB_LIMIT = 2,
        } cachedAssetsLimitType;
        float cachedAssetsLimitValue;                 
 
        // DR2 specific options
        union {
            int dr2Flags;
            struct {
                bool dr2AsDispatcher : 1;             
                bool dr2RunLocalRenderServer : 1;     
                bool dr2SecureConnection : 1;         
                bool dr2DisableUdp : 1;               
                bool dr2ListenOnIpv4 : 1;             
                bool dr2ListenOnIpv6 : 1;             
                bool dr2PipelinedUpstream : 1;        
            };
        };
        std::string dr2HttpProxy;                     
        int dr2WorkerThreadsPerServer;                
        int dr2ConnectTimeout;                        
        int dr2UpstreamChannels;                      
 
        ServerOptions() : portNumber(), numThreads(), flags(), cachedAssetsLimitType(), cachedAssetsLimitValue()
            , dr2Flags(), dr2HttpProxy(), dr2WorkerThreadsPerServer(2), dr2ConnectTimeout(10), dr2UpstreamChannels(3) {
            dr2ListenOnIpv4 = true;
#ifndef __APPLE__
            dr2ListenOnIpv6 = true;
#endif
            dr2PipelinedUpstream = true;
        }
        ServerOptions(const ServerOptions& options) = default;
        ServerOptions(ServerOptions&& options) = default;
        ServerOptions& operator=(const ServerOptions& options) = default;
        ServerOptions& operator=(ServerOptions&& options) = default;
 
        void swap(ServerOptions& options) noexcept {
            std::swap(portNumber, options.portNumber);
            std::swap(numThreads, options.numThreads);
            remoteScenePath.swap(options.remoteScenePath);
            pluginLibraryPath.swap(options.pluginLibraryPath);
            includePaths.swap(options.includePaths);
            std::swap(flags, options.flags);
            std::swap(cachedAssetsLimitType, options.cachedAssetsLimitType);
            std::swap(cachedAssetsLimitValue, options.cachedAssetsLimitValue);
            std::swap(dr2Flags, options.dr2Flags);
            dr2HttpProxy.swap(options.dr2HttpProxy);
            std::swap(dr2WorkerThreadsPerServer, options.dr2WorkerThreadsPerServer);
            std::swap(dr2ConnectTimeout, options.dr2ConnectTimeout);
            std::swap(dr2UpstreamChannels, options.dr2UpstreamChannels);
        }
    };
 
    struct LiveLinkServerOptions {
        int portNumber;                               
        union {
            int flags;
            struct {
                bool noRenderLicensePreCheck : 1;     
            };
        };
 
        LiveLinkServerOptions() : portNumber(0), flags() {
        }
        LiveLinkServerOptions(const LiveLinkServerOptions& options) = default;
        LiveLinkServerOptions(LiveLinkServerOptions&& options) = default;
        LiveLinkServerOptions& operator=(const LiveLinkServerOptions& options) = default;
        LiveLinkServerOptions& operator=(LiveLinkServerOptions&& options) = default;
 
        void swap(LiveLinkServerOptions& options) noexcept {
            std::swap(portNumber, options.portNumber);
            std::swap(flags, options.flags);
        }
    };
 
    namespace Internal {
 
        struct ServerOptions_Internal {
            int portNumber;
            int numThreads;
            const char* remoteScenePath;
            const char* pluginLibraryPath;
            const char* includePaths;
            int flags;
            ServerOptions::AssetCacheLimit cachedAssetsLimitType;
            float cachedAssetsLimitValue;
            int dr2Flags;
            const char* dr2HttpProxy;
            int dr2WorkerThreadsPerServer;
            int dr2ConnectTimeout;
            int dr2UpstreamChannels;
 
            ServerOptions_Internal(const ServerOptions &opts) {
                portNumber = opts.portNumber;
                numThreads = opts.numThreads;
                remoteScenePath = (opts.remoteScenePath.empty()) ? nullptr : opts.remoteScenePath.c_str();
                pluginLibraryPath = (opts.pluginLibraryPath.empty()) ? nullptr : opts.pluginLibraryPath.c_str();
                includePaths = (opts.includePaths.empty()) ? nullptr : opts.includePaths.c_str();
                flags = opts.flags;
                cachedAssetsLimitType = opts.cachedAssetsLimitType;
                cachedAssetsLimitValue = opts.cachedAssetsLimitValue;
                dr2Flags = opts.dr2Flags;
                dr2HttpProxy = (opts.dr2HttpProxy.empty()) ? nullptr : opts.dr2HttpProxy.c_str();
                dr2WorkerThreadsPerServer = opts.dr2WorkerThreadsPerServer;
                dr2ConnectTimeout = opts.dr2ConnectTimeout;
                dr2UpstreamChannels = opts.dr2UpstreamChannels;
            }
        };
 
        struct LiveLinkServerOptions_Internal {
            int portNumber;
            int flags;
 
            LiveLinkServerOptions_Internal(const LiveLinkServerOptions& opts) {
                portNumber = opts.portNumber;
                flags = opts.flags;
            }
        };
    }
}
 
// internal function declarations
#include "_vraysrv_import.hpp"
 
namespace VRay {
    inline std::string LicenseError::toString() const {
        char* str = Internal::VRay_getLicenseErrorTextStringFromErrorCode(errs);
        std::string res = str;
        Internal::C_memory_free(str);
        return res;
    }
 
    inline std::ostream& operator <<(std::ostream& stream, const LicenseError& err) {
        char* str = Internal::VRay_getLicenseErrorTextStringFromErrorCode(err.errs);
        stream << (str ? str : "");
        Internal::C_memory_free(str);
        return stream;
    }
 
    struct ExternalString {
        ExternalString() = delete;
        ExternalString(const ExternalString&) = delete;
        ExternalString& operator=(const ExternalString &image) = delete;
 
        const char* getData() const {
            return reinterpret_cast<const char*>(this);
        }
        char* getData() {
            return reinterpret_cast<char*>(this);
        }
        static void operator delete(void* p) {
            Internal::C_memory_free(p);
        }
        static void* operator new (size_t) = delete;
        static void* operator new[](size_t) = delete;
        static void  operator delete[](void*) = delete;
    };
 
#if !defined(VRAY_RUNTIME_LOAD_PRIMARY) && !defined(VRAY_RUNTIME_LOAD_SECONDARY)
 
    class VRayServerInit {
        VRayServerInit(VRayServerInit&);    // copy construction disabled
 
    public:
        VRayServerInit() {}
 
        ~VRayServerInit() {
            Internal::VRay_LicenseManager_releaseLicense();
        }
    };
 
#elif defined(VRAY_RUNTIME_LOAD_PRIMARY)
 
#ifdef _MSC_VER
#   pragma warning(push)
#   pragma warning(disable: 4706) // "assignment within conditional expression" - for VRayServerInit::importFunctions()
#endif // _MSC_VER
 
    class VRayServerInit {
        VRayServerInit(VRayServerInit&);    // copy construction disabled
 
    public:
        explicit VRayServerInit(const char* const libraryFileName) {
            initialize(libraryFileName);
        }
 
        ~VRayServerInit() {
            if (Internal::VRay_LicenseManager_releaseLicense)
                Internal::VRay_LicenseManager_releaseLicense();
            release();
        }
 
        operator bool() const {
            return !!hLib;
        }
 
    protected:
        VRayServerInit() {}
 
        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) {
            if (!libraryFileName) {
                if ((hLib = LoadUtils::tryPreloadSDKLibraryFromEnvVar(VRAY_XSTRING(APPSDK_ENV_VAR_BIN_FOLDER), false))) {
                    importFunctions();
                    return;
                }
                if ((hLib = LoadUtils::tryPreloadSDKLibraryFromEnvVar(VRAY_XSTRING(VRAY_SDK_ENV_VAR), true))) {
                    importFunctions();
                    return;
                }
            }
            hLib = LoadUtils::loadLibrary(libraryFileName);
            importFunctions();
        }
 
        void importFunctions() {
#   ifdef VRAY_NOTHROW
#       define PROC_IMPORT_FAIL(message) return makeError(LoadUtils::getLoaderError(message))
#   else
#       define PROC_IMPORT_FAIL(message) throw InitErr( (errString = LoadUtils::getLoaderError(message)) )
#   endif
 
            if (!hLib)
                PROC_IMPORT_FAIL("Cannot load V-Ray SDK Library file.");
 
#   define VRAY_INTERNAL_GENERATE_IMPORT_CODE
#   include "_vraysrv_import.hpp"
#   undef VRAY_INTERNAL_GENERATE_IMPORT_CODE
        }
 
#ifdef _MSC_VER
#   pragma warning(pop)
#endif // _MSC_VER
 
        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)
 
 
    class VRayServer {
        VRayServer(const VRayServer&);
        VRayServer& operator=(const VRayServer&);
 
        VRayServerNative* serverNative;
        LicenseError licErr;
 
        static VRayServer* getVRayServer(void* serverNative) {
            return static_cast<VRayServer*>(Internal::VRay_VRayServer_getUserData(static_cast<VRayServerNative*>(serverNative), 0));
        }
 
        void createInstance(const Internal::ServerOptions_Internal* options) {
            serverNative = Internal::VRay_VRayServer_create(options, &licErr.errs);
            if (serverNative) Internal::VRay_VRayServer_setUserData(serverNative, 0, this);
#ifndef VRAY_NOTHROW
            if (licErr.error())
                throw InstantiationErr(licErr.toString());
            if (!serverNative)
                throw InstantiationErr();
#endif
        }
 
        static void serverStartCallback(const Internal::CallbackParamsBase* params) {
            VRayServer* server = getVRayServer(params->self);
            auto fn = (void(*)(VRayServer&, double, void*))params->userObject;
            fn(*server, params->instant, params->userData);
        }
 
        template<class T, void (T::*TMethod)(VRayServer&, double instant, void* userData)>
        static void serverStartCallbackT(const Internal::CallbackParamsBase* params) {
            VRayServer* server = getVRayServer(params->self);
            (static_cast<T*>(params->userObject)->*TMethod)(*server, params->instant, params->userData);
        }
 
        static void hostConnectedCallback(const Internal::ConnectParams* params) {
            VRayServer* server = getVRayServer(params->self);
            auto fn = (void(*)(VRayServer&, const char*, double, void*))params->userObject;
            fn(*server, params->hostname, params->instant, params->userData);
        }
 
        template<class T, void (T::*TMethod)(VRayServer&, const char* hostName, double instant, void* userData)>
        static void hostConnectedCallbackT(const Internal::ConnectParams* params) {
            VRayServer* server = getVRayServer(params->self);
            (static_cast<T*>(params->userObject)->*TMethod)(*server, params->hostname, params->instant, params->userData);
        }
 
        static void logMessageCallback(const Internal::LogMessageParams* params) {
            VRayServer* server = getVRayServer(params->self);
            auto fn = (void(*)(VRayServer&, const char*, MessageLevel, double, void*))params->userObject;
            fn(*server, params->message, static_cast<MessageLevel>(params->level), params->instant, params->userData);
        }
 
        template<class T, void (T::*TMethod)(VRayServer& renderer, const char* msg, MessageLevel level, double instant, void* userData)>
        static void logMessageCallbackT(const Internal::LogMessageParams* params) {
            VRayServer* server = getVRayServer(params->self);
            (static_cast<T*>(params->userObject)->*TMethod)(*server, params->message, static_cast<MessageLevel>(params->level), params->instant, params->userData);
        }
 
        static void progressCallback(const Internal::ProgressParams* params) {
            VRayServer* server = getVRayServer(params->self);
            auto fn = (void(*)(VRayServer&, const char*, int, int, double, void*))params->userObject;
            fn(*server, params->message, params->progress, params->total, params->instant, params->userData);
        }
 
        template<class T, void (T::*TMethod)(VRayServer&, const char* msg, int elementNumber, int elementsCount, double, void* userData)>
        static void progressCallbackT(const Internal::ProgressParams* params) {
            VRayServer* server = getVRayServer(params->self);
            (static_cast<T*>(params->userObject)->*TMethod)(*server, params->message, params->progress, params->total, params->instant, params->userData);
        }
 
        static void sceneUpdateCallback(const Internal::SceneUpdateParams* params) {
            VRayServer* server = getVRayServer(params->self);
            auto fn = (void(*)(VRayServer&, int, uint64_t, uint64_t, const char*, double, void*))params->userObject;
            fn(*server, params->action, params->changeIndex, params->pluginId, params->name, params->instant, params->userData);
        }
 
        template<class T, void (T::*TMethod)(VRayServer&, int, uint64_t, uint64_t, const char* name, double instant, void* userData)>
        static void sceneUpdateCallbackT(const Internal::SceneUpdateParams* params) {
            VRayServer* server = getVRayServer(params->self);
            (static_cast<T*>(params->userObject)->*TMethod)(*server, params->action, params->changeIndex, params->pluginId, params->name, params->instant, params->userData);
        }
 
    public:
        VRayServer() {
            createInstance(nullptr);
        }
 
        VRayServer(const ServerOptions &serverOptions) {
            Internal::ServerOptions_Internal optionsInternal(serverOptions);
            createInstance(&optionsInternal);
        }
 
        ~VRayServer() {
            if (serverNative) {
                Internal::VRay_VRayServer_release(serverNative);
            }
        }
 
        operator bool () const {
            return !!serverNative;
        }
 
        LicenseError getLicenseError() const {
            return licErr;
        }
 
        void setOnServerStart(void (*callback)(VRayServer&, double instant, void*), const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnServerStart> callbackData = { serverStartCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayServer_setServerStartCallback(serverNative, callback ? &callbackData : nullptr);
        }
 
        template<class T, void (T::*TMethod)(VRayServer&, double, void*)>
        void setOnServerStart(T& object, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnServerStart> callbackData = { &serverStartCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayServer_setServerStartCallback(serverNative, &callbackData);
        }
 
        void setOnServerClose(void (*callback)(VRayServer&, double instant, void*), const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnServerClose> callbackData = { serverStartCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayServer_setServerCloseCallback(serverNative, callback ? &callbackData : nullptr);
        }
 
        template<class T, void (T::*TMethod)(VRayServer&, double, void*)>
        void setOnServerClose(T& object, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnServerClose> callbackData = { &serverStartCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayServer_setServerCloseCallback(serverNative, &callbackData);
        }
 
        void setOnConnect(void (*callback)(VRayServer&, const char* msg, double instant, void*), const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnConnect> callbackData = { hostConnectedCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayServer_setConnectCallback(serverNative, callback ? &callbackData : nullptr);
        }
 
        template<class T, void (T::*TMethod)(VRayServer&, const char* msg, double, void*)>
        void setOnDisconnect(T& object, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnConnect> callbackData = { &hostConnectedCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayServer_setDisconnectCallback(serverNative, &callbackData);
        }
 
        void setOnDisconnect(void (*callback)(VRayServer&, const char* msg, double instant, void*), const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnConnect> callbackData = { hostConnectedCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayServer_setDisconnectCallback(serverNative, callback ? &callbackData : nullptr);
        }
 
        template<class T, void (T::*TMethod)(VRayServer&, const char* msg, double, void*)>
        void setOnConnect(T& object, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnConnect> callbackData = { &hostConnectedCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayServer_setConnectCallback(serverNative, &callbackData);
        }
 
        void setOnLogMessage(void (*callback)(VRayServer&, const char* msg, MessageLevel level, double instant, void*), MessageLevel minLevel = MessageInfo, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnLogMessage> callbackData = { logMessageCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayServer_setDumpMessageCallback(serverNative, callback ? &callbackData : nullptr, (int)minLevel);
        }
 
        template<class T, void (T::*TMethod)(VRayServer&, const char* msg, MessageLevel level, double, void*)>
        void setOnLogMessage(T& object, MessageLevel minLevel = MessageInfo, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnLogMessage> callbackData = { &logMessageCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayServer_setDumpMessageCallback(serverNative, &callbackData, (int)minLevel);
        }
 
        void setOnProgress(void (*callback)(VRayServer&, const char* msg, int elementNumber, int elementsCount, double instant, void*), const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnProgress> callbackData = { progressCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayServer_setProgressCallback(serverNative, callback ? &callbackData : nullptr);
        }
 
        template<class T, void (T::*TMethod)(VRayServer&, const char* msg, int elementNumber, int elementsCount, double instant, void* userData)>
        void setOnProgress(T& object, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnProgress> callbackData = { &progressCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayServer_setProgressCallback(serverNative, &callbackData);
        }
 
        void setOnSceneUpdate(void (*callback)(VRayServer& vray, int action, uint64_t changeIndex, uint64_t pluginId, const char* name, double instant, void*), const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnSceneUpdate> callbackData = { sceneUpdateCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayServer_setSceneUpdateCallback(serverNative, callback ? &callbackData : nullptr);
        }
 
        template<class T, void (T::*TMethod)(VRayServer&, int, uint64_t, uint64_t, const char* name, double instant, void* userData)>
        void setOnSceneUpdate(T& object, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnSceneUpdate> callbackData = { &sceneUpdateCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayServer_setSceneUpdateCallback(serverNative, &callbackData);
        }
 
        int run() {
            return Internal::VRay_VRayServer_run(serverNative);
        }
 
        int start() {
            return Internal::VRay_VRayServer_start(serverNative);
        }
 
        void stop() {
            Internal::VRay_VRayServer_stop(serverNative);
        }
 
        std::string exportSceneBuffer(int flags) const {
            size_t len = 0;
            char* data = Internal::VRay_VRayServer_exportSceneBuffer(serverNative, len, flags);
            std::string buf;
            if (data && len > 0) {
                buf.assign(data, len);
                Internal::C_memory_free(data);
            }
            return buf;
        }
 
        ExternalString* exportSceneBufferFast(size_t& length, int flags) const {
            return reinterpret_cast<ExternalString*>(Internal::VRay_VRayServer_exportSceneBuffer(serverNative, length, flags));
        }
 
        int addHosts(const char* hosts) {
            if (Internal::VRay_isDR2())
                return Internal::VRay_VRayServer_addHosts(serverNative, hosts);
            else
#ifndef VRAY_NOTHROW
                throw NotSupportedErr();
#else
                return -1;
#endif
        }
 
        int removeHosts(const char* hosts) {
            if (Internal::VRay_isDR2())
                return Internal::VRay_VRayServer_removeHosts(serverNative, hosts);
            else
#ifndef VRAY_NOTHROW
                throw NotSupportedErr();
#else
                return -1;
#endif
        }
 
        int resetHosts(const char* hosts) {
            if (Internal::VRay_isDR2())
                return Internal::VRay_VRayServer_resetHosts(serverNative, hosts);
            else
#ifndef VRAY_NOTHROW
                throw NotSupportedErr();
#else
                return -1;
#endif
        }
 
        char* getAllHosts(int* size) const {
            if (Internal::VRay_isDR2())
                return Internal::VRay_VRayServer_getAllHosts(serverNative, size);
            else
#ifndef VRAY_NOTHROW
                throw NotSupportedErr();
#else
                return nullptr;
#endif
        }
 
        char* getActiveHosts(int* size) const {
            if (Internal::VRay_isDR2())
                return Internal::VRay_VRayServer_getActiveHosts(serverNative, size);
            else
#ifndef VRAY_NOTHROW
                throw NotSupportedErr();
#else
                return nullptr;
#endif
        }
 
        char* getInactiveHosts(int* size) const {
            if (Internal::VRay_isDR2())
                return Internal::VRay_VRayServer_getInactiveHosts(serverNative, size);
            else
#ifndef VRAY_NOTHROW
                throw NotSupportedErr();
#else
                return nullptr;
#endif
        }
    };
 
    class VRayLiveLinkServer {
        VRayLiveLinkServer(const VRayLiveLinkServer&);
        VRayLiveLinkServer& operator=(const VRayLiveLinkServer&);
 
        VRayLiveLinkServerNative* serverNative;
        LicenseError licErr;
 
        static VRayLiveLinkServer* getVRayLiveLinkServer(void* serverNative) {
            if (Internal::VRay_isDR2())
                return static_cast<VRayLiveLinkServer*>(Internal::VRay_VRayLiveLinkServer_getUserData(static_cast<VRayLiveLinkServerNative*>(serverNative), 0));
            else
                return nullptr;
        }
 
        void createInstance(const Internal::LiveLinkServerOptions_Internal* options) {
            if (Internal::VRay_isDR2()) {
                serverNative = Internal::VRay_VRayLiveLinkServer_create(options, &licErr.errs);
                if (serverNative) Internal::VRay_VRayLiveLinkServer_setUserData(serverNative, 0, this);
#ifndef VRAY_NOTHROW
                if (licErr.error())
                    throw InstantiationErr(licErr.toString());
                if (!serverNative)
                    throw InstantiationErr();
#endif
            }
        }
 
        static void serverStartCallback(const Internal::CallbackParamsBase* params) {
            VRayLiveLinkServer* server = getVRayLiveLinkServer(params->self);
            auto fn = (void(*)(VRayLiveLinkServer&, double, void*))params->userObject;
            fn(*server, params->instant, params->userData);
        }
 
        template<class T, void (T::* TMethod)(VRayServer&, double instant, void* userData)>
        static void serverStartCallbackT(const Internal::CallbackParamsBase* params) {
            VRayLiveLinkServer* server = getVRayLiveLinkServer(params->self);
            (static_cast<T*>(params->userObject)->*TMethod)(*server, params->instant, params->userData);
        }
 
        static void hostConnectedCallback(const Internal::ConnectParams* params) {
            VRayLiveLinkServer* server = getVRayLiveLinkServer(params->self);
            auto fn = (void(*)(VRayLiveLinkServer&, const char*, double, void*))params->userObject;
            fn(*server, params->hostname, params->instant, params->userData);
        }
 
        template<class T, void (T::* TMethod)(VRayServer&, const char* hostName, double instant, void* userData)>
        static void hostConnectedCallbackT(const Internal::ConnectParams* params) {
            VRayLiveLinkServer* server = getVRayLiveLinkServer(params->self);
            (static_cast<T*>(params->userObject)->*TMethod)(*server, params->hostname, params->instant, params->userData);
        }
 
        static void logMessageCallback(const Internal::LogMessageParams* params) {
            VRayLiveLinkServer* server = getVRayLiveLinkServer(params->self);
            auto fn = (void(*)(VRayLiveLinkServer&, const char*, MessageLevel, double, void*))params->userObject;
            fn(*server, params->message, static_cast<MessageLevel>(params->level), params->instant, params->userData);
        }
 
        template<class T, void (T::* TMethod)(VRayLiveLinkServer& renderer, const char* msg, MessageLevel level, double instant, void* userData)>
        static void logMessageCallbackT(const Internal::LogMessageParams* params) {
            VRayLiveLinkServer* server = getVRayLiveLinkServer(params->self);
            (static_cast<T*>(params->userObject)->*TMethod)(*server, params->message, static_cast<MessageLevel>(params->level), params->instant, params->userData);
        }
 
        static void progressCallback(const Internal::ProgressParams* params) {
            VRayLiveLinkServer* server = getVRayLiveLinkServer(params->self);
            auto fn = (void(*)(VRayLiveLinkServer&, const char*, int, int, double, void*))params->userObject;
            fn(*server, params->message, params->progress, params->total, params->instant, params->userData);
        }
 
        template<class T, void (T::* TMethod)(VRayServer&, const char* msg, int elementNumber, int elementsCount, double, void* userData)>
        static void progressCallbackT(const Internal::ProgressParams* params) {
            VRayLiveLinkServer* server = getVRayLiveLinkServer(params->self);
            (static_cast<T*>(params->userObject)->*TMethod)(*server, params->message, params->progress, params->total, params->instant, params->userData);
        }
 
        static void sceneUpdateCallback(const Internal::SceneUpdateParams* params) {
            VRayLiveLinkServer* server = getVRayLiveLinkServer(params->self);
            auto fn = (void(*)(VRayLiveLinkServer&, int, uint64_t, uint64_t, const char*, double, void*))params->userObject;
            fn(*server, params->action, params->changeIndex, params->pluginId, params->name, params->instant, params->userData);
        }
 
        template<class T, void (T::* TMethod)(VRayLiveLinkServer&, int, uint64_t, uint64_t, const char* name, double instant, void* userData)>
        static void sceneUpdateCallbackT(const Internal::SceneUpdateParams* params) {
            VRayLiveLinkServer* server = getVRayLiveLinkServer(params->self);
            (static_cast<T*>(params->userObject)->*TMethod)(*server, params->action, params->changeIndex, params->pluginId, params->name, params->instant, params->userData);
        }
 
    public:
        VRayLiveLinkServer() {
            createInstance(nullptr);
        }
 
        VRayLiveLinkServer(const LiveLinkServerOptions& serverOptions) {
            Internal::LiveLinkServerOptions_Internal optionsInternal(serverOptions);
            createInstance(&optionsInternal);
        }
 
        ~VRayLiveLinkServer() {
            if (serverNative) {
                Internal::VRay_VRayLiveLinkServer_release(serverNative);
            }
        }
 
        operator bool() const {
            return !!serverNative;
        }
 
        LicenseError getLicenseError() const {
            return licErr;
        }
 
        void setOnServerStart(void (*callback)(VRayLiveLinkServer&, double instant, void*), const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnServerStart> callbackData = { serverStartCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayLiveLinkServer_setServerStartCallback(serverNative, callback ? &callbackData : nullptr);
        }
 
        template<class T, void (T::* TMethod)(VRayLiveLinkServer&, double, void*)>
        void setOnServerStart(T& object, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnServerStart> callbackData = { &serverStartCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayLiveLinkServer_setServerStartCallback(serverNative, &callbackData);
        }
 
        void setOnServerClose(void (*callback)(VRayLiveLinkServer&, double instant, void*), const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnServerClose> callbackData = { serverStartCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayLiveLinkServer_setServerCloseCallback(serverNative, callback ? &callbackData : nullptr);
        }
 
        template<class T, void (T::* TMethod)(VRayLiveLinkServer&, double, void*)>
        void setOnServerClose(T& object, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnServerClose> callbackData = { &serverStartCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayLiveLinkServer_setServerCloseCallback(serverNative, &callbackData);
        }
 
        void setOnConnect(void (*callback)(VRayLiveLinkServer&, const char* msg, double instant, void*), const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnConnect> callbackData = { hostConnectedCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayLiveLinkServer_setConnectCallback(serverNative, callback ? &callbackData : nullptr);
        }
 
        template<class T, void (T::* TMethod)(VRayLiveLinkServer&, const char* msg, double, void*)>
        void setOnDisconnect(T& object, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnConnect> callbackData = { &hostConnectedCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayLiveLinkServer_setDisconnectCallback(serverNative, &callbackData);
        }
 
        void setOnDisconnect(void (*callback)(VRayLiveLinkServer&, const char* msg, double instant, void*), const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnConnect> callbackData = { hostConnectedCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayLiveLinkServer_setDisconnectCallback(serverNative, callback ? &callbackData : nullptr);
        }
 
        template<class T, void (T::* TMethod)(VRayLiveLinkServer&, const char* msg, double, void*)>
        void setOnConnect(T& object, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnConnect> callbackData = { &hostConnectedCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayLiveLinkServer_setConnectCallback(serverNative, &callbackData);
        }
 
        void setOnLogMessage(void (*callback)(VRayLiveLinkServer&, const char* msg, MessageLevel level, double instant, void*), MessageLevel minLevel = MessageInfo, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnLogMessage> callbackData = { logMessageCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayLiveLinkServer_setDumpMessageCallback(serverNative, callback ? &callbackData : nullptr, (int)minLevel);
        }
 
        template<class T, void (T::* TMethod)(VRayLiveLinkServer&, const char* msg, MessageLevel level, double, void*)>
        void setOnLogMessage(T& object, MessageLevel minLevel = MessageInfo, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnLogMessage> callbackData = { &logMessageCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayLiveLinkServer_setDumpMessageCallback(serverNative, &callbackData, (int)minLevel);
        }
 
        void setOnProgress(void (*callback)(VRayLiveLinkServer&, const char* msg, int elementNumber, int elementsCount, double instant, void*), const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnProgress> callbackData = { progressCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayLiveLinkServer_setProgressCallback(serverNative, callback ? &callbackData : nullptr);
        }
 
        template<class T, void (T::* TMethod)(VRayLiveLinkServer&, const char* msg, int elementNumber, int elementsCount, double instant, void* userData)>
        void setOnProgress(T& object, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnProgress> callbackData = { &progressCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayLiveLinkServer_setProgressCallback(serverNative, &callbackData);
        }
 
        void setOnSceneUpdate(void (*callback)(VRayLiveLinkServer& vray, int action, uint64_t changeIndex, uint64_t pluginId, const char* name, double instant, void*), const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnSceneUpdate> callbackData = { sceneUpdateCallback, serverNative, (void*)callback, userData };
            Internal::VRay_VRayLiveLinkServer_setSceneUpdateCallback(serverNative, callback ? &callbackData : nullptr);
        }
 
        template<class T, void (T::* TMethod)(VRayLiveLinkServer&, int, uint64_t, uint64_t, const char* name, double instant, void* userData)>
        void setOnSceneUpdate(T& object, const void* userData = nullptr) {
            Internal::CallbackData<Internal::OnSceneUpdate> callbackData = { &sceneUpdateCallbackT<T, TMethod>, serverNative, &object, userData };
            Internal::VRay_VRayLiveLinkServer_setSceneUpdateCallback(serverNative, &callbackData);
        }
 
        int run() {
            return Internal::VRay_VRayLiveLinkServer_run(serverNative);
        }
 
        int start() {
            return Internal::VRay_VRayLiveLinkServer_start(serverNative);
        }
 
        void stop() {
            Internal::VRay_VRayLiveLinkServer_stop(serverNative);
        }
 
        std::string exportSceneBuffer(int flags) const {
            size_t len = 0;
            char* data = Internal::VRay_VRayLiveLinkServer_exportSceneBuffer(serverNative, len, flags);
            std::string buf;
            if (data && len > 0) {
                buf.assign(data, len);
                Internal::C_memory_free(data);
            }
            return buf;
        }
 
        ExternalString* exportSceneBufferFast(size_t& length, int flags) const {
            return reinterpret_cast<ExternalString*>(Internal::VRay_VRayLiveLinkServer_exportSceneBuffer(serverNative, length, flags));
        }
 
    };
 
}
 
#endif // _VRAY_SRV_HPP_