1 /*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: vtkOpenGLExtensionManager.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 Copyright 2003 Sandia Corporation.
15 Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
16 license for use of this work by or on behalf of the
17 U.S. Government. Redistribution and use in source and binary forms, with
18 or without modification, are permitted provided that this Notice and any
19 statement of authorship are reproduced on all copies.
20
21 =========================================================================*/
22
23 #include "vtkOpenGLExtensionManager.h"
24 #include "vtkOpenGLExtensionManagerConfigure.h"
25 #include "vtkgl.h"
26
27 #include "vtkRenderWindow.h"
28 #include "vtkObjectFactory.h"
29
30 #include <string.h>
31 #include <string>
32 #include <cassert>
33 #include <sstream>
34 using std::istringstream;
35 using std::string;
36
37 #ifdef VTK_DEFINE_GLX_GET_PROC_ADDRESS_PROTOTYPE
38 extern "C" vtkglX::__GLXextFuncPtr glXGetProcAddressARB(const GLubyte *);
39 #endif //VTK_DEFINE_GLX_GET_PROC_ADDRESS_PROTOTYPE
40
41 #ifdef VTK_USE_VTK_DYNAMIC_LOADER
42 #include "vtkDynamicLoader.h"
43 #include <list>
44 #endif
45
46 #ifdef VTK_USE_APPLE_LOADER
47 #include <dlfcn.h>
48 #endif //VTK_USE_APPLE_LOADER
49
50 #ifdef VTK_OPENGL_HAS_OSMESA
51 # include <GL/osmesa.h>
52 #endif
53
54 // GLU is currently not linked in VTK. We do not support it here.
55 #define GLU_SUPPORTED 0
56
57 // ensure we never use a null pointer to
58 // a string.
59 #define safes(arg) (arg?((const char *)arg):"")
60
61 namespace
62 {
63 // helper to locate a token(a substr delimitted by ' ' or '\n')
64 // for eg searching for "ati" should not succeed on "corporation"
FindToken(const string & str,string token)65 bool FindToken(const string &str, string token)
66 {
67 string tmp;
68 istringstream iss(str);
69 while (iss.good())
70 {
71 iss >> tmp;
72 if (tmp==token)
73 {
74 return true;
75 }
76 }
77 return false;
78 }
79 // convert a string in the forms of "#.#.#","#.#", or "#" to
80 // major minor and patch version numbers.
StringToVersion(string ver,int & major,int & minor,int & patch)81 int StringToVersion(string ver, int &major, int &minor, int &patch)
82 {
83 char dot;
84 istringstream iss(ver);
85 major=0;
86 minor=0;
87 patch=0;
88 if (!(iss >> major))
89 {
90 return 0;
91 }
92 if (!((iss >> dot) && (iss >> minor)))
93 {
94 return 1;
95 }
96 if (!((iss >> dot) && (iss >> patch)))
97 {
98 return 2;
99 }
100 return 3;
101 }
102 }
103
104 namespace vtkgl
105 {
106 // Description:
107 // Set the OpenGL function pointers with the function pointers
108 // of the core-promoted extension.
109 int LoadCorePromotedExtension(const char *name,
110 vtkOpenGLExtensionManager *manager);
111 // Description:
112 // Set the ARB function pointers with the function pointers
113 // of a EXT extension.
114 int LoadAsARBExtension(const char *name,
115 vtkOpenGLExtensionManager *manager);
116 }
117
118
119 // ----------------------------------------------------------------------------
120 vtkStandardNewMacro(vtkOpenGLExtensionManager);
121
122 // ----------------------------------------------------------------------------
vtkOpenGLExtensionManager()123 vtkOpenGLExtensionManager::vtkOpenGLExtensionManager()
124 {
125 this->OwnRenderWindow = 0;
126 this->RenderWindow = NULL;
127 this->ExtensionsString = NULL;
128 this->DriverGLVersion = "";
129 this->DriverGLVersionMajor = 1;
130 this->DriverGLVersionMinor = 1;
131 this->DriverGLVersionPatch = 0;
132 this->DriverGLVendor = "";
133 this->DriverGLRenderer = "";
134 this->DriverVersionMajor = 0;
135 this->DriverVersionMinor = 0;
136 this->DriverVersionPatch = 0;
137 this->DriverGLVendorId = DRIVER_VENDOR_UNKNOWN;
138 this->IgnoreDriverBugs
139 #if defined(VTK_IGNORE_GLDRIVER_BUGS)
140 = true;
141 #else
142 = false;
143 #endif
144 this->Modified();
145 }
146
147 // ----------------------------------------------------------------------------
~vtkOpenGLExtensionManager()148 vtkOpenGLExtensionManager::~vtkOpenGLExtensionManager()
149 {
150 this->SetRenderWindow(NULL);
151 delete [] this->ExtensionsString;
152 this->ExtensionsString = 0;
153 }
154
155 // ----------------------------------------------------------------------------
PrintSelf(ostream & os,vtkIndent indent)156 void vtkOpenGLExtensionManager::PrintSelf(ostream &os, vtkIndent indent)
157 {
158 this->Superclass::PrintSelf(os, indent);
159
160 os << indent << "RenderWindow: (" << this->RenderWindow << ")" << endl;
161 os << indent << "BuildTime: " << this->BuildTime << endl;
162 os << indent << "ExtensionsString: "
163 << (this->ExtensionsString ? this->ExtensionsString : "(NULL)") << endl;
164 }
165
166 // ----------------------------------------------------------------------------
GetRenderWindow()167 vtkRenderWindow* vtkOpenGLExtensionManager::GetRenderWindow()
168 {
169 return this->RenderWindow;
170 }
171
172 // ----------------------------------------------------------------------------
SetRenderWindow(vtkRenderWindow * renwin)173 void vtkOpenGLExtensionManager::SetRenderWindow(vtkRenderWindow *renwin)
174 {
175 if (renwin == this->RenderWindow)
176 {
177 return;
178 }
179
180 if (this->OwnRenderWindow && this->RenderWindow)
181 {
182 this->RenderWindow->UnRegister(this);
183 this->RenderWindow = 0;
184 }
185
186 vtkDebugMacro("Setting RenderWindow to " << renwin);
187 this->OwnRenderWindow = 0;
188 this->RenderWindow = renwin;
189 this->DriverGLVersion = "";
190 this->DriverGLVersionMajor = 1;
191 this->DriverGLVersionMinor = 1;
192 this->DriverGLVersionPatch = 0;
193 this->DriverGLVendor = "";
194 this->DriverGLVendorId = DRIVER_VENDOR_UNKNOWN;
195 this->DriverGLRenderer = "";
196 this->DriverVersionMajor = 0;
197 this->DriverVersionMinor = 0;
198 this->DriverVersionPatch = 0;
199 this->IgnoreDriverBugs
200 #if defined(VTK_IGNORE_GLDRIVER_BUGS)
201 = true;
202 #else
203 = false;
204 #endif
205 this->Modified();
206 }
207
208 /*
209 a few examples of the info that's provided
210 by glGetString that can be used to identify
211 specific driver/cards on various platforms
212
213 linux
214 GL_VENDOR: NVIDIA Corporation
215 GL_VERSION: 3.3.0 NVIDIA 319.23
216 GL_RENDERER: Quadro FX 580/PCIe/SSE2
217
218 GL_VENDOR: NVIDIA Corporation
219 GL_VERSION: 4.2.0 NVIDIA 304.88
220 GL_RENDERER: GeForce GTX 480/PCIe/SSE2
221
222 GL_VENDOR: VMware, Inc.
223 GL_VERSION: 2.1 Mesa 9.2.0 (git-062317d)
224 GL_RENDERER: Gallium 0.4 on llvmpipe (LLVM 3.2, 128 bits)
225
226 GL_VENDOR: Brian Paul
227 GL_VERSION: 2.1 Mesa 8.0.5
228 GL_RENDERER: Mesa OffScreen
229
230 GL_VENDOR: Tungsten Graphics, Inc
231 GL_VERSION: 1.4 Mesa 8.0.4
232 GL_RENDERER: Mesa DRI Intel(R) 945GME
233
234 GL_VENDOR: Brian Paul
235 GL_VERSION: 2.1 Mesa 7.10.3
236 GL_RENDERER: Mesa OffScreen
237
238 GL_VENDOR: Brian Paul
239 GL_VERSION: 2.1 Mesa 9.2.0-devel
240 GL_RENDERER: Mesa X11
241
242
243 apple
244 GL_VENDOR: NVIDIA Corporation
245 GL_VERSION: 2.1 NVIDIA-7.32.12
246 GL_RENDERER: NVIDIA GeForce 320M OpenGL Engine
247
248 GL_VENDOR: ATI Technologies Inc.
249 GL_VERSION: 2.1 ATI-1.0.29
250 GL_RENDERER: AMD Radeon HD 6750M OpenGL Engine
251
252 GL_VENDOR: Intel Inc.
253 GL_VERSION: 2.1 APPLE-8.0.61
254 GL_RENDERER: Intel HD Graphics 3000 OpenGL Engine
255
256 GL_VENDOR: ATI Technologies Inc.
257 GL_VERSION: 2.0 ATI-1.5.48
258 GL_RENDERER: ATI Radeon 9600 XT OpenGL Engine
259
260
261 windows
262 GL_VENDOR: Intel
263 GL_VERSION: 3.3.0 - Build 8.15.10.2712
264 GL_RENDERER: Intel(R) HD Graphics 4000
265
266 GL_VENDOR: Microsoft Corporation
267 GL_VERSION: 1.1.0
268 GL_RENDERER: GDI Generic
269
270 GL_VENDOR: NVIDIA Corporation
271 GL_VERSION: 3.3.0
272 GL_RENDERER: GeForce GTS 250M/PCIe/SSE2
273
274 GL_VENDOR: ATI Technologies Inc.
275 GL_VERSION: 4.2.11631 Compatibility Profile Context
276 GL_RENDERER: AMD Radeon(TM) HD 7670M
277 */
278
279 // ----------------------------------------------------------------------------
InitializeDriverInformation()280 void vtkOpenGLExtensionManager::InitializeDriverInformation()
281 {
282 // collect some info about the driver
283 // for use in fine-grained feature
284 // validation see examples below.
285 if (this->RenderWindow)
286 {
287 this->DriverGLVendor = safes(glGetString(GL_VENDOR));
288 this->DriverGLVersion = safes(glGetString(GL_VERSION));
289 this->DriverGLRenderer = safes(glGetString(GL_RENDERER));
290
291 // attempt to detect driver gl version
292 const char *numbers="0123456789.";
293 size_t glVerStart = this->DriverGLVersion.find_first_of(numbers);
294 size_t glVerEnd = this->DriverGLVersion.find_first_not_of(numbers, glVerStart);
295 if (glVerEnd==string::npos)
296 {
297 glVerEnd = this->DriverGLVersion.size();
298 }
299 if (glVerStart!=string::npos)
300 {
301 // driver gl version found
302 StringToVersion(
303 this->DriverGLVersion.substr(glVerStart,glVerEnd-glVerStart),
304 this->DriverGLVersionMajor,
305 this->DriverGLVersionMinor,
306 this->DriverGLVersionPatch);
307 // attempt to detect driver version
308 // windows sometimes doesn't have it.
309 size_t driverVerStart = this->DriverGLVersion.find_first_of(numbers, glVerEnd+1);
310 size_t driverVerEnd = this->DriverGLVersion.find_first_not_of(numbers, driverVerStart);
311 if (driverVerEnd==string::npos)
312 {
313 driverVerEnd = this->DriverGLVersion.size();
314 }
315 if (driverVerStart!=string::npos)
316 {
317 // driver version found
318 StringToVersion(
319 this->DriverGLVersion.substr(driverVerStart,driverVerEnd-driverVerStart),
320 this->DriverVersionMajor,
321 this->DriverVersionMinor,
322 this->DriverVersionPatch);
323 }
324 }
325
326 // attempt to identify driver vendor
327 if ( FindToken(this->DriverGLVendor, "ATI")
328 || FindToken(this->DriverGLVendor, "AMD") )
329 {
330 this->DriverGLVendorId = DRIVER_VENDOR_ATI;
331 }
332 else if (FindToken(this->DriverGLVendor, "NVIDIA"))
333 {
334 this->DriverGLVendorId = DRIVER_VENDOR_NVIDIA;
335 }
336 else if (FindToken(this->DriverGLVendor, "Intel"))
337 {
338 this->DriverGLVendorId = DRIVER_VENDOR_INTEL;
339 }
340 // Mesa's use of the vendor field is all over the map
341 // but they consistently use version field.
342 else if (FindToken(this->DriverGLVersion, "Mesa"))
343 {
344 this->DriverGLVendorId = DRIVER_VENDOR_MESA;
345 }
346 else if (FindToken(this->DriverGLVendor, "Microsoft"))
347 {
348 this->DriverGLVendorId = DRIVER_VENDOR_MICROSOFT;
349 }
350 else
351 {
352 this->DriverGLVendorId = DRIVER_VENDOR_UNKNOWN;
353 }
354 }
355 }
356
357 // ----------------------------------------------------------------------------
DriverIsATI()358 bool vtkOpenGLExtensionManager::DriverIsATI()
359 {
360 return this->DriverGLVendorId == DRIVER_VENDOR_ATI;
361 }
362
363 // ----------------------------------------------------------------------------
DriverIsNvidia()364 bool vtkOpenGLExtensionManager::DriverIsNvidia()
365 {
366 return this->DriverGLVendorId == DRIVER_VENDOR_NVIDIA;
367 }
368
369 // ----------------------------------------------------------------------------
DriverIsIntel()370 bool vtkOpenGLExtensionManager::DriverIsIntel()
371 {
372 return this->DriverGLVendorId == DRIVER_VENDOR_INTEL;
373 }
374
375 // ----------------------------------------------------------------------------
DriverIsMesa()376 bool vtkOpenGLExtensionManager::DriverIsMesa()
377 {
378 return this->DriverGLVendorId == DRIVER_VENDOR_MESA;
379 }
380
381 // ----------------------------------------------------------------------------
DriverIsMicrosoft()382 bool vtkOpenGLExtensionManager::DriverIsMicrosoft()
383 {
384 return this->DriverGLVendorId == DRIVER_VENDOR_MICROSOFT;
385 }
386
387 // ----------------------------------------------------------------------------
DriverVersionIs(int major,int minor,int patch)388 bool vtkOpenGLExtensionManager::DriverVersionIs(
389 int major,
390 int minor,
391 int patch)
392 {
393 return (this->DriverVersionMajor==major)
394 && (this->DriverVersionMinor==minor)
395 && (this->DriverVersionPatch==patch);
396 }
397
398 // ----------------------------------------------------------------------------
DriverVersionIs(int major,int minor)399 bool vtkOpenGLExtensionManager::DriverVersionIs(int major, int minor)
400 {
401 return (this->DriverVersionMajor==major)
402 && (this->DriverVersionMinor==minor);
403 }
404
405 // ----------------------------------------------------------------------------
DriverVersionIs(int major)406 bool vtkOpenGLExtensionManager::DriverVersionIs(int major)
407 {
408 return (this->DriverVersionMajor==major);
409 }
410
411 // ----------------------------------------------------------------------------
DriverVersionAtLeast(int major,int minor,int patch)412 bool vtkOpenGLExtensionManager::DriverVersionAtLeast(
413 int major,
414 int minor,
415 int patch)
416 {
417 return (this->DriverVersionMajor>major)
418 || ((this->DriverVersionMajor==major)
419 && ((this->DriverVersionMinor>minor)
420 || ((this->DriverVersionMinor==minor)
421 && (this->DriverVersionPatch>=patch))));
422 }
423
424 // ----------------------------------------------------------------------------
DriverVersionAtLeast(int major,int minor)425 bool vtkOpenGLExtensionManager::DriverVersionAtLeast(int major, int minor)
426 {
427 return (this->DriverVersionMajor>major)
428 || ((this->DriverVersionMajor==major)
429 && (this->DriverVersionMinor>=minor));
430 }
431
432 // ----------------------------------------------------------------------------
DriverVersionAtLeast(int major)433 bool vtkOpenGLExtensionManager::DriverVersionAtLeast(int major)
434 {
435 return (this->DriverVersionMajor>=major);
436 }
437
438 // ----------------------------------------------------------------------------
DriverGLVersionIs(int major,int minor,int patch)439 bool vtkOpenGLExtensionManager::DriverGLVersionIs(
440 int major,
441 int minor,
442 int patch)
443 {
444 return (this->DriverGLVersionMajor==major)
445 && (this->DriverGLVersionMinor==minor)
446 && (this->DriverGLVersionPatch==patch);
447 }
448
449 // ----------------------------------------------------------------------------
DriverGLVersionIs(int major,int minor)450 bool vtkOpenGLExtensionManager::DriverGLVersionIs(int major, int minor)
451 {
452 return (this->DriverGLVersionMajor==major)
453 && (this->DriverGLVersionMinor==minor);
454 }
455
456 // ----------------------------------------------------------------------------
DriverGLRendererIs(const char * str)457 bool vtkOpenGLExtensionManager::DriverGLRendererIs(const char *str)
458 {
459 return this->DriverGLRenderer==str;
460 }
461
462 // ----------------------------------------------------------------------------
DriverGLRendererHas(const char * str)463 bool vtkOpenGLExtensionManager::DriverGLRendererHas(const char *str)
464 {
465 return this->DriverGLRenderer.find(str)!=string::npos;
466 }
467
468 // ----------------------------------------------------------------------------
DriverGLRendererHasToken(const char * str)469 bool vtkOpenGLExtensionManager::DriverGLRendererHasToken(const char *str)
470 {
471 return FindToken(this->DriverGLRenderer, str);
472 }
473
474 // ----------------------------------------------------------------------------
DriverGLRendererIsOSMesa()475 bool vtkOpenGLExtensionManager::DriverGLRendererIsOSMesa()
476 {
477 // check the type of render window because
478 // OffScreen token is not used with the OS Mesa
479 // llvmpipe state tracker
480 return
481 this->DriverIsMesa()
482 && this->RenderWindow->IsA("vtkOSOpenGLRenderWindow");
483 }
484
485 // ----------------------------------------------------------------------------
GetIgnoreDriverBugs(const char * description)486 bool vtkOpenGLExtensionManager::GetIgnoreDriverBugs(const char *description)
487 {
488 if (this->IgnoreDriverBugs)
489 {
490 vtkWarningMacro(
491 << "Ignoring OpenGL driver bug: " << description);
492 return true;
493 }
494 return false;
495 }
496
497 // ----------------------------------------------------------------------------
Update()498 void vtkOpenGLExtensionManager::Update()
499 {
500 if (this->BuildTime > this->MTime)
501 {
502 return;
503 }
504
505 vtkDebugMacro("Update");
506
507 delete[] this->ExtensionsString;
508 this->ExtensionsString = 0;
509
510 this->ReadOpenGLExtensions();
511 this->InitializeDriverInformation();
512
513 this->BuildTime.Modified();
514 }
515
516 // ----------------------------------------------------------------------------
ExtensionSupported(const char * name)517 int vtkOpenGLExtensionManager::ExtensionSupported(const char *name)
518 {
519 this->Update();
520
521 const char *p = this->ExtensionsString;
522 size_t NameLen = strlen(name);
523 int result = 0;
524
525 while (true)
526 {
527 size_t n;
528 while (*p == ' ') p++;
529 if (*p == '\0')
530 {
531 result = 0;
532 break;
533 }
534 n = strcspn(p, " ");
535 if ((NameLen == n) && (strncmp(name, p, n) == 0))
536 {
537 result = 1;
538 break;
539 }
540 p += n;
541 }
542
543 if (result == 0)
544 {
545 // the requested feature is not supported
546 return 0;
547 }
548
549 // Workaround for a nVidia bug in indirect/remote rendering mode (ssh -X)
550 // The version returns is not the one actually supported.
551 // For example, the version returns is greater or equal to 2.1
552 // but where PBO (which are core in 2.1) are not actually supported.
553 // In this case, force the version to be 1.1 (minimal). Anything above
554 // will be requested only through extensions.
555 // See ParaView bug
556 if ( (strncmp(name,"GL_VERSION_",11) == 0)
557 && !this->RenderWindow->IsDirect() && !this->DriverGLRendererIsOSMesa() )
558 {
559 // whatever is the OpenGL version, return false.
560 // (nobody asks for GL_VERSION_1_1)
561 return 0;
562 }
563
564 if (strcmp(name, "GL_VERSION_1_4") == 0)
565 {
566 // Workaround for a bug on Mac PowerPC G5 with nVidia GeForce FX 5200
567 // Mac OS 10.3.9 and driver 1.5 NVIDIA-1.3.42. It reports it supports
568 // OpenGL>=1.4 but querying for glPointParameteri and glPointParameteriv
569 // return null pointers. So it does not actually supports fully OpenGL 1.4.
570 // It will make this method return false with "GL_VERSION_1_4" and true
571 // with "GL_VERSION_1_5".
572 if ( (this->GetProcAddress("glPointParameteri") == 0)
573 || (this->GetProcAddress("glPointParameteriv") == 0) )
574 {
575 return 0;
576 }
577
578 // Workaround for a bug on renderer string="Quadro4 900 XGL/AGP/SSE2"
579 // version string="1.5.8 NVIDIA 96.43.01" or "1.5.6 NVIDIA 87.56"
580 // The driver reports it supports 1.5 but the 1.4 core promoted extension
581 // GL_EXT_blend_func_separate is implemented in software (poor performance).
582 // All the NV2x chipsets are probably affected. NV2x chipsets are used
583 // in GeForce4 and Quadro4.
584 // It will make this method return false with "GL_VERSION_1_4" and true
585 // with "GL_VERSION_1_5".
586 if ( result && (this->DriverGLRendererHasToken("Quadro4")
587 || this->DriverGLRendererHasToken("GeForce4")) )
588 {
589 return 0;
590 }
591 }
592
593 // Workaround for a bug on renderer string="ATI Radeon X1600 OpenGL Engine"
594 // version string="2.0 ATI-1.4.58" vendor string="ATI Technologies Inc."
595 // It happens on a Apple iMac Intel Core Duo (early 2006) with Mac OS X
596 // 10.4.11 (Tiger) and an ATI Radeon X1600 128MB.
597
598 // The driver reports it supports 2.0 (where GL_ARB_texture_non_power_of_two
599 // extension has been promoted to core) and that it supports extension
600 // GL_ARB_texture_non_power_of_two. Reality is that non power of two
601 // textures just don't work in this OS/driver/card.
602
603 // It will make this method returns false with "GL_VERSION_2_0" and true
604 // with "GL_VERSION_2_1".
605 // It will make this method returns false with
606 // "GL_ARB_texture_non_power_of_two".
607 if ( this->DriverIsATI()
608 && this->DriverVersionIs(1,4,58) && this->DriverGLVersionIs(2,0)
609 && this->DriverGLRendererIs("ATI Radeon X1600 OpenGL Engine")
610 && ((strcmp(name,"GL_VERSION_2_0") == 0)
611 || (strcmp(name, "GL_ARB_texture_non_power_of_two") == 0)))
612 {
613 return 0;
614 }
615
616 // Workaround for a bug in Mesa 7.7 with separate specular color. The
617 // GL_EXT_separate_specular_color extension does not work properly with
618 // Mesa prior to version 7.10. If the user is requesting the separate
619 // specular color extension and the renderer is mesa and the mesa version
620 // is less than 7.10 we report that the platform does not support it.
621 if ( (strcmp(name,"GL_EXT_separate_specular_color") == 0)
622 && this->DriverIsMesa() && !this->DriverVersionAtLeast(7,10) )
623 {
624 return 0;
625 }
626
627 // Workaround for a bug in OS Mesa's pre 8.0 FBO implementation.
628 if ( (strcmp(name,"GL_EXT_framebuffer_object")==0)
629 && this->DriverGLRendererIsOSMesa() && !this->DriverVersionAtLeast(8) )
630 {
631 return 0;
632 }
633
634 // feature is suppported
635 return 1;
636 }
637
638 vtkOpenGLExtensionManagerFunctionPointer
GetProcAddress(const char * fname)639 vtkOpenGLExtensionManager::GetProcAddress(const char *fname)
640 {
641 vtkDebugMacro(<< "Trying to load OpenGL function " << fname);
642
643 #ifdef VTK_USE_WGL_GET_PROC_ADDRESS
644 return reinterpret_cast<vtkOpenGLExtensionManagerFunctionPointer>(wglGetProcAddress(fname));
645 #endif //VTK_USE_WGL_GET_PROC_ADDRESS
646
647 #ifdef VTK_USE_APPLE_LOADER
648
649 void* globalsymbolobject = dlopen(NULL, RTLD_GLOBAL);
650 if (globalsymbolobject)
651 {
652 void* dlsymbol = dlsym(globalsymbolobject, fname);
653 dlclose(globalsymbolobject);
654 if (!dlsymbol)
655 {
656 vtkDebugMacro("Could not load " << fname);
657 }
658 return (vtkOpenGLExtensionManagerFunctionPointer)(dlsymbol);
659 }
660 else
661 {
662 vtkDebugMacro("Could not load " << fname);
663 return NULL;
664 }
665 #endif //VTK_USE_APPLE_LOADER
666
667 #ifdef VTK_USE_OSMESA_GET_PROC_ADDRESS
668 return reinterpret_cast<vtkOpenGLExtensionManagerFunctionPointer>(OSMesaGetProcAddress(fname));
669 #endif
670
671 #ifdef VTK_USE_X
672 #ifdef VTK_USE_GLX_GET_PROC_ADDRESS
673 // In a perfect world, it should be
674 // return static_cast<vtkOpenGLExtensionManagerFunctionPointer>(glXGetProcAddress(reinterpret_cast<const GLubyte *>(fname)));
675 // but glx.h of Solaris 10 has line 209 wrong: it is
676 // extern void (*glXGetProcAddress(const GLubyte *procname))();
677 // when it should be:
678 // extern void (*glXGetProcAddress(const GLubyte *procname))(void);
679 return reinterpret_cast<vtkOpenGLExtensionManagerFunctionPointer>(glXGetProcAddress(reinterpret_cast<const GLubyte *>(fname)));
680 #endif //VTK_USE_GLX_GET_PROC_ADDRESS
681 #ifdef VTK_USE_GLX_GET_PROC_ADDRESS_ARB
682 return reinterpret_cast<vtkOpenGLExtensionManagerFunctionPointer>(glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(fname)));
683 #endif //VTK_USE_GLX_GET_PROC_ADDRESS_ARB
684 #endif
685
686 #ifdef VTK_USE_VTK_DYNAMIC_LOADER
687 // If the GLX implementation cannot load procedures for us, load them
688 // directly from the dynamic libraries.
689 static std::list<std::string> ogl_libraries;
690
691 if (ogl_libraries.empty())
692 {
693 const char *ext = vtkDynamicLoader::LibExtension();
694 std::string::size_type ext_size = strlen(ext);
695 // Must be the first function we tried to load. Fill this list with
696 // the OpenGL libraries we linked against.
697 std::string l(OPENGL_LIBRARIES);
698 std::string::size_type filename_start = 0;
699 while (1)
700 {
701 std::string::size_type filename_end = l.find(';', filename_start);
702 if (filename_end == std::string::npos)
703 {
704 break;
705 }
706 std::string possible_file = l.substr(filename_start,
707 filename_end-filename_start);
708 // Make sure this is actually a library. Do this by making sure it
709 // has an appropriate extension. This is by no means definitive, but
710 // it1 should do.
711 if ((possible_file.length() > ext_size)
712 && (possible_file.substr(possible_file.length()-ext_size) == ext))
713 {
714 ogl_libraries.push_back(possible_file);
715 }
716
717 filename_start = filename_end + 1;
718 }
719 }
720
721 // Look for the function in each library.
722 for (std::list<std::string>::iterator i = ogl_libraries.begin();
723 i != ogl_libraries.end(); i++)
724 {
725 vtkLibHandle lh = vtkDynamicLoader::OpenLibrary((*i).c_str());
726 void *f = vtkDynamicLoader::GetSymbolAddress(lh, fname);
727 vtkDynamicLoader::CloseLibrary(lh);
728 if (f) return (vtkOpenGLExtensionManagerFunctionPointer)f;
729 }
730
731 // Could not find the function.
732 return NULL;
733 #endif //VTK_USE_VTK_DYNAMIC_LOADER
734
735 #ifdef VTK_OPENGL_HAS_OSMESA
736 return static_cast<vtkOpenGLExtensionManagerFunctionPointer>(
737 OSMesaGetProcAddress(fname));
738 #endif
739
740 #ifdef VTK_NO_EXTENSION_LOADING
741 return NULL;
742 #endif //VTK_NO_EXTENSION_LOADING
743 }
744
LoadExtension(const char * name)745 void vtkOpenGLExtensionManager::LoadExtension(const char *name)
746 {
747 if (!this->ExtensionSupported(name))
748 {
749 vtkWarningMacro("Attempting to load " << name
750 << ", which is not supported.");
751 }
752
753 int success = this->SafeLoadExtension(name);
754
755 if (!success)
756 {
757 vtkErrorMacro("Extension " << name << " could not be loaded.");
758 }
759 }
760
LoadSupportedExtension(const char * name)761 int vtkOpenGLExtensionManager::LoadSupportedExtension(const char *name)
762 {
763 int supported = this->ExtensionSupported(name);
764 int loaded = supported ? this->SafeLoadExtension(name) : 0;
765
766 vtkDebugMacro(
767 << "vtkOpenGLExtensionManager::LoadSupportedExtension" << endl
768 << " name: " << name << endl
769 << " supported: " << supported << endl
770 << " loaded: " << loaded << endl
771 );
772
773 return supported && loaded;
774 }
775
LoadCorePromotedExtension(const char * name)776 void vtkOpenGLExtensionManager::LoadCorePromotedExtension(const char *name)
777 {
778 if (!this->ExtensionSupported(name))
779 {
780 vtkWarningMacro("Attempting to load " << name
781 << ", which is not supported.");
782 }
783 int success = vtkgl::LoadCorePromotedExtension(name, this);
784
785 if (!success)
786 {
787 vtkErrorMacro("Extension " << name << " could not be loaded.");
788 }
789 }
790
LoadAsARBExtension(const char * name)791 void vtkOpenGLExtensionManager::LoadAsARBExtension(const char *name)
792 {
793 if (!this->ExtensionSupported(name))
794 {
795 vtkWarningMacro("Attempting to load " << name
796 << ", which is not supported.");
797 }
798 int success = vtkgl::LoadAsARBExtension(name, this);
799
800 if (!success)
801 {
802 vtkErrorMacro("Extension " << name << " could not be loaded.");
803 }
804 }
805
ReadOpenGLExtensions()806 void vtkOpenGLExtensionManager::ReadOpenGLExtensions()
807 {
808 vtkDebugMacro("ReadOpenGLExtensions");
809
810 #ifdef VTK_NO_EXTENSION_LOADING
811
812 this->ExtensionsString = new char[1];
813 this->ExtensionsString[0] = '\0';
814 return;
815
816 #else //!VTK_NO_EXTENSION_LOADING
817
818 if (this->RenderWindow)
819 {
820 if (!this->RenderWindow->IsA("vtkOpenGLRenderWindow"))
821 {
822 // If the render window is not OpenGL, then it obviously has no
823 // extensions.
824 delete [] this->ExtensionsString;
825 this->ExtensionsString = new char[1];
826 this->ExtensionsString[0] = '\0';
827 return;
828 }
829 this->RenderWindow->MakeCurrent();
830 if (!this->RenderWindow->IsCurrent())
831 {
832 // Really should create a method in the render window to create
833 // the graphics context instead of forcing a full render.
834 this->RenderWindow->Render();
835 }
836 if (!this->RenderWindow->IsCurrent())
837 {
838 // this case happens with a headless Mac: a mac with a graphics card
839 // with no monitor attached to it, connected to it with "Screen Sharing"
840 // (VNC-like feature added in Mac OS 10.5)
841 // see bug 8554.
842 delete [] this->ExtensionsString;
843 this->ExtensionsString = new char[1];
844 this->ExtensionsString[0] = '\0';
845 return;
846 }
847 }
848
849 const char *gl_extensions;
850 const char *glu_extensions = "";
851 const char *win_extensions = "";
852
853 gl_extensions = reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS));
854
855 if (gl_extensions == NULL)
856 {
857 gl_extensions = "";
858 }
859
860 if (!this->RenderWindow && (gl_extensions[0] == '\0'))
861 {
862 vtkDebugMacro("No window active? Attaching default render window.");
863 vtkRenderWindow *renwin = vtkRenderWindow::New();
864 renwin->SetSize(1, 1);
865 this->SetRenderWindow(renwin);
866 renwin->Register(this);
867 this->OwnRenderWindow = 1;
868 renwin->Delete();
869 this->ReadOpenGLExtensions();
870 return;
871 }
872
873 std::string extensions_string = gl_extensions;
874
875 #if GLU_SUPPORTED
876 glu_extensions =
877 reinterpret_cast<const char *>(gluGetString(GLU_EXTENSIONS));
878 #endif
879 if (glu_extensions)
880 {
881 extensions_string += " ";
882 extensions_string += glu_extensions;
883 }
884
885 #if defined(WIN32)
886 // Don't use this->LoadExtension or we will go into an infinite loop.
887 vtkgl::LoadExtension("WGL_ARB_extensions_string", this);
888 if (vtkwgl::GetExtensionsStringARB)
889 {
890 win_extensions = vtkwgl::GetExtensionsStringARB(wglGetCurrentDC());
891 }
892 else
893 {
894 //vtkWarningMacro("Could not query WGL extensions.");
895 win_extensions = "";
896 }
897 #elif defined(__APPLE__)
898 // vtkWarningMacro("Does APPLE have a windows extension string?");
899 win_extensions = "";
900 #elif defined(VTK_USE_X)
901 win_extensions = glXGetClientString(glXGetCurrentDisplay(),
902 GLX_EXTENSIONS);
903 #endif
904
905 if (win_extensions && win_extensions[0] != '\0')
906 {
907 extensions_string += " ";
908 extensions_string += win_extensions;
909 }
910
911 // We build special extension identifiers for OpenGL versions. Check to
912 // see which are supported.
913 std::string version_extensions;
914 std::string::size_type beginpos, endpos;
915
916 const char *version =
917 reinterpret_cast<const char *>(glGetString(GL_VERSION));
918 int driverMajor = 0;
919 int driverMinor = 0;
920 sscanf(version, "%d.%d", &driverMajor, &driverMinor);
921
922 version_extensions = vtkgl::GLVersionExtensionsString();
923 endpos = 0;
924 while (endpos != std::string::npos)
925 {
926 beginpos = version_extensions.find_first_not_of(' ', endpos);
927 if (beginpos == std::string::npos) break;
928 endpos = version_extensions.find_first_of(' ', beginpos);
929
930 std::string ve = version_extensions.substr(beginpos, endpos-beginpos);
931 int tryMajor, tryMinor;
932 sscanf(ve.c_str(), "GL_VERSION_%d_%d", &tryMajor, &tryMinor);
933 if ( (driverMajor > tryMajor)
934 || ((driverMajor == tryMajor) && (driverMinor >= tryMinor)) )
935 {
936 // OpenGL version supported.
937 extensions_string += " ";
938 extensions_string += ve;
939 }
940 }
941
942 #ifdef VTK_USE_X
943 Display *display = NULL;
944 int closeDisplay = 0;
945 if (this->RenderWindow)
946 {
947 // Try getting the display of the window we are doing the queries on.
948 display =
949 static_cast<Display *>(this->RenderWindow->GetGenericDisplayId());
950 }
951 if (!display)
952 {
953 // Try opening my own display.
954 display = XOpenDisplay(NULL);
955 closeDisplay = 1;
956 }
957
958 if (!display)
959 {
960 // If we could not find a display, silently fail to query the glX
961 // extensions. It could be that there is no glX (for example if using Mesa
962 // offscreen).
963 vtkDebugMacro(<< "Could not get a Display to query GLX extensions.");
964 }
965 else
966 {
967 glXQueryExtension(display, &driverMajor, &driverMinor);
968
969 version_extensions = vtkgl::GLXVersionExtensionsString();
970 endpos = 0;
971 while (endpos != std::string::npos)
972 {
973 beginpos = version_extensions.find_first_not_of(' ', endpos);
974 if (beginpos == std::string::npos) break;
975 endpos = version_extensions.find_first_of(' ', beginpos);
976
977 std::string ve = version_extensions.substr(beginpos, endpos-beginpos);
978 int tryMajor, tryMinor;
979 sscanf(ve.c_str(), "GLX_VERSION_%d_%d", &tryMajor, &tryMinor);
980 if ( (driverMajor > tryMajor)
981 || ((driverMajor == tryMajor) && (driverMinor >= tryMinor)) )
982 {
983 extensions_string += " ";
984 extensions_string += ve;
985 }
986 }
987
988 if (closeDisplay)
989 {
990 XCloseDisplay(display);
991 }
992 }
993 #endif //VTK_USE_X
994
995 // Store extensions string.
996 delete [] this->ExtensionsString;
997 this->ExtensionsString = new char[extensions_string.length()+1];
998 strcpy(this->ExtensionsString, extensions_string.c_str());
999
1000 #endif //!VTK_NO_EXTENSION_LOADING
1001 }
1002
1003 // ----------------------------------------------------------------------------
1004 // Description:
1005 // Wrap around the generated vtkgl::LoadExtension to deal with OpenGL 1.2
1006 // and its optional part GL_ARB_imaging. Also functions like glBlendEquation()
1007 // or glBlendColor are optional in OpenGL 1.2 or 1.3 and provided by the
1008 // GL_ARB_imaging but there are core features in OpenGL 1.4.
SafeLoadExtension(const char * name)1009 int vtkOpenGLExtensionManager::SafeLoadExtension(const char *name)
1010 {
1011 if (strcmp(name, "GL_VERSION_1_2") == 0)
1012 {
1013 vtkgl::DrawRangeElements = reinterpret_cast<vtkgl::PFNGLDRAWRANGEELEMENTSPROC>(this->GetProcAddress("glDrawRangeElements"));
1014 vtkgl::TexImage3D = reinterpret_cast<vtkgl::PFNGLTEXIMAGE3DPROC>(this->GetProcAddress("glTexImage3D"));
1015 vtkgl::TexSubImage3D = reinterpret_cast<vtkgl::PFNGLTEXSUBIMAGE3DPROC>(this->GetProcAddress("glTexSubImage3D"));
1016 vtkgl::CopyTexSubImage3D = reinterpret_cast<vtkgl::PFNGLCOPYTEXSUBIMAGE3DPROC>(this->GetProcAddress("glCopyTexSubImage3D"));
1017
1018 // rely on the generated function for most of the OpenGL 1.2 functions.
1019 int success = vtkgl::LoadExtension(name, this);
1020 success = success && vtkgl::LoadExtension("GL_VERSION_1_2_DEPRECATED", this);
1021
1022 return success && (vtkgl::DrawRangeElements != NULL) && (vtkgl::TexImage3D != NULL) && (vtkgl::TexSubImage3D != NULL) && (vtkgl::CopyTexSubImage3D != NULL);
1023 }
1024 if (strcmp(name, "GL_ARB_imaging") == 0)
1025 {
1026 vtkgl::BlendColor = reinterpret_cast<vtkgl::PFNGLBLENDCOLORPROC>(this->GetProcAddress("glBlendColor"));
1027 vtkgl::BlendEquation = reinterpret_cast<vtkgl::PFNGLBLENDEQUATIONPROC>(this->GetProcAddress("glBlendEquation"));
1028 vtkgl::ColorTable = reinterpret_cast<vtkgl::PFNGLCOLORTABLEPROC>(this->GetProcAddress("glColorTable"));
1029 vtkgl::ColorTableParameterfv = reinterpret_cast<vtkgl::PFNGLCOLORTABLEPARAMETERFVPROC>(this->GetProcAddress("glColorTableParameterfv"));
1030 vtkgl::ColorTableParameteriv = reinterpret_cast<vtkgl::PFNGLCOLORTABLEPARAMETERIVPROC>(this->GetProcAddress("glColorTableParameteriv"));
1031 vtkgl::CopyColorTable = reinterpret_cast<vtkgl::PFNGLCOPYCOLORTABLEPROC>(this->GetProcAddress("glCopyColorTable"));
1032 vtkgl::GetColorTable = reinterpret_cast<vtkgl::PFNGLGETCOLORTABLEPROC>(this->GetProcAddress("glGetColorTable"));
1033 vtkgl::GetColorTableParameterfv = reinterpret_cast<vtkgl::PFNGLGETCOLORTABLEPARAMETERFVPROC>(this->GetProcAddress("glGetColorTableParameterfv"));
1034 vtkgl::GetColorTableParameteriv = reinterpret_cast<vtkgl::PFNGLGETCOLORTABLEPARAMETERIVPROC>(this->GetProcAddress("glGetColorTableParameteriv"));
1035 vtkgl::ColorSubTable = reinterpret_cast<vtkgl::PFNGLCOLORSUBTABLEPROC>(this->GetProcAddress("glColorSubTable"));
1036 vtkgl::CopyColorSubTable = reinterpret_cast<vtkgl::PFNGLCOPYCOLORSUBTABLEPROC>(this->GetProcAddress("glCopyColorSubTable"));
1037 vtkgl::ConvolutionFilter1D = reinterpret_cast<vtkgl::PFNGLCONVOLUTIONFILTER1DPROC>(this->GetProcAddress("glConvolutionFilter1D"));
1038 vtkgl::ConvolutionFilter2D = reinterpret_cast<vtkgl::PFNGLCONVOLUTIONFILTER2DPROC>(this->GetProcAddress("glConvolutionFilter2D"));
1039 vtkgl::ConvolutionParameterf = reinterpret_cast<vtkgl::PFNGLCONVOLUTIONPARAMETERFPROC>(this->GetProcAddress("glConvolutionParameterf"));
1040 vtkgl::ConvolutionParameterfv = reinterpret_cast<vtkgl::PFNGLCONVOLUTIONPARAMETERFVPROC>(this->GetProcAddress("glConvolutionParameterfv"));
1041 vtkgl::ConvolutionParameteri = reinterpret_cast<vtkgl::PFNGLCONVOLUTIONPARAMETERIPROC>(this->GetProcAddress("glConvolutionParameteri"));
1042 vtkgl::ConvolutionParameteriv = reinterpret_cast<vtkgl::PFNGLCONVOLUTIONPARAMETERIVPROC>(this->GetProcAddress("glConvolutionParameteriv"));
1043 vtkgl::CopyConvolutionFilter1D = reinterpret_cast<vtkgl::PFNGLCOPYCONVOLUTIONFILTER1DPROC>(this->GetProcAddress("glCopyConvolutionFilter1D"));
1044 vtkgl::CopyConvolutionFilter2D = reinterpret_cast<vtkgl::PFNGLCOPYCONVOLUTIONFILTER2DPROC>(this->GetProcAddress("glCopyConvolutionFilter2D"));
1045 vtkgl::GetConvolutionFilter = reinterpret_cast<vtkgl::PFNGLGETCONVOLUTIONFILTERPROC>(this->GetProcAddress("glGetConvolutionFilter"));
1046 vtkgl::GetConvolutionParameterfv = reinterpret_cast<vtkgl::PFNGLGETCONVOLUTIONPARAMETERFVPROC>(this->GetProcAddress("glGetConvolutionParameterfv"));
1047 vtkgl::GetConvolutionParameteriv = reinterpret_cast<vtkgl::PFNGLGETCONVOLUTIONPARAMETERIVPROC>(this->GetProcAddress("glGetConvolutionParameteriv"));
1048 vtkgl::GetSeparableFilter = reinterpret_cast<vtkgl::PFNGLGETSEPARABLEFILTERPROC>(this->GetProcAddress("glGetSeparableFilter"));
1049 vtkgl::SeparableFilter2D = reinterpret_cast<vtkgl::PFNGLSEPARABLEFILTER2DPROC>(this->GetProcAddress("glSeparableFilter2D"));
1050 vtkgl::GetHistogram = reinterpret_cast<vtkgl::PFNGLGETHISTOGRAMPROC>(this->GetProcAddress("glGetHistogram"));
1051 vtkgl::GetHistogramParameterfv = reinterpret_cast<vtkgl::PFNGLGETHISTOGRAMPARAMETERFVPROC>(this->GetProcAddress("glGetHistogramParameterfv"));
1052 vtkgl::GetHistogramParameteriv = reinterpret_cast<vtkgl::PFNGLGETHISTOGRAMPARAMETERIVPROC>(this->GetProcAddress("glGetHistogramParameteriv"));
1053 vtkgl::GetMinmax = reinterpret_cast<vtkgl::PFNGLGETMINMAXPROC>(this->GetProcAddress("glGetMinmax"));
1054 vtkgl::GetMinmaxParameterfv = reinterpret_cast<vtkgl::PFNGLGETMINMAXPARAMETERFVPROC>(this->GetProcAddress("glGetMinmaxParameterfv"));
1055 vtkgl::GetMinmaxParameteriv = reinterpret_cast<vtkgl::PFNGLGETMINMAXPARAMETERIVPROC>(this->GetProcAddress("glGetMinmaxParameteriv"));
1056 vtkgl::Histogram = reinterpret_cast<vtkgl::PFNGLHISTOGRAMPROC>(this->GetProcAddress("glHistogram"));
1057 vtkgl::Minmax = reinterpret_cast<vtkgl::PFNGLMINMAXPROC>(this->GetProcAddress("glMinmax"));
1058 vtkgl::ResetHistogram = reinterpret_cast<vtkgl::PFNGLRESETHISTOGRAMPROC>(this->GetProcAddress("glResetHistogram"));
1059 vtkgl::ResetMinmax = reinterpret_cast<vtkgl::PFNGLRESETMINMAXPROC>(this->GetProcAddress("glResetMinmax"));
1060 return (vtkgl::BlendColor != NULL) && (vtkgl::BlendEquation != NULL) && (vtkgl::ColorTable != NULL) && (vtkgl::ColorTableParameterfv != NULL) && (vtkgl::ColorTableParameteriv != NULL) && (vtkgl::CopyColorTable != NULL) && (vtkgl::GetColorTable != NULL) && (vtkgl::GetColorTableParameterfv != NULL) && (vtkgl::GetColorTableParameteriv != NULL) && (vtkgl::ColorSubTable != NULL) && (vtkgl::CopyColorSubTable != NULL) && (vtkgl::ConvolutionFilter1D != NULL) && (vtkgl::ConvolutionFilter2D != NULL) && (vtkgl::ConvolutionParameterf != NULL) && (vtkgl::ConvolutionParameterfv != NULL) && (vtkgl::ConvolutionParameteri != NULL) && (vtkgl::ConvolutionParameteriv != NULL) && (vtkgl::CopyConvolutionFilter1D != NULL) && (vtkgl::CopyConvolutionFilter2D != NULL) && (vtkgl::GetConvolutionFilter != NULL) && (vtkgl::GetConvolutionParameterfv != NULL) && (vtkgl::GetConvolutionParameteriv != NULL) && (vtkgl::GetSeparableFilter != NULL) && (vtkgl::SeparableFilter2D != NULL) && (vtkgl::GetHistogram != NULL) && (vtkgl::GetHistogramParameterfv != NULL) && (vtkgl::GetHistogramParameteriv != NULL) && (vtkgl::GetMinmax != NULL) && (vtkgl::GetMinmaxParameterfv != NULL) && (vtkgl::GetMinmaxParameteriv != NULL) && (vtkgl::Histogram != NULL) && (vtkgl::Minmax != NULL) && (vtkgl::ResetHistogram != NULL) && (vtkgl::ResetMinmax != NULL);
1061 }
1062
1063 if (strcmp(name, "GL_VERSION_1_3") == 0)
1064 {
1065 int success = vtkgl::LoadExtension(name, this);
1066 return success && vtkgl::LoadExtension("GL_VERSION_1_3_DEPRECATED", this);
1067 }
1068
1069 if (strcmp(name, "GL_ARB_fragment_program") == 0)
1070 {
1071 // fragment_program is loaded as part of vertex_program
1072 int success = vtkgl::LoadExtension("GL_ARB_vertex_program", this);
1073 return success && vtkgl::LoadExtension(name, this);
1074 }
1075
1076 if (strcmp(name, "GL_VERSION_1_4") == 0)
1077 {
1078 // rely on the generated function for most of the OpenGL 1.4 functions.
1079 int success = vtkgl::LoadExtension(name, this);
1080 success = success && vtkgl::LoadExtension("GL_VERSION_1_4_DEPRECATED", this);
1081
1082 // The following functions that used to be optional in OpenGL 1.2 and 1.3
1083 // and only available through GL_ARB_imaging are now core features in
1084 // OpenGL 1.4.
1085 // See Appendix G.3 Changes to the imaging Subset.
1086 vtkgl::BlendColor = reinterpret_cast<vtkgl::PFNGLBLENDCOLORPROC>(this->GetProcAddress("glBlendColor"));
1087 vtkgl::BlendEquation = reinterpret_cast<vtkgl::PFNGLBLENDEQUATIONPROC>(this->GetProcAddress("glBlendEquation"));
1088 return success && (vtkgl::BlendColor != NULL) && (vtkgl::BlendEquation != NULL);
1089 }
1090 if (strcmp(name, "GL_VERSION_1_5") == 0)
1091 {
1092 int success = vtkgl::LoadExtension(name, this);
1093 return success && vtkgl::LoadExtension("GL_VERSION_1_5_DEPRECATED", this);
1094 }
1095 if (strcmp(name, "GL_VERSION_2_0") == 0)
1096 {
1097 int success = vtkgl::LoadExtension(name, this);
1098 return success && vtkgl::LoadExtension("GL_VERSION_2_0_DEPRECATED", this);
1099 }
1100 if (strcmp(name, "GL_VERSION_2_1") == 0)
1101 {
1102 int success = vtkgl::LoadExtension(name, this);
1103 return success && vtkgl::LoadExtension("GL_VERSION_2_1_DEPRECATED", this);
1104 }
1105 if (strcmp(name, "GL_VERSION_3_0") == 0)
1106 {
1107 int success = vtkgl::LoadExtension(name, this);
1108 return success && vtkgl::LoadExtension("GL_VERSION_3_0_DEPRECATED", this);
1109 }
1110 if (strcmp(name, "GL_ARB_framebuffer_object") == 0)
1111 {
1112 int success = vtkgl::LoadExtension(name, this);
1113 return success &&
1114 vtkgl::LoadExtension("GL_ARB_framebuffer_object_DEPRECATED", this);
1115 }
1116
1117 // For all other cases, rely on the generated function.
1118 int result = vtkgl::LoadExtension(name, this);
1119 return result;
1120 }
1121
1122 // Those two functions are part of OpenGL2.0 but don't have direct
1123 // translation in the GL_ARB_shader_objects extension
IsProgramFromARBToPromoted(GLuint program)1124 static GLboolean IsProgramFromARBToPromoted(GLuint program)
1125 {
1126 GLint param;
1127 // in this case, vtkgl::GetProgramiv has been initialized with the pointer to
1128 // "GetObjectParameterivARB" by LoadCorePromotedExtension()
1129 // but vtkgl::GetObjectParameterivARB hasn't been initialized.
1130 vtkgl::GetProgramiv(program, vtkgl::OBJECT_TYPE_ARB, ¶m);
1131 return param == static_cast<GLint>(vtkgl::PROGRAM_OBJECT_ARB);
1132 }
1133
IsShaderFromARBToPromoted(GLuint shader)1134 static GLboolean IsShaderFromARBToPromoted(GLuint shader)
1135 {
1136 GLint param;
1137 // in this case, vtkgl::GetShaderiv has been initialized with the pointer to
1138 // "GetObjectParameterivARB" by LoadCorePromotedExtension()
1139 // but vtkgl::GetObjectParameterivARB hasn't been initialized.
1140 vtkgl::GetShaderiv(shader, vtkgl::OBJECT_TYPE_ARB, ¶m);
1141 return param == static_cast<GLint>(vtkgl::SHADER_OBJECT_ARB);
1142 }
1143
1144 // This function was implemented in the following way:
1145 // 1. Compile VTK in a build directory in order to generate Rendering/vtkgl.h
1146 // from glext.h, glxext.h and wglext.h
1147 // 2. From the OpenGL specification 2.1
1148 // ( http://www.opengl.org/registry/doc/glspec21.20061201.pdf ), go through
1149 // Appendix C to Appendix J to identify the extensions promoted as core OpenGL
1150 // features and in which version of OpenGL.
1151
1152 // For instance, for OpenGL 1.5 extensions, look for GL_VERSION_1_5 section.
1153 // Each section is divided into three parts: the first part defines macros
1154 // (const GLenum ....)
1155 // the second part defines function pointer types (typedef ...) .
1156 // the third part defines the function pointers.
1157
1158 // 3. Copy the function pointers part into this file.
1159 // Group function pointers by extensions by looking at the Appendix in the
1160 // OpenGL specifications and the description of the extension in the
1161 // OpenGL extension registry at http://www.opengl.org/registry.
1162
1163 // 4. For each function pointer, get the address of the function defined in the
1164 // extension and cast it as a core function pointer.
1165
LoadCorePromotedExtension(const char * name,vtkOpenGLExtensionManager * manager)1166 int vtkgl::LoadCorePromotedExtension(const char *name,
1167 vtkOpenGLExtensionManager *manager)
1168 {
1169 assert("pre: name_exists" && name!=NULL);
1170 assert("pre: manager_exists" && manager!=NULL);
1171
1172 // OpenGL 1.1
1173
1174 // VTK supports at least OpenGL 1.1. There is no need to load promoted
1175 // extensions GL_EXT_subtexture and GL_EXT_copy_texture.
1176 // Just silently returns 1.
1177
1178 if (strcmp(name, "GL_EXT_subtexture") == 0)
1179 {
1180 // GL_EXT_subtexture defines glTexSubImage1D and glTexSubImage2D()
1181 return 1;
1182 }
1183 if (strcmp(name, "GL_EXT_copy_texture") == 0)
1184 {
1185 // GL_EXT_copy_texture defines glCopyTexImage1D(), glCopyTexImage2D(),
1186 // glCopyTexSubImage1D()
1187 // and glCopyTexSubImage2D().
1188 // if both GL_EXT_copy_texture and GL_EXT_texture3D are supported,
1189 // it also defines vtkgl::CopyTexSubImage3D but we postpone that
1190 // in the GL_EXT_texture3D section.
1191 return 1;
1192 }
1193
1194 // OpenGL 1.2
1195 if (strcmp(name, "GL_EXT_texture3D") == 0)
1196 {
1197 vtkgl::TexImage3D = reinterpret_cast<vtkgl::PFNGLTEXIMAGE3DPROC>(manager->GetProcAddress("glTexImage3DEXT"));
1198 vtkgl::TexSubImage3D = reinterpret_cast<vtkgl::PFNGLTEXSUBIMAGE3DPROC>(manager->GetProcAddress("glTexSubImage3DEXT"));
1199 vtkgl::CopyTexSubImage3D = reinterpret_cast<vtkgl::PFNGLCOPYTEXSUBIMAGE3DPROC>(manager->GetProcAddress("glCopyTexSubImage3DEXT"));
1200 return 1 && (vtkgl::TexImage3D != NULL) && (vtkgl::TexSubImage3D != NULL)
1201 && (vtkgl::CopyTexSubImage3D != NULL);
1202 }
1203
1204 if (strcmp(name, "GL_EXT_bgra") == 0)
1205 {
1206 return 1;
1207 }
1208 if (strcmp(name, "GL_EXT_packed_pixels") == 0)
1209 {
1210 return 1;
1211 }
1212 if (strcmp(name, "GL_EXT_rescale_normal") == 0)
1213 {
1214 return 1;
1215 }
1216 if (strcmp(name, "GL_EXT_separate_specular_color") == 0)
1217 {
1218 return 1;
1219 }
1220 if (strcmp(name, "GL_SGIS_texture_edge_clamp") == 0)
1221 {
1222 return 1;
1223 }
1224 if (strcmp(name, "GL_EXT_draw_range_elements") == 0)
1225 {
1226 vtkgl::DrawRangeElements = reinterpret_cast<vtkgl::PFNGLDRAWRANGEELEMENTSPROC>(manager->GetProcAddress("glDrawRangeElementsEXT"));
1227 return 1 && (vtkgl::DrawRangeElements != NULL);
1228 }
1229
1230 if (strcmp(name, "GL_SGI_color_table") == 0)
1231 {
1232 // OpenGL Spec talks about GL_EXT_color_table but reality is
1233 // GL_SGI_color_table is used. Also GL_EXT_color_table is not listed
1234 // on the registry website.
1235 vtkgl::ColorTable = reinterpret_cast<vtkgl::PFNGLCOLORTABLESGIPROC>(manager->GetProcAddress("glColorTableSGI"));
1236 vtkgl::ColorTableParameterfv = reinterpret_cast<vtkgl::PFNGLCOLORTABLEPARAMETERFVSGIPROC>(manager->GetProcAddress("glColorTableParameterfvSGI"));
1237 vtkgl::ColorTableParameteriv = reinterpret_cast<vtkgl::PFNGLCOLORTABLEPARAMETERIVSGIPROC>(manager->GetProcAddress("glColorTableParameterivSGI"));
1238 vtkgl::CopyColorTable = reinterpret_cast<vtkgl::PFNGLCOPYCOLORTABLESGIPROC>(manager->GetProcAddress("glCopyColorTableSGI"));
1239 vtkgl::GetColorTable = reinterpret_cast<vtkgl::PFNGLGETCOLORTABLESGIPROC>(manager->GetProcAddress("glGetColorTableSGI"));
1240 vtkgl::GetColorTableParameterfv = reinterpret_cast<vtkgl::PFNGLGETCOLORTABLEPARAMETERFVSGIPROC>(manager->GetProcAddress("glGetColorTableParameterfvSGI"));
1241 vtkgl::GetColorTableParameteriv = reinterpret_cast<vtkgl::PFNGLGETCOLORTABLEPARAMETERIVSGIPROC>(manager->GetProcAddress("glGetColorTableParameterivSGI"));
1242 return 1 && (vtkgl::ColorTable != NULL) && (vtkgl::ColorTableParameterfv != NULL) && (vtkgl::ColorTableParameteriv != NULL) && (vtkgl::CopyColorTable != NULL) && (vtkgl::GetColorTable != NULL) && (vtkgl::GetColorTableParameterfv != NULL) && (vtkgl::GetColorTableParameteriv != NULL);
1243 }
1244
1245 if (strcmp(name, "GL_EXT_color_subtable") == 0)
1246 {
1247 vtkgl::ColorSubTable = reinterpret_cast<vtkgl::PFNGLCOLORSUBTABLEPROC>(manager->GetProcAddress("glColorSubTableEXT"));
1248 vtkgl::CopyColorSubTable = reinterpret_cast<vtkgl::PFNGLCOPYCOLORSUBTABLEPROC>(manager->GetProcAddress("glCopyColorSubTableEXT"));
1249 return 1 && (vtkgl::ColorSubTable != NULL) && (vtkgl::CopyColorSubTable != NULL);
1250 }
1251
1252 if (strcmp(name, "GL_EXT_convolution") == 0)
1253 {
1254 vtkgl::ConvolutionFilter1D = reinterpret_cast<vtkgl::PFNGLCONVOLUTIONFILTER1DPROC>(manager->GetProcAddress("glConvolutionFilter1DEXT"));
1255 vtkgl::ConvolutionFilter2D = reinterpret_cast<vtkgl::PFNGLCONVOLUTIONFILTER2DPROC>(manager->GetProcAddress("glConvolutionFilter2DEXT"));
1256 vtkgl::ConvolutionParameterf = reinterpret_cast<vtkgl::PFNGLCONVOLUTIONPARAMETERFPROC>(manager->GetProcAddress("glConvolutionParameterfEXT"));
1257 vtkgl::ConvolutionParameterfv = reinterpret_cast<vtkgl::PFNGLCONVOLUTIONPARAMETERFVPROC>(manager->GetProcAddress("glConvolutionParameterfvEXT"));
1258 vtkgl::ConvolutionParameteri = reinterpret_cast<vtkgl::PFNGLCONVOLUTIONPARAMETERIPROC>(manager->GetProcAddress("glConvolutionParameteriEXT"));
1259 vtkgl::ConvolutionParameteriv = reinterpret_cast<vtkgl::PFNGLCONVOLUTIONPARAMETERIVPROC>(manager->GetProcAddress("glConvolutionParameterivEXT"));
1260 vtkgl::CopyConvolutionFilter1D = reinterpret_cast<vtkgl::PFNGLCOPYCONVOLUTIONFILTER1DPROC>(manager->GetProcAddress("glCopyConvolutionFilter1DEXT"));
1261 vtkgl::CopyConvolutionFilter2D = reinterpret_cast<vtkgl::PFNGLCOPYCONVOLUTIONFILTER2DPROC>(manager->GetProcAddress("glCopyConvolutionFilter2DEXT"));
1262 vtkgl::GetConvolutionFilter = reinterpret_cast<vtkgl::PFNGLGETCONVOLUTIONFILTERPROC>(manager->GetProcAddress("glGetConvolutionFilterEXT"));
1263 vtkgl::GetConvolutionParameterfv = reinterpret_cast<vtkgl::PFNGLGETCONVOLUTIONPARAMETERFVPROC>(manager->GetProcAddress("glGetConvolutionParameterfvEXT"));
1264 vtkgl::GetConvolutionParameteriv = reinterpret_cast<vtkgl::PFNGLGETCONVOLUTIONPARAMETERIVPROC>(manager->GetProcAddress("glGetConvolutionParameterivEXT"));
1265 vtkgl::GetSeparableFilter = reinterpret_cast<vtkgl::PFNGLGETSEPARABLEFILTERPROC>(manager->GetProcAddress("glGetSeparableFilterEXT"));
1266 vtkgl::SeparableFilter2D = reinterpret_cast<vtkgl::PFNGLSEPARABLEFILTER2DPROC>(manager->GetProcAddress("glSeparableFilter2DEXT"));
1267 return 1 && (vtkgl::ConvolutionFilter1D != NULL) && (vtkgl::ConvolutionFilter2D != NULL) && (vtkgl::ConvolutionParameterf != NULL) && (vtkgl::ConvolutionParameterfv != NULL) && (vtkgl::ConvolutionParameteri != NULL) && (vtkgl::ConvolutionParameteriv != NULL) && (vtkgl::CopyConvolutionFilter1D != NULL) && (vtkgl::CopyConvolutionFilter2D != NULL) && (vtkgl::GetConvolutionFilter != NULL) && (vtkgl::GetConvolutionParameterfv != NULL) && (vtkgl::GetConvolutionParameteriv != NULL) && (vtkgl::GetSeparableFilter != NULL) && (vtkgl::SeparableFilter2D != NULL);
1268 }
1269
1270 if (strcmp(name, "GL_HP_convolution_border_modes") == 0)
1271 {
1272 return 1;
1273 }
1274
1275 if (strcmp(name, "GL_SGI_color_matrix") == 0)
1276 {
1277 return 1;
1278 }
1279
1280 if (strcmp(name, "GL_EXT_histogram") == 0)
1281 {
1282 vtkgl::GetHistogram = reinterpret_cast<vtkgl::PFNGLGETHISTOGRAMPROC>(manager->GetProcAddress("glGetHistogramEXT"));
1283 vtkgl::GetHistogramParameterfv = reinterpret_cast<vtkgl::PFNGLGETHISTOGRAMPARAMETERFVPROC>(manager->GetProcAddress("glGetHistogramParameterfvEXT"));
1284 vtkgl::GetHistogramParameteriv = reinterpret_cast<vtkgl::PFNGLGETHISTOGRAMPARAMETERIVPROC>(manager->GetProcAddress("glGetHistogramParameterivEXT"));
1285 vtkgl::GetMinmax = reinterpret_cast<vtkgl::PFNGLGETMINMAXPROC>(manager->GetProcAddress("glGetMinmaxEXT"));
1286 vtkgl::GetMinmaxParameterfv = reinterpret_cast<vtkgl::PFNGLGETMINMAXPARAMETERFVPROC>(manager->GetProcAddress("glGetMinmaxParameterfvEXT"));
1287 vtkgl::GetMinmaxParameteriv = reinterpret_cast<vtkgl::PFNGLGETMINMAXPARAMETERIVPROC>(manager->GetProcAddress("glGetMinmaxParameterivEXT"));
1288 vtkgl::Histogram = reinterpret_cast<vtkgl::PFNGLHISTOGRAMPROC>(manager->GetProcAddress("glHistogramEXT"));
1289 vtkgl::Minmax = reinterpret_cast<vtkgl::PFNGLMINMAXPROC>(manager->GetProcAddress("glMinmaxEXT"));
1290 vtkgl::ResetHistogram = reinterpret_cast<vtkgl::PFNGLRESETHISTOGRAMPROC>(manager->GetProcAddress("glResetHistogramEXT"));
1291 vtkgl::ResetMinmax = reinterpret_cast<vtkgl::PFNGLRESETMINMAXPROC>(manager->GetProcAddress("glResetMinmaxEXT"));
1292 return 1 && (vtkgl::GetHistogram != NULL) && (vtkgl::GetHistogramParameterfv != NULL) && (vtkgl::GetHistogramParameteriv != NULL) && (vtkgl::GetMinmax != NULL) && (vtkgl::GetMinmaxParameterfv != NULL) && (vtkgl::GetMinmaxParameteriv != NULL) && (vtkgl::Histogram != NULL) && (vtkgl::Minmax != NULL) && (vtkgl::ResetHistogram != NULL) && (vtkgl::ResetMinmax != NULL);
1293 }
1294
1295 if (strcmp(name, "GL_EXT_blend_color") == 0)
1296 {
1297 vtkgl::BlendColor = reinterpret_cast<vtkgl::PFNGLBLENDCOLORPROC>(manager->GetProcAddress("glBlendColorEXT"));
1298 return 1 && (vtkgl::BlendColor != NULL);
1299 }
1300
1301 if (strcmp(name, "GL_EXT_blend_minmax") == 0)
1302 {
1303 vtkgl::BlendEquation = reinterpret_cast<vtkgl::PFNGLBLENDEQUATIONPROC>(manager->GetProcAddress("glBlendEquationEXT"));
1304 return 1 && (vtkgl::BlendEquation != NULL);
1305 }
1306 if (strcmp(name, "GL_EXT_blend_subtract") == 0)
1307 {
1308 return 1;
1309 }
1310
1311 // OpenGL 1.3
1312
1313 if (strcmp(name, "GL_ARB_texture_compression") == 0)
1314 {
1315 vtkgl::CompressedTexImage3D = reinterpret_cast<vtkgl::PFNGLCOMPRESSEDTEXIMAGE3DPROC>(manager->GetProcAddress("glCompressedTexImage3DARB"));
1316 vtkgl::CompressedTexImage2D = reinterpret_cast<vtkgl::PFNGLCOMPRESSEDTEXIMAGE2DPROC>(manager->GetProcAddress("glCompressedTexImage2DARB"));
1317 vtkgl::CompressedTexImage1D = reinterpret_cast<vtkgl::PFNGLCOMPRESSEDTEXIMAGE1DPROC>(manager->GetProcAddress("glCompressedTexImage1DARB"));
1318 vtkgl::CompressedTexSubImage3D = reinterpret_cast<vtkgl::PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC>(manager->GetProcAddress("glCompressedTexSubImage3DARB"));
1319 vtkgl::CompressedTexSubImage2D = reinterpret_cast<vtkgl::PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC>(manager->GetProcAddress("glCompressedTexSubImage2DARB"));
1320 vtkgl::CompressedTexSubImage1D = reinterpret_cast<vtkgl::PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC>(manager->GetProcAddress("glCompressedTexSubImage1DARB"));
1321 vtkgl::GetCompressedTexImage = reinterpret_cast<vtkgl::PFNGLGETCOMPRESSEDTEXIMAGEPROC>(manager->GetProcAddress("glGetCompressedTexImageARB"));
1322 return 1 && (vtkgl::CompressedTexImage3D != NULL) && (vtkgl::CompressedTexImage2D != NULL) && (vtkgl::CompressedTexImage1D != NULL) && (vtkgl::CompressedTexSubImage3D != NULL) && (vtkgl::CompressedTexSubImage2D != NULL) && (vtkgl::CompressedTexSubImage1D != NULL) && (vtkgl::GetCompressedTexImage != NULL);
1323 }
1324
1325 if (strcmp(name, "GL_ARB_texture_cube_map") == 0)
1326 {
1327 return 1;
1328 }
1329
1330 if (strcmp(name, "GL_ARB_multisample") == 0)
1331 {
1332 vtkgl::SampleCoverage = reinterpret_cast<vtkgl::PFNGLSAMPLECOVERAGEPROC>(manager->GetProcAddress("glSampleCoverageARB"));
1333 return 1 && (vtkgl::SampleCoverage != NULL);
1334 }
1335
1336 if (strcmp(name, "GL_ARB_multitexture") == 0)
1337 {
1338 vtkgl::ActiveTexture = reinterpret_cast<vtkgl::PFNGLACTIVETEXTUREPROC>(manager->GetProcAddress("glActiveTextureARB"));
1339 vtkgl::ClientActiveTexture = reinterpret_cast<vtkgl::PFNGLCLIENTACTIVETEXTUREPROC>(manager->GetProcAddress("glClientActiveTextureARB"));
1340 vtkgl::MultiTexCoord1d = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD1DPROC>(manager->GetProcAddress("glMultiTexCoord1dARB"));
1341 vtkgl::MultiTexCoord1dv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD1DVPROC>(manager->GetProcAddress("glMultiTexCoord1dvARB"));
1342 vtkgl::MultiTexCoord1f = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD1FPROC>(manager->GetProcAddress("glMultiTexCoord1fARB"));
1343 vtkgl::MultiTexCoord1fv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD1FVPROC>(manager->GetProcAddress("glMultiTexCoord1fvARB"));
1344 vtkgl::MultiTexCoord1i = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD1IPROC>(manager->GetProcAddress("glMultiTexCoord1iARB"));
1345 vtkgl::MultiTexCoord1iv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD1IVPROC>(manager->GetProcAddress("glMultiTexCoord1ivARB"));
1346 vtkgl::MultiTexCoord1s = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD1SPROC>(manager->GetProcAddress("glMultiTexCoord1sARB"));
1347 vtkgl::MultiTexCoord1sv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD1SVPROC>(manager->GetProcAddress("glMultiTexCoord1svARB"));
1348 vtkgl::MultiTexCoord2d = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD2DPROC>(manager->GetProcAddress("glMultiTexCoord2dARB"));
1349 vtkgl::MultiTexCoord2dv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD2DVPROC>(manager->GetProcAddress("glMultiTexCoord2dvARB"));
1350 vtkgl::MultiTexCoord2f = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD2FPROC>(manager->GetProcAddress("glMultiTexCoord2fARB"));
1351 vtkgl::MultiTexCoord2fv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD2FVPROC>(manager->GetProcAddress("glMultiTexCoord2fvARB"));
1352 vtkgl::MultiTexCoord2i = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD2IPROC>(manager->GetProcAddress("glMultiTexCoord2iARB"));
1353 vtkgl::MultiTexCoord2iv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD2IVPROC>(manager->GetProcAddress("glMultiTexCoord2ivARB"));
1354 vtkgl::MultiTexCoord2s = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD2SPROC>(manager->GetProcAddress("glMultiTexCoord2sARB"));
1355 vtkgl::MultiTexCoord2sv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD2SVPROC>(manager->GetProcAddress("glMultiTexCoord2svARB"));
1356 vtkgl::MultiTexCoord3d = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD3DPROC>(manager->GetProcAddress("glMultiTexCoord3dARB"));
1357 vtkgl::MultiTexCoord3dv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD3DVPROC>(manager->GetProcAddress("glMultiTexCoord3dvARB"));
1358 vtkgl::MultiTexCoord3f = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD3FPROC>(manager->GetProcAddress("glMultiTexCoord3fARB"));
1359 vtkgl::MultiTexCoord3fv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD3FVPROC>(manager->GetProcAddress("glMultiTexCoord3fvARB"));
1360 vtkgl::MultiTexCoord3i = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD3IPROC>(manager->GetProcAddress("glMultiTexCoord3iARB"));
1361 vtkgl::MultiTexCoord3iv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD3IVPROC>(manager->GetProcAddress("glMultiTexCoord3ivARB"));
1362 vtkgl::MultiTexCoord3s = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD3SPROC>(manager->GetProcAddress("glMultiTexCoord3sARB"));
1363 vtkgl::MultiTexCoord3sv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD3SVPROC>(manager->GetProcAddress("glMultiTexCoord3svARB"));
1364 vtkgl::MultiTexCoord4d = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD4DPROC>(manager->GetProcAddress("glMultiTexCoord4dARB"));
1365 vtkgl::MultiTexCoord4dv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD4DVPROC>(manager->GetProcAddress("glMultiTexCoord4dvARB"));
1366 vtkgl::MultiTexCoord4f = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD4FPROC>(manager->GetProcAddress("glMultiTexCoord4fARB"));
1367 vtkgl::MultiTexCoord4fv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD4FVPROC>(manager->GetProcAddress("glMultiTexCoord4fvARB"));
1368 vtkgl::MultiTexCoord4i = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD4IPROC>(manager->GetProcAddress("glMultiTexCoord4iARB"));
1369 vtkgl::MultiTexCoord4iv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD4IVPROC>(manager->GetProcAddress("glMultiTexCoord4ivARB"));
1370 vtkgl::MultiTexCoord4s = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD4SPROC>(manager->GetProcAddress("glMultiTexCoord4sARB"));
1371 vtkgl::MultiTexCoord4sv = reinterpret_cast<vtkgl::PFNGLMULTITEXCOORD4SVPROC>(manager->GetProcAddress("glMultiTexCoord4svARB"));
1372 return 1 && (vtkgl::ActiveTexture != NULL) && (vtkgl::ClientActiveTexture != NULL) && (vtkgl::MultiTexCoord1d != NULL) && (vtkgl::MultiTexCoord1dv != NULL) && (vtkgl::MultiTexCoord1f != NULL) && (vtkgl::MultiTexCoord1fv != NULL) && (vtkgl::MultiTexCoord1i != NULL) && (vtkgl::MultiTexCoord1iv != NULL) && (vtkgl::MultiTexCoord1s != NULL) && (vtkgl::MultiTexCoord1sv != NULL) && (vtkgl::MultiTexCoord2d != NULL) && (vtkgl::MultiTexCoord2dv != NULL) && (vtkgl::MultiTexCoord2f != NULL) && (vtkgl::MultiTexCoord2fv != NULL) && (vtkgl::MultiTexCoord2i != NULL) && (vtkgl::MultiTexCoord2iv != NULL) && (vtkgl::MultiTexCoord2s != NULL) && (vtkgl::MultiTexCoord2sv != NULL) && (vtkgl::MultiTexCoord3d != NULL) && (vtkgl::MultiTexCoord3dv != NULL) && (vtkgl::MultiTexCoord3f != NULL) && (vtkgl::MultiTexCoord3fv != NULL) && (vtkgl::MultiTexCoord3i != NULL) && (vtkgl::MultiTexCoord3iv != NULL) && (vtkgl::MultiTexCoord3s != NULL) && (vtkgl::MultiTexCoord3sv != NULL) && (vtkgl::MultiTexCoord4d != NULL) && (vtkgl::MultiTexCoord4dv != NULL) && (vtkgl::MultiTexCoord4f != NULL) && (vtkgl::MultiTexCoord4fv != NULL) && (vtkgl::MultiTexCoord4i != NULL) && (vtkgl::MultiTexCoord4iv != NULL) && (vtkgl::MultiTexCoord4s != NULL) && (vtkgl::MultiTexCoord4sv !=NULL);
1373 }
1374
1375 if (strcmp(name, "GL_ARB_texture_env_add") == 0)
1376 {
1377 return 1;
1378 }
1379
1380 if (strcmp(name, "GL_ARB_texture_env_combine") == 0)
1381 {
1382 return 1;
1383 }
1384
1385 if (strcmp(name, "GL_ARB_texture_env_dot3") == 0)
1386 {
1387 return 1;
1388 }
1389
1390 if (strcmp(name, "GL_ARB_texture_border_clamp") == 0)
1391 {
1392 return 1;
1393 }
1394
1395 if (strcmp(name, "GL_ARB_transpose_matrix") == 0)
1396 {
1397 vtkgl::LoadTransposeMatrixf = reinterpret_cast<vtkgl::PFNGLLOADTRANSPOSEMATRIXFPROC>(manager->GetProcAddress("glLoadTransposeMatrixfARB"));
1398 vtkgl::LoadTransposeMatrixd = reinterpret_cast<vtkgl::PFNGLLOADTRANSPOSEMATRIXDPROC>(manager->GetProcAddress("glLoadTransposeMatrixdARB"));
1399 vtkgl::MultTransposeMatrixf = reinterpret_cast<vtkgl::PFNGLMULTTRANSPOSEMATRIXFPROC>(manager->GetProcAddress("glMultTransposeMatrixfARB"));
1400 vtkgl::MultTransposeMatrixd = reinterpret_cast<vtkgl::PFNGLMULTTRANSPOSEMATRIXDPROC>(manager->GetProcAddress("glMultTransposeMatrixdARB"));
1401 return 1 && (vtkgl::LoadTransposeMatrixf != NULL) && (vtkgl::LoadTransposeMatrixd != NULL) && (vtkgl::MultTransposeMatrixf != NULL) && (vtkgl::MultTransposeMatrixd != NULL);
1402 }
1403
1404 // OpenGL 1.4
1405
1406 if (strcmp(name, "GL_SGIS_generate_mipmap") == 0)
1407 {
1408 return 1;
1409 }
1410
1411 if (strcmp(name, "GL_NV_blend_square") == 0)
1412 {
1413 return 1;
1414 }
1415
1416 if (strcmp(name, "GL_ARB_depth_texture") == 0)
1417 {
1418 return 1;
1419 }
1420
1421 if (strcmp(name, "GL_ARB_shadow") == 0)
1422 {
1423 return 1;
1424 }
1425
1426 if (strcmp(name, "GL_EXT_fog_coord") == 0)
1427 {
1428 vtkgl::FogCoordf = reinterpret_cast<vtkgl::PFNGLFOGCOORDFPROC>(manager->GetProcAddress("glFogCoordfEXT"));
1429 vtkgl::FogCoordfv = reinterpret_cast<vtkgl::PFNGLFOGCOORDFVPROC>(manager->GetProcAddress("glFogCoordfvEXT"));
1430 vtkgl::FogCoordd = reinterpret_cast<vtkgl::PFNGLFOGCOORDDPROC>(manager->GetProcAddress("glFogCoorddEXT"));
1431 vtkgl::FogCoorddv = reinterpret_cast<vtkgl::PFNGLFOGCOORDDVPROC>(manager->GetProcAddress("glFogCoorddvEXT"));
1432 vtkgl::FogCoordPointer = reinterpret_cast<vtkgl::PFNGLFOGCOORDPOINTERPROC>(manager->GetProcAddress("glFogCoordPointerEXT"));
1433 return 1 && (vtkgl::FogCoordf != NULL) && (vtkgl::FogCoordfv != NULL) && (vtkgl::FogCoordd != NULL) && (vtkgl::FogCoorddv != NULL) && (vtkgl::FogCoordPointer != NULL);
1434 }
1435
1436 if (strcmp(name, "GL_EXT_multi_draw_arrays") == 0)
1437 {
1438 vtkgl::MultiDrawArrays = reinterpret_cast<vtkgl::PFNGLMULTIDRAWARRAYSPROC>(manager->GetProcAddress("glMultiDrawArraysEXT"));
1439 vtkgl::MultiDrawElements = reinterpret_cast<vtkgl::PFNGLMULTIDRAWELEMENTSPROC>(manager->GetProcAddress("glMultiDrawElementsEXT"));
1440 return 1 && (vtkgl::MultiDrawArrays != NULL) && (vtkgl::MultiDrawElements != NULL);
1441 }
1442
1443 if (strcmp(name, "GL_ARB_point_parameters") == 0)
1444 {
1445 vtkgl::PointParameterf = reinterpret_cast<vtkgl::PFNGLPOINTPARAMETERFPROC>(manager->GetProcAddress("glPointParameterfARB"));
1446 vtkgl::PointParameterfv = reinterpret_cast<vtkgl::PFNGLPOINTPARAMETERFVPROC>(manager->GetProcAddress("glPointParameterfvARB"));
1447 return 1 && (vtkgl::PointParameterf != NULL) && (vtkgl::PointParameterfv != NULL);
1448 }
1449
1450
1451 if (strcmp(name, "GL_EXT_secondary_color") == 0)
1452 {
1453 vtkgl::SecondaryColor3b = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3BPROC>(manager->GetProcAddress("glSecondaryColor3bEXT"));
1454 vtkgl::SecondaryColor3bv = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3BVPROC>(manager->GetProcAddress("glSecondaryColor3bvEXT"));
1455 vtkgl::SecondaryColor3d = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3DPROC>(manager->GetProcAddress("glSecondaryColor3dEXT"));
1456 vtkgl::SecondaryColor3dv = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3DVPROC>(manager->GetProcAddress("glSecondaryColor3dvEXT"));
1457 vtkgl::SecondaryColor3f = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3FPROC>(manager->GetProcAddress("glSecondaryColor3fEXT"));
1458 vtkgl::SecondaryColor3fv = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3FVPROC>(manager->GetProcAddress("glSecondaryColor3fvEXT"));
1459 vtkgl::SecondaryColor3i = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3IPROC>(manager->GetProcAddress("glSecondaryColor3iEXT"));
1460 vtkgl::SecondaryColor3iv = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3IVPROC>(manager->GetProcAddress("glSecondaryColor3ivEXT"));
1461 vtkgl::SecondaryColor3s = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3SPROC>(manager->GetProcAddress("glSecondaryColor3sEXT"));
1462 vtkgl::SecondaryColor3sv = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3SVPROC>(manager->GetProcAddress("glSecondaryColor3svEXT"));
1463 vtkgl::SecondaryColor3ub = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3UBPROC>(manager->GetProcAddress("glSecondaryColor3ubEXT"));
1464 vtkgl::SecondaryColor3ubv = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3UBVPROC>(manager->GetProcAddress("glSecondaryColor3ubvEXT"));
1465 vtkgl::SecondaryColor3ui = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3UIPROC>(manager->GetProcAddress("glSecondaryColor3uiEXT"));
1466 vtkgl::SecondaryColor3uiv = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3UIVPROC>(manager->GetProcAddress("glSecondaryColor3uivEXT"));
1467 vtkgl::SecondaryColor3us = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3USPROC>(manager->GetProcAddress("glSecondaryColor3usEXT"));
1468 vtkgl::SecondaryColor3usv = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLOR3USVPROC>(manager->GetProcAddress("glSecondaryColor3usvEXT"));
1469 vtkgl::SecondaryColorPointer = reinterpret_cast<vtkgl::PFNGLSECONDARYCOLORPOINTERPROC>(manager->GetProcAddress("glSecondaryColorPointerEXT"));
1470 return 1 && (vtkgl::SecondaryColor3b != NULL) && (vtkgl::SecondaryColor3bv != NULL) && (vtkgl::SecondaryColor3d != NULL) && (vtkgl::SecondaryColor3dv != NULL) && (vtkgl::SecondaryColor3f != NULL) && (vtkgl::SecondaryColor3fv != NULL) && (vtkgl::SecondaryColor3i != NULL) && (vtkgl::SecondaryColor3iv != NULL) && (vtkgl::SecondaryColor3s != NULL) && (vtkgl::SecondaryColor3sv != NULL) && (vtkgl::SecondaryColor3ub!= NULL) && (vtkgl::SecondaryColor3ubv != NULL) && (vtkgl::SecondaryColor3ui != NULL) && (vtkgl::SecondaryColor3uiv != NULL) && (vtkgl::SecondaryColor3us != NULL) && (vtkgl::SecondaryColor3usv != NULL) && (vtkgl::SecondaryColorPointer != NULL);
1471 }
1472
1473 if (strcmp(name, "GL_EXT_blend_func_separate") == 0)
1474 {
1475 vtkgl::BlendFuncSeparate = reinterpret_cast<vtkgl::PFNGLBLENDFUNCSEPARATEPROC>(manager->GetProcAddress("glBlendFuncSeparateEXT"));
1476 return 1 && (vtkgl::BlendFuncSeparate != NULL);
1477 }
1478
1479 if (strcmp(name, "GL_EXT_stencil_wrap") == 0)
1480 {
1481 return 1;
1482 }
1483
1484 if (strcmp(name, "GL_ARB_texture_env_crossbar") == 0)
1485 {
1486 return 1;
1487 }
1488
1489 if (strcmp(name, "GL_EXT_texture_lod_bias") == 0)
1490 {
1491 return 1;
1492 }
1493
1494 if (strcmp(name, "GL_ARB_texture_mirrored_repeat") == 0)
1495 {
1496 return 1;
1497 }
1498
1499 if (strcmp(name, "GL_ARB_window_pos") == 0)
1500 {
1501 vtkgl::WindowPos2d = reinterpret_cast<vtkgl::PFNGLWINDOWPOS2DPROC>(manager->GetProcAddress("glWindowPos2dARB"));
1502 vtkgl::WindowPos2dv = reinterpret_cast<vtkgl::PFNGLWINDOWPOS2DVPROC>(manager->GetProcAddress("glWindowPos2dvARB"));
1503 vtkgl::WindowPos2f = reinterpret_cast<vtkgl::PFNGLWINDOWPOS2FPROC>(manager->GetProcAddress("glWindowPos2fARB"));
1504 vtkgl::WindowPos2fv = reinterpret_cast<vtkgl::PFNGLWINDOWPOS2FVPROC>(manager->GetProcAddress("glWindowPos2fvARB"));
1505 vtkgl::WindowPos2i = reinterpret_cast<vtkgl::PFNGLWINDOWPOS2IPROC>(manager->GetProcAddress("glWindowPos2iARB"));
1506 vtkgl::WindowPos2iv = reinterpret_cast<vtkgl::PFNGLWINDOWPOS2IVPROC>(manager->GetProcAddress("glWindowPos2ivARB"));
1507 vtkgl::WindowPos2s = reinterpret_cast<vtkgl::PFNGLWINDOWPOS2SPROC>(manager->GetProcAddress("glWindowPos2sARB"));
1508 vtkgl::WindowPos2sv = reinterpret_cast<vtkgl::PFNGLWINDOWPOS2SVPROC>(manager->GetProcAddress("glWindowPos2svARB"));
1509 vtkgl::WindowPos3d = reinterpret_cast<vtkgl::PFNGLWINDOWPOS3DPROC>(manager->GetProcAddress("glWindowPos3dARB"));
1510 vtkgl::WindowPos3dv = reinterpret_cast<vtkgl::PFNGLWINDOWPOS3DVPROC>(manager->GetProcAddress("glWindowPos3dvARB"));
1511 vtkgl::WindowPos3f = reinterpret_cast<vtkgl::PFNGLWINDOWPOS3FPROC>(manager->GetProcAddress("glWindowPos3fARB"));
1512 vtkgl::WindowPos3fv = reinterpret_cast<vtkgl::PFNGLWINDOWPOS3FVPROC>(manager->GetProcAddress("glWindowPos3fvARB"));
1513 vtkgl::WindowPos3i = reinterpret_cast<vtkgl::PFNGLWINDOWPOS3IPROC>(manager->GetProcAddress("glWindowPos3iARB"));
1514 vtkgl::WindowPos3iv = reinterpret_cast<vtkgl::PFNGLWINDOWPOS3IVPROC>(manager->GetProcAddress("glWindowPos3ivARB"));
1515 vtkgl::WindowPos3s = reinterpret_cast<vtkgl::PFNGLWINDOWPOS3SPROC>(manager->GetProcAddress("glWindowPos3sARB"));
1516 vtkgl::WindowPos3sv = reinterpret_cast<vtkgl::PFNGLWINDOWPOS3SVPROC>(manager->GetProcAddress("glWindowPos3svARB"));
1517 return 1 && (vtkgl::WindowPos2d != NULL) && (vtkgl::WindowPos2dv != NULL) && (vtkgl::WindowPos2f != NULL) && (vtkgl::WindowPos2fv != NULL) && (vtkgl::WindowPos2i != NULL) && (vtkgl::WindowPos2iv != NULL) && (vtkgl::WindowPos2s != NULL) && (vtkgl::WindowPos2sv != NULL) && (vtkgl::WindowPos3d != NULL) && (vtkgl::WindowPos3dv != NULL) && (vtkgl::WindowPos3f != NULL) && (vtkgl::WindowPos3fv != NULL) && (vtkgl::WindowPos3i != NULL) && (vtkgl::WindowPos3iv != NULL) && (vtkgl::WindowPos3s != NULL) && (vtkgl::WindowPos3sv != NULL);
1518 }
1519
1520 // OpenGL 1.5
1521
1522 if (strcmp(name, "GL_ARB_vertex_buffer_object") == 0)
1523 {
1524 vtkgl::BindBuffer = reinterpret_cast<vtkgl::PFNGLBINDBUFFERPROC>(manager->GetProcAddress("glBindBufferARB"));
1525 vtkgl::DeleteBuffers = reinterpret_cast<vtkgl::PFNGLDELETEBUFFERSPROC>(manager->GetProcAddress("glDeleteBuffersARB"));
1526 vtkgl::GenBuffers = reinterpret_cast<vtkgl::PFNGLGENBUFFERSPROC>(manager->GetProcAddress("glGenBuffersARB"));
1527 vtkgl::IsBuffer = reinterpret_cast<vtkgl::PFNGLISBUFFERPROC>(manager->GetProcAddress("glIsBufferARB"));
1528 vtkgl::BufferData = reinterpret_cast<vtkgl::PFNGLBUFFERDATAPROC>(manager->GetProcAddress("glBufferDataARB"));
1529 vtkgl::BufferSubData = reinterpret_cast<vtkgl::PFNGLBUFFERSUBDATAPROC>(manager->GetProcAddress("glBufferSubDataARB"));
1530 vtkgl::GetBufferSubData = reinterpret_cast<vtkgl::PFNGLGETBUFFERSUBDATAPROC>(manager->GetProcAddress("glGetBufferSubDataARB"));
1531 vtkgl::MapBuffer = reinterpret_cast<vtkgl::PFNGLMAPBUFFERPROC>(manager->GetProcAddress("glMapBufferARB"));
1532 vtkgl::UnmapBuffer = reinterpret_cast<vtkgl::PFNGLUNMAPBUFFERPROC>(manager->GetProcAddress("glUnmapBufferARB"));
1533 vtkgl::GetBufferParameteriv = reinterpret_cast<vtkgl::PFNGLGETBUFFERPARAMETERIVPROC>(manager->GetProcAddress("glGetBufferParameterivARB"));
1534 vtkgl::GetBufferPointerv = reinterpret_cast<vtkgl::PFNGLGETBUFFERPOINTERVPROC>(manager->GetProcAddress("glGetBufferPointervARB"));
1535 return 1 && (vtkgl::BindBuffer != NULL) && (vtkgl::DeleteBuffers != NULL) && (vtkgl::GenBuffers != NULL) && (vtkgl::IsBuffer != NULL) && (vtkgl::BufferData != NULL) && (vtkgl::BufferSubData != NULL) && (vtkgl::GetBufferSubData != NULL) && (vtkgl::MapBuffer != NULL) && (vtkgl::UnmapBuffer != NULL) && (vtkgl::GetBufferParameteriv != NULL) && (vtkgl::GetBufferPointerv != NULL);
1536 }
1537
1538 if (strcmp(name, "GL_ARB_occlusion_query") == 0)
1539 {
1540 vtkgl::GenQueries = reinterpret_cast<vtkgl::PFNGLGENQUERIESPROC>(manager->GetProcAddress("glGenQueriesARB"));
1541 vtkgl::DeleteQueries = reinterpret_cast<vtkgl::PFNGLDELETEQUERIESPROC>(manager->GetProcAddress("glDeleteQueriesARB"));
1542 vtkgl::IsQuery = reinterpret_cast<vtkgl::PFNGLISQUERYPROC>(manager->GetProcAddress("glIsQueryARB"));
1543 vtkgl::BeginQuery = reinterpret_cast<vtkgl::PFNGLBEGINQUERYPROC>(manager->GetProcAddress("glBeginQueryARB"));
1544 vtkgl::EndQuery = reinterpret_cast<vtkgl::PFNGLENDQUERYPROC>(manager->GetProcAddress("glEndQueryARB"));
1545 vtkgl::GetQueryiv = reinterpret_cast<vtkgl::PFNGLGETQUERYIVPROC>(manager->GetProcAddress("glGetQueryivARB"));
1546 vtkgl::GetQueryObjectiv = reinterpret_cast<vtkgl::PFNGLGETQUERYOBJECTIVPROC>(manager->GetProcAddress("glGetQueryObjectivARB"));
1547 vtkgl::GetQueryObjectuiv = reinterpret_cast<vtkgl::PFNGLGETQUERYOBJECTUIVPROC>(manager->GetProcAddress("glGetQueryObjectuivARB"));
1548 return 1 && (vtkgl::GenQueries != NULL) && (vtkgl::DeleteQueries != NULL) && (vtkgl::IsQuery != NULL) && (vtkgl::BeginQuery != NULL) && (vtkgl::EndQuery != NULL) && (vtkgl::GetQueryiv != NULL) && (vtkgl::GetQueryObjectiv != NULL) && (vtkgl::GetQueryObjectuiv != NULL);
1549 }
1550
1551 if (strcmp(name, "GL_EXT_shadow_funcs") == 0)
1552 {
1553 return 1;
1554 }
1555
1556 // OpenGL 2.0
1557
1558 if (strcmp(name, "GL_ARB_shader_objects") == 0)
1559 {
1560 // glDeleteObjectARB translates both to DeleteProgram and DeleteShader.
1561
1562 vtkgl::DeleteProgram = reinterpret_cast<vtkgl::PFNGLDELETEPROGRAMPROC>(manager->GetProcAddress("glDeleteObjectARB"));
1563 vtkgl::DeleteShader = reinterpret_cast<vtkgl::PFNGLDELETESHADERPROC>(manager->GetProcAddress("glDeleteObjectARB"));
1564
1565 // There is no translation for GetHandle in OpenGL2.0.
1566
1567 vtkgl::IsProgram = reinterpret_cast<vtkgl::PFNGLISPROGRAMPROC>(IsProgramFromARBToPromoted);
1568 vtkgl::IsShader = reinterpret_cast<vtkgl::PFNGLISSHADERPROC>(IsShaderFromARBToPromoted);
1569
1570 vtkgl::DetachShader = reinterpret_cast<vtkgl::PFNGLDETACHSHADERPROC>(manager->GetProcAddress("glDetachObjectARB"));
1571 vtkgl::CreateShader = reinterpret_cast<vtkgl::PFNGLCREATESHADERPROC>(manager->GetProcAddress("glCreateShaderObjectARB"));
1572 vtkgl::ShaderSource = reinterpret_cast<vtkgl::PFNGLSHADERSOURCEPROC>(manager->GetProcAddress("glShaderSourceARB"));
1573 vtkgl::CompileShader = reinterpret_cast<vtkgl::PFNGLCOMPILESHADERPROC>(manager->GetProcAddress("glCompileShaderARB"));
1574 vtkgl::CreateProgram = reinterpret_cast<vtkgl::PFNGLCREATEPROGRAMPROC>(manager->GetProcAddress("glCreateProgramObjectARB"));
1575
1576 vtkgl::AttachShader = reinterpret_cast<vtkgl::PFNGLATTACHSHADERPROC>(manager->GetProcAddress("glAttachObjectARB"));
1577 vtkgl::LinkProgram = reinterpret_cast<vtkgl::PFNGLLINKPROGRAMPROC>(manager->GetProcAddress("glLinkProgramARB"));
1578 vtkgl::UseProgram = reinterpret_cast<vtkgl::PFNGLUSEPROGRAMPROC>(manager->GetProcAddress("glUseProgramObjectARB"));
1579 vtkgl::ValidateProgram = reinterpret_cast<vtkgl::PFNGLVALIDATEPROGRAMPROC>(manager->GetProcAddress("glValidateProgramARB"));
1580 vtkgl::Uniform1f = reinterpret_cast<vtkgl::PFNGLUNIFORM1FPROC>(manager->GetProcAddress("glUniform1fARB"));
1581 vtkgl::Uniform2f = reinterpret_cast<vtkgl::PFNGLUNIFORM2FPROC>(manager->GetProcAddress("glUniform2fARB"));
1582 vtkgl::Uniform3f = reinterpret_cast<vtkgl::PFNGLUNIFORM3FPROC>(manager->GetProcAddress("glUniform3fARB"));
1583 vtkgl::Uniform4f = reinterpret_cast<vtkgl::PFNGLUNIFORM4FPROC>(manager->GetProcAddress("glUniform4fARB"));
1584 vtkgl::Uniform1i = reinterpret_cast<vtkgl::PFNGLUNIFORM1IPROC>(manager->GetProcAddress("glUniform1iARB"));
1585 vtkgl::Uniform2i = reinterpret_cast<vtkgl::PFNGLUNIFORM2IPROC>(manager->GetProcAddress("glUniform2iARB"));
1586 vtkgl::Uniform3i = reinterpret_cast<vtkgl::PFNGLUNIFORM3IPROC>(manager->GetProcAddress("glUniform3iARB"));
1587 vtkgl::Uniform4i = reinterpret_cast<vtkgl::PFNGLUNIFORM4IPROC>(manager->GetProcAddress("glUniform4iARB"));
1588 vtkgl::Uniform1fv = reinterpret_cast<vtkgl::PFNGLUNIFORM1FVPROC>(manager->GetProcAddress("glUniform1fvARB"));
1589 vtkgl::Uniform2fv = reinterpret_cast<vtkgl::PFNGLUNIFORM2FVPROC>(manager->GetProcAddress("glUniform2fvARB"));
1590 vtkgl::Uniform3fv = reinterpret_cast<vtkgl::PFNGLUNIFORM3FVPROC>(manager->GetProcAddress("glUniform3fvARB"));
1591 vtkgl::Uniform4fv = reinterpret_cast<vtkgl::PFNGLUNIFORM4FVPROC>(manager->GetProcAddress("glUniform4fvARB"));
1592 vtkgl::Uniform1iv = reinterpret_cast<vtkgl::PFNGLUNIFORM1IVPROC>(manager->GetProcAddress("glUniform1ivARB"));
1593 vtkgl::Uniform2iv = reinterpret_cast<vtkgl::PFNGLUNIFORM2IVPROC>(manager->GetProcAddress("glUniform2ivARB"));
1594 vtkgl::Uniform3iv = reinterpret_cast<vtkgl::PFNGLUNIFORM3IVPROC>(manager->GetProcAddress("glUniform3ivARB"));
1595 vtkgl::Uniform4iv = reinterpret_cast<vtkgl::PFNGLUNIFORM4IVPROC>(manager->GetProcAddress("glUniform4ivARB"));
1596 vtkgl::UniformMatrix2fv = reinterpret_cast<vtkgl::PFNGLUNIFORMMATRIX2FVPROC>(manager->GetProcAddress("glUniformMatrix2fvARB"));
1597 vtkgl::UniformMatrix3fv = reinterpret_cast<vtkgl::PFNGLUNIFORMMATRIX3FVPROC>(manager->GetProcAddress("glUniformMatrix3fvARB"));
1598 vtkgl::UniformMatrix4fv = reinterpret_cast<vtkgl::PFNGLUNIFORMMATRIX4FVPROC>(manager->GetProcAddress("glUniformMatrix4fvARB"));
1599
1600 // GetObjectParameterf* don't have translation in OpenGL2.0
1601
1602 // GetObjectParameter* translate both to GetProgram* and GetShader*
1603 vtkgl::GetProgramiv = reinterpret_cast<vtkgl::PFNGLGETPROGRAMIVPROC>(manager->GetProcAddress("glGetObjectParameterivARB"));
1604 vtkgl::GetShaderiv = reinterpret_cast<vtkgl::PFNGLGETSHADERIVPROC>(manager->GetProcAddress("glGetObjectParameterivARB"));
1605
1606 // glGetInfoLogARB translates both to GetProgramInfoLog and
1607 // GetShaderInfoLog.
1608
1609 vtkgl::GetProgramInfoLog = reinterpret_cast<vtkgl::PFNGLGETPROGRAMINFOLOGPROC>(manager->GetProcAddress("glGetInfoLogARB"));
1610 vtkgl::GetShaderInfoLog = reinterpret_cast<vtkgl::PFNGLGETSHADERINFOLOGPROC>(manager->GetProcAddress("glGetInfoLogARB"));
1611
1612
1613 vtkgl::GetAttachedShaders = reinterpret_cast<vtkgl::PFNGLGETATTACHEDSHADERSPROC>(manager->GetProcAddress("glGetAttachedObjectsARB"));
1614 vtkgl::GetUniformLocation = reinterpret_cast<vtkgl::PFNGLGETUNIFORMLOCATIONPROC>(manager->GetProcAddress("glGetUniformLocationARB"));
1615 vtkgl::GetActiveUniform = reinterpret_cast<vtkgl::PFNGLGETACTIVEUNIFORMPROC>(manager->GetProcAddress("glGetActiveUniformARB"));
1616 vtkgl::GetUniformfv = reinterpret_cast<vtkgl::PFNGLGETUNIFORMFVPROC>(manager->GetProcAddress("glGetUniformfvARB"));
1617 vtkgl::GetUniformiv = reinterpret_cast<vtkgl::PFNGLGETUNIFORMIVPROC>(manager->GetProcAddress("glGetUniformivARB"));
1618 vtkgl::GetShaderSource = reinterpret_cast<vtkgl::PFNGLGETSHADERSOURCEPROC>(manager->GetProcAddress("glGetShaderSourceARB"));
1619 return 1 && (vtkgl::DeleteProgram != NULL) && (vtkgl::DeleteShader != NULL) && (vtkgl::IsProgram != NULL) && (vtkgl::IsShader != NULL) && (vtkgl::DetachShader != NULL) && (vtkgl::CreateShader != NULL) && (vtkgl::ShaderSource != NULL) && (vtkgl::CompileShader != NULL) && (vtkgl::CreateProgram != NULL) && (vtkgl::AttachShader != NULL) && (vtkgl::LinkProgram != NULL) && (vtkgl::UseProgram != NULL) && (vtkgl::ValidateProgram != NULL) && (vtkgl::Uniform1f != NULL) && (vtkgl::Uniform2f != NULL) && (vtkgl::Uniform3f != NULL) && (vtkgl::Uniform4f != NULL) && (vtkgl::Uniform1i != NULL) && (vtkgl::Uniform2i != NULL) && (vtkgl::Uniform3i != NULL) && (vtkgl::Uniform4i != NULL) && (vtkgl::Uniform1fv != NULL) && (vtkgl::Uniform2fv != NULL) && (vtkgl::Uniform3fv != NULL) && (vtkgl::Uniform4fv != NULL) && (vtkgl::Uniform1iv != NULL) && (vtkgl::Uniform2iv != NULL) && (vtkgl::Uniform3iv != NULL) && (vtkgl::Uniform4iv != NULL) && (vtkgl::UniformMatrix2fv != NULL) && (vtkgl::UniformMatrix3fv != NULL) && (vtkgl::UniformMatrix4fv != NULL) && (vtkgl::GetProgramiv != NULL) && (vtkgl::GetShaderiv != NULL) && (vtkgl::GetProgramInfoLog != NULL) && (vtkgl::GetShaderInfoLog != NULL) && (vtkgl::GetAttachedShaders != NULL) && (vtkgl::GetUniformLocation != NULL) && (vtkgl::GetActiveUniform != NULL) && (vtkgl::GetUniformfv != NULL) && (vtkgl::GetUniformiv != NULL) && (vtkgl::GetShaderSource != NULL);
1620 }
1621
1622 if (strcmp(name, "GL_ARB_vertex_shader") == 0)
1623 {
1624 vtkgl::BindAttribLocation = reinterpret_cast<vtkgl::PFNGLBINDATTRIBLOCATIONPROC>(manager->GetProcAddress("glBindAttribLocationARB"));
1625 vtkgl::GetActiveAttrib = reinterpret_cast<vtkgl::PFNGLGETACTIVEATTRIBPROC>(manager->GetProcAddress("glGetActiveAttribARB"));
1626 vtkgl::GetAttribLocation = reinterpret_cast<vtkgl::PFNGLGETATTRIBLOCATIONPROC>(manager->GetProcAddress("glGetAttribLocationARB"));
1627
1628 // Defined both by GL_ARB_vertex_shader and GL_ARB_vertex_program
1629 vtkgl::DisableVertexAttribArray = reinterpret_cast<vtkgl::PFNGLDISABLEVERTEXATTRIBARRAYPROC>(manager->GetProcAddress("glDisableVertexAttribArrayARB"));
1630 vtkgl::EnableVertexAttribArray = reinterpret_cast<vtkgl::PFNGLENABLEVERTEXATTRIBARRAYPROC>(manager->GetProcAddress("glEnableVertexAttribArrayARB"));
1631
1632 vtkgl::GetVertexAttribdv = reinterpret_cast<vtkgl::PFNGLGETVERTEXATTRIBDVPROC>(manager->GetProcAddress("glGetVertexAttribdvARB"));
1633 vtkgl::GetVertexAttribfv = reinterpret_cast<vtkgl::PFNGLGETVERTEXATTRIBFVPROC>(manager->GetProcAddress("glGetVertexAttribfvARB"));
1634 vtkgl::GetVertexAttribiv = reinterpret_cast<vtkgl::PFNGLGETVERTEXATTRIBIVPROC>(manager->GetProcAddress("glGetVertexAttribivARB"));
1635 vtkgl::GetVertexAttribPointerv = reinterpret_cast<vtkgl::PFNGLGETVERTEXATTRIBPOINTERVPROC>(manager->GetProcAddress("glGetVertexAttribPointervARB"));
1636
1637 vtkgl::VertexAttrib1d = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB1DPROC>(manager->GetProcAddress("glVertexAttrib1dARB"));
1638 vtkgl::VertexAttrib1dv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB1DVPROC>(manager->GetProcAddress("glVertexAttrib1dvARB"));
1639 vtkgl::VertexAttrib1f = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB1FPROC>(manager->GetProcAddress("glVertexAttrib1fARB"));
1640 vtkgl::VertexAttrib1fv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB1FVPROC>(manager->GetProcAddress("glVertexAttrib1fvARB"));
1641 vtkgl::VertexAttrib1s = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB1SPROC>(manager->GetProcAddress("glVertexAttrib1sARB"));
1642 vtkgl::VertexAttrib1sv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB1SVPROC>(manager->GetProcAddress("glVertexAttrib1svARB"));
1643 vtkgl::VertexAttrib2d = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB2DPROC>(manager->GetProcAddress("glVertexAttrib2dARB"));
1644 vtkgl::VertexAttrib2dv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB2DVPROC>(manager->GetProcAddress("glVertexAttrib2dvARB"));
1645 vtkgl::VertexAttrib2f = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB2FPROC>(manager->GetProcAddress("glVertexAttrib2fARB"));
1646 vtkgl::VertexAttrib2fv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB2FVPROC>(manager->GetProcAddress("glVertexAttrib2fvARB"));
1647 vtkgl::VertexAttrib2s = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB2SPROC>(manager->GetProcAddress("glVertexAttrib2sARB"));
1648 vtkgl::VertexAttrib2sv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB2SVPROC>(manager->GetProcAddress("glVertexAttrib2svARB"));
1649 vtkgl::VertexAttrib3d = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB3DPROC>(manager->GetProcAddress("glVertexAttrib3dARB"));
1650 vtkgl::VertexAttrib3dv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB3DVPROC>(manager->GetProcAddress("glVertexAttrib3dvARB"));
1651 vtkgl::VertexAttrib3f = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB3FPROC>(manager->GetProcAddress("glVertexAttrib3fARB"));
1652 vtkgl::VertexAttrib3fv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB3FVPROC>(manager->GetProcAddress("glVertexAttrib3fvARB"));
1653 vtkgl::VertexAttrib3s = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB3SPROC>(manager->GetProcAddress("glVertexAttrib3sARB"));
1654 vtkgl::VertexAttrib3sv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB3SVPROC>(manager->GetProcAddress("glVertexAttrib3svARB"));
1655 vtkgl::VertexAttrib4Nbv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4NBVPROC>(manager->GetProcAddress("glVertexAttrib4NbvARB"));
1656 vtkgl::VertexAttrib4Niv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4NIVPROC>(manager->GetProcAddress("glVertexAttrib4NivARB"));
1657 vtkgl::VertexAttrib4Nsv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4NSVPROC>(manager->GetProcAddress("glVertexAttrib4NsvARB"));
1658 vtkgl::VertexAttrib4Nub = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4NUBPROC>(manager->GetProcAddress("glVertexAttrib4NubARB"));
1659 vtkgl::VertexAttrib4Nubv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4NUBVPROC>(manager->GetProcAddress("glVertexAttrib4NubvARB"));
1660 vtkgl::VertexAttrib4Nuiv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4NUIVPROC>(manager->GetProcAddress("glVertexAttrib4NuivARB"));
1661 vtkgl::VertexAttrib4Nusv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4NUSVPROC>(manager->GetProcAddress("glVertexAttrib4NusvARB"));
1662 vtkgl::VertexAttrib4bv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4BVPROC>(manager->GetProcAddress("glVertexAttrib4bvARB"));
1663 vtkgl::VertexAttrib4d = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4DPROC>(manager->GetProcAddress("glVertexAttrib4dARB"));
1664 vtkgl::VertexAttrib4dv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4DVPROC>(manager->GetProcAddress("glVertexAttrib4dvARB"));
1665 vtkgl::VertexAttrib4f = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4FPROC>(manager->GetProcAddress("glVertexAttrib4fARB"));
1666 vtkgl::VertexAttrib4fv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4FVPROC>(manager->GetProcAddress("glVertexAttrib4fvARB"));
1667 vtkgl::VertexAttrib4iv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4IVPROC>(manager->GetProcAddress("glVertexAttrib4ivARB"));
1668 vtkgl::VertexAttrib4s = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4SPROC>(manager->GetProcAddress("glVertexAttrib4sARB"));
1669 vtkgl::VertexAttrib4sv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4SVPROC>(manager->GetProcAddress("glVertexAttrib4svARB"));
1670 vtkgl::VertexAttrib4ubv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4UBVPROC>(manager->GetProcAddress("glVertexAttrib4ubvARB"));
1671 vtkgl::VertexAttrib4uiv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4UIVPROC>(manager->GetProcAddress("glVertexAttrib4uivARB"));
1672 vtkgl::VertexAttrib4usv = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIB4USVPROC>(manager->GetProcAddress("glVertexAttrib4usvARB"));
1673 vtkgl::VertexAttribPointer = reinterpret_cast<vtkgl::PFNGLVERTEXATTRIBPOINTERPROC>(manager->GetProcAddress("glVertexAttribPointerARB"));
1674
1675 return 1 && (vtkgl::BindAttribLocation != NULL) && (vtkgl::GetActiveAttrib != NULL) && (vtkgl::GetAttribLocation != NULL) && (vtkgl::DisableVertexAttribArray != NULL) && (vtkgl::EnableVertexAttribArray != NULL) && (vtkgl::GetVertexAttribdv != NULL) && (vtkgl::GetVertexAttribfv != NULL) && (vtkgl::GetVertexAttribiv != NULL) && (vtkgl::GetVertexAttribPointerv != NULL) && (vtkgl::VertexAttrib1d != NULL) && (vtkgl::VertexAttrib1dv != NULL) && (vtkgl::VertexAttrib1f != NULL) && (vtkgl::VertexAttrib1fv != NULL) && (vtkgl::VertexAttrib1s != NULL) && (vtkgl::VertexAttrib1sv != NULL) && (vtkgl::VertexAttrib2d != NULL) && (vtkgl::VertexAttrib2dv != NULL) && (vtkgl::VertexAttrib2f != NULL) && (vtkgl::VertexAttrib2fv != NULL) && (vtkgl::VertexAttrib2s != NULL) && (vtkgl::VertexAttrib2sv != NULL) && (vtkgl::VertexAttrib3d != NULL) && (vtkgl::VertexAttrib3dv != NULL) && (vtkgl::VertexAttrib3f != NULL) && (vtkgl::VertexAttrib3fv != NULL) && (vtkgl::VertexAttrib3s != NULL) && (vtkgl::VertexAttrib3sv != NULL) && (vtkgl::VertexAttrib4Nbv != NULL) && (vtkgl::VertexAttrib4Niv != NULL) && (vtkgl::VertexAttrib4Nsv != NULL) && (vtkgl::VertexAttrib4Nub != NULL) && (vtkgl::VertexAttrib4Nubv != NULL) && (vtkgl::VertexAttrib4Nuiv != NULL) && (vtkgl::VertexAttrib4Nusv != NULL) && (vtkgl::VertexAttrib4bv != NULL) && (vtkgl::VertexAttrib4d != NULL) && (vtkgl::VertexAttrib4dv != NULL) && (vtkgl::VertexAttrib4f != NULL) && (vtkgl::VertexAttrib4fv != NULL) && (vtkgl::VertexAttrib4iv != NULL) && (vtkgl::VertexAttrib4s != NULL) && (vtkgl::VertexAttrib4sv != NULL) && (vtkgl::VertexAttrib4ubv != NULL) && (vtkgl::VertexAttrib4uiv != NULL) && (vtkgl::VertexAttrib4usv != NULL) && (vtkgl::VertexAttribPointer != NULL);
1676
1677 // bug in the glext.h file:
1678 // the following method are in GL_ARB_vertex_program instead of
1679 // GL_ARB_vertex_shader
1680 // vtkgl::PFNGLENABLEVERTEXATTRIBARRAYARBPROC vtkgl::EnableVertexAttribArrayARB = NULL;
1681 //vtkgl::PFNGLDISABLEVERTEXATTRIBARRAYARBPROC vtkgl::DisableVertexAttribArrayARB = NULL;
1682 }
1683
1684 if (strcmp(name, "GL_ARB_fragment_shader") == 0)
1685 {
1686 return 1;
1687 }
1688
1689 if (strcmp(name, "GL_ARB_shading_language_100") == 0)
1690 {
1691 return 1;
1692 }
1693
1694 if (strcmp(name, "GL_ARB_draw_buffers") == 0)
1695 {
1696 vtkgl::DrawBuffers = reinterpret_cast<vtkgl::PFNGLDRAWBUFFERSPROC>(manager->GetProcAddress("glDrawBuffersARB"));
1697 return 1 && (vtkgl::DrawBuffers != NULL);
1698 }
1699
1700 if (strcmp(name, "GL_ARB_texture_non_power_of_two") == 0)
1701 {
1702 return 1;
1703 }
1704
1705 if (strcmp(name, "GL_ARB_point_sprite") == 0)
1706 {
1707 return 1;
1708 }
1709
1710 if (strcmp(name, "GL_EXT_blend_equation_separate") == 0)
1711 {
1712 vtkgl::BlendEquationSeparate = reinterpret_cast<vtkgl::PFNGLBLENDEQUATIONSEPARATEPROC>(manager->GetProcAddress("glBlendEquationSeparateEXT"));
1713 return 1 && (vtkgl::BlendEquationSeparate != NULL);
1714 }
1715
1716 if (strcmp(name, "GL_EXT_blend_logic_op") == 0)
1717 {
1718 return 1;
1719 }
1720
1721 // Separate stencil was "based on" API of extension GL_ATI_separate_stencil
1722 // but this extension was not promoted to OpenGL2.0...
1723
1724 if (strcmp(name, "GL_ATI_separate_stencil") == 0)
1725 {
1726 vtkgl::StencilOpSeparate = reinterpret_cast<vtkgl::PFNGLSTENCILOPSEPARATEPROC>(manager->GetProcAddress("glStencilOpSeparateATI"));
1727 vtkgl::StencilFuncSeparate = reinterpret_cast<vtkgl::PFNGLSTENCILFUNCSEPARATEPROC>(manager->GetProcAddress("glStencilFuncSeparateATI"));
1728 return 1 && (vtkgl::StencilOpSeparate != NULL) && (vtkgl::StencilFuncSeparate != NULL);
1729 // StencilMaskSeparate?
1730 }
1731
1732 // No GL_EXT_stencil_two_side ? No ActiveStencilFace?
1733
1734 // OpenGL 2.1
1735 if (strcmp(name, "GL_EXT_texture_sRGB") == 0)
1736 {
1737 return 1;
1738 }
1739
1740 if (strcmp(name, "GL_ARB_pixel_buffer_object") == 0)
1741 {
1742 return 1;
1743 }
1744
1745 return 0;
1746 }
1747
1748 // ----------------------------------------------------------------------------
LoadAsARBExtension(const char * name,vtkOpenGLExtensionManager * manager)1749 int vtkgl::LoadAsARBExtension(const char *name,
1750 vtkOpenGLExtensionManager *manager)
1751 {
1752 assert("pre: name_exists" && name!=NULL);
1753 assert("pre: manager_exists" && manager!=NULL);
1754
1755 if (strcmp(name, "GL_EXT_geometry_shader4") == 0)
1756 {
1757 vtkgl::ProgramParameteriARB = reinterpret_cast<vtkgl::PFNGLPROGRAMPARAMETERIARBPROC>(manager->GetProcAddress("glProgramParameteriEXT"));
1758
1759 // FramebufferTextureEXT(), FramebufferTextureLayerEXT() and
1760 // FramebufferTextureFaceEXT() are also define by extension
1761 // GL_NV_geometry_program4. Weird. Spec mistake.
1762
1763 vtkgl::FramebufferTextureARB = reinterpret_cast<vtkgl::PFNGLFRAMEBUFFERTEXTUREARBPROC>(manager->GetProcAddress("glFramebufferTextureEXT"));
1764
1765 vtkgl::FramebufferTextureLayerARB = reinterpret_cast<vtkgl::PFNGLFRAMEBUFFERTEXTURELAYERARBPROC>(manager->GetProcAddress("glFramebufferTextureLayerEXT"));
1766
1767 vtkgl::FramebufferTextureFaceARB = reinterpret_cast<vtkgl::PFNGLFRAMEBUFFERTEXTUREFACEARBPROC>(manager->GetProcAddress("glFramebufferTextureFaceEXT"));
1768
1769 return 1;
1770 }
1771 return 0;
1772 }
1773