2016-10-02 00:08:34 +00:00
/// \file X3DImporter_Node.hpp
/// \brief Elements of scene graph.
/// \date 2015-2016
/// \author smal.root@gmail.com
2016-09-29 15:50:24 +00:00
# ifndef INCLUDED_AI_X3D_IMPORTER_NODE_H
# define INCLUDED_AI_X3D_IMPORTER_NODE_H
2016-10-02 00:08:34 +00:00
// Header files, Assimp.
# include "assimp/scene.h"
# include "assimp/types.h"
// Header files, stdlib.
2016-09-29 15:50:24 +00:00
# include <list>
# include <string>
/// \class CX3DImporter_NodeElement
/// Base class for elements of nodes.
class CX3DImporter_NodeElement
{
/***********************************************/
/******************** Types ********************/
/***********************************************/
public :
/// \enum EType
/// Define what data type contain node element.
enum EType
{
ENET_Group , ///< Element has type "Group".
ENET_MetaBoolean , ///< Element has type "Metadata boolean".
ENET_MetaDouble , ///< Element has type "Metadata double".
ENET_MetaFloat , ///< Element has type "Metadata float".
ENET_MetaInteger , ///< Element has type "Metadata integer".
ENET_MetaSet , ///< Element has type "Metadata set".
ENET_MetaString , ///< Element has type "Metadata string".
ENET_Arc2D , ///< Element has type "Arc2D".
ENET_ArcClose2D , ///< Element has type "ArcClose2D".
ENET_Circle2D , ///< Element has type "Circle2D".
ENET_Disk2D , ///< Element has type "Disk2D".
ENET_Polyline2D , ///< Element has type "Polyline2D".
ENET_Polypoint2D , ///< Element has type "Polypoint2D".
ENET_Rectangle2D , ///< Element has type "Rectangle2D".
ENET_TriangleSet2D , ///< Element has type "TriangleSet2D".
ENET_Box , ///< Element has type "Box".
ENET_Cone , ///< Element has type "Cone".
ENET_Cylinder , ///< Element has type "Cylinder".
ENET_Sphere , ///< Element has type "Sphere".
ENET_ElevationGrid , ///< Element has type "ElevationGrid".
ENET_Extrusion , ///< Element has type "Extrusion".
ENET_Coordinate , ///< Element has type "Coordinate".
ENET_Normal , ///< Element has type "Normal".
ENET_TextureCoordinate , ///< Element has type "TextureCoordinate".
ENET_IndexedFaceSet , ///< Element has type "IndexedFaceSet".
ENET_IndexedLineSet , ///< Element has type "IndexedLineSet".
ENET_IndexedTriangleSet , ///< Element has type "IndexedTriangleSet".
ENET_IndexedTriangleFanSet , ///< Element has type "IndexedTriangleFanSet".
ENET_IndexedTriangleStripSet , ///< Element has type "IndexedTriangleStripSet".
ENET_LineSet , ///< Element has type "LineSet".
ENET_PointSet , ///< Element has type "PointSet".
ENET_TriangleSet , ///< Element has type "TriangleSet".
ENET_TriangleFanSet , ///< Element has type "TriangleFanSet".
ENET_TriangleStripSet , ///< Element has type "TriangleStripSet".
ENET_Color , ///< Element has type "Color".
ENET_ColorRGBA , ///< Element has type "ColorRGBA".
ENET_Shape , ///< Element has type "Shape".
ENET_Appearance , ///< Element has type "Appearance".
ENET_Material , ///< Element has type "Material".
ENET_ImageTexture , ///< Element has type "ImageTexture".
ENET_TextureTransform , ///< Element has type "TextureTransform".
ENET_DirectionalLight , ///< Element has type "DirectionalLight".
ENET_PointLight , ///< Element has type "PointLight".
ENET_SpotLight , ///< Element has type "SpotLight".
ENET_Invalid ///< Element has invalid type and possible contain invalid data.
} ;
/***********************************************/
/****************** Constants ******************/
/***********************************************/
public :
const EType Type ;
/***********************************************/
/****************** Variables ******************/
/***********************************************/
public :
std : : string ID ; ///< ID of the element. Can be empty. In X3D synonym for "ID" attribute.
2016-10-02 00:08:34 +00:00
CX3DImporter_NodeElement * Parent ; ///< Parrent element. If nullptr then this node is root.
2016-09-29 15:50:24 +00:00
std : : list < CX3DImporter_NodeElement * > Child ; ///< Child elements.
/***********************************************/
/****************** Functions ******************/
/***********************************************/
private :
/// \fn CX3DImporter_NodeElement(const CX3DImporter_NodeElement& pNodeElement)
/// Disabled copy constructor.
CX3DImporter_NodeElement ( const CX3DImporter_NodeElement & pNodeElement ) ;
/// \fn CX3DImporter_NodeElement& operator=(const CX3DImporter_NodeElement& pNodeElement)
/// Disabled assign operator.
CX3DImporter_NodeElement & operator = ( const CX3DImporter_NodeElement & pNodeElement ) ;
/// \fn CX3DImporter_NodeElement()
/// Disabled default constructor.
CX3DImporter_NodeElement ( ) ;
protected :
/// \fn CX3DImporter_NodeElement(const EType pType, CX3DImporter_NodeElement* pParent)
/// In constructor inheritor must set element type.
/// \param [in] pType - element type.
/// \param [in] pParent - parent element.
CX3DImporter_NodeElement ( const EType pType , CX3DImporter_NodeElement * pParent )
: Type ( pType ) , Parent ( pParent )
{ }
} ; // class IX3DImporter_NodeElement
/// \class CX3DImporter_NodeElement_Group
/// Class that define grouping node. Define transformation matrix for children.
/// Also can select which child will be kept and others are removed.
class CX3DImporter_NodeElement_Group : public CX3DImporter_NodeElement
{
/***********************************************/
/****************** Variables ******************/
/***********************************************/
public :
aiMatrix4x4 Transformation ; ///< Transformation matrix.
/// \var bool Static
/// As you know node elements can use already defined node elements when attribute "USE" is defined.
/// Standard search when looking for an element in the whole scene graph, existing at this moment.
/// If a node is marked as static, the children(or lower) can not search for elements in the nodes upper then static.
bool Static ;
bool UseChoice ; ///< Flag: if true then use number from \ref Choice to choose what the child will be kept.
int32_t Choice ; ///< Number of the child which will be kept.
/***********************************************/
/****************** Functions ******************/
/***********************************************/
private :
/// \fn CX3DImporter_NodeElement_Group(const CX3DImporter_NodeElement_Group& pNode)
/// Disabled copy constructor.
CX3DImporter_NodeElement_Group ( const CX3DImporter_NodeElement_Group & pNode ) ;
/// \fn CX3DImporter_NodeElement_Group& operator=(const CX3DImporter_NodeElement_Group& pNode)
/// Disabled assign operator.
CX3DImporter_NodeElement_Group & operator = ( const CX3DImporter_NodeElement_Group & pNode ) ;
/// \fn CX3DImporter_NodeElement_Group()
/// Disabled default constructor.
CX3DImporter_NodeElement_Group ( ) ;
public :
/// \fn CX3DImporter_NodeElement_Group(CX3DImporter_NodeElement_Group* pParent, const bool pStatic = false)
/// Constructor.
/// \param [in] pParent - pointer to parent node.
/// \param [in] pStatic - static node flag.
CX3DImporter_NodeElement_Group ( CX3DImporter_NodeElement * pParent , const bool pStatic = false )
: CX3DImporter_NodeElement ( ENET_Group , pParent ) , Static ( pStatic ) , UseChoice ( false )
{ }
} ; // class CX3DImporter_NodeElement_Group
/// \class CX3DImporter_NodeElement_Meta
/// This struct describe metavalue.
class CX3DImporter_NodeElement_Meta : public CX3DImporter_NodeElement
{
/***********************************************/
/****************** Variables ******************/
/***********************************************/
public :
std : : string Name ; ///< Name of metadata object.
/// \var std::string Reference
/// If provided, it identifies the metadata standard or other specification that defines the name field. If the reference field is not provided or is
/// empty, the meaning of the name field is considered implicit to the characters in the string.
std : : string Reference ;
/***********************************************/
/****************** Functions ******************/
/***********************************************/
private :
/// \fn CX3DImporter_NodeElement_Meta(const CX3DImporter_NodeElement_Meta& pNode)
/// Disabled copy constructor.
CX3DImporter_NodeElement_Meta ( const CX3DImporter_NodeElement_Meta & pNode ) ;
/// \fn CX3DImporter_NodeElement_Meta& operator=(const CX3DImporter_NodeElement_Meta& pNode)
/// Disabled assign operator.
CX3DImporter_NodeElement_Meta & operator = ( const CX3DImporter_NodeElement_Meta & pNode ) ;
/// \fn CX3DImporter_NodeElement_Meta()
/// Disabled default constructor.
CX3DImporter_NodeElement_Meta ( ) ;
public :
/// \fn CX3DImporter_NodeElement_Meta(const EType pType, CX3DImporter_NodeElement* pParent)
/// In constructor inheritor must set element type.
/// \param [in] pType - element type.
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_Meta ( const EType pType , CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( pType , pParent )
{ }
} ; // class CX3DImporter_NodeElement_Meta
/// \struct CX3DImporter_NodeElement_MetaBoolean
/// This struct describe metavalue of type boolean.
struct CX3DImporter_NodeElement_MetaBoolean : public CX3DImporter_NodeElement_Meta
{
std : : list < bool > Value ; ///< Stored value.
/// \fn CX3DImporter_NodeElement_MetaBoolean(CX3DImporter_NodeElement* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_MetaBoolean ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement_Meta ( ENET_MetaBoolean , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_MetaBoolean
/// \struct CX3DImporter_NodeElement_MetaDouble
/// This struct describe metavalue of type double.
struct CX3DImporter_NodeElement_MetaDouble : public CX3DImporter_NodeElement_Meta
{
std : : list < double > Value ; ///< Stored value.
/// \fn CX3DImporter_NodeElement_MetaDouble(CX3DImporter_NodeElement* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_MetaDouble ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement_Meta ( ENET_MetaDouble , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_MetaDouble
/// \struct CX3DImporter_NodeElement_MetaFloat
/// This struct describe metavalue of type float.
struct CX3DImporter_NodeElement_MetaFloat : public CX3DImporter_NodeElement_Meta
{
std : : list < float > Value ; ///< Stored value.
/// \fn CX3DImporter_NodeElement_MetaFloat(CX3DImporter_NodeElement* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_MetaFloat ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement_Meta ( ENET_MetaFloat , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_MetaFloat
/// \struct CX3DImporter_NodeElement_MetaInteger
/// This struct describe metavalue of type integer.
struct CX3DImporter_NodeElement_MetaInteger : public CX3DImporter_NodeElement_Meta
{
std : : list < int32_t > Value ; ///< Stored value.
/// \fn CX3DImporter_NodeElement_MetaInteger(CX3DImporter_NodeElement* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_MetaInteger ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement_Meta ( ENET_MetaInteger , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_MetaInteger
/// \struct CX3DImporter_NodeElement_MetaSet
/// This struct describe container for metaobjects.
struct CX3DImporter_NodeElement_MetaSet : public CX3DImporter_NodeElement_Meta
{
std : : list < CX3DImporter_NodeElement_Meta > Value ; ///< Stored value.
/// \fn CX3DImporter_NodeElement_MetaSet(CX3DImporter_NodeElement* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_MetaSet ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement_Meta ( ENET_MetaSet , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_MetaSet
/// \struct CX3DImporter_NodeElement_MetaString
/// This struct describe metavalue of type string.
struct CX3DImporter_NodeElement_MetaString : public CX3DImporter_NodeElement_Meta
{
std : : list < std : : string > Value ; ///< Stored value.
/// \fn CX3DImporter_NodeElement_MetaString(CX3DImporter_NodeElement* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_MetaString ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement_Meta ( ENET_MetaString , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_MetaString
/// \struct CX3DImporter_NodeElement_Color
/// This struct hold <Color> value.
struct CX3DImporter_NodeElement_Color : public CX3DImporter_NodeElement
{
std : : list < aiColor3D > Value ; ///< Stored value.
/// \fn CX3DImporter_NodeElement_Color(CX3DImporter_NodeElement* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_Color ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( ENET_Color , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_Color
/// \struct CX3DImporter_NodeElement_ColorRGBA
/// This struct hold <ColorRGBA> value.
struct CX3DImporter_NodeElement_ColorRGBA : public CX3DImporter_NodeElement
{
std : : list < aiColor4D > Value ; ///< Stored value.
/// \fn CX3DImporter_NodeElement_ColorRGBA(CX3DImporter_NodeElement* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_ColorRGBA ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( ENET_ColorRGBA , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_ColorRGBA
/// \struct CX3DImporter_NodeElement_Coordinate
/// This struct hold <Coordinate> value.
struct CX3DImporter_NodeElement_Coordinate : public CX3DImporter_NodeElement
{
std : : list < aiVector3D > Value ; ///< Stored value.
/// \fn CX3DImporter_NodeElement_Coordinate(CX3DImporter_NodeElement* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_Coordinate ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( ENET_Coordinate , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_Coordinate
/// \struct CX3DImporter_NodeElement_Normal
/// This struct hold <Normal> value.
struct CX3DImporter_NodeElement_Normal : public CX3DImporter_NodeElement
{
std : : list < aiVector3D > Value ; ///< Stored value.
/// \fn CX3DImporter_NodeElement_Normal(CX3DImporter_NodeElement* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_Normal ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( ENET_Normal , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_Normal
/// \struct CX3DImporter_NodeElement_TextureCoordinate
/// This struct hold <TextureCoordinate> value.
struct CX3DImporter_NodeElement_TextureCoordinate : public CX3DImporter_NodeElement
{
std : : list < aiVector2D > Value ; ///< Stored value.
/// \fn CX3DImporter_NodeElement_TextureCoordinate(CX3DImporter_NodeElement* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_TextureCoordinate ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( ENET_TextureCoordinate , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_TextureCoordinate
/// \class CX3DImporter_NodeElement_Geometry2D
/// Two-dimensional figure.
class CX3DImporter_NodeElement_Geometry2D : public CX3DImporter_NodeElement
{
/***********************************************/
/****************** Variables ******************/
/***********************************************/
public :
std : : list < aiVector3D > Vertices ; ///< Vertices list.
size_t NumIndices ; ///< Number of indices in one face.
bool Solid ; ///< Flag: if true then render must use back-face culling, else render must draw both sides of object.
/***********************************************/
/****************** Functions ******************/
/***********************************************/
private :
/// \fn CX3DImporter_NodeElement_Geometry2D(const CX3DImporter_NodeElement_Geometry2D& pNode)
/// Disabled copy constructor.
CX3DImporter_NodeElement_Geometry2D ( const CX3DImporter_NodeElement_Geometry2D & pNode ) ;
/// \fn CX3DImporter_NodeElement_Geometry2D& operator=(const CX3DImporter_NodeElement_Geometry2D& pNode)
/// Disabled assign operator.
CX3DImporter_NodeElement_Geometry2D & operator = ( const CX3DImporter_NodeElement_Geometry2D & pNode ) ;
public :
/// \fn CX3DImporter_NodeElement_Geometry2D(const EType pType, CX3DImporter_NodeElement* pParent)
/// Constructor.
/// \param [in] pParent - pointer to parent node.
/// \param [in] pType - type of geometry object.
CX3DImporter_NodeElement_Geometry2D ( const EType pType , CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( pType , pParent ) , Solid ( true )
{ }
} ; // class CX3DImporter_NodeElement_Geometry2D
/// \class CX3DImporter_NodeElement_Geometry3D
/// Three-dimensional body.
class CX3DImporter_NodeElement_Geometry3D : public CX3DImporter_NodeElement
{
/***********************************************/
/****************** Variables ******************/
/***********************************************/
public :
std : : list < aiVector3D > Vertices ; ///< Vertices list.
size_t NumIndices ; ///< Number of indices in one face.
bool Solid ; ///< Flag: if true then render must use back-face culling, else render must draw both sides of object.
/***********************************************/
/****************** Functions ******************/
/***********************************************/
private :
/// \fn CX3DImporter_NodeElement_Geometry3D(const CX3DImporter_NodeElement_Geometry3D& pNode)
/// Disabled copy constructor.
CX3DImporter_NodeElement_Geometry3D ( const CX3DImporter_NodeElement_Geometry3D & pNode ) ;
/// \fn CX3DImporter_NodeElement_Geometry3D& operator=(const CX3DImporter_NodeElement_Geometry3D& pNode)
/// Disabled assign operator.
CX3DImporter_NodeElement_Geometry3D & operator = ( const CX3DImporter_NodeElement_Geometry3D & pNode ) ;
public :
/// \fn CX3DImporter_NodeElement_Geometry3D(const EType pType, CX3DImporter_NodeElement* pParent)
/// Constructor.
/// \param [in] pParent - pointer to parent node.
/// \param [in] pType - type of geometry object.
CX3DImporter_NodeElement_Geometry3D ( const EType pType , CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( pType , pParent ) , Solid ( true )
{ }
} ; // class CX3DImporter_NodeElement_Geometry3D
/// \class CX3DImporter_NodeElement_ElevationGrid
/// Uniform rectangular grid of varying height.
class CX3DImporter_NodeElement_ElevationGrid : public CX3DImporter_NodeElement_Geometry3D
{
/***********************************************/
/****************** Variables ******************/
/***********************************************/
public :
bool NormalPerVertex ; ///< If true then normals are defined for every vertex, else for every face(line).
bool ColorPerVertex ; ///< If true then colors are defined for every vertex, else for every face(line).
/// \var CreaseAngle
/// If the angle between the geometric normals of two adjacent faces is less than the crease angle, normals shall be calculated so that the faces are
/// shaded smoothly across the edge; otherwise, normals shall be calculated so that a lighting discontinuity across the edge is produced.
float CreaseAngle ;
std : : list < int32_t > CoordIdx ; ///< Coordinates list by faces. In X3D format: "-1" - delimiter for faces.
/***********************************************/
/****************** Functions ******************/
/***********************************************/
private :
/// \fn CX3DImporter_NodeElement_ElevationGrid(const CX3DImporter_NodeElement_ElevationGrid& pNode)
/// Disabled copy constructor.
CX3DImporter_NodeElement_ElevationGrid ( const CX3DImporter_NodeElement_ElevationGrid & pNode ) ;
/// \fn CX3DImporter_NodeElement_ElevationGrid& operator=(const CX3DImporter_NodeElement_ElevationGrid& pNode)
/// Disabled assign operator.
CX3DImporter_NodeElement_ElevationGrid & operator = ( const CX3DImporter_NodeElement_ElevationGrid & pNode ) ;
public :
/// \fn CX3DImporter_NodeElement_ElevationGrid(const EType pType, CX3DImporter_NodeElement* pParent)
/// Constructor.
/// \param [in] pParent - pointer to parent node.
/// \param [in] pType - type of geometry object.
CX3DImporter_NodeElement_ElevationGrid ( const EType pType , CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement_Geometry3D ( pType , pParent )
{ }
} ; // class CX3DImporter_NodeElement_IndexedSet
/// \class CX3DImporter_NodeElement_IndexedSet
/// Shape with indexed vertices.
class CX3DImporter_NodeElement_IndexedSet : public CX3DImporter_NodeElement_Geometry3D
{
/***********************************************/
/****************** Variables ******************/
/***********************************************/
public :
/// \var CCW
/// The ccw field defines the ordering of the vertex coordinates of the geometry with respect to user-given or automatically generated normal vectors
/// used in the lighting model equations. If ccw is TRUE, the normals shall follow the right hand rule; the orientation of each normal with respect to
/// the vertices (taken in order) shall be such that the vertices appear to be oriented in a counterclockwise order when the vertices are viewed (in the
/// local coordinate system of the Shape) from the opposite direction as the normal. If ccw is FALSE, the normals shall be oriented in the opposite
/// direction. If normals are not generated but are supplied using a Normal node, and the orientation of the normals does not match the setting of the
/// ccw field, results are undefined.
bool CCW ;
std : : list < int32_t > ColorIndex ; ///< Field to specify the polygonal faces by indexing into the <Color> or <ColorRGBA>.
bool ColorPerVertex ; ///< If true then colors are defined for every vertex, else for every face(line).
/// \var Convex
/// The convex field indicates whether all polygons in the shape are convex (TRUE). A polygon is convex if it is planar, does not intersect itself,
/// and all of the interior angles at its vertices are less than 180 degrees. Non planar and self intersecting polygons may produce undefined results
/// even if the convex field is FALSE.
bool Convex ;
std : : list < int32_t > CoordIndex ; ///< Field to specify the polygonal faces by indexing into the <Coordinate>.
/// \var CreaseAngle
/// If the angle between the geometric normals of two adjacent faces is less than the crease angle, normals shall be calculated so that the faces are
/// shaded smoothly across the edge; otherwise, normals shall be calculated so that a lighting discontinuity across the edge is produced.
float CreaseAngle ;
std : : list < int32_t > NormalIndex ; ///< Field to specify the polygonal faces by indexing into the <Normal>.
bool NormalPerVertex ; ///< If true then normals are defined for every vertex, else for every face(line).
std : : list < int32_t > TexCoordIndex ; ///< Field to specify the polygonal faces by indexing into the <TextureCoordinate>.
/***********************************************/
/****************** Functions ******************/
/***********************************************/
private :
/// \fn CX3DImporter_NodeElement_IndexedSet(const CX3DImporter_NodeElement_IndexedSet& pNode)
/// Disabled copy constructor.
CX3DImporter_NodeElement_IndexedSet ( const CX3DImporter_NodeElement_IndexedSet & pNode ) ;
/// \fn CX3DImporter_NodeElement_IndexedSet& operator=(const CX3DImporter_NodeElement_IndexedSet& pNode)
/// Disabled assign operator.
CX3DImporter_NodeElement_IndexedSet & operator = ( const CX3DImporter_NodeElement_IndexedSet & pNode ) ;
public :
/// \fn CX3DImporter_NodeElement_IndexedSet(const EType pType, CX3DImporter_NodeElement* pParent)
/// Constructor.
/// \param [in] pParent - pointer to parent node.
/// \param [in] pType - type of geometry object.
CX3DImporter_NodeElement_IndexedSet ( const EType pType , CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement_Geometry3D ( pType , pParent )
{ }
} ; // class CX3DImporter_NodeElement_IndexedSet
/// \class CX3DImporter_NodeElement_Set
/// Shape with set of vertices.
class CX3DImporter_NodeElement_Set : public CX3DImporter_NodeElement_Geometry3D
{
/***********************************************/
/****************** Variables ******************/
/***********************************************/
public :
/// \var CCW
/// The ccw field defines the ordering of the vertex coordinates of the geometry with respect to user-given or automatically generated normal vectors
/// used in the lighting model equations. If ccw is TRUE, the normals shall follow the right hand rule; the orientation of each normal with respect to
/// the vertices (taken in order) shall be such that the vertices appear to be oriented in a counterclockwise order when the vertices are viewed (in the
/// local coordinate system of the Shape) from the opposite direction as the normal. If ccw is FALSE, the normals shall be oriented in the opposite
/// direction. If normals are not generated but are supplied using a Normal node, and the orientation of the normals does not match the setting of the
/// ccw field, results are undefined.
bool CCW ;
bool ColorPerVertex ; ///< If true then colors are defined for every vertex, else for every face(line).
bool NormalPerVertex ; ///< If true then normals are defined for every vertex, else for every face(line).
std : : list < int32_t > CoordIndex ; ///< Field to specify the polygonal faces by indexing into the <Coordinate>.
std : : list < int32_t > NormalIndex ; ///< Field to specify the polygonal faces by indexing into the <Normal>.
std : : list < int32_t > TexCoordIndex ; ///< Field to specify the polygonal faces by indexing into the <TextureCoordinate>.
std : : list < int32_t > VertexCount ; ///< Field describes how many vertices are to be used in each polyline(polygon) from the <Coordinate> field.
/***********************************************/
/****************** Functions ******************/
/***********************************************/
private :
/// \fn CX3DImporter_NodeElement_Set(const CX3DImporter_NodeElement_Set& pNode)
/// Disabled copy constructor.
CX3DImporter_NodeElement_Set ( const CX3DImporter_NodeElement_Set & pNode ) ;
/// \fn CX3DImporter_NodeElement_Set& operator=(const CX3DImporter_NodeElement_Set& pNode)
/// Disabled assign operator.
CX3DImporter_NodeElement_Set & operator = ( const CX3DImporter_NodeElement_Set & pNode ) ;
public :
/// \fn CX3DImporter_NodeElement_Set(const EType pType, CX3DImporter_NodeElement* pParent)
/// Constructor.
/// \param [in] pParent - pointer to parent node.
/// \param [in] pType - type of geometry object.
CX3DImporter_NodeElement_Set ( const EType pType , CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement_Geometry3D ( pType , pParent )
{ }
} ; // class CX3DImporter_NodeElement_Set
/// \struct CX3DImporter_NodeElement_Shape
/// This struct hold <Shape> value.
struct CX3DImporter_NodeElement_Shape : public CX3DImporter_NodeElement
{
/// \fn CX3DImporter_NodeElement_Shape(CX3DImporter_NodeElement_Shape* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_Shape ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( ENET_Shape , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_Shape
/// \struct CX3DImporter_NodeElement_Appearance
/// This struct hold <Appearance> value.
struct CX3DImporter_NodeElement_Appearance : public CX3DImporter_NodeElement
{
/// \fn CX3DImporter_NodeElement_Appearance(CX3DImporter_NodeElement_Appearance* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_Appearance ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( ENET_Appearance , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_Appearance
/// \class CX3DImporter_NodeElement_Material
/// Material.
class CX3DImporter_NodeElement_Material : public CX3DImporter_NodeElement
{
/***********************************************/
/****************** Variables ******************/
/***********************************************/
public :
float AmbientIntensity ; ///< Specifies how much ambient light from light sources this surface shall reflect.
aiColor3D DiffuseColor ; ///< Reflects all X3D light sources depending on the angle of the surface with respect to the light source.
aiColor3D EmissiveColor ; ///< Models "glowing" objects. This can be useful for displaying pre-lit models.
float Shininess ; ///< Lower shininess values produce soft glows, while higher values result in sharper, smaller highlights.
aiColor3D SpecularColor ; ///< The specularColor and shininess fields determine the specular highlights.
float Transparency ; ///< Specifies how "clear" an object is, with 1.0 being completely transparent, and 0.0 completely opaque.
/***********************************************/
/****************** Functions ******************/
/***********************************************/
private :
/// \fn CX3DImporter_NodeElement_Material(const CX3DImporter_NodeElement_Material& pNode)
/// Disabled copy constructor.
CX3DImporter_NodeElement_Material ( const CX3DImporter_NodeElement_Material & pNode ) ;
/// \fn CX3DImporter_NodeElement_Material& operator=(const CX3DImporter_NodeElement_Material& pNode)
/// Disabled assign operator.
CX3DImporter_NodeElement_Material & operator = ( const CX3DImporter_NodeElement_Material & pNode ) ;
public :
/// \fn CX3DImporter_NodeElement_Material(const EType pType, CX3DImporter_NodeElement* pParent)
/// Constructor.
/// \param [in] pParent - pointer to parent node.
/// \param [in] pType - type of geometry object.
CX3DImporter_NodeElement_Material ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( ENET_Material , pParent )
{ }
} ; // class CX3DImporter_NodeElement_Material
/// \struct CX3DImporter_NodeElement_ImageTexture
/// This struct hold <ImageTexture> value.
struct CX3DImporter_NodeElement_ImageTexture : public CX3DImporter_NodeElement
{
/// \var RepeatS
/// RepeatS and RepeatT, that specify how the texture wraps in the S and T directions. If repeatS is TRUE (the default), the texture map is repeated
/// outside the [0.0, 1.0] texture coordinate range in the S direction so that it fills the shape. If repeatS is FALSE, the texture coordinates are
/// clamped in the S direction to lie within the [0.0, 1.0] range. The repeatT field is analogous to the repeatS field.
bool RepeatS ;
bool RepeatT ; ///< See \ref RepeatS.
std : : string URL ; ///< URL of the texture.
/// \fn CX3DImporter_NodeElement_ImageTexture(CX3DImporter_NodeElement_ImageTexture* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_ImageTexture ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( ENET_ImageTexture , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_ImageTexture
/// \struct CX3DImporter_NodeElement_TextureTransform
/// This struct hold <TextureTransform> value.
struct CX3DImporter_NodeElement_TextureTransform : public CX3DImporter_NodeElement
{
aiVector2D Center ; ///< Specifies a translation offset in texture coordinate space about which the rotation and scale fields are applied.
float Rotation ; ///< Specifies a rotation in angle base units of the texture coordinates about the center point after the scale has been applied.
aiVector2D Scale ; ///< Specifies a scaling factor in S and T of the texture coordinates about the center point.
aiVector2D Translation ; ///< Specifies a translation of the texture coordinates.
/// \fn CX3DImporter_NodeElement_TextureTransform(CX3DImporter_NodeElement_TextureTransform* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
CX3DImporter_NodeElement_TextureTransform ( CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( ENET_TextureTransform , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_TextureTransform
/// \struct CX3DImporter_NodeElement_Light
/// This struct hold <TextureTransform> value.
struct CX3DImporter_NodeElement_Light : public CX3DImporter_NodeElement
{
float AmbientIntensity ; ///< Specifies the intensity of the ambient emission from the light.
aiColor3D Color ; ///< specifies the spectral colour properties of both the direct and ambient light emission as an RGB value.
aiVector3D Direction ; ///< Specifies the direction vector of the illumination emanating from the light source in the local coordinate system.
/// \var Global
/// Field that determines whether the light is global or scoped. Global lights illuminate all objects that fall within their volume of lighting influence.
/// Scoped lights only illuminate objects that are in the same transformation hierarchy as the light.
bool Global ;
float Intensity ; ///< Specifies the brightness of the direct emission from the light.
/// \var Attenuation
/// PointLight node's illumination falls off with distance as specified by three attenuation coefficients. The attenuation factor
/// is: "1 / max(attenuation[0] + attenuation[1] × ×
aiVector3D Attenuation ;
aiVector3D Location ; ///< Specifies a translation offset of the centre point of the light source from the light's local coordinate system origin.
float Radius ; ///< Specifies the radial extent of the solid angle and the maximum distance from location that may be illuminated by the light source.
float BeamWidth ; ///< Specifies an inner solid angle in which the light source emits light at uniform full intensity.
float CutOffAngle ; ///< The light source's emission intensity drops off from the inner solid angle (beamWidth) to the outer solid angle (cutOffAngle).
/// \fn CX3DImporter_NodeElement_Light(EType pLightType, CX3DImporter_NodeElement* pParent)
/// Constructor
/// \param [in] pParent - pointer to parent node.
/// \param [in] pLightType - type of the light source.
CX3DImporter_NodeElement_Light ( EType pLightType , CX3DImporter_NodeElement * pParent )
: CX3DImporter_NodeElement ( pLightType , pParent )
{ }
} ; // struct CX3DImporter_NodeElement_Light
# endif // INCLUDED_AI_X3D_IMPORTER_NODE_H
