vrayinterop.hpp

#ifdef _VRAY_SDK_HPP_
#ifndef _VRAY_INTEROP_HPP_
#define _VRAY_INTEROP_HPP_
 
#ifndef _MSC_VER
#include <stdint.h>
#endif
 
namespace VRay {
    namespace VUtils {
        struct CharStringBuf {
            static CharStringBuf* create(int size) {
                return static_cast<CharStringBuf*>(Internal::CharStringBuf_create(size));
            }
 
            CharStringBuf* incRefCount() {
                Internal::CharStringBuf_incRefCount(this);
                return this;
            }
 
            void decRefCount() {
                return Internal::CharStringBuf_decRefCount(this);
            }
 
            int getRefCount() {
                return Internal::CharStringBuf_getRefCount(this);
            }
 
            char* resize(int s) {
                return Internal::CharStringBuf_resize(this, s);
            }
 
            char* ptr() {
                return Internal::CharStringBuf_getBuf(this);
            }
 
        private:
            CharStringBuf();
            ~CharStringBuf();
        };
 
        inline int vutils_strcpy_n(char *dest, const char *source, int destSize) {
            if (destSize <= 0) return 0;
            int len;
            for (len = 0; (len<destSize - 1) && (source[len] != '\0'); len++) {
                dest[len] = source[len];
            }
            dest[len] = '\0';
            return len + 1;
        }
 
        inline int vutils_strlen_n(const char *str, int maxSize) {
            int len = 0;
            while (len<maxSize && str[len] != '\0') len++;
            return len;
        }
 
        inline int vutils_strcat_n(char *dest, const char *source, int destSize) {
            int len = vutils_strlen_n(dest, destSize);
            return vutils_strcpy_n(dest + len, source, destSize - len);
        }
 
        inline int vutils_strcmp(const char *strA, const char *strB) {
            const char *a = strA;
            const char *b = strB;
            while ((*a) != '\0' && (*a) == (*b)) { a++; b++; }
            return (*a) - (*b);
        }
 
        inline int vutils_strcmp_n(const char *strA, const char *strB, int maxSize) {
            const char *a = strA;
            const char *b = strB;
            int n = 1;
            while ((*a) != '\0' && (*a) == (*b) && (n < maxSize)) { a++; b++; n++; }
            return (*a) - (*b);
        }
 
        class CharString {
            CharStringBuf *buf;
            void freeMem(void) {
                if (buf) buf->decRefCount();
                buf = nullptr;
            }
 
            // Create a new buffer into which we can copy len+1 characters (the last one is the NUL char)
            void splitBuffer(int len, int copyString) {
                if (!buf) buf = CharStringBuf::create(len + 1); // There is no buffer currently, so create one
                else if (buf->getRefCount()>1) { // Our buffer is shared with other objects, we must create a new one
                    CharStringBuf *tmpBuf = CharStringBuf::create(len + 1);
                    if (copyString)
                        vutils_strcpy_n(tmpBuf->ptr(), buf->ptr(), len + 1);
                    buf->decRefCount();
                    buf = tmpBuf;
                }
                else { // Buffer is not shared, we can modify it directly
                    buf->resize(len + 1);
                }
            }
 
            // Set our buffer to the given one
            void setBuffer(CharStringBuf *newBuffer) {
                // Only do stuff if the new buffer is different from the old one.
                if (newBuffer != buf) {
                    if (buf) buf->decRefCount(); // If there is a buffer already, release it
                    if (!newBuffer) buf = nullptr; // The new buffer is empty
                    else buf = newBuffer->incRefCount(); // The new buffer is not empty, so just reference it
                }
            }
 
            // Make our buffer writeable (e.g. if shared, copy it)
            void makeWriteable(void) {
                if (!buf) return;
                if (buf->getRefCount() <= 1) return; // This is the only copy of the buffer, it is safe to modify
 
                                                     // There are other references to the buffer, so we must clone it.
                int len = length() + 1;
                CharStringBuf *newBuffer = CharStringBuf::create(len + 1);
                vutils_strcpy_n(newBuffer->ptr(), buf->ptr(), len + 1);
                buf->decRefCount();
                buf = newBuffer;
            }
 
        public:
            CharString(void) :buf(nullptr) {}
 
            CharString(const char *val) :buf(nullptr) {
                if (val) {
                    int len = (int)strlen(val);
                    buf = CharStringBuf::create(len + 1);
                    char* wptr = buf->ptr();
                    if (wptr) vutils_strcpy_n(wptr, val, len + 1);
                }
            }
 
            CharString(const CharString& r) :buf(nullptr) {
                if (r.buf) buf = r.buf->incRefCount();
            }
 
            CharString(const char *str, int strLen) :buf(nullptr) {
                set(str, strLen);
            }
 
            CharString(unsigned strLen) :buf(nullptr) {
                buf = nullptr;
                if (strLen) {
                    buf = CharStringBuf::create(strLen + 1);
                    char* wptr = buf->ptr();
                    if (wptr) {
                        memset(wptr, ' ', sizeof(char)*(strLen + 1));
                        wptr[strLen] = 0;
                    }
                }
            }
 
            ~CharString(void) { freeMem(); }
 
            const char* ptr(void) const {
                return buf ? buf->ptr() : nullptr;
            }
 
