assimp/code/X3DImporter_Node.hpp

/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------

Copyright (c) 2006-2017, assimp team

All rights reserved.

Redistribution and use of this software 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 assimp team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the assimp team.

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
OWNER 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.

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

#ifndef INCLUDED_AI_X3D_IMPORTER_NODE_H
#define INCLUDED_AI_X3D_IMPORTER_NODE_H

// Header files, Assimp.
#include <assimp/scene.h>
#include <assimp/types.h>

// Header files, stdlib.
#include <list>
#include <vector>
#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.
	CX3DImporter_NodeElement* Parent;///< Parent element. If nullptr then this node is root.
	std::list<CX3DImporter_NodeElement*> Child;///< Child elements.

	/***********************************************/
	/****************** Functions ******************/
	/***********************************************/

    /// @brief  The destructor, virtual.
    virtual ~CX3DImporter_NodeElement() {
        // empty
    }

private:
	/// Disabled copy constructor.
	CX3DImporter_NodeElement(const CX3DImporter_NodeElement& pNodeElement);

	/// Disabled assign operator.
	CX3DImporter_NodeElement& operator=(const CX3DImporter_NodeElement& pNodeElement);

	/// Disabled default constructor.
	CX3DImporter_NodeElement();

protected:
	/// 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::vector<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::vector<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::vector<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::vector<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 {
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.

	/// 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)
	, Vertices()
	, NumIndices( 0 )
	, Solid(true) {
        // empty		
	}

private:
	/// Disabled copy constructor.
	CX3DImporter_NodeElement_Geometry3D(const CX3DImporter_NodeElement_Geometry3D& pNode);

	/// Disabled assign operator.
	CX3DImporter_NodeElement_Geometry3D& operator=(const CX3DImporter_NodeElement_Geometry3D& pNode);
};// 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::vector<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::vector<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::vector<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::vector<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::vector<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::vector<int32_t> CoordIndex;///< Field to specify the polygonal faces by indexing into the <Coordinate>.
	std::vector<int32_t> NormalIndex;///< Field to specify the polygonal faces by indexing into the <Normal>.
	std::vector<int32_t> TexCoordIndex;///< Field to specify the polygonal faces by indexing into the <TextureCoordinate>.
	std::vector<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 {
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.

	/// 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)
	, AmbientIntensity( 0.0f )
	, DiffuseColor()
	, EmissiveColor()
	, Shininess( 0.0f )
	, SpecularColor()
	, Transparency( 1.0f ) {
		// empty
	}

private:
	/// Disabled copy constructor.
	CX3DImporter_NodeElement_Material(const CX3DImporter_NodeElement_Material& pNode);

	/// Disabled assign operator.
	CX3DImporter_NodeElement_Material& operator=(const CX3DImporter_NodeElement_Material& pNode);
};// 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