SbTypeInfo.h
#ifndef COIN_SBTYPEINFO_H
#define COIN_SBTYPEINFO_H
/**************************************************************************\
* Copyright (c) Kongsberg Oil & Gas Technologies AS
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\**************************************************************************/
// SbTypeInfo<> is a Coin type information library.
#ifndef DOXYGEN_SKIP_THIS
#include <Inventor/system/inttypes.h>
#include <Inventor/C/basic.h>
// *************************************************************************
// Predeclarations
// Sb-classes
class SbVec2b;
class SbVec2ub;
class SbVec2s;
class SbVec2us;
class SbVec2i32;
class SbVec2ui32;
class SbVec2f;
class SbVec2d;
class SbVec3b;
class SbVec3ub;
class SbVec3s;
class SbVec3us;
class SbVec3i32;
class SbVec3ui32;
class SbVec3f;
class SbVec3d;
class SbVec4b;
class SbVec4ub;
class SbVec4s;
class SbVec4us;
class SbVec4i32;
class SbVec4ui32;
class SbVec4f;
class SbVec4d;
class SbBox2s;
class SbBox2i32;
class SbBox2f;
class SbBox2d;
class SbBox3s;
class SbBox3i32;
class SbBox3f;
class SbBox3d;
class SbLine;
class SbDPLine;
class SbPlane;
class SbDPPlane;
class SbMatrix;
class SbDPMatrix;
class SbRotation;
class SbDPRotation;
class SbTime;
class SbName;
class SbColor;
class SbColor4f;
class SbString;
// Field classes
class SoSFBitMask;
class SoSFBool;
class SoSFBox2s;
class SoSFBox2i32;
class SoSFBox2f;
class SoSFBox2d;
class SoSFBox3s;
class SoSFBox3i32;
class SoSFBox3f;
class SoSFBox3d;
class SoSFColor;
class SoSFColorRGBA;
class SoSFEngine;
class SoSFEnum;
class SoSFImage3;
class SoSFImage;
class SoSFMatrix;
class SoSFName;
class SoSFNode;
class SoSFPath;
class SoSFPlane;
class SoSFRotation;
class SoSFString;
class SoSFTime;
class SoSFTrigger;
class SoSFShort;
class SoSFUShort;
class SoSFInt32;
class SoSFUInt32;
class SoSFLong;
class SoSFULong;
class SoSFFloat;
class SoSFDouble;
class SoSFVec2b;
class SoSFVec2s;
class SoSFVec2i32;
class SoSFVec2f;
class SoSFVec2d;
class SoSFVec3b;
class SoSFVec3s;
class SoSFVec3i32;
class SoSFVec3f;
class SoSFVec3d;
class SoSFVec4b;
class SoSFVec4ub;
class SoSFVec4s;
class SoSFVec4us;
class SoSFVec4i32;
class SoSFVec4ui32;
class SoSFVec4f;
class SoSFVec4d;
class SoMFBitMask;
class SoMFBool;
class SoMFColor;
class SoMFColorRGBA;
class SoMFDouble;
class SoMFEngine;
class SoMFEnum;
class SoMFFloat;
class SoMFInt32;
class SoMFLong;
class SoMFMatrix;
class SoMFName;
class SoMFNode;
class SoMFPath;
class SoMFPlane;
class SoMFRotation;
class SoMFShort;
class SoMFString;
class SoMFTime;
class SoMFUInt32;
class SoMFULong;
class SoMFUShort;
class SoMFVec2b;
class SoMFVec2s;
class SoMFVec2i32;
class SoMFVec2f;
class SoMFVec2d;
class SoMFVec3b;
class SoMFVec3s;
class SoMFVec3i32;
class SoMFVec3f;
class SoMFVec3d;
class SoMFVec4b;
class SoMFVec4ub;
class SoMFVec4s;
class SoMFVec4us;
class SoMFVec4i32;
class SoMFVec4ui32;
class SoMFVec4f;
class SoMFVec4d;
class SoEngine;
class SoNode;
class SoPath;
// *************************************************************************
// namespace SIM { namespace Coin3D { namespace Coin {
template <typename T>
struct SbTypeInfo {
typedef T Type;
typedef const T & ParamType;
}; // fallback
template <>
struct SbTypeInfo<float> {
typedef float Type;
typedef float PrimitiveType;
enum { isPrimitive = 1 };
typedef Type ParamType;
enum { Dimensions = 1 };
typedef SbVec2f Vec2Type;
typedef SbVec3f Vec3Type;
typedef SbVec4f Vec4Type;
typedef SbBox2f Box2Type;
typedef SbBox3f Box3Type;
typedef SoSFFloat SFieldType;
typedef SoMFFloat MFieldType;
typedef SbPlane PlaneType;
typedef SbLine LineType;
typedef SbMatrix MatrixType;
typedef SbRotation RotationType;
};
template<typename PrimitiveType, unsigned int dim>
struct Vec
{
};
template<typename PrimitiveType>
struct Vec<PrimitiveType,2>
{
typedef typename SbTypeInfo<PrimitiveType>::Vec2Type Type;
};
template<typename PrimitiveType>
struct Vec<PrimitiveType,3>
{
typedef typename SbTypeInfo<PrimitiveType>::Vec3Type Type;
};
template<typename PrimitiveType>
struct Vec<PrimitiveType,4>
{
typedef typename SbTypeInfo<PrimitiveType>::Vec4Type Type;
};
//This should have been a template for SbBool, but since SbBool is an
//int, we would risk unwanted behaviour for ints.
template <>
struct SbTypeInfo<bool> {
typedef bool Type;
typedef bool PrimitiveType;
enum { isPrimitive = 1 };
typedef Type ParamType;
enum { Dimensions = 1 };
typedef SoSFBool SFieldType;
typedef SoMFBool MFieldType;
};
template <>
struct SbTypeInfo<double> {
typedef double Type;
typedef Type ParamType;
enum { isPrimitive = 1 };
enum { Dimensions = 1 };
typedef SbVec2d Vec2Type;
typedef SbVec3d Vec3Type;
typedef SbVec4d Vec4Type;
typedef SbBox2d Box2Type;
typedef SbBox3d Box3Type;
typedef SoSFDouble SFieldType;
typedef SoMFDouble MFieldType;
typedef SbDPPlane PlaneType;
typedef SbDPLine LineType;
typedef SbDPMatrix MatrixType;
typedef SbDPRotation RotationType;
};
template <>
struct SbTypeInfo<int8_t> {
typedef int8_t Type;
typedef Type ParamType;
typedef SbVec2b Vec2Type;
typedef SbVec3b Vec3Type;
typedef SbVec4b Vec4Type;
};
template <>
struct SbTypeInfo<uint8_t> {
typedef uint8_t Type;
typedef Type ParamType;
typedef SbVec2ub Vec2Type;
typedef SbVec3ub Vec3Type;
typedef SbVec4ub Vec4Type;
};
template <>
struct SbTypeInfo<short> {
typedef short Type;
typedef Type ParamType;
enum { isPrimitive = 1 };
typedef SbVec2s Vec2Type;
typedef SbVec3s Vec3Type;
typedef SbVec4s Vec4Type;
typedef SbBox2s Box2Type;
typedef SbBox3s Box3Type;
typedef SoSFShort SFieldType;
typedef SoMFShort MFieldType;
};
template <>
struct SbTypeInfo<unsigned short> {
typedef unsigned short Type;
typedef Type ParamType;
typedef SbVec2us Vec2Type;
typedef SbVec3us Vec3Type;
typedef SbVec4us Vec4Type;
typedef SoSFUShort SFieldType;
typedef SoMFUShort MFieldType;
};
template <>
struct SbTypeInfo<int32_t> {
typedef int32_t Type;
typedef Type ParamType;
typedef SbVec2i32 Vec2Type;
typedef SbVec3i32 Vec3Type;
typedef SbVec4i32 Vec4Type;
typedef SbBox2i32 Box2Type;
typedef SbBox3i32 Box3Type;
typedef SoSFInt32 SFieldType;
typedef SoMFInt32 MFieldType;
};
template <>
struct SbTypeInfo<uint32_t> {
typedef uint32_t Type;
typedef Type ParamType;
typedef SbVec2ui32 Vec2Type;
typedef SbVec3ui32 Vec3Type;
typedef SbVec4ui32 Vec4Type;
typedef SoSFUInt32 SFieldType;
typedef SoMFUInt32 MFieldType;
};
template <>
struct SbTypeInfo<SbVec2f> {
typedef SbVec2f Type;
typedef const Type & ParamType;
typedef float PrimitiveType;
enum { isPrimitive = 0 };
enum { Dimensions = 2 };
typedef SbBox2f BoxType;
typedef SoSFVec2f SFieldType;
typedef SoMFVec2f MFieldType;
static const char * getTypeName() { return "SbVec2f"; }
};
template <>
struct SbTypeInfo<SbVec2d> {
typedef SbVec2d Type;
typedef const Type & ParamType;
typedef double PrimitiveType;
enum { Dimensions = 2 };
typedef SbBox2d BoxType;
typedef SoSFVec2d SFieldType;
typedef SoMFVec2d MFieldType;
};
template <>
struct SbTypeInfo<SbVec2b> {
typedef SbVec2b Type;
typedef Type ParamType;
typedef int8_t PrimitiveType;
enum { Dimensions = 2 };
typedef SoSFVec2b SFieldType;
typedef SoMFVec2b MFieldType;
};
template <>
struct SbTypeInfo<SbVec2ub> {
typedef SbVec2ub Type;
typedef Type ParamType;
typedef uint8_t PrimitiveType;
enum { Dimensions = 2 };
};
template <>
struct SbTypeInfo<SbVec2s> {
typedef SbVec2s Type;
typedef Type ParamType;
typedef short PrimitiveType;
enum { isPrimitive = 0 };
enum { Dimensions = 2 };
typedef SbBox2s BoxType;
typedef SoSFVec2s SFieldType;
typedef SoMFVec2s MFieldType;
static const char * getTypeName() { return "SbVec2s"; }
};
template <>
struct SbTypeInfo<SbVec2us> {
typedef SbVec2us Type;
typedef Type ParamType;
typedef unsigned short PrimitiveType;
enum { Dimensions = 2 };
};
template <>
struct SbTypeInfo<SbVec2i32> {
typedef SbVec2i32 Type;
typedef const Type & ParamType;
typedef int32_t PrimitiveType;
enum { Dimensions = 2 };
typedef SbBox2i32 BoxType;
typedef SoSFVec2i32 SFieldType;
typedef SoMFVec2i32 MFieldType;
};
template <>
struct SbTypeInfo<SbVec2ui32> {
typedef SbVec2ui32 Type;
typedef const Type & ParamType;
typedef uint32_t PrimitiveType;
enum { Dimensions = 2 };
};
template <>
struct SbTypeInfo<SbVec3f> {
typedef SbVec3f Type;
typedef const Type & ParamType;
typedef float PrimitiveType;
enum { isPrimitive = 0 };
enum { Dimensions = 3 };
typedef SbBox3f BoxType;
typedef SoSFVec3f SFieldType;
typedef SoMFVec3f MFieldType;
static const char * getTypeName() { return "SbVec3f"; }
};
template <>
struct SbTypeInfo<SbVec3d> {
typedef SbVec3d Type;
typedef const Type & ParamType;
typedef double PrimitiveType;
enum { Dimensions = 3 };
typedef SbBox3d BoxType;
typedef SoSFVec3d SFieldType;
typedef SoMFVec3d MFieldType;
};
template <>
struct SbTypeInfo<SbVec3b> {
typedef SbVec3b Type;
typedef Type ParamType;
typedef int8_t PrimitiveType;
enum { Dimensions = 3 };
typedef SoSFVec3b SFieldType;
typedef SoMFVec3b MFieldType;
};
template <>
struct SbTypeInfo<SbVec3ub> {
typedef SbVec3ub Type;
typedef Type ParamType;
typedef uint8_t PrimitiveType;
enum { Dimensions = 3 };
};
template <>
struct SbTypeInfo<SbVec3s> {
typedef SbVec3s Type;
typedef const Type & ParamType;
typedef short PrimitiveType;
enum { isPrimitive = 0 };
enum { Dimensions = 3 };
typedef SbBox3s BoxType;
typedef SoSFVec3s SFieldType;
typedef SoMFVec3s MFieldType;
static const char * getTypeName() { return "SbVec3s"; }
};
template <>
struct SbTypeInfo<SbVec3us> {
typedef SbVec3us Type;
typedef const Type & ParamType;
typedef unsigned short PrimitiveType;
enum { Dimensions = 3 };
static const char * getTypeName() { return "SbVec3us"; }
};
template <>
struct SbTypeInfo<SbVec3i32> {
typedef SbVec3i32 Type;
typedef const Type & ParamType;
typedef int32_t PrimitiveType;
enum { Dimensions = 3 };
typedef SbBox3i32 BoxType;
typedef SoSFVec3i32 SFieldType;
typedef SoMFVec3i32 MFieldType;
};
template <>
struct SbTypeInfo<SbVec3ui32> {
typedef SbVec3ui32 Type;
typedef const Type & ParamType;
typedef uint32_t PrimitiveType;
enum { Dimensions = 3 };
};
template <>
struct SbTypeInfo<SbVec4f> {
typedef SbVec4f Type;
typedef const Type & ParamType;
typedef float PrimitiveType;
enum { Dimensions = 4 };
typedef SoSFVec4f SFieldType;
typedef SoMFVec4f MFieldType;
};
template <>
struct SbTypeInfo<SbVec4d> {
typedef SbVec4d Type;
typedef const Type & ParamType;
typedef double PrimitiveType;
enum { Dimensions = 4 };
typedef SoSFVec4d SFieldType;
typedef SoMFVec4d MFieldType;
};
template <>
struct SbTypeInfo<SbVec4b> {
typedef SbVec4b Type;
typedef Type ParamType;
typedef int8_t PrimitiveType;
enum { Dimensions = 4 };
typedef SoSFVec4b SFieldType;
typedef SoMFVec4b MFieldType;
};
template <>
struct SbTypeInfo<SbVec4ub> {
typedef SbVec4ub Type;
typedef Type ParamType;
typedef uint8_t PrimitiveType;
enum { Dimensions = 4 };
typedef SoSFVec4ub SFieldType;
typedef SoMFVec4ub MFieldType;
};
template <>
struct SbTypeInfo<SbVec4s> {
typedef SbVec4s Type;
typedef const Type & ParamType;
typedef short PrimitiveType;
enum { Dimensions = 4 };
typedef SoSFVec4s SFieldType;
typedef SoMFVec4s MFieldType;
};
template <>
struct SbTypeInfo<SbVec4us> {
typedef SbVec4us Type;
typedef const Type & ParamType;
typedef unsigned short PrimitiveType;
enum { Dimensions = 4 };
typedef SoSFVec4us SFieldType;
typedef SoMFVec4us MFieldType;
};
template <>
struct SbTypeInfo<SbVec4i32> {
typedef SbVec4i32 Type;
typedef const Type & ParamType;
typedef int32_t PrimitiveType;
enum { Dimensions = 4 };
typedef SoSFVec4i32 SFieldType;
typedef SoMFVec4i32 MFieldType;
};
template <>
struct SbTypeInfo<SbVec4ui32> {
typedef SbVec4ui32 Type;
typedef const Type & ParamType;
typedef uint32_t PrimitiveType;
enum { Dimensions = 4 };
typedef SoSFVec4ui32 SFieldType;
typedef SoMFVec4ui32 MFieldType;
};
template <>
struct SbTypeInfo<SbBox2f> {
typedef SbBox2f Type;
typedef const Type & ParamType;
typedef float PrimitiveType;
enum { Dimensions = 2 };
typedef SbVec2f VecType;
typedef SoSFBox2f SFieldType;
};
template <>
struct SbTypeInfo<SbBox2d> {
typedef SbBox2d Type;
typedef const Type & ParamType;
typedef double PrimitiveType;
enum { Dimensions = 2 };
typedef SbVec2d VecType;
typedef SoSFBox2d SFieldType;
};
template <>
struct SbTypeInfo<SbBox2s> {
typedef SbBox2s Type;
typedef const Type & ParamType;
typedef short PrimitiveType;
enum { Dimensions = 2 };
typedef SbVec2s VecType;
typedef SoSFBox2s SFieldType;
};
template <>
struct SbTypeInfo<SbBox2i32> {
typedef SbBox2i32 Type;
typedef const Type & ParamType;
typedef int32_t PrimitiveType;
enum { Dimensions = 2 };
typedef SbVec2i32 VecType;
typedef SoSFBox2i32 SFieldType;
};
template <>
struct SbTypeInfo<SbBox3f> {
typedef SbBox3f Type;
typedef const Type & ParamType;
typedef float PrimitiveType;
enum { Dimensions = 3 };
typedef SbVec3f VecType;
typedef SoSFBox3f SFieldType;
};
template <>
struct SbTypeInfo<SbBox3d> {
typedef SbBox3d Type;
typedef const Type & ParamType;
typedef double PrimitiveType;
enum { Dimensions = 3 };
typedef SbVec3d VecType;
typedef SoSFBox3d SFieldType;
};
template <>
struct SbTypeInfo<SbBox3s> {
typedef SbBox3s Type;
typedef const Type & ParamType;
typedef short PrimitiveType;
enum { Dimensions = 3 };
typedef SbVec3s VecType;
typedef SoSFBox3s SFieldType;
};
template <>
struct SbTypeInfo<SbBox3i32> {
typedef SbBox3i32 Type;
typedef const Type & ParamType;
typedef int32_t PrimitiveType;
enum { Dimensions = 3 };
typedef SbVec3i32 VecType;
typedef SoSFBox3i32 SFieldType;
};
template <>
struct SbTypeInfo<SbPlane> {
typedef SbPlane Type;
typedef const Type & ParamType;
typedef float PrimitiveType;
enum { Dimensions = 3 };
typedef SoSFPlane SFieldType;
typedef SoMFPlane MFieldType;
};
template <>
struct SbTypeInfo<SbDPPlane> {
typedef SbDPPlane Type;
typedef const Type & ParamType;
typedef double PrimitiveType;
enum { Dimensions = 3 };
};
template <>
struct SbTypeInfo<SbLine> {
typedef SbLine Type;
typedef const Type & ParamType;
typedef float PrimitiveType;
enum { Dimensions = 3 };
};
template <>
struct SbTypeInfo<SbDPLine> {
typedef SbDPLine Type;
typedef const Type & ParamType;
typedef double PrimitiveType;
enum { Dimensions = 3 };
};
template <>
struct SbTypeInfo<SbRotation> {
typedef SbRotation Type;
typedef const Type & ParamType;
typedef float PrimitiveType;
enum { isPrimitive = 0 };
typedef SoSFRotation SFieldType;
typedef SoMFRotation MFieldType;
enum { Dimensions = 4 };
static const char * getTypeName() { return "SbRotation"; }
};
template <>
struct SbTypeInfo<SbDPRotation> {
typedef SbDPRotation Type;
typedef const Type & ParamType;
typedef double PrimitiveType;
};
template <>
struct SbTypeInfo<SbMatrix> {
typedef SbMatrix Type;
typedef const Type & ParamType;
typedef float PrimitiveType;
typedef SoSFMatrix SFieldType;
typedef SoMFMatrix MFieldType;
};
template <>
struct SbTypeInfo<SbDPMatrix> {
typedef SbDPMatrix Type;
typedef const Type & ParamType;
typedef double PrimitiveType;
};
// *************************************************************************
template<>
struct SbTypeInfo<SoSFBitMask> {
typedef SoSFBitMask Type;
typedef int32_t DataType;
};
template<>
struct SbTypeInfo<SoSFBool> {
typedef SoSFBool Type;
typedef SbBool DataType;
};
template<>
struct SbTypeInfo<SoSFBox2d> {
typedef SoSFBox2d Type;
typedef SbBox2d DataType;
};
template<>
struct SbTypeInfo<SoSFBox2f> {
typedef SoSFBox2f Type;
typedef SbBox2f DataType;
};
template<>
struct SbTypeInfo<SoSFBox2i32> {
typedef SoSFBox2i32 Type;
typedef SbBox2i32 DataType;
};
template<>
struct SbTypeInfo<SoSFBox2s> {
typedef SoSFBox2s Type;
typedef SbBox2s DataType;
};
template<>
struct SbTypeInfo<SoSFBox3d> {
typedef SoSFBox3d Type;
typedef SbBox3d DataType;
};
template<>
struct SbTypeInfo<SoSFBox3f> {
typedef SoSFBox3f Type;
typedef SbBox3f DataType;
};
template<>
struct SbTypeInfo<SoSFBox3i32> {
typedef SoSFBox3i32 Type;
typedef SbBox3i32 DataType;
};
template<>
struct SbTypeInfo<SoSFBox3s> {
typedef SoSFBox3s Type;
typedef SbBox3s DataType;
};
template<>
struct SbTypeInfo<SoSFColor> {
typedef SoSFColor Type;
typedef SbColor DataType;
};
template<>
struct SbTypeInfo<SoSFColorRGBA> {
typedef SoSFColorRGBA Type;
typedef SbColor4f DataType;
};
template<>
struct SbTypeInfo<SoSFDouble> {
typedef SoSFDouble Type;
typedef double DataType;
};
template<>
struct SbTypeInfo<SoSFEngine> {
typedef SoSFEngine Type;
typedef SoEngine * DataType;
};
template<>
struct SbTypeInfo<SoSFEnum> {
typedef SoSFEnum Type;
typedef int32_t DataType;
};
template<>
struct SbTypeInfo<SoSFFloat> {
typedef SoSFFloat Type;
typedef float DataType;
};
//template<>
//struct SbTypeInfo<SoSFImage3> {
// typedef SoSFImage3 Type;
// typedef SoImage3 DataType;
//};
template<>
struct SbTypeInfo<SoSFImage> {
typedef SoSFImage Type;
// typedef SbImage DataType;
};
template<>
struct SbTypeInfo<SoSFInt32> {
typedef SoSFInt32 Type;
typedef int32_t DataType;
};
template<>
struct SbTypeInfo<SoSFMatrix> {
typedef SoSFMatrix Type;
typedef SbMatrix DataType;
};
template<>
struct SbTypeInfo<SoSFName> {
typedef SoSFName Type;
typedef SbName DataType;
};
template<>
struct SbTypeInfo<SoSFNode> {
typedef SoSFNode Type;
typedef SoNode * DataType;
};
template<>
struct SbTypeInfo<SoSFPath> {
typedef SoSFPath Type;
typedef SoPath * DataType;
};
template<>
struct SbTypeInfo<SoSFPlane> {
typedef SoSFPlane Type;
typedef SbPlane DataType;
};
template<>
struct SbTypeInfo<SoSFRotation> {
typedef SoSFRotation Type;
typedef SbRotation DataType;
};
template<>
struct SbTypeInfo<SoSFShort> {
typedef SoSFShort Type;
typedef short DataType;
};
template<>
struct SbTypeInfo<SoSFString> {
typedef SoSFString Type;
typedef SbString DataType;
};
template<>
struct SbTypeInfo<SoSFTime> {
typedef SoSFTime Type;
typedef SbTime DataType;
};
//template<>
//struct SbTypeInfo<SoSFTrigger> {
// typedef SoSFTrigger Type;
// typedef SoTrigger DataType;
//};
template<>
struct SbTypeInfo<SoSFUInt32> {
typedef SoSFUInt32 Type;
typedef uint32_t DataType;
};
template<>
struct SbTypeInfo<SoSFUShort> {
typedef SoSFUShort Type;
typedef unsigned short DataType;
};
template<>
struct SbTypeInfo<SoSFVec2b> {
typedef SoSFVec2b Type;
typedef SbVec2b DataType;
};
template<>
struct SbTypeInfo<SoSFVec2d> {
typedef SoSFVec2d Type;
typedef SbVec2d DataType;
};
template<>
struct SbTypeInfo<SoSFVec2f> {
typedef SoSFVec2f Type;
typedef SbVec2f DataType;
};
template<>
struct SbTypeInfo<SoSFVec2i32> {
typedef SoSFVec2i32 Type;
typedef SbVec2i32 DataType;
};
template<>
struct SbTypeInfo<SoSFVec2s> {
typedef SoSFVec2s Type;
typedef SbVec2s DataType;
};
template<>
struct SbTypeInfo<SoSFVec3b> {
typedef SoSFVec3b Type;
typedef SbVec3b DataType;
};
template<>
struct SbTypeInfo<SoSFVec3d> {
typedef SoSFVec3d Type;
typedef SbVec3d DataType;
};
template<>
struct SbTypeInfo<SoSFVec3f> {
typedef SoSFVec3f Type;
typedef SbVec3f DataType;
};
template<>
struct SbTypeInfo<SoSFVec3i32> {
typedef SoSFVec3i32 Type;
typedef SbVec3i32 DataType;
};
template<>
struct SbTypeInfo<SoSFVec3s> {
typedef SoSFVec3s Type;
typedef SbVec3s DataType;
};
template<>
struct SbTypeInfo<SoSFVec4b> {
typedef SoSFVec4b Type;
typedef SbVec4b DataType;
};
template<>
struct SbTypeInfo<SoSFVec4d> {
typedef SoSFVec4d Type;
typedef SbVec4d DataType;
};
template<>
struct SbTypeInfo<SoSFVec4f> {
typedef SoSFVec4f Type;
typedef SbVec4f DataType;
};
template<>
struct SbTypeInfo<SoSFVec4i32> {
typedef SoSFVec4i32 Type;
typedef SbVec4i32 DataType;
};
template<>
struct SbTypeInfo<SoSFVec4s> {
typedef SoSFVec4s Type;
typedef SbVec4s DataType;
};
template<>
struct SbTypeInfo<SoSFVec4ub> {
typedef SoSFVec4ub Type;
typedef SbVec4ub DataType;
};
template<>
struct SbTypeInfo<SoSFVec4ui32> {
typedef SoSFVec4ui32 Type;
typedef SbVec4ui32 DataType;
};
template<>
struct SbTypeInfo<SoSFVec4us> {
typedef SoSFVec4us Type;
typedef SbVec4us DataType;
};
template<>
struct SbTypeInfo<SoMFBitMask> {
typedef SoMFBitMask Type;
typedef int32_t DataType;
};
template<>
struct SbTypeInfo<SoMFBool> {
typedef SoMFBool Type;
typedef SbBool DataType;
};
template<>
struct SbTypeInfo<SoMFColor> {
typedef SoMFColor Type;
typedef SbColor DataType;
};
template<>
struct SbTypeInfo<SoMFColorRGBA> {
typedef SoMFColorRGBA Type;
typedef SbColor4f DataType;
};
template<>
struct SbTypeInfo<SoMFDouble> {
typedef SoMFDouble Type;
typedef double DataType;
};
template<>
struct SbTypeInfo<SoMFEngine> {
typedef SoMFEngine Type;
typedef SoEngine * DataType;
};
template<>
struct SbTypeInfo<SoMFEnum> {
typedef SoMFEnum Type;
typedef int32_t DataType;
};
template<>
struct SbTypeInfo<SoMFFloat> {
typedef SoMFFloat Type;
typedef float DataType;
};
template<>
struct SbTypeInfo<SoMFInt32> {
typedef SoMFInt32 Type;
typedef int32_t DataType;
};
template<>
struct SbTypeInfo<SoMFMatrix> {
typedef SoMFMatrix Type;
typedef SbMatrix DataType;
};
template<>
struct SbTypeInfo<SoMFName> {
typedef SoSFVec4us Type;
typedef SbVec4us DataType;
};
template<>
struct SbTypeInfo<SoMFNode> {
typedef SoMFNode Type;
typedef SoNode * DataType;
};
template<>
struct SbTypeInfo<SoMFPath> {
typedef SoMFPath Type;
typedef SoPath * DataType;
};
template<>
struct SbTypeInfo<SoMFPlane> {
typedef SoMFPlane Type;
typedef SbPlane DataType;
};
template<>
struct SbTypeInfo<SoMFRotation> {
typedef SoMFRotation Type;
typedef SbRotation DataType;
};
template<>
struct SbTypeInfo<SoMFShort> {
typedef SoMFShort Type;
typedef short DataType;
};
template<>
struct SbTypeInfo<SoMFString> {
typedef SoMFString Type;
typedef SbString DataType;
};
template<>
struct SbTypeInfo<SoMFTime> {
typedef SoMFTime Type;
typedef SbTime DataType;
};
template<>
struct SbTypeInfo<SoMFUInt32> {
typedef SoMFUInt32 Type;
typedef uint32_t DataType;
};
template<>
struct SbTypeInfo<SoMFUShort> {
typedef SoMFUShort Type;
typedef unsigned short DataType;
};
template<>
struct SbTypeInfo<SoMFVec2b> {
typedef SoMFVec2b Type;
typedef SbVec2b DataType;
};
template<>
struct SbTypeInfo<SoMFVec2d> {
typedef SoMFVec2d Type;
typedef SbVec2d DataType;
};
template<>
struct SbTypeInfo<SoMFVec2f> {
typedef SoMFVec2f Type;
typedef SbVec2f DataType;
};
template<>
struct SbTypeInfo<SoMFVec2i32> {
typedef SoMFVec2i32 Type;
typedef SbVec2i32 DataType;
};
template<>
struct SbTypeInfo<SoMFVec2s> {
typedef SoMFVec2s Type;
typedef SbVec2s DataType;
};
template<>
struct SbTypeInfo<SoMFVec3b> {
typedef SoMFVec3b Type;
typedef SbVec3b DataType;
};
template<>
struct SbTypeInfo<SoMFVec3d> {
typedef SoMFVec3d Type;
typedef SbVec3d DataType;
};
template<>
struct SbTypeInfo<SoMFVec3f> {
typedef SoMFVec3f Type;
typedef SbVec3f DataType;
};
template<>
struct SbTypeInfo<SoMFVec3i32> {
typedef SoMFVec3i32 Type;
typedef SbVec3i32 DataType;
};
template<>
struct SbTypeInfo<SoMFVec3s> {
typedef SoMFVec3s Type;
typedef SbVec3s DataType;
};
template<>
struct SbTypeInfo<SoMFVec4b> {
typedef SoMFVec4b Type;
typedef SbVec4b DataType;
};
template<>
struct SbTypeInfo<SoMFVec4d> {
typedef SoMFVec4d Type;
typedef SbVec4d DataType;
};
template<>
struct SbTypeInfo<SoMFVec4f> {
typedef SoMFVec4f Type;
typedef SbVec4f DataType;
};
template<>
struct SbTypeInfo<SoMFVec4i32> {
typedef SoMFVec4i32 Type;
typedef SbVec4i32 DataType;
};
template<>
struct SbTypeInfo<SoMFVec4s> {
typedef SoMFVec4s Type;
typedef SbVec4s DataType;
};
template<>
struct SbTypeInfo<SoMFVec4ub> {
typedef SoMFVec4ub Type;
typedef SbVec4ub DataType;
};
template<>
struct SbTypeInfo<SoMFVec4ui32> {
typedef SoMFVec4ui32 Type;
typedef SbVec4ui32 DataType;
};
template<>
struct SbTypeInfo<SoMFVec4us> {
typedef SoMFVec4us Type;
typedef SbVec4us DataType;
};
// *************************************************************************
// } } } // namespace SIM::Coin3D::Coin
#endif // !DOXYGEN_SKIP_THIS
#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