VRUT::VRMLParser Class Reference

Class for parsing VRML files. More...

#include <vrmlparser.h>

List of all members.

Public Member Functions
	VRMLParser (wxInputStream *_inputStream, SCENE_ID _sceneID, const wxString _scenePath, Module *_module)
	~VRMLParser ()
	Class destructor.
bool	Parse (const wxString &rootUid, bool teselate, NodeUidsList *nnl)
Private Types
enum	ERROR_MSG { EXPECTED, UNEXPECTED, VECTOR, MATERIAL }
	Error message enumeration. More...
enum	WARN_MSG { TRIANGULATE, DISABLED, UNSUPPORTED, UNSUPPORTED_ATTR }
	Warrning message enumeration. More...
Private Member Functions
	WX_DECLARE_STRING_HASH_MAP (bool, NodeUidsList)
NodeUidsList &	getNodeUidsList ()
	WX_DECLARE_STRING_HASH_MAP (std::vector< VECTOR3 > *, DefNamesListV3)
	WX_DECLARE_STRING_HASH_MAP (std::vector< VECTOR2 > *, DefNamesListV2)
	WX_DECLARE_STRING_HASH_MAP (wxString, DefNamesListSN)
	WX_DECLARE_STRING_HASH_MAP (Material *, DefNamesListM)
	WX_DECLARE_STRING_HASH_MAP (wxString, DefNamesListG)
	WX_DECLARE_STRING_HASH_MAP (unsigned, DefNamesListSNDindex)
void	logWarnMsg (WARN_MSG msg, const wxString &name)
bool	logErrorMsg (ERROR_MSG msg, const wxString &line, const wxChar *expected=NULL)
const wxString	getUniqueUid (const wxString &uid)
bool	externproto ()
bool	node (const wxString &parentUid, bool just_define)
bool	proto ()
bool	routeStatement ()
bool	statement (const wxString &parentUid)
bool	URLList ()
bool	parseModel (const wxString &rootUid)
bool	Anchor (const wxString &parentUid, bool just_define)
bool	Appearance (const wxString &parentUid, VRUT::Material *material, VECTOR2 &translation, float &rotation, VECTOR2 &scale, VECTOR2 &center)
bool	Billboard (const wxString &parentUid, bool just_define)
bool	Box (GeometryTriangles *geometry)
bool	Collision (const wxString &parentUid, bool just_define)
bool	DirectionalLight (Light *light)
bool	ElevationGrid (const wxString &parentUid, GeometryTriangles *geometry, bool just_define)
bool	Extrusion (const wxString &parentUid, GeometryTriangles *geometry)
bool	Group (const wxString &parentUid, bool just_define)
bool	IndexedFaceSet (const wxString &parentUid, GeometryTriangles *geometry)
bool	IndexedLineSet (const wxString &parentUid, GeometryTriangles *geometry)
bool	Inline (const wxString &parentUid)
bool	ImageTexture (VRUT::Material *material)
bool	LOD (const wxString &parentUid, bool just_define)
bool	Material (VRUT::Material *material)
bool	PointLight (Light *light)
bool	PointSet (const wxString &parentUid, GeometryTriangles *geometry)
bool	Shape (const wxString &nodeUid, bool just_define, GNode *gnode=NULL)
bool	SpotLight (Light *light)
bool	Switch (const wxString &parentUid, bool just_define)
bool	Transform (const wxString &parentUid, bool just_define, ANode *anode=NULL)
bool	Viewpoint (MATRIX &mat, float &field)
void	skip (char z)
bool	skip_stack (char z, char inv_z)
bool	parseFArray3 (std::vector< VECTOR3 > *array, const char *VRMLnode, const char *VRMLfield, bool skip=false)
bool	parseFArray2 (std::vector< VECTOR2 > *array, const char *VRMLnode, const char *VRMLfield, bool skip=false)
bool	parseIndices (std::vector< GeometryTriangles::Indice > *indices, size_t &count, size_t count_exp)
bool	parseIndicesTSL (std::vector< GeometryTriangles::Indice > *indices, size_t &count, size_t count_exp)
void	computeNormals (VRUT::GeometryTriangles *geometry, float &creaseAngle)
float	abs (const float &x)
Private Attributes
TextParser *	textParser
	Input text parser.
SCENE_ID	sceneID
	ID of scene to be built.
wxString	scenePath
	Path to scene resources, can be archive filename.
Module *	module
	Parent module's interface.
bool	fromVRUT
	Importing file that has been exported by VRUT.
NodeUidsList	nodeUidsList
	List of nodes' names used during import to assure they are unique.
DefNamesListV3	defNamesListV3
	List of DEF nodes' names used during import that labels type VECTOR3.
DefNamesListV2	defNamesListV2
	List of DEF nodes' names used during import that labels type VECTOR2.
DefNamesListSN	defNamesListSN
	List of DEF nodes' names used during import that labels type VRUT::SceneNode.
DefNamesListM	defNamesListM
	List of DEF nodes' names used during import that labels type VRUT::Material.
DefNamesListG	defNamesListG
	List of DEF nodes' names used during import that labels type VRUT::Geometry.
DefNamesListSNDindex	defNamesListSNDindex
	index to a vector of defined scene nodes but not yet used (Defined in switch)
std::vector< Node * >	defNamesListSND
	vector of scene nodes defined but not yet used
Friends
struct	ANode
struct	GNode
struct	LNode
Classes
struct	ANode
	basic structure for defined Transformation nodes that are hidden in Switch and will be maybe used More...
struct	GNode
	basic structure for defined Geometry nodes that are hidden in Switch and will be maybe used More...
struct	LNode
	structure for defined Light nodes that are hidden in Switch and will be maybe used More...
struct	Node
	basic structure for defined nodes that are hidden in Switch and will be maybe used More...

---

Detailed Description

Class for parsing VRML files.

Definition at line 33 of file vrmlparser.h.

---

Member Enumeration Documentation

enum VRUT::VRMLParser::ERROR_MSG [private]

Error message enumeration.

Enumerator:

EXPECTED	Expected something else.
UNEXPECTED	Unexpected token.
VECTOR	Vector parsing error.
MATERIAL	Material not defined error.

Definition at line 274 of file vrmlparser.h.

              {
                     EXPECTED,                   
                     UNEXPECTED,          
                     VECTOR,                            
                     MATERIAL                    
              };

enum VRUT::VRMLParser::WARN_MSG [private]

Warrning message enumeration.

Enumerator:

TRIANGULATE
DISABLED	Not supported feature.
UNSUPPORTED	Triangulation disabled.
UNSUPPORTED_ATTR	Unsupported type of node. Unsupported atribute of a node

Definition at line 282 of file vrmlparser.h.

              {
                     TRIANGULATE, 
      DISABLED,    
      UNSUPPORTED,  
      UNSUPPORTED_ATTR 
              };

---

Constructor & Destructor Documentation

VRMLParser::VRMLParser	(	wxInputStream *	_inputStream,
		SCENE_ID	_sceneID,
		const wxString	_scenePath,
		Module *	_module
	)

Class constructor

Parameters:

[in]	_inputStream	Stream to read data from
[in]	_sceneID	Scene ID
[in]	_scenePath	Path to scene resources (can be an archive filename)
[in]	_module	Parent module with messaging interface

Definition at line 17 of file vrmlparser.cpp.

: module(_module)
{
       textParser = new TextParser(_inputStream, 10000, 100);
       wxFileName filename(_scenePath);
       scenePath = filename.GetPath() + filename.GetPathSeparator();
       sceneID = _sceneID;
  Node::vrmlp = this;
  fromVRUT = false;
}

VRMLParser::~VRMLParser

(

)

Class destructor.

Definition at line 29 of file vrmlparser.cpp.

{
       delete textParser;

       for(DefNamesListV3::iterator it = defNamesListV3.begin(); it != defNamesListV3.end(); it++)
    delete it->second;
       for(DefNamesListV2::iterator it = defNamesListV2.begin(); it != defNamesListV2.end(); it++)
    delete it->second;
       for(DefNamesListM::iterator it = defNamesListM.begin(); it != defNamesListM.end(); it++)
    delete it->second;
  for(std::vector<Node*>::iterator it = defNamesListSND.begin(); it != defNamesListSND.end(); it++)
    delete (*it);
}

---

Member Function Documentation

VRUT::VRMLParser::WX_DECLARE_STRING_HASH_MAP	(	bool	,
		NodeUidsList
	)			[private]

NodeUidsList& VRUT::VRMLParser::getNodeUidsList

(

)

[inline, private]

Method used during importing several files (node Inline in VRML97)

Returns:

reference to list of nodes' names used to assure they are unique

Definition at line 54 of file vrmlparser.h.

                                             {
                return nodeUidsList;
    }

VRUT::VRMLParser::WX_DECLARE_STRING_HASH_MAP	(	std::vector< VECTOR3 > *	,
		DefNamesListV3
	)			[private]

VRUT::VRMLParser::WX_DECLARE_STRING_HASH_MAP	(	std::vector< VECTOR2 > *	,
		DefNamesListV2
	)			[private]

VRUT::VRMLParser::WX_DECLARE_STRING_HASH_MAP	(	wxString	,
		DefNamesListSN
	)			[private]

VRUT::VRMLParser::WX_DECLARE_STRING_HASH_MAP	(	Material *	,
		DefNamesListM
	)			[private]

VRUT::VRMLParser::WX_DECLARE_STRING_HASH_MAP	(	wxString	,
		DefNamesListG
	)			[private]

VRUT::VRMLParser::WX_DECLARE_STRING_HASH_MAP	(	unsigned	,
		DefNamesListSNDindex
	)			[private]

void VRMLParser::logWarnMsg	(	WARN_MSG	msg,
		const wxString &	name = wxT("")
	)			[private]

Log warning message

Parameters:

[in]

msg

Warrning ID

Definition at line 43 of file vrmlparser.cpp.

                                                                       {
 switch(msg){
 case TRIANGULATE:
  LOGWARNING(wxT("<VRMLParser>Triangulation not yet supported."));
  break;
 case DISABLED:
  LOGWARNING(wxT("<VRMLParser>Triangulation disabled."));
  break;
 case UNSUPPORTED:
  LOGWARNING(wxT("<VRMLParser>Node ") + name + wxT(" not yet supported"));
  break;
 case UNSUPPORTED_ATTR:
  LOGWARNING(wxT("<VRMLParser>Attribute ") + name + wxT(" not yet supported"));
  break;
 }
 return;
}

bool VRMLParser::logErrorMsg	(	ERROR_MSG	msg,
		const wxString &	line,
		const wxChar *	expected = NULL
	)			[private]

Log error message

Parameters:

[in]	msg	Error ID
[in]	line	Part of string parsed with error
[in]	expected	Expected token if applicable

Returns:

Always false

Definition at line 61 of file vrmlparser.cpp.

{
       if (module->TestExit())
              return false;

       switch (msg)
       {
       case EXPECTED:
              if (expected)
              {
                     LOGERROR(wxT("<VRMLParser>Expected '") + wxString(expected) + wxT("' before '") + line + wxT("'"));
                     break;
              }
       case UNEXPECTED:
              if (wxString(line).Trim().IsEmpty())
                     LOGERROR(wxT("<VRMLParser>Unexpected end of file"));
              else
                     LOGERROR(wxT("<VRMLParser>Unexpected token: '" + line + wxT("'")));
              break;
       case VECTOR:
              LOGERROR(wxT("<VRMLParser>Vector parse error, invalid dimension or format: '" + line + wxT("'")));
              break;
       case MATERIAL:
              LOGERROR(wxT("<VRMLParser>Material not defined: '" + line + wxT("'")));
              break;
       }
       return false;
}

const wxString VRMLParser::getUniqueUid

(

const wxString &

uid

)

[private]

Check if given uid is unique, generate new if not and add to list

Parameters:

[in]

uid

uid to check if it is unique

Returns:

unique uid

Definition at line 91 of file vrmlparser.cpp.

{

       wxString unqUid = CloneWxString(uid);
       unsigned cnt = 0;
       while (nodeUidsList.find(unqUid) != nodeUidsList.end())
              unqUid = wxString::Format(wxT("%s_%i"), uid.c_str(), cnt++);
       nodeUidsList.insert(NodeUidsList::value_type(unqUid, false));
       return unqUid;
}

bool VRMLParser::externproto

(

)

[private]

method that parses EXTERNPROTO VRML node

Returns:

if the externproto was read successfully

Definition at line 102 of file vrmlparser.cpp.

                            {
//externproto -> EXTERNPROTO Id [externInterfaceDeclarations] URLList
     logWarnMsg(UNSUPPORTED, wxT("EXTERNPROTO"));
     textParser->GetWxString(); //Id
     textParser->GetChar(); //[
     skip(']'); // -> exposedField fieldType Id
     return ( URLList());
}

bool VRMLParser::node	(	const wxString &	parentUid,
		bool	just_define
	)			[private]

method that parses VRLM nodes which can stand alone

Parameters:

[in]	parentUid	uid of parent used in VRUT scene
[in]	just_define	indicates if it is hidden in a Switch

Returns:

if the node was read successfully

