GeometryGL.cpp

#include <Base/Common/W32Compat.hh>
#include "GeometryGL.hh"

// must be first
#include "biasgl.h"

#include <Base/Debug/DebugSimple.hh>
#include <Base/Debug/TimeMeasure.hh>
#include <Base/Math/Vector2.hh>
#include <Base/Math/Vector3.hh>
#include <Base/Math/Matrix3x3.hh>
#include <Base/Math/Matrix3x4.hh>
#include <Geometry/RMatrix.hh>
#include <Geometry/PMatrix.hh>

#include <Base/Image/ImageBase.hh>
#include <math.h>


// convert GLBoolean for output in stream:
#define GL2Cbool(arg) (unsigned int)(arg)<< (arg?" (true)":" (false)")


// ----------------------------------------------------------
// namespace stuff:
using namespace BIAS;
using namespace std;
// ----------------------------------------------------------

/** @author Jan Woetzel 04/2005 */

GeometryGL::~GeometryGL(){}

GeometryGL::GeometryGL(){}


void GeometryGL::GetInfoGLmatrices(std::ostream & os)
{
  GLfloat modelviewMatrix[16];
  glGetFloatv(GL_MODELVIEW_MATRIX, &modelviewMatrix[0]);
  GLfloat projectionMatrix[16];
  glGetFloatv(GL_PROJECTION_MATRIX, &projectionMatrix[0]);
  GLfloat textureMatrix0[16];
  glGetFloatv(GL_TEXTURE_MATRIX, &textureMatrix0[0]);

  unsigned int row=0;
  os << "GL_MODELVIEW_MATRIX = (column-major!)"<<endl;
  for (row=0; row<4; row++) {
    os<<std::setprecision(10)<<modelviewMatrix[row+ 0]<<" \t";
    os<<std::setprecision(10)<<modelviewMatrix[row+ 4]<<" \t";
    os<<std::setprecision(10)<<modelviewMatrix[row+ 8]<<" \t";
    os<<std::setprecision(10)<<modelviewMatrix[row+12];
    os<<endl;
  };
  os << "GL_PROJECTION_MATRIX = (column-major!) "<<endl;
  for (row=0; row<4; row++) {
    os<<std::setprecision(10)<<projectionMatrix[row+ 0]<<" \t";
    os<<std::setprecision(10)<<projectionMatrix[row+ 4]<<" \t";
    os<<std::setprecision(10)<<projectionMatrix[row+ 8]<<" \t";
    os<<std::setprecision(10)<<projectionMatrix[row+12];
    os<<endl;
  };
  os << "GL_TEXTURE_MATRIX = (column-major!) "<<endl;
  for (row=0; row<4; row++) {
    os<<std::setprecision(10)<<textureMatrix0[row+ 0]<<" \t";
    os<<std::setprecision(10)<<textureMatrix0[row+ 4]<<" \t";
    os<<std::setprecision(10)<<textureMatrix0[row+ 8]<<" \t";
    os<<std::setprecision(10)<<textureMatrix0[row+12];
    os<<endl;
  };
  CHECK_GL_ERROR;
}


void GeometryGL::GetInfoGLDisplayLists(std::ostream & os)
{
  unsigned int i=0;
  // query all available display lists
  int foundDisplists=0;
  for (i=0; i<MAX_GL_DISPLIST_ID; i++)
  {
    if(glIsList(i) == GL_TRUE)
    {
      foundDisplists++;
      os<<"valid displaylistID="<<i<<endl;
    };
  };
  os<<"** found a total of "<<foundDisplists<<" valid display lists/IDs <MAX_GL_DISPLIST_ID="<<MAX_GL_DISPLIST_ID<<" **"<<endl;
}


void GeometryGL::GetInfoGLTexID(const GLint id,
                                int & foundTextures,
                                std::ostream & os,
                                const bool & noOutputIfInvalid)
{
  if (!glIsTexture(id)) {
    if (!noOutputIfInvalid)
      os<<"texid="<<id<<" invalid."<<endl;
    return;
  }

  // query residence and priority status of all texobj's
  GLint target=GL_TEXTURE_2D;
  GLint resident=GL_FALSE;
  GLfloat priority=0;
  GLint width=0, height=0;
  GLint min_tex=0, mag_tex=0;
  GLint tex_state=0;
  GLint tex_env=0;
  GLint int_fmt=0;
  GLint components=0, red=0, green=0, blue=0, alpha=0;

  foundTextures++;
  glBindTexture(GL_TEXTURE_2D, id );
  glGetIntegerv(GL_TEXTURE_2D, &tex_state);

  glGetTexParameteriv(target, GL_TEXTURE_WIDTH,      &width);
  glGetTexParameteriv(target, GL_TEXTURE_HEIGHT,     &height);
  glGetTexParameteriv(target, GL_TEXTURE_INTERNAL_FORMAT, &int_fmt);
  glGetTexParameteriv(target, GL_TEXTURE_COMPONENTS, &components );
  glGetTexParameteriv(target, GL_TEXTURE_RED_SIZE,   &red);
  glGetTexParameteriv(target, GL_TEXTURE_GREEN_SIZE, &green);
  glGetTexParameteriv(target, GL_TEXTURE_BLUE_SIZE,  &blue);
  glGetTexParameteriv(target, GL_TEXTURE_ALPHA_SIZE, &alpha);

  glGetTexParameteriv(target, GL_TEXTURE_MAG_FILTER, &mag_tex);
  glGetTexParameteriv(target, GL_TEXTURE_MIN_FILTER, &min_tex);
  glGetTexParameteriv(target, GL_TEXTURE_RESIDENT,   &resident);
  glGetTexParameterfv(target, GL_TEXTURE_PRIORITY,   &priority);

  glGetTexEnviv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &tex_env);

  CHECK_GL_ERROR;
  os<<"valid texID="<<id<<" : "<<endl;
  os<<"\tminifiction   filter = "<<GetName(min_tex)<<endl;
  os<<"\tmagnifictaion filter = "<<GetName(mag_tex)<<endl;
  //target="<<GetName(target)
  os<<"\tdim          "<<width<<" x "<<height<<endl;
  os<<"\tcomponents   "<<components<<endl;
  os<<"\ttex red   bits "<<red<<endl;
  os<<"\ttex green bits "<<green<<endl;
  os<<"\ttex blue  bits "<<blue<<endl;
  os<<"\ttex alpha bits "<<alpha<<endl;

  os<<"\tinternal_fmt="<<GetName(int_fmt)<<endl;
  os<<"\ttex_state   ="<<GetName(tex_state)<<endl;
  os<<"\ttex_env     ="<<GetName(tex_env)<<endl;
  os<<"\tresident="<<GetName(resident)<<" priority="<<(float)priority<<endl;
  const unsigned int maxLevels=(unsigned int)(log((float)max(width,height))/log(2.0f));
  for (int level=-1*(int)(maxLevels); level<=(int)maxLevels; level++){
    //GL_PROXY_TEXTURE_2D
    glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH,  &width);
    glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
    CHECK_GL_ERROR;
    if ((width!=0) || (height!=0))
    {
      // can use that texture
      os<<"\t"<<level<<". level dim: "<<width<<"x"<<height<<endl;
    }
  }
}


