graphmisc.h

Go to the documentation of this file.

#ifndef GRAPHMISC_H
#define GRAPHMISC_H

#include <cassert>
#include <string>
#include <sstream>
#include <iostream>
#include <vector>
using namespace std;

#include <GL/glut.h>

#include <commandline.h>
#include <mathlib.h>
#include <print.h>
#include <gobj.h>


class OpenGLinitialisation
{
public:

  static GLfloat light_ambient[];
  static GLfloat light_diffuse[];
  static GLfloat light_specular[];
  static GLfloat light_position[];

  static GLfloat mat_ambient[];
  static GLfloat mat_diffuse[];
  static GLfloat mat_specular[];
  static GLfloat mat_shininess[];

  OpenGLinitialisation();

  void light0Init();
  void materialInit();

};

class myRotate : public gobj
{
public:

  point3<double> axis;

  myRotate(point3<double> const & axis_)
    : axis(axis_) {}

  static point3<double> const zaxis;

  void draw()
  {
    GOBJDEBUGCODE
    if (axis!=zaxis)
    {
      assert(axis!=point3<double>(0,0,0));

      point3<double> N;
      crossproduct::evalxyz(N,zaxis,axis);

      double angle = acos( axis.dot(zaxis) / axis.distance() );
      angle *= 180.0/PI;
      glRotated(angle,N.x,N.y,N.z);
    }
  }

};
    


class myglPushMatrixMode
{
public:

  GLint mode;

  myglPushMatrixMode()
    { glGetIntegerv(GL_MATRIX_MODE, &mode); }

  ~myglPushMatrixMode()
    { glMatrixMode(mode); }
};

class myglPushMatrix
{
public:

  myglPushMatrix()
    { glPushMatrix(); }

  ~myglPushMatrix()
    { glPopMatrix(); }
};

class myglPushAttrib
{
  myglPushAttrib() { assert(false); }
public:

  myglPushAttrib( GLbitfield mask )
    { glPushAttrib(mask); } 

  ~myglPushAttrib()
    { glPopAttrib(); }
};

class myglCapability
{
  myglCapability() { assert(false); }
public:

  GLenum capability;

  myglCapability(GLenum capability_)
    : capability(capability_) 
    { glEnable(capability); }

  ~myglCapability()
    { glDisable(capability); }
};

class myglMode
{
  myglMode() { assert(false); }
public:

  myglMode(GLenum mode)
   { glBegin(mode); }

  ~myglMode()
    { glEnd(); }
};
  

  

class myLightingTurnOff
{
public:

  myLightingTurnOff()
  {     
    glPushAttrib(GL_CURRENT_BIT);
    glPushAttrib(GL_LIGHTING_BIT);
    glDisable(GL_LIGHTING);
  }

  ~myLightingTurnOff()
    { glPopAttrib(); glPopAttrib(); }
};


// Write a vector of triangles. 
//void writeTriangles(vector< point3<double> > const & v);

void glerrordisplay();

void axes(doublec length);

class myaxes : public gobj
{
public:

  point3<float> xaxiscolor;
  point3<float> yaxiscolor;
  point3<float> zaxiscolor;

  double length;

  myaxes(doublec length_);

  void draw();

};

void wirerectangle(floatc x, floatc y, floatc z);

class camera
{
public:

  static void lookatxz
  (
    commandline & cmd,
    doublec camerax_=0.0, 
    doublec cameraz_=2.0 
  ); 

  static void lookat
  (
    commandline & cmd,
    doublec camerax_=0.0, 
    doublec cameray_=0.0, 
    doublec cameraz_=2.0 
  ); 
};





template< int period = 500 >
class framerate
{
  int frame;
  int time;
  int timebase;
  float fps;
  string sr;
public:

  float xpos;
  float ypos;

  framerate(float xpos_=0.1, float ypos_=0.05) :
    frame(0), time(0), timebase(0), fps(0.0), xpos(xpos_), ypos(ypos_) {}

  void update()
  {
    // glutGet(GLUT_ELAPSED_TIME) returns the time in millisecond units. 
    //   1unit=1ms
    time = glutGet(GLUT_ELAPSED_TIME);

    // Has a period passed? 
    if (time - timebase > period ) 
    {
      fps = frame*((GLfloat)period)/(time-timebase);
      timebase = time;    
      frame = 0;

      stringstream ss;
      ss << fps;
      sr = ss.str();
      sr += "fps";
    }
  }

