2016-10-02 00:08:34 +00:00
/// \file X3DImporter.hpp
/// \brief X3D-format files importer for Assimp.
/// \date 2015-2016
/// \author smal.root@gmail.com
// Thanks to acorn89 for support.
2016-09-29 15:50:24 +00:00
# ifndef INCLUDED_AI_X3D_IMPORTER_H
# define INCLUDED_AI_X3D_IMPORTER_H
2016-10-02 00:08:34 +00:00
# include "X3DImporter_Node.hpp"
2016-09-29 15:50:24 +00:00
2016-10-02 00:08:34 +00:00
// Header files, Assimp.
# include "assimp/DefaultLogger.hpp"
# include "assimp/importerdesc.h"
# include "assimp/ProgressHandler.hpp"
# include "assimp/types.h"
2016-09-29 15:50:24 +00:00
# include "BaseImporter.h"
# include "irrXMLWrapper.h"
namespace Assimp
{
/// \class X3DImporter
/// Class that holding scene graph which include: groups, geometry, metadata etc.
///
/// Limitations.
///
/// Pay attention that X3D is format for interactive graphic and simulations for web browsers.
/// So not all features can be imported using Assimp.
///
/// Unsupported nodes:
/// CAD geometry component:
/// "CADAssembly", "CADFace", "CADLayer", "CADPart", "IndexedQuadSet", "QuadSet"
/// Core component:
/// "ROUTE", "ExternProtoDeclare", "ProtoDeclare", "ProtoInstance", "ProtoInterface", "WorldInfo"
/// Distributed interactive simulation (DIS) component:
/// "DISEntityManager", "DISEntityTypeMapping", "EspduTransform", "ReceiverPdu", "SignalPdu", "TransmitterPdu"
/// Cube map environmental texturing component:
/// "ComposedCubeMapTexture", "GeneratedCubeMapTexture", "ImageCubeMapTexture"
/// Environmental effects component:
/// "Background", "Fog", "FogCoordinate", "LocalFog", "TextureBackground"
/// Environmental sensor component:
/// "ProximitySensor", "TransformSensor", "VisibilitySensor"
/// Followers component:
/// "ColorChaser", "ColorDamper", "CoordinateChaser", "CoordinateDamper", "OrientationChaser", "OrientationDamper", "PositionChaser",
/// "PositionChaser2D", "PositionDamper", "PositionDamper2D", "ScalarChaser", "ScalarDamper", "TexCoordChaser2D", "TexCoordDamper2D"
/// Geospatial component:
/// "GeoCoordinate", "GeoElevationGrid", "GeoLocation", "GeoLOD", "GeoMetadata", "GeoOrigin", "GeoPositionInterpolator", "GeoProximitySensor",
/// "GeoTouchSensor", "GeoTransform", "GeoViewpoint"
/// Humanoid Animation (H-Anim) component:
/// "HAnimDisplacer", "HAnimHumanoid", "HAnimJoint", "HAnimSegment", "HAnimSite"
/// Interpolation component:
/// "ColorInterpolator", "CoordinateInterpolator", "CoordinateInterpolator2D", "EaseInEaseOut", "NormalInterpolator", "OrientationInterpolator",
/// "PositionInterpolator", "PositionInterpolator2D", "ScalarInterpolator", "SplinePositionInterpolator", "SplinePositionInterpolator2D",
/// "SplineScalarInterpolator", "SquadOrientationInterpolator",
/// Key device sensor component:
/// "KeySensor", "StringSensor"
/// Layering component:
/// "Layer", "LayerSet", "Viewport"
/// Layout component:
/// "Layout", "LayoutGroup", "LayoutLayer", "ScreenFontStyle", "ScreenGroup"
/// Navigation component:
/// "Billboard", "Collision", "LOD", "NavigationInfo", "OrthoViewpoint", "Viewpoint", "ViewpointGroup"
/// Networking component:
/// "Anchor", "LoadSensor"
/// NURBS component:
/// "Contour2D", "ContourPolyline2D", "CoordinateDouble", "NurbsCurve", "NurbsCurve2D", "NurbsOrientationInterpolator", "NurbsPatchSurface",
/// "NurbsPositionInterpolator", "NurbsSet", "NurbsSurfaceInterpolator", "NurbsSweptSurface", "NurbsSwungSurface", "NurbsTextureCoordinate",
/// "NurbsTrimmedSurface"
/// Particle systems component:
/// "BoundedPhysicsModel", "ConeEmitter", "ExplosionEmitter", "ForcePhysicsModel", "ParticleSystem", "PointEmitter", "PolylineEmitter",
/// "SurfaceEmitter", "VolumeEmitter", "WindPhysicsModel"
/// Picking component:
/// "LinePickSensor", "PickableGroup", "PointPickSensor", "PrimitivePickSensor", "VolumePickSensor"
/// Pointing device sensor component:
/// "CylinderSensor", "PlaneSensor", "SphereSensor", "TouchSensor"
/// Rendering component:
/// "ClipPlane"
/// Rigid body physics:
/// "BallJoint", "CollidableOffset", "CollidableShape", "CollisionCollection", "CollisionSensor", "CollisionSpace", "Contact", "DoubleAxisHingeJoint",
/// "MotorJoint", "RigidBody", "RigidBodyCollection", "SingleAxisHingeJoint", "SliderJoint", "UniversalJoint"
/// Scripting component:
/// "Script"
/// Programmable shaders component:
/// "ComposedShader", "FloatVertexAttribute", "Matrix3VertexAttribute", "Matrix4VertexAttribute", "PackagedShader", "ProgramShader", "ShaderPart",
/// "ShaderProgram",
/// Shape component:
/// "FillProperties", "LineProperties", "TwoSidedMaterial"
/// Sound component:
/// "AudioClip", "Sound"
/// Text component:
/// "FontStyle", "Text"
/// Texturing3D Component:
/// "ComposedTexture3D", "ImageTexture3D", "PixelTexture3D", "TextureCoordinate3D", "TextureCoordinate4D", "TextureTransformMatrix3D",
/// "TextureTransform3D"
/// Texturing component:
/// "MovieTexture", "MultiTexture", "MultiTextureCoordinate", "MultiTextureTransform", "PixelTexture", "TextureCoordinateGenerator",
/// "TextureProperties",
/// Time component:
/// "TimeSensor"
/// Event Utilities component:
/// "BooleanFilter", "BooleanSequencer", "BooleanToggle", "BooleanTrigger", "IntegerSequencer", "IntegerTrigger", "TimeTrigger",
/// Volume rendering component:
/// "BlendedVolumeStyle", "BoundaryEnhancementVolumeStyle", "CartoonVolumeStyle", "ComposedVolumeStyle", "EdgeEnhancementVolumeStyle",
/// "IsoSurfaceVolumeData", "OpacityMapVolumeStyle", "ProjectionVolumeStyle", "SegmentedVolumeData", "ShadedVolumeStyle",
/// "SilhouetteEnhancementVolumeStyle", "ToneMappedVolumeStyle", "VolumeData"
///
/// Supported nodes:
/// Core component:
/// "MetadataBoolean", "MetadataDouble", "MetadataFloat", "MetadataInteger", "MetadataSet", "MetadataString"
/// Geometry2D component:
/// "Arc2D", "ArcClose2D", "Circle2D", "Disk2D", "Polyline2D", "Polypoint2D", "Rectangle2D", "TriangleSet2D"
/// Geometry3D component:
/// "Box", "Cone", "Cylinder", "ElevationGrid", "Extrusion", "IndexedFaceSet", "Sphere"
/// Grouping component:
/// "Group", "StaticGroup", "Switch", "Transform"
/// Lighting component:
/// "DirectionalLight", "PointLight", "SpotLight"
/// Networking component:
/// "Inline"
/// Rendering component:
/// "Color", "ColorRGBA", "Coordinate", "IndexedLineSet", "IndexedTriangleFanSet", "IndexedTriangleSet", "IndexedTriangleStripSet", "LineSet",
/// "PointSet", "TriangleFanSet", "TriangleSet", "TriangleStripSet", "Normal"
/// Shape component:
/// "Shape", "Appearance", "Material"
/// Texturing component:
/// "ImageTexture", "TextureCoordinate", "TextureTransform"
///
/// Limitations of attribute "USE".
/// If "USE" is set then node must be empty, like that:
/// <Node USE='name'/>
/// not the
/// <Node USE='name'><!-- something --> </Node>
///
/// Ignored attributes: "creaseAngle", "convex", "solid".
///
/// Texture coordinates generating: only for Sphere, Cone, Cylinder. In all other case used PLANE mapping.
/// It's better that Assimp main code has powerfull texture coordinates generator. Then is not needed to
/// duplicate this code in every importer.
///
/// Lighting limitations.
/// If light source placed in some group with "DEF" set. And after that some node is use it group with "USE" attribute then
/// you will get error about duplicate light sources. That's happening because Assimp require names for lights but do not like
/// duplicates of it )).
///
/// Color for faces.
2016-10-02 00:08:34 +00:00
/// That's happening when attribute "colorPerVertex" is set to "false". But Assimp do not hold how many colors has mesh and require
2016-09-29 15:50:24 +00:00
/// equal length for mVertices and mColors. You will see the colors but vertices will use call which last used in "colorIdx".
///
/// That's all for now. Enjoy
///
class X3DImporter : public BaseImporter
{
/***********************************************/
/******************** Types ********************/
/***********************************************/
/***********************************************/
/****************** Constants ******************/
/***********************************************/
private :
static const aiImporterDesc Description ;
/***********************************************/
/****************** Variables ******************/
/***********************************************/
private :
CX3DImporter_NodeElement * NodeElement_Cur ; ///< Current element.
irr : : io : : IrrXMLReader * mReader ; ///< Pointer to XML-reader object
std : : string mFileDir ;
public :
std : : list < CX3DImporter_NodeElement * > NodeElement_List ; ///< All elements of scene graph.
/***********************************************/
/****************** Functions ******************/
/***********************************************/
private :
/// \fn X3DImporter(const X3DImporter& pScene)
/// Disabled copy constructor.
X3DImporter ( const X3DImporter & pScene ) ;
/// \fn X3DImporter& operator=(const X3DImporter& pScene)
/// Disabled assign operator.
X3DImporter & operator = ( const X3DImporter & pScene ) ;
/// \fn void Clear()
/// Clear all temporary data.
void Clear ( ) ;
/***********************************************/
/************* Functions: find set *************/
/***********************************************/
/// \fn bool FindNodeElement_FromRoot(const std::string& pID, const CX3DImporter_NodeElement::EType pType, CX3DImporter_NodeElement** pElement)
/// Find requested node element. Search will be made in all existing nodes.
/// \param [in] pID - ID of requested element.
/// \param [in] pType - type of requested element.
/// \param [out] pElement - pointer to pointer to item found.
/// \return true - if the element is found, else - false.
bool FindNodeElement_FromRoot ( const std : : string & pID , const CX3DImporter_NodeElement : : EType pType , CX3DImporter_NodeElement * * pElement ) ;
/// \fn bool FindNodeElement_FromNode(CX3DImporter_NodeElement* pStartNode, const std::string& pID, const CX3DImporter_NodeElement::EType pType, CX3DImporter_NodeElement** pElement)
/// Find requested node element. Search will be made from pointed node down to childs.
/// \param [in] pStartNode - pointer to start node.
/// \param [in] pID - ID of requested element.
/// \param [in] pType - type of requested element.
/// \param [out] pElement - pointer to pointer to item found.
/// \return true - if the element is found, else - false.
bool FindNodeElement_FromNode ( CX3DImporter_NodeElement * pStartNode , const std : : string & pID , const CX3DImporter_NodeElement : : EType pType ,
CX3DImporter_NodeElement * * pElement ) ;
/// \fn bool FindNodeElement(const std::string& pName, const CX3DImporter_NodeElement::EType pType, CX3DImporter_NodeElement** pElement)
/// Find requested node element. For "Node"'s accounting flag "Static".
/// \param [in] pName - name of requested element.
/// \param [in] pType - type of requested element.
/// \param [out] pElement - pointer to pointer to item found.
/// \return true - if the element is found, else - false.
bool FindNodeElement ( const std : : string & pName , const CX3DImporter_NodeElement : : EType pType , CX3DImporter_NodeElement * * pElement ) ;
/***********************************************/
/********* Functions: postprocess set **********/
/***********************************************/
/// \fn aiMatrix4x4 PostprocessHelper_Matrix_GlobalToCurrent() const
/// \return transformation matrix from global coordinate system to local.
aiMatrix4x4 PostprocessHelper_Matrix_GlobalToCurrent ( ) const ;
/// \fn void PostprocessHelper_CollectMetadata(const CX3DImporter_NodeElement& pNodeElement, std::list<CX3DImporter_NodeElement*>& pList) const
/// Check if child elements of node element is metadata and add it to temporary list.
/// \param [in] pNodeElement - node element where metadata is searching.
/// \param [out] pList - temporary list for collected metadata.
void PostprocessHelper_CollectMetadata ( const CX3DImporter_NodeElement & pNodeElement , std : : list < CX3DImporter_NodeElement * > & pList ) const ;
/// \fn bool bool PostprocessHelper_ElementIsMetadata(const CX3DImporter_NodeElement::EType pType) const
/// Check if type of node element is metadata. E.g. <MetadataSet>, <MetadataString>.
/// \param [in] pType - checked type.
/// \return true - if the type corresponds to the metadata.
bool PostprocessHelper_ElementIsMetadata ( const CX3DImporter_NodeElement : : EType pType ) const ;
/// \fn bool PostprocessHelper_ElementIsMesh(const CX3DImporter_NodeElement::EType pType) const
/// Check if type of node element is geometry object and can be used to build mesh. E.g. <Box>, <Arc2D>.
/// \param [in] pType - checked type.
/// \return true - if the type corresponds to the mesh.
bool PostprocessHelper_ElementIsMesh ( const CX3DImporter_NodeElement : : EType pType ) const ;
/// \fn void Postprocess_BuildLight(const CX3DImporter_NodeElement& pNodeElement, std::list<aiLight*>& pSceneLightList) const
/// Read CX3DImporter_NodeElement_Light, create aiLight and add it to list of the lights.
/// \param [in] pNodeElement - reference to lisght element(<DirectionalLight>, <PointLight>, <SpotLight>).
/// \param [out] pSceneLightList - reference to list of the lights.
void Postprocess_BuildLight ( const CX3DImporter_NodeElement & pNodeElement , std : : list < aiLight * > & pSceneLightList ) const ;
/// \fn void Postprocess_BuildMaterial(const CX3DImporter_NodeElement& pNodeElement, aiMaterial** pMaterial) const
/// Create filled structure with type \ref aiMaterial from \ref CX3DImporter_NodeElement. This function itseld extract
/// all needed data from scene graph.
/// \param [in] pNodeElement - reference to material element(<Appearance>).
2016-10-02 00:08:34 +00:00
/// \param [out] pMaterial - pointer to pointer to created material. *pMaterial must be nullptr.
2016-09-29 15:50:24 +00:00
void Postprocess_BuildMaterial ( const CX3DImporter_NodeElement & pNodeElement , aiMaterial * * pMaterial ) const ;
/// \fn void Postprocess_BuildMesh(const CX3DImporter_NodeElement& pNodeElement, aiMesh** pMesh) const
/// Create filled structure with type \ref aiMaterial from \ref CX3DImporter_NodeElement. This function itseld extract
/// all needed data from scene graph.
/// \param [in] pNodeElement - reference to geometry object.
2016-10-02 00:08:34 +00:00
/// \param [out] pMesh - pointer to pointer to created mesh. *pMesh must be nullptr.
2016-09-29 15:50:24 +00:00
void Postprocess_BuildMesh ( const CX3DImporter_NodeElement & pNodeElement , aiMesh * * pMesh ) const ;
/// \fn void Postprocess_BuildNode(const CX3DImporter_NodeElement& pNodeElement, aiNode& pSceneNode, std::list<aiMesh*>& pSceneMeshList, std::list<aiMaterial*>& pSceneMaterialList, std::list<aiLight*>& pSceneLightList) const
/// Create aiNode from CX3DImporter_NodeElement. Also function check children and make recursive call.
2016-10-02 00:08:34 +00:00
/// \param [out] pNode - pointer to pointer to created node. *pNode must be nullptr.
2016-09-29 15:50:24 +00:00
/// \param [in] pNodeElement - CX3DImporter_NodeElement which read.
/// \param [out] pSceneNode - aiNode for filling.
/// \param [out] pSceneMeshList - list with aiMesh which belong to scene.
/// \param [out] pSceneMaterialList - list with aiMaterial which belong to scene.
/// \param [out] pSceneLightList - list with aiLight which belong to scene.
void Postprocess_BuildNode ( const CX3DImporter_NodeElement & pNodeElement , aiNode & pSceneNode , std : : list < aiMesh * > & pSceneMeshList ,
std : : list < aiMaterial * > & pSceneMaterialList , std : : list < aiLight * > & pSceneLightList ) const ;
/// \fn void Postprocess_BuildShape(const CX3DImporter_NodeElement_Shape& pShapeNodeElement, std::list<unsigned int>& pNodeMeshInd, std::list<aiMesh*>& pSceneMeshList, std::list<aiMaterial*>& pSceneMaterialList) const
/// To create mesh and material kept in <Schape>.
/// \param pShapeNodeElement - reference to node element which kept <Shape> data.
/// \param pNodeMeshInd - reference to list with mesh indices. When pShapeNodeElement will read new mesh index will be added to this list.
/// \param pSceneMeshList - reference to list with meshes. When pShapeNodeElement will read new mesh will be added to this list.
/// \param pSceneMaterialList - reference to list with materials. When pShapeNodeElement will read new material will be added to this list.
void Postprocess_BuildShape ( const CX3DImporter_NodeElement_Shape & pShapeNodeElement , std : : list < unsigned int > & pNodeMeshInd ,
std : : list < aiMesh * > & pSceneMeshList , std : : list < aiMaterial * > & pSceneMaterialList ) const ;
/// \fn void Postprocess_CollectMetadata(aiNode& pSceneNode, const CX3DImporter_NodeElement& pNodeElement) const
/// Check if child elements of node element is metadata and add it to scene node.
/// \param [in] pNodeElement - node element where metadata is searching.
/// \param [out] pSceneNode - scene node in which metadata will be added.
void Postprocess_CollectMetadata ( const CX3DImporter_NodeElement & pNodeElement , aiNode & pSceneNode ) const ;
/***********************************************/
/************* Functions: throw set ************/
/***********************************************/
/// \fn void Throw_ArgOutOfRange(const std::string& pArgument)
/// Call that function when argument is out of range and exception must be raised.
/// \throw DeadlyImportError.
/// \param [in] pArgument - argument name.
void Throw_ArgOutOfRange ( const std : : string & pArgument ) ;
/// \fn void Throw_CloseNotFound(const std::string& pNode)
/// Call that function when close tag of node not found and exception must be raised.
/// E.g.:
/// <Scene>
/// <Shape>
/// </Scene> <!--- shape not closed --->
/// \throw DeadlyImportError.
/// \param [in] pNode - node name in which exception happened.
void Throw_CloseNotFound ( const std : : string & pNode ) ;
/// \fn void Throw_ConvertFail_Str2ArrF(const std::string& pAttrValue)
/// Call that function when string value can not be converted to floating point value and exception must be raised.
/// \param [in] pAttrValue - attribute value.
/// \throw DeadlyImportError.
void Throw_ConvertFail_Str2ArrF ( const std : : string & pAttrValue ) ;
/// \fn void Throw_DEF_And_USE()
/// Call that function when in node defined attributes "DEF" and "USE" and exception must be raised.
/// E.g.: <Box DEF="BigBox" USE="MegaBox">
/// \throw DeadlyImportError.
void Throw_DEF_And_USE ( ) ;
/// \fn void Throw_IncorrectAttr(const std::string& pAttrName)
/// Call that function when attribute name is incorrect and exception must be raised.
/// \param [in] pAttrName - attribute name.
/// \throw DeadlyImportError.
void Throw_IncorrectAttr ( const std : : string & pAttrName ) ;
/// \fn void Throw_IncorrectAttrValue(const std::string& pAttrName)
/// Call that function when attribute value is incorrect and exception must be raised.
/// \param [in] pAttrName - attribute name.
/// \throw DeadlyImportError.
void Throw_IncorrectAttrValue ( const std : : string & pAttrName ) ;
/// \fn void Throw_MoreThanOnceDefined(const std::string& pNode, const std::string& pDescription)
/// Call that function when some type of nodes are defined twice or more when must be used only once and exception must be raised.
/// E.g.:
/// <Shape>
/// <Box/> <!--- first geometry node --->
/// <Sphere/> <!--- second geometry node. raise exception --->
/// </Shape>
/// \throw DeadlyImportError.
/// \param [in] pNodeType - type of node which defined one more time.
/// \param [in] pDescription - message about error. E.g. what the node defined while exception raised.
void Throw_MoreThanOnceDefined ( const std : : string & pNodeType , const std : : string & pDescription ) ;
/// \fn void Throw_TagCountIncorrect(const std::string& pNode)
/// Call that function when count of opening and closing tags which create group(e.g. <Group>) are not equal and exception must be raised.
/// E.g.:
/// <Scene>
/// <Transform> <!--- first grouping node begin --->
/// <Group> <!--- second grouping node begin --->
/// </Transform> <!--- first grouping node end --->
/// </Scene> <!--- one grouping node still not closed --->
/// \throw DeadlyImportError.
/// \param [in] pNode - node name in which exception happened.
void Throw_TagCountIncorrect ( const std : : string & pNode ) ;
/// \fn void Throw_USE_NotFound(const std::string& pAttrValue)
/// Call that function when defined in "USE" element are not found in graph and exception must be raised.
/// \param [in] pAttrValue - "USE" attribute value.
/// \throw DeadlyImportError.
void Throw_USE_NotFound ( const std : : string & pAttrValue ) ;
/***********************************************/
/************** Functions: LOG set *************/
/***********************************************/
/// \fn void LogInfo(const std::string& pMessage)
/// Short variant for calling \ref DefaultLogger::get()->info()
void LogInfo ( const std : : string & pMessage ) { DefaultLogger : : get ( ) - > info ( pMessage ) ; }
/***********************************************/
/************** Functions: XML set *************/
/***********************************************/
/// \fn void XML_CheckNode_MustBeEmpty()
/// Chek if current node is empty: <node />. If not then exception will throwed.
void XML_CheckNode_MustBeEmpty ( ) ;
/// \fn bool XML_CheckNode_NameEqual(const std::string& pNodeName)
/// Chek if current node name is equal to pNodeName.
/// \param [in] pNodeName - name for checking.
/// return true if current node name is equal to pNodeName, else - false.
bool XML_CheckNode_NameEqual ( const std : : string & pNodeName ) { return mReader - > getNodeName ( ) = = pNodeName ; }
/// \fn void XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName)
/// Skip unsupported node and report about that. Depend on node name can be skipped begin tag of node all whole node.
/// \param [in] pParentNodeName - parent node name. Used for reporting.
void XML_CheckNode_SkipUnsupported ( const std : : string & pParentNodeName ) ;
/// \fn bool XML_SearchNode(const std::string& pNodeName)
/// Search for specified node in file. XML file read pointer(mReader) will point to found node or file end after search is end.
/// \param [in] pNodeName - requested node name.
/// return true - if node is found, else - false.
bool XML_SearchNode ( const std : : string & pNodeName ) ;
/// \fn bool XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \return read data.
bool XML_ReadNode_GetAttrVal_AsBool ( const int pAttrIdx ) ;
/// \fn float XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \return read data.
float XML_ReadNode_GetAttrVal_AsFloat ( const int pAttrIdx ) ;
/// \fn int32_t XML_ReadNode_GetAttrVal_AsI32(const int pAttrIdx)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \return read data.
int32_t XML_ReadNode_GetAttrVal_AsI32 ( const int pAttrIdx ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsCol3f(const int pAttrIdx, aiColor3D& pValue)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsCol3f ( const int pAttrIdx , aiColor3D & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsVec2f(const int pAttrIdx, aiVector2D& pValue)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsVec2f ( const int pAttrIdx , aiVector2D & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsVec3f(const int pAttrIdx, aiVector3D& pValue)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsVec3f ( const int pAttrIdx , aiVector3D & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsListB(const int pAttrIdx, std::list<bool>& pValue)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListB ( const int pAttrIdx , std : : list < bool > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsArrB(const int pAttrIdx, std::vector<bool>& pValue)
/// \overload void XML_ReadNode_GetAttrVal_AsListBool(const int pAttrIdx, std::list<bool>& pValue)
void XML_ReadNode_GetAttrVal_AsArrB ( const int pAttrIdx , std : : vector < bool > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsListI32(const int pAttrIdx, std::list<int32_t>& pValue)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListI32 ( const int pAttrIdx , std : : list < int32_t > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsArrI32(const int pAttrIdx, std::vector<int32_t>& pValue)
/// \overload void XML_ReadNode_GetAttrVal_AsListI32(const int pAttrIdx, std::list<int32_t>& pValue)
void XML_ReadNode_GetAttrVal_AsArrI32 ( const int pAttrIdx , std : : vector < int32_t > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsListF(const int pAttrIdx, std::list<float>& pValue)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListF ( const int pAttrIdx , std : : list < float > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsArrF(const int pAttrIdx, std::vector<float>& pValue)
/// \overload void XML_ReadNode_GetAttrVal_AsListF(const int pAttrIdx, std::list<float>& pValue)
void XML_ReadNode_GetAttrVal_AsArrF ( const int pAttrIdx , std : : vector < float > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsListD(const int pAttrIdx, std::list<double>& pValue)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListD ( const int pAttrIdx , std : : list < double > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsArrD(const int pAttrIdx, std::vector<double>& pValue)
/// \overload void XML_ReadNode_GetAttrVal_AsListD(const int pAttrIdx, std::list<double>& pValue)
void XML_ReadNode_GetAttrVal_AsArrD ( const int pAttrIdx , std : : vector < double > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsListCol3f(const int pAttrIdx, std::list<aiColor3D>& pValue)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListCol3f ( const int pAttrIdx , std : : list < aiColor3D > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsArrCol3f(const int pAttrIdx, std::vector<aiColor3D>& pValue)
/// \overload void XML_ReadNode_GetAttrVal_AsListCol3f(const int pAttrIdx, std::vector<aiColor3D>& pValue)
void XML_ReadNode_GetAttrVal_AsArrCol3f ( const int pAttrIdx , std : : vector < aiColor3D > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsListCol4f(const int pAttrIdx, std::list<aiColor4D>& pValue)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListCol4f ( const int pAttrIdx , std : : list < aiColor4D > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsArrCol4f(const int pAttrIdx, std::vector<aiColor4D>& pValue)
/// \overload void XML_ReadNode_GetAttrVal_AsListCol4f(const int pAttrIdx, std::list<aiColor4D>& pValue)
void XML_ReadNode_GetAttrVal_AsArrCol4f ( const int pAttrIdx , std : : vector < aiColor4D > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsListVec2f(const int pAttrIdx, std::list<aiVector2D>& pValue)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListVec2f ( const int pAttrIdx , std : : list < aiVector2D > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsArrVec2f(const int pAttrIdx, std::vector<aiVector2D>& pValue)
/// \overload void XML_ReadNode_GetAttrVal_AsListVec2f(const int pAttrIdx, std::list<aiVector2D>& pValue)
void XML_ReadNode_GetAttrVal_AsArrVec2f ( const int pAttrIdx , std : : vector < aiVector2D > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsListVec3f(const int pAttrIdx, std::list<aiVector3D>& pValue)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListVec3f ( const int pAttrIdx , std : : list < aiVector3D > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsArrVec3f(const int pAttrIdx, std::vector<aiVector3D>& pValue)
/// \overload void XML_ReadNode_GetAttrVal_AsListVec3f(const int pAttrIdx, std::list<aiVector3D>& pValue)
void XML_ReadNode_GetAttrVal_AsArrVec3f ( const int pAttrIdx , std : : vector < aiVector3D > & pValue ) ;
/// \fn void XML_ReadNode_GetAttrVal_AsListS(const int pAttrIdx, std::list<std::string>& pValue)
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListS ( const int pAttrIdx , std : : list < std : : string > & pValue ) ;
/***********************************************/
/******* Functions: geometry helper set *******/
/***********************************************/
/// \fn aiVector3D GeometryHelper_Make_Point2D(const float pAngle, const float pRadius)
/// Make point on surface oXY.
/// \param [in] pAngle - angle in radians between radius-vector of point and oX axis. Angle extends from the oX axis counterclockwise to the radius-vector.
/// \param [in] pRadius - length of radius-vector.
/// \return made point coordinates.
aiVector3D GeometryHelper_Make_Point2D ( const float pAngle , const float pRadius ) ;
/// \fn void GeometryHelper_Make_Arc2D(const float pStartAngle, const float pEndAngle, const float pRadius, size_t pNumSegments, std::list<aiVector3D>& pVertices)
/// Make 2D figure - linear circular arc with center in (0, 0). The z-coordinate is 0. The arc extends from the pStartAngle counterclockwise
/// to the pEndAngle. If pStartAngle and pEndAngle have the same value, a circle is specified. If the absolute difference between pStartAngle
/// and pEndAngle is greater than or equal to 2pi, a circle is specified.
/// \param [in] pStartAngle - angle in radians of start of the arc.
/// \param [in] pEndAngle - angle in radians of end of the arc.
/// \param [in] pRadius - radius of the arc.
/// \param [out] pNumSegments - number of segments in arc. In other words - tesselation factor.
/// \param [out] pVertices - generated vertices.
void GeometryHelper_Make_Arc2D ( const float pStartAngle , const float pEndAngle , const float pRadius , size_t pNumSegments , std : : list < aiVector3D > & pVertices ) ;
/// \fn void GeometryHelper_Extend_PointToLine(const std::list<aiVector3D>& pPoint, std::list<aiVector3D>& pLine)
/// Create line set from point set.
/// \param [in] pPoint - input points list.
/// \param [out] pLine - made lines list.
void GeometryHelper_Extend_PointToLine ( const std : : list < aiVector3D > & pPoint , std : : list < aiVector3D > & pLine ) ;
/// \fn GeometryHelper_Extend_PolylineIdxToLineIdx(const std::list<int32_t>& pPolylineCoordIdx, std::list<int32_t>& pLineCoordIdx)
/// Create CoordIdx of line set from CoordIdx of polyline set.
/// \param [in] pPolylineCoordIdx - vertices indices divided by delimiter "-1". Must contain faces with two or more indices.
/// \param [out] pLineCoordIdx - made CoordIdx of line set.
void GeometryHelper_Extend_PolylineIdxToLineIdx ( const std : : list < int32_t > & pPolylineCoordIdx , std : : list < int32_t > & pLineCoordIdx ) ;
/// \fn void GeometryHelper_MakeQL_RectParallelepiped(const aiVector3D& pSize, std::list<aiVector3D>& pVertices)
/// Make 3D body - rectangular parallelepiped with center in (0, 0). QL mean quadlist (\sa pVertices).
/// \param [in] pSize - scale factor for body for every axis. E.g. (1, 2, 1) mean: X-size and Z-size - 1, Y-size - 2.
/// \param [out] pVertices - generated vertices. The list of vertices is grouped in quads.
void GeometryHelper_MakeQL_RectParallelepiped ( const aiVector3D & pSize , std : : list < aiVector3D > & pVertices ) ;
/// \fn void GeometryHelper_CoordIdxStr2FacesArr(const std::list<int32_t>& pCoordIdx, std::vector<aiFace>& pFaces, unsigned int& pPrimitiveTypes) const
/// Create faces array from vertices indices array.
/// \param [in] pCoordIdx - vertices indices divided by delimiter "-1".
/// \param [in] pFaces - created faces array.
/// \param [in] pPrimitiveTypes - type of primitives in faces.
void GeometryHelper_CoordIdxStr2FacesArr ( const std : : list < int32_t > & pCoordIdx , std : : vector < aiFace > & pFaces , unsigned int & pPrimitiveTypes ) const ;
/// \fn void MeshGeometry_AddColor(aiMesh& pMesh, const std::list<int32_t>& pCoordIdx, const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const
/// Add colors to mesh.
/// a. If colorPerVertex is FALSE, colours are applied to each face, as follows:
/// If the colorIndex field is not empty, one colour is used for each face of the mesh. There shall be at least as many indices in the
/// colorIndex field as there are faces in the mesh. The colorIndex field shall not contain any negative entries.
/// If the colorIndex field is empty, the colours in the X3DColorNode node are applied to each face of the mesh in order.
/// There shall be at least as many colours in the X3DColorNode node as there are faces.
/// b. If colorPerVertex is TRUE, colours are applied to each vertex, as follows:
/// If the colorIndex field is not empty, colours are applied to each vertex of the mesh in exactly the same manner that the coordIndex
/// field is used to choose coordinates for each vertex from the <Coordinate> node. The colorIndex field shall contain end-of-face markers (− 1)
/// in exactly the same places as the coordIndex field.
/// If the colorIndex field is empty, the coordIndex field is used to choose colours from the X3DColorNode node.
/// \param [in] pMesh - mesh for adding data.
/// \param [in] pCoordIdx - vertices indices divided by delimiter "-1".
/// \param [in] pColorIdx - color indices for every vertex divided by delimiter "-1" if \ref pColorPerVertex is true. if \ref pColorPerVertex is false
/// then pColorIdx contain color indices for every faces and must not contain delimiter "-1".
/// \param [in] pColors - defined colors.
/// \param [in] pColorPerVertex - if \ref pColorPerVertex is true then color in \ref pColors defined for every vertex, if false - for every face.
void MeshGeometry_AddColor ( aiMesh & pMesh , const std : : list < int32_t > & pCoordIdx , const std : : list < int32_t > & pColorIdx ,
const std : : list < aiColor4D > & pColors , const bool pColorPerVertex ) const ;
/// \fn void MeshGeometry_AddColor(aiMesh& pMesh, const std::list<int32_t>& pCoordIdx, const std::list<int32_t>& pColorIdx, const std::list<aiColor3D>& pColors, const bool pColorPerVertex) const;
/// \overload void MeshGeometry_AddColor(aiMesh& pMesh, const std::list<int32_t>& pCoordIdx, const std::list<int32_t>& pColorIdx, const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const;
void MeshGeometry_AddColor ( aiMesh & pMesh , const std : : list < int32_t > & pCoordIdx , const std : : list < int32_t > & pColorIdx ,
const std : : list < aiColor3D > & pColors , const bool pColorPerVertex ) const ;
/// \fn void MeshGeometry_AddColor(aiMesh& pMesh, const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const
/// Add colors to mesh.
/// \param [in] pMesh - mesh for adding data.
/// \param [in] pColors - defined colors.
/// \param [in] pColorPerVertex - if \ref pColorPerVertex is true then color in \ref pColors defined for every vertex, if false - for every face.
void MeshGeometry_AddColor ( aiMesh & pMesh , const std : : list < aiColor4D > & pColors , const bool pColorPerVertex ) const ;
/// \fn void MeshGeometry_AddColor(aiMesh& pMesh, const std::list<aiColor3D>& pColors, const bool pColorPerVertex) const
/// \overload void MeshGeometry_AddColor(aiMesh& pMesh, const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const
void MeshGeometry_AddColor ( aiMesh & pMesh , const std : : list < aiColor3D > & pColors , const bool pColorPerVertex ) const ;
/// \fn void MeshGeometry_AddNormal(aiMesh& pMesh, const std::list<int32_t>& pCoordIdx, const std::list<int32_t>& pNormalIdx, const std::list<aiVector3D>& pNormals, const bool pNormalPerVertex) const
/// Add normals to mesh. Function work similar to \ref MeshGeometry_AddColor;
void MeshGeometry_AddNormal ( aiMesh & pMesh , const std : : list < int32_t > & pCoordIdx , const std : : list < int32_t > & pNormalIdx ,
const std : : list < aiVector3D > & pNormals , const bool pNormalPerVertex ) const ;
/// \fn void MeshGeometry_AddNormal(aiMesh& pMesh, const std::list<aiVector3D>& pNormals, const bool pNormalPerVertex) const
/// Add normals to mesh. Function work similar to \ref MeshGeometry_AddColor;
void MeshGeometry_AddNormal ( aiMesh & pMesh , const std : : list < aiVector3D > & pNormals , const bool pNormalPerVertex ) const ;
/// \fn void MeshGeometry_AddTexCoord(aiMesh& pMesh, const std::list<int32_t>& pCoordIdx, const std::list<int32_t>& pTexCoordIdx, const std::list<aiVector2D>& pTexCoords) const
/// Add texture coordinates to mesh. Function work similar to \ref MeshGeometry_AddColor;
void MeshGeometry_AddTexCoord ( aiMesh & pMesh , const std : : list < int32_t > & pCoordIdx , const std : : list < int32_t > & pTexCoordIdx ,
const std : : list < aiVector2D > & pTexCoords ) const ;
/// \fn void MeshGeometry_AddTexCoord(aiMesh& pMesh, const std::list<aiVector2D>& pTexCoords) const
/// Add texture coordinates to mesh. Function work similar to \ref MeshGeometry_AddColor;
void MeshGeometry_AddTexCoord ( aiMesh & pMesh , const std : : list < aiVector2D > & pTexCoords ) const ;
/// \fn aiMesh* GeometryHelper_MakeMesh(const std::list<int32_t>& pCoordIdx, const std::list<aiVector3D>& pVertices) const
/// Create mesh.
/// \param [in] pCoordIdx - vertices indices divided by delimiter "-1".
/// \param [in] pVertices - vertices of mesh.
/// \return created mesh.
aiMesh * GeometryHelper_MakeMesh ( const std : : list < int32_t > & pCoordIdx , const std : : list < aiVector3D > & pVertices ) const ;
/***********************************************/
/******** Functions: parse set private *********/
/***********************************************/
/// \fn void ParseHelper_Group_Begin()
/// Create node element with type "Node" in scene graph. That operation is needed when you enter to X3D group node
/// like <Group>, <Transform> etc. When exiting from X3D group node(e.g. </Group>) \ref ParseHelper_Node_Exit must
/// be called.
/// \param [in] pStatic - flag: if true then static node is created(e.g. <StaticGroup>).
void ParseHelper_Group_Begin ( const bool pStatic = false ) ;
/// \fn void ParseHelper_Node_Enter(CX3DImporter_NodeElement* pNode)
/// Make pNode as current and enter deeper for parsing child nodes. At end \ref ParseHelper_Node_Exit must be called.
/// \param [in] pNode - new current node.
void ParseHelper_Node_Enter ( CX3DImporter_NodeElement * pNode ) ;
/// \fn void ParseHelper_Group_End()
/// This function must be called when exiting from X3D group node(e.g. </Group>). \ref ParseHelper_Group_Begin.
void ParseHelper_Node_Exit ( ) ;
/// \fn void ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString)
/// Attribute values of floating point types can take form ".x"(without leading zero). irrXMLReader can not read this form of values and it
/// must be converted to right form - "0.xxx".
/// \param [in] pInStr - pointer to input string which can contain incorrect form of values.
/// \param [out[ pOutString - output string with right form of values.
void ParseHelper_FixTruncatedFloatString ( const char * pInStr , std : : string & pOutString ) ;
/// \fn bool ParseHelper_CheckRead_X3DMetadataObject()
/// Check if current node has nodes of type X3DMetadataObject. Why we must do it? Because X3DMetadataObject can be in any non-empty X3DNode.
/// Meaning that X3DMetadataObject can be in any non-empty node in <Scene>.
/// \return true - if metadata node are found and parsed, false - metadata not found.
bool ParseHelper_CheckRead_X3DMetadataObject ( ) ;
/// \fn bool ParseHelper_CheckRead_X3DMetadataObject()
/// Check if current node has nodes of type X3DGeometricPropertyNode. X3DGeometricPropertyNode
/// X3DGeometricPropertyNode inheritors:
/// <FogCoordinate>, <HAnimDisplacer>, <Color>, <ColorRGBA>, <Coordinate>, <CoordinateDouble>, <GeoCoordinate>, <Normal>,
/// <MultiTextureCoordinate>, <TextureCoordinate>, <TextureCoordinate3D>, <TextureCoordinate4D>, <TextureCoordinateGenerator>,
/// <FloatVertexAttribute>, <Matrix3VertexAttribute>, <Matrix4VertexAttribute>.
/// \return true - if nodes are found and parsed, false - nodes not found.
bool ParseHelper_CheckRead_X3DGeometricPropertyNode ( ) ;
/// \fn void ParseNode_Root()
/// Parse <X3D> node of the file.
void ParseNode_Root ( ) ;
/// \fn void ParseNode_Head()
/// Parse <head> node of the file.
void ParseNode_Head ( ) ;
/// \fn void ParseNode_Root()
/// Parse <Scene> node of the file.
void ParseNode_Scene ( ) ;
/// \fn void ParseNode_Metadata(CX3DImporter_NodeElement* pParent, const std::string& pNodeName)
/// Parse child nodes of <Metadata*> node.
/// \param [in] pNodeName - parsed node name. Must be set because that function is general and name needed for checking the end
/// and error reporing.
/// \param [in] pParentElement - parent metadata element.
void ParseNode_Metadata ( CX3DImporter_NodeElement * pParentElement , const std : : string & pNodeName ) ;
/// \fn void ParseNode_MetadataBoolean()
/// Parse <MetadataBoolean> node of the file.
void ParseNode_MetadataBoolean ( ) ;
/// \fn void ParseNode_MetadataDouble()
/// Parse <MetadataDouble> node of the file.
void ParseNode_MetadataDouble ( ) ;
/// \fn void ParseNode_MetadataFloat()
/// Parse <MetadataFloat> node of the file.
void ParseNode_MetadataFloat ( ) ;
/// \fn void ParseNode_MetadataInteger()
/// Parse <MetadataInteger> node of the file.
void ParseNode_MetadataInteger ( ) ;
/// \fn void ParseNode_MetadataSet()
/// Parse <MetadataSet> node of the file.
void ParseNode_MetadataSet ( ) ;
/// \fn void ParseNode_MetadataString()
/// Parse <MetadataString> node of the file.
void ParseNode_MetadataString ( ) ;
/// \fn void ParseNode_Geometry2D_Arc2D()
/// Parse <Arc2D> node of the file.
void ParseNode_Geometry2D_Arc2D ( ) ;
/// \fn void ParseNode_Geometry2D_ArcClose2D()
/// Parse <ArcClose2D> node of the file.
void ParseNode_Geometry2D_ArcClose2D ( ) ;
/// \fn void ParseNode_Geometry2D_Circle2D()
/// Parse <Circle2D> node of the file.
void ParseNode_Geometry2D_Circle2D ( ) ;
/// \fn void ParseNode_Geometry2D_Disk2D()
/// Parse <Disk2D> node of the file.
void ParseNode_Geometry2D_Disk2D ( ) ;
/// \fn void ParseNode_Geometry2D_Polyline2D()
/// Parse <Polyline2D> node of the file.
void ParseNode_Geometry2D_Polyline2D ( ) ;
/// \fn void ParseNode_Geometry2D_Polypoint2D()
/// Parse <Polypoint2D> node of the file.
void ParseNode_Geometry2D_Polypoint2D ( ) ;
/// \fn void ParseNode_Geometry2D_Rectangle2D()
/// Parse <Rectangle2D> node of the file.
void ParseNode_Geometry2D_Rectangle2D ( ) ;
/// \fn void ParseNode_Geometry2D_TriangleSet2D()
/// Parse <TriangleSet2D> node of the file.
void ParseNode_Geometry2D_TriangleSet2D ( ) ;
/// \fn void ParseNode_Geometry3D_Box()
/// Parse <Box> node of the file.
void ParseNode_Geometry3D_Box ( ) ;
/// \fn void ParseNode_Geometry3D_Cone()
/// Parse <Cone> node of the file.
void ParseNode_Geometry3D_Cone ( ) ;
/// \fn void ParseNode_Geometry3D_Cylinder()
/// Parse <Cylinder> node of the file.
void ParseNode_Geometry3D_Cylinder ( ) ;
/// \fn void ParseNode_Geometry3D_ElevationGrid()
/// Parse <ElevationGrid> node of the file.
void ParseNode_Geometry3D_ElevationGrid ( ) ;
/// \fn void ParseNode_Geometry3D_Extrusion()
/// Parse <Extrusion> node of the file.
void ParseNode_Geometry3D_Extrusion ( ) ;
/// \fn void ParseNode_Geometry3D_IndexedFaceSet()
/// Parse <IndexedFaceSet> node of the file.
void ParseNode_Geometry3D_IndexedFaceSet ( ) ;
/// \fn void ParseNode_Geometry3D_Sphere()
/// Parse <Sphere> node of the file.
void ParseNode_Geometry3D_Sphere ( ) ;
/// \fn void ParseNode_Grouping_Group()
/// Parse <Group> node of the file. And create new node in scene graph.
void ParseNode_Grouping_Group ( ) ;
/// \fn void ParseNode_Grouping_GroupEnd()
/// Doing actions at an exit from <Group>. Walk up in scene graph.
void ParseNode_Grouping_GroupEnd ( ) ;
/// \fn void ParseNode_Grouping_StaticGroup()
/// Parse <StaticGroup> node of the file. And create new node in scene graph.
void ParseNode_Grouping_StaticGroup ( ) ;
/// \fn void ParseNode_Grouping_StaticGroupEnd()
/// Doing actions at an exit from <StaticGroup>. Walk up in scene graph.
void ParseNode_Grouping_StaticGroupEnd ( ) ;
/// \fn void ParseNode_Grouping_Switch()
/// Parse <Switch> node of the file. And create new node in scene graph.
void ParseNode_Grouping_Switch ( ) ;
/// \fn void ParseNode_Grouping_SwitchEnd()
/// Doing actions at an exit from <Switch>. Walk up in scene graph.
void ParseNode_Grouping_SwitchEnd ( ) ;
/// \fn void ParseNode_Grouping_Transform()
/// Parse <Transform> node of the file. And create new node in scene graph.
void ParseNode_Grouping_Transform ( ) ;
/// \fn void ParseNode_Grouping_TransformEnd()
/// Doing actions at an exit from <Transform>. Walk up in scene graph.
void ParseNode_Grouping_TransformEnd ( ) ;
/// \fn void ParseNode_Rendering_Color()
/// Parse <Color> node of the file.
void ParseNode_Rendering_Color ( ) ;
/// \fn void ParseNode_Rendering_ColorRGBA()
/// Parse <ColorRGBA> node of the file.
void ParseNode_Rendering_ColorRGBA ( ) ;
/// \fn void ParseNode_Rendering_Coordinate()
/// Parse <Coordinate> node of the file.
void ParseNode_Rendering_Coordinate ( ) ;
/// \fn void ParseNode_Rendering_Normal()
/// Parse <Normal> node of the file.
void ParseNode_Rendering_Normal ( ) ;
/// \fn void ParseNode_Rendering_IndexedLineSet()
/// Parse <IndexedLineSet> node of the file.
void ParseNode_Rendering_IndexedLineSet ( ) ;
/// \fn void ParseNode_Rendering_IndexedTriangleFanSet()
/// Parse <IndexedTriangleFanSet> node of the file.
void ParseNode_Rendering_IndexedTriangleFanSet ( ) ;
/// \fn void ParseNode_Rendering_IndexedTriangleSet()
/// Parse <IndexedTriangleSet> node of the file.
void ParseNode_Rendering_IndexedTriangleSet ( ) ;
/// \fn void ParseNode_Rendering_IndexedTriangleStripSet()
/// Parse <IndexedTriangleStripSet> node of the file.
void ParseNode_Rendering_IndexedTriangleStripSet ( ) ;
/// \fn void ParseNode_Rendering_LineSet()
/// Parse <LineSet> node of the file.
void ParseNode_Rendering_LineSet ( ) ;
/// \fn void ParseNode_Rendering_PointSet()
/// Parse <PointSet> node of the file.
void ParseNode_Rendering_PointSet ( ) ;
/// \fn void ParseNode_Rendering_TriangleFanSet()
/// Parse <TriangleFanSet> node of the file.
void ParseNode_Rendering_TriangleFanSet ( ) ;
/// \fn void ParseNode_Rendering_TriangleSet()
/// Parse <TriangleSet> node of the file.
void ParseNode_Rendering_TriangleSet ( ) ;
/// \fn void ParseNode_Rendering_TriangleStripSet()
/// Parse <TriangleStripSet> node of the file.
void ParseNode_Rendering_TriangleStripSet ( ) ;
/// \fn void ParseNode_Texturing_ImageTexture()
/// Parse <ImageTexture> node of the file.
void ParseNode_Texturing_ImageTexture ( ) ;
/// \fn void ParseNode_Texturing_TextureCoordinate()
/// Parse <TextureCoordinate> node of the file.
void ParseNode_Texturing_TextureCoordinate ( ) ;
/// \fn void ParseNode_Texturing_TextureTransform()
/// Parse <TextureTransform> node of the file.
void ParseNode_Texturing_TextureTransform ( ) ;
/// \fn void ParseNode_Shape_Shape()
/// Parse <Shape> node of the file.
void ParseNode_Shape_Shape ( ) ;
/// \fn void ParseNode_Shape_Appearance()
/// Parse <Appearance> node of the file.
void ParseNode_Shape_Appearance ( ) ;
/// \fn void ParseNode_Shape_Material()
/// Parse <Material> node of the file.
void ParseNode_Shape_Material ( ) ;
/// \fn void ParseNode_Networking_Inline()
/// Parse <Inline> node of the file.
void ParseNode_Networking_Inline ( ) ;
/// \fn void ParseNode_Lighting_DirectionalLight()
/// Parse <DirectionalLight> node of the file.
void ParseNode_Lighting_DirectionalLight ( ) ;
/// \fn void ParseNode_Lighting_PointLight()
/// Parse <PointLight> node of the file.
void ParseNode_Lighting_PointLight ( ) ;
/// \fn void ParseNode_Lighting_SpotLight()
/// Parse <SpotLight> node of the file.
void ParseNode_Lighting_SpotLight ( ) ;
public :
/// \fn X3DImporter()
/// Default constructor.
X3DImporter ( )
2016-10-02 00:08:34 +00:00
: NodeElement_Cur ( nullptr ) , mReader ( nullptr )
2016-09-29 15:50:24 +00:00
{ }
/// \fn ~X3DImporter()
/// Default destructor.
~ X3DImporter ( ) ;
/***********************************************/
/******** Functions: parse set, public *********/
/***********************************************/
/// \fn void ParseFile(const std::string& pFile, IOSystem* pIOHandler)
/// Parse X3D file and fill scene graph. The function has no return value. Result can be found by analyzing the generated graph.
/// Also exception can be throwed if trouble will found.
/// \param [in] pFile - name of file to be parsed.
/// \param [in] pIOHandler - pointer to IO helper object.
void ParseFile ( const std : : string & pFile , IOSystem * pIOHandler ) ;
/***********************************************/
/********* Functions: BaseImporter set *********/
/***********************************************/
bool CanRead ( const std : : string & pFile , IOSystem * pIOHandler , bool pCheckSig ) const ;
void GetExtensionList ( std : : set < std : : string > & pExtensionList ) ;
void InternReadFile ( const std : : string & pFile , aiScene * pScene , IOSystem * pIOHandler ) ;
const aiImporterDesc * GetInfo ( ) const ;
} ; // class X3DImporter
} // namespace Assimp
# endif // INCLUDED_AI_X3D_IMPORTER_H