Definition at line 111 of file vrmlparser.cpp.

                                                                 {

  static const char *keywords[]={"Anchor", "AudioClip", "Background", "Billboard", "Collision", "ColorInterpolator", "CoordinateInterpolator", "CylinderSensor",  "DirectionalLight", "Fog", "Group", "Inline", "LOD", "NavigationInfo", "NormalInterpolator", "OrientationInterpolator",
  "PlaneSensor", "PointLight", "PositionInterpolator", "ProximitySensor",  "ScalarInterpolator", "Script", "Shape", "Sound", "SphereSensor", "SpotLight", "Switch",  "TimeSensor", "TouchSensor", "Transform", "Viewpoint",   "VisibilitySensor", "WorldInfo", "NULL", ""};

  wxString defName = wxT("");
  wxString useName;
  if ( textParser->NextKeywordIs("DEF"," \t\n\r,"))
    defName = textParser->GetWxString();

  if ( textParser->NextKeywordIs("USE"," \t\n\r,") ){
    useName = textParser->GetWxString();
    DefNamesListSN::iterator it = defNamesListSN.find(useName);
    if ( it != defNamesListSN.end()){
      wxCommandEvent ev1 = Event::GET_EVT_SCENE_NODE_COPY(sceneID, it->second, parentUid);
      module->PostToKernel(ev1);
      return true;
    }
    //it could have been declared and not used yet
    DefNamesListSNDindex::iterator it1 = defNamesListSNDindex.find(useName);
    if ( it1 != defNamesListSNDindex.end()){
      defNamesListSND[it1->second]->addToScene(parentUid);
      delete defNamesListSND[it1->second];
      return true;
    }
    //several VRML Nodes not yet implemented
    //LOGERROR(wxT("Unexpected USE name ")+useName);
    //return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
    LOGWARNING(wxT("Not supported type of node! Skipped."));
    return true;
  }

  int index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
  switch(index){
    case 0: return Anchor(parentUid, just_define);
    case 1: //AudioClip
            logWarnMsg(UNSUPPORTED, wxT("AudioClip"));
            skip('}'); return true;
    case 2: //Background
            logWarnMsg(UNSUPPORTED, wxT("Background"));
            skip('}'); //{}
            return true;
    case 3: return Billboard(parentUid, just_define);
    case 4: return Collision(parentUid, just_define);
    case 5: //ColorInterpolator
            logWarnMsg(UNSUPPORTED, wxT("ColorInterpolator"));
            skip('}'); //{}
            return true;
    case 6: //CoordinateInterpolator
            logWarnMsg(UNSUPPORTED, wxT("CoordinateInterpolator"));
            skip('}'); //{}
            return true;
    case 7: //CylinderSensor
            logWarnMsg(UNSUPPORTED, wxT("CylinderSensor"));
            skip('}'); //{}
            return true;
    case 8: {//DirectionalLight
            // if nothing defined and in Swtich hidden skip it!
            if ( just_define && defName == wxT("")){
              skip('}');
              return true;
            }
            //Add new light node
            wxString nodeName;
            if ( defName == wxT(""))
              nodeName = wxT("light");
            else nodeName = defName;
                           wxString nodeUid = getUniqueUid(nodeName);
            LightNode * node = new LightNode(nodeUid, nodeName);

            Light * light = new Light;
            if (!DirectionalLight(light)){
              LOGERROR(wxT("<VRMLParser>Failed parsing light '") + nodeName + wxT("'"));
              SAFE_DELETE(light);
              SAFE_DELETE(node);
              return false;
            }
            // if it is not hidden in a Switch
            if ( !just_define){
              wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, parentUid);
              module->PostToKernel(ev);
              wxCommandEvent ev2 = Event::GET_EVT_SCENE_NODE_LIGHT_SET(sceneID, nodeUid, light);
              module->PostToKernel(ev2);
              if ( defName != wxT(""))
                defNamesListSN[nodeName] = defName;
              return true;
            }
            // if it is hidden in a Switch and defined
            defNamesListSNDindex[defName] =  (DefNamesListSNDindex::mapped_type)defNamesListSND.size();
            LNode* ln = new LNode( nodeName, node, defName);
            ln -> setParam ( light);
            defNamesListSND.push_back(ln);
            return true;
            }
    case 9: //Fog
            logWarnMsg(UNSUPPORTED, wxT("Fog"));
            skip('}'); //{}
            return true;
    case 10: return Group(parentUid, just_define);
    case 11: //Inline
             return Inline(parentUid);
    case 12: return LOD(parentUid, just_define);
    case 13: //NavigationInfo
            logWarnMsg(UNSUPPORTED, wxT("NavigationInfo"));
            skip('}'); //{}
            return true;
    case 14: //NoramlInterpolator
            logWarnMsg(UNSUPPORTED, wxT("NormalInterpolator"));
            skip('}'); //{}
            return true;
    case 15: //OrientationInterpolator
            logWarnMsg(UNSUPPORTED, wxT("OrientationInterpolator"));
            skip('}'); //{}
            return true;
    case 16: //PlaneSensor
            logWarnMsg(UNSUPPORTED, wxT("PlaneSensor"));
            skip('}'); //{}
            return true;
    case 17: {//PointLight
            // if nothing defined and in Swtich hidden skip it!
            if ( just_define && defName == wxT("")){
              skip('}');
              return true;
            }
            //Add new light node
            wxString nodeName;
            if ( defName == wxT(""))
              nodeName = wxT("light");
            else nodeName = defName;
                           wxString nodeUid = getUniqueUid(nodeName);
            LightNode * node = new LightNode(nodeUid, nodeName);

            Light * light = new Light;
            if (!PointLight(light)){
              LOGERROR(wxT("<VRMLParser>Failed parsing light '") + nodeName + wxT("'"));
              SAFE_DELETE(light);
              SAFE_DELETE(node);
              return false;
            }
            // if it is not hidden in a Switch
            if ( !just_define){
              wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, parentUid);
              module->PostToKernel(ev);
              wxCommandEvent ev2 = Event::GET_EVT_SCENE_NODE_LIGHT_SET(sceneID, nodeUid, light);
              module->PostToKernel(ev2);
              if ( defName != wxT(""))
                defNamesListSN[nodeName] = defName;
              return true;
            }
            // if it is hidden in a Switch and defined
            defNamesListSNDindex[defName] =  (DefNamesListSNDindex::mapped_type)defNamesListSND.size();
            LNode* ln = new LNode( nodeName, node, defName);
            ln -> setParam ( light);
            defNamesListSND.push_back(ln);
            return true;
            }
    case 18: //PositionInterpolator
            logWarnMsg(UNSUPPORTED, wxT("PositionInterpolator"));
            skip('}'); //{}
            return true;
    case 19: //ProximitySensor
            logWarnMsg(UNSUPPORTED, wxT("ProximitySensor"));
            skip('}'); //{}
            return true;
    case 20: //ScalarInterpolator
            logWarnMsg(UNSUPPORTED, wxT("ScalarInterpolator"));
            skip('}'); //{}
            return true;
    case 21: //Script
            logWarnMsg(UNSUPPORTED, wxT("Script"));
            skip_stack('}', '{'); //{}
            return true;
    case 22: { //Shape
            // if nothing defined and in Switch hidden it could be defined the geometry or material
            GeometryNode *node = NULL;
            wxString nodeName;
                           wxString nodeUid;
            GNode* ln = NULL;
            //Add new geometry node
            if ( !just_define || defName != wxT("")){
               if ( defName == wxT(""))
                nodeName = wxT("shape");
               else nodeName = defName;
                              nodeUid = getUniqueUid(nodeName);
               node = new GeometryNode(nodeUid, nodeName);
            }
            if ( !just_define){
              wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, parentUid);
              module->PostToKernel(ev);
            }
            if ( just_define && defName != wxT("")){ // if it is hidden in a Switch and defined
              defNamesListSNDindex[defName] =  (DefNamesListSNDindex::mapped_type)defNamesListSND.size();
              ln = new GNode( nodeName, node, defName);
              defNamesListSND.push_back(ln);
            }
            if (!Shape(nodeUid, just_define, ln)){
              LOGERROR(wxT("<VRMLParser>Failed parsing Shape "));
              return false;
            }
            if ( !just_define && defName != wxT(""))
                   defNamesListSN.insert(DefNamesListSN::value_type(defName, nodeName ));
            return true;
            }
    case 23: //Sound
            logWarnMsg(UNSUPPORTED, wxT("Sound"));
            skip_stack('}', '{');
            return true;
    case 24: //SphereSensor
            logWarnMsg(UNSUPPORTED, wxT("SphereSensor"));
            skip('}'); //{}
            return true;
    case 25: {//SpotLight
            // if nothing defined and in Swtich hidden skip it!
            if ( just_define && defName == wxT("")){
              skip('}');
              return true;
            }
            //Add new light node
            wxString nodeName;
            if ( defName == wxT(""))
              nodeName = wxT("light");
            else nodeName = defName;
                           wxString nodeUid = getUniqueUid(nodeName);
            LightNode * node = new LightNode(nodeUid, nodeName);

            Light * light = new Light;
            if (!SpotLight(light)){
              LOGERROR(wxT("<VRMLParser>Failed parsing light '") + nodeName + wxT("'"));
              SAFE_DELETE(light);
              SAFE_DELETE(node);
              return false;
            }
            // if it is not hidden in a Switch
            if ( !just_define){
              wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, parentUid);
              module->PostToKernel(ev);
              wxCommandEvent ev2 = Event::GET_EVT_SCENE_NODE_LIGHT_SET(sceneID, nodeUid, light);
              module->PostToKernel(ev2);
              if ( defName != wxT(""))
                defNamesListSN[nodeName] = defName;
              return true;
            }
            // if it is hidden in a Switch and defined
            defNamesListSNDindex[defName] =  (DefNamesListSNDindex::mapped_type)defNamesListSND.size();
            LNode* ln = new LNode( nodeName, node, defName);
            ln -> setParam ( light);
            defNamesListSND.push_back(ln);
            return true;
            }
    case 26: return Switch(parentUid, just_define);
    case 27: //TimeSensor
            logWarnMsg(UNSUPPORTED, wxT("TimeSensor"));
            skip('}'); //{}
            return true;
    case 28: //TouchSensor
            logWarnMsg(UNSUPPORTED, wxT("TouchSensor"));
            skip('}'); //{}
            return true;
    case 29: //Transform //Add new node
            {
            wxString nodeName;
                           wxString nodeUid;
            SceneNode* node = NULL;
            ANode* ln = NULL;

            if ( !just_define || defName != wxT("")) {
              if ( defName == wxT(""))
                nodeName = wxT("transform");
              else nodeName = defName;
                             nodeUid = getUniqueUid(nodeName);
              node = new SceneNode(nodeUid, nodeName, SceneNode::ASSEMBLY);
            }
            // if it is not hidden in a Switch
            if ( !just_define){
              wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, node, parentUid);
              module->PostToKernel(ev);
            }
            if ( just_define && defName != wxT("")){
              // if it is hidden in a Switch and defined
              defNamesListSNDindex[defName] =  (DefNamesListSNDindex::mapped_type)defNamesListSND.size();
              ln = new ANode( nodeName, node, defName);
              defNamesListSND.push_back(ln);
            }
            if (!Transform(nodeUid, just_define, ln)){
              //SAFE_DELETE(node);
              LOGERROR(wxT("<VRMLParser>Failed parsing transformation "));
              return false;
            }
            if ( !just_define && defName != wxT(""))
                   defNamesListSN.insert(DefNamesListSN::value_type(defName, nodeName ));
            return true;
            }
    case 30: {//Viewpoint
            // I don't expect Viewpoints to be hidden in a switch
            //Add new Camera node
            wxString nodeName;

            MATRIX trans = MATRIX();
            float fov = 0;
            if (!Viewpoint(trans,fov)){
              LOGERROR(wxT("<VRMLParser>Failed parsing Viewpoint '"));
              return false;
            }
            //create transformation node to transform camera
            if ( defName == wxT(""))
              nodeName = wxT("camera");
            else nodeName = defName;
                           wxString nodeUid = getUniqueUid(nodeName);
            SceneNode* camera = new Camera(nodeUid, nodeName);

            wxCommandEvent ev2 = Event::GET_EVT_SCENE_NODE_INSERT(sceneID, camera, parentUid);
            module->PostToKernel(ev2);

            wxCommandEvent ev1 = Event::GET_EVT_SCENE_NODE_TRANSFORM(sceneID, nodeUid, trans);
            module->PostToKernel(ev1);

            // width, height, near, far, fov
            wxCommandEvent ev3 = Event::GET_EVT_SCENE_CAM_PROJECTION_SET(sceneID, nodeUid,
              4,3,0.001,10000,(fov/M_PI)*180);
            module->PostToKernel(ev3);

            if ( defName != wxT(""))
             defNamesListSN[nodeName] = defName;

            return true;
            }
    case 31: //VisibilitySensor
            logWarnMsg(UNSUPPORTED, wxT("VisibilitySensor"));
            skip('}'); //{}
            return true;
    case 32: //WorldInfo
            logWarnMsg(UNSUPPORTED, wxT("WorldInfo"));
            skip('}'); //{}
            return true;
    case 33: //NULL
             return true;
    default:
       return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
  }

}

bool VRMLParser::proto

(

)

[private]

method that parser PROTO structures

Returns:

if the node was read successfully

Definition at line 2405 of file vrmlparser.cpp.

                      {
//proto -> PROTO Id [ interfaceDeclarations ] { protoBody }
  logWarnMsg(UNSUPPORTED, wxT("PROTO"));
  textParser->GetWxString(); //Id
  textParser->GetChar(); //[
  skip(']');
  if (textParser->GetChar(" \t\n\r,") == '{') return skip_stack('}','{');
    else return logErrorMsg(UNEXPECTED, textParser->GetWxLine());

}

bool VRMLParser::routeStatement

(

)

[private]

method that parser ROUTE statments

Returns:

if the ROUTE was read successfully

Definition at line 2417 of file vrmlparser.cpp.

                               {
  logWarnMsg(UNSUPPORTED, wxT("ROUTE"));
  //routeStatement -> ROUTE Id.Id TO Id.Id
  textParser->GetWxString(); //Id.Id
  textParser->GetWxString(); //TO
  textParser->GetWxString(); //Id.Id
  return true;
}

bool VRMLParser::statement

(

const wxString &

parentUid

)

[private]

method that destinguish EXTERNPROTO, PROTO, ROUTE and normal nodes

Returns:

if the parsing was successful

Definition at line 2428 of file vrmlparser.cpp.

                                                    {
  static const char *keywords[]={"EXTERNPROTO", "PROTO", "ROUTE",  ""};//static - nemusi data plnit kazde volani fce
  int index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
  switch(index){
    case 0:
    case 1: //statement -> protoStatement
     return proto();
    case 2: //statement -> routeStatement
     return routeStatement();
    default: //statement -> nodeStatement
     return node(parentUid, false);
  }
}

bool VRMLParser::URLList

(

)

[private]

method that parser URLList

Returns:

if the parsing was successful

Definition at line 2442 of file vrmlparser.cpp.

                        {
  wxString word = textParser->GetWxString();

  if ( word == wxString::FromAscii("[") )  skip(']'); //URLList -> [ MFString ]

  //URLList -> string
  return true;
}

bool VRMLParser::parseModel

(

const wxString &

rootUid

)

[private]

the root method to read the VRML header and call other methods

Parameters:

[in]

rootUid

uid of a root node

Returns:

if the parsing was successful

Definition at line 2451 of file vrmlparser.cpp.

{
   //each valid VRML file must begin with a head "#VRML V2.0 utf8"
  if (textParser->GetChar(NULL, false) != '#')
    return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
  if ( !textParser->NextKeywordIs("VRML") )
    return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
  if ( !textParser->NextKeywordIs("V2.0") )
    return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
  if ( !textParser->NextKeywordIs("utf8") )
    return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
  if ( !textParser->NextCharIs('\n', " \t\r")){
    if ( textParser->NextKeywordIs("VRUTexporter"))
      fromVRUT = true;
    else textParser->GetWxLine();
  }

  if ( textParser->IsEmpty())
     return true;

  //vrmlScene -> head statements
   while ( !textParser->IsEmpty()){
       if ( !statement(rootUid) )
            return false;
   }
   return true;
}

