NVIDIA Index example code nvidia_logo_transpbg.gif Up
ray_sampling_simple_shapes.h
Go to the documentation of this file.
1/******************************************************************************
2 * Copyright 2023 NVIDIA Corporation. All rights reserved.
3 *****************************************************************************/
4
5#ifndef EXAMPLES_RAY_SAMPLING_SIMPLE_SHAPES_H
6#define EXAMPLES_RAY_SAMPLING_SIMPLE_SHAPES_H
7
8#include "ray_sampling_scenes.h"
9
10#include <nv/index/iscene_group.h>
11#include <nv/index/icylinder.h>
12#include <nv/index/icone.h>
13#include <nv/index/isphere.h>
14#include <nv/index/iellipsoid.h>
15#include <nv/index/iplane.h>
16
17#include <nv/index/imaterial.h>
18#include <nv/index/ilight.h>
19
20namespace simple_shapes {
21
22static const char* program_begin =
23";NV_IDX_XAC_VERSION_1_0 \n"
24" \n"
25"class Surface_sample_program \n"
26"{ \n"
27" NV_IDX_SURFACE_SAMPLE_PROGRAM \n"
28" \n"
29"public: \n"
30" int counter; \n"
31" \n"
32" NV_IDX_DEVICE_INLINE_MEMBER void initialize() \n"
33" { \n"
34" counter = 0; \n"
35" } \n"
36" \n"
37;
38
39static const char* program_end =
40"}; \n"
41;
42
43static const char* color_program =
44" NV_IDX_DEVICE_INLINE_MEMBER int execute( \n"
45" const Sample_info_self& sample_info, \n"
46" Sample_output& sample_output) \n"
47" { \n"
48" const uint light_id = state.self.get_light_id(); \n"
49" const uint material_id = state.self.get_material_id(); \n"
50" \n"
51" const float3 ray_direction = normalize(sample_info.ray_direction); \n"
52" float4 color = nv::index::xaclib::phong_shading( \n"
53" state.scene, material_id, light_id, \n"
54" ray_direction, \n"
55" sample_info.sample_normal, true); \n"
56" \n"
57" color.w = 1.f; \n"
58" const float screen_gamma = 0.6f; \n"
59" color = nv::index::xaclib::gamma_correct(color, screen_gamma); \n"
60" sample_output.set_color(color); \n"
61" return NV_IDX_PROG_OK; \n"
62" } \n"
63;
64
65static const char* inquire_program =
66" // The user program used for picking. \n"
67" NV_IDX_DEVICE_INLINE_MEMBER int inquire( \n"
68" const Sample_info_self& sample_info, \n"
69" Query_results& query_results) \n"
70" { \n"
71" // sample_info.ray_t is automatically written \n"
72" // color is automatically written \n"
73" \n"
74" // we could invalidate current sample to skip/ignore it \n"
75" //query_results.invalidate_sample(); \n"
76" \n"
77" // write some attribute value of current sample \n"
78" const float v = \n"
79" sample_info.scene_position.x; \n"
80" query_results.write_value<float>(0u /*user_value_idx*/, v); \n"
81" \n"
82" counter += 1; \n"
83" if (counter & 1) { \n"
84" // write every other counter as user value \n"
85" query_results.write_value<int>(1u /*user_value_idx*/, counter); \n"
86" } \n"
87" \n"
88" const float3 normal = sample_info.sample_normal; \n"
89" query_results.write_value<float3>(2u /*user_value_idx*/, normal); \n"
90" \n"
91" return NV_IDX_PROG_OK; \n"
92" \n"
93" // we can stop sampling: \n"
94" //return NV_IDX_PROG_TERMINATE_PROGRAM_INSTANCE; \n"
95" } \n"
96;
97
98
99//----------------------------------------------------------------------
100
101class Simple_shapes_setup : public ray_sampling::IRay_sampling_scene_setup
102{
103public:
104 const char* name() const { return "Simple Shapes"; }
105
106 const char* get_roi_string() const
107 {
108 return "0 0 0 1500 1500 1500";
109 }
110
111 const mi::math::Bbox< mi::Float32, 3> get_roi_box() const
112 {
113 return nv::index::app::get_bbox_from_string<mi::Float32,3>(get_roi_string());
114 }
115
116 bool create_scene(
117 nv::index::app::IApplication_layer* app_layer,
118 Scene_info& scene_info,
119 const mi::math::Bbox< mi::Float32, 3>& roi_bbox,
120 const mi::neuraylib::Tag& session_tag,
121 std::map<std::string, std::string>& opt_map,
122 mi::neuraylib::IDice_transaction* dice_transaction) const
123 {
124 // Access the session instance from the database.
125 mi::base::Handle<const nv::index::ISession> session(
126 dice_transaction->access<const nv::index::ISession>(session_tag));
127 check_success(session.is_valid_interface());
128
129 // Access (edit mode) the scene instance from the database.
130 mi::base::Handle<nv::index::IScene> scene(
131 dice_transaction->edit<nv::index::IScene>(session->get_scene()));
132 check_success(scene.is_valid_interface());
133
134 // Append the surface sample program
135 const int user_prg = nv::index::app::get_sint32(opt_map["user_program_mode"]);
136 if (user_prg)
137 {
138 mi::base::Handle<nv::index::ISurface_sample_program> surface_sample_program(
139 scene->create_attribute<nv::index::ISurface_sample_program>());
140 check_success(surface_sample_program.is_valid_interface());
141
142 std::string program_src = scene_info.rtc_program_source;
143 if (program_src.empty()) {
144 program_src = program_begin;
145 program_src.append(color_program);
146 if (user_prg > 1)
147 {
148 program_src.append(inquire_program);
149 }
150 program_src.append(program_end);
151 scene_info.rtc_program_source = program_src;
152 }
153 surface_sample_program->set_program_source(program_src.c_str());
154
155 const mi::neuraylib::Tag surface_program_tag =
156 dice_transaction->store_for_reference_counting(surface_sample_program.get());
157 check_success(surface_program_tag.is_valid());
158 scene->append(surface_program_tag, dice_transaction);
159 }
160
161 // Add a light and a material
162 {
163 // Set the default light source
164 mi::base::Handle<nv::index::IDirectional_light> light_global(
165 scene->create_attribute<nv::index::IDirectional_light>());
166 check_success(light_global.is_valid_interface());
167 light_global->set_direction(mi::math::Vector<mi::Float32, 3>(0.5f, 0.f, 1.f));
168 const mi::neuraylib::Tag light_global_tag = dice_transaction->store_for_reference_counting(light_global.get());
169 check_success(light_global_tag.is_valid());
170 scene->append(light_global_tag, dice_transaction);
171
172 // Set the default material
173 mi::base::Handle<nv::index::IPhong_gl> phong_global(scene->create_attribute<nv::index::IPhong_gl>());
174 check_success(phong_global.is_valid_interface());
175 phong_global->set_ambient(mi::math::Color(0.1f, 0.15f, 0.1f, 1.0f));
176 phong_global->set_diffuse(mi::math::Color(0.95f, 0.3f, 0.3f, 1.0f));
177 phong_global->set_specular(mi::math::Color(0.4f, 0.4f, 0.5f, 1.0f));
178 phong_global->set_shininess(100);
179 const mi::neuraylib::Tag phong_global_tag = dice_transaction->store_for_reference_counting(phong_global.get());
180 check_success(phong_global_tag.is_valid());
181 scene->append(phong_global_tag, dice_transaction);
182 }
183
184 // Add various shapes with individual materials
185 {
186 mi::base::Handle<nv::index::IPhong_gl> phong_0(scene->create_attribute<nv::index::IPhong_gl>());
187 check_success(phong_0.is_valid_interface());
188 phong_0->set_ambient(mi::math::Color(0.f, 0.3f, 0.0f, 1.0f));
189 phong_0->set_diffuse(mi::math::Color(0.f, 0.1f, 0.0f, 1.0f));
190 phong_0->set_specular(mi::math::Color(0.2f, 0.2f, 0.2f, 1.0f));
191 phong_0->set_shininess(10);
192 const mi::neuraylib::Tag phong_0_tag = dice_transaction->store_for_reference_counting(phong_0.get());
193 check_success(phong_0_tag.is_valid());
194 scene->append(phong_0_tag, dice_transaction);
195
196 mi::base::Handle<nv::index::IPlane> plane_1(scene->create_shape<nv::index::IPlane>());
197 check_success(plane_1.is_valid_interface());
198 plane_1->set_point(mi::math::Vector<mi::Float32, 3>(10.f, 10.f, 400.f));
199 plane_1->set_normal(mi::math::Vector<mi::Float32, 3>(0.f, 0.f, 1.f));
200 plane_1->set_up(mi::math::Vector<mi::Float32, 3>(0.f, 1.f, 0.f));
201 plane_1->set_extent(mi::math::Vector<mi::Float32, 2>(580.f, 300.f));
202 const mi::neuraylib::Tag plane_1_tag = dice_transaction->store_for_reference_counting(
203 plane_1.get(), mi::neuraylib::NULL_TAG, "plane_1");
204 check_success(plane_1_tag.is_valid());
205 scene->append(plane_1_tag, dice_transaction);
206
207 mi::base::Handle<nv::index::IPhong_gl> phong_1(scene->create_attribute<nv::index::IPhong_gl>());
208 check_success(phong_1.is_valid_interface());
209 phong_1->set_ambient(mi::math::Color(0.f, 0.1f, 0.4f, 1.0f));
210 phong_1->set_diffuse(mi::math::Color(0.f, 0.3f, 0.6f, 1.0f));
211 phong_1->set_specular(mi::math::Color(0.4f, 0.4f, 0.5f, 1.0f));
212 phong_1->set_shininess(10);
213 const mi::neuraylib::Tag phong_1_tag = dice_transaction->store_for_reference_counting(phong_1.get());
214 check_success(phong_1_tag.is_valid());
215 scene->append(phong_1_tag, dice_transaction);
216
217 mi::base::Handle<nv::index::ISphere> sphere_1(scene->create_shape<nv::index::ISphere>());
218 check_success(sphere_1.is_valid_interface());
219 sphere_1->set_center(mi::math::Vector<mi::Float32, 3>(300.f, 250.f, 500.f));
220 sphere_1->set_radius(250);
221 const mi::neuraylib::Tag sphere_1_tag = dice_transaction->store_for_reference_counting(
222 sphere_1.get(), mi::neuraylib::NULL_TAG, "sphere_1");
223 check_success(sphere_1_tag.is_valid());
224 scene->append(sphere_1_tag, dice_transaction);
225
226 mi::base::Handle<nv::index::IPhong_gl> phong_2(scene->create_attribute<nv::index::IPhong_gl>());
227 check_success(phong_2.is_valid_interface());
228 phong_2->set_ambient(mi::math::Color(0.15f, 0.1f, 0.1f, 1.0f));
229 phong_2->set_diffuse(mi::math::Color(0.75f, 0.1f, 0.1f, 1.0f));
230 phong_2->set_specular(mi::math::Color(0.5f, 0.4f, 0.4f, 1.0f));
231 phong_2->set_shininess(50);
232 const mi::neuraylib::Tag phong_2_tag = dice_transaction->store_for_reference_counting(phong_2.get());
233 check_success(phong_2_tag.is_valid());
234 scene->append(phong_2_tag, dice_transaction);
235
236 mi::base::Handle<nv::index::ICone> cone_1(scene->create_shape<nv::index::ICone>());
237 check_success(cone_1.is_valid_interface());
238 const mi::math::Vector<mi::Float32, 3> cone_1_center(280.f, 230.f, 100.f);
239 cone_1->set_center(cone_1_center);
240 cone_1->set_tip(cone_1_center + mi::math::Vector<mi::Float32, 3>(20.f, 80.f, 20.f));
241 cone_1->set_radius(50);
242 cone_1->set_capped(true);
243 const mi::neuraylib::Tag cone_1_tag = dice_transaction->store_for_reference_counting(
244 cone_1.get(), mi::neuraylib::NULL_TAG, "cone_1");
245 check_success(cone_1_tag.is_valid());
246 scene->append(cone_1_tag, dice_transaction);
247
248 mi::base::Handle<nv::index::IPhong_gl> phong_3(scene->create_attribute<nv::index::IPhong_gl>());
249 check_success(phong_3.is_valid_interface());
250 phong_3->set_ambient(mi::math::Color(0.1f, 0.15f, 0.1f, 1.0f));
251 phong_3->set_diffuse(mi::math::Color(0.5f, 0.55f, 0.5f, 1.0f));
252 phong_3->set_specular(mi::math::Color(0.4f, 0.4f, 0.5f, 1.0f));
253 phong_3->set_shininess(80);
254 const mi::neuraylib::Tag phong_3_tag = dice_transaction->store_for_reference_counting(phong_3.get());
255 check_success(phong_3_tag.is_valid());
256 scene->append(phong_3_tag, dice_transaction);
257
258 mi::base::Handle<nv::index::ICylinder> cylinder_1(scene->create_shape<nv::index::ICylinder>());
259 check_success(cylinder_1.is_valid_interface());
260 const mi::math::Vector<mi::Float32, 3> cylinder_1_bottom(280.f, 200.f, 200.f);
261 cylinder_1->set_bottom(cylinder_1_bottom);
262 cylinder_1->set_top(cylinder_1_bottom + mi::math::Vector<mi::Float32, 3>(0.f, 120.f, -60.f));
263 cylinder_1->set_radius(40);
264 cylinder_1->set_capped(true);
265 const mi::neuraylib::Tag cylinder_1_tag = dice_transaction->store_for_reference_counting(
266 cylinder_1.get(), mi::neuraylib::NULL_TAG, "cylinder_1");
267 check_success(cylinder_1_tag.is_valid());
268 scene->append(cylinder_1_tag, dice_transaction);
269 }
270
271 return true;
272 }
273
274 void setup_camera(
275 const mi::neuraylib::Tag& camera_tag,
276 mi::neuraylib::IDice_transaction* transaction) const
277 {
278 check_success(camera_tag.is_valid());
279 check_success(transaction != 0);
280
281 mi::base::Handle<nv::index::IPerspective_camera> cam(
282 transaction->edit<nv::index::IPerspective_camera>(camera_tag));
283 check_success(cam.is_valid_interface());
284
285 // Set the camera parameters to see the whole scene
286 const mi::math::Vector<mi::Float32, 3> from(254.f, 254.f, 550.f);
287 const mi::math::Vector<mi::Float32, 3> to (255.f, 255.f, -255.f);
288 const mi::math::Vector<mi::Float32, 3> up (0.f, 1.f, 0.f);
289 mi::math::Vector<mi::Float32, 3> viewdir = to - from;
290 viewdir.normalize();
291
292 cam->set(from, viewdir, up);
293 cam->set_aperture(0.033f);
294 cam->set_aspect(1.f);
295 cam->set_focal(0.03f);
296 cam->set_clip_min(1.f);
297 cam->set_clip_max(5000.f);
298 }
299};
300
301} // namespace simple_shapes
302
303#endif // EXAMPLES_RAY_SAMPLING_SIMPLE_SHAPES_H
ray_sampling::IRay_sampling_scene_setup
Definition: ray_sampling_scenes.h:28
simple_shapes::Simple_shapes_setup
Definition: ray_sampling_simple_shapes.h:102
simple_shapes::Simple_shapes_setup::get_roi_string
const char * get_roi_string() const
Definition: ray_sampling_simple_shapes.h:106
simple_shapes::Simple_shapes_setup::setup_camera
void setup_camera(const mi::neuraylib::Tag &camera_tag, mi::neuraylib::IDice_transaction *transaction) const
Definition: ray_sampling_simple_shapes.h:274
simple_shapes::Simple_shapes_setup::get_roi_box
const mi::math::Bbox< mi::Float32, 3 > get_roi_box() const
Definition: ray_sampling_simple_shapes.h:111
simple_shapes::Simple_shapes_setup::name
const char * name() const
Definition: ray_sampling_simple_shapes.h:104
simple_shapes::Simple_shapes_setup::create_scene
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 *dice_transaction) const
Definition: ray_sampling_simple_shapes.h:116
simple_shapes
Definition: ray_sampling_simple_shapes.h:20
simple_shapes::program_end
static const char * program_end
Definition: ray_sampling_simple_shapes.h:39
simple_shapes::inquire_program
static const char * inquire_program
Definition: ray_sampling_simple_shapes.h:65
simple_shapes::color_program
static const char * color_program
Definition: ray_sampling_simple_shapes.h:43
simple_shapes::program_begin
static const char * program_begin
Definition: ray_sampling_simple_shapes.h:22
ray_sampling_scenes.h
Scene setup interface for ray sampling example.
check_success
#define check_success(expr)
Definition: start_application_layer.cpp:46
ray_sampling::Scene_info
Definition: ray_sampling_scenes.h:22
ray_sampling::Scene_info::rtc_program_source
std::string rtc_program_source
Definition: ray_sampling_scenes.h:23