v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Some small format changes for assimp-style :-).

pull/1017/head
Kim Kulling 2016-10-04 11:45:08 +02:00
parent 9dc4fb2aa3
commit 7b9162136f
14 changed files with 1029 additions and 543 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

511
code/X3DImporter.cpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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.cpp /// \file X3DImporter.cpp
/// \brief X3D-format files importer for Assimp: main algorithm implementation. /// \brief X3D-format files importer for Assimp: main algorithm implementation.
/// \date 2015-2016 /// \date 2015-2016
@ -100,8 +139,8 @@ fne_fn_end:
bool X3DImporter::FindNodeElement(const std::string& pID, const CX3DImporter_NodeElement::EType pType, CX3DImporter_NodeElement** pElement) bool X3DImporter::FindNodeElement(const std::string& pID, const CX3DImporter_NodeElement::EType pType, CX3DImporter_NodeElement** pElement)
{ {
CX3DImporter_NodeElement* tnd = NodeElement_Cur;// temporary pointer to node. CX3DImporter_NodeElement* tnd = NodeElement_Cur;// temporary pointer to node.
bool static_search = false;// flag: true if searching in static node. bool static_search = false;// flag: true if searching in static node.
// At first check if we have deal with static node. Go up thru parent nodes and check flag. // At first check if we have deal with static node. Go up thru parent nodes and check flag.
while(tnd != nullptr) while(tnd != nullptr)
@ -187,86 +226,86 @@ void X3DImporter::XML_CheckNode_MustBeEmpty()
void X3DImporter::XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName) void X3DImporter::XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName)
{ {
const size_t Uns_Skip_Len = 189; const size_t Uns_Skip_Len = 189;
const char* Uns_Skip[Uns_Skip_Len] = { const char* Uns_Skip[ Uns_Skip_Len ] = {
// CAD geometry component // CAD geometry component
"CADAssembly", "CADFace", "CADLayer", "CADPart", "IndexedQuadSet", "QuadSet", "CADAssembly", "CADFace", "CADLayer", "CADPart", "IndexedQuadSet", "QuadSet",
// Core // Core
"ROUTE", "ExternProtoDeclare", "ProtoDeclare", "ProtoInstance", "ProtoInterface", "WorldInfo", "ROUTE", "ExternProtoDeclare", "ProtoDeclare", "ProtoInstance", "ProtoInterface", "WorldInfo",
// Distributed interactive simulation (DIS) component // Distributed interactive simulation (DIS) component
"DISEntityManager", "DISEntityTypeMapping", "EspduTransform", "ReceiverPdu", "SignalPdu", "TransmitterPdu", "DISEntityManager", "DISEntityTypeMapping", "EspduTransform", "ReceiverPdu", "SignalPdu", "TransmitterPdu",
// Cube map environmental texturing component // Cube map environmental texturing component
"ComposedCubeMapTexture", "GeneratedCubeMapTexture", "ImageCubeMapTexture", "ComposedCubeMapTexture", "GeneratedCubeMapTexture", "ImageCubeMapTexture",
// Environmental effects component // Environmental effects component
"Background", "Fog", "FogCoordinate", "LocalFog", "TextureBackground", "Background", "Fog", "FogCoordinate", "LocalFog", "TextureBackground",
// Environmental sensor component // Environmental sensor component
"ProximitySensor", "TransformSensor", "VisibilitySensor", "ProximitySensor", "TransformSensor", "VisibilitySensor",
// Followers component // Followers component
"ColorChaser", "ColorDamper", "CoordinateChaser", "CoordinateDamper", "OrientationChaser", "OrientationDamper", "PositionChaser", "PositionChaser2D", "ColorChaser", "ColorDamper", "CoordinateChaser", "CoordinateDamper", "OrientationChaser", "OrientationDamper", "PositionChaser", "PositionChaser2D",
"PositionDamper", "PositionDamper2D", "ScalarChaser", "ScalarDamper", "TexCoordChaser2D", "TexCoordDamper2D", "PositionDamper", "PositionDamper2D", "ScalarChaser", "ScalarDamper", "TexCoordChaser2D", "TexCoordDamper2D",
// Geospatial component // Geospatial component
"GeoCoordinate", "GeoElevationGrid", "GeoLocation", "GeoLOD", "GeoMetadata", "GeoOrigin", "GeoPositionInterpolator", "GeoProximitySensor", "GeoCoordinate", "GeoElevationGrid", "GeoLocation", "GeoLOD", "GeoMetadata", "GeoOrigin", "GeoPositionInterpolator", "GeoProximitySensor",
"GeoTouchSensor", "GeoTransform", "GeoViewpoint", "GeoTouchSensor", "GeoTransform", "GeoViewpoint",
// Humanoid Animation (H-Anim) component // Humanoid Animation (H-Anim) component
"HAnimDisplacer", "HAnimHumanoid", "HAnimJoint", "HAnimSegment", "HAnimSite", "HAnimDisplacer", "HAnimHumanoid", "HAnimJoint", "HAnimSegment", "HAnimSite",
// Interpolation component // Interpolation component
"ColorInterpolator", "CoordinateInterpolator", "CoordinateInterpolator2D", "EaseInEaseOut", "NormalInterpolator", "OrientationInterpolator", "ColorInterpolator", "CoordinateInterpolator", "CoordinateInterpolator2D", "EaseInEaseOut", "NormalInterpolator", "OrientationInterpolator",
"PositionInterpolator", "PositionInterpolator2D", "ScalarInterpolator", "SplinePositionInterpolator", "SplinePositionInterpolator2D", "PositionInterpolator", "PositionInterpolator2D", "ScalarInterpolator", "SplinePositionInterpolator", "SplinePositionInterpolator2D",
"SplineScalarInterpolator", "SquadOrientationInterpolator", "SplineScalarInterpolator", "SquadOrientationInterpolator",
// Key device sensor component // Key device sensor component
"KeySensor", "StringSensor" "KeySensor", "StringSensor"
// Layering component // Layering component
"Layer", "LayerSet", "Viewport", "Layer", "LayerSet", "Viewport",
// Layout component // Layout component
"Layout", "LayoutGroup", "LayoutLayer", "ScreenFontStyle", "ScreenGroup", "Layout", "LayoutGroup", "LayoutLayer", "ScreenFontStyle", "ScreenGroup",
// Navigation component // Navigation component
"Billboard", "Collision", "LOD", "NavigationInfo", "OrthoViewpoint", "Viewpoint", "ViewpointGroup", "Billboard", "Collision", "LOD", "NavigationInfo", "OrthoViewpoint", "Viewpoint", "ViewpointGroup",
// Networking component // Networking component
"Anchor", "LoadSensor", "Anchor", "LoadSensor",
// NURBS component // NURBS component
"Contour2D", "ContourPolyline2D", "CoordinateDouble", "NurbsCurve", "NurbsCurve2D", "NurbsOrientationInterpolator", "NurbsPatchSurface", "Contour2D", "ContourPolyline2D", "CoordinateDouble", "NurbsCurve", "NurbsCurve2D", "NurbsOrientationInterpolator", "NurbsPatchSurface",
"NurbsPositionInterpolator", "NurbsSet", "NurbsSurfaceInterpolator", "NurbsSweptSurface", "NurbsSwungSurface", "NurbsTextureCoordinate", "NurbsPositionInterpolator", "NurbsSet", "NurbsSurfaceInterpolator", "NurbsSweptSurface", "NurbsSwungSurface", "NurbsTextureCoordinate",
"NurbsTrimmedSurface", "NurbsTrimmedSurface",
// Particle systems component // Particle systems component
"BoundedPhysicsModel", "ConeEmitter", "ExplosionEmitter", "ForcePhysicsModel", "ParticleSystem", "PointEmitter", "PolylineEmitter", "SurfaceEmitter", "BoundedPhysicsModel", "ConeEmitter", "ExplosionEmitter", "ForcePhysicsModel", "ParticleSystem", "PointEmitter", "PolylineEmitter", "SurfaceEmitter",
"VolumeEmitter", "WindPhysicsModel", "VolumeEmitter", "WindPhysicsModel",
// Picking component // Picking component
"LinePickSensor", "PickableGroup", "PointPickSensor", "PrimitivePickSensor", "VolumePickSensor", "LinePickSensor", "PickableGroup", "PointPickSensor", "PrimitivePickSensor", "VolumePickSensor",
// Pointing device sensor component // Pointing device sensor component
"CylinderSensor", "PlaneSensor", "SphereSensor", "TouchSensor", "CylinderSensor", "PlaneSensor", "SphereSensor", "TouchSensor",
// Rendering component // Rendering component
"ClipPlane", "ClipPlane",
// Rigid body physics // Rigid body physics
"BallJoint", "CollidableOffset", "CollidableShape", "CollisionCollection", "CollisionSensor", "CollisionSpace", "Contact", "DoubleAxisHingeJoint", "BallJoint", "CollidableOffset", "CollidableShape", "CollisionCollection", "CollisionSensor", "CollisionSpace", "Contact", "DoubleAxisHingeJoint",
"MotorJoint", "RigidBody", "RigidBodyCollection", "SingleAxisHingeJoint", "SliderJoint", "UniversalJoint", "MotorJoint", "RigidBody", "RigidBodyCollection", "SingleAxisHingeJoint", "SliderJoint", "UniversalJoint",
// Scripting component // Scripting component
"Script", "Script",
// Programmable shaders component // Programmable shaders component
"ComposedShader", "FloatVertexAttribute", "Matrix3VertexAttribute", "Matrix4VertexAttribute", "PackagedShader", "ProgramShader", "ShaderPart", "ComposedShader", "FloatVertexAttribute", "Matrix3VertexAttribute", "Matrix4VertexAttribute", "PackagedShader", "ProgramShader", "ShaderPart",
"ShaderProgram", "ShaderProgram",
// Shape component // Shape component
"FillProperties", "LineProperties", "TwoSidedMaterial", "FillProperties", "LineProperties", "TwoSidedMaterial",
// Sound component // Sound component
"AudioClip", "Sound", "AudioClip", "Sound",
// Text component // Text component
"FontStyle", "Text", "FontStyle", "Text",
// Texturing3D Component // Texturing3D Component
"ComposedTexture3D", "ImageTexture3D", "PixelTexture3D", "TextureCoordinate3D", "TextureCoordinate4D", "TextureTransformMatrix3D", "TextureTransform3D", "ComposedTexture3D", "ImageTexture3D", "PixelTexture3D", "TextureCoordinate3D", "TextureCoordinate4D", "TextureTransformMatrix3D", "TextureTransform3D",
// Texturing component // Texturing component
"MovieTexture", "MultiTexture", "MultiTextureCoordinate", "MultiTextureTransform", "PixelTexture", "TextureCoordinateGenerator", "TextureProperties", "MovieTexture", "MultiTexture", "MultiTextureCoordinate", "MultiTextureTransform", "PixelTexture", "TextureCoordinateGenerator", "TextureProperties",
// Time component // Time component
"TimeSensor", "TimeSensor",
// Event Utilities component // Event Utilities component
"BooleanFilter", "BooleanSequencer", "BooleanToggle", "BooleanTrigger", "IntegerSequencer", "IntegerTrigger", "TimeTrigger", "BooleanFilter", "BooleanSequencer", "BooleanToggle", "BooleanTrigger", "IntegerSequencer", "IntegerTrigger", "TimeTrigger",
// Volume rendering component // Volume rendering component
"BlendedVolumeStyle", "BoundaryEnhancementVolumeStyle", "CartoonVolumeStyle", "ComposedVolumeStyle", "EdgeEnhancementVolumeStyle", "IsoSurfaceVolumeData", "BlendedVolumeStyle", "BoundaryEnhancementVolumeStyle", "CartoonVolumeStyle", "ComposedVolumeStyle", "EdgeEnhancementVolumeStyle", "IsoSurfaceVolumeData",
"OpacityMapVolumeStyle", "ProjectionVolumeStyle", "SegmentedVolumeData", "ShadedVolumeStyle", "SilhouetteEnhancementVolumeStyle", "ToneMappedVolumeStyle", "OpacityMapVolumeStyle", "ProjectionVolumeStyle", "SegmentedVolumeData", "ShadedVolumeStyle", "SilhouetteEnhancementVolumeStyle", "ToneMappedVolumeStyle",
"VolumeData" "VolumeData"
}; };
std::string nn(mReader->getNodeName()); const std::string nn( mReader->getNodeName() );
bool found = false; bool found = false;
bool close_found = false; bool close_found = false;
for(size_t i = 0; i < Uns_Skip_Len; i++) for(size_t i = 0; i < Uns_Skip_Len; i++)
{ {
@ -326,8 +365,8 @@ std::string val(mReader->getAttributeValue(pAttrIdx));
float X3DImporter::XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx) float X3DImporter::XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx)
{ {
std::string val; std::string val;
float tvalf; float tvalf;
ParseHelper_FixTruncatedFloatString(mReader->getAttributeValue(pAttrIdx), val); ParseHelper_FixTruncatedFloatString(mReader->getAttributeValue(pAttrIdx), val);
fast_atoreal_move(val.c_str(), tvalf, false); fast_atoreal_move(val.c_str(), tvalf, false);
@ -342,8 +381,8 @@ int32_t X3DImporter::XML_ReadNode_GetAttrVal_AsI32(const int pAttrIdx)
void X3DImporter::XML_ReadNode_GetAttrVal_AsCol3f(const int pAttrIdx, aiColor3D& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsCol3f(const int pAttrIdx, aiColor3D& pValue)
{ {
std::list<float> tlist; std::list<float> tlist;
std::list<float>::iterator it; std::list<float>::iterator it;
XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist); XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist);
if(tlist.size() != 3) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx)); if(tlist.size() != 3) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx));
@ -356,8 +395,8 @@ std::list<float>::iterator it;
void X3DImporter::XML_ReadNode_GetAttrVal_AsVec2f(const int pAttrIdx, aiVector2D& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsVec2f(const int pAttrIdx, aiVector2D& pValue)
{ {
std::list<float> tlist; std::list<float> tlist;
std::list<float>::iterator it; std::list<float>::iterator it;
XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist); XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist);
if(tlist.size() != 2) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx)); if(tlist.size() != 2) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx));
@ -369,8 +408,8 @@ std::list<float>::iterator it;
void X3DImporter::XML_ReadNode_GetAttrVal_AsVec3f(const int pAttrIdx, aiVector3D& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsVec3f(const int pAttrIdx, aiVector3D& pValue)
{ {
std::list<float> tlist; std::list<float> tlist;
std::list<float>::iterator it; std::list<float>::iterator it;
XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist); XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist);
if(tlist.size() != 3) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx)); if(tlist.size() != 3) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx));
@ -383,15 +422,14 @@ std::list<float>::iterator it;
void X3DImporter::XML_ReadNode_GetAttrVal_AsListB(const int pAttrIdx, std::list<bool>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsListB(const int pAttrIdx, std::list<bool>& pValue)
{ {
char* tok_str;
size_t tok_str_len;
// make copy of attribute value - string with list of bool values. Also all bool values is strings. // make copy of attribute value - string with list of bool values. Also all bool values is strings.
tok_str_len = strlen(mReader->getAttributeValue(pAttrIdx)); size_t tok_str_len = strlen(mReader->getAttributeValue(pAttrIdx));
if(!tok_str_len) Throw_IncorrectAttrValue(mReader->getAttributeName(pAttrIdx)); if ( 0 == tok_str_len ) {
Throw_IncorrectAttrValue( mReader->getAttributeName( pAttrIdx ) );
}
tok_str_len++;// take in account terminating '\0'. tok_str_len++;// take in account terminating '\0'.
tok_str = new char[tok_str_len]; char *tok_str = new char[tok_str_len];
strcpy(tok_str, mReader->getAttributeValue(pAttrIdx)); strcpy(tok_str, mReader->getAttributeValue(pAttrIdx));
// change all spacebars to symbol '\0'. That is needed for parsing. // change all spacebars to symbol '\0'. That is needed for parsing.
@ -425,7 +463,7 @@ size_t tok_str_len;
void X3DImporter::XML_ReadNode_GetAttrVal_AsArrB(const int pAttrIdx, std::vector<bool>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsArrB(const int pAttrIdx, std::vector<bool>& pValue)
{ {
std::list<bool> tlist; std::list<bool> tlist;
XML_ReadNode_GetAttrVal_AsListB(pAttrIdx, tlist);// read as list XML_ReadNode_GetAttrVal_AsListB(pAttrIdx, tlist);// read as list
// and copy to array // and copy to array
@ -438,8 +476,8 @@ std::list<bool> tlist;
void X3DImporter::XML_ReadNode_GetAttrVal_AsListI32(const int pAttrIdx, std::list<int32_t>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsListI32(const int pAttrIdx, std::list<int32_t>& pValue)
{ {
const char* tstr = mReader->getAttributeValue(pAttrIdx); const char* tstr = mReader->getAttributeValue(pAttrIdx);
const char* tstr_end = tstr + strlen(tstr); const char* tstr_end = tstr + strlen(tstr);
do do
{ {
@ -459,7 +497,7 @@ const char* tstr_end = tstr + strlen(tstr);
void X3DImporter::XML_ReadNode_GetAttrVal_AsArrI32(const int pAttrIdx, std::vector<int32_t>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsArrI32(const int pAttrIdx, std::vector<int32_t>& pValue)
{ {
std::list<int32_t> tlist; std::list<int32_t> tlist;
XML_ReadNode_GetAttrVal_AsListI32(pAttrIdx, tlist);// read as list XML_ReadNode_GetAttrVal_AsListI32(pAttrIdx, tlist);// read as list
// and copy to array // and copy to array
@ -472,7 +510,7 @@ std::list<int32_t> tlist;
void X3DImporter::XML_ReadNode_GetAttrVal_AsListF(const int pAttrIdx, std::list<float>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsListF(const int pAttrIdx, std::list<float>& pValue)
{ {
std::string str_fixed; std::string str_fixed;
// at first check string values like '.xxx'. // at first check string values like '.xxx'.
ParseHelper_FixTruncatedFloatString(mReader->getAttributeValue(pAttrIdx), str_fixed); ParseHelper_FixTruncatedFloatString(mReader->getAttributeValue(pAttrIdx), str_fixed);
@ -498,7 +536,7 @@ std::string str_fixed;
void X3DImporter::XML_ReadNode_GetAttrVal_AsArrF(const int pAttrIdx, std::vector<float>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsArrF(const int pAttrIdx, std::vector<float>& pValue)
{ {
std::list<float> tlist; std::list<float> tlist;
XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist);// read as list XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist);// read as list
// and copy to array // and copy to array
@ -511,7 +549,7 @@ std::list<float> tlist;
void X3DImporter::XML_ReadNode_GetAttrVal_AsListD(const int pAttrIdx, std::list<double>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsListD(const int pAttrIdx, std::list<double>& pValue)
{ {
std::string str_fixed; std::string str_fixed;
// at first check string values like '.xxx'. // at first check string values like '.xxx'.
ParseHelper_FixTruncatedFloatString(mReader->getAttributeValue(pAttrIdx), str_fixed); ParseHelper_FixTruncatedFloatString(mReader->getAttributeValue(pAttrIdx), str_fixed);
@ -537,7 +575,7 @@ std::string str_fixed;
void X3DImporter::XML_ReadNode_GetAttrVal_AsArrD(const int pAttrIdx, std::vector<double>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsArrD(const int pAttrIdx, std::vector<double>& pValue)
{ {
std::list<double> tlist; std::list<double> tlist;
XML_ReadNode_GetAttrVal_AsListD(pAttrIdx, tlist);// read as list XML_ReadNode_GetAttrVal_AsListD(pAttrIdx, tlist);// read as list
// and copy to array // and copy to array
@ -550,7 +588,7 @@ std::list<double> tlist;
void X3DImporter::XML_ReadNode_GetAttrVal_AsListCol3f(const int pAttrIdx, std::list<aiColor3D>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsListCol3f(const int pAttrIdx, std::list<aiColor3D>& pValue)
{ {
std::list<float> tlist; std::list<float> tlist;
XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist);// read as list XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist);// read as list
if(tlist.size() % 3) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx)); if(tlist.size() % 3) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx));
@ -569,7 +607,7 @@ std::list<float> tlist;
void X3DImporter::XML_ReadNode_GetAttrVal_AsArrCol3f(const int pAttrIdx, std::vector<aiColor3D>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsArrCol3f(const int pAttrIdx, std::vector<aiColor3D>& pValue)
{ {
std::list<aiColor3D> tlist; std::list<aiColor3D> tlist;
XML_ReadNode_GetAttrVal_AsListCol3f(pAttrIdx, tlist);// read as list XML_ReadNode_GetAttrVal_AsListCol3f(pAttrIdx, tlist);// read as list
// and copy to array // and copy to array
@ -582,7 +620,7 @@ std::list<aiColor3D> tlist;
void X3DImporter::XML_ReadNode_GetAttrVal_AsListCol4f(const int pAttrIdx, std::list<aiColor4D>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsListCol4f(const int pAttrIdx, std::list<aiColor4D>& pValue)
{ {
std::list<float> tlist; std::list<float> tlist;
XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist);// read as list XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist);// read as list
if(tlist.size() % 4) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx)); if(tlist.size() % 4) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx));
@ -602,23 +640,29 @@ std::list<float> tlist;
void X3DImporter::XML_ReadNode_GetAttrVal_AsArrCol4f(const int pAttrIdx, std::vector<aiColor4D>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsArrCol4f(const int pAttrIdx, std::vector<aiColor4D>& pValue)
{ {
std::list<aiColor4D> tlist; std::list<aiColor4D> tlist;
XML_ReadNode_GetAttrVal_AsListCol4f(pAttrIdx, tlist);// read as list XML_ReadNode_GetAttrVal_AsListCol4f(pAttrIdx, tlist);// read as list
// and copy to array // and copy to array
if(tlist.size() > 0) if(tlist.size() > 0)
{ {
pValue.reserve(tlist.size()); pValue.reserve(tlist.size());
for(std::list<aiColor4D>::iterator it = tlist.begin(); it != tlist.end(); it++) pValue.push_back(*it); for ( std::list<aiColor4D>::iterator it = tlist.begin(); it != tlist.end(); it++ )
{
pValue.push_back( *it );
}
} }
} }
void X3DImporter::XML_ReadNode_GetAttrVal_AsListVec2f(const int pAttrIdx, std::list<aiVector2D>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsListVec2f(const int pAttrIdx, std::list<aiVector2D>& pValue)
{ {
std::list<float> tlist; std::list<float> tlist;
XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist);// read as list XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist);// read as list
if(tlist.size() % 2) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx)); if ( tlist.size() % 2 )
{
Throw_ConvertFail_Str2ArrF( mReader->getAttributeValue( pAttrIdx ) );
}
// copy data to array // copy data to array
for(std::list<float>::iterator it = tlist.begin(); it != tlist.end();) for(std::list<float>::iterator it = tlist.begin(); it != tlist.end();)
@ -633,23 +677,29 @@ std::list<float> tlist;
void X3DImporter::XML_ReadNode_GetAttrVal_AsArrVec2f(const int pAttrIdx, std::vector<aiVector2D>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsArrVec2f(const int pAttrIdx, std::vector<aiVector2D>& pValue)
{ {
std::list<aiVector2D> tlist; std::list<aiVector2D> tlist;
XML_ReadNode_GetAttrVal_AsListVec2f(pAttrIdx, tlist);// read as list XML_ReadNode_GetAttrVal_AsListVec2f(pAttrIdx, tlist);// read as list
// and copy to array // and copy to array
if(tlist.size() > 0) if(tlist.size() > 0)
{ {
pValue.reserve(tlist.size()); pValue.reserve(tlist.size());
for(std::list<aiVector2D>::iterator it = tlist.begin(); it != tlist.end(); it++) pValue.push_back(*it); for ( std::list<aiVector2D>::iterator it = tlist.begin(); it != tlist.end(); it++ )
{
pValue.push_back( *it );
}
} }
} }
void X3DImporter::XML_ReadNode_GetAttrVal_AsListVec3f(const int pAttrIdx, std::list<aiVector3D>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsListVec3f(const int pAttrIdx, std::list<aiVector3D>& pValue)
{ {
std::list<float> tlist; std::list<float> tlist;
XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist);// read as list XML_ReadNode_GetAttrVal_AsListF(pAttrIdx, tlist);// read as list
if(tlist.size() % 3) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx)); if ( tlist.size() % 3 )
{
Throw_ConvertFail_Str2ArrF( mReader->getAttributeValue( pAttrIdx ) );
}
// copy data to array // copy data to array
for(std::list<float>::iterator it = tlist.begin(); it != tlist.end();) for(std::list<float>::iterator it = tlist.begin(); it != tlist.end();)
@ -665,30 +715,32 @@ std::list<float> tlist;
void X3DImporter::XML_ReadNode_GetAttrVal_AsArrVec3f(const int pAttrIdx, std::vector<aiVector3D>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsArrVec3f(const int pAttrIdx, std::vector<aiVector3D>& pValue)
{ {
std::list<aiVector3D> tlist; std::list<aiVector3D> tlist;
XML_ReadNode_GetAttrVal_AsListVec3f(pAttrIdx, tlist);// read as list XML_ReadNode_GetAttrVal_AsListVec3f(pAttrIdx, tlist);// read as list
// and copy to array // and copy to array
if(tlist.size() > 0) if(tlist.size() > 0)
{ {
pValue.reserve(tlist.size()); pValue.reserve(tlist.size());
for(std::list<aiVector3D>::iterator it = tlist.begin(); it != tlist.end(); it++) pValue.push_back(*it); for ( std::list<aiVector3D>::iterator it = tlist.begin(); it != tlist.end(); it++ )
{
pValue.push_back( *it );
}
} }
} }
void X3DImporter::XML_ReadNode_GetAttrVal_AsListS(const int pAttrIdx, std::list<std::string>& pValue) void X3DImporter::XML_ReadNode_GetAttrVal_AsListS(const int pAttrIdx, std::list<std::string>& pValue)
{ {
char* tok_str;
char* tok_str_end;
size_t tok_str_len;
// make copy of attribute value - strings list. // make copy of attribute value - strings list.
tok_str_len = strlen(mReader->getAttributeValue(pAttrIdx)); const size_t tok_str_len = strlen(mReader->getAttributeValue(pAttrIdx));
if(!tok_str_len) Throw_IncorrectAttrValue(mReader->getAttributeName(pAttrIdx)); if ( 0 == tok_str_len )
{
Throw_IncorrectAttrValue( mReader->getAttributeName( pAttrIdx ) );
}
// get pointer to begin of value. // get pointer to begin of value.
tok_str = const_cast<char*>(mReader->getAttributeValue(pAttrIdx)); char *tok_str = const_cast<char*>(mReader->getAttributeValue(pAttrIdx));
tok_str_end = tok_str + tok_str_len; char *tok_str_end = tok_str + tok_str_len;
// string list has following format: attr_name='"s1" "s2" "sn"'. // string list has following format: attr_name='"s1" "s2" "sn"'.
do do
{ {
@ -729,25 +781,33 @@ aiVector3D X3DImporter::GeometryHelper_Make_Point2D(const float pAngle, const fl
void X3DImporter::GeometryHelper_Make_Arc2D(const float pStartAngle, const float pEndAngle, const float pRadius, size_t pNumSegments, void X3DImporter::GeometryHelper_Make_Arc2D(const float pStartAngle, const float pEndAngle, const float pRadius, size_t pNumSegments,
std::list<aiVector3D>& pVertices) std::list<aiVector3D>& pVertices)
{ {
float angle_full, angle_step;
// check argument values ranges. // check argument values ranges.
if((pStartAngle < -AI_MATH_TWO_PI_F) || (pStartAngle > AI_MATH_TWO_PI_F)) Throw_ArgOutOfRange("GeometryHelper_Make_Arc2D.pStartAngle"); if ( ( pStartAngle < -AI_MATH_TWO_PI_F ) || ( pStartAngle > AI_MATH_TWO_PI_F ) )
if((pEndAngle < -AI_MATH_TWO_PI_F) || (pEndAngle > AI_MATH_TWO_PI_F)) Throw_ArgOutOfRange("GeometryHelper_Make_Arc2D.pEndAngle"); {
if(pRadius <= 0) Throw_ArgOutOfRange("GeometryHelper_Make_Arc2D.pRadius"); Throw_ArgOutOfRange( "GeometryHelper_Make_Arc2D.pStartAngle" );
}
if ( ( pEndAngle < -AI_MATH_TWO_PI_F ) || ( pEndAngle > AI_MATH_TWO_PI_F ) )
{
Throw_ArgOutOfRange( "GeometryHelper_Make_Arc2D.pEndAngle" );
}
if ( pRadius <= 0 )
{
Throw_ArgOutOfRange( "GeometryHelper_Make_Arc2D.pRadius" );
}
// calculate arc angle and check type of arc // calculate arc angle and check type of arc
angle_full = fabs(pEndAngle - pStartAngle); float angle_full = fabs(pEndAngle - pStartAngle);
if((angle_full > AI_MATH_TWO_PI_F) || (angle_full == 0.0f)) angle_full = AI_MATH_TWO_PI_F; if ( ( angle_full > AI_MATH_TWO_PI_F ) || ( angle_full == 0.0f ) )
{
angle_full = AI_MATH_TWO_PI_F;
}
// calculate angle for one step - angle to next point of line. // calculate angle for one step - angle to next point of line.
angle_step = angle_full / (float)pNumSegments; float angle_step = angle_full / (float)pNumSegments;
// make points // make points
for(size_t pi = 0; pi <= pNumSegments; pi++) for(size_t pi = 0; pi <= pNumSegments; pi++)
{ {
float tangle; float tangle = pStartAngle + pi * angle_step;
tangle = pStartAngle + pi * angle_step;
pVertices.push_back(GeometryHelper_Make_Point2D(tangle, pRadius)); pVertices.push_back(GeometryHelper_Make_Point2D(tangle, pRadius));
}// for(size_t pi = 0; pi <= pNumSegments; pi++) }// for(size_t pi = 0; pi <= pNumSegments; pi++)
@ -757,12 +817,15 @@ float angle_full, angle_step;
void X3DImporter::GeometryHelper_Extend_PointToLine(const std::list<aiVector3D>& pPoint, std::list<aiVector3D>& pLine) void X3DImporter::GeometryHelper_Extend_PointToLine(const std::list<aiVector3D>& pPoint, std::list<aiVector3D>& pLine)
{ {
std::list<aiVector3D>::const_iterator pit = pPoint.begin(); std::list<aiVector3D>::const_iterator pit = pPoint.begin();
std::list<aiVector3D>::const_iterator pit_last = pPoint.end(); std::list<aiVector3D>::const_iterator pit_last = pPoint.end();
pit_last--; pit_last--;
if(pPoint.size() < 2) Throw_ArgOutOfRange("GeometryHelper_Extend_PointToLine.pPoint.size() can not be less than 2."); if ( pPoint.size() < 2 )
{
Throw_ArgOutOfRange( "GeometryHelper_Extend_PointToLine.pPoint.size() can not be less than 2." );
}
// add first point of first line. // add first point of first line.
pLine.push_back(*pit++); pLine.push_back(*pit++);
@ -779,7 +842,7 @@ std::list<aiVector3D>::const_iterator pit_last = pPoint.end();
void X3DImporter::GeometryHelper_Extend_PolylineIdxToLineIdx(const std::list<int32_t>& pPolylineCoordIdx, std::list<int32_t>& pLineCoordIdx) void X3DImporter::GeometryHelper_Extend_PolylineIdxToLineIdx(const std::list<int32_t>& pPolylineCoordIdx, std::list<int32_t>& pLineCoordIdx)
{ {
std::list<int32_t>::const_iterator plit = pPolylineCoordIdx.begin(); std::list<int32_t>::const_iterator plit = pPolylineCoordIdx.begin();
while(plit != pPolylineCoordIdx.end()) while(plit != pPolylineCoordIdx.end())
{ {
@ -831,16 +894,19 @@ void X3DImporter::GeometryHelper_MakeQL_RectParallelepiped(const aiVector3D& pSi
void X3DImporter::GeometryHelper_CoordIdxStr2FacesArr(const std::list<int32_t>& pCoordIdx, std::vector<aiFace>& pFaces, unsigned int& pPrimitiveTypes) const void X3DImporter::GeometryHelper_CoordIdxStr2FacesArr(const std::list<int32_t>& pCoordIdx, std::vector<aiFace>& pFaces, unsigned int& pPrimitiveTypes) const
{ {
std::list<int32_t> f_data(pCoordIdx); std::list<int32_t> f_data(pCoordIdx);
std::vector<unsigned int> inds; std::vector<unsigned int> inds;
unsigned int prim_type = 0; unsigned int prim_type = 0;
if(f_data.back() != (-1)) f_data.push_back(-1); if ( f_data.back() != ( -1 ) )
{
f_data.push_back( -1 );
}
// reserve average size. // reserve average size.
pFaces.reserve(f_data.size() / 3); pFaces.reserve(f_data.size() / 3);
inds.reserve(4); inds.reserve(4);
//PrintVectorSet("build. ci", pCoordIdx); //PrintVectorSet("build. ci", pCoordIdx);
for(std::list<int32_t>::iterator it = f_data.begin(); it != f_data.end(); it++) for(std::list<int32_t>::iterator it = f_data.begin(); it != f_data.end(); it++)
{ {
// when face is got count how many indices in it. // when face is got count how many indices in it.
@ -896,7 +962,7 @@ std::list<aiColor4D> tcol;
void X3DImporter::MeshGeometry_AddColor(aiMesh& pMesh, const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const void X3DImporter::MeshGeometry_AddColor(aiMesh& pMesh, const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const
{ {
std::list<aiColor4D>::const_iterator col_it = pColors.begin(); std::list<aiColor4D>::const_iterator col_it = pColors.begin();
if(pColorPerVertex) if(pColorPerVertex)
{ {
@ -933,10 +999,13 @@ std::list<aiColor4D>::const_iterator col_it = pColors.begin();
void X3DImporter::MeshGeometry_AddColor(aiMesh& pMesh, const std::list<int32_t>& pCoordIdx, const std::list<int32_t>& pColorIdx, void X3DImporter::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 const std::list<aiColor3D>& pColors, const bool pColorPerVertex) const
{ {
std::list<aiColor4D> tcol; std::list<aiColor4D> tcol;
// create RGBA array from RGB. // create RGBA array from RGB.
for(std::list<aiColor3D>::const_iterator it = pColors.begin(); it != pColors.end(); it++) tcol.push_back(aiColor4D((*it).r, (*it).g, (*it).b, 1)); for ( std::list<aiColor3D>::const_iterator it = pColors.begin(); it != pColors.end(); it++ )
{
tcol.push_back( aiColor4D( ( *it ).r, ( *it ).g, ( *it ).b, 1 ) );
}
// call existing function for adding RGBA colors // call existing function for adding RGBA colors
MeshGeometry_AddColor(pMesh, pCoordIdx, pColorIdx, tcol, pColorPerVertex); MeshGeometry_AddColor(pMesh, pCoordIdx, pColorIdx, tcol, pColorPerVertex);
@ -945,15 +1014,21 @@ std::list<aiColor4D> tcol;
void X3DImporter::MeshGeometry_AddColor(aiMesh& pMesh, const std::list<int32_t>& pCoordIdx, const std::list<int32_t>& pColorIdx, void X3DImporter::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 const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const
{ {
std::vector<aiColor4D> col_tgt_arr; std::vector<aiColor4D> col_tgt_arr;
std::list<aiColor4D> col_tgt_list; std::list<aiColor4D> col_tgt_list;
std::vector<aiColor4D> col_arr_copy; std::vector<aiColor4D> col_arr_copy;
if(pCoordIdx.size() == 0) throw DeadlyImportError("MeshGeometry_AddColor2. pCoordIdx can not be empty."); if ( pCoordIdx.size() == 0 )
{
throw DeadlyImportError( "MeshGeometry_AddColor2. pCoordIdx can not be empty." );
}
// copy list to array because we are need indexed access to colors. // copy list to array because we are need indexed access to colors.
col_arr_copy.reserve(pColors.size()); col_arr_copy.reserve(pColors.size());
for(std::list<aiColor4D>::const_iterator it = pColors.begin(); it != pColors.end(); it++) col_arr_copy.push_back(*it); for ( std::list<aiColor4D>::const_iterator it = pColors.begin(); it != pColors.end(); it++ )
{
col_arr_copy.push_back( *it );
}
if(pColorPerVertex) if(pColorPerVertex)
{ {
@ -1036,12 +1111,15 @@ std::vector<aiColor4D> col_arr_copy;
void X3DImporter::MeshGeometry_AddNormal(aiMesh& pMesh, const std::list<int32_t>& pCoordIdx, const std::list<int32_t>& pNormalIdx, void X3DImporter::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 const std::list<aiVector3D>& pNormals, const bool pNormalPerVertex) const
{ {
std::vector<size_t> tind; std::vector<size_t> tind;
std::vector<aiVector3D> norm_arr_copy; std::vector<aiVector3D> norm_arr_copy;
// copy list to array because we are need indexed access to normals. // copy list to array because we are need indexed access to normals.
norm_arr_copy.reserve(pNormals.size()); norm_arr_copy.reserve(pNormals.size());
for(std::list<aiVector3D>::const_iterator it = pNormals.begin(); it != pNormals.end(); it++) norm_arr_copy.push_back(*it); for ( std::list<aiVector3D>::const_iterator it = pNormals.begin(); it != pNormals.end(); it++ )
{
norm_arr_copy.push_back( *it );
}
if(pNormalPerVertex) if(pNormalPerVertex)
{ {
@ -1109,7 +1187,7 @@ std::vector<aiVector3D> norm_arr_copy;
void X3DImporter::MeshGeometry_AddNormal(aiMesh& pMesh, const std::list<aiVector3D>& pNormals, const bool pNormalPerVertex) const void X3DImporter::MeshGeometry_AddNormal(aiMesh& pMesh, const std::list<aiVector3D>& pNormals, const bool pNormalPerVertex) const
{ {
std::list<aiVector3D>::const_iterator norm_it = pNormals.begin(); std::list<aiVector3D>::const_iterator norm_it = pNormals.begin();
if(pNormalPerVertex) if(pNormalPerVertex)
{ {
@ -1138,9 +1216,9 @@ std::list<aiVector3D>::const_iterator norm_it = pNormals.begin();
void X3DImporter::MeshGeometry_AddTexCoord(aiMesh& pMesh, const std::list<int32_t>& pCoordIdx, const std::list<int32_t>& pTexCoordIdx, void X3DImporter::MeshGeometry_AddTexCoord(aiMesh& pMesh, const std::list<int32_t>& pCoordIdx, const std::list<int32_t>& pTexCoordIdx,
const std::list<aiVector2D>& pTexCoords) const const std::list<aiVector2D>& pTexCoords) const
{ {
std::vector<aiVector3D> texcoord_arr_copy; std::vector<aiVector3D> texcoord_arr_copy;
std::vector<aiFace> faces; std::vector<aiFace> faces;
unsigned int prim_type; unsigned int prim_type;
// copy list to array because we are need indexed access to normals. // copy list to array because we are need indexed access to normals.
texcoord_arr_copy.reserve(pTexCoords.size()); texcoord_arr_copy.reserve(pTexCoords.size());
@ -1152,8 +1230,14 @@ unsigned int prim_type;
if(pTexCoordIdx.size() > 0) if(pTexCoordIdx.size() > 0)
{ {
GeometryHelper_CoordIdxStr2FacesArr(pTexCoordIdx, faces, prim_type); GeometryHelper_CoordIdxStr2FacesArr(pTexCoordIdx, faces, prim_type);
if(!faces.size()) throw DeadlyImportError("Failed to add texture coordinates to mesh, faces list is empty."); if ( faces.empty() )
if(faces.size() != pMesh.mNumFaces) throw DeadlyImportError("Texture coordinates faces count must be equal to mesh faces count."); {
throw DeadlyImportError( "Failed to add texture coordinates to mesh, faces list is empty." );
}
if ( faces.size() != pMesh.mNumFaces )
{
throw DeadlyImportError( "Texture coordinates faces count must be equal to mesh faces count." );
}
} }
else else
{ {
@ -1179,30 +1263,42 @@ unsigned int prim_type;
void X3DImporter::MeshGeometry_AddTexCoord(aiMesh& pMesh, const std::list<aiVector2D>& pTexCoords) const void X3DImporter::MeshGeometry_AddTexCoord(aiMesh& pMesh, const std::list<aiVector2D>& pTexCoords) const
{ {
std::vector<aiVector3D> tc_arr_copy; std::vector<aiVector3D> tc_arr_copy;
if(pTexCoords.size() != pMesh.mNumVertices) throw DeadlyImportError("MeshGeometry_AddTexCoord. Texture coordinates and vertices count must be equal."); if ( pTexCoords.size() != pMesh.mNumVertices )
{
throw DeadlyImportError( "MeshGeometry_AddTexCoord. Texture coordinates and vertices count must be equal." );
}
// copy list to array because we are need convert aiVector2D to aiVector3D and also get indexed access as a bonus. // copy list to array because we are need convert aiVector2D to aiVector3D and also get indexed access as a bonus.
tc_arr_copy.reserve(pTexCoords.size()); tc_arr_copy.reserve(pTexCoords.size());
for(std::list<aiVector2D>::const_iterator it = pTexCoords.begin(); it != pTexCoords.end(); it++) tc_arr_copy.push_back(aiVector3D((*it).x, (*it).y, 0)); for ( std::list<aiVector2D>::const_iterator it = pTexCoords.begin(); it != pTexCoords.end(); it++ )
{
tc_arr_copy.push_back( aiVector3D( ( *it ).x, ( *it ).y, 0 ) );
}
// copy texture coordinates to mesh // copy texture coordinates to mesh
pMesh.mTextureCoords[0] = new aiVector3D[pMesh.mNumVertices]; pMesh.mTextureCoords[0] = new aiVector3D[pMesh.mNumVertices];
pMesh.mNumUVComponents[0] = 2; pMesh.mNumUVComponents[0] = 2;
for(size_t i = 0; i < pMesh.mNumVertices; i++) pMesh.mTextureCoords[0][i] = tc_arr_copy[i]; for ( size_t i = 0; i < pMesh.mNumVertices; i++ )
{
pMesh.mTextureCoords[ 0 ][ i ] = tc_arr_copy[ i ];
}
} }
aiMesh* X3DImporter::GeometryHelper_MakeMesh(const std::list<int32_t>& pCoordIdx, const std::list<aiVector3D>& pVertices) const aiMesh* X3DImporter::GeometryHelper_MakeMesh(const std::list<int32_t>& pCoordIdx, const std::list<aiVector3D>& pVertices) const
{ {
aiMesh* tmesh; aiMesh* tmesh( nullptr );
std::vector<aiFace> faces; std::vector<aiFace> faces;
unsigned int prim_type = 0; unsigned int prim_type = 0;
size_t ts; size_t ts;
// create faces array from input string with vertices indices. // create faces array from input string with vertices indices.
GeometryHelper_CoordIdxStr2FacesArr(pCoordIdx, faces, prim_type); GeometryHelper_CoordIdxStr2FacesArr(pCoordIdx, faces, prim_type);
if(!faces.size()) throw DeadlyImportError("Failed to create mesh, faces list is empty."); if ( !faces.size() )
{
throw DeadlyImportError( "Failed to create mesh, faces list is empty." );
}
// //
// Create new mesh and copy geometry data. // Create new mesh and copy geometry data.
@ -1220,7 +1316,10 @@ size_t ts;
ts = pVertices.size(); ts = pVertices.size();
tmesh->mVertices = new aiVector3D[ts]; tmesh->mVertices = new aiVector3D[ts];
tmesh->mNumVertices = ts; tmesh->mNumVertices = ts;
for(size_t i = 0; i < ts; i++) tmesh->mVertices[i] = *vit++; for ( size_t i = 0; i < ts; i++ )
{
tmesh->mVertices[ i ] = *vit++;
}
// set primitives type and return result. // set primitives type and return result.
tmesh->mPrimitiveTypes = prim_type; tmesh->mPrimitiveTypes = prim_type;
@ -1234,10 +1333,13 @@ size_t ts;
void X3DImporter::ParseHelper_Group_Begin(const bool pStatic) void X3DImporter::ParseHelper_Group_Begin(const bool pStatic)
{ {
CX3DImporter_NodeElement_Group* new_group = new CX3DImporter_NodeElement_Group(NodeElement_Cur, pStatic);// create new node with current node as parent. CX3DImporter_NodeElement_Group* new_group = new CX3DImporter_NodeElement_Group(NodeElement_Cur, pStatic);// create new node with current node as parent.
// if we are adding not the root element then add new element to current element child list. // if we are adding not the root element then add new element to current element child list.
if(NodeElement_Cur != nullptr) NodeElement_Cur->Child.push_back(new_group); if ( NodeElement_Cur != nullptr )
{
NodeElement_Cur->Child.push_back( new_group );
}
NodeElement_List.push_back(new_group);// it's a new element - add it to list. NodeElement_List.push_back(new_group);// it's a new element - add it to list.
NodeElement_Cur = new_group;// switch current element to new one. NodeElement_Cur = new_group;// switch current element to new one.
@ -1252,20 +1354,27 @@ void X3DImporter::ParseHelper_Node_Enter(CX3DImporter_NodeElement* pNode)
void X3DImporter::ParseHelper_Node_Exit() void X3DImporter::ParseHelper_Node_Exit()
{ {
// check if we can walk up. // check if we can walk up.
if(NodeElement_Cur != nullptr) NodeElement_Cur = NodeElement_Cur->Parent; if ( NodeElement_Cur != nullptr )
{
NodeElement_Cur = NodeElement_Cur->Parent;
}
} }
void X3DImporter::ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString) void X3DImporter::ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString)
{ {
size_t instr_len;
pOutString.clear(); pOutString.clear();
instr_len = strlen(pInStr); const size_t instr_len = strlen(pInStr);
if(!instr_len) return; if ( 0 == instr_len )
{
return;
}
pOutString.reserve(instr_len * 3 / 2); pOutString.reserve(instr_len * 3 / 2);
// check and correct floats in format ".x". Must be "x.y". // check and correct floats in format ".x". Must be "x.y".
if(pInStr[0] == '.') pOutString.push_back('0'); if ( pInStr[ 0 ] == '.' )
{
pOutString.push_back( '0' );
}
pOutString.push_back(pInStr[0]); pOutString.push_back(pInStr[0]);
for(size_t ci = 1; ci < instr_len; ci++) for(size_t ci = 1; ci < instr_len; ci++)
@ -1284,15 +1393,21 @@ size_t instr_len;
void X3DImporter::ParseFile(const std::string& pFile, IOSystem* pIOHandler) void X3DImporter::ParseFile(const std::string& pFile, IOSystem* pIOHandler)
{ {
irr::io::IrrXMLReader* OldReader = mReader;// store current XMLreader. irr::io::IrrXMLReader* OldReader = mReader;// store current XMLreader.
std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb")); std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
// Check whether we can read from the file // Check whether we can read from the file
if(file.get() == nullptr) throw DeadlyImportError("Failed to open X3D file " + pFile + "."); if ( file.get() == nullptr )
{
throw DeadlyImportError( "Failed to open X3D file " + pFile + "." );
}
// generate a XML reader for it // generate a XML reader for it
std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper(new CIrrXML_IOStreamReader(file.get())); std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper(new CIrrXML_IOStreamReader(file.get()));
mReader = irr::io::createIrrXMLReader(mIOWrapper.get()); mReader = irr::io::createIrrXMLReader(mIOWrapper.get());
if(!mReader) throw DeadlyImportError("Failed to create XML reader for file" + pFile + "."); if ( !mReader )
{
throw DeadlyImportError( "Failed to create XML reader for file" + pFile + "." );
}
// start reading // start reading
ParseNode_Root(); ParseNode_Root();
@ -1303,16 +1418,22 @@ std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
void X3DImporter::ParseNode_Root() void X3DImporter::ParseNode_Root()
{ {
LogInfo("ParseNode_Root b"); LogInfo("ParseNode_Root b");
// search for root tag <X3D> // search for root tag <X3D>
if(!XML_SearchNode("X3D")) throw DeadlyImportError("Root node \"X3D\" not found."); if ( !XML_SearchNode( "X3D" ) )
{
throw DeadlyImportError( "Root node \"X3D\" not found." );
}
ParseHelper_Group_Begin();// create root node element. ParseHelper_Group_Begin();// create root node element.
// parse other contents // parse other contents
LogInfo("ParseNode_Root. read loop"); LogInfo("ParseNode_Root. read loop");
while(mReader->read()) while(mReader->read())
{ {
if(mReader->getNodeType() != irr::io::EXN_ELEMENT) continue; if ( mReader->getNodeType() != irr::io::EXN_ELEMENT )
{
continue;
}
if(XML_CheckNode_NameEqual("head")) if(XML_CheckNode_NameEqual("head"))
ParseNode_Head(); ParseNode_Head();
@ -1321,16 +1442,16 @@ LogInfo("ParseNode_Root. read loop");
else else
XML_CheckNode_SkipUnsupported("Root"); XML_CheckNode_SkipUnsupported("Root");
} }
LogInfo("ParseNode_Root. end loop"); LogInfo("ParseNode_Root. end loop");
// exit from root node element. // exit from root node element.
ParseHelper_Node_Exit(); ParseHelper_Node_Exit();
LogInfo("ParseNode_Root e"); LogInfo("ParseNode_Root e");
} }
void X3DImporter::ParseNode_Head() void X3DImporter::ParseNode_Head()
{ {
bool close_found = false;// flag: true if close tag of node are found. bool close_found = false;// flag: true if close tag of node are found.
while(mReader->read()) while(mReader->read())
{ {
@ -1371,10 +1492,10 @@ bool close_found = false;// flag: true if close tag of node are found.
void X3DImporter::ParseNode_Scene() void X3DImporter::ParseNode_Scene()
{ {
auto GroupCounter_Increase = [](size_t& pCounter, const char* pGroupName) -> void auto GroupCounter_Increase = [](size_t& pCounter, const char* pGroupName) -> void
{ {
pCounter++; pCounter++;
if(pCounter == 0) throw DeadlyImportError("Group counter overflow. Too much groups with type: " + std::string(pGroupName) + "."); if(pCounter == 0) throw DeadlyImportError("Group counter overflow. Too much groups with type: " + std::string(pGroupName) + ".");
}; };
auto GroupCounter_Decrease = [&](size_t& pCounter, const char* pGroupName) -> void auto GroupCounter_Decrease = [&](size_t& pCounter, const char* pGroupName) -> void
@ -1499,7 +1620,7 @@ size_t counter_switch = 0;
bool X3DImporter::CanRead(const std::string& pFile, IOSystem* pIOHandler, bool pCheckSig) const bool X3DImporter::CanRead(const std::string& pFile, IOSystem* pIOHandler, bool pCheckSig) const
{ {
const std::string extension = GetExtension(pFile); const std::string extension = GetExtension(pFile);
if(extension == "x3d") return true; if(extension == "x3d") return true;

289
code/X3DImporter.hpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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.hpp /// \file X3DImporter.hpp
/// \brief X3D-format files importer for Assimp. /// \brief X3D-format files importer for Assimp.
/// \date 2015-2016 /// \date 2015-2016
@ -10,10 +49,10 @@
#include "X3DImporter_Node.hpp" #include "X3DImporter_Node.hpp"
// Header files, Assimp. // Header files, Assimp.
#include "assimp/DefaultLogger.hpp" #include <assimp/DefaultLogger.hpp>
#include "assimp/importerdesc.h" #include <assimp/importerdesc.h>
#include "assimp/ProgressHandler.hpp" #include <assimp/ProgressHandler.hpp>
#include "assimp/types.h" #include <assimp/types.h>
#include "BaseImporter.h" #include "BaseImporter.h"
#include "irrXMLWrapper.h" #include "irrXMLWrapper.h"
@ -151,47 +190,49 @@ namespace Assimp
/// ///
class X3DImporter : public BaseImporter 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: public:
std::list<CX3DImporter_NodeElement*> NodeElement_List;///< All elements of scene graph. std::list<CX3DImporter_NodeElement*> NodeElement_List;///< All elements of scene graph.
/***********************************************/ public:
/****************** Functions ******************/ /***********************************************/
/***********************************************/ /****************** Functions ******************/
/***********************************************/
/// Default constructor.
X3DImporter()
: NodeElement_Cur( nullptr ), mReader( nullptr )
{}
/// Default destructor.
~X3DImporter();
/***********************************************/
/******** Functions: parse set, public *********/
/***********************************************/
/// 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;
private: private:
/// \fn X3DImporter(const X3DImporter& pScene)
/// Disabled copy constructor. /// Disabled copy constructor.
X3DImporter(const X3DImporter& pScene); X3DImporter(const X3DImporter& pScene);
/// \fn X3DImporter& operator=(const X3DImporter& pScene)
/// Disabled assign operator. /// Disabled assign operator.
X3DImporter& operator=(const X3DImporter& pScene); X3DImporter& operator=(const X3DImporter& pScene);
/// \fn void Clear()
/// Clear all temporary data. /// Clear all temporary data.
void Clear(); void Clear();
@ -199,7 +240,6 @@ private:
/************* Functions: find set *************/ /************* 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. /// Find requested node element. Search will be made in all existing nodes.
/// \param [in] pID - ID of requested element. /// \param [in] pID - ID of requested element.
/// \param [in] pType - type of requested element. /// \param [in] pType - type of requested element.
@ -207,7 +247,6 @@ private:
/// \return true - if the element is found, else - false. /// \return true - if the element is found, else - false.
bool FindNodeElement_FromRoot(const std::string& pID, const CX3DImporter_NodeElement::EType pType, CX3DImporter_NodeElement** pElement); 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. /// Find requested node element. Search will be made from pointed node down to childs.
/// \param [in] pStartNode - pointer to start node. /// \param [in] pStartNode - pointer to start node.
/// \param [in] pID - ID of requested element. /// \param [in] pID - ID of requested element.
@ -217,7 +256,6 @@ private:
bool FindNodeElement_FromNode(CX3DImporter_NodeElement* pStartNode, const std::string& pID, const CX3DImporter_NodeElement::EType pType, bool FindNodeElement_FromNode(CX3DImporter_NodeElement* pStartNode, const std::string& pID, const CX3DImporter_NodeElement::EType pType,
CX3DImporter_NodeElement** pElement); 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". /// Find requested node element. For "Node"'s accounting flag "Static".
/// \param [in] pName - name of requested element. /// \param [in] pName - name of requested element.
/// \param [in] pType - type of requested element. /// \param [in] pType - type of requested element.
@ -229,49 +267,41 @@ private:
/********* Functions: postprocess set **********/ /********* Functions: postprocess set **********/
/***********************************************/ /***********************************************/
/// \fn aiMatrix4x4 PostprocessHelper_Matrix_GlobalToCurrent() const
/// \return transformation matrix from global coordinate system to local. /// \return transformation matrix from global coordinate system to local.
aiMatrix4x4 PostprocessHelper_Matrix_GlobalToCurrent() const; 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. /// 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 [in] pNodeElement - node element where metadata is searching.
/// \param [out] pList - temporary list for collected metadata. /// \param [out] pList - temporary list for collected metadata.
void PostprocessHelper_CollectMetadata(const CX3DImporter_NodeElement& pNodeElement, std::list<CX3DImporter_NodeElement*>& pList) const; 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>. /// Check if type of node element is metadata. E.g. <MetadataSet>, <MetadataString>.
/// \param [in] pType - checked type. /// \param [in] pType - checked type.
/// \return true - if the type corresponds to the metadata. /// \return true - if the type corresponds to the metadata.
bool PostprocessHelper_ElementIsMetadata(const CX3DImporter_NodeElement::EType pType) const; 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>. /// 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. /// \param [in] pType - checked type.
/// \return true - if the type corresponds to the mesh. /// \return true - if the type corresponds to the mesh.
bool PostprocessHelper_ElementIsMesh(const CX3DImporter_NodeElement::EType pType) const; 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. /// 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 [in] pNodeElement - reference to lisght element(<DirectionalLight>, <PointLight>, <SpotLight>).
/// \param [out] pSceneLightList - reference to list of the lights. /// \param [out] pSceneLightList - reference to list of the lights.
void Postprocess_BuildLight(const CX3DImporter_NodeElement& pNodeElement, std::list<aiLight*>& pSceneLightList) const; 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 /// Create filled structure with type \ref aiMaterial from \ref CX3DImporter_NodeElement. This function itseld extract
/// all needed data from scene graph. /// all needed data from scene graph.
/// \param [in] pNodeElement - reference to material element(<Appearance>). /// \param [in] pNodeElement - reference to material element(<Appearance>).
/// \param [out] pMaterial - pointer to pointer to created material. *pMaterial must be nullptr. /// \param [out] pMaterial - pointer to pointer to created material. *pMaterial must be nullptr.
void Postprocess_BuildMaterial(const CX3DImporter_NodeElement& pNodeElement, aiMaterial** pMaterial) const; 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 /// Create filled structure with type \ref aiMaterial from \ref CX3DImporter_NodeElement. This function itseld extract
/// all needed data from scene graph. /// all needed data from scene graph.
/// \param [in] pNodeElement - reference to geometry object. /// \param [in] pNodeElement - reference to geometry object.
/// \param [out] pMesh - pointer to pointer to created mesh. *pMesh must be nullptr. /// \param [out] pMesh - pointer to pointer to created mesh. *pMesh must be nullptr.
void Postprocess_BuildMesh(const CX3DImporter_NodeElement& pNodeElement, aiMesh** pMesh) const; 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. /// Create aiNode from CX3DImporter_NodeElement. Also function check children and make recursive call.
/// \param [out] pNode - pointer to pointer to created node. *pNode must be nullptr. /// \param [out] pNode - pointer to pointer to created node. *pNode must be nullptr.
/// \param [in] pNodeElement - CX3DImporter_NodeElement which read. /// \param [in] pNodeElement - CX3DImporter_NodeElement which read.
@ -282,7 +312,6 @@ private:
void Postprocess_BuildNode(const CX3DImporter_NodeElement& pNodeElement, aiNode& pSceneNode, std::list<aiMesh*>& pSceneMeshList, void Postprocess_BuildNode(const CX3DImporter_NodeElement& pNodeElement, aiNode& pSceneNode, std::list<aiMesh*>& pSceneMeshList,
std::list<aiMaterial*>& pSceneMaterialList, std::list<aiLight*>& pSceneLightList) const; 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>. /// To create mesh and material kept in <Schape>.
/// \param pShapeNodeElement - reference to node element which kept <Shape> data. /// \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 pNodeMeshInd - reference to list with mesh indices. When pShapeNodeElement will read new mesh index will be added to this list.
@ -291,7 +320,6 @@ private:
void Postprocess_BuildShape(const CX3DImporter_NodeElement_Shape& pShapeNodeElement, std::list<unsigned int>& pNodeMeshInd, void Postprocess_BuildShape(const CX3DImporter_NodeElement_Shape& pShapeNodeElement, std::list<unsigned int>& pNodeMeshInd,
std::list<aiMesh*>& pSceneMeshList, std::list<aiMaterial*>& pSceneMaterialList) const; 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. /// 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 [in] pNodeElement - node element where metadata is searching.
/// \param [out] pSceneNode - scene node in which metadata will be added. /// \param [out] pSceneNode - scene node in which metadata will be added.
@ -301,13 +329,11 @@ private:
/************* Functions: throw set ************/ /************* 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. /// Call that function when argument is out of range and exception must be raised.
/// \throw DeadlyImportError. /// \throw DeadlyImportError.
/// \param [in] pArgument - argument name. /// \param [in] pArgument - argument name.
void Throw_ArgOutOfRange(const std::string& pArgument); 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. /// Call that function when close tag of node not found and exception must be raised.
/// E.g.: /// E.g.:
/// <Scene> /// <Scene>
@ -317,31 +343,26 @@ private:
/// \param [in] pNode - node name in which exception happened. /// \param [in] pNode - node name in which exception happened.
void Throw_CloseNotFound(const std::string& pNode); 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. /// Call that function when string value can not be converted to floating point value and exception must be raised.
/// \param [in] pAttrValue - attribute value. /// \param [in] pAttrValue - attribute value.
/// \throw DeadlyImportError. /// \throw DeadlyImportError.
void Throw_ConvertFail_Str2ArrF(const std::string& pAttrValue); 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. /// Call that function when in node defined attributes "DEF" and "USE" and exception must be raised.
/// E.g.: <Box DEF="BigBox" USE="MegaBox"> /// E.g.: <Box DEF="BigBox" USE="MegaBox">
/// \throw DeadlyImportError. /// \throw DeadlyImportError.
void Throw_DEF_And_USE(); 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. /// Call that function when attribute name is incorrect and exception must be raised.
/// \param [in] pAttrName - attribute name. /// \param [in] pAttrName - attribute name.
/// \throw DeadlyImportError. /// \throw DeadlyImportError.
void Throw_IncorrectAttr(const std::string& pAttrName); 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. /// Call that function when attribute value is incorrect and exception must be raised.
/// \param [in] pAttrName - attribute name. /// \param [in] pAttrName - attribute name.
/// \throw DeadlyImportError. /// \throw DeadlyImportError.
void Throw_IncorrectAttrValue(const std::string& pAttrName); 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. /// 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.: /// E.g.:
/// <Shape> /// <Shape>
@ -353,7 +374,6 @@ private:
/// \param [in] pDescription - message about error. E.g. what the node defined while exception raised. /// \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); 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. /// 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.: /// E.g.:
/// <Scene> /// <Scene>
@ -365,7 +385,6 @@ private:
/// \param [in] pNode - node name in which exception happened. /// \param [in] pNode - node name in which exception happened.
void Throw_TagCountIncorrect(const std::string& pNode); 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. /// Call that function when defined in "USE" element are not found in graph and exception must be raised.
/// \param [in] pAttrValue - "USE" attribute value. /// \param [in] pAttrValue - "USE" attribute value.
/// \throw DeadlyImportError. /// \throw DeadlyImportError.
@ -375,15 +394,12 @@ private:
/************** Functions: LOG set *************/ /************** Functions: LOG set *************/
/***********************************************/ /***********************************************/
/// \fn void LogInfo(const std::string& pMessage)
/// Short variant for calling \ref DefaultLogger::get()->info() /// Short variant for calling \ref DefaultLogger::get()->info()
void LogInfo(const std::string& pMessage) { DefaultLogger::get()->info(pMessage); } void LogInfo(const std::string& pMessage) { DefaultLogger::get()->info(pMessage); }
/// \fn void LogWarning(const std::string& pMessage)
/// Short variant for calling \ref DefaultLogger::get()->warn() /// Short variant for calling \ref DefaultLogger::get()->warn()
void LogWarning(const std::string& pMessage) { DefaultLogger::get()->warn(pMessage); } void LogWarning(const std::string& pMessage) { DefaultLogger::get()->warn(pMessage); }
/// \fn void LogError(const std::string& pMessage)
/// Short variant for calling \ref DefaultLogger::get()->error() /// Short variant for calling \ref DefaultLogger::get()->error()
void LogError(const std::string& pMessage) { DefaultLogger::get()->error(pMessage); } void LogError(const std::string& pMessage) { DefaultLogger::get()->error(pMessage); }
@ -391,144 +407,117 @@ private:
/************** Functions: XML set *************/ /************** Functions: XML set *************/
/***********************************************/ /***********************************************/
/// \fn void XML_CheckNode_MustBeEmpty()
/// Chek if current node is empty: <node />. If not then exception will throwed. /// Chek if current node is empty: <node />. If not then exception will throwed.
void XML_CheckNode_MustBeEmpty(); void XML_CheckNode_MustBeEmpty();
/// \fn bool XML_CheckNode_NameEqual(const std::string& pNodeName)
/// Chek if current node name is equal to pNodeName. /// Chek if current node name is equal to pNodeName.
/// \param [in] pNodeName - name for checking. /// \param [in] pNodeName - name for checking.
/// return true if current node name is equal to pNodeName, else - false. /// return true if current node name is equal to pNodeName, else - false.
bool XML_CheckNode_NameEqual(const std::string& pNodeName) { return mReader->getNodeName() == pNodeName; } 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. /// 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. /// \param [in] pParentNodeName - parent node name. Used for reporting.
void XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName); 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. /// 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. /// \param [in] pNodeName - requested node name.
/// return true - if node is found, else - false. /// return true - if node is found, else - false.
bool XML_SearchNode(const std::string& pNodeName); bool XML_SearchNode(const std::string& pNodeName);
/// \fn bool XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx)
/// Read attribute value. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \return read data. /// \return read data.
bool XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx); bool XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx);
/// \fn float XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx)
/// Read attribute value. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \return read data. /// \return read data.
float XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx); float XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx);
/// \fn int32_t XML_ReadNode_GetAttrVal_AsI32(const int pAttrIdx)
/// Read attribute value. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \return read data. /// \return read data.
int32_t XML_ReadNode_GetAttrVal_AsI32(const int pAttrIdx); int32_t XML_ReadNode_GetAttrVal_AsI32(const int pAttrIdx);
/// \fn void XML_ReadNode_GetAttrVal_AsCol3f(const int pAttrIdx, aiColor3D& pValue)
/// Read attribute value. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data. /// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsCol3f(const int pAttrIdx, aiColor3D& pValue); void XML_ReadNode_GetAttrVal_AsCol3f(const int pAttrIdx, aiColor3D& pValue);
/// \fn void XML_ReadNode_GetAttrVal_AsVec2f(const int pAttrIdx, aiVector2D& pValue)
/// Read attribute value. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data. /// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsVec2f(const int pAttrIdx, aiVector2D& pValue); void XML_ReadNode_GetAttrVal_AsVec2f(const int pAttrIdx, aiVector2D& pValue);
/// \fn void XML_ReadNode_GetAttrVal_AsVec3f(const int pAttrIdx, aiVector3D& pValue)
/// Read attribute value. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data. /// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsVec3f(const int pAttrIdx, aiVector3D& pValue); 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. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data. /// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListB(const int pAttrIdx, std::list<bool>& pValue); 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) /// \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); 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. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data. /// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListI32(const int pAttrIdx, std::list<int32_t>& pValue); 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) /// \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); 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. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data. /// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListF(const int pAttrIdx, std::list<float>& pValue); 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)
/// \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); 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.
/// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data. /// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListD(const int pAttrIdx, std::list<double>& pValue); 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) /// \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); 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. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data. /// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListCol3f(const int pAttrIdx, std::list<aiColor3D>& pValue); 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) /// \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); 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. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data. /// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListCol4f(const int pAttrIdx, std::list<aiColor4D>& pValue); 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) /// \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); 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. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data. /// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListVec2f(const int pAttrIdx, std::list<aiVector2D>& pValue); 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) /// \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); 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. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data. /// \param [out] pValue - read data.
void XML_ReadNode_GetAttrVal_AsListVec3f(const int pAttrIdx, std::list<aiVector3D>& pValue); 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) /// \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); 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. /// Read attribute value.
/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set). /// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
/// \param [out] pValue - read data. /// \param [out] pValue - read data.
@ -538,14 +527,12 @@ private:
/******* Functions: geometry helper set *******/ /******* Functions: geometry helper set *******/
/***********************************************/ /***********************************************/
/// \fn aiVector3D GeometryHelper_Make_Point2D(const float pAngle, const float pRadius)
/// Make point on surface oXY. /// 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] 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. /// \param [in] pRadius - length of radius-vector.
/// \return made point coordinates. /// \return made point coordinates.
aiVector3D GeometryHelper_Make_Point2D(const float pAngle, const float pRadius); 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 /// 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 /// 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. /// and pEndAngle is greater than or equal to 2pi, a circle is specified.
@ -556,32 +543,27 @@ private:
/// \param [out] pVertices - generated vertices. /// \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); 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. /// Create line set from point set.
/// \param [in] pPoint - input points list. /// \param [in] pPoint - input points list.
/// \param [out] pLine - made lines list. /// \param [out] pLine - made lines list.
void GeometryHelper_Extend_PointToLine(const std::list<aiVector3D>& pPoint, std::list<aiVector3D>& pLine); 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. /// 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 [in] pPolylineCoordIdx - vertices indices divided by delimiter "-1". Must contain faces with two or more indices.
/// \param [out] pLineCoordIdx - made CoordIdx of line set. /// \param [out] pLineCoordIdx - made CoordIdx of line set.
void GeometryHelper_Extend_PolylineIdxToLineIdx(const std::list<int32_t>& pPolylineCoordIdx, std::list<int32_t>& pLineCoordIdx); 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). /// 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 [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. /// \param [out] pVertices - generated vertices. The list of vertices is grouped in quads.
void GeometryHelper_MakeQL_RectParallelepiped(const aiVector3D& pSize, std::list<aiVector3D>& pVertices); 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. /// Create faces array from vertices indices array.
/// \param [in] pCoordIdx - vertices indices divided by delimiter "-1". /// \param [in] pCoordIdx - vertices indices divided by delimiter "-1".
/// \param [in] pFaces - created faces array. /// \param [in] pFaces - created faces array.
/// \param [in] pPrimitiveTypes - type of primitives in faces. /// \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; 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. /// Add colors to mesh.
/// a. If colorPerVertex is FALSE, colours are applied to each face, as follows: /// 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 /// 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
@ -602,41 +584,33 @@ private:
void MeshGeometry_AddColor(aiMesh& pMesh, const std::list<int32_t>& pCoordIdx, const std::list<int32_t>& pColorIdx, 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; 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; /// \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, 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; 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. /// Add colors to mesh.
/// \param [in] pMesh - mesh for adding data. /// \param [in] pMesh - mesh for adding data.
/// \param [in] pColors - defined colors. /// \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. /// \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; 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 /// \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; 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; /// 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, 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; 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; /// 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; 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;
/// 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, void MeshGeometry_AddTexCoord(aiMesh& pMesh, const std::list<int32_t>& pCoordIdx, const std::list<int32_t>& pTexCoordIdx,
const std::list<aiVector2D>& pTexCoords) const; 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;
/// Add texture coordinates to mesh. Function work similar to \ref MeshGeometry_AddColor;
void MeshGeometry_AddTexCoord(aiMesh& pMesh, const std::list<aiVector2D>& pTexCoords) const; 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. /// Create mesh.
/// \param [in] pCoordIdx - vertices indices divided by delimiter "-1". /// \param [in] pCoordIdx - vertices indices divided by delimiter "-1".
/// \param [in] pVertices - vertices of mesh. /// \param [in] pVertices - vertices of mesh.
@ -647,36 +621,30 @@ private:
/******** Functions: parse set private *********/ /******** 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 /// 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 /// like <Group>, <Transform> etc. When exiting from X3D group node(e.g. </Group>) \ref ParseHelper_Node_Exit must
/// be called. /// be called.
/// \param [in] pStatic - flag: if true then static node is created(e.g. <StaticGroup>). /// \param [in] pStatic - flag: if true then static node is created(e.g. <StaticGroup>).
void ParseHelper_Group_Begin(const bool pStatic = false); 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. /// 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. /// \param [in] pNode - new current node.
void ParseHelper_Node_Enter(CX3DImporter_NodeElement* pNode); 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. /// This function must be called when exiting from X3D group node(e.g. </Group>). \ref ParseHelper_Group_Begin.
void ParseHelper_Node_Exit(); 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 /// 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". /// must be converted to right form - "0.xxx".
/// \param [in] pInStr - pointer to input string which can contain incorrect form of values. /// \param [in] pInStr - pointer to input string which can contain incorrect form of values.
/// \param [out[ pOutString - output string with right form of values. /// \param [out[ pOutString - output string with right form of values.
void ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString); 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. /// 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>. /// 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. /// \return true - if metadata node are found and parsed, false - metadata not found.
bool ParseHelper_CheckRead_X3DMetadataObject(); bool ParseHelper_CheckRead_X3DMetadataObject();
/// \fn bool ParseHelper_CheckRead_X3DMetadataObject()
/// Check if current node has nodes of type X3DGeometricPropertyNode. X3DGeometricPropertyNode /// Check if current node has nodes of type X3DGeometricPropertyNode. X3DGeometricPropertyNode
/// X3DGeometricPropertyNode inheritors: /// X3DGeometricPropertyNode inheritors:
/// <FogCoordinate>, <HAnimDisplacer>, <Color>, <ColorRGBA>, <Coordinate>, <CoordinateDouble>, <GeoCoordinate>, <Normal>, /// <FogCoordinate>, <HAnimDisplacer>, <Color>, <ColorRGBA>, <Coordinate>, <CoordinateDouble>, <GeoCoordinate>, <Normal>,
@ -685,42 +653,33 @@ private:
/// \return true - if nodes are found and parsed, false - nodes not found. /// \return true - if nodes are found and parsed, false - nodes not found.
bool ParseHelper_CheckRead_X3DGeometricPropertyNode(); bool ParseHelper_CheckRead_X3DGeometricPropertyNode();
/// \fn void ParseNode_Root()
/// Parse <X3D> node of the file. /// Parse <X3D> node of the file.
void ParseNode_Root(); void ParseNode_Root();
/// \fn void ParseNode_Head()
/// Parse <head> node of the file. /// Parse <head> node of the file.
void ParseNode_Head(); void ParseNode_Head();
/// \fn void ParseNode_Root()
/// Parse <Scene> node of the file. /// Parse <Scene> node of the file.
void ParseNode_Scene(); void ParseNode_Scene();
/// \fn void ParseNode_Metadata(CX3DImporter_NodeElement* pParent, const std::string& pNodeName)
/// Parse child nodes of <Metadata*> node. /// 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 /// \param [in] pNodeName - parsed node name. Must be set because that function is general and name needed for checking the end
/// and error reporing. /// and error reporing.
/// \param [in] pParentElement - parent metadata element. /// \param [in] pParentElement - parent metadata element.
void ParseNode_Metadata(CX3DImporter_NodeElement* pParentElement, const std::string& pNodeName); void ParseNode_Metadata(CX3DImporter_NodeElement* pParentElement, const std::string& pNodeName);
/// \fn void ParseNode_MetadataBoolean()
/// Parse <MetadataBoolean> node of the file. /// Parse <MetadataBoolean> node of the file.
void ParseNode_MetadataBoolean(); void ParseNode_MetadataBoolean();
/// \fn void ParseNode_MetadataDouble()
/// Parse <MetadataDouble> node of the file. /// Parse <MetadataDouble> node of the file.
void ParseNode_MetadataDouble(); void ParseNode_MetadataDouble();
/// \fn void ParseNode_MetadataFloat()
/// Parse <MetadataFloat> node of the file. /// Parse <MetadataFloat> node of the file.
void ParseNode_MetadataFloat(); void ParseNode_MetadataFloat();
/// \fn void ParseNode_MetadataInteger()
/// Parse <MetadataInteger> node of the file. /// Parse <MetadataInteger> node of the file.
void ParseNode_MetadataInteger(); void ParseNode_MetadataInteger();
/// \fn void ParseNode_MetadataSet()
/// Parse <MetadataSet> node of the file. /// Parse <MetadataSet> node of the file.
void ParseNode_MetadataSet(); void ParseNode_MetadataSet();
@ -728,222 +687,160 @@ private:
/// Parse <MetadataString> node of the file. /// Parse <MetadataString> node of the file.
void ParseNode_MetadataString(); void ParseNode_MetadataString();
/// \fn void ParseNode_Geometry2D_Arc2D()
/// Parse <Arc2D> node of the file. /// Parse <Arc2D> node of the file.
void ParseNode_Geometry2D_Arc2D(); void ParseNode_Geometry2D_Arc2D();
/// \fn void ParseNode_Geometry2D_ArcClose2D()
/// Parse <ArcClose2D> node of the file. /// Parse <ArcClose2D> node of the file.
void ParseNode_Geometry2D_ArcClose2D(); void ParseNode_Geometry2D_ArcClose2D();
/// \fn void ParseNode_Geometry2D_Circle2D()
/// Parse <Circle2D> node of the file. /// Parse <Circle2D> node of the file.
void ParseNode_Geometry2D_Circle2D(); void ParseNode_Geometry2D_Circle2D();
/// \fn void ParseNode_Geometry2D_Disk2D()
/// Parse <Disk2D> node of the file. /// Parse <Disk2D> node of the file.
void ParseNode_Geometry2D_Disk2D(); void ParseNode_Geometry2D_Disk2D();
/// \fn void ParseNode_Geometry2D_Polyline2D()
/// Parse <Polyline2D> node of the file. /// Parse <Polyline2D> node of the file.
void ParseNode_Geometry2D_Polyline2D(); void ParseNode_Geometry2D_Polyline2D();
/// \fn void ParseNode_Geometry2D_Polypoint2D()
/// Parse <Polypoint2D> node of the file. /// Parse <Polypoint2D> node of the file.
void ParseNode_Geometry2D_Polypoint2D(); void ParseNode_Geometry2D_Polypoint2D();
/// \fn void ParseNode_Geometry2D_Rectangle2D()
/// Parse <Rectangle2D> node of the file. /// Parse <Rectangle2D> node of the file.
void ParseNode_Geometry2D_Rectangle2D(); void ParseNode_Geometry2D_Rectangle2D();
/// \fn void ParseNode_Geometry2D_TriangleSet2D()
/// Parse <TriangleSet2D> node of the file. /// Parse <TriangleSet2D> node of the file.
void ParseNode_Geometry2D_TriangleSet2D(); void ParseNode_Geometry2D_TriangleSet2D();
/// \fn void ParseNode_Geometry3D_Box()
/// Parse <Box> node of the file. /// Parse <Box> node of the file.
void ParseNode_Geometry3D_Box(); void ParseNode_Geometry3D_Box();
/// \fn void ParseNode_Geometry3D_Cone()
/// Parse <Cone> node of the file. /// Parse <Cone> node of the file.
void ParseNode_Geometry3D_Cone(); void ParseNode_Geometry3D_Cone();
/// \fn void ParseNode_Geometry3D_Cylinder()
/// Parse <Cylinder> node of the file. /// Parse <Cylinder> node of the file.
void ParseNode_Geometry3D_Cylinder(); void ParseNode_Geometry3D_Cylinder();
/// \fn void ParseNode_Geometry3D_ElevationGrid()
/// Parse <ElevationGrid> node of the file. /// Parse <ElevationGrid> node of the file.
void ParseNode_Geometry3D_ElevationGrid(); void ParseNode_Geometry3D_ElevationGrid();
/// \fn void ParseNode_Geometry3D_Extrusion()
/// Parse <Extrusion> node of the file. /// Parse <Extrusion> node of the file.
void ParseNode_Geometry3D_Extrusion(); void ParseNode_Geometry3D_Extrusion();
/// \fn void ParseNode_Geometry3D_IndexedFaceSet()
/// Parse <IndexedFaceSet> node of the file. /// Parse <IndexedFaceSet> node of the file.
void ParseNode_Geometry3D_IndexedFaceSet(); void ParseNode_Geometry3D_IndexedFaceSet();
/// \fn void ParseNode_Geometry3D_Sphere()
/// Parse <Sphere> node of the file. /// Parse <Sphere> node of the file.
void ParseNode_Geometry3D_Sphere(); void ParseNode_Geometry3D_Sphere();
/// \fn void ParseNode_Grouping_Group()
/// Parse <Group> node of the file. And create new node in scene graph. /// Parse <Group> node of the file. And create new node in scene graph.
void ParseNode_Grouping_Group(); void ParseNode_Grouping_Group();
/// \fn void ParseNode_Grouping_GroupEnd()
/// Doing actions at an exit from <Group>. Walk up in scene graph. /// Doing actions at an exit from <Group>. Walk up in scene graph.
void ParseNode_Grouping_GroupEnd(); void ParseNode_Grouping_GroupEnd();
/// \fn void ParseNode_Grouping_StaticGroup()
/// Parse <StaticGroup> node of the file. And create new node in scene graph. /// Parse <StaticGroup> node of the file. And create new node in scene graph.
void ParseNode_Grouping_StaticGroup(); void ParseNode_Grouping_StaticGroup();
/// \fn void ParseNode_Grouping_StaticGroupEnd()
/// Doing actions at an exit from <StaticGroup>. Walk up in scene graph. /// Doing actions at an exit from <StaticGroup>. Walk up in scene graph.
void ParseNode_Grouping_StaticGroupEnd(); void ParseNode_Grouping_StaticGroupEnd();
/// \fn void ParseNode_Grouping_Switch()
/// Parse <Switch> node of the file. And create new node in scene graph. /// Parse <Switch> node of the file. And create new node in scene graph.
void ParseNode_Grouping_Switch(); void ParseNode_Grouping_Switch();
/// \fn void ParseNode_Grouping_SwitchEnd()
/// Doing actions at an exit from <Switch>. Walk up in scene graph. /// Doing actions at an exit from <Switch>. Walk up in scene graph.
void ParseNode_Grouping_SwitchEnd(); void ParseNode_Grouping_SwitchEnd();
/// \fn void ParseNode_Grouping_Transform()
/// Parse <Transform> node of the file. And create new node in scene graph. /// Parse <Transform> node of the file. And create new node in scene graph.
void ParseNode_Grouping_Transform(); void ParseNode_Grouping_Transform();
/// \fn void ParseNode_Grouping_TransformEnd()
/// Doing actions at an exit from <Transform>. Walk up in scene graph. /// Doing actions at an exit from <Transform>. Walk up in scene graph.
void ParseNode_Grouping_TransformEnd(); void ParseNode_Grouping_TransformEnd();
/// \fn void ParseNode_Rendering_Color()
/// Parse <Color> node of the file. /// Parse <Color> node of the file.
void ParseNode_Rendering_Color(); void ParseNode_Rendering_Color();
/// \fn void ParseNode_Rendering_ColorRGBA()
/// Parse <ColorRGBA> node of the file. /// Parse <ColorRGBA> node of the file.
void ParseNode_Rendering_ColorRGBA(); void ParseNode_Rendering_ColorRGBA();
/// \fn void ParseNode_Rendering_Coordinate()
/// Parse <Coordinate> node of the file. /// Parse <Coordinate> node of the file.
void ParseNode_Rendering_Coordinate(); void ParseNode_Rendering_Coordinate();
/// \fn void ParseNode_Rendering_Normal()
/// Parse <Normal> node of the file. /// Parse <Normal> node of the file.
void ParseNode_Rendering_Normal(); void ParseNode_Rendering_Normal();
/// \fn void ParseNode_Rendering_IndexedLineSet()
/// Parse <IndexedLineSet> node of the file. /// Parse <IndexedLineSet> node of the file.
void ParseNode_Rendering_IndexedLineSet(); void ParseNode_Rendering_IndexedLineSet();
/// \fn void ParseNode_Rendering_IndexedTriangleFanSet()
/// Parse <IndexedTriangleFanSet> node of the file. /// Parse <IndexedTriangleFanSet> node of the file.
void ParseNode_Rendering_IndexedTriangleFanSet(); void ParseNode_Rendering_IndexedTriangleFanSet();
/// \fn void ParseNode_Rendering_IndexedTriangleSet()
/// Parse <IndexedTriangleSet> node of the file. /// Parse <IndexedTriangleSet> node of the file.
void ParseNode_Rendering_IndexedTriangleSet(); void ParseNode_Rendering_IndexedTriangleSet();
/// \fn void ParseNode_Rendering_IndexedTriangleStripSet()
/// Parse <IndexedTriangleStripSet> node of the file. /// Parse <IndexedTriangleStripSet> node of the file.
void ParseNode_Rendering_IndexedTriangleStripSet(); void ParseNode_Rendering_IndexedTriangleStripSet();
/// \fn void ParseNode_Rendering_LineSet()
/// Parse <LineSet> node of the file. /// Parse <LineSet> node of the file.
void ParseNode_Rendering_LineSet(); void ParseNode_Rendering_LineSet();
/// \fn void ParseNode_Rendering_PointSet()
/// Parse <PointSet> node of the file. /// Parse <PointSet> node of the file.
void ParseNode_Rendering_PointSet(); void ParseNode_Rendering_PointSet();
/// \fn void ParseNode_Rendering_TriangleFanSet()
/// Parse <TriangleFanSet> node of the file. /// Parse <TriangleFanSet> node of the file.
void ParseNode_Rendering_TriangleFanSet(); void ParseNode_Rendering_TriangleFanSet();
/// \fn void ParseNode_Rendering_TriangleSet()
/// Parse <TriangleSet> node of the file. /// Parse <TriangleSet> node of the file.
void ParseNode_Rendering_TriangleSet(); void ParseNode_Rendering_TriangleSet();
/// \fn void ParseNode_Rendering_TriangleStripSet()
/// Parse <TriangleStripSet> node of the file. /// Parse <TriangleStripSet> node of the file.
void ParseNode_Rendering_TriangleStripSet(); void ParseNode_Rendering_TriangleStripSet();
/// \fn void ParseNode_Texturing_ImageTexture()
/// Parse <ImageTexture> node of the file. /// Parse <ImageTexture> node of the file.
void ParseNode_Texturing_ImageTexture(); void ParseNode_Texturing_ImageTexture();
/// \fn void ParseNode_Texturing_TextureCoordinate()
/// Parse <TextureCoordinate> node of the file. /// Parse <TextureCoordinate> node of the file.
void ParseNode_Texturing_TextureCoordinate(); void ParseNode_Texturing_TextureCoordinate();
/// \fn void ParseNode_Texturing_TextureTransform()
/// Parse <TextureTransform> node of the file. /// Parse <TextureTransform> node of the file.
void ParseNode_Texturing_TextureTransform(); void ParseNode_Texturing_TextureTransform();
/// \fn void ParseNode_Shape_Shape()
/// Parse <Shape> node of the file. /// Parse <Shape> node of the file.
void ParseNode_Shape_Shape(); void ParseNode_Shape_Shape();
/// \fn void ParseNode_Shape_Appearance()
/// Parse <Appearance> node of the file. /// Parse <Appearance> node of the file.
void ParseNode_Shape_Appearance(); void ParseNode_Shape_Appearance();
/// \fn void ParseNode_Shape_Material()
/// Parse <Material> node of the file. /// Parse <Material> node of the file.
void ParseNode_Shape_Material(); void ParseNode_Shape_Material();
/// \fn void ParseNode_Networking_Inline()
/// Parse <Inline> node of the file. /// Parse <Inline> node of the file.
void ParseNode_Networking_Inline(); void ParseNode_Networking_Inline();
/// \fn void ParseNode_Lighting_DirectionalLight()
/// Parse <DirectionalLight> node of the file. /// Parse <DirectionalLight> node of the file.
void ParseNode_Lighting_DirectionalLight(); void ParseNode_Lighting_DirectionalLight();
/// \fn void ParseNode_Lighting_PointLight()
/// Parse <PointLight> node of the file. /// Parse <PointLight> node of the file.
void ParseNode_Lighting_PointLight(); void ParseNode_Lighting_PointLight();
/// \fn void ParseNode_Lighting_SpotLight()
/// Parse <SpotLight> node of the file. /// Parse <SpotLight> node of the file.
void ParseNode_Lighting_SpotLight(); void ParseNode_Lighting_SpotLight();
public: private:
/***********************************************/
/******************** Types ********************/
/***********************************************/
/// \fn X3DImporter() /***********************************************/
/// Default constructor. /****************** Constants ******************/
X3DImporter() /***********************************************/
: NodeElement_Cur(nullptr), mReader(nullptr) static const aiImporterDesc Description;
{}
/// \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;
/***********************************************/
/****************** Variables ******************/
/***********************************************/
CX3DImporter_NodeElement* NodeElement_Cur;///< Current element.
irr::io::IrrXMLReader* mReader;///< Pointer to XML-reader object
std::string mFileDir;
};// class X3DImporter };// class X3DImporter
}// namespace Assimp }// namespace Assimp

39
code/X3DImporter_Geometry2D.cpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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_Geometry2D.cpp /// \file X3DImporter_Geometry2D.cpp
/// \brief Parsing data from nodes of "Geometry2D" set of X3D. /// \brief Parsing data from nodes of "Geometry2D" set of X3D.
/// \date 2015-2016 /// \date 2015-2016

39
code/X3DImporter_Geometry3D.cpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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_Geometry3D.cpp /// \file X3DImporter_Geometry3D.cpp
/// \brief Parsing data from nodes of "Geometry3D" set of X3D. /// \brief Parsing data from nodes of "Geometry3D" set of X3D.
/// \date 2015-2016 /// \date 2015-2016

39
code/X3DImporter_Group.cpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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_Group.cpp /// \file X3DImporter_Group.cpp
/// \brief Parsing data from nodes of "Grouping" set of X3D. /// \brief Parsing data from nodes of "Grouping" set of X3D.
/// \date 2015-2016 /// \date 2015-2016

101
code/X3DImporter_Light.cpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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_Light.cpp /// \file X3DImporter_Light.cpp
/// \brief Parsing data from nodes of "Lighting" set of X3D. /// \brief Parsing data from nodes of "Lighting" set of X3D.
/// \date 2015-2016 /// \date 2015-2016
@ -23,14 +62,14 @@ namespace Assimp
// /> // />
void X3DImporter::ParseNode_Lighting_DirectionalLight() void X3DImporter::ParseNode_Lighting_DirectionalLight()
{ {
std::string def, use; std::string def, use;
float ambientIntensity = 0; float ambientIntensity = 0;
aiColor3D color(1, 1, 1); aiColor3D color(1, 1, 1);
aiVector3D direction(0, 0, -1); aiVector3D direction(0, 0, -1);
bool global = false; bool global = false;
float intensity = 1; float intensity = 1;
bool on = true; bool on = true;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne;
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -93,16 +132,16 @@ CX3DImporter_NodeElement* ne;
// /> // />
void X3DImporter::ParseNode_Lighting_PointLight() void X3DImporter::ParseNode_Lighting_PointLight()
{ {
std::string def, use; std::string def, use;
float ambientIntensity = 0; float ambientIntensity = 0;
aiVector3D attenuation(1, 0, 0); aiVector3D attenuation( 1, 0, 0 );
aiColor3D color(1, 1, 1); aiColor3D color( 1, 1, 1 );
bool global = true; bool global = true;
float intensity = 1; float intensity = 1;
aiVector3D location(0, 0, 0); aiVector3D location( 0, 0, 0 );
bool on = true; bool on = true;
float radius = 100; float radius = 100;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne;
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -171,19 +210,19 @@ CX3DImporter_NodeElement* ne;
// /> // />
void X3DImporter::ParseNode_Lighting_SpotLight() void X3DImporter::ParseNode_Lighting_SpotLight()
{ {
std::string def, use; std::string def, use;
float ambientIntensity = 0; float ambientIntensity = 0;
aiVector3D attenuation(1, 0, 0); aiVector3D attenuation( 1, 0, 0 );
float beamWidth = 0.7854f; float beamWidth = 0.7854f;
aiColor3D color(1, 1, 1); aiColor3D color( 1, 1, 1 );
float cutOffAngle = 1.570796f; float cutOffAngle = 1.570796f;
aiVector3D direction(0, 0, -1); aiVector3D direction( 0, 0, -1 );
bool global = true; bool global = true;
float intensity = 1; float intensity = 1;
aiVector3D location(0, 0, 0); aiVector3D location( 0, 0, 0 );
bool on = true; bool on = true;
float radius = 100; float radius = 100;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne;
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);

39
code/X3DImporter_Macro.hpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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_Macro.hpp /// \file X3DImporter_Macro.hpp
/// \brief Useful macrodefines. /// \brief Useful macrodefines.
/// \date 2015-2016 /// \date 2015-2016

77
code/X3DImporter_Metadata.cpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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_Metadata.cpp /// \file X3DImporter_Metadata.cpp
/// \brief Parsing data from nodes of "Metadata" set of X3D. /// \brief Parsing data from nodes of "Metadata" set of X3D.
/// \date 2015-2016 /// \date 2015-2016
@ -81,10 +120,10 @@ void X3DImporter::ParseNode_Metadata(CX3DImporter_NodeElement* pParentElement, c
// /> // />
void X3DImporter::ParseNode_MetadataBoolean() void X3DImporter::ParseNode_MetadataBoolean()
{ {
std::string def, use; std::string def, use;
std::string name, reference; std::string name, reference;
std::list<bool> value; std::list<bool> value;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne;
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -105,10 +144,10 @@ CX3DImporter_NodeElement* ne;
// /> // />
void X3DImporter::ParseNode_MetadataDouble() void X3DImporter::ParseNode_MetadataDouble()
{ {
std::string def, use; std::string def, use;
std::string name, reference; std::string name, reference;
std::list<double> value; std::list<double> value;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne;
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -153,10 +192,10 @@ CX3DImporter_NodeElement* ne;
// /> // />
void X3DImporter::ParseNode_MetadataInteger() void X3DImporter::ParseNode_MetadataInteger()
{ {
std::string def, use; std::string def, use;
std::string name, reference; std::string name, reference;
std::list<int32_t> value; std::list<int32_t> value;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne;
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -176,9 +215,9 @@ CX3DImporter_NodeElement* ne;
// /> // />
void X3DImporter::ParseNode_MetadataSet() void X3DImporter::ParseNode_MetadataSet()
{ {
std::string def, use; std::string def, use;
std::string name, reference; std::string name, reference;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne;
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -216,10 +255,10 @@ CX3DImporter_NodeElement* ne;
// /> // />
void X3DImporter::ParseNode_MetadataString() void X3DImporter::ParseNode_MetadataString()
{ {
std::string def, use; std::string def, use;
std::string name, reference; std::string name, reference;
std::list<std::string> value; std::list<std::string> value;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne;
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);

39
code/X3DImporter_Networking.cpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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_Networking.cpp /// \file X3DImporter_Networking.cpp
/// \brief Parsing data from nodes of "Networking" set of X3D. /// \brief Parsing data from nodes of "Networking" set of X3D.
/// \date 2015-2016 /// \date 2015-2016

39
code/X3DImporter_Node.hpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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 /// \file X3DImporter_Node.hpp
/// \brief Elements of scene graph. /// \brief Elements of scene graph.
/// \date 2015-2016 /// \date 2015-2016

71
code/X3DImporter_Postprocess.cpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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_Postprocess.cpp /// \file X3DImporter_Postprocess.cpp
/// \brief Convert built scenegraph and objects to Assimp scenegraph. /// \brief Convert built scenegraph and objects to Assimp scenegraph.
/// \date 2015-2016 /// \date 2015-2016
@ -20,9 +59,9 @@ namespace Assimp
aiMatrix4x4 X3DImporter::PostprocessHelper_Matrix_GlobalToCurrent() const aiMatrix4x4 X3DImporter::PostprocessHelper_Matrix_GlobalToCurrent() const
{ {
CX3DImporter_NodeElement* cur_node; CX3DImporter_NodeElement* cur_node;
std::list<aiMatrix4x4> matr; std::list<aiMatrix4x4> matr;
aiMatrix4x4 out_matr; aiMatrix4x4 out_matr;
// starting walk from current element to root // starting walk from current element to root
cur_node = NodeElement_Cur; cur_node = NodeElement_Cur;
@ -100,9 +139,9 @@ bool X3DImporter::PostprocessHelper_ElementIsMesh(const CX3DImporter_NodeElement
void X3DImporter::Postprocess_BuildLight(const CX3DImporter_NodeElement& pNodeElement, std::list<aiLight*>& pSceneLightList) const void X3DImporter::Postprocess_BuildLight(const CX3DImporter_NodeElement& pNodeElement, std::list<aiLight*>& pSceneLightList) const
{ {
const CX3DImporter_NodeElement_Light& ne = *((CX3DImporter_NodeElement_Light*)&pNodeElement); const CX3DImporter_NodeElement_Light& ne = *( ( CX3DImporter_NodeElement_Light* ) &pNodeElement );
aiMatrix4x4 transform_matr = PostprocessHelper_Matrix_GlobalToCurrent(); aiMatrix4x4 transform_matr = PostprocessHelper_Matrix_GlobalToCurrent();
aiLight* new_light = new aiLight; aiLight* new_light = new aiLight;
new_light->mName = ne.ID; new_light->mName = ne.ID;
new_light->mColorAmbient = ne.Color * ne.AmbientIntensity; new_light->mColorAmbient = ne.Color * ne.AmbientIntensity;
@ -564,10 +603,10 @@ void X3DImporter::Postprocess_BuildMesh(const CX3DImporter_NodeElement& pNodeEle
void X3DImporter::Postprocess_BuildNode(const CX3DImporter_NodeElement& pNodeElement, aiNode& pSceneNode, std::list<aiMesh*>& pSceneMeshList, void X3DImporter::Postprocess_BuildNode(const CX3DImporter_NodeElement& pNodeElement, aiNode& pSceneNode, std::list<aiMesh*>& pSceneMeshList,
std::list<aiMaterial*>& pSceneMaterialList, std::list<aiLight*>& pSceneLightList) const std::list<aiMaterial*>& pSceneMaterialList, std::list<aiLight*>& pSceneLightList) const
{ {
std::list<CX3DImporter_NodeElement*>::const_iterator chit_begin = pNodeElement.Child.begin(); std::list<CX3DImporter_NodeElement*>::const_iterator chit_begin = pNodeElement.Child.begin();
std::list<CX3DImporter_NodeElement*>::const_iterator chit_end = pNodeElement.Child.end(); std::list<CX3DImporter_NodeElement*>::const_iterator chit_end = pNodeElement.Child.end();
std::list<aiNode*> SceneNode_Child; std::list<aiNode*> SceneNode_Child;
std::list<unsigned int> SceneNode_Mesh; std::list<unsigned int> SceneNode_Mesh;
// At first read all metadata // At first read all metadata
Postprocess_CollectMetadata(pNodeElement, pSceneNode); Postprocess_CollectMetadata(pNodeElement, pSceneNode);
@ -649,10 +688,10 @@ std::list<unsigned int> SceneNode_Mesh;
void X3DImporter::Postprocess_BuildShape(const CX3DImporter_NodeElement_Shape& pShapeNodeElement, std::list<unsigned int>& pNodeMeshInd, void X3DImporter::Postprocess_BuildShape(const CX3DImporter_NodeElement_Shape& pShapeNodeElement, std::list<unsigned int>& pNodeMeshInd,
std::list<aiMesh*>& pSceneMeshList, std::list<aiMaterial*>& pSceneMaterialList) const std::list<aiMesh*>& pSceneMeshList, std::list<aiMaterial*>& pSceneMaterialList) const
{ {
aiMaterial* tmat = nullptr; aiMaterial* tmat = nullptr;
aiMesh* tmesh = nullptr; aiMesh* tmesh = nullptr;
CX3DImporter_NodeElement::EType mesh_type = CX3DImporter_NodeElement::ENET_Invalid; CX3DImporter_NodeElement::EType mesh_type = CX3DImporter_NodeElement::ENET_Invalid;
unsigned int mat_ind = 0; unsigned int mat_ind = 0;
for(std::list<CX3DImporter_NodeElement*>::const_iterator it = pShapeNodeElement.Child.begin(); it != pShapeNodeElement.Child.end(); it++) for(std::list<CX3DImporter_NodeElement*>::const_iterator it = pShapeNodeElement.Child.begin(); it != pShapeNodeElement.Child.end(); it++)
{ {
@ -714,8 +753,8 @@ unsigned int mat_ind = 0;
void X3DImporter::Postprocess_CollectMetadata(const CX3DImporter_NodeElement& pNodeElement, aiNode& pSceneNode) const void X3DImporter::Postprocess_CollectMetadata(const CX3DImporter_NodeElement& pNodeElement, aiNode& pSceneNode) const
{ {
std::list<CX3DImporter_NodeElement*> meta_list; std::list<CX3DImporter_NodeElement*> meta_list;
size_t meta_idx; size_t meta_idx;
PostprocessHelper_CollectMetadata(pNodeElement, meta_list);// find metadata in current node element. PostprocessHelper_CollectMetadata(pNodeElement, meta_list);// find metadata in current node element.
if(meta_list.size() > 0) if(meta_list.size() > 0)

159
code/X3DImporter_Rendering.cpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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_Rendering.cpp /// \file X3DImporter_Rendering.cpp
/// \brief Parsing data from nodes of "Rendering" set of X3D. /// \brief Parsing data from nodes of "Rendering" set of X3D.
/// \date 2015-2016 /// \date 2015-2016
@ -18,9 +57,9 @@ namespace Assimp
// /> // />
void X3DImporter::ParseNode_Rendering_Color() void X3DImporter::ParseNode_Rendering_Color()
{ {
std::string use, def; std::string use, def;
std::list<aiColor3D> color; std::list<aiColor3D> color;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -56,9 +95,9 @@ CX3DImporter_NodeElement* ne;
// /> // />
void X3DImporter::ParseNode_Rendering_ColorRGBA() void X3DImporter::ParseNode_Rendering_ColorRGBA()
{ {
std::string use, def; std::string use, def;
std::list<aiColor4D> color; std::list<aiColor4D> color;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -94,9 +133,9 @@ CX3DImporter_NodeElement* ne;
// /> // />
void X3DImporter::ParseNode_Rendering_Coordinate() void X3DImporter::ParseNode_Rendering_Coordinate()
{ {
std::string use, def; std::string use, def;
std::list<aiVector3D> point; std::list<aiVector3D> point;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -139,11 +178,11 @@ CX3DImporter_NodeElement* ne;
// </IndexedLineSet> // </IndexedLineSet>
void X3DImporter::ParseNode_Rendering_IndexedLineSet() void X3DImporter::ParseNode_Rendering_IndexedLineSet()
{ {
std::string use, def; std::string use, def;
std::list<int32_t> colorIndex; std::list<int32_t> colorIndex;
bool colorPerVertex = true; bool colorPerVertex = true;
std::list<int32_t> coordIndex; std::list<int32_t> coordIndex;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -213,13 +252,13 @@ CX3DImporter_NodeElement* ne;
// </IndexedTriangleFanSet> // </IndexedTriangleFanSet>
void X3DImporter::ParseNode_Rendering_IndexedTriangleFanSet() void X3DImporter::ParseNode_Rendering_IndexedTriangleFanSet()
{ {
std::string use, def; std::string use, def;
bool ccw = true; bool ccw = true;
bool colorPerVertex = true; bool colorPerVertex = true;
std::list<int32_t> index; std::list<int32_t> index;
bool normalPerVertex = true; bool normalPerVertex = true;
bool solid = true; bool solid = true;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -294,13 +333,13 @@ CX3DImporter_NodeElement* ne;
// </IndexedTriangleSet> // </IndexedTriangleSet>
void X3DImporter::ParseNode_Rendering_IndexedTriangleSet() void X3DImporter::ParseNode_Rendering_IndexedTriangleSet()
{ {
std::string use, def; std::string use, def;
bool ccw = true; bool ccw = true;
bool colorPerVertex = true; bool colorPerVertex = true;
std::list<int32_t> index; std::list<int32_t> index;
bool normalPerVertex = true; bool normalPerVertex = true;
bool solid = true; bool solid = true;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -375,13 +414,13 @@ CX3DImporter_NodeElement* ne;
// </IndexedTriangleStripSet> // </IndexedTriangleStripSet>
void X3DImporter::ParseNode_Rendering_IndexedTriangleStripSet() void X3DImporter::ParseNode_Rendering_IndexedTriangleStripSet()
{ {
std::string use, def; std::string use, def;
bool ccw = true; bool ccw = true;
bool colorPerVertex = true; bool colorPerVertex = true;
std::list<int32_t> index; std::list<int32_t> index;
bool normalPerVertex = true; bool normalPerVertex = true;
bool solid = true; bool solid = true;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -451,9 +490,9 @@ CX3DImporter_NodeElement* ne;
// </LineSet> // </LineSet>
void X3DImporter::ParseNode_Rendering_LineSet() void X3DImporter::ParseNode_Rendering_LineSet()
{ {
std::string use, def; std::string use, def;
std::list<int32_t> vertexCount; std::list<int32_t> vertexCount;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -525,8 +564,8 @@ CX3DImporter_NodeElement* ne;
// </PointSet> // </PointSet>
void X3DImporter::ParseNode_Rendering_PointSet() void X3DImporter::ParseNode_Rendering_PointSet()
{ {
std::string use, def; std::string use, def;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -584,13 +623,13 @@ CX3DImporter_NodeElement* ne;
// </TriangleFanSet> // </TriangleFanSet>
void X3DImporter::ParseNode_Rendering_TriangleFanSet() void X3DImporter::ParseNode_Rendering_TriangleFanSet()
{ {
std::string use, def; std::string use, def;
bool ccw = true; bool ccw = true;
bool colorPerVertex = true; bool colorPerVertex = true;
std::list<int32_t> fanCount; std::list<int32_t> fanCount;
bool normalPerVertex = true; bool normalPerVertex = true;
bool solid = true; bool solid = true;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -700,12 +739,12 @@ CX3DImporter_NodeElement* ne;
// </TriangleSet> // </TriangleSet>
void X3DImporter::ParseNode_Rendering_TriangleSet() void X3DImporter::ParseNode_Rendering_TriangleSet()
{ {
std::string use, def; std::string use, def;
bool ccw = true; bool ccw = true;
bool colorPerVertex = true; bool colorPerVertex = true;
bool normalPerVertex = true; bool normalPerVertex = true;
bool solid = true; bool solid = true;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -775,13 +814,13 @@ CX3DImporter_NodeElement* ne;
// </TriangleStripSet> // </TriangleStripSet>
void X3DImporter::ParseNode_Rendering_TriangleStripSet() void X3DImporter::ParseNode_Rendering_TriangleStripSet()
{ {
std::string use, def; std::string use, def;
bool ccw = true; bool ccw = true;
bool colorPerVertex = true; bool colorPerVertex = true;
std::list<int32_t> stripCount; std::list<int32_t> stripCount;
bool normalPerVertex = true; bool normalPerVertex = true;
bool solid = true; bool solid = true;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);

63
code/X3DImporter_Shape.cpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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_Shape.cpp /// \file X3DImporter_Shape.cpp
/// \brief Parsing data from nodes of "Shape" set of X3D. /// \brief Parsing data from nodes of "Shape" set of X3D.
/// \date 2015-2016 /// \date 2015-2016
@ -28,8 +67,8 @@ namespace Assimp
// NOTE Geometry nodes that represent lines or points do not support lighting. // NOTE Geometry nodes that represent lines or points do not support lighting.
void X3DImporter::ParseNode_Shape_Shape() void X3DImporter::ParseNode_Shape_Shape()
{ {
std::string use, def; std::string use, def;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -105,8 +144,8 @@ CX3DImporter_NodeElement* ne;
// </Appearance> // </Appearance>
void X3DImporter::ParseNode_Shape_Appearance() void X3DImporter::ParseNode_Shape_Appearance()
{ {
std::string use, def; std::string use, def;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -158,14 +197,14 @@ CX3DImporter_NodeElement* ne;
// /> // />
void X3DImporter::ParseNode_Shape_Material() void X3DImporter::ParseNode_Shape_Material()
{ {
std::string use, def; std::string use, def;
float ambientIntensity = 0.2f; float ambientIntensity = 0.2f;
float shininess = 0.2f; float shininess = 0.2f;
float transparency = 0; float transparency = 0;
aiColor3D diffuseColor(0.8f, 0.8f, 0.8f); aiColor3D diffuseColor(0.8f, 0.8f, 0.8f);
aiColor3D emissiveColor(0, 0, 0); aiColor3D emissiveColor(0, 0, 0);
aiColor3D specularColor(0, 0, 0); aiColor3D specularColor(0, 0, 0);
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);

67
code/X3DImporter_Texturing.cpp
View File

@ -1,3 +1,42 @@
/*
Open Asset Import Library (assimp)
----------------------------------------------------------------------
Copyright (c) 2006-2016, 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_Texturing.cpp /// \file X3DImporter_Texturing.cpp
/// \brief Parsing data from nodes of "Texturing" set of X3D. /// \brief Parsing data from nodes of "Texturing" set of X3D.
/// \date 2015-2016 /// \date 2015-2016
@ -21,11 +60,11 @@ namespace Assimp
// When the url field contains no values ([]), texturing is disabled. // When the url field contains no values ([]), texturing is disabled.
void X3DImporter::ParseNode_Texturing_ImageTexture() void X3DImporter::ParseNode_Texturing_ImageTexture()
{ {
std::string use, def; std::string use, def;
bool repeatS = true; bool repeatS = true;
bool repeatT = true; bool repeatT = true;
std::list<std::string> url; std::list<std::string> url;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -70,9 +109,9 @@ CX3DImporter_NodeElement* ne;
// /> // />
void X3DImporter::ParseNode_Texturing_TextureCoordinate() void X3DImporter::ParseNode_Texturing_TextureCoordinate()
{ {
std::string use, def; std::string use, def;
std::list<aiVector2D> point; std::list<aiVector2D> point;
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
@ -111,12 +150,12 @@ CX3DImporter_NodeElement* ne;
// /> // />
void X3DImporter::ParseNode_Texturing_TextureTransform() void X3DImporter::ParseNode_Texturing_TextureTransform()
{ {
std::string use, def; std::string use, def;
aiVector2D center(0, 0); aiVector2D center(0, 0);
float rotation = 0; float rotation = 0;
aiVector2D scale(1, 1); aiVector2D scale(1, 1);
aiVector2D translation(0, 0); aiVector2D translation(0, 0);
CX3DImporter_NodeElement* ne; CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);