mdl_generated_dag.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2024 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 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_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;
};
 
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) = 0;
 
    virtual DAG_parameter const *create_parameter(
        IType const *type,
        int         index) = 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;
};
 
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, 
    };
 
    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[],
            int                           num_call_args,
            IType const                   *ret_type) = 0;
 
        virtual DAG_parameter const *create_parameter(IType const *type, int index) = 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 IType_factory *get_type_factory() = 0;
 
        virtual IValue_factory *get_value_factory() = 0;
    };
 
    static char const MESSAGE_CLASS = 'C';
 
    enum 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 IMaterial_instance : public
        mi::base::Interface_declare
        <0x29c36255,0x7558,0x4865,0xa7,0x7e,0xaa,0x3a,0x50,0x4f,0x70,0xbc,
        IDag_builder>
    {
    public:
        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) = 0;
 
        virtual DAG_parameter const *create_parameter(
            IType const *type,
            int         index) = 0;
 
        // ----------------- own methods -----------------
 
        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) = 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 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 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;
    };
 
    // -------------------------- 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 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_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 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 bool get_material_exported(size_t material_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_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;
};
 
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