void GeometryGL::GetInfoGLTexObjects(std::ostream & os)
{
  int foundTextures=0;
  for (unsigned int id=0; id<MAX_GL_TEXOBJ_ID; id++)
  {
    GetInfoGLTexID(id, foundTextures, os);
  }
  os<<"** found a total of "<<foundTextures<<" validtextures/IDs <MAX_GL_TEXOBJ_ID="<<MAX_GL_TEXOBJ_ID<<" **"<<endl;
}


// TODO implement as macro: JW
void GeometryGL::GetInfoGLenvironment(std::ostream & os)
{
  // get OpenGL info strings into std. strings:
  if ( NULL==(char *) glGetString(GL_VENDOR)) {
    BIASERR("No Context available (NULL ptr). Skipping RenderGL::GetInfo."<<endl<<flush);;
    //CheckGLError();
    return;
  };
#ifdef BIAS_HAVE_GLEW
  string strGlewVersion = (char*) glewGetString(GLEW_VERSION);
#endif // BIAS_HAVE_GLEW
  string strVendor     = (char *) glGetString(GL_VENDOR);
  string strRenderer   = (char *) glGetString(GL_RENDERER);
  string strVersion    = (char *) glGetString(GL_VERSION);
  string strExtensions = (char *) glGetString(GL_EXTENSIONS);
  //strExtensions  = (char*) wglGetExtensionsStringARB();
  // replace blank by newline:
  unsigned int index = 0;
  while ((index = strExtensions.find(' ', index)) != string::npos)
    strExtensions[index++] = '\n';

  // only on Win32
  string strWglExtensions;
#ifdef WIN32
#  ifdef BIAS_HAVE_GLEW
  if (WGLEW_EXT_extensions_string)
  {
    strWglExtensions = (char*) wglGetExtensionsStringEXT();
    CHECK_GL_ERROR;
    // replace blank by newline:
    index = 0;
    while ((index = strWglExtensions.find(' ', index)) != string::npos)
      strWglExtensions[index++]='\n';
  };
#  endif // BIAS_HAVE_GLEW
#endif // WIN32

  GLint max_texture_units=0;
#if defined(BIAS_HAVE_GLEW)
  glGetIntegerv(GL_MAX_TEXTURE_UNITS, &max_texture_units);
  //CHECK_GL_ERROR;
#endif

  GLint max_texture_image_units=0;
#ifdef BIAS_HAVE_GLEW
  glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_image_units);
#endif // BIAS_HAVE_GLEW


//#if defined(BIAS_HAVE_GLEW)
//  GLint max_general_combiners=0;
//  glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &max_general_combiners);
//#endif
  //CHECK_GL_ERROR;
  //GLint max_vertex_units;
  //glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &max_vertex_units);
  //CHECK_GL_ERROR;
  //GLint max_vertex_shader_instructions;
  //glGetIntegerv(GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT, &max_vertex_shader_instructions);
  //CHECK_GL_ERROR;

  GLint red_bits;
  glGetIntegerv(GL_RED_BITS, &red_bits);
  GLint green_bits;
  glGetIntegerv(GL_GREEN_BITS, &green_bits);
  GLint blue_bits;
  glGetIntegerv(GL_BLUE_BITS, &blue_bits);
  GLint alpha_bits;
  glGetIntegerv(GL_ALPHA_BITS, &alpha_bits);
  GLfloat alpha_bias;
  glGetFloatv(GL_ALPHA_BIAS, &alpha_bias);
  GLfloat alpha_scale;
  glGetFloatv(GL_ALPHA_SCALE, &alpha_scale);
  GLboolean cull_face;
  glGetBooleanv(GL_CULL_FACE, &cull_face);
  GLfloat depth_scale;
  glGetFloatv(GL_DEPTH_SCALE, &depth_scale);
  GLint depth_bits;
  glGetIntegerv(GL_DEPTH_BITS, &depth_bits);
  GLfloat depth_bias;
  glGetFloatv(GL_DEPTH_BIAS, &depth_bias);
  GLfloat depth_range[2];
  glGetFloatv(GL_DEPTH_BIAS, &depth_range[0]);
  GLfloat depth_clear_value;
  glGetFloatv(GL_DEPTH_CLEAR_VALUE, &depth_clear_value);
  GLboolean fog;
  glGetBooleanv(GL_FOG, &fog);
  GLfloat line_width;
  glGetFloatv(GL_LINE_WIDTH, &line_width);
  GLboolean lighting;
  glGetBooleanv(GL_LIGHTING, &lighting);
  GLint max_modelview_stack_depth;
  glGetIntegerv(GL_MAX_MODELVIEW_STACK_DEPTH, &max_modelview_stack_depth);
  GLint max_projection_stack_depth;
  glGetIntegerv(GL_MAX_PROJECTION_STACK_DEPTH, &max_projection_stack_depth);
  GLint max_texture_stack_depth;
  glGetIntegerv(GL_MAX_TEXTURE_STACK_DEPTH, &max_texture_stack_depth);
  GLint max_texture_size;
  glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
  GLint max_viewport_dims[2];
  glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_viewport_dims[0]);
  GLint name_stack_depth;
  glGetIntegerv(GL_NAME_STACK_DEPTH, &name_stack_depth);
  GLint max_name_stack_depth;
  glGetIntegerv(GL_MAX_NAME_STACK_DEPTH, &max_name_stack_depth);
  GLint point_size;
  glGetIntegerv(GL_POINT_SIZE, &point_size);
  GLint point_size_range[2];
  glGetIntegerv(GL_POINT_SIZE_RANGE, &point_size_range[0]);
  GLboolean rgba_mode;
  glGetBooleanv(GL_RGBA_MODE, &rgba_mode);
  GLboolean stencil_test;
  glGetBooleanv(GL_STENCIL_TEST, &stencil_test);
  GLint stencil_bits;
  glGetIntegerv(GL_STENCIL_BITS, &stencil_bits);

  GLint draw_buffer;
  glGetIntegerv(GL_DRAW_BUFFER, &draw_buffer);
  GLint aux_buffers;
  glGetIntegerv(GL_AUX_BUFFERS, &aux_buffers);
  GLboolean double_buffer;
  glGetBooleanv(GL_DOUBLEBUFFER, &double_buffer);
  GLboolean stereo;
  glGetBooleanv(GL_STEREO, &stereo);
  GLint polygon_mode[2];
  glGetIntegerv(GL_POLYGON_MODE, &polygon_mode[0]);
  GLint max_cube_map_texture_size=0;