bool VRMLParser::Anchor	(	const wxString &	parentUid,
		bool	just_define
	)			[private]

the method to parse Anchor node - it only imports its children

Parameters:

[in]	parentUid	uid of a parent used in VRUT scene
[in]	just_define	indicates if it is hidden in a Switch

Returns:

if the parsing was successful

Definition at line 454 of file vrmlparser.cpp.

                                                                   {
  if ( !textParser->NextCharIs('{'," \t\n\r,")) {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    else textParser->GetChar();

  static const char *keywords[]={ "children", "parameter", "url",  "bboxCenter", "bboxSize", "description", ""};
  int index;
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
    index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
    switch(index){
      case 0: //children
         if ( textParser->NextCharIs('['," \t\n\r,")){
           textParser->GetChar();
           while ( !textParser->NextCharIs(']'," \t\n\r,"))
             node(parentUid, just_define);
           textParser->GetChar();
         } else
           if ( !node(parentUid, just_define))
             return false;
           break;
      case 1: //parameter
         logWarnMsg(UNSUPPORTED_ATTR, wxT("parameter"));
         skip('"');
         skip('"');
         break;
      case 2: //url []
         logWarnMsg(UNSUPPORTED_ATTR, wxT("url"));
         if ( textParser->NextCharIs('['," \t\n\r,")) skip(']');
         else {skip('"');skip('"');}
         break;
      case 3: //bboxCenter
      case 4: //bboxSize float float float
         logWarnMsg(UNSUPPORTED_ATTR, wxT("bboxCenter|bboxSize"));
         textParser->GetWxString();
         textParser->GetWxString();
         textParser->GetWxString();
         break;
      case 5: //description
         logWarnMsg(UNSUPPORTED_ATTR, wxT("description"));
         skip('"');
         skip('"');
         break;
      default:
       return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
    }
   }
 textParser->GetChar(" \t\n\r,");
 return true;
}

bool VRMLParser::Appearance	(	const wxString &	parentUid,
		VRUT::Material *	material,
		VECTOR2 &	translation,
		float &	rotation,
		VECTOR2 &	scale,
		VECTOR2 &	center
	)			[private]

the method to parse Appeearence node

Parameters:

[in]	parentUid	uid of a parent used in VRUT scene
[in]	material	pointer to material node in VRUT scene to change
[out]	translation	translation of texture
[out]	rotation	rotation of texture
[out]	scale	scale of texture
[out]	center	for rotation and scale

Returns:

if the parsing was successful

Definition at line 503 of file vrmlparser.cpp.

                                                                                                                                                      {
  if ( textParser->GetChar(" \t\n\r,") != '{') {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}

  static const char *keywords[]={ "material", "texture", "textureTransform", ""};
  static const char *keywords_t[]={ "ImageTexture", "MovieTexture", "PixelTexture", ""};
  static const char *keywords_tt[] = {"translation", "rotation", "scale", "center",""};

  int index;
  wxString defName;
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
    defName = wxT("");
    index = textParser->KeywordsSwitch(keywords, " \t\n\r", " \t\n\r,{}[]");
    switch(index){
      case 0:
              if (textParser->NextKeywordIs("DEF"," \t\n\r,"))
                defName = textParser->GetWxString();
              if (textParser->NextKeywordIs("USE"," \t\n\r,")){
                DefNamesListM::iterator it = defNamesListM.find(textParser->GetWxString());
                if ( it != defNamesListM.end()) {
                  VRUT::Material* temp = it -> second;
                  material->diffuse = temp->diffuse;
                  material->emission = temp->emission;
                  material->specular = temp->specular;
                  material->ambient = temp->ambient;
                  material->shininess = temp->shininess;
                  material->flags = temp->flags;
                     break;
                }
                else {
                  LOGERROR(wxT("Unexpected USE name"));
                  return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
                }
              }
              if (textParser->NextKeywordIs("Material"," \t\n\r,")) {
                if (!Material(material))  //musi obsahovat jen tento uzel
                  return false;
               } else return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
              if ( defName != wxT(""))
                defNamesListM.insert(DefNamesListM::value_type(defName, material->Clone() ));
              break;
      case 1: {//ImageTexture, MovieTexture, PixelTexture
              if (textParser->NextKeywordIs("DEF"," \t\n\r,"))
                defName = textParser->GetWxString();
              if (textParser->NextKeywordIs("USE"," \t\n\r,")){
                DefNamesListM::iterator it = defNamesListM.find(textParser->GetWxString());
                if ( it != defNamesListM.end()) {
                  VRUT::Material* temp = it -> second;
                  material->imageName = temp->imageName;
                  material->texFlags = temp->texFlags;
                     break;
                }
                else {
                  LOGERROR(wxT("Unexpected USE name"));
                  return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
                }
              }
               index = textParser->KeywordsSwitch(keywords_t, " \t\n\r,", " \t\n\r,{}[]");
               switch(index){
                 case 0: //ImageTexture
                   if (!ImageTexture(material)) return false;
                   break;
                 case 1:
                   logWarnMsg(UNSUPPORTED_ATTR, wxT("MovieTexture"));
                   skip('}'); //{}
                   break;
                 case 2:
                   logWarnMsg(UNSUPPORTED_ATTR, wxT("PixelTexture"));
                   skip('}'); //{}
                   break;
                 default:
                   LOGERROR(wxT("<VRMLParser>Failed parsing texture "));
                   return false;
               }
               break;
              }
      case 2: //TextureTransform
            if (textParser->NextKeywordIs("NULL"," \t\n\r,")) break;
            if (textParser->NextKeywordIs("DEF"," \t\n\r,"))
              defName = textParser->GetWxString();
            if (textParser->NextKeywordIs("USE"," \t\n\r,")) {
              textParser->GetWxString(); break;
            }
            if (!textParser->NextKeywordIs("TextureTransform")) return false;
            if (textParser->GetChar(" \t\n\r,")!='{') return false;
            while ( !textParser->NextCharIs('}')){
              index = textParser->KeywordsSwitch(keywords_tt, " \t\n\r,", " \t\n\r,{}[]");
              switch(index){
                case 0: //translation
                     if ( textParser->ParseVector(translation._v, 2, true) != 2 )
                    return false;
                  break;
                case 1: //rotation
                  if ( !textParser->ParseFloat(&rotation)) return false;
                  break;
                case 2: //scale
                     if ( textParser->ParseVector(scale._v, 2, true) != 2 )
                    return false;
                  break;
                case 3: //center
                     if ( textParser->ParseVector(center._v, 2, true) != 2 )
                    return false;
                  break;
                default: return false;
              }
            }
            textParser->GetChar(" \t\n\r,");
            break;
      default: logErrorMsg(UNEXPECTED, textParser->GetWxLine());
               return false;
    }
  }
  textParser->GetChar(" \t\n\r,");
  return true;
}

bool VRMLParser::Billboard	(	const wxString &	parentUid,
		bool	just_define
	)			[private]

the method to parse Billboard node - it only imports its children

Parameters:

[in]	parentUid	uid of a parent used in VRUT scene
[in]	just_define	indicates if it is hidden in a Switch

Returns:

if the parsing was successful

Definition at line 619 of file vrmlparser.cpp.

                                                                      {
  if ( !textParser->NextCharIs('{'," \t\n\r,")) {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    else textParser->GetChar();

       static const char *keywords[]={"axisOfRotation", "bboxCenter", "bboxSize", "children", ""};
       int index;
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
    index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
         switch(index){
       case 0:
         case 1:
       case 2: //float float float
         logWarnMsg(UNSUPPORTED_ATTR, wxT("bboxCenter|bboxSize|axisOfRotation"));
              textParser->GetWxString();
              textParser->GetWxString();
              textParser->GetWxString();
              break;
       case 3: // [] MFNode
              {
                     textParser->GetChar(); //[
                     while ( !textParser->NextCharIs(']'," \t\n\r,") ){
                            if ( !node(parentUid, just_define)) return false;
                     }
                     textParser->GetChar(); //]
                     break;
              }
       default: logErrorMsg(UNEXPECTED, textParser->GetWxLine());
              return false;
       }
  }
  textParser->GetChar();
  return true;
}

bool VRMLParser::Box

(

GeometryTriangles *

geometry

)

[private]

the method to parse Box node

Parameters:

[in]

geometry

geometry VRUT node to modify

Returns:

if the parsing was successful

Definition at line 653 of file vrmlparser.cpp.

                                                {
  if ( textParser->GetChar(" \t\n\r,") != '{') {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
  vector3 size(2,2,2);
  if ( textParser->NextCharIs('}'," \t\n\r,")) {
    geometry->AddBox(-size/2, size);
    textParser->GetChar();
    return true;
  }

  static const char *keywords[]={ "size",""};
  int index;
  while ( !textParser->NextCharIs('}') ){
    index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
    switch(index){
     case 0: //float float float
       if (!textParser->ParseVector(size._v, 3, true)) {
         LOGERROR(wxT("<VRMLParser>Failed parsing box "));
         return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
       }
       break;
     default:
       LOGERROR(wxT("<VRMLParser>Failed parsing box "));
       return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
    }
  }
  geometry->AddBox(-size/2, size);
  textParser->GetChar(" \t\n\r,");
  return true;
}

bool VRMLParser::Collision	(	const wxString &	parentUid,
		bool	just_define
	)			[private]

the method to parse Collision node - it only imports its children

Parameters:

[in]	parentUid	uid of a parent used in VRUT scene
[in]	just_define	indicates if it is hidden in a Switch

Returns:

if the parsing was successful

Definition at line 684 of file vrmlparser.cpp.

                                                                      {
  if ( !textParser->NextCharIs('{'," \t\n\r,")) {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    else textParser->GetChar();

       static const char *keywords[]={ "collide", "proxy", "bboxCenter", "bboxSize", "children", ""};
       int index;
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
    index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
       switch(index){
       case 0: // TRUE | NULL
       case 1:
         logWarnMsg(UNSUPPORTED_ATTR, wxT("collide|proxy"));
              textParser->GetWxString();
              break;
       case 2:
       case 3: //float float float
         logWarnMsg(UNSUPPORTED_ATTR, wxT("bboxCenter|bboxSize"));
              textParser->GetWxString();
              textParser->GetWxString();
              textParser->GetWxString();
              break;
       case 4: // [] MFNode
              {
                     static const char *k[] = {"]",""};
                     textParser->GetWxString(); //[
                     while ( index = textParser->KeywordsSwitch(k," \t\n\r,"," \t\n\r,{}[]") != 0){
                            if ( !node(parentUid, just_define)) return false;
                     }
                     break;
              }
       default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
       }
  }
  textParser->GetChar(" \t\n\r,");
  return true;
}

bool VRMLParser::DirectionalLight

(

Light *

light

)

[private]

the method to parse DirectionalLight node

Parameters:

[in]

light

light VRUT node to modify

Returns:

if the parsing was successful

Definition at line 721 of file vrmlparser.cpp.

                                             {
  if ( textParser->GetChar(" \t\n\r,")!='{') return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));
  static const char* keywords[] = {"direction","color","intensity","ambientIntensity","on",""};

  VECTOR3 direction(0,0,-1);
  VECTOR4 color(1,1,1);
  float intensity = 1;
  float ambientIntensity = 0;

  while( !textParser->NextCharIs('}'," \t\n\r,")){
    int index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
    switch(index){
      case 0: //direction
           if ( textParser->ParseVector(direction._v, 3, true) != 3 )
             return false;
        break;
      case 1: //color
           if ( textParser->ParseVector(color._v, 3, true) != 3 )
             return false;
        break;
      case 2: //intensity
        if ( !textParser->ParseFloat(&intensity))
          return false;
        break;
      case 3: //ambientIntensity
        logWarnMsg(UNSUPPORTED_ATTR, wxT("ambientIntensity"));
        textParser->GetWxString();
        break;
      case 4: //on
        logWarnMsg(UNSUPPORTED_ATTR, wxT("on"));
        textParser->GetWxString();
        break;
      default: LOGERROR(wxT("Failed parsing DirectionalLight"));
               return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
    }
  }
  textParser->GetChar(" \t\n\r,");
  light->type = Light::DIRECTIONAL;
  color._v[3] = intensity;
  light->diffuse = color;
  light->direction = direction;
  return true;
}

bool VRMLParser::ElevationGrid	(	const wxString &	parentUid,
		GeometryTriangles *	geometry,
		bool	just_define
	)			[private]

the method to parse ElevationGrid node

Parameters:

[in]	parentUid	uid of a parent used in VRUT scene
[in]	geometry	geometry VRUT node to modify
[in]	just_define	indicates if it is hidden in a Switch

Returns:

if the parsing was successful