            char* write_ptr(void) {
                if (!buf) return nullptr;
                makeWriteable();
                return buf->ptr();
            }
 
            CharString& operator=(const char *newBuf) {
                if (!newBuf) { freeMem(); return *this; }
 
                int len = (int)strlen(newBuf);
                splitBuffer(len, false);
                char* wptr = buf->ptr();
                if (wptr) vutils_strcpy_n(wptr, newBuf, len + 1);
                return *this;
            }
 
            CharString& operator=(const CharString& str) {
                setBuffer(str.buf);
                return *this;
            }
 
            // strLen is without the trailing NUL character
            void set(const char* str, int strLen) {
                if (!str || strLen == 0) { freeMem(); return; }
 
                splitBuffer(strLen, false);
                char* wptr = buf->ptr();
                if (wptr) vutils_strcpy_n(wptr, str, strLen + 1);
            }
 
            void set(const char* str) { *this = str; }
 
            void set(const char* str1, const char* str2) {
                int sz1 = (int)((str1) ? strlen(str1) : 0);
                int sz2 = (int)((str2) ? strlen(str2) : 0);
                if (!str1 || !str2 || !sz1 || !sz2) { freeMem(); return; }
 
                splitBuffer(sz1 + sz2, false);
                char* wptr = buf->ptr();
                if (wptr) {
                    vutils_strcpy_n(wptr, str1, sz1 + sz2 + 1);
                    vutils_strcpy_n(wptr + sz1, str2, sz1 + sz2 + 1);
                }
            }
 
            char operator[](int index) const { return buf->ptr()[index]; }
 
            int length(void) const { return buf ? (int)strlen(buf->ptr()) : 0; }
 
            void setLength(int newLen, char fillChar = ' ') {
                if (newLen <= 0) { freeMem(); return; }
 
                int len = length();
                if (newLen == len) return;
 
                splitBuffer(newLen, true);
                char* wptr = buf->ptr();
                if (wptr) {
                    if (newLen > len && fillChar != 0)
                        for (int i = len; i < newLen; i++)
                            wptr[i] = fillChar;
                    wptr[newLen] = 0;
                }
            }
 
            void append(const char *str) {
                if (!str) return;
                if (!buf) *this = str;
                else {
                    int strLen = (int)strlen(str);
                    int curLen = length();
                    splitBuffer(strLen + curLen, true);
                    char* wptr = buf->ptr();
                    if (wptr) vutils_strcat_n(wptr, str, curLen + strLen + 1);
                }
            }
 
            void append(const CharString &str) {
                append(str.ptr());
            }
 
            void append(const char *str, int length) {
                if (!str) return;
                if (!buf) set(str, length);
                else {
                    int curLen = this->length();
                    splitBuffer(length + curLen, true);
                    char* wptr = buf->ptr();
                    if (wptr) vutils_strcat_n(wptr, str, curLen + length + 1);
                }
            }
 
            void swap(CharString &str) noexcept {
                CharStringBuf *temp = buf;
                buf = str.buf;
                str.buf = temp;
            }
 
            void clear(void) { freeMem(); }
 
            bool empty(void) const { return (buf == nullptr) || (buf->ptr()[0] == 0); }
        };
 
        inline std::ostream& operator <<(std::ostream& stream, const CharString& str) {
            const char* ptr = str.ptr();
            stream << (ptr ? ptr : "<null string>");
            return stream;
        }
 
        inline CharString operator+(const CharString &a, const CharString &b) {
            CharString res(a);
            res.append(b);
            return res;
        }
 
        inline bool operator==(const CharString &a, const char *str) {
            const char* ptr = a.ptr();
            if (ptr == str) return true;
            if (ptr == nullptr || str == nullptr) return false;
            return strcmp(ptr, str) == 0;
        }
 
        inline bool operator!=(const CharString &a, const char *str) {
            return !(a == str);
        }
 
        inline bool operator==(const CharString &a, const CharString &b) {
            return a == b.ptr();
        }
 
        inline bool operator!=(const CharString &a, const CharString &b) {
            return !(a == b);
        }
 
        inline bool operator<(const CharString &a, const CharString &b) {
            const char* aptr = a.ptr();
            const char* bptr = b.ptr();
            if (bptr == nullptr) return false;
            if (aptr == nullptr) return true;
            return strcmp(aptr, bptr) < 0;
        }
 
        inline CharString makeCharString(const char *a, const char *b) {
            CharString res(a);
            res.append(b);
            return res;
        }
 
        inline CharString makeCharString(const char *a, const char *b, const char *c) {
            CharString res(a);
            res.append(b);
            res.append(c);
            return res;
        }
 
        inline CharString makeCharString(const char *a, const char *b, const char *c, const char *d) {
            CharString res(a);
            res.append(b);
            res.append(c);
            res.append(d);
            return res;
        }
 
        template<class T>
        struct RefCounter {
            static RefCounter* create(int type, Internal::PtrArrayCustomCallbackFn callbackFn = nullptr, void* callbackData = nullptr);
            void inc(int type);
            int dec(int type);
            T* allocMem(int type, int n);
            void destroy(int type, T* ptr, int n);
            static int unite(Type dataType, int counterType) {
                return dataType | (counterType << 16);
            }
        private:
            RefCounter();
            ~RefCounter();
        };
 