#if defined(BIAS_HAVE_GLEW)
  glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT, &max_cube_map_texture_size);
#endif

  GLint viewport[4];
  glGetIntegerv(GL_VIEWPORT, &viewport[0]);
  CHECK_GL_ERROR;

  GLint max_texture_lod_bias=0;
#if defined(BIAS_HAVE_GLEW)
  glGetIntegerv(GL_MAX_TEXTURE_LOD_BIAS_EXT, &max_texture_lod_bias);
  //CHECK_GL_ERROR;
#endif


  os << "Getting Info about OpenGL: " << endl;
#ifdef BIAS_HAVE_GLEW
  os << "GLEW_VERSION = " << strGlewVersion  << endl;
#endif // BIAS_HAVE_GLEW
  os << "GL_VENDOR    = " << strVendor << endl;
  os << "GL_RENDERER  = " << strRenderer << endl;
  os << "GL_VERSION   = " << strVersion << endl;
  os << "* GL_EXTENSIONS:  " << endl << strExtensions << endl;
  os << "* WGL_EXTENSIONS: " << endl << strWglExtensions << endl;

  os << endl;

  os<<"GL_RED_BITS  = "<<red_bits<<endl;
  os<<"GL_GREEN_BITS= "<<green_bits<<endl;
  os<<"GL_BLUE_BITS = "<<blue_bits<<endl;
  os<<"GL_ALPHA_BITS= "<<alpha_bits<<endl;
  os<<"GL_DEPTH_BITS  ="<<depth_bits<<endl;
  os<<"GL_STENCIL_BITS="<<stencil_bits<< endl;

  os << "GL_MAX_TEXTURE_UNITS= "<<max_texture_units<<" (detected texture units)" << endl;
  os << "GL_MAX_TEXTURE_IMAGE_UNITS= " << max_texture_image_units <<endl;
//#if defined(BIAS_HAVE_GLEW)
//  os << "GL_MAX_GENERAL_COMBINERS_NV= " << max_general_combiners<<endl;
//#endif
  //os << "GL_MAX_VERTEX_UNITS = " << max_vertex_units <<" (detected vertex units)" << endl;
  //os << "GL_MAX_VERTEX_SHADER_INSTRUCTIONS= "<<max_vertex_shader_instructions << endl;
  os << "GL_ALPHA_SCALE      = " << alpha_scale << endl;
  os << "GL_ALPHA_BIAS       = " << alpha_bias << endl;
  os << "GL_CULL_FACE        = " << GL2Cbool(cull_face) << endl;
  os << "GL_STENCIL_TEST     = " << GL2Cbool(stencil_test) << endl;
  os << "GL_DEPTH_SCALE      = " << depth_scale << endl;
  os << "GL_DEPTH_BIAS       = " << depth_bias << endl;
  os << "GL_DEPTH_RANGE      = " << depth_range[0] << " " <<depth_range[1] << endl;
  os << "GL_DEPTH_CLEAR_VALUE= " << depth_clear_value << endl;
  os << "GL_DRAW_BUFFER      = " << GetName(draw_buffer)<<endl;
  os << "GL_AUX_BUFFERS      = " << aux_buffers <<endl;
  os << "GL_DOUBLE_BUFFER    = " << GL2Cbool(double_buffer)<<endl;
  os << "GL_STEREO           = " << GL2Cbool(stereo);
  if (stereo) os<<" (but not neccessarily enabled)"<<endl;

  os << "GL_FOG              = " << GL2Cbool(fog) << endl;
  os << "GL_LINE_WIDTH       = " << line_width << endl;
  os << "GL_LIGHTING         = " << GL2Cbool(lighting) << endl;
  os << "GL_MAX_MODELVIEW_STACK_DEPTH = " <<max_modelview_stack_depth << endl;
  os << "GL_MAX_PROJECTION_STACK_DEPTH= " <<max_projection_stack_depth << endl;
  os << "GL_MAX_TEXTURE_LOD_BIAS_EXT  = " << max_texture_lod_bias << endl;
  os << "GL_MAX_TEXTURE_STACK_DEPTH   = " << max_texture_stack_depth<< endl;
  os << "GL_MAX_TEXTURE_SIZE = " << max_texture_size << endl;
  os << "GL_MAX_VIEWPORT_DIMS= " << max_viewport_dims[0]
  <<" "<<max_viewport_dims[1] << endl;
  os << "GL_POINT_SIZE       = " << point_size << endl;
  os << "GL_POINT_SIZE_RANGE = " << point_size_range[0]
  <<" "<<point_size_range[1] << endl;

  os << "GL_MAX_CUBE_MAP_TEXTURE_SIZE="<<max_cube_map_texture_size<<endl;

  os << "GL_MAX_NAME_STACK_DEPTH = " << max_name_stack_depth<<endl;
  os << "GL_NAME_STACK_DEPTH = " << name_stack_depth<<endl;

  os << "GL_POLYGON_MODE     = ("<<GetName(polygon_mode[0])<<", "<<GetName(polygon_mode[1])<<")"<<endl;
  os << "GL_RGBA_MODE        = " << GL2Cbool(rgba_mode) << endl;
  os << "GL_VIEWPORT         = x="<<viewport[0]<<" y="<<viewport[1]<<" w="<<viewport[2]<<" h="<<viewport[3]<<endl;
}


void GeometryGL::GetInfoGLWriteMasks(std::ostream & os)
{
  // write masks
  GLboolean depth_writemask;
  glGetBooleanv(GL_DEPTH_WRITEMASK, &depth_writemask);

  GLboolean color_writemask[4]  = {false,false,false,false};
  glGetBooleanv(GL_COLOR_WRITEMASK, color_writemask);

  GLboolean stencil_writemask;
  glGetBooleanv(GL_STENCIL_WRITEMASK, &stencil_writemask);

  GLboolean index_writemask;
  glGetBooleanv(GL_INDEX_WRITEMASK, &index_writemask);

  os<<"GL_DEPTH_WRITEMASK   = "<<depth_writemask<<endl;
  os<<"GL_COLOR_WRITEMASK   = "
    <<color_writemask[0]<<" "
    <<color_writemask[1]<<" "
    <<color_writemask[2]<<" "
    <<color_writemask[3]<<" "
    <<endl;
  os<<"GL_STENCIL_WRITEMASK = "<<stencil_writemask<<endl;
  os<<"GL_INDEX_WRITEMASK   = "<<index_writemask<<endl;
}


