ImgObjGL.cpp

// Jan Woetzel

#include "ImgObjGL.hh"

// DBG:
#include <Base/Image/ImageIO.hh>
#include <iostream>

// -----------------------------
using namespace BIAS;
using namespace std;


// destructor
ImgObjGL::~ImgObjGL()
{
  Release();
}


// ctor
ImgObjGL::ImgObjGL()
: p_valueImage(NULL)
{
  InitMembers();
}


// ctor
ImgObjGL::ImgObjGL(
                   const GLuint & id,
                   const unsigned int & widthBrutto,
                   const unsigned int & heightBrutto,
                   const GLenum & target )
{
  InitMembers();
  this->id           = id;
  this->widthBrutto  = widthBrutto;  
  this->heightBrutto = heightBrutto;
  this->target       = target;

  // assume netto=brutto size
  this->widthOrig    = widthBrutto;
  this->heightOrig = heightBrutto;

}


// static
void ImgObjGL::InitGlew()
{
#ifdef BIAS_HAVE_GLEW
  if (!GLEW_VERSION_1_1){
    // maybe glewInit was missing
    static int err = -42;
    if (GLEW_OK != err){
      BIASWARN("initializing glewInit.");
      err=glewInit(); // once
      if (GLEW_OK != err) { 
        // problem: glewInit failed, something is seriously wrong 
        if (glewGetErrorString(err)==NULL) {
          BIASERR("could not init GLEW. glewGetErrorString(err) is NULL");
        } else {
          if (err==-42){ /* catceh arr that glewgetErorstring would crash */
            BIASERR("could not init GLEW. Error -42 ");
          } else {
            BIASERR("could not init GLEW. Error: "<<glewGetErrorString(err));
            BIASBREAK;
          }
        }
      };
    }
  }
#endif // BIAS_HAVE_GLEW
}


void ImgObjGL::InitMembers()
{
  id=0;
  p_id_SelfAllocated=false;

  target=GL_TEXTURE_2D;
  magnificationMode=
    GL_NEAREST /* prefer blocks for zoom in */
    //GL_LINEAR
    ;
  minificationMode=
    GL_NEAREST /* accept aliasing */
    //GL_LINEAR
    /* avoid aliasing */
    //GL_NEAREST_MIPMAP_NEAREST 
    //GL_LINEAR_MIPMAP_NEAREST // linear pix. interpol. within nearest mipmap
    //GL_NEAREST_MIPMAP_LINEAR
    //GL_LINEAR_MIPMAP_LINEAR
    ;
  widthOrig=0;
  heightOrig=0;
  widthBrutto=0;
  heightBrutto=0;
  p_valueImage=NULL;
  p_valueImage_SelfAllocated=false;
}



void ImgObjGL::Release()
{
  if (p_id_SelfAllocated){
    this->DeleteGLTexture();
  }
  if (p_valueImage_SelfAllocated) {
    delete p_valueImage;
  }
  // always set NULL, no matter if we freed or another will do.
  p_valueImage=NULL;
}


void ImgObjGL::DeleteGLTexture()
{
  glEnable( target );
  CHECK_GL_ERROR;
  // free gl texture memory and id:
  glDeleteTextures(1, (GLuint*)(&id) );
  id=0;
  CHECK_GL_ERROR;
  glDisable( target );
  CHECK_GL_ERROR;

  //this->InitMembers();
}


bool ImgObjGL::IsTexture2D() const
{
  return target == GL_TEXTURE_2D;
}

bool ImgObjGL::IsRectangleTexture() const
{
#if defined(BIAS_HAVE_GLEW)
  return target == GL_TEXTURE_RECTANGLE_NV;
#else
  return false;
#endif
}

bool ImgObjGL::IsCubemap() const
{
#if defined(BIAS_HAVE_GLEW)
  return target == GL_TEXTURE_CUBE_MAP_EXT;
#else
  return false;
#endif
}

void ImgObjGL::SetTargetPOW2(){ 
  SetTarget2D(); 
}
void ImgObjGL::SetTarget2D(){ 
  target=GL_TEXTURE_2D; 
}
void ImgObjGL::SetTargetRECT(){ 
#if defined(BIAS_HAVE_GLEW)
  target=GL_TEXTURE_RECTANGLE_NV; 
#else
  BIASEXIT(1, "you need glew to use GL_TEXTURE_RECTANGLE_NV");
#endif
}
void ImgObjGL::SetTargetCUBE(){ 
#if defined(BIAS_HAVE_GLEW)
  target=GL_TEXTURE_CUBE_MAP_EXT; 
#else
  BIASEXIT(1, "you need glew to use GL_TEXTURE_RECTANGLE_NV");
#endif
}



