mdl_argument_editor.h File Reference

‎//*****************************************************************************
// Copyright 1986, 2016 NVIDIA Corporation. All rights reserved.
//*****************************************************************************
//*****************************************************************************

#ifndef MI_NEURAYLIB_MDL_ARGUMENT_EDITOR_H
#define MI_NEURAYLIB_MDL_ARGUMENT_EDITOR_H

#include <mi/base/handle.h>
#include <mi/neuraylib/assert.h>
#include <mi/neuraylib/iarray.h>
#include <mi/neuraylib/iattachable.h>
#include <mi/neuraylib/idynamic_array.h>
#include <mi/neuraylib/ifactory.h>
#include <mi/neuraylib/imdl_function_call.h>
#include <mi/neuraylib/imdl_material_instance.h>
#include <mi/neuraylib/itransaction.h>
#include <mi/neuraylib/set_get.h>
#include <mi/neuraylib/version.h>

#include <string>

namespace mi {

namespace neuraylib {




















class Mdl_argument_editor
{
public:



    Mdl_argument_editor(
        ITransaction* transaction, const char* name, IFactory* factory);

    bool is_valid() const;
    
    Element_type 
               get_type() const;

    const char* get_name() const;

    const char* get_definition() const;

    Uint32 
               get_parameter_count() const;

    const char* get_parameter_name( Uint32 index) const;

    Sint32 
               get_parameter_index( const char* name) const;

    const char* get_parameter_type( Uint32 index) const;

    const char* get_parameter_type( const char* name) const;

    bool is_parameter_type_uniform( Uint32 index) const;

    bool is_parameter_type_uniform( const char* name) const;

    const char* get_argument_type( Uint32 index) const;

    const char* get_argument_type( const char* name) const;

    const char* get_return_type() const;

    bool is_return_type_varying() const;




    template <class T>
    Sint32 
               get_value( Uint32 argument_index, T& value) const;

    template <class T>
    Sint32 
               get_value( const char* argument_name, T& value) const;

    template <class T>
    Sint32 
               get_value( Uint32 argument_index, Size array_index, T& value) const;

    template <class T>
    Sint32 
               get_value( const char* argument_name, Size array_index, T& value) const;

    template <class T>
    Sint32 
               set_value( Uint32 argument_index, const T& value);

    template <class T>
    Sint32 
               set_value( const char* argument_name, const T& value);

    template <class T>
    Sint32 
               set_value( Uint32 argument_index, Size array_index, const T& value);

    template <class T>
    Sint32 
               set_value( const char* argument_name, Size array_index, const T& value);




    bool has_attachment( Uint32 argument_index) const;

    bool has_attachment( const char* argument_name) const;

    bool has_attachment( Uint32 argument_index, Size array_index) const;

    bool has_attachment( const char* argument_name, Size array_index) const;
    
    const char* get_attachment( Uint32 argument_index) const;

    const char* get_attachment( const char* argument_name) const;

    const char* get_attachment( Uint32 argument_index, Size array_index) const;

    const char* get_attachment( const char* argument_name, Size array_index) const;

    Sint32 
               set_attachment( Uint32 argument_index, const char* attachment_name);

    Sint32 
               set_attachment( const char* argument_name, const char* attachment_name);

    Sint32 
               set_attachment(
        Uint32 argument_index, Size array_index, const char* attachment_name);

    Sint32 
               set_attachment(
        const char* argument_name, Size array_index, const char* attachment_name);

    Sint32 
               remove_attachment( Uint32 argument_index);

    Sint32 
               remove_attachment( const char* argument_name);

    Sint32 
               remove_attachment( Uint32 argument_index, Size array_index);

    Sint32 
               remove_attachment( const char* argument_name, Size array_index);




    Sint32 
               get_array_length( Uint32 argument_index, Size& size) const;

    Sint32 
               get_array_length( const char* argument_name, Size& size) const;

    Sint32 
               set_array_length( Uint32 argument_index, Size size);

    Sint32 
               set_array_length( const char* argument_name, Size size);


private:
    void promote_to_edit_if_needed();