  void display()
  {
    //assuming GL_MODELVIEW
    glPushMatrix(); //save
    glLoadIdentity(); //clear

    myLightingTurnOff temp2;

    glMatrixMode(GL_PROJECTION);
    glPushMatrix(); //save
    glLoadIdentity(); //clear
    //gluOrtho2D(-1.0, 1.0, -1.0, 1.0);
    gluOrtho2D(0.0, 1.0, 0.0, 1.0);
    glMatrixMode(GL_MODELVIEW);

    ++frame;

    glColor3f(0.0,1.0,0.0);

//cout << SHOW(xpos) << " " << SHOW(ypos) << endl;

    glRasterPos2f(xpos,ypos);
    //glRasterPos2f(0.8,0.2);

//cout << SHOW(sr) << endl;
    int len = sr.length();
    for (int i = 0; i < len; ++i)
      glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, sr[i]);

    glMatrixMode(GL_PROJECTION);
    glPopMatrix(); //restore
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix(); //restore
  }
};



class gltextmsg
{
  gltextmsg() { assert(false); }
public:
  
  string msg;
  float pos[2];
  float col[3];

  gltextmsg
  ( 
    string const & msg_,
    floatc x, 
    floatc y,
    floatc c0,
    floatc c1,
    floatc c2
  )
    : msg(msg_)
  {
    pos[0] = x;
    pos[1] = y;
    col[0] = c0;
    col[1] = c1;
    col[2] = c2;
  }

  template < typename T >
  void updatevalue
  ( 
    T const & v,
    string const & post = string("")
  )
  {  
    stringstream ss;
    ss << v;
    msg = ss.str();
    msg += post;
  }

  template < typename T >
  void updatevalue
  ( 
    string const & pre,
    T const & v,
    string const & post = string("")
  )
  {  
    stringstream ss;
    ss << v;
    msg = pre;
    msg += ss.str();
    msg += post;
  }
  

  void display() const
  {
    myglPushMatrix temp;

    myLightingTurnOff temp2;

    glLoadIdentity();
    gluOrtho2D(-1.0, 1.0, -1.0, 1.0);

    glColor3f(col[0],col[1],col[2]);

    glRasterPos2f(pos[0],pos[1]);

    int len = msg.length();
    for (int i = 0; i < len; ++i)
      glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, msg[i]);
  } 
};

class gobjMyTranslateDraw : public gobj
{
  gobjMyTranslateDraw() { assert(false); }
public:

  gobj* target;
  bool clean;

  point3<double> shift;

  gobjMyTranslateDraw
  (
    gobj * target_, 
    boolc clean_,
    point3<double> const & shift_
  )
    : target(target_), clean(clean_), shift(shift_) {}

  ~gobjMyTranslateDraw()
    { if (clean) delete target; }


  void draw()
  {
    GOBJDEBUGCODE
    assert(target!=0);

    glPushMatrix();
    glTranslatef(shift.x,shift.y,shift.z);
    target->draw();
    glPopMatrix();
  }
};

class gobjQuadric : public gobj
{
public:

  GLUquadric * quadric;

  // Possible states
  float radius;
  int slices;
  int loops;

  gobjQuadric()
    : quadric(gluNewQuadric()), radius(0.2), slices(10), loops(3) {}

  void detailincrease()
    { slices *= 2; loops *=2; }

  ~gobjQuadric()
    { gluDeleteQuadric(quadric); }

  void draw()
    { GOBJDEBUGCODE }
};

class gobjMyDiscDraw: public gobj
{
public:

  gobjQuadric * d;

  float x;
  float y;

  gobjMyDiscDraw()
    : d(0), x(0.0), y(0.0) {}

  gobjMyDiscDraw
  (
    floatc x_,
    floatc y_,
    gobjQuadric * d_
  )
    : d(d_), x(x_), y(y_) {}

  gobjMyDiscDraw
  (
    point2<double> const & x,
    gobjQuadric * d_
  )
    : d(d_), x(x.x), y(x.y) {}