void GeometryGL::GetInfoGL(std::ostream & os)
{
  GetInfoGLenvironment(os);
  GetInfoGLWriteMasks(os);
  GetInfoGLmatrices(os);
  GetInfoGLDisplayLists(os);
  GetInfoGLTexObjects(os);

  glGetError();
}


// static
void GeometryGL::DisplayClear(const GLbitfield & mask)
{
  CHECK_GL_ERROR;

  // set values for clear:
  glClearColor(0, 0, 0, 0); // rgba [0,1]
  glClearDepth(1.0);
  glClearAccum(0,0,0,0);
  glClearStencil(0);
  glClearIndex(0);

  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); // no color mask RGBA

  // perform clear operation:
  //glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ACCUM_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
  glClear( mask );

  // set gl states (on or off)
  glDisable(GL_ALPHA_TEST);
  glDisable(GL_LIGHTING);

  // counter clockwise on screen is front face:
  glFrontFace(GL_CCW);
  glDisable(GL_CULL_FACE);
  glDisable(GL_FOG);
  glDisable(GL_NORMALIZE); // just for glNormal

  //glDisable(GL_DEPTH_TEST);
  glEnable(GL_DEPTH_TEST);

  glDisable(GL_BLEND);

  glDisable(GL_STENCIL_TEST);
  //glEnable(GL_STENCIL_TEST);

  glDisable(GL_TEXTURE_2D);
  //glDisable(GL_TEXTURE_RECTANGLE_NV); // non-pow2 textures?

  // set compare functions
  glDepthFunc(GL_LEQUAL);
  glAlphaFunc(GL_LEQUAL, (GLclampf)1 );

  // set matrices:
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glMatrixMode(GL_TEXTURE);
  glLoadIdentity();
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  CHECK_GL_ERROR;
}


void GeometryGL::DisplayRenderMode(const BIAS::RenderModeGL  & m)
{
  CHECK_GL_ERROR;
  glPolygonMode(GL_FRONT, m.polygonmodeFRONT);
  glPolygonMode(GL_BACK,  m.polygonmodeBACK);

  glShadeModel(m.shademodel);

  glEnable(GL_CULL_FACE);
  glCullFace(m.cullface);
  if (m.enable_cullface) {
    glEnable(GL_CULL_FACE);
  } else {
    glDisable(GL_CULL_FACE);
  };

  glPointSize(m.pointsize);
  glLineWidth(m.linewidth);

  CHECK_GL_ERROR;
}


void
GeometryGL::DisplaySimpleAnimation(const double & time)
{
  //COUT("DBG time="<<time<<endl);

  // animation: rotate depending on current time
  glRotated(
    time, /*angle*/
    0,1,1 /* axis */
    );

  DisplaySceneExampleSimple();
}


void
GeometryGL::DisplaySceneExampleSimple()
{
  // A simple scene not using push or pop
  glDisable(GL_LIGHTING); // may be switched on/off for every object
  glEnable(GL_DEPTH_TEST); // depth buffer occlusions of objects
  glShadeModel(GL_SMOOTH);

  const float z = 1.0f;
  const float xd= 0.9f; // x dimension
  const float yd= 0.9f; // y dimension

  // 3 2
  // 0 1
  BIAS::Vector3<float> p0(-xd, -yd, z);
  BIAS::Vector3<float> p1( xd, -yd, z);
  BIAS::Vector3<float> p2( xd,  yd, z);
  BIAS::Vector3<float> p3(-xd,  yd, z);

  {
    glBegin(GL_QUADS);
    glColor3f(1,0,0);  // red 0
    glVertex3fv( &(p0[0]));

    glColor3f(0,1,0); // green 1
    glVertex3fv( &(p1[0]));

    glColor3f(0,0,1); // blue 2
    glVertex3fv( &(p2[0]));

    glColor3f(1,1,1); // white 3
    glVertex3fv( &(p3[0]));
    glEnd();

    GeometryGL::DisplayCoordCross();
  }
  CHECK_GL_ERROR;
}

#ifdef BIAS_HAVE_FONTGL
void GeometryGL::DisplayCoordCross(const float & size,
                                   const float & linewidth,
                                   const BIAS::DrawTextGL & font,
                                   const std::string & LabelX,
                                   const std::string & LabelY,
                                   const std::string & LabelZ )
{
  DisplayCoordCrossAxesLabel(size, font, LabelX, LabelY, LabelZ);
  DisplayCoordCross(size, linewidth);
}


void GeometryGL::DisplayCoordCrossAxesLabel(const float & size,
                                            const DrawTextGL & font,
                                            const std::string & LabelX,
                                            const std::string & LabelY,
                                            const std::string & LabelZ )
{
  if (!font.IsInitialized()) {
    BIASERR("font not initialized. Please do it on your OpenGLCanvas (because of the context). aborting");
    return;
  }
  // X
  glColor3f(
    1.0f, 0.0f, 0.0f);
  font.Print3D(LabelX,
    size, 0.0f, 0.0f);

  // Y
  glColor3f(
    0.0f, 1.0f, 0.0f);
  font.Print3D(LabelY,
    0.0f, size, 0.0f);

  // Z
  glColor3f(
    0.0f, 0.0f, 1.0f);
  font.Print3D(LabelZ,
    0.0f, 0.0f, size);
}
#endif //BIAS_HAVE_FONTGL

void GeometryGL::DisplayCoordCross(const float & size,
                                   const float & linewidth )
{

  // X-axis:
  glDisable(GL_TEXTURE_2D);
  glDisable(GL_LIGHTING);

  if ((linewidth>=1.0) && (linewidth<32.0))
    glLineWidth((GLfloat)linewidth);
  else
    glLineWidth((GLfloat)1.0);

  glColor4f(1,0,0, VISIBLEALPHA); // r
  glBegin(GL_LINES);
  glVertex3f(0,0,0);
  glVertex3f(size,0,0);
  glEnd();
  // Y-axis:
  glColor4f(0,1,0, VISIBLEALPHA); // g
  glBegin(GL_LINES);
  glVertex3f(0,0,0);
  glVertex3f(0,size,0);
  glEnd();
  // Z-axis:
  glColor4f(0,0,1, VISIBLEALPHA); // r
  glBegin(GL_LINES);
  glVertex3f(0,0,0);
  glVertex3f(0,0,size);
  glEnd();
}