//JW
void ImgObjGL::CreateGLTexture(const BIAS::ImageBase & c_img,
                               const bool & forcePow2tex,
                               const bool & flipY,
                               const bool ImmediateCopyData )
{
  InitGlew();
  Release(); // release old texture (if there is one)

  if (forcePow2tex) 
    target=GL_TEXTURE_2D;

  // do not change the texture target *TO* GL_TEXTURE_RECTANGLE_NV, user should do it by hand.
  // This way you can put a pow2 texture into a RECT target - which makes sense for shaders.
  // assume target is correct and fixed...


  // TODO: use a pointer to avoid copy if it is not required. 
  // create a non const copy: 
  BIAS::ImageBase img(c_img);
  //BIAS::Image<unsigned char> img(c_img);

  // save Orig size
  this->widthOrig=img.GetWidth();
  this->heightOrig=img.GetHeight();
  this->widthBrutto=img.GetWidth();
  this->heightBrutto=img.GetHeight();

  // determine new size (after padding)
  if (!IsRectangleTexture() && !img.IsPowerOfTwoSize()) 
  { /* padding required */
    img.PowerOfTwoSize(this->widthBrutto, this->heightBrutto);
  }

  // create a copy because we usually need to flip
  if (ImmediateCopyData) 
  {
    if (IsRectangleTexture()){            
      // RECT 
      if (flipY) // just flip, RECT dont need padding. 
        img.Flip(); 

    } else {
      // POT  2D always needs padding
      if (flipY) {
        img.PadToPowerOfTwoAndFlip();
      } else {
        img.PadToPowerOfTwo();
      }
    };
    BIASASSERT(img.GetWidth()==this->widthBrutto);
    BIASASSERT(img.GetHeight()==this->heightBrutto);
  }
  BIASASSERT(this->widthBrutto>0);
  BIASASSERT(this->heightBrutto>0);

  // HACK
  glEnable( target );
  CHECK_GL_ERROR;
  glGenTextures(1, &id);
  glBindTexture(target, id);
  CHECK_GL_ERROR;

  // set up GL texture env an params
  glPixelStorei(GL_PACK_ALIGNMENT, 1);
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  // border handling - repeat or clamp?
  glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP);
  glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP);

  if (IsRectangleTexture()){
    // no mipmapping for rectangle non-power of two texture
    // minification
    glTexParameteri(target, GL_TEXTURE_MIN_FILTER,  GL_NEAREST);
    // magnification
    glTexParameteri(target, GL_TEXTURE_MAG_FILTER,  GL_NEAREST);
  } else {
    // build mipmaps on texture load?
    switch (minificationMode){
    case GL_NEAREST_MIPMAP_NEAREST: 
    case GL_LINEAR_MIPMAP_NEAREST:
    case GL_NEAREST_MIPMAP_LINEAR:
    case GL_LINEAR_MIPMAP_LINEAR:
#ifdef BIAS_HAVE_GLEW
      // warning: mipmaping takes performance
      glTexParameteri(target, GL_GENERATE_MIPMAP, GL_TRUE);
      glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0); 
      glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, 10);
#endif //BIAS_HAVE_GLEW
#ifdef BIAS_HAVE_GLEW
      glTexParameterf(target, GL_TEXTURE_LOD_BIAS, 0.0);
#endif // BIAS_HAVE_GLEW
      break;
    case GL_NEAREST:
    case GL_LINEAR:
    default: {
#ifdef BIAS_HAVE_GLEW
      glTexParameteri(target, GL_GENERATE_MIPMAP, GL_FALSE); 
      glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0);
      glTexParameteri(target, GL_TEXTURE_MAX_LEVEL,  0);
      glTexParameterf(target, GL_TEXTURE_LOD_BIAS, 0.0);
