assimp/code/X3DImporter_Node.hpp

/// \file X3DImporter_Node.hpp
/// \brief Elements of scene graph.
/// \date 2015-2016
/// \author nevorek@gmail.com

#ifndef INCLUDED_AI_X3D_IMPORTER_NODE_H
#define INCLUDED_AI_X3D_IMPORTER_NODE_H

#include <list>
#include <string>

#include "../include/assimp/types.h"
#include "../include/assimp/scene.h"

/// \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.
	CX3DImporter_NodeElement* Parent;///< Parrent element. If NULL then this node is root.
	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] × r + attenuation[2] × r2, 1)", where r is the distance from the light to the surface being illuminated.
	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