  gobjMyDiscDraw
  (
    point2<float> const & x,
    gobjQuadric * d_
  )
    : d(d_), x(x.x), y(x.y) {}

  void draw()
  {
    GOBJDEBUGCODE
    assert(d!=0);

    glPushMatrix();
    glTranslatef(x,y,0.0);
    gluDisk(d->quadric, 0.0, d->radius, d->slices, d->loops);
    glPopMatrix();
  }
};
 
class gobjMySphereDraw : public gobj
{
public:
  
  gobjQuadric * quadric;

  float x;
  float y;
  float z;

  gobjMySphereDraw()
    : quadric(0), x(0.0), y(0.0), z(0.0) {}

  gobjMySphereDraw
  (
    floatc x_,
    floatc y_,
    floatc z_,
    gobjQuadric * quadric_
  )
    : quadric(quadric_), x(x_), y(y_), z(z_) {}

  gobjMySphereDraw
  (
    doublec x_,
    doublec y_,
    doublec z_,
    gobjQuadric * quadric_
  )
    : quadric(quadric_), x(x_), y(y_), z(z_) {}

  gobjMySphereDraw
  (
    point3<double> const & p,
    gobjQuadric * quadric_
  )
    : quadric(quadric_), x(p.x), y(p.y), z(p.z) {}

  gobjMySphereDraw
  (
    point3<float> const & p,
    gobjQuadric * quadric_
  )
    : quadric(quadric_), x(p.x), y(p.y), z(p.z) {}

  gobjMySphereDraw
  (
    point2<double> const & x,
    gobjQuadric * quadric_
  )
    : quadric(quadric_), x(x.x), y(x.y), z(0.0) {}

  // Unhappy with reference pass.
  gobjMySphereDraw
  (
    point2<double> const & x,
    gobjQuadric& quadricref
  )
    : quadric(&quadricref), x(x.x), y(x.y), z(0.0) {}

  gobjMySphereDraw
  (
    point2<float> const & x,
    gobjQuadric * quadric_
  )
    : quadric(quadric_), x(x.x), y(x.y), z(0.0) {}

  void draw()
  {
    GOBJDEBUGCODE
    assert(quadric!=0);

    glPushMatrix();
    glTranslatef(x,y,z);
    gluSphere(quadric->quadric,quadric->radius,quadric->slices,quadric->loops);
    glPopMatrix();
  }

};

class gobjMyCircle : public gobj
{
public:

  uintc N;

  float * const ptx;
  float * const pty;

  gobjMyCircle
  (
    doublec theta0, 
    doublec theta1, 
    doublec xaxislength,
    doublec yaxislength,
    uintc N_=360
  );

  gobjMyCircle
  (
    doublec theta0, 
    doublec theta1, 
    doublec radius=1.0,
    uintc N_=360
  );

  gobjMyCircle( uintc N_=360 );

  void draw() { GOBJDEBUGCODE }

  ~gobjMyCircle();

};

class gobjMyCircleDraw : public gobj
{
  static point3<double> const zaxis;
public:

  double scalex;
  double scaley;

  point3<double> center;

  point3<double> axis;

  gobjMyCircle const & cir;

  void radiusset(doublec radius)
    { scalex=radius; scaley=radius; }
  
  template<typename T>
  gobjMyCircleDraw
  (
    point3<T> const & center_,
    gobjMyCircle const & cir_
  )
    : scalex(1.0), scaley(1.0), center(center_.x,center_.y,center_.z), 
      axis(zaxis), cir(cir_) {}

  template<typename T>
  gobjMyCircleDraw
  (
    point2<T> const & center_,
    gobjMyCircle const & cir_
  )
    : scalex(1.0), scaley(1.0), center(center_.x,center_.y,0.0), 
      axis(zaxis), cir(cir_) {}


  template<typename T>
  gobjMyCircleDraw
  (
    doublec radius,
    point3<T> const & center_,
    gobjMyCircle const & cir_
  )
    : scalex(radius), scaley(radius), center(center_.x,center_.y,center_.z), 
      axis(zaxis), cir(cir_) {}

  template<typename T>
  gobjMyCircleDraw
  (
    doublec radius,
    point3<T> const & center_,
    point3<T> const & axis_,
    gobjMyCircle const & cir_
  )
    : scalex(radius), scaley(radius), center(center_), 
      axis(axis_), cir(cir_) {}