        class Value;
        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;
 
        class Object;
 
        struct ObjectID {
            InstanceId id; // Holds a plugin InstanceID
            CharString subobj; // Holds a plugin output parameter name (plugin::outParamName)
 
            explicit ObjectID(InstanceId id = 0)
                : id(id)
            {}
 
            explicit ObjectID(const Plugin& plugin)
                : id(plugin.getIntegerID())
            {}
 
            explicit ObjectID(const PluginRef& plugin)
                : id(plugin.getIntegerID())
                , subobj(plugin.getOutputName())
            {}
 
            bool operator==(const ObjectID &objID) {
                return id == objID.id && subobj == objID.subobj;
            }
            bool operator!=(const ObjectID &objID) {
                return id != objID.id || subobj != objID.subobj;
            }
        };
 
        struct RuntimeValue {
            Object *obj;
            CharString valueName;
 
            RuntimeValue() : obj() {}
            RuntimeValue(const RuntimeValue& rv) = default;
            RuntimeValue(RuntimeValue&& rv) = default;
 
            bool operator==(const RuntimeValue& rv) {
                return obj == rv.obj && valueName == rv.valueName;
            }
            bool operator!=(const RuntimeValue& rv) {
                return obj != rv.obj || valueName != rv.valueName;
            }
        };
 
        struct TracePoint {
            double x, y, z;
 
            TracePoint() {}
            TracePoint(double x, double y, double z) : x(x), y(y), z(z) {}
            explicit TracePoint(double v) : x(v), y(v), z(v) {}
            TracePoint(const Vector &v) : x(v.x), y(v.y), z(v.z) {}
            TracePoint(const TracePoint& tp) = default;
 
            Vector toVector() const { return Vector(x, y, z); }
 
            bool operator==(const TracePoint& tp) {
                return x != tp.x && y == tp.y && z == tp.z;
            }
            bool operator!=(const TracePoint& tp) {
                return x != tp.x || y != tp.y || z != tp.z;
            }
            std::string toString() const;
        };
 
        inline std::ostream& operator <<(std::ostream& stream, const TracePoint& vector) {
            stream << "Vector(" << vector.x << ", " << vector.y << ", " << vector.z << ")";
            return stream;
        }
 
        inline std::string TracePoint::toString() const {
            std::ostringstream stream;
            stream << *this;
            return stream.str();
        }
 
        struct TraceTransform {
            Matrix m; 
            int padding; 
            TracePoint offs; 
 
            TraceTransform() {}
            explicit TraceTransform(float f) : m(f), offs(0) {}
            TraceTransform(const Transform& t) : m(t.matrix), offs(t.offset) {}
            TraceTransform(const TraceTransform& tt) = default;
 
            Transform toTransform() const { return Transform(m, offs.toVector()); }
 
            bool operator==(const TraceTransform& tt) {
                return m == tt.m && offs == tt.offs;
            }
            bool operator!=(const TraceTransform& tt) {
                return m != tt.m || offs != tt.offs;
            }
            std::string toString() const;
        };
 
        inline std::ostream& operator <<(std::ostream& stream, const TraceTransform& transform) {
            stream << "Transform(" << transform.m << ", " << transform.offs << ")";
            return stream;
        }
 
        inline std::string TraceTransform::toString() const {
            std::ostringstream stream;
            stream << *this;
            return stream.str();
        }
 
        enum VALUE_TYPE {
            UNKNOWN = 0, 
            NUMBER, 
            LIST, 
            VECTOR, 
            MATRIX, 
            COLOR, 
            ACOLOR, 
            TRANSFORM, 
            LISTVECTOR, 
            LISTINT, 
            LISTCOLOR, 
            LISTFLOAT, 
            STRING, 
            OBJECT, 
            OBJECTID, 
            RUNTIMEVALUE, 
            LISTSTRING, 
            //OBJECT_NAME
        };
 
        template<>
        struct RefCounter<int> {
            static RefCounter* create(int type, Internal::PtrArrayCustomCallbackFn callbackFn = nullptr, void* callbackData = nullptr) {
                return static_cast<RefCounter*>(Internal::RefCounter_create(RefCounter<void>::unite(TYPE_INT, type), callbackFn, callbackData));
            }
 
            void inc(int type) {
                Internal::RefCounter_increment(this, RefCounter<void>::unite(TYPE_INT, type));
            }
 
            int dec(int type) {
                return Internal::RefCounter_decrement(this, RefCounter<void>::unite(TYPE_INT, type));
            }
 
            int* allocMem(int type, int n) {
                return static_cast<int*>(Internal::RefCounter_allocMem(this, RefCounter<void>::unite(TYPE_INT, type), n));
            }
 
            void destroy(int type, int* ptr, int n) {
                Internal::RefCounter_release(this, RefCounter<void>::unite(TYPE_INT, type), ptr, n);
            }
        };
 
        template<>
        struct RefCounter<float> {
            static RefCounter* create(int type, Internal::PtrArrayCustomCallbackFn callbackFn = nullptr, void* callbackData = nullptr) {
                return static_cast<RefCounter*>(Internal::RefCounter_create(RefCounter<void>::unite(TYPE_FLOAT, type), callbackFn, callbackData));
            }
 