Definition at line 765 of file vrmlparser.cpp.

                                                                                                       {
       if ( textParser->GetChar(" \t\n\r,")!='{') return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));

       static const char *keywords[]={"color", "normal", "texCoord", "height", "ccw", "colorPerVertex", "creaseAngle", "normalPerVertex", "solid", "xDimension", "xSpacing", "zDimension", "zSpacing", ""};

       int index;
       int xDimension=0, zDimension=0;
       float xSpacing=1, zSpacing=1;
       while ( !textParser->NextCharIs('}'," \t\n\r,") ){
              if ( textParser ->NextKeywordIs("DEF"," \t\n\r,"))
                     textParser->GetString();
              if ( textParser ->NextKeywordIs("USE"," \t\n\r,")) {
                     textParser->GetString();
                     continue;
              }
              index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
              switch(index){
         case 0: //SFNode
         case 1:
         case 2://texCoord
                {
                       if ( textParser->NextKeywordIs("USE"," \t\n\r,")){
                              std::vector<GeometryTriangles::TexCoord> *temp = dynamic_cast<std::vector<GeometryTriangles::TexCoord> * > (defNamesListV2[textParser->GetWxString()]);
                              if ( temp == NULL){
                                     LOGERROR(wxT("Unexpected USE name for TextureCoordinate"));
                                     return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
                              }
                              geometry->texCoords.insert(geometry->texCoords.end(), temp->begin(), temp->end());
                              break;
                       }
                       wxString defName = wxT("");
                       if (textParser->NextKeywordIs("DEF"," \t\n\r,")) {
                              defName = textParser->GetWxString();
                       }
                       if (!parseFArray2(&(geometry->texCoords),"TextureCoordinate","point"))
                              return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
                       if ( defName != wxT(""))
                              defNamesListV2.insert(DefNamesListV2::value_type(defName,  new std::vector<VECTOR2>(geometry->texCoords)));
                       defName = wxT("");
                       break;
                }
         case 3://height
                {
                       if (xDimension<2 || zDimension<2)
                       {
                              skip(']');
                              break;
                       }
                       if (textParser->GetChar() != '[')
                              return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
                       std::vector<VECTOR3> * verts = &(geometry->vertices);
                       //std::vector<VECTOR3> * norms = &(geometry->normals);
                       //std::vector<GeometryTriangles::TexCoord> * texs = &(geometry->texCoords);
                       std::vector<GeometryTriangles::Indice> * inds = &(geometry->indices);
                       GeometryTriangles::TriDescList *triDescList = &(geometry->triDescList);
                       size_t firstVert = verts->size();
                       //read height and prepare vertices
                       float y = 0;
                       for (int i=0; i<zDimension; i++)
                       {
                              for (int j=0; j<xDimension; j++)
                              {
                                     textParser->ParseFloat(&y, " \t\n\r,");
                                     verts->push_back(vector3(xSpacing*j, y, zSpacing*i));
                              }
                       }
                       if (textParser->GetChar(" \t\n\r,") != ']')
                              return logErrorMsg(UNEXPECTED, textParser->GetWxLine());

                       //prepare indices and tridescs
                       for (int i=1; i<zDimension; i++)
                       {
                              std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> indType((GeometryTriangles::Indice)inds->size(), GeometryTriangles::TRI_STRIP);
                              triDescList->push_back(indType);
                              inds->push_back(GeometryTriangles::Indice(firstVert+(i-1)*xDimension));
                              inds->push_back(GeometryTriangles::Indice(firstVert+(i)*xDimension));
                              for (int j=1; j<xDimension; j++)
                              {
                                     inds->push_back(GeometryTriangles::Indice(firstVert+(i-1)*xDimension+j));
                                     inds->push_back(GeometryTriangles::Indice(firstVert+i*xDimension+j));
                              }
                       }
                       break;
                }
         case 4:
         case 5:
         case 6:
         case 7:
         case 8://solid
           logWarnMsg(UNSUPPORTED_ATTR, wxT("ccw|colorPerVertex|creaseAngle|normalPerVertex|solid"));
                textParser->GetWxString();
                break;
         case 9://xDimension
                textParser->ParseInt(&xDimension);
                break;
         case 10://xSpacing
                textParser->ParseFloat(&xSpacing);
                break;
         case 11://zDimension
                textParser->ParseInt(&zDimension);
                break;
         case 12://zSpacing
                textParser->ParseFloat(&zSpacing);
                break;
         default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
              }
       }
       textParser->GetChar(" \t\n\r,");
       return true;
}

bool VRMLParser::Extrusion	(	const wxString &	parentUid,
		GeometryTriangles *	geometry
	)			[private]

the method to parse Extrusion node

Parameters:

[in]	parentUid	uid of a parent used in VRUT scene
[in]	geometry	geometry VRUT node to modify
[in]	just_define	indicates if it is hidden in a Switch

Returns:

if the parsing was successful

Definition at line 876 of file vrmlparser.cpp.

                                                                                {
  if ( !textParser->NextCharIs('{'," \t\n\r,")) {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    else textParser->GetChar();

  std::vector<VECTOR2> profil;
  std::vector<VECTOR3> spine;
  std::vector<VECTOR2> scale;
  float creaseAngle = 0;

  static const char *keywords[]={"crossSection", "spine", "scale", "orientation","beginCap","endCap","convex","ccw","solid","creaseAngle",""};
  int index;
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
       index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
       switch(index){
         case 0: if (!parseFArray2(&profil,"","",true)) {
                   std::cout << textParser->GetString() << " " << textParser->GetString()
                   << " " << textParser->GetString() << std::endl;
                   return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
                 }
                 break;
      case 1: if (!parseFArray3(&spine,"","",true)) return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
              break;
      case 2: if (!parseFArray2(&scale,"","",true)) return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
              break;
      case 3: skip(']'); break;
      case 4:
      case 5:
      case 6:
      case 7:
      case 8: logWarnMsg(UNSUPPORTED_ATTR, wxT("beginCap|endCap|convex|ccw|solid"));
              textParser->GetWxString();
              break;
      case 9: textParser->ParseFloat(&creaseAngle);
              break;
      default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
       }
  }
  if ( profil.empty()){
    profil.push_back(VECTOR2(1,1));
    profil.push_back(VECTOR2(1,-1));
    profil.push_back(VECTOR2(-1,-1));
    profil.push_back(VECTOR2(-1,1));
    profil.push_back(VECTOR2(1,1));
  }
  if ( spine.empty()){
    spine.push_back(VECTOR3(0,0,0));
    spine.push_back(VECTOR3(0,1,0));
  }
  if ( scale.empty())
    scale.push_back(VECTOR2(1,1));

  size_t i,j;
  geometry->triDescList.push_back(std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> ((GeometryTriangles::Indice)( 0),GeometryTriangles::QUADS));
  std::vector<VECTOR3> * coord = new std::vector<VECTOR3>; //list of vertices
  std::vector<GeometryTriangles::Indice> * c = new std::vector<GeometryTriangles::Indice>; //list of coord indexes

  for ( i = 0; i < spine.size()-1; i++){
    for ( j=0; j < profil.size()-1; j++){
      if ( scale.size() < i)
        coord->push_back(VECTOR3(profil[j]._v[0],spine[i]._v[1], profil[j]._v[1]));
      else
        coord->push_back(VECTOR3(profil[j]._v[0]*scale[i]._v[0],spine[i]._v[1], profil[j]._v[1]*scale[i]._v[1]));

      c->push_back(GeometryTriangles::Indice(i*profil.size()+j));
      c->push_back(GeometryTriangles::Indice(i*profil.size()+j+1));
      c->push_back(GeometryTriangles::Indice(i*profil.size()+j+1+profil.size()));
      c->push_back(GeometryTriangles::Indice(i*profil.size()+j+profil.size()));
    }
    if (scale.size() < i)
      coord->push_back(VECTOR3(profil[j]._v[0],spine[i]._v[1], profil[j]._v[1]));
    else
      coord->push_back(VECTOR3(profil[j]._v[0]*scale[i]._v[0],spine[i]._v[1], profil[j]._v[1]*scale[i]._v[1]));
  }

  for ( j=0; j < profil.size(); j++)
    coord->push_back(VECTOR3(profil[j]._v[0],spine[i]._v[1], profil[j]._v[1]));

  if (creaseAngle > 0){ //method for smooth normal needs unique vertices
    for ( i = 0; i < c->size(); i++){
      geometry->vertices.push_back((*coord)[(*c)[i]]);
      geometry->indices.push_back(GeometryTriangles::Indice(i));
    }
    computeNormals(geometry, creaseAngle);
  } else {
    geometry->vertices.assign(coord->begin(), coord->end());
    geometry->indices.assign(c->begin(), c->end());
  }

  delete c; delete coord;

  return true;
}

bool VRMLParser::Group	(	const wxString &	parentUid,
		bool	just_define
	)			[private]

the method to parse Group node - it only imports its children

Parameters:

[in]	parentUid	uid of a parent used in VRUT scene
[in]	just_define	indicates if it is hidden in a Switch

Returns:

if the parsing was successful

Definition at line 969 of file vrmlparser.cpp.

                                                                  {
  if ( !textParser->NextCharIs('{'," \t\n\r,")) {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    else textParser->GetChar();

  static const char *keywords[]={"bboxCenter", "bboxSize", "children", ""};
  int index;
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
       index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
    if ( textParser ->NextKeywordIs("DEF"," \t\n\r,"))
      textParser->GetString();
    if ( textParser ->NextKeywordIs("USE"," \t\n\r,") ){
      textParser->GetString();
      continue;
    }
       switch(index){
       case 0:
       case 1:  //float float float
         logWarnMsg(UNSUPPORTED_ATTR, wxT("bboxCenter|bboxSize"));
              textParser->GetWxString();
              textParser->GetWxString();
              textParser->GetWxString();
              break;
       case 2: // [] MFNode
              {
                     static const char *k[] = {"]",""};
                     if ( textParser->NextCharIs('[')){
          textParser->GetWxString(); //[
          while ( index = textParser->KeywordsSwitch(k," \t\n\r,", " \t\n\r,{}[]") != 0){
            if ( !node(parentUid, just_define)) return false;
          }
                     } else
                       if ( !node(parentUid, just_define)) return false;
                     break;
              }
       default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
       }
  }
  textParser->GetChar(" \t\n\r,");
  return true;
}

bool VRMLParser::IndexedFaceSet	(	const wxString &	parentUid,
		GeometryTriangles *	geometry
	)			[private]

the method to parse IndexedFaceSet node

Parameters:

[in]	parentUid	uid of a parent used in VRUT scene
[in]	geometry	geometry VRUT node to modify

Returns:

if the parsing was successful

Definition at line 1266 of file vrmlparser.cpp.

                                                                                       {
  if ( !textParser->NextCharIs('{'," \t\n\r,")) {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    else textParser->GetChar(" \t\n\r,");

  static const char *keywords[]={"color", "normal", "coord", "texCoord", "ccw",  "colorPerVertex", "convex", "creaseAngle", "normalPerVertex", "solid", "colorIndex", "coordIndex", "normalIndex", "texCoordIndex", ""};

  std::vector<VECTOR3> * norms = NULL; //list of normals
  std::vector<GeometryTriangles::Indice> * n = NULL; //normals' index

  std::vector<GeometryTriangles::TexCoord> * texs = NULL; //list of texture coordinate
  std::vector<GeometryTriangles::Indice> * t = NULL; //list of textrue index
  typedef  std::vector<GeometryTriangles::TexCoord> TexCoord;

  std::vector<VECTOR3> * coord = NULL; //list of vertices
  std::vector<GeometryTriangles::Indice> * c = NULL; //list of coord indexes

  wxString defName = wxT("");
  float creaseAngle = 0;

  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
    int index = textParser->KeywordsSwitch(keywords," \t\n\r,", " \t\n\r,{}[]");
    switch(index){
      case 0: { //color - SFNode
         logWarnMsg(UNSUPPORTED_ATTR, wxT("color"));
         if ( textParser->NextKeywordIs("USE"," \t\n\r,")){
           textParser->GetWxString();
           break;
         }
         if ( textParser->NextKeywordIs("NULL"," \t\n\r,")) break;
         skip('}');
         break;
         }
      case 1: {//normal
         if ( textParser->NextKeywordIs("USE"," \t\n\r,")){
           std::vector<VECTOR3>* temp = dynamic_cast<std::vector<VECTOR3> *>(defNamesListV3[textParser->GetWxString()]);
           if ( temp == NULL){
             LOGERROR(wxT("Unexpected USE name"));
             return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
           }
           norms = new std::vector<VECTOR3>(*temp);
           break;
         }
         norms = new std::vector<VECTOR3>();
         if ( textParser->NextKeywordIs("DEF"," \t\n\r,")){
           defName = textParser->GetWxString();
         }
         if (!parseFArray3(norms, "Normal", "vector") ) {
           if (!parseFArray3(norms,"Coordinate", "point")) {
             return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
             delete norms;
           }
         }
         if ( defName != wxT(""))
           defNamesListV3.insert(DefNamesListV3::value_type(defName,  new std::vector<VECTOR3>(*norms)));
           defName = wxT("");
         break;
         }
      case 2: { //coord = MFVec3f ... point [ vertices ]
         if ( textParser->NextKeywordIs("USE"," \t\n\r,")){
           std::vector<VECTOR3> * geom = dynamic_cast<std::vector<VECTOR3> *>(defNamesListV3[textParser->GetWxString()]);
           if ( geom == NULL){
             LOGERROR(wxT("Unexpected USE name for Coordinate"));
             return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
           }
           coord = new std::vector<VECTOR3>(*geom);
           break;
         }
         coord = new std::vector<VECTOR3>();
         if ( textParser->NextKeywordIs("DEF"," \t\n\r,")){
           defName = textParser->GetWxString();
           //make a copy but safe it after the information will be updated
         }
         if (!parseFArray3(coord, "Coordinate", "point"))
           return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
         if ( defName != wxT(""))
           defNamesListV3.insert(DefNamesListV3::value_type(defName,  new std::vector<VECTOR3>(*coord)));
           defName = wxT("");
         break;
         }
      case 3: {//texCoord
         if ( textParser->NextKeywordIs("USE"," \t\n\r,")){
           TexCoord* temp = dynamic_cast<std::vector<GeometryTriangles::TexCoord> * > (defNamesListV2[textParser->GetWxString()]);
           if ( temp == NULL){
             LOGERROR(wxT("Unexpected USE name for TextureCoordinate"));
             return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
           }
           texs = new std::vector<GeometryTriangles::TexCoord>(*temp);
           break;
         }
         texs = new std::vector<GeometryTriangles::TexCoord>();
         if (textParser->NextKeywordIs("DEF"," \t\n\r,")) {
           defName = textParser->GetWxString();
         }
         if (!parseFArray2(texs,"TextureCoordinate","point"))
           return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
         if ( defName != wxT("")) {
           defNamesListV2.insert(DefNamesListV2::value_type(defName,  new std::vector<VECTOR2>(*texs)));
           defName = wxT("");
         }
         break;
      }
      case 4: //ccw bool | float
      case 5: //colorPerVertex
      case 6: //convex
         logWarnMsg(UNSUPPORTED_ATTR, wxT("ccw|colorPerVertex|convex"));
         textParser->GetWxString();
         break;
      case 7: //creaseAngle
         textParser->ParseFloat(&creaseAngle);
         break;
      case 8: //normalPerVertex
      case 9: //solid
         logWarnMsg(UNSUPPORTED_ATTR, wxT("solid|normalPerVertex"));
         textParser->GetWxString();
         break;
      case 10: //colorIndex
         logWarnMsg(UNSUPPORTED_ATTR, wxT("colorIndex"));
         skip(']');
         break;
      case 11: { //coordIndex - MFInt32
         if ( textParser->GetChar(" \t\n\r,") != '[') { return logErrorMsg(UNEXPECTED, textParser->GetWxLine());}
         textParser->SkipChars(" \t\n\r,");
         if ( textParser->NextCharIs(']'," \t\n\r,",false)) {
           textParser->GetChar(" \t\n\r,");
           break;
         }

         c = new std::vector<GeometryTriangles::Indice>;
         GeometryTriangles::PRIMITIVE_TYPE type = GeometryTriangles::TRI_LIST;
              size_t count = 0;
              size_t count_exp = 0;

         while ( !textParser->NextCharIs(']'," \t\n\r,",false) ){

           if (!parseIndices(c,count,count_exp )) {
             LOGERROR(wxT("Failde parsing coordIndex"));
             return false;
           }

           switch( count) {
            case 0:
            case 1: fromVRUT = true;
                    while (count == 1 || count == 0 ){
                      if (textParser->NextCharIs(']'," \t\n\r,")) break;
                      if ( count == 0 ) type = GeometryTriangles::TRI_STRIP;
                      else type = GeometryTriangles::TRI_FAN;
                      geometry->triDescList.push_back(std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> ((GeometryTriangles::Indice)(c->size()),type));
                      if (!parseIndicesTSL(c,count,count_exp)) {
                        LOGERROR(wxT("Failed parsing coordIndex - TRI_STRIP| TRI_FAN"));
                        return false;
                      }
                    }
                    break;

            case 2: type = GeometryTriangles::TRI_LIST;
                    geometry->triDescList.push_back(std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> ((GeometryTriangles::Indice)(c->size()),type));
                    count_exp = 3; break;
            case 3: type = GeometryTriangles::TRI_LIST;
                    geometry->triDescList.push_back(std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> ((GeometryTriangles::Indice)(c->size()-count),type));
                    count_exp = 3; break;
            case 4: type = GeometryTriangles::QUADS; count_exp = count;
                    geometry->triDescList.push_back(std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> ((GeometryTriangles::Indice)(c->size()-count),type));
                    break;
            default: type = GeometryTriangles::POLYGON; count_exp = 0;
                     geometry->triDescList.push_back(std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> ((GeometryTriangles::Indice)(c->size()-count),type));

           }

           textParser->SkipChars(" \t\n\r,");
         }
         textParser->GetChar(" \t\n\r,"); //]
         break;
         }
      case 12: {//normalIndex
        if ( textParser->GetChar(" \t\n\r,") != '[')
          return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
        if ( textParser->NextCharIs(']'," \t\n\r,")) { textParser->GetChar(); break;}

        n = new std::vector<GeometryTriangles::Indice>();
        int v;
        while ( !textParser->NextCharIs(']'," \t\n\r,") ){
         if (!textParser->ParseInt(&v, " \t\n\r,"))
           return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
         n->push_back(v);
         textParser->NextKeywordIs("-1", " \t\n\r,"); //skip
        }

        textParser->GetChar(" \t\n\r,"); //]
        break;
        }
      case 13: {//texCoordIndex
        if ( textParser->GetChar(" \t\n\r,") != '[')
          return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
        if ( textParser->NextCharIs(']'," \t\n\r,")) { textParser->GetChar(" \t\n\r,"); break;}

        t = new std::vector<GeometryTriangles::Indice>();
        int v;
        while ( !textParser->NextCharIs(']'," \t\n\r,") ){
         if (!textParser->ParseInt(&v, " \t\n\r,]"))
           return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
         t->push_back(v);
         if ( textParser->NextCharIs(']'," \t\n\r,")) break;
         textParser->NextKeywordIs("-1", " \t\n\r,]"); //skip
        }

        textParser->GetChar(" \t\n\r,"); //]
        break;
        }
      default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
    }
  }
  textParser->GetChar(" \t\n\r,");
  if (!fromVRUT){
  if ( coord != NULL && c == NULL){
    geometry->vertices.assign(coord->begin(), coord->end());
    GeometryTriangles::Indice counter = 0;
    for ( std::vector<VECTOR3>::iterator it = coord->begin(); it != coord->end(); it++)
      geometry->indices.push_back( counter++);
    c = new std::vector<GeometryTriangles::Indice>(geometry->indices);
  }
  if ( coord != NULL && c != NULL){
    //copy vertices according to indices (maybe one vertex has more normals)
    GeometryTriangles::Indice counter = 0;
    for ( std::vector<GeometryTriangles::Indice>::iterator it = c->begin(); it != c->end(); it++){
      if ( *it > coord->max_size()){
        LOGERROR(wxT("index out of bounds ") + wxString::Format(wxT("%i"), *it));
        return false;
      }
      geometry->vertices.push_back( (*coord)[(size_t)(*it)] );
      geometry->indices.push_back( counter++);
    }
  }
  size_t counter;
  if ( texs != NULL && t == NULL && c != NULL){
    // copy UVs according to indices, it doesn't have any explicit mapping
    for ( std::vector<GeometryTriangles::Indice>::iterator it = c->begin(); it != c->end(); it++){
      if ( *it > texs->max_size()){
        LOGERROR(wxT("texture index out of bounds " ) + wxString::Format(wxT("%i"), *it));
        return false;
      }
      geometry->texCoords.push_back((*texs)[(size_t)(*it)]);
    }
  }
  if ( texs != NULL && t != NULL && coord != NULL){
    //copy UV according to indices
    counter = 0;
    for ( std::vector<GeometryTriangles::Indice>::iterator it = t->begin(); it != t->end(); it++){
      if ( *it > texs->max_size()){
        LOGERROR(wxT("UV index out of bounds " ) + wxString::Format(wxT("%i"), *it));
        return false;
      }
      geometry->texCoords.push_back((*texs)[(size_t)(*it)]);
    }
  }
  if ( norms != NULL && n != NULL && coord != NULL){
    //copy normals according to indices
    counter = 0;
    for ( std::vector<GeometryTriangles::Indice>::iterator it = n->begin(); it != n->end(); it++){
      if ( *it > norms->max_size()){
        LOGERROR(wxT("normal index out of bounds " ) + wxString::Format(wxT("%i"), *it));
        return false;
      }
      geometry->normals.push_back((*norms)[(size_t)(*it)]);
    }
  }
  }else {
     if ( coord != NULL) geometry->vertices.assign(coord->begin(), coord->end());
     if ( c != NULL) geometry->indices.assign(c->begin(), c->end());
     if ( texs!= NULL) geometry->texCoords.assign(texs->begin(), texs->end());
     if ( norms!=NULL)
       geometry->normals.assign(norms->begin(), norms->end());

  }
  // generate smooth auto normals
  if ( creaseAngle > 0.0001 && norms == NULL)
    computeNormals(geometry, creaseAngle);
  SAFE_DELETE(norms);
  SAFE_DELETE(n);
  SAFE_DELETE(texs);
  SAFE_DELETE(t);
  SAFE_DELETE(coord);
  SAFE_DELETE(c);
  return true;
}