#endif // BIAS_HAVE_GLEW
             }
    }; // end of switch
    // minification
    glTexParameteri(target, GL_TEXTURE_MIN_FILTER,  minificationMode);
    // magnification
    glTexParameteri(target, GL_TEXTURE_MAG_FILTER,  magnificationMode);    
  };
  CHECK_GL_ERROR;

  //color RGB888 interleaved format: RGB RGB RGB
  GLvoid * p_pixels=NULL;
  // copy or just allocate?
  if (ImmediateCopyData) 
    p_pixels = img.GetImageData();

  //
  // determine flags for conversion between CPU and GPU storage
  // 

  GLenum pixSrc_fmt  = GetGLPixelFormat(img.GetColorModel(),  img.GetChannelCount() );
  GLenum pixSrc_type = GetGLStorageType(img.GetStorageType(), img.GetDepth() );
  // contains channelcount + precision, 1,2,3,4, GL_RGB, GL_RGBA is NOT enough for >8 bit
  GLint gpu_internalFmt = GetGLInternalFormat(img);
  // check if the GPU internal format (bits, channels) 
  // is compatible with texture target (pow2, RECT)
  if (!IsRectangleTexture()) {
    switch (gpu_internalFmt)
    {
    case 1:
    case 2:
    case 3:
    case 4:
    case GL_RGB:
    case GL_RGBA:
    case GL_BGR_EXT:
    case GL_BGRA_EXT:
      // OK, standard fmt that works with pow2 and rect.
      break;
    default:
      // the other formats *may* not work with pow2 textures! 
      BIASERR("Your requested GPU internal format (>8 bit) and texture target (pow2 GL_TEXTURE_2D)  are possibly not compatible!");
      BIASBREAK;
    };
  };

  //
  // now really create the GL texture4 (object)
  // if p_pixels != NULL then the data will be copied, too.
  //
  glTexImage2D( target , // target
    0, // level
    gpu_internalFmt,    // internalformat on GPU, typically GL_RGB
    this->widthBrutto,  // width, typically 1024
    this->heightBrutto, // height, typically 512
    GLint(0),    // no border, BORDER does not work anyway!
    pixSrc_fmt,  // format of src pixel data, typically GL_RGB
    pixSrc_type, // type, typcially GL_UNSIGNED_BYTE
    p_pixels );  // datptr. NULL means just allocate (without copy)

  CHECK_GL_ERROR;
  BIASASSERT( GL_TRUE == glIsTexture( id ) ); // success ?

  p_id_SelfAllocated=true; // we want to release id on destructor

  // replace, no light (often forgotten...)
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 
  glDisable( target );

  CHECK_GL_ERROR;
}


void ImgObjGL::CreateGLCubemap(const std::vector< BIAS::ImageBase * > cm,
                               const bool ImmediateCopyData,
                               const bool mipmapped )
{
  InitGlew();
  Release(); // release old texture (if there is one)
#if defined(BIAS_HAVE_GLEW)
  target=GL_TEXTURE_CUBE_MAP_EXT;
#else 
  BIASEXIT(1,"You nee dglew to use GL_TEXTURE_CUBE_MAP_EXT")
#endif

  // cube maps must have 
  // -exactly 6 faces 
  // -pow2 dim
  // -same width and height
  // -same dim for all faces
  BIASASSERT(cm.size()==6);
  BIASASSERT(cm[0]!=NULL);
  const unsigned int w=cm[0]->GetWidth();
  const unsigned int h=cm[0]->GetHeight();
  BIASASSERT(w==h);
  BIASASSERT(w>0);
  BIASASSERT(h>0);
  BIASASSERT(BIAS::ImageBase::IsPowerOfTwoSize(w,h));

  // allocate
  this->CreateGLCubemapEmpty(w, h,
    this->GetGLInternalFormat(*cm[0]),
    mipmapped);

  // fill with data
  unsigned int face=0;
  for (face=0; face<cm.size(); face++) {
    BIASASSERT(cm[face]!=NULL);
    // cube map faces must be equal size and equal w and h
    BIASASSERT(w==cm[face]->GetWidth() );
    BIASASSERT(h==cm[face]->GetHeight());

    // build mipmaps on texture load?
    switch (minificationMode){
        case GL_NEAREST_MIPMAP_NEAREST: 
        case GL_LINEAR_MIPMAP_NEAREST:
        case GL_NEAREST_MIPMAP_LINEAR:
        case GL_LINEAR_MIPMAP_LINEAR:
#ifdef BIAS_HAVE_GLEW
          // warning: mipmaping takes performance
          glTexParameteri(target, GL_GENERATE_MIPMAP, GL_TRUE);
          glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0); 
          glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, 10);
          glTexParameterf(target, GL_TEXTURE_LOD_BIAS, 0.0);
#endif // BIAS_HAVE_GLEW
          break;
        case GL_NEAREST:
        case GL_LINEAR:
        default:
          {
#ifdef BIAS_HAVE_GLEW
            glTexParameteri(target, GL_GENERATE_MIPMAP, GL_FALSE); 
            glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0);
            glTexParameteri(target, GL_TEXTURE_MAX_LEVEL,  0);
            glTexParameterf(target, GL_TEXTURE_LOD_BIAS, 0.0);
#endif // BIAS_HAVE_GLEW
          }
    }; // end of switch

    // minification
    glTexParameteri(target, GL_TEXTURE_MIN_FILTER,  minificationMode);
    // magnification
    glTexParameteri(target, GL_TEXTURE_MAG_FILTER,  magnificationMode);

    if (ImmediateCopyData){
#if defined(BIAS_HAVE_GLEW)
      // copy pixel data
      GLvoid * p_pixels     = cm[face]->GetImageData();  
      GLenum pixSrc_fmt     = GetGLPixelFormat(cm[face]->GetColorModel(),  cm[face]->GetChannelCount() );
      GLenum pixSrc_type    = GetGLStorageType(cm[face]->GetStorageType(), cm[face]->GetDepth() );
      GLint gpu_internalFmt = GetGLInternalFormat(*cm[face]);
      glTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT +face , // target
        0, // level
        gpu_internalFmt,    // internalformat on GPU, typically GL_RGB
        this->widthBrutto,  // width,  typically 512
        this->heightBrutto, // height, typically 512
        GLint(0),    // no border, BORDER does not work anyway!
        pixSrc_fmt,  // format of src pixel data, typically GL_RGB
        pixSrc_type, // type, typcially GL_UNSIGNED_BYTE
        p_pixels );  // datptr. NULL means just allocate (without copy)
