xac_compute_trianglemesh.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#include "xac_compute_trianglemesh.h"
#include <nv/index/itriangle_mesh_scene_element.h>
#include <nv/index/ilight.h>
#include <nv/index/imaterial.h>
#include <nv/index/irendering_kernel_programs.h>
 
namespace xac_compute {
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"
"    NV_IDX_DEVICE_INLINE_MEMBER void initialize()                          \n"
"    {                                                                      \n"
"    }                                                                      \n"
"                                                                           \n"
"   NV_IDX_DEVICE_INLINE_MEMBER float checker(const float3& pos) const      \n"
"   {                                                                       \n"
"       int box = 20;                                                       \n"
"       int a = (int(pos.x) / box & 1);                                     \n"
"       int b = (int(pos.y) / box & 1);                                     \n"
"       return (a ^ b) ? 1.f : 0.f;                                         \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"
"        sample_output.set_color(make_float4(                               \n"
"            sample_info.texture_coordinates.x,                             \n"
"            sample_info.texture_coordinates.y,                             \n"
"            checker(sample_info.scene_position),                           \n"
"            1.f));                                                         \n"
"                                                                           \n"
"        //sample_output.set_color(sample_info.sample_color);               \n"
"        return NV_IDX_PROG_OK;                                             \n"
"    }                                                                      \n"
;
 
static const char* compute_program =
"    // The user program for compute.                                       \n"
"    NV_IDX_DEVICE_INLINE_MEMBER                                            \n"
"    int compute(                                                           \n"
"        const Data_point_info_self&  data_point_info,                      \n"
"        Data_point_output&           data_output)                          \n"
"    {                                                                      \n"
"        const auto& surf = state.self;                                     \n"
"        unsigned attr_idx = surf.Attr_vertex_texture_coordinate;           \n"
"        float2 v = surf.get_attribute<float2>(attr_idx, data_point_info);  \n"
"                                                                           \n"
"        // Modify value v.                                                 \n"
"        v.x = 1.f - v.x;                                                   \n"
"        v.y = 1.f - v.y;                                                   \n"
"                                                                           \n"
"        float3 pos = data_point_info.get_position();                       \n"
"        v *= checker(pos);                                                 \n"
"                                                                           \n"
"        data_output.write_value(attr_idx, v);                              \n"
"                                                                           \n"
"        return NV_IDX_PROG_OK;                                             \n"
"    }                                                                      \n"
;
 
//----------------------------------------------------------------------
 
 
void Trianglemesh_setup::register_classes(nv::index::IIndex* index_interface) const
{
    // empty
}
 
 
void Trianglemesh_setup::add_arguments(Option_map& 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 Trianglemesh_setup::usage_info(Usage_helper& usage) const
{
    usage.opt("tmesh.file", "FILENAME", "Filename of the triangle mesh (.bin-format).");
}
 
 
const char* Trianglemesh_setup::get_roi_string() const
{
    return "368.38 727.758 482.661 630.081 995.543 590.383";
}
 
 
bool Trianglemesh_setup::create_scene(
    Nvindex_access&                     nvindex_accessor,
    Scene_info&                         scene_info, 
    const Bbox3f&                       roi_bbox, 
    mi::neuraylib::Tag                  session_tag, 
    const Option_map&                   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(Vec3f(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(compute_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);
        scene_info.compute_launch_info.compute_program_tag = surface_program_tag;
    }
 
    {
        // 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(
                nvindex_accessor.get_application_layer_interface(),
                "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);
        scene_info.compute_launch_info.scene_element_tag = mesh_tag;
    }
    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;
}
 
 
void Trianglemesh_setup::setup_camera(
    mi::neuraylib::Tag                  camera_tag, 
    const Option_map&                   opt_map,
    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, 850.f, 800.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);
}
 
}}