            void inc(int type) {
                Internal::RefCounter_increment(this, RefCounter<void>::unite(TYPE_FLOAT, type));
            }
 
            int dec(int type) {
                return Internal::RefCounter_decrement(this, RefCounter<void>::unite(TYPE_FLOAT, type));
            }
 
            float* allocMem(int type, int n) {
                return static_cast<float*>(Internal::RefCounter_allocMem(this, RefCounter<void>::unite(TYPE_FLOAT, type), n));
            }
 
            void destroy(int type, float* ptr, int n) {
                Internal::RefCounter_release(this, RefCounter<void>::unite(TYPE_FLOAT, type), ptr, n);
            }
        };
 
        template<>
        struct RefCounter<Vector> {
            static RefCounter* create(int type, Internal::PtrArrayCustomCallbackFn callbackFn = nullptr, void* callbackData = nullptr) {
                return static_cast<RefCounter*>(Internal::RefCounter_create(RefCounter<void>::unite(TYPE_VECTOR, type), callbackFn, callbackData));
            }
 
            void inc(int type) {
                Internal::RefCounter_increment(this, RefCounter<void>::unite(TYPE_VECTOR, type));
            }
 
            int dec(int type) {
                return Internal::RefCounter_decrement(this, RefCounter<void>::unite(TYPE_VECTOR, type));
            }
 
            Vector* allocMem(int type, int n) {
                return static_cast<Vector*>(Internal::RefCounter_allocMem(this, RefCounter<void>::unite(TYPE_VECTOR, type), n));
            }
 
            void destroy(int type, Vector* ptr, int n) {
                Internal::RefCounter_release(this, RefCounter<void>::unite(TYPE_VECTOR, type), ptr, n);
            }
        };
 
        template<>
        struct RefCounter<Color> {
            static RefCounter* create(int type, Internal::PtrArrayCustomCallbackFn callbackFn = nullptr, void* callbackData = nullptr) {
                return static_cast<RefCounter*>(Internal::RefCounter_create(RefCounter<void>::unite(TYPE_COLOR, type), callbackFn, callbackData));
            }
 
            void inc(int type) {
                Internal::RefCounter_increment(this, RefCounter<void>::unite(TYPE_COLOR, type));
            }
 
            int dec(int type) {
                return Internal::RefCounter_decrement(this, RefCounter<void>::unite(TYPE_COLOR, type));
            }
 
            Color* allocMem(int type, int n) {
                return static_cast<Color*>(Internal::RefCounter_allocMem(this, RefCounter<void>::unite(TYPE_COLOR, type), n));
            }
 
            void destroy(int type, Color* ptr, int n) {
                Internal::RefCounter_release(this, RefCounter<void>::unite(TYPE_COLOR, type), ptr, n);
            }
        };
 
        template<>
        struct RefCounter<TraceTransform> {
            static RefCounter* create(int type, Internal::PtrArrayCustomCallbackFn callbackFn = nullptr, void* callbackData = nullptr) {
                return static_cast<RefCounter*>(Internal::RefCounter_create(RefCounter<void>::unite(TYPE_TRANSFORM, type), callbackFn, callbackData));
            }
 
            void inc(int type) {
                Internal::RefCounter_increment(this, RefCounter<void>::unite(TYPE_TRANSFORM, type));
            }
 
            int dec(int type) {
                return Internal::RefCounter_decrement(this, RefCounter<void>::unite(TYPE_TRANSFORM, type));
            }
 
            TraceTransform* allocMem(int type, int n) {
                return static_cast<TraceTransform*>(Internal::RefCounter_allocMem(this, RefCounter<void>::unite(TYPE_TRANSFORM, type), n));
            }
 
            void destroy(int type, TraceTransform* ptr, int n) {
                Internal::RefCounter_release(this, RefCounter<void>::unite(TYPE_TRANSFORM, type), ptr, n);
            }
        };
 
        template<>
        struct RefCounter<CharString> {
            static RefCounter* create(int type, Internal::PtrArrayCustomCallbackFn callbackFn = nullptr, void* callbackData = nullptr) {
                return static_cast<RefCounter*>(Internal::RefCounter_create(RefCounter<void>::unite(TYPE_STRING, type), callbackFn, callbackData));
            }
 
            void inc(int type) {
                Internal::RefCounter_increment(this, RefCounter<void>::unite(TYPE_STRING, type));
            }
 
            int dec(int type) {
                return Internal::RefCounter_decrement(this, RefCounter<void>::unite(TYPE_STRING, type));
            }
 
            CharString* allocMem(int type, int n) {
                return static_cast<CharString*>(Internal::RefCounter_allocMem(this, RefCounter<void>::unite(TYPE_STRING, type), n));
            }
 
            void destroy(int type, CharString* ptr, int n) {
                Internal::RefCounter_release(this, RefCounter<void>::unite(TYPE_STRING, type), ptr, n);
            }
        };
 
        template<>
        struct RefCounter<Value> {
            static RefCounter* create(int type, Internal::PtrArrayCustomCallbackFn callbackFn = nullptr, void* callbackData = nullptr) {
                return static_cast<RefCounter*>(Internal::RefCounter_create(RefCounter<void>::unite(TYPE_LIST, type), callbackFn, callbackData));
            }
 
            void inc(int type) {
                Internal::RefCounter_increment(this, RefCounter<void>::unite(TYPE_LIST, type));
            }
 