  void draw();

};





class gobjMyBitmapCharacter : public gobj
{
public:

  string name;

  point3<float> x;

  void * font;

  gobjMyBitmapCharacter
  (
    string const & name_,
    point3<float> const & x_,  
    void* font_=GLUT_BITMAP_HELVETICA_10
  )
    : name(name_), x(x_), font(font_) {};

  gobjMyBitmapCharacter
  (
    string const & name_,
    point3<double> const & x_,  
    void* font_=GLUT_BITMAP_HELVETICA_10
  )
    : name(name_), x( point3<float>(x_.x,x_.y,x_.z) ), font(font_) {};

  void draw();

};

class gobjMyArrow : public gobj
{
public:

  point3<double> p0;
  point3<double> p1;
  doublec headlength;
  doublec headwidth;
  double delta;

  gobjMyArrow
  (
    point3<double> const & p0_,
    point3<double> const & p1_,
    doublec headlength_,
    doublec headwidth_,
    doublec delta_
  );

/*
  gobjMyArrow
  (
    point2<double> const & _p0,
    point2<double> const & _p1,
    doublec _delta
  );
*/

  void draw();

};

class gobjMyDiskDraw : public gobj
{
public:
  
  gobjQuadric * d;

  float x;
  float y;
  float z;

  gobjMyDiskDraw()
    : d(0), x(0.0), y(0.0), z(0.0) {}

  gobjMyDiskDraw
  (
    floatc x_,
    floatc y_,
    floatc z_,
    gobjQuadric * d_
  )
    : d(d_), x(x_), y(y_), z(z_) {}

  gobjMyDiskDraw
  (
    point3<double> x,
    gobjQuadric * d_
  )
    : d(d_), x(x.x), y(x.y), z(x.z) {}

  gobjMyDiskDraw
  (
    point3<float> x,
    gobjQuadric * d_
  )
    : d(d_), x(x.x), y(x.y), z(x.z) {}

  void draw()
  {
    GOBJDEBUGCODE
    assert(d!=0);

    glPushMatrix();
    glTranslatef(x,y,z);
    gluDisk(d->quadric,0.0,d->radius,d->slices,d->loops);
    glPopMatrix();
  }

};


class colorfunction
{
public:

  template< class T >
  point3<T>& operator () (point3<T>& p, T const v) const;
  template< class T >
  void operator () (T& x, T& y, T& z, T const v) const;

};


class gridsquare : public gobjContainer
{
public:

  gridsquare
  (
    GLint factor,
    GLushort pattern,
    uintc xcolumns,
    uintc ycolumns,
    doublec xmax,
    doublec ymax
  );


};

class graphmisc
{
public:

  static void colornormalize(point3<double> & p1, point3<uint> const & p2);

  static void colornormalize(point3<double> & p1, commandline & cmd, stringc tag );

};


//----------------------------------------------------------
// Implementation

template< class T >
point3<T>& colorfunction::operator () (point3<T>& p, T const v) const
{
  assert(v>=0.0);
  assert(v<=1.0);

  p.x =  p.z = 0.0;
  p.y = 1.0;

  if (v>=0.75)
    p.x = 1.0;  
  else
    if (v>0.5)
      p.x = (v-0.5)/0.25;

  if (v<=0.25)
    p.z = 1.0;
  else
    if (v<0.5)
      p.z = 1.0 - (v-0.25)/0.25;

  if (v>0.75)
    p.y = 1.0 - (v-0.75)/0.25;
  else
    if (v<0.25)
      p.y = v/0.25;

  return p;
}

template< class T >
void colorfunction::operator () (T& x, T& y, T& z, T const v) const
{
  assert(v>=0.0);
  assert(v<=1.0);

  x = z = 0.0;
  y = 1.0;

  if (v>=0.75)
    x = 1.0;  
  else
    if (v>0.5)
      x = (v-0.5)/0.25;

  if (v<=0.25)
    z = 1.0;
  else
    if (v<0.5)
      z = 1.0 - (v-0.25)/0.25;

  if (v>0.75)
    y = 1.0 - (v-0.75)/0.25;
  else
    if (v<0.25)
      y = v/0.25;
}



#endif