RenderTools: C:/development/RenderTools/src/factory/Sampler.cpp Source File

00001 #include "Sampler.h"
00002 #include "Plane.h"
00003 #include "Program.h"
00004 #include "Stateset.h"
00005 #include "Image.h"
00006 #include "Types.h"
00007 #include "Error.h"
00008 
00009 using namespace std;
00010 
00012 namespace RenderTools {
00013 
00014 Sampler::Sampler( GLuint width, GLuint height, GLubyte * data ):
00015         Image(),
00016         m_internal( GL_RGBA ),
00017         m_w2( 1 ),
00018         m_h2( 1 ),
00019         m_makePOT( GL_TRUE ),
00020         m_overrideDefaultColor( false ),
00021         m_id( 0 ),
00022 #ifndef RT_GLES2
00023         m_mode( GL_MODULATE ),
00024         m_wrap( GL_REPEAT ),
00025         m_doMipMap( GL_TRUE ),
00026         m_filter( GL_NEAREST ),
00027 #endif
00028         m_formatGL( GL_RGBA ),
00029         m_typeGL( GL_UNSIGNED_BYTE ){
00030 
00031         m_data = data;
00032 }
00033 
00034 Sampler::Sampler( void ):
00035         Image(),
00036         m_internal( GL_RGBA ),
00037         m_w2( 1 ),
00038         m_h2( 1 ),
00039         m_makePOT( GL_TRUE ),
00040         m_overrideDefaultColor( false ),
00041         m_id( 0 ),
00042 #ifndef RT_GLES2
00043         m_mode( GL_MODULATE ),
00044         m_wrap( GL_REPEAT ),
00045         m_doMipMap( GL_TRUE ),
00046         m_filter( GL_NEAREST ),
00047 #endif
00048         m_formatGL( GL_RGBA ),
00049         m_typeGL( GL_UNSIGNED_BYTE ){
00050 
00051 }
00052 
00053 PropertyPtr Sampler::create( const XMLNodePtr & xml ){
00054         SamplerPtr p( new Sampler() );
00055         p->setName( xml );
00056         p->createProperties();
00057         p->setProperties( xml, false );
00058         return( dynamic_pointer_cast< AbstractProperty, Sampler >( p ) );
00059 }
00060 
00061 void Sampler::createProperties( void ){
00062         Image::createProperties();
00063         createProperty( this, "powerOfTwoWidth", & m_w2 );
00064         createProperty( this, "powerOfTwoHeight", & m_h2 );
00065 
00066         EnumList internalEnums;
00067 #ifdef GL_ALPHA
00068         internalEnums << GL_ALPHA;
00069 #endif
00070 #ifdef GL_ALPHA4
00071         internalEnums << GL_ALPHA4;
00072 #endif
00073 #ifdef GL_ALPHA8
00074         internalEnums << GL_ALPHA8;
00075 #endif
00076 #ifdef GL_ALPHA12
00077         internalEnums << GL_ALPHA12;
00078 #endif
00079 #ifdef GL_ALPHA16
00080         internalEnums << GL_ALPHA16;
00081 #endif
00082 #ifdef GL_LUMINANCE
00083         internalEnums << GL_LUMINANCE;
00084 #endif
00085 #ifdef GL_LUMINANCE4
00086         internalEnums << GL_LUMINANCE4;
00087 #endif
00088 #ifdef GL_LUMINANCE8
00089         internalEnums << GL_LUMINANCE8;
00090 #endif
00091 #ifdef GL_LUMINANCE12
00092         internalEnums << GL_LUMINANCE12;
00093 #endif
00094 #ifdef GL_LUMINANCE16
00095         internalEnums << GL_LUMINANCE16;
00096 #endif
00097 #ifdef GL_LUMINANCE_ALPHA
00098         internalEnums << GL_LUMINANCE_ALPHA;
00099 #endif
00100 #ifdef GL_LUMINANCE4_ALPHA4
00101         internalEnums << GL_LUMINANCE4_ALPHA4;
00102 #endif
00103 #ifdef GL_LUMINANCE6_ALPHA2
00104         internalEnums << GL_LUMINANCE6_ALPHA2;
00105 #endif
00106 #ifdef GL_LUMINANCE8_ALPHA8
00107         internalEnums << GL_LUMINANCE8_ALPHA8;
00108 #endif
00109 #ifdef GL_LUMINANCE12_ALPHA4
00110         internalEnums << GL_LUMINANCE12_ALPHA4;
00111 #endif
00112 #ifdef GL_LUMINANCE12_ALPHA12
00113         internalEnums << GL_LUMINANCE12_ALPHA12;
00114 #endif
00115 #ifdef GL_LUMINANCE16_ALPHA16
00116         internalEnums << GL_LUMINANCE16_ALPHA16;
00117 #endif
00118 #ifdef GL_INTENSITY
00119         internalEnums << GL_INTENSITY;
00120 #endif
00121 #ifdef GL_INTENSITY4
00122         internalEnums << GL_INTENSITY4;
00123 #endif
00124 #ifdef GL_INTENSITY8
00125         internalEnums << GL_INTENSITY8;
00126 #endif
00127 #ifdef GL_INTENSITY12
00128         internalEnums << GL_INTENSITY12;
00129 #endif
00130 #ifdef GL_INTENSITY16
00131         internalEnums << GL_INTENSITY16;
00132 #endif
00133 #ifdef GL_RGB
00134         internalEnums << GL_RGB;
00135 #endif
00136 #ifdef GL_R3_G3_B2
00137         internalEnums << GL_R3_G3_B2;
00138 #endif
00139 #ifdef GL_RGB4
00140         internalEnums << GL_RGB4;
00141 #endif
00142 #ifdef GL_RGB5
00143         internalEnums << GL_RGB5;
00144 #endif
00145 #ifdef GL_RGB8
00146         internalEnums << GL_RGB8;
00147 #endif
00148 #ifdef GL_RGB10
00149         internalEnums << GL_RGB10;
00150 #endif
00151 #ifdef GL_RGB12
00152         internalEnums << GL_RGB12;
00153 #endif
00154 #ifdef GL_RGB16
00155         internalEnums << GL_RGB16;
00156 #endif
00157 #ifdef GL_RGBA
00158         internalEnums << GL_RGBA;
00159 #endif
00160 #ifdef GL_RGBA2
00161         internalEnums << GL_RGBA2;
00162 #endif
00163 #ifdef GL_RGBA4
00164         internalEnums << GL_RGBA4;
00165 #endif
00166 #ifdef GL_RGB5_A1
00167         internalEnums << GL_RGB5_A1;
00168 #endif
00169 #ifdef GL_RGBA8
00170         internalEnums << GL_RGBA8;
00171 #endif
00172 #ifdef GL_RGB10_A2
00173         internalEnums << GL_RGB10_A2;
00174 #endif
00175 #ifdef GL_RGBA12
00176         internalEnums << GL_RGBA12;
00177 #endif
00178 #ifdef GL_RGBA16
00179         internalEnums << GL_RGBA16;
00180 #endif
00181 #ifdef GL_RGBA32F_ARB
00182         internalEnums << GL_RGBA32F_ARB;
00183 #endif
00184 #ifdef GL_RGB32F_ARB
00185         internalEnums << GL_RGB32F_ARB;
00186 #endif
00187 #ifdef GL_ALPHA32F_ARB
00188         internalEnums << GL_ALPHA32F_ARB;
00189 #endif
00190 #ifdef GL_INTENSITY32F_ARB
00191         internalEnums << GL_INTENSITY32F_ARB;
00192 #endif
00193 #ifdef GL_LUMINANCE32F_ARB
00194         internalEnums << GL_LUMINANCE32F_ARB;
00195 #endif
00196 #ifdef GL_LUMINANCE_ALPHA32F_ARB
00197         internalEnums << GL_LUMINANCE_ALPHA32F_ARB;
00198 #endif
00199 #ifdef GL_RGBA16F_ARB
00200         internalEnums << GL_RGBA16F_ARB;
00201 #endif
00202 #ifdef GL_RGB16F_ARB
00203         internalEnums << GL_RGB16F_ARB;
00204 #endif
00205 #ifdef GL_ALPHA16F_ARB
00206         internalEnums << GL_ALPHA16F_ARB;
00207 #endif
00208 #ifdef GL_INTENSITY16F_ARB
00209         internalEnums << GL_INTENSITY16F_ARB;
00210 #endif
00211 #ifdef GL_LUMINANCE16F_ARB
00212         internalEnums << GL_LUMINANCE16F_ARB;
00213 #endif
00214 #ifdef GL_LUMINANCE_ALPHA16F_ARB
00215         internalEnums << GL_LUMINANCE_ALPHA16F_ARB;
00216 #endif
00217 #ifdef GL_STENCIL_INDEX1
00218         internalEnums << GL_STENCIL_INDEX1;
00219 #endif
00220 #ifdef GL_STENCIL_INDEX4
00221         internalEnums << GL_STENCIL_INDEX4;
00222 #endif
00223 #ifdef GL_STENCIL_INDEX8
00224         internalEnums << GL_STENCIL_INDEX8;
00225 #endif
00226 #ifdef GL_STENCIL_INDEX16
00227         internalEnums << GL_STENCIL_INDEX16;
00228 #endif
00229 #ifdef GL_DEPTH_COMPONENT16
00230         internalEnums << GL_DEPTH_COMPONENT16;
00231 #endif
00232 #ifdef GL_DEPTH_COMPONENT24
00233         internalEnums << GL_DEPTH_COMPONENT24;
00234 #endif
00235 #ifdef GL_DEPTH_COMPONENT32
00236         internalEnums << GL_DEPTH_COMPONENT32;
00237 #endif
00238 #ifdef GL_DEPTH_COMPONENT32F_NV
00239         internalEnums << GL_DEPTH_COMPONENT32F_NV;
00240 #endif
00241 #ifdef GL_DEPTH_BUFFER_FLOAT_MODE_NV
00242         internalEnums << GL_DEPTH_BUFFER_FLOAT_MODE_NV;
00243 #endif
00244         createProperty( this, "internalFormat", GLenumStruct( & m_internal ), internalEnums );
00245 
00246         EnumList targets;
00247 #ifdef GL_TEXTURE_2D
00248         targets << GL_TEXTURE_2D;
00249 #endif
00250 #ifdef GL_TEXTURE_RECTANGLE_EXT
00251         targets << GL_TEXTURE_RECTANGLE_EXT;
00252 #endif
00253         createProperty( this, "target", GLenumStruct( & m_target ), targets );
00254 
00255         EnumList modes;
00256 #ifdef GL_MODULATE
00257         modes << GL_MODULATE;
00258 #endif
00259 #ifdef GL_DECAL
00260         modes << GL_DECAL;
00261 #endif
00262 #ifdef GL_BLEND
00263         modes << GL_BLEND;
00264 #endif
00265 #ifdef GL_REPLACE
00266         modes << GL_REPLACE;
00267 #endif
00268         createProperty( this, "mode", GLenumStruct( & m_mode ), modes );
00269 
00270         EnumList wrapModes;
00271 #ifdef GL_CLAMP
00272         wrapModes << GL_CLAMP;
00273 #endif
00274 #ifdef GL_CLAMP_TO_EDGE
00275         wrapModes << GL_CLAMP_TO_EDGE;
00276 #endif
00277 #ifdef GL_REPEAT
00278         wrapModes << GL_REPEAT;
00279 #endif
00280         createProperty( this, "wrapMode", GLenumStruct( & m_wrap ), wrapModes );
00281 
00282         EnumList formats;
00283 #ifdef GL_ALPHA
00284         formats << GL_ALPHA;
00285 #endif
00286 #ifdef GL_RGB
00287         formats << GL_RGB;
00288 #endif
00289 #ifdef GL_RGBA
00290         formats << GL_RGBA;
00291 #endif
00292 #ifdef GL_LUMINANCE
00293         formats << GL_LUMINANCE;
00294 #endif
00295 #ifdef GL_LUMINANCE_ALPHA
00296         formats << GL_LUMINANCE_ALPHA;
00297 #endif
00298         createProperty( this, "format", GLenumStruct( & m_formatGL ), formats );
00299 
00300         EnumList filters;
00301 #ifdef GL_LINEAR
00302         filters << GL_LINEAR;
00303 #endif
00304 #ifdef GL_NEAREST
00305         filters << GL_NEAREST;
00306 #endif
00307         createProperty( this, "filter", GLenumStruct( & m_filter ), filters );
00308 
00309         EnumList types;
00310 #ifdef GL_UNSIGNED_BYTE
00311         types << GL_UNSIGNED_BYTE;
00312 #endif
00313 #ifdef GL_BYTE
00314         types << GL_BYTE;
00315 #endif
00316 #ifdef GL_UNSIGNED_SHORT
00317         types << GL_UNSIGNED_SHORT;
00318 #endif
00319 #ifdef GL_SHORT
00320         types << GL_SHORT;
00321 #endif
00322 #ifdef GL_UNSIGNED_INT
00323         types << GL_UNSIGNED_INT;
00324 #endif
00325 #ifdef GL_INT
00326         types << GL_INT;
00327 #endif
00328 #ifdef GL_FLOAT
00329         types << GL_FLOAT;
00330 #endif
00331 #ifdef GL_HALF_FLOAT
00332         types << GL_HALF_FLOAT;
00333 #endif
00334         createProperty( this, "type", GLenumStruct( & m_typeGL ), types );
00335 
00336 #ifndef RT_GLES2
00337         createProperty( this, "powerOfTwo", GLbooleanStruct( & m_makePOT ) );
00338         createProperty( this, "mipmap", GLbooleanStruct( & m_doMipMap ) );
00339 #endif
00340 
00341         createProperty( this, "defaultColor", & m_defaultColor );
00342 
00343 }
00344 
00345 const string Sampler::getTypeName( bool ofComponent ) const {
00346         return( "Sampler" );
00347 }
00348 
00349 Sampler::~Sampler( void ){
00351         glDeleteTextures( 1, &m_id );
00352 }
00353 
00354 const Vec4 & Sampler::getDefaultColor( void ) const { 
00355         return( m_defaultColor ); 
00356 }
00357 
00358 void Sampler::setDefaultColor( const Vec4 & color ){ 
00359         m_defaultColor = color; 
00360 }
00361 
00362 GLuint Sampler::getWidth( void ) const { 
00363         return( m_w ); 
00364 }
00365 
00366 GLuint Sampler::getHeight( void ) const { 
00367         return( m_h ); 
00368 }
00369 
00370 GLuint Sampler::getWidth2( void ) const { 
00371         return( m_w2 ); 
00372 }
00373 
00374 GLuint Sampler::getHeight2( void ) const { 
00375         return( m_h2 ); 
00376 }
00377 
00378 Vec2 Sampler::getSize( void ) const { 
00379         return( Vec2( m_w, m_h ) ); 
00380 }
00381 
00382 Vec2 Sampler::getSize2( void ) const { 
00383         return( Vec2( m_w2, m_h2 ) ); 
00384 }
00385 
00386 GLuint Sampler::getID( void ) const { 
00387         return( m_id ); 
00388 }
00389 
00390 GLenum Sampler::getInternalFormat( void ) const { 
00391         return( m_internal ); 
00392 }
00393 
00394 GLenum Sampler::getTarget( void ) const { 
00395         return( m_target ); 
00396 }
00397 
00398 GLenum Sampler::getMode( void ) const { 
00399         return( m_mode ); 
00400 }
00401 
00402 GLenum Sampler::getWrap( void ) const { 
00403         return( m_wrap ); 
00404 }
00405 
00406 GLenum Sampler::getFilter( void ) const { 
00407         return( m_filter ); 
00408 }
00409 
00416 void Sampler::onInitialize( void ){
00417         Image::onInitialize();
00418 
00419 #ifdef RT_DEVIL
00420         // get and store the equivalent GL format from the format set by Image
00421         m_formatGL = getGLFormat( m_format );
00422         // get and store the equivalent GL type from the type set by Image
00423         m_typeGL = getGLType( m_type );
00424 #else
00425         m_formatGL = m_format;
00426         m_typeGL = m_type;
00427 #endif
00428 
00429         if( m_filename != "" && ( ! m_fileNotFound ) ){
00431                 m_internal = m_format;
00432         }
00433 
00434         // find the nearest power of two
00435         m_w2 = 1;
00436         m_h2 = 1;
00437         while( m_w2 < m_w )m_w2 *= 2;
00438         while( m_h2 < m_h )m_h2 *= 2;
00439 
00440         bool createdTemporaryImageData = false;
00441         bool createdTemporarySamplerData = false;
00442 
00444         bool setDefaultColor = m_fileNotFound || m_filename == "";
00445 
00447         if( ! m_data ){
00448                 createdTemporaryImageData = true;
00449                 m_data = ( GLubyte * )calloc( m_w * m_h * m_channels, m_bytespp );
00450                 setDefaultColor = true;
00451         }
00452 
00453         if( m_overrideDefaultColor ){
00454                 setDefaultColor = false;
00455         }
00456         m_overrideDefaultColor = false;
00457 
00458         if( setDefaultColor ){
00459                 for( unsigned int i = 0; i < m_w * m_h; i++ ){
00460                         for( unsigned int j = 0; j < m_channels; j++ ){
00461                                 ( ( GLubyte * )( m_data ) )[ i * m_channels + j ] = (GLubyte)( m_defaultColor[ j ] * 255 ); 
00462                         }
00463                 }
00464         }
00465 
00466         // initially, the datablock of the image is used
00467         GLubyte * data = ( GLubyte * )m_data;
00468 
00469         // see if we are already POT or we are asked to make POT
00470         if( m_makePOT || ( m_w == m_w2 && m_h == m_h2 ) ){
00471                 // if so, use the normal OpenGL target
00472                 m_target = GL_TEXTURE_2D;
00473                 // check if we need to convert to POT
00474                 if( m_w != m_w2 || m_h != m_h2 ){
00475                         // create a power-of-two sampler, start by clean allocation 
00476                         data = ( GLubyte * )calloc( m_w2 * m_h2 * m_channels, m_bytespp );
00477                         if( ! data ){
00478                                 Error::error( Error::TEXTURE_ALLOCATION_FAILED, __FILE__, __LINE__ );
00479                         }
00480                         for( unsigned int i = 0; i < m_w2 * m_h2; i++ ){
00481                                 for( unsigned int j = 0; j < m_channels; j++ ){
00482                                         ( ( GLubyte * )( data ) )[ i * m_channels + j ] = (GLubyte)( m_defaultColor[ j ] * 255 ); 
00483                                 }
00484                         }
00485                         createdTemporarySamplerData = true;
00486 
00487                         // if data is set, copy into the power-of-two sampler data
00488                         if( m_data && data && ( ! createdTemporaryImageData ) ){
00489                                 for( unsigned int i = 0; i < m_h; i++ ){
00490                                         memcpy( &data[ i * m_w2 * m_channels ], &(( GLubyte *)m_data)[ i * m_w * m_channels ], m_w * m_bytespp );
00491                                 }
00492                         }
00493                 }
00494         }
00495 #ifdef GL_TEXTURE_RECTANGLE_EXT
00496         else{
00497                 // if not POT, check for limitations
00498                 if( m_wrap != GL_CLAMP &&
00499                         m_wrap != GL_CLAMP_TO_EDGE && 
00500                         m_wrap != GL_CLAMP_TO_BORDER ){
00501                                 Error::warning( Error::ILLEGAL_WRAPMODE_FOR_RECTANGLE_EXT, __FILE__, __LINE__, "set to: GL_CLAMP" );
00502                                 m_wrap = GL_CLAMP;
00503                 }
00504                 if( m_doMipMap ){
00505                         Error::warning( Error::MIPMAP_REQUESTED_FOR_RECTANGLE_EXT, __FILE__, __LINE__, "set to: false");
00506                         m_doMipMap = false;
00507                 }
00508                 // set the POT dimensions to the NPOT dimensions
00509                 m_w2 = m_w;
00510                 m_h2 = m_h;
00511 
00512                 // use the rectangle target
00513                 m_target = GL_TEXTURE_RECTANGLE_EXT;
00514 
00515                 data = ( GLubyte * )calloc( m_w * m_h * m_channels, m_bytespp );
00516                 if( ! data ){
00517                         Error::error( Error::TEXTURE_ALLOCATION_FAILED, __FILE__, __LINE__ );
00518                 }
00519                 createdTemporarySamplerData = true;
00520                 // if data is set, copy into the non-power-of-two sampler data
00521                 if( m_data && data && ( ! createdTemporaryImageData ) ){
00522                         for( unsigned int i = 0; i < m_h; i++ ){
00523                                 memcpy( &data[ i * m_w * m_channels ], &(( GLubyte *)m_data)[ i * m_w * m_channels ], m_w * m_bytespp );
00524                         }
00525                 }
00526         }
00527 #else
00528         else{
00530                 data = ( GLubyte * )calloc( m_w * m_h * m_channels, m_bytespp );
00531                 createdTemporarySamplerData = true;
00532                 if( ! data ){
00533                         Error::error( Error::TEXTURE_ALLOCATION_FAILED, __FILE__, __LINE__ );
00534                 }
00535                 // if data is set, copy into the non-power-of-two sampler data
00536                 if( m_data && data && createdTemporaryImageData ){
00537                         for( unsigned int i = 0; i < m_h; i++ ){
00538                                 memcpy( &data[ i * m_w * m_channels ], &(( GLubyte *)m_data)[ i * m_w * m_channels ], m_w * m_bytespp );
00539                         }
00540                 }
00541         }
00542 #endif
00543 
00544         // image is loaded / created, now create a sampler object for it
00545         if( glIsTexture( m_id ) == GL_FALSE ){
00546                 glGenTextures( 1, & m_id );
00547         }
00548 
00549         bind( 0 );
00550 
00551         // and set the sampler environment
00552         setTexEnv();
00553 
00554         // make sure bind & setenv were succesful
00555         Error::assertNoErrors( __FILE__, __LINE__ );
00556 
00558         if( m_internal != m_formatGL ){
00560         }
00561 
00562         // upload the first level (0) ignoring borders ( unsupported )
00563         glTexImage2D( m_target, 0, m_internal, m_w2, m_h2, 0, m_formatGL, m_typeGL, ( void * )data );
00565         
00566         // make sure upload was succesful
00567         Error::assertNoErrors( __FILE__, __LINE__ );
00568 
00569 #ifndef RT_GLES2
00570         // generate using glGenerateMipmap
00571         if( m_doMipMap ){
00572                 glHint( GL_GENERATE_MIPMAP_HINT, GL_NICEST );
00573                 glTexParameteri( m_target, GL_GENERATE_MIPMAP, GL_TRUE );
00574 #       ifndef RT_GLES
00575                 glGenerateMipmap( m_target );
00576 #       endif
00577 }
00578 #endif
00579 
00580         Error::assertNoErrors( __FILE__, __LINE__ );
00581 
00582         // make sure the data is uploaded 
00583         glFlush();
00584 
00585         Error::assertNoErrors( __FILE__, __LINE__ );
00586 
00587         if( createdTemporaryImageData ){
00588                 free( m_data );
00589         }
00590         if( createdTemporarySamplerData ){
00591                 // if a power-of-two copy was made, destroy that too
00592                 free( data );
00593         }
00594 
00595         // then destroy the image
00596         deleteImage();
00597 
00598         Error::assertNoErrors( __FILE__, __LINE__ );
00599 
00600         // clear the data
00601         m_data = NULL;
00602 
00603         Error::assertNoErrors( __FILE__, __LINE__ );
00604 
00605         // unbind till bind() is called
00606         unbind();
00607         
00608         Error::assertNoErrors( __FILE__, __LINE__ );
00609 }
00610 
00611 void Sampler::clear( void ){
00612         GLfloat * data = ( GLfloat * )calloc( m_w * m_h * m_channels, m_bytespp );
00613         for( unsigned int i = 0; i < m_w2 * m_h2; i++ ){
00614                 for( unsigned int j = 0; j < m_channels; j++ ){
00615                         ( ( GLubyte * )( data ) )[ i * m_channels + j ] = (GLubyte)( m_defaultColor[ j ] * 255 ); 
00616                 }
00617         }
00618         glTexImage2D( m_target, 0, m_internal, m_w2, m_h2, 0, m_formatGL, m_typeGL, ( void * )data );
00619         glFlush();
00620         glFinish();
00621         free( data );
00622 }
00623 
00628 void Sampler::download( string filename ){
00629 #ifndef RT_GLES
00630         // create and bind a new framebuffer / renderbuffer 
00631         GLuint fb_id, rb_id;
00632         glGenFramebuffers( 1, &fb_id );
00633         glGenRenderbuffers( 1, &rb_id );
00634         glBindFramebuffer( GL_FRAMEBUFFER, fb_id );
00635         glBindFramebuffer( GL_DRAW_FRAMEBUFFER, fb_id );
00636         glBindFramebuffer( GL_READ_FRAMEBUFFER, fb_id );
00637 
00638         glBindRenderbuffer( GL_RENDERBUFFER, rb_id );
00639         glRenderbufferStorage( GL_RENDERBUFFER, m_internal, m_w, m_h );
00640         glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rb_id );
00641 
00642         // make sure we're ok
00643         Error::assertNoErrors( __FILE__, __LINE__ );
00644 
00645         // setup a camera / viewport
00646         glMatrixMode( GL_PROJECTION );
00647         glLoadIdentity();
00648         glViewport( 0, 0, m_w, m_h );
00649         glOrtho( 0, m_w, 0, m_h, -1.0, 1.0 );
00650         glMatrixMode( GL_MODELVIEW );
00651         glLoadIdentity();
00652         
00653         // save state
00654         //glPushAttrib( GL_ALL_ATTRIB_BITS );
00655 
00656         // bind this sampler
00657         bind();
00658 
00659         // set alpha pass-through
00660         glEnable( GL_ALPHA_TEST );
00661         glAlphaFunc( GL_ALWAYS, 0 );
00662 
00663         // render a quad with the current sampler 
00664         glBegin( GL_QUADS );
00665         glTexCoord2f( 0.0, 0.0 );
00666         glVertex2f( 0.0, 0.0 );
00667         glTexCoord2f( 1.0, 0.0 );
00668         glVertex2f( m_w, 0.0 );
00669         glTexCoord2f( 1.0, 1.0 );
00670         glVertex2f( m_w, m_h );
00671         glTexCoord2f( 0.0, 1.0 );
00672         glVertex2f( 0.0, m_h );
00673         glEnd();
00674 
00675         // create a new databuffer
00676         GLubyte * data = ( GLubyte * )malloc( m_w * m_h * m_bytespp );
00677 
00678         // read from the currently active buffer
00679         glReadPixels( 0, 0, m_w, m_h, m_formatGL, m_typeGL, data );
00680 
00681         // push into the image data
00682         setData( data );
00683 
00684         // set data to Image data
00685         m_data = const_cast< void * >( getData() );
00686 
00687         // if filename is given, save to it
00688         if( filename != "" ){
00689                 save( filename );
00690         }
00691 
00692         // delete the local copy
00693         free( data );
00694 
00695         // upload
00696         initialize( true );
00697 
00698         // destroy the temporary framebufer
00699         glDeleteRenderbuffers( 1, &rb_id );
00700         glDeleteFramebuffers( 1, &fb_id );
00701 
00702         // make sure we're ok
00703         Error::assertNoErrors( __FILE__, __LINE__ );
00704 #elif WIN32
00705 #       pragma message( "warning: Sampler::download() not implemented under OpenGL|ES" )
00706 #elif APPLE
00707 #endif
00708 
00709 }
00710 
00711 void Sampler::setData( const void * data ){
00712         Image::setData( data ); 
00713         m_data = const_cast< void * >( data );
00714         m_overrideDefaultColor = true;
00715         initialize( true );
00716 }
00717 
00719 void Sampler::onBind( int unit ){
00720         Mat4 mat = Mat4::fromIdentity();
00721         if( m_makePOT ){
00722                 mat[0] = (float)m_w / (float)m_w2;
00723                 mat[5] = (float)m_h / (float)m_h2;
00724         }
00725         set( Matrix::TEXTURE, mat );
00726         Error::assertNoErrors( __FILE__, __LINE__ );
00727 
00728         glActiveTexture( GL_TEXTURE0 + unit );
00729         glEnable( m_target );
00730         glBindTexture( m_target, m_id );
00731 
00732         Error::assertNoErrors( __FILE__, __LINE__ );
00733 }
00734 
00735 void Sampler::setTexEnv( void ){
00736 #ifndef RT_GLES2
00737         GLfloat white[4] = { 1.0, 1.0, 1.0, 1.0 };
00738 
00739         // set the sampler environment
00740         glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, m_mode );
00741         glTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, white );
00742 
00743         // set the wrapping and filter modes
00744         glTexParameteri( m_target, GL_TEXTURE_WRAP_S, m_wrap );
00745         glTexParameteri( m_target, GL_TEXTURE_WRAP_T, m_wrap );
00746         glTexParameteri( m_target, GL_TEXTURE_MAG_FILTER, m_filter );
00747         glTexParameteri( m_target, GL_TEXTURE_MIN_FILTER, m_filter );
00748 
00749         // set the pixel storage 
00750 #ifdef GL_UNPACK_ALIGNMENT
00751         glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
00752 #endif
00753 #ifdef GL_UNPACK_SKIP_ROWS
00754         glPixelStorei( GL_UNPACK_SKIP_ROWS, 0 ); 
00755 #endif
00756 #ifdef GL_UNPACK_SKIP_PIXELS
00757         glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0 );
00758 #endif
00759 #ifdef GL_UNPACK_ROW_LENGTH
00760         glPixelStorei( GL_UNPACK_ROW_LENGTH, 0 );
00761 #endif
00762 #ifdef GL_UNPACK_SWAP_BYTES
00763         glPixelStorei( GL_UNPACK_SWAP_BYTES, GL_FALSE );
00764 #endif
00765 #elif WIN32
00766 #       pragma message( "warning: Sampler::setTexEnv() not implemented under OpenGL|ES 2.0" )
00767 #elif APPLE
00768 //#     message( "warning: Sampler::setTexEnv() not implemented under OpenGL|ES 2.0" )
00769 #endif
00770 }
00771 
00772 void Sampler::onUnbind( int unit ){
00773 
00774         if( unit == -1 ){
00775                 GLint maxSamplers = 4;
00776                 
00777 #ifdef GL_MAX_TEXTURE_COORDS 
00778         //      maxSamplers = maxSamplers < glGetInteger( GL_MAX_TEXTURE_COORDS ) ? maxSamplers : glGetInteger( GL_MAX_TEXTURE_COORDS );
00779         //      Error::assertNoErrors( __FILE__, __LINE__ );
00780 #endif
00781 
00782 #ifdef GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
00783         //      maxSamplers = maxSamplers < glGetInteger( GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS ) ? maxSamplers : glGetInteger( GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS );
00784         //      Error::assertNoErrors( __FILE__, __LINE__ );
00785 #endif
00786 
00791                 for( GLint i = 0; i < maxSamplers; i++ ){
00792                         onUnbind( i );
00793                 }
00794         }
00795         else{
00796                 glActiveTexture( GL_TEXTURE0 + unit );
00797                 Error::assertNoErrors( __FILE__, __LINE__ );
00798 #ifdef GL_TEXTURE_RECTANGLE_EXT 
00799                 if( glIsEnabled( GL_TEXTURE_RECTANGLE_EXT ) ){
00800                         glDisable( GL_TEXTURE_RECTANGLE_EXT );
00801                         Error::assertNoErrors( __FILE__, __LINE__ );
00802                 }
00803                 else
00804 #endif
00805                 if( glIsEnabled( GL_TEXTURE_2D ) ){
00806                         glDisable( GL_TEXTURE_2D );
00807                         Error::assertNoErrors( __FILE__, __LINE__ );
00808                 }
00809         }
00810 }
00811 
00814 GLboolean Sampler::isResident( void ) const {
00815         GLboolean ret = GL_FALSE;
00816 #ifndef RT_GLES
00817         glAreTexturesResident( 1, &m_id, &ret );
00818 #endif
00819         return( ret );
00820 }
00821 
00822 #ifdef RT_DEVIL
00823 
00825 GLenum Sampler::getGLFormat( ILenum formatIL ){
00826         // return GL pixelformat from IL
00827         switch( formatIL ){
00828                 // ignore COLOR_INDEX
00829                 case IL_COLOR_INDEX:
00830                         return( 0 );
00831                 case IL_ALPHA:
00832                         return( GL_ALPHA );
00833                 case IL_RGB:
00834                         return( GL_RGB );
00835                 case IL_RGBA:
00836                         return( GL_RGBA );
00837                 case IL_BGR: // no difference implemented
00838                         return( GL_RGB );
00839                 case IL_BGRA: // idem
00840                         return( GL_RGBA );
00841                 case IL_LUMINANCE:
00842                         return( GL_LUMINANCE );
00843                 case IL_LUMINANCE_ALPHA:
00844                         return( GL_LUMINANCE_ALPHA );
00845                 default:
00846                         return( GL_RGBA );
00847         }
00848 }
00849 
00850 ILenum Sampler::getILFormat( GLenum typeGL ){
00851         // get IL format from GL
00852         switch( typeGL ){
00853 #ifdef GL_COLOR_INDEX 
00854                 case IL_COLOR_INDEX:
00855                         return( GL_COLOR_INDEX );
00856 #endif
00857                 case GL_ALPHA:
00858                         return( IL_ALPHA );
00859                 case GL_RGB:
00860                         return( IL_RGB );
00861                 case GL_RGBA:
00862                         return( IL_RGBA );
00863 #ifdef GL_LUMINANCE
00864                 case GL_LUMINANCE:
00865                         return( IL_LUMINANCE );
00866 #endif
00867 #ifdef GL_LUMINANCE_ALPHA
00868                 case GL_LUMINANCE_ALPHA:
00869                         return( IL_LUMINANCE_ALPHA );
00870 #endif
00871                 default:
00872                         return( IL_RGBA );
00873         }
00874 }
00875 
00876 
00877 GLenum Sampler::getGLType( ILenum typeIL ){
00878         // get GL datatype from IL
00879         switch( typeIL ){
00880                 case IL_BYTE:
00881                         return( GL_BYTE );
00882                 case IL_UNSIGNED_BYTE:
00883                         return( GL_UNSIGNED_BYTE );
00884                 case IL_SHORT:
00885                         return( GL_SHORT );
00886                 case IL_UNSIGNED_SHORT:
00887                         return( GL_UNSIGNED_SHORT );
00888 #ifdef GL_INT
00889                 case IL_INT:
00890                         return( GL_INT );
00891 #endif
00892 #ifdef GL_UNSIGNED_INT
00893                 case IL_UNSIGNED_INT:
00894                         return( GL_UNSIGNED_INT );
00895 #endif
00896                 case IL_FLOAT:
00897                         return( GL_FLOAT );
00898 #ifdef GL_DOUBLE 
00899                 case IL_DOUBLE:
00900                         return( GL_DOUBLE );
00901 #endif
00902 #ifdef GL_HALF_FLOAT 
00903                 case IL_HALF:
00904                         return( GL_HALF_FLOAT );
00905 #endif
00906                 default:
00907                         return( GL_UNSIGNED_BYTE );
00908         }
00909 }
00910 
00911 ILenum Sampler::getILType( GLenum typeGL ){
00912         // get IL datatype from GL
00913         switch( typeGL ){
00914                 case GL_BYTE:
00915                         return( IL_BYTE );
00916                 case GL_UNSIGNED_BYTE:
00917                         return( IL_UNSIGNED_BYTE );
00918                 case GL_SHORT:
00919                         return( IL_SHORT );
00920                 case GL_UNSIGNED_SHORT:
00921                         return( IL_UNSIGNED_SHORT );
00922 #ifdef GL_INT
00923                 case GL_INT:
00924                         return( IL_INT );
00925 #endif
00926 #ifdef GL_UNSIGNED_INT
00927                 case GL_UNSIGNED_INT:
00928                         return( IL_UNSIGNED_INT );
00929 #endif
00930                 case GL_FLOAT:
00931                         return( IL_FLOAT );
00932 #ifdef GL_DOUBLE
00933                 case GL_DOUBLE:
00934                         return( IL_DOUBLE );
00935 #endif
00936 #ifdef GL_HALF_FLOAT
00937                 case GL_HALF_FLOAT:
00938                         return( IL_HALF );
00939 #endif
00940                 default:
00941                         return( IL_UNSIGNED_BYTE );
00942         }
00943 }
00944 
00945 #endif // RT_DEVIL
00946 
00947 };