            int dec(int type) {
                return Internal::RefCounter_decrement(this, RefCounter<void>::unite(TYPE_LIST, type));
            }
 
            Value* allocMem(int type, int n) {
                return static_cast<Value*>(Internal::RefCounter_allocMem(this, RefCounter<void>::unite(TYPE_LIST, type), n));
            }
 
            void destroy(int type, Value* ptr, int n) {
                Internal::RefCounter_release(this, RefCounter<void>::unite(TYPE_LIST, type), ptr, n);
            }
        };
 
        template<class T>
        struct PtrArray {
            PtrArray(void) { ptr = nullptr; refCounter = nullptr; length = 0; }
 
            PtrArray(const PtrArray &p) { copy(p); }
 
            PtrArray(PtrArray &&p) noexcept { m0ve(std::move(p)); }
 
            PtrArray& operator=(const PtrArray &p) {
                if (this!=&p) {
                    freeMem();
                    copy(p);
                }
                return *this;
            }
 
            PtrArray& operator=(PtrArray &&p) noexcept {
                if (this != &p) {
                    freeMem();
                    m0ve(std::move(p));
                }
                return *this;
            }
 
            bool operator==(const PtrArray&& p) {
                if (ptr == p.ptr) return true;
                if (!ptr || !p.ptr) return false;
                for (int i = 0; i < length; ++i) {
                    if (ptr[i] != p.ptr[i]) return false;
                }
                return true;
            }
 
            explicit PtrArray(int num) { allocArray(num); }
 
            PtrArray(T *ptr, int len) { init(ptr, len); }
 
            template<int len>
            explicit PtrArray(T (&arr)[len]) { init(arr, len); }
 
            ~PtrArray(void) { freeMem(); }
 
            T& operator[](int i) { return ptr[i]; }
 
            const T& operator[](int i) const { return ptr[i]; }
 
            bool operator!(void) const { return (ptr == nullptr); }
 
            operator T*(void) { return ptr; }
 
            operator const T*(void) const { return ptr; }
 
            void init(T *ptr, int len) {
                type = Internal::ownerTypeNone;
                this->ptr = ptr;
                refCounter = nullptr;
                length = len;
            }
 
            void freeMem(void) {
                if (refCounter) { // We count the references.
                    if (refCounter->dec(type) == 0) { // This was the last reference to it - delete it.
                        refCounter->destroy(type, ptr, length);
                    }
                }
                refCounter = nullptr;
                ptr = nullptr;
                length = 0;
                type = Internal::ownerTypeNone;
            }
 
            T* get(void) { return ptr; }
            const T* get(void) const { return ptr; }
 
            int size(void) const { return length; }
            int count(void) const { return length; }
 
            std::string toString() const;
 
        private:
            T *ptr; 
            RefCounter<T> *refCounter;
            int length;
 
            Internal::PtrArrayOwnershipType type;
 
            PtrArray(T *ptr, int len, Internal::PtrArrayCustomCallbackFn callbackFn, void* callbackData) { init(ptr, len, callbackFn, callbackData); }
 
            void init(T *ptr, int len, Internal::PtrArrayCustomCallbackFn callbackFn, void* callbackData) {
                type = Internal::ownerTypeCallback;
                this->ptr = ptr;
                refCounter = RefCounter<T>::create(type, callbackFn, callbackData);
                length = len;
            }
 
            void copy(const PtrArray &p) {
                ptr = p.ptr;
                refCounter = p.refCounter;
                length = p.length;
                type = p.type;
                if (refCounter) refCounter->inc(type);
            }
 
            void m0ve(PtrArray&& p) {
                ptr = p.ptr;
                refCounter = p.refCounter;
                length = p.length;
                type = p.type;
 
                p.ptr = nullptr;
                p.refCounter = nullptr;
                p.length = 0;
                p.type = Internal::ownerTypeNone;
            }
 
            void allocArray(int num) {
                type = Internal::ownerTypeOwnMem;
                length = num;
                refCounter = RefCounter<T>::create(type);
                ptr = refCounter->allocMem(type, length);
            }
        };
 
        template<class T>
        inline std::ostream& operator <<(std::ostream& stream, const PtrArray<T>& list) {
            stream << "[";
            if (list && list.count() > 0) {
                int i = 0;
                while (i < list.count() - 1)
                    stream << list[i++] << ", ";
                stream << list[i];
            }
            stream << ']';
            return stream;
        }
 
        template<class T>
        inline std::string PtrArray<T>::toString() const {
            std::ostringstream stream;
            stream << *this;
            return stream.str();
        }
 
        class Value {
            struct StringValue {
                CharString str;
                CharString scenePath;
                CharStringRefList stringList;
            };
 
            size_t data[8];
            VALUE_TYPE valueType;
 
            template<typename TYPE> TYPE& as() { return *reinterpret_cast<TYPE *>(data); }
            template<typename TYPE> const TYPE& as() const { return *reinterpret_cast<const TYPE *>(data); }
 
