dox/Rendering/OpenGL/vtkOpenGLExtensionManager.h

Go to the documentation of this file.

// -*- c++ -*-

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkOpenGLExtensionManager.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

  Copyright 2003 Sandia Corporation.
  Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
  license for use of this work by or on behalf of the
  U.S. Government. Redistribution and use in source and binary forms, with
  or without modification, are permitted provided that this Notice and any
  statement of authorship are reproduced on all copies.

=========================================================================*/

#include "vtkRenderingOpenGLModule.h" // For export macro
// #include "vtkOpenGLExtensionManager.h"
// #include "vtkgl.h"
// \endcode
// 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.
//
// \code
// if (   !extensions->ExtensionSupported("GL_VERSION_1_2")
//     || !extensions->ExtensionSupported("GL_ARB_multitexture") ) {
//   {
//   vtkErrorMacro("Required extensions not supported!");
//   }
// \endcode
//
// Once you have verified that the extensions you want exist, before you
// use them you have to load them with the LoadExtension method.
//
// \code
// extensions->LoadExtension("GL_VERSION_1_2");
// extensions->LoadExtension("GL_ARB_multitexture");
// \endcode
//
// 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.
//
// \code
// if (   extensions->LoadSupportedExtension("GL_VERSION_1_2")
//     && extensions->LoadSupportedExtension("GL_ARB_multitexture") ) {
//   {
//   vtkgl::ActiveTexture(vtkgl::TEXTURE0_ARB);
//   }
// else
//   {
//   vtkErrorMacro("Required extensions could not be loaded!");
//   }
// \endcode
//
// 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).
//
// \code
// extensions->Delete();
// ...
// vtkgl::ActiveTexture(vtkgl::TEXTURE0_ARB);
// \endcode
//
// For wgl extensions, replace the "WGL_" and "wgl" prefixes with
// "vtkwgl::".  For glX extensions, replace the "GLX_" and "glX" prefixes
// with "vtkglX::".
//

#ifndef __vtkOpenGLExtensionManager_h
#define __vtkOpenGLExtensionManager_h

#include "vtkObject.h"
#include "vtkWeakPointer.h" // needed for vtkWeakPointer.
#include <string> // needed for std::string

class vtkRenderWindow;

//BTX
extern "C" {
#ifdef _WIN32
#include "vtkOpenGL.h"  // Needed for WINAPI
  typedef int (WINAPI *vtkOpenGLExtensionManagerFunctionPointer)(void);
#else
  typedef void (*vtkOpenGLExtensionManagerFunctionPointer)(void);
#endif
}
//ETX

class VTKRENDERINGOPENGL_EXPORT vtkOpenGLExtensionManager : public vtkObject
{
public:
  vtkTypeMacro(vtkOpenGLExtensionManager, vtkObject);
  static vtkOpenGLExtensionManager *New();
  void PrintSelf(ostream &os, vtkIndent indent);


  vtkRenderWindow* GetRenderWindow();
  virtual void SetRenderWindow(vtkRenderWindow *renwin);

  virtual void Update();


  vtkGetStringMacro(ExtensionsString);

  virtual int ExtensionSupported(const char *name);

//BTX

  virtual vtkOpenGLExtensionManagerFunctionPointer GetProcAddress(
    const char *fname);
//ETX

  virtual void LoadExtension(const char *name);

  virtual int LoadSupportedExtension(const char *name);


  virtual void LoadCorePromotedExtension(const char *name);

  virtual void LoadAsARBExtension(const char *name);


  virtual int GetDriverVersionMajor(){ return this->DriverVersionMajor; }
  virtual int GetDriverVersionMinor(){ return this->DriverVersionMinor; }
  virtual int GetDriverVersionPatch(){ return this->DriverVersionPatch; }


  virtual int GetDriverGLVersionMajor(){ return this->DriverGLVersionMajor; }
  virtual int GetDriverGLVersionMinor(){ return this->DriverGLVersionMinor; }
  virtual int GetDriverGLVersionPatch(){ return this->DriverGLVersionPatch; }


  virtual bool DriverIsATI();
  virtual bool DriverIsNvidia();
  virtual bool DriverIsIntel();
  virtual bool DriverIsMesa();
  virtual bool DriverIsMicrosoft();


  virtual bool DriverVersionIs(int major);
  virtual bool DriverVersionIs(int major, int minor);
  virtual bool DriverVersionIs(int major, int minor, int patch);


  virtual bool DriverVersionAtLeast(int major);
  virtual bool DriverVersionAtLeast(int major, int minor);
  virtual bool DriverVersionAtLeast(int major, int minor, int patch);


  virtual bool DriverGLVersionIs(int major, int minor, int patch);
  virtual bool DriverGLVersionIs(int major, int minor);


  virtual bool DriverGLRendererIs(const char *str);
  virtual bool DriverGLRendererHas(const char *str);
  virtual bool DriverGLRendererHasToken(const char *str);

  virtual bool DriverGLRendererIsOSMesa();


  virtual const char *GetDriverGLVendor(){ return this->DriverGLVendor.c_str(); }
  virtual const char *GetDriverGLVersion(){ return this->DriverGLVersion.c_str(); }
  virtual const char *GetDriverGLRenderer(){ return this->DriverGLRenderer.c_str(); }


  bool GetIgnoreDriverBugs(const char *description);
  vtkSetMacro(IgnoreDriverBugs, bool);
  vtkBooleanMacro(IgnoreDriverBugs, bool);

//BTX
protected:
  vtkOpenGLExtensionManager();
  virtual ~vtkOpenGLExtensionManager();

  int OwnRenderWindow;
  char *ExtensionsString;

  vtkTimeStamp BuildTime;

  // driver specific info
  std::string DriverGLVersion;
  int DriverGLVersionMajor;
  int DriverGLVersionMinor;
  int DriverGLVersionPatch;
  std::string DriverGLVendor;
  std::string DriverGLRenderer;
  int DriverVersionMajor;
  int DriverVersionMinor;
  int DriverVersionPatch;
  enum DriverGLVendorIdType
    {
    DRIVER_VENDOR_UNKNOWN=0,
    DRIVER_VENDOR_ATI,
    DRIVER_VENDOR_NVIDIA,
    DRIVER_VENDOR_INTEL,
    DRIVER_VENDOR_MESA,
    DRIVER_VENDOR_MICROSOFT
    };
  DriverGLVendorIdType DriverGLVendorId;
  bool IgnoreDriverBugs;

  virtual void InitializeDriverInformation();

  virtual void ReadOpenGLExtensions();

  virtual int SafeLoadExtension(const char *name);

private:
  vtkOpenGLExtensionManager(const vtkOpenGLExtensionManager&); // Not implemented
  void operator=(const vtkOpenGLExtensionManager&); // Not implemented

  vtkWeakPointer<vtkRenderWindow> RenderWindow;
//ETX
};

#endif //__vtkOpenGLExtensionManager