ray_sampling_trianglemesh.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
#ifndef EXAMPLES_RAY_SAMPLING_TRIANGLEMESH_H
#define EXAMPLES_RAY_SAMPLING_TRIANGLEMESH_H
 
#include "ray_sampling_scenes.h"
#include <nv/index/itriangle_mesh_scene_element.h>
#include <nv/index/ilight.h>
#include <nv/index/imaterial.h>
 
 
namespace trianglemesh {
 
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.scene_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 Trianglemesh_setup : public ray_sampling::IRay_sampling_scene_setup
{
public:
    const char* name() const { return "Trianglemesh"; }
 
    void register_classes(nv::index::IIndex* index_interface) const
    {
        // empty
    }
 
 
    void add_arguments(std::map<std::string, std::string>& opt_map) const
    {
        opt_map["tmesh.file"] = "../create_trianglemesh/jacket.bin";  // input triangle mesh file name
//        opt_map["tmesh.roi"] = "368.38 727.758 482.661 630.081 995.543 590.383";  // input roi
    }
 
 
    void usage_info(std::ostream& os, const char* indent, std::map<std::string, std::string>& opt_map) const
    {
        os << indent << "[-tmesh.file string]\n"
            << indent << "    name of the triangle mesh file (in .bin-format).\n"
            << indent << "    (default: [" << opt_map["tmesh.file"] << "])\n"
            //<< indent << "[-tmesh.roi \"float float float  float float float\"]\n"
            //<< indent << "    the bounding box representing the region of interest (roi).\n"
            //<< indent << "    (default: [" << opt_map["tmesh.roi"] << "])\n"
            ;
    }
 
 
    const char* get_roi_string() const
    {
        return "368.38 727.758 482.661 630.081 995.543 590.383";
    }
 
 
    //void adjust_configuration(
    //    nv::index::IConfig_settings* config_settings,
    //    std::map<std::string, std::string>& opt_map) const {}
 
 
    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
    {
        const std::string mesh_file = opt_map["tmesh.file"];
        check_success(session_tag.is_valid());
        check_success(transaction != 0);
 
        mi::base::Handle< nv::index::ISession const > session(
            transaction->access<nv::index::ISession const>(session_tag));
        check_success(session.is_valid_interface());
 
        // Get the scene (root)
        mi::base::Handle< nv::index::IScene > scene_edit(
            transaction->edit<nv::index::IScene>(session->get_scene()));
        check_success(scene_edit.is_valid_interface());
 
        {
            // Set the default light source
            mi::base::Handle<nv::index::IDirectional_headlight> headlight(
                scene_edit->create_attribute<nv::index::IDirectional_headlight>());
            check_success(headlight.is_valid_interface());
            headlight->set_direction(mi::math::Vector<mi::Float32, 3>(0.5f, 0.f, -1.f));
            const mi::neuraylib::Tag headlight_tag = transaction->store(headlight.get());
            check_success(headlight_tag.is_valid());
            scene_edit->append(headlight_tag, transaction);
 
            // Set the default material
            mi::base::Handle<nv::index::IPhong_gl> phong_1(scene_edit->create_attribute<nv::index::IPhong_gl>());
            check_success(phong_1.is_valid_interface());
            phong_1->set_ambient(mi::math::Color(0.1f, 0.1f, 0.1f, 1.0f));
            phong_1->set_diffuse(mi::math::Color(0.45f, 0.3f, 0.3f, 1.0f));
            phong_1->set_specular(mi::math::Color(0.4f, 0.4f, 0.75f, 1.0f));
            const mi::Float32 opacity = 1.f;
            phong_1->set_opacity(opacity);
            phong_1->set_shininess(85);
            const mi::neuraylib::Tag phong_1_tag = transaction->store(phong_1.get());
            check_success(phong_1_tag.is_valid());
            scene_edit->append(phong_1_tag, transaction);
        }
 
        // Create a static scene group
        mi::base::Handle<nv::index::IStatic_scene_group> static_group(
            scene_edit->create_scene_group<nv::index::IStatic_scene_group>());
        check_success(static_group.is_valid_interface());
 
        // 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_edit->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->append(surface_program_tag, transaction);
        }
 
        {
            // triangle mesh creation parameter
            std::map<std::string, std::string> triangle_mesh_opt;
            triangle_mesh_opt["type"]       = "triangle_mesh";
            triangle_mesh_opt["importer"]   = "nv::index::plugin::base_importer.Triangle_mesh_importer";
            triangle_mesh_opt["input_file"] = mesh_file;
            triangle_mesh_opt["bbox"]       = get_roi_string();
            nv::index::IDistributed_data_import_callback* importer_callback = 
                get_importer_from_application_layer(
                    app_layer,
                    "nv::index::plugin::base_importer.Triangle_mesh_importer",
                    triangle_mesh_opt);
 
 
            // Create the triangle mesh scene element
            mi::base::Handle<nv::index::ITriangle_mesh_scene_element> mesh(
                scene_edit->create_triangle_mesh(roi_bbox, importer_callback, transaction));
            check_success(mesh != 0);
 
            // scene element properties
            mesh->set_enabled(true);
 
            // storing the mesh in the data (base) store
            mi::neuraylib::Tag mesh_tag = transaction->store_for_reference_counting(
                mesh.get(), mi::neuraylib::NULL_TAG, "mesh");
            check_success(mesh_tag.is_valid());
 
 
            // append mesh to the static scene group
            static_group->append(mesh_tag, transaction);
        }
        mi::neuraylib::Tag static_group_tag = transaction->store(static_group.get());
        check_success(static_group_tag.is_valid());
 
        // append the static scene group to the hierachical scene description.
        scene_edit->append(static_group_tag, transaction);
 
        return true;
    }
 
 
    // setup camera to see this example scene
    //
    // \param[in] camera_tag camera tag
    // \param[in] transaction dice transaction
    void setup_camera(
        const mi::neuraylib::Tag&         camera_tag,
        mi::neuraylib::IDice_transaction* transaction) const
    {
        mi::base::Handle<nv::index::IPerspective_camera> cam(
            transaction->edit<nv::index::IPerspective_camera>(camera_tag));
        check_success(cam.is_valid_interface());
 
        const mi::math::Vector< mi::Float32, 3 > from(500.f, 861.f, -890.f);
        mi::math::Vector< mi::Float32, 3 > viewdir(0.f, 0.f, 1.f);
        const mi::math::Vector< mi::Float32, 3 > up(0.f, 1.f, 0.f);
        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(10.0f);
        cam->set_clip_max(5000.0f);
    }
 
};
 
}
 
#endif