Coin: SbTypeInfo.h Source File

| Coin3D is Free Software, published under the BSD 3-clause license. | https://coin3d.github.io https://www.kongsberg.com/en/kogt/

SbTypeInfo.h
1#ifndef COIN_SBTYPEINFO_H
2#define COIN_SBTYPEINFO_H
3
4/**************************************************************************\
5 * Copyright (c) Kongsberg Oil & Gas Technologies AS
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
10 * met:
11 *
12 * Redistributions of source code must retain the above copyright notice,
13 * this list of conditions and the following disclaimer.
14 *
15 * Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * Neither the name of the copyright holder nor the names of its
20 * contributors may be used to endorse or promote products derived from
21 * this software without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34\**************************************************************************/
35
36// SbTypeInfo<> is a Coin type information library.
37
61
62#ifndef DOXYGEN_SKIP_THIS
63
64#include <Inventor/system/inttypes.h>
65#include <Inventor/C/basic.h>
66
67// *************************************************************************
68// Predeclarations
69
70// Sb-classes
71class SbVec2b;
72class SbVec2ub;
73class SbVec2s;
74class SbVec2us;
75class SbVec2i32;
76class SbVec2ui32;
77class SbVec2f;
78class SbVec2d;
79class SbVec3b;
80class SbVec3ub;
81class SbVec3s;
82class SbVec3us;
83class SbVec3i32;
84class SbVec3ui32;
85class SbVec3f;
86class SbVec3d;
87class SbVec4b;
88class SbVec4ub;
89class SbVec4s;
90class SbVec4us;
91class SbVec4i32;
92class SbVec4ui32;
93class SbVec4f;
94class SbVec4d;
95
96class SbBox2s;
97class SbBox2i32;
98class SbBox2f;
99class SbBox2d;
100class SbBox3s;
101class SbBox3i32;
102class SbBox3f;
103class SbBox3d;
104
105class SbLine;
106class SbDPLine;
107class SbPlane;
108class SbDPPlane;
109class SbMatrix;
110class SbDPMatrix;
111class SbRotation;
112class SbDPRotation;
113
114class SbTime;
115class SbName;
116class SbColor;
117class SbColor4f;
118class SbString;
119
120// Field classes
121class SoSFBitMask;
122class SoSFBool;
123class SoSFBox2s;
124class SoSFBox2i32;
125class SoSFBox2f;
126class SoSFBox2d;
127class SoSFBox3s;
128class SoSFBox3i32;
129class SoSFBox3f;
130class SoSFBox3d;
131class SoSFColor;
132class SoSFColorRGBA;
133class SoSFEngine;
134class SoSFEnum;
135class SoSFImage3;
136class SoSFImage;
137class SoSFMatrix;
138class SoSFName;
139class SoSFNode;
140class SoSFPath;
141class SoSFPlane;
142class SoSFRotation;
143class SoSFString;
144class SoSFTime;
145class SoSFTrigger;
146
147class SoSFShort;
148class SoSFUShort;
149class SoSFInt32;
150class SoSFUInt32;
151class SoSFLong;
152class SoSFULong;
153class SoSFFloat;
154class SoSFDouble;
155
156class SoSFVec2b;
157class SoSFVec2s;
158class SoSFVec2i32;
159class SoSFVec2f;
160class SoSFVec2d;
161class SoSFVec3b;
162class SoSFVec3s;
163class SoSFVec3i32;
164class SoSFVec3f;
165class SoSFVec3d;
166class SoSFVec4b;
167class SoSFVec4ub;
168class SoSFVec4s;
169class SoSFVec4us;
170class SoSFVec4i32;
171class SoSFVec4ui32;
172class SoSFVec4f;
173class SoSFVec4d;
174
175class SoMFBitMask;
176class SoMFBool;
177class SoMFColor;
178class SoMFColorRGBA;
179class SoMFDouble;
180class SoMFEngine;
181class SoMFEnum;
182class SoMFFloat;
183class SoMFInt32;
184class SoMFLong;
185class SoMFMatrix;
186class SoMFName;
187class SoMFNode;
188class SoMFPath;
189class SoMFPlane;
190class SoMFRotation;
191class SoMFShort;
192class SoMFString;
193class SoMFTime;
194class SoMFUInt32;
195class SoMFULong;
196class SoMFUShort;
197class SoMFVec2b;
198class SoMFVec2s;
199class SoMFVec2i32;
200class SoMFVec2f;
201class SoMFVec2d;
202class SoMFVec3b;
203class SoMFVec3s;
204class SoMFVec3i32;
205class SoMFVec3f;
206class SoMFVec3d;
207class SoMFVec4b;
208class SoMFVec4ub;
209class SoMFVec4s;
210class SoMFVec4us;
211class SoMFVec4i32;
212class SoMFVec4ui32;
213class SoMFVec4f;
214class SoMFVec4d;
215
216class SoEngine;
217class SoNode;
218class SoPath;
219
220// *************************************************************************
221
222// namespace SIM { namespace Coin3D { namespace Coin {
223
224template <typename T>
225struct SbTypeInfo {
226 typedef T Type;
227 typedef const T & ParamType;
228}; // fallback
229
230template <>
231struct SbTypeInfo<float> {
232 typedef float Type;
233 typedef float PrimitiveType;
234 enum { isPrimitive = 1 };
235
236 typedef Type ParamType;
237
238 enum { Dimensions = 1 };
239
240 typedef SbVec2f Vec2Type;
241 typedef SbVec3f Vec3Type;
242 typedef SbVec4f Vec4Type;
243 typedef SbBox2f Box2Type;
244 typedef SbBox3f Box3Type;
245
246 typedef SoSFFloat SFieldType;
247 typedef SoMFFloat MFieldType;
248
249 typedef SbPlane PlaneType;
250 typedef SbLine LineType;
251 typedef SbMatrix MatrixType;
252 typedef SbRotation RotationType;
253};
254
255template<typename PrimitiveType, unsigned int dim>
256struct Vec
257{
258};
259template<typename PrimitiveType>
260struct Vec<PrimitiveType,2>
261{
262 typedef typename SbTypeInfo<PrimitiveType>::Vec2Type Type;
263};
264template<typename PrimitiveType>
265struct Vec<PrimitiveType,3>
266{
267 typedef typename SbTypeInfo<PrimitiveType>::Vec3Type Type;
268};
269
270template<typename PrimitiveType>
271struct Vec<PrimitiveType,4>
272{
273 typedef typename SbTypeInfo<PrimitiveType>::Vec4Type Type;
274};
275
276
277
278//This should have been a template for SbBool, but since SbBool is an
279//int, we would risk unwanted behaviour for ints.
280template <>
281struct SbTypeInfo<bool> {
282 typedef bool Type;
283 typedef bool PrimitiveType;
284 enum { isPrimitive = 1 };
285
286 typedef Type ParamType;
287
288 enum { Dimensions = 1 };
289
290 typedef SoSFBool SFieldType;
291 typedef SoMFBool MFieldType;
292};
293
294template <>
295struct SbTypeInfo<double> {
296 typedef double Type;
297 typedef Type ParamType;
298
299 enum { isPrimitive = 1 };
300
301 enum { Dimensions = 1 };
302
303 typedef SbVec2d Vec2Type;
304 typedef SbVec3d Vec3Type;
305 typedef SbVec4d Vec4Type;
306 typedef SbBox2d Box2Type;
307 typedef SbBox3d Box3Type;
308
309 typedef SoSFDouble SFieldType;
310 typedef SoMFDouble MFieldType;
311
312 typedef SbDPPlane PlaneType;
313 typedef SbDPLine LineType;
314 typedef SbDPMatrix MatrixType;
315 typedef SbDPRotation RotationType;
316};
317
318template <>
319struct SbTypeInfo<int8_t> {
320 typedef int8_t Type;
321 typedef Type ParamType;
322
323 typedef SbVec2b Vec2Type;
324 typedef SbVec3b Vec3Type;
325 typedef SbVec4b Vec4Type;
326};
327
328template <>
329struct SbTypeInfo<uint8_t> {
330 typedef uint8_t Type;
331 typedef Type ParamType;
332
333 typedef SbVec2ub Vec2Type;
334 typedef SbVec3ub Vec3Type;
335 typedef SbVec4ub Vec4Type;
336};
337
338template <>
339struct SbTypeInfo<short> {
340 typedef short Type;
341 typedef Type ParamType;
342
343 enum { isPrimitive = 1 };
344
345 typedef SbVec2s Vec2Type;
346 typedef SbVec3s Vec3Type;
347 typedef SbVec4s Vec4Type;
348 typedef SbBox2s Box2Type;
349 typedef SbBox3s Box3Type;
350
351 typedef SoSFShort SFieldType;
352 typedef SoMFShort MFieldType;
353};
354
355template <>
356struct SbTypeInfo<unsigned short> {
357 typedef unsigned short Type;
358 typedef Type ParamType;
359
360 typedef SbVec2us Vec2Type;
361 typedef SbVec3us Vec3Type;
362 typedef SbVec4us Vec4Type;
363
364 typedef SoSFUShort SFieldType;
365 typedef SoMFUShort MFieldType;
366};
367
368template <>
369struct SbTypeInfo<int32_t> {
370 typedef int32_t Type;
371 typedef Type ParamType;
372
373 typedef SbVec2i32 Vec2Type;
374 typedef SbVec3i32 Vec3Type;
375 typedef SbVec4i32 Vec4Type;
376 typedef SbBox2i32 Box2Type;
377 typedef SbBox3i32 Box3Type;
378
379 typedef SoSFInt32 SFieldType;
380 typedef SoMFInt32 MFieldType;
381};
382
383template <>
384struct SbTypeInfo<uint32_t> {
385 typedef uint32_t Type;
386 typedef Type ParamType;
387
388 typedef SbVec2ui32 Vec2Type;
389 typedef SbVec3ui32 Vec3Type;
390 typedef SbVec4ui32 Vec4Type;
391
392 typedef SoSFUInt32 SFieldType;
393 typedef SoMFUInt32 MFieldType;
394};
395
396
397template <>
398struct SbTypeInfo<SbVec2f> {
399 typedef SbVec2f Type;
400 typedef const Type & ParamType;
401
402 typedef float PrimitiveType;
403 enum { isPrimitive = 0 };
404
405 enum { Dimensions = 2 };
406
407 typedef SbBox2f BoxType;
408
409 typedef SoSFVec2f SFieldType;
410 typedef SoMFVec2f MFieldType;
411
412 static const char * getTypeName() { return "SbVec2f"; }
413};
414
415template <>
416struct SbTypeInfo<SbVec2d> {
417 typedef SbVec2d Type;
418 typedef const Type & ParamType;
419
420 typedef double PrimitiveType;
421 enum { Dimensions = 2 };
422
423 typedef SbBox2d BoxType;
424
425 typedef SoSFVec2d SFieldType;
426 typedef SoMFVec2d MFieldType;
427};
428
429template <>
430struct SbTypeInfo<SbVec2b> {
431 typedef SbVec2b Type;
432 typedef Type ParamType;
433
434 typedef int8_t PrimitiveType;
435 enum { Dimensions = 2 };
436
437 typedef SoSFVec2b SFieldType;
438 typedef SoMFVec2b MFieldType;
439};
440
441template <>
442struct SbTypeInfo<SbVec2ub> {
443 typedef SbVec2ub Type;
444 typedef Type ParamType;
445
446 typedef uint8_t PrimitiveType;
447 enum { Dimensions = 2 };
448};
449
450template <>
451struct SbTypeInfo<SbVec2s> {
452 typedef SbVec2s Type;
453 typedef Type ParamType;
454
455 typedef short PrimitiveType;
456 enum { isPrimitive = 0 };
457
458 enum { Dimensions = 2 };
459
460 typedef SbBox2s BoxType;
461
462 typedef SoSFVec2s SFieldType;
463 typedef SoMFVec2s MFieldType;
464
465 static const char * getTypeName() { return "SbVec2s"; }
466};
467
468template <>
469struct SbTypeInfo<SbVec2us> {
470 typedef SbVec2us Type;
471 typedef Type ParamType;
472
473 typedef unsigned short PrimitiveType;
474 enum { Dimensions = 2 };
475};
476
477template <>
478struct SbTypeInfo<SbVec2i32> {
479 typedef SbVec2i32 Type;
480 typedef const Type & ParamType;
481
482 typedef int32_t PrimitiveType;
483 enum { Dimensions = 2 };
484
485 typedef SbBox2i32 BoxType;
486
487 typedef SoSFVec2i32 SFieldType;
488 typedef SoMFVec2i32 MFieldType;
489};
490
491template <>
492struct SbTypeInfo<SbVec2ui32> {
493 typedef SbVec2ui32 Type;
494 typedef const Type & ParamType;
495
496 typedef uint32_t PrimitiveType;
497 enum { Dimensions = 2 };
498};
499
500template <>
501struct SbTypeInfo<SbVec3f> {
502 typedef SbVec3f Type;
503 typedef const Type & ParamType;
504
505 typedef float PrimitiveType;
506 enum { isPrimitive = 0 };
507
508 enum { Dimensions = 3 };
509
510 typedef SbBox3f BoxType;
511
512 typedef SoSFVec3f SFieldType;
513 typedef SoMFVec3f MFieldType;
514
515 static const char * getTypeName() { return "SbVec3f"; }
516};
517
518template <>
519struct SbTypeInfo<SbVec3d> {
520 typedef SbVec3d Type;
521 typedef const Type & ParamType;
522
523 typedef double PrimitiveType;
524 enum { Dimensions = 3 };
525
526 typedef SbBox3d BoxType;
527
528 typedef SoSFVec3d SFieldType;
529 typedef SoMFVec3d MFieldType;
530};
531
532template <>
533struct SbTypeInfo<SbVec3b> {
534 typedef SbVec3b Type;
535 typedef Type ParamType;
536
537 typedef int8_t PrimitiveType;
538 enum { Dimensions = 3 };
539
540 typedef SoSFVec3b SFieldType;
541 typedef SoMFVec3b MFieldType;
542};
543
544template <>
545struct SbTypeInfo<SbVec3ub> {
546 typedef SbVec3ub Type;
547 typedef Type ParamType;
548
549 typedef uint8_t PrimitiveType;
550 enum { Dimensions = 3 };
551};
552
553template <>
554struct SbTypeInfo<SbVec3s> {
555 typedef SbVec3s Type;
556 typedef const Type & ParamType;
557
558 typedef short PrimitiveType;
559 enum { isPrimitive = 0 };
560
561 enum { Dimensions = 3 };
562
563 typedef SbBox3s BoxType;
564
565 typedef SoSFVec3s SFieldType;
566 typedef SoMFVec3s MFieldType;
567
568 static const char * getTypeName() { return "SbVec3s"; }
569};
570
571template <>
572struct SbTypeInfo<SbVec3us> {
573 typedef SbVec3us Type;
574 typedef const Type & ParamType;
575
576 typedef unsigned short PrimitiveType;
577 enum { Dimensions = 3 };
578
579 static const char * getTypeName() { return "SbVec3us"; }
580};
581
582template <>
583struct SbTypeInfo<SbVec3i32> {
584 typedef SbVec3i32 Type;
585 typedef const Type & ParamType;
586
587 typedef int32_t PrimitiveType;
588 enum { Dimensions = 3 };
589
590 typedef SbBox3i32 BoxType;
591
592 typedef SoSFVec3i32 SFieldType;
593 typedef SoMFVec3i32 MFieldType;
594};
595
596template <>
597struct SbTypeInfo<SbVec3ui32> {
598 typedef SbVec3ui32 Type;
599 typedef const Type & ParamType;
600
601 typedef uint32_t PrimitiveType;
602 enum { Dimensions = 3 };
603};
604
605template <>
606struct SbTypeInfo<SbVec4f> {
607 typedef SbVec4f Type;
608 typedef const Type & ParamType;
609
610 typedef float PrimitiveType;
611 enum { Dimensions = 4 };
612
613 typedef SoSFVec4f SFieldType;
614 typedef SoMFVec4f MFieldType;
615};
616
617template <>
618struct SbTypeInfo<SbVec4d> {
619 typedef SbVec4d Type;
620 typedef const Type & ParamType;
621
622 typedef double PrimitiveType;
623 enum { Dimensions = 4 };
624
625 typedef SoSFVec4d SFieldType;
626 typedef SoMFVec4d MFieldType;
627};
628
629template <>
630struct SbTypeInfo<SbVec4b> {
631 typedef SbVec4b Type;
632 typedef Type ParamType;
633
634 typedef int8_t PrimitiveType;
635 enum { Dimensions = 4 };
636
637 typedef SoSFVec4b SFieldType;
638 typedef SoMFVec4b MFieldType;
639};
640
641template <>
642struct SbTypeInfo<SbVec4ub> {
643 typedef SbVec4ub Type;
644 typedef Type ParamType;
645
646 typedef uint8_t PrimitiveType;
647 enum { Dimensions = 4 };
648
649 typedef SoSFVec4ub SFieldType;
650 typedef SoMFVec4ub MFieldType;
651};
652
653template <>
654struct SbTypeInfo<SbVec4s> {
655 typedef SbVec4s Type;
656 typedef const Type & ParamType;
657
658 typedef short PrimitiveType;
659 enum { Dimensions = 4 };
660
661 typedef SoSFVec4s SFieldType;
662 typedef SoMFVec4s MFieldType;
663};
664
665template <>
666struct SbTypeInfo<SbVec4us> {
667 typedef SbVec4us Type;
668 typedef const Type & ParamType;
669
670 typedef unsigned short PrimitiveType;
671 enum { Dimensions = 4 };
672
673 typedef SoSFVec4us SFieldType;
674 typedef SoMFVec4us MFieldType;
675};
676
677template <>
678struct SbTypeInfo<SbVec4i32> {
679 typedef SbVec4i32 Type;
680 typedef const Type & ParamType;
681
682 typedef int32_t PrimitiveType;
683 enum { Dimensions = 4 };
684
685 typedef SoSFVec4i32 SFieldType;
686 typedef SoMFVec4i32 MFieldType;
687};
688
689template <>
690struct SbTypeInfo<SbVec4ui32> {
691 typedef SbVec4ui32 Type;
692 typedef const Type & ParamType;
693
694 typedef uint32_t PrimitiveType;
695 enum { Dimensions = 4 };
696
697 typedef SoSFVec4ui32 SFieldType;
698 typedef SoMFVec4ui32 MFieldType;
699};
700
701template <>
702struct SbTypeInfo<SbBox2f> {
703 typedef SbBox2f Type;
704 typedef const Type & ParamType;
705
706 typedef float PrimitiveType;
707 enum { Dimensions = 2 };
708
709 typedef SbVec2f VecType;
710
711 typedef SoSFBox2f SFieldType;
712};
713
714template <>
715struct SbTypeInfo<SbBox2d> {
716 typedef SbBox2d Type;
717 typedef const Type & ParamType;
718
719 typedef double PrimitiveType;
720 enum { Dimensions = 2 };
721
722 typedef SbVec2d VecType;
723
724 typedef SoSFBox2d SFieldType;
725};
726
727template <>
728struct SbTypeInfo<SbBox2s> {
729 typedef SbBox2s Type;
730 typedef const Type & ParamType;
731
732 typedef short PrimitiveType;
733 enum { Dimensions = 2 };
734
735 typedef SbVec2s VecType;
736
737 typedef SoSFBox2s SFieldType;
738};
739
740template <>
741struct SbTypeInfo<SbBox2i32> {
742 typedef SbBox2i32 Type;
743 typedef const Type & ParamType;
744
745 typedef int32_t PrimitiveType;
746 enum { Dimensions = 2 };
747
748 typedef SbVec2i32 VecType;
749
750 typedef SoSFBox2i32 SFieldType;
751};
752
753template <>
754struct SbTypeInfo<SbBox3f> {
755 typedef SbBox3f Type;
756 typedef const Type & ParamType;
757
758 typedef float PrimitiveType;
759 enum { Dimensions = 3 };
760
761 typedef SbVec3f VecType;
762
763 typedef SoSFBox3f SFieldType;
764};
765
766template <>
767struct SbTypeInfo<SbBox3d> {
768 typedef SbBox3d Type;
769 typedef const Type & ParamType;
770
771 typedef double PrimitiveType;
772 enum { Dimensions = 3 };
773
774 typedef SbVec3d VecType;
775
776 typedef SoSFBox3d SFieldType;
777};
778
779template <>
780struct SbTypeInfo<SbBox3s> {
781 typedef SbBox3s Type;
782 typedef const Type & ParamType;
783
784 typedef short PrimitiveType;
785 enum { Dimensions = 3 };
786
787 typedef SbVec3s VecType;
788
789 typedef SoSFBox3s SFieldType;
790};
791
792template <>
793struct SbTypeInfo<SbBox3i32> {
794 typedef SbBox3i32 Type;
795 typedef const Type & ParamType;
796
797 typedef int32_t PrimitiveType;
798 enum { Dimensions = 3 };
799
800 typedef SbVec3i32 VecType;
801
802 typedef SoSFBox3i32 SFieldType;
803};
804
805template <>
806struct SbTypeInfo<SbPlane> {
807 typedef SbPlane Type;
808 typedef const Type & ParamType;
809
810 typedef float PrimitiveType;
811 enum { Dimensions = 3 };
812
813 typedef SoSFPlane SFieldType;
814 typedef SoMFPlane MFieldType;
815};
816
817template <>
818struct SbTypeInfo<SbDPPlane> {
819 typedef SbDPPlane Type;
820 typedef const Type & ParamType;
821
822 typedef double PrimitiveType;
823 enum { Dimensions = 3 };
824};
825
826template <>
827struct SbTypeInfo<SbLine> {
828 typedef SbLine Type;
829 typedef const Type & ParamType;
830
831 typedef float PrimitiveType;
832 enum { Dimensions = 3 };
833};
834
835template <>
836struct SbTypeInfo<SbDPLine> {
837 typedef SbDPLine Type;
838 typedef const Type & ParamType;
839
840 typedef double PrimitiveType;
841 enum { Dimensions = 3 };
842};
843
844template <>
845struct SbTypeInfo<SbRotation> {
846 typedef SbRotation Type;
847 typedef const Type & ParamType;
848
849 typedef float PrimitiveType;
850 enum { isPrimitive = 0 };
851
852 typedef SoSFRotation SFieldType;
853 typedef SoMFRotation MFieldType;
854
855 enum { Dimensions = 4 };
856 static const char * getTypeName() { return "SbRotation"; }
857};
858
859template <>
860struct SbTypeInfo<SbDPRotation> {
861 typedef SbDPRotation Type;
862 typedef const Type & ParamType;
863
864 typedef double PrimitiveType;
865};
866
867template <>
868struct SbTypeInfo<SbMatrix> {
869 typedef SbMatrix Type;
870 typedef const Type & ParamType;
871
872 typedef float PrimitiveType;
873
874 typedef SoSFMatrix SFieldType;
875 typedef SoMFMatrix MFieldType;
876};
877
878template <>
879struct SbTypeInfo<SbDPMatrix> {
880 typedef SbDPMatrix Type;
881 typedef const Type & ParamType;
882
883 typedef double PrimitiveType;
884};
885
886// *************************************************************************
887
888template<>
889struct SbTypeInfo<SoSFBitMask> {
890 typedef SoSFBitMask Type;
891 typedef int32_t DataType;
892};
893
894template<>
895struct SbTypeInfo<SoSFBool> {
896 typedef SoSFBool Type;
897 typedef SbBool DataType;
898};
899
900template<>
901struct SbTypeInfo<SoSFBox2d> {
902 typedef SoSFBox2d Type;
903 typedef SbBox2d DataType;
904};
905
906template<>
907struct SbTypeInfo<SoSFBox2f> {
908 typedef SoSFBox2f Type;
909 typedef SbBox2f DataType;
910};
911
912template<>
913struct SbTypeInfo<SoSFBox2i32> {
914 typedef SoSFBox2i32 Type;
915 typedef SbBox2i32 DataType;
916};
917
918template<>
919struct SbTypeInfo<SoSFBox2s> {
920 typedef SoSFBox2s Type;
921 typedef SbBox2s DataType;
922};
923
924template<>
925struct SbTypeInfo<SoSFBox3d> {
926 typedef SoSFBox3d Type;
927 typedef SbBox3d DataType;
928};
929
930template<>
931struct SbTypeInfo<SoSFBox3f> {
932 typedef SoSFBox3f Type;
933 typedef SbBox3f DataType;
934};
935
936template<>
937struct SbTypeInfo<SoSFBox3i32> {
938 typedef SoSFBox3i32 Type;
939 typedef SbBox3i32 DataType;
940};
941
942template<>
943struct SbTypeInfo<SoSFBox3s> {
944 typedef SoSFBox3s Type;
945 typedef SbBox3s DataType;
946};
947
948template<>
949struct SbTypeInfo<SoSFColor> {
950 typedef SoSFColor Type;
951 typedef SbColor DataType;
952};
953
954template<>
955struct SbTypeInfo<SoSFColorRGBA> {
956 typedef SoSFColorRGBA Type;
957 typedef SbColor4f DataType;
958};
959
960template<>
961struct SbTypeInfo<SoSFDouble> {
962 typedef SoSFDouble Type;
963 typedef double DataType;
964};
965
966template<>
967struct SbTypeInfo<SoSFEngine> {
968 typedef SoSFEngine Type;
969 typedef SoEngine * DataType;
970};
971
972template<>
973struct SbTypeInfo<SoSFEnum> {
974 typedef SoSFEnum Type;
975 typedef int32_t DataType;
976};
977
978template<>
979struct SbTypeInfo<SoSFFloat> {
980 typedef SoSFFloat Type;
981 typedef float DataType;
982};
983
984//template<>
985//struct SbTypeInfo<SoSFImage3> {
986// typedef SoSFImage3 Type;
987// typedef SoImage3 DataType;
988//};
989
990template<>
991struct SbTypeInfo<SoSFImage> {
992 typedef SoSFImage Type;
993// typedef SbImage DataType;
994};
995
996template<>
997struct SbTypeInfo<SoSFInt32> {
998 typedef SoSFInt32 Type;
999 typedef int32_t DataType;
1000};
1001
1002template<>
1003struct SbTypeInfo<SoSFMatrix> {
1004 typedef SoSFMatrix Type;
1005 typedef SbMatrix DataType;
1006};
1007
1008template<>
1009struct SbTypeInfo<SoSFName> {
1010 typedef SoSFName Type;
1011 typedef SbName DataType;
1012};
1013
1014template<>
1015struct SbTypeInfo<SoSFNode> {
1016 typedef SoSFNode Type;
1017 typedef SoNode * DataType;
1018};
1019
1020template<>
1021struct SbTypeInfo<SoSFPath> {
1022 typedef SoSFPath Type;
1023 typedef SoPath * DataType;
1024};
1025
1026template<>
1027struct SbTypeInfo<SoSFPlane> {
1028 typedef SoSFPlane Type;
1029 typedef SbPlane DataType;
1030};
1031
1032template<>
1033struct SbTypeInfo<SoSFRotation> {
1034 typedef SoSFRotation Type;
1035 typedef SbRotation DataType;
1036};
1037
1038template<>
1039struct SbTypeInfo<SoSFShort> {
1040 typedef SoSFShort Type;
1041 typedef short DataType;
1042};
1043
1044template<>
1045struct SbTypeInfo<SoSFString> {
1046 typedef SoSFString Type;
1047 typedef SbString DataType;
1048};
1049
1050template<>
1051struct SbTypeInfo<SoSFTime> {
1052 typedef SoSFTime Type;
1053 typedef SbTime DataType;
1054};
1055
1056//template<>
1057//struct SbTypeInfo<SoSFTrigger> {
1058// typedef SoSFTrigger Type;
1059// typedef SoTrigger DataType;
1060//};
1061
1062template<>
1063struct SbTypeInfo<SoSFUInt32> {
1064 typedef SoSFUInt32 Type;
1065 typedef uint32_t DataType;
1066};
1067
1068template<>
1069struct SbTypeInfo<SoSFUShort> {
1070 typedef SoSFUShort Type;
1071 typedef unsigned short DataType;
1072};
1073
1074template<>
1075struct SbTypeInfo<SoSFVec2b> {
1076 typedef SoSFVec2b Type;
1077 typedef SbVec2b DataType;
1078};
1079
1080template<>
1081struct SbTypeInfo<SoSFVec2d> {
1082 typedef SoSFVec2d Type;
1083 typedef SbVec2d DataType;
1084};
1085
1086template<>
1087struct SbTypeInfo<SoSFVec2f> {
1088 typedef SoSFVec2f Type;
1089 typedef SbVec2f DataType;
1090};
1091
1092template<>
1093struct SbTypeInfo<SoSFVec2i32> {
1094 typedef SoSFVec2i32 Type;
1095 typedef SbVec2i32 DataType;
1096};
1097
1098template<>
1099struct SbTypeInfo<SoSFVec2s> {
1100 typedef SoSFVec2s Type;
1101 typedef SbVec2s DataType;
1102};
1103
1104template<>
1105struct SbTypeInfo<SoSFVec3b> {
1106 typedef SoSFVec3b Type;
1107 typedef SbVec3b DataType;
1108};
1109
1110template<>
1111struct SbTypeInfo<SoSFVec3d> {
1112 typedef SoSFVec3d Type;
1113 typedef SbVec3d DataType;
1114};
1115
1116template<>
1117struct SbTypeInfo<SoSFVec3f> {
1118 typedef SoSFVec3f Type;
1119 typedef SbVec3f DataType;
1120};
1121
1122template<>
1123struct SbTypeInfo<SoSFVec3i32> {
1124 typedef SoSFVec3i32 Type;
1125 typedef SbVec3i32 DataType;
1126};
1127
1128template<>
1129struct SbTypeInfo<SoSFVec3s> {
1130 typedef SoSFVec3s Type;
1131 typedef SbVec3s DataType;
1132};
1133
1134template<>
1135struct SbTypeInfo<SoSFVec4b> {
1136 typedef SoSFVec4b Type;
1137 typedef SbVec4b DataType;
1138};
1139
1140template<>
1141struct SbTypeInfo<SoSFVec4d> {
1142 typedef SoSFVec4d Type;
1143 typedef SbVec4d DataType;
1144};
1145
1146template<>
1147struct SbTypeInfo<SoSFVec4f> {
1148 typedef SoSFVec4f Type;
1149 typedef SbVec4f DataType;
1150};
1151
1152template<>
1153struct SbTypeInfo<SoSFVec4i32> {
1154 typedef SoSFVec4i32 Type;
1155 typedef SbVec4i32 DataType;
1156};
1157
1158template<>
1159struct SbTypeInfo<SoSFVec4s> {
1160 typedef SoSFVec4s Type;
1161 typedef SbVec4s DataType;
1162};
1163
1164template<>
1165struct SbTypeInfo<SoSFVec4ub> {
1166 typedef SoSFVec4ub Type;
1167 typedef SbVec4ub DataType;
1168};
1169
1170template<>
1171struct SbTypeInfo<SoSFVec4ui32> {
1172 typedef SoSFVec4ui32 Type;
1173 typedef SbVec4ui32 DataType;
1174};
1175
1176template<>
1177struct SbTypeInfo<SoSFVec4us> {
1178 typedef SoSFVec4us Type;
1179 typedef SbVec4us DataType;
1180};
1181
1182template<>
1183struct SbTypeInfo<SoMFBitMask> {
1184 typedef SoMFBitMask Type;
1185 typedef int32_t DataType;
1186};
1187
1188template<>
1189struct SbTypeInfo<SoMFBool> {
1190 typedef SoMFBool Type;
1191 typedef SbBool DataType;
1192};
1193
1194template<>
1195struct SbTypeInfo<SoMFColor> {
1196 typedef SoMFColor Type;
1197 typedef SbColor DataType;
1198};
1199
1200template<>
1201struct SbTypeInfo<SoMFColorRGBA> {
1202 typedef SoMFColorRGBA Type;
1203 typedef SbColor4f DataType;
1204};
1205
1206template<>
1207struct SbTypeInfo<SoMFDouble> {
1208 typedef SoMFDouble Type;
1209 typedef double DataType;
1210};
1211
1212template<>
1213struct SbTypeInfo<SoMFEngine> {
1214 typedef SoMFEngine Type;
1215 typedef SoEngine * DataType;
1216};
1217
1218template<>
1219struct SbTypeInfo<SoMFEnum> {
1220 typedef SoMFEnum Type;
1221 typedef int32_t DataType;
1222};
1223
1224template<>
1225struct SbTypeInfo<SoMFFloat> {
1226 typedef SoMFFloat Type;
1227 typedef float DataType;
1228};
1229
1230template<>
1231struct SbTypeInfo<SoMFInt32> {
1232 typedef SoMFInt32 Type;
1233 typedef int32_t DataType;
1234};
1235
1236template<>
1237struct SbTypeInfo<SoMFMatrix> {
1238 typedef SoMFMatrix Type;
1239 typedef SbMatrix DataType;
1240};
1241
1242template<>
1243struct SbTypeInfo<SoMFName> {
1244 typedef SoSFVec4us Type;
1245 typedef SbVec4us DataType;
1246};
1247
1248template<>
1249struct SbTypeInfo<SoMFNode> {
1250 typedef SoMFNode Type;
1251 typedef SoNode * DataType;
1252};
1253
1254template<>
1255struct SbTypeInfo<SoMFPath> {
1256 typedef SoMFPath Type;
1257 typedef SoPath * DataType;
1258};
1259
1260template<>
1261struct SbTypeInfo<SoMFPlane> {
1262 typedef SoMFPlane Type;
1263 typedef SbPlane DataType;
1264};
1265
1266template<>
1267struct SbTypeInfo<SoMFRotation> {
1268 typedef SoMFRotation Type;
1269 typedef SbRotation DataType;
1270};
1271
1272template<>
1273struct SbTypeInfo<SoMFShort> {
1274 typedef SoMFShort Type;
1275 typedef short DataType;
1276};
1277
1278template<>
1279struct SbTypeInfo<SoMFString> {
1280 typedef SoMFString Type;
1281 typedef SbString DataType;
1282};
1283
1284template<>
1285struct SbTypeInfo<SoMFTime> {
1286 typedef SoMFTime Type;
1287 typedef SbTime DataType;
1288};
1289
1290template<>
1291struct SbTypeInfo<SoMFUInt32> {
1292 typedef SoMFUInt32 Type;
1293 typedef uint32_t DataType;
1294};
1295
1296template<>
1297struct SbTypeInfo<SoMFUShort> {
1298 typedef SoMFUShort Type;
1299 typedef unsigned short DataType;
1300};
1301
1302template<>
1303struct SbTypeInfo<SoMFVec2b> {
1304 typedef SoMFVec2b Type;
1305 typedef SbVec2b DataType;
1306};
1307
1308template<>
1309struct SbTypeInfo<SoMFVec2d> {
1310 typedef SoMFVec2d Type;
1311 typedef SbVec2d DataType;
1312};
1313
1314template<>
1315struct SbTypeInfo<SoMFVec2f> {
1316 typedef SoMFVec2f Type;
1317 typedef SbVec2f DataType;
1318};
1319
1320template<>
1321struct SbTypeInfo<SoMFVec2i32> {
1322 typedef SoMFVec2i32 Type;
1323 typedef SbVec2i32 DataType;
1324};
1325
1326template<>
1327struct SbTypeInfo<SoMFVec2s> {
1328 typedef SoMFVec2s Type;
1329 typedef SbVec2s DataType;
1330};
1331
1332template<>
1333struct SbTypeInfo<SoMFVec3b> {
1334 typedef SoMFVec3b Type;
1335 typedef SbVec3b DataType;
1336};
1337
1338template<>
1339struct SbTypeInfo<SoMFVec3d> {
1340 typedef SoMFVec3d Type;
1341 typedef SbVec3d DataType;
1342};
1343
1344template<>
1345struct SbTypeInfo<SoMFVec3f> {
1346 typedef SoMFVec3f Type;
1347 typedef SbVec3f DataType;
1348};
1349
1350template<>
1351struct SbTypeInfo<SoMFVec3i32> {
1352 typedef SoMFVec3i32 Type;
1353 typedef SbVec3i32 DataType;
1354};
1355
1356template<>
1357struct SbTypeInfo<SoMFVec3s> {
1358 typedef SoMFVec3s Type;
1359 typedef SbVec3s DataType;
1360};
1361
1362template<>
1363struct SbTypeInfo<SoMFVec4b> {
1364 typedef SoMFVec4b Type;
1365 typedef SbVec4b DataType;
1366};
1367
1368template<>
1369struct SbTypeInfo<SoMFVec4d> {
1370 typedef SoMFVec4d Type;
1371 typedef SbVec4d DataType;
1372};
1373
1374template<>
1375struct SbTypeInfo<SoMFVec4f> {
1376 typedef SoMFVec4f Type;
1377 typedef SbVec4f DataType;
1378};
1379
1380template<>
1381struct SbTypeInfo<SoMFVec4i32> {
1382 typedef SoMFVec4i32 Type;
1383 typedef SbVec4i32 DataType;
1384};
1385
1386template<>
1387struct SbTypeInfo<SoMFVec4s> {
1388 typedef SoMFVec4s Type;
1389 typedef SbVec4s DataType;
1390};
1391
1392template<>
1393struct SbTypeInfo<SoMFVec4ub> {
1394 typedef SoMFVec4ub Type;
1395 typedef SbVec4ub DataType;
1396};
1397
1398template<>
1399struct SbTypeInfo<SoMFVec4ui32> {
1400 typedef SoMFVec4ui32 Type;
1401 typedef SbVec4ui32 DataType;
1402};
1403
1404template<>
1405struct SbTypeInfo<SoMFVec4us> {
1406 typedef SoMFVec4us Type;
1407 typedef SbVec4us DataType;
1408};
1409
1410// *************************************************************************
1411
1412// } } } // namespace SIM::Coin3D::Coin
1413
1414#endif // !DOXYGEN_SKIP_THIS
1415
1416#endif // !COIN_SBTYPEINFO_H
SbBox2d
The SbBox2d class is a 2 dimensional box with double precision corner coordinates.
Definition SbBox2d.h:42
SbBox2f
The SbBox2f class is a 2 dimensional box with floating point corner coordinates.
Definition SbBox2f.h:42
SbBox2i32
The SbBox2i32 class is a 2 dimensional box with 32-bit integer coordinates.
Definition SbBox2i32.h:43
SbBox2s
The SbBox2s class is a 2 dimensional box with short integer coordinates.
Definition SbBox2s.h:43
SbBox3d
The SbBox3d class is an abstraction for an axis aligned 3 dimensional box.
Definition SbBox3d.h:46
SbBox3f
The SbBox3f class is an abstraction for an axis aligned 3 dimensional box.
Definition SbBox3f.h:46
SbBox3i32
The SbBox3i32 class is a 3 dimensional box with 32-bit integer coordinates.
Definition SbBox3i32.h:44
SbBox3s
The SbBox3s class is a 3 dimensional box with short integer coordinates.
Definition SbBox3s.h:43
SbColor4f
The SbColor4f class contains the red, green, blue and alpha components which make up a color value.
Definition SbColor4f.h:42
SbColor
The SbColor class contains the red, green and blue components which make up a color value.
Definition SbColor.h:39
SbDPLine
The SbDPLine class represents a line using double precision coordinates.
Definition SbDPLine.h:41
SbDPMatrix
The SbDPMatrix class is a 4x4 dimensional representation of a double-precision matrix.
Definition SbDPMatrix.h:47
SbDPPlane
The SbDPPlane class represents a plane in 3D space.
Definition SbDPPlane.h:43
SbDPRotation
The SbDPRotation class represents a rotation in 3D space using double precision data.
Definition SbDPRotation.h:42
SbLine
The SbLine class represents a line in 3D space.
Definition SbLine.h:41
SbMatrix
The SbMatrix class is a 4x4 dimensional representation of a matrix.
Definition SbMatrix.h:47
SbName
The SbName class stores strings by reference.
Definition SbName.h:40
SbPlane
The SbPlane class represents a plane in 3D space.
Definition SbPlane.h:43
SbRotation
The SbRotation class represents a rotation in 3D space.
Definition SbRotation.h:44
SbString
The SbString class is a string class with convenience functions for string operations.
Definition SbString.h:52
SbTime
The SbTime class instances represents time values.
Definition SbTime.h:50
SbTypeInfo
a type information library for Coin types and their relations.
SbVec2b
a vector class for containing two byte integers.
Definition SbVec2b.h:48
SbVec2d
The SbVec2d class is a 2 dimensional vector with double precision floating point coordinates.
Definition SbVec2d.h:48
SbVec2f
The SbVec2f class is a 2 dimensional vector with floating point coordinates.
Definition SbVec2f.h:49
SbVec2i32
The SbVec2i32 class is a 2 dimensional vector with 32-bit signed integer coordinates.
Definition SbVec2i32.h:50
SbVec2s
The SbVec2s class is a 2 dimensional vector with short integer coordinates.
Definition SbVec2s.h:51
SbVec2ub
Definition SbVec2ub.h:46
SbVec2ui32
Definition SbVec2ui32.h:46
SbVec2us
Definition SbVec2us.h:46
SbVec3b
Definition SbVec3b.h:48
SbVec3d
The SbVec3d class is a 3 dimensional vector with double precision floating point coordinates.
Definition SbVec3d.h:50
SbVec3f
The SbVec3f class is a 3 dimensional vector with floating point coordinates.
Definition SbVec3f.h:51
SbVec3i32
Definition SbVec3i32.h:48
SbVec3s
The SbVec3s class is a 3 dimensional vector with short integer coordinates.
Definition SbVec3s.h:51
SbVec3ub
Definition SbVec3ub.h:46
SbVec3ui32
Definition SbVec3ui32.h:46
SbVec3us
Definition SbVec3us.h:50
SbVec4b
Definition SbVec4b.h:48
SbVec4d
The SbVec4d class is a 4 dimensional vector with double precision floating point coordinates.
Definition SbVec4d.h:49
SbVec4f
The SbVec4f class is a 4 dimensional vector with floating point coordinates.
Definition SbVec4f.h:49
SbVec4i32
Definition SbVec4i32.h:48
SbVec4s
Definition SbVec4s.h:48
SbVec4ub
Definition SbVec4ub.h:46
SbVec4ui32
Definition SbVec4ui32.h:46
SbVec4us
Definition SbVec4us.h:46
SoEngine
SoEngine is the base class for Coin engines.
Definition SoEngine.h:43
SoMFBitMask
The SoMFBitMask class is a container for a set of bitmasks.
Definition SoMFBitMask.h:38
SoMFBool
The SoMFBool class is a container for SbBool values.
Definition SoMFBool.h:39
SoMFColorRGBA
The SoMFColorRGBA class is a container for SbColor4f values.
Definition SoMFColorRGBA.h:40
SoMFColor
The SoMFColor class is a container for SbColor values.
Definition SoMFColor.h:40
SoMFDouble
The SoMFDouble class is a container for double float precision point values.
Definition SoMFDouble.h:39
SoMFEngine
The SoMFEngine class is a container for engines.
Definition SoMFEngine.h:41
SoMFEnum
The SoMFEnum class is a container for a set of enumerated values.
Definition SoMFEnum.h:39
SoMFFloat
The SoMFFloat class is a container for floating point values.
Definition SoMFFloat.h:39
SoMFInt32
The SoMFInt32 class is a container for 32-bit integer values.
Definition SoMFInt32.h:39
SoMFMatrix
The SoMFMatrix class is a container for SbMatrix values.
Definition SoMFMatrix.h:40
SoMFName
The SoMFName class is a container for SbName values.
Definition SoMFName.h:40
SoMFNode
The SoMFNode class is a container for nodes.
Definition SoMFNode.h:41
SoMFPath
The SoMFPath class is a container for paths.
Definition SoMFPath.h:44
SoMFPlane
The SoMFPlane class is a container for SbPlane values.
Definition SoMFPlane.h:40
SoMFRotation
The SoMFRotation class is a container for SbRotation values.
Definition SoMFRotation.h:40
SoMFShort
The SoMFShort class is a container for short integer values.
Definition SoMFShort.h:39
SoMFString
The SoMFString class is a container for SbString values.
Definition SoMFString.h:40
SoMFTime
The SoMFTime class is a container for SbTime values.
Definition SoMFTime.h:40
SoMFUInt32
The SoMFUInt32 class is a container for 32-bit unsigned integer values.
Definition SoMFUInt32.h:39
SoMFUShort
The SoMFUShort class is a container for unsigned short integer values.
Definition SoMFUShort.h:39
SoMFVec2b
The SoMFVec2b class is a container for SbVec2b vectors.
Definition SoMFVec2b.h:40
SoMFVec2d
The SoMFVec2d class is a container for SbVec2d vectors.
Definition SoMFVec2d.h:40
SoMFVec2f
The SoMFVec2f class is a container for SbVec2f vectors.
Definition SoMFVec2f.h:40
SoMFVec2i32
The SoMFVec2i32 class is a container for SbVec2i32 vectors.
Definition SoMFVec2i32.h:40
SoMFVec2s
The SoMFVec2s class is a container for SbVec2s vectors.
Definition SoMFVec2s.h:40
SoMFVec3b
The SoMFVec3b class is a container for SbVec3b vectors.
Definition SoMFVec3b.h:40
SoMFVec3d
The SoMFVec3d class is a container for SbVec3d vectors.
Definition SoMFVec3d.h:40
SoMFVec3f
The SoMFVec3f class is a container for SbVec3f vectors.
Definition SoMFVec3f.h:40
SoMFVec3i32
The SoMFVec3i32 class is a container for SbVec3i32 vectors.
Definition SoMFVec3i32.h:40
SoMFVec3s
The SoMFVec3s class is a container for SbVec3s vectors.
Definition SoMFVec3s.h:40
SoMFVec4b
The SoMFVec4b class is a container for SbVec4b vectors.
Definition SoMFVec4b.h:40
SoMFVec4d
The SoMFVec4d class is a container for SbVec4d vectors.
Definition SoMFVec4d.h:40
SoMFVec4f
The SoMFVec4f class is a container for SbVec4f vectors.
Definition SoMFVec4f.h:40
SoMFVec4i32
The SoMFVec4i32 class is a container for SbVec4i32 vectors.
Definition SoMFVec4i32.h:40
SoMFVec4s
The SoMFVec4s class is a container for SbVec4s vectors.
Definition SoMFVec4s.h:40
SoMFVec4ub
The SoMFVec4ub class is a container for SbVec4ub vectors.
Definition SoMFVec4ub.h:40
SoMFVec4ui32
The SoMFVec4ui32 class is a container for SbVec4ui32 vectors.
Definition SoMFVec4ui32.h:40
SoMFVec4us
The SoMFVec4us class is a container for SbVec4us vectors.
Definition SoMFVec4us.h:40
SoNode
The SoNode class is the base class for nodes used in scene graphs.
Definition SoNode.h:56
SoPath
The SoPath class is a container class for traversal path descriptions.
Definition SoPath.h:52
SoSFBitMask
The SoSFBitMask class is a container for a set of bit flags.
Definition SoSFBitMask.h:38
SoSFBool
The SoSFBool class is a container for an SbBool value.
Definition SoSFBool.h:39
SoSFBox2d
The SoSFBox2d class is a container for an SbBox2d vector.
Definition SoSFBox2d.h:40
SoSFBox2f
The SoSFBox2f class is a container for an SbBox2f vector.
Definition SoSFBox2f.h:40
SoSFBox2i32
The SoSFBox2i32 class is a container for an SbBox2i32 vector.
Definition SoSFBox2i32.h:40
SoSFBox2s
The SoSFBox2s class is a container for an SbBox2s vector.
Definition SoSFBox2s.h:40
SoSFBox3d
The SoSFBox3d class is a container for an SbBox3d vector.
Definition SoSFBox3d.h:40
SoSFBox3f
The SoSFBox3f class is a container for an SbBox3f vector.
Definition SoSFBox3f.h:40
SoSFBox3i32
The SoSFBox3i32 class is a container for an SbBox3i32 vector.
Definition SoSFBox3i32.h:40
SoSFBox3s
The SoSFBox3s class is a container for an SbBox3s vector.
Definition SoSFBox3s.h:40
SoSFColorRGBA
The SoSFColorRGBA class is a container for an SbColor4f value.
Definition SoSFColorRGBA.h:40
SoSFColor
The SoSFColor class is a container for an SbColor value.
Definition SoSFColor.h:40
SoSFDouble
The SoSFDouble class is a container for a double precision floating point value.
Definition SoSFDouble.h:39
SoSFEngine
The SoSFEngine class is a container for a single engine.
Definition SoSFEngine.h:47
SoSFEnum
The SoSFEnum class is a container for an enum value.
Definition SoSFEnum.h:40
SoSFFloat
The SoSFFloat class is a container for a floating point value.
Definition SoSFFloat.h:39
SoSFImage3
The SoSFImage3 class is used to store 3D (volume) images.
Definition SoSFImage3.h:40
SoSFImage
The SoSFImage class is used to store pixel images.
Definition SoSFImage.h:42
SoSFInt32
The SoSFInt32 class is a container for a 32-bit integer value.
Definition SoSFInt32.h:39
SoSFMatrix
The SoSFMatrix class is a container for an SbMatrix.
Definition SoSFMatrix.h:40
SoSFName
The SoSFName class is a container for an SbName.
Definition SoSFName.h:40
SoSFNode
The SoSFNode class is a container for a single node.
Definition SoSFNode.h:47
SoSFPath
The SoSFPath class is a container for a single path.
Definition SoSFPath.h:43
SoSFPlane
The SoSFPlane class is a container for an SbPlane value.
Definition SoSFPlane.h:40
SoSFRotation
The SoSFRotation class is a container for an SbRotation.
Definition SoSFRotation.h:40
SoSFShort
The SoSFShort class is a container for a short integer value.
Definition SoSFShort.h:39
SoSFString
The SoSFString class is a container for an SbString.
Definition SoSFString.h:40
SoSFTime
The SoSFTime class is a container for an SbTime value.
Definition SoSFTime.h:40
SoSFTrigger
The SoSFTrigger class is the "void" class used for detecting field changes.
Definition SoSFTrigger.h:41
SoSFUInt32
The SoSFUInt32 class is a container for a 32-bit unsigned integer value.
Definition SoSFUInt32.h:39
SoSFUShort
The SoSFUShort class is a container for a unsigned short integer value.
Definition SoSFUShort.h:39
SoSFVec2b
The SoSFVec2b class is a container for an SbVec2b vector.
Definition SoSFVec2b.h:40
SoSFVec2d
The SoSFVec2d class is a container for an SbVec2d vector.
Definition SoSFVec2d.h:40
SoSFVec2f
The SoSFVec2f class is a container for an SbVec2f vector.
Definition SoSFVec2f.h:40
SoSFVec2i32
The SoSFVec2i32 class is a container for an SbVec2i32 vector.
Definition SoSFVec2i32.h:40
SoSFVec2s
The SoSFVec2s class is a container for an SbVec2s vector.
Definition SoSFVec2s.h:40
SoSFVec3b
The SoSFVec3b class is a container for an SbVec3b vector.
Definition SoSFVec3b.h:40
SoSFVec3d
The SoSFVec3d class is a container for an SbVec3d vector.
Definition SoSFVec3d.h:40
SoSFVec3f
The SoSFVec3f class is a container for an SbVec3f vector.
Definition SoSFVec3f.h:40
SoSFVec3i32
The SoSFVec3i32 class is a container for an SbVec3i32 vector.
Definition SoSFVec3i32.h:40
SoSFVec3s
The SoSFVec3s class is a container for an SbVec3s vector.
Definition SoSFVec3s.h:40
SoSFVec4b
The SoSFVec4b class is a container for an SbVec4b vector.
Definition SoSFVec4b.h:40
SoSFVec4d
The SoSFVec4d class is a container for an SbVec4d vector.
Definition SoSFVec4d.h:40
SoSFVec4f
The SoSFVec4f class is a container for an SbVec4f vector.
Definition SoSFVec4f.h:40
SoSFVec4i32
The SoSFVec4i32 class is a container for an SbVec4i32 vector.
Definition SoSFVec4i32.h:40
SoSFVec4s
The SoSFVec4s class is a container for an SbVec4s vector.
Definition SoSFVec4s.h:40
SoSFVec4ub
The SoSFVec4ub class is a container for an SbVec4ub vector.
Definition SoSFVec4ub.h:40
SoSFVec4ui32
The SoSFVec4ui32 class is a container for an SbVec4ui32 vector.
Definition SoSFVec4ui32.h:40
SoSFVec4us
The SoSFVec4us class is a container for an SbVec4us vector.
Definition SoSFVec4us.h:40