xac_compute_scene_tool.cpp

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#include "xac_compute_scene_tool.h"
#include <nv/index/irendering_kernel_programs.h>
 
namespace xac_compute {
 
 
Scene_tool::Scene_tool(
    mi::neuraylib::Tag session_tag_, 
    mi::neuraylib::IDice_transaction* transaction_) 
    : transaction(transaction_)
{
    check_success(transaction != 0);
 
    // Access the session instance from the database.
    session = transaction->access<const nv::index::ISession>(session_tag_);
    check_success(session.is_valid_interface());
 
    // Access (edit mode) the scene instance from the database.
    scene = transaction->edit<nv::index::IScene>(session->get_scene());
    check_success(scene.is_valid_interface());
}
 
 
 
mi::neuraylib::Tag Scene_tool::add_new_group(bool transformed_group /*= false*/)
{
    mi::base::Handle<nv::index::IScene_group> group;
    if (transformed_group) {
        group = scene->create_scene_group<nv::index::ITransformed_scene_group>();
    }
    else {
        group = scene->create_scene_group<nv::index::IStatic_scene_group>();
    }
    mi::neuraylib::Tag group_tag = transaction->store_for_reference_counting(group.get());
    check_success(group_tag.is_valid());
    // append the static scene group to the hierarchical scene description.
    scene->append(group_tag, transaction);
    set_group(group_tag);
    return group_tag;
}
 
 
void Scene_tool::set_group(mi::neuraylib::Tag group_)
{
    if (group_.is_valid()) {
        current_group = transaction->edit<nv::index::IScene_group>(group_);
    }
    else {
        current_group.reset();
    }
}
 
 
// factory to create concrete XAC program type
template<class T>
inline mi::base::Handle<nv::index::IRendering_kernel_program> 
create_kernel_program(Scene_tool& scene_tool)
{
    mi::base::Handle<T> program;
    scene_tool.create_attribute(program);
    mi::base::Handle<nv::index::IRendering_kernel_program> rprog;
    if (program) {
        rprog = program-> template get_interface<nv::index::IRendering_kernel_program>();
    }
    return rprog;
}
 
 
// nv::index::IVolume_sample_program or nv::index::ISurface_sample_program
std::pair<mi::neuraylib::Tag, std::string>
add_user_program(
    Sample_program_kind     prg_kind,
    int                     user_prg,
    const std::string&      user_text,
    const Program_source&   prg_text,
    Scene_tool&             scene_tool,
    const char*             extra_pgr_methods)
 
{
    if (user_prg == 0) {
        return std::pair<mi::neuraylib::Tag, std::string>();
    }
 
    // IRendering_kernel_program
    mi::base::Handle<nv::index::IRendering_kernel_program> sampling_program;
    switch (prg_kind) {
    case Surface_sample_program: {
        sampling_program = create_kernel_program<nv::index::ISurface_sample_program>(scene_tool);
        break;
    }
    case Volume_sample_program: {
        sampling_program = create_kernel_program<nv::index::IVolume_sample_program>(scene_tool);
        break;
    }
    default: return std::make_pair(mi::neuraylib::NULL_TAG, std::string());
    }
 
    std::string program_src = user_text;
    if (program_src.empty()) {
        program_src = prg_text.program_begin;
        if (extra_pgr_methods) program_src.append(extra_pgr_methods);
        program_src.append(prg_text.color_program);
        if (user_prg > 1) {
            program_src.append(prg_text.compute_program);
        }
        program_src.append(prg_text.program_end);
    }
    sampling_program->set_program_source(program_src.c_str());
 
    const mi::neuraylib::Tag prog_tag = scene_tool.store_and_add_to_group(sampling_program);
 
    return std::make_pair(prog_tag, program_src);
}
 
 
}//xac_compute