#else
      BIASEXIT(1, "you need glew to use GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT");
#endif
      //if (mipmapped)
      //gluBuild2DMipmaps
      CHECK_GL_ERROR;
      BIASASSERT( GL_TRUE == glIsTexture( id ) ); // success ?
    }
  } // for all faces
  p_id_SelfAllocated=true; // we want to release id on destructor
  glDisable( target );
  CHECK_GL_ERROR;
}


// create an empty cubemap including allocating all mipmap texture levels
// thus the complete mipmap chain for all faces and levels is created on request
void ImgObjGL::CreateGLCubemapEmpty(const unsigned int w, const unsigned int h, 
                                    GLint gpu_internalFmt,
                                    const bool & mipmapped)
{ 
#if !defined(BIAS_HAVE_GLEW)
  BIASEXIT(1,"you need glew to use GL_TEXTURE_CUBE_MAP_EXT");
#else

  InitGlew();
  Release(); // release old texture (if there is one)

  target=GL_TEXTURE_CUBE_MAP_EXT;

  // cube maps must have 
  // -exactly 6 faces 
  // -pow2 dim
  // -same width and height
  // -same dim for all faces
  BIASASSERT(target==GL_TEXTURE_CUBE_MAP_EXT);
  BIASASSERT(w==h);
  BIASASSERT(w>0);
  BIASASSERT(h>0);
  BIASASSERT(BIAS::ImageBase::IsPowerOfTwoSize(w,h));

  // save Orig size
  this->widthOrig    = w;
  this->heightOrig   = h;
  this->widthBrutto  = w;
  this->heightBrutto = h;

  int maxLevel = 0; 
  if (mipmapped) {
    maxLevel = (int)(logf((float)w)/logf(2.0f));
    BIASASSERT(maxLevel>=0);
    BIASASSERT(maxLevel<=12);// 12==ld(4096), the usual max.
  }

  glEnable( target );
  CHECK_GL_ERROR;
  glGenTextures(1, &id);
  glBindTexture(target, id);
  CHECK_GL_ERROR;

  // set up GL texture env an params
  glPixelStorei(GL_PACK_ALIGNMENT,   1);
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

  // border handling - should be clamp to avoid cube border artefacts
  glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP);
  glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP);
  glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0);
  // replace, no light (often forgotten...)
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 

#ifdef BIAS_HAVE_GLEW
  glTexParameterf(target, GL_TEXTURE_LOD_BIAS, 0.0);
