VRMLParser.H

Go to the documentation of this file.

#ifndef VRMLPARSER_H
#define VRMLPARSER_H

#include "IS3DCommon.H"
#include "ModelObj.H"
#include "ProgressBar.H"
#include "Event.H"
#include "FsaMgr.H"

namespace IS3D {


// VRML node type classes
typedef ReferenceCountedPointer< class VRMLNode >            VRMLNodeRef;
typedef ReferenceCountedPointer< class VRMLSeparatorNode >   VRMLSeparatorNodeRef;
typedef ReferenceCountedPointer< class VRMLMaterialNode >    VRMLMaterialNodeRef;
typedef ReferenceCountedPointer< class VRMLCoordinatesNode > VRMLCoordinatesNodeRef;
typedef ReferenceCountedPointer< class VRMLNormalsNode >     VRMLNormalsNodeRef;
typedef ReferenceCountedPointer< class VRMLIndexedFaceNode > VRMLIndexedFaceNodeRef;
typedef ReferenceCountedPointer< class VRMLGroupNode >       VRMLGroupNodeRef;
typedef ReferenceCountedPointer< class VRMLSwitchNode >      VRMLSwitchNodeRef;
typedef ReferenceCountedPointer< class VRMLPerspCameraNode > VRMLPerspCameraNodeRef;


  
class VRMLNode : public ReferenceCountedObject {
public:
  enum { SEP_NODE, MAT_NODE, COORD3_NODE, NORMALS_NODE,
         INDEXED_FACE_NODE, GROUP_NODE, SWITCH_NODE,
         PCAM_NODE,
         NO_MORE_NODES_IN_SCOPE // A fake node type to help our peeking function
  };
  virtual int getNodeType() = 0;
};

class VRMLPerspCameraNode : public VRMLNode {
public:
  virtual int getNodeType() { return PCAM_NODE; }
  Vector3 _position;
  Vector3 _lookVec;
  double  _rotAboutLookVec;
};
  
class VRMLSeparatorNode : public VRMLNode {
public:
  virtual int getNodeType() { return SEP_NODE; }
  Array< VRMLGroupNodeRef >        _groups;
  Array< VRMLSwitchNodeRef >       _switches;
  Array< VRMLMaterialNodeRef >     _materials;
  Array< VRMLCoordinatesNodeRef >  _coordinates;
  Array< VRMLNormalsNodeRef >      _normals;
  Array< VRMLSeparatorNodeRef >    _children;
  Array< VRMLIndexedFaceNodeRef >  _faces;
  VRMLPerspCameraNodeRef           _perspCamera;
};
  
class VRMLMaterialNode : public VRMLNode {
public:
  virtual int getNodeType() { return MAT_NODE; }
  // Material nodes can store indexed values or single values that apply 
  // to all geom. In the latter case these arrays will only have one element
  // Store as vector 3s for convenience. Change to color3s later.
  Array< Vector3 > _ambient;
  Array< Vector3 > _specular;
  Array< Vector3 > _diffuse;
  Array< Vector3 > _emissive;
  Array< double >  _shininess, _transparency;
};
  
class VRMLCoordinatesNode : public VRMLNode {
public:
  virtual int getNodeType() { return COORD3_NODE; }
  Array< Vector3 > _points;
};
  
class VRMLNormalsNode : public VRMLNode {
public:
  virtual int getNodeType() { return NORMALS_NODE; }
  Array< Vector3 > _normal_vectors;
};

class VRMLIndexedFaceNode : public VRMLNode {
public:
  virtual int getNodeType() { return INDEXED_FACE_NODE; }
  Array< Array<int> > _faces_vertices;
};
  
class VRMLGroupNode : public VRMLNode {
public:
  virtual int getNodeType() { return GROUP_NODE; }
  Array< VRMLSwitchNodeRef > _switches;
};
  
class VRMLSwitchNode : public VRMLNode {
public:
  virtual int getNodeType() { return SWITCH_NODE; }
  Array< VRMLSeparatorNodeRef > _separators;
};
  

  

typedef ReferenceCountedPointer<class VRMLParser> VRMLParserRef;

class VRMLParser : public ReferenceCountedObject
{
public:

  VRMLParser(const std::string &filename,
             bool getCameraFromFile = true,
             bool addModelsToDrawMgr = true,
             bool loadInSecondThread = true);  

  virtual ~VRMLParser();

  void         parseAndCreateModels();
  void         addAllModelsToDrawMgr();
  
  int          getNumModels();
  ModelObjRef  getModel(int index=0);

  float        getPercentageDoneLoading();
  void         checkForThreadComplete(EventRef e);
  
private:

  Array<ModelObjRef> _models;
  
  // Geometry building methods
  void recursiveTraverseVRML(VRMLSeparatorNodeRef root);
  
  // Parsing methods
  int                    peekNextNodeType    ( TextInput& vrmlTextFile );
  VRMLPerspCameraNodeRef parsePerspCameraNode ( TextInput& vrmlTextFile );
  VRMLSeparatorNodeRef   parseSeparatorNode  ( TextInput& vrmlTextFile, bool isRootSep=false );
  VRMLMaterialNodeRef    parseMaterialNode   ( TextInput& vrmlTextFile );
  VRMLCoordinatesNodeRef parseCoordinate3Node( TextInput& vrmlTextFile );
  VRMLNormalsNodeRef     parseNormalsNode    ( TextInput& vrmlTextFile );
  VRMLIndexedFaceNodeRef parseIndexedFaceNode( TextInput& vrmlTextFile );
  VRMLGroupNodeRef       parseGroupNode      ( TextInput& vrmlTextFile );
  VRMLSwitchNodeRef      parseSwitchNode     ( TextInput& vrmlTextFile );

  Array< Array<int> >    reshapeDelimitedIntArray(const Array<int>& srcArray, int delimiter);  
  void    readThreeTuples( TextInput& vrmlTextFile, Array< Vector3 >& values );
  void    readScalars    ( TextInput& vrmlTextFile, Array< double >& values );
  void    readInts       ( TextInput& vrmlTextFile, Array< int >& values );
  Vector3 readThreeTuple ( TextInput& vrmlTextFile );
  double  readScalar     ( TextInput& vrmlTextFile );
  void    eatString( TextInput& vrmlTextFile, const std::string expectedToken );
  void    eatBeginCurly     ( TextInput& vrmlTextFile );
  void    eatCloseCurly     ( TextInput& vrmlTextFile );
  void    eatBeginBrace     ( TextInput& vrmlTextFile );
  void    eatCloseBrace     ( TextInput& vrmlTextFile );
  void    eatUntilCloseCurly( TextInput& vrmlTextFile );   

private:
  // access to these 2 member variables should be protected by this
  // mutex when loading with threads.
  SDL_mutex*     _threadMutex;  
  bool           _parseAndCreateModelsDone;
  float          _percDoneLoading;
  
  std::string    _filename;
  bool           _useCamera;
  bool           _addModels;
  int            _numLinesInFile;
  ProgressBarRef _progressBar;
  FsaRef         _fsa;
  
public:
  // currently there can be only one VRMLParser loading in the
  // background via threads at a time..
  static VRMLParserRef _parserLoadingInThread;
};



} // end namespace

#endif

---