            // common for copy constructor and operator=
            void copy(const Value &other)
            {
                // Make sure destroy is called (directly or from a setXXX method).
                // If it is not called there would be memory leaks!
 
                switch (other.valueType) {
                case NUMBER:
                    setDouble(other.getDouble());
                    break;
                case VECTOR:
                    setVector(other.getTracePoint());
                    break;
                case MATRIX:
                    setMatrix(other.getMatrix());
                    break;
                case COLOR:
                    setColor(other.getColor());
                    break;
                case ACOLOR:
                    setAColor(other.getAColor());
                    break;
                case TRANSFORM:
                    setTransform(other.getTransform());
                    break;
                case OBJECT:
                    setObject(other.getObject());
                    break;
                case OBJECTID:
                    setObjectID(other.getObjectID());
                    break;
                case LIST:
                    setList(other.getList());
                    break;
                case LISTINT:
                    setListInt(other.getListInt());
                    break;
                case LISTFLOAT:
                    setListFloat(other.getListFloat());
                    break;
                case LISTVECTOR:
                    setListVector(other.getListVector());
                    break;
                case LISTCOLOR:
                    setListColor(other.getListColor());
                    break;
                case LISTSTRING:
                    setListString(other.getListString());
                    //setScenePath(other.getScenePath());
                    break;
                case STRING:
                //case OBJECT_NAME:
                    setString(other.getString());
                    //setScenePath(other.getScenePath());
                    break;
                case RUNTIMEVALUE:
                    setRuntimeValue(other.getRuntimeValue());
                    break;
                case UNKNOWN:
                    destroy();
                    valueType = UNKNOWN;
                    break;
                }
            }
 
            void destroy() {
                switch (valueType) {
                case UNKNOWN:
                case NUMBER:
                case VECTOR:
                case MATRIX:
                case COLOR:
                case ACOLOR:
                case TRANSFORM:
                case OBJECT:
                    /* POD, no destructor */
                    break;
                case OBJECTID:
                    as<ObjectID>().~ObjectID();
                    break;
                case LIST:
                    as<ValueRefList>().~PtrArray();
                    break;
                case LISTINT:
                    as<IntRefList>().~PtrArray();
                    break;
                case LISTFLOAT:
                    as<FloatRefList>().~PtrArray();
                    break;
                case LISTVECTOR:
                    as<VectorRefList>().~PtrArray();
                    break;
                case LISTCOLOR:
                    as<ColorRefList>().~PtrArray();
                    break;
                case LISTSTRING:
                    as<StringValue>().stringList.~PtrArray();
                    as<StringValue>().scenePath.~CharString();
                    break;
                case STRING:
                //case OBJECT_NAME:
                    as<StringValue>().str.~CharString();
                    as<StringValue>().scenePath.~CharString();
                    break;
                case RUNTIMEVALUE:
                    as<RuntimeValue>().~RuntimeValue();
                    break;
                }
            }
 
        public:
            explicit Value() {
                valueType = UNKNOWN;
            }
 
            explicit Value(double val) {
                valueType = NUMBER;
                new (data) double(val);
            }
 
            explicit Value(const TracePoint &v) {
                valueType = VECTOR;
                new (data) TracePoint(v);
            }
 
            explicit Value(const Vector &v) {
                valueType = VECTOR;
                new (data) TracePoint(v);
            }
 
            explicit Value(const Matrix &mat) {
                valueType = MATRIX;
                new (data) Matrix(mat);
            }
 
            explicit Value(const Color &col) {
                valueType = COLOR;
                new (data) Color(col);
            }
 
            explicit Value(const AColor &acol) {
                valueType = ACOLOR;
                new (data) AColor(acol);
            }
 
            explicit Value(const TraceTransform &transform) {
                valueType = TRANSFORM;
                new (data) TraceTransform(transform);
            }
 
            explicit Value(Object *obj) {
                valueType = OBJECT;
                new (data) Object*(obj);
            }
 
            explicit Value(const ObjectID &id) {
                valueType = OBJECTID;
                new (data) ObjectID(id);
            }
 
            explicit Value(const ValueRefList &lst) {
                valueType = LIST;
                new (data) ValueRefList(lst);
            }
 
            explicit Value(const RuntimeValue &rtVal) {
                valueType = RUNTIMEVALUE;
                new (data) RuntimeValue(rtVal);
            }
 
            explicit Value(const CharString &str) {
                valueType = STRING;
                new (&(as<StringValue>().str)) CharString(str);
                new (&(as<StringValue>().scenePath)) CharString();
            }
 
            //explicit Value(const CharString &str, VALUE_TYPE customType) {
            //  valueType = OBJECT_NAME;
            //  new (&(as<StringValue>().str)) CharString(str);
            //  new (&(as<StringValue>().scenePath)) CharString();
            //}
 
            explicit Value(const VectorRefList &list) {
                valueType = LISTVECTOR;
                new (data) VectorRefList(list);
            }
 
            explicit Value(const ColorRefList &list) {
                valueType = LISTCOLOR;
                new (data) ColorRefList(list);
            }
 
            explicit Value(const FloatRefList &list) {
                valueType = LISTFLOAT;
                new (data) FloatRefList(list);
            }
 
            explicit Value(const IntRefList &list) {
                valueType = LISTINT;
                new (data) IntRefList(list);
            }
 
            explicit Value(const CharStringRefList &list) {
                valueType = LISTSTRING;
                new (&(as<StringValue>().stringList)) CharStringRefList(list);
                new (&(as<StringValue>().scenePath)) CharString();
            }
 