bool VRMLParser::IndexedLineSet	(	const wxString &	parentUid,
		GeometryTriangles *	geometry
	)			[private]

the method to parse IndexedLineSet node

Parameters:

[in]	parentUid	uid of a parent used in VRUT scene
[in]	geometry	geometry VRUT node to modify

Returns:

if the parsing was successful

Definition at line 1551 of file vrmlparser.cpp.

                                                                                     {
  if ( !textParser->NextCharIs('{'," \t\n\r,")) {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    else textParser->GetChar(" \t\n\r,");

  static const char *keywords[]={ "color", "coord", "colorPerVertex", "colorIndex", "coordIndex", "" };
  std::vector<VECTOR3> * verts = &(geometry->vertices);
  std::vector<GeometryTriangles::Indice> * indices = &(geometry->indices);

  wxString defName = wxT("");
  int index;
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
    index = textParser->KeywordsSwitch(keywords, " \t\n\r", " \t\n\r,{}[]");
    switch(index){
      case 0: //color //SFNode
         logWarnMsg(UNSUPPORTED_ATTR, wxT("color"));
         if ( textParser->NextKeywordIs("USE"," \t\n\r,")){
           textParser->GetWxString();
           break;
         }
         skip('}');
         break;
      case 1: {//coord
         if ( textParser->NextKeywordIs("USE"," \t\n\r,")){
           std::vector<VECTOR3> * geom = dynamic_cast<std::vector<VECTOR3> *>(defNamesListV3[textParser->GetWxString()]);
           if ( geom == NULL){
             LOGERROR(wxT("Unexpected USE name"));
             return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
           }
           verts->assign(geom->begin(), geom->end());
           break;
         }
         if ( textParser->NextKeywordIs("DEF"," \t\n\r,")){
           defName = textParser->GetWxString();
           //make a copy but safe it after the information will be updated
         }
         if (!parseFArray3(verts, "Coordinate", "point")) {
           LOGERROR(wxT("Failed parsing coordinate"));
           return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
         }
         if ( defName != wxT(""))
           defNamesListV3.insert(DefNamesListV3::value_type(defName,  new std::vector<VECTOR3>(geometry->vertices)));
         break;
         }
      case 2: //colorPerVertex - bool
         logWarnMsg(UNSUPPORTED_ATTR, wxT("colorPerVertex"));
         textParser->GetWxString();
         break;
      case 3: //colorIndex
         logWarnMsg(UNSUPPORTED_ATTR, wxT("colorIndex"));
         skip(']');
         break;
      case 4: {//coordIndex
         if ( textParser->GetChar(" \t\n\r,") != '[') { return logErrorMsg(UNEXPECTED, textParser->GetWxLine());}
         if ( textParser->NextCharIs(']'," \t\n\r,")) {
           textParser->GetChar(" \t\n\r,");
           break;
         }

         GeometryTriangles::PRIMITIVE_TYPE type;
            size_t count = 0;
         long v;
         while ( !textParser->NextCharIs(']'," \t\n\r,") ){
            while (  !textParser->NextKeywordIs("-1"," \t\n\r,") ) {
                    if (!textParser->ParseLong(&v," \t\n\r,") || v < 0 ) {
                      LOGERROR(wxT("Failed parsing indexes"));
                      return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
                    }
              indices->push_back((GeometryTriangles::Indice)v);
              count++;
            }
            if (count == 2) type = GeometryTriangles::LINES;
            else type = GeometryTriangles::LINE_STRIP;
            geometry->triDescList.push_back(std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> ((GeometryTriangles::Indice)(indices->size()-count),type));
            count = 0;
         }

         textParser->GetChar(" \t\n\r,"); //]
         break;
         }

      default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
    }
  }
  textParser->GetChar(" \t\n\r,");
  return true;
}

bool VRMLParser::Inline

(

const wxString &

parentUid

)

[private]

the method to parse Inline node - can handle gzip files

Parameters:

[in]

parentUid

uid of a parent used in VRUT scene

Returns:

if the parsing was successful

Definition at line 1638 of file vrmlparser.cpp.

                                                 {
  if (textParser->GetChar(" \t\n\r,")!= '{' ) return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));
  static const char *keywords[] = {"url", "bboxSize", "bboxCenter", ""};
  int index;
  bool ret = true;

  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
       index = textParser->KeywordsSwitch(keywords, " \t\n\r", " \t\n\r,{}[]");
       switch(index){
       case 0:{ //url
               wxInputStream * is;
            if ( textParser->NextCharIs('['," \t\n\r,")) {
              textParser->GetChar();
              //TODO more files can be specified
              while ( !textParser->NextCharIs(']'," \t\n\r,")){}
            }else {
              wxString fname = scenePath+textParser->GetWxString(" \t\n\r,");
              is = new wxFileInputStream(wxFileName(fname).GetFullPath());

              if (is)       {
                    //is gzip file?
              unsigned char buffer[2];
                   is -> Read(buffer, sizeof(unsigned char)*2);
                   if ( buffer[0] == 31 && buffer[1] == 139){
                 wxFileName wxFname(fname);
                 delete is;
                 is = new wxFileInputStream(wxFname.GetFullPath());
                 is = new wxZlibInputStream(is,wxZLIB_GZIP);
                 VRMLParser vrmlParser2(is, sceneID, fname, module);
                           ret = vrmlParser2.Parse(parentUid, true, &nodeUidsList);
                           nodeUidsList = NodeUidsList(vrmlParser2.getNodeUidsList());
                           delete is;
               }
                   else {
                     is -> Ungetch(buffer,  sizeof(unsigned char)*2);
                VRMLParser vrmlParser(is, sceneID, fname, module);
                ret = vrmlParser.Parse(parentUid, true, &nodeUidsList);
                nodeUidsList = NodeUidsList(vrmlParser.getNodeUidsList());
                          delete is;
              }
                  } else {
                LOGERROR(wxT("<VRMLParser>File not found")+fname);
                return false;
             }

             if ( !ret) {
                LOGERROR(wxT("<VRMLParser>Failed parsing inline file ")+fname);
                return false;
             }
             break;
            }
         }
    case 1:
    case 2: logWarnMsg(UNSUPPORTED_ATTR, wxT("bboxSize|bboxCenter"));
            textParser->GetWxString();
            textParser->GetWxString();
            textParser->GetWxString();
            break;
    default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
       }
  }
  textParser->GetChar(" \t\n\r,"); //}
  return true;
}

bool VRMLParser::ImageTexture

(

VRUT::Material *

material

)

[private]

the method to parse ImageTexture node

Parameters:

[in]

material

material VRUT node to modify

Returns:

if the parsing was successful

Definition at line 1703 of file vrmlparser.cpp.

                                                    {
  if ( !textParser->NextCharIs('{'," \t\n\r,")) {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    else textParser->GetChar(" \t\n\r,");

  static const char *keywords[]={"url", "repeatS", "repeatT", ""};
  int index;
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
       index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
       switch(index){
       case 0:{ //MFString []
               if ( textParser->NextCharIs('['," \t\n\r,")){
              textParser->GetChar(" \t\n\r,"); //[
              while ( !textParser->NextCharIs(']')){ //TODO: && till the path is valid
                wxString texPath = scenePath + textParser->GetWxString();
                         wxCommandEvent texEvt = Event::GET_EVT_SCENE_IMAGE_ADD(texPath);
                         module->PostToKernel(texEvt);
                         material->imageName = texPath;
              }
              textParser->GetChar(" \t\n\r,"); //]
               }
               else {
                 //std::cout << (const char*)scenePath.mb_str(wxConvUTF8) << std::endl;
              wxString texPath = scenePath + textParser->GetWxString();
              //std::cout <<  (const char*)texPath.mb_str(wxConvUTF8) << std::endl;
                       wxCommandEvent texEvt = Event::GET_EVT_SCENE_IMAGE_ADD(texPath);
                       module->PostToKernel(texEvt);
                       material->imageName = texPath;
               }
                     }
              break;
       case 1: //repeatS
          if ( textParser->NextKeywordIs("TRUE"," \t\n\r,")){
         material->texFlags |= ( Material::TEX_UWRAP_REPEAT );
          }
       else {
         textParser->GetWxString();
         material->texFlags |= ( Material::TEX_UWRAP_CLAMP );
       }
       break;
       case 2: //repeatT
          if ( textParser->NextKeywordIs("TRUE"," \t\n\r,")){
         material->texFlags |= ( Material::TEX_VWRAP_REPEAT );
          }
       else {
         textParser->GetWxString();
         material->texFlags |= ( Material::TEX_VWRAP_CLAMP );
       }
       break;
       default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
       }
  }
  //material could have some transparent texture
  material->texBlendSrc = GL_SRC_ALPHA ;
  material->texBlendDst = GL_ONE_MINUS_SRC_ALPHA ;
//  material->texFlags |= Material::TEX_ENV_BLEND;
  material->flags |= Material::BLENDED ;

  textParser->GetChar(" \t\n\r,");
  return true;
}

