texturegl.C

Go to the documentation of this file.

#include "gtex/gl_extensions.H"
#include "texturegl.H"
#include "appear.H"
#include "gl_view.H"

#include <GL/glu.h>

using mlib::Wvec;
using mlib::Wtransf;
using mlib::CWtransf;

static bool debug = Config::get_var_bool("DEBUG_TEXTURE",false);


//can be 2D or 3D
TEXTUREgl::TEXTUREgl(GLenum target,GLenum unit):
  TEXTURE(""),
   _dl(0),
   _dl_valid(0),
   _format(GL_RGBA),            // reset in load file
   _tex_unit(unit),
   _save_img(0),
   _mipmap(false),              // set to true below
   _min_filter(GL_LINEAR_MIPMAP_LINEAR),
   _max_filter(GL_LINEAR),
   _wrap_r(GL_REPEAT),
   _wrap_s(GL_REPEAT),
   _wrap_t(GL_REPEAT),
   _tex_fn(GL_MODULATE),
   _target(target)
{
    init_settings();
}

TEXTUREgl::TEXTUREgl(Cstr_ptr& file, GLenum target) :
   TEXTURE(file),
   _dl(0),
   _dl_valid(0),
   _format(GL_RGBA),            // reset in load file
   _tex_unit(GL_TEXTURE0),
   _save_img(0),
   _mipmap(false),              // set to true below
   _min_filter(GL_LINEAR_MIPMAP_LINEAR),
   _max_filter(GL_LINEAR),
   _wrap_r(GL_REPEAT),
   _wrap_s(GL_REPEAT),
   _wrap_t(GL_REPEAT),
   _tex_fn(GL_MODULATE),
   _target(target)
{
   init_settings();
   set_mipmap(true); 
}

TEXTUREgl::TEXTUREgl(CBBOX2D& bb, CVIEWptr& v) :
   TEXTURE(""),
   _dl(0),
   _dl_valid(0),
   _format(GL_RGBA),    // reset in load file
   _save_img(0),
   _mipmap(false),      // set to true below
   _min_filter(GL_LINEAR_MIPMAP_LINEAR),
   _max_filter(GL_LINEAR),
   _wrap_r(GL_REPEAT),
   _wrap_s(GL_REPEAT),
   _wrap_t(GL_REPEAT),
   _tex_fn(GL_MODULATE),
   _target(GL_TEXTURE_2D) 
{
   set_mipmap(true);
   copy_texture(bb, v);
   init_settings();
}

void
TEXTUREgl::set_mipmap(bool mipmap)   
{
   if (mipmap != _mipmap) {
      _mipmap = mipmap;
      _dl_valid = false; // Invalidate texture object/display list
      _min_filter = _mipmap ? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST;
      _max_filter = _mipmap ? GL_LINEAR : GL_NEAREST;
      // Only expand image to power of 2 dimensions when not mipmapping
      set_expand_image(!_mipmap);
   }
}

/***********************************************************************P5
 * Method : TEXTUREgl::load_image
 * Params : 
 * Returns: int (success/failure)
 * Effects: clear the texture object
 *          set image from data (not from file)
 ***********************************************************************/
int
TEXTUREgl::load_image()
{
   err_adv(debug, "TEXTUREgl::load_image (%s)", **_file);
   free_dl();
   const int retval = TEXTURE::load_image();
   _format = bpp_to_format();
   return retval;
}

/***********************************************************************P5
 * Method : TEXTUREgl::set_image
 * Params : unsigned char *data, int w, int h, uint bpp
 * Returns: int (success/failure)
 * Effects: clear the texture object
 *          set image from data (not from file)
 ***********************************************************************/
int
TEXTUREgl::set_image(unsigned char *data, int w, int h, uint bpp)
{
   err_adv(debug, "TEXTUREgl::set_image (%s)", **_file);
   free_dl();
   const int retval = TEXTURE::set_image(data,w,h,bpp);
   _format = bpp_to_format();
   return retval;
}

