VRMLModel.H

Go to the documentation of this file.

#ifndef _VRMLMODEL_H
#define _VRMLMODEL_H

#include <G3D/G3D.h>
#include <GLG3D/PosedModel.h>
#include "IS3DCommon.H"

#include "VRMLParser.H"


namespace IS3D {



  
   /*******************************************************************************
   * VRML Node types. 
   *******************************************************************************/

  /******
  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;

  class VRMLNode : public ReferenceCountedObject {
  public:
    enum { UNKNOWN_NODE = 0, // I don't think i need this now
       SEP_NODE, MAT_NODE, COORD3_NODE, NORMALS_NODE, INDEXED_FACE_NODE,
           GROUP_NODE, SWITCH_NODE,
       NO_MORE_NODES_IN_SCOPE // A fake node type to help our peeking function
    };
    virtual int getNodeType() = 0;
  };

  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;
  };

  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 VRMLModel> VRMLModelRef;
class VRMLObj;

class VRMLModel : public ReferenceCountedObject {

private:
  
  /******************************************************************************
   * Nested class: PosedVRMLModel
   * Purpose:      G3D can render posed models. Adapted from the PosedIFSModel class.
   ******************************************************************************/
  class PosedVRMLModel : public PosedModel {
  public:
    VRMLModelRef             model;
    CoordinateFrame         cframe;
    bool                    perVertexNormals;
    bool                    useMaterial;
    GMaterial               material;
    static GFontRef                labelFont;

    PosedVRMLModel(VRMLModelRef _model, const CoordinateFrame& _cframe, bool _pvn,
           const GMaterial& _mat, bool _useMat);
    virtual ~PosedVRMLModel() {}
    virtual std::string name() const;
    virtual void getCoordinateFrame(CoordinateFrame&) const;
    virtual const MeshAlg::Geometry& objectSpaceGeometry() const;
    virtual const Array<MeshAlg::Face>& faces() const;
    virtual const Array<MeshAlg::Edge>& edges() const;
    virtual const Array<MeshAlg::Vertex>& vertices() const;
    virtual const Array<MeshAlg::Face>& weldedFaces() const;
    virtual const Array<MeshAlg::Edge>& weldedEdges() const;
    virtual const Array<MeshAlg::Vertex>& weldedVertices() const;
    virtual const Array<int>& triangleIndices() const;
    virtual void getObjectSpaceBoundingSphere(Sphere&) const;
    virtual void getObjectSpaceBoundingBox(Box&) const;
    virtual void render(RenderDevice* renderDevice) const;
    virtual int numBoundaryEdges() const;
    virtual int numWeldedBoundaryEdges() const;
    virtual const Array<Vector3>& objectSpaceFaceNormals(bool normalize = true) const;
  };
  
  friend class PosedVRMLModel;
  friend class VRMLObj;

  VRMLSeparatorNodeRef        root_vrml_node;

  std::string                 filename;
  MeshAlg::Geometry           geometry;
  Array<int>                  indexArray;
  Array<Vector3>              faceNormalArray;
  Array<MeshAlg::Face>        weldedFaceArray;
  Array<MeshAlg::Edge>        weldedEdgeArray;
  Array<MeshAlg::Vertex>      weldedVertexArray;
  Array<MeshAlg::Face>        faceArray;
  Array<MeshAlg::Edge>        edgeArray;
  Array<MeshAlg::Vertex>      vertexArray;
  Sphere                      boundingSphere;
  Box                         boundingBox;
  int                         numBoundaryEdges;
  int                         numWeldedBoundaryEdges;
  std::string                 name;
  

  bool _show_vertex_numbers;

  static VARAreaRef           varArea;
  
    VRMLModel();
    
    void load(const std::string& filename, const Vector3& scale, const CoordinateFrame& cframe);

    void reset();

  void makeG3DMesh();
  void traverseVRML( const VRMLSeparatorNodeRef& sepNode );


  int                    peekNextNodeType    ( 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 ); 
public:

    virtual ~VRMLModel();

    static VRMLModelRef create(const std::string& filename, const Vector3& scale = Vector3(1,1,1), const CoordinateFrame& cframe = CoordinateFrame());
    static VRMLModelRef create(const std::string& filename, const double scale, const CoordinateFrame& cframe = CoordinateFrame());

    virtual PosedModelRef pose(const CoordinateFrame& cframe, bool perVertexNormals = true);

    virtual PosedModelRef pose(const CoordinateFrame& cframe, const GMaterial& material, bool perVertexNormals = true);

    virtual size_t mainMemorySize() const;

  virtual const MeshAlg::Geometry& getGeometry() { return geometry; }
};

}

#endif

---