mdl_generated_dag.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2025 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
#ifndef MDL_GENERATED_DAG_H
#define MDL_GENERATED_DAG_H 1
 
#include <cstring>
#include <mi/mdl/mdl_iowned.h>
#include <mi/mdl/mdl_generated_code.h>
#include <mi/mdl/mdl_values.h>
 
namespace mi {
namespace mdl {
 
class DAG_unit;
class ICall_name_resolver;
class IResource_modifier;
class IValue;
class IValue_float;
class IValue_resource;
class IValue_factory;
class Messages;
class IType_factory;
 
class DAG_hash {
public:
    DAG_hash() {
        memset(hash, 0, sizeof(hash));
    }
 
    explicit DAG_hash(unsigned char const (&arr)[16])
    {
        memcpy(hash, arr, sizeof(hash));
    }
 
    bool operator==(DAG_hash const &other) const {
        return memcmp(hash, other.hash, sizeof(hash)) == 0;
    }
 
    bool operator!=(DAG_hash const &other) const {
        return memcmp(hash, other.hash, sizeof(hash)) != 0;
    }
 
    bool operator<(DAG_hash const &other) const {
        return memcmp(hash, other.hash, sizeof(hash)) < 0;
    }
 
    bool operator<=(DAG_hash const &other) const {
        return memcmp(hash, other.hash, sizeof(hash)) <= 0;
    }
 
    bool operator>(DAG_hash const &other) const {
        return memcmp(hash, other.hash, sizeof(hash)) > 0;
    }
 
    bool operator>=(DAG_hash const &other) const {
        return memcmp(hash, other.hash, sizeof(hash)) >= 0;
    }
 
    unsigned char operator[](size_t n) const {
        if (n < 16)
            return hash[n];
        return 0;
    }
 
    unsigned char *data() {
        return hash;
    }
 
    unsigned char const *data() const {
        return hash;
    }
 
    static size_t size() { return 16; }
 
private:
    unsigned char hash[16];
};
 
class DAG_DbgInfo {
public:
    DAG_DbgInfo()
    : line(0)
    , file_column(0)
    {
    }
 
    DAG_DbgInfo(
        unsigned file_id,
        unsigned line,
        unsigned column)
    : line(line)
    , file_column((file_id << 20u) | (column & 0x000FFFFFu))
    {
    }
 
    operator bool() const { return file_column != 0u && line != 0u; }
 
    bool operator==(DAG_DbgInfo other) {
        return file_column == other.file_column && line == other.line;
    }
 
    bool operator!=(DAG_DbgInfo other) { return !operator==(other); }
 
    unsigned get_file_id() const { return (file_column >> 20u) & 0x00000FFFu; }
 
    unsigned get_line() const { return line; }
 
    unsigned get_column() const { return (file_column & 0x000FFFFFu); }
 
    static const DAG_DbgInfo generated;
 
    static const DAG_DbgInfo builtin;
 
private:
    unsigned line;
    unsigned file_column;
};
 
class DAG_node : public Interface_owned {
public:
    enum Kind {
        EK_CONSTANT,  
        EK_TEMPORARY, 
        EK_CALL,      
        EK_PARAMETER  
    };
 
    virtual Kind get_kind() const = 0;
 
    virtual IType const *get_type() const = 0;
 
    virtual size_t get_id() const = 0;
 
    virtual DAG_DbgInfo get_dbg_info() const = 0;
};
 
class DAG_constant : public DAG_node {
public:
    static Kind const s_kind = EK_CONSTANT;
 
    virtual IValue const *get_value() const = 0;
};
 
class DAG_temporary : public DAG_node {
public:
    static Kind const s_kind = EK_TEMPORARY;
 
    virtual int get_index() const = 0;
 
    virtual DAG_node const *get_expr() const = 0;
};
 
class DAG_call : public DAG_node {
public:
    struct Call_argument {
        Call_argument() {
            arg = NULL;
            param_name = NULL;
        }
 