            explicit Value(const Plugin &plugin) {
                valueType = OBJECTID;
                new (data) ObjectID(plugin);
            }
 
            explicit Value(const PluginRef& plugin) {
                valueType = OBJECTID;
                new (data) ObjectID(plugin);
            }
 
            Value(const Value &v) {
                valueType = UNKNOWN;
                copy(v);
            }
 
            Value &operator=(const Value &v) {
                copy(v);
                return *this;
            }
 
            bool operator==(const Value &v) {
                if (valueType != v.valueType) return false;
                switch (valueType) {
                case NUMBER:
                    return as<double>() == v.as<double>();
                case VECTOR:
                    return as<TracePoint>() == v.as<TracePoint>();
                case MATRIX:
                    return as<Matrix>() == v.as<Matrix>();
                case COLOR:
                    return as<Color>() == v.as<Color>();
                case ACOLOR:
                    return as<AColor>() == v.as<AColor>();
                case TRANSFORM:
                    return as<TraceTransform>() == v.as<TraceTransform>();
                case OBJECT:
                    return as<Object*>() == v.as<Object*>();
                case OBJECTID:
                    return as<ObjectID>() == v.as<ObjectID>();
                case LIST:
                    return as<ValueRefList>() == v.as<ValueRefList>();
                case LISTINT:
                    return as<IntRefList>() == v.as<IntRefList>();
                case LISTFLOAT:
                    return as<FloatRefList>() == v.as<FloatRefList>();
                case LISTVECTOR:
                    return as<VectorRefList>() == v.as<VectorRefList>();
                case LISTCOLOR:
                    return as<ColorRefList>() == v.as<ColorRefList>();
                case LISTSTRING:
                    return as<StringValue>().stringList == v.as<StringValue>().stringList;
                case STRING:
                    return as<StringValue>().str == v.as<StringValue>().str;
                case RUNTIMEVALUE:
                    return as<RuntimeValue>() == v.as<RuntimeValue>();
                case UNKNOWN:
                    return false;
                }
            }
 
            bool operator!=(const Value& v) {
                return !operator==(v);
            }
 
            ~Value() {
                destroy();
            }
 
            VALUE_TYPE getValueType() const {
                return valueType;
            }
 
            // Pair
            void setRuntimeValue(const RuntimeValue &rtVal) {
                destroy();
                valueType = RUNTIMEVALUE;
                new (data) RuntimeValue(rtVal);
            }
 
            RuntimeValue getRuntimeValue() const {
                if (valueType == RUNTIMEVALUE) {
                    return as<RuntimeValue>();
                }
                
                return RuntimeValue();
            }
 
            void setDouble(double val) {
                destroy();
                valueType = NUMBER;
                new (data) double(val);
            }
 
            double getDouble() const {
                if (valueType == NUMBER) {
                    return as<double>();
                }
                
                return 0.0;
            }
 
            void setList(const ValueRefList &list) {
                destroy();
                valueType = LIST;
                new (data) ValueRefList(list);
            }
 
            ValueRefList getList() const {
                if (valueType == LIST) {
                    return as<ValueRefList>();
                }
                
                return ValueRefList();
            }
 
            void setListVector(const VectorRefList &list) {
                destroy();
                valueType = LISTVECTOR;
                new (data) VectorRefList(list);
            }
 
            VectorRefList getListVector() const {
                if (valueType == LISTVECTOR) {
                    return as<VectorRefList>();
                }
                
                return VectorRefList();
            }
 
            void setListInt(const IntRefList &list) {
                destroy();
                valueType = LISTINT;
                new (data) IntRefList(list);
            }
 
            IntRefList getListInt() const {
                if (valueType == LISTINT) {
                    return as<IntRefList>();
                }
                
                return IntRefList();
            }
 
            void setListColor(const ColorRefList &list) {
                destroy();
                valueType = LISTCOLOR;
                new (data) ColorRefList(list);
            }
 
            ColorRefList getListColor() const {
                if (valueType == LISTCOLOR) {
                    return as<ColorRefList>();
                }
                
                return ColorRefList();
            }
 
            void setListFloat(const FloatRefList &list) {
                destroy();
                valueType = LISTFLOAT;
                new (data) FloatRefList(list);
            }
 
            FloatRefList getListFloat() const {
                if (valueType == LISTFLOAT) {
                    return as<FloatRefList>();
                }
                
                return FloatRefList();
            }
 
            void setListString(const CharStringRefList &list) {
                destroy();
                valueType = LISTSTRING;
                new (&(as<StringValue>().stringList)) CharStringRefList(list);
                new (&(as<StringValue>().scenePath)) CharString();
            }
 
            CharStringRefList getListString() const {
                if (valueType == LISTSTRING) {
                    return as<StringValue>().stringList;
                }
                
                return CharStringRefList();
            }
 
            void setObject(Object *obj) {
                destroy();
                valueType = OBJECT;
                new (data) Object*(obj);
            }
 
            Object* getObject() const {
                if (valueType == OBJECT) {
                    return as<Object*>();
                }
                
                return nullptr;
            }
 
            // Plugin
            void setObjectID(const ObjectID &id) {
                destroy();
                valueType = OBJECTID;
                new (data) ObjectID(id);
            }
 
