Archives March 2009

PyOpenGL 3.0.0 is almost out the door.  Testing is done on Linux 64-bit and all seems well.  Documentation is updated (including deprecation warnings and updated PyDoc version).  Install of the library worked on a MacBook this afternoon, but the PyOpenGL-Demo module refused to download (some SourceForge issue with a redirect). Will have to try again tomorrow if I can find another friendly Mac user.  I'll need to boot into Vista to test on Win32 with extension support (already tested and passed on Win32 virtual machine (Qemu)).

I was intending to play around with a shadow-mapping demo today ...

I've just released version 2.0.0b4 of the RunSnakeRun profile-viewer module I mentioned in my PyCon presentation on profiling.  This version runs reasonably well on Win32 platforms (as well as Linux, of course) and has tooltips for the SquareMap and text where there's sufficient room to display it.

Saw strange performance show up during testing of a simple set of shader-based samples in OpenGLContext.  Discovered what seemed to be a memory leak of the wrapper objects in OpenGL_accelerate... investigation showed that the wrapers were re-"compiling" the finalized versions of the functions on every call.  Turns out that setting self.__class__.__call__ doesn't alter future calls to the instance?  Or maybe it's just that it doesn't work when you use staticmethods... will need to figure that out at some point.

Other than that, got the OpenGL presentation down to approximately the set of ideas I ...

Decided to work on the workstation today (bigger screen, tablet for drawing)... ran the little mandelbrot explorer demo.  Managed to lock up the whole machine at just a few hundred iterations.  Apparently having compiz on while doing "test the limits of your graphics card" code running is... counter-indicated.

Kinda neat zooming into the mandelbrot until you run into the limits of floating-point precision.  Very cool seeing computer-science principles suddenly pop up as a real-world effect :) .

The Orange Book (OpenGL Shading Language 2nd Ed) has a neat little shader demo where you render the Mandelbrot set with a fragment shader.  It's one of those "cool, but not particularly practical" examples of shader's power.

I've been adding some rudimentary "generic" shader support to OpenGLContext, so I decided I'd use that little bit of sample code to test that support... and time got away from me.  Result is quite neat, the (simple) scene allows you to explore the mandelbrot with zoom, pan, and number-of-iterations control.

10 iterations gives you a loose sketch.  127 gives ...

Which uses the directdocs generator, which is based on python-lxml... but the API for lxml has apparently changed (with the rebuilding of the workstation to Ubuntu).  Namespaces have to be passed explicitly as a named argument... no problem, can fix that... oh, but now it can't resolve entity references such as ⁢ in the document.

Weird, I'm guessing either the version has increased or decreased and the version on Ubuntu doesn't handle resolving entities automatically.  On the Gentoo box it resolved the ⁢ entity to "", which would seem to make sense, as it looks like it's ...

OpenGL presentation at PyGTA went alright, but it went *way* over time (2.25 hours) and that was without any particularly involved demos or the like.  Then again, wasn't really attempting to keep to any sort of timeline.  Can likely cut out much of the political stuff, and can go faster on the shader theory (I'm thinking a couple more diagrams at least).

Really want to get some interesting shader demos for the end of the presentation, things that show what you can do with shader-based rendering that wasn't possible (or was at least very cumbersome) with ...

As I've been working on the OpenGL presentation I've run into this issue a couple of times... much of the overhead in PyOpenGL 3.x's array-handling could be eliminated if we didn't allow for copying data at all when passing in array values.  That is, if we were to always require that the client-passed value be an array-compatible format that is contiguous and otherwise C-friendly then we could reduce many of the wrappers down to a simple 2 or 3 line function (many of which are available in the OpenGL_accelerate module).

I'm considering implementing a ...

Working on one of the graphics for the OpenGL 3.1 presentation most of today.  It's a fairly generic drawing, showing the VBOs, texture-storage, Vertex and Fragment shaders and the various interconnections such as Vertex Attributes, Uniforms, Varying attributes and the like.  I found two drawings that were very similar to what I wanted, one in the "OpenGL SuperBible", the other in "The OpenGL Shading Language", but neither seemed to focus on "how you program" the shaders.  They discussed, in the first case, the parts of the fixed-function pipeline that shaders replaced, and in the second, the components that ...

Did a version of the PyCon talk on profiling at HackLab's weekly Python Newbies night this evening.  This was a bit of a "kitchen sink" presentation; every thought I had on the topic thrown into a presentation to see what stuck.  As a result it was around an hour long (pushing to get it done that fast).  The big TODOs:

• need to have a few slides at the beginning giving a simple, graphical "what is profiling" introduction (to replace the current midway "how does profiling work" section)
• need to watch out for jargon, one of the new programmers found ...