VTK
|
00001 /*========================================================================= 00002 00003 Program: Visualization Toolkit 00004 Module: $RCSfile: vtkOpenGLStateCache.h,v $ 00005 00006 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen 00007 All rights reserved. 00008 See Copyright.txt or http://www.kitware.com/Copyright.htm for details. 00009 00010 This software is distributed WITHOUT ANY WARRANTY; without even 00011 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 00012 PURPOSE. See the above copyright notice for more information. 00013 00014 =========================================================================*/ 00023 #ifndef VTK_IMPLEMENT_MESA_CXX 00024 # include "vtkOpenGL.h" // Needed for GL api types. 00025 #endif 00026 00027 #define vtkOpenGLCall_glEnable vtkOpenGLStateCache::CurrentGLCache->glEnable 00028 #define vtkOpenGLCall_glDisable vtkOpenGLStateCache::CurrentGLCache->glDisable 00029 #define vtkOpenGLCall_glAlphaFunc vtkOpenGLStateCache::CurrentGLCache->glAlphaFunc 00030 #define vtkOpenGLCall_glBlendFunc vtkOpenGLStateCache::CurrentGLCache->glBlendFunc 00031 #define vtkOpenGLCall_glDepthFunc vtkOpenGLStateCache::CurrentGLCache->glDepthFunc 00032 #define vtkOpenGLCall_glTexEnvf vtkOpenGLStateCache::CurrentGLCache->glTexEnvf 00033 #define vtkOpenGLCall_glLightModeli vtkOpenGLStateCache::CurrentGLCache->glLightModeli 00034 #define vtkOpenGLCall_glLightModelfv vtkOpenGLStateCache::CurrentGLCache->glLightMOdelfv 00035 #define vtkOpenGLCall_glLightfv vtkOpenGLStateCache::CurrentGLCache->glLightfv 00036 #define vtkOpenGLCall_glLightf vtkOpenGLStateCache::CurrentGLCache->glLightf 00037 #define vtkOpenGLCall_glLighti vtkOpenGLStateCache::CurrentGLCache->glLighti 00038 #define vtkOpenGLCall_glMaterialfv vtkOpenGLStateCache::CurrentGLCache->glMaterialfv 00039 #define vtkOpenGLCall_glShadeModel vtkOpenGLStateCache::CurrentGLCache->glShadeModel 00040 #define vtkOpenGLCall_glClearColor vtkOpenGLStateCache::CurrentGLCache->glClearColor 00041 #define vtkOpenGLCall_glClearDepth vtkOpenGLStateCache::CurrentGLCache->glClearDepth 00042 #define vtkOpenGLCall_glDepthMask vtkOpenGLStateCache::CurrentGLCache->glDepthMask 00043 #define vtkOpenGLCall_glCullFace vtkOpenGLStateCache::CurrentGLCache->glCullFace 00044 #define vtkOpenGLCall_glClear vtkOpenGLStateCache::CurrentGLCache->glClear 00045 #define vtkOpenGLCall_glDrawBuffer vtkOpenGLStateCache::CurrentGLCache->glDrawBuffer 00046 #define vtkOpenGLCall_glMatrixMode vtkOpenGLStateCache::CurrentGLCache->glMatrixMode 00047 #define vtkOpenGLCall_glViewport vtkOpenGLStateCache::CurrentGLCache->glViewport 00048 #define vtkOpenGLCall_glScissor vtkOpenGLStateCache::CurrentGLCache->glScissor 00049 #define vtkOpenGLCall_glClipPlane vtkOpenGLStateCache::CurrentGLCache->glClipPlane 00050 #define vtkOpenGLCall_glColorMaterial vtkOpenGLStateCache::CurrentGLCache->glColorMaterial 00051 #define vtkOpenGLCall_glPointSize vtkOpenGLStateCache::CurrentGLCache->glPointSize 00052 #define vtkOpenGLCall_glLineWidth vtkOpenGLStateCache::CurrentGLCache->glLineWidth 00053 #define vtkOpenGLCall_glLineStipple vtkOpenGLStateCache::CurrentGLCache->glLineStipple 00054 #define vtkOpenGLCall_glDepthRange vtkOpenGLStateCache::CurrentGLCache->glDepthRange 00055 #define vtkOpenGLCall_glPolygonOffset vtkOpenGLStateCache::CurrentGLCache->glPolygonOffset 00056 00057 #define vtkOpenGLCall_glPushMatrix glPushMatrix 00058 #define vtkOpenGLCall_glPopMatrix glPopMatrix 00059 #define vtkOpenGLCall_glMultMatrixd glMultMatrixd 00060 #define vtkOpenGLCall_glLoadMatrixd glLoadMatrixd 00061 #define vtkOpenGLCall_glLoadIdentity glLoadIdentity 00062 #define vtkOpenGLCall_glSelectBuffer glSelectBuffer 00063 #define vtkOpenGLCall_glRenderMode glRenderMode 00064 #define vtkOpenGLCall_glInitNames glInitNames 00065 #define vtkOpenGLCall_glPushName glPushName 00066 #define vtkOpenGLCall_glLoadName glLoadName 00067 #define vtkOpenGLCall_glGetIntegerv glGetIntegerv 00068 #define vtkOpenGLCall_glIsTexture glIsTexture 00069 #define vtkOpenGLCall_glDeleteTextures glDeleteTexture 00070 #define vtkOpenGLCall_glGenTextures glGenTextures 00071 #define vtkOpenGLCall_glBindTexture glBindTexture 00072 #define vtkOpenGLCall_glTexParameterf glTextParameterf 00073 #define vtkOpenGLCall_glTexCoord2fv glTexCoord2fv 00074 #define vtkOpenGLCall_glVertex3fv glVertex3fv 00075 #define vtkOpenGLCall_glNormal3fv glNormal3fv 00076 #define vtkOpenGLCall_glColor3f glColor3f 00077 #define vtkOpenGLCall_glColor4ubv glColor4ubv 00078 #define vtkOpenGLCall_glColor4fv glColor4fv 00079 #define vtkOpenGLCall_glBegin glBegin 00080 #define vtkOpenGLCall_glEnd glEnd 00081 #define vtkOpenGLCall_glTexImage2D glTextImage2D 00082 #define vtkOpenGLCall_glDeleteLists glDeleteLists 00083 #define vtkOpenGLCall_glIsList glIsList 00084 #define vtkOpenGLCall_glGenLists glGenLists 00085 #define vtkOpenGLCall_glCallList glCallList 00086 #define vtkOpenGLCall_glReadBuffer glReadBuffer 00087 #define vtkOpenGLCall_glPixelStorei glPixelStorei 00088 #define vtkOpenGLCall_glReadPixels glReadPixels 00089 #define vtkOpenGLCall_glRasterPos3f glRasterPos3f 00090 #define vtkOpenGLCall_glDrawPixels glDrawPixels 00091 #define vtkOpenGLCall_glRasterPos2f glRasterPos2f 00092 #define vtkOpenGLCall_glNewList glNewList 00093 #define vtkOpenGLCall_glEndList glEndList 00094 00095 class vtkOpenGLStateCache 00096 { 00097 public: 00098 static vtkOpenGLStateCache *CurrentGLCache; // recursive definition 00099 00100 vtkOpenGLStateCache(); // set all members to initial values 00101 ~vtkOpenGLStateCache(); // delete any dynamic objects 00102 void Initialize(); 00103 00104 // GL_BLEND = 0x0BE2 00105 // GL_POINT_SMOOTH = 0x0B10 00106 // GL_LINE_SMOOTH = 0x0B20 00107 // GL_POLYGON_SMOOTH= 0x0B41 00108 // GL_DEPTH_TEST = 0x0B71 00109 // GL_ALPHA_TEST = 0x0BC0 00110 // GL_TEXTURE_2D = 0x0DE1 00111 // GL_CLIP_PLANE0+i = 0x3000 00112 // GL_LIGHTING = 0x0B50 00113 // GL_COLOR_MATERIAL= 0x0B57 00114 // GL_NORMALIZE = 0x0BA1 00115 // GL_CULL_FACE = 0x0B44 00116 // GL_SCISSOR_TEST = 0x0C11 00117 // GL_POLYGON_OFFSET_FILL = 0x8037 00118 // GL_LINE_STIPPLE = 0x0B24 00119 // GL_LIGHT+i = 0x4000 00120 char Enable_buckets[0xDE1-0xB10+1]; // 0xB10-0xDE1 00121 char Enable_GL_LIGHT_buckets[8]; // 0x4000 + i (0<i<8) 00122 char Enable_GL_CLIP_PLANE_buckets[8]; // 0x8000 + i (0<i<8) 00123 /* Need to have special handling for disabling and enabling the 00124 GL_LIGHT's because they are disabling too many lights! 00125 need to propagate in how many lights are actually *on* 00126 and only apply the op to them. 00127 */ 00128 inline void glEnable(GLenum e) 00129 { 00130 register int ex; 00131 register char *val=0; 00132 if(e&0x4000) 00133 { 00134 ex=e-0x4000; 00135 if(ex<8) {val=Enable_GL_LIGHT_buckets+ex; } 00136 } 00137 else 00138 { 00139 if(e&0x8000) 00140 { 00141 ex=e-0x8000; 00142 if(ex<8) { val=Enable_GL_CLIP_PLANE_buckets+ex; } 00143 } 00144 else 00145 { 00146 if(e>=0xB10 && e<=0xDE1) 00147 { 00148 ex=e-0xB10; 00149 val=Enable_buckets+ex; 00150 } 00151 else 00152 { 00153 printf("Error: glEnable of 0x%X failed\n",e); 00154 } 00155 } 00156 } 00157 if(val && *val!=1) 00158 { 00159 *val=1; 00160 ::glEnable(e); 00161 } 00162 } 00163 inline void glDisable(GLenum e) 00164 { 00165 register int ex; 00166 register char *val=0; 00167 if(e&0x4000) 00168 { 00169 ex=e-0x4000; 00170 if(ex<8) { val=Enable_GL_LIGHT_buckets+ex; } 00171 } 00172 else 00173 { 00174 if(e&0x8000) 00175 { 00176 ex=e-0x8000; 00177 if(ex<8) { val=Enable_GL_CLIP_PLANE_buckets+ex; } 00178 } 00179 else 00180 { 00181 if(e>=0xB10 && e<=0xDE1) 00182 { 00183 ex=e-0xB10; 00184 val=Enable_buckets+ex; 00185 } 00186 else 00187 { 00188 printf("Error: glEnable of 0x%X failed\n",e); 00189 } 00190 } 00191 } 00192 if(val && *val!=0) 00193 { 00194 *val=0; 00195 ::glDisable(e); 00196 } 00197 } 00198 00199 // GL_GREATER = 0x0204, (GLclampf) 0 00200 GLclampf AlphaFunc_bucket; 00201 inline void glAlphaFunc(GLenum e,GLclampf cf) 00202 { 00203 if(e==GL_GREATER && cf!=AlphaFunc_bucket) 00204 { 00205 AlphaFunc_bucket=cf; 00206 ::glAlphaFunc(e,cf); 00207 } 00208 } 00209 00210 // GL_SRC_ALPHA = 0x0302, GL_ONE_MINUS_SRC_ALPHA = 0x0303 00211 GLenum BlendFunc_bucket; // multibucket if any other blendfunc is used 00212 inline void glBlendFunc(GLenum e,GLenum e1) 00213 { 00214 if(e==GL_SRC_ALPHA && e1!=BlendFunc_bucket) 00215 { 00216 BlendFunc_bucket=e1; 00217 ::glBlendFunc(e,e1); 00218 } 00219 } 00220 00221 // GL_GREATER = 0x0204 00222 // GL_LESS = 0x0201 00223 // GL_LEQUAL = 0x0203 00224 GLenum DepthFunc_bucket; 00225 inline void glDepthFunc(GLenum e) 00226 { 00227 if(e!=DepthFunc_bucket) 00228 { 00229 DepthFunc_bucket=e; 00230 ::glDepthFunc(e); 00231 } 00232 } 00233 00234 // GL_TEXTURE_ENV = 0x2300, GL_TEXTURE_ENV_MODE = 0x2200, GL_MODULATE = 0x2100 00235 GLfloat TexEnvf_MODE_bucket; // total kludge right now 00236 inline void glTexEnvf(GLenum e,GLenum e1,GLfloat f) 00237 { 00238 if(e==GL_TEXTURE_ENV && e1==GL_TEXTURE_ENV_MODE) 00239 { 00240 if(f!=TexEnvf_MODE_bucket) 00241 { 00242 TexEnvf_MODE_bucket=f; 00243 ::glTexEnvf(e,e1,f); 00244 } 00245 } 00246 } 00247 00248 // GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE/FALSE 00249 // GL_LIGHT_MODEL_TWO_SIDE, 0 00250 GLint LightModeli_LIGHT_MODEL_TWO_SIDE_bucket; // shoudld check other modes 00251 inline void glLightModeli(GLenum e,GLint i) 00252 { 00253 if(e==GL_LIGHT_MODEL_TWO_SIDE && i!=LightModeli_LIGHT_MODEL_TWO_SIDE_bucket){ 00254 LightModeli_LIGHT_MODEL_TWO_SIDE_bucket=i; 00255 ::glLightModeli(e,i); 00256 } 00257 } 00258 00259 // GL_LIGHT_MODEL_AMBIENT, fvect(amb color), A=1.0 00260 // GL_LIGHT_MODEL_AMBIENT = 0x0B53 00261 GLfloat LightModelfv_LIGHT_MODEL_AMBIENT_bucket[3]; 00262 inline void glLightModelfv(GLenum e,GLfloat *fv) 00263 { 00264 if(e==GL_LIGHT_MODEL_AMBIENT && 00265 (fv[0]!=LightModelfv_LIGHT_MODEL_AMBIENT_bucket[0] || 00266 fv[1]!=LightModelfv_LIGHT_MODEL_AMBIENT_bucket[1] || 00267 fv[2]!=LightModelfv_LIGHT_MODEL_AMBIENT_bucket[2])){ 00268 fv[0]=LightModelfv_LIGHT_MODEL_AMBIENT_bucket[0]; 00269 fv[1]=LightModelfv_LIGHT_MODEL_AMBIENT_bucket[1]; 00270 fv[2]=LightModelfv_LIGHT_MODEL_AMBIENT_bucket[2]; 00271 ::glLightModelfv(e,fv); 00272 } 00273 } 00274 00275 // light=GL_LIGHT index 00276 // pname= lighting type 00277 // GL_DIFFUSE = 0x1201 00278 // GL_SPECULAR = 0x1202 00279 // GL_POSITION = 0x1203 00280 // GL_SPOT_DIRECTION = 0x1204 00281 GLfloat Lightfv_buckets[8*4*8]; 00282 inline void glLightfv( GLenum light, GLenum pname, const GLfloat *params) 00283 { 00284 register GLfloat *val = Lightfv_buckets + ((((int)(pname-0x1201))|((int)(light-GL_LIGHT0)<<3))<<2); 00285 if(params[0]!=val[0] || 00286 params[1]!=val[1] || 00287 params[2]!=val[2] || 00288 params[3]!=val[3]) 00289 { 00290 val[0]=params[0]; 00291 val[1]=params[1]; 00292 val[2]=params[2]; 00293 val[3]=params[3]; 00294 ::glLightfv(light,pname,params); 00295 } 00296 } 00297 00298 // light=GL_LIGHT index 00299 // pname= lighting parameter 00300 // GL_SPOT_EXPONENT = 0x1205 00301 // GL_SPOT_CUTOFF = 0x1206 00302 // GL_CONSTANT_ATTENUATION = 0x1207 00303 // GL_LINEAR_ATTENUATION = 0x1208 00304 // GL_QUADRATIC_ATTENUATION= 0x1209 00305 GLfloat Lightf_buckets[8*8]; 00306 GLint Lighti_SPOT_CUTOFF_buckets[8]; 00307 inline void glLightf( GLenum light, GLenum pname, GLfloat f){ 00308 register GLfloat *val=Lightf_buckets+(((int)(light-GL_LIGHT0)<<3)|((int)(pname-0x1205))); 00309 if(val[0]!=f) 00310 { 00311 val[0]=f; 00312 ::glLightf(light,pname,f); 00313 if(pname==GL_SPOT_CUTOFF) // invalidate integer spot cutoff 00314 Lighti_SPOT_CUTOFF_buckets[light-GL_LIGHT0]=-1; 00315 } 00316 } 00317 00318 // light=GL_LIGHT index 00319 // pname=lighting parameter 00320 // GL_SPOT_CUTOFF = 0x1206 00321 // needs to invalidate the float light cutoff 00322 inline void glLighti( GLenum light, GLenum pname, GLint f) 00323 { 00324 if(pname==GL_SPOT_CUTOFF && f!=Lighti_SPOT_CUTOFF_buckets[light-GL_LIGHT0]){ 00325 Lighti_SPOT_CUTOFF_buckets[light-GL_LIGHT0]=f; 00326 ::glLighti(light,pname,f); 00327 // need to invalidate the float cutoff 00328 Lightf_buckets[((int)(light-GL_LIGHT0)<<3)|0x02] = -1.0f; 00329 } 00330 } 00331 00332 // Face, GL_AMBIENT, float Info[4] 00333 // GL_FRONT = 0x0404 00334 // GL_BACK = 0x0405 00335 // GL_FRONT_AND_BACK = 0x0408 00336 // GL_AMBIENT = 0x1200 00337 // GL_DIFFUSE = 0x1201 00338 // GL_SPECULAR = 0x1202 00339 // GL_EMISSION = 0x1600 00340 // GL_SHININESS = 0x1601 00341 // GL_AMBIENT_AND_DIFFUSE = 0x1602 00342 // GL_COLOR_INDEXES = 0x1603 00343 GLfloat Materialfv_buckets[8*8*4]; 00344 inline void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params ) 00345 { 00346 register int idx; 00347 register GLfloat *val; 00348 if(pname>=0x1600) 00349 { 00350 idx=pname-0x1600 + 4; // put it just past the 120x buckets 00351 } 00352 else 00353 { 00354 idx=pname-0x1200; 00355 } 00356 // FRONT/BACK and FRONT_AND_BACK should do both. 00357 // or perhaps should be a separate state key? 00358 // For now, we will treat FRONT_AND_BACK independently 00359 // because from a practical standpoint, that's how 00360 // it tends to get used. 00361 val = Materialfv_buckets + ((((face-0x0404)<<3)|idx)<<2); 00362 if(val[0]!=params[0] || 00363 val[1]!=params[1] || 00364 val[2]!=params[2] || 00365 val[3]!=params[3]) 00366 { 00367 val[0]=params[0]; 00368 val[1]=params[1]; 00369 val[2]=params[2]; 00370 val[3]=params[3]; 00371 ::glMaterialfv(face,pname,params); 00372 } 00373 } 00374 00375 /* 00376 a=0; 00377 a|=(val[0]^params[0]) 00378 a|=(val[1]^params[1]) 00379 a|=(val[2]^params[2]) 00380 a|=(val[3]^params[3]) 00381 */ 00382 // GL_FLAT = 0x1D00 00383 // GL_SMOOTH = 0x1D01 00384 GLenum ShadeModel_bucket; 00385 inline void glShadeModel(GLenum e) 00386 { 00387 if(ShadeModel_bucket!=e) 00388 { 00389 ShadeModel_bucket=e; 00390 ::glShadeModel(e); 00391 } 00392 } 00393 00394 GLclampf ClearColor_buckets[4]; 00395 inline void glClearColor(GLclampf r,GLclampf g,GLclampf b,GLclampf a) 00396 { 00397 register GLclampf *c=ClearColor_buckets; 00398 if(c[0]!=r || 00399 c[1]!=g || 00400 c[2]!=b || 00401 c[3]!=a) 00402 { 00403 c[0]=r; 00404 c[1]=g; 00405 c[2]=b; 00406 c[3]=a; 00407 ::glClearColor(r,g,b,a); 00408 } 00409 } 00410 00411 GLclampd ClearDepth_bucket; 00412 inline void glClearDepth(GLclampd d) 00413 { 00414 if(d!=ClearDepth_bucket) 00415 { 00416 ClearDepth_bucket=d; 00417 ::glClearDepth(d); 00418 } 00419 } 00420 00421 GLclampf DepthMask_bucket; 00422 inline void glDepthMask(GLenum e) 00423 { 00424 if(DepthMask_bucket!=e) 00425 { 00426 DepthMask_bucket=e; 00427 ::glDepthMask(e); 00428 } 00429 } 00430 00431 // GL_FRONT = 0x0404 00432 // GL_BACK = 0x0405 00433 GLenum CullFace_bucket; 00434 inline void glCullFace(GLenum e) 00435 { 00436 if(CullFace_bucket!=e) 00437 { 00438 CullFace_bucket=e; 00439 ::glCullFace(e); 00440 } 00441 } 00442 00443 // well, lets go ahead and let it clear when it wants to 00444 inline void glClear(GLbitfield b) { ::glClear(b);} 00445 // GL_BACK_LEFT = 0x0402 00446 // GL_BACK_RIGHT = 0x0403 00447 // GL_FRONT = 0x0404 00448 // GL_BACK = 0x0405 00449 GLenum DrawBuffer_bucket; 00450 inline void glDrawBuffer(GLenum e) { 00451 if(e!=DrawBuffer_bucket){ 00452 DrawBuffer_bucket=e; 00453 ::glDrawBuffer(e); 00454 } 00455 } 00456 //============Matrix Ops (behave different for deferred ops)=== 00457 // GL_MODELVIEW=0x1700 00458 // GL_PROJECTION=0x1701 00459 GLenum MatrixMode_bucket; 00460 inline void glMatrixMode(GLenum e) { 00461 if(e!=MatrixMode_bucket){ 00462 MatrixMode_bucket=e; 00463 ::glMatrixMode(e); 00464 } 00465 } 00466 00467 GLint Viewport_bucket[4]; 00468 inline void glViewport(GLint llx,GLint lly,GLint u,GLint v){ 00469 register GLint *val=Viewport_bucket; 00470 if(val[0]!=llx || 00471 val[1]!=lly || 00472 val[2]!=u || 00473 val[3]!=v){ 00474 val[0]=llx; 00475 val[1]=lly; 00476 val[2]=u; 00477 val[3]=v; 00478 ::glViewport(llx,lly,u,v); 00479 } 00480 } 00481 // only needs to be called if scissor changes (and it usually won't) 00482 GLint Scissor_bucket[4]; 00483 inline void glScissor(GLint llx,GLint lly,GLint u,GLint v){ 00484 register GLint *val=Scissor_bucket; 00485 if(val[0]!=llx || 00486 val[1]!=lly || 00487 val[2]!=u || 00488 val[3]!=v){ 00489 val[0]=llx; 00490 val[1]=lly; 00491 val[2]=u; 00492 val[3]=v; 00493 ::glScissor(llx,lly,u,v); 00494 } 00495 } 00496 00497 // what is the order of the clip plane eqn??? 00498 // GL_CLIP_PLANE0 = 0x3000 00499 GLdouble ClipPlane_bucket[4*GL_MAX_CLIP_PLANES]; 00500 inline void glClipPlane(GLenum e,const GLdouble *eqn){ 00501 register GLdouble *val=ClipPlane_bucket + ((e-0x3000)<<2); 00502 if(val[0]!=eqn[0] || 00503 val[1]!=eqn[1] || 00504 val[2]!=eqn[2] || 00505 val[3]!=eqn[3]){ 00506 val[0]=eqn[0]; 00507 val[1]=eqn[1]; 00508 val[2]=eqn[2]; 00509 val[3]=eqn[3]; 00510 ::glClipPlane(e,eqn); 00511 } 00512 } 00513 00514 // face= 00515 // GL_FRONT = 0x0404 00516 // GL_BACK = 0x0405 00517 // GL_FRONT_AND_BACK = 0x0408 00518 GLenum ColorMaterial_bucket[8]; 00519 inline void glColorMaterial(GLenum face,GLenum mode ){ 00520 register GLenum *val= ColorMaterial_bucket + (face-0x0404); 00521 if(*val!=mode){ 00522 *val=mode; 00523 ::glColorMaterial(face,mode); 00524 } 00525 } 00526 GLfloat PointSize_bucket; 00527 inline void glPointSize(GLfloat f) { 00528 if(f!=PointSize_bucket){ 00529 PointSize_bucket=f; 00530 ::glPointSize(f); 00531 } 00532 } 00533 GLfloat LineWidth_bucket; 00534 inline void glLineWidth(GLfloat f){ 00535 if(f!=LineWidth_bucket){ 00536 LineWidth_bucket=f; 00537 ::glPointSize(f); 00538 } 00539 } 00540 GLint LineStipple_FACTOR_bucket; 00541 GLushort LineStipple_PATTERN_bucket; 00542 inline void glLineStipple(GLint factor, GLushort pattern ) 00543 { 00544 if(factor!=LineStipple_FACTOR_bucket || 00545 pattern!=LineStipple_PATTERN_bucket) 00546 { 00547 LineStipple_FACTOR_bucket=factor; 00548 LineStipple_PATTERN_bucket=pattern; 00549 ::glLineStipple(factor,pattern); 00550 } 00551 } 00552 00553 GLclampd DepthRange_NEAR_bucket; 00554 GLclampd DepthRange_FAR_bucket; 00555 inline void glDepthRange(GLclampd nearval,GLclampd farval ) 00556 { 00557 if(DepthRange_NEAR_bucket!=nearval || 00558 DepthRange_FAR_bucket!=farval) 00559 { 00560 DepthRange_NEAR_bucket=nearval; 00561 DepthRange_FAR_bucket=farval; 00562 ::glDepthRange(nearval,farval); 00563 } 00564 } 00565 00566 #ifdef GL_VERSION_1_1 00567 // enable GL_POLYGON_OFFSET_FILL = 0x8037 00568 GLfloat PolygonOffset_bucket[2]; 00569 inline void glPolygonOffset( GLfloat f,GLfloat u) { 00570 if(PolygonOffset_bucket[0]!=f || 00571 PolygonOffset_bucket[1]!=u){ 00572 PolygonOffset_bucket[0]=f; 00573 PolygonOffset_bucket[1]=u; 00574 ::glPolygonOffset(f,u); 00575 } 00576 } 00577 #endif 00578 }; 00579 00580 00581 //#ifdef vtkOpenGLStateCache_Cache 00582 //#undef vtkOpenGLStateCache_Cache 00583 //#endif