bool VRMLParser::LOD	(	const wxString &	parentUid,
		bool	just_define
	)			[private]

the method to parse LOD node - it only imports all its children from all levels

Parameters:

[in]	parentUid	uid of a parent used in VRUT scene
[in]	geometry	geometry VRUT node to modify

Returns:

if the parsing was successful

Definition at line 1765 of file vrmlparser.cpp.

                                                                 {
  if ( !textParser->NextCharIs('{'," \t\n\r,")) {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    else textParser->GetChar();

       static const char *keywords[]={"center", "range", "level", ""};
  int index;
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
       index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
       switch(index){
       case 0:  //float float float
         logWarnMsg(UNSUPPORTED_ATTR, wxT("center"));
              textParser->GetWxString();
              textParser->GetWxString();
              textParser->GetWxString();
              break;
       case 1: //MFFloat
         logWarnMsg(UNSUPPORTED_ATTR, wxT("range"));
              skip(']');
              break;
       case 2: // [] MFNode
              {
                     static const char *k[] = {"]",""};
                     textParser->GetWxString(); //[
                     while ( index = textParser->KeywordsSwitch(k," \t\n\r,", " \t\n\r,{}[]") != 0){
                            if ( !node(parentUid, just_define)) return false;
                     }
                     break;
              }
       default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
       }
  }
  textParser->GetChar(" \t\n\r,");
  return true;
}

bool VRMLParser::Material

(

VRUT::Material *

material

)

[private]

the method to parse Material node

Parameters:

[in]

material

material VRUT node to modify

Returns:

if the parsing was successful

Definition at line 1800 of file vrmlparser.cpp.

                                                {
  if ( textParser->GetChar(" \t\n\r,") != '{') {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}

  static const char *keywords[]={ "diffuseColor", "emissiveColor", "specularColor", "ambientIntensity", "shininess", "transparency",  ""};

  VECTOR4 diffuse(0.8,0.8,0.8,1); //last one is transparency
  VECTOR4 emissive(0,0,0);
  VECTOR4 specular(0,0,0);
  float ambIntensity = 0.2;
  float shininess = 0.2;

  int index;
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
    index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");

    switch(index){
      case 0: //diffuseColor
          if (textParser->ParseVector(diffuse._v, 3, true) != 3)
                              return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
          break;
      case 1: //emissiveColor
          if (textParser->ParseVector(emissive._v, 3, true) != 3)
                              return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
          break;
      case 2: //spcularColor
          if (textParser->ParseVector(specular._v, 3, true) != 3)
                              return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
          break;
      case 3: //ambientIntensity - světlost povrchu získaná odrazem od okolního světla, tedy bez ohledu na úhel dopadu světla na povrch
                       if (!textParser->ParseFloat(&ambIntensity))
                            return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
          break;
      case 4: //shininess
                       if (!textParser->ParseFloat(&shininess))
                              return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
          break;
      case 5:  //transparency
          float temp;
          //here must be temp because following statement doesn't work!
          //material->diffuse.w = 1 - material->diffuse.w
                       if (textParser->ParseFloat(&temp)){
                         material->diffuse.w = 1 - temp;
          } else
                            return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
          material->texBlendSrc = GL_SRC_ALPHA;
          material->texBlendDst = GL_ONE_MINUS_SRC_ALPHA;
                       material->flags |= Material::BLENDED;
          break;
      default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
    }
  }
  material->diffuse = diffuse;
  material->emission = emissive;
  material->specular = specular;
  material->ambient.w = ambIntensity;
  material->shininess = shininess;
  textParser->GetChar(" \t\n\r,");
  return true;
}

bool VRMLParser::PointLight

(

Light *

light

)

[private]

the method to parse PointLight node

Parameters:

[in]

light

light VRUT node to modify

Returns:

if the parsing was successful

Definition at line 1860 of file vrmlparser.cpp.

                                       {
  if ( !textParser->NextCharIs('{'," \t\n\r,")) {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    else textParser->GetChar();

  static const char *keywords[]={"location", "attenuation", "radius", "intensity", "ambientIntensity","color", "on",""};
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
    int index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
    switch(index){
      case 0: //SFVec3f //location
        if ( textParser->ParseVector(light->position._v,3,true) != 3)
          return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
        break;
      case 1: //attenuation
        logWarnMsg(UNSUPPORTED_ATTR, wxT("attenuation"));
        textParser->GetWxString();
        textParser->GetWxString();
        textParser->GetWxString();
        break;
      case 2: //SFFloat radius
      case 3: //intensity
      case 4: //ambientIntensity
        logWarnMsg(UNSUPPORTED_ATTR, wxT("radius|intensity|ambientIntensity"));
        textParser->GetWxString();
        break;
      case 5: //SFColor color
        if (textParser->ParseVector(light->diffuse._v, 3,true) != 3)
                    return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
        break;
      case 6: //SFBool on
        logWarnMsg(UNSUPPORTED_ATTR, wxT("on"));
        textParser->GetWxString();
        break;
      default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
    }
  }
  light->type = Light::SPOTLIGHT;
  light->angle = 180; //PointLight
  light->exponent = 1;
  textParser->GetChar(" \t\n\r,");
  return true;
}

bool VRMLParser::PointSet	(	const wxString &	parentUid,
		GeometryTriangles *	geometry
	)			[private]

the method to parse PointSet node

Parameters:

[in]	parentUid	uid of a parent used in VRUT scene
[in]	geometry	goemetry VRUT node to modify

Returns:

if the parsing was successful

Definition at line 1902 of file vrmlparser.cpp.

                                                                                {
  if ( !textParser->NextCharIs('{'," \t\n\r,")) {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    else textParser->GetChar();

  std::vector<VECTOR3> * verts = &(geometry->vertices);

  wxString defName = wxT("");
  static const char *keywords[]={"color", "coord", ""};
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){

    int index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
    switch(index){
      case 0: //SFNode
             logWarnMsg(UNSUPPORTED_ATTR, wxT("color"));
             if ( textParser->NextKeywordIs("USE"," \t\n\r,")){
               textParser->GetWxString();
               break;
             }
             skip('}');
             break;
      case 1: {//coord
         if ( textParser->NextKeywordIs("USE"," \t\n\r,")){
           std::vector<VECTOR3> * geom = dynamic_cast<std::vector<VECTOR3> *>(defNamesListV3[textParser->GetWxString()]);
           if ( geom == NULL){
             LOGERROR(wxT("Unexpected USE name"));
             return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
           }
           verts->assign(geom->begin(), geom->end());
           break;
         }
         if ( textParser->NextKeywordIs("DEF"," \t\n\r,")){
           defName = textParser->GetWxString();
         }
         if (!parseFArray3(verts, "Coordinate", "point")) {
           LOGERROR(wxT("Failed parsing coordinate"));
           return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
         }
         if ( defName != wxT(""))
           defNamesListV3.insert(DefNamesListV3::value_type(defName,  new std::vector<VECTOR3>(geometry->vertices)));
         break;
         }
      default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
    }
  }
  GeometryTriangles::Indice counter = 0;
  for ( std::vector<VECTOR3>::iterator it = verts->begin(); it != verts->end(); it++)
    geometry->indices.push_back(counter++);
  if ( verts->size() != 0 )
    geometry->triDescList.push_back(std::pair<GeometryTriangles::Indice, GeometryTriangles::PRIMITIVE_TYPE> ((GeometryTriangles::Indice)(0),GeometryTriangles::POINTS));
  textParser->GetChar(" \t\n\r,");
  return true;
}

bool VRMLParser::Shape	(	const wxString &	nodeUid,
		bool	just_define,
		GNode *	gnode = NULL
	)			[private]

the method to parse Shape node

Parameters:

[in]	nodeUid	uid of a node used in VRUT scene
[in]	geometry	goemetry VRUT node to modify
[in]	just_define	indicates if it is hidden in a Switch

Returns:

if the parsing was successful

Transformation has following order: 1) translation 2) rotation according to center 3) scale according to center

Definition at line 1955 of file vrmlparser.cpp.

                                                                                {
  if ( textParser->GetChar(" \t\n\r,") != '{') {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}

  static const char *keywords[]={"appearance", "geometry", ""};
  static const char *keywords_g[]={"Box","Cone","Cylinder","Sphere", "ElevationGrid", "Extrusion", "Text", "IndexedFaceSet", "IndexedLineSet", "PointSet", ""};

  int index;
  wxString defName;

  //variables for textureTransform
  VECTOR2 translation = VECTOR2(0,0);
  float rotation = 0;
  VECTOR2 scale = VECTOR2(1,1);
  VECTOR2 center = VECTOR2(0,0);

  GeometryTriangles *geometry = NULL;
  wxString g_name;

  while ( !textParser->NextCharIs('}'," \t\n\r,") )
  {
    defName = wxT("");
    index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
    switch(index)
    {
      case 0: //Appearance
            {
              if ( textParser -> NextKeywordIs("USE"," \t\n\r,")){
                wxString useName = textParser->GetWxString();
                DefNamesListM::iterator it = defNamesListM.find(useName);
                if ( it != defNamesListM.end()){
                  VRUT::Material* help = it->second;
                  if ( !just_define ){
                    wxCommandEvent ev1 = Event::GET_EVT_SCENE_NODE_MATERIAL_SET(sceneID, nodeUid, help->name);
                    module->PostToKernel(ev1);
                  }
                  else
                    if (gnode!= NULL) gnode->setMaterial(NULL, help->name, useName);
                  break;
                }
                else
                  LOGERROR(wxT("<VRMLParser>Unexpected USE name "));
                  return false;
              }
              wxString mat_name;
              VRUT::Material* material;

              if (textParser->NextKeywordIs("DEF"," \t\n\r,") )
                defName = textParser->GetWxString();

              if ( defName != wxT(""))
                mat_name = getUniqueUid(defName);
              else  mat_name = getUniqueUid(wxString::FromAscii("material"));
              material = new VRUT::Material(mat_name);

              if (textParser->NextKeywordIs("Appearance"," \t\n\r,") && Appearance(nodeUid, material, translation, rotation, scale, center)){
                if ( !just_define ) {
                  wxCommandEvent ev = Event::GET_EVT_SCENE_MATERIAL_ADD(sceneID, material);
                  module->PostToKernel(ev);
                                 wxCommandEvent ev1 = Event::GET_EVT_SCENE_NODE_MATERIAL_SET(sceneID, nodeUid, mat_name);
                                 module->PostToKernel(ev1);
                } else {
                  if (gnode!=NULL) gnode->setMaterial(material, mat_name, defName);
                  else {
                    wxCommandEvent ev = Event::GET_EVT_SCENE_MATERIAL_ADD(sceneID, material);
                    module->PostToKernel(ev);
                  }
                }
              } else {
                     SAFE_DELETE(material);
                     LOGERROR(wxT("<VRMLParser>Failed parsing material "));
                     return false;
              }
              if ( defName != wxT(""))
                defNamesListM.insert(DefNamesListM::value_type(defName, material->Clone() ));
              break;
             }
      case 1: // Box, Cone, Cylinder, Sphere ,ElevationGrid, Extrusion, Text, IndexedFaceSet, IndexedLineSet, PointSet
             {
              if ( textParser -> NextKeywordIs("USE"," \t\n\r,")){
                wxString useName = textParser->GetWxString();
                DefNamesListG::iterator it = defNamesListG.find(useName);
                if ( it != defNamesListG.end() ){
                  if ( !just_define) {
                    wxCommandEvent ev = Event::GET_EVT_SCENE_NODE_GEOMETRY_SET(sceneID, nodeUid, it->second);
                       module->PostToKernel(ev);
                  } else
                    gnode->setGeometry(NULL, it->second, useName );
                                 break;
                }
                else
                  LOGERROR(wxT("<VRMLParser>Unexpected USE name "));
                  return false;
              }

              if (textParser->NextKeywordIs("DEF"," \t\n\r,"))
                defName = textParser->GetWxString();
              //Create new mesh
              if ( defName == wxT(""))
                g_name = getUniqueUid(wxString::FromAscii("geometry"));
              else g_name = getUniqueUid(defName);
              geometry = new GeometryTriangles(g_name);

              index = textParser->KeywordsSwitch(keywords_g, " \t\n\r,", " \t\n\r,{}[]");
              switch(index){
               case 0: //Box
                 if (!Box(geometry)) {SAFE_DELETE(geometry); return false;}
                 break;
               case 1: //Cone
               case 2: //Cylinder
               case 3: //Sphere
                 logWarnMsg(UNSUPPORTED, wxT("Cone|Cylinder|Sphere"));
                 skip('}'); //{}
                 break;
               case 4: //ElevationGrid
                 if (!ElevationGrid(nodeUid, geometry, just_define))
                   {SAFE_DELETE(geometry); LOGERROR(wxT("<VRMLParser>Failed parsing ElevationGrid")); return false;}
                 break;
               case 5: //Extrusion
                 if (!Extrusion(nodeUid,geometry)) {SAFE_DELETE(geometry); return false;}
                 break;
               case 6: //Text
                 logWarnMsg(UNSUPPORTED, wxT("Text"));
                 skip('{');
                 skip_stack('}', '{');
                 break;
               case 7: //IndexedFaceSet
                 if (!IndexedFaceSet(nodeUid, geometry))
                   {SAFE_DELETE(geometry); LOGERROR(wxT("<VRMLParser>Failed parsing IndexedFaceSet")); return false;}
                 break;
               case 8: //IndexedLineSet
                 if (!IndexedLineSet(nodeUid, geometry))
                  {SAFE_DELETE(geometry);LOGERROR(wxT("<VRMLParser>Failed parsing IndexedLineSet")); return false;}
                 break;
               case 9: //PointSet
                 if (!PointSet(nodeUid, geometry))
                  {SAFE_DELETE(geometry); LOGERROR(wxT("<VRMLParser>Failed parsing PointSet")); return false;}
                 break;
               default:
                 LOGERROR(wxT("<VRMLParser>Failed parsing geometry of a Shape"));
                 SAFE_DELETE(geometry);
                 return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
              }
              break;
             }
      default:
       LOGERROR(wxT("<VRMLParser>Failed parsing Shape attributes"));
       return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
    }
  }
  textParser->GetChar(" \t\n\r,");
  if ( geometry != NULL) {
    if ( geometry->texCoords.size() != 0) {
      //transform UVs
      if ( translation != VECTOR2(0,0) || rotation != 0 || scale != VECTOR2(1,1)) {
        for ( std::vector<GeometryTriangles::TexCoord>::iterator it = geometry->texCoords.begin(); it != geometry->texCoords.end(); it++){
          (*it)._v[0] = (*it)._v[0] + translation._v[0];
          (*it)._v[1] = (*it)._v[1] + translation._v[1];
        }
      }
      if ( rotation != 0) {
        for ( std::vector<GeometryTriangles::TexCoord>::iterator it = geometry->texCoords.begin(); it != geometry->texCoords.end(); it++){
          (*it)._v[0] = (*it)._v[0] - center._v[0];
          (*it)._v[1] = (*it)._v[1] - center._v[1];
          (*it)._v[0] = (*it)._v[0] * cos(rotation) - (*it)._v[0] * sin(rotation);
          (*it)._v[1] = (*it)._v[1] * sin(rotation) + (*it)._v[1] * sin(rotation);
          (*it)._v[0] = (*it)._v[0] + center._v[0];
          (*it)._v[1] = (*it)._v[1] + center._v[1];
        }
      }
      if ( scale != VECTOR2(1,1)) {
        for ( std::vector<GeometryTriangles::TexCoord>::iterator it = geometry->texCoords.begin(); it != geometry->texCoords.end(); it++){
          (*it)._v[0] = (*it)._v[0] - center._v[0];
          (*it)._v[1] = (*it)._v[1] - center._v[1];
          (*it)._v[0] = (*it)._v[0] * scale._v[0];
          (*it)._v[1] = (*it)._v[1] * scale._v[1];
          (*it)._v[0] = (*it)._v[0] + center._v[0];
          (*it)._v[1] = (*it)._v[1] + center._v[1];
        }
      }
    }
  if ( !just_define) {
  //Add geometry to scene
    wxCommandEvent ev2 = Event::GET_EVT_SCENE_GEOMETRY_ADD(sceneID, geometry);
    module->PostToKernel(ev2);
   //Assign geometry to node
   wxCommandEvent ev3 = Event::GET_EVT_SCENE_NODE_GEOMETRY_SET(sceneID, nodeUid, geometry->GetName());
   module->PostToKernel(ev3);
  } else {
    if (gnode != NULL) gnode->setGeometry(geometry, geometry->GetName(), defName);
    else {
       wxCommandEvent ev2 = Event::GET_EVT_SCENE_GEOMETRY_ADD(sceneID, geometry);
       module->PostToKernel(ev2);
    }
  }
  if ( defName != wxT(""))
   defNamesListG.insert(DefNamesListG::value_type(defName, geometry->GetName() ));
  }
  return true;
}