void
GeometryGL::DisplayCameraInternalParams(
                                        const int & x0,
                                        const int & y0,
                                        const unsigned int & width,
                                        const unsigned int & height,
                                        const float & fovY,
                                        const float & zNear,
                                        const float & zFar )
{
  BIASASSERT(width>=0);
  BIASASSERT(height>=0);
  BIASASSERT(fovY>0.0);// min. field of view Y (in deg.)
  BIASASSERT(fovY<180.0); // max field of view Y (in deg.)

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  float aspect=1.0;
  if ((height==0) || (width==0)) {
    // degenerate case
    aspect = 1.0;
  } else {
    aspect = (float)width/(float)height;
  };
  //COUT("DBG aspect w/h = "<<aspect<<endl);
  gluPerspective(fovY,
    aspect,
    zNear, zFar);

  // pixel rasterization=which part of image plane:  origin, w, h
  glViewport((GLint)x0, (GLint)y0,
    (GLsizei)width, (GLsizei)height);

}



void GeometryGL::DisplayCameraExternalParams(BIAS::PMatrix & P){
  GeometryGL::DisplayCameraExternalParams(
    P.GetC()
    ,P.GetV() // P.GetUp_gl()
    ,P.GetA()
    );
}


void GeometryGL::DisplayCameraExternalParams(const BIAS::Vector3<double> & C,
                                             const BIAS::Vector3<double> & up,
                                             const BIAS::Vector3<double> & a  )
{
  // pose and orientation of the camera (where is it looking at)
  Vector3<double> viewAt = C + a;

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  gluLookAt((GLdouble)C[0],
    (GLdouble)C[1],
    (GLdouble)C[2],
    (GLdouble)viewAt[0],
    (GLdouble)viewAt[1],
    (GLdouble)viewAt[2],
    (GLdouble)up[0],
    (GLdouble)up[1],
    (GLdouble)up[2]
    );
}


BIAS::Vector2<double>
GeometryGL::GetImgCorner2d( const unsigned int & w
                           ,const unsigned int & h
                           ,const unsigned int & corner
                           ,const int texMode
                           ,const bool flipY )
{
  float width = 1.0;
  float height= 1.0;

#if defined(BIAS_HAVE_GLEW)
  if (texMode==GL_TEXTURE_RECTANGLE_NV)
  {
    // TexRECT has pixel coordinates NOT normalized and possibly non-pow2
    // texRect dim is in pixel, e.g. 0..1024
    width  = float( w );
    height = float( h );
  } else
#endif
  {
    // pow2 texture has normalized coordinates
    // assign the fractional (filled) part.
    BIASASSERT(w <= BIAS::ImageBase::PowerOfTwoSize(w) );
    BIASASSERT(h <= BIAS::ImageBase::PowerOfTwoSize(h) );
    width  = float(w) / float(BIAS::ImageBase::PowerOfTwoSize(w));
    //float tmp = BIAS::ImageBase::PowerOfTwoSize(h);
    height = float(h) / float(BIAS::ImageBase::PowerOfTwoSize(h));
  };
  BIASASSERT(0<width);
  BIASASSERT(0<height);

  // return texture coordinates in OpenGL coordinate system
  switch (corner)
  {
  case LOWER_LEFT:
    if (flipY) return Vector2<double>(0.0, height);
    return Vector2<double>(0.0, 0.0);
    break;
  case LOWER_RIGHT:
    if (flipY) return Vector2<double>(width, height);
    return Vector2<double>(width, 0.0);
    break;
  case UPPER_RIGHT:
    if (flipY) return Vector2<double>(width, 0.0);
    return Vector2<double>(width, height);
    break;
  case UPPER_LEFT:
    if (flipY) return Vector2<double>(0.0, 0.0);
    return Vector2<double>(0.0, height);
    break;
  default:
    BIASERR("corner="<<corner<<" invalid."<<endl);
    return Vector2<double>(0.0, 0.0);
  };
}


/** compute 3D pos. of P in OpenGL coordinate system
TODO: move this to PMatrix with addition imgDim parameter JW */
BIAS::Vector3<double>
GeometryGL::GetImgCorner3d(BIAS::PMatrix & P
                           ,const unsigned int & w
                           ,const unsigned int & h
                           ,const unsigned int & corner
                           ,const double & scale )
{
  HomgPoint2D p2d(0,0, 1);
  BIAS::Vector3<double> p3d(0,0,0);

  // these pixel coordinates are in MIP coordinaet system:
  switch (corner)
  {
  case LOWER_LEFT:
    p2d.Set(0,h, 1);
    break;
  case LOWER_RIGHT:
    p2d.Set(w,h, 1);
    break;
  case UPPER_RIGHT:
    p2d.Set(w,0, 1);
    break;
  case UPPER_LEFT:
    p2d.Set(0,0, 1);
    break;
  case OPTICAL_CENTER:
    p2d.Set( P.GetK().GetHx()
      ,P.GetK().GetHy()
      ,1);
    break;
  default:
    BIASERR("corner="<<corner<<" invalid."<<endl);
    return p3d;
  };

  Vector3< double > dir; // vector from C to 3D point
  dir = P.GetRayWorldCoo(p2d);
  dir.Normalize(); // length 1
  p3d = P.GetC() + scale * dir;

  return p3d;
}


void GeometryGL::DisplayImgPlaneTextured(BIAS::PMatrix & P
                                         ,const unsigned int & w
                                         ,const unsigned int & h
                                         ,const int & texID
                                         ,const int & texTarget
                                         ,const double & scale
                                         ,const bool & flipY
                                         ,const BIAS::Vector4<float> & vertexColor)
{
  // Display the image plane at a distant scale from projection center textured:
  BIASASSERT( GL_TRUE == glIsTexture( texID ) ); // success ?
  glEnable( texTarget );
  glBindTexture(texTarget, texID );
  //glActiveTexture(GL_TEXTURE0);
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  CHECK_GL_ERROR;

  // fancy pink in case of texturing error:
  //glColor4d(1.0, 0.0, 1.0, VISIBLEALPHA);
  glColor4fv( & vertexColor[0] );
  glBegin(GL_QUADS);
  glTexCoord2dv( & GetImgCorner2d(w,h, LOWER_LEFT, texTarget, flipY)[0] );
  glVertex3dv( & GetImgCorner3d(P,w,h, LOWER_LEFT, scale)[0]);

  glTexCoord2dv( & GetImgCorner2d(w,h, LOWER_RIGHT, texTarget, flipY)[0] );
  glVertex3dv( & GetImgCorner3d(P,w,h, LOWER_RIGHT, scale)[0] );

  glTexCoord2dv( & GetImgCorner2d(w,h, UPPER_RIGHT, texTarget, flipY)[0] );
  glVertex3dv( & GetImgCorner3d(P,w,h, UPPER_RIGHT, scale)[0] );

  glTexCoord2dv( & GetImgCorner2d(w,h, UPPER_LEFT, texTarget, flipY)[0] );
  glVertex3dv( & GetImgCorner3d(P,w,h, UPPER_LEFT, scale)[0] );
  glEnd();
}