    base::Handle< neuraylib::ITransaction> m_transaction;
    base::Handle< neuraylib::IFactory> m_factory;
    base::Handle< const IScene_element> m_access;
    base::Handle< const IScene_element> m_old_access;
    base::Handle< IScene_element> m_edit;
    Element_type m_type;
    MISTD::string m_name;
};
 // end group mi_neuray_materials

inline Mdl_argument_editor::Mdl_argument_editor(
    ITransaction* transaction, const char* name, IFactory* factory)
{
    mi_neuray_assert( transaction);
    mi_neuray_assert( name);

    m_transaction = make_handle_dup( transaction);
    m_name = name;
    m_factory = make_handle_dup( factory);
    m_access = transaction->access<IScene_element>( name);
    m_type = m_access.is_valid_interface()
        ? m_access->get_element_type() : static_cast<Element_type>( 0);
}

inline bool Mdl_argument_editor::is_valid() const
{
    return m_access.is_valid_interface()
        && (m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE
        ||  m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL);
}

inline Element_type 
               Mdl_argument_editor::get_type() const
{
    return m_type;
}

inline const char* Mdl_argument_editor::get_name() const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        return mi->get_name();

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        return fc->get_name();

    } else
        return 0;
}

inline const char* Mdl_argument_editor::get_definition() const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        return mi->get_material_definition();

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        return fc->get_function_definition();

    } else
        return 0;
}

inline Uint32 
               Mdl_argument_editor::get_parameter_count() const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        return mi->get_parameter_count();

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        return fc->get_parameter_count();

    } else
        return 0;
}

inline const char* Mdl_argument_editor::get_parameter_name( Uint32 index) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        return mi->get_parameter_name( index);

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        return fc->get_parameter_name( index);

    } else
        return 0;
}

inline Sint32 
               Mdl_argument_editor::get_parameter_index( const char* name) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        return mi->get_parameter_index( name);

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        return fc->get_parameter_index( name);

    } else
        return 0;
}

inline const char* Mdl_argument_editor::get_parameter_type( Uint32 index) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        return mi->get_parameter_type( index);

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        return fc->get_parameter_type( index);

    } else
        return 0;
}

inline const char* Mdl_argument_editor::get_parameter_type( const char* name) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        return mi->get_parameter_type( name);

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        return fc->get_parameter_type( name);

    } else
        return 0;
}

inline const char* Mdl_argument_editor::get_argument_type( Uint32 index) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        return mi->get_argument_type( index);

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        return fc->get_argument_type( index);

    } else
        return 0;
}

inline const char* Mdl_argument_editor::get_argument_type( const char* name) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        return mi->get_argument_type( name);

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        return fc->get_argument_type( name);

    } else
        return 0;
}

inline bool Mdl_argument_editor::is_parameter_type_uniform( Uint32 index) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        return mi->is_parameter_type_uniform( index);

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        return fc->is_parameter_type_uniform( index);

    } else
        return false;
}

inline bool Mdl_argument_editor::is_parameter_type_uniform( const char* name) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        return mi->is_parameter_type_uniform( name);

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        return fc->is_parameter_type_uniform( name);

    } else
        return false;
}

inline const char* Mdl_argument_editor::get_return_type() const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        return 0;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        return fc->get_return_type();

    } else
        return 0;
}

inline bool Mdl_argument_editor::is_return_type_varying() const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        return 0;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        return fc->is_return_type_varying();

    } else
        return false;
}
























template <class T>
Sint32 
               Mdl_argument_editor::get_value( Uint32 argument_index, T& value) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< const IData> data( argument->get_value());
        Sint32 result = mi::get_value( data.get(), value);
        return result == 0 ? 0 : -3;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< const IData> data( argument->get_value());
        Sint32 result = mi::get_value( data.get(), value);
        return result == 0 ? 0 : -3;

    } else
        return -1;
}

template <class T>
Sint32 
               Mdl_argument_editor::get_value( const char* argument_name, T& value) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< const IData> data( argument->get_value());
        Sint32 result = mi::get_value( data.get(), value);
        return result == 0 ? 0 : -3;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< const IData> data( argument->get_value());
        Sint32 result = mi::get_value( data.get(), value);
        return result == 0 ? 0 : -3;

    } else
        return -1;
}

template <class T>
Sint32 
               Mdl_argument_editor::get_value( Uint32 argument_index, Size array_index, T& value) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return -2;
        base::Handle< const IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return -2;
        base::Handle< const IData> data( element->get_value());
        Sint32 result = mi::get_value( data.get(), value);
        return result == 0 ? 0 : -3;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return -2;
        base::Handle< const IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return -2;
        base::Handle< const IData> data( element->get_value());
        Sint32 result = mi::get_value( data.get(), value);
        return result == 0 ? 0 : -3;

    } else
        return -1;
}

