OpenGLtemplated.h

Go to the documentation of this file.

#ifndef OPENGLTEMPLATED
#define OPENGLTEMPLATED

#include <GL/gl.h>

#include <cassert>


#define CLASSFUNC2xy(cnm,typ,fnname) \
template<> \
class cnm<typ> \
{ \
public: \
  void operator ()  \
  ( \
    typ const x,  \
    typ const y  \
  ) const           \
    { fnname(x,y); } \
  template< typename U> \
  void operator () (U const & pt) \
    { fnname(pt.x,pt.y); } \
}

#define CLASSFUNC3xyz(cnm,typ,fnname) \
template<> \
class cnm<typ> \
{ \
public: \
  void operator ()  \
  ( \
    typ const x,  \
    typ const y,  \
    typ const z   \
  ) const           \
    { fnname(x,y,z); } \
  template< typename U> \
  void operator () (U const & pt) \
    { fnname(pt.x,pt.y,pt.z); } \
}

#define CLASSFUNC4xyzw(cnm,typ,fnname) \
template<> \
class cnm<typ> \
{ \
public: \
  void operator ()  \
  ( \
    typ const x,  \
    typ const y,  \
    typ const z,  \
    typ const w   \
  ) const           \
    { fnname(x,y,z,w); } \
}

#define CLASSFUNC1v(cnm,typ,fnname) \
template<> \
class cnm<typ> \
{ \
public: \
  void operator() (typ const *v ) const \
    { fnname(v); } \
}






template< typename T >
class glTranslateT
{
public:
 
  void operator () (T const x, T const y) const
    { assert(false); }
};

template< typename T >
class glVertex2T
{
public:
 
  void operator () (T const x, T const y) const
    { assert(false); }
};

template< typename T >
class glVertex3T
{
public:
  
  void operator () (T const x, T const y, T const z) const
    { assert(false); }
};

template< typename T >
class glVertex4T
{
public:
  
  void operator () 
  (
    T const x, 
    T const y, 
    T const z, 
    T const w
  ) const
    { assert(false); }
};

template< typename T >
class glVertex2Tv
{
public:
  
  void operator () ( T const *v ) const 
    { assert(false); }
};

template< typename T >
class glVertex3Tv
{
public:
  
  void operator () ( T const *v ) const 
    { assert(false); }
};

template< typename T >
class glVertex4Tv
{
public:
  
  void operator () ( T const *v ) const 
    { assert(false); }
};

template< typename T >
class glNormal3T
{
public:
  
  void operator () (T const x, T const y, T const z) const
    { assert(false); }
};

template< typename T >
class glNormal3Tv
{
public:
  
  void operator () ( T const *v ) const 
    { assert(false); }
};

template< typename T >
class glColor3T
{
public:
  
  void operator () 
  (
    T const x, 
    T const y, 
    T const z 
  ) const
    { assert(false); }
};

template< typename T >
class glColor3Tv
{
public:
  
  void operator () ( T const *v ) const 
    { assert(false); }
};

template< typename T >
class glColor4T
{
public:
  
  void operator () 
  (
    T const x, 
    T const y, 
    T const z, 
    T const w
  ) const
    { assert(false); }
};

template< typename T >
class glColor4Tv
{
public:
  
  void operator () ( T const *v ) const 
    { assert(false); }
};






//******************************************************
//  Implementation


CLASSFUNC3xyz(glTranslateT,GLdouble,glTranslated);
CLASSFUNC3xyz(glTranslateT,GLfloat,glTranslatef);

CLASSFUNC2xy(glVertex2T,GLdouble,glVertex2d);
CLASSFUNC2xy(glVertex2T,GLfloat,glVertex2f);
CLASSFUNC2xy(glVertex2T,GLint,glVertex2i);
CLASSFUNC2xy(glVertex2T,GLshort,glVertex2s);

CLASSFUNC3xyz(glVertex3T,GLdouble,glVertex3d);
CLASSFUNC3xyz(glVertex3T,GLfloat,glVertex3f);
CLASSFUNC3xyz(glVertex3T,GLint,glVertex3i);
CLASSFUNC3xyz(glVertex3T,GLshort,glVertex3s);

CLASSFUNC4xyzw(glVertex4T,GLdouble,glVertex4d);
CLASSFUNC4xyzw(glVertex4T,GLfloat,glVertex4f);
CLASSFUNC4xyzw(glVertex4T,GLint,glVertex4i);
CLASSFUNC4xyzw(glVertex4T,GLshort,glVertex4s);

