iindex.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#ifndef NVIDIA_INDEX_IINDEX_H
#define NVIDIA_INDEX_IINDEX_H
 
#include <mi/dice.h>
 
#include <nv/index/iaffinity_information.h>
#include <nv/index/iapplication_depth_buffer.h>
#include <nv/index/ibalancing_operations.h>
#include <nv/index/icluster_change_callback.h>
#include <nv/index/idistributed_data_locality.h>
#include <nv/index/ierror.h>
#include <nv/index/iindex_canvas.h>
#include <nv/index/iindex_scene_query.h>
#include <nv/index/iperformance_values.h>
#include <nv/index/iprogress_callback.h>
#include <nv/index/iscene_query_results.h>
#include <nv/index/itime_mapping.h>
#include <nv/index/iviewport.h>
#include <nv/index/ievent_tracing.h>
 
//
// Define modules for the API documentation.
// They will be listed in the same order in which they are defined here.
//
 
 
// ----------------------------------------------------------------------------------
 
 
// ----------------------------------------------------------------------------------
 
 
 
 
// ----------------------------------------------------------------------------------
 
 
 
 
// ----------------------------------------------------------------------------------
 
 
 
 
 
 
 
 
// ----------------------------------------------------------------------------------
 
 
// ----------------------------------------------------------------------------------
 
 
 
 
 
// ----------------------------------------------------------------------------------
 
 
 
 
 
 
// ----------------------------------------------------------------------------------
 
 
// ----------------------------------------------------------------------------------
 
 
// ----------------------------------------------------------------------------------
 
 
// ----------------------------------------------------------------------------------
 
 
// ----------------------------------------------------------------------------------
 
 
 