        Call_argument(
            DAG_node const *arg,
            char const     *param_name)
        : arg(arg)
        , param_name(param_name)
        {}
 
        DAG_node const *arg;        
        char const     *param_name; 
    };
 
public:
    static Kind const s_kind = EK_CALL;
 
    virtual char const *get_name() const = 0;
 
    virtual int get_argument_count() const = 0;
 
    virtual char const *get_parameter_name(int index) const = 0;
 
    virtual DAG_node const *get_argument(int index) const = 0;
 
    virtual DAG_node const *get_argument(char const *name) const = 0;
 
    virtual IDefinition::Semantics get_semantic() const = 0;
 
    virtual void set_argument(
        int            index,
        DAG_node const *arg) = 0;
 
    virtual size_t get_name_hash() const = 0;
};
 
class DAG_parameter : public DAG_node {
public:
    static Kind const s_kind = EK_PARAMETER;
 
    virtual int get_index() const = 0;
};
 
class IResource_tagger : public Interface_owned {
public:
    virtual int get_resource_tag(
        IValue_resource const *res) const = 0;
};
 
class IDag_builder : public
    mi::base::Interface_declare
    <0x01dbe5fb,0xa13d,0x42eb,0xbe,0x3e,0x0a,0x1d,0x2c,0x53,0x11,0xdf,
    mi::base::IInterface>
{
public:
    virtual IType_factory *get_type_factory() = 0;
 
    virtual IValue_factory *get_value_factory() = 0;
 
    virtual DAG_constant const *create_constant(
        IValue const *value) = 0;
 
    virtual DAG_node const *create_call(
        char const                    *signature,
        IDefinition::Semantics        sema,
        DAG_call::Call_argument const call_args[],
        int                           num_call_args,
        IType const                   *ret_type,
        DAG_DbgInfo                   dbg_info) = 0;
 
    virtual DAG_parameter const *create_parameter(
        IType const *type,
        int         index,
        DAG_DbgInfo dbg_info) = 0;
 
    virtual bool enable_cse(bool flag) = 0;
 
    virtual bool enable_opt(bool flag) = 0;
 
    virtual bool enable_unsafe_math_opt(bool flag) = 0;
};
 
class ICall_evaluator {
public:
    virtual bool is_evaluate_intrinsic_function_enabled(
        IDefinition::Semantics sema) const = 0;
 
