---

wrapGL.H

Go to the documentation of this file.

#ifndef _WRAPGL_H
#define _WRAPGL_H

#include <GL/glut.h>
#include <Rect.H>
#include <Frenet.H>
#include <RGB.H>
#include <UserInterface.H>

namespace xchen
{
  enum Axis { NegXDir, PosXDir, NegYDir, PosYDir, NegZDir, PosZDir };

  void xglCylinder( GLUquadric* quad, GLdouble base=.5, GLdouble top=.5, GLdouble height=1.0, 
                    GLdouble base_at=0, GLint slices=200, GLint stacks=200, Axis dir=PosXDir );
  void xglDisk(GLUquadric* quad, GLdouble inner_r, GLdouble outer_r, GLdouble at=0, GLint slices=200, GLint rings=200, Axis dir=PosXDir );
  void wglCone(double bs=0.5, double h=1.0,  double top = 0, Axis align = PosZDir, GLint slices=200, GLint stacks=200);

  void wglArrow();   // pos-x direction
  void wglArrow(const dVector3D& dir, const RGBAS&);

  void wglCircle(const dPoint3D& center, double r, const RGB& col=White, int segments = 100);
  void wgl2DStar(const dPoint2D& pnt);
  void wglXYZAxes(float scale=1.0);
  void wglFrame(const Frame& frm, float scale = 1.0);
  void wglFrenet(const Frenet& frt, float frmscale = 1.0);
  void wglFrames( vector<Frame> :: const_iterator iter, vector<Frame> :: const_iterator stop );
  void wglFrenets( vector<Frenet> :: const_iterator iter, vector<Frenet> :: const_iterator stop );

  template<class T, int dim>
  void wglPolyLine( const vector< Point<T, dim> >& pnts )
  {
    glDisable(GL_LIGHTING);
    {
      if(cur_glmodel_ui->GetfloatControl("Line Width") == 0 ) 
      {
        glPointSize( cur_glmodel_ui->GetfloatControl("Point Size") );
        glBegin(GL_POINTS);
      }
      else
        glBegin(GL_LINE_STRIP);    

      for(typename vector< Point<T, dim> > :: const_iterator iter = pnts.begin(); iter != pnts.end(); iter++) 
        wglVertex( *iter );
    
      glEnd();
    }
    glEnable(GL_LIGHTING);
  }

        
  inline void wglViewport(const GLViewPort& gl_viewport)
  {
    glViewport(gl_viewport.StartX(),gl_viewport.StartY(),gl_viewport.Width(),gl_viewport.Height());
  }

  void wglOrtho(const dPoint2D& min, const dPoint2D& max);
  void wglOrtho(const dPoint3D& min, const dPoint3D& max);


  inline void wglTranslate(const dVector3D& v) { glTranslated(v[0], v[1], v[2]); }
  inline void wglTranslate(const fVector3D& v) { glTranslatef(v[0], v[1], v[2]); }
  inline void wglTranslate(const iVector3D& v) { glTranslatef(v[0], v[1], v[2]); }

  inline void wglScale(float s)  { glScalef(s,s,s); }
  inline void wglScale(double s) { glScaled(s,s,s); }
  inline void wglScale(int s)    { glScalef(s,s,s); }

  inline void wglScale(const fVector3D& v) { glScalef(v[0],v[1],v[2]); }
  inline void wglScale(const dVector3D& v) { glScaled(v[0],v[1],v[2]); }
  inline void wglScale(const iVector3D& v) { glScalef(v[0],v[1],v[2]); }

    
  inline void wglRotate(const fVector3D& angles) 
  {
    glRotatef(angles[0], 1,0,0);
    glRotatef(angles[1], 0,1,0);
    glRotatef(angles[2], 0,0,1);
  }

  inline void wglRotate(const dVector3D& rot_dir, double rot_angle) 

  {
    glRotated(rot_angle, rot_dir[0], rot_dir[1], rot_dir[2]);
  }
  inline void wglRotate(double rot_angle, const dVector3D& rot_dir) 

  {
    glRotated(rot_angle, rot_dir[0], rot_dir[1], rot_dir[2]);
  }

  inline void wglRotateTo(const dVector3D& from, const dVector3D& to) 

  {
    wglRotate(from^to, from.Angle(to)); 
  }



  inline void wglClearColor (const RGBA& rgba) 
  {
    glClearColor(rgba[0], rgba[1], rgba[2], rgba[2]);
  }

  inline void wglColor(const fVector3D& col) 
  {
    glColor3f(col[0], col[1], col[2]);
  }

  inline void wglColorHSV(const HSV& hsv) 
  {
    HSV col(hsv); HSV2RGB(col); wglColor(col);
  }

  inline void wglNormal(const dPoint3D& v) 
  {
    glNormal3d(v[0], v[1], v[2]);
  }
  inline void wglNormal(const dPoint3D* v) 
  {
    wglNormal(*v);
  }
  inline void wglNormal(const fPoint3D& v) 
  {
    glNormal3f(v[0], v[1], v[2]);
  }
  inline void wglNormal(const fPoint3D* v) 
  {
    wglNormal(*v);
  }
  inline void wglNormal(const iPoint3D& v) 
  {
    glNormal3i(v[0], v[1], v[2]);
  }
  inline void wglNormal(const iPoint3D* v) 
  {
    wglNormal(*v);
  }