            ObjectID getObjectID() const {
                if (valueType == OBJECTID) {
                    return as<ObjectID>();
                }
                
                return ObjectID();
            }
 
            Vector getVector() const {
                if (valueType == VECTOR) {
                    const TracePoint &pt = as<TracePoint>();
                    return Vector(pt.x, pt.y, pt.z);
                }
                
                return Vector(0.0f);
            }
 
            void setVector(const TracePoint &v) {
                destroy();
                valueType = VECTOR;
                new (data) TracePoint(v);
            }
 
            void setVector(const Vector &v) {
                destroy();
                valueType = VECTOR;
                new (data) TracePoint(v);
            }
 
            TracePoint getTracePoint() const {
                if (valueType == VECTOR) {
                    return as<TracePoint>();
                }
                
                return TracePoint(0.0f);
            }
 
            void setTracePoint(const TracePoint &v) {
                destroy();
                valueType = VECTOR;
                new (data) TracePoint(v);
            }
 
            Matrix getMatrix() const {
                if (valueType == MATRIX || valueType == TRANSFORM) {
                    return as<Matrix>();
                }
 
                return Matrix(0);
            }
 
            void setMatrix(const Matrix &v) {
                destroy();
                valueType = MATRIX;
                new (data) Matrix(v);
            }
 
            Color getColor() const {
                if (valueType == COLOR) {
                    return as<Color>();
                }
 
                return Color(0.0f);
            }
 
            void setColor(const Color &v) {
                destroy();
                valueType = COLOR;
                new (data) Color(v);
            }
 
            AColor getAColor() const {
                if (valueType == ACOLOR) {
                    return as<AColor>();
                } else if (valueType == COLOR) {
                    return AColor(as<Color>());
                }
                
                return AColor(0.0f);
            }
 
            void setAColor(const AColor &v) {
                destroy();
                valueType = ACOLOR;
                new (data) AColor(v);
            }
 
            void setString(const CharString &str) {
                destroy();
                valueType = STRING;
                new (&(as<StringValue>().str)) CharString(str);
                new (&(as<StringValue>().scenePath)) CharString();
            }
 
            CharString getString() const {
                if (valueType == STRING) {
                    return as<StringValue>().str;
                }
                
                return CharString();
            }
 
            void setTransform(const TraceTransform &tr) {
                destroy();
                valueType = TRANSFORM;
                new (data) TraceTransform(tr);
            }
 
            TraceTransform getTransform() const {
                if (valueType == TRANSFORM) {
                    return as<TraceTransform>();
                } else if (valueType == MATRIX) {
                    TraceTransform t;
                    t.m = as<Matrix>();
                    t.offs = TracePoint(0.0);
                    return t;
                }
                
                return TraceTransform(0);
            }
 
 
            // AppSDK PluginRef
            const PluginRef getPlugin(VRayRenderer& renderer) const {
                struct PluginRefWrap : public PluginRef {
                    PluginRefWrap(VRayRenderer& renderer, InstanceId id, const char* output)
                        : PluginRef(renderer, id, output) { }
                };
                if (valueType == OBJECTID) {
                    ObjectID objId = as<ObjectID>();
                    return PluginRefWrap(renderer, objId.id, objId.subobj.ptr());
                }
                return PluginRefWrap(renderer, 0, nullptr);
            }
 
            void setPlugin(const PluginRef& plugin) {
                destroy();
                valueType = OBJECTID;
                new (data) ObjectID(plugin);
            }
        };
 
        inline std::ostream& operator <<(std::ostream& stream, const Value& value) {
            switch (value.getValueType()) {
            case NUMBER:
                stream << value.getDouble();
                break;
            case VECTOR:
                stream << value.getVector();
                break;
            case MATRIX:
                stream << value.getMatrix();
                break;
            case COLOR:
                stream << value.getColor();
                break;
            case ACOLOR:
                stream << value.getAColor();
                break;
            case TRANSFORM:
                stream << value.getTransform().toTransform();
                break;
            case OBJECT:
                stream << "<Scene Parser Object>";
                break;
            case OBJECTID: {
                const ObjectID& objId = value.getObjectID();
                stream << "ObjectID<" << value.getObjectID().id;
                if (!objId.subobj.empty())
                    stream << ", " << objId.subobj.ptr();
                stream << ">";
            }   break;
            case LIST:
                stream << value.getList();
                break;
            case LISTINT:
                stream << value.getListInt();
                break;
            case LISTFLOAT:
                stream << value.getListFloat();
                break;
            case LISTVECTOR:
                stream << value.getListVector();
                break;
            case LISTCOLOR:
                stream << value.getListColor();
                break;
            case LISTSTRING:
                stream << value.getListString();
                break;
            case STRING:
                stream << value.getString();
                break;
            case RUNTIMEVALUE:
                stream << "<Scene Parser Runtime Value>";
                break;
            case UNKNOWN:
                stream << "<Unknown Value>";
                break;
            }
            return stream;
        }
 
    }
#undef DATAPTR
}
 
#endif // _VRAY_INTEROP_HPP_
 
#else // _VRAY_SDK_HPP_
 
# ifndef VRAY_SDK_INTEROPERABILITY
#  define VRAY_SDK_INTEROPERABILITY
# endif
# include "vraysdk.hpp"
 
#endif // _VRAY_SDK_HPP_