namespace nv
{
 
//
namespace index
{
 
//
class ICluster_configuration :
    public mi::base::Interface_declare<0x84fcac5c,0x25d1,0x4456,0x88,0x22,0xe4,0x92,0xec,0xee,0xea,0x1a>
{
public:
    virtual bool set_service_mode(const char* service_mode) = 0;
 
    virtual mi::Uint32 get_number_of_GPUs() const = 0;
 
    virtual mi::Uint32 get_number_of_hosts() const = 0;
 
    virtual mi::Uint32 get_number_of_rendering_hosts() const = 0;
 
    virtual mi::Uint32 get_number_of_compositing_hosts() const = 0;
 
    virtual mi::Uint32 get_host_index(mi::Uint32 index) const = 0;
 
    virtual mi::Uint32 get_local_host_id() const = 0;
 
    virtual const char* get_host_name(mi::Uint32 host_id) const = 0;
 
    virtual bool set_sub_cluster_id(mi::Uint32 sub_cluster_id) = 0;
 
    virtual bool set_automatic_subclustering(
        mi::Uint32 min_sub_cluster_size,
        mi::Uint32 max_nr_of_sub_clusters) = 0;
 
    virtual void register_callback(ICluster_change_callback* callback) = 0;
};
 
class IIndex_session :
    public mi::base::Interface_declare<0x8ba1e5c7,0xaeb9,0x45ee,0xbb,0xf1,0xd6,0x25,0x91,0x70,0xce,0xaa>
{
public:
    virtual mi::neuraylib::Tag_struct create_session(
        mi::neuraylib::IDice_transaction*   dice_transaction,
        const char*                         session_name = 0) = 0;
 
    virtual mi::neuraylib::Tag_struct get_session(
        mi::neuraylib::IDice_transaction*   dice_transaction,
        const char*                         session_name = 0) = 0;
 
    virtual void set_affinity_information(IAffinity_information* affinity_information) = 0;
 
    virtual void update(
        mi::neuraylib::Tag_struct           session_tag,
        mi::neuraylib::IDice_transaction*   dice_transaction) = 0;
 
    virtual void set_clock(IClock_pulse_generator* clock_pulse_generator) = 0;
 
    virtual IClock_pulse_generator* get_clock() const = 0;
};
 
typedef mi::Uint64  IFrame_identifier; 
 
class IFrame_results :
    public mi::base::Interface_declare<0xdbe8f991, 0xccbf, 0x4445, 0xad, 0x4d, 0x77, 0xf3, 0xd, 0x67, 0xcc, 0xff>
{
public:
    virtual IPerformance_values* get_performance_values() const = 0;
 
    virtual IError_set* get_error_set() const = 0;
 
    virtual IFrame_identifier get_frame_id() const = 0;
};
 
class IFrame_results_list :
    public mi::base::Interface_declare<0x9524bb73,0x4392,0x477b,0x9a,0x0f,0x5d,0xd6,0x10,0x32,0xc3,0x85>
{
public:
    virtual mi::Size size() const = 0;
 
    virtual nv::index::IFrame_results* get(mi::Size index) const = 0;
};
 
class IFrame_info_callbacks :
    public mi::base::Interface_declare<0xa686de09,0x6605,0x46ae,0xa0,0x9a,0xd2,0x8c,0x8b,0xcc,0xf1,0x92>
{
public:
    virtual void set_frame_identifier(const IFrame_identifier& frame_id) = 0;
 
    virtual void report_dynamic_memory_eviction(
        mi::Uint32  host_id,
        mi::Uint32  device_id,
        mi::Size    memory_allocation_size,
        mi::Size    memory_available,
        mi::Size    memory_freed_up) = 0;
 
    virtual void report_device_memory_reset(
        mi::Uint32  host_id,
        mi::Uint32  device_id) = 0;
 
    virtual void report_workload_balancing_operations(
        IBalancing_operations* balancing_ops) = 0;
};
 
class IIndex_canvas_creation_properties :
    public mi::base::Interface_declare<0x788ee4b1,0xa0eb,0x47e5,0x91,0xf0,0x92,0x0a,0x30,0xfa,0xad,0x11>
{
public:
    virtual const mi::math::Vector_struct<mi::Uint32, 2>& get_resolution() const = 0;
};
 
class IIndex_cuda_canvas_creation_properties :
    public mi::base::Interface_declare<0xae97ca4b,0xe8c5,0x4c5b,0xa7,0xe6,0xd6,0x10,0xfd,0xad,0xcf,0xe1, nv::index::IIndex_canvas_creation_properties>
{
public:
    virtual mi::Sint32 get_cuda_device_id() const = 0;
};
 
class Index_cuda_canvas_creation_properties : public mi::base::Interface_implement<nv::index::IIndex_cuda_canvas_creation_properties>
{
public:
    Index_cuda_canvas_creation_properties(
        mi::Sint32                                          cuda_device_id,
        const mi::math::Vector_struct<mi::Uint32, 2>&       resolution)
      : m_cuda_device_id(cuda_device_id),
        m_resolution(resolution) {}
 