template <class T>
Sint32 
               Mdl_argument_editor::get_value( const char* argument_name, Size array_index, T& value) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return -2;
        base::Handle< const IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return -2;
        base::Handle< const IData> data( element->get_value());
        Sint32 result = mi::get_value( data.get(), value);
        return result == 0 ? 0 : -3;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return -2;
        base::Handle< const IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return -2;
        base::Handle< const IData> data( element->get_value());
        Sint32 result = mi::get_value( data.get(), value);
        return result == 0 ? 0 : -3;

    } else
        return -1;
}

template <class T>
Sint32 
               Mdl_argument_editor::set_value( Uint32 argument_index, const T& value)
{
    promote_to_edit_if_needed();

    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< IMdl_material_instance> mi( m_edit->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IData> data( clone->get_value());
        if( mi::set_value( data.get(), value) != 0)
            return -3;
        return mi->set_argument( argument_index, clone.get());

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< IMdl_function_call> fc( m_edit->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IData> data( clone->get_value());
        if( mi::set_value( data.get(), value) != 0)
            return -3;
        return fc->set_argument( argument_index, clone.get());

    } else
        return -1;
}

template <class T>
Sint32 
               Mdl_argument_editor::set_value( const char* argument_name, const T& value)
{
    promote_to_edit_if_needed();

    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< IMdl_material_instance> mi( m_edit->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IData> data( clone->get_value());
        if( mi::set_value( data.get(), value) != 0)
            return -3;
        return mi->set_argument( argument_name, clone.get());

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< IMdl_function_call> fc( m_edit->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IData> data( clone->get_value());
        if( mi::set_value( data.get(), value) != 0)
            return -3;
        return fc->set_argument( argument_name, clone.get());

    } else
        return -1;
}

template <class T>
Sint32 
               Mdl_argument_editor::set_value( Uint32 argument_index, Size array_index, const T& value)
{
    promote_to_edit_if_needed();

    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< IMdl_material_instance> mi( m_edit->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IArray> array( clone->get_value<IArray>());
        if( !array.is_valid_interface())
            return -2;
        base::Handle< IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return -2;
        base::Handle< IData> data( element->get_value());
        if( mi::set_value( data.get(), value) != 0)
            return -3;
        return mi->set_argument( argument_index, clone.get());

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< IMdl_function_call> fc( m_edit->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IArray> array( clone->get_value<IArray>());
        if( !array.is_valid_interface())
            return -2;
        base::Handle< IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return -2;
        base::Handle< IData> data( element->get_value());
        if( mi::set_value( data.get(), value) != 0)
            return -3;
        return fc->set_argument( argument_index, clone.get());

    } else
        return -1;
}

template <class T>
Sint32 
               Mdl_argument_editor::set_value( const char* argument_name, Size array_index, const T& value)
{
    promote_to_edit_if_needed();

    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< IMdl_material_instance> mi( m_edit->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IArray> array( clone->get_value<IArray>());
        if( !array.is_valid_interface())
            return -2;
        base::Handle< IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return -2;
        base::Handle< IData> data( element->get_value());
        if( mi::set_value( data.get(), value) != 0)
            return -3;
        return mi->set_argument( argument_name, clone.get());

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< IMdl_function_call> fc( m_edit->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IArray> array( clone->get_value<IArray>());
        if( !array.is_valid_interface())
            return -2;
        base::Handle< IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return -2;
        base::Handle< IData> data( element->get_value());
        if( mi::set_value( data.get(), value) != 0)
            return -3;
        return fc->set_argument( argument_name, clone.get());

    } else
        return -1;
}

inline bool Mdl_argument_editor::has_attachment( Uint32 argument_index) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return false;
        return argument->get_reference_name() != 0;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return false;
        return argument->get_reference_name() != 0;

    } else
        return false;
}

inline bool Mdl_argument_editor::has_attachment( const char* argument_name) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return false;
        return argument->get_reference_name() != 0;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return false;
        return argument->get_reference_name() != 0;

    } else
        return false;
}

inline bool Mdl_argument_editor::has_attachment( Uint32 argument_index, Size array_index) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return false;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return false;
        base::Handle< const IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return false;
        return element->get_reference_name() != 0;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return false;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return false;
        base::Handle< const IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return false;
        return element->get_reference_name() != 0;

    } else
        return false;
}

