ivalue.h

Go to the documentation of this file.

/***************************************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 **************************************************************************************************/
 
#ifndef MI_NEURAYLIB_IVALUE_H
#define MI_NEURAYLIB_IVALUE_H
 
#include <mi/base/handle.h>
#include <mi/math/color.h>
#include <mi/math/matrix.h>
#include <mi/math/spectrum.h>
#include <mi/math/vector.h>
#include <mi/neuraylib/itype.h>
 
namespace mi {
 
namespace neuraylib {
 
class IAnnotation;
class IAnnotation_block;
 
class IValue : public
    mi::base::Interface_declare<0xbf837f4a,0x9034,0x4f32,0xaf,0x5c,0x75,0xb3,0x67,0x64,0x53,0x23>
{
public:
    enum Kind {
        VK_BOOL,
        VK_INT,
        VK_ENUM,
        VK_FLOAT,
        VK_DOUBLE,
        VK_STRING,
        VK_VECTOR,
        VK_MATRIX,
        VK_COLOR,
        VK_ARRAY,
        VK_STRUCT,
        VK_INVALID_DF,
        VK_TEXTURE,
        VK_LIGHT_PROFILE,
        VK_BSDF_MEASUREMENT,
        //  Undocumented, for alignment only.
        VK_FORCE_32_BIT = 0xffffffffU
    };
 
    virtual Kind get_kind() const = 0;
 
    virtual const IType* get_type() const = 0;
 
    template <class T>
    const T* get_type() const
    {
        const IType* ptr_type = get_type();
        if( !ptr_type)
            return 0;
        const T* ptr_T = static_cast<const T*>( ptr_type->get_interface( typename T::IID()));
        ptr_type->release();
        return ptr_T;
    }
};
 
mi_static_assert( sizeof( IValue::Kind) == sizeof( Uint32));
 
class IValue_atomic : public
    mi::base::Interface_declare<0xf2413c80,0x8e71,0x4974,0xaa,0xf2,0x60,0xd5,0xe2,0x94,0x9d,0x3e,
                                neuraylib::IValue>
{
public:
    const IType_atomic* get_type() const = 0;
};
 
class IValue_bool : public
    mi::base::Interface_declare<0xaf253a14,0x1f04,0x4b67,0xba,0x70,0x7b,0x01,0x05,0xfb,0xc8,0xf5,
                                neuraylib::IValue_atomic>
{
public:
    static const Kind s_kind = VK_BOOL;
 
    const IType_bool* get_type() const = 0;
 
    virtual bool get_value() const = 0;
 
    virtual void set_value( bool value) = 0;
};
 
class IValue_int : public
    mi::base::Interface_declare<0x91e6f145,0x280d,0x4d68,0x95,0x57,0xe1,0xd0,0x9c,0xd2,0x5c,0x74,
                                neuraylib::IValue_atomic>
{
public:
    static const Kind s_kind = VK_INT;
 
    const IType_int* get_type() const = 0;
 
    virtual Sint32 get_value() const = 0;
 
    virtual void set_value( Sint32 value) = 0;
};
 
class IValue_enum : public
    mi::base::Interface_declare<0xdc876204,0x8a97,0x40e9,0xb9,0xb6,0xca,0xdc,0xdd,0x60,0x1f,0xbf,
                                neuraylib::IValue_atomic>
{
public:
    static const Kind s_kind = VK_ENUM;
 
    virtual const IType_enum* get_type() const = 0;
 
    virtual Sint32 get_value() const = 0;
 
    virtual Size get_index() const = 0;
 
    virtual Sint32 set_value( Sint32 value) = 0;
 
    virtual Sint32 set_index( Size index) = 0;
 
    virtual const char* get_name() const = 0;
 
    virtual Sint32 set_name( const char* name) = 0;
};
 
class IValue_float : public
    mi::base::Interface_declare<0x21f07151,0x74b5,0x4296,0x90,0x29,0xc7,0xde,0x49,0x38,0x2a,0xbc,
                                neuraylib::IValue_atomic>
{
public:
    static const Kind s_kind = VK_FLOAT;
 
    const IType_float* get_type() const = 0;
 
    virtual Float32 get_value() const = 0;
 
    virtual void set_value( Float32 value) = 0;
};
 
class IValue_double : public
    mi::base::Interface_declare<0xbdc84417,0x3e83,0x4bab,0x90,0xb1,0x9f,0x57,0xed,0x7b,0x15,0x03,
                                neuraylib::IValue_atomic>
{
public:
    static const Kind s_kind = VK_DOUBLE;
 
    const IType_double* get_type() const = 0;
 
    virtual Float64 get_value() const = 0;
 
    virtual void set_value( Float64 value) = 0;
};
 
class IValue_string : public
    mi::base::Interface_declare<0x64b28506,0x8675,0x4724,0xa1,0x0d,0xc6,0xf2,0x35,0x46,0x26,0x39,
                                neuraylib::IValue_atomic>
{
public:
    static const Kind s_kind = VK_STRING;
 
    const IType_string* get_type() const = 0;
 
    virtual const char* get_value() const = 0;
 
    virtual void set_value( const char* value) = 0;
};
 
class IValue_string_localized : public
    mi::base::Interface_declare<0x1fe80d3d,0xe79e,0x4bdb,0xb6,0x30,0xe3,0x36,0x31,0xa4,0x1e,0x39,
                                neuraylib::IValue_string>
{
public:
    virtual const char* get_original_value() const = 0;
};
 
class IValue_compound : public
    mi::base::Interface_declare<0xdabc8fe3,0x5c70,0x4ef0,0xa2,0xf7,0x34,0x30,0xb5,0x67,0xdc,0x75,
                                neuraylib::IValue>
{
public:
    virtual const IType_compound* get_type() const = 0;
 
    virtual Size get_size() const = 0;
 
    virtual const IValue* get_value( Size index) const = 0;
 
    template <class T>
    const T* get_value( Size index) const
    {
        const IValue* ptr_value = get_value( index);
        if( !ptr_value)
            return 0;
        const T* ptr_T = static_cast<const T*>( ptr_value->get_interface( typename T::IID()));
        ptr_value->release();
        return ptr_T;
    }
 
    virtual IValue* get_value( Size index) = 0;
 
    template <class T>
    T* get_value( Size index)
    {
        IValue* ptr_value = get_value( index);
        if( !ptr_value)
            return 0;
        T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
        ptr_value->release();
        return ptr_T;
    }
 
    virtual Sint32 set_value( Size index, IValue* value) = 0;
};
 
class IValue_vector : public
    mi::base::Interface_declare<0xf5d09fc3,0xd783,0x4571,0x8d,0x59,0x41,0xb1,0xff,0xd3,0x91,0x49,
                                neuraylib::IValue_compound>
{
public:
    static const Kind s_kind = VK_VECTOR;
 
    virtual const IType_vector* get_type() const = 0;
 
    virtual const IValue_atomic* get_value( Size index) const = 0;
 
    template <class T>
    const T* get_value( Size index) const
    {
        const IValue_atomic* ptr_value = get_value( index);
        if( !ptr_value)
            return 0;
        const T* ptr_T = static_cast<const T*>( ptr_value->get_interface( typename T::IID()));
        ptr_value->release();
        return ptr_T;
    }
 
    virtual IValue_atomic* get_value( Size index) = 0;
 
    template <class T>
    T* get_value( Size index)
    {
        IValue_atomic* ptr_value = get_value( index);
        if( !ptr_value)
            return 0;
        T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
        ptr_value->release();
        return ptr_T;
    }
};
 
class IValue_matrix : public
    mi::base::Interface_declare<0x9ee95da6,0x2cd6,0x4168,0x89,0xea,0x92,0x10,0x57,0xda,0xe6,0xdc,
                                neuraylib::IValue_compound>
{
public:
    static const Kind s_kind = VK_MATRIX;
 
    virtual const IType_matrix* get_type() const = 0;
 
    virtual const IValue_vector* get_value( Size index) const = 0;
 
    virtual IValue_vector* get_value( Size index) = 0;
};
 
class IValue_color : public
    mi::base::Interface_declare<0x3bb9bf46,0x1cbb,0x4460,0xbe,0x27,0x10,0xf5,0x71,0x61,0x96,0xa2,
                                neuraylib::IValue_compound>
{
public:
    static const Kind s_kind = VK_COLOR;
 
    virtual const IType_color* get_type() const = 0;
 
    virtual const IValue_float* get_value( Size index) const = 0;
 
    virtual IValue_float* get_value( Size index) = 0;
 
    virtual Sint32 set_value( Size index, IValue_float* value) = 0;
 
    using IValue_compound::set_value;
};
 
class IValue_array : public
    mi::base::Interface_declare<0xa17c5f57,0xa647,0x41c4,0x86,0x2f,0x4c,0x0d,0xe1,0x30,0x08,0xfc,
                                neuraylib::IValue_compound>
{
public:
    static const Kind s_kind = VK_ARRAY;
 
    virtual const IType_array* get_type() const = 0;
 
    virtual Sint32 set_size( Size size) = 0;
};
 
class IValue_struct : public
    mi::base::Interface_declare<0xcbe089ce,0x4aea,0x474d,0x94,0x5f,0x52,0x13,0xef,0x01,0xce,0x81,
                                neuraylib::IValue_compound>
{
public:
    static const Kind s_kind = VK_STRUCT;
 
    virtual const IType_struct* get_type() const = 0;
 
    virtual const IValue* get_field( const char* name) const = 0;
 
    template <class T>
    const T* get_field( const char* name) const
    {
        const IValue* ptr_value = get_field( name);
        if( !ptr_value)
            return 0;
        T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
        ptr_value->release();
        return ptr_T;
    }
 
    virtual IValue* get_field( const char* name) = 0;
 
    template <class T>
    T* get_field( const char* name)
    {
        IValue* ptr_value = get_field( name);
        if( !ptr_value)
            return 0;
        T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
        ptr_value->release();
        return ptr_T;
    }
 
    virtual Sint32 set_field( const char* name, IValue* value) = 0;
};
 
class IValue_resource : public
    mi::base::Interface_declare<0x479bb10c,0xd444,0x426c,0x83,0xab,0x26,0xdf,0xf6,0x1d,0x6f,0xd7,
                                neuraylib::IValue>
{
public:
    virtual const IType_resource* get_type() const = 0;
 
    virtual const char* get_value() const = 0;
 
    virtual Sint32 set_value( const char* value) = 0;
 
    virtual const char* get_file_path() const = 0;
};
 
class IValue_texture : public
    mi::base::Interface_declare<0xf2a03651,0x8883,0x4ba4,0xb9,0xa9,0xe6,0x87,0x34,0x3a,0xb3,0xb8,
                                neuraylib::IValue_resource>
{
public:
    static const Kind s_kind = VK_TEXTURE;
 
    virtual const IType_texture* get_type() const = 0;
 
    virtual Float32 get_gamma() const = 0;
 
    virtual const char* get_selector() const = 0;
};
 
class IValue_light_profile : public
    mi::base::Interface_declare<0xd7c9ffbd,0xb5e4,0x4bf4,0x90,0xd0,0xe9,0x75,0x4d,0x6d,0x49,0x07,
                                neuraylib::IValue_resource>
{
public:
    static const Kind s_kind = VK_LIGHT_PROFILE;
 
    virtual const IType_light_profile* get_type() const = 0;
};
 
class IValue_bsdf_measurement : public
    mi::base::Interface_declare<0x31a55244,0x415c,0x4b4d,0xa7,0x86,0x2f,0x21,0x9c,0xb8,0xb9,0xff,
                                neuraylib::IValue_resource>
{
public:
    static const Kind s_kind = VK_BSDF_MEASUREMENT;
 
    virtual const IType_bsdf_measurement* get_type() const = 0;
};
 
class IValue_invalid_df : public
    mi::base::Interface_declare<0x1588b6fa,0xa143,0x4bac,0xa0,0x32,0x06,0xbd,0x9e,0x7f,0xb6,0xe5,
                                neuraylib::IValue>
{
public:
    static const Kind s_kind = VK_INVALID_DF;
 
    const IType_reference* get_type() const = 0;
};
 
class IValue_list : public
    mi::base::Interface_declare<0x8027a5e5,0x4e25,0x410c,0xbb,0xce,0x84,0xb4,0x88,0x8b,0x03,0x46>
{
public:
    virtual Size get_size() const = 0;
 
    virtual Size get_index( const char* name) const = 0;
 
    virtual const char* get_name( Size index) const = 0;
 
    virtual const IValue* get_value( Size index) const = 0;
 
    template <class T>
    const T* get_value( Size index) const
    {
        const IValue* ptr_value = get_value( index);
        if( !ptr_value)
            return 0;
        const T* ptr_T = static_cast<const T*>( ptr_value->get_interface( typename T::IID()));
        ptr_value->release();
        return ptr_T;
    }
 
    virtual const IValue* get_value( const char* name) const = 0;
 
    template <class T>
    const T* get_value( const char* name) const
    {
        const IValue* ptr_value = get_value( name);
        if( !ptr_value)
            return 0;
        const T* ptr_T = static_cast<const T*>( ptr_value->get_interface( typename T::IID()));
        ptr_value->release();
        return ptr_T;
    }
 
    virtual Sint32 set_value( Size index, const IValue* value) = 0;
 
    virtual Sint32 set_value( const char* name, const IValue* value) = 0;
 
    virtual Sint32 add_value( const char* name, const IValue* value) = 0;
};
 
class IValue_factory : public
    mi::base::Interface_declare<0x82595c0d,0x3687,0x4b45,0xa3,0x38,0x42,0x20,0x02,0xea,0x3f,0x9b>
{
public:
 
 
    virtual IType_factory* get_type_factory() const = 0;
 
 
 
    virtual IValue_bool* create_bool( bool value = false) const = 0;
 
    virtual IValue_int* create_int( Sint32 value = 0) const = 0;
 
    virtual IValue_enum* create_enum( const IType_enum* type, Size index = 0) const = 0;
 
    virtual IValue_float* create_float( Float32 value = 0.0f) const = 0;
 
    virtual IValue_double* create_double( Float64 value = 0.0) const = 0;
 
    virtual IValue_string* create_string( const char* value = "") const = 0;
 
    virtual IValue_vector* create_vector( const IType_vector* type) const = 0;
 
    virtual IValue_matrix* create_matrix( const IType_matrix* type) const = 0;
 
    virtual IValue_color* create_color(
        Float32 red = 0.0f,
        Float32 green = 0.0f,
        Float32 blue = 0.0f) const = 0;
 
    virtual IValue_array* create_array( const IType_array* type) const = 0;
 
    virtual IValue_struct* create_struct( const IType_struct* type) const = 0;
 
    virtual IValue_texture* create_texture( const IType_texture* type, const char* value) const = 0;
 
    virtual IValue_light_profile* create_light_profile( const char* value) const = 0;
 
    virtual IValue_bsdf_measurement* create_bsdf_measurement( const char* value) const = 0;
 
    virtual IValue_invalid_df* create_invalid_df( const IType_reference* type) const = 0;
 
    virtual IValue* create( const IType* type) const = 0;
 
    template <class T>
    T* create( const IType* type) const
    {
        IValue* ptr_value = create( type);
        if( !ptr_value)
            return 0;
        T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
        ptr_value->release();
        return ptr_T;
    }
 
    virtual IValue* create( const IAnnotation* annotation) const = 0;
 
    template <class T>
    T* create( const IAnnotation* annotation) const
    {
        IValue* ptr_value = create( annotation);
        if( !ptr_value)
            return 0;
        T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
        ptr_value->release();
        return ptr_T;
    }
 
    virtual IValue* create( const IType* type, const IAnnotation_block* annotation_block) const = 0;
 
    template <class T>
    T* create( const IType* type, const IAnnotation_block* annotation_block) const
    {
        IValue* ptr_value = create( type, annotation_block);
        if( !ptr_value)
            return 0;
        T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
        ptr_value->release();
        return ptr_T;
    }
 
    virtual IValue_list* create_value_list() const = 0;
 
 
 
    virtual IValue* clone( const IValue* value) const = 0;
 
    template <class T>
    T* clone( const T* value) const
    {
        IValue* ptr_value = clone( static_cast<const IValue*>( value));
        if( !ptr_value)
            return 0;
        T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
        ptr_value->release();
        return ptr_T;
    }
 
    virtual IValue_list* clone( const IValue_list* value_list) const = 0;
 
 
 
    virtual Sint32 compare(
        const IValue* lhs, const IValue* rhs, Float64 epsilon = 0.0) const = 0;
 
    virtual Sint32 compare(
        const IValue_list* lhs, const IValue_list* rhs, Float64 epsilon = 0.0) const = 0;
 
 
 
    virtual const IString* dump( const IValue* value, const char* name, Size depth = 0) const = 0;
 
    virtual const IString* dump(
        const IValue_list* list, const char* name, Size depth = 0) const = 0;
 
};
 
template<class T>
mi::Sint32 set_value( mi::neuraylib::IValue* value, const T& v)
{
    mi::base::Handle<mi::neuraylib::IValue_int> value_int(
        value->get_interface<mi::neuraylib::IValue_int>());
    if( value_int) {
        value_int->set_value( v);
        return 0;
    }
 
    mi::base::Handle<mi::neuraylib::IValue_enum> value_enum(
        value->get_interface<mi::neuraylib::IValue_enum>());
    if( value_enum) {
        if( value_enum->set_value( v) != 0)
            return -2;
        return 0;
    }
 
    return -1;
}
 
inline mi::Sint32 set_value( mi::neuraylib::IValue* value, const bool& v)
{
    mi::base::Handle<mi::neuraylib::IValue_bool> value_bool(
        value->get_interface<mi::neuraylib::IValue_bool>());
    if( value_bool) {
        value_bool->set_value( v);
        return 0;
    }
 
    return -1;
}
 
inline mi::Sint32 set_value( mi::neuraylib::IValue* value, const mi::Float32& v)
{
    mi::base::Handle<mi::neuraylib::IValue_float> value_float(
        value->get_interface<mi::neuraylib::IValue_float>());
    if( value_float) {
        value_float->set_value( v);
        return 0;
    }
 
    mi::base::Handle<mi::neuraylib::IValue_double> value_double(
        value->get_interface<mi::neuraylib::IValue_double>());
    if( value_double) {
        value_double->set_value( v);
        return 0;
    }
 
    return -1;
}
 
inline mi::Sint32 set_value( mi::neuraylib::IValue* value, const mi::Float64& v)
{
    mi::base::Handle<mi::neuraylib::IValue_float> value_float(
        value->get_interface<mi::neuraylib::IValue_float>());
    if( value_float) {
        value_float->set_value( static_cast<mi::Float32>( v));
        return 0;
    }
 
    mi::base::Handle<mi::neuraylib::IValue_double> value_double(
        value->get_interface<mi::neuraylib::IValue_double>());
    if( value_double) {
        value_double->set_value( v);
        return 0;
    }
 
    return -1;
}
 
inline mi::Sint32 set_value( mi::neuraylib::IValue* value, const char* v)
{
    mi::base::Handle<mi::neuraylib::IValue_enum> value_enum(
        value->get_interface<mi::neuraylib::IValue_enum>());
    if( value_enum) {
        if( value_enum->set_name( v) != 0)
            return -2;
        return 0;
    }
 
    mi::base::Handle<mi::neuraylib::IValue_string> value_string(
        value->get_interface<mi::neuraylib::IValue_string>());
    if( value_string) {
        value_string->set_value( v);
        return 0;
    }
 
    mi::base::Handle<mi::neuraylib::IValue_resource> value_resource(
        value->get_interface<mi::neuraylib::IValue_resource>());
    if( value_resource) {
        if( value_resource->set_value( v) != 0)
            return -2;
        return 0;
    }
 
    return -1;
}
 
template<class T, Size DIM>
mi::Sint32 set_value( mi::neuraylib::IValue* value, const mi::math::Vector<T,DIM>& v)
{
    mi::base::Handle<mi::neuraylib::IValue_vector> value_vector(
        value->get_interface<mi::neuraylib::IValue_vector>());
    if( value_vector) {
        if( value_vector->get_size() != DIM)
            return -1;
        for( Size  i = 0; i < DIM; ++i) {
            mi::base::Handle<mi::neuraylib::IValue> component( value_vector->get_value( i));
            mi::Sint32 result = set_value( component.get(), v[i]);
            if( result != 0)
                return result;
        }
        return 0;
    }
 
    return -1;
}
 
template<class T, Size ROW, Size COL>
mi::Sint32 set_value( mi::neuraylib::IValue* value, const mi::math::Matrix<T,ROW,COL>& v)
{
    mi::base::Handle<mi::neuraylib::IValue_matrix> value_matrix(
        value->get_interface<mi::neuraylib::IValue_matrix>());
    if( value_matrix) {
        if( value_matrix->get_size() != ROW)
            return -1;
        for( Size  i = 0; i < ROW; ++i) {
            mi::base::Handle<mi::neuraylib::IValue_vector> column( value_matrix->get_value( i));
            if( column->get_size() != COL)
                return -1;
            for( Size j = 0; j < COL; ++j) {
                mi::base::Handle<mi::neuraylib::IValue> element( column->get_value( j));
                mi::Sint32 result = set_value( element.get(), v[i][j]);
                if( result != 0)
                    return result;
            }
        }
        return 0;
    }
 
    return -1;
}
 
inline mi::Sint32 set_value( mi::neuraylib::IValue* value, const mi::math::Color& v)
{
    mi::base::Handle<mi::neuraylib::IValue_color> value_color(
        value->get_interface<mi::neuraylib::IValue_color>());
    if( value_color) {
        mi::base::Handle<mi::neuraylib::IValue_float> red  ( value_color->get_value( 0));
        red  ->set_value( v.r);
        mi::base::Handle<mi::neuraylib::IValue_float> green( value_color->get_value( 1));
        green->set_value( v.g);
        mi::base::Handle<mi::neuraylib::IValue_float> blue ( value_color->get_value( 2));
        blue ->set_value( v.b);
        return 0;
    }
 
    return -1;
}
 
inline mi::Sint32 set_value( mi::neuraylib::IValue* value, const mi::math::Spectrum& v)
{
    mi::base::Handle<mi::neuraylib::IValue_color> value_color(
        value->get_interface<mi::neuraylib::IValue_color>());
    if( value_color) {
        mi::base::Handle<mi::neuraylib::IValue_float> red  ( value_color->get_value( 0));
        red  ->set_value( v[0]);
        mi::base::Handle<mi::neuraylib::IValue_float> green( value_color->get_value( 1));
        green->set_value( v[1]);
        mi::base::Handle<mi::neuraylib::IValue_float> blue ( value_color->get_value( 2));
        blue ->set_value( v[2]);
        return 0;
    }
 
    return -1;
}
 
template<class T>
mi::Sint32 set_value( mi::neuraylib::IValue* value, mi::Size index, const T& v)
{
    mi::base::Handle<mi::neuraylib::IValue_compound> value_compound(
        value->get_interface<mi::neuraylib::IValue_compound>());
    if( value_compound) {
        mi::base::Handle<mi::neuraylib::IValue> component( value_compound->get_value( index));
        if( !component)
            return -3;
        return set_value( component.get(), v);
    }
 
    return -1;
}
 
template<class T>
mi::Sint32 set_value( mi::neuraylib::IValue* value, const char* name, const T& v)
{
    mi::base::Handle<mi::neuraylib::IValue_struct> value_struct(
        value->get_interface<mi::neuraylib::IValue_struct>());
    if( value_struct) {
        mi::base::Handle<mi::neuraylib::IValue> field( value_struct->get_field( name));
        if( !field)
            return -3;
        return set_value( field.get(), v);
    }
 
    return -1;
}
 
template<class T>
mi::Sint32 set_value( mi::neuraylib::IValue* value, const T* v, mi::Size n)
{
    mi::base::Handle<mi::neuraylib::IValue_array> value_array(
        value->get_interface<mi::neuraylib::IValue_array>());
    if( value_array) {
        if( value_array->get_size() != n)
            return -3;
        for( mi::Size i = 0; i < n; ++i) {
            mi::base::Handle<mi::neuraylib::IValue> element( value_array->get_value( i));
            mi::Sint32 result = set_value( element.get(), v[i]);
            if( result != 0)
                return result;
        }
        return 0;
    }
 
    return -1;
}
 
template<class T>
mi::Sint32 get_value( const mi::neuraylib::IValue* value, T& v)
{
    mi::base::Handle<const mi::neuraylib::IValue_int> value_int(
        value->get_interface<mi::neuraylib::IValue_int>());
    if( value_int) {
        v = value_int->get_value();
        return 0;
    }
 
    mi::base::Handle<const mi::neuraylib::IValue_enum> value_enum(
        value->get_interface<mi::neuraylib::IValue_enum>());
    if( value_enum) {
        v = value_enum->get_value();
        return 0;
    }
 
    return -1;
}
 
inline mi::Sint32 get_value( const mi::neuraylib::IValue* value, bool& v)
{
    mi::base::Handle<const mi::neuraylib::IValue_bool> value_bool(
        value->get_interface<mi::neuraylib::IValue_bool>());
    if( value_bool) {
        v = value_bool->get_value();
        return 0;
    }
 
    return -1;
}
 
inline mi::Sint32 get_value( const mi::neuraylib::IValue* value, mi::Float32& v)
{
    mi::base::Handle<const mi::neuraylib::IValue_float> value_float(
        value->get_interface<mi::neuraylib::IValue_float>());
    if( value_float) {
        v = value_float->get_value();
        return 0;
    }
 
    mi::base::Handle<const mi::neuraylib::IValue_double> value_double(
        value->get_interface<mi::neuraylib::IValue_double>());
    if( value_double) {
        v = static_cast<mi::Float32>( value_double->get_value());
        return 0;
    }
 
    return -1;
}
 
inline mi::Sint32 get_value( const mi::neuraylib::IValue* value, mi::Float64& v)
{
    mi::base::Handle<const mi::neuraylib::IValue_float> value_float(
        value->get_interface<mi::neuraylib::IValue_float>());
    if( value_float) {
        v = value_float->get_value();
        return 0;
    }
 
    mi::base::Handle<const mi::neuraylib::IValue_double> value_double(
        value->get_interface<mi::neuraylib::IValue_double>());
    if( value_double) {
        v = value_double->get_value();
        return 0;
    }
 
    return -1;
}
 
inline mi::Sint32 get_value( const mi::neuraylib::IValue* value, const char*& v)
{
    mi::base::Handle<const mi::neuraylib::IValue_enum> value_enum(
        value->get_interface<mi::neuraylib::IValue_enum>());
    if( value_enum) {
        v = value_enum->get_name();
        return 0;
    }
 
    mi::base::Handle<const mi::neuraylib::IValue_string> value_string(
        value->get_interface<mi::neuraylib::IValue_string>());
    if( value_string) {
        v = value_string->get_value();
        return 0;
    }
 
    mi::base::Handle<const mi::neuraylib::IValue_resource> value_resource(
        value->get_interface<mi::neuraylib::IValue_resource>());
    if( value_resource) {
        v = value_resource->get_value();
        return 0;
    }
 
    return -1;
}
 
template <class T, Size DIM>
mi::Sint32 get_value( const mi::neuraylib::IValue* value, mi::math::Vector<T,DIM>& v)
{
    mi::base::Handle<const mi::neuraylib::IValue_vector> value_vector(
        value->get_interface<mi::neuraylib::IValue_vector>());
    if( value_vector) {
        if( value_vector->get_size() != DIM)
            return -1;
        for( Size i = 0; i < DIM; ++i) {
            mi::base::Handle<const mi::neuraylib::IValue> component( value_vector->get_value( i));
            mi::Sint32 result = get_value( component.get(), v[i]);
            if( result != 0)
                return result;
        }
        return 0;
    }
 
    return -1;
}
 
template <class T, Size ROW, Size COL>
mi::Sint32 get_value( const mi::neuraylib::IValue* value, mi::math::Matrix<T,ROW,COL>& v)
{
    mi::base::Handle<const mi::neuraylib::IValue_matrix> value_matrix(
        value->get_interface<mi::neuraylib::IValue_matrix>());
    if( value_matrix) {
        if( value_matrix->get_size() != ROW)
            return -1;
        for( Size i = 0; i < ROW; ++i) {
            mi::base::Handle<const mi::neuraylib::IValue_vector> column(
                value_matrix->get_value( i));
            if( column->get_size() != COL)
                return -1;
            for( Size j = 0; j < COL; ++j) {
                mi::base::Handle<const mi::neuraylib::IValue> element( column->get_value( j));
                mi::Sint32 result = get_value( element.get(), v[i][j]);
                if( result != 0)
                    return result;
            }
        }
        return 0;
    }
 
    return -1;
}
 
inline mi::Sint32 get_value( const mi::neuraylib::IValue* value, mi::math::Color& v)
{
    mi::base::Handle<const mi::neuraylib::IValue_color> value_color(
        value->get_interface<mi::neuraylib::IValue_color>());
    if( value_color) {
        mi::base::Handle<const mi::neuraylib::IValue_float> red  ( value_color->get_value( 0));
        v.r = red  ->get_value();
        mi::base::Handle<const mi::neuraylib::IValue_float> green( value_color->get_value( 1));
        v.g = green->get_value();
        mi::base::Handle<const mi::neuraylib::IValue_float> blue ( value_color->get_value( 2));
        v.b = blue ->get_value();
        v.a = 1.0f;
        return 0;
    }
 
    return -1;
}
 
inline mi::Sint32 get_value( const mi::neuraylib::IValue* value, mi::math::Spectrum& v)
{
    mi::base::Handle<const mi::neuraylib::IValue_color> value_color(
        value->get_interface<mi::neuraylib::IValue_color>());
    if( value_color) {
        mi::base::Handle<const mi::neuraylib::IValue_float> red  ( value_color->get_value( 0));
        v[0] = red  ->get_value();
        mi::base::Handle<const mi::neuraylib::IValue_float> green( value_color->get_value( 1));
        v[1] = green->get_value();
        mi::base::Handle<const mi::neuraylib::IValue_float> blue ( value_color->get_value( 2));
        v[2] = blue ->get_value();
        return 0;
    }
 
    return -1;
}
 
template<class T>
mi::Sint32 get_value( const mi::neuraylib::IValue* value, mi::Size index, T& v)
{
    mi::base::Handle<const mi::neuraylib::IValue_compound> value_compound(
        value->get_interface<mi::neuraylib::IValue_compound>());
    if( value_compound) {
        mi::base::Handle<const mi::neuraylib::IValue> component( value_compound->get_value( index));
        if( !component)
            return -3;
        return get_value( component.get(), v);
    }
 
    return -1;
}
 
template<class T>
mi::Sint32 get_value( const mi::neuraylib::IValue* value, const char* name, T& v)
{
    mi::base::Handle<const mi::neuraylib::IValue_struct> value_struct(
        value->get_interface<mi::neuraylib::IValue_struct>());
    if( value_struct) {
        mi::base::Handle<const mi::neuraylib::IValue> field( value_struct->get_field( name));
        if( !field)
            return -3;
        return get_value( field.get(), v);
    }
 
    return -1;
}
 
template<class T>
mi::Sint32 get_value( const mi::neuraylib::IValue* value, T* v, mi::Size n)
{
    mi::base::Handle<const mi::neuraylib::IValue_array> value_array(
        value->get_interface<mi::neuraylib::IValue_array>());
    if( value_array) {
        if( value_array->get_size() != n)
            return -3;
        for( mi::Size i = 0; i < n; ++i) {
            mi::base::Handle<const  mi::neuraylib::IValue> element( value_array->get_value( i));
            mi::Sint32 result = get_value( element.get(), v[i]);
            if( result != 0)
                return result;
        }
        return 0;
    }
 
    return -1;
}
 
 // end group mi_neuray_mdl_types
 
}  // namespace neuraylib
 
}  // namespace mi
 
#endif // MI_NEURAYLIB_IVALUE_H