MDL SDK API nvidia_logo_transpbg.gif Up
ivalue.h
Go to the documentation of this file.
1/***************************************************************************************************
2 * Copyright 2024 NVIDIA Corporation. All rights reserved.
3 **************************************************************************************************/
6
7#ifndef MI_NEURAYLIB_IVALUE_H
8#define MI_NEURAYLIB_IVALUE_H
9
10#include <mi/base/handle.h>
11#include <mi/math/color.h>
12#include <mi/math/matrix.h>
13#include <mi/math/spectrum.h>
14#include <mi/math/vector.h>
15#include <mi/neuraylib/itype.h>
16
17namespace mi {
18
19namespace neuraylib {
20
25class IAnnotation;
26class IAnnotation_block;
27
31class IValue : public
32 mi::base::Interface_declare<0xbf837f4a,0x9034,0x4f32,0xaf,0x5c,0x75,0xb3,0x67,0x64,0x53,0x23>
33{
34public:
36 enum Kind {
67 // Undocumented, for alignment only.
68 VK_FORCE_32_BIT = 0xffffffffU
69 };
70
72 virtual Kind get_kind() const = 0;
73
75 virtual const IType* get_type() const = 0;
76
78 template <class T>
79 const T* get_type() const
80 {
81 const IType* ptr_type = get_type();
82 if( !ptr_type)
83 return 0;
84 const T* ptr_T = static_cast<const T*>( ptr_type->get_interface( typename T::IID()));
85 ptr_type->release();
86 return ptr_T;
87 }
88};
89
90mi_static_assert( sizeof( IValue::Kind) == sizeof( Uint32));
91
93class IValue_atomic : public
94 mi::base::Interface_declare<0xf2413c80,0x8e71,0x4974,0xaa,0xf2,0x60,0xd5,0xe2,0x94,0x9d,0x3e,
95 neuraylib::IValue>
96{
97public:
99 const IType_atomic* get_type() const = 0;
100};
101
103class IValue_bool : public
104 mi::base::Interface_declare<0xaf253a14,0x1f04,0x4b67,0xba,0x70,0x7b,0x01,0x05,0xfb,0xc8,0xf5,
105 neuraylib::IValue_atomic>
106{
107public:
109 static const Kind s_kind = VK_BOOL;
110
112 const IType_bool* get_type() const = 0;
113
115 virtual bool get_value() const = 0;
116
118 virtual void set_value( bool value) = 0;
119};
120
122class IValue_int : public
123 mi::base::Interface_declare<0x91e6f145,0x280d,0x4d68,0x95,0x57,0xe1,0xd0,0x9c,0xd2,0x5c,0x74,
124 neuraylib::IValue_atomic>
125{
126public:
128 static const Kind s_kind = VK_INT;
129
131 const IType_int* get_type() const = 0;
132
134 virtual Sint32 get_value() const = 0;
135
137 virtual void set_value( Sint32 value) = 0;
138};
139
141class IValue_enum : public
142 mi::base::Interface_declare<0xdc876204,0x8a97,0x40e9,0xb9,0xb6,0xca,0xdc,0xdd,0x60,0x1f,0xbf,
143 neuraylib::IValue_atomic>
144{
145public:
147 static const Kind s_kind = VK_ENUM;
148
150 virtual const IType_enum* get_type() const = 0;
151
153 virtual Sint32 get_value() const = 0;
154
156 virtual Size get_index() const = 0;
157
163 virtual Sint32 set_value( Sint32 value) = 0;
164
168 virtual Sint32 set_index( Size index) = 0;
169
171 virtual const char* get_name() const = 0;
172
176 virtual Sint32 set_name( const char* name) = 0;
177};
178
180class IValue_float : public
181 mi::base::Interface_declare<0x21f07151,0x74b5,0x4296,0x90,0x29,0xc7,0xde,0x49,0x38,0x2a,0xbc,
182 neuraylib::IValue_atomic>
183{
184public:
186 static const Kind s_kind = VK_FLOAT;
187
189 const IType_float* get_type() const = 0;
190
192 virtual Float32 get_value() const = 0;
193
195 virtual void set_value( Float32 value) = 0;
196};
197
199class IValue_double : public
200 mi::base::Interface_declare<0xbdc84417,0x3e83,0x4bab,0x90,0xb1,0x9f,0x57,0xed,0x7b,0x15,0x03,
201 neuraylib::IValue_atomic>
202{
203public:
205 static const Kind s_kind = VK_DOUBLE;
206
208 const IType_double* get_type() const = 0;
209
211 virtual Float64 get_value() const = 0;
212
214 virtual void set_value( Float64 value) = 0;
215};
216
218class IValue_string : public
219 mi::base::Interface_declare<0x64b28506,0x8675,0x4724,0xa1,0x0d,0xc6,0xf2,0x35,0x46,0x26,0x39,
220 neuraylib::IValue_atomic>
221{
222public:
224 static const Kind s_kind = VK_STRING;
225
227 const IType_string* get_type() const = 0;
228
230 virtual const char* get_value() const = 0;
231
233 virtual void set_value( const char* value) = 0;
234};
235
239 mi::base::Interface_declare<0x1fe80d3d,0xe79e,0x4bdb,0xb6,0x30,0xe3,0x36,0x31,0xa4,0x1e,0x39,
240 neuraylib::IValue_string>
241{
242public:
245 virtual const char* get_original_value() const = 0;
246};
247
249class IValue_compound : public
250 mi::base::Interface_declare<0xdabc8fe3,0x5c70,0x4ef0,0xa2,0xf7,0x34,0x30,0xb5,0x67,0xdc,0x75,
251 neuraylib::IValue>
252{
253public:
255 virtual const IType_compound* get_type() const = 0;
256
258 virtual Size get_size() const = 0;
259
261 virtual const IValue* get_value( Size index) const = 0;
262
264 template <class T>
265 const T* get_value( Size index) const
266 {
267 const IValue* ptr_value = get_value( index);
268 if( !ptr_value)
269 return 0;
270 const T* ptr_T = static_cast<const T*>( ptr_value->get_interface( typename T::IID()));
271 ptr_value->release();
272 return ptr_T;
273 }
274
276 virtual IValue* get_value( Size index) = 0;
277
279 template <class T>
280 T* get_value( Size index)
281 {
282 IValue* ptr_value = get_value( index);
283 if( !ptr_value)
284 return 0;
285 T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
286 ptr_value->release();
287 return ptr_T;
288 }
289
299 virtual Sint32 set_value( Size index, IValue* value) = 0;
300};
301
306class IValue_vector : public
307 mi::base::Interface_declare<0xf5d09fc3,0xd783,0x4571,0x8d,0x59,0x41,0xb1,0xff,0xd3,0x91,0x49,
308 neuraylib::IValue_compound>
309{
310public:
312 static const Kind s_kind = VK_VECTOR;
313
315 virtual const IType_vector* get_type() const = 0;
316
318 virtual const IValue_atomic* get_value( Size index) const = 0;
319
321 template <class T>
322 const T* get_value( Size index) const
323 {
324 const IValue_atomic* ptr_value = get_value( index);
325 if( !ptr_value)
326 return 0;
327 const T* ptr_T = static_cast<const T*>( ptr_value->get_interface( typename T::IID()));
328 ptr_value->release();
329 return ptr_T;
330 }
331
333 virtual IValue_atomic* get_value( Size index) = 0;
334
336 template <class T>
337 T* get_value( Size index)
338 {
339 IValue_atomic* ptr_value = get_value( index);
340 if( !ptr_value)
341 return 0;
342 T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
343 ptr_value->release();
344 return ptr_T;
345 }
346};
347
352class IValue_matrix : public
353 mi::base::Interface_declare<0x9ee95da6,0x2cd6,0x4168,0x89,0xea,0x92,0x10,0x57,0xda,0xe6,0xdc,
354 neuraylib::IValue_compound>
355{
356public:
358 static const Kind s_kind = VK_MATRIX;
359
361 virtual const IType_matrix* get_type() const = 0;
362
364 virtual const IValue_vector* get_value( Size index) const = 0;
365
367 virtual IValue_vector* get_value( Size index) = 0;
368};
369
371class IValue_color : public
372 mi::base::Interface_declare<0x3bb9bf46,0x1cbb,0x4460,0xbe,0x27,0x10,0xf5,0x71,0x61,0x96,0xa2,
373 neuraylib::IValue_compound>
374{
375public:
377 static const Kind s_kind = VK_COLOR;
378
380 virtual const IType_color* get_type() const = 0;
381
383 virtual const IValue_float* get_value( Size index) const = 0;
384
386 virtual IValue_float* get_value( Size index) = 0;
387
394 virtual Sint32 set_value( Size index, IValue_float* value) = 0;
395
397};
398
400class IValue_array : public
401 mi::base::Interface_declare<0xa17c5f57,0xa647,0x41c4,0x86,0x2f,0x4c,0x0d,0xe1,0x30,0x08,0xfc,
402 neuraylib::IValue_compound>
403{
404public:
406 static const Kind s_kind = VK_ARRAY;
407
409 virtual const IType_array* get_type() const = 0;
410
417 virtual Sint32 set_size( Size size) = 0;
418};
419
421class IValue_struct : public
422 mi::base::Interface_declare<0xcbe089ce,0x4aea,0x474d,0x94,0x5f,0x52,0x13,0xef,0x01,0xce,0x81,
423 neuraylib::IValue_compound>
424{
425public:
427 static const Kind s_kind = VK_STRUCT;
428
430 virtual const IType_struct* get_type() const = 0;
431
436 virtual const IValue* get_field( const char* name) const = 0;
437
442 template <class T>
443 const T* get_field( const char* name) const
444 {
445 const IValue* ptr_value = get_field( name);
446 if( !ptr_value)
447 return 0;
448 T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
449 ptr_value->release();
450 return ptr_T;
451 }
452
457 virtual IValue* get_field( const char* name) = 0;
458
463 template <class T>
464 T* get_field( const char* name)
465 {
466 IValue* ptr_value = get_field( name);
467 if( !ptr_value)
468 return 0;
469 T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
470 ptr_value->release();
471 return ptr_T;
472 }
473
483 virtual Sint32 set_field( const char* name, IValue* value) = 0;
484};
485
487class IValue_resource : public
488 mi::base::Interface_declare<0x479bb10c,0xd444,0x426c,0x83,0xab,0x26,0xdf,0xf6,0x1d,0x6f,0xd7,
489 neuraylib::IValue>
490{
491public:
493 virtual const IType_resource* get_type() const = 0;
494
498 virtual const char* get_value() const = 0;
499
510 virtual Sint32 set_value( const char* value) = 0;
511
516 virtual const char* get_file_path() const = 0;
517
518 virtual const char* get_owner_module() const = 0;
519};
520
522class IValue_texture : public
523 mi::base::Interface_declare<0xf2a03651,0x8883,0x4ba4,0xb9,0xa9,0xe6,0x87,0x34,0x3a,0xb3,0xb8,
524 neuraylib::IValue_resource>
525{
526public:
528 static const Kind s_kind = VK_TEXTURE;
529
531 virtual const IType_texture* get_type() const = 0;
532
537 virtual Float32 get_gamma() const = 0;
538
540 virtual const char* get_selector() const = 0;
541};
542
545 mi::base::Interface_declare<0xd7c9ffbd,0xb5e4,0x4bf4,0x90,0xd0,0xe9,0x75,0x4d,0x6d,0x49,0x07,
546 neuraylib::IValue_resource>
547{
548public:
551
553 virtual const IType_light_profile* get_type() const = 0;
554};
555
558 mi::base::Interface_declare<0x31a55244,0x415c,0x4b4d,0xa7,0x86,0x2f,0x21,0x9c,0xb8,0xb9,0xff,
559 neuraylib::IValue_resource>
560{
561public:
564
566 virtual const IType_bsdf_measurement* get_type() const = 0;
567};
568
570class IValue_invalid_df : public
571 mi::base::Interface_declare<0x1588b6fa,0xa143,0x4bac,0xa0,0x32,0x06,0xbd,0x9e,0x7f,0xb6,0xe5,
572 neuraylib::IValue>
573{
574public:
576 static const Kind s_kind = VK_INVALID_DF;
577
579 const IType_reference* get_type() const = 0;
580};
581
585class IValue_list : public
586 mi::base::Interface_declare<0x8027a5e5,0x4e25,0x410c,0xbb,0xce,0x84,0xb4,0x88,0x8b,0x03,0x46>
587{
588public:
590 virtual Size get_size() const = 0;
591
593 virtual Size get_index( const char* name) const = 0;
594
596 virtual const char* get_name( Size index) const = 0;
597
599 virtual const IValue* get_value( Size index) const = 0;
600
602 template <class T>
603 const T* get_value( Size index) const
604 {
605 const IValue* ptr_value = get_value( index);
606 if( !ptr_value)
607 return 0;
608 const T* ptr_T = static_cast<const T*>( ptr_value->get_interface( typename T::IID()));
609 ptr_value->release();
610 return ptr_T;
611 }
612
614 virtual const IValue* get_value( const char* name) const = 0;
615
617 template <class T>
618 const T* get_value( const char* name) const
619 {
620 const IValue* ptr_value = get_value( name);
621 if( !ptr_value)
622 return 0;
623 const T* ptr_T = static_cast<const T*>( ptr_value->get_interface( typename T::IID()));
624 ptr_value->release();
625 return ptr_T;
626 }
627
634 virtual Sint32 set_value( Size index, const IValue* value) = 0;
635
642 virtual Sint32 set_value( const char* name, const IValue* value) = 0;
643
650 virtual Sint32 add_value( const char* name, const IValue* value) = 0;
651};
652
658class IValue_factory : public
659 mi::base::Interface_declare<0x82595c0d,0x3687,0x4b45,0xa3,0x38,0x42,0x20,0x02,0xea,0x3f,0x9b>
660{
661public:
663
664
666 virtual IType_factory* get_type_factory() const = 0;
667
669
671
673 virtual IValue_bool* create_bool( bool value = false) const = 0;
674
676 virtual IValue_int* create_int( Sint32 value = 0) const = 0;
677
679 virtual IValue_enum* create_enum( const IType_enum* type, Size index = 0) const = 0;
680
682 virtual IValue_float* create_float( Float32 value = 0.0f) const = 0;
683
685 virtual IValue_double* create_double( Float64 value = 0.0) const = 0;
686
690 virtual IValue_string* create_string( const char* value = "") const = 0;
691
693 virtual IValue_vector* create_vector( const IType_vector* type) const = 0;
694
696 virtual IValue_matrix* create_matrix( const IType_matrix* type) const = 0;
697
700 Float32 red = 0.0f,
701 Float32 green = 0.0f,
702 Float32 blue = 0.0f) const = 0;
703
705 virtual IValue_array* create_array( const IType_array* type) const = 0;
706
708 virtual IValue_struct* create_struct( const IType_struct* type) const = 0;
709
711 virtual IValue_texture* create_texture( const IType_texture* type, const char* value) const = 0;
712
714 virtual IValue_light_profile* create_light_profile( const char* value) const = 0;
715
717 virtual IValue_bsdf_measurement* create_bsdf_measurement( const char* value) const = 0;
718
720 virtual IValue_invalid_df* create_invalid_df( const IType_reference* type) const = 0;
721
723 virtual IValue* create( const IType* type) const = 0;
724
726 template <class T>
727 T* create( const IType* type) const
728 {
729 IValue* ptr_value = create( type);
730 if( !ptr_value)
731 return 0;
732 T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
733 ptr_value->release();
734 return ptr_T;
735 }
736
741 virtual IValue* create( const IAnnotation* annotation) const = 0;
742
747 template <class T>
748 T* create( const IAnnotation* annotation) const
749 {
750 IValue* ptr_value = create( annotation);
751 if( !ptr_value)
752 return 0;
753 T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
754 ptr_value->release();
755 return ptr_T;
756 }
757
766 virtual IValue* create( const IType* type, const IAnnotation_block* annotation_block) const = 0;
767
776 template <class T>
777 T* create( const IType* type, const IAnnotation_block* annotation_block) const
778 {
779 IValue* ptr_value = create( type, annotation_block);
780 if( !ptr_value)
781 return 0;
782 T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
783 ptr_value->release();
784 return ptr_T;
785 }
786
788 virtual IValue_list* create_value_list() const = 0;
789
791
793
797 virtual IValue* clone( const IValue* value) const = 0;
798
802 template <class T>
803 T* clone( const T* value) const
804 {
805 IValue* ptr_value = clone( static_cast<const IValue*>( value));
806 if( !ptr_value)
807 return 0;
808 T* ptr_T = static_cast<T*>( ptr_value->get_interface( typename T::IID()));
809 ptr_value->release();
810 return ptr_T;
811 }
812
816 virtual IValue_list* clone( const IValue_list* value_list) const = 0;
817
819
821
844 const IValue* lhs, const IValue* rhs, Float64 epsilon = 0.0) const = 0;
845
861 const IValue_list* lhs, const IValue_list* rhs, Float64 epsilon = 0.0) const = 0;
862
864
866
877 virtual const IString* dump( const IValue* value, const char* name, Size depth = 0) const = 0;
878
888 virtual const IString* dump(
889 const IValue_list* list, const char* name, Size depth = 0) const = 0;
890
892};
893
924template<class T>
926{
929 if( value_int) {
930 value_int->set_value( v);
931 return 0;
932 }
933
936 if( value_enum) {
937 if( value_enum->set_value( v) != 0)
938 return -2;
939 return 0;
940 }
941
942 return -1;
943}
944
948inline mi::Sint32 set_value( mi::neuraylib::IValue* value, const bool& v)
949{
952 if( value_bool) {
953 value_bool->set_value( v);
954 return 0;
955 }
956
957 return -1;
958}
959
964{
967 if( value_float) {
968 value_float->set_value( v);
969 return 0;
970 }
971
974 if( value_double) {
975 value_double->set_value( v);
976 return 0;
977 }
978
979 return -1;
980}
981
986{
989 if( value_float) {
990 value_float->set_value( static_cast<mi::Float32>( v));
991 return 0;
992 }
993
996 if( value_double) {
997 value_double->set_value( v);
998 return 0;
999 }
1000
1001 return -1;
1002}
1003
1008inline mi::Sint32 set_value( mi::neuraylib::IValue* value, const char* v)
1009{
1012 if( value_enum) {
1013 if( value_enum->set_name( v) != 0)
1014 return -2;
1015 return 0;
1016 }
1017
1020 if( value_string) {
1021 value_string->set_value( v);
1022 return 0;
1023 }
1024
1027 if( value_resource) {
1028 if( value_resource->set_value( v) != 0)
1029 return -2;
1030 return 0;
1031 }
1032
1033 return -1;
1034}
1035
1040template<class T, Size DIM>
1042{
1045 if( value_vector) {
1046 if( value_vector->get_size() != DIM)
1047 return -1;
1048 for( Size i = 0; i < DIM; ++i) {
1049 mi::base::Handle<mi::neuraylib::IValue> component( value_vector->get_value( i));
1050 mi::Sint32 result = set_value( component.get(), v[i]);
1051 if( result != 0)
1052 return result;
1053 }
1054 return 0;
1055 }
1056
1057 return -1;
1058}
1059
1069template<class T, Size ROW, Size COL>
1071{
1074 if( value_matrix) {
1075 if( value_matrix->get_size() != ROW)
1076 return -1;
1077 for( Size i = 0; i < ROW; ++i) {
1078 mi::base::Handle<mi::neuraylib::IValue_vector> column( value_matrix->get_value( i));
1079 if( column->get_size() != COL)
1080 return -1;
1081 for( Size j = 0; j < COL; ++j) {
1082 mi::base::Handle<mi::neuraylib::IValue> element( column->get_value( j));
1083 mi::Sint32 result = set_value( element.get(), v[i][j]);
1084 if( result != 0)
1085 return result;
1086 }
1087 }
1088 return 0;
1089 }
1090
1091 return -1;
1092}
1093
1098{
1101 if( value_color) {
1102 mi::base::Handle<mi::neuraylib::IValue_float> red ( value_color->get_value( 0));
1103 red ->set_value( v.r);
1104 mi::base::Handle<mi::neuraylib::IValue_float> green( value_color->get_value( 1));
1105 green->set_value( v.g);
1106 mi::base::Handle<mi::neuraylib::IValue_float> blue ( value_color->get_value( 2));
1107 blue ->set_value( v.b);
1108 return 0;
1109 }
1110
1111 return -1;
1112}
1113
1119{
1122 if( value_color) {
1123 mi::base::Handle<mi::neuraylib::IValue_float> red ( value_color->get_value( 0));
1124 red ->set_value( v[0]);
1125 mi::base::Handle<mi::neuraylib::IValue_float> green( value_color->get_value( 1));
1126 green->set_value( v[1]);
1127 mi::base::Handle<mi::neuraylib::IValue_float> blue ( value_color->get_value( 2));
1128 blue ->set_value( v[2]);
1129 return 0;
1130 }
1131
1132 return -1;
1133}
1134
1148template<class T>
1150{
1153 if( value_compound) {
1154 mi::base::Handle<mi::neuraylib::IValue> component( value_compound->get_value( index));
1155 if( !component)
1156 return -3;
1157 return set_value( component.get(), v);
1158 }
1159
1160 return -1;
1161}
1162
1176template<class T>
1177mi::Sint32 set_value( mi::neuraylib::IValue* value, const char* name, const T& v)
1178{
1181 if( value_struct) {
1182 mi::base::Handle<mi::neuraylib::IValue> field( value_struct->get_field( name));
1183 if( !field)
1184 return -3;
1185 return set_value( field.get(), v);
1186 }
1187
1188 return -1;
1189}
1190
1204template<class T>
1206{
1209 if( value_array) {
1210 if( value_array->get_size() != n)
1211 return -5;
1212 for( mi::Size i = 0; i < n; ++i) {
1213 mi::base::Handle<mi::neuraylib::IValue> element( value_array->get_value( i));
1214 mi::Sint32 result = set_value( element.get(), v[i]);
1215 if( result != 0)
1216 return result;
1217 }
1218 return 0;
1219 }
1220
1221 return -1;
1222}
1223
1253template<class T>
1255{
1258 if( value_int) {
1259 v = value_int->get_value();
1260 return 0;
1261 }
1262
1265 if( value_enum) {
1266 v = value_enum->get_value();
1267 return 0;
1268 }
1269
1270 return -1;
1271}
1272
1276inline mi::Sint32 get_value( const mi::neuraylib::IValue* value, bool& v)
1277{
1280 if( value_bool) {
1281 v = value_bool->get_value();
1282 return 0;
1283 }
1284
1285 return -1;
1286}
1287
1292{
1295 if( value_float) {
1296 v = value_float->get_value();
1297 return 0;
1298 }
1299
1302 if( value_double) {
1303 v = static_cast<mi::Float32>( value_double->get_value());
1304 return 0;
1305 }
1306
1307 return -1;
1308}
1309
1314{
1317 if( value_float) {
1318 v = value_float->get_value();
1319 return 0;
1320 }
1321
1324 if( value_double) {
1325 v = value_double->get_value();
1326 return 0;
1327 }
1328
1329 return -1;
1330}
1331
1336inline mi::Sint32 get_value( const mi::neuraylib::IValue* value, const char*& v)
1337{
1340 if( value_enum) {
1341 v = value_enum->get_name();
1342 return 0;
1343 }
1344
1347 if( value_string) {
1348 v = value_string->get_value();
1349 return 0;
1350 }
1351
1354 if( value_resource) {
1355 v = value_resource->get_value();
1356 return 0;
1357 }
1358
1359 return -1;
1360}
1361
1366template <class T, Size DIM>
1368{
1371 if( value_vector) {
1372 if( value_vector->get_size() != DIM)
1373 return -1;
1374 for( Size i = 0; i < DIM; ++i) {
1375 mi::base::Handle<const mi::neuraylib::IValue> component( value_vector->get_value( i));
1376 mi::Sint32 result = get_value( component.get(), v[i]);
1377 if( result != 0)
1378 return result;
1379 }
1380 return 0;
1381 }
1382
1383 return -1;
1384}
1385
1395template <class T, Size ROW, Size COL>
1397{
1400 if( value_matrix) {
1401 if( value_matrix->get_size() != ROW)
1402 return -1;
1403 for( Size i = 0; i < ROW; ++i) {
1405 value_matrix->get_value( i));
1406 if( column->get_size() != COL)
1407 return -1;
1408 for( Size j = 0; j < COL; ++j) {
1409 mi::base::Handle<const mi::neuraylib::IValue> element( column->get_value( j));
1410 mi::Sint32 result = get_value( element.get(), v[i][j]);
1411 if( result != 0)
1412 return result;
1413 }
1414 }
1415 return 0;
1416 }
1417
1418 return -1;
1419}
1420
1425{
1428 if( value_color) {
1429 mi::base::Handle<const mi::neuraylib::IValue_float> red ( value_color->get_value( 0));
1430 v.r = red ->get_value();
1431 mi::base::Handle<const mi::neuraylib::IValue_float> green( value_color->get_value( 1));
1432 v.g = green->get_value();
1433 mi::base::Handle<const mi::neuraylib::IValue_float> blue ( value_color->get_value( 2));
1434 v.b = blue ->get_value();
1435 v.a = 1.0f;
1436 return 0;
1437 }
1438
1439 return -1;
1440}
1441
1447{
1450 if( value_color) {
1451 mi::base::Handle<const mi::neuraylib::IValue_float> red ( value_color->get_value( 0));
1452 v[0] = red ->get_value();
1453 mi::base::Handle<const mi::neuraylib::IValue_float> green( value_color->get_value( 1));
1454 v[1] = green->get_value();
1455 mi::base::Handle<const mi::neuraylib::IValue_float> blue ( value_color->get_value( 2));
1456 v[2] = blue ->get_value();
1457 return 0;
1458 }
1459
1460 return -1;
1461}
1462
1475template<class T>
1477{
1480 if( value_compound) {
1481 mi::base::Handle<const mi::neuraylib::IValue> component( value_compound->get_value( index));
1482 if( !component)
1483 return -3;
1484 return get_value( component.get(), v);
1485 }
1486
1487 return -1;
1488}
1489
1502template<class T>
1503mi::Sint32 get_value( const mi::neuraylib::IValue* value, const char* name, T& v)
1504{
1507 if( value_struct) {
1508 mi::base::Handle<const mi::neuraylib::IValue> field( value_struct->get_field( name));
1509 if( !field)
1510 return -3;
1511 return get_value( field.get(), v);
1512 }
1513
1514 return -1;
1515}
1516
1529template<class T>
1531{
1534 if( value_array) {
1535 if( value_array->get_size() != n)
1536 return -5;
1537 for( mi::Size i = 0; i < n; ++i) {
1538 mi::base::Handle<const mi::neuraylib::IValue> element( value_array->get_value( i));
1539 mi::Sint32 result = get_value( element.get(), v[i]);
1540 if( result != 0)
1541 return result;
1542 }
1543 return 0;
1544 }
1545
1546 return -1;
1547}
1548
1549 // end group mi_neuray_mdl_types
1551
1552} // namespace neuraylib
1553
1554} // namespace mi
1555
1556#endif // MI_NEURAYLIB_IVALUE_H
A simple string class.
Definition: istring.h:22
Handle class template for interfaces, automatizing the lifetime control via reference counting.
Definition: handle.h:113
Mixin class template for deriving new interface declarations.
Definition: interface_declare.h:43
Standard RGBA color class with floating point elements and operations.
Definition: color.h:81
NxM-dimensional matrix class template of fixed dimensions.
Definition: matrix.h:367
Spectrum with floating point elements and operations.
Definition: spectrum.h:53
Fixed-size math vector class template with generic operations.
Definition: vector.h:286
An annotation block is an array of annotations.
Definition: iexpression.h:575
An annotation is similar to a direct call expression, but without return type.
Definition: iexpression.h:552
The type of kind array.
Definition: itype.h:452
An atomic type.
Definition: itype.h:257
The type of kind bool.
Definition: itype.h:264
The type of kind bsdf_measurement.
Definition: itype.h:588
The type of kind color.
Definition: itype.h:442
A compound type.
Definition: itype.h:383
The type of kind double.
Definition: itype.h:363
A type of kind enum.
Definition: itype.h:284
The interface for creating types.
Definition: itype.h:716
The type of kind float.
Definition: itype.h:353
The type of kind int.
Definition: itype.h:274
The type of kind light_profile.
Definition: itype.h:578
The type of kind matrix.
Definition: itype.h:427
The reference types.
Definition: itype.h:538
A string valued resource type.
Definition: itype.h:545
The type of kind string.
Definition: itype.h:373
The type of kind struct.
Definition: itype.h:475
The type of kind texture.
Definition: itype.h:552
The type of kind vector.
Definition: itype.h:399
The interface to MDL types.
Definition: itype.h:151
A value of type array.
Definition: ivalue.h:403
virtual Sint32 set_size(Size size)=0
Sets the size for deferred-sized arrays.
virtual const IType_array * get_type() const =0
Returns the type of this value.
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:406
An atomic value.
Definition: ivalue.h:96
const IType_atomic * get_type() const =0
Returns the type of this value.
A value of type boolean.
Definition: ivalue.h:106
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:109
virtual bool get_value() const =0
Returns the value.
virtual void set_value(bool value)=0
Sets the value.
const IType_bool * get_type() const =0
Returns the type of this value.
A BSDF measurement value.
Definition: ivalue.h:560
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:563
virtual const IType_bsdf_measurement * get_type() const =0
Returns the type of this value.
A value of type color.
Definition: ivalue.h:374
virtual const IValue_float * get_value(Size index) const =0
Returns the value at index, or NULL if index is out of bounds.
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:377
virtual IValue_float * get_value(Size index)=0
Returns the value at index, or NULL if index is out of bounds.
virtual Sint32 set_value(Size index, IValue_float *value)=0
Sets the value at index.
virtual const IType_color * get_type() const =0
Returns the type of this value.
A compound value.
Definition: ivalue.h:252
virtual Size get_size() const =0
Returns the number of components in this compound value.
virtual const IValue * get_value(Size index) const =0
Returns the value at index, or NULL if index is out of bounds.
virtual IValue * get_value(Size index)=0
Returns the value at index, or NULL if index is out of bounds.
T * get_value(Size index)
Returns the value at index, or NULL if index is out of bounds.
Definition: ivalue.h:280
virtual const IType_compound * get_type() const =0
Returns the type of this value.
const T * get_value(Size index) const
Returns the value at index, or NULL if index is out of bounds.
Definition: ivalue.h:265
virtual Sint32 set_value(Size index, IValue *value)=0
Sets the value at index.
A value of type double.
Definition: ivalue.h:202
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:205
virtual Float64 get_value() const =0
Returns the value.
virtual void set_value(Float64 value)=0
Sets the value.
const IType_double * get_type() const =0
Returns the type of this value.
A value of type enum.
Definition: ivalue.h:144
virtual const IType_enum * get_type() const =0
Returns the type of this value.
virtual Sint32 set_name(const char *name)=0
Sets the enum value by string representation in linear time.
virtual Sint32 set_value(Sint32 value)=0
Sets the enum value by integer in linear time.
virtual Sint32 get_value() const =0
Returns the (integer) value of this enum value.
virtual const char * get_name() const =0
Returns the string representation of this enum value.
virtual Sint32 set_index(Size index)=0
Sets the enum value by index.
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:147
virtual Size get_index() const =0
Returns the index of this enum value.
The interface for creating values.
Definition: ivalue.h:660
virtual IValue_texture * create_texture(const IType_texture *type, const char *value) const =0
Creates a new texture value, or returns NULL in case of errors.
virtual IValue_matrix * create_matrix(const IType_matrix *type) const =0
Creates a new value of type matrix, or returns NULL in case of errors.
virtual const IString * dump(const IValue *value, const char *name, Size depth=0) const =0
Returns a textual representation of a value.
virtual const IString * dump(const IValue_list *list, const char *name, Size depth=0) const =0
Returns a textual representation of a value list.
virtual IValue * create(const IType *type, const IAnnotation_block *annotation_block) const =0
Creates a value observing a potentially present range annotation.
virtual IValue_list * clone(const IValue_list *value_list) const =0
Clones the given value list.
virtual IValue_string * create_string(const char *value="") const =0
Creates a new value of type string.
virtual Sint32 compare(const IValue_list *lhs, const IValue_list *rhs, Float64 epsilon=0.0) const =0
Compares two instances of mi::neuraylib::IValue_list.
virtual IValue_struct * create_struct(const IType_struct *type) const =0
Creates a new value of type struct, or returns NULL in case of errors.
virtual IValue_invalid_df * create_invalid_df(const IType_reference *type) const =0
Creates a new invalid distribution function value.
T * create(const IType *type) const
Creates a default-constructed value of the given type.
Definition: ivalue.h:727
virtual IValue * clone(const IValue *value) const =0
Clones the given value.
virtual IValue * create(const IAnnotation *annotation) const =0
Creates a value observing the range of an "::anno::soft_range()" or an "::anno::hard_range()" annotat...
virtual Sint32 compare(const IValue *lhs, const IValue *rhs, Float64 epsilon=0.0) const =0
Compares two instances of mi::neuraylib::IValue.
T * clone(const T *value) const
Clones the given value.
Definition: ivalue.h:803
T * create(const IType *type, const IAnnotation_block *annotation_block) const
Creates a value observing a potentially present range annotation.
Definition: ivalue.h:777
virtual IValue_bool * create_bool(bool value=false) const =0
Creates a new value of type boolean.
virtual IValue_list * create_value_list() const =0
Creates a new value list.
virtual IValue_enum * create_enum(const IType_enum *type, Size index=0) const =0
Creates a new value of type enum, or returns NULL in case of errors.
virtual IValue_bsdf_measurement * create_bsdf_measurement(const char *value) const =0
Creates a new BSDF measurement value, or returns NULL in case of errors.
virtual IValue_vector * create_vector(const IType_vector *type) const =0
Creates a new value of type vector, or returns NULL in case of errors.
virtual IValue_array * create_array(const IType_array *type) const =0
Creates a new value of type array, or returns NULL in case of errors.
virtual IValue_int * create_int(Sint32 value=0) const =0
Creates a new value of type integer.
virtual IValue_float * create_float(Float32 value=0.0f) const =0
Creates a new value of type float.
virtual IValue_light_profile * create_light_profile(const char *value) const =0
Creates a new light profile value, or returns NULL in case of errors.
virtual IType_factory * get_type_factory() const =0
Returns the type factory associated with this value factory.
T * create(const IAnnotation *annotation) const
Creates a value observing the range of an "::anno::soft_range()" or an "::anno::hard_range()" annotat...
Definition: ivalue.h:748
virtual IValue * create(const IType *type) const =0
Creates a default-constructed value of the given type.
virtual IValue_color * create_color(Float32 red=0.0f, Float32 green=0.0f, Float32 blue=0.0f) const =0
Creates a new value of type color.
virtual IValue_double * create_double(Float64 value=0.0) const =0
Creates a new value of type double.
A value of type float.
Definition: ivalue.h:183
const IType_float * get_type() const =0
Returns the type of this value.
virtual Float32 get_value() const =0
Returns the value.
virtual void set_value(Float32 value)=0
Sets the value.
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:186
A value of type integer.
Definition: ivalue.h:125
virtual Sint32 get_value() const =0
Returns the value.
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:128
virtual void set_value(Sint32 value)=0
Sets the value.
const IType_int * get_type() const =0
Returns the type of this value.
An invalid distribution function value.
Definition: ivalue.h:573
const IType_reference * get_type() const =0
Returns the type of this value.
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:576
A light profile value.
Definition: ivalue.h:547
virtual const IType_light_profile * get_type() const =0
Returns the type of this value.
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:550
An ordered collection of values identified by name or index.
Definition: ivalue.h:587
virtual Size get_index(const char *name) const =0
Returns the index for the given name, or -1 if there is no such value.
const T * get_value(Size index) const
Returns the value for index, or NULL if there is no such value.
Definition: ivalue.h:603
const T * get_value(const char *name) const
Returns the value for name, or NULL if there is no such value.
Definition: ivalue.h:618
virtual Sint32 set_value(Size index, const IValue *value)=0
Sets a value at a given index.
virtual const char * get_name(Size index) const =0
Returns the name for the given index, or NULL if there is no such value.
virtual const IValue * get_value(const char *name) const =0
Returns the value for name, or NULL if there is no such value.
virtual Size get_size() const =0
Returns the number of elements.
virtual const IValue * get_value(Size index) const =0
Returns the value for index, or NULL if there is no such value.
virtual Sint32 add_value(const char *name, const IValue *value)=0
Adds a value at the end of the list.
virtual Sint32 set_value(const char *name, const IValue *value)=0
Sets a value identified by name.
A value of type matrix.
Definition: ivalue.h:355
virtual const IValue_vector * get_value(Size index) const =0
Returns the value at index, or NULL if index is out of bounds.
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:358
virtual const IType_matrix * get_type() const =0
Returns the type of this value.
virtual IValue_vector * get_value(Size index)=0
Returns the value at index, or NULL if index is out of bounds.
Base class for resource values.
Definition: ivalue.h:490
virtual const char * get_file_path() const =0
Returns the absolute MDL file path of the resource, or NULL if not known.
virtual const IType_resource * get_type() const =0
Returns the type of this value.
virtual const char * get_value() const =0
Returns the name of the DB element representing this resource.
virtual Sint32 set_value(const char *value)=0
Sets the name of the DB element representing this resource.
A value of type string which can be used to obtain the original, non-localized value of a localized s...
Definition: ivalue.h:241
virtual const char * get_original_value() const =0
Returns the original value of a localized string.
A value of type string.
Definition: ivalue.h:221
const IType_string * get_type() const =0
Returns the type of this value.
virtual const char * get_value() const =0
Returns the value.
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:224
virtual void set_value(const char *value)=0
Sets the value.
A value of type struct.
Definition: ivalue.h:424
virtual Sint32 set_field(const char *name, IValue *value)=0
Sets a field by name in linear time.
virtual IValue * get_field(const char *name)=0
Returns a field by name in linear time.
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:427
virtual const IType_struct * get_type() const =0
Returns the type of this value.
virtual const IValue * get_field(const char *name) const =0
Returns a field by name in linear time.
T * get_field(const char *name)
Returns a field by name in linear time.
Definition: ivalue.h:464
const T * get_field(const char *name) const
Returns a field by name in linear time.
Definition: ivalue.h:443
A texture value.
Definition: ivalue.h:525
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:528
virtual const IType_texture * get_type() const =0
Returns the type of this value.
virtual Float32 get_gamma() const =0
Returns the gamma value of this texture.
virtual const char * get_selector() const =0
Returns the selector of this texture, or NULL.
A value of type vector.
Definition: ivalue.h:309
const T * get_value(Size index) const
Returns the value at index, or NULL if index is out of bounds.
Definition: ivalue.h:322
virtual IValue_atomic * get_value(Size index)=0
Returns the value at index, or NULL if index is out of bounds.
static const Kind s_kind
The kind of this subclass.
Definition: ivalue.h:312
virtual const IType_vector * get_type() const =0
Returns the type of this value.
T * get_value(Size index)
Returns the value at index, or NULL if index is out of bounds.
Definition: ivalue.h:337
virtual const IValue_atomic * get_value(Size index) const =0
Returns the value at index, or NULL if index is out of bounds.
The interface to MDL values.
Definition: ivalue.h:33
virtual Kind get_kind() const =0
Returns the kind of the value.
const T * get_type() const
Returns the type of this value.
Definition: ivalue.h:79
virtual const IType * get_type() const =0
Returns the type of this value.
Kind
The possible kinds of values.
Definition: ivalue.h:36
@ VK_TEXTURE
A texture value. See mi::neuraylib::IValue_texture.
Definition: ivalue.h:62
@ VK_LIGHT_PROFILE
A light_profile value. See mi::neuraylib::IValue_light_profile.
Definition: ivalue.h:64
@ VK_ARRAY
An array value. See mi::neuraylib::IValue_array.
Definition: ivalue.h:56
@ VK_STRUCT
A struct value. See mi::neuraylib::IValue_struct.
Definition: ivalue.h:58
@ VK_FLOAT
A float value. See mi::neuraylib::IValue_float.
Definition: ivalue.h:44
@ VK_DOUBLE
A double value. See mi::neuraylib::IValue_double.
Definition: ivalue.h:46
@ VK_MATRIX
A matrix value. See mi::neuraylib::IValue_matrix.
Definition: ivalue.h:52
@ VK_BSDF_MEASUREMENT
A bsdf_measurement value. See mi::neuraylib::IValue_bsdf_measurement.
Definition: ivalue.h:66
@ VK_ENUM
An enum value. See mi::neuraylib::IValue_enum.
Definition: ivalue.h:42
@ VK_INT
An integer value. See mi::neuraylib::IValue_int.
Definition: ivalue.h:40
@ VK_VECTOR
A vector value. See mi::neuraylib::IValue_vector.
Definition: ivalue.h:50
@ VK_INVALID_DF
An invalid distribution function value. See mi::neuraylib::IValue_invalid_df.
Definition: ivalue.h:60
@ VK_BOOL
A boolean value. See mi::neuraylib::IValue_bool.
Definition: ivalue.h:38
@ VK_STRING
A string value. See mi::neuraylib::IValue_string.
Definition: ivalue.h:48
@ VK_COLOR
A color value. See mi::neuraylib::IValue_color.
Definition: ivalue.h:54
Standard RGBA color class with floating point elements and operations.
#define mi_static_assert(expr)
Compile time assertion that raises a compilation error if the constant expression expr evaluates to f...
Definition: assert.h:58
virtual const IInterface * get_interface(const Uuid &interface_id) const =0
Acquires a const interface from another.
Interface * get() const
Access to the interface. Returns 0 for an invalid interface.
Definition: handle.h:294
virtual Uint32 release() const =0
Decrements the reference count.
unsigned int Uint32
32-bit unsigned integer.
Definition: types.h:49
Uint64 Size
Unsigned integral type that is large enough to hold the size of all types.
Definition: types.h:112
double Float64
64-bit float.
Definition: types.h:52
float Float32
32-bit float.
Definition: types.h:51
signed int Sint32
32-bit signed integer.
Definition: types.h:46
Float32 g
Green color component.
Definition: vector.h:71
Float32 a
Alpha value, 0.0 is fully transparent and 1.0 is opaque; value can lie outside that range.
Definition: vector.h:75
Float32 r
Red color component.
Definition: vector.h:69
Float32 b
Blue color component.
Definition: vector.h:73
mi::Sint32 set_value(mi::neuraylib::IValue *value, const T &v)
Simplifies setting the value of mi::neuraylib::IValue from the corresponding classes from the base an...
Definition: ivalue.h:925
mi::Sint32 get_value(const mi::neuraylib::IValue *value, T &v)
Simplifies reading the value of mi::neuraylib::IValue into the corresponding classes from the base an...
Definition: ivalue.h:1254
Smart-pointer handle class for interfaces, const and non-const version.
Types of the MDL type system.
A NxM-dimensional matrix class template of fixed dimensions with supporting functions.
Common namespace for APIs of NVIDIA Advanced Rendering Center GmbH.
Definition: example_derivatives.dox:5
Spectrum class with floating point elements and operations.
Math vector class template of fixed dimension with arithmetic operators and generic functions.