Material Definition Language API nvidia_logo_transpbg.gif Up
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
type_traits.h
Go to the documentation of this file.
1 /***************************************************************************************************
2  * Copyright 2020 NVIDIA Corporation. All rights reserved.
3  **************************************************************************************************/
6 
7 #ifndef MI_NEURAYLIB_TYPE_TRAITS_H
8 #define MI_NEURAYLIB_TYPE_TRAITS_H
9 
11 #include <mi/base/uuid.h>
12 #include <mi/math/bbox.h>
13 #include <mi/math/color.h>
14 #include <mi/math/matrix.h>
15 #include <mi/math/spectrum.h>
16 #include <mi/math/vector.h>
17 
18 #include <string>
19 
20 namespace mi {
21 
26 class IData;
27 class IBoolean;
28 class ISint8;
29 class ISint16;
30 class ISint32;
31 class ISint64;
32 class IUint8;
33 class IUint16;
34 class IUint32;
35 class IUint64;
36 class IFloat32;
37 class IFloat64;
38 class ISize;
39 class IDifference;
40 class IString;
41 class IUuid;
42 class IVoid;
43 class IRef;
44 class IBoolean_2;
45 class IBoolean_3;
46 class IBoolean_4;
47 class ISint32_2;
48 class ISint32_3;
49 class ISint32_4;
50 class IUint32_2;
51 class IUint32_3;
52 class IUint32_4;
53 class IFloat32_2;
54 class IFloat32_3;
55 class IFloat32_4;
56 class IFloat64_2;
57 class IFloat64_3;
58 class IFloat64_4;
59 class IBoolean_2_2;
60 class IBoolean_2_3;
61 class IBoolean_2_4;
62 class IBoolean_3_2;
63 class IBoolean_3_3;
64 class IBoolean_3_4;
65 class IBoolean_4_2;
66 class IBoolean_4_3;
67 class IBoolean_4_4;
68 class ISint32_2_2;
69 class ISint32_2_3;
70 class ISint32_2_4;
71 class ISint32_3_2;
72 class ISint32_3_3;
73 class ISint32_3_4;
74 class ISint32_4_2;
75 class ISint32_4_3;
76 class ISint32_4_4;
77 class IUint32_2_2;
78 class IUint32_2_3;
79 class IUint32_2_4;
80 class IUint32_3_2;
81 class IUint32_3_3;
82 class IUint32_3_4;
83 class IUint32_4_2;
84 class IUint32_4_3;
85 class IUint32_4_4;
86 class IFloat32_2_2;
87 class IFloat32_2_3;
88 class IFloat32_2_4;
89 class IFloat32_3_2;
90 class IFloat32_3_3;
91 class IFloat32_3_4;
92 class IFloat32_4_2;
93 class IFloat32_4_3;
94 class IFloat32_4_4;
95 class IFloat64_2_2;
96 class IFloat64_2_3;
97 class IFloat64_2_4;
98 class IFloat64_3_2;
99 class IFloat64_3_3;
100 class IFloat64_3_4;
101 class IFloat64_4_2;
102 class IFloat64_4_3;
103 class IFloat64_4_4;
104 class IColor;
105 class IColor3;
106 class ISpectrum;
107 class IBbox3;
108 
162 template<typename I> struct Type_traits {};
163 
164 template<> struct Type_traits<mi::IBoolean>
165 {
166  static const char* get_type_name() { return "Boolean"; }
167  typedef bool Primitive_type;
168 };
169 
170 template<> struct Type_traits<mi::ISint8>
171 {
172  static const char* get_type_name() { return "Sint8"; }
173  typedef mi::Sint8 Primitive_type;
174 };
175 
176 template<> struct Type_traits<mi::ISint16>
177 {
178  static const char* get_type_name() { return "Sint16"; }
179  typedef mi::Sint16 Primitive_type;
180 };
181 
182 template<> struct Type_traits<mi::ISint32>
183 {
184  static const char* get_type_name() { return "Sint32"; }
185  typedef mi::Sint32 Primitive_type;
186 };
187 
188 template<> struct Type_traits<mi::ISint64>
189 {
190  static const char* get_type_name() { return "Sint64"; }
191  typedef mi::Sint64 Primitive_type;
192 };
193 
194 template<> struct Type_traits<mi::IUint8>
195 {
196  static const char* get_type_name() { return "Uint8"; }
197  typedef mi::Uint8 Primitive_type;
198 };
199 
200 template<> struct Type_traits<mi::IUint16>
201 {
202  static const char* get_type_name() { return "Uint16"; }
203  typedef mi::Uint16 Primitive_type;
204 };
205 
206 template<> struct Type_traits<mi::IUint32>
207 {
208  static const char* get_type_name() { return "Uint32"; }
209  typedef mi::Uint32 Primitive_type;
210 };
211 
212 template<> struct Type_traits<mi::IUint64>
213 {
214  static const char* get_type_name() { return "Uint64"; }
215  typedef mi::Uint64 Primitive_type;
216 };
217 
218 template<> struct Type_traits<mi::IFloat32>
219 {
220  static const char* get_type_name() { return "Float32"; }
221  typedef mi::Float32 Primitive_type;
222 };
223 
224 template<> struct Type_traits<mi::IFloat64>
225 {
226  static const char* get_type_name() { return "Float64"; }
227  typedef mi::Float64 Primitive_type;
228 };
229 
230 template<> struct Type_traits<mi::ISize>
231 {
232  static const char* get_type_name() { return "Size"; }
233  typedef mi::Size Primitive_type;
234 };
235 
236 template<> struct Type_traits<mi::IDifference>
237 {
238  static const char* get_type_name() { return "Difference"; }
239  typedef mi::Difference Primitive_type;
240 };
241 
242 template<> struct Type_traits<mi::IString>
243 {
244  static const char* get_type_name() { return "String"; }
245  typedef const char* Primitive_type;
246 };
247 
248 template<> struct Type_traits<mi::IUuid>
249 {
250  static const char* get_type_name() { return "Uuid"; }
251  typedef mi::base::Uuid Primitive_type;
252 };
253 
254 template<> struct Type_traits<mi::IVoid>
255 {
256  static const char* get_type_name() { return "Void"; }
257  typedef void Primitive_type;
258 };
259 
260 template<> struct Type_traits<mi::IRef>
261 {
262  static const char* get_type_name() { return "Ref"; }
263  typedef const char* Primitive_type;
264 };
265 
266 template<> struct Type_traits<mi::IBoolean_2>
267 {
268  static const char* get_type_name() { return "Boolean<2>"; }
269  typedef mi::math::Vector<bool,2> Primitive_type;
270 };
271 
272 template<> struct Type_traits<mi::IBoolean_3>
273 {
274  static const char* get_type_name() { return "Boolean<3>"; }
275  typedef mi::math::Vector<bool,3> Primitive_type;
276 };
277 
278 template<> struct Type_traits<mi::IBoolean_4>
279 {
280  static const char* get_type_name() { return "Boolean<4>"; }
281  typedef mi::math::Vector<bool,4> Primitive_type;
282 };
283 
284 template<> struct Type_traits<mi::ISint32_2>
285 {
286  static const char* get_type_name() { return "Sint32<2>"; }
287  typedef mi::math::Vector<mi::Sint32,2> Primitive_type;
288 };
289 
290 template<> struct Type_traits<mi::ISint32_3>
291 {
292  static const char* get_type_name() { return "Sint32<3>"; }
293  typedef mi::math::Vector<mi::Sint32,3> Primitive_type;
294 };
295 
296 template<> struct Type_traits<mi::ISint32_4>
297 {
298  static const char* get_type_name() { return "Sint32<4>"; }
299  typedef mi::math::Vector<mi::Sint32,4> Primitive_type;
300 };
301 
302 template<> struct Type_traits<mi::IUint32_2>
303 {
304  static const char* get_type_name() { return "Uint32<2>"; }
305  typedef mi::math::Vector<mi::Uint32,2> Primitive_type;
306 };
307 
308 template<> struct Type_traits<mi::IUint32_3>
309 {
310  static const char* get_type_name() { return "Uint32<3>"; }
311  typedef mi::math::Vector<mi::Uint32,3> Primitive_type;
312 };
313 
314 template<> struct Type_traits<mi::IUint32_4>
315 {
316  static const char* get_type_name() { return "Uint32<4>"; }
317  typedef mi::math::Vector<mi::Uint32,4> Primitive_type;
318 };
319 
320 template<> struct Type_traits<mi::IFloat32_2>
321 {
322  static const char* get_type_name() { return "Float32<2>"; }
323  typedef mi::math::Vector<mi::Float32,2> Primitive_type;
324 };
325 
326 template<> struct Type_traits<mi::IFloat32_3>
327 {
328  static const char* get_type_name() { return "Float32<3>"; }
329  typedef mi::math::Vector<mi::Float32,3> Primitive_type;
330 };
331 
332 template<> struct Type_traits<mi::IFloat32_4>
333 {
334  static const char* get_type_name() { return "Float32<4>"; }
335  typedef mi::math::Vector<mi::Float32,4> Primitive_type;
336 };
337 
338 template<> struct Type_traits<mi::IFloat64_2>
339 {
340  static const char* get_type_name() { return "Float64<2>"; }
341  typedef mi::math::Vector<mi::Float64,2> Primitive_type;
342 };
343 
344 template<> struct Type_traits<mi::IFloat64_3>
345 {
346  static const char* get_type_name() { return "Float64<3>"; }
347  typedef mi::math::Vector<mi::Float64,3> Primitive_type;
348 };
349 
350 template<> struct Type_traits<mi::IFloat64_4>
351 {
352  static const char* get_type_name() { return "Float64<4>"; }
353  typedef mi::math::Vector<mi::Float64,4> Primitive_type;
354 };
355 
356 template<> struct Type_traits<mi::IBoolean_2_2>
357 {
358  static const char* get_type_name() { return "Boolean<2,2>"; }
359  typedef mi::math::Matrix<bool,2,2> Primitive_type;
360 };
361 
362 template<> struct Type_traits<mi::IBoolean_2_3>
363 {
364  static const char* get_type_name() { return "Boolean<2,3>"; }
365  typedef mi::math::Matrix<bool,2,3> Primitive_type;
366 };
367 
368 template<> struct Type_traits<mi::IBoolean_2_4>
369 {
370  static const char* get_type_name() { return "Boolean<2,4>"; }
371  typedef mi::math::Matrix<bool,2,4> Primitive_type;
372 };
373 
374 template<> struct Type_traits<mi::IBoolean_3_2>
375 {
376  static const char* get_type_name() { return "Boolean<3,2>"; }
377  typedef mi::math::Matrix<bool,3,2> Primitive_type;
378 };
379 
380 template<> struct Type_traits<mi::IBoolean_3_3>
381 {
382  static const char* get_type_name() { return "Boolean<3,3>"; }
383  typedef mi::math::Matrix<bool,3,3> Primitive_type;
384 };
385 
386 template<> struct Type_traits<mi::IBoolean_3_4>
387 {
388  static const char* get_type_name() { return "Boolean<3,4>"; }
389  typedef mi::math::Matrix<bool,3,4> Primitive_type;
390 };
391 
392 template<> struct Type_traits<mi::IBoolean_4_2>
393 {
394  static const char* get_type_name() { return "Boolean<4,2>"; }
395  typedef mi::math::Matrix<bool,4,2> Primitive_type;
396 };
397 
398 template<> struct Type_traits<mi::IBoolean_4_3>
399 {
400  static const char* get_type_name() { return "Boolean<4,3>"; }
401  typedef mi::math::Matrix<bool,4,3> Primitive_type;
402 };
403 
404 template<> struct Type_traits<mi::IBoolean_4_4>
405 {
406  static const char* get_type_name() { return "Boolean<4,4>"; }
407  typedef mi::math::Matrix<bool,4,4> Primitive_type;
408 };
409 
410 template<> struct Type_traits<mi::ISint32_2_2>
411 {
412  static const char* get_type_name() { return "Sint32<2,2>"; }
413  typedef mi::math::Matrix<mi::Sint32,2,2> Primitive_type;
414 };
415 
416 template<> struct Type_traits<mi::ISint32_2_3>
417 {
418  static const char* get_type_name() { return "Sint32<2,3>"; }
419  typedef mi::math::Matrix<mi::Sint32,2,3> Primitive_type;
420 };
421 
422 template<> struct Type_traits<mi::ISint32_2_4>
423 {
424  static const char* get_type_name() { return "Sint32<2,4>"; }
425  typedef mi::math::Matrix<mi::Sint32,2,4> Primitive_type;
426 };
427 
428 template<> struct Type_traits<mi::ISint32_3_2>
429 {
430  static const char* get_type_name() { return "Sint32<3,2>"; }
431  typedef mi::math::Matrix<mi::Sint32,3,2> Primitive_type;
432 };
433 
434 template<> struct Type_traits<mi::ISint32_3_3>
435 {
436  static const char* get_type_name() { return "Sint32<3,3>"; }
437  typedef mi::math::Matrix<mi::Sint32,3,3> Primitive_type;
438 };
439 
440 template<> struct Type_traits<mi::ISint32_3_4>
441 {
442  static const char* get_type_name() { return "Sint32<3,4>"; }
443  typedef mi::math::Matrix<mi::Sint32,3,4> Primitive_type;
444 };
445 
446 template<> struct Type_traits<mi::ISint32_4_2>
447 {
448  static const char* get_type_name() { return "Sint32<4,2>"; }
449  typedef mi::math::Matrix<mi::Sint32,4,2> Primitive_type;
450 };
451 
452 template<> struct Type_traits<mi::ISint32_4_3>
453 {
454  static const char* get_type_name() { return "Sint32<4,3>"; }
455  typedef mi::math::Matrix<mi::Sint32,4,3> Primitive_type;
456 };
457 
458 template<> struct Type_traits<mi::ISint32_4_4>
459 {
460  static const char* get_type_name() { return "Sint32<4,4>"; }
461  typedef mi::math::Matrix<mi::Sint32,4,4> Primitive_type;
462 };
463 
464 template<> struct Type_traits<mi::IUint32_2_2>
465 {
466  static const char* get_type_name() { return "Uint32<2,2>"; }
467  typedef mi::math::Matrix<mi::Uint32,2,2> Primitive_type;
468 };
469 
470 template<> struct Type_traits<mi::IUint32_2_3>
471 {
472  static const char* get_type_name() { return "Uint32<2,3>"; }
473  typedef mi::math::Matrix<mi::Uint32,2,3> Primitive_type;
474 };
475 
476 template<> struct Type_traits<mi::IUint32_2_4>
477 {
478  static const char* get_type_name() { return "Uint32<2,4>"; }
479  typedef mi::math::Matrix<mi::Uint32,2,4> Primitive_type;
480 };
481 
482 template<> struct Type_traits<mi::IUint32_3_2>
483 {
484  static const char* get_type_name() { return "Uint32<3,2>"; }
485  typedef mi::math::Matrix<mi::Uint32,3,2> Primitive_type;
486 };
487 
488 template<> struct Type_traits<mi::IUint32_3_3>
489 {
490  static const char* get_type_name() { return "Uint32<3,3>"; }
491  typedef mi::math::Matrix<mi::Uint32,3,3> Primitive_type;
492 };
493 
494 template<> struct Type_traits<mi::IUint32_3_4>
495 {
496  static const char* get_type_name() { return "Uint32<3,4>"; }
497  typedef mi::math::Matrix<mi::Uint32,3,4> Primitive_type;
498 };
499 
500 template<> struct Type_traits<mi::IUint32_4_2>
501 {
502  static const char* get_type_name() { return "Uint32<4,2>"; }
503  typedef mi::math::Matrix<mi::Uint32,4,2> Primitive_type;
504 };
505 
506 template<> struct Type_traits<mi::IUint32_4_3>
507 {
508  static const char* get_type_name() { return "Uint32<4,3>"; }
509  typedef mi::math::Matrix<mi::Uint32,4,3> Primitive_type;
510 };
511 
512 template<> struct Type_traits<mi::IUint32_4_4>
513 {
514  static const char* get_type_name() { return "Uint32<4,4>"; }
515  typedef mi::math::Matrix<mi::Uint32,4,4> Primitive_type;
516 };
517 
518 template<> struct Type_traits<mi::IFloat32_2_2>
519 {
520  static const char* get_type_name() { return "Float32<2,2>"; }
521  typedef mi::math::Matrix<mi::Float32,2,2> Primitive_type;
522 };
523 
524 template<> struct Type_traits<mi::IFloat32_2_3>
525 {
526  static const char* get_type_name() { return "Float32<2,3>"; }
527  typedef mi::math::Matrix<mi::Float32,2,3> Primitive_type;
528 };
529 
530 template<> struct Type_traits<mi::IFloat32_2_4>
531 {
532  static const char* get_type_name() { return "Float32<2,4>"; }
533  typedef mi::math::Matrix<mi::Float32,2,4> Primitive_type;
534 };
535 
536 template<> struct Type_traits<mi::IFloat32_3_2>
537 {
538  static const char* get_type_name() { return "Float32<3,2>"; }
539  typedef mi::math::Matrix<mi::Float32,3,2> Primitive_type;
540 };
541 
542 template<> struct Type_traits<mi::IFloat32_3_3>
543 {
544  static const char* get_type_name() { return "Float32<3,3>"; }
545  typedef mi::math::Matrix<mi::Float32,3,3> Primitive_type;
546 };
547 
548 template<> struct Type_traits<mi::IFloat32_3_4>
549 {
550  static const char* get_type_name() { return "Float32<3,4>"; }
551  typedef mi::math::Matrix<mi::Float32,3,4> Primitive_type;
552 };
553 
554 template<> struct Type_traits<mi::IFloat32_4_2>
555 {
556  static const char* get_type_name() { return "Float32<4,2>"; }
557  typedef mi::math::Matrix<mi::Float32,4,2> Primitive_type;
558 };
559 
560 template<> struct Type_traits<mi::IFloat32_4_3>
561 {
562  static const char* get_type_name() { return "Float32<4,3>"; }
563  typedef mi::math::Matrix<mi::Float32,4,3> Primitive_type;
564 };
565 
566 template<> struct Type_traits<mi::IFloat32_4_4>
567 {
568  static const char* get_type_name() { return "Float32<4,4>"; }
569  typedef mi::math::Matrix<mi::Float32,4,4> Primitive_type;
570 };
571 
572 template<> struct Type_traits<mi::IFloat64_2_2>
573 {
574  static const char* get_type_name() { return "Float64<2,2>"; }
575  typedef mi::math::Matrix<mi::Float64,2,2> Primitive_type;
576 };
577 
578 template<> struct Type_traits<mi::IFloat64_2_3>
579 {
580  static const char* get_type_name() { return "Float64<2,3>"; }
581  typedef mi::math::Matrix<mi::Float64,2,3> Primitive_type;
582 };
583 
584 template<> struct Type_traits<mi::IFloat64_2_4>
585 {
586  static const char* get_type_name() { return "Float64<2,4>"; }
587  typedef mi::math::Matrix<mi::Float64,2,4> Primitive_type;
588 };
589 
590 template<> struct Type_traits<mi::IFloat64_3_2>
591 {
592  static const char* get_type_name() { return "Float64<3,2>"; }
593  typedef mi::math::Matrix<mi::Float64,3,2> Primitive_type;
594 };
595 
596 template<> struct Type_traits<mi::IFloat64_3_3>
597 {
598  static const char* get_type_name() { return "Float64<3,3>"; }
599  typedef mi::math::Matrix<mi::Float64,3,3> Primitive_type;
600 };
601 
602 template<> struct Type_traits<mi::IFloat64_3_4>
603 {
604  static const char* get_type_name() { return "Float64<3,4>"; }
605  typedef mi::math::Matrix<mi::Float64,3,4> Primitive_type;
606 };
607 
608 template<> struct Type_traits<mi::IFloat64_4_2>
609 {
610  static const char* get_type_name() { return "Float64<4,2>"; }
611  typedef mi::math::Matrix<mi::Float64,4,2> Primitive_type;
612 };
613 
614 template<> struct Type_traits<mi::IFloat64_4_3>
615 {
616  static const char* get_type_name() { return "Float64<4,3>"; }
617  typedef mi::math::Matrix<mi::Float64,4,3> Primitive_type;
618 };
619 
620 template<> struct Type_traits<mi::IFloat64_4_4>
621 {
622  static const char* get_type_name() { return "Float64<4,4>"; }
623  typedef mi::math::Matrix<mi::Float64,4,4> Primitive_type;
624 };
625 
626 template<> struct Type_traits<mi::IColor>
627 {
628  static const char* get_type_name() { return "Color"; }
629  typedef mi::math::Color Primitive_type;
630 };
631 
632 template<> struct Type_traits<mi::IColor3>
633 {
634  static const char* get_type_name() { return "Color3"; }
635  typedef mi::math::Color Primitive_type;
636 };
637 
638 template<> struct Type_traits<mi::ISpectrum>
639 {
640  static const char* get_type_name() { return "Spectrum"; }
641  typedef mi::math::Spectrum Primitive_type;
642 };
643 
644 template<> struct Type_traits<mi::IBbox3>
645 {
646  static const char* get_type_name() { return "Bbox3"; }
647  typedef mi::math::Bbox<mi::Float32,3> Primitive_type;
648 };
649 
650 
651 template<> struct Type_traits<bool>
652 {
653  static const char* get_type_name() { return "Boolean"; };
654  typedef mi::IBoolean Interface_type;
655 };
656 
657 template<> struct Type_traits<mi::Sint8>
658 {
659  static const char* get_type_name() { return "Sint8"; };
660  typedef mi::ISint8 Interface_type;
661 };
662 
663 template<> struct Type_traits<mi::Sint16>
664 {
665  static const char* get_type_name() { return "Sint16"; };
666  typedef mi::ISint16 Interface_type;
667 };
668 
669 template<> struct Type_traits<mi::Sint32>
670 {
671  static const char* get_type_name() { return "Sint32"; };
672  typedef mi::ISint32 Interface_type;
673 };
674 
675 template<> struct Type_traits<mi::Sint64>
676 {
677  static const char* get_type_name() { return "Sint64"; };
678  typedef mi::ISint64 Interface_type;
679 };
680 
681 template<> struct Type_traits<mi::Uint8>
682 {
683  static const char* get_type_name() { return "Uint8"; };
684  typedef mi::IUint8 Interface_type;
685 };
686 
687 template<> struct Type_traits<mi::Uint16>
688 {
689  static const char* get_type_name() { return "Uint16"; };
690  typedef mi::IUint16 Interface_type;
691 };
692 
693 template<> struct Type_traits<mi::Uint32>
694 {
695  static const char* get_type_name() { return "Uint32"; };
696  typedef mi::IUint32 Interface_type;
697 };
698 
699 template<> struct Type_traits<mi::Uint64>
700 {
701  static const char* get_type_name() { return "Uint64"; };
702  typedef mi::IUint64 Interface_type;
703 };
704 
705 template<> struct Type_traits<mi::Float32>
706 {
707  static const char* get_type_name() { return "Float32"; };
708  typedef mi::IFloat32 Interface_type;
709 };
710 
711 template<> struct Type_traits<mi::Float64>
712 {
713  static const char* get_type_name() { return "Float64"; };
714  typedef mi::IFloat64 Interface_type;
715 };
716 
717 template<> struct Type_traits<const char*>
718 {
719  static const char* get_type_name() { return "String"; };
720  typedef mi::IString Interface_type;
721 };
722 
723 template<> struct Type_traits<std::string>
724 {
725  static const char* get_type_name() { return "String"; };
726  typedef mi::IString Interface_type;
727 };
728 
729 template<std::size_t N> struct Type_traits<char[N]>
730 {
731  static const char* get_type_name() { return "String"; };
732  typedef mi::IString Interface_type;
733 };
734 
735 template<> struct Type_traits<mi::base::Uuid>
736 {
737  static const char* get_type_name() { return "Uuid"; };
738  typedef mi::IUuid Interface_type;
739 };
740 
741 template<> struct Type_traits<void>
742 {
743  static const char* get_type_name() { return "Void"; };
744  typedef mi::IVoid Interface_type;
745 };
746 
747 template<> struct Type_traits<mi::math::Vector<bool,2> >
748 {
749  static const char* get_type_name() { return "Boolean<2>"; };
750  typedef mi::IBoolean_2 Interface_type;
751 };
752 
753 template<> struct Type_traits<mi::math::Vector<bool,3> >
754 {
755  static const char* get_type_name() { return "Boolean<3>"; };
756  typedef mi::IBoolean_3 Interface_type;
757 };
758 
759 template<> struct Type_traits<mi::math::Vector<bool,4> >
760 {
761  static const char* get_type_name() { return "Boolean<4>"; };
762  typedef mi::IBoolean_4 Interface_type;
763 };
764 
765 template<> struct Type_traits<mi::math::Vector<mi::Sint32,2> >
766 {
767  static const char* get_type_name() { return "Sint32<2>"; };
768  typedef mi::ISint32_2 Interface_type;
769 };
770 
771 template<> struct Type_traits<mi::math::Vector<mi::Sint32,3> >
772 {
773  static const char* get_type_name() { return "Sint32<3>"; };
774  typedef mi::ISint32_3 Interface_type;
775 };
776 
777 template<> struct Type_traits<mi::math::Vector<mi::Sint32,4> >
778 {
779  static const char* get_type_name() { return "Sint32<4>"; };
780  typedef mi::ISint32_4 Interface_type;
781 };
782 
783 template<> struct Type_traits<mi::math::Vector<mi::Uint32,2> >
784 {
785  static const char* get_type_name() { return "Uint32<2>"; };
786  typedef mi::IUint32_2 Interface_type;
787 };
788 
789 template<> struct Type_traits<mi::math::Vector<mi::Uint32,3> >
790 {
791  static const char* get_type_name() { return "Uint32<3>"; };
792  typedef mi::IUint32_3 Interface_type;
793 };
794 
795 template<> struct Type_traits<mi::math::Vector<mi::Uint32,4> >
796 {
797  static const char* get_type_name() { return "Uint32<4>"; };
798  typedef mi::IUint32_4 Interface_type;
799 };
800 
801 template<> struct Type_traits<mi::math::Vector<mi::Float32,2> >
802 {
803  static const char* get_type_name() { return "Float32<2>"; };
804  typedef mi::IFloat32_2 Interface_type;
805 };
806 
807 template<> struct Type_traits<mi::math::Vector<mi::Float32,3> >
808 {
809  static const char* get_type_name() { return "Float32<3>"; };
810  typedef mi::IFloat32_3 Interface_type;
811 };
812 
813 template<> struct Type_traits<mi::math::Vector<mi::Float32,4> >
814 {
815  static const char* get_type_name() { return "Float32<4>"; };
816  typedef mi::IFloat32_4 Interface_type;
817 };
818 
819 template<> struct Type_traits<mi::math::Vector<mi::Float64,2> >
820 {
821  static const char* get_type_name() { return "Float64<2>"; };
822  typedef mi::IFloat64_2 Interface_type;
823 };
824 
825 template<> struct Type_traits<mi::math::Vector<mi::Float64,3> >
826 {
827  static const char* get_type_name() { return "Float64<3>"; };
828  typedef mi::IFloat64_3 Interface_type;
829 };
830 
831 template<> struct Type_traits<mi::math::Vector<mi::Float64,4> >
832 {
833  static const char* get_type_name() { return "Float64<4>"; };
834  typedef mi::IFloat64_4 Interface_type;
835 };
836 
837 template<> struct Type_traits<mi::math::Matrix<bool,2,2> >
838 {
839  static const char* get_type_name() { return "Boolean<2,2>"; };
840  typedef mi::IBoolean_2_2 Interface_type;
841 };
842 
843 template<> struct Type_traits<mi::math::Matrix<bool,2,3> >
844 {
845  static const char* get_type_name() { return "Boolean<2,3>"; };
846  typedef mi::IBoolean_2_3 Interface_type;
847 };
848 
849 template<> struct Type_traits<mi::math::Matrix<bool,2,4> >
850 {
851  static const char* get_type_name() { return "Boolean<2,4>"; };
852  typedef mi::IBoolean_2_4 Interface_type;
853 };
854 
855 template<> struct Type_traits<mi::math::Matrix<bool,3,2> >
856 {
857  static const char* get_type_name() { return "Boolean<3,2>"; };
858  typedef mi::IBoolean_3_2 Interface_type;
859 };
860 
861 template<> struct Type_traits<mi::math::Matrix<bool,3,3> >
862 {
863  static const char* get_type_name() { return "Boolean<3,3>"; };
864  typedef mi::IBoolean_3_3 Interface_type;
865 };
866 
867 template<> struct Type_traits<mi::math::Matrix<bool,3,4> >
868 {
869  static const char* get_type_name() { return "Boolean<3,4>"; };
870  typedef mi::IBoolean_3_4 Interface_type;
871 };
872 
873 template<> struct Type_traits<mi::math::Matrix<bool,4,2> >
874 {
875  static const char* get_type_name() { return "Boolean<4,2>"; };
876  typedef mi::IBoolean_4_2 Interface_type;
877 };
878 
879 template<> struct Type_traits<mi::math::Matrix<bool,4,3> >
880 {
881  static const char* get_type_name() { return "Boolean<4,3>"; };
882  typedef mi::IBoolean_4_3 Interface_type;
883 };
884 
885 template<> struct Type_traits<mi::math::Matrix<bool,4,4> >
886 {
887  static const char* get_type_name() { return "Boolean<4,4>"; };
888  typedef mi::IBoolean_4_4 Interface_type;
889 };
890 
891 template<> struct Type_traits<mi::math::Matrix<mi::Sint32,2,2> >
892 {
893  static const char* get_type_name() { return "Sint32<2,2>"; };
894  typedef mi::ISint32_2_2 Interface_type;
895 };
896 
897 template<> struct Type_traits<mi::math::Matrix<mi::Sint32,2,3> >
898 {
899  static const char* get_type_name() { return "Sint32<2,3>"; };
900  typedef mi::ISint32_2_3 Interface_type;
901 };
902 
903 template<> struct Type_traits<mi::math::Matrix<mi::Sint32,2,4> >
904 {
905  static const char* get_type_name() { return "Sint32<2,4>"; };
906  typedef mi::ISint32_2_4 Interface_type;
907 };
908 
909 template<> struct Type_traits<mi::math::Matrix<mi::Sint32,3,2> >
910 {
911  static const char* get_type_name() { return "Sint32<3,2>"; };
912  typedef mi::ISint32_3_2 Interface_type;
913 };
914 
915 template<> struct Type_traits<mi::math::Matrix<mi::Sint32,3,3> >
916 {
917  static const char* get_type_name() { return "Sint32<3,3>"; };
918  typedef mi::ISint32_3_3 Interface_type;
919 };
920 
921 template<> struct Type_traits<mi::math::Matrix<mi::Sint32,3,4> >
922 {
923  static const char* get_type_name() { return "Sint32<3,4>"; };
924  typedef mi::ISint32_3_4 Interface_type;
925 };
926 
927 template<> struct Type_traits<mi::math::Matrix<mi::Sint32,4,2> >
928 {
929  static const char* get_type_name() { return "Sint32<4,2>"; };
930  typedef mi::ISint32_4_2 Interface_type;
931 };
932 
933 template<> struct Type_traits<mi::math::Matrix<mi::Sint32,4,3> >
934 {
935  static const char* get_type_name() { return "Sint32<4,3>"; };
936  typedef mi::ISint32_4_3 Interface_type;
937 };
938 
939 template<> struct Type_traits<mi::math::Matrix<mi::Sint32,4,4> >
940 {
941  static const char* get_type_name() { return "Sint32<4,4>"; };
942  typedef mi::ISint32_4_4 Interface_type;
943 };
944 
945 template<> struct Type_traits<mi::math::Matrix<mi::Uint32,2,2> >
946 {
947  static const char* get_type_name() { return "Uint32<2,2>"; };
948  typedef mi::IUint32_2_2 Interface_type;
949 };
950 
951 template<> struct Type_traits<mi::math::Matrix<mi::Uint32,2,3> >
952 {
953  static const char* get_type_name() { return "Uint32<2,3>"; };
954  typedef mi::IUint32_2_3 Interface_type;
955 };
956 
957 template<> struct Type_traits<mi::math::Matrix<mi::Uint32,2,4> >
958 {
959  static const char* get_type_name() { return "Uint32<2,4>"; };
960  typedef mi::IUint32_2_4 Interface_type;
961 };
962 
963 template<> struct Type_traits<mi::math::Matrix<mi::Uint32,3,2> >
964 {
965  static const char* get_type_name() { return "Uint32<3,2>"; };
966  typedef mi::IUint32_3_2 Interface_type;
967 };
968 
969 template<> struct Type_traits<mi::math::Matrix<mi::Uint32,3,3> >
970 {
971  static const char* get_type_name() { return "Uint32<3,3>"; };
972  typedef mi::IUint32_3_3 Interface_type;
973 };
974 
975 template<> struct Type_traits<mi::math::Matrix<mi::Uint32,3,4> >
976 {
977  static const char* get_type_name() { return "Uint32<3,4>"; };
978  typedef mi::IUint32_3_4 Interface_type;
979 };
980 
981 template<> struct Type_traits<mi::math::Matrix<mi::Uint32,4,2> >
982 {
983  static const char* get_type_name() { return "Uint32<4,2>"; };
984  typedef mi::IUint32_4_2 Interface_type;
985 };
986 
987 template<> struct Type_traits<mi::math::Matrix<mi::Uint32,4,3> >
988 {
989  static const char* get_type_name() { return "Uint32<4,3>"; };
990  typedef mi::IUint32_4_3 Interface_type;
991 };
992 
993 template<> struct Type_traits<mi::math::Matrix<mi::Uint32,4,4> >
994 {
995  static const char* get_type_name() { return "Uint32<4,4>"; };
996  typedef mi::IUint32_4_4 Interface_type;
997 };
998 
999 template<> struct Type_traits<mi::math::Matrix<mi::Float32,2,2> >
1000 {
1001  static const char* get_type_name() { return "Float32<2,2>"; };
1002  typedef mi::IFloat32_2_2 Interface_type;
1003 };
1004 
1005 template<> struct Type_traits<mi::math::Matrix<mi::Float32,2,3> >
1006 {
1007  static const char* get_type_name() { return "Float32<2,3>"; };
1008  typedef mi::IFloat32_2_3 Interface_type;
1009 };
1010 
1011 template<> struct Type_traits<mi::math::Matrix<mi::Float32,2,4> >
1012 {
1013  static const char* get_type_name() { return "Float32<2,4>"; };
1014  typedef mi::IFloat32_2_4 Interface_type;
1015 };
1016 
1017 template<> struct Type_traits<mi::math::Matrix<mi::Float32,3,2> >
1018 {
1019  static const char* get_type_name() { return "Float32<3,2>"; };
1020  typedef mi::IFloat32_3_2 Interface_type;
1021 };
1022 
1023 template<> struct Type_traits<mi::math::Matrix<mi::Float32,3,3> >
1024 {
1025  static const char* get_type_name() { return "Float32<3,3>"; };
1026  typedef mi::IFloat32_3_3 Interface_type;
1027 };
1028 
1029 template<> struct Type_traits<mi::math::Matrix<mi::Float32,3,4> >
1030 {
1031  static const char* get_type_name() { return "Float32<3,4>"; };
1032  typedef mi::IFloat32_3_4 Interface_type;
1033 };
1034 
1035 template<> struct Type_traits<mi::math::Matrix<mi::Float32,4,2> >
1036 {
1037  static const char* get_type_name() { return "Float32<4,2>"; };
1038  typedef mi::IFloat32_4_2 Interface_type;
1039 };
1040 
1041 template<> struct Type_traits<mi::math::Matrix<mi::Float32,4,3> >
1042 {
1043  static const char* get_type_name() { return "Float32<4,3>"; };
1044  typedef mi::IFloat32_4_3 Interface_type;
1045 };
1046 
1047 template<> struct Type_traits<mi::math::Matrix<mi::Float32,4,4> >
1048 {
1049  static const char* get_type_name() { return "Float32<4,4>"; };
1050  typedef mi::IFloat32_4_4 Interface_type;
1051 };
1052 
1053 template<> struct Type_traits<mi::math::Matrix<mi::Float64,2,2> >
1054 {
1055  static const char* get_type_name() { return "Float64<2,2>"; };
1056  typedef mi::IFloat64_2_2 Interface_type;
1057 };
1058 
1059 template<> struct Type_traits<mi::math::Matrix<mi::Float64,2,3> >
1060 {
1061  static const char* get_type_name() { return "Float64<2,3>"; };
1062  typedef mi::IFloat64_2_3 Interface_type;
1063 };
1064 
1065 template<> struct Type_traits<mi::math::Matrix<mi::Float64,2,4> >
1066 {
1067  static const char* get_type_name() { return "Float64<2,4>"; };
1068  typedef mi::IFloat64_2_4 Interface_type;
1069 };
1070 
1071 template<> struct Type_traits<mi::math::Matrix<mi::Float64,3,2> >
1072 {
1073  static const char* get_type_name() { return "Float64<3,2>"; };
1074  typedef mi::IFloat64_3_2 Interface_type;
1075 };
1076 
1077 template<> struct Type_traits<mi::math::Matrix<mi::Float64,3,3> >
1078 {
1079  static const char* get_type_name() { return "Float64<3,3>"; };
1080  typedef mi::IFloat64_3_3 Interface_type;
1081 };
1082 
1083 template<> struct Type_traits<mi::math::Matrix<mi::Float64,3,4> >
1084 {
1085  static const char* get_type_name() { return "Float64<3,4>"; };
1086  typedef mi::IFloat64_3_4 Interface_type;
1087 };
1088 
1089 template<> struct Type_traits<mi::math::Matrix<mi::Float64,4,2> >
1090 {
1091  static const char* get_type_name() { return "Float64<4,2>"; };
1092  typedef mi::IFloat64_4_2 Interface_type;
1093 };
1094 
1095 template<> struct Type_traits<mi::math::Matrix<mi::Float64,4,3> >
1096 {
1097  static const char* get_type_name() { return "Float64<4,3>"; };
1098  typedef mi::IFloat64_4_3 Interface_type;
1099 };
1100 
1101 template<> struct Type_traits<mi::math::Matrix<mi::Float64,4,4> >
1102 {
1103  static const char* get_type_name() { return "Float64<4,4>"; };
1104  typedef mi::IFloat64_4_4 Interface_type;
1105 };
1106 
1107 template<> struct Type_traits<mi::math::Color>
1108 {
1109  static const char* get_type_name() { return "Color"; };
1110  typedef mi::IColor Interface_type;
1111 };
1112 
1113 template<> struct Type_traits<mi::math::Spectrum>
1114 {
1115  static const char* get_type_name() { return "Spectrum"; };
1116  typedef mi::ISpectrum Interface_type;
1117 };
1118 
1119 template<> struct Type_traits<mi::math::Bbox<mi::Float32,3> >
1120 {
1121  static const char* get_type_name() { return "Bbox3"; };
1122  typedef mi::IBbox3 Interface_type;
1123 };
1124 
1125 
1126 template<typename I, Size DIM> struct Vector_type_traits {};
1127 
1128 template<> struct Vector_type_traits<bool, 2>
1129 { typedef mi::IBoolean_2 Interface_type; };
1130 
1131 template<> struct Vector_type_traits<bool, 3>
1132 { typedef mi::IBoolean_3 Interface_type; };
1133 
1134 template<> struct Vector_type_traits<bool, 4>
1135 { typedef mi::IBoolean_4 Interface_type; };
1136 
1137 template<> struct Vector_type_traits<mi::Sint32, 2>
1138 { typedef mi::ISint32_2 Interface_type; };
1139 
1140 template<> struct Vector_type_traits<mi::Sint32, 3>
1141 { typedef mi::ISint32_3 Interface_type; };
1142 
1143 template<> struct Vector_type_traits<mi::Sint32, 4>
1144 { typedef mi::ISint32_4 Interface_type; };
1145 
1146 template<> struct Vector_type_traits<mi::Uint32, 2>
1147 { typedef mi::IUint32_2 Interface_type; };
1148 
1149 template<> struct Vector_type_traits<mi::Uint32, 3>
1150 { typedef mi::IUint32_3 Interface_type; };
1151 
1152 template<> struct Vector_type_traits<mi::Uint32, 4>
1153 { typedef mi::IUint32_4 Interface_type; };
1154 
1155 template<> struct Vector_type_traits<mi::Float32, 2>
1156 { typedef mi::IFloat32_2 Interface_type; };
1157 
1158 template<> struct Vector_type_traits<mi::Float32, 3>
1159 { typedef mi::IFloat32_3 Interface_type; };
1160 
1161 template<> struct Vector_type_traits<mi::Float32, 4>
1162 { typedef mi::IFloat32_4 Interface_type; };
1163 
1164 template<> struct Vector_type_traits<mi::Float64, 2>
1165 { typedef mi::IFloat64_2 Interface_type; };
1166 
1167 template<> struct Vector_type_traits<mi::Float64, 3>
1168 { typedef mi::IFloat64_3 Interface_type; };
1169 
1170 template<> struct Vector_type_traits<mi::Float64, 4>
1171 { typedef mi::IFloat64_4 Interface_type; };
1172 
1173 
1174 template<typename I, Size ROW, Size COL> struct Matrix_type_traits {};
1175 
1176 template<> struct Matrix_type_traits<bool, 2, 2>
1177 { typedef mi::IBoolean_2_2 Interface_type; };
1178 
1179 template<> struct Matrix_type_traits<bool, 2, 3>
1180 { typedef mi::IBoolean_2_3 Interface_type; };
1181 
1182 template<> struct Matrix_type_traits<bool, 2, 4>
1183 { typedef mi::IBoolean_2_4 Interface_type; };
1184 
1185 template<> struct Matrix_type_traits<bool, 3, 2>
1186 { typedef mi::IBoolean_3_2 Interface_type; };
1187 
1188 template<> struct Matrix_type_traits<bool, 3, 3>
1189 { typedef mi::IBoolean_3_3 Interface_type; };
1190 
1191 template<> struct Matrix_type_traits<bool, 3, 4>
1192 { typedef mi::IBoolean_3_4 Interface_type; };
1193 
1194 template<> struct Matrix_type_traits<bool, 4, 2>
1195 { typedef mi::IBoolean_4_2 Interface_type; };
1196 
1197 template<> struct Matrix_type_traits<bool, 4, 3>
1198 { typedef mi::IBoolean_4_3 Interface_type; };
1199 
1200 template<> struct Matrix_type_traits<bool, 4, 4>
1201 { typedef mi::IBoolean_4_4 Interface_type; };
1202 
1203 template<> struct Matrix_type_traits<mi::Sint32, 2, 2>
1204 { typedef mi::ISint32_2_2 Interface_type; };
1205 
1206 template<> struct Matrix_type_traits<mi::Sint32, 2, 3>
1207 { typedef mi::ISint32_2_3 Interface_type; };
1208 
1209 template<> struct Matrix_type_traits<mi::Sint32, 2, 4>
1210 { typedef mi::ISint32_2_4 Interface_type; };
1211 
1212 template<> struct Matrix_type_traits<mi::Sint32, 3, 2>
1213 { typedef mi::ISint32_3_2 Interface_type; };
1214 
1215 template<> struct Matrix_type_traits<mi::Sint32, 3, 3>
1216 { typedef mi::ISint32_3_3 Interface_type; };
1217 
1218 template<> struct Matrix_type_traits<mi::Sint32, 3, 4>
1219 { typedef mi::ISint32_3_4 Interface_type; };
1220 
1221 template<> struct Matrix_type_traits<mi::Sint32, 4, 2>
1222 { typedef mi::ISint32_4_2 Interface_type; };
1223 
1224 template<> struct Matrix_type_traits<mi::Sint32, 4, 3>
1225 { typedef mi::ISint32_4_3 Interface_type; };
1226 
1227 template<> struct Matrix_type_traits<mi::Sint32, 4, 4>
1228 { typedef mi::ISint32_4_4 Interface_type; };
1229 
1230 template<> struct Matrix_type_traits<mi::Float32, 2, 2>
1231 { typedef mi::IFloat32_2_2 Interface_type; };
1232 
1233 template<> struct Matrix_type_traits<mi::Float32, 2, 3>
1234 { typedef mi::IFloat32_2_3 Interface_type; };
1235 
1236 template<> struct Matrix_type_traits<mi::Float32, 2, 4>
1237 { typedef mi::IFloat32_2_4 Interface_type; };
1238 
1239 template<> struct Matrix_type_traits<mi::Float32, 3, 2>
1240 { typedef mi::IFloat32_3_2 Interface_type; };
1241 
1242 template<> struct Matrix_type_traits<mi::Float32, 3, 3>
1243 { typedef mi::IFloat32_3_3 Interface_type; };
1244 
1245 template<> struct Matrix_type_traits<mi::Float32, 3, 4>
1246 { typedef mi::IFloat32_3_4 Interface_type; };
1247 
1248 template<> struct Matrix_type_traits<mi::Float32, 4, 2>
1249 { typedef mi::IFloat32_4_2 Interface_type; };
1250 
1251 template<> struct Matrix_type_traits<mi::Float32, 4, 3>
1252 { typedef mi::IFloat32_4_3 Interface_type; };
1253 
1254 template<> struct Matrix_type_traits<mi::Float32, 4, 4>
1255 { typedef mi::IFloat32_4_4 Interface_type; };
1256 
1257 template<> struct Matrix_type_traits<mi::Float64, 2, 2>
1258 { typedef mi::IFloat64_2_2 Interface_type; };
1259 
1260 template<> struct Matrix_type_traits<mi::Float64, 2, 3>
1261 { typedef mi::IFloat64_2_3 Interface_type; };
1262 
1263 template<> struct Matrix_type_traits<mi::Float64, 2, 4>
1264 { typedef mi::IFloat64_2_4 Interface_type; };
1265 
1266 template<> struct Matrix_type_traits<mi::Float64, 3, 2>
1267 { typedef mi::IFloat64_3_2 Interface_type; };
1268 
1269 template<> struct Matrix_type_traits<mi::Float64, 3, 3>
1270 { typedef mi::IFloat64_3_3 Interface_type; };
1271 
1272 template<> struct Matrix_type_traits<mi::Float64, 3, 4>
1273 { typedef mi::IFloat64_3_4 Interface_type; };
1274 
1275 template<> struct Matrix_type_traits<mi::Float64, 4, 2>
1276 { typedef mi::IFloat64_4_2 Interface_type; };
1277 
1278 template<> struct Matrix_type_traits<mi::Float64, 4, 3>
1279 { typedef mi::IFloat64_4_3 Interface_type; };
1280 
1281 template<> struct Matrix_type_traits<mi::Float64, 4, 4>
1282 { typedef mi::IFloat64_4_4 Interface_type; };
1283  // end group mi_neuray_types
1285 
1286 } // namespace mi
1287 
1288 #endif // MI_NEURAYLIB_TYPE_TRAITS_H