CLASSFUNC1v(glVertex2Tv,GLdouble,glVertex2dv);
CLASSFUNC1v(glVertex2Tv,GLfloat,glVertex2fv);
CLASSFUNC1v(glVertex2Tv,GLint,glVertex2iv);
CLASSFUNC1v(glVertex2Tv,GLshort,glVertex2sv);

CLASSFUNC1v(glVertex3Tv,GLdouble,glVertex3dv);
CLASSFUNC1v(glVertex3Tv,GLfloat,glVertex3fv);
CLASSFUNC1v(glVertex3Tv,GLint,glVertex3iv);
CLASSFUNC1v(glVertex3Tv,GLshort,glVertex3sv);

CLASSFUNC1v(glVertex4Tv,GLdouble,glVertex4dv);
CLASSFUNC1v(glVertex4Tv,GLfloat,glVertex4fv);
CLASSFUNC1v(glVertex4Tv,GLint,glVertex4iv);
CLASSFUNC1v(glVertex4Tv,GLshort,glVertex4sv);

CLASSFUNC3xyz(glNormal3T,GLbyte,glNormal3b);
CLASSFUNC3xyz(glNormal3T,GLdouble,glNormal3d);
CLASSFUNC3xyz(glNormal3T,GLfloat,glNormal3f);
CLASSFUNC3xyz(glNormal3T,GLint,glNormal3i);
CLASSFUNC3xyz(glNormal3T,GLshort,glNormal3s);

CLASSFUNC1v(glNormal3Tv,GLbyte,glNormal3bv);
CLASSFUNC1v(glNormal3Tv,GLdouble,glNormal3dv);
CLASSFUNC1v(glNormal3Tv,GLfloat,glNormal3fv);
CLASSFUNC1v(glNormal3Tv,GLint,glNormal3iv);
CLASSFUNC1v(glNormal3Tv,GLshort,glNormal3sv);

CLASSFUNC3xyz(glColor3T,GLbyte,glColor3b);
CLASSFUNC3xyz(glColor3T,GLdouble,glColor3d);
CLASSFUNC3xyz(glColor3T,GLfloat,glColor3f);
CLASSFUNC3xyz(glColor3T,GLint,glColor3i);
CLASSFUNC3xyz(glColor3T,GLshort,glColor3s);
CLASSFUNC3xyz(glColor3T,GLubyte,glColor3ub);
CLASSFUNC3xyz(glColor3T,GLuint,glColor3ui);
CLASSFUNC3xyz(glColor3T,GLushort,glColor3us);

CLASSFUNC1v(glColor3Tv,GLbyte,glColor3bv);
CLASSFUNC1v(glColor3Tv,GLdouble,glColor3dv);
CLASSFUNC1v(glColor3Tv,GLfloat,glColor3fv);
CLASSFUNC1v(glColor3Tv,GLint,glColor3iv);
CLASSFUNC1v(glColor3Tv,GLshort,glColor3sv);
CLASSFUNC1v(glColor3Tv,GLubyte,glColor3ubv);
CLASSFUNC1v(glColor3Tv,GLuint,glColor3uiv);
CLASSFUNC1v(glColor3Tv,GLushort,glColor3usv);

CLASSFUNC4xyzw(glColor4T,GLbyte,glColor4b);
CLASSFUNC4xyzw(glColor4T,GLdouble,glColor4d);
CLASSFUNC4xyzw(glColor4T,GLfloat,glColor4f);
CLASSFUNC4xyzw(glColor4T,GLint,glColor4i);
CLASSFUNC4xyzw(glColor4T,GLshort,glColor4s);
CLASSFUNC4xyzw(glColor4T,GLubyte,glColor4ub);
CLASSFUNC4xyzw(glColor4T,GLuint,glColor4ui);
CLASSFUNC4xyzw(glColor4T,GLushort,glColor4us);

CLASSFUNC1v(glColor4Tv,GLbyte,glColor4bv);
CLASSFUNC1v(glColor4Tv,GLdouble,glColor4dv);
CLASSFUNC1v(glColor4Tv,GLfloat,glColor4fv);
CLASSFUNC1v(glColor4Tv,GLint,glColor4iv);
CLASSFUNC1v(glColor4Tv,GLshort,glColor4sv);
CLASSFUNC1v(glColor4Tv,GLubyte,glColor4ubv);
CLASSFUNC1v(glColor4Tv,GLuint,glColor4uiv);
CLASSFUNC1v(glColor4Tv,GLushort,glColor4usv);


#undef CLASSFUNC1v
#undef CLASSFUNC2xy
#undef CLASSFUNC3xyz
#undef CLASSFUNC4xyzw

#endif