bool VRMLParser::SpotLight

(

Light *

light

)

[private]

the method to parse SpotLight node

Parameters:

[in]

light

light VRUT node to modify

Returns:

if the parsing was successful

Definition at line 2161 of file vrmlparser.cpp.

                                      {
  if ( textParser->GetChar(" \t\n\r,") != '{') {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
  static const char *keywords[]={"location", "direction", "beamWidth","cutOffAngle",
  "radius", "attenuation", "color", "intensity", "ambientIntensity","on", ""};

  float beamWidth = 1.570796;
  light->angle = 0.785398;
  light->direction = VECTOR3(0,0,-1);
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
    int index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
    switch(index){
      case 0: //SFVec3f //location
        if ( textParser->ParseVector(light->position._v,3,true) != 3)
          return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
        break;
      case 1: // direction
        if ( textParser->ParseVector(light->direction._v,3,true) != 3 )
          return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
        break;
      case 2: // beamWidth - can't be reprezent correctly in OpenGL
        // if beamWidth > cutOffAngle than it is OK with setting exponent = 0.0
        logWarnMsg(UNSUPPORTED_ATTR, wxT("beamWidth"));
        if ( !textParser->ParseFloat(&beamWidth))
          return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
        break;
      case 3: //cutOfAngle
        if ( !textParser->ParseFloat(& (light->angle)))
          return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
        break;
      case 4: //radius
        logWarnMsg(UNSUPPORTED_ATTR, wxT("radius"));
        textParser->GetWxString();
        break;
      case 5: //attenuation
        logWarnMsg(UNSUPPORTED_ATTR, wxT("attenuation"));
        textParser->GetWxString();
        textParser->GetWxString();
        textParser->GetWxString();
        break;
      case 6: //SFColor color
        if (textParser->ParseVector(light->diffuse._v, 3,true) != 3)
                    return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
        break;
      case 7: //intensity
      case 8: //ambientIntensity
      case 9: //SFBool on
        logWarnMsg(UNSUPPORTED_ATTR, wxT("intensity|ambientIntensity|on"));
        textParser->GetWxString();
        break;
      default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
    }
  }
  light->type = Light::SPOTLIGHT;
  if ( light->angle < beamWidth)
    LOGWARNING(wxT("<VRMLParser>: The spotlight can't be translated exactly."));
  else light->exponent = 0;
  textParser->GetChar(" \t\n\r,");
  return true;
}

bool VRMLParser::Switch	(	const wxString &	parentUid,
		bool	just_define
	)			[private]

the method to parse Switch node - it only imports its children, can deal with whichChoice -1

Parameters:

[in]	parentUid	uid of a parent used in VRUT scene
[in]	just_define	indicates if it is hidden in a Switch

Returns:

if the parsing was successful

Definition at line 2222 of file vrmlparser.cpp.

                                                                {
  if ( textParser->GetChar(" \t\n\r,") != '{') {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}

  // whichChoice must be written before choice !
  static const char *keywords[]={"whichChoice", "choice",  ""};
  bool just_define = true;
  int index;
  int which = -1;
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
       index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
       switch(index){
       case 0:  //int
        if (textParser->NextKeywordIs("-1"))
          just_define = true;
        else {
          just_define = false;
                  if (!textParser->ParseInt(&which))
                    return logErrorMsg(UNEXPECTED, textParser->GetWxLine() );
        }
              break;
       case 1: // [] MFNode
              {
                if ( jd_upper ) just_define = true;
                     if ( textParser->GetChar() != '[')
                       return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("["));
        int counter = 0;
        if ( just_define) {
                       while ( !textParser->NextCharIs(']')){
                            if ( !node(parentUid, just_define)) return false;
                       }
        } else {
                       while ( !textParser->NextCharIs(']')){
                         if ( counter != which ) skip_stack('}', '{');
                         else
                                if ( !node(parentUid, just_define)) return false;
                       }
        }
        textParser->GetChar(" \t\n\r,"); //]
                     break;
              }
       default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
       }
  }
  textParser->GetChar(" \t\n\r,");
  return true;
}

bool VRMLParser::Transform	(	const wxString &	parentUid,
		bool	just_define,
		ANode *	anode = NULL
	)			[private]

the method to parse Transform node

Parameters:

[in]	parentUid	uid of a parent used in VRUT scene
[in]	just_define	indicates if it is hidden in a Switch
[in]	anode	Assembly VRUT node to modify

Returns:

if the parsing was successful

transformation has following order: 1) scale according scaleOrientation 2) rotation according point center 3) translation

Definition at line 2270 of file vrmlparser.cpp.

                                                                                    {

  if ( textParser->GetChar(" \t\n\r,") != '{') {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}

       static const char *keywords[]={"center", "rotation", "scale", "scaleOrientation", "translation", "bboxCenter", "bboxSize", "children", ""};
  VECTOR3 scale(1,1,1);
  VECTOR4 scaleOrientation(0,0,1,0);
  VECTOR3 center(0,0,0);
  VECTOR3 translation(0,0,0);
  VECTOR4 rotation(0,0,1,0);

  int index;
  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
       index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
       switch(index){
       case 0: //center
         if ( textParser->ParseVector(center._v, 3, true) != 3 )
           return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
              break;
       case 1: {//rotation
           if ( textParser->ParseVector(rotation._v, 4, true) != 4)
             return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
              break;
                     }
       case 2:{ //scale
           if (textParser->ParseVector(scale._v, 3, true) != 3)
             return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
              break;
      }
       case 3: //scaleOrientation
              { if ( textParser->ParseVector(scaleOrientation._v, 4, true) != 4)
                  return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
                     break;
              }
       case 4: //translation
              {
            if (textParser->ParseVector(translation._v, 3, true) != 3)
             return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
                     break;
              }
       case 5: //bbox center
       case 6: //bbox size - float float float
         logWarnMsg(UNSUPPORTED_ATTR, wxT("bboxCenter|bboxSize"));
              textParser->GetWxString();
              textParser->GetWxString();
              textParser->GetWxString();
              break;
       case 7: // [] MFNode
              {
                     if ( textParser->NextCharIs('['," \t\n\r,")) {
                            textParser->GetChar(" \t\n\r,"); //[
                            while ( !textParser->NextCharIs(']'," \t\n\r,") )
                                   if ( !node(parentUid, just_define)) return false;
                            textParser->GetChar(" \t\n\r,"); //]
                     } else
                            if ( !node(parentUid, just_define)) return false;
                     break;
              }
       default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
       }
  }
  textParser->GetChar(" \t\n\r,");

  //MATRIX mat = MATRIX();
    MATRIX mat =
    MATRIX::RotationAxis(VECTOR3(scaleOrientation[0],scaleOrientation[1],scaleOrientation[2]),scaleOrientation[3])
  * MATRIX::ScaleMat(scale)
  * MATRIX::RotationAxis(VECTOR3(scaleOrientation[0],scaleOrientation[1],scaleOrientation[2]),-scaleOrientation[3])
  * MATRIX::Translation(center)
  * MATRIX::RotationAxis(VECTOR3(rotation[0],rotation[1],rotation[2]),-rotation[3])
  * MATRIX::Translation(-center)
  * MATRIX::Translation(translation);

  if ( !just_define){
    wxCommandEvent ev3 = Event::GET_EVT_SCENE_NODE_TRANSFORM(sceneID, parentUid, mat);
    module->PostToKernel(ev3);

  } else {
    if (anode != NULL) {
      anode -> setParam(mat);
    }
  }
  return true;
}

bool VRMLParser::Viewpoint	(	MATRIX &	mat,
		float &	field
	)			[private]

the method to parse Viewpoint node - creates new cameras in VRUT scene

Parameters:

[out]	mat	viewing transformation matrix
[out]	field	field of view