#endif // BIAS_HAVE_GLEW

  // build mipmaps on texture load?
  switch (minificationMode){
      case GL_NEAREST_MIPMAP_NEAREST: 
      case GL_LINEAR_MIPMAP_NEAREST:
      case GL_NEAREST_MIPMAP_LINEAR:
      case GL_LINEAR_MIPMAP_LINEAR:
        {
          BIASASSERT(mipmapped);
          glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, (GLint)maxLevel );
          break;
        }
      case GL_NEAREST:
      case GL_LINEAR:
      default:
        BIASASSERT(!mipmapped);
        glTexParameteri(target, GL_TEXTURE_MAX_LEVEL,  0);
  }; // end of switch
  glTexParameteri(target, GL_TEXTURE_MIN_FILTER,  minificationMode);
  glTexParameteri(target, GL_TEXTURE_MAG_FILTER,  magnificationMode);    
  CHECK_GL_ERROR;

  GLvoid * p_pixels_dummy=NULL; // dummy pixel data ptr
  unsigned int face=0;
  int level=0;
  // allocate for all faces amd all levels
  for (face=0; face<6; face++)
  { 
    for (level=0; level<=maxLevel; level++)
    { 
      glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT+face, // do NOT use target here
        (GLint)level, 
        (GLint)gpu_internalFmt,    // internalformat on GPU, typically GL_RGB/GL_RGBA
        w,
        h,
        GLint(0),          // no border, BORDER does not work anyway!
        GL_RGB,            // format ,unsued, ptr NULL, of src pixel data, typically GL_RGB
        GL_UNSIGNED_BYTE,  // type, unsued, ptr NULL,, typcially GL_UNSIGNED_BYTE
        p_pixels_dummy );  // datptr. NULL means just allocate (without copy)
      CHECK_GL_ERROR;
    }
  }
  CHECK_GL_ERROR;
  BIASASSERT( GL_TRUE == glIsTexture( id ) ); // success ?
  p_id_SelfAllocated=true; // we want to release id on destructor
  glDisable( target );
  
#endif
  CHECK_GL_ERROR;
}


int ImgObjGL::CreateGLCubemap(const std::string & cm0PosX,
                              const std::string & cm1NegX,
                              const std::string & cm2PosY,
                              const std::string & cm3NegY,
                              const std::string & cm4PosZ,
                              const std::string & cm5NegZ,
                              const bool ImmediateCopyData,
                              const bool mipmapped)
{
  std::vector< std::string > filenames;
  filenames.push_back(cm0PosX);
  filenames.push_back(cm1NegX);
  filenames.push_back(cm2PosY);
  filenames.push_back(cm3NegY);
  filenames.push_back(cm4PosZ);  
  filenames.push_back(cm5NegZ);
  BIASASSERT(filenames.size()==6);
  return CreateGLCubemap(filenames, ImmediateCopyData, mipmapped);
}


int ImgObjGL::CreateGLCubemap(const std::vector< std::string > cmFilenames,
                              const bool ImmediateCopyData,
                              const bool mipmapped)
{ 
  int result=0;
  BIASASSERT(cmFilenames.size()==6);
  std::vector< BIAS::ImageBase > img;
  img.resize(cmFilenames.size());
  int loadres=0;
  for (unsigned int i=0; i<img.size(); i++)
  {
    loadres=BIAS::ImageIO::Load(cmFilenames[i], img[i]);
    if (loadres!=0) {
      BIASERR("could not load "<<cmFilenames[i]);
      BIASBREAK;
      result=-1*i;
    } else {
      // OpenGL image coordiate system has origin on lower left while BIAS has upper left corner
      img[i].Flip();
    }
  }
  if (result==0)
  {
    // convert to image pointers
    std::vector<BIAS::ImageBase * > v_ptr;
    for (unsigned int i=0; i<img.size(); i++)
      v_ptr.push_back( &img[i] );

    BIASASSERT(v_ptr.size()==6);
    CreateGLCubemap(v_ptr, ImmediateCopyData, mipmapped );
  }
  return result;
}