void 
TEXTUREgl::set_texture(Cstr_ptr& filename)
{
   // delete current texture (if any) and store the given filename
   // as the texture file to load next time we need the data:

   // do nothing if it's the same filename as before
   if (filename == _file)
      return;

   if (debug) {
      cerr << "TEXTUREgl::set_texture: old name: "
           << _file
           << ", new name: "
           << filename << endl;
   }

   // free the old texture
   free_dl();

   // store the filename to load when needed:
   _file = filename;
   _image_not_available = false; // becomes true if attempt to load fails
}

/***********************************************************************
 * Method : TEXTUREgl::free_dl
 * Params : 
 * Returns: void
 * Effects: frees the texture object or display list
 ***********************************************************************/
void
TEXTUREgl::free_dl()
{
   if (_dl) {
      err_adv(debug, "TEXTUREgl::free_dl (%s)", **_file);
      glDeleteTextures(1, &_dl);
      _dl = 0;
      _dl_valid = false;
   }
}

/***********************************************************************
 * Method : TEXTUREgl::declare_texture
 * Params : 
 * Returns: void
 * Effects: frees the old texture object (if any)
 *          creates and binds a texture object (or display list)
 ***********************************************************************/
void
TEXTUREgl::declare_texture() 
{
   if (!_dl) {
      glGenTextures (1, &_dl);
      glActiveTexture(_tex_unit);
      glBindTexture (_target, _dl);
      _dl_valid = (_dl > 0);
      err_adv(debug, "TEXTUREgl::declare_texture (%s) %s",
              **_file,
              _dl_valid ? "succeeded" : "failed");
   }
}

/***********************************************************************
 * Method : TEXTUREgl::load_texture
 * Params : unsigned char **copy = 0
 * Returns: bool (success/failure)
 * Effects: if texture object has not been initialized:
 *              loads the image from file
 *              (makes a copy of the data on request)
 *              creates and binds texture object
 *              assigns image data to texture object
 *              frees the image data.
 ***********************************************************************/
bool
TEXTUREgl::load_texture(unsigned char **copy) 
{
   // If _dl is set and valid, do nothing
   if (_dl && _dl_valid)
      return 1;

   // if image is empty and we can't load it, give up:
   if (_img.empty() && !load_image()) {
      err_adv(debug, "TEXTUREgl::load_texture: error: can't load image (%)",
              **_file);
      return 0;
   }

   err_adv(debug, "TEXTUREgl::load_texture: loading (%s)...", **_file);

   // copy the image data on request:
   if (copy)
      *copy = _img.copy();

   // create and bind texture object:
   declare_texture();

   if (!is_valid()) {
      cerr << "TEXTUREgl::load_texture: error: can't generate texture" << endl;
      return false;
   }

   if (_target == GL_TEXTURE_2D) {
      if (_mipmap) {
         gluBuild2DMipmaps(_target,
                           _img.bpp(),
                           _img.width(),
                           _img.height(),
                           format(),
                           GL_UNSIGNED_BYTE,
                           _img.data()
                          );
      } else {
         glTexImage2D(_target,
                      0,                // mipmap level
                      _img.bpp(),
                      _img.width(),     // width
                      _img.height(),    // height
                      0,                // no border
                      format(),         // GL_RGB, GL_RGBA, etc.
                      GL_UNSIGNED_BYTE, // type of each color component
                      _img.data()       // image data
                     );
      }
   } else {
      glTexImage1D(_target,
                   0,                // mipmap level
                   _img.bpp(),
                   _img.width(),     // width
                   0,                // no border
                   format(),         // GL_RGB, GL_RGBA, etc.
                   GL_UNSIGNED_BYTE, // type of each color component
                   _img.data()       // image data
                  );
   }

   // the image is now saved in the texture object (or display list)
   // we can free the image data
   if (!_save_img)
      _img.freedata();
 
   return is_valid();
}

