ray_sampling_lod_heightfield.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
#ifndef EXAMPLES_RAY_SAMPLING_LOD_HEIGHTFIELD_H
#define EXAMPLES_RAY_SAMPLING_LOD_HEIGHTFIELD_H
 
#include "ray_sampling_scenes.h"
#include <nv/index/ilight.h>
#include <nv/index/imaterial.h>
#include <nv/index/itexture_filter_mode.h>
#include <nv/index/iregular_heightfield_rendering_properties.h>
 
// Application layer component
#include <nv/index/app/idata_analysis_and_processing.h>
 
namespace heightfield_common {
 
static const char* program_begin =
";NV_IDX_XAC_VERSION_1_0                                 \n"
"                                                       \n"
"class Surface_sample_program                           \n"
"{                                                      \n"
"    NV_IDX_SURFACE_SAMPLE_PROGRAM                      \n"
"                                                       \n"
"public:                                                \n"
"    int counter;                                       \n"
"                                                       \n"
"    NV_IDX_DEVICE_INLINE_MEMBER void initialize()      \n"
"    {                                                  \n"
"        counter = 0;                                   \n"
"    }                                                  \n"
"                                                       \n"
;
 
static const char* program_end =
"}; \n"
;
 
static const char* color_program =
"    NV_IDX_DEVICE_INLINE_MEMBER int execute(                                   \n"
"        const Sample_info_self&  sample_info,                                  \n"
"              Sample_output&     sample_output)                                \n"
"    {                                                                          \n"
"        const float4& sample_color = sample_info.sample_color;                 \n"
"        sample_output.set_color(sample_color);                                 \n"
"        return NV_IDX_PROG_OK;                                                 \n"
"    }                                                                          \n"
;
 
static const char* inquire_program =
"    // The user program used for picking.                                      \n"
"    NV_IDX_DEVICE_INLINE_MEMBER int inquire(                                   \n"
"            const Sample_info_self&  sample_info,                              \n"
"            Query_results&           query_results)                            \n"
"    {                                                                          \n"
"        // sample_info.ray_t is automatically written                          \n"
"        // color is automatically written                                      \n"
"                                                                               \n"
"        // we could invalidate current sample to skip/ignore it                \n"
"        //query_results.invalidate_sample();                                   \n"
"                                                                               \n"
"        // write some attribute value of current sample                        \n"
"        const float v = //state.self.sample<float>(                            \n"
"            sample_info.sample_position.x;                                     \n"
"        query_results.write_value<float>(0u /*user_value_idx*/, v);            \n"
"                                                                               \n"
"        counter += 1;                                                          \n"
"        if (counter & 1) {                                                     \n"
"            // write every other counter as user value                         \n"
"            query_results.write_value<int>(1u /*user_value_idx*/, counter);    \n"
"        }                                                                      \n"
"                                                                               \n"
"        const float3 normal = sample_info.sample_normal;                       \n"
"        query_results.write_value<float3>(2u /*user_value_idx*/, normal);      \n"
"                                                                               \n"
"        return NV_IDX_PROG_OK;                                                 \n"
"                                                                               \n"
"        // we can stop sampling:                                               \n"
"        //return NV_IDX_PROG_TERMINATE_PROGRAM_INSTANCE;                       \n"
"    }                                                                          \n"
;
 
//----------------------------------------------------------------------
 
 
class Common_heightfield_setup : public ray_sampling::IRay_sampling_scene_setup
{
public:
    void register_classes(nv::index::IIndex* index_interface) const
    {
    }
 
    void add_arguments(std::map<std::string, std::string>& opt_map) const
    {
        opt_map["hfield.texture"] = "height_color";          // texture "none","mandelbrot","height_color"
    }
 
    void usage_info(std::ostream& os, const char* indent, std::map<std::string, std::string>& opt_map) const
    {
        os << indent << "[-hfield.texture mode]\n"
            << indent << "    map a computed texture onto the heightfield. \n"
            << indent << "    Available modes: none, mandelbrot, height_color \n"
            << indent << "    (default: " << opt_map["hfield.texture"] << ")\n";
    }
 
    const char* get_roi_string() const
    {
        return "-1000 -1000 -1000  5000 5000 5000";
    }
 