  inline void wglTexCoord(const dPoint2D& v) 
  {
    glTexCoord2d(v[0], v[1]);
  }
  inline void wglTexCoord(const dPoint2D* v) 
  {
    wglTexCoord(*v);
  }
  inline void wglTexCoord(const fPoint2D& v) 
  {
    glTexCoord2f(v[0], v[1]);
  }
  inline void wglTexCoord(const fPoint2D* v) 
  {
    wglTexCoord(*v);
  }
  inline void wglTexCoord(const iPoint2D& v) 
  {
    glTexCoord2i(v[0], v[1]);
  }
  inline void wglTexCoord(const iPoint2D* v) 
  {
    wglTexCoord(*v);
  }


  inline void wglTexCoord(const dPoint3D& v) 
  {
    glTexCoord3d(v[0], v[1], v[2]);
  }
  inline void wglTexCoord(const dPoint3D* v) 
  {
    wglTexCoord(*v);
  }
  inline void wglTexCoord(const fPoint3D& v) 
  {
    glTexCoord3f(v[0], v[1], v[2]);
  }
  inline void wglTexCoord(const fPoint3D* v) 
  {
    wglTexCoord(*v);
  }
  inline void wglTexCoord(const iPoint3D& v) 
  {
    glTexCoord3i(v[0], v[1], v[2]);
  }
  inline void wglTexCoord(const iPoint3D* v) 
  {
    wglTexCoord(*v);
  }


  inline void wglRect(const Rect<float>& r) 
  {
    float sx = r.StartX(), sy = r.StartY();
    glRectf(sx, sy, sx + r.Width(), sy + r.Height());
  }
  inline void wglRect(const dRect& r) 
  {
    double sx = r.StartX(), sy = r.StartY();
    glRectd(sx, sy, sx + r.Width(), sy + r.Height());
  }
  inline void wglRect(const iRect& r) 
  {
    int sx = r.StartX(), sy = r.StartY();
    glRecti(sx, sy, sx + r.Width(), sy + r.Height());
  }



  void wglText(bool fixed, const dPoint3D& pos, char* str, bool large_font = false, const RGB& col = White);
  void wglDrawMarkSquare(double u, double v,  double z=-1, const RGB& col=Magenta, int sz=5);

  inline void wglText(bool fixed, double x, double y, char* str, bool large_font = false, const RGB& col = White) 

  {
    wglText(fixed, dPoint3D(x,y,0), str, large_font, col);
  }

  inline void wglFixedPositionText(const dPoint3D& pos, char* str, bool large_font = false, const RGB& col = White) 

  {
    wglText(true, pos, str, large_font, col);
  }
  inline void wglFixedPositionText(double x, double y, char* str, bool large_font = false, const RGB& col = White) 

  {
    wglFixedPositionText(dPoint3D(x,y,0), str, large_font, col);
  }



  inline void wglNonFixedPositionText(const dPoint3D& pos, char* str, bool large_font = false, const RGB& col = White) 

  {
    wglText(false, pos, str, large_font, col);
  }
  inline void wglNonFixedPositionText(double x, double y, char* str, bool large_font = false, const RGB& col = White) 

  {
    wglNonFixedPositionText(dPoint3D(x,y,0), str, large_font, col);
  }


  inline void _wglVertex(const iPoint2D& v) { glVertex2iv(v.GetData()); }
  inline void _wglVertex(const iPoint2D* v) { glVertex2iv(v->GetData()); }
  inline void _wglVertex(const iPoint3D& v) { glVertex3iv(v.GetData()); }
  inline void _wglVertex(const iPoint3D* v) { glVertex3iv(v->GetData()); }
  inline void _wglVertex(const iPoint4D& v) { glVertex4iv(v.GetData()); }
  inline void _wglVertex(const iPoint4D* v) { glVertex4iv(v->GetData()); }

  inline void _wglVertex(const fPoint2D& v) { glVertex2fv(v.GetData()); }
  inline void _wglVertex(const fPoint2D* v) { glVertex2fv(v->GetData()); }
  inline void _wglVertex(const fPoint3D& v) { glVertex3fv(v.GetData()); }
  inline void _wglVertex(const fPoint3D* v) { glVertex3fv(v->GetData()); }
  inline void _wglVertex(const fPoint4D& v) { glVertex4fv(v.GetData()); }
  inline void _wglVertex(const fPoint4D* v) { glVertex4fv(v->GetData()); }

  inline void _wglVertex(const dPoint2D& v) { glVertex2dv(v.GetData()); }
  inline void _wglVertex(const dPoint2D* v) { glVertex2dv(v->GetData()); }
  inline void _wglVertex(const dPoint3D& v) { glVertex3dv(v.GetData()); }
  inline void _wglVertex(const dPoint3D* v) { glVertex3dv(v->GetData()); }
  inline void _wglVertex(const dPoint4D& v) { glVertex4dv(v.GetData()); }
  inline void _wglVertex(const dPoint4D* v) { glVertex4dv(v->GetData()); }

  template<class T, int sz>
  void wglNormalizeVertex(const Point<T,sz>& p) 
  {
    _wglVertex(p.GetNormalizedVector());
  }

  template<class T, int sz>
  void wglVertex(const Point<T,sz>& p) 
  {
    _wglVertex(p);
  }


  void wglShading(const RGBAS& rgbas, bool revert_color = false );
  
}
#endif
 

---