
 Usage

vtkOpenGLExtensionManager acts as an interface to OpenGL
extensions. It provides methods to query OpenGL extensions
on the current or a given render window and to load
extension function pointers. Currently does not support GLU
extensions since the GLU library is not linked to VTK.
Before using vtkOpenGLExtensionManager, an OpenGL context
must be created. This is generally done with a
vtkRenderWindow. Note that simply creating the
vtkRenderWindow is not sufficient. Usually you have to call
Render before the actual OpenGL context is created. You can
specify the RenderWindow with the SetRenderWindow method.

   vtkOpenGLExtensionManager *extensions =
  vtkOpenGLExtensionManager::New();
   extensions->SetRenderWindow(renwin);

If no vtkRenderWindow is specified, the current OpenGL
context (if any) is used.
Generally speaking, when using OpenGL extensions, you will
need an vtkOpenGLExtensionManager and the prototypes defined
in vtkgl.h.

   #include "vtkOpenGLExtensionManager.h"
   #include "vtkgl.h"

The vtkgl.h include file contains all the constants and
function pointers required for using OpenGL extensions in a
portable and namespace safe way. vtkgl.h is built from
parsed glext.h, glxext.h, and wglext.h files. Snapshots of
these files are distributed with VTK, but you can also set
CMake options to use other files.
To use an OpenGL extension, you first need to make an
instance of vtkOpenGLExtensionManager and give it a
vtkRenderWindow. You can then query the
vtkOpenGLExtensionManager to see if the extension is
supported with the ExtensionSupported method. Valid names
for extensions are given in the OpenGL extension registry at
http://www.opengl.org/registry/ . You can also grep vtkgl.h
(which will be in the binary build directory if VTK is not
installed) for appropriate names. There are also special
extensions GL_VERSION_X_X (where X_X is replaced with a
major and minor version, respectively) which contain all the
constants and functions for OpenGL versions for which the
gl.h header file is of an older version than the driver.

   if (   !extensions->ExtensionSupported("GL_VERSION_1_2")
       || !extensions->ExtensionSupported
  ("GL_ARB_multitexture") ) {
     {
     vtkErrorMacro("Required extensions not supported!");
     }

Once you have verified that the extensions you want exist,
before you use them you have to load them with the
LoadExtension method.

   extensions->LoadExtension("GL_VERSION_1_2");
   extensions->LoadExtension("GL_ARB_multitexture");

Alternatively, you can use the LoadSupportedExtension
method, which checks whether the requested extension is
supported and, if so, loads it. The LoadSupportedExtension
method will not raise any errors or warnings if it fails, so
it is important for callers to pay attention to the return
value.

   if (   extensions->LoadSupportedExtension
  ("GL_VERSION_1_2")
       &amp;&amp; extensions->LoadSupportedExtension
  ("GL_ARB_multitexture") ) {
     {
     vtkgl::ActiveTexture(vtkgl::TEXTURE0_ARB);
     }
   else
     {
     vtkErrorMacro("Required extensions could not be
  loaded!");
     }

Once you have queried and loaded all of the extensions you
need, you can delete the vtkOpenGLExtensionManager. To use a
constant of an extension, simply replace the "GL_" prefix
with "vtkgl::". Likewise, replace the "gl" prefix of
functions with "vtkgl::". In rare cases, an extension will
add a type. In this case, add vtkgl:: to the type (i.e.
vtkgl::GLchar).

   extensions->Delete();
   ...
   vtkgl::ActiveTexture(vtkgl::TEXTURE0_ARB);

For wgl extensions, replace the "WGL_" and "wgl" prefixes
with "vtkwgl::". For glX extensions, replace the "GLX_" and
"glX" prefixes with "vtkglX::".
To create an instance of class vtkOpenGLExtensionManager,
simply invoke its constructor as follows

    obj = vtkOpenGLExtensionManager



 Methods

The class vtkOpenGLExtensionManager has several methods that
can be used. They are listed below. Note that the
documentation is translated automatically from the VTK
sources, and may not be completely intelligible. When in
doubt, consult the VTK website. In the methods listed below,
obj is an instance of the vtkOpenGLExtensionManager class.

* string = obj.GetClassName ()
* int = obj.IsA (string name)
* vtkOpenGLExtensionManager = obj.NewInstance ()
* vtkOpenGLExtensionManager = obj.SafeDownCast (vtkObject o)
* vtkRenderWindow = obj.GetRenderWindow () - Set/Get the
  render window to query extensions on. If set to null,
  justs queries the current render window.
* obj.SetRenderWindow (vtkRenderWindow renwin) - Set/Get the
  render window to query extensions on. If set to null,
  justs queries the current render window.
* obj.Update () - Updates the extensions string.
* string = obj.GetExtensionsString () - Returns a string
  listing all available extensions. Call Update first to
  validate this string.
* int = obj.ExtensionSupported (string name) - Returns true
  if the extension is supported, false otherwise.
* obj.LoadExtension (string name) - Loads all the functions
  associated with the given extension into the appropriate
  static members of vtkgl. This method emits a warning if
  the requested extension is not supported. It emits an
  error if the extension does not load successfully.
* int = obj.LoadSupportedExtension (string name) - Returns
  true if the extension is supported and loaded
  successfully, false otherwise. This method will "fail
  silently/gracefully" if the extension is not supported or
  does not load properly. It emits neither warnings nor
  errors. It is up to the caller to determine if the
  extension loaded properly by paying attention to the
  return value.
* obj.LoadCorePromotedExtension (string name) - Loads all
  the functions associated with the given core-promoted
  extension into the appropriate static members of vtkgl
  associated with the OpenGL version that promoted the
  extension as a core feature. This method emits a warning
  if the requested extension is not supported. It emits an
  error if the extension does not load successfully.
  For instance, extension GL_ARB_multitexture was promoted
  as a core feature into OpenGL 1.3. An implementation that
  uses this feature has to (IN THIS ORDER), check if OpenGL
  1.3 is supported with ExtensionSupported
  ("GL_VERSION_1_3"), if true, load the extension with
  LoadExtension("GL_VERSION_1_3"). If false, test for the
  extension with ExtensionSupported
  ("GL_ARB_multitexture"),if true load the extension with
  this method LoadCorePromotedExtension
  ("GL_ARB_multitexture"). If any of those loading stage
  succeeded, use vtgl::ActiveTexture() in any case, NOT
  vtgl::ActiveTextureARB(). This method avoids the use of if
  statements everywhere in implementations using core-
  promoted extensions. Without this method, the
  implementation code should look like:

     int opengl_1_3=extensions->ExtensionSupported
    ("GL_VERSION_1_3");
     if(opengl_1_3)
     {
       extensions->LoadExtension("GL_VERSION_1_3");
     }
     else
     {
      if(extensions->ExtensionSupported
    ("GL_ARB_multitexture"))
      {
       extensions->LoadCorePromotedExtension
    ("GL_ARB_multitexture");
      }
      else
      {
       vtkErrorMacro("Required multitexture feature is not
    supported!");
      }
     }
     ...
     if(opengl_1_3)
     {
      vtkgl::ActiveTexture(vtkgl::TEXTURE0)
     }
     else
     {
      vtkgl::ActiveTextureARB(vtkgl::TEXTURE0_ARB)
     }

  Thanks to this method, the code looks like:

     int opengl_1_3=extensions->ExtensionSupported
    ("GL_VERSION_1_3");
     if(opengl_1_3)
     {
       extensions->LoadExtension("GL_VERSION_1_3");
     }
     else
     {
      if(extensions->ExtensionSupported
    ("GL_ARB_multitexture"))
      {
       extensions->LoadCorePromotedExtension
    ("GL_ARB_multitexture");
      }
      else
      {
       vtkErrorMacro("Required multitexture feature is not
    supported!");
      }
     }
     ...
     vtkgl::ActiveTexture(vtkgl::TEXTURE0);



* FreeMat_Documentation
* Visualization_Toolkit_Rendering_Classes
* Generated on Thu Jul 25 2013 17:18:35 for FreeMat by
  doxygen_ 1.8.1.1