    virtual IValue const *evaluate_intrinsic_function(
        IValue_factory         *value_factory,
        IDefinition::Semantics sema,
        IValue const * const   arguments[],
        size_t                 n_arguments) const = 0;
};
 
// forward
class IMaterial_instance;
 
enum Dag_error_code {
    EC_NONE,                   
    EC_INVALID_INDEX,          
    EC_MATERIAL_HAS_ERROR,     
    EC_TOO_FEW_ARGUMENTS,      
    EC_TOO_MANY_ARGUMENTS,     
    EC_INSTANTIATION_ERROR,    
    EC_ARGUMENT_TYPE_MISMATCH, 
    EC_WRONG_TRANSMISSION_ON_THIN_WALLED,  
};
 
class IGenerated_code_dag : public
    mi::base::Interface_declare<0x9dbfd12e,0x8207,0x4a47,0x8c,0x1f,0x5f,0x9a,0xc4,0x9b,0x00,0xf6,
    IGenerated_code>
{
public:
    enum Function_property {
        FP_ALLOW_INLINE      = 0, 
        FP_IS_EXPORTED       = 1, 
        FP_USES_TEXTURES     = 2, 
        FP_CAN_THROW_BOUNDS  = 3, 
        FP_CAN_THROW_DIVZERO = 4, 
        FP_IS_UNIFORM        = 5, 
        FP_IS_NATIVE         = 6, 
        FP_IS_DECLARATIVE    = 7, 
    };
 
    enum Annotation_property {
        AP_IS_EXPORTED       = 1, 
    };
 
    class DAG_node_factory
    {
    public:
        virtual DAG_constant const *create_constant(
            IValue const *value) = 0;
 
        virtual DAG_temporary const *create_temporary(
            DAG_node const *node,
            int            index)  = 0;
 
        virtual DAG_node const *create_call(
            char const                    *signature,
            IDefinition::Semantics        sema,
            DAG_call::Call_argument const call_args[],
            size_t                        num_call_args,
            IType const                   *ret_type,
            DAG_DbgInfo                   dbg_info) = 0;
 
        virtual DAG_parameter const *create_parameter(
            IType const *type,
            int         index,
            DAG_DbgInfo dbg_info) = 0;
 
        virtual bool enable_cse(bool flag) = 0;
 
        virtual bool enable_opt(bool flag) = 0;
 
        virtual bool enable_unsafe_math_opt(bool flag) = 0;
 
        virtual bool get_unsafe_math_opt() const = 0;
 
        virtual IType_factory *get_type_factory() = 0;
 
        virtual IValue_factory *get_value_factory() = 0;
    };
 
    static char const MESSAGE_CLASS = 'C';
 
    typedef Dag_error_code Error_code;
 
    // -------------------------- methods --------------------------
 
public:
    virtual char const *get_module_name() const = 0;
 
    virtual char const *get_module_file_name() const = 0;
 
    virtual size_t get_import_count() const = 0;
 
    virtual char const *get_import(size_t index) const = 0;
 
    virtual size_t get_function_count() const = 0;
 
    virtual IType const *get_function_return_type(size_t function_index) const = 0;
 
    virtual IDefinition::Semantics get_function_semantics(size_t function_index) const = 0;
 
    virtual char const *get_function_name(size_t function_index) const = 0;
 
    virtual char const *get_simple_function_name(size_t function_index) const = 0;
 
    virtual char const *get_original_function_name(size_t function_index) const = 0;
 
    virtual size_t get_function_parameter_count(size_t function_index) const = 0;
 
    virtual IType const *get_function_parameter_type(
        size_t function_index,
        size_t parameter_index) const = 0;
 
    virtual char const *get_function_parameter_type_name(
        size_t function_index,
        size_t parameter_index) const = 0;
 
    virtual char const *get_function_parameter_name(
        size_t function_index,
        size_t parameter_index) const = 0;
 
    virtual size_t get_function_parameter_index(
        size_t     function_index,
        char const *parameter_name) const = 0;
 
    virtual DAG_node const *get_function_parameter_enable_if_condition(
        size_t function_index,
        size_t parameter_index) const = 0;
 
    virtual size_t get_function_parameter_enable_if_condition_users(
        size_t function_index,
        size_t parameter_index) const = 0;
 
    virtual size_t get_function_parameter_enable_if_condition_user(
        size_t function_index,
        size_t parameter_index,
        size_t user_index) const = 0;
 
    virtual DAG_hash const *get_function_hash(
        size_t function_index) const = 0;
 
    virtual size_t get_material_count() const = 0;
 
    virtual IType const *get_material_return_type(size_t material_index) const = 0;
 
    virtual IDefinition::Semantics get_material_semantics(size_t material_index) const = 0;
 
    virtual char const *get_material_name(size_t material_index) const = 0;
 
    virtual char const *get_simple_material_name(size_t material_index) const = 0;
 
    virtual char const *get_original_material_name(size_t material_index) const = 0;
 
    virtual size_t get_material_parameter_count(size_t material_index) const = 0;
 
    virtual IType const *get_material_parameter_type(
        size_t material_index,
        size_t parameter_index) const = 0;
 
    virtual char const *get_material_parameter_type_name(
        size_t material_index,
        size_t parameter_index) const = 0;
 
    virtual char const *get_material_parameter_name(
        size_t material_index,
        size_t parameter_index) const = 0;
 
    virtual size_t get_material_parameter_index(
        size_t     material_index,
        char const *parameter_name) const = 0;
 
    virtual DAG_node const *get_material_parameter_enable_if_condition(
        size_t material_index,
        size_t parameter_index) const = 0;
 
    virtual size_t get_material_parameter_enable_if_condition_users(
        size_t material_index,
        size_t parameter_index) const = 0;
 
    virtual size_t get_material_parameter_enable_if_condition_user(
        size_t material_index,
        size_t parameter_index,
        size_t user_index) const = 0;
 
    virtual DAG_hash const *get_material_hash(
        size_t material_index) const = 0;
 
    virtual DAG_node_factory *get_node_factory() = 0;
 
    virtual size_t get_function_annotation_count(
        size_t function_index) const = 0;
 
    virtual DAG_node const *get_function_annotation(
        size_t function_index,
        size_t annotation_index) const = 0;
 
    virtual size_t get_function_return_annotation_count(
        size_t function_index) const = 0;
 
    virtual DAG_node const *get_function_return_annotation(
        size_t function_index,
        size_t annotation_index) const = 0;
 
    virtual DAG_node const *get_function_parameter_default(
        size_t function_index,
        size_t parameter_index) const = 0;
 
    virtual size_t get_function_parameter_annotation_count(
        size_t function_index,
        size_t parameter_index) const = 0;
 
    virtual DAG_node const *get_function_parameter_annotation(
        size_t function_index,
        size_t parameter_index,
        size_t annotation_index) const = 0;
 
    virtual size_t get_function_temporary_count(
        size_t function_index) const = 0;
 
    virtual DAG_node const *get_function_temporary(
        size_t function_index,
        size_t temporary_index) const = 0;
 
    virtual char const *get_function_temporary_name(
        size_t function_index,
        size_t temporary_index) const = 0;
 
    virtual DAG_node const *get_function_body(
        size_t function_index) const = 0;
 
    virtual DAG_node const *get_function_value(
        size_t function_index) const = 0;
 
    virtual bool get_function_exported(size_t function_index) const = 0;
 
    virtual bool get_function_property(
        size_t            function_index,
        Function_property fp) const = 0;
 
    virtual size_t get_function_references_count(size_t function_index) const = 0;
 
    virtual char const *get_function_reference(
        size_t function_index,
        size_t callee_index) const = 0;
 
    virtual char const *get_cloned_function_name(
        size_t function_index) const = 0;
 
    virtual size_t get_material_annotation_count(
        size_t material_index) const = 0;
 
    virtual DAG_node const *get_material_annotation(
        size_t material_index,
        size_t annotation_index) const = 0;
 
    virtual DAG_node const *get_material_parameter_default(
        size_t material_index,
        size_t parameter_index) const = 0;
 
    virtual size_t get_material_return_annotation_count(
        size_t material_index) const = 0;
 
    virtual DAG_node const *get_material_return_annotation(
        size_t material_index,
        size_t annotation_index) const = 0;
 
    virtual size_t get_material_parameter_annotation_count(
        size_t material_index,
        size_t parameter_index) const = 0;
 
    virtual DAG_node const *get_material_parameter_annotation(
        size_t material_index,
        size_t parameter_index,
        size_t annotation_index) const = 0;
 
    virtual size_t get_material_temporary_count(
        size_t material_index) const = 0;
 
    virtual DAG_node const *get_material_temporary(
        size_t material_index,
        size_t temporary_index) const = 0;
 
    virtual char const *get_material_temporary_name(
        size_t material_index,
        size_t temporary_index) const = 0;
 
    virtual DAG_node const *get_material_value(
        size_t material_index) const = 0;
 
    virtual DAG_node const *get_material_body(
        size_t material_index) const = 0;
 
    virtual bool get_material_exported(size_t material_index) const = 0;
 
    virtual bool get_material_property(
        size_t            material_index,
        Function_property fp) const = 0;
 
    virtual size_t get_material_references_count(size_t material_index) const = 0;
 
    virtual char const *get_material_reference(
        size_t material_index,
        size_t callee_index) const = 0;
 
    virtual char const *get_cloned_material_name(
        size_t material_index) const = 0;
 
    virtual IMaterial_instance *create_material_instance(
        size_t     index,
        Error_code *error_code = NULL) const = 0;
 
    virtual size_t get_struct_category_count() const = 0;
 
    virtual char const *get_struct_category_name(
        size_t index) const = 0;
 
    virtual IStruct_category const *get_struct_category(
        size_t index) const = 0;
 
    virtual size_t get_struct_category_annotation_count(
        size_t index) const = 0;
 
    virtual DAG_node const *get_struct_category_annotation(
        size_t cat_index,
        size_t annotation_index) const = 0;
 
    virtual bool is_struct_category_exported(
        size_t index) const = 0;
 
    virtual size_t get_type_count() const = 0;
 
    virtual char const *get_type_name(
        size_t index) const = 0;
 
    virtual char const *get_original_type_name(
        size_t index) const = 0;
 
    virtual IType const *get_type(
        size_t index) const = 0;
 
    virtual bool is_type_exported(
        size_t index) const = 0;
 
    virtual size_t get_type_annotation_count(
        size_t index) const = 0;
 
    virtual DAG_node const *get_type_annotation(
        size_t type_index,
        size_t annotation_index) const = 0;
 
    virtual size_t get_type_sub_entity_count(
        size_t type_index) const = 0;
 
    virtual char const *get_type_sub_entity_name(
        size_t type_index,
        size_t entity_index) const = 0;
 
    virtual IType const *get_type_sub_entity_type(
        size_t type_index,
        size_t entity_index) const = 0;
 
    virtual size_t get_type_sub_entity_annotation_count(
        size_t type_index,
        size_t entity_index) const = 0;
 
    virtual DAG_node const *get_type_sub_entity_annotation(
        size_t type_index,
        size_t entity_index,
        size_t annotation_index) const = 0;
 
    virtual size_t get_constant_count() const = 0;
 
    virtual char const *get_constant_name(
        size_t index) const = 0;
 
    virtual DAG_constant const *get_constant_value(
        size_t index) const = 0;
 
    virtual size_t get_constant_annotation_count(
        size_t index) const = 0;
 
    virtual DAG_node const *get_constant_annotation(
        size_t constant_index,
        size_t annotation_index) const = 0;
 
    virtual Messages const &access_messages() const = 0;
 
    virtual Messages &access_messages() = 0;
 
    virtual size_t get_memory_size() const = 0;
 
    virtual size_t get_module_annotation_count() const = 0;
 
    virtual DAG_node const *get_module_annotation(
        size_t annotation_index) const = 0;
 
    virtual char const *get_internal_space() const = 0;
 
    virtual size_t get_annotation_count() const = 0;
 
    virtual IDefinition::Semantics get_annotation_semantics(
        size_t annotation_index) const = 0;
 
    virtual char const *get_annotation_name(
        size_t annotation_index) const = 0;
 
    virtual char const *get_simple_annotation_name(
        size_t annotation_index) const = 0;
 
    virtual char const *get_original_annotation_name(
        size_t annotation_index) const = 0;
 
    virtual size_t get_annotation_parameter_count(
        size_t annotation_index) const = 0;
 
    virtual IType const *get_annotation_parameter_type(
        size_t annotation_index,
        size_t parameter_index) const = 0;
 
    virtual char const *get_annotation_parameter_type_name(
        size_t annotation_index,
        size_t parameter_index) const = 0;
 
    virtual char const *get_annotation_parameter_name(
        size_t annotation_index,
        size_t parameter_index) const = 0;
 
    virtual size_t get_annotation_parameter_index(
        size_t     annotation_index,
        char const *parameter_name) const = 0;
 
    virtual DAG_node const *get_annotation_parameter_default(
        size_t annotation_index,
        size_t parameter_index) const = 0;
 
    virtual bool get_annotation_property(
        size_t              annotation_index,
        Annotation_property ap) const = 0;
 
    virtual size_t get_annotation_annotation_count(
        size_t annotation_index) const = 0;
 
    virtual DAG_node const *get_annotation_annotation(
        size_t anno_decl_index,
        size_t annotation_index) const = 0;
 
    virtual int get_resource_tag(
        IValue_resource const *res) const = 0;
 
    virtual void set_resource_tag(
        IValue_resource const *res,
        int                   tag) = 0;
 
    virtual size_t get_resource_tag_map_entries_count() const = 0;
 
    virtual Resource_tag_tuple const *get_resource_tag_map_entry(size_t index) const = 0;
 
    virtual IResource_tagger *get_resource_tagger() const = 0;
};
 
 
class IMaterial_instance : public
    mi::base::Interface_declare
    <0x29c36255,0x7558,0x4865,0xa7,0x7e,0xaa,0x3a,0x50,0x4f,0x70,0xbc,
    IDag_builder>
{
public:
    typedef Dag_error_code Error_code;
 
    enum Flags {
        INSTANCE_COMPILATION = 0 << 0,  
        CLASS_COMPILATION    = 1 << 0,  
        NO_ARGUMENT_INLINE   = 1 << 1,  
        NO_RESOURCE_SHARING  = 1 << 2,  
        NO_TERNARY_ON_DF     = 1 << 3,  
        NO_DEAD_PARAMS       = 1 << 4,  
        NO_STRING_PARAMS     = 1 << 5,  
        NO_BOOL_PARAMS       = 1 << 6,  
        NO_ENUM_PARAMS       = 1 << 7,  
        NO_TRIVIAL_CUTOUT_OPACITY = 1 <<  8,
        NO_TRANSPARENT_LAYERS     = 1 <<  9,
        IGNORE_NOINLINE           = 1 << 10, 
        TARGET_MATERIAL_MODEL     = 1 << 11, 
 
        DEFAULT_CLASS_COMPILATION =  
            CLASS_COMPILATION |
            NO_ARGUMENT_INLINE |
            NO_RESOURCE_SHARING |
            NO_DEAD_PARAMS
    };
 
    enum Slot {
        MS_THIN_WALLED,                     
 
        MS_SURFACE_BSDF_SCATTERING,         
        MS_SURFACE_EMISSION_EDF_EMISSION,   
        MS_SURFACE_EMISSION_INTENSITY,      
        MS_SURFACE_EMISSION_MODE,           
 
        MS_BACKFACE_BSDF_SCATTERING,        
        MS_BACKFACE_EMISSION_EDF_EMISSION,  
        MS_BACKFACE_EMISSION_INTENSITY,     
        MS_BACKFACE_EMISSION_MODE,          
 
        MS_IOR,                             
 
        MS_VOLUME_VDF_SCATTERING,           
        MS_VOLUME_ABSORPTION_COEFFICIENT,   
        MS_VOLUME_SCATTERING_COEFFICIENT,   
        MS_VOLUME_EMISSION_INTENSITY,       
 
        MS_GEOMETRY_DISPLACEMENT,           
        MS_GEOMETRY_CUTOUT_OPACITY,         
        MS_GEOMETRY_NORMAL,                 
 
        MS_HAIR,                            
 
        MS_LAST = MS_HAIR
    };
 
    enum Property {
        IP_DEPENDS_ON_TRANSFORM           = 0x001,   
        IP_DEPENDS_ON_OBJECT_ID           = 0x002,   
        IP_DEPENDS_ON_GLOBAL_DISTRIBUTION = 0x004,   
        IP_USES_TERNARY_OPERATOR          = 0x008,   
        IP_USES_TERNARY_OPERATOR_ON_DF    = 0x010,   
        IP_CLASS_COMPILED                 = 0x020,   
        IP_DISTILLED                      = 0x040,   
        IP_DEPENDS_ON_UNIFORM_SCENE_DATA  = 0x080,   
        IP_TARGET_MATERIAL_MODEL          = 0x100,   
    };
 
    enum Opacity {
        OPACITY_OPAQUE,             
        OPACITY_TRANSPARENT,        
        OPACITY_UNKNOWN             
    };
 
    typedef unsigned Properties;
 
public:
    // ----------------- from IDAG_builder -----------------
 
    virtual IType_factory *get_type_factory() = 0;
 
    virtual IValue_factory *get_value_factory() = 0;
 
    virtual DAG_constant const *create_constant(
        IValue const *value) = 0;
 
    virtual DAG_node const *create_call(
        char const                    *signature,
        IDefinition::Semantics        sema,
        DAG_call::Call_argument const call_args[],
        int                           num_call_args,
        IType const                   *ret_type,
        DAG_DbgInfo                   dbg_info) = 0;
 
    virtual DAG_parameter const *create_parameter(
        IType const *type,
        int         index,
        DAG_DbgInfo dbg_info) = 0;
 
    // ----------------- own methods -----------------
 
    virtual DAG_unit &get_dag_unit() = 0;
 
    virtual DAG_unit const &get_dag_unit() const = 0;
 
    virtual Error_code initialize(
        ICall_name_resolver       *resolver,
        IResource_modifier        *resource_modifier,
        IGenerated_code_dag const *code_dag,
        size_t                    argc,
        DAG_node const            *argv[],
        bool                      use_temporaries,
        unsigned                  flags,
        ICall_evaluator           *evaluator,
        bool                      fold_meters_per_scene_unit,
        float                     mdl_meters_per_scene_unit,
        float                     wavelength_min,
        float                     wavelength_max,
        char const * const        fold_params[],
        size_t                    num_fold_params,
        IType const *target_type) = 0;
 
    virtual DAG_call const *get_constructor() const = 0;
 
    virtual size_t get_temporary_count() const = 0;
 
    virtual DAG_node const *get_temporary_value(size_t index) const = 0;
 
    virtual size_t get_parameter_count() const = 0;
 
    virtual IValue const *get_parameter_default(size_t index) const = 0;
 
    virtual void lookup_sub_expression(
        char const *path,
        DAG_node const *&node_result,
        IValue const *&value_result) const = 0;
 
    virtual DAG_hash get_sub_expression_hash(char const *path) const = 0;
 
    virtual DAG_hash const *get_hash() const = 0;
 
    virtual DAG_hash const *get_slot_hash(Slot slot) const = 0;
 
    virtual char const *get_parameter_name(size_t index) const = 0;
 
    virtual bool depends_on_transform() const = 0;
 
    virtual bool depends_on_object_id() const = 0;
 
    virtual bool depends_on_global_distribution() const = 0;
 
    virtual bool depends_on_uniform_scene_data() const = 0;
 
    virtual size_t get_referenced_scene_data_count() const = 0;
 
    virtual char const *get_referenced_scene_data_name(size_t index) const = 0;
 
    virtual Opacity get_opacity() const = 0;
 
    virtual Opacity get_surface_opacity() const = 0;
 
    virtual IValue_float const *get_cutout_opacity() const = 0;
 
    virtual Messages const &access_messages() const = 0;
 
    virtual size_t get_memory_size() const = 0;
 
    virtual Properties get_properties() const = 0;
 
    virtual char const *get_internal_space() const = 0;
 
    virtual void set_resource_tag(
        IValue_resource const *res,
        int                   tag) = 0;
 
    virtual size_t get_resource_tag_map_entries_count() const = 0;
 
    virtual Resource_tag_tuple const *get_resource_tag_map_entry(size_t index) const = 0;
 
    virtual IResource_tagger *get_resource_tagger() const = 0;
};
 
template<typename T>
bool is(DAG_node const *node)
{
    return node->get_kind() == T::s_kind;
}
 
template<typename T>
T *as(DAG_node *type) {
    return (type->get_kind() == T::s_kind) ? static_cast<T *>(type) : NULL;
}
 
template<typename T>
T const *as(DAG_node const *type) {
    return (type->get_kind() == T::s_kind) ? static_cast<const T *>(type) : NULL;
}
 
} // mdl
} // mi
 
#endif