    void add_light_and_material(
        const std::string&                  texture_type,
        nv::index::IScene*                  scene,
        nv::index::IStatic_scene_group*     static_group_node,
        mi::neuraylib::IDice_transaction*   transaction) const
    {
        // Add a light
        mi::base::Handle<nv::index::IDirectional_headlight> headlight(
            scene->create_attribute<nv::index::IDirectional_headlight>());
        check_success(headlight.is_valid_interface());
        const mi::math::Color color_intensity(1.0f, 1.0f, 1.0f, 1.0f);
        headlight->set_intensity(color_intensity);
        headlight->set_direction(mi::math::Vector<mi::Float32, 3>(1.0f, -1.0f, -1.0f));
        const mi::neuraylib::Tag headlight_tag = transaction->store_for_reference_counting(headlight.get());
        check_success(headlight_tag.is_valid());
        static_group_node->append(headlight_tag, transaction);
 
        // Material for the heightfield
        mi::base::Handle<nv::index::IPhong_gl> phong_1(scene->create_attribute<nv::index::IPhong_gl>());
        check_success(phong_1.is_valid_interface());
 
        if (texture_type != "none") {
            // Use just ambient white with texture
            phong_1->set_ambient(mi::math::Color(1.f));
            phong_1->set_diffuse(mi::math::Color(0.f));
            phong_1->set_specular(mi::math::Color(0.f));
        }
        else {
            // Define a more interesting greenish material
            phong_1->set_ambient(mi::math::Color(0.f, 0.3f, 0.0f, 0.3f));
            phong_1->set_diffuse(mi::math::Color(0.f, 0.8f, 0.2f, 0.3f));
            phong_1->set_specular(mi::math::Color(0.6f));
            phong_1->set_shininess(100.f);
        }
 
        const mi::neuraylib::Tag phong_1_tag
            = transaction->store_for_reference_counting(phong_1.get());
        check_success(phong_1_tag.is_valid());
        static_group_node->append(phong_1_tag, transaction);
    }
 