inline bool Mdl_argument_editor::has_attachment( const char* argument_name, Size array_index) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return false;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return false;
        base::Handle< const IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return false;
        return element->get_reference_name() != 0;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return false;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return false;
        base::Handle< const IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return false;
        return element->get_reference_name() != 0;

    } else
        return false;
}

inline const char* Mdl_argument_editor::get_attachment( Uint32 argument_index) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return 0;
        return argument->get_reference_name();

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return 0;
        return argument->get_reference_name();

    } else
        return 0;
}

inline const char* Mdl_argument_editor::get_attachment( const char* argument_name) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return 0;
        return argument->get_reference_name();

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return 0;
        return argument->get_reference_name();

    } else
        return 0;
}

inline const char* Mdl_argument_editor::get_attachment(
    Uint32 argument_index, Size array_index) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return 0;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return 0;
        base::Handle< const IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return 0;
        return element->get_reference_name();

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return 0;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return 0;
        base::Handle< const IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return 0;
        return element->get_reference_name();

    } else
        return 0;
}

inline const char* Mdl_argument_editor::get_attachment(
    const char* argument_name, Size array_index) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return 0;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return 0;
        base::Handle< const IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return 0;
        return element->get_reference_name();

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return 0;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return 0;
        base::Handle< const IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return 0;
        return element->get_reference_name();

    } else
        return 0;
}

