/**************************************************************************\ * * This file is part of the Coin 3D visualization library. * Copyright (C) 1998-2007 by Systems in Motion. All rights reserved. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * ("GPL") version 2 as published by the Free Software Foundation. * See the file LICENSE.GPL at the root directory of this source * distribution for additional information about the GNU GPL. * * For using Coin with software that can not be combined with the GNU * GPL, and for taking advantage of the additional benefits of our * support services, please contact Systems in Motion about acquiring * a Coin Professional Edition License. * * See http://www.coin3d.org/ for more information. * * Systems in Motion, Postboks 1283, Pirsenteret, 7462 Trondheim, NORWAY. * http://www.sim.no/ sales@sim.no coin-support@coin3d.org * \**************************************************************************/ // FIXME: in my not so humble opinion, this class is an ugly mess -- // or at least its interface. // // Some examples: there are *4* functions named "setData()" -- which // should throw up a huge red warning sign alone. Methods named // "setData()" and "setFlags()" (the latter which we also have in // SoGLImage) should make API designers cringe. There's a whole bunch // of *public* methods marked as being *private* and *internal* -- // another warning sign. The setData() method that creates a 2D // texture object simply calls into the method that makes a 3D texture // object, while the obvious right thing to do would be to refactor // common code to private methods. // // Since this was made part of the public API of Coin 2, I guess we'll // have to support it until the end of time, or at least a couple of // major versions down the road. What we should do with it is to mark // it as obsolete, then refactor the functionality out of it, // preferably into a nice, *clean* little C API to complement the // stuff contained in cc_glglue_*(), then convert all internal code to // use that instead. // // 20030312 mortene. // ************************************************************************* // FIXME: Add TEX3 enviroment variables (or general TEX variables?) // (kintel 20011112) // ************************************************************************* /*! \class SoGLImage include/Inventor/misc/SoGLImage.h \brief The SoGLImage class is used to handle OpenGL 2D/3D textures. A number of environment variables can be set to control how textures are created. This is useful to tune Coin to fit your system. E.g. if you are running on a laptop, it might be a good idea to disable linear filtering and mipmaps. \li COIN_TEX2_LINEAR_LIMIT: Linear filtering is enabled if Complexity::textureQuality is greater or equal to this value. Default value is 0.2. \li COIN_TEX2_MIPMAP_LIMIT: Mipmaps are created if textureQuality is greater or equal to this value. Default value is 0.5. \li COIN_TEX2_LINEAR_MIPMAP_LIMIT: Linear filtering between mipmap levels is enabled if textureQuality is greater or equal to this value. Default value is 0.8. \li COIN_TEX2_SCALEUP_LIMIT: Textures with width or height not equal to a power of two will always be scaled up if textureQuality is greater or equal to this value. Default value is 0.7. If textureQuality is lower than this value, and the width or height is larger than 256 pixels, the texture is only scaled up if it's relatively close to the next power of two size. This could save a lot of texture memory. \li COIN_TEX2_USE_GLTEXSUBIMAGE: When set, and when the new texture data has the same attributes as the old data, glTexSubImage() will be used to copy new data into the texture instead of recreating the texture. This is not enabled by default, since it seems to trigger a bug in the Linux nVidia drivers. It just happens in some unreproducable cases. It could be a bug in our glTexSubImage() code, of course. :) \li COIN_TEX2_USE_SGIS_GENERATE_MIPMAP: When set, use the GL_SGIS_generate_mip extension (if available) to generate mipmaps, otherwise use a fast internal routine to generate them. Use of SGIS_generate_mipmap is not enabled by default since we suspect some ATi drivers have problems with this extensions. \li COIN_ENABLE_CONFORMANT_GL_CLAMP: When set, GL_CLAMP will be used when SoGLImage::CLAMP is specified as the texture wrap mode. By default GL_CLAMP_TO_EDGE is used, since this is usually what people want. See http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/007306.html for a discussion regarding GL_CLAMP and GL_CLAMP_TO_EDGE. \li COIN_TEX2_ANISOTROPIC_LIMIT: Anisotropic filtering is enabled for textures when the texture quality is higher than this value. Default value is 0.85 \COIN_CLASS_EXTENSION \since Coin 2.0 */ // ************************************************************************* /*! \enum SoGLImage::Wrap Used to specify how texture coordinates < 0.0 and > 1.0 should be handled. It can either be repeated (REPEAT), clamped (CLAMP) or clamped to edge (CLAMP_TO_EDGE), which is useful when tiling textures. Since 2002-11-18, CLAMP will be treated as CLAMP_TO_EDGE. The environment variable COIN_ENABLE_CONFORMANT_GL_CLAMP can be used to override this behaviour. */ #ifdef COIN_NEXT_MINOR /*! \enum SoGLImage::ResizeReason Sent as a parameter to SoGLImageResizeCB as a hint to why an image is being resized. IMAGE means that a whole image is being initially resized (e.g. a texture image). SUBIMAGE and MIPMAP are not in use and reserved for future use. */ #endif // COIN_NEXT_MINOR /*! \enum SoGLImage::Flags Can be used to tune/optimize the GL texture handling. Normally the texture quality will be used to decide scaling and filtering, and the image data will be scanned to decide if the image is (partly) transparent, and if the texture can be rendered using the cheaper alpha test instead of blending if it does contain transparency. If you know the contents of your texture image, or if you have special requirements on how the texture should be rendered, you can set the flags using the SoGLImage::setFlags() method. */ #ifdef COIN_NEXT_MINOR // FIXME: Support other reason values than IMAGE (kintel 20050531) /*! \typedef bool SoGLImage::SoGLImageResizeCB(SoState * state, const SbVec3s &newsize, unsigned char * destbuffer, SoGLImage::ResizeReason reason, void * closure, class SoGLImage * image) Image resize callback type. If registered using setResizeCallback(), this function will be called whenever Coin needs to resize an image. The function will be called both for 2D and 3D images. \e state is the current state at the time of resizing. \e newsize is the requested new image size. Note that the z size of a 2D image is 0. \e destbuffer is a pre-allocated buffer big enough to hold the pixels for the resized image. The # of bytes per pixel is the same as for the original image. \e reason is a hint about why the image is resized. At the moment, only IMAGE is supported. \e image is the original image. Return value: TRUE if the resize ahs been resized, FALSE if not. If FALSE is returned, Coin will resize the image instead. */ #endif // COIN_NEXT_MINOR // ************************************************************************* #include #include #include #include #include #ifdef HAVE_CONFIG_H #include #endif // HAVE_CONFIG_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef COIN_THREADSAFE #include #endif // COIN_THREADSAFE // ************************************************************************* static float DEFAULT_LINEAR_LIMIT = 0.2f; static float DEFAULT_MIPMAP_LIMIT = 0.5f; static float DEFAULT_LINEAR_MIPMAP_LIMIT = 0.8f; static float DEFAULT_SCALEUP_LIMIT = 0.7f; static float DEFAULT_ANISOTROPIC_LIMIT = 0.85f; static float COIN_TEX2_LINEAR_LIMIT = -1.0f; static float COIN_TEX2_MIPMAP_LIMIT = -1.0f; static float COIN_TEX2_LINEAR_MIPMAP_LIMIT = -1.0f; static float COIN_TEX2_SCALEUP_LIMIT = -1.0f; static float COIN_TEX2_ANISOTROPIC_LIMIT = -1.0f; static int COIN_TEX2_USE_GLTEXSUBIMAGE = -1; static int COIN_TEX2_USE_SGIS_GENERATE_MIPMAP = -1; static int COIN_ENABLE_CONFORMANT_GL_CLAMP = -1; static int COIN_TEX2_ALLOW_ALPHA_TEST = -1; // ************************************************************************* // buffer used for creating mipmap images static SbStorage * glimage_bufferstorage = NULL; typedef struct { unsigned char * buffer; int buffersize; unsigned char * mipmapbuffer; int mipmapbuffersize; } soglimage_buffer; static void glimage_buffer_construct(void * buffer) { soglimage_buffer * buf = (soglimage_buffer*) buffer; buf->buffer = NULL; buf->buffersize = 0; buf->mipmapbuffer = NULL; buf->mipmapbuffersize = 0; } static void glimage_buffer_destruct(void * buffer) { soglimage_buffer * buf = (soglimage_buffer*) buffer; delete[] buf->buffer; delete[] buf->mipmapbuffer; } static unsigned char * glimage_get_buffer(const int buffersize, const SbBool mipmap) { soglimage_buffer * buf = NULL; assert(glimage_bufferstorage != NULL); buf = (soglimage_buffer*) glimage_bufferstorage->get(); if (mipmap) { if (buf->mipmapbuffersize < buffersize) { delete[] buf->mipmapbuffer; buf->mipmapbuffer = new unsigned char[buffersize]; buf->mipmapbuffersize = buffersize; } return buf->mipmapbuffer; } else { if (buf->buffersize < buffersize) { delete[] buf->buffer; buf->buffer = new unsigned char[buffersize]; buf->buffersize = buffersize; // FIXME: this is an extremely lame workaround for a Purify UMR // reported by Tore Kristiansen of HitecO. // // An UMR is reported from buf->buffer (when disabling the // memset() workaround below) from somewhere within the // fast_mipmap() method. Purify doesn't go far enough down the // call-stack (probably because fast_mipmap() is a local static // method?) for us to easily see where the exact error happens, // though. // // My guess is that the mipmap-buffer isn't completely "filled // out", and so the glTex[Sub]Image2D() call asks for more // pixels than was generated. // // Should try to get this problem reproduced locally before // attempting to fix it. // // 20030514 mortene. (void)memset(buf->buffer, 0x55, buf->buffersize); } return buf->buffer; } } // ************************************************************************* static int compute_log(int value) { int i = 0; while (value > 1) { value>>=1; i++; } return i; } //FIXME: Use as a special case of 3D image to reduce codelines ? (kintel 20011115) static void halve_image(const int width, const int height, const int nc, const unsigned char *datain, unsigned char *dataout) { assert(width > 1 || height > 1); int nextrow = width *nc; int newwidth = width >> 1; int newheight = height >> 1; unsigned char *dst = dataout; const unsigned char *src = datain; // check for 1D images if (width == 1 || height == 1) { int n = SbMax(newwidth, newheight); for (int i = 0; i < n; i++) { for (int j = 0; j < nc; j++) { *dst = (src[0] + src[nc]) >> 1; dst++; src++; } src += nc; // skip to next pixel } } else { for (int i = 0; i < newheight; i++) { for (int j = 0; j < newwidth; j++) { for (int c = 0; c < nc; c++) { *dst = (src[0] + src[nc] + src[nextrow] + src[nextrow+nc] + 2) >> 2; dst++; src++; } src += nc; // skip to next pixel } src += nextrow; } } } static void halve_image(const int width, const int height, const int depth, const int nc, const unsigned char *datain, unsigned char *dataout) { assert(width > 1 || height > 1 || depth > 1); int rowsize = width * nc; int imagesize = width * height * nc; int newwidth = width >> 1; int newheight = height >> 1; int newdepth = depth >> 1; unsigned char *dst = dataout; const unsigned char *src = datain; int numdims = (width>=1?1:0)+(height>=1?1:0)+(depth>=1?1:0); // check for 1D images. if (numdims == 1) { int n = SbMax(SbMax(newwidth, newheight), newdepth); for (int i = 0; i < n; i++) { for (int j = 0; j < nc; j++) { *dst = (src[0] + src[nc]) >> 1; dst++; src++; } src += nc; // skip to next pixel/row/image } } // check for 2D images else if (numdims == 2) { int s1,s2,blocksize; if (width==1) { s1 = newheight; blocksize = height * nc; } else { s1 = newwidth; blocksize = width * nc; } s2 = depth==1?newheight:newdepth; for (int j = 0; j < s2; j++) { for (int i = 0; i < s1; i++) { for (int j = 0; j < nc; j++) { *dst = (src[0] + src[nc] + src[blocksize] + src[blocksize+nc] + 2) >> 2; dst++; src++; } src += nc; // skip to next pixel (x or y direction) } src += blocksize; // Skip to next row/image } } else { // 3D image for (int k = 0; k < newdepth; k++) { for (int j = 0; j < newheight; j++) { for (int i = 0; i < newwidth; i++) { for (int c = 0; c < nc; c++) { *dst = (src[0] + src[nc] + src[rowsize] + src[rowsize+nc] + src[imagesize] + src[imagesize+nc] + src[imagesize+rowsize] + src[imagesize+rowsize+nc] + 4) >> 3; dst++; src++; } src += nc; // skip one pixel } src += rowsize; // skip one row } src += imagesize; // skip one image } } } // fast mipmap creation. no repeated memory allocations. static void fast_mipmap(SoState * state, int width, int height, int nc, const unsigned char *data, const SbBool useglsubimage, SbBool compress) { const cc_glglue * glw = sogl_glue_instance(state); GLint internalFormat = coin_glglue_get_internal_texture_format(nc, compress); GLenum format = coin_glglue_get_texture_format(nc); int levels = compute_log(width); int level = compute_log(height); if (level > levels) levels = level; int memreq = (SbMax(width>>1,1))*(SbMax(height>>1,1))*nc; unsigned char * mipmap_buffer = glimage_get_buffer(memreq, TRUE); if (useglsubimage) { if (cc_glglue_has_texsubimage(glw)) { cc_glglue_glTexSubImage2D(glw, GL_TEXTURE_2D, 0, 0, 0, width, height, format, GL_UNSIGNED_BYTE, data); } } else { glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, width, height, 0, format, GL_UNSIGNED_BYTE, data); } unsigned char *src = (unsigned char *) data; for (level = 1; level <= levels; level++) { halve_image(width, height, nc, src, mipmap_buffer); if (width > 1) width >>= 1; if (height > 1) height >>= 1; src = mipmap_buffer; if (useglsubimage) { if (cc_glglue_has_texsubimage(glw)) { cc_glglue_glTexSubImage2D(glw, GL_TEXTURE_2D, level, 0, 0, width, height, format, GL_UNSIGNED_BYTE, (void*) src); } } else { glTexImage2D(GL_TEXTURE_2D, level, internalFormat, width, height, 0, format, GL_UNSIGNED_BYTE, (void *) src); } } } // fast mipmap creation. no repeated memory allocations. 3D version. static void fast_mipmap(SoState * state, int width, int height, int depth, int nc, const unsigned char *data, const SbBool useglsubimage, SbBool compress) { const cc_glglue * glw = sogl_glue_instance(state); GLint internalFormat = coin_glglue_get_internal_texture_format(nc, compress); GLenum format = coin_glglue_get_texture_format(nc); int levels = compute_log(SbMax(SbMax(width, height), depth)); int memreq = (SbMax(width>>1,1))*(SbMax(height>>1,1))*(SbMax(depth>>1,1))*nc; unsigned char * mipmap_buffer = glimage_get_buffer(memreq, TRUE); // Send level 0 (original image) to OpenGL if (useglsubimage) { if (cc_glglue_has_3d_textures(glw)) { cc_glglue_glTexSubImage3D(glw, GL_TEXTURE_3D, 0, 0, 0, 0, width, height, depth, format, GL_UNSIGNED_BYTE, data); } } else { if (cc_glglue_has_3d_textures(glw)) { cc_glglue_glTexImage3D(glw, GL_TEXTURE_3D, 0, internalFormat, width, height, depth, 0, format, GL_UNSIGNED_BYTE, data); } } unsigned char *src = (unsigned char *) data; for (int level = 1; level <= levels; level++) { halve_image(width, height, depth, nc, src, mipmap_buffer); if (width > 1) width >>= 1; if (height > 1) height >>= 1; if (depth > 1) depth >>= 1; src = mipmap_buffer; if (useglsubimage) { if (cc_glglue_has_3d_textures(glw)) { cc_glglue_glTexSubImage3D(glw, GL_TEXTURE_3D, level, 0, 0, 0, width, height, depth, format, GL_UNSIGNED_BYTE, (void*) src); } } else { if (cc_glglue_has_3d_textures(glw)) { cc_glglue_glTexImage3D(glw, GL_TEXTURE_3D, level, internalFormat, width, height, depth, 0, format, GL_UNSIGNED_BYTE, (void *) src); } } } } // A low quality resize function. It is only used when neither simage // nor GLU is available. static void fast_image_resize(const unsigned char * src, unsigned char * dest, int width, int height, int num_comp, int newwidth, int newheight) { float sx, sy, dx, dy; int src_bpr, dest_bpr, xstop, ystop, x, y, offset, i; dx = ((float)width)/((float)newwidth); dy = ((float)height)/((float)newheight); src_bpr = width * num_comp; dest_bpr = newwidth * num_comp; sy = 0.0f; ystop = newheight * dest_bpr; xstop = newwidth * num_comp; for (y = 0; y < ystop; y += dest_bpr) { sx = 0.0f; for (x = 0; x < xstop; x += num_comp) { offset = ((int)sy)*src_bpr + ((int)sx)*num_comp; for (i = 0; i < num_comp; i++) dest[x+y+i] = src[offset+i]; sx += dx; } sy += dy; } } // A low quality resize function for 3D texture image buffers. It is // only used when neither simage nor GLU is available. static void fast_image_resize3d(const unsigned char * src, unsigned char * dest, int width, int height, int nc, int layers, int newwidth, int newheight, int newlayers) { float sx, sy, sz, dx, dy, dz; int src_bpr, dest_bpr, src_bpl, dest_bpl, xstop, ystop, zstop; int x, y, z, offset, i; dx = ((float)width)/((float)newwidth); dy = ((float)height)/((float)newheight); dz = ((float)layers)/((float)newlayers); src_bpr = width * nc; dest_bpr = newwidth * nc; src_bpl = src_bpr * height; dest_bpl = dest_bpr * newheight; zstop = newlayers * dest_bpl; ystop = dest_bpl; xstop = dest_bpr; sz = 0.0f; for (z = 0; z < zstop; z += dest_bpl) { sy = 0.0f; for (y = 0; y < ystop; y += dest_bpr) { sx = 0.0f; for (x = 0; x < xstop; x += nc) { offset = ((int)sz)*src_bpl + ((int)sy)*src_bpr + ((int)sx)*nc; for (i = 0; i < nc; i++) dest[x+y+z+i] = src[offset+i]; sx += dx; } sy += dy; } sz += dz; } } // ************************************************************************* class SoGLImageP { public: #ifdef COIN_THREADSAFE static SbMutex * mutex; #endif // COIN_THREADSAFE static SoType classTypeId; static uint32_t current_glimageid; static uint32_t getNextGLImageId(void); SoGLDisplayList *createGLDisplayList(SoState *state); void checkTransparency(void); void unrefDLists(SoState *state); void reallyCreateTexture(SoState *state, const unsigned char *const texture, const int numComponents, const int w, const int h, const int d, const SbBool dlist, const SbBool mipmap, const int border); void reallyBindPBuffer(SoState *state); void resizeImage(SoState * state, unsigned char *&imageptr, uint32_t &xsize, uint32_t &ysize, uint32_t &zsize); SbBool shouldCreateMipmap(void); void applyFilter(const SbBool ismipmap); void * pbuffer; const SbImage *image; SbImage dummyimage; SbVec3s glsize; int glcomp; SbBool needtransparencytest; SbBool hastransparency; SbBool usealphatest; uint32_t flags; float quality; SoGLImage::Wrap wraps; SoGLImage::Wrap wrapt; SoGLImage::Wrap wrapr; int border; SbBool isregistered; uint32_t imageage; void (*endframecb)(void*); void *endframeclosure; class dldata { public: dldata(void) : dlist(NULL), age(0) { } dldata(SoGLDisplayList *dl) : dlist(dl), age(0) { } dldata(const dldata & org) : dlist(org.dlist), age(org.age) { } SoGLDisplayList *dlist; uint32_t age; }; SbList dlists; SoGLDisplayList *findDL(SoState *state); void tagDL(SoState *state); void unrefOldDL(SoState *state, const uint32_t maxage); SoGLImage *owner; uint32_t glimageid; void init(void); static void contextCleanup(uint32_t context, void * closure); #ifdef COIN_NEXT_MINOR static SoGLImage::SoGLImageResizeCB * resizecb; static void * resizeclosure; #endif // COIN_NEXT_MINOR }; SoType SoGLImageP::classTypeId STATIC_SOTYPE_INIT; uint32_t SoGLImageP::current_glimageid = 1; #ifdef COIN_NEXT_MINOR SoGLImage::SoGLImageResizeCB * SoGLImageP::resizecb = NULL; void * SoGLImageP::resizeclosure = NULL; #endif // COIN_NEXT_MINOR #ifdef COIN_THREADSAFE SbMutex * SoGLImageP::mutex; #endif // COIN_THREADSAFE #undef PRIVATE #define PRIVATE(p) ((p)->pimpl) // ************************************************************************* // This class is not 100% threadsafe. It is threadsafe for rendering // only. It is assumed that setData() is called by only one thread at // a time. The reason for this is that all threads should use the same // data, and it would be meaningless if two threads set different data // for an SoGLImage. The nodes using SoGLImage should use a mutex to // ensure that only one thread calls setData(), the other threads // should wait for that thread to finish. This is done in Coin now. // // SoGLImage::getGLDisplayList() use a mutex so that several // threads can call this method safely. // we now share one mutex among all glimages to avoid allocating too // many mutexes. #ifdef COIN_THREADSAFE #define LOCK_GLIMAGE SoGLImageP::mutex->lock() #define UNLOCK_GLIMAGE SoGLImageP::mutex->unlock() #else // COIN_THREADSAFE #define LOCK_GLIMAGE #define UNLOCK_GLIMAGE #endif // !COIN_THREADSAFE // ************************************************************************* /*! Constructor. */ SoGLImage::SoGLImage(void) { PRIVATE(this) = new SoGLImageP; SoContextHandler::addContextDestructionCallback(SoGLImageP::contextCleanup, PRIVATE(this)); PRIVATE(this)->init(); // init members to default values PRIVATE(this)->owner = this; // check environment variables if (COIN_TEX2_LINEAR_LIMIT < 0.0f) { const char *env = coin_getenv("COIN_TEX2_LINEAR_LIMIT"); if (env) COIN_TEX2_LINEAR_LIMIT = (float) atof(env); if (COIN_TEX2_LINEAR_LIMIT < 0.0f || COIN_TEX2_LINEAR_LIMIT > 1.0f) { COIN_TEX2_LINEAR_LIMIT = DEFAULT_LINEAR_LIMIT; } } if (COIN_TEX2_MIPMAP_LIMIT < 0.0f) { const char *env = coin_getenv("COIN_TEX2_MIPMAP_LIMIT"); if (env) COIN_TEX2_MIPMAP_LIMIT = (float) atof(env); if (COIN_TEX2_MIPMAP_LIMIT < 0.0f || COIN_TEX2_MIPMAP_LIMIT > 1.0f) { COIN_TEX2_MIPMAP_LIMIT = DEFAULT_MIPMAP_LIMIT; } } if (COIN_TEX2_LINEAR_MIPMAP_LIMIT < 0.0f) { const char *env = coin_getenv("COIN_TEX2_LINEAR_MIPMAP_LIMIT"); if (env) COIN_TEX2_LINEAR_MIPMAP_LIMIT = (float) atof(env); if (COIN_TEX2_LINEAR_MIPMAP_LIMIT < 0.0f || COIN_TEX2_LINEAR_MIPMAP_LIMIT > 1.0f) { COIN_TEX2_LINEAR_MIPMAP_LIMIT = DEFAULT_LINEAR_MIPMAP_LIMIT; } } if (COIN_TEX2_SCALEUP_LIMIT < 0.0f) { const char *env = coin_getenv("COIN_TEX2_SCALEUP_LIMIT"); if (env) COIN_TEX2_SCALEUP_LIMIT = (float) atof(env); if (COIN_TEX2_SCALEUP_LIMIT < 0.0f || COIN_TEX2_SCALEUP_LIMIT > 1.0f) { COIN_TEX2_SCALEUP_LIMIT = DEFAULT_SCALEUP_LIMIT; } } if (COIN_TEX2_USE_GLTEXSUBIMAGE < 0) { const char *env = coin_getenv("COIN_TEX2_USE_GLTEXSUBIMAGE"); if (env && atoi(env) == 1) { COIN_TEX2_USE_GLTEXSUBIMAGE = 1; } else COIN_TEX2_USE_GLTEXSUBIMAGE = 0; } if (COIN_TEX2_USE_SGIS_GENERATE_MIPMAP < 0) { const char *env = coin_getenv("COIN_TEX2_USE_SGIS_GENERATE_MIPMAP"); if (env && atoi(env) == 1) { COIN_TEX2_USE_SGIS_GENERATE_MIPMAP = 1; } else COIN_TEX2_USE_SGIS_GENERATE_MIPMAP = 0; } if (COIN_ENABLE_CONFORMANT_GL_CLAMP < 0) { const char * env = coin_getenv("COIN_ENABLE_CONFORMANT_GL_CLAMP"); if (env && atoi(env) == 1) { COIN_ENABLE_CONFORMANT_GL_CLAMP = 1; } else COIN_ENABLE_CONFORMANT_GL_CLAMP = 0; } if (COIN_TEX2_ANISOTROPIC_LIMIT < 0.0f) { const char *env = coin_getenv("COIN_TEX2_ANISOTROPIC_LIMIT"); if (env) COIN_TEX2_ANISOTROPIC_LIMIT = (float) atof(env); else COIN_TEX2_ANISOTROPIC_LIMIT = DEFAULT_ANISOTROPIC_LIMIT; } // disable alpha test rendering by default, since we've seen lots // of problems with nVidia cards and alpha testing. if (COIN_TEX2_ALLOW_ALPHA_TEST < 0) { const char *env = coin_getenv("COIN_TEX2_ALLOW_ALPHA_TEST"); if (env) COIN_TEX2_ALLOW_ALPHA_TEST = atoi(env); else COIN_TEX2_ALLOW_ALPHA_TEST = 0; } } /*! \COININTERNAL */ void SoGLImage::initClass(void) { assert(SoGLImageP::classTypeId.isBad()); SoGLImageP::classTypeId = SoType::createType(SoType::badType(), SbName("GLImage")); #ifdef COIN_THREADSAFE SoGLImageP::mutex = new SbMutex; #endif // COIN_THREADSAFE glimage_bufferstorage = new SbStorage(sizeof(soglimage_buffer), glimage_buffer_construct, glimage_buffer_destruct); coin_atexit(SoGLImage::cleanupClass, CC_ATEXIT_NORMAL); } // // called by atexit() // void SoGLImage::cleanupClass(void) { delete glimage_bufferstorage; glimage_bufferstorage = NULL; #ifdef COIN_THREADSAFE delete SoGLImageP::mutex; SoGLImageP::mutex = NULL; #endif // COIN_THREADSAFE SoGLImageP::classTypeId STATIC_SOTYPE_INIT; #ifdef COIN_NEXT_MINOR SoGLImageP::resizecb = NULL; SoGLImageP::resizeclosure = NULL; #endif // COIN_NEXT_MINOR SoGLImageP::current_glimageid = 1; } /*! Returns the type id for this class. */ SoType SoGLImage::getClassTypeId(void) { assert(!SoGLImageP::classTypeId.isBad()); return SoGLImageP::classTypeId; } // FIXME: grab better version of getTypeId() doc from SoBase, SoAction // and / or SoDetail? At least if this ever makes it into the public // API. 20010913 mortene. /*! Returns the type id for an SoGLImage instance. */ SoType SoGLImage::getTypeId(void) const { return SoGLImage::getClassTypeId(); } /*! Returns whether an SoGLImage instance inherits (or is of) type \a type. */ SbBool SoGLImage::isOfType(SoType type) const { return this->getTypeId().isDerivedFrom(type); } /*! Sets the pbuffer for this texture. Experimental code, use with care. */ void SoGLImage::setPBuffer(SoState * state, void * pbuffer, const Wrap wraps, const Wrap wrapt, const float quality) { if (PRIVATE(this)->pbuffer && state) { // bind texture before releasing pbuffer this->getGLDisplayList(state)->call(state); cc_glglue_context_release_pbuffer(PRIVATE(this)->pbuffer); } if (PRIVATE(this)->isregistered) SoGLImage::unregisterImage(this); PRIVATE(this)->unrefDLists(state); PRIVATE(this)->init(); // init to default values if (pbuffer) { PRIVATE(this)->pbuffer = pbuffer; PRIVATE(this)->wraps = wraps; PRIVATE(this)->wrapt = wrapt; PRIVATE(this)->glimageid = SoGLImageP::getNextGLImageId(); // assign an unique id to this image PRIVATE(this)->needtransparencytest = TRUE; PRIVATE(this)->hastransparency = FALSE; PRIVATE(this)->usealphatest = FALSE; PRIVATE(this)->quality = quality; if (PRIVATE(this)->pbuffer && !PRIVATE(this)->isregistered && !(this->getFlags() & INVINCIBLE)) { PRIVATE(this)->isregistered = TRUE; SoGLImage::registerImage(this); } } } /*! Convenience 2D wrapper function around the 3D setData(). */ void SoGLImage::setData(const SbImage * image, const Wrap wraps, const Wrap wrapt, const float quality, const int border, SoState * createinstate) { this->setData(image, wraps, wrapt, (Wrap)PRIVATE(this)->wrapr, quality, border, createinstate); } /*! Sets the data for this GL image. Should only be called when one of the parameters have changed, since this will cause the GL texture object to be recreated. Caller is responsible for sending legal Wrap values. CLAMP_TO_EDGE is only supported on OpenGL v1.2 implementations, and as an extension on some earlier SGI implementations (GL_SGIS_texture_edge_clamp). For now, if quality > 0.5 when created, we create mipmaps, otherwise a regular texture is created. Be aware, if you for instance create a texture with texture quality 0.4, and then later try to apply the texture with a texture quality greater than 0.5, the texture object will be recreated as a mipmap texture object. This will happen only once though, of course. If \a border != 0, the OpenGL texture will be created with this border size. Be aware that this might be extremely slow on most PC hardware. Normally, the OpenGL texture object isn't created until the first time it is needed, but if \a createinstate is != NULL, the texture object is created immediately. This is useful if you use a temporary buffer to hold the texture data. Be careful when using this feature, since the texture data might be needed at a later stage (for instance to create a texture object for another context). It will not be possible to create texture objects for other cache contexts when \a createinstate is != NULL. Also if \a createinstate is supplied, and all the attributes are the same as the current data in the image, glTexSubImage() will be used to insert the image data instead of creating a new texture object. This is much faster on most OpenGL drivers, and is very useful, for instance when doing animated textures. If you supply NULL for \a image, the instance will be reset, causing all display lists and memory to be freed. */ void SoGLImage::setData(const SbImage *image, const Wrap wraps, const Wrap wrapt, const Wrap wrapr, const float quality, const int border, SoState *createinstate) { PRIVATE(this)->imageage = 0; if (image == NULL) { PRIVATE(this)->unrefDLists(createinstate); if (PRIVATE(this)->isregistered) SoGLImage::unregisterImage(this); PRIVATE(this)->init(); // init to default values return; } PRIVATE(this)->glimageid = SoGLImageP::getNextGLImageId(); // assign an unique id to this image PRIVATE(this)->needtransparencytest = TRUE; PRIVATE(this)->hastransparency = FALSE; PRIVATE(this)->usealphatest = FALSE; PRIVATE(this)->quality = quality; // check for special case where glTexSubImage can be used. // faster for most drivers. if (createinstate) { // We need the state for cc_glglue const cc_glglue * glw = sogl_glue_instance(createinstate); SoGLDisplayList *dl = NULL; SbBool copyok = wraps == PRIVATE(this)->wraps && wrapt == PRIVATE(this)->wrapt && wrapr == PRIVATE(this)->wrapr && border == PRIVATE(this)->border && border == 0 && // haven't tested with borders yet. Play it safe. (dl = PRIVATE(this)->findDL(createinstate)) != NULL; SbVec3s size; int nc; const unsigned char * bytes = image->getValue(size, nc); if (copyok) { if (bytes && size != PRIVATE(this)->glsize || nc != PRIVATE(this)->glcomp) copyok = FALSE; } SbBool is3D = (size[2]==0)?FALSE:TRUE; SbBool usesubimage = COIN_TEX2_USE_GLTEXSUBIMAGE && (is3D && cc_glglue_has_3d_textures(glw)) || (!is3D && cc_glglue_has_texsubimage(glw)); if (!usesubimage) copyok=FALSE; if (PRIVATE(this)->flags & RECTANGLE) copyok = FALSE; if (copyok) { dl->ref(); PRIVATE(this)->unrefDLists(createinstate); PRIVATE(this)->dlists.append(SoGLImageP::dldata(dl)); PRIVATE(this)->image = NULL; // data is temporary, and only for current context dl->call(createinstate); SbBool compress = (PRIVATE(this)->flags & COMPRESSED) && cc_glue_has_texture_compression(glw); if (dl->isMipMapTextureObject()) { if (is3D) fast_mipmap(createinstate, size[0], size[1], size[2], nc, bytes, TRUE, compress); else fast_mipmap(createinstate, size[0], size[1], nc, bytes, TRUE, compress); } else { GLenum format = coin_glglue_get_texture_format(nc); if (is3D) { cc_glglue_glTexSubImage3D(glw, GL_TEXTURE_3D, 0, 0, 0, 0, size[0], size[1], size[2], format, GL_UNSIGNED_BYTE, (void*) bytes); } else { cc_glglue_glTexSubImage2D(glw, GL_TEXTURE_2D, 0, 0, 0, size[0], size[1], format, GL_UNSIGNED_BYTE, (void*) bytes); } } } else { PRIVATE(this)->image = image; PRIVATE(this)->wraps = wraps; PRIVATE(this)->wrapt = wrapt; PRIVATE(this)->wrapr = wrapr; PRIVATE(this)->border = border; PRIVATE(this)->unrefDLists(createinstate); if (createinstate) { PRIVATE(this)->dlists.append(SoGLImageP::dldata(PRIVATE(this)->createGLDisplayList(createinstate))); PRIVATE(this)->image = NULL; // data is assumed to be temporary } } } else { PRIVATE(this)->image = image; PRIVATE(this)->wraps = wraps; PRIVATE(this)->wrapt = wrapt; PRIVATE(this)->wrapr = wrapr; PRIVATE(this)->border = border; PRIVATE(this)->unrefDLists(createinstate); } if (PRIVATE(this)->image && !PRIVATE(this)->isregistered && !(this->getFlags() & INVINCIBLE)) { PRIVATE(this)->isregistered = TRUE; SoGLImage::registerImage(this); } } /*! 2D setData() wrapper. Supplies raw data, size and numcomponents instead of an SbImage. Creates a temporary image, then calls the read setData(). \overload */ void SoGLImage::setData(const unsigned char *bytes, const SbVec2s & size, const int numcomponents, const Wrap wraps, const Wrap wrapt, const float quality, const int border, SoState *createinstate) { PRIVATE(this)->dummyimage.setValuePtr(size, numcomponents, bytes); this->setData(&PRIVATE(this)->dummyimage, wraps, wrapt, quality, border, createinstate); } /*! 3D setData() wrapper. Supplies raw data, size and numcomponents instead of an SbImage. Creates a temporary image, then calls the read setData(). \overload */ void SoGLImage::setData(const unsigned char *bytes, const SbVec3s & size, const int numcomponents, const Wrap wraps, const Wrap wrapt, const Wrap wrapr, const float quality, const int border, SoState *createinstate) { PRIVATE(this)->dummyimage.setValuePtr(size, numcomponents, bytes); this->setData(&PRIVATE(this)->dummyimage, wraps, wrapt, wrapr, quality, border, createinstate); } /*! Destructor. */ SoGLImage::~SoGLImage() { SoContextHandler::removeContextDestructionCallback(SoGLImageP::contextCleanup, PRIVATE(this)); if (PRIVATE(this)->isregistered) SoGLImage::unregisterImage(this); PRIVATE(this)->unrefDLists(NULL); delete PRIVATE(this); } /*! This class has a private destuctor since we want users to supply the current GL state when deleting the image. This is to make sure gl texture objects are freed as soon as possible. If you supply NULL to this method, the gl texture objects won't be deleted until the next time an GLRenderAction is applied in the image's cache context(s). */ void SoGLImage::unref(SoState *state) { if (PRIVATE(this)->pbuffer) this->setPBuffer(state, NULL); PRIVATE(this)->unrefDLists(state); delete this; } /*! Sets flags to control how the texture is handled/initialized. */ void SoGLImage::setFlags(const uint32_t flags) { PRIVATE(this)->flags = flags; } /*! Returns the flags. \sa setFlags() */ uint32_t SoGLImage::getFlags(void) const { return PRIVATE(this)->flags; } /*! Returns a pointer to the image data. */ const SbImage * SoGLImage::getImage(void) const { return PRIVATE(this)->image; } /*! Returns or creates a SoGLDisplayList to be used for rendering. Returns NULL if no SoDLDisplayList could be created. */ SoGLDisplayList * SoGLImage::getGLDisplayList(SoState *state) { LOCK_GLIMAGE; SoGLDisplayList *dl = PRIVATE(this)->findDL(state); UNLOCK_GLIMAGE; if (dl == NULL) { dl = PRIVATE(this)->createGLDisplayList(state); if (dl) { LOCK_GLIMAGE; PRIVATE(this)->dlists.append(SoGLImageP::dldata(dl)); UNLOCK_GLIMAGE; } } if (dl && !dl->isMipMapTextureObject() && PRIVATE(this)->image) { float quality = SoTextureQualityElement::get(state); float oldquality = PRIVATE(this)->quality; PRIVATE(this)->quality = quality; if (PRIVATE(this)->shouldCreateMipmap()) { LOCK_GLIMAGE; // recreate DL to get a mipmapped image int n = PRIVATE(this)->dlists.getLength(); for (int i = 0; i < n; i++) { if (PRIVATE(this)->dlists[i].dlist == dl) { dl->unref(state); // unref old DL dl = PRIVATE(this)->createGLDisplayList(state); PRIVATE(this)->dlists[i].dlist = dl; break; } } UNLOCK_GLIMAGE; } else PRIVATE(this)->quality = oldquality; } return dl; } /*! Returns \e TRUE if this texture has some pixels with alpha != 255 */ SbBool SoGLImage::hasTransparency(void) const { if (PRIVATE(this)->flags & FORCE_TRANSPARENCY_TRUE) return TRUE; if (PRIVATE(this)->flags & FORCE_TRANSPARENCY_FALSE) return FALSE; if (PRIVATE(this)->needtransparencytest) { ((SoGLImage*)this)->pimpl->checkTransparency(); } return PRIVATE(this)->hastransparency; } /*! Returns TRUE if this image has some alpha value != 255, and all these values are 0. If this is the case, alpha test can be used to render this texture instead of for instance blending, which is usually slower and might yield z-buffer artifacts. */ SbBool SoGLImage::useAlphaTest(void) const { if (PRIVATE(this)->flags & FORCE_ALPHA_TEST_TRUE) return TRUE; if (PRIVATE(this)->flags & FORCE_ALPHA_TEST_FALSE) return FALSE; if (PRIVATE(this)->needtransparencytest) { ((SoGLImage*)this)->pimpl->checkTransparency(); } if (COIN_TEX2_ALLOW_ALPHA_TEST == 0) return FALSE; return PRIVATE(this)->usealphatest; } /*! Returns the wrap strategy for the S (horizontal) direction. */ SoGLImage::Wrap SoGLImage::getWrapS(void) const { return PRIVATE(this)->wraps; } /*! Returns the wrap strategy for the T (vertical) direction. */ SoGLImage::Wrap SoGLImage::getWrapT(void) const { return PRIVATE(this)->wrapt; } /*! Returns the wrap strategy for the R (depth) direction. */ SoGLImage::Wrap SoGLImage::getWrapR(void) const { return PRIVATE(this)->wrapr; } #ifdef COIN_NEXT_MINOR /*! Returns the texture quality for this texture image. \since 2005-02-19 */ float SoGLImage::getQuality(void) const { return PRIVATE(this)->quality; } #endif // COIN_NEXT_MINOR /*! Returns an unique if for this GL image. This id can be used to test for changes in an SoGLImage's internal data. */ uint32_t SoGLImage::getGLImageId(void) const { return PRIVATE(this)->glimageid; } /*! Virtual method that will be called once each frame. The method should unref display lists that has an age bigger or equal to \a maxage, and increment the age for other display lists. */ void SoGLImage::unrefOldDL(SoState *state, const uint32_t maxage) { PRIVATE(this)->unrefOldDL(state, maxage); this->incAge(); } // ************************************************************************* void SoGLImageP::init(void) { this->isregistered = FALSE; this->image = NULL; this->pbuffer = NULL; this->glsize.setValue(0,0,0); this->glcomp = 0; this->wraps = SoGLImage::CLAMP; this->wrapt = SoGLImage::CLAMP; this->wrapr = SoGLImage::CLAMP; this->border = 0; this->flags = SoGLImage::USE_QUALITY_VALUE; this->needtransparencytest = TRUE; this->hastransparency = FALSE; this->usealphatest = FALSE; this->quality = 0.4f; this->imageage = 0; this->endframecb = NULL; this->glimageid = 0; // glimageid 0 is an empty image } // // resize image if necessary. Returns pointer to temporary // buffer if that happens, and the new size in xsize, ysize. // void SoGLImageP::resizeImage(SoState * state, unsigned char *& imageptr, uint32_t & xsize, uint32_t & ysize, uint32_t & zsize) { SbVec3s size; int numcomponents; unsigned char *bytes = this->image->getValue(size, numcomponents); uint32_t newx = xsize; uint32_t newy = ysize; uint32_t newz = zsize; uint32_t maxrectsize = 0; if (!(this->flags & SoGLImage::RECTANGLE)) { newx = coin_geq_power_of_two(xsize - 2*this->border); newy = coin_geq_power_of_two(ysize - 2*this->border); newz = zsize ? coin_geq_power_of_two(zsize - 2*this->border) : 0; // if >= 256 and low quality, don't scale up unless size is // close to an above power of two. This saves a lot of texture memory if (this->flags & SoGLImage::SCALE_DOWN) { // no use scaling down for very small images if (newx > xsize && newx > 16) newx >>= 1; if (newy > ysize && newy > 16) newy >>= 1; if (newz > zsize && newz > 16) newz >>= 1; } else if (this->flags & SoGLImage::USE_QUALITY_VALUE) { if (this->quality < COIN_TEX2_SCALEUP_LIMIT) { if ((newx >= 256) && ((newx - (xsize-2*this->border)) > (newx>>3))) newx >>= 1; if ((newy >= 256) && ((newy - (ysize-2*this->border)) > (newy>>3))) newy >>= 1; if ((newz >= 256) && ((newz - (zsize-2*this->border)) > (newz>>3))) newz >>= 1; } } } else { GLint maxr; glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT, &maxr); maxrectsize = (uint32_t) maxr; } // downscale to legal GL size (implementation dependent) const cc_glglue * glw = sogl_glue_instance(state); SbBool sizeok = FALSE; #if COIN_DEBUG uint32_t orgsize[3] = { newx, newy, newz }; #endif // COIN_DEBUG while (!sizeok) { SbBool compressed = (this->flags & SoGLImage::COMPRESSED) ? TRUE : FALSE && cc_glue_has_texture_compression(glw); if (this->flags & SoGLImage::RECTANGLE) { // FIXME: add support for rectangular textures in glglue proxy test sizeok = (newx <= maxrectsize) && (newy <= maxrectsize); } else { sizeok = coin_glglue_is_texture_size_legal(glw, newx, newy, newz, numcomponents, this->shouldCreateMipmap(), compressed); } if (!sizeok) { unsigned int max = SbMax(newx, SbMax(newy, newz)); if (max==newz) newz >>= 1; else if (max==newy) newy >>= 1; else newx >>= 1; } if (newy == 0) { // Avoid endless loop in a buggy driver environment. SoDebugError::post("SoGLImageP::resizeImage", "There is something seriously wrong with OpenGL on " "this system -- can't find *any* valid texture " "size! Expect further problems."); break; } } #if COIN_DEBUG if (orgsize[0] != newx || orgsize[1] != newy || orgsize[2] != newz) { if (orgsize[2] != 0) { SoDebugError::postWarning("SoGLImageP::resizeImage", "Original 3D texture too large for " "your graphics hardware and / or OpenGL " "driver. Rescaled from (%d x %d x %d) " "to (%d x %d x %d).", orgsize[0], orgsize[1], orgsize[2], newx, newy, newz); } else { SoDebugError::postWarning("SoGLImageP::resizeImage", "Original 2D texture too large for " "your graphics hardware and / or OpenGL " "driver. Rescaled from (%d x %d) " "to (%d x %d).", orgsize[0], orgsize[1], newx, newy); } } #endif // COIN_DEBUG newx += 2 * this->border; newy += 2 * this->border; newz = (zsize==0)?0:newz + (2 * this->border); if ((newx != xsize) || (newy != ysize) || (newz != zsize)) { // We need to resize. int numbytes = newx * newy * ((newz==0)?1:newz) * numcomponents; unsigned char * glimage_tmpimagebuffer = glimage_get_buffer(numbytes, FALSE); // First check if there is a custom resize function registered SbBool customresizedone = FALSE; #ifdef COIN_NEXT_MINOR if (SoGLImageP::resizecb) { customresizedone = SoGLImageP::resizecb(state, SbVec3s(newx, newy, newz), glimage_tmpimagebuffer, SoGLImage::IMAGE, SoGLImageP::resizeclosure, this->owner); } #endif // COIN_NEXT_MINOR if (!customresizedone) { // simage version 1.1.1 has a pretty high quality resize // function. We prefer to use that to avoid using GLU, since // there are lots of buggy GLU libraries out there. if (zsize == 0) { // 2D image // simage_resize and gluScaleImage can be pretty slow. Use // fast_image_resize() if high quality isn't needed if (SoTextureScaleQualityElement::get(state) < 0.5f) { fast_image_resize(bytes, glimage_tmpimagebuffer, xsize, ysize, numcomponents, newx, newy); } else if (simage_wrapper()->available && simage_wrapper()->versionMatchesAtLeast(1,1,1) && simage_wrapper()->simage_resize) { unsigned char *result = simage_wrapper()->simage_resize((unsigned char*) bytes, xsize, ysize, numcomponents, newx, newy); (void)memcpy(glimage_tmpimagebuffer, result, numbytes); simage_wrapper()->simage_free_image(result); } else if (GLUWrapper()->available) { glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); glPixelStorei(GL_PACK_ROW_LENGTH, 0); glPixelStorei(GL_PACK_SKIP_PIXELS, 0); glPixelStorei(GL_PACK_SKIP_ROWS, 0); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glPixelStorei(GL_PACK_ALIGNMENT, 1); // FIXME: ignoring the error code. Silly. 20000929 mortene. (void)GLUWrapper()->gluScaleImage(coin_glglue_get_texture_format(numcomponents), xsize, ysize, GL_UNSIGNED_BYTE, (void*) bytes, newx, newy, GL_UNSIGNED_BYTE, (void*)glimage_tmpimagebuffer); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); glPixelStorei(GL_PACK_ALIGNMENT, 4); } else { // fall back to the internal low-quality resize function fast_image_resize(bytes, glimage_tmpimagebuffer, xsize, ysize, numcomponents, newx, newy); } } else { // (zsize > 0) => 3D image if (simage_wrapper()->available && simage_wrapper()->versionMatchesAtLeast(1,3,0) && simage_wrapper()->simage_resize3d) { unsigned char *result = simage_wrapper()->simage_resize3d((unsigned char*) bytes, xsize, ysize, numcomponents, zsize, newx, newy, newz); (void)memcpy(glimage_tmpimagebuffer, result, numbytes); simage_wrapper()->simage_free_image(result); } else { // fall back to the internal low-quality resize function fast_image_resize3d(bytes, glimage_tmpimagebuffer, xsize, ysize, numcomponents, zsize, newx, newy, newz); } } } imageptr = glimage_tmpimagebuffer; } xsize = newx; ysize = newy; zsize = newz; } // // private method that in addition to creating the display list, // tests the size of the image and performs a resize if the size is not // a power of two. // reallyCreateTexture is called (only) from here. // SoGLDisplayList * SoGLImageP::createGLDisplayList(SoState *state) { SbVec3s size; int numcomponents; unsigned char *bytes = this->image ? this->image->getValue(size, numcomponents) : NULL; if (!this->pbuffer && !bytes) return NULL; uint32_t xsize = size[0]; uint32_t ysize = size[1]; uint32_t zsize = size[2]; // these might change if image is resized unsigned char *imageptr = (unsigned char *) bytes; if (imageptr) this->resizeImage(state, imageptr, xsize, ysize, zsize); SbBool mipmap = this->shouldCreateMipmap(); SoGLDisplayList *dl = new SoGLDisplayList(state, SoGLDisplayList::TEXTURE_OBJECT, 1, mipmap); dl->ref(); #ifdef COIN_NEXT_MINOR if (bytes) { SbBool is3D = (size[2]==0)?FALSE:TRUE; if (is3D) { dl->setTextureTarget((int) GL_TEXTURE_3D); } else { dl->setTextureTarget((int) ((this->flags & SoGLImage::RECTANGLE) ? GL_TEXTURE_RECTANGLE_EXT : GL_TEXTURE_2D)); } } #endif // COIN_NEXT_MINOR dl->open(state); if (this->pbuffer) { this->reallyBindPBuffer(state); } else { this->reallyCreateTexture(state, imageptr, numcomponents, xsize, ysize, zsize, dl->getType() == SoGLDisplayList::DISPLAY_LIST, mipmap, this->border); } dl->close(state); return dl; } // // Test image data for transparency by checking each texel. // void SoGLImageP::checkTransparency(void) { this->needtransparencytest = FALSE; this->usealphatest = FALSE; this->hastransparency = FALSE; SbVec3s size; int numcomponents; unsigned char *bytes = this->image ? this->image->getValue(size, numcomponents) : NULL; if (bytes == NULL) { if (this->glcomp == 2 || this->glcomp == 4) { // we must assume it has transparency, and that we // can't use alpha testing this->hastransparency = TRUE; } } else { if (numcomponents == 2 || numcomponents == 4) { int n = size[0] * size[1] * (size[2] ? size[2] : 1); int nc = numcomponents; unsigned char *ptr = (unsigned char *) bytes + nc - 1; while (n) { if (*ptr != 255 && *ptr != 0) break; if (*ptr == 0) this->usealphatest = TRUE; ptr += nc; n--; } if (n > 0) { this->hastransparency = TRUE; this->usealphatest = FALSE; } else { this->hastransparency = this->usealphatest; } } } } static GLenum translate_wrap(SoState *state, const SoGLImage::Wrap wrap) { if (wrap == SoGLImage::REPEAT) return (GLenum) GL_REPEAT; if (COIN_ENABLE_CONFORMANT_GL_CLAMP) { if (wrap == SoGLImage::CLAMP_TO_EDGE) { const cc_glglue * glw = sogl_glue_instance(state); if (cc_glglue_has_texture_edge_clamp(glw)) return (GLenum) GL_CLAMP_TO_EDGE; } return (GLenum) GL_CLAMP; } const cc_glglue * glw = sogl_glue_instance(state); if (cc_glglue_has_texture_edge_clamp(glw)) return (GLenum) GL_CLAMP_TO_EDGE; return (GLenum) GL_CLAMP; } void SoGLImageP::reallyBindPBuffer(SoState * state) { GLenum target = this->flags & SoGLImage::RECTANGLE ? GL_TEXTURE_RECTANGLE_EXT : GL_TEXTURE_2D; glTexParameteri(target, GL_TEXTURE_WRAP_S, translate_wrap(state, this->wraps)); glTexParameteri(target, GL_TEXTURE_WRAP_T, translate_wrap(state, this->wrapt)); const cc_glglue * glue = sogl_glue_instance(state); SbBool mipmap = FALSE; #if 0 // disabled, we probably need to allocate space for the mipmaps in // the pbuffer pederb, 2003-11-27 if (this->shouldCreateMipmap() && cc_glglue_glext_supported(glue, "GL_SGIS_generate_mipmap")) { glTexParameteri(target, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); // glHint(GL_GENERATE_MIPMAP_HINT_SGIS, GL_NICEST); mipmap = TRUE; } #endif // disabled this->applyFilter(mipmap); cc_glglue_context_bind_pbuffer(this->pbuffer); } void SoGLImageP::reallyCreateTexture(SoState *state, const unsigned char *const texture, const int numComponents, const int w, const int h, const int d, const SbBool dlist, //FIXME: Not in use (kintel 20011129) const SbBool mipmap, const int border) { const cc_glglue * glw = sogl_glue_instance(state); this->glsize = SbVec3s((short) w, (short) h, (short) d); this->glcomp = numComponents; SbBool compress = (this->flags & SoGLImage::COMPRESSED) && cc_glue_has_texture_compression(glw); GLint internalFormat = coin_glglue_get_internal_texture_format(numComponents, compress); GLenum dataFormat = coin_glglue_get_texture_format(numComponents); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); //FIXME: Check cc_glglue capability as well? (kintel 20011129) if (SoGLTexture3EnabledElement::get(state)) { // 3D textures glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, translate_wrap(state, this->wraps)); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, translate_wrap(state, this->wrapt)); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, translate_wrap(state, this->wrapr)); this->applyFilter(mipmap); if (!mipmap) { if (cc_glglue_has_3d_textures(glw)) { cc_glglue_glTexImage3D(glw, GL_TEXTURE_3D, 0, internalFormat, w, h, d, border, dataFormat, GL_UNSIGNED_BYTE, texture); } } else { // mipmaps // We used to default to calling GLU's gluBuild3DMipmaps() here, // but that was axed, because the gluBuild[2|3]DMipmaps() // functions implicitly uses glGenTextures() and other OpenGL // 1.1+ functions -- which again can cause trouble when doing // remote rendering. (At least we've had lots of problems with // NVidia's GLX implementation for non-1.0 OpenGL stuff.) // // (void)GLUWrapper()->gluBuild3DMipmaps(GL_TEXTURE_3D, internalFormat, // w, h, d, dataFormat, // GL_UNSIGNED_BYTE, texture); fast_mipmap(state, w, h, d, numComponents, texture, FALSE, compress); } } else { // 2D textures SbBool mipmapimage = mipmap; SbBool mipmapfilter = mipmap; GLenum target = this->flags & SoGLImage::RECTANGLE ? GL_TEXTURE_RECTANGLE_EXT : GL_TEXTURE_2D; glTexParameteri(target, GL_TEXTURE_WRAP_S, translate_wrap(state, this->wraps)); glTexParameteri(target, GL_TEXTURE_WRAP_T, translate_wrap(state, this->wrapt)); if (mipmap && (this->flags & SoGLImage::RECTANGLE)) { mipmapimage = FALSE; if (cc_glglue_glext_supported(glw, "GL_SGIS_generate_mipmap")) { glTexParameteri(target, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); } else mipmapfilter = FALSE; } else if (mipmap && COIN_TEX2_USE_SGIS_GENERATE_MIPMAP && cc_glglue_glext_supported(glw, "GL_SGIS_generate_mipmap")) { glTexParameteri(target, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); mipmapimage = FALSE; } this->applyFilter(mipmapfilter); #ifdef COIN_NEXT_MINOR if ((this->quality > COIN_TEX2_ANISOTROPIC_LIMIT) && cc_glglue_can_do_anisotropic_filtering(glw)) { glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, cc_glglue_get_max_anisotropy(glw)); } #endif // COIN_NEXT_MINOR if (!mipmapimage) { // Create only level 0 texture. Mimpamps might be created by GL_SGIS_generate_mipmap glTexImage2D(target, 0, internalFormat, w, h, border, dataFormat, GL_UNSIGNED_BYTE, texture); } else { // mipmaps // The GLU function invocation has been disabled, for the // reasons stated in the code comments ~20 lines above on the // construction of 3D mipmap textures. // // (void)GLUWrapper()->gluBuild2DMipmaps(GL_TEXTURE_2D, internalFormat, // w, h, dataFormat, // GL_UNSIGNED_BYTE, texture); fast_mipmap(state, w, h, numComponents, texture, FALSE, compress); } } glPixelStorei(GL_UNPACK_ALIGNMENT, 4); } // // unref all dlists stored in image // void SoGLImageP::unrefDLists(SoState *state) { int n = this->dlists.getLength(); for (int i = 0; i < n; i++) { this->dlists[i].dlist->unref(state); } this->dlists.truncate(0); } // find dl for a context, NULL if not found SoGLDisplayList * SoGLImageP::findDL(SoState *state) { int currcontext = SoGLCacheContextElement::get(state); int i, n = this->dlists.getLength(); SoGLDisplayList *dl; for (i = 0; i < n; i++) { dl = this->dlists[i].dlist; if (dl->getContext() == currcontext) return dl; } return NULL; } void SoGLImageP::tagDL(SoState *state) { int currcontext = SoGLCacheContextElement::get(state); int i, n = this->dlists.getLength(); SoGLDisplayList *dl; for (i = 0; i < n; i++) { dl = this->dlists[i].dlist; if (dl->getContext() == currcontext) { this->dlists[i].age = 0; break; } } } void SoGLImage::incAge(void) const { PRIVATE(this)->imageage++; } void SoGLImage::resetAge(void) const { PRIVATE(this)->imageage = 0; } void SoGLImageP::unrefOldDL(SoState *state, const uint32_t maxage) { int n = this->dlists.getLength(); int i = 0; while (i < n) { dldata & data = this->dlists[i]; if (data.age >= maxage) { #if COIN_DEBUG && 0 // debug SoDebugError::postInfo("SoGLImageP::unrefOldDL", "DL killed because of old age: %p", this->owner); #endif // debug data.dlist->unref(state); this->dlists.removeFast(i); n--; // one less in list now } else { // increment age data.age++; i++; } } } SbBool SoGLImageP::shouldCreateMipmap(void) { if (this->flags & SoGLImage::USE_QUALITY_VALUE) { return this->quality >= COIN_TEX2_MIPMAP_LIMIT; } else { return (this->flags & SoGLImage::NO_MIPMAP) == 0; } } // // Actually apply the texture filters using OpenGL calls. // void SoGLImageP::applyFilter(const SbBool ismipmap) { GLenum target; // Casting away const const SbVec3s size = this->image ? this->image->getSize() : this->glsize; if (size[2] >= 1) target = GL_TEXTURE_3D; else { target = this->flags & SoGLImage::RECTANGLE ? GL_TEXTURE_RECTANGLE_EXT : GL_TEXTURE_2D; } if (this->flags & SoGLImage::USE_QUALITY_VALUE) { if (this->quality < COIN_TEX2_LINEAR_LIMIT) { glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); } else if ((this->quality < COIN_TEX2_MIPMAP_LIMIT) || !ismipmap) { glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); } else if (this->quality < COIN_TEX2_LINEAR_MIPMAP_LIMIT) { glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR); } else { // max quality glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); } } else { if ((this->flags & SoGLImage::NO_MIPMAP) || !ismipmap) { glTexParameteri(target, GL_TEXTURE_MAG_FILTER, (this->flags & SoGLImage::LINEAR_MAG_FILTER) ? GL_LINEAR : GL_NEAREST); glTexParameteri(target, GL_TEXTURE_MIN_FILTER, (this->flags & SoGLImage::LINEAR_MIN_FILTER) ? GL_LINEAR : GL_NEAREST); } else { glTexParameteri(target, GL_TEXTURE_MAG_FILTER, (this->flags & SoGLImage::LINEAR_MAG_FILTER) ? GL_LINEAR : GL_NEAREST); GLenum minfilter = GL_NEAREST_MIPMAP_NEAREST; if (this->flags & SoGLImage::LINEAR_MIPMAP_FILTER) { if (this->flags & SoGLImage::LINEAR_MIN_FILTER) minfilter = GL_LINEAR_MIPMAP_LINEAR; else minfilter = GL_LINEAR_MIPMAP_NEAREST; } else if (this->flags & SoGLImage::LINEAR_MIN_FILTER) minfilter = GL_NEAREST_MIPMAP_LINEAR; glTexParameteri(target, GL_TEXTURE_MIN_FILTER, minfilter); } } } // returns an unique uint32_t id for gl images uint32_t SoGLImageP::getNextGLImageId(void) { return current_glimageid++; } // ************************************************************************* // // Texture resource management. // // FIXME: consider sorting images on an LRU strategy to // speed up the process of searching for GL-images to free. // static SbList * glimage_reglist; static uint32_t glimage_maxage = 60; static void regimage_cleanup(void) { delete glimage_reglist; glimage_reglist = NULL; glimage_maxage = 60; } /*! When doing texture resource control, call this method before rendering the scene, typically in the viewer's actualRedraw(). \a state should be your SoGLRenderAction state. \sa endFrame(), tagImage(), setDisplayListMaxAge() */ void SoGLImage::beginFrame(SoState * /* state */) { // nothing is done for now } /*! Should be called when a texture image is used. In Coin this is handled by SoGLTextureImageElement, but if you use an SoGLImage on your own, you should call this method to avoid that the display list is deleted too soon. \a state should be your SoGLRenderAction state, \a image the image you are about to use/have used. */ void SoGLImage::tagImage(SoState *state, SoGLImage *image) { assert(image); if (image) { LOCK_GLIMAGE; image->resetAge(); image->pimpl->tagDL(state); UNLOCK_GLIMAGE; } } /*! Should be called after your scene is rendered. Old display lists will be deleted when you call this method. \a state should be your SoGLRenderAction state. \sa beginFrame(), tagImage(), setDisplayListMaxAge() */ void SoGLImage::endFrame(SoState *state) { if (glimage_reglist) { LOCK_GLIMAGE; int n = glimage_reglist->getLength(); for (int i = 0; i < n; i++) { SoGLImage *img = (*glimage_reglist)[i]; img->unrefOldDL(state, glimage_maxage); if (img->pimpl->endframecb) img->pimpl->endframecb(img->pimpl->endframeclosure); } UNLOCK_GLIMAGE; } } void SoGLImage::setEndFrameCallback(void (*cb)(void *), void *closure) { PRIVATE(this)->endframecb = cb; PRIVATE(this)->endframeclosure = closure; } int SoGLImage::getNumFramesSinceUsed(void) const { return PRIVATE(this)->imageage; } /*! Free all GL images currently used. This can be used to help the operating system and/or OpenGL driver's resource handling. If you know you're not going to render for a while, maybe you're switching to a different application or something, calling this method could be a good idea since it will release all the texture memory used by your application. */ void SoGLImage::freeAllImages(SoState *state) { int oldmax = glimage_maxage; glimage_maxage = 0; // call begin/end with maxage 0 to free all images SoGLImage::beginFrame(state); SoGLImage::endFrame(state); glimage_maxage = oldmax; } /*! Set the maximum age for a texture object/display list. The age of an image is the number of frames since it has been used. Default maximum age is 60. */ void SoGLImage::setDisplayListMaxAge(const uint32_t maxage) { glimage_maxage = maxage; } // used internally to keep track of the SoGLImages void SoGLImage::registerImage(SoGLImage *image) { LOCK_GLIMAGE; if (glimage_reglist == NULL) { coin_atexit((coin_atexit_f *)regimage_cleanup, CC_ATEXIT_NORMAL); glimage_reglist = new SbList; } assert(glimage_reglist->find(image) < 0); glimage_reglist->append(image); UNLOCK_GLIMAGE; } // used internally to keep track of the SoGLImages void SoGLImage::unregisterImage(SoGLImage *image) { assert(glimage_reglist); LOCK_GLIMAGE; int idx = glimage_reglist->find(image); assert(idx >= 0); if (idx >= 0) { glimage_reglist->removeFast(idx); } UNLOCK_GLIMAGE; } #ifdef COIN_NEXT_MINOR /*! Sets a custom image resize function. \since Coin 2.5 */ void SoGLImage::setResizeCallback(SoGLImageResizeCB * f, void * closure) { SoGLImageP::resizecb = f; SoGLImageP::resizeclosure = closure; } #endif // COIN_NEXT_MINOR // ************************************************************************* // // Callback from SoContextHandler // void SoGLImageP::contextCleanup(uint32_t context, void * closure) { SoGLImageP * thisp = (SoGLImageP *) closure; #ifdef COIN_THREADSAFE SoGLImageP::mutex->lock(); #endif // COIN_THREADSAFE int n = thisp->dlists.getLength(); int i = 0; while (i < n) { if (thisp->dlists[i].dlist->getContext() == (int) context) { thisp->dlists[i].dlist->unref(NULL); thisp->dlists.remove(i); n--; } else i++; } #ifdef COIN_THREADSAFE SoGLImageP::mutex->unlock(); #endif // COIN_THREADSAFE } // ************************************************************************* #undef PRIVATE #undef LOCK_GLIMAGE #undef UNLOCK_GLIMAGE