    void add_texture_mapping(
        nv::index::app::IApplication_layer*     app_layer,        
        const std::string&                      texture_type,
        const mi::math::Bbox<mi::Float32, 3>&   heightfield_bbox,
        nv::index::IScene*                      scene,
        nv::index::IStatic_scene_group*         static_group_node,
        mi::neuraylib::IDice_transaction*       transaction) const
    {
        // Mandelbrot texture
        if (texture_type == "mandelbrot")
        {
            mi::base::Handle<nv::index::ITexture_filter_mode> tex_filter(
                scene->create_attribute<nv::index::ITexture_filter_mode_nearest_neighbor>());
            check_success(tex_filter.is_valid_interface());
            mi::neuraylib::Tag tex_filter_tag = transaction->store_for_reference_counting(tex_filter.get());
            check_success(tex_filter_tag.is_valid());
            static_group_node->append(tex_filter_tag, transaction);
 
 
            mi::base::Handle<nv::index::app::data_analysis_and_processing::IData_analysis_and_processing> processing(
                app_layer->get_api_component<nv::index::app::data_analysis_and_processing::IData_analysis_and_processing>());    
            check_success(processing.is_valid_interface());
            // Create a mandelbrot technique and add it to the scene. For more details on how to implement the checkerboard, please review the provided 
            // source that was shipped with the application layer component 'nv::index::app::data_analysis_and_processing::IData_analysis_and_processing'. 
            mi::base::Handle<nv::index::IDistributed_compute_technique> mapping(
                processing->get_sample_tool_set()->create_mandelbrot_2d_technique(mi::math::Vector<mi::Float32, 2>(1250.f, 680.f)));
            check_success(mapping.is_valid_interface());
 
            // Add the mapping to the scene before the heightfield
            mi::neuraylib::Tag mapping_tag = transaction->store_for_reference_counting(mapping.get());
            check_success(mapping_tag.is_valid());
            static_group_node->append(mapping_tag, transaction);
        }
        // Map height values in the heightfield to colors
        else if (texture_type == "height_color")
        {
            // Create the computed texture, passing the height range of the heightfield
            const mi::math::Vector<mi::Float32, 2> height_range(
                heightfield_bbox.min.z, heightfield_bbox.max.z);
 
            mi::base::Handle<nv::index::ITexture_filter_mode> tex_filter(
                scene->create_attribute<nv::index::ITexture_filter_mode_nearest_neighbor>());
            check_success(tex_filter.is_valid_interface());
            mi::neuraylib::Tag tex_filter_tag = transaction->store_for_reference_counting(tex_filter.get());
            check_success(tex_filter_tag.is_valid());
            static_group_node->append(tex_filter_tag, transaction);
 
            // Create the computed texture, with a size fitting the heightfield
            mi::base::Handle<nv::index::app::data_analysis_and_processing::IData_analysis_and_processing> processing(
                app_layer->get_api_component<nv::index::app::data_analysis_and_processing::IData_analysis_and_processing>());    
            check_success(processing.is_valid_interface());
            // Create a mandelbrot technique and add it to the scene. For more details on how to implement the checkerboard, please review the provided 
            // source that was shipped with the application layer component 'nv::index::app::data_analysis_and_processing::IData_analysis_and_processing'.
            const mi::math::Color color0(0.f, 1.f, 0.f, 1.f); // green
            const mi::math::Color color1(1.f, 0.f, 0.f, 1.f); // red
            mi::base::Handle<nv::index::IDistributed_compute_technique> mapping(
                processing->get_sample_tool_set()->create_color_encoded_elevation_technique(height_range, color0, color1));
            check_success(mapping.is_valid_interface());
 
            // Add the mapping to the scene before the heightfield
            mi::neuraylib::Tag mapping_tag = transaction->store_for_reference_counting(mapping.get());
            static_group_node->append(mapping_tag, transaction);
        }
    }
 
 
    mi::neuraylib::Tag create_synthetic_heightfield(
        nv::index::app::IApplication_layer*     app_layer,        
        nv::index::IScene*                      scene,
        mi::math::Bbox<mi::Float32, 3>&         heightfield_bbox,
        mi::neuraylib::IDice_transaction*       transaction) const
    {
            // Details for creating a synthetic heightfield.
        const mi::math::Vector<mi::Uint32, 2> heightfield_size(2000, 2000);
        std::map<std::string, std::string> heightfield_opt;
        heightfield_opt["type"]           = "heightfield";
        heightfield_opt["importer"]       = "nv::index::plugin::legacy_importer.Synthetic_heightfield_generator";
        heightfield_opt["synthetic_type"] = "i";
        heightfield_opt["size"]           = "2000 2000";
        heightfield_opt["range"]          = "0.1 1000";
        nv::index::IDistributed_data_import_callback* importer_callback = 
            get_importer_from_application_layer(
                app_layer,
                "nv::index::plugin::legacy_importer.Synthetic_heightfield_generator",
                heightfield_opt);
 
        // Create heightfield scene element and add it to the scene
        const mi::Float32 rotate_k = 0.0f;
        const mi::math::Vector<mi::Float32, 3> translate(0.0f, 0.0f, 0.0f);
        const mi::math::Vector<mi::Float32, 3> scale(0.5f, 0.5f, 0.5f);
        const mi::math::Vector<mi::Float32, 2> elevation_range(0.0f, 128.0f);
 
        mi::base::Handle<nv::index::IRegular_heightfield> heightfield_scene_element(
            scene->create_regular_heightfield(
                scale, rotate_k, translate,
                heightfield_size,
                elevation_range,
                importer_callback,
                transaction));
        check_success(heightfield_scene_element.is_valid_interface());
 
        heightfield_bbox = heightfield_scene_element->get_IJK_bounding_box();
 
        // Set the name of the heightfield scene element
        const std::string heightfield_name = "synthetic lod heightfield";
        heightfield_scene_element->set_name(heightfield_name.c_str());
 
        // ... and store the heightfield scene element in the distributed database ...
        mi::neuraylib::Tag heightfield_tag =
            transaction->store_for_reference_counting(heightfield_scene_element.get(), mi::neuraylib::NULL_TAG,
                "lod_heightfield_scene_element");
        return heightfield_tag;
    }
 
 
    //mi::neuraylib::Tag create_imported_heightfield(
    //    nv::index::IScene*                      scene,
    //    mi::math::Bbox<mi::Float32, 3>&         heightfield_bbox,
    //    mi::neuraylib::IDice_transaction*       transaction) const
    //{
    //    // WIP
    //}
 
 
 
