[pygame] Python - Pygame - PyOpenGL performance

[Zack Schilling <zack.schilling@xxxxxxxxx>]

I know the PyOpenGL mailing list might be a better place to ask this  
question, but I've had a lot of luck talking to the experienced people  
here so I figured I'd try it first.

I'm trying to migrate a game I created from using the Pygame / SDL  
software rendering to OpenGL. Before attempting the massive and  
complex conversion involved with moving the whole game, I decided to  
make a little test program while I learned OpenGL.

In this test, I set up OpenGL to work in 2D and began loading images  
into texture objects and drawing textured quads as sprites. I created  
a little glSprite class to handle the drawing and translation. At  
first its draw routine looked like this:

        glPushMatrix()
        glTranslate(self.positionx,self.positiony,0)
        glBindTexture(GL_TEXTURE_2D, self.texture)
        glBegin(GL_QUADS)
        glTexCoord2f(0, 1)
        glVertex2f(0, 0)
        glTexCoord2f(1, 1)
        glVertex2f(w, 0)
        glTexCoord2f(1, 0)
        glVertex2f(w, h)
        glTexCoord2f(0, 0)
        glVertex2f(0, h)
        glEnd()
        glPopMatrix()

Note: self.texture is a texture ID of a loaded OpenGL texture object.  
My sprite class keeps a dictionary cache and only loads the sprite's  
image into a texture if it needs to.

I'd get maybe 200 identical sprites (same texture) onscreen and my CPU  
would hit 100% load from Python execution. I looked into what could be  
causing this and found out that it's probably function call overhead.  
That's 14 external library function calls per sprite draw.

The next thing I tried was to create a display list at each sprite's  
initialization. Then my code looked like this:
        glPushMatrix()
        glTranslate(self.positionx,self.positiony,0)
        glCallList(self.displist)
        glPopMatrix()

Well, that's nice, down to 4 calls per draw. I was able to push ~500  
sprites per frame using this method before the CPU tapped out. I need  
more speed than this. My game logic uses 30-40% of the CPU alone and  
I'd like to push at least 1000 sprites. What can I do? I've looked  
into passing sprites as a matrix with vertex arrays, but forming a  
proper vertex array with numpy can sometimes be more trouble than it's  
worth. Plus, I can't swap out textures easily mid-draw, so it makes  
things much more complex than the simple way I'm doing things now.

Is there any design pattern I could follow that will get me more speed  
without sending me off the deep end with complexity.

Thanks,

Zack