void GeometryGL::DisplayP(BIAS::PMatrix & P
                          ,const unsigned int & w
                          ,const unsigned int & h
                          ,const double & scale
                          ,const float & linewidth
                          )
{
  //Vector3<double> C(0,0,0);
  Vector3<double> C( P.GetC() );

  const float alpha = VISIBLEALPHA;

  // Display textured image plane
  //DisplayImgPlaneTextured(cam, scale);

  glDisable(GL_TEXTURE_2D);
  glLineWidth(linewidth);

  // rectangle between image corners
  glBegin(GL_LINE_LOOP);
  glColor4f(0,1,0, alpha); // plane corners green
  glVertex4d( GetImgCorner3d(P,w,h, LOWER_LEFT, scale)[0],
    GetImgCorner3d(P,w,h, LOWER_LEFT, scale)[1],
    GetImgCorner3d(P,w,h, LOWER_LEFT, scale)[2],
    1.0
    );

  //glVertex3dv( & GetImgCorner3d(P,w,h, LOWER_LEFT, scale)[0] );
  glVertex3dv( & GetImgCorner3d(P,w,h, LOWER_RIGHT,scale)[0] );
  glVertex3dv( & GetImgCorner3d(P,w,h, UPPER_RIGHT,scale)[0] );
  glVertex3dv( & GetImgCorner3d(P,w,h, UPPER_LEFT, scale)[0] );
  glEnd();

  glBegin(GL_LINES);
  // Display view vector from red=C=eye=red to center=blue
  glColor4f(1,0,0, alpha); // eye=red
  glVertex3dv( & C[0] );
  glColor4f(0,0,1, alpha); // blue
  glVertex3dv( & GetImgCorner3d(P,w,h, OPTICAL_CENTER, scale)[0] );

  // connect eye=center to all 4 corners
  glColor4f(0,1,0, alpha); // plane corners green
  glVertex3dv( & GetImgCorner3d(P,w,h, LOWER_LEFT, scale)[0] );
  glColor4f(1,0,0, alpha); // center=red
  glVertex3dv( & C[0] );

  glColor4f(0,1,0, alpha); // plane corners green
  glVertex3dv( & GetImgCorner3d(P,w,h, LOWER_RIGHT, scale)[0] );
  glColor4f(1,0,0, alpha); // center=red
  glVertex3dv( & C[0] );

  glColor4f(0,1,0, alpha); // plane corners green
  glVertex3dv( & GetImgCorner3d(P,w,h, UPPER_LEFT, scale)[0] );
  glColor4f(1,0,0, alpha); // center=red
  glVertex3dv( & C[0] );

  glColor4f(0,1,0, alpha); // plane corners green
  glVertex3dv( & GetImgCorner3d(P,w,h, UPPER_RIGHT, scale)[0] );
  glColor4f(1,0,0, alpha); // center=red
  glVertex3dv( & C[0] );
  glEnd();
}



BIAS::Matrix4x4<double>
GeometryGL::CreateTextureMatrix(BIAS::PMatrix & P
                                ,const unsigned int w
                                ,const unsigned int h
                                ,const bool & useRECTcoord )
{
  Matrix4x4<double> result;
  result.SetIdentity();

  // HACK: determine next pow2 depending on RECT or POW2 texture.
  //Vector2<unsigned int> RescaledDimension(1024,768);

  // scaleMatrix for normalization
  Matrix3x3<double> Mat;
  Mat.SetIdentity();
  //Mat[0][2] =  1.0; //hx
  //Mat[1][2] =  1.0; //hy

  // normalized power of two coords required (RECT otherwise)
  if (!useRECTcoord ) {
    Mat[0][0] =  1.0/w;
    Mat[1][1] =  1.0/h;
    //Mat[0][2] =  1.0/w;
    //Mat[1][2] =  1.0/h;
  }

  // transform workaround...
  Matrix3x4<double> newP;
  newP = Mat * P;

  // create transposed special 4x4 marix of PTexture
  // for OpenGL
  // old line 2 will become 3 (for projective comp.)
  // new line 2 will be filled with 0 to removed z-component
  for (int s=0; s<4; s++) {
    result[0][s] = newP[0][s];
    result[1][s] = newP[1][s];
    result[2][s] = 0.0;
    result[3][s] = newP[2][s];
  }

  // normalize all elements by W (lower right)
  result /= result[3][3];

  return result;
}



void GeometryGL::DisplayQuadTexCoord2DFull(const BIAS::ImgObjGL & texobj,
                                           const bool & additionalFlipY)
{
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();
  {
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glPushMatrix();
    {
      DisplayQuadTexCoord2D(texobj, additionalFlipY);
    }
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
  }
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
}