inline GLenum
gltex_enum(CTEXTUREptr &t) 
{
   return (t->dimension() == 2 ? GL_TEXTURE_2D :
           t->dimension() == 3 ? GL_TEXTURE_3D :
           GL_TEXTURE_1D);
}

/***********************************************************************
 * Method : TEXTUREgl::apply_texture
 * Params : 
 * Returns: void
 * Effects: Make my texture the current texture
 ***********************************************************************/
void
TEXTUREgl::apply_texture(CWtransf *xf)
{
   // load image data into texture if needed:
   load_texture();

   // press on even if that failed
   // (some textures don't load from file...)

   // ensure we get a texture object:
   declare_texture(); // no-op if load texture worked; otherwise create one
   if (!is_valid()) { // ensure texture object is valid
      cerr << "TEXTUREgl::apply_texture: error: can't generate texture"
           << endl;
      return;
   }

   // Make the texture the current texture
   glActiveTexture(_tex_unit);
   glBindTexture (_target, _dl);

   // set texture parameters
   glTexParameteri(_target, GL_TEXTURE_MIN_FILTER, _min_filter);
   glTexParameteri(_target, GL_TEXTURE_MAG_FILTER, _max_filter);
   glTexParameteri(_target, GL_TEXTURE_WRAP_R, _wrap_r);
   glTexParameteri(_target, GL_TEXTURE_WRAP_S, _wrap_s);
   glTexParameteri(_target, GL_TEXTURE_WRAP_T, _wrap_t);

   static GLfloat color[4] = {1,1,1,0};
   glTexParameterfv(_target, GL_TEXTURE_BORDER_COLOR, color);

   // set texture function (GL_REPLACE, GL_DECAL, etc.)cd 
   glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, _tex_fn);

   // Set up the texture matrix
   glPushAttrib(GL_TRANSFORM_BIT); // save current matrix mode
   glMatrixMode(GL_TEXTURE);
   glLoadMatrixd((xf ? (_scale * (*xf)) : _scale).transpose().matrix());
   glPopAttrib();                  // restore previous matrix mode

   // enable the texture:
   glEnable(gltex_enum(this));  // GL_ENABLE_BIT
}

/***********************************************************************
 * Method : TEXTUREgl::copy_texture
 * Params : CBBOX2D& bb, CVIEWptr &v
 * Returns: void
 * Effects: Copies part of the framebuffer as a texture
 ***********************************************************************/
void
TEXTUREgl::copy_texture(CBBOX2D& bb, CVIEWptr &v) 
{
   int width, height;
   assert(_target == GL_TEXTURE_2D);
   v->get_size(width, height);
   int orig_width = (int) (bb.dim()[0] * width  / 2.0);
   int orig_height= (int) (bb.dim()[1] * height / 2.0);
   width  = getPower2Size(orig_width);
   height = getPower2Size(orig_height);
   
   _scale = Wtransf::scaling(Wvec((double)width/orig_width,
                                    (double)height/orig_height,
                                    1));
   glReadBuffer(GL_BACK);

   declare_texture();

   int x = int((bb.min()[0] + 1.0) * width  / 2.0); // X start
   int y = int((bb.min()[1] + 1.0) * height / 2.0); // Y start
   cerr << x << " " << y << " " << width << " " << height << "\n";
   glCopyTexImage2D(_target,
                    0,                                  // mip map level
                    GL_RGB,
                    x,
                    y,
                    width,
                    height,
                    0);                                 // no border

   _save_img = false;
   _img.clear();
}

void
TEXTUREgl::init_settings()
{
   _min_filter = GL_LINEAR_MIPMAP_LINEAR;
   _max_filter = GL_LINEAR;
   _wrap_r = GL_REPEAT;
   _wrap_s = GL_REPEAT;
   _wrap_t = GL_REPEAT;
   _tex_fn = GL_MODULATE;
}

/* end of file texturegl.C */

---