//static
GLenum ImgObjGL::GetGLStorageType(const BIAS::ImageBase::EStorageType & biasST,
                                  const unsigned int & ByteDepth )
{
  switch (biasST)
  {
  case BIAS::ImageBase::ST_unsignedchar:
    BIASASSERT(ByteDepth==1);
    return GL_UNSIGNED_BYTE;
    break;
  case BIAS::ImageBase::ST_char:
    BIASASSERT(ByteDepth==1);
    return GL_BYTE;
    break;
  case BIAS::ImageBase::ST_unsignedshortint:
    BIASASSERT(ByteDepth==2);
    return GL_UNSIGNED_SHORT;
    break;
  case BIAS::ImageBase::ST_shortint:
    BIASASSERT(ByteDepth==2);
    return GL_SHORT;
    break;
  case BIAS::ImageBase::ST_unsignedint:
    BIASASSERT(ByteDepth==4);
    return GL_UNSIGNED_INT;
    break;
  case BIAS::ImageBase::ST_int:
    BIASASSERT(ByteDepth==4);
    return GL_INT;
    break;
  case BIAS::ImageBase::ST_float:
    BIASASSERT(ByteDepth==4);
    return GL_FLOAT;
    break;
  default:
    BIASERR( "unsupported StorageType:"<<biasST<<" "
      <<"(with Byte depth="<<ByteDepth<<")" );
    BIASBREAK;
  };
  return 0;
}


//static
GLenum ImgObjGL::GetGLPixelFormat(const BIAS::ImageBase::EColorModel & biasCM,
                                  const unsigned int & channelcount )
{
  switch (biasCM)
  {
    // these may need ifs tbhrough glew for > GL 1.1
    // DIB
  case BIAS::ImageBase::CM_BGR:
    BIASASSERT(channelcount==3);
#ifdef BIAS_HAVE_GLEW
    if (!GLEW_VERSION_1_1) 
      BIASERR("You need a BGR capable GPU!");
#endif // BIAS_HAVE_GLEW
    return GL_BGR_EXT;
    break;
    // DIB
  case BIAS::ImageBase::CM_BGRA:
    BIASASSERT(channelcount==3);
#ifdef BIAS_HAVE_GLEW
    if (!GLEW_VERSION_1_1) 
      BIASERR("You need a BGRA_EXT capable GPU!");
#endif // BIAS_HAVE_GLEW
    return GL_BGRA_EXT;
    break;
    // one channel grey, replicated to 4 channel RGBA (grey,grey,grey, 1.0)
  case BIAS::ImageBase::CM_Grey:
    BIASASSERT(channelcount==1);
    return GL_LUMINANCE;
    break;
    // one channel grey+Alpha, replicated to 4 channel RGBA (grey,grey,grey, alpha)
  case BIAS::ImageBase::CM_GreyA:
    BIASASSERT(channelcount==2);
    return GL_LUMINANCE_ALPHA;
    break;
    // one channel grey+Alpha, replicated to 4 channel RGBA (grey,grey,grey, alpha)

  case BIAS::ImageBase::CM_Bayer_BGGR:
  case BIAS::ImageBase::CM_Bayer_RGGB:
  case BIAS::ImageBase::CM_Bayer_GRBG:
  case BIAS::ImageBase::CM_Bayer_GBRG:
    BIASASSERT(channelcount==3);
    BIASWARN("you are loading raw Bayer image as RGBA.");
    return GL_RGB;
    break;

  case BIAS::ImageBase::CM_HSV:
  case BIAS::ImageBase::CM_HSL:
  case BIAS::ImageBase::CM_hsL:
    BIASWARN("you are loading HSV/HSL/hsL as RGB.");
  case BIAS::ImageBase::CM_RGB:
    BIASASSERT(channelcount==3);
    return GL_RGB;
    break;

    // the two simple default cases, used for unkonw formats: 
  case BIAS::ImageBase::CM_RGBA:
    BIASASSERT(channelcount==4);
    return GL_RGBA;
    break;

  default:
    BIASERR( "unsupported ColroModel:"<<biasCM<<" "
      <<"(with channelcount ="<<channelcount<<")" );
    BIASBREAK;
  };
  return 0;
}


//static
GLint ImgObjGL::GetGLInternalFormat(const BIAS::ImageBase & img)
{
  return GetGLInternalFormat(
    img.GetStorageType(),
    img.GetColorModel(),
    img.GetChannelCount(),
    img.GetDepth(),
    img.GetBitDepth()
    );
}


