xac_compute_plane.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#include "xac_compute_plane.h"
#include <nv/index/iplane.h>
#include <nv/index/irendering_kernel_programs.h>
#include <nv/index/ilight.h>
#include <nv/index/imaterial.h>
#include <nv/index/icompute.h>
 
#include <nv/index/app/string_dict.h> // get_*
 
namespace xac_compute {
 
 
static const char* plane_program_begin =
";NV_IDX_XAC_VERSION_1_0                                 \n"
"namespace xac = nv::index::xac;                        \n"
"namespace xaclib = nv::index::xaclib;                  \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"
;
 
static const char* program_end =
"}; \n"
;
 
static const char* plane_color_program =
"    NV_IDX_DEVICE_INLINE_MEMBER int execute(                                       \n"
"        const Sample_info_self&  sample_info,                                      \n"
"              Sample_output&     sample_output)                                    \n"
"    {                                                                              \n"
"        float4 color = sample_info.sample_color;                                   \n"
"        float sample = 0.f;                                                        \n"
"        sample_func(sample_info.scene_position, sample, color);                    \n"
"                                                                                   \n"
"        // boost the opacity                                                       \n"
"        color.w = min(1.f, 0.3f + (color.w * 100.f) * 0.7f);                       \n"
"        sample_output.set_color(color);                                            \n"
"        return NV_IDX_PROG_OK;                                                     \n"
"    }                                                                              \n"
;
 
static const char* plane_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"
"        if (!data_point_info.is_valid()) { return NV_IDX_PROG_OK; }                \n"
"                                                                                   \n"
"        float sample = 0.f;                                                        \n"
"        float4 vcolor;                                                             \n"
"        if (sample_func(data_point_info.get_position(), sample, vcolor)) {         \n"
"            data_output.write_value(0, sample);                                    \n"
"            data_output.write_value(1, make_float3(vcolor.x, vcolor.y, vcolor.z)); \n"
"        }                                                                          \n"
"        return NV_IDX_PROG_OK;                                                     \n"
"    }                                                                              \n"
;
 
static const Program_source plane_program = {
    plane_program_begin,
    program_end,
    plane_color_program,
    plane_compute_program
};
 
 
void Plane_setup::add_arguments(Option_map& opt_map) const
{
    opt_map["cplane.resolution"] = "256 256";
}
 
 
void Plane_setup::usage_info(Usage_helper& usage) const
{
    usage.opt("cplane.resolution", "X Y", "Resolution of compute plane.");
}
 
 
void Plane_setup::add_compute_plane_group(
    const mi::neuraylib::Tag compute_target,
    const char* plane_sample_function,
    const Option_map& opt_map,
    Scene_info& scene_info,
    Scene_tool& scene_tool) const
{
    scene_tool.add_new_group(true);
 
    // Set transformation of the new group.
    {
        mi::base::Handle<nv::index::ITransformed_scene_group> xfgroup(
            scene_tool.current_group.get_interface<nv::index::ITransformed_scene_group>());
        check_success(xfgroup);
 
        mi::math::Matrix<mi::Float32, 4, 4> transform_mat(1.f);
        const Vec3f rotation(0.f, 0.f, 45.f);
        transform_mat.rotate(rotation / 180.f * float(M_PI));
        const Vec3f translate(70.f, 10.f, 5.f);
        transform_mat.translate(translate);
        xfgroup->set_transform(transform_mat);
    }
 
    // Add scene element mapping. This ensures presence of volume even if it is disabled.
    {
        mi::base::Handle<nv::index::IRendering_kernel_program_scene_element_mapping> mapping;
        scene_tool.create_attribute(mapping);
 
        mapping->set_mapping(0, compute_target);
        scene_tool.store_and_add_to_group(mapping);
    }
 
    // Add a light, needed to suppress a warning
    {
        mi::base::Handle<nv::index::IDirectional_headlight> headlight;
        scene_tool.create_attribute(headlight);
 
        const mi::math::Color color_intensity(1.0f, 1.0f, 1.0f, 1.0f);
        headlight->set_intensity(color_intensity);
        headlight->set_direction(Vec3f(1.0f, -1.0f, -1.0f));
        scene_tool.store_and_add_to_group(headlight);
    }
 
    // create material
    {
        mi::base::Handle<nv::index::IPhong_gl> mat;
        scene_tool.create_attribute(mat);
 
        mat->set_ambient(mi::math::Color(0.1f, 0.1f, 0.1f, 1.f));
        mat->set_diffuse(mi::math::Color(0.5f, 0.5f, 0.5f, 1.f));
        mat->set_specular(mi::math::Color(0.f));
        mat->set_shininess(0.f);
        scene_tool.store_and_add_to_group(mat);
    }
 
    // create ICompute_plane_parameters
    {
        mi::base::Handle<nv::index::ICompute_plane_parameters> comp_par;
        scene_tool.create_attribute(comp_par);
 
        const Vec2u plane_resolution = nv::index::app::get_vector_from_string<mi::Uint32,2>(opt_map["cplane.resolution"]);
        const mi::Uint32 value_sizes[3] = {sizeof(float), sizeof(float) * 3, sizeof(int)};
        comp_par->set_resolution(plane_resolution);
        //comp_par->set_value_sizes(value_sizes, 3);
        comp_par->set_value_sizes(value_sizes, 2);  // just use 2 value slots in non-debug mode
        scene_tool.store_and_add_to_group(comp_par);
    }
 
    // add compute program for plane
    {
        const int prg_mode = 2; // include the compute method
                                //const int prg_mode = nv::index::app::get_sint32(opt_map["user_program_mode"]);
        std::pair<mi::neuraylib::Tag, std::string> prg_info =
            add_user_program(
                Surface_sample_program,
                prg_mode,
                scene_info.plane_rtc_program_source,
                plane_program,
                scene_tool,
                plane_sample_function);
 
        scene_info.compute_launch_info.plane_compute_program_tag = prg_info.first;
        scene_info.plane_rtc_program_source = prg_info.second;
    }
 
    // create plane
    {
        mi::base::Handle<nv::index::IPlane> plane(
            scene_tool.scene->create_shape<nv::index::IPlane>());
        check_success(plane.is_valid_interface());
 
        plane->set_point(Vec3f(0.f, 0.f, 5.f));
        plane->set_normal(Vec3f(-1.f, 0.f, 0.f));
        plane->set_up(Vec3f(0.f, 1.f, 0.f));
        plane->set_extent(Vec2f(60.0f, 60.0f));
 
        scene_info.compute_launch_info.plane_tag = scene_tool.store_and_add_to_group(plane);
    }
}
 
 
 
 
}//xac_compute