    bool create_heightfield_scene(
        nv::index::app::IApplication_layer*    app_layer,        
        bool                                   enable_LOD,
        Scene_info&                            scene_info,
        const mi::math::Bbox< mi::Float32, 3>& roi_bbox,
        const mi::neuraylib::Tag&              session_tag,
        std::map<std::string, std::string>&    opt_map,
        mi::neuraylib::IDice_transaction*       transaction) const
    {
        // Access the session instance from the database.
        mi::base::Handle<const nv::index::ISession> session(
            transaction->access<const nv::index::ISession>(session_tag));
        check_success(session.is_valid_interface());
 
        // Access (edit mode) the scene instance from the database.
        mi::base::Handle<nv::index::IScene> scene(
            transaction->edit<nv::index::IScene>(session->get_scene()));
        check_success(scene.is_valid_interface());
 
        // Create static group node for large data
        mi::base::Handle<nv::index::IStatic_scene_group> static_group_node(
            scene->create_scene_group<nv::index::IStatic_scene_group>());
        check_success(static_group_node.is_valid_interface());
 
 
 
        mi::neuraylib::Tag heightfield_tag;
        mi::math::Bbox<mi::Float32, 3> heightfield_bbox;
        {
            heightfield_tag = create_synthetic_heightfield(app_layer, scene.get(), heightfield_bbox, transaction);
            check_success(heightfield_tag.is_valid());
        }
 
 
        if (enable_LOD)
        {
            // Heightfield rendering properties
            mi::base::Handle<nv::index::IRegular_heightfield_rendering_properties> hf_prop(
                scene->create_attribute<nv::index::IRegular_heightfield_rendering_properties>());
            check_success(hf_prop.is_valid_interface());
 
            hf_prop->set_lod_rendering_enabled(true);   // if false all black!
            hf_prop->set_lod_pixel_threshold(2.f);
            hf_prop->set_enabled(true);
 
            mi::neuraylib::Tag hf_prop_tag = transaction->store_for_reference_counting(hf_prop.get());
            check_success(hf_prop_tag.is_valid());
 
            static_group_node->append(hf_prop_tag, transaction);
        }
 
 
 
        // Add a light and a material to the static group node
        add_light_and_material(opt_map["hfield.texture"], scene.get(), static_group_node.get(), transaction);
 
        add_texture_mapping(app_layer, opt_map["hfield.texture"], heightfield_bbox, scene.get(), static_group_node.get(), transaction);
 
 
        // Append the surface sample program
        const int user_prg = nv::index::app::get_sint32(opt_map["user_program_mode"]);
        if (user_prg) {
            mi::base::Handle<nv::index::ISurface_sample_program> surface_sample_program(
                scene->create_attribute<nv::index::ISurface_sample_program>());
            check_success(surface_sample_program.is_valid_interface());
 
            std::string program_src = scene_info.rtc_program_source;
            if (program_src.empty()) {
                program_src = program_begin;
                program_src.append(color_program);
                if (user_prg > 1) {
                    program_src.append(inquire_program);
                }
                program_src.append(program_end);
                scene_info.rtc_program_source = program_src;
            }
            surface_sample_program->set_program_source(program_src.c_str());
 
            const mi::neuraylib::Tag surface_program_tag =
                transaction->store_for_reference_counting(surface_sample_program.get());
            check_success(surface_program_tag.is_valid());
            static_group_node->append(surface_program_tag, transaction);
        }
 
 
        // Append the heightfield to the scene group
        static_group_node->append(heightfield_tag, transaction);
 
 
        mi::neuraylib::Tag static_group_tag = transaction->store_for_reference_counting(static_group_node.get());
        check_success(static_group_tag.is_valid());
 
        // append the static scene group to the hierachical scene description.
        scene->append(static_group_tag, transaction);
 
 
        return true;
    }
 
 
    void setup_camera(
        const mi::neuraylib::Tag&         camera_tag,
        mi::neuraylib::IDice_transaction* transaction) const
    {
        check_success(camera_tag.is_valid());
        check_success(transaction != 0);
 
        mi::base::Handle<nv::index::IPerspective_camera> cam(
            transaction->edit<nv::index::IPerspective_camera>(camera_tag));
        check_success(cam.is_valid_interface());
 
        // Set the camera parameters to see the whole scene
        const mi::math::Vector<mi::Float32, 3> from(2000, 2000, -30);
        const mi::math::Vector<mi::Float32, 3> to(0.f, 0.f, -30.f);
        const mi::math::Vector<mi::Float32, 3> up(0.f, 0.f, 1.0f);
        mi::math::Vector<mi::Float32, 3> viewdir = to - from;
        viewdir.normalize();
 
        cam->set(from, viewdir, up);
        cam->set_aperture(0.033f);
        cam->set_aspect(1.0f);
        cam->set_focal(0.03f);
        cam->set_clip_min(2.0f);
        cam->set_clip_max(1000.0f);
    }
 
};
 
}//heightfield_common
 
 
namespace lod_heightfield {
 
 
class Lod_heightfield_setup : public heightfield_common::Common_heightfield_setup
{
public:
    const char* name() const { return "LOD Heightfield"; }
 
    bool create_scene(
        nv::index::app::IApplication_layer*     app_layer,        
        Scene_info&                             scene_info,
        const mi::math::Bbox< mi::Float32, 3>&  roi_bbox,
        const mi::neuraylib::Tag&               session_tag,
        std::map<std::string, std::string>&     opt_map,
        mi::neuraylib::IDice_transaction*       transaction) const
    {
        return create_heightfield_scene(
            app_layer,
            true /*enable_LOD*/,
            scene_info, roi_bbox, session_tag, opt_map, transaction);
    }
};
 
}
 
#endif