Definition at line 2360 of file vrmlparser.cpp.

                                                    {
  if ( !textParser->NextCharIs('{'," \t\n\r,")) {return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    else textParser->GetChar(" \t\n\r,");

       static const char *keywords[]={"fieldOfView", "position", "orientation", "jump", "description", ""};
  int index;
  field = 0.785398f;
  VECTOR3 position(0,0,10);
  VECTOR4 orientation(0,0,1,0);

  while ( !textParser->NextCharIs('}'," \t\n\r,") ){
       index = textParser->KeywordsSwitch(keywords, " \t\n\r,", " \t\n\r,{}[]");
       switch(index){
      case 0: //fieldOfView
        if (!textParser->ParseFloat(&field))
          return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
        break;
      case 1: //position
             if (textParser->ParseVector(position._v, 3, true) != 3)
               return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
                break;
      case 2: //orientation
             if ( textParser->ParseVector(orientation._v, 4, true) != 4)
               return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
                break;
      case 3: //jump
        logWarnMsg(UNSUPPORTED_ATTR, wxT("jump"));
        textParser->GetWxString();
        break;
      case 4: //description
        logWarnMsg(UNSUPPORTED_ATTR, wxT("description"));
        skip('"'); skip('"');
        break;
      default: return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
       }
  }
  mat = mat * MATRIX::Translation(position);
  mat  = MATRIX::RotationAxis(VECTOR3(orientation[0],orientation[1],orientation[2]),orientation[3]) * mat;

  textParser->GetChar(" \t\n\r,"); //}

  return true;
}

void VRUT::VRMLParser::skip

(

char

z

)

[inline, private]

method to skip chars til one defined char is found

Parameters:

[in]

z

char till which all chars will be skipped

Definition at line 438 of file vrmlparser.h.

                            {
     while ( textParser->GetChar("") != z) { }
     return;
    }

bool VRUT::VRMLParser::skip_stack	(	char	z,
		char	inv_z
	)			[inline, private]

method to skip chars, usefull to skip expression with brackets

Parameters:

[in]	z	left opennign bracket
[in]	inv_z	right closing bracket

Definition at line 445 of file vrmlparser.h.

                                              {
      int count = 1;
      char p;
      while ( count ) {
        p = textParser->GetChar("");
        if ( p == z) count--;
        if ( p == inv_z) count++;
        if ( textParser->IsEmpty() ) return false;
      }
      return true;
    }

bool VRMLParser::parseFArray3	(	std::vector< VECTOR3 > *	array,
		const char *	VRMLnode,
		const char *	VRMLfield,
		bool	skip = false
	)			[private]

method to parse arrays of 3D float numbers, skippes VRMLnode name and VRMLfield name

Parameters:

[out]	array	array of parsed numbers
[in]	VRMLnode	name of VRML node to expect on the beginning
[in]	VRMLfield	name of a VRML field which holds VRMLNode with 3D float numbers
[in]	skip	indicates that there is no name of VRML node and VRML field

Returns:

if the parsing was successful

Definition at line 1010 of file vrmlparser.cpp.

                                                                                                              {
  if (!skip){
    if ( !textParser->NextKeywordIs(VRMLnode," \t\n\r,")) { return false;}
    if ( textParser->GetChar(" \t\n\r,") != '{') { return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    if ( !textParser->NextKeywordIs(VRMLfield," \t\n\r,") ) {  return logErrorMsg(UNEXPECTED, textParser->GetWxLine());}
  }
  if ( textParser->GetChar(" \t\n\r,") != '[') { return logErrorMsg(UNEXPECTED, textParser->GetWxLine());}
  VECTOR3 v;
  while ( !textParser->NextCharIs(']'," \t\n\r,") ){
       if (textParser->ParseVector(v._v, 3, true, " \t\n\r,]") != 3)
         return false;
    array->push_back(v);
  }
  textParser->GetChar(" \t\n\r,"); //]
  if (!skip)
    if ( textParser->GetChar(" \t\n\r,") != '}') { return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("}"));}

  return true;
}

bool VRMLParser::parseFArray2	(	std::vector< VECTOR2 > *	array,
		const char *	VRMLnode,
		const char *	VRMLfield,
		bool	skip = false
	)			[private]

method to parse arrays of 2D float numbers, skippes VRMLnode name and VRMLfield name

Parameters:

[out]	array	array of parsed numbers
[in]	VRMLnode	name of VRML node to expect on the beginning
[in]	VRMLfield	name of a VRML field which holds VRMLNode with 3D float numbers
[in]	skip	indicates that there is no name of VRML node and VRML field

Returns:

if the parsing was successful

Definition at line 1030 of file vrmlparser.cpp.

                                                                                                              {
  if (!skip){
    if ( !textParser->NextKeywordIs(VRMLnode," \t\n\r,")) { return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    if ( textParser->GetChar(" \t\n\r,") != '{') { return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("{"));}
    if ( !textParser->NextKeywordIs(VRMLfield," \t\n\r,") ) {  return logErrorMsg(UNEXPECTED, textParser->GetWxLine());}
  }
  if ( textParser->GetChar(" \t\n\r,") != '[') { return logErrorMsg(UNEXPECTED, textParser->GetWxLine());}
  VECTOR2 v;
  while ( !textParser->NextCharIs(']'," \t\n\r,") ){
    if (textParser->ParseVector(v._v, 2, true, " \t\n\r,]") != 2)
      return false;
    array->push_back(v);
  }
  textParser->GetChar(" \t\n\r,"); //]
  if (!skip){
    if ( !textParser->NextCharIs('}'," \t\n\r,")) { return logErrorMsg(EXPECTED, textParser->GetWxLine() , wxT("}"));}
     else textParser->GetChar(" \t\n\r,");
  }
  return true;
}

bool VRMLParser::parseIndices	(	std::vector< GeometryTriangles::Indice > *	indices,
		size_t &	count,
		size_t	count_exp
	)			[private]

method to parse VRML indices

Parameters:

[out]	indices	parsed indices
[out]	count	number of indices really read
[in]	count_exp	number of indices expected

Returns:

if the parsing was successful

Definition at line 1123 of file vrmlparser.cpp.

{
       //read indices
       long v;
  textParser->SkipChars(" \t\n\r,");
       while (!textParser->NextCharIs(']', " \t\n\r,",false))
       {
            count = 0;

       if (!textParser->ParseLong(&v," \t\n\r,",false)){
         wxString line = textParser->GetWxLine();
         if ( line == wxT("#TL")) {count = 2; return true;}
         if ( line == wxT("#TF")) {count = 1; return true;}
         if ( line == wxT("#TS")) {count = 0; return true;}
         textParser->ParseLong(&v," \t\n\r,");
       }
       if (v < 0 )
         return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
       indices->push_back((GeometryTriangles::Indice)v);
       count ++;

       for ( ; count < count_exp; count++){
                  if ( textParser->NextKeywordIs("-1"," \t\n\r,]") || textParser->NextCharIs(']'," \t\n\r,")) //for less indices than we expect
                    return true;
                  if (!textParser->ParseLong(&v," \t\n\r,]") || v < 0 )
                    return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
        indices->push_back((GeometryTriangles::Indice)v);
       }

       if ( textParser->NextCharIs(']'," \t\n\r,")) return true;
       if ( !textParser->NextKeywordIs("-1"," \t\n\r,")){
         while( !textParser->NextKeywordIs("-1"," \t\n\r,]") ){
                     if ( textParser->NextCharIs(']'," \t\n\r,")) return true;
                     if (!textParser->ParseLong(&v," \t\n\r,") || v < 0 )
                       return logErrorMsg(UNEXPECTED, textParser->GetWxLine()+textParser->GetWxLine());
           indices->push_back((GeometryTriangles::Indice)v);
           count++;
                   }
                   if ( count < 3 ) return false;
                     return true;
       }
       textParser->SkipChars(" \t\n\r,");
       }
    return true;
}

bool VRMLParser::parseIndicesTSL	(	std::vector< GeometryTriangles::Indice > *	indices,
		size_t &	count,
		size_t	count_exp
	)			[private]

method to parse VRML indices written by VRUT exporter - it has topological information, so it skippes several indices

Parameters:

[out]	indices	parsed indices
[out]	count	number of indices really read
[in]	count_exp	number of indices expected

Returns:

if the parsing was successful

Definition at line 1051 of file vrmlparser.cpp.

{
       //read indices
       long v;
       long vector[3];
       //take all indices for the first triangle
       for ( int i = 0; i < 3; i++){
      if (!textParser->ParseLong(&v," \t\n\r,") || v < 0 ) {
             LOGERROR(wxT("coordIndex out of bounds"));
             return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
      }
      indices->push_back((GeometryTriangles::Indice)v);
       }
       // then must be -1
  textParser->SkipChars(" \t\n\r,");
  if ( textParser->GetChar() != '-') {
      return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
  }else {
    textParser->GetChar(); //-1
  }
  textParser->SkipChars(" \t\n\r,");
  if ( textParser->NextCharIs(']', " \t\n\r,",false)) return true;

       while (!textParser->NextCharIs(']', " \t\n\r,",false))
       {
          count = 0;
     if (!textParser->ParseLong(vector," \t\n\r,",false)){
       wxString line = textParser->GetWxLine();
       if ( line == wxT("#TL")) {count = 2; return true;}
       if ( line == wxT("#TF")) {count = 1; return true;}
       if ( line == wxT("#TS")) {count = 0; return true;}
       textParser->ParseLong(vector," \t\n\r,");
     }

       textParser->ParseLong(vector+1," \t\n\r,");
       textParser->ParseLong(vector+2," \t\n\r,"); //the indice that we wont
       //if another type of geometry has began, we wont all indices
       textParser->SkipChars(" \t\n\r,");
       if ( !textParser->NextCharIs('-'," \t\n\r,",false)) {
         for ( int i =0; i < 3; i++){
           if ( vector[i] < 0 ) {
             LOGERROR(wxT("coordIndex out of bounds"+vector[i]));
             return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
           }
           indices->push_back((GeometryTriangles::Indice)vector[i]);
           count++;
         }
         while( !textParser->NextKeywordIs("-1"," \t\n\r,") && !textParser->NextCharIs(']', " \t\n\r,") ){
                     if (!textParser->ParseLong(&v," \t\n\r,") || v < 0 ) {
                       LOGERROR(wxT("coordIndex out of bounds"+v));
                       return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
                     }
           indices->push_back((GeometryTriangles::Indice)v);
           count++;
                  }
                  return true;
       }
       //if it is still TF or TS store the last index
       else {
         textParser->GetWxString();
         if ( vector[2] < 0 ) {
           LOGERROR(wxT("coordIndex out of bounds"+vector[2]));
           return logErrorMsg(UNEXPECTED, textParser->GetWxLine());
         }
         indices->push_back((GeometryTriangles::Indice)vector[2]);
       }
    textParser->SkipChars(" \t\n\r,");
       }
  return true;
}

void VRMLParser::computeNormals	(	VRUT::GeometryTriangles *	geometry,
		float &	creaseAngle
	)			[private]

method for computing normals to smooth the mesh when creaseAngle is set

Parameters:

	in/out]	geometry with vertices
[in]	creaseAngle	is an angle to indicate maximal anlge which should be considered as smooth

Definition at line 1175 of file vrmlparser.cpp.

                                                                               {
       std::vector<VECTOR3> * norms = &(geometry->normals);
       norms->resize(geometry->indices.size());
       std::pair<VECTOR3,size_t> *vertices = new std::pair<VECTOR3, size_t>[geometry->indices.size()] ;
       size_t it_vertices;
       size_t endInd;
  float x = 0, y = 0, z = 0;
  VECTOR3 normal;

  unsigned count;
  for (GeometryTriangles::TriDescList::iterator it = geometry->triDescList.begin(); it != geometry->triDescList.end(); it++){
    GeometryTriangles::TriDescList::const_iterator endIndPrimType = it + 1;
              endInd = ( endIndPrimType == geometry->triDescList.end()) ? geometry->indices.size() : endIndPrimType->first ;
              endInd = __min( endInd,  geometry->indices.size() );
    it_vertices = it->first;
    count = 0;

    while ( it_vertices + count < endInd){
    switch (it->second){
      case GeometryTriangles::TRI_LIST:
        count = 2;
        break;
      case GeometryTriangles::QUADS:
        count = 3;
        break;
      case GeometryTriangles::POLYGON:
        if ( it+1 == geometry->triDescList.end())
          count = 3;
        else count = (it+1)->first - it->first - 1;
    }

    //Newell's method for computing surface face normals
    //it is a robust method - dealing correctly also with nonconvex polygon
    x = y = z = 0;
    for ( unsigned loop = 0; loop < count; loop++){
      x += (geometry->vertices[it_vertices]._v[1] - geometry->vertices[it_vertices+1]._v[1]) * (geometry->vertices[it_vertices]._v[2] + geometry->vertices[it_vertices+1]._v[2]);
      y += (geometry->vertices[it_vertices]._v[2] - geometry->vertices[it_vertices+1]._v[2]) * (geometry->vertices[it_vertices]._v[0] + geometry->vertices[it_vertices+1]._v[0]);
      z += (geometry->vertices[it_vertices]._v[0] - geometry->vertices[it_vertices+1]._v[0]) * (geometry->vertices[it_vertices]._v[1] + geometry->vertices[it_vertices+1]._v[1]);
      it_vertices++;
    }
    x += (geometry->vertices[it_vertices ]._v[1] - geometry->vertices[it_vertices - count]._v[1]) * (geometry->vertices[it_vertices]._v[2] + geometry->vertices[it_vertices - count]._v[2]);
    y += (geometry->vertices[it_vertices ]._v[2] - geometry->vertices[it_vertices - count]._v[2]) * (geometry->vertices[it_vertices]._v[0] + geometry->vertices[it_vertices - count]._v[0]);
    z += (geometry->vertices[it_vertices ]._v[0] - geometry->vertices[it_vertices - count]._v[0]) * (geometry->vertices[it_vertices]._v[1] + geometry->vertices[it_vertices - count]._v[1]);
    //copy face normal to all vertices
    #define PRECISION 0.0001
    normal = VECTOR3((abs(x)<PRECISION)?0:x,(abs(y)<PRECISION)?0:y,(abs(z)<PRECISION)?0:z);
    normal = normal.Normalize();
    it_vertices -= count;

    for ( unsigned i = 0; i != count + 1; i++){
      vertices[it_vertices] = std::pair<VECTOR3,size_t> (geometry->vertices[it_vertices],it_vertices);
      norms->insert(norms->begin() + it_vertices,normal);
      it_vertices++;
    }
    }
  }
  //sort vertices, so that the same vertices are together
  qsort(vertices,geometry->indices.size()-1,sizeof(std::pair<VECTOR3,size_t>),cmp);
  //average normals for the same vertices and less angle than creaseAngle
  float cosAngle;
  size_t number = 0;
  VECTOR3 temp(0,0,0);
  std::vector<size_t> index;
  for ( size_t i = 0; i < geometry->indices.size(); ){
    temp = norms->at(vertices[i].second);
    number = i;
    while ( vertices[number].first == vertices[number+1].first ){
      cosAngle = norms->at(vertices[number].second).Dot(norms->at(vertices[number+1].second));
      cosAngle = cosAngle / (norms->at(vertices[number].second).Length() * norms->at(vertices[number+1].second).Length());
      if ( creaseAngle > acos(cosAngle)){
       index.push_back(vertices[number].second);
       index.push_back(vertices[number+1].second);
       temp += norms->at(vertices[number+1].second);
      }
      ++number;
    }
    //copy the average normal
    if ( i < number){
      temp = temp.Normalize();
      for ( std::vector<size_t>::iterator iter = index.begin(); iter != index.end(); iter++){
        (*norms)[*iter] = temp;
      }
      index.clear();
      i = number;
    } else ++i;
  }

  delete [] vertices;
  return;
}

float VRUT::VRMLParser::abs

(

const float &

x

)

[inline, private]

method similar to abs in Math but taking a float argument

Parameters:

[in]

x

is the argument of the function

Definition at line 490 of file vrmlparser.h.

                                    {
      if ( x < 0 ) return -x;
      return x;
    }

bool VRMLParser::Parse	(	const wxString &	rootUid,
		bool	teselate,
		NodeUidsList *	nnl
	)

Parse VRML stream and build scene graph

Parameters:

[in]

rootUid

Uid of node that will be root of imported scene

Returns:

true if successful

Definition at line 2480 of file vrmlparser.cpp.

                                                                                {
  if (nnl != NULL)
    nodeUidsList = NodeUidsList(*nnl);
  if ( teselate)
    LOGWARNING(wxT("<VRMLParser>Teselation enabled"));
  else
    LOGWARNING(wxT("<VRMLParser>Teselation disabled"));
       if (!parseModel(rootUid)){
              LOGERROR(wxT("<VRMLParser>Scene not loaded properly"));
              return false;
       }
       return true;
}

---

Friends And Related Function Documentation

friend struct ANode [friend]

Definition at line 270 of file vrmlparser.h.

friend struct GNode [friend]

Definition at line 271 of file vrmlparser.h.

friend struct LNode [friend]

Definition at line 272 of file vrmlparser.h.

---

Member Data Documentation

TextParser* VRUT::VRMLParser::textParser [private]

Input text parser.

Definition at line 38 of file vrmlparser.h.

SCENE_ID VRUT::VRMLParser::sceneID [private]

ID of scene to be built.

Definition at line 40 of file vrmlparser.h.

wxString VRUT::VRMLParser::scenePath [private]

Path to scene resources, can be archive filename.

Definition at line 42 of file vrmlparser.h.

Module* VRUT::VRMLParser::module [private]

Parent module's interface.

Definition at line 44 of file vrmlparser.h.

bool VRUT::VRMLParser::fromVRUT [private]

Importing file that has been exported by VRUT.

Definition at line 46 of file vrmlparser.h.

NodeUidsList VRUT::VRMLParser::nodeUidsList [private]

List of nodes' names used during import to assure they are unique.

Definition at line 50 of file vrmlparser.h.

DefNamesListV3 VRUT::VRMLParser::defNamesListV3 [private]

List of DEF nodes' names used during import that labels type VECTOR3.

Definition at line 60 of file vrmlparser.h.

DefNamesListV2 VRUT::VRMLParser::defNamesListV2 [private]

List of DEF nodes' names used during import that labels type VECTOR2.

Definition at line 63 of file vrmlparser.h.

DefNamesListSN VRUT::VRMLParser::defNamesListSN [private]

List of DEF nodes' names used during import that labels type VRUT::SceneNode.

Definition at line 66 of file vrmlparser.h.

DefNamesListM VRUT::VRMLParser::defNamesListM [private]

List of DEF nodes' names used during import that labels type VRUT::Material.

Definition at line 69 of file vrmlparser.h.

DefNamesListG VRUT::VRMLParser::defNamesListG [private]

List of DEF nodes' names used during import that labels type VRUT::Geometry.

Definition at line 72 of file vrmlparser.h.

DefNamesListSNDindex VRUT::VRMLParser::defNamesListSNDindex [private]

index to a vector of defined scene nodes but not yet used (Defined in switch)

Definition at line 266 of file vrmlparser.h.

std::vector<Node*> VRUT::VRMLParser::defNamesListSND [private]

vector of scene nodes defined but not yet used

Definition at line 268 of file vrmlparser.h.

---

The documentation for this class was generated from the following files:

• /cygdrive/d/src/svn/vrut/trunk/modules/iovrml/vrmlparser.h
• /cygdrive/d/src/svn/vrut/trunk/modules/iovrml/vrmlparser.cpp