MDL SDK API nvidia_logo_transpbg.gif Up
type_traits.h
Go to the documentation of this file.
1/***************************************************************************************************
2 * Copyright 2022 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
20namespace mi {
21
26class IData;
27class IBoolean;
28class ISint8;
29class ISint16;
30class ISint32;
31class ISint64;
32class IUint8;
33class IUint16;
34class IUint32;
35class IUint64;
36class IFloat32;
37class IFloat64;
38class ISize;
39class IDifference;
40class IString;
41class IUuid;
42class IVoid;
43class IRef;
44class IBoolean_2;
45class IBoolean_3;
46class IBoolean_4;
47class ISint32_2;
48class ISint32_3;
49class ISint32_4;
50class IUint32_2;
51class IUint32_3;
52class IUint32_4;
53class IFloat32_2;
54class IFloat32_3;
55class IFloat32_4;
56class IFloat64_2;
57class IFloat64_3;
58class IFloat64_4;
59class IBoolean_2_2;
60class IBoolean_2_3;
61class IBoolean_2_4;
62class IBoolean_3_2;
63class IBoolean_3_3;
64class IBoolean_3_4;
65class IBoolean_4_2;
66class IBoolean_4_3;
67class IBoolean_4_4;
68class ISint32_2_2;
69class ISint32_2_3;
70class ISint32_2_4;
71class ISint32_3_2;
72class ISint32_3_3;
73class ISint32_3_4;
74class ISint32_4_2;
75class ISint32_4_3;
76class ISint32_4_4;
77class IUint32_2_2;
78class IUint32_2_3;
79class IUint32_2_4;
80class IUint32_3_2;
81class IUint32_3_3;
82class IUint32_3_4;
83class IUint32_4_2;
84class IUint32_4_3;
85class IUint32_4_4;
86class IFloat32_2_2;
87class IFloat32_2_3;
88class IFloat32_2_4;
89class IFloat32_3_2;
90class IFloat32_3_3;
91class IFloat32_3_4;
92class IFloat32_4_2;
93class IFloat32_4_3;
94class IFloat32_4_4;
95class IFloat64_2_2;
96class IFloat64_2_3;
97class IFloat64_2_4;
98class IFloat64_3_2;
99class IFloat64_3_3;
100class IFloat64_3_4;
101class IFloat64_4_2;
102class IFloat64_4_3;
103class IFloat64_4_4;
104class IColor;
105class IColor3;
106class ISpectrum;
107class IBbox3;
108
162template<typename I> struct Type_traits {};
163
164template<> struct Type_traits<mi::IBoolean>
165{
166 static const char* get_type_name() { return "Boolean"; }
167 typedef bool Primitive_type;
168};
169
170template<> struct Type_traits<mi::ISint8>
171{
172 static const char* get_type_name() { return "Sint8"; }
173 typedef mi::Sint8 Primitive_type;
174};
175
176template<> struct Type_traits<mi::ISint16>
177{
178 static const char* get_type_name() { return "Sint16"; }
179 typedef mi::Sint16 Primitive_type;
180};
181
182template<> struct Type_traits<mi::ISint32>
183{
184 static const char* get_type_name() { return "Sint32"; }
185 typedef mi::Sint32 Primitive_type;
186};
187
188template<> struct Type_traits<mi::ISint64>
189{
190 static const char* get_type_name() { return "Sint64"; }
191 typedef mi::Sint64 Primitive_type;
192};
193
194template<> struct Type_traits<mi::IUint8>
195{
196 static const char* get_type_name() { return "Uint8"; }
197 typedef mi::Uint8 Primitive_type;
198};
199
200template<> struct Type_traits<mi::IUint16>
201{
202 static const char* get_type_name() { return "Uint16"; }
203 typedef mi::Uint16 Primitive_type;
204};
205
206template<> struct Type_traits<mi::IUint32>
207{
208 static const char* get_type_name() { return "Uint32"; }
209 typedef mi::Uint32 Primitive_type;
210};
211
212template<> struct Type_traits<mi::IUint64>
213{
214 static const char* get_type_name() { return "Uint64"; }
215 typedef mi::Uint64 Primitive_type;
216};
217
218template<> struct Type_traits<mi::IFloat32>
219{
220 static const char* get_type_name() { return "Float32"; }
221 typedef mi::Float32 Primitive_type;
222};
223
224template<> struct Type_traits<mi::IFloat64>
225{
226 static const char* get_type_name() { return "Float64"; }
227 typedef mi::Float64 Primitive_type;
228};
229
230template<> struct Type_traits<mi::ISize>
231{
232 static const char* get_type_name() { return "Size"; }
233 typedef mi::Size Primitive_type;
234};
235
236template<> struct Type_traits<mi::IDifference>
237{
238 static const char* get_type_name() { return "Difference"; }
239 typedef mi::Difference Primitive_type;
240};
241
242template<> struct Type_traits<mi::IString>
243{
244 static const char* get_type_name() { return "String"; }
245 typedef const char* Primitive_type;
246};
247
248template<> struct Type_traits<mi::IUuid>
249{
250 static const char* get_type_name() { return "Uuid"; }
251 typedef mi::base::Uuid Primitive_type;
252};
253
254template<> struct Type_traits<mi::IVoid>
255{
256 static const char* get_type_name() { return "Void"; }
257 typedef void Primitive_type;
258};
259
260template<> struct Type_traits<mi::IRef>
261{
262 static const char* get_type_name() { return "Ref"; }
263 typedef const char* Primitive_type;
264};
265
266template<> 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
272template<> 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
278template<> 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
284template<> 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
290template<> 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
296template<> 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
302template<> 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
308template<> 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
314template<> 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
320template<> 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
326template<> 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
332template<> 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
338template<> 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
344template<> 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
350template<> 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
356template<> 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
362template<> 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
368template<> 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
374template<> 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
380template<> 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
386template<> 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
392template<> 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
398template<> 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
404template<> 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
410template<> 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
416template<> 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
422template<> 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
428template<> 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
434template<> 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
440template<> 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
446template<> 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
452template<> 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
458template<> 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
464template<> 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
470template<> 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
476template<> 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
482template<> 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
488template<> 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
494template<> 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
500template<> 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
506template<> 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
512template<> 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
518template<> 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
524template<> 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
530template<> 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
536template<> 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
542template<> 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
548template<> 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
554template<> 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
560template<> 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
566template<> 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
572template<> 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
578template<> 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
584template<> 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
590template<> 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
596template<> 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
602template<> 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
608template<> 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
614template<> 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
620template<> 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
626template<> struct Type_traits<mi::IColor>
627{
628 static const char* get_type_name() { return "Color"; }
629 typedef mi::math::Color Primitive_type;
630};
631
632template<> struct Type_traits<mi::IColor3>
633{
634 static const char* get_type_name() { return "Color3"; }
635 typedef mi::math::Color Primitive_type;
636};
637
638template<> struct Type_traits<mi::ISpectrum>
639{
640 static const char* get_type_name() { return "Spectrum"; }
641 typedef mi::math::Spectrum Primitive_type;
642};
643
644template<> 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
651template<> struct Type_traits<bool>
652{
653 static const char* get_type_name() { return "Boolean"; };
654 typedef mi::IBoolean Interface_type;
655};
656
657template<> struct Type_traits<mi::Sint8>
658{
659 static const char* get_type_name() { return "Sint8"; };
660 typedef mi::ISint8 Interface_type;
661};
662
663template<> struct Type_traits<mi::Sint16>
664{
665 static const char* get_type_name() { return "Sint16"; };
666 typedef mi::ISint16 Interface_type;
667};
668
669template<> struct Type_traits<mi::Sint32>
670{
671 static const char* get_type_name() { return "Sint32"; };
672 typedef mi::ISint32 Interface_type;
673};
674
675template<> struct Type_traits<mi::Sint64>
676{
677 static const char* get_type_name() { return "Sint64"; };
678 typedef mi::ISint64 Interface_type;
679};
680
681template<> struct Type_traits<mi::Uint8>
682{
683 static const char* get_type_name() { return "Uint8"; };
684 typedef mi::IUint8 Interface_type;
685};
686
687template<> struct Type_traits<mi::Uint16>
688{
689 static const char* get_type_name() { return "Uint16"; };
690 typedef mi::IUint16 Interface_type;
691};
692
693template<> struct Type_traits<mi::Uint32>
694{
695 static const char* get_type_name() { return "Uint32"; };
696 typedef mi::IUint32 Interface_type;
697};
698
699template<> struct Type_traits<mi::Uint64>
700{
701 static const char* get_type_name() { return "Uint64"; };
702 typedef mi::IUint64 Interface_type;
703};
704
705template<> struct Type_traits<mi::Float32>
706{
707 static const char* get_type_name() { return "Float32"; };
708 typedef mi::IFloat32 Interface_type;
709};
710
711template<> struct Type_traits<mi::Float64>
712{
713 static const char* get_type_name() { return "Float64"; };
714 typedef mi::IFloat64 Interface_type;
715};
716
717template<> struct Type_traits<const char*>
718{
719 static const char* get_type_name() { return "String"; };
720 typedef mi::IString Interface_type;
721};
722
723template<> struct Type_traits<std::string>
724{
725 static const char* get_type_name() { return "String"; };
726 typedef mi::IString Interface_type;
727};
728
729template<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
735template<> struct Type_traits<mi::base::Uuid>
736{
737 static const char* get_type_name() { return "Uuid"; };
738 typedef mi::IUuid Interface_type;
739};
740
741template<> struct Type_traits<void>
742{
743 static const char* get_type_name() { return "Void"; };
744 typedef mi::IVoid Interface_type;
745};
746
747template<> 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
753template<> 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
759template<> 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
765template<> 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
771template<> 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
777template<> 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
783template<> 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
789template<> 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
795template<> 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
801template<> 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
807template<> 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
813template<> 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
819template<> 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
825template<> 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
831template<> 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
837template<> 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
843template<> 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
849template<> 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
855template<> 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
861template<> 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
867template<> 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
873template<> 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
879template<> 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
885template<> 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
891template<> 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
897template<> 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
903template<> 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
909template<> 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
915template<> 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
921template<> 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
927template<> 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
933template<> 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
939template<> 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
945template<> 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
951template<> 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
957template<> 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
963template<> 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
969template<> 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
975template<> 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
981template<> 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
987template<> 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
993template<> 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
999template<> 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
1005template<> 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
1011template<> 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
1017template<> 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
1023template<> 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
1029template<> 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
1035template<> 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
1041template<> 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
1047template<> 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
1053template<> 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
1059template<> 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
1065template<> 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
1071template<> 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
1077template<> 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
1083template<> 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
1089template<> 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
1095template<> 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
1101template<> 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
1107template<> struct Type_traits<mi::math::Color>
1108{
1109 static const char* get_type_name() { return "Color"; };
1110 typedef mi::IColor Interface_type;
1111};
1112
1113template<> struct Type_traits<mi::math::Spectrum>
1114{
1115 static const char* get_type_name() { return "Spectrum"; };
1116 typedef mi::ISpectrum Interface_type;
1117};
1118
1119template<> 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
1126template<typename I, Size DIM> struct Vector_type_traits {};
1127
1128template<> struct Vector_type_traits<bool, 2>
1129{ typedef mi::IBoolean_2 Interface_type; };
1130
1131template<> struct Vector_type_traits<bool, 3>
1132{ typedef mi::IBoolean_3 Interface_type; };
1133
1134template<> struct Vector_type_traits<bool, 4>
1135{ typedef mi::IBoolean_4 Interface_type; };
1136
1137template<> struct Vector_type_traits<mi::Sint32, 2>
1138{ typedef mi::ISint32_2 Interface_type; };
1139
1140template<> struct Vector_type_traits<mi::Sint32, 3>
1141{ typedef mi::ISint32_3 Interface_type; };
1142
1143template<> struct Vector_type_traits<mi::Sint32, 4>
1144{ typedef mi::ISint32_4 Interface_type; };
1145
1146template<> struct Vector_type_traits<mi::Uint32, 2>
1147{ typedef mi::IUint32_2 Interface_type; };
1148
1149template<> struct Vector_type_traits<mi::Uint32, 3>
1150{ typedef mi::IUint32_3 Interface_type; };
1151
1152template<> struct Vector_type_traits<mi::Uint32, 4>
1153{ typedef mi::IUint32_4 Interface_type; };
1154
1155template<> struct Vector_type_traits<mi::Float32, 2>
1156{ typedef mi::IFloat32_2 Interface_type; };
1157
1158template<> struct Vector_type_traits<mi::Float32, 3>
1159{ typedef mi::IFloat32_3 Interface_type; };
1160
1161template<> struct Vector_type_traits<mi::Float32, 4>
1162{ typedef mi::IFloat32_4 Interface_type; };
1163
1164template<> struct Vector_type_traits<mi::Float64, 2>
1165{ typedef mi::IFloat64_2 Interface_type; };
1166
1167template<> struct Vector_type_traits<mi::Float64, 3>
1168{ typedef mi::IFloat64_3 Interface_type; };
1169
1170template<> struct Vector_type_traits<mi::Float64, 4>
1171{ typedef mi::IFloat64_4 Interface_type; };
1172
1173
1174template<typename I, Size ROW, Size COL> struct Matrix_type_traits {};
1175
1176template<> struct Matrix_type_traits<bool, 2, 2>
1177{ typedef mi::IBoolean_2_2 Interface_type; };
1178
1179template<> struct Matrix_type_traits<bool, 2, 3>
1180{ typedef mi::IBoolean_2_3 Interface_type; };
1181
1182template<> struct Matrix_type_traits<bool, 2, 4>
1183{ typedef mi::IBoolean_2_4 Interface_type; };
1184
1185template<> struct Matrix_type_traits<bool, 3, 2>
1186{ typedef mi::IBoolean_3_2 Interface_type; };
1187
1188template<> struct Matrix_type_traits<bool, 3, 3>
1189{ typedef mi::IBoolean_3_3 Interface_type; };
1190
1191template<> struct Matrix_type_traits<bool, 3, 4>
1192{ typedef mi::IBoolean_3_4 Interface_type; };
1193
1194template<> struct Matrix_type_traits<bool, 4, 2>
1195{ typedef mi::IBoolean_4_2 Interface_type; };
1196
1197template<> struct Matrix_type_traits<bool, 4, 3>
1198{ typedef mi::IBoolean_4_3 Interface_type; };
1199
1200template<> struct Matrix_type_traits<bool, 4, 4>
1201{ typedef mi::IBoolean_4_4 Interface_type; };
1202
1203template<> struct Matrix_type_traits<mi::Sint32, 2, 2>
1204{ typedef mi::ISint32_2_2 Interface_type; };
1205
1206template<> struct Matrix_type_traits<mi::Sint32, 2, 3>
1207{ typedef mi::ISint32_2_3 Interface_type; };
1208
1209template<> struct Matrix_type_traits<mi::Sint32, 2, 4>
1210{ typedef mi::ISint32_2_4 Interface_type; };
1211
1212template<> struct Matrix_type_traits<mi::Sint32, 3, 2>
1213{ typedef mi::ISint32_3_2 Interface_type; };
1214
1215template<> struct Matrix_type_traits<mi::Sint32, 3, 3>
1216{ typedef mi::ISint32_3_3 Interface_type; };
1217
1218template<> struct Matrix_type_traits<mi::Sint32, 3, 4>
1219{ typedef mi::ISint32_3_4 Interface_type; };
1220
1221template<> struct Matrix_type_traits<mi::Sint32, 4, 2>
1222{ typedef mi::ISint32_4_2 Interface_type; };
1223
1224template<> struct Matrix_type_traits<mi::Sint32, 4, 3>
1225{ typedef mi::ISint32_4_3 Interface_type; };
1226
1227template<> struct Matrix_type_traits<mi::Sint32, 4, 4>
1228{ typedef mi::ISint32_4_4 Interface_type; };
1229
1230template<> struct Matrix_type_traits<mi::Float32, 2, 2>
1231{ typedef mi::IFloat32_2_2 Interface_type; };
1232
1233template<> struct Matrix_type_traits<mi::Float32, 2, 3>
1234{ typedef mi::IFloat32_2_3 Interface_type; };
1235
1236template<> struct Matrix_type_traits<mi::Float32, 2, 4>
1237{ typedef mi::IFloat32_2_4 Interface_type; };
1238
1239template<> struct Matrix_type_traits<mi::Float32, 3, 2>
1240{ typedef mi::IFloat32_3_2 Interface_type; };
1241
1242template<> struct Matrix_type_traits<mi::Float32, 3, 3>
1243{ typedef mi::IFloat32_3_3 Interface_type; };
1244
1245template<> struct Matrix_type_traits<mi::Float32, 3, 4>
1246{ typedef mi::IFloat32_3_4 Interface_type; };
1247
1248template<> struct Matrix_type_traits<mi::Float32, 4, 2>
1249{ typedef mi::IFloat32_4_2 Interface_type; };
1250
1251template<> struct Matrix_type_traits<mi::Float32, 4, 3>
1252{ typedef mi::IFloat32_4_3 Interface_type; };
1253
1254template<> struct Matrix_type_traits<mi::Float32, 4, 4>
1255{ typedef mi::IFloat32_4_4 Interface_type; };
1256
1257template<> struct Matrix_type_traits<mi::Float64, 2, 2>
1258{ typedef mi::IFloat64_2_2 Interface_type; };
1259
1260template<> struct Matrix_type_traits<mi::Float64, 2, 3>
1261{ typedef mi::IFloat64_2_3 Interface_type; };
1262
1263template<> struct Matrix_type_traits<mi::Float64, 2, 4>
1264{ typedef mi::IFloat64_2_4 Interface_type; };
1265
1266template<> struct Matrix_type_traits<mi::Float64, 3, 2>
1267{ typedef mi::IFloat64_3_2 Interface_type; };
1268
1269template<> struct Matrix_type_traits<mi::Float64, 3, 3>
1270{ typedef mi::IFloat64_3_3 Interface_type; };
1271
1272template<> struct Matrix_type_traits<mi::Float64, 3, 4>
1273{ typedef mi::IFloat64_3_4 Interface_type; };
1274
1275template<> struct Matrix_type_traits<mi::Float64, 4, 2>
1276{ typedef mi::IFloat64_4_2 Interface_type; };
1277
1278template<> struct Matrix_type_traits<mi::Float64, 4, 3>
1279{ typedef mi::IFloat64_4_3 Interface_type; };
1280
1281template<> 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
An axis-aligned N-dimensional bounding box class template of fixed dimension with supporting function...
This interface represents bounding boxes.
Definition: ibbox.h:28
This interface represents a 2 x 2 matrix of bool.
Definition: imatrix.h:29
This interface represents a 2 x 3 matrix of bool.
Definition: imatrix.h:53
This interface represents a 2 x 4 matrix of bool.
Definition: imatrix.h:75
This interface represents a vector of two bool.
Definition: ivector.h:26
This interface represents a 3 x 2 matrix of bool.
Definition: imatrix.h:97
This interface represents a 3 x 3 matrix of bool.
Definition: imatrix.h:119
This interface represents a 3 x 4 matrix of bool.
Definition: imatrix.h:141
This interface represents a vector of three bool.
Definition: ivector.h:48
This interface represents a 4 x 2 matrix of bool.
Definition: imatrix.h:163
This interface represents a 4 x 3 matrix of bool.
Definition: imatrix.h:185
This interface represents a 4 x 4 matrix of bool.
Definition: imatrix.h:207
This interface represents a vector of four bool.
Definition: ivector.h:70
This interface represents bool.
Definition: inumber.h:122
This interface represents RGBA colors.
Definition: icolor.h:28
This interface represents a 2 x 2 matrix of Float32.
Definition: imatrix.h:631
This interface represents a 2 x 3 matrix of Float32.
Definition: imatrix.h:653
This interface represents a 2 x 4 matrix of Float32.
Definition: imatrix.h:675
This interface represents a vector of two Float32.
Definition: ivector.h:227
This interface represents a 3 x 2 matrix of Float32.
Definition: imatrix.h:697
This interface represents a 3 x 3 matrix of Float32.
Definition: imatrix.h:719
This interface represents a 3 x 4 matrix of Float32.
Definition: imatrix.h:741
This interface represents a vector of three Float32.
Definition: ivector.h:249
This interface represents a 4 x 2 matrix of Float32.
Definition: imatrix.h:763
This interface represents a 4 x 3 matrix of Float32.
Definition: imatrix.h:785
This interface represents a 4 x 4 matrix of Float32.
Definition: imatrix.h:807
This interface represents a vector of four Float32.
Definition: ivector.h:271
This interface represents mi::Float32.
Definition: inumber.h:221
This interface represents a 2 x 2 matrix of Float64.
Definition: imatrix.h:831
This interface represents a 2 x 3 matrix of Float64.
Definition: imatrix.h:853
This interface represents a 2 x 4 matrix of Float64.
Definition: imatrix.h:875
This interface represents a vector of two Float64.
Definition: ivector.h:294
This interface represents a 3 x 2 matrix of Float64.
Definition: imatrix.h:897
This interface represents a 3 x 3 matrix of Float64.
Definition: imatrix.h:919
This interface represents a 3 x 4 matrix of Float64.
Definition: imatrix.h:941
This interface represents a vector of three Float64.
Definition: ivector.h:316
This interface represents a 4 x 2 matrix of Float64.
Definition: imatrix.h:963
This interface represents a 4 x 3 matrix of Float64.
Definition: imatrix.h:985
This interface represents a 4 x 4 matrix of Float64.
Definition: imatrix.h:1007
This interface represents a vector of four Float64.
Definition: ivector.h:338
This interface represents mi::Float64.
Definition: inumber.h:232
This interface represents mi::Sint16.
Definition: inumber.h:188
This interface represents a 2 x 2 matrix of Sint32.
Definition: imatrix.h:231
This interface represents a 2 x 3 matrix of Sint32.
Definition: imatrix.h:253
This interface represents a 2 x 4 matrix of Sint32.
Definition: imatrix.h:275
This interface represents a vector of two Sint32.
Definition: ivector.h:93
This interface represents a 3 x 2 matrix of Sint32.
Definition: imatrix.h:297
This interface represents a 3 x 3 matrix of Sint32.
Definition: imatrix.h:319
This interface represents a 3 x 4 matrix of Sint32.
Definition: imatrix.h:341
This interface represents a vector of three Sint32.
Definition: ivector.h:115
This interface represents a 4 x 2 matrix of Sint32.
Definition: imatrix.h:363
This interface represents a 4 x 3 matrix of Sint32.
Definition: imatrix.h:385
This interface represents a 4 x 4 matrix of Sint32.
Definition: imatrix.h:407
This interface represents a vector of four Sint32.
Definition: ivector.h:137
This interface represents mi::Sint32.
Definition: inumber.h:199
This interface represents mi::Sint64.
Definition: inumber.h:210
This interface represents mi::Sint8.
Definition: inumber.h:177
This interface represents spectrums.
Definition: ispectrum.h:28
A simple string class.
Definition: istring.h:22
This interface represents mi::Uint16.
Definition: inumber.h:144
This interface represents a 2 x 2 matrix of Uint32.
Definition: imatrix.h:431
This interface represents a 2 x 3 matrix of Uint32.
Definition: imatrix.h:453
This interface represents a 2 x 4 matrix of Uint32.
Definition: imatrix.h:475
This interface represents a vector of two Uint32.
Definition: ivector.h:160
This interface represents a 3 x 2 matrix of Uint32.
Definition: imatrix.h:497
This interface represents a 3 x 3 matrix of Uint32.
Definition: imatrix.h:519
This interface represents a 3 x 4 matrix of Uint32.
Definition: imatrix.h:541
This interface represents a vector of three Uint32.
Definition: ivector.h:182
This interface represents a 4 x 2 matrix of Uint32.
Definition: imatrix.h:563
This interface represents a 4 x 3 matrix of Uint32.
Definition: imatrix.h:585
This interface represents a 4 x 4 matrix of Uint32.
Definition: imatrix.h:607
This interface represents a vector of four Uint32.
Definition: ivector.h:204
This interface represents mi::Uint32.
Definition: inumber.h:155
This interface represents mi::Uint64.
Definition: inumber.h:166
This interface represents mi::Uint8.
Definition: inumber.h:133
This interface represents UUIDs.
Definition: iuuid.h:24
This interface represents the void type.
Definition: idata.h:523
Axis-aligned N-dimensional bounding box class template of fixed dimension.
Definition: bbox.h:74
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
Standard RGBA color class with floating point elements and operations.
long long Sint64
64-bit signed integer.
Definition: types.h:59
unsigned long long Uint64
64-bit unsigned integer.
Definition: types.h:60
signed short Sint16
16-bit signed integer.
Definition: types.h:43
unsigned int Uint32
32-bit unsigned integer.
Definition: types.h:47
unsigned char Uint8
8-bit unsigned integer.
Definition: types.h:45
Sint64 Difference
Signed integral type that is large enough to hold the difference of two pointers.
Definition: types.h:120
Uint64 Size
Unsigned integral type that is large enough to hold the size of all types.
Definition: types.h:110
signed char Sint8
8-bit signed integer.
Definition: types.h:42
double Float64
64-bit float.
Definition: types.h:50
float Float32
32-bit float.
Definition: types.h:49
unsigned short Uint16
16-bit unsigned integer.
Definition: types.h:46
signed int Sint32
32-bit signed integer.
Definition: types.h:44
math::Spectrum Spectrum
Spectrum class.
Definition: typedefs.h:47
math::Color Color
RGBA color class.
Definition: typedefs.h:28
Mixin class template for deriving new interface declarations.
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.
Type traits relating interfaces, corresponding primitive types, and their type names.
Definition: type_traits.h:162
A 128 bit representation of a universally unique identifier (UUID or GUID).
Definition: uuid.h:26
A 128 bit representation of a universally unique identifier (UUID or GUID).
Math vector class template of fixed dimension with arithmetic operators and generic functions.