//static
GLint ImgObjGL::GetGLInternalFormat(const BIAS::ImageBase::EStorageType & biasST,
                                    const BIAS::ImageBase::EColorModel & /*biasCM*/,
                                    const unsigned int & channelcount,
                                    const unsigned int & ByteDepth,
                                    const unsigned int & BitDepth )
{
  // bind the GPU storagetype to the number of Byte and channels for now
  // TODO: more general assignment to nr. of bits, colormodel etc.

  // 1,2,3,4, 
  // GL_RGB, GL_RGBA, GL_LUMINANCE 
  // GL_FLOAT_R32_NV
  // GL_RGBA32F_ARB
  // GL_FLOAT_RGB16_NV 

  // do ByteDepth and storagtype depth match?
  BIASASSERT( ByteDepth ==  (unsigned int) ImageBase::GetSizeByte(biasST));

  // more fractional bits than capacity?
  BIASASSERT( (unsigned int)(ImageBase::GetSizeByte(biasST)*8) <= BitDepth);

  switch (ByteDepth)
  {
  case 1: // 8 bit
    {
      if (channelcount==4) 
        return GL_RGBA;
      if (channelcount==3) 
        return GL_RGB;
      //if (channelcount==1) 
      //  return GL_LUMINANCE; /// TODO 
      BIASERR("unsupported channel count for 8 bit"); 
      BIASBREAK;
      break;
    }
  case 2: // 16 bit
    {
#if defined(BIAS_DEBUG) && defined(BIAS_HAVE_GLEW)
      if (!GLEW_VERSION_1_1)
        BIASERR("glew said not even OpenGL 1.1 is supported - did you call glewInit() ?");
#endif 

#ifdef BIAS_HAVE_GLEW
      if (GLEW_ARB_texture_float){ // requires NV GF FX 6,7

        if (channelcount==4) 
          return GL_RGBA16F_ARB;
        else if (channelcount==3) 
          return GL_RGB16F_ARB;

      } else if (GLEW_NV_float_buffer){ // for older NV GF 5xxx

        if (channelcount==4) 
          return GL_FLOAT_RGBA16_NV;
        else if (channelcount==3) 
          return GL_FLOAT_RGB16_NV;
        else if (channelcount==1) 
          return GL_FLOAT_RGBA16_NV; // TODO
      }
#endif // BIAS_HAVE_GLEW
      BIASERR("unsupported channelcount="<<channelcount<<" for 16 bit or missing extension (e.g. ARB_texture_float,NV_float_buffer)");
      BIASBREAK;
      break;
    }
  case 4: // 32 bit 
    {
#if defined(BIAS_DEBUG) && defined(BIAS_HAVE_GLEW)
      if (!GLEW_VERSION_1_1)
        BIASERR("glew said not even OpenGL 1.1 is supported - did you call glewInit() ?");
#endif //BIAS_DEBUG + BIAS_HAVE_GLEW

#ifdef BIAS_HAVE_GLEW

      if (GLEW_ARB_texture_float){ // newer extension, requires Nvidia GF 6,7

        if (channelcount==4)
          return GL_RGBA32F_ARB;
        else if (channelcount==3) 
          return GL_RGB32F_ARB;
        else if (channelcount==2)
          return GL_LUMINANCE_ALPHA32F_ARB; // untested
        else if (channelcount==1) {
          BIASWARNONCE("One channel (e.g.LUMINANCE) image is probably not GPU Hardware accelerated! "
            "You may want to use RGB or RGBA instead!");
          //return GL_LUMINANCE32F_ARB; // TODO TESTME. use RGB/RGBA instaed?
          return GL_RGB16F_ARB; // required for Oliver Niemann, (JW)
        }

      } else if (GLEW_NV_float_buffer){ // works (only?) with Geforce FX 5xxx

        if (channelcount==4)
          return GL_FLOAT_RGBA32_NV;
        else if (channelcount==3) 
          return GL_FLOAT_RGB32_NV;
        else if (channelcount==1) {
          BIASWARNONCE("One channel (e.g. LUMINANCE) images are probably not GPU Hardware accelerated! "
            "Using RGBA for one channel image.");
          return GL_FLOAT_RGBA32_NV; // TESTME. Only RGB, RGBA are currently HW accelerated!
        }

      } // ext.
#endif // BIAS_HAVE_GLEW

      BIASERR("unsupported channelcount="<<channelcount<<" for 32 bit or missing extension (e.g. ARB_texture_float,NV_float_buffer)");
      BIASBREAK;
      break;
    }
  default:
    BIASERR("unsupported ByteDepth.");
    BIASBREAK;
  }
  return 0;
}