GLEWpy: Python Wrappings of the OpenGL Extension Wrangler

GLEWpy aims to bring advanced OpenGL extensions to Python. This will allow the Python OpenGL developer to use features such as fragment and vertex shaders and image processing on the GPU. It serves as a compliment to PyOpenGL and toolkits such as GLUT and SDL (pygame).

Latest Release: 0.7.4

Project Page -- Download (requires Pyrex >=0.9.4.1 and GLEW >=1.3.4)

Installation Notes:

The OSX binary can be unstable, but should work with 10.3 and all the latest developer tools. It is recommended that you build from source on OSX using the setup-osx.py distutils script.
Examples can be found in the source distributions in glewpy/examples/. Submitted examples are encouraged.
Standard install commands:

python setup.py build
python setup.py install

Sample Usage:

>>> import sys
>>> from OpenGL.GL import *
>>> from OpenGL.GLUT import *
>>> from glew import *

# MUST have a GL context before initializing GLEW
>>> glutInit(sys.argv)
>>> glutInitWindowSize(512, 512)
>>> glutCreateWindow('GLEW Testing')

# Now initialize GLEW
>>> err = glewInit()
>>> if (err != GLEW_OK):
       print 'Error loading glew:', glewGetErrorString(err)
       sys.exit()
    else:
       print 'GLEW Version:', glewGetString(GLEW_VERSION)

# Now you can query extension availability in two ways.
>>> if (glewGetExtension('GL_ARB_shading_language_100') == GL_TRUE):
       print 'You have OpenGL Shading Language Support'

# The faster method
# Note this is a function call, unlike GLEW's value check
>>> if GLEW_ARB_shading_language_100(): 
       print 'You have OpenGL Shading Language Support'

All extension methods are defined whether you machine supports them or not. Attempting to call an unsupported method OR calling a supported method before glewInit is called, will result in a GlewpyError being raised. Glewpy acts as if no extensions are supported before glewInit is called, because attempting to run the methods before would yeild a segmentation fault.

Supported Extensions:

Notes: Many extensions are duplications or pre-cursors to standard OpenGL. These will have low priority unless requested (see the FAQ for how to request). GLX and WGL extensions require other API's, so wrapping their functionality will require access to these libraries. How we do this will be decided when the GL extensions are mature enough.

Coding Conventions:

void glColor3i(GLint r, GLint g, GLint b) -->
   glColor3i(r, g, b) # Easy enough

void glColor3iv(GLint* rgb) -->
   glColor3iv([r, g, b]) # Any iterable

void glGetParameterfv(GLenum target, GLenum pname, GLfloat* params) -->
   params glGetParameterfv(target, pname) # Can't pass pointers, so value returned

void glTexImage1D(GLenum target, GLint level, GLint internalFormat, GLsizei width, \
 GLint border, GLenum format, GLenum type, const GLvoid* pixels) -->
   glTexImage1D(target, level, internalFormat, width, border, format, type, pixels) 

   # So what should be passed for pixels?
   # The best way we have decided to handle a void pointer is by passing a byte string.
   # This allows developers to use the module of their choice for textures and lut's.
   # The most common uses will be to pass PIL's Image.tostring() and NumArray's array.tostring().

FAQs:

Q: Why Glewpy?
A: We don't believe that C should be the only option for having access to the latest features of GPU's. GLEW is a really nice toolkit for runtime extension querying and usage, and it is easy to wrap. PyOpenGL is a wonderful module, but it usually lacks up to date functionality. In short, one should not be limited by the API, but by the driver and hardware support.

Q: What can I do with Glewpy that I could not before?
A: Glewpy's primary motivation is to allow the use of shaders in python. Shaders open up a world of possibilities: fluid dynamic simulations, per-pixel lighting, and procedural textures to name a few. Glewpy also opens up support for compressed textures and the latest OpenGL specs if your hardware supports them.

Q: The extension I want is not wrapped yet! Do my bidding!
A: Please post requests to the glewpy-users list if you have an extension you would like to utilize. We are currently wrapping functionality that we deem important. We want to support everything, but that will take a little time.

Q: What software are you wrapping GLEW with?
A: We use Pyrex. It is a wonderful mix of python and C that allows for easily creating python modules.

Q: "from glew import *" pollutes my precious namespace. How can I import just what I want?
A: At minimum you need "from glew.glew import *" to import the GLEW methods and constants. To import just an extension domain you can do something like "from glew.gl.arb import *". To import OpenGL 1.[2345] and 2.0 support: "from glew.gl.gl import *".