NektarModel.H

Go to the documentation of this file.

#ifndef _NektarMODEL_H
#define _NektarMODEL_H

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




namespace IS3D {


typedef ReferenceCountedPointer<class NektarModel> NektarModelRef;
class NektarModelObj;

class NektarModel : public ReferenceCountedObject {

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

    PosedNektarModel(NektarModelRef _model, const CoordinateFrame& _cframe, bool _pvn,
           const GMaterial& _mat, bool _useMat);
    virtual ~PosedNektarModel() {}
    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 PosedNektarModel;
  friend class NektarModelObj;

  std::string                 filename;
  
  // We use arrays of arrays, where the first index is the timestep
  Array< MeshAlg::Geometry >          geometry;
  Array< Array<int> >                 indexArray;
  
  
  Array< Array<Vector3> >             faceNormalArray;
  Array< Array<MeshAlg::Face> >       weldedFaceArray;
  Array< Array<MeshAlg::Edge> >       weldedEdgeArray;
  Array< Array<MeshAlg::Vertex> >     weldedVertexArray;
  Array< Array<MeshAlg::Face> >       faceArray;
  Array< Array<MeshAlg::Edge> >       edgeArray;
  Array< Array<MeshAlg::Vertex> >     vertexArray;
 

  Sphere                              boundingSphere;
  Box                                 boundingBox;
  int                                 numBoundaryEdges;
  int                                 numWeldedBoundaryEdges;
  std::string                         name;
  
  int _num_triangles, _num_timesteps, _curr_timestep;
  bool _show_vertex_numbers, _show_face_numbers;
  
  static VARAreaRef           varArea;
  
  NektarModel();
  
  void load(const std::string& filename, 
        int numTriangles, int numTimesteps, 
        const Vector3& scale, const CoordinateFrame& cframe);
  
  void reset();
  
  void makeG3DMesh();

  void parseAllTimesteps( TextInput& nektarTextFile );
  void parseTimestep    ( TextInput& nektarTextFile );
  void parseTriangle    ( TextInput& nektarTextFile );
  
public:

    virtual ~NektarModel();

    static NektarModelRef create(const std::string& filename, 
                 int numTriangles, int numTimesteps,
                 const Vector3& scale = Vector3(1,1,1), const CoordinateFrame& cframe = CoordinateFrame());
    static NektarModelRef create(const std::string& filename, 
                 int numTriangles, int numTimesteps, 
                 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[ _curr_timestep ]; }

  
};

}

#endif

---