Material Definition Language API nvidia_logo_transpbg.gif Up
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
set_get.h
Go to the documentation of this file.
1 /***************************************************************************************************
2  * Copyright 2020 NVIDIA Corporation. All rights reserved.
3  **************************************************************************************************/
6 
7 #ifndef MI_NEURAYLIB_SET_GET_H
8 #define MI_NEURAYLIB_SET_GET_H
9 
10 #include <mi/base/config.h>
11 #include <mi/base/handle.h>
13 #include <mi/neuraylib/ibbox.h>
14 #include <mi/neuraylib/icolor.h>
15 #include <mi/neuraylib/ienum.h>
16 #include <mi/neuraylib/imatrix.h>
17 #include <mi/neuraylib/inumber.h>
18 #include <mi/neuraylib/iref.h>
19 #include <mi/neuraylib/ispectrum.h>
20 #include <mi/neuraylib/istring.h>
21 #include <mi/neuraylib/iuuid.h>
22 #include <mi/neuraylib/ivector.h>
24 
25 namespace mi {
26 
31 template<class T>
52 mi::Sint32 set_value( mi::IData* data, const T& value)
53 {
55  if( v.is_valid_interface()) {
56  v->set_value( value);
57  return 0;
58  }
60  if( e.is_valid_interface()) {
61  mi::Sint32 result = e->set_value( static_cast<mi::Sint32>( value));
62  return result == 0 ? 0 : -2;
63  }
64  return -1;
65 }
66 
70 inline mi::Sint32 set_value( mi::IData* data, const char* value)
71 {
73  if( s.is_valid_interface()) {
74  s->set_c_str( value);
75  return 0;
76  }
78  if( r.is_valid_interface()) {
79  mi::Sint32 result = r->set_reference( value);
80  return result == 0 ? 0 : -2;
81  }
83  if( e.is_valid_interface()) {
84  mi::Sint32 result = e->set_value_by_name( value);
85  return result == 0 ? 0 : -2;
86  }
87  return -1;
88 }
89 
93 inline mi::Sint32 set_value( mi::IData* data, const std::string& value)
94 {
95  return set_value(data,value.c_str());
96 }
97 
101 inline mi::Sint32 set_value( mi::IData* data, const mi::base::Uuid& value)
102 {
104  if( u.is_valid_interface()) {
105  u->set_uuid( value);
106  return 0;
107  }
108  return -1;
109 }
110 
121 template <class T, Size DIM>
123 {
124  typedef typename mi::Vector_type_traits<T,DIM>::Interface_type Vector_interface_type;
125  mi::base::Handle<Vector_interface_type> v( data->get_interface<Vector_interface_type>());
126  if( v.is_valid_interface()) {
127  v->set_value( value);
128  return 0;
129  }
130  return -1;
131 }
132 
143 template <class T, Size ROW, Size COL>
145 {
146  typedef typename mi::Matrix_type_traits<T,ROW,COL>::Interface_type Matrix_interface_type;
147  mi::base::Handle<Matrix_interface_type> m( data->get_interface<Matrix_interface_type>());
148  if( m.is_valid_interface()) {
149  m->set_value( value);
150  return 0;
151  }
152  return -1;
153 }
154 
158 inline mi::Sint32 set_value( mi::IData* data, const mi::Color& value)
159 {
161  if( c.is_valid_interface()) {
162  c->set_value( value);
163  return 0;
164  }
166  if( c3.is_valid_interface()) {
167  c3->set_value( value);
168  return 0;
169  }
170  return -1;
171 }
172 
176 inline mi::Sint32 set_value( mi::IData* data, const mi::Spectrum& value)
177 {
179  if( s.is_valid_interface()) {
180  s->set_value( value);
181  return 0;
182  }
183  return -1;
184 }
185 
189 inline mi::Sint32 set_value( mi::IData* data, const mi::Bbox3& value)
190 {
192  if( b.is_valid_interface()) {
193  b->set_value( value);
194  return 0;
195  }
196  return -1;
197 }
198 
210 template<class T>
211 mi::Sint32 set_value( mi::IData* data, mi::Size index, const T& value)
212 {
214  if( c.is_valid_interface()) {
216  if( !d.is_valid_interface())
217  return -3;
218  return set_value( d.get(), value);
219  }
220  return -1;
221 }
222 
234 template<class T>
235 mi::Sint32 set_value( mi::IData* data, const char* key, const T& value)
236 {
238  if( c.is_valid_interface()) {
240  if( !d.is_valid_interface())
241  return -3;
242  return set_value( d.get(), value);
243  }
244  return -1;
245 }
246 
266 template<class T>
267 mi::Sint32 get_value( const mi::IData* data, T& value)
268 {
270  if( v.is_valid_interface()) {
271  v->get_value( value);
272  return 0;
273  }
274 // disable C4800: 'mi::Sint32' : forcing value to bool 'true' or 'false' (performance warning)
275 // disable C4800: 'mi::Uint32' : forcing value to bool 'true' or 'false' (performance warning)
276 #ifdef MI_COMPILER_MSC
277 #pragma warning( push )
278 #pragma warning( disable : 4800 )
279 #endif
281  if( e.is_valid_interface()) {
282  value = static_cast<T>( e->get_value());
283  return 0;
284  }
285 #ifdef MI_COMPILER_MSC
286 #pragma warning( pop )
287 #endif
288  return -1;
289 }
290 
294 inline mi::Sint32 get_value( const mi::IData* data, const char*& value)
295 {
297  if( i.is_valid_interface()) {
298  value = i->get_c_str();
299  return 0;
300  }
302  if( r.is_valid_interface()) {
303  value = r->get_reference_name();
304  return 0;
305  }
307  if( e.is_valid_interface()) {
308  value = e->get_value_by_name();
309  return 0;
310  }
311  return -1;
312 }
313 
317 inline mi::Sint32 get_value( const mi::IData* data, mi::base::Uuid& value)
318 {
320  if( u.is_valid_interface()) {
321  value = u->get_uuid();
322  return 0;
323  }
324  return -1;
325 }
326 
337 template <class T, Size DIM>
339 {
340  typedef typename mi::Vector_type_traits<T,DIM>::Interface_type Vector_interface_type;
341  mi::base::Handle<const Vector_interface_type> v( data->get_interface<Vector_interface_type>());
342  if( v.is_valid_interface()) {
343  value = v->get_value();
344  return 0;
345  }
346  return -1;
347 }
348 
359 template <class T, Size ROW, Size COL>
361 {
362  typedef typename mi::Matrix_type_traits<T,ROW,COL>::Interface_type Matrix_interface_type;
363  mi::base::Handle<const Matrix_interface_type> m( data->get_interface<Matrix_interface_type>());
364  if( m.is_valid_interface()) {
365  value = m->get_value();
366  return 0;
367  }
368  return -1;
369 }
370 
374 inline mi::Sint32 get_value( const mi::IData* data, mi::Color& value)
375 {
377  if( c.is_valid_interface()) {
378  value = c->get_value();
379  return 0;
380  }
382  if( c3.is_valid_interface()) {
383  value = c3->get_value();
384  return 0;
385  }
386  return -1;
387 }
388 
392 inline mi::Sint32 get_value( const mi::IData* data, mi::Spectrum& value)
393 {
395  if( s.is_valid_interface()) {
396  value = s->get_value();
397  return 0;
398  }
399  return -1;
400 }
401 
405 inline mi::Sint32 get_value( const mi::IData* data, mi::Bbox3& value)
406 {
408  if( b.is_valid_interface()) {
409  value = b->get_value();
410  return 0;
411  }
412  return -1;
413 }
414 
425 template<class T>
426 mi::Sint32 get_value( const mi::IData* data, mi::Size index, T& value)
427 {
429  if( c.is_valid_interface()) {
431  if( !d.is_valid_interface())
432  return -3;
433  return get_value( d.get(), value);
434  }
435  return -1;
436 }
437 
448 template<class T>
449 mi::Sint32 get_value( const mi::IData* data, const char* key, T& value)
450 {
452  if( c.is_valid_interface()) {
454  if( !d.is_valid_interface())
455  return -3;
456  return get_value( d.get(), value);
457  }
458  return -1;
459 }
460  // end group mi_neuray_types
462 
467 template<class T>
481  mi::neuraylib::IAttribute_set* attribute_set, const char* name, const T& value)
482 {
483  mi::base::Handle<mi::IData> data( attribute_set->edit_attribute<mi::IData>( name));
484  if( !data.is_valid_interface())
485  return -4;
486  return set_value( data.get(), value);
487 }
488 
503 template<class T>
505  mi::neuraylib::IAttribute_set* attribute_set, const char* name, mi::Size index, const T& value)
506 {
507  mi::base::Handle<mi::IData> data( attribute_set->edit_attribute<mi::IData>( name));
508  if( !data.is_valid_interface())
509  return -4;
510  return set_value( data.get(), index, value);
511 }
512 
527 template<class T>
529  mi::neuraylib::IAttribute_set* attribute_set, const char* name, const char* key, const T& value)
530 {
531  mi::base::Handle<mi::IData> data( attribute_set->edit_attribute<mi::IData>( name));
532  if( !data.is_valid_interface())
533  return -4;
534  return set_value( data.get(), key, value);
535 }
536 
548 template<class T>
550  const mi::neuraylib::IAttribute_set* attribute_set, const char* name, T& value)
551 {
552  mi::base::Handle<const mi::IData> data( attribute_set->access_attribute<mi::IData>( name));
553  if( !data.is_valid_interface())
554  return -4;
555  return get_value( data.get(), value);
556 }
557 
571 template<class T>
573  const mi::neuraylib::IAttribute_set* attribute_set, const char* name, mi::Size index, T& value)
574 {
575  mi::base::Handle<const mi::IData> data( attribute_set->access_attribute<mi::IData>( name));
576  if( !data.is_valid_interface())
577  return -4;
578  return get_value( data.get(), index, value);
579 }
580 
594 template<class T>
596  const mi::neuraylib::IAttribute_set* attribute_set, const char* name, const char* key, T& value)
597 {
598  mi::base::Handle<const mi::IData> data( attribute_set->access_attribute<mi::IData>( name));
599  if( !data.is_valid_interface())
600  return -4;
601  return get_value( data.get(), key, value);
602 }
603  // end group mi_neuray_types
605 
606 } // namespace mi
607 
608 #endif // MI_NEURAYLIB_SET_GET_H