inline Sint32 
               Mdl_argument_editor::set_attachment(
    Uint32 argument_index, const char* attachment_name)
{
    promote_to_edit_if_needed();

    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< IMdl_material_instance> mi( m_edit->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        if( clone->set_reference( attachment_name) != 0)
            return -3;
        return mi->set_argument( argument_index, clone.get());

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< IMdl_function_call> fc( m_edit->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        if( clone->set_reference( attachment_name) != 0)
            return -3;
        return fc->set_argument( argument_index, clone.get());

    } else
        return -1;
}

inline Sint32 
               Mdl_argument_editor::set_attachment(
    const char* argument_name, const char* attachment_name)
{
    promote_to_edit_if_needed();

    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< IMdl_material_instance> mi( m_edit->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        if( clone->set_reference( attachment_name) != 0)
            return -3;
        return mi->set_argument( argument_name, clone.get());

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< IMdl_function_call> fc( m_edit->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        if( clone->set_reference( attachment_name) != 0)
            return -3;
        return fc->set_argument( argument_name, clone.get());

    } else
        return -1;
}

inline Sint32  
               Mdl_argument_editor::set_attachment(
    Uint32 argument_index, Size array_index, const char* attachment_index)
{
    promote_to_edit_if_needed();

    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< IMdl_material_instance> mi( m_edit->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IArray> array( clone->get_value<IArray>());
        if( !array.is_valid_interface())
            return -2;
        base::Handle< IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return -2;
        if( element->set_reference( attachment_index) != 0)
            return -3;
        return mi->set_argument( argument_index, clone.get());

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< IMdl_function_call> fc( m_edit->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IArray> array( clone->get_value<IArray>());
        if( !array.is_valid_interface())
            return -2;
        base::Handle< IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return -2;
        if( element->set_reference( attachment_index) != 0)
            return -3;
        return fc->set_argument( argument_index, clone.get());

    } else
        return -1;
}

inline Sint32  
               Mdl_argument_editor::set_attachment(
    const char* argument_name, Size array_index, const char* attachment_name)
{
    promote_to_edit_if_needed();

    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< IMdl_material_instance> mi( m_edit->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IArray> array( clone->get_value<IArray>());
        if( !array.is_valid_interface())
            return -2;
        base::Handle< IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return -2;
        if( element->set_reference( attachment_name) != 0)
            return -3;
        return mi->set_argument( argument_name, clone.get());

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< IMdl_function_call> fc( m_edit->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IArray> array( clone->get_value<IArray>());
        if( !array.is_valid_interface())
            return -2;
        base::Handle< IAttachable> element( array->get_element<IAttachable>( array_index));
        if( !element.is_valid_interface())
            return -2;
        if( element->set_reference( attachment_name) != 0)
            return -3;
        return fc->set_argument( argument_name, clone.get());

    } else
        return -1;
}

inline Sint32 
               Mdl_argument_editor::remove_attachment( Uint32 argument_index)
{
    return set_attachment( argument_index, 0);
}

inline Sint32 
               Mdl_argument_editor::remove_attachment( const char* argument_name)
{
    return set_attachment( argument_name, 0);
}

inline Sint32 
               Mdl_argument_editor::remove_attachment( Uint32 argument_index, Size array_index)
{
    return set_attachment( argument_index, array_index, 0);
}

inline Sint32 
               Mdl_argument_editor::remove_attachment( const char* argument_name, Size array_index)
{
    return set_attachment( argument_name, array_index, 0);
}

inline Sint32 
               Mdl_argument_editor::get_array_length( Uint32 argument_index, Size& size) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return -4;
        size = array->get_length();
        return 0;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return -4;
        size = array->get_length();
        return 0;

    } else
        return -1;
}

inline Sint32 
               Mdl_argument_editor::get_array_length( const char* argument_name, Size& size) const
{
    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< const IMdl_material_instance> mi(
            m_access->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return -4;
        size = array->get_length();
        return 0;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< const IMdl_function_call> fc(
            m_access->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< const IArray> array( argument->get_value<IArray>());
        if( !array.is_valid_interface())
            return -4;
        size = array->get_length();
        return 0;

    } else
        return -1;
}

inline Sint32 
               Mdl_argument_editor::set_array_length( Uint32 argument_index, Size size)
{
    promote_to_edit_if_needed();

    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< IMdl_material_instance> mi( m_edit->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IDynamic_array> dynamic_array( clone->get_value<IDynamic_array>());
        if( !dynamic_array.is_valid_interface())
            return -4;
        dynamic_array->set_length( size);
        mi->set_argument( argument_index, clone.get());
        return 0;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< IMdl_function_call> fc( m_edit->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_index));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IDynamic_array> dynamic_array( clone->get_value<IDynamic_array>());
        if( !dynamic_array.is_valid_interface())
            return -4;
        dynamic_array->set_length( size);
        fc->set_argument( argument_index, clone.get());
        return 0;

    } else
        return -1;
}

inline Sint32 
               Mdl_argument_editor::set_array_length( const char* argument_name, Size size)
{
    promote_to_edit_if_needed();

    if( m_type == ELEMENT_TYPE_MDL_MATERIAL_INSTANCE) {

        base::Handle< IMdl_material_instance> mi( m_edit->get_interface<IMdl_material_instance>());
        base::Handle< const IAttachable> argument( mi->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IDynamic_array> dynamic_array( clone->get_value<IDynamic_array>());
        if( !dynamic_array.is_valid_interface())
            return -4;
        dynamic_array->set_length( size);
        mi->set_argument( argument_name, clone.get());
        return 0;

    } else if( m_type == ELEMENT_TYPE_MDL_FUNCTION_CALL) {

        base::Handle< IMdl_function_call> fc( m_edit->get_interface<IMdl_function_call>());
        base::Handle< const IAttachable> argument( fc->get_argument( argument_name));
        if( !argument.is_valid_interface())
            return -2;
        base::Handle< IAttachable> clone( m_factory->clone<IAttachable>( argument.get()));
        base::Handle< IDynamic_array> dynamic_array( clone->get_value<IDynamic_array>());
        if( !dynamic_array.is_valid_interface())
            return -4;
        dynamic_array->set_length( size);
        fc->set_argument( argument_name, clone.get());
        return 0;

    } else
        return -1;
}

inline void Mdl_argument_editor::promote_to_edit_if_needed()
{
    if( m_edit.is_valid_interface())
        return;
    m_edit = m_transaction->edit<IScene_element>( m_name.c_str());
    mi_neuray_assert( m_edit.is_valid_interface());
    m_old_access = m_access;
    m_access = m_edit;
}

} // namespace neuraylib

#ifdef MI_NEURAYLIB_DEPRECATED_NAMESPACE_MI_TRANSITION
using neuraylib::ELEMENT_TYPE_MDL_FUNCTION_CALL;
using neuraylib::ELEMENT_TYPE_MDL_MATERIAL_INSTANCE;
using neuraylib::Element_type;
using neuraylib::IMdl_function_call;
using neuraylib::IMdl_material_instance;
using neuraylib::IScene_element;
using neuraylib::Mdl_argument_editor;
#endif // MI_NEURAYLIB_DEPRECATED_NAMESPACE_MI_TRANSITION

} // namespace mi

#endif // MI_NEURAYLIB_MDL_ARGUMENT_EDITOR_H