    virtual mi::Sint32                                    get_cuda_device_id()  const { return m_cuda_device_id; }
    virtual const mi::math::Vector_struct<mi::Uint32, 2>& get_resolution()      const { return m_resolution;     }
 
private:
    mi::Sint32                              m_cuda_device_id;
    mi::math::Vector_struct<mi::Uint32, 2>  m_resolution;
};
 
class IIndex_rendering :
    public mi::base::Interface_declare<0x435617a4,0x589b,0x47d9,0x99,0x17,0x05,0x82,0x7d,0x1d,0xfc,0x3e>
{
public:
    enum Index_builtin_canvas_type
    {
        IDX_CANVAS_CUDA_MEMORY = 0u, 
        IDX_CANVAS_MAIN_MEMORY = 1u  
    };
 
    virtual IIndex_canvas* create_canvas(
        IIndex_canvas_creation_properties*              properties) const = 0;
 
    virtual IFrame_results* render(
        mi::neuraylib::Tag_struct                session_tag,
        IIndex_canvas*                           canvas,
        mi::neuraylib::IDice_transaction*        dice_transaction,
        IProgress_callback*                      progress = 0,
        IFrame_info_callbacks*                   frame_info = 0,
        bool                                     composite_immediately = true,
        IApplication_depth_buffer*               application_depth_buffer = 0) = 0;
 
    virtual IFrame_results_list* render(
        mi::neuraylib::Tag_struct                session_tag,
        IIndex_canvas*                           canvas,
        IViewport_list*                          viewport_list) = 0;
 
    virtual IFrame_results_list* render(
        mi::neuraylib::Tag_struct                session_tag,
        ICanvas_viewport_list*                   canvas_viewport_list) = 0;
 
    virtual bool cancel_rendering(const IFrame_identifier& frame_id) = 0;
};
 
 
class IIndex :
    public mi::base::Interface_declare<0x3beb46c0,0xb77d,0x4c90,0xbc,0xc3,0x1d,0xb1,0xa5,0xd5,0xb8,0xd5>
{
public:
    virtual mi::Sint32 authenticate(
        const char* vendor_key,
        mi::Sint32  vendor_key_length,
        const char* secret_key,
        mi::Sint32  secret_key_length,
        const char* flexnet_license_path = 0,
        mi::Sint32  flexnet_license_path_length = 0) = 0;
 
    //
    virtual mi::Uint32 start(
        bool is_dice_start_block = true) = 0;
 
    virtual mi::Sint32 shutdown() = 0;
 
    virtual mi::base::IInterface* get_api_component(const mi::base::Uuid& interface_id) const = 0;
 
    template<class T>
    T* get_api_component() const
    {
        mi::base::IInterface* ptr_iinterface = get_api_component(typename T::IID());
        if (!ptr_iinterface)
        {
            return 0;
        }
        T* ptr_T = static_cast<T*>(ptr_iinterface->get_interface(typename T::IID()));
        ptr_iinterface->release();
        return ptr_T;
    }
 
    virtual IIndex_rendering* create_rendering_interface() const = 0;
 
    virtual bool register_serializable_class(
        mi::base::Uuid                      class_id,
        mi::neuraylib::IUser_class_factory* factory) const = 0;
 
    template <class T>
    bool register_serializable_class() const
    {
        mi::base::Handle<mi::neuraylib::IUser_class_factory> factory(
                new mi::neuraylib::User_class_factory<T>());
        return register_serializable_class(typename T::IID(), factory.get());
    }
 
    virtual const char* get_product_name() const = 0;
 
    virtual const char* get_version() const = 0;
 
    virtual const char* get_revision() const = 0;
 
    virtual const char* get_nvidia_driver_version() const = 0;
 
    virtual mi::Sint32 get_cuda_runtime_version() const = 0;
 
    virtual const char* get_dice_version() const = 0;
 
    virtual mi::base::ILogger* get_built_in_logger() const = 0;
 
    virtual mi::base::ILogger* get_forwarding_logger() const = 0;
 
    virtual mi::neuraylib::INeuray* get_dice_interface() = 0;
};
 
class IIndex_loader_configuration :
    public mi::base::Interface_declare<0x48c60a29,0x6c27,0x4d2c,0x86,0x90,0xfa,0x47,0x17,0xc2,0xa7,0xd8>
{
public:
    virtual void clear() = 0;
 
    virtual void add_library_search_path(const char* directory) = 0;
 
    virtual void add_library_search_origin(const char* path = 0) = 0;
 
    virtual void add_library_search_default() = 0;
};
 
} // namespace index
 
} // namespace nv
 
extern "C"
{

nv::index::IIndex* nv_index_factory();
 

mi::base::IInterface* nv_factory(const mi::base::Uuid& iid, void* arg);
 
} // extern "C"
 
namespace nv {
namespace index {
 
template <class T>
T* nv_factory(void* symbol, void* arg = 0)
{
    if (!symbol)
    {
        return 0;
    }
 
    typedef mi::base::IInterface* IIndex_factory(const mi::base::Uuid& iid, void* arg);
    IIndex_factory* factory = reinterpret_cast<IIndex_factory*>(symbol);
    mi::base::Handle<mi::base::IInterface> iinterface(factory(typename T::IID(), arg));
    if (iinterface)
    {
        return iinterface->get_interface<T>();
    }
    else
    {
        return 0;
    }
}
 
} // namespace index
} // namespace nv
 
#endif // NVIDIA_INDEX_IINDEX_H