void GeometryGL::DisplayQuadTexCoord2D(const BIAS::ImgObjGL & texobj,
                                       const bool & additionalFlipY)
{
  CHECK_GL_ERROR;
  BIASASSERT(texobj.widthOrig>0);
  BIASASSERT(texobj.heightOrig>0);
  BIASASSERT(glIsTexture(texobj.id));
  CHECK_GL_ERROR;

  // pow2 texture dim is normalized to 0..1
  float width = 1.0f;
  float height= 1.0f;

  if (texobj.IsRectangleTexture()){
    // texRect dim is in pixel, e.g. 0..1024
    width  = (float) texobj.widthOrig;
    height = (float) texobj.heightOrig;
  } else
    //if (texobj.IsTexture2D())
  {
    // pow2 texture which may be used partially, only.
    //width = 1.0f;
    //height= 1.0f;
    width = float(texobj.widthOrig)  / float(texobj.widthBrutto);
    height= float(texobj.heightOrig) / float(texobj.heightBrutto);
    //} else {
    //  BIASERR("unsupported. Neither RECT nor 2D texture.");
    //  BIASBREAK;
  }
  // 3 2
  // 0 1
  BIAS::Vector2<float> tc0, tc1, tc2, tc3; // 2d RECT texcoords
  if (!additionalFlipY) {
    // OpenGL orientation Y up (=Y is NOT flipped)
    tc0.Set(0,      0 );
    tc1.Set( width, 0 );
    tc2.Set( width, height);
    tc3.Set( 0,     height);
  } else {
    // y is flipped (MIP img orientation)
    tc0.Set(0,      height );
    tc1.Set( width, height );
    tc2.Set( width, 0);
    tc3.Set( 0,     0);
  };

  // enable texture mapping:
  //glPushAttrib( texobj.target );

#ifdef BIAS_HAVE_GLEW
  glActiveTexture( GL_TEXTURE0 );
#endif // BIAS_HAVE_GLEW
  // the rest of multitexturing is left to the caller
  glEnable( texobj.target );
  glBindTexture(texobj.target, texobj.id );
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
  CHECK_GL_ERROR;
  glTexParameteri(texobj.target, GL_TEXTURE_MIN_FILTER, texobj.minificationMode);
  glTexParameteri(texobj.target, GL_TEXTURE_MAG_FILTER, texobj.magnificationMode);
  CHECK_GL_ERROR;

  glColor3f(1, 1, 0); // pink - fallback color
  //const float z = -1.0;
  const float z = 0;

#ifdef BIAS_HAVE_GLEW
  // for multitexturing:
  const unsigned int maxTU=4;
  unsigned int i=0;
#endif // BIAS_HAVE_GLEW

  glBegin(GL_QUADS);
  glTexCoord2fv( &tc0[0] );
#ifdef BIAS_HAVE_GLEW
  for (i=0; i<maxTU;i++)
    glMultiTexCoord2fv(GL_TEXTURE0+i, &tc0[0]);
#endif // BIAS_HAVE_GLEW
  glVertex3f(-1,-1, z);
  glTexCoord2fv(&tc1[0]);
#ifdef BIAS_HAVE_GLEW
  for (i=0; i<maxTU;i++)
    glMultiTexCoord2fv(GL_TEXTURE0+i, &tc1[0]);
#endif // BIAS_HAVE_GLEW
  glVertex3f( 1,-1, z);
  glTexCoord2fv(&tc2[0]);
#ifdef BIAS_HAVE_GLEW
  for (i=0; i<maxTU;i++)
    glMultiTexCoord2fv(GL_TEXTURE0+i, &tc2[0]);
#endif // BIAS_HAVE_GLEW
  glVertex3f( 1, 1, z);
  glTexCoord2fv(&tc3[0]);
#ifdef BIAS_HAVE_GLEW
  for (i=0; i<maxTU;i++)
    glMultiTexCoord2fv(GL_TEXTURE0+i, &tc3[0]);
#endif // BIAS_HAVE_GLEW
  glVertex3f(-1, 1, z);
  glEnd();
  // texmapping done.
  //glPopAttrib();
  glDisable( texobj.target );

  CHECK_GL_ERROR;
}


void GeometryGL::CreateSampleDisplayListScene(int & dplistID)
{
#ifndef BIAS_HAVE_GLUT
  BIASERR("not implemented without glut, please recompile BIAS with USE_GLUT to see a a fancy dispal ylist scene !");
  dplistID=0;
#else // BIAS_HAVE_GLUT

  // init once:
  static bool initDone=false;
  if(initDone)
    return;

  // do init
  CHECK_GL_ERROR;
  // example for an OpenGL display list
  dplistID = glGenLists(1); // identifier
  glNewList(dplistID, GL_COMPILE ); // or: GL_COMPILE_AND_EXECUTE
  {
    // light source proeprties for enabled lighting:
    // specified pos by w=1, direction by w=0:
    GLfloat light_position0[]     = {10.0f, 10.0, 10.0f, 0.0f}; // w=0: direction
    GLfloat light_maincolor0[]    = {1.0f, 1.0, 1.0f, 1.0f};
    GLfloat light_ambientcolor0[] = {0.4f, 0.2f, 0.2f, 1.0f};

    // GL create light 0
    glLightfv(GL_LIGHT0, GL_POSITION, light_position0);
    glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_maincolor0);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_maincolor0);
    glLightfv(GL_LIGHT0, GL_AMBIENT,  light_ambientcolor0);

    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHTING); // may be switched on/off for every object
    glEnable(GL_DEPTH_TEST); // depth buffer occlusions of objects

    // material properties for enabled lighting:
    GLfloat paintcolor0[]    = { 0.9, 0.2, 0.5, 1.0};
    GLfloat specularcolor0[] = { 1.0, 1.0, 1.0, 1.0};
    GLfloat shininess0[]     = { 70. }; // 1..128, large values make smaller specular highlights

    GLfloat paintcolor1[]    = { 0.3, 0.9, 0.4, 1.0};
    GLfloat paintcolor2[]    = { 0.1, 0.2, 0.9, 0.5};
    GLfloat paintcolor3[]    = { 0.5, 0.0, 0.5, 1.0};

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();

    //// activate material properties:
    glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, specularcolor0);
    glMaterialfv( GL_FRONT_AND_BACK, GL_SHININESS, shininess0);
    glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
      paintcolor0);
    glColor4fv(paintcolor0);

    // draw geometry
    BIAS::Vector3<float> dtea(-0.5,-0.2,0);
    // position of the scene "modeling" matrix
    glTranslatef( dtea[0], dtea[1], dtea[2] );
    // teapot has strange vertex ordering for historical reasons
    glFrontFace(GL_CW);
    glutSolidTeapot(0.6);
    glFrontFace(GL_CCW);

    glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
      paintcolor1 );
    glColor4fv(paintcolor1);

    glTranslatef( -2*dtea[0], -2*dtea[1], -2*dtea[2] );
    glFrontFace(GL_CW);
    glutSolidTeapot(0.3);
    glFrontFace(GL_CCW);
    glTranslatef( dtea[0], dtea[1], dtea[2] );
    // back on origin

    // activate material properties:
    glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, paintcolor2);
    glColor4fv(paintcolor2);

    glTranslatef(0,0,-2);
    glutSolidSphere(0.8, 30, 60);
    glTranslatef(0,0, 2); // back to origin

    glTranslatef( 1,0,-3);
    glutSolidSphere(0.5, 50, 100);
    glTranslatef(-1,0, 3);// back to origin


    glTranslatef(0,2,0);
    glutSolidCube(0.7);
    glTranslatef(0,-2,0);

    glTranslatef(0,-1,0);
    glutSolidIcosahedron();
    glTranslatef(0, 1,0);

    glTranslatef(0,-2.2,0);
    glutSolidTetrahedron();
    glTranslatef(0, 2.2,0);

    // environment sphere to demonstrate back face
    glColor4fv( paintcolor3 );
    glutSolidSphere(75.0, 50, 100);

    glPopMatrix();
  }
  glEndList();

  CHECK_GL_ERROR;
  initDone=true;
#endif // BIAS_HAVE_GLUT
}


