1 /*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: TestFBOImplementation.cxx
5
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13
14 =========================================================================*/
15
16 // This code test to make sure vtkOpenGLExtensionManager can properly get
17 // extension functions that can be used. To do this, we convolve an image
18 // with a kernel for a Laplacian filter. This requires the use of functions
19 // defined in OpenGL 1.2, which should be available pretty much everywhere
20 // but still has functions that can be loaded as extensions.
21
22 #include "vtkConeSource.h"
23 #include "vtkPolyDataMapper.h"
24 #include "vtkActor.h"
25 #include "vtkRenderer.h"
26 #include "vtkRenderWindow.h"
27 #include "vtkRenderWindowInteractor.h"
28 #include "vtkCamera.h"
29 #include "vtkCallbackCommand.h"
30 #include "vtkUnsignedCharArray.h"
31 #include "vtkRegressionTestImage.h"
32 #include "vtkOpenGLExtensionManager.h"
33 #include "vtkgl.h"
34 #include <cassert>
35
36 static bool ARB_texture_rectangle_supported=false;
37 static bool depth_texture_supported=false; // OpenGL 1.4 or GL_ARB_depth_texture
38 static bool srgb_texture_supported=false; // OpenGL 2.1 or GL_EXT_texture_sRGB
39 static bool float_texture_supported=false; // GL_ARB_texture_float
40 static bool integer_texture_supported=false; // GL_EXT_texture_integer (GeForce 8)
41
42 // ----------------------------------------------------------------------------
43 // Description:
44 // Return a string matching the OpenGL errorCode.
45 // \post result_exists: result!=0
OpenGLErrorMessage2(GLenum errorCode)46 const char *OpenGLErrorMessage2(GLenum errorCode)
47 {
48 const char *result;
49 switch(errorCode)
50 {
51 case GL_NO_ERROR:
52 result="No error";
53 break;
54 case GL_INVALID_ENUM:
55 result="Invalid enum";
56 break;
57 case GL_INVALID_VALUE:
58 result="Invalid value";
59 break;
60 case GL_INVALID_OPERATION:
61 result="Invalid operation";
62 break;
63 case GL_STACK_OVERFLOW:
64 result="stack overflow";
65 break;
66 case GL_STACK_UNDERFLOW:
67 result="stack underflow";
68 break;
69 case GL_OUT_OF_MEMORY:
70 result="out of memory";
71 break;
72 case vtkgl::INVALID_FRAMEBUFFER_OPERATION_EXT:
73 // GL_EXT_framebuffer_object, 310
74 result="invalid framebuffer operation ext";
75 break;
76 default:
77 result="unknown error";
78 }
79 assert("post: result_exists" && result!=0);
80 return result;
81 }
82
CheckOpenGLError(const char * message)83 void CheckOpenGLError(const char *message)
84 {
85 GLenum errorCode=glGetError();
86 if(errorCode!=GL_NO_ERROR)
87 {
88 cout << "ERROR:"
89 << OpenGLErrorMessage2(errorCode) << message << endl;
90 }
91 }
92
CheckMinValidValue(GLint value,GLint specMinValue)93 void CheckMinValidValue(GLint value,
94 GLint specMinValue)
95 {
96 if(value<specMinValue)
97 {
98 cout<<"This OpenGL implementation is not compliant with the OpenGL";
99 cout<<"specifications."<<endl;
100 }
101 }
102
CheckMinValidFValue(GLfloat value,GLfloat specMinValue)103 void CheckMinValidFValue(GLfloat value,
104 GLfloat specMinValue)
105 {
106 if(value<specMinValue)
107 {
108 cout<<"This OpenGL implementation is not compliant with the OpenGL";
109 cout<<"specifications."<<endl;
110 }
111 }
112
CheckMaxValidValue(GLint value,GLint specMaxValue)113 void CheckMaxValidValue(GLint value,
114 GLint specMaxValue)
115 {
116 if(value>specMaxValue)
117 {
118 cout<<"This OpenGL implementation is not compliant with the OpenGL";
119 cout<<"specifications."<<endl;
120 }
121 }
122
123 void DisplayFrameBufferAttachments();
124 void DisplayFrameBufferAttachment(unsigned int uattachment);
125
126 // ----------------------------------------------------------------------------
127 // Description:
128 // Display the status of the current framebuffer on the standard output.
CheckFrameBufferStatus()129 void CheckFrameBufferStatus()
130 {
131 GLenum status;
132 status = vtkgl::CheckFramebufferStatusEXT(vtkgl::FRAMEBUFFER_EXT);
133 switch(status)
134 {
135 case 0:
136 cout << "call to vtkgl::CheckFramebufferStatusEXT generates an error."
137 << endl;
138 break;
139 case vtkgl::FRAMEBUFFER_COMPLETE_EXT:
140 cout<<"framebuffer is complete"<<endl;
141 break;
142 case vtkgl::FRAMEBUFFER_UNSUPPORTED_EXT:
143 cout << "framebuffer is unsupported" << endl;
144 break;
145 case vtkgl::FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
146 cout << "framebuffer has an attachment error"<<endl;
147 break;
148 case vtkgl::FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
149 cout << "framebuffer has a missing attachment"<<endl;
150 break;
151 case vtkgl::FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
152 cout << "framebuffer has bad dimensions"<<endl;
153 break;
154 case vtkgl::FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
155 cout << "framebuffer has bad formats"<<endl;
156 break;
157 case vtkgl::FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
158 cout << "framebuffer has bad draw buffer"<<endl;
159 break;
160 case vtkgl::FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
161 cout << "framebuffer has bad read buffer"<<endl;
162 break;
163 default:
164 cout << "Unknown framebuffer status=0x" << hex<< status << dec << endl;
165 }
166 // DO NOT REMOVE THE FOLLOWING COMMENTED LINE. FOR DEBUGGING PURPOSE.
167 DisplayFrameBufferAttachments();
168 }
169
170 // ----------------------------------------------------------------------------
171 // Description:
172 // Display all the attachments of the current framebuffer object.
DisplayFrameBufferAttachments()173 void DisplayFrameBufferAttachments()
174 {
175 GLint framebufferBinding;
176 glGetIntegerv(vtkgl::FRAMEBUFFER_BINDING_EXT,&framebufferBinding);
177 CheckOpenGLError("after getting FRAMEBUFFER_BINDING_EXT");
178 if(framebufferBinding==0)
179 {
180 cout<<"Current framebuffer is bind to the system one"<<endl;
181 }
182 else
183 {
184 cout<<"Current framebuffer is bind to framebuffer object "
185 <<framebufferBinding<<endl;
186
187 GLint maxColorAttachments;
188 glGetIntegerv(vtkgl::MAX_COLOR_ATTACHMENTS_EXT,&maxColorAttachments);
189 CheckOpenGLError("after getting MAX_COLOR_ATTACHMENTS_EXT");
190 int i=0;
191 while(i<maxColorAttachments)
192 {
193 cout<<"color attachement "<<i<<":"<<endl;
194 DisplayFrameBufferAttachment(vtkgl::COLOR_ATTACHMENT0_EXT+i);
195 ++i;
196 }
197 cout<<"depth attachement :"<<endl;
198 DisplayFrameBufferAttachment(vtkgl::DEPTH_ATTACHMENT_EXT);
199 cout<<"stencil attachement :"<<endl;
200 DisplayFrameBufferAttachment(vtkgl::STENCIL_ATTACHMENT_EXT);
201 }
202 }
203
204 // ----------------------------------------------------------------------------
205 // Description:
206 // Display a given attachment for the current framebuffer object.
DisplayFrameBufferAttachment(unsigned int uattachment)207 void DisplayFrameBufferAttachment(unsigned int uattachment)
208 {
209 GLenum attachment=static_cast<GLenum>(uattachment);
210
211 GLint params;
212 vtkgl::GetFramebufferAttachmentParameterivEXT(
213 vtkgl::FRAMEBUFFER_EXT,attachment,
214 vtkgl::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT,¶ms);
215
216 CheckOpenGLError("after getting FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT");
217
218 switch(params)
219 {
220 case GL_NONE:
221 cout<<" this attachment is empty"<<endl;
222 break;
223 case GL_TEXTURE:
224 vtkgl::GetFramebufferAttachmentParameterivEXT(
225 vtkgl::FRAMEBUFFER_EXT,attachment,
226 vtkgl::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT,¶ms);
227 CheckOpenGLError("after getting FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT");
228 cout<<" this attachment is a texture with name: "<<params<<endl;
229 vtkgl::GetFramebufferAttachmentParameterivEXT(
230 vtkgl::FRAMEBUFFER_EXT,attachment,
231 vtkgl::FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT,¶ms);
232 CheckOpenGLError("after getting FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT");
233 cout<<" its mipmap level is: "<<params<<endl;
234 #if 0
235 vtkgl::GetFramebufferAttachmentParameterivEXT(
236 vtkgl::FRAMEBUFFER_EXT,attachment,
237 vtkgl::FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT,¶ms);
238 CheckOpenGLError("after getting FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT");
239 if(params==0)
240 {
241 cout<<" this is not a cube map texture."<<endl;
242 }
243 else
244 {
245 cout<<" this is a cube map texture and the image is contained in face "
246 <<params<<endl;
247 }
248 #endif
249 vtkgl::GetFramebufferAttachmentParameterivEXT(
250 vtkgl::FRAMEBUFFER_EXT,attachment,
251 vtkgl::FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT,¶ms);
252
253 CheckOpenGLError("after getting FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT");
254 if(params==0)
255 {
256 cout<<" this is not 3D texture."<<endl;
257 }
258 else
259 {
260 cout<<" this is a 3D texture and the zoffset of the attached image is "
261 <<params<<endl;
262 }
263 break;
264 case vtkgl::RENDERBUFFER_EXT:
265 cout<<" this attachment is a renderbuffer"<<endl;
266 vtkgl::GetFramebufferAttachmentParameterivEXT(
267 vtkgl::FRAMEBUFFER_EXT,attachment,
268 vtkgl::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT,¶ms);
269 CheckOpenGLError("after getting FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT");
270 cout<<" this attachment is a renderbuffer with name: "<<params<<endl;
271
272 vtkgl::BindRenderbufferEXT(vtkgl::RENDERBUFFER_EXT,params);
273 CheckOpenGLError(
274 "after getting binding the current RENDERBUFFER_EXT to params");
275
276 vtkgl::GetRenderbufferParameterivEXT(vtkgl::RENDERBUFFER_EXT,
277 vtkgl::RENDERBUFFER_WIDTH_EXT,
278 ¶ms);
279 CheckOpenGLError("after getting RENDERBUFFER_WIDTH_EXT");
280 cout<<" renderbuffer width="<<params<<endl;
281 vtkgl::GetRenderbufferParameterivEXT(vtkgl::RENDERBUFFER_EXT,
282 vtkgl::RENDERBUFFER_HEIGHT_EXT,
283 ¶ms);
284 CheckOpenGLError("after getting RENDERBUFFER_HEIGHT_EXT");
285 cout<<" renderbuffer height="<<params<<endl;
286 vtkgl::GetRenderbufferParameterivEXT(
287 vtkgl::RENDERBUFFER_EXT,vtkgl::RENDERBUFFER_INTERNAL_FORMAT_EXT,
288 ¶ms);
289 CheckOpenGLError("after getting RENDERBUFFER_INTERNAL_FORMAT_EXT");
290
291 cout<<" renderbuffer internal format=0x"<< hex<<params<<dec<<endl;
292
293 vtkgl::GetRenderbufferParameterivEXT(vtkgl::RENDERBUFFER_EXT,
294 vtkgl::RENDERBUFFER_RED_SIZE_EXT,
295 ¶ms);
296 CheckOpenGLError("after getting RENDERBUFFER_RED_SIZE_EXT");
297 cout<<" renderbuffer actual resolution for the red component="<<params
298 <<endl;
299 vtkgl::GetRenderbufferParameterivEXT(vtkgl::RENDERBUFFER_EXT,
300 vtkgl::RENDERBUFFER_GREEN_SIZE_EXT,
301 ¶ms);
302 CheckOpenGLError("after getting RENDERBUFFER_GREEN_SIZE_EXT");
303 cout<<" renderbuffer actual resolution for the green component="<<params
304 <<endl;
305 vtkgl::GetRenderbufferParameterivEXT(vtkgl::RENDERBUFFER_EXT,
306 vtkgl::RENDERBUFFER_BLUE_SIZE_EXT,
307 ¶ms);
308 CheckOpenGLError("after getting RENDERBUFFER_BLUE_SIZE_EXT");
309 cout<<" renderbuffer actual resolution for the blue component="<<params
310 <<endl;
311 vtkgl::GetRenderbufferParameterivEXT(vtkgl::RENDERBUFFER_EXT,
312 vtkgl::RENDERBUFFER_ALPHA_SIZE_EXT,
313 ¶ms);
314 CheckOpenGLError("after getting RENDERBUFFER_ALPHA_SIZE_EXT");
315 cout<<" renderbuffer actual resolution for the alpha component="<<params
316 <<endl;
317 vtkgl::GetRenderbufferParameterivEXT(vtkgl::RENDERBUFFER_EXT,
318 vtkgl::RENDERBUFFER_DEPTH_SIZE_EXT,
319 ¶ms);
320 CheckOpenGLError("after getting RENDERBUFFER_DEPTH_SIZE_EXT");
321 cout<<" renderbuffer actual resolution for the depth component="<<params
322 <<endl;
323 vtkgl::GetRenderbufferParameterivEXT(
324 vtkgl::RENDERBUFFER_EXT,vtkgl::RENDERBUFFER_STENCIL_SIZE_EXT,¶ms);
325 CheckOpenGLError("after getting RENDERBUFFER_STENCIL_SIZE_EXT");
326 cout<<" renderbuffer actual resolution for the stencil component="
327 <<params<<endl;
328 break;
329 default:
330 cout<<" unexcepted value."<<endl;
331 break;
332 }
333 }
334
335
BooleanToString(GLboolean value)336 const char *BooleanToString(GLboolean value)
337 {
338 if(value)
339 {
340 return "True";
341 }
342 else
343 {
344 return "False";
345 }
346 }
347
TextureCompressionFormat(GLint value)348 const char *TextureCompressionFormat(GLint value)
349 {
350 const char *result;
351 switch(value)
352 {
353 //
354 case vtkgl::COMPRESSED_RGB_S3TC_DXT1_EXT:
355 result="GL_COMPRESSED_RGB_S3TC_DXT1_EXT";
356 break;
357 case vtkgl::COMPRESSED_RGBA_S3TC_DXT1_EXT:
358 result="GL_COMPRESSED_RGBA_S3TC_DXT1_EXT";
359 break;
360 case vtkgl::COMPRESSED_RGBA_S3TC_DXT3_EXT:
361 result="GL_COMPRESSED_RGBA_S3TC_DXT3_EXT";
362 break;
363 case vtkgl::COMPRESSED_RGBA_S3TC_DXT5_EXT:
364 result="GL_COMPRESSED_RGBA_S3TC_DXT5_EXT";
365 break;
366
367 // extension 3DFX_texture_compression_FXT1
368 case vtkgl::COMPRESSED_RGB_FXT1_3DFX:
369 result="GL_COMPRESSED_RGB_FXT1_3DFX";
370 break;
371 case vtkgl::COMPRESSED_RGBA_FXT1_3DFX:
372 result="GL_COMPRESSED_RGBA_FXT1_3DFX";
373 break;
374
375 // extension GL_EXT_texture_sRGB (or OpenGL>=2.1)
376 case vtkgl::COMPRESSED_SRGB_S3TC_DXT1_EXT:
377 result="GL_COMPRESSED_SRGB_S3TC_DXT1_EXT";
378 break;
379 case vtkgl::COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
380 result="GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT";
381 break;
382 case vtkgl::COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
383 result="GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT";
384 break;
385 case vtkgl::COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
386 result="GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT";
387 break;
388 default:
389 result="unknown texture compression format";
390 break;
391 }
392 return result;
393 }
394
MinMagModToString(int minMagMode)395 const char *MinMagModToString(int minMagMode)
396 {
397 const char *result;
398 switch(minMagMode)
399 {
400 case GL_NEAREST:
401 result="GL_NEAREST";
402 break;
403 case GL_LINEAR:
404 result="GL_LINEAR";
405 break;
406 case GL_NEAREST_MIPMAP_NEAREST:
407 result="GL_NEAREST_MIPMAP_NEAREST";
408 break;
409 case GL_NEAREST_MIPMAP_LINEAR:
410 result="GL_NEAREST_MIPMAP_LINEAR";
411 break;
412 case GL_LINEAR_MIPMAP_NEAREST:
413 result="GL_LINEAR_MIPMAP_NEAREST";
414 break;
415 case GL_LINEAR_MIPMAP_LINEAR:
416 result="GL_LINEAR_MIPMAP_LINEAR";
417 break;
418 default:
419 result=0;
420 // assert("check: impossible case." && 0);
421 break;
422 }
423 return result;
424 }
425
InternalTextureFormatToString(int internalFormat)426 const char *InternalTextureFormatToString(int internalFormat)
427 {
428 const char *result;
429 switch(internalFormat)
430 {
431 case 1:
432 result="backwards compatible GL_LUMINANCE";
433 break;
434 case 2:
435 result="backwards compatible GL_LUMINANCE_ALPHA";
436 break;
437 case 3:
438 result="backwards compatible GL_RGB";
439 break;
440 case 4:
441 result="backwards compatible GL_RGBA";
442 break;
443 case GL_ALPHA:
444 result="GL_ALPHA";
445 break;
446 case GL_DEPTH_COMPONENT:
447 result="GL_DEPTH_COMPONENT";
448 break;
449 case GL_LUMINANCE:
450 result="GL_LUMINANCE";
451 break;
452 case GL_LUMINANCE_ALPHA:
453 result="GL_LUMINANCE_ALPHA";
454 break;
455 case GL_INTENSITY:
456 result="GL_INTENSITY";
457 break;
458 case GL_RGB:
459 result="GL_RGB";
460 break;
461 case GL_RGBA:
462 result="GL_RGBA";
463 break;
464 // sized internal format
465 case GL_ALPHA4:
466 result="GL_ALPHA4";
467 break;
468 case GL_ALPHA8:
469 result="GL_ALPHA8";
470 break;
471 case GL_ALPHA12:
472 result="GL_ALPHA12";
473 break;
474 case GL_ALPHA16:
475 result="GL_ALPHA16";
476 break;
477 case vtkgl::DEPTH_COMPONENT16:
478 result="GL_DEPTH_COMPONENT16";
479 break;
480 case vtkgl::DEPTH_COMPONENT24:
481 result="GL_DEPTH_COMPONENT24";
482 break;
483 case vtkgl::DEPTH_COMPONENT32:
484 result="GL_DEPTH_COMPONENT32";
485 break;
486 case GL_LUMINANCE4:
487 result="GL_LUMINANCE4";
488 break;
489 case GL_LUMINANCE8:
490 result="GL_LUMINANCE8";
491 break;
492 case GL_LUMINANCE12:
493 result="GL_LUMINANCE12";
494 break;
495 case GL_LUMINANCE16:
496 result="GL_LUMINANCE16";
497 break;
498 case GL_LUMINANCE4_ALPHA4:
499 result="GL_LUMINANCE4_ALPHA4";
500 break;
501 case GL_LUMINANCE6_ALPHA2:
502 result="GL_LUMINANCE6_ALPHA2";
503 break;
504 case GL_LUMINANCE8_ALPHA8:
505 result="GL_LUMINANCE8_ALPHA8";
506 break;
507 case GL_LUMINANCE12_ALPHA4:
508 result="GL_LUMINANCE12_ALPHA4";
509 break;
510 case GL_LUMINANCE12_ALPHA12:
511 result="GL_LUMINANCE12_ALPHA12";
512 break;
513 case GL_LUMINANCE16_ALPHA16:
514 result="GL_LUMINANCE16_ALPHA16";
515 break;
516 case GL_INTENSITY4:
517 result="GL_INTENSITY4";
518 break;
519 case GL_INTENSITY8:
520 result="GL_INTENSITY8";
521 break;
522 case GL_INTENSITY12:
523 result="GL_INTENSITY12";
524 break;
525 case GL_INTENSITY16:
526 result="GL_INTENSITY16";
527 break;
528 case GL_R3_G3_B2:
529 result="GL_R3_G3_B2";
530 break;
531 case GL_RGB4:
532 result="GL_RGB4";
533 break;
534 case GL_RGB5:
535 result="GL_RGB5";
536 break;
537 case GL_RGB8:
538 result="GL_RGB8";
539 break;
540 case GL_RGB10:
541 result="GL_RGB10";
542 break;
543 case GL_RGB12:
544 result="GL_RGB12";
545 break;
546 case GL_RGB16:
547 result="GL_RGB16";
548 break;
549 case GL_RGBA2:
550 result="GL_RGBA2";
551 break;
552 case GL_RGBA4:
553 result="GL_RGBA4";
554 break;
555 case GL_RGB5_A1:
556 result="GL_RGB5_A1";
557 break;
558 case GL_RGBA8:
559 result="GL_RGBA8";
560 break;
561 case GL_RGB10_A2:
562 result="GL_RGB10_A2";
563 break;
564 case GL_RGBA12:
565 result="GL_RGBA12";
566 break;
567 case GL_RGBA16:
568 result="GL_RGBA16";
569 break;
570 // OpenGL 2.1 (GL_EXT_texture_sRGB)
571 case vtkgl::SRGB8:
572 result="GL_SRGB8";
573 break;
574 case vtkgl::SRGB8_ALPHA8:
575 result="GL_SRGB8_ALPHA8";
576 break;
577 case vtkgl::SLUMINANCE8:
578 result="GL_SLUMINANCE8";
579 break;
580 case vtkgl::SLUMINANCE8_ALPHA8:
581 result="GL_SLUMINANCE8_ALPHA8";
582 break;
583 // Provided by GL_ARB_texture_float
584 case vtkgl::RGBA32F_ARB:
585 result="GL_RGBA32F_ARB";
586 break;
587 case vtkgl::RGB32F_ARB:
588 result="GL_RGB32F_ARB";
589 break;
590 case vtkgl::ALPHA32F_ARB:
591 result="GL_ALPHA32F_ARB";
592 break;
593 case vtkgl::INTENSITY32F_ARB:
594 result="GL_INTENSITY32F_ARB";
595 break;
596 case vtkgl::LUMINANCE32F_ARB:
597 result="GL_LUMINANCE32F_ARB";
598 break;
599 case vtkgl::LUMINANCE_ALPHA32F_ARB:
600 result="GL_LUMINANCE_ALPHA32F_ARB";
601 break;
602 case vtkgl::RGBA16F_ARB:
603 result="GL_RGBA16F_ARB";
604 break;
605 case vtkgl::RGB16F_ARB:
606 result="GL_RGB16F_ARB";
607 break;
608 case vtkgl::ALPHA16F_ARB:
609 result="GL_ALPHA16F_ARB";
610 break;
611 case vtkgl::INTENSITY16F_ARB:
612 result="GL_INTENSITY16F_ARB";
613 break;
614 case vtkgl::LUMINANCE16F_ARB:
615 result="GL_LUMINANCE16F_ARB";
616 break;
617 case vtkgl::LUMINANCE_ALPHA16F_ARB:
618 result="GL_LUMINANCE_ALPHA16F_ARB";
619 break;
620 // Provided by GL_EXT_texture_integer (from GeForce 8)
621 case vtkgl::RGBA32UI_EXT:
622 result="GL_RGBA32UI_EXT";
623 break;
624 case vtkgl::RGB32UI_EXT:
625 result="GL_RGB32UI_EXT";
626 break;
627 case vtkgl::ALPHA32UI_EXT:
628 result="GL_ALPHA32UI_EXT";
629 break;
630 case vtkgl::INTENSITY32UI_EXT:
631 result="GL_INTENSITY32UI_EXT";
632 break;
633 case vtkgl::LUMINANCE32UI_EXT:
634 result="GL_LUMINANCE32UI_EXT";
635 break;
636 case vtkgl::LUMINANCE_ALPHA32UI_EXT:
637 result="GL_LUMINANCE_ALPHA32UI_EXT";
638 break;
639 case vtkgl::RGBA16UI_EXT:
640 result="GL_RGBA16UI_EXT";
641 break;
642 case vtkgl::RGB16UI_EXT:
643 result="GL_RGB16UI_EXT";
644 break;
645 case vtkgl::ALPHA16UI_EXT:
646 result="GL_ALPHA16UI_EXT";
647 break;
648 case vtkgl::INTENSITY16UI_EXT:
649 result="GL_INTENSITY16UI_EXT";
650 break;
651 case vtkgl::LUMINANCE16UI_EXT:
652 result="GL_LUMINANCE16UI_EXT";
653 break;
654 case vtkgl::LUMINANCE_ALPHA16UI_EXT :
655 result="GL_LUMINANCE_ALPHA16UI_EXT ";
656 break;
657 case vtkgl::RGBA8UI_EXT:
658 result="GL_RGBA8UI_EXT";
659 break;
660 case vtkgl::RGB8UI_EXT:
661 result="GL_RGB8UI_EXT";
662 break;
663 case vtkgl::ALPHA8UI_EXT:
664 result="GL_ALPHA8UI_EXT";
665 break;
666 case vtkgl::INTENSITY8UI_EXT:
667 result="GL_INTENSITY8UI_EXT";
668 break;
669 case vtkgl::LUMINANCE8UI_EXT:
670 result="GL_LUMINANCE8UI_EXT";
671 break;
672 case vtkgl::LUMINANCE_ALPHA8UI_EXT:
673 result="GL_LUMINANCE_ALPHA8UI_EXT";
674 break;
675 case vtkgl::RGBA32I_EXT:
676 result="GL_RGBA32I_EXT";
677 break;
678 case vtkgl::RGB32I_EXT:
679 result="GL_RGB32I_EXT";
680 break;
681 case vtkgl::ALPHA32I_EXT:
682 result="GL_ALPHA32I_EXT";
683 break;
684 case vtkgl::INTENSITY32I_EXT:
685 result="GL_INTENSITY32I_EXT";
686 break;
687 case vtkgl::LUMINANCE32I_EXT:
688 result="GL_LUMINANCE32I_EXT";
689 break;
690 case vtkgl::LUMINANCE_ALPHA32I_EXT:
691 result="GL_LUMINANCE_ALPHA32I_EXT";
692 break;
693 case vtkgl::RGBA16I_EXT:
694 result="GL_RGBA16I_EXT";
695 break;
696 case vtkgl::RGB16I_EXT:
697 result="GL_RGB16I_EXT";
698 break;
699 case vtkgl::ALPHA16I_EXT:
700 result="GL_ALPHA16I_EXT";
701 break;
702 case vtkgl::INTENSITY16I_EXT:
703 result="GL_INTENSITY16I_EXT";
704 break;
705 case vtkgl::LUMINANCE16I_EXT:
706 result="GL_LUMINANCE16I_EXT";
707 break;
708 case vtkgl::LUMINANCE_ALPHA16I_EXT:
709 result="GL_LUMINANCE_ALPHA16I_EXT";
710 break;
711 case vtkgl::RGBA8I_EXT:
712 result="GL_RGBA8I_EXT";
713 break;
714 case vtkgl::RGB8I_EXT:
715 result="GL_RGB8I_EXT";
716 break;
717 case vtkgl::ALPHA8I_EXT:
718 result="GL_ALPHA8I_EXT";
719 break;
720 case vtkgl::INTENSITY8I_EXT:
721 result="GL_INTENSITY8I_EXT";
722 break;
723 case vtkgl::LUMINANCE8I_EXT:
724 result="GL_LUMINANCE8I_EXT";
725 break;
726 case vtkgl::LUMINANCE_ALPHA8I_EXT:
727 result="GL_LUMINANCE_ALPHA8I_EXT";
728 break;
729 default:
730 result=0;
731 // assert("check: impossible case." && 0);
732 // cout<<"unknown"<<"(0x"<< hex << ivalue[0] << dec << ")";
733 break;
734 }
735 return result;
736 }
737
WrapModeToString(GLenum wrapMode)738 const char *WrapModeToString(GLenum wrapMode)
739 {
740 const char *result;
741 switch(wrapMode)
742 {
743 case GL_CLAMP:
744 result="GL_CLAMP";
745 break;
746 case GL_REPEAT:
747 result="GL_REPEAT";
748 break;
749 case vtkgl::CLAMP_TO_EDGE:// OpenGL>=1.2 or Gl_SGIS_texture_edge_clamp
750 result="vtkgl::CLAMP_TO_EDGE";
751 break;
752 case vtkgl::CLAMP_TO_BORDER:// OpenGL>=1.3 or GL_ARB_texture_border_clamp
753 result="vtkgl::CLAMP_TO_BORDER";
754 break;
755 case vtkgl::MIRRORED_REPEAT:// OpenGL>=1.4 or GL_ARB_texture_mirrored_repeat
756 result="vtkgl::MIRRORED_REPEAT";
757 break;
758 default:
759 result="";
760 assert("check: impossible case." && 0);
761 break;
762 }
763 return result;
764 }
765
TextureComponentTypeToString(GLint ivalue)766 const char *TextureComponentTypeToString(GLint ivalue)
767 {
768 const char *result;
769 switch(ivalue)
770 {
771 case GL_NONE:
772 // missing component
773 result="missing";
774 break;
775 case vtkgl::UNSIGNED_NORMALIZED_ARB:
776 // default type for OpenGL 1.1, fixed-point component
777 result="";
778 break;
779 case GL_FLOAT:
780 result="f"; // floating-point component, with GL_ARB_texture_float
781 break;
782 case GL_INT:
783 result="i"; // signed unnormalized integer component, with GL_EXT_texture_integer (GeForce8)
784 break;
785 case GL_UNSIGNED_INT:
786 result="ui"; // unsigned unnormalized integer component, with GL_EXT_texture_integer (GeForce8)
787 break;
788 default:
789 result="error: unknown type";
790 break;
791 }
792 return result;
793 }
794
QueryTextureObject(GLenum target)795 void QueryTextureObject(GLenum target)
796 {
797 assert("pre: valid_target" && (target==GL_TEXTURE_1D
798 || target==GL_PROXY_TEXTURE_1D
799 || target==GL_TEXTURE_2D
800 || target==GL_PROXY_TEXTURE_2D
801 || target==vtkgl::TEXTURE_CUBE_MAP_POSITIVE_X
802 || target==vtkgl::TEXTURE_CUBE_MAP_NEGATIVE_X
803 || target==vtkgl::TEXTURE_CUBE_MAP_POSITIVE_Y
804 || target==vtkgl::TEXTURE_CUBE_MAP_NEGATIVE_Y
805 || target==vtkgl::TEXTURE_CUBE_MAP_POSITIVE_Z
806 || target==vtkgl::TEXTURE_CUBE_MAP_NEGATIVE_Z
807 || target==vtkgl::PROXY_TEXTURE_CUBE_MAP
808 || target==vtkgl::TEXTURE_3D
809 || target==vtkgl::PROXY_TEXTURE_3D
810 || target==vtkgl::TEXTURE_RECTANGLE_ARB
811 || target==vtkgl::PROXY_TEXTURE_RECTANGLE_ARB ));
812
813 GLint ivalue[4];
814 GLfloat fvalue[4];
815
816 glGetTexParameterfv(target,GL_TEXTURE_BORDER_COLOR,fvalue);
817 CheckOpenGLError("");
818 cout<<"border color="<<fvalue[0]<<" "<<fvalue[1]<<" "<<fvalue[2]<<" "
819 <<fvalue[3]<<endl;
820 glGetTexParameteriv(target,GL_TEXTURE_MIN_FILTER,ivalue);
821 CheckOpenGLError("");
822 cout<<" min filter=";
823 cout<<MinMagModToString(ivalue[0]);
824 // cout<<"unknown min filter."<<"(0x"<< hex << ivalue[0] << dec << ")";
825 cout<<endl;
826 glGetTexParameteriv(target,GL_TEXTURE_MAG_FILTER,ivalue);
827 CheckOpenGLError("");
828 cout<<" mag filter=";
829 cout<<MinMagModToString(ivalue[0]);
830 // cout<<"unknown mag filter."<<"(0x"<< hex << ivalue[0] << dec << ")";
831 glGetTexParameteriv(target,GL_TEXTURE_WRAP_S,ivalue);
832 CheckOpenGLError("");
833 cout<<" wrap s="<<WrapModeToString(ivalue[0])<<endl;
834 glGetTexParameteriv(target,GL_TEXTURE_WRAP_T,ivalue);
835 CheckOpenGLError("");
836 cout<<" wrap t="<<WrapModeToString(ivalue[0])<<endl;
837 glGetTexParameteriv(target,vtkgl::TEXTURE_WRAP_R,ivalue);
838 CheckOpenGLError("");
839 cout<<" wrap r="<<WrapModeToString(ivalue[0])<<endl;
840 glGetTexParameterfv(target,GL_TEXTURE_PRIORITY,fvalue);
841 CheckOpenGLError("");
842 cout<<" priority="<<fvalue[0]<<endl;
843 glGetTexParameteriv(target,GL_TEXTURE_RESIDENT,ivalue);
844 CheckOpenGLError("");
845 cout<<" resident="<<BooleanToString(ivalue[0])<<endl;
846 glGetTexParameterfv(target,vtkgl::TEXTURE_MIN_LOD,fvalue);
847 CheckOpenGLError("");
848 cout<<" min LOD="<<fvalue[0]<<endl;
849 glGetTexParameterfv(target,vtkgl::TEXTURE_MAX_LOD,fvalue);
850 CheckOpenGLError("");
851 cout<<" max LOD="<<fvalue[0]<<endl;
852 glGetTexParameterfv(target,vtkgl::TEXTURE_BASE_LEVEL,fvalue);
853 CheckOpenGLError("");
854 cout<<" base level="<<fvalue[0]<<endl;
855 glGetTexParameterfv(target,vtkgl::TEXTURE_MAX_LEVEL,fvalue);
856 CheckOpenGLError("");
857 cout<<" max level="<<fvalue[0]<<endl;
858 glGetTexParameterfv(target,vtkgl::TEXTURE_LOD_BIAS,fvalue);
859 CheckOpenGLError("");
860 cout<<" LOD bias="<<fvalue[0]<<endl;
861 glGetTexParameteriv(target,vtkgl::DEPTH_TEXTURE_MODE,ivalue);
862 CheckOpenGLError("");
863 cout<<" depth texture mode=";
864 switch(ivalue[0])
865 {
866 case GL_LUMINANCE:
867 cout<<"GL_LUMINANCE";
868 break;
869 case GL_INTENSITY:
870 cout<<"GL_INTENSITY";
871 break;
872 case GL_ALPHA:
873 cout<<"GL_ALPHA";
874 break;
875 default:
876 cout<<"unknown depth texture mode."<<"(0x"<< hex << ivalue[0] << dec << ")";
877 break;
878 }
879 glGetTexParameteriv(target,vtkgl::TEXTURE_COMPARE_MODE,ivalue);
880 CheckOpenGLError("");
881 cout<<" compare mode=";
882 switch(ivalue[0])
883 {
884 case GL_NONE:
885 cout<<"GL_NONE";
886 break;
887 case vtkgl::COMPARE_R_TO_TEXTURE:
888 cout<<"GL_COMPARE_R_TO_TEXTURE";
889 break;
890 default:
891 cout<<"unknown."<<"(0x"<< hex << ivalue[0] << dec << ")";
892 break;
893 }
894 glGetTexParameteriv(target,vtkgl::TEXTURE_COMPARE_FUNC,ivalue);
895 CheckOpenGLError("");
896 cout<<" compare function=";
897 switch(ivalue[0])
898 {
899 case GL_LEQUAL:
900 cout<<"GL_LEQUAL";
901 break;
902 case GL_GEQUAL:
903 cout<<"GL_GEQUAL";
904 break;
905 case GL_LESS:
906 cout<<"GL_LESS";
907 break;
908 case GL_GREATER:
909 cout<<"GL_GREATER";
910 break;
911 case GL_EQUAL:
912 cout<<"GL_EQUAL";
913 break;
914 case GL_NOTEQUAL:
915 cout<<"GL_NOTEQUAL";
916 break;
917 case GL_ALWAYS:
918 cout<<"GL_ALWAYS";
919 break;
920 case GL_NEVER:
921 cout<<"GL_NEVER";
922 break;
923 default:
924 cout<<"unknown"<<"(0x"<< hex << ivalue[0] << dec << ")";
925 break;
926 }
927 glGetTexParameteriv(target,vtkgl::GENERATE_MIPMAP,ivalue);
928 CheckOpenGLError("");
929 cout<<" generate mipmap="<<BooleanToString(ivalue[0])<<endl;
930 }
931
QueryTextureImage(GLenum target)932 void QueryTextureImage(GLenum target)
933 {
934 assert("pre: valid_target" && (target==GL_TEXTURE_1D
935 || target==GL_PROXY_TEXTURE_1D
936 || target==GL_TEXTURE_2D
937 || target==GL_PROXY_TEXTURE_2D
938 || target==vtkgl::TEXTURE_CUBE_MAP_POSITIVE_X
939 || target==vtkgl::TEXTURE_CUBE_MAP_NEGATIVE_X
940 || target==vtkgl::TEXTURE_CUBE_MAP_POSITIVE_Y
941 || target==vtkgl::TEXTURE_CUBE_MAP_NEGATIVE_Y
942 || target==vtkgl::TEXTURE_CUBE_MAP_POSITIVE_Z
943 || target==vtkgl::TEXTURE_CUBE_MAP_NEGATIVE_Z
944 || target==vtkgl::PROXY_TEXTURE_CUBE_MAP
945 || target==vtkgl::TEXTURE_3D
946 || target==vtkgl::PROXY_TEXTURE_3D
947 || target==vtkgl::TEXTURE_RECTANGLE_ARB
948 || target==vtkgl::PROXY_TEXTURE_RECTANGLE_ARB ));
949
950 GLint ivalue[4];
951 GLint iv;
952
953 glGetTexLevelParameteriv(target,0,GL_TEXTURE_WIDTH,ivalue);
954 CheckOpenGLError("");
955 cout<<" width="<<ivalue[0]<<endl;
956 glGetTexLevelParameteriv(target,0,GL_TEXTURE_HEIGHT,ivalue);
957 CheckOpenGLError("");
958 cout<<" height="<<ivalue[0]<<endl;
959 glGetTexLevelParameteriv(target,0,vtkgl::TEXTURE_DEPTH,ivalue);
960 CheckOpenGLError("");
961 cout<<" depth="<<ivalue[0]<<endl;
962 glGetTexLevelParameteriv(target,0,GL_TEXTURE_BORDER,ivalue);
963 CheckOpenGLError("");
964 cout<<" border="<<ivalue[0]<<endl;
965 glGetTexLevelParameteriv(target,0,GL_TEXTURE_INTERNAL_FORMAT,
966 ivalue);
967 CheckOpenGLError("");
968 cout<<" internal format=";
969 const char *f=InternalTextureFormatToString(ivalue[0]);
970 if(f==0)
971 {
972 cout<<"unknown"<<"(0x"<< hex << ivalue[0] << dec << ")";
973 }
974 else
975 {
976 cout<<f;
977 }
978 cout<<endl;
979 cout<<" real internal format=";
980
981 glGetTexLevelParameteriv(target,0,GL_TEXTURE_RED_SIZE,ivalue);
982 CheckOpenGLError("");
983 if(ivalue[0]>0)
984 {
985 cout<<"R";
986 iv=ivalue[0];
987 if(float_texture_supported)
988 {
989 glGetTexLevelParameteriv(target,0,vtkgl::TEXTURE_RED_TYPE_ARB,ivalue);
990 cout<<TextureComponentTypeToString(ivalue[0]);
991 }
992 cout<<iv;
993 }
994 glGetTexLevelParameteriv(target,0,GL_TEXTURE_GREEN_SIZE,ivalue);
995 CheckOpenGLError("");
996 if(ivalue[0]>0)
997 {
998 cout<<"G";
999 iv=ivalue[0];
1000 if(float_texture_supported)
1001 {
1002 glGetTexLevelParameteriv(target,0,vtkgl::TEXTURE_GREEN_TYPE_ARB,ivalue);
1003 cout<<TextureComponentTypeToString(ivalue[0]);
1004 }
1005 cout<<iv;
1006 }
1007 glGetTexLevelParameteriv(target,0,GL_TEXTURE_BLUE_SIZE,ivalue);
1008 CheckOpenGLError("");
1009 if(ivalue[0]>0)
1010 {
1011 cout<<"B";
1012 iv=ivalue[0];
1013 if(float_texture_supported)
1014 {
1015 glGetTexLevelParameteriv(target,0,vtkgl::TEXTURE_BLUE_TYPE_ARB,ivalue);
1016 cout<<TextureComponentTypeToString(ivalue[0]);
1017 }
1018 cout<<iv;
1019 }
1020 glGetTexLevelParameteriv(target,0,GL_TEXTURE_LUMINANCE_SIZE,ivalue);
1021 CheckOpenGLError("");
1022 if(ivalue[0]>0)
1023 {
1024 cout<<"L";
1025 iv=ivalue[0];
1026 if(float_texture_supported)
1027 {
1028 glGetTexLevelParameteriv(target,0,vtkgl::TEXTURE_LUMINANCE_TYPE_ARB,ivalue);
1029 cout<<TextureComponentTypeToString(ivalue[0]);
1030 }
1031 cout<<iv;
1032 }
1033 glGetTexLevelParameteriv(target,0,GL_TEXTURE_ALPHA_SIZE,ivalue);
1034 CheckOpenGLError("");
1035 if(ivalue[0]>0)
1036 {
1037 cout<<"A";
1038 iv=ivalue[0];
1039 if(float_texture_supported)
1040 {
1041 glGetTexLevelParameteriv(target,0,vtkgl::TEXTURE_ALPHA_TYPE_ARB,ivalue);
1042 cout<<TextureComponentTypeToString(ivalue[0]);
1043 }
1044 cout<<iv;
1045 }
1046 glGetTexLevelParameteriv(target,0,GL_TEXTURE_INTENSITY_SIZE,ivalue);
1047 CheckOpenGLError("");
1048 if(ivalue[0]>0)
1049 {
1050 cout<<"I";
1051 iv=ivalue[0];
1052 if(float_texture_supported)
1053 {
1054 glGetTexLevelParameteriv(target,0,vtkgl::TEXTURE_INTENSITY_TYPE_ARB,ivalue);
1055 cout<<TextureComponentTypeToString(ivalue[0]);
1056 }
1057 cout<<iv;
1058 }
1059 glGetTexLevelParameteriv(target,0,vtkgl::TEXTURE_DEPTH_SIZE,ivalue);
1060 CheckOpenGLError("");
1061 if(ivalue[0]>0)
1062 {
1063 cout<<"D";
1064 iv=ivalue[0];
1065 if(float_texture_supported)
1066 {
1067 glGetTexLevelParameteriv(target,0,vtkgl::TEXTURE_DEPTH_TYPE_ARB,ivalue);
1068 cout<<TextureComponentTypeToString(ivalue[0]);
1069 }
1070 cout<<iv;
1071 }
1072
1073 cout<<endl;
1074 glGetTexLevelParameteriv(target,0,vtkgl::TEXTURE_COMPRESSED,ivalue);
1075 CheckOpenGLError("");
1076 cout<<" compressed="<<BooleanToString(ivalue[0])<<endl;
1077 if(ivalue[0])
1078 {
1079 glGetTexLevelParameteriv(target,0,vtkgl::TEXTURE_COMPRESSED_IMAGE_SIZE,
1080 ivalue);
1081 CheckOpenGLError("");
1082 cout<<" compressed image size="<<ivalue[0]<<" ubytes."<<endl;
1083 }
1084 }
1085
QueryTexture1D()1086 void QueryTexture1D()
1087 {
1088 // void GetBooleanv(value,ivalue) GLboolean
1089
1090 GLboolean bvalue[4];
1091 GLint ivalue[4];
1092
1093 // State per texture unit and binding point
1094 bvalue[0]=glIsEnabled(GL_TEXTURE_1D);
1095 cout<<"2D texturing is enabled:"<< BooleanToString(bvalue[0]) << endl;
1096 glGetIntegerv(GL_TEXTURE_BINDING_1D,ivalue);
1097 cout<<"texture object "<<ivalue[0]<<" is bind to texture 1d."<<endl;
1098
1099 // State per texture object
1100 QueryTextureObject(GL_TEXTURE_1D);
1101
1102 // State per texture image
1103 QueryTextureImage(GL_TEXTURE_1D);
1104
1105 // Texture environment and generation
1106
1107 }
1108
QueryTexture2D()1109 void QueryTexture2D()
1110 {
1111 // void GetBooleanv(value,ivalue) GLboolean
1112
1113 GLboolean bvalue[4];
1114 GLint ivalue[4];
1115
1116 // State per texture unit and binding point
1117 bvalue[0]=glIsEnabled(GL_TEXTURE_2D);
1118 CheckOpenGLError("");
1119 cout<<"2D texturing is enabled:"<< BooleanToString(bvalue[0]) << endl;
1120 glGetIntegerv(GL_TEXTURE_BINDING_2D,ivalue);
1121 CheckOpenGLError("");
1122 cout<<"texture object "<<ivalue[0]<<" is bind to texture 2d."<<endl;
1123
1124 // State per texture object
1125 QueryTextureObject(GL_TEXTURE_2D);
1126 CheckOpenGLError("");
1127 // State per texture image
1128 QueryTextureImage(GL_TEXTURE_2D);
1129 CheckOpenGLError("");
1130 // Texture environment and generation
1131
1132 }
1133
QueryTexture2DRectangle()1134 void QueryTexture2DRectangle()
1135 {
1136 // void GetBooleanv(value,ivalue) GLboolean
1137
1138 GLboolean bvalue[4];
1139 GLint ivalue[4];
1140
1141 // State per texture unit and binding point
1142 bvalue[0]=glIsEnabled(vtkgl::TEXTURE_RECTANGLE_ARB);
1143 cout<<"2D rect texturing is enabled:"<< BooleanToString(bvalue[0]) << endl;
1144 glGetIntegerv(vtkgl::TEXTURE_BINDING_RECTANGLE_ARB,ivalue);
1145 cout<<"texture object "<<ivalue[0]<<" is bind to texture 2d rect."<<endl;
1146
1147 // State per texture object
1148 QueryTextureObject(vtkgl::TEXTURE_RECTANGLE_ARB);
1149
1150 // State per texture image
1151 QueryTextureImage(vtkgl::TEXTURE_RECTANGLE_ARB);
1152
1153 // Texture environment and generation
1154
1155 }
QueryTexture3D()1156 void QueryTexture3D()
1157 {
1158 // void GetBooleanv(value,ivalue) GLboolean
1159
1160 GLboolean bvalue[4];
1161 GLint ivalue[4];
1162
1163 // State per texture unit and binding point
1164 bvalue[0]=glIsEnabled(vtkgl::TEXTURE_3D);
1165 cout<<"3D texturing is enabled:"<< BooleanToString(bvalue[0]) << endl;
1166 glGetIntegerv(vtkgl::TEXTURE_BINDING_3D,ivalue);
1167 cout<<"texture object "<<ivalue[0]<<" is bind to texture 3d."<<endl;
1168
1169 // State per texture object
1170 QueryTextureObject(vtkgl::TEXTURE_3D);
1171
1172 // State per texture image
1173 QueryTextureImage(vtkgl::TEXTURE_3D);
1174
1175 // Texture environment and generation
1176
1177 }
1178
1179 const int textureSizes[2][2]={{64,32}, // spec says min of max is 64.
1180 {63,32}};
1181
1182 const int textureSizedInternalFormats[87]={GL_ALPHA4,
1183 GL_ALPHA8,
1184 GL_ALPHA12,
1185 GL_ALPHA16,
1186 vtkgl::DEPTH_COMPONENT16, //4
1187 vtkgl::DEPTH_COMPONENT24, //5
1188 vtkgl::DEPTH_COMPONENT32, //6
1189 GL_LUMINANCE4,
1190 GL_LUMINANCE8,
1191 GL_LUMINANCE12,
1192 GL_LUMINANCE16,
1193 GL_LUMINANCE4_ALPHA4,
1194 GL_LUMINANCE6_ALPHA2,
1195 GL_LUMINANCE8_ALPHA8,
1196 GL_LUMINANCE12_ALPHA4,
1197 GL_LUMINANCE12_ALPHA12,
1198 GL_LUMINANCE16_ALPHA16,
1199 GL_INTENSITY4,
1200 GL_INTENSITY8,
1201 GL_INTENSITY12,
1202 GL_INTENSITY16,
1203 GL_R3_G3_B2,
1204 GL_RGB4,
1205 GL_RGB5,
1206 GL_RGB8,
1207 GL_RGB10,
1208 GL_RGB12,
1209 GL_RGB16,
1210 GL_RGBA2,
1211 GL_RGBA4,
1212 GL_RGB5_A1,
1213 GL_RGBA8,
1214 GL_RGB10_A2,
1215 GL_RGBA12,
1216 GL_RGBA16,
1217 vtkgl::SRGB8, //35
1218 vtkgl::SRGB8_ALPHA8,
1219 vtkgl::SLUMINANCE8,
1220 vtkgl::SLUMINANCE8_ALPHA8, // idx=38,count=39
1221 vtkgl::RGBA32F_ARB,
1222 vtkgl::RGB32F_ARB,
1223 vtkgl::ALPHA32F_ARB,
1224 vtkgl::INTENSITY32F_ARB,
1225 vtkgl::LUMINANCE32F_ARB,
1226 vtkgl::LUMINANCE_ALPHA32F_ARB,
1227 vtkgl::RGBA16F_ARB,
1228 vtkgl::RGB16F_ARB,
1229 vtkgl::ALPHA16F_ARB,
1230 vtkgl::INTENSITY16F_ARB,
1231 vtkgl::LUMINANCE16F_ARB,
1232 vtkgl::LUMINANCE_ALPHA16F_ARB,// i=50,c=51
1233 vtkgl::ALPHA8I_EXT,
1234 vtkgl::ALPHA8UI_EXT,
1235 vtkgl::ALPHA16I_EXT,
1236 vtkgl::ALPHA16UI_EXT,
1237 vtkgl::ALPHA32I_EXT,
1238 vtkgl::ALPHA32UI_EXT,
1239 vtkgl::LUMINANCE8I_EXT,
1240 vtkgl::LUMINANCE8UI_EXT,
1241 vtkgl::LUMINANCE16I_EXT,
1242 vtkgl::LUMINANCE16UI_EXT,
1243 vtkgl::LUMINANCE32I_EXT,
1244 vtkgl::LUMINANCE32UI_EXT,
1245 vtkgl::LUMINANCE_ALPHA8I_EXT,
1246 vtkgl::LUMINANCE_ALPHA8UI_EXT,
1247 vtkgl::LUMINANCE_ALPHA16I_EXT,
1248 vtkgl::LUMINANCE_ALPHA16UI_EXT,
1249 vtkgl::LUMINANCE_ALPHA32I_EXT,
1250 vtkgl::LUMINANCE_ALPHA32UI_EXT,
1251 vtkgl::INTENSITY8I_EXT,
1252 vtkgl::INTENSITY8UI_EXT,
1253 vtkgl::INTENSITY16I_EXT,
1254 vtkgl::INTENSITY16UI_EXT,
1255 vtkgl::INTENSITY32I_EXT,
1256 vtkgl::INTENSITY32UI_EXT,
1257 vtkgl::RGB8I_EXT,
1258 vtkgl::RGB8UI_EXT,
1259 vtkgl::RGB16I_EXT,
1260 vtkgl::RGB16UI_EXT,
1261 vtkgl::RGB32I_EXT,
1262 vtkgl::RGB32UI_EXT,
1263 vtkgl::RGBA8I_EXT,
1264 vtkgl::RGBA8UI_EXT,
1265 vtkgl::RGBA16I_EXT,
1266 vtkgl::RGBA16UI_EXT,
1267 vtkgl::RGBA32I_EXT,
1268 vtkgl::RGBA32UI_EXT}; // i=86, c=87
1269
1270 const int NumberOftextureSizedInternalFormats=87;
1271
1272 const GLenum textureTarget[2]={GL_TEXTURE_2D,
1273 vtkgl::TEXTURE_RECTANGLE_ARB};
1274
1275 const int textureProxyTarget[2]={GL_PROXY_TEXTURE_2D,
1276 vtkgl::PROXY_TEXTURE_RECTANGLE_ARB};
1277
1278 const int textureMinMag[2]={GL_NEAREST,GL_LINEAR};
1279
1280 // OpenGL 1.2: vtkgl::CLAMP_TO_EDGE
1281 // OpenGL 1.3: vtkgl::CLAMP_TO_BORDER
1282 // OpenGL 1.4: vtkgl::MIRRORED_REPEAT
1283
1284 const int textureWrap[5]={GL_CLAMP,
1285 GL_REPEAT,
1286 vtkgl::CLAMP_TO_EDGE,
1287 vtkgl::CLAMP_TO_BORDER,
1288 vtkgl::MIRRORED_REPEAT};
1289
1290 // GL_ARB_color_buffer_float
1291 // GL_ARB_half_float_pixel
1292 // GL_ARB_texture_float <=====
1293 // GL_ATI_pixel_format_float
1294 // GL_ATI_texture_float
1295 // GL_NV_float_buffer
1296 // GL_NV_half_float
1297 // GL_EXT_packed_float
1298 // GL_NV_depth_buffer_float
1299
1300
FromTextureSizedInternalFormatsToBaseInternalFormat(int f)1301 int FromTextureSizedInternalFormatsToBaseInternalFormat(int f)
1302 {
1303 int result;
1304
1305 switch(f)
1306 {
1307 case GL_ALPHA4:
1308 case GL_ALPHA8:
1309 case GL_ALPHA12:
1310 case GL_ALPHA16:
1311 case vtkgl::ALPHA32F_ARB:
1312 case vtkgl::ALPHA16F_ARB:
1313 case vtkgl::ALPHA8I_EXT:
1314 case vtkgl::ALPHA8UI_EXT:
1315 case vtkgl::ALPHA16I_EXT:
1316 case vtkgl::ALPHA16UI_EXT:
1317 case vtkgl::ALPHA32I_EXT:
1318 case vtkgl::ALPHA32UI_EXT:
1319 result=GL_ALPHA;
1320 break;
1321 case vtkgl::DEPTH_COMPONENT16:
1322 case vtkgl::DEPTH_COMPONENT24:
1323 case vtkgl::DEPTH_COMPONENT32:
1324 result=GL_DEPTH_COMPONENT;
1325 break;
1326 case GL_LUMINANCE4:
1327 case GL_LUMINANCE8:
1328 case GL_LUMINANCE12:
1329 case GL_LUMINANCE16:
1330 case vtkgl::SLUMINANCE8:
1331 case vtkgl::LUMINANCE32F_ARB:
1332 case vtkgl::LUMINANCE16F_ARB:
1333 case vtkgl::LUMINANCE8I_EXT:
1334 case vtkgl::LUMINANCE8UI_EXT:
1335 case vtkgl::LUMINANCE16I_EXT:
1336 case vtkgl::LUMINANCE16UI_EXT:
1337 case vtkgl::LUMINANCE32I_EXT:
1338 case vtkgl::LUMINANCE32UI_EXT:
1339 result=GL_LUMINANCE;
1340 break;
1341 case GL_LUMINANCE4_ALPHA4:
1342 case GL_LUMINANCE6_ALPHA2:
1343 case GL_LUMINANCE8_ALPHA8:
1344 case GL_LUMINANCE12_ALPHA4:
1345 case GL_LUMINANCE12_ALPHA12:
1346 case GL_LUMINANCE16_ALPHA16:
1347 case vtkgl::SLUMINANCE8_ALPHA8:
1348 case vtkgl::LUMINANCE_ALPHA32F_ARB:
1349 case vtkgl::LUMINANCE_ALPHA16F_ARB:
1350 case vtkgl::LUMINANCE_ALPHA8I_EXT:
1351 case vtkgl::LUMINANCE_ALPHA8UI_EXT:
1352 case vtkgl::LUMINANCE_ALPHA16I_EXT:
1353 case vtkgl::LUMINANCE_ALPHA16UI_EXT:
1354 case vtkgl::LUMINANCE_ALPHA32I_EXT:
1355 case vtkgl::LUMINANCE_ALPHA32UI_EXT:
1356 result=GL_LUMINANCE_ALPHA;
1357 break;
1358 case GL_INTENSITY4:
1359 case GL_INTENSITY8:
1360 case GL_INTENSITY12:
1361 case GL_INTENSITY16:
1362 case vtkgl::INTENSITY32F_ARB:
1363 case vtkgl::INTENSITY16F_ARB:
1364 case vtkgl::INTENSITY8I_EXT:
1365 case vtkgl::INTENSITY8UI_EXT:
1366 case vtkgl::INTENSITY16I_EXT:
1367 case vtkgl::INTENSITY16UI_EXT:
1368 case vtkgl::INTENSITY32I_EXT:
1369 case vtkgl::INTENSITY32UI_EXT:
1370 result=GL_INTENSITY;
1371 break;
1372 case GL_R3_G3_B2:
1373 case GL_RGB4:
1374 case GL_RGB5:
1375 case GL_RGB8:
1376 case GL_RGB10:
1377 case GL_RGB12:
1378 case GL_RGB16:
1379 case vtkgl::SRGB8:
1380 case vtkgl::RGB32F_ARB:
1381 case vtkgl::RGB16F_ARB:
1382 case vtkgl::RGB8I_EXT:
1383 case vtkgl::RGB8UI_EXT:
1384 case vtkgl::RGB16I_EXT:
1385 case vtkgl::RGB16UI_EXT:
1386 case vtkgl::RGB32I_EXT:
1387 case vtkgl::RGB32UI_EXT:
1388 result=GL_RGB;
1389 break;
1390 case GL_RGBA2:
1391 case GL_RGBA4:
1392 case GL_RGB5_A1:
1393 case GL_RGBA8:
1394 case GL_RGB10_A2:
1395 case GL_RGBA12:
1396 case GL_RGBA16:
1397 case vtkgl::SRGB8_ALPHA8:
1398 case vtkgl::RGBA32F_ARB:
1399 case vtkgl::RGBA16F_ARB:
1400 case vtkgl::RGBA8I_EXT:
1401 case vtkgl::RGBA8UI_EXT:
1402 case vtkgl::RGBA16I_EXT:
1403 case vtkgl::RGBA16UI_EXT:
1404 case vtkgl::RGBA32I_EXT:
1405 case vtkgl::RGBA32UI_EXT:
1406 result=GL_RGBA;
1407 break;
1408 default:
1409 result=0;
1410 assert("check: impossible case." && 0);
1411 break;
1412 }
1413 return result;
1414 }
1415
TextureSizedInternalFormatIsInteger(int f)1416 bool TextureSizedInternalFormatIsInteger(int f)
1417 {
1418 bool result;
1419
1420 switch(f)
1421 {
1422 case vtkgl::ALPHA8I_EXT:
1423 case vtkgl::ALPHA8UI_EXT:
1424 case vtkgl::ALPHA16I_EXT:
1425 case vtkgl::ALPHA16UI_EXT:
1426 case vtkgl::ALPHA32I_EXT:
1427 case vtkgl::ALPHA32UI_EXT:
1428 case vtkgl::LUMINANCE8I_EXT:
1429 case vtkgl::LUMINANCE8UI_EXT:
1430 case vtkgl::LUMINANCE16I_EXT:
1431 case vtkgl::LUMINANCE16UI_EXT:
1432 case vtkgl::LUMINANCE32I_EXT:
1433 case vtkgl::LUMINANCE32UI_EXT:
1434 case vtkgl::LUMINANCE_ALPHA8I_EXT:
1435 case vtkgl::LUMINANCE_ALPHA8UI_EXT:
1436 case vtkgl::LUMINANCE_ALPHA16I_EXT:
1437 case vtkgl::LUMINANCE_ALPHA16UI_EXT:
1438 case vtkgl::LUMINANCE_ALPHA32I_EXT:
1439 case vtkgl::LUMINANCE_ALPHA32UI_EXT:
1440 case vtkgl::INTENSITY8I_EXT:
1441 case vtkgl::INTENSITY8UI_EXT:
1442 case vtkgl::INTENSITY16I_EXT:
1443 case vtkgl::INTENSITY16UI_EXT:
1444 case vtkgl::INTENSITY32I_EXT:
1445 case vtkgl::INTENSITY32UI_EXT:
1446 case vtkgl::RGB8I_EXT:
1447 case vtkgl::RGB8UI_EXT:
1448 case vtkgl::RGB16I_EXT:
1449 case vtkgl::RGB16UI_EXT:
1450 case vtkgl::RGB32I_EXT:
1451 case vtkgl::RGB32UI_EXT:
1452 case vtkgl::RGBA8I_EXT:
1453 case vtkgl::RGBA8UI_EXT:
1454 case vtkgl::RGBA16I_EXT:
1455 case vtkgl::RGBA16UI_EXT:
1456 case vtkgl::RGBA32I_EXT:
1457 case vtkgl::RGBA32UI_EXT:
1458 result=true;
1459 break;
1460 default:
1461 result=false;
1462 }
1463
1464 return result;
1465 }
1466
FromBaseInternalFormatToFormat(int f,bool isInteger)1467 int FromBaseInternalFormatToFormat(int f,
1468 bool isInteger)
1469 {
1470 int result=f;
1471 if(f==GL_INTENSITY)
1472 {
1473 result=GL_RED;
1474 }
1475 if(isInteger)
1476 {
1477 switch(result)
1478 {
1479 case GL_RED:
1480 result=vtkgl::RED_INTEGER_EXT;
1481 break;
1482 case GL_ALPHA:
1483 result=vtkgl::ALPHA_INTEGER_EXT;
1484 break;
1485 case GL_RGB:
1486 result=vtkgl::RGB_INTEGER_EXT;
1487 break;
1488 case GL_RGBA:
1489 result=vtkgl::RGBA_INTEGER_EXT;
1490 break;
1491 case GL_LUMINANCE:
1492 result=vtkgl::LUMINANCE_INTEGER_EXT;
1493 break;
1494 case GL_LUMINANCE_ALPHA:
1495 result=vtkgl::LUMINANCE_ALPHA_INTEGER_EXT;
1496 break;
1497 default:
1498 assert("check: impossible case." && 0);
1499 break;
1500 }
1501 }
1502 return result;
1503 }
1504
TargetToString(int target)1505 const char *TargetToString(int target)
1506 {
1507 const char *result;
1508 switch(target)
1509 {
1510 case GL_TEXTURE_2D:
1511 result="GL_TEXTURE_2D";
1512 break;
1513 case vtkgl::TEXTURE_RECTANGLE_ARB:
1514 result="vtkgl::TEXTURE_RECTANGLE_ARB";
1515 break;
1516 case vtkgl::TEXTURE_3D:
1517 result="vtkgl::TEXTURE_3D";
1518 break;
1519 default:
1520 result="";
1521 assert("check: impossible case." && 0);
1522 break;
1523 }
1524 return result;
1525 }
1526
WrapModeToString(int wrapMode)1527 const char *WrapModeToString(int wrapMode)
1528 {
1529 const char *result;
1530 switch(wrapMode)
1531 {
1532 case GL_CLAMP:
1533 result="GL_CLAMP";
1534 break;
1535 case GL_REPEAT:
1536 result="GL_REPEAT";
1537 break;
1538 case vtkgl::CLAMP_TO_EDGE:
1539 result="vtkgl::CLAMP_TO_EDGE";
1540 break;
1541 case vtkgl::CLAMP_TO_BORDER:
1542 result="vtkgl::CLAMP_TO_BORDER";
1543 break;
1544 case vtkgl::MIRRORED_REPEAT:
1545 result="vtkgl::MIRRORED_REPEAT";
1546 break;
1547 default:
1548 result="";
1549 assert("check: impossible case." && 0);
1550 break;
1551 }
1552 return result;
1553 }
1554
TestTextureFormatsAndFBO()1555 void TestTextureFormatsAndFBO()
1556 {
1557 // target TEXTURE_2D ARB_TEXTURE_RECTANGLE
1558 // 1 component luminance, depth, intensity
1559 // 2 components luminance+alpha
1560 // 3 components RGB
1561 // 4 components RGBA
1562 // wrapping mode: edge edge_clamp
1563 // linear/nearest.
1564 // size POT or NPOT
1565
1566 bool supportedtextureSizedInternalFormats[NumberOftextureSizedInternalFormats];
1567
1568 int i=0;
1569 while(i<NumberOftextureSizedInternalFormats)
1570 {
1571 supportedtextureSizedInternalFormats[i]=true;
1572 ++i;
1573 }
1574 if(!depth_texture_supported)
1575 {
1576 i=4;
1577 while(i<=6)
1578 {
1579 supportedtextureSizedInternalFormats[i]=false;
1580 ++i;
1581 }
1582 }
1583 if(!srgb_texture_supported)
1584 {
1585 i=35;
1586 while(i<=38)
1587 {
1588 supportedtextureSizedInternalFormats[i]=false;
1589 ++i;
1590 }
1591 }
1592 if(!float_texture_supported)
1593 {
1594 i=39;
1595 while(i<=50)
1596 {
1597 supportedtextureSizedInternalFormats[i]=false;
1598 ++i;
1599 }
1600 }
1601 if(!integer_texture_supported)
1602 {
1603 i=51;
1604 while(i<=86)
1605 {
1606 supportedtextureSizedInternalFormats[i]=false;
1607 ++i;
1608 }
1609 }
1610
1611 GLuint textureObject;
1612
1613 int numberOfTarget=1;
1614 if(ARB_texture_rectangle_supported)
1615 {
1616 numberOfTarget=2;
1617 }
1618 int targetIdx=0;
1619 while(targetIdx<numberOfTarget)
1620 {
1621 GLenum target=textureTarget[targetIdx];
1622 int wrapIdx=0;
1623 while(wrapIdx<5)
1624 {
1625 int magIdx=0;
1626 while(magIdx<2)
1627 {
1628 int textureSizeIdx=0;
1629 while(textureSizeIdx<2)
1630 {
1631
1632 int internalFormatIndex=0;
1633 while(internalFormatIndex<NumberOftextureSizedInternalFormats)
1634 {
1635 if(supportedtextureSizedInternalFormats[internalFormatIndex])
1636 {
1637 cout<<"----------------------------------------------------"<<endl;
1638 cout<<"Test "<<TargetToString(target)<<" "<<WrapModeToString(textureWrap[wrapIdx])<<" "<<MinMagModToString(textureMinMag[magIdx]);
1639
1640 if(textureSizeIdx==0)
1641 {
1642 cout<<" POT";
1643 }
1644 else
1645 {
1646 cout<<" NPOT";
1647 }
1648 int internalFormat=textureSizedInternalFormats[internalFormatIndex];
1649 cout<<" "<<InternalTextureFormatToString(internalFormat)<<endl;
1650
1651
1652 glGenTextures(1,&textureObject);
1653 CheckOpenGLError("after glGenTextures");
1654 glBindTexture(target,textureObject);
1655 CheckOpenGLError("after glBindTexture");
1656 glTexParameteri(target, GL_TEXTURE_WRAP_S, textureWrap[wrapIdx]);
1657
1658 GLenum errorCode=glGetError();
1659 if((textureWrap[wrapIdx]==GL_REPEAT || textureWrap[wrapIdx]==static_cast<GLint>(vtkgl::MIRRORED_REPEAT)) && errorCode==GL_INVALID_ENUM && target==vtkgl::TEXTURE_RECTANGLE_ARB)
1660 {
1661 // expected error. see extension spec.
1662 }
1663 else
1664 {
1665 if(errorCode!=GL_NO_ERROR)
1666 {
1667 cout << "ERROR:"
1668 << OpenGLErrorMessage2(errorCode) << "after GL_TEXTURE_WRAP_S" <<endl;
1669 }
1670 }
1671 glTexParameteri(target, GL_TEXTURE_WRAP_T, textureWrap[wrapIdx]);
1672
1673 errorCode=glGetError();
1674 if((textureWrap[wrapIdx]==GL_REPEAT || textureWrap[wrapIdx]==static_cast<GLint>(vtkgl::MIRRORED_REPEAT)) && errorCode==GL_INVALID_ENUM && target==vtkgl::TEXTURE_RECTANGLE_ARB)
1675 {
1676 // expected error. see extension spec.
1677 }
1678 else
1679 {
1680 if(errorCode!=GL_NO_ERROR)
1681 {
1682 cout << "ERROR:"
1683 << OpenGLErrorMessage2(errorCode) << "after GL_TEXTURE_WRAP_T" <<endl;
1684 }
1685 }
1686
1687 glTexParameteri(target, GL_TEXTURE_MIN_FILTER, textureMinMag[magIdx]);
1688 CheckOpenGLError("after GL_TEXTURE_MIN_FILTER");
1689 glTexParameteri(target, GL_TEXTURE_MAG_FILTER, textureMinMag[magIdx]);
1690 CheckOpenGLError("after GL_TEXTURE_MAG_FILTER");
1691
1692
1693 int format= FromBaseInternalFormatToFormat(
1694 FromTextureSizedInternalFormatsToBaseInternalFormat(internalFormat),
1695 TextureSizedInternalFormatIsInteger(internalFormat));
1696 int type=GL_UNSIGNED_BYTE;
1697
1698 glTexImage2D(textureProxyTarget[targetIdx],0,internalFormat,
1699 textureSizes[textureSizeIdx][0],
1700 textureSizes[textureSizeIdx][1],
1701 0, format, type, NULL );
1702 CheckOpenGLError("after glTexImage2D on proxy");
1703
1704 GLint width;
1705 glGetTexLevelParameteriv(textureProxyTarget[targetIdx],0,
1706 GL_TEXTURE_WIDTH,&width);
1707
1708 CheckOpenGLError("after getting proxy result");
1709 if(width!=0)
1710 {
1711 glTexImage2D(target,0,internalFormat,
1712 textureSizes[textureSizeIdx][0],
1713 textureSizes[textureSizeIdx][1],
1714 0, format, type, NULL );
1715 CheckOpenGLError("after glTexImage2D on real target");
1716 if(target==GL_TEXTURE_2D)
1717 {
1718 QueryTexture2D();
1719 }
1720 else
1721 {
1722 // vtkgl::TEXTURE_RECTANGLE_ARB
1723 QueryTexture2DRectangle();
1724 }
1725 CheckOpenGLError("after querying the current texture");
1726
1727 if(vtkgl::GenFramebuffersEXT!=0) // FBO supported
1728 {
1729 // Try an FBO with just one color attachment:
1730 GLint savedFrameBuffer;
1731 glGetIntegerv(vtkgl::FRAMEBUFFER_BINDING_EXT,&savedFrameBuffer);
1732 GLuint fbo;
1733 vtkgl::GenFramebuffersEXT(1,&fbo);
1734 CheckOpenGLError("");
1735 vtkgl::BindFramebufferEXT(vtkgl::FRAMEBUFFER_EXT,fbo);
1736 CheckOpenGLError("");
1737 vtkgl::FramebufferTexture2DEXT(vtkgl::FRAMEBUFFER_EXT,
1738 vtkgl::COLOR_ATTACHMENT0_EXT,
1739 target, textureObject, 0);
1740 CheckOpenGLError("");
1741 CheckFrameBufferStatus();
1742
1743 // Detach the color buffer
1744 vtkgl::FramebufferTexture2DEXT(vtkgl::FRAMEBUFFER_EXT,
1745 vtkgl::COLOR_ATTACHMENT0_EXT,
1746 target, 0, 0);
1747 CheckOpenGLError("");
1748 // Restore default frame buffer.
1749 vtkgl::BindFramebufferEXT(vtkgl::FRAMEBUFFER_EXT,
1750 savedFrameBuffer);
1751 CheckOpenGLError("");
1752 vtkgl::DeleteFramebuffersEXT(1,&fbo);
1753 CheckOpenGLError("");
1754 }
1755 }
1756 else
1757 {
1758 cout<<"Texture format not supported."<<endl;
1759 }
1760 glDeleteTextures(1,&textureObject);
1761 CheckOpenGLError("");
1762 }
1763 ++internalFormatIndex;
1764 }
1765 ++textureSizeIdx;
1766 }
1767 ++magIdx;
1768 }
1769 ++wrapIdx;
1770 }
1771 ++targetIdx;
1772 }
1773 }
1774
TestVisual(int multiSample,int alphaBitPlanes,int width,int height)1775 void TestVisual(int multiSample,
1776 int alphaBitPlanes,
1777 int width,
1778 int height)
1779 {
1780 cout<<"Context: multisample="<<BooleanToString(multiSample)<<" alphaBitPlanes="<<BooleanToString(alphaBitPlanes)<<" "<<width<<"x"<<height<<endl;
1781 vtkRenderWindow *renwin = vtkRenderWindow::New();
1782 if(multiSample)
1783 {
1784 renwin->SetMultiSamples(8);
1785 }
1786 else
1787 {
1788 renwin->SetMultiSamples(0);
1789 }
1790 renwin->SetAlphaBitPlanes(alphaBitPlanes);
1791 renwin->SetSize(width,height);
1792 // vtkRenderer *renderer = vtkRenderer::New();
1793 // renwin->AddRenderer(renderer);
1794
1795 // vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
1796 // renwin->SetInteractor(iren);
1797
1798 vtkOpenGLExtensionManager *extensions = vtkOpenGLExtensionManager::New();
1799 extensions->SetRenderWindow(renwin);
1800 renwin->Render();
1801
1802 cout<<"OpenGL 1.1 Implementation dependent values : "<<endl;
1803
1804 GLint value[2];
1805 GLboolean bvalue[1];
1806 GLfloat fvalue[2];
1807
1808 const GLubyte *svalue=glGetString(GL_EXTENSIONS);
1809 cout<<"GL_EXTENSIONS="<<svalue<<" . Supported extensions."<<endl;
1810
1811 svalue=glGetString(GL_RENDERER);
1812 cout<<"GL_RENDERER="<<svalue<<" . Renderer string."<<endl;
1813
1814 svalue=glGetString(GL_VENDOR);
1815 cout<<"GL_VENDOR="<<svalue<<" . Vendor string."<<endl;
1816
1817 svalue=glGetString(GL_VERSION);
1818 cout<<"GL_VERSION="<<svalue<<" . OpenGL version supported."<<endl;
1819
1820 glGetIntegerv(GL_MAX_LIGHTS,value);
1821 cout<<"GL_MAX_LIGHTS="<<value[0]<<" . Maximum number of lights. Min is 8."<<endl;
1822 CheckMinValidValue(value[0],8);
1823
1824 glGetIntegerv(GL_MAX_CLIP_PLANES,value);
1825 cout<<"GL_MAX_CLIP_PLANES="<<value[0]<<" . Maximum number of user clipping planes. Min is 6."<<endl;
1826 CheckMinValidValue(value[0],6);
1827
1828 glGetIntegerv(GL_MAX_MODELVIEW_STACK_DEPTH,value);
1829 cout<<"GL_MAX_MODELVIEW_STACK_DEPTH="<<value[0]<<" . Maximum model-view stack depth. Min is 32."<<endl;
1830 CheckMinValidValue(value[0],32);
1831
1832 glGetIntegerv(GL_MAX_PROJECTION_STACK_DEPTH,value);
1833 cout<<"GL_MAX_PROJECTION_STACK_DEPTH="<<value[0]<<" . Maximum projection matrix stack depth. Min is 2."<<endl;
1834 CheckMinValidValue(value[0],2);
1835
1836 glGetIntegerv(GL_MAX_TEXTURE_STACK_DEPTH,value);
1837 cout<<"GL_MAX_TEXTURE_STACK_DEPTH="<<value[0]<<" . Maximum number depth of texture matrix stack. Min is 2."<<endl;
1838 CheckMinValidValue(value[0],2);
1839
1840 glGetIntegerv(GL_SUBPIXEL_BITS,value);
1841 cout<<"GL_SUBPIXEL_BITS="<<value[0]<<" . Number of bits of subpixel precision in screen x_w and y_w. Min is 4."<<endl;
1842 CheckMinValidValue(value[0],4);
1843
1844 glGetIntegerv(GL_MAX_TEXTURE_SIZE,value);
1845 cout<<"GL_MAX_TEXTURE_SIZE="<<value[0]<<" . Maximum texture image dimension. Min is 64."<<endl;
1846 CheckMinValidValue(value[0],64);
1847 cout<<"It means that the maximum 2D texture size is "<<value[0]<<"x"<<value[0]<<endl;
1848 cout<<"It also means that "<<(value[0]+1)<<"x1 is too large"<<endl;
1849
1850 glGetIntegerv(GL_MAX_PIXEL_MAP_TABLE,value);
1851 cout<<"GL_MAX_PIXEL_MAP_TABLE="<<value[0]<<" . Maximum size of a PixelMap translation table. Min is 32."<<endl;
1852 CheckMinValidValue(value[0],32);
1853
1854 glGetIntegerv(GL_MAX_NAME_STACK_DEPTH,value);
1855 cout<<"GL_MAX_NAME_STACK_DEPTH="<<value[0]<<" . Maximum selection name stack depth. Min is 64."<<endl;
1856 CheckMinValidValue(value[0],64);
1857
1858 glGetIntegerv(GL_MAX_LIST_NESTING,value);
1859 cout<<"GL_MAX_LIST_NESTING="<<value[0]<<" . Maximum display list call nesting. Min is 64."<<endl;
1860 CheckMinValidValue(value[0],64);
1861
1862 glGetIntegerv(GL_MAX_EVAL_ORDER,value);
1863 cout<<"GL_MAX_EVAL_ORDER="<<value[0]<<" . Maximum evaluator polynomial order. Min is 8."<<endl;
1864 CheckMinValidValue(value[0],8);
1865
1866 glGetIntegerv(GL_MAX_VIEWPORT_DIMS,value);
1867 cout<<"GL_MAX_VIEWPORT_DIMS="<<value[0]<<"x"<<value[1]<<". Maximum viewport dimensions"<<endl;
1868
1869 glGetIntegerv(GL_MAX_ATTRIB_STACK_DEPTH,value);
1870 cout<<"GL_MAX_ATTRIB_STACK_DEPTH="<<value[0]<<". Maximum depth of the server attribute stack. Min is 16."<<endl;
1871 CheckMinValidValue(value[0],16);
1872
1873 glGetIntegerv(GL_MAX_CLIENT_ATTRIB_STACK_DEPTH,value);
1874 cout<<"GL_MAX_CLIENT_ATTRIB_STACK_DEPTH="<<value[0]<<". Maximum depth of the client attribute stack. Min is 16."<<endl;
1875 CheckMinValidValue(value[0],16);
1876
1877 glGetIntegerv(GL_AUX_BUFFERS,value);
1878 cout<<"GL_AUX_BUFFERS="<<value[0]<<". Number of auxiliary buffers. Min is 0."<<endl;
1879 CheckMinValidValue(value[0],0);
1880
1881 glGetBooleanv(GL_RGBA_MODE,bvalue);
1882 cout<<"GL_RGBA_MODE="<<BooleanToString(bvalue[0])<<". True if color buffers store rgba."<<endl;
1883 glGetBooleanv(GL_INDEX_MODE,bvalue);
1884 cout<<"GL_INDEX_MODE="<<BooleanToString(bvalue[0])<<". True if color buffers store indexes."<<endl;
1885
1886 glGetBooleanv(GL_DOUBLEBUFFER,bvalue);
1887 cout<<"GL_DOUBLEBUFFER="<<BooleanToString(bvalue[0])<<". True if front and back buffers exist."<<endl;
1888
1889 glGetBooleanv(GL_STEREO,bvalue);
1890 cout<<"GL_STEREO="<<BooleanToString(bvalue[0])<<". True if left and right buffers exist."<<endl;
1891 glGetFloatv(GL_POINT_SIZE_RANGE,fvalue);
1892 cout<<"GL_POINT_SIZE_RANGE="<<fvalue[0]<<","<<fvalue[1]<<". Range (lo to hi) of antialiased point sizes. Min is (1,1)"<<endl;
1893 // check range.
1894
1895 glGetFloatv(GL_POINT_SIZE_GRANULARITY,fvalue);
1896 cout<<"GL_POINT_SIZE_GRANULARITY="<<fvalue[0]<<". Antialiased point size granularity."<<endl;
1897
1898 glGetFloatv(GL_LINE_WIDTH_RANGE,fvalue);
1899 cout<<"GL_LINE_WIDTH_RANGE="<<fvalue[0]<<","<<fvalue[1]<<". Range (lo to hi) of antialiased line widths. Min is (1,1)"<<endl;
1900 // check range.
1901
1902 glGetFloatv(GL_LINE_WIDTH_GRANULARITY,fvalue);
1903 cout<<"GL_LINE_WIDTH_GRANULARITY="<<fvalue[0]<<". Antialiased line width granularity."<<endl;
1904
1905 glGetIntegerv(GL_RED_BITS,value);
1906 cout<<"GL_RED_BITS="<<value[0]<<". Number of bits per red component in color buffers."<<endl;
1907 glGetIntegerv(GL_GREEN_BITS,value);
1908 cout<<"GL_GREEN_BITS="<<value[0]<<". Number of bits per green component in color buffers."<<endl;
1909 glGetIntegerv(GL_BLUE_BITS,value);
1910 cout<<"GL_BLUE_BITS="<<value[0]<<". Number of bits per blue component in color buffers."<<endl;
1911 glGetIntegerv(GL_ALPHA_BITS,value);
1912 cout<<"GL_ALPHA_BITS="<<value[0]<<". Number of bits per alpha component in color buffers."<<endl;
1913 glGetIntegerv(GL_INDEX_BITS,value);
1914 cout<<"GL_INDEX_BITS="<<value[0]<<". Number of bits per index component in color buffers."<<endl;
1915 glGetIntegerv(GL_DEPTH_BITS,value);
1916 cout<<"GL_DEPTH_BITS="<<value[0]<<". Number of depth buffer planes."<<endl;
1917
1918 glGetIntegerv(GL_STENCIL_BITS,value);
1919 cout<<"GL_STENCIL_BITS="<<value[0]<<". Number of stencil planes."<<endl;
1920
1921 glGetIntegerv(GL_ACCUM_RED_BITS,value);
1922 cout<<"GL_ACCUM_RED_BITS="<<value[0]<<". Number of bits per red component in the accumulation buffer."<<endl;
1923 glGetIntegerv(GL_ACCUM_GREEN_BITS,value);
1924 cout<<"GL_ACCUM_GREEN_BITS="<<value[0]<<". Number of bits per green component in accumulation buffer."<<endl;
1925 glGetIntegerv(GL_ACCUM_BLUE_BITS,value);
1926 cout<<"GL_ACCUM_BLUE_BITS="<<value[0]<<". Number of bits per blue component in accumulation buffer."<<endl;
1927 glGetIntegerv(GL_ACCUM_ALPHA_BITS,value);
1928 cout<<"GL_ACCUM_ALPHA_BITS="<<value[0]<<". Number of bits per alpha component in accumulation buffer."<<endl;
1929
1930 if(extensions->LoadSupportedExtension("GL_VERSION_1_2"))
1931 {
1932 cout<<endl<<"OpenGL 1.2 Implementation dependent values : "<<endl;
1933
1934 glGetIntegerv(vtkgl::MAX_3D_TEXTURE_SIZE,value);
1935 cout<<"GL_MAX_3D_TEXTURE_SIZE="<<value[0]<<" . Maximum 3D texture image dimension. Min is 16."<<endl;
1936 CheckMinValidValue(value[0],16);
1937 cout<<"It means that the maximum 3D texture size is "<<value[0]<<"x"<<value[0]<<"x"<<value[0]<<endl;
1938 cout<<"It also means that "<<(value[0]+1)<<"x1x1 is too large"<<endl;
1939
1940 glGetFloatv(vtkgl::ALIASED_POINT_SIZE_RANGE,fvalue);
1941 cout<<"GL_ALIASED_POINT_SIZE_RANGE="<<fvalue[0]<<","<<fvalue[1]<<". Range (lo to hi) of aliased point sizes. Min is (1,1)"<<endl;
1942 // check range.
1943
1944 glGetFloatv(vtkgl::SMOOTH_POINT_SIZE_RANGE,fvalue);
1945 cout<<"GL_SMOOTH_POINT_SIZE_RANGE (GL_POINT_SIZE_RANGE in 1.1)="<<fvalue[0]<<","<<fvalue[1]<<". Range (lo to hi) of antialiased point sizes. Min is (1,1)"<<endl;
1946 // check range.
1947
1948 glGetFloatv(vtkgl::SMOOTH_POINT_SIZE_GRANULARITY,fvalue);
1949 cout<<"GL_SMOOTH_POINT_SIZE_GRANULARITY (GL_POINT_SIZE_GRANULARITY in 1.1)="<<fvalue[0]<<". Antialiased point size granularity."<<endl;
1950
1951 glGetFloatv(vtkgl::ALIASED_LINE_WIDTH_RANGE,fvalue);
1952 cout<<"GL_ALIASED_LINE_WIDTH_RANGE="<<fvalue[0]<<","<<fvalue[1]<<". Range (lo to hi) of aliased line widths. Min is (1,1)"<<endl;
1953 // check range.
1954
1955 glGetFloatv(vtkgl::SMOOTH_LINE_WIDTH_RANGE,fvalue);
1956 cout<<"GL_SMOOTH_LINE_WIDTH_RANGE (GL_LINE_WIDTH_RANGE in 1.1)="<<fvalue[0]<<","<<fvalue[1]<<". Range (lo to hi) of antialiased line widths. Min is (1,1)"<<endl;
1957 // check range.
1958
1959 glGetFloatv(vtkgl::SMOOTH_LINE_WIDTH_GRANULARITY,fvalue);
1960 cout<<"GL_SMOOTH_LINE_WIDTH_GRANULARITY (GL_LINE_WIDTH_GRANULARITY in 1.1)="<<fvalue[0]<<". Antialiased line width granularity."<<endl;
1961
1962 glGetIntegerv(vtkgl::MAX_ELEMENTS_INDICES,value);
1963 cout<<"GL_MAX_ELEMENTS_INDICES="<<value[0]<<" . Recommended maximum number of DrawRangeElements indices."<<endl;
1964
1965 glGetIntegerv(vtkgl::MAX_ELEMENTS_VERTICES,value);
1966 cout<<"GL_MAX_ELEMENTS_VERTICES="<<value[0]<<" . Recommended maximum number of DrawRangeElements vertices."<<endl;
1967
1968 if(extensions->LoadSupportedExtension("GL_ARB_imaging"))
1969 {
1970 cout<<"imaging subset is supported."<<endl;
1971
1972 glGetIntegerv(vtkgl::MAX_COLOR_MATRIX_STACK_DEPTH,value);
1973 cout<<"GL_MAX_COLOR_MATRIX_STACK_DEPTH="<<value[0]<<" . Maximum color matrix stack depth. Min is 2."<<endl;
1974 CheckMinValidValue(value[0],2);
1975
1976 vtkgl::GetConvolutionParameteriv(vtkgl::CONVOLUTION_1D,
1977 vtkgl::MAX_CONVOLUTION_WIDTH,value);
1978
1979 cout<<"for GL_CONVOLUTION_1D, GL_MAX_CONVOLUTION_WIDTH="<<value[0]<<" . Maximum width of the convolution filter. Min is 3."<<endl;
1980 CheckMinValidValue(value[0],3);
1981
1982 vtkgl::GetConvolutionParameteriv(vtkgl::CONVOLUTION_2D,
1983 vtkgl::MAX_CONVOLUTION_WIDTH,value);
1984 cout<<"for GL_CONVOLUTION_2D, GL_MAX_CONVOLUTION_WIDTH="<<value[0]<<" . Maximum width of the convolution filter. Min is 3."<<endl;
1985 CheckMinValidValue(value[0],3);
1986
1987 vtkgl::GetConvolutionParameteriv(vtkgl::CONVOLUTION_2D,
1988 vtkgl::MAX_CONVOLUTION_HEIGHT,value);
1989 cout<<"for GL_CONVOLUTION_2D, GL_MAX_CONVOLUTION_HEIGHT="<<value[0]<<" . Maximum height of the convolution filter. Min is 3."<<endl;
1990 CheckMinValidValue(value[0],3);
1991
1992 vtkgl::GetConvolutionParameteriv(vtkgl::SEPARABLE_2D,
1993 vtkgl::MAX_CONVOLUTION_WIDTH,value);
1994 cout<<"for GL_SEPARABLE_2D, GL_MAX_CONVOLUTION_WIDTH="<<value[0]<<" . Maximum width of the convolution filter. Min is 3."<<endl;
1995 CheckMinValidValue(value[0],3);
1996
1997 vtkgl::GetConvolutionParameteriv(vtkgl::SEPARABLE_2D,
1998 vtkgl::MAX_CONVOLUTION_HEIGHT,value);
1999 cout<<"for GL_SEPARABLE_2D, GL_MAX_CONVOLUTION_HEIGHT="<<value[0]<<" . Maximum height of the convolution filter. Min is 3."<<endl;
2000 CheckMinValidValue(value[0],3);
2001 }
2002 else
2003 {
2004 cout<<"imaging subset is not supported."<<endl;
2005 }
2006 }
2007 if(extensions->LoadSupportedExtension("GL_VERSION_1_3"))
2008 {
2009 cout<<endl<<"OpenGL 1.3 Implementation dependent values : "<<endl;
2010 glGetIntegerv(vtkgl::MAX_CUBE_MAP_TEXTURE_SIZE,value);
2011 cout<<"GL_MAX_CUBE_MAP_TEXTURE_SIZE="<<value[0]<<" . Maximum cube map texture image dimension. Min is 16."<<endl;
2012 CheckMinValidValue(value[0],16);
2013 cout<<"It means that the maximum cube map texture size is "<<value[0]<<"x"<<value[0]<<endl;
2014 cout<<"It also means that "<<(value[0]+1)<<"x1 is too large"<<endl;
2015
2016 glGetIntegerv(vtkgl::MAX_TEXTURE_UNITS,value);
2017 cout<<"GL_MAX_TEXTURE_UNITS="<<value[0]<<" . Number of (fixed-function) texture units. Min is 2. Max is 32."<<endl;
2018 CheckMinValidValue(value[0],2);
2019 CheckMaxValidValue(value[0],32);
2020
2021 glGetIntegerv(vtkgl::SAMPLE_BUFFERS,value);
2022 cout<<"GL_SAMPLE_BUFFERS="<<value[0]<<" . Number of multisample buffers. Min is 0."<<endl;
2023 CheckMinValidValue(value[0],0);
2024
2025 glGetIntegerv(vtkgl::SAMPLES,value);
2026 cout<<"GL_SAMPLES="<<value[0]<<" . Coverage mask size. Min is 0."<<endl;
2027 CheckMinValidValue(value[0],0);
2028
2029 GLint count;
2030
2031 glGetIntegerv(vtkgl::NUM_COMPRESSED_TEXTURE_FORMATS,&count);
2032 cout<<"GL_NUM_COMPRESSED_TEXTURE_FORMATS="<<count<<" . Number of enumerated compressed texture formats."<<endl;
2033 CheckMinValidValue(count,0);
2034
2035 if(count>0)
2036 {
2037 GLint *ivalues=new GLint[count];
2038 glGetIntegerv(vtkgl::COMPRESSED_TEXTURE_FORMATS,ivalues);
2039 cout<<"GL_COMPRESSED_TEXTURE_FORMATS (Enumerated compressed texture formats)=";
2040 int i=0;
2041 while(i<count)
2042 {
2043 cout<<" "<<TextureCompressionFormat(ivalues[i])<<"(0x"<< hex << ivalues[i] << dec << ")";
2044 ++i;
2045 }
2046 delete[] ivalues;
2047 cout<<endl;
2048 }
2049 }
2050 if(extensions->LoadSupportedExtension("GL_VERSION_1_4"))
2051 {
2052 cout<<endl<<"OpenGL 1.4 Implementation dependent values : "<<endl;
2053 glGetFloatv(vtkgl::MAX_TEXTURE_LOD_BIAS,fvalue);
2054 cout<<"GL_MAX_TEXTURE_LOD_BIAS="<<fvalue[0]<<" . Maximum absolute texture level of detail bias. Min is 2.0."<<endl;
2055 CheckMinValidFValue(fvalue[0],2.0);
2056 }
2057
2058 depth_texture_supported=extensions->ExtensionSupported("GL_VERSION_1_4") ||
2059 extensions->ExtensionSupported("GL_ARB_depth_texture");
2060
2061 if(extensions->LoadSupportedExtension("GL_VERSION_1_5"))
2062 {
2063 cout<<endl<<"OpenGL 1.5 Implementation dependent values : "<<endl;
2064
2065 vtkgl::GetQueryiv(vtkgl::SAMPLES_PASSED,vtkgl::QUERY_COUNTER_BITS,value);
2066 cout<<"GL_QUERY_COUNTER_BITS="<<value[0]<<" . Occlusion query counter bits. Max is 32."<<endl;
2067 CheckMaxValidValue(value[0],32);
2068 }
2069
2070 if(extensions->LoadSupportedExtension("GL_VERSION_2_0"))
2071 {
2072 cout<<endl<<"OpenGL 2.0 Implementation dependent values : "<<endl;
2073
2074 svalue=glGetString(vtkgl::SHADING_LANGUAGE_VERSION);
2075 cout<<"GL_SHADING_LANGUAGE_VERSION="<<svalue<<" . Shading Language version supported."<<endl;
2076
2077 glGetIntegerv(vtkgl::MAX_VERTEX_ATTRIBS,value);
2078 cout<<"GL_MAX_VERTEX_ATTRIBS="<<value[0]<<" . Number of active vertex attributes. Min is 16."<<endl;
2079 CheckMinValidValue(value[0],16);
2080
2081 glGetIntegerv(vtkgl::MAX_VERTEX_UNIFORM_COMPONENTS,value);
2082 cout<<"GL_MAX_VERTEX_UNIFORM_COMPONENTS="<<value[0]<<" . Number of words for vertex shader uniform variables. Min is 512."<<endl;
2083 CheckMinValidValue(value[0],512);
2084
2085 glGetIntegerv(vtkgl::MAX_VARYING_FLOATS,value);
2086 cout<<"GL_MAX_VARYING_FLOATS="<<value[0]<<" . Number of floats for varying variables. Min is 32."<<endl;
2087 CheckMinValidValue(value[0],32);
2088
2089 glGetIntegerv(vtkgl::MAX_COMBINED_TEXTURE_IMAGE_UNITS,value);
2090 cout<<"GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS="<<value[0]<<" . Total number of texture units accessible by the GL. Min is 2."<<endl;
2091 CheckMinValidValue(value[0],2);
2092
2093 glGetIntegerv(vtkgl::MAX_VERTEX_TEXTURE_IMAGE_UNITS,value);
2094 cout<<"GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS="<<value[0]<<" . Number of texture image units accessible by a vertex shader. Min is 0."<<endl;
2095 CheckMinValidValue(value[0],0);
2096
2097 glGetIntegerv(vtkgl::MAX_TEXTURE_IMAGE_UNITS,value);
2098 cout<<"GL_MAX_TEXTURE_IMAGE_UNITS="<<value[0]<<" . Number of texture image units accessible by fragment processing. Min is 2."<<endl;
2099 CheckMinValidValue(value[0],2);
2100
2101 glGetIntegerv(vtkgl::MAX_TEXTURE_COORDS,value);
2102 cout<<"GL_MAX_TEXTURE_COORDS="<<value[0]<<" . Number of texture coordinate sets. Min is 2."<<endl;
2103 CheckMinValidValue(value[0],2);
2104
2105 glGetIntegerv(vtkgl::MAX_FRAGMENT_UNIFORM_COMPONENTS,value);
2106 cout<<"GL_MAX_FRAGMENT_UNIFORM_COMPONENTS="<<value[0]<<" . Number of words for fragment shader uniform variables. Min is 64."<<endl;
2107 CheckMinValidValue(value[0],64);
2108
2109 glGetIntegerv(vtkgl::MAX_DRAW_BUFFERS,value);
2110 cout<<"GL_MAX_DRAW_BUFFERS="<<value[0]<<" . Maximum number of active draw buffers. Min is 1."<<endl;
2111 CheckMinValidValue(value[0],1);
2112 }
2113
2114
2115 srgb_texture_supported=extensions->ExtensionSupported("GL_VERSION_2_1") ||
2116 extensions->ExtensionSupported("GL_EXT_texture_sRGB");
2117 float_texture_supported=extensions->LoadSupportedExtension("GL_ARB_texture_float")==1;
2118 integer_texture_supported=extensions->ExtensionSupported("GL_EXT_texture_integer")==1;
2119
2120 ARB_texture_rectangle_supported=extensions->LoadSupportedExtension("GL_ARB_texture_rectangle")==1;
2121
2122 if(ARB_texture_rectangle_supported)
2123 {
2124 cout<<endl<<"GL_ARB_texture_rectangle extension Implementation dependent values : "<<endl;
2125
2126 glGetIntegerv(vtkgl::MAX_RECTANGLE_TEXTURE_SIZE_ARB,value);
2127 cout<<"MAX_RECTANGLE_TEXTURE_SIZE_ARB="<<value[0]<<" . Maximum rectangle texture image dimension. Min is 64."<<endl;
2128 CheckMinValidValue(value[0],64);
2129 cout<<"It means that the maximum rectangle texture size is "<<value[0]<<"x"<<value[0]<<endl;
2130 cout<<"It also means that "<<(value[0]+1)<<"x1 is too large"<<endl;
2131 }
2132
2133 if(extensions->LoadSupportedExtension("GL_EXT_framebuffer_object"))
2134 {
2135 cout<<endl<<"GL_EXT_framebuffer_object extension Implementation dependent values : "<<endl;
2136
2137 glGetIntegerv(vtkgl::MAX_COLOR_ATTACHMENTS_EXT,value);
2138 cout<<"MAX_COLOR_ATTACHMENTS_EXT="<<value[0]<<" . Maximum number of attachment points to color buffers when using framebuffer objects. Min is 1."<<endl;
2139 CheckMinValidValue(value[0],1);
2140 glGetIntegerv(vtkgl::MAX_RENDERBUFFER_SIZE_EXT,value);
2141 cout<<"MAX_RENDERBUFFER_SIZE_EXT="<<value[0]<<" . Maximum width and height of renderbuffers supported by the implementation. Min is 1."<<endl;
2142 CheckMinValidValue(value[0],1);
2143 }
2144 extensions->Delete();
2145 renwin->Delete();
2146 }
2147
2148 const int windowSize[2]={512,511};
2149
main(int vtkNotUsed (argc),char * vtkNotUsed (argv)[])2150 int main(int vtkNotUsed(argc), char *vtkNotUsed(argv)[])
2151 {
2152 cout << "CTEST_FULL_OUTPUT (Avoid ctest truncation of output)" << endl;
2153
2154 int multisample=0;
2155 while(multisample<2)
2156 {
2157 int alpha=0;
2158 while(alpha<2)
2159 {
2160 int index=0;
2161 while(index<2)
2162 {
2163 TestVisual(multisample,alpha,windowSize[index],windowSize[index]);
2164 ++index;
2165 }
2166 ++alpha;
2167 }
2168 ++multisample;
2169 }
2170
2171 vtkRenderWindow *renwin = vtkRenderWindow::New();
2172 renwin->SetAlphaBitPlanes(1);
2173 renwin->SetSize(250, 250);
2174
2175 vtkRenderer *renderer = vtkRenderer::New();
2176 renwin->AddRenderer(renderer);
2177
2178 // Force a Render here so that we can call glGetString reliably:
2179 //
2180 renwin->Render();
2181
2182 if(vtkgl::TexImage3D!=0)
2183 {
2184 QueryTexture3D();
2185 }
2186 QueryTexture2D();
2187 QueryTexture1D();
2188
2189 if(ARB_texture_rectangle_supported)
2190 {
2191 QueryTexture2DRectangle();
2192 }
2193
2194 // Check if non-power-of-two texture is supported based on glError not
2195 // on the OpenGL version returned by the driver or on the list of
2196 // extensions returned by the driver.
2197
2198 // clean glError
2199 GLenum errorCode=glGetError();
2200 glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA16,64,64,0, GL_RGBA, GL_FLOAT, NULL );
2201 errorCode=glGetError();
2202 if(errorCode!=GL_NO_ERROR)
2203 {
2204 cout << "Loading a power-of-two texture failed with the following error:"
2205 << OpenGLErrorMessage2(errorCode) <<endl;
2206 }
2207 glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA16,64,65,0, GL_RGBA, GL_FLOAT, NULL );
2208 errorCode=glGetError();
2209 if(errorCode!=GL_NO_ERROR)
2210 {
2211 cout << "Loading a none-power-of-two texture failed with the following"
2212 << "error:" << OpenGLErrorMessage2(errorCode) <<endl;
2213 }
2214
2215
2216
2217
2218 TestTextureFormatsAndFBO();
2219
2220 renderer->Delete();
2221 renwin->Delete();
2222
2223 return 0; // 0==passed, always pass.
2224 }
2225