iconfig_settings.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#ifndef NVIDIA_INDEX_ICONFIG_SETTINGS_H
#define NVIDIA_INDEX_ICONFIG_SETTINGS_H
 
#include <mi/dice.h>
#include <mi/base/interface_declare.h>
 
#include <nv/index/idepth_test.h>
 
namespace nv
{
namespace index
{
 
class IConfig_settings :
    public mi::base::Interface_declare<0xf7d37400,0xdf43,0x49f2,0x8e,0x12,0x67,0xe3,0x62,0x90,0xad,0xee,
                                       mi::neuraylib::IElement>
{
public:
    enum Rendering_mode
    {
        CPU_RENDERING        = 0,
        GPU_RENDERING        = 1,
        GPU_OR_CPU_RENDERING = 2
    };
 
    enum Compositing_mode
    {
        COMPOSITING_ALL         = 0,
        COMPOSITING_LOCAL_ONLY  = 1,
        COMPOSITING_REMOTE_ONLY = 2,
        NO_COMPOSITING          = 3
    };
 
    enum Data_import_mode
    {
        DATA_IMPORT_DELAYED    = 0,
        DATA_IMPORT_IMMEDIATE  = 1
    };
 
    enum Heightfield_normal_calculation_mode
    {
        FACE_NORMAL_AVERAGE                = 0,
        AREA_WEIGHTED_FACE_NORMAL_AVERAGE  = 1,
    };
 
    struct Data_transfer_config
    {
        Data_transfer_config()
          : span_compression_level(1),
            tile_compression_level(1),
            span_image_encoding(true),
            tile_image_encoding(true),
            span_alpha_channel(false),
            span_compression_mode(0),
            tile_compression_mode(0),
            span_compression_threads(0),
            tile_compression_threads(0),
            z_buffer_compression_level(1),
            z_buffer_compression_mode(0),
            z_buffer_compression_threads(0)
        {}
 
        mi::Uint8 span_compression_level;
 
        mi::Uint8 tile_compression_level;
 
        bool span_image_encoding;
 
        bool tile_image_encoding;
 
        bool span_alpha_channel;
 
        mi::Uint32 span_compression_mode;
 
        mi::Uint32 tile_compression_mode;
 
        mi::Uint8 span_compression_threads;
 
        mi::Uint8 tile_compression_threads;
 
        mi::Uint8 z_buffer_compression_level;
 
        mi::Uint32 z_buffer_compression_mode;
 
        mi::Uint8 z_buffer_compression_threads;
    };
 
    struct Sparse_volume_config
    {
        mi::math::Vector_struct<mi::Uint32, 3>      brick_dimensions;
 
        mi::Uint32                                  brick_shared_border_size;
    };
 
    struct Corner_point_grid_config
    {
        mi::math::Vector_struct<mi::Uint32, 2>      tile_dimensions;
    };
 
    struct Height_field_lod_config
    {
        mi::math::Vector_struct<mi::Uint32, 2>      tile_dimensions;
 
        mi::Uint32                                  tile_shared_border_size;
    };
 
 
    struct Subdivision_config
    {
        enum Subdivision_mode {
            SUBDIVIDE_USING_GRID = 0,
 
            SUBDIVIDE_USING_KD_TREE = 1
        };
 
        Subdivision_mode                            subdivision_mode;
 
        mi::Uint32                                  subdivision_part_count;
 
        bool                                        suppress_x_axis_subdivision;
        bool                                        suppress_y_axis_subdivision;
        bool                                        suppress_z_axis_subdivision;
 
        bool                                        save_subdivision;
    };
 
 
 
    virtual bool set_sparse_volume_configuration(
        const Sparse_volume_config&     svol_config) = 0;
 
    virtual const Sparse_volume_config& get_sparse_volume_configuration() const = 0;
 
    virtual bool set_corner_point_grid_configuration(
        const Corner_point_grid_config& cpg_config) = 0;
 
    virtual const Corner_point_grid_config& get_corner_point_grid_configuration() const = 0;
 
    virtual bool set_height_field_lod_configuration(
        const Height_field_lod_config&  hf_lod_config) = 0;
 
    virtual const Height_field_lod_config& get_height_field_lod_configuration() const = 0;
 
    virtual bool set_subdivision_configuration(
        const Subdivision_config& subdiv_config) = 0;
 
    virtual const Subdivision_config& get_subdivision_configuration() const = 0;
 
    virtual const Subdivision_config& get_default_subdivision_configuration() const = 0;
 
    virtual bool set_subcube_configuration(
        const mi::math::Vector_struct<mi::Uint32, 3>&  initial_subcube_size,
        mi::Uint32                                     subcube_border_size,
        bool                                           support_continuous_volume_translation,
        bool                                           support_volume_rotation,
        const mi::math::Vector_struct<mi::Float32, 3>& minimal_volume_scaling) = 0;
 
    virtual void get_subcube_size(mi::math::Vector_struct<mi::Uint32, 3>& subcube_size) const = 0;
 
    virtual bool get_continuous_volume_translation_supported() const = 0;
 
    virtual bool get_volume_rotation_supported() const = 0;
 
    virtual void get_minimal_volume_scaling(mi::math::Vector_struct<mi::Float32, 3>& minimal_scaling) const = 0;
 
    virtual mi::Uint32 get_subcube_border_size() const = 0;
 
    virtual void set_cuda_debug_checks_enabled(bool debug_checks) = 0;
 
    virtual bool is_cuda_debug_checks_enabled() const = 0;
 
    virtual void set_dynamic_memory_management_enabled(bool dyn_mm) = 0;
 
    virtual bool is_dynamic_memory_management_enabled() const = 0;
 
    virtual void set_data_import_mode(Data_import_mode import_mode) = 0;
 
    virtual Data_import_mode get_data_import_mode() const = 0;
 
 
    virtual Rendering_mode get_rendering_mode() const = 0;
    virtual void set_rendering_mode(Rendering_mode mode) = 0;
 
    virtual mi::Uint32 get_cpu_thread_count() const = 0;
    virtual void set_cpu_thread_count(mi::Uint32 count) = 0;
 
    virtual Compositing_mode get_compositing_mode() const = 0;
 
    virtual void set_compositing_mode(Compositing_mode mode) = 0;
 
    virtual bool is_parallel_rendering_and_compositing() const = 0;
 
    virtual void set_parallel_rendering_and_compositing(bool is_parallel) = 0;
 
    virtual bool set_size_of_rendering_results_in_queue(mi::Uint32 size) = 0;
 
    virtual mi::Uint32 get_size_of_rendering_results_in_queue() const = 0;
 
    virtual bool is_monitor_performance_values() const = 0;
 
    virtual void set_monitor_performance_values(bool monitor) = 0;
 
    virtual Data_transfer_config get_data_transfer_config() const = 0;
 
    virtual void set_data_transfer_config(const Data_transfer_config& config) = 0;
 
 
    virtual bool is_automatic_span_control() const = 0;
 
    virtual void set_automatic_span_control(bool automatic_span_control) = 0;
 
    virtual mi::Uint32 get_max_spans_per_machine() const = 0;
 
    virtual bool set_max_spans_per_machine(mi::Uint32 max_spans_per_machine) = 0;
 
    virtual mi::Uint32 get_nb_spans() const = 0;
 
    virtual bool set_nb_spans(mi::Uint32 nb_spans) = 0;
 
    virtual void set_pick_origin(bool pixel_center) = 0;
 
    virtual bool get_pick_origin() const = 0;
 
 
    virtual mi::Uint32 get_rendering_samples() const = 0;
 
    virtual void set_rendering_samples(mi::Uint32 samples) = 0;
 
    virtual bool is_boost_geometry_colormap_opacity() const = 0;
 
    virtual void set_boost_geometry_colormap_opacity(bool boost_opacity) = 0;
 
    virtual void set_depth_test(nv::index::IDepth_test::Depth_test_mode test_mode) = 0;
 
    virtual nv::index::IDepth_test::Depth_test_mode get_depth_test() const = 0;
 
 
 
    virtual bool is_forced_data_upload() const = 0;
 
    virtual void set_force_data_upload(bool upload) = 0;
 
    virtual bool is_workload_balancing_enabled() const = 0;
 
    virtual void set_workload_balancing(bool enable) = 0;
 
 
    virtual mi::Uint32 get_nb_timesteps() const = 0;
 
    virtual void set_nb_timesteps(mi::Uint32 nb_timesteps) = 0;
    
    virtual mi::Uint32 get_current_timestep() const = 0;
 
    virtual void set_current_timestep(mi::Uint32 current_timestep) = 0;
 
    virtual void enable_frame_buffer_blending(bool enable_flag) = 0;
 
    virtual bool is_frame_buffer_blending_enabled() const = 0;
 
    virtual void set_heightfield_normal_calculation_mode(Heightfield_normal_calculation_mode calculation_mode) = 0;
 
    virtual Heightfield_normal_calculation_mode get_heightfield_normal_calculation_mode() const = 0;
 
    virtual void flush_custom_cuda_programs() = 0;
 
    virtual void set_volume_picking_threshold(mi::Float32 threshold) = 0;
 
    virtual mi::Float32 get_volume_picking_threshold() const = 0;
 
};
 
}} // namespace index / nv
 
#endif // NVIDIA_INDEX_ICONFIG_SETTINGS_H