PyOpenGL Tutorial?

[Clay Hobbs]

I need a tutorial for PyOpenGL (specifically, to be used with wxPython).
I searched with Google and didn't find one. Does anybody know where one
is?

-- Ratfink

[sturlamolden]

Re: PyOpenGL Tutorial?

On Jul 23, 10:07 pm, Clay Hobbs <c...@lakeserv. netwrote:

I need a tutorial for PyOpenGL (specifically, to be used with wxPython).
I searched with Google and didn't find one.  Does anybody know where one
is?

PyOpenGL is just a wrapper for OpenGL. The API is identical. Do you
need an OpenGL tutorial?

As for wxPython, you just subclass wxGLCanvas. Call the method
SetCurrent() before you call OpenGL (e.g. through PyOpenGL) and
SwapBuffers() when you are done. See the wxWidgets reference.

Personally I think PyOpenGL is a slow beast. It is not just a thin
wrapper over OpenGL, but bloated with sanity checks, exception
handling, etc (look at the code, it is pure Python and easy to read).
I prefer to put all calls to OpenGL in a C DLL, and call that with
ctypes. If I make repeated calls to functions like glVertex3f, I want
them to to be fast, thus C is indicated over Python. And if all I do
in C is to make calls into OpenGL, there is no real advantage to using
Python here - the Python code would look almost exactly the same, but
would be slower by several orders of magnitude. By the way, I still
use wxGLCanvas from wxPython to set things up. The ctypes call into my
C DLL is called between SetCurrent() and SwapBuffers().

If you want a pure Python solution, you will need to use display
lists, vertex arrays (with NumPy) or vertex buffers (if your graphics
card supports it) to get acceptable performance.

Here is a short tutorial:

import wx
import wx.glcanvas
import ctypes

glrender = ctypes.pydll.gl render.render # use ctypes.cdll to call with
GIL released
glrender.argtyp es = (ctypes.c_int, ctypes.c_int,)
glrender.restyp e = None

class MyCanvas(wx.glc anvas.GLCanvas) :

def __init__(self, parent):
attribList = (wx.glcanvas.WX _GL_DOUBLEBUFFE R,
wx.glcanvas.WX_ GL_RGBA, 0)
wx.glcanvas.GLC anvas.__init__( self, parent, -1, attribList =
attribList)
self.context = wx.glcanvas.GLC ontext(self)
self.Bind(wx.EV T_SIZE, self.OnSize)
self.Bind(wx.EV T_PAINT, self.OnPaint)

def OnSize(self, evt):
w,h = self.GetClientS ize()
self.w = w
self.h = h
dc = wx.ClientDC(sel f)
self.Render(dc)

def OnPaint(self, evt):
dc = wx.PaintDC(self )
self.Render(dc)

def Render(self, dc):
self.SetCurrent ()
glrender(self.w , self.h)
self.SwapBuffer s()

And then in glrender.c, put the following:


#include <GL\gl.h>
#include <GL\glu.h>
#include <GL\glext.h>

__declspec(dlle xport)
void render(int w, int h)
{
/* calls to OpenGL goes here */
return;
}

And for Python 2.5.x on Windows, compile with:

gcc -O2 -o glrender.dll -shared -lopengl -lmsvcr71 glrender.c