void GeometryGL::DisplayCallsSampleDisplayListScene(const double & curTime)
{
  //CALLINFO;
  CHECK_GL_ERROR;
  static int dplist = -1;

  // setup scenen as one displaylist
  BIAS::GeometryGL::CreateSampleDisplayListScene(dplist);


  CHECK_GL_ERROR;
  {
    if(glIsList(dplist) == GL_TRUE)
    {
      // animation: rotate the scene (not the camera) by using global time as angle:
      // thus light and camera stay in the same place
      {
        const float cycletime=10.0; // approx. sec for a full cycle
        const float angleM = fmodf( float(2.0*360.0/cycletime *curTime), 2.0*360.0);
        if (angleM<=360.0){
          glRotatef( angleM,       0.0f, 1.0f, 0.0f );
        } else {
          glRotatef( angleM-360.0f, 1.0f, 0.0f, 0.0f );
        }
      }

      //// interpolate between vertices
      //glShadeModel(GL_SMOOTH);
      glCallList(dplist);

      // no interpolation between vertices
      //glTranslatef(0.3,0.2,0.2);
      //glShadeModel(GL_FLAT);
      //glCallList(dplist);

      DisplayCoordCross();

    } else {
      BIASERR("invalid display list dplist="<<dplist);
    }

    //glPopAttrib();
  }
}



// convert flag from define into string with preprocessor
#define GLS(_flag) case _flag: {s=string(#_flag); break;}

std::string GeometryGL::GetName(const GLint flag,
                                const bool withNumericDisplay,
                                const bool numerixHexFormat )
{
  // catch special non verbose defs
  if(flag==0) // GL_FALSE
    return string("0");

  std::string s;
  bool unknownFlag=false;
  /// TODO \todo extract all OpenGL defines from gl.h/glew.h with regular expression.
  switch(flag)
  {
    GLS(GL_TRUE);
    GLS(GL_FRONT_LEFT);
    GLS(GL_FRONT_RIGHT);
    GLS(GL_BACK_LEFT );
    GLS(GL_BACK_RIGHT);
    GLS(GL_FRONT);
    GLS(GL_BACK);
    GLS(GL_LEFT);
    GLS(GL_RIGHT);
    GLS(GL_FRONT_AND_BACK);
    GLS(GL_POINT);
    GLS(GL_LINE);
    GLS(GL_FILL);
    GLS(GL_BYTE);
    GLS(GL_SHORT);
    GLS(GL_INT);
    GLS(GL_FLOAT);
    GLS(GL_DOUBLE);
    GLS(GL_TEXTURE_INTERNAL_FORMAT);
    GLS(GL_TEXTURE_BORDER_COLOR);
    GLS(GL_TEXTURE_BORDER);
    GLS(GL_DONT_CARE);
    GLS(GL_FASTEST);
    GLS(GL_NICEST);
    GLS(GL_COMPILE);
    GLS(GL_COMPILE_AND_EXECUTE);
    GLS(GL_CLEAR);
    GLS(GL_AND);
    GLS(GL_AND_REVERSE);
    GLS(GL_COPY);
    GLS(GL_AND_INVERTED);
    GLS(GL_NOOP);
    GLS(GL_XOR);
    GLS(GL_NOR);
    GLS(GL_EQUIV);
    GLS(GL_INVERT);
    GLS(GL_OR_REVERSE);
    GLS(GL_COPY_INVERTED);
    GLS(GL_OR_INVERTED);
    GLS(GL_NAND);
    GLS(GL_SET);
    GLS(GL_TEXTURE_1D);
    GLS(GL_TEXTURE_2D);
#if defined(BIAS_HAVE_GLEW)
    GLS(GL_TEXTURE_3D);
    GLS(GL_TEXTURE_CUBE_MAP_EXT);
    GLS(GL_TEXTURE_RECTANGLE_NV);
#endif
    GLS(GL_NEAREST);
    GLS(GL_LINEAR);
    GLS(GL_NEAREST_MIPMAP_NEAREST);
    GLS(GL_LINEAR_MIPMAP_NEAREST);
    GLS(GL_NEAREST_MIPMAP_LINEAR);
    GLS(GL_LINEAR_MIPMAP_LINEAR);
    GLS(GL_MODULATE);
    GLS(GL_DECAL);
    GLS(GL_BLEND);
    GLS(GL_RENDER);
    GLS(GL_FEEDBACK);
    GLS(GL_SELECT);
    GLS(GL_FLAT);
    GLS(GL_SMOOTH);
    GLS(GL_KEEP);
    GLS(GL_REPLACE);
    GLS(GL_INCR);
    GLS(GL_DECR);
    GLS(GL_TEXTURE_ENV);
    GLS(GL_OBJECT_LINEAR);
    GLS(GL_SPHERE_MAP);
    GLS(GL_ALPHA4 );
    GLS(GL_ALPHA8 );
    GLS(GL_ALPHA12 );
    GLS(GL_ALPHA16 );
    GLS(GL_LUMINANCE4);
    GLS(GL_LUMINANCE8 );
    GLS(GL_LUMINANCE12 );
    GLS(GL_LUMINANCE16 );
    GLS(GL_LUMINANCE4_ALPHA4 );
    GLS(GL_LUMINANCE6_ALPHA2 );
    GLS(GL_LUMINANCE8_ALPHA8 );
    GLS(GL_LUMINANCE12_ALPHA4 );
    GLS(GL_LUMINANCE12_ALPHA12 );
    GLS(GL_LUMINANCE16_ALPHA16 );
    GLS(GL_INTENSITY );
    GLS(GL_INTENSITY4 );
    GLS(GL_INTENSITY8 );
    GLS(GL_INTENSITY12 );
    GLS(GL_INTENSITY16 );
    GLS(GL_R3_G3_B2 );
    GLS(GL_RGB4 );
    GLS(GL_RGB5 );
    GLS(GL_RGB8 );
    GLS(GL_RGB10 );
    GLS(GL_RGB12 );
    GLS(GL_RGB16 );
    GLS(GL_RGBA2 );
    GLS(GL_RGBA4 );
    GLS(GL_RGB5_A1 );
    GLS(GL_RGBA8 );
    GLS(GL_RGB10_A2);
    GLS(GL_RGBA12 );
    GLS(GL_RGBA16 );

  default:
    unknownFlag=true;
    //s="unknown";
  }

  stringstream ss;
  if (withNumericDisplay || unknownFlag){
    if (flag!=1) {
      if (numerixHexFormat){
        // imitate OpenGL define format from gl.h/glew.h
        ss<<"0x"<<setw(4)<<setfill('0')<<hex<<flag<<" ";
      } else {
        ss<<setw(8)<<setfill(' ')<<dec<<flag<<" ";
      }
    }
  }
  if (!unknownFlag)
    ss<<s;

  return ss.str();
}
#undef GLS // save the environemt


//static
void GeometryGL::FillCubemap(BIAS::ImgObjGL & im, const bool & mipmapColorChange)
{
  CALLINFO;
  // TODO
  //BIASASSERT(im.IsCubemap());
  //std::vector< BIAS::Image<unsigned char> > vImg;
}