So you have a Dell Ubuntu 14.04 Laptop and it is running way too hot. You can configure it to run at a reasonable level using i8kmon. As with anything heat related, be careful. If you miss-configure the machine you are likely to wind up with a fried machine!

You create a file called /etc/i8kmon.conf and put the following in it:

set config(daemon)      0

# Automatic fan control, override with --auto option
set config(auto)        1

# Report status on stdout, override with --verbose option
set config(verbose) 1

# Status check timeout (seconds), override with --timeout option
set ...

So the good news is that I've now got far more PyOpenGL output parameters automatically wrapped such that they can be passed in or automatically generated. That drops a *lot* of the manually maintained code. OpenGLContext works with the revisions, but the revision currently does *not* support non-contiguous input arrays (basically the cleanup included removing manually maintained code that said "this is an input array, so allow it to be non-contiguous"). I'll be moving the logic to doing that wrapping into the run-time eventually.

Upshot, however, is that there are a lot of changes, and while they are ...

Walter on PyOpenGL Users pointed me at the chromium "regal" tool, which has a table of constant definitions for output parameter sizings. I have a similar mechanism inside PyOpenGL's source code, so I parsed the table out of regal and used it to spot and plug gaps in the PyOpenGL table. The regal stuff is all-one-table for any COMPSIZE() value, while PyOpenGL has traditionally had many tables, one for each output-parameter... seems that could be simplified now to just use the one table, though there are definitely some corner-cases to be addressed (cases where e.g. another API call ...

I played with getting a py2exe executable created from PyOpenGL today, and it is very close to working.  The basics:

from distutils.core import setup
import py2exe
import glob, os
import OpenGL
data_files = [
    (
        os.path.join('OpenGL','DLLS'),
        glob.glob( os.path.join( os.path.dirname( OpenGL.__file__ ), 'DLLS', '*.*' ))
    ),
]

if __name__ == "__main__":
    setup(
        windows=['shader_test.py'],
        options={
            "py2exe": {
                "includes": [
                    "ctypes", "logging",
                    'OpenGL.platform.win32',
                ] + [
                    'OpenGL.arrays.%s'%x for x in [
                        'ctypesarrays','ctypesparameters','ctypespointers',
                        'lists','nones','numbers','numpymodule','strings','vbo'
                    ]
                ],
                'skip_archive': True,
            },
        },
        data_files = data_files,
    )

Which collects all of PyOpenGL's plugins that are applicable for use in Win32 (basically the ...

The second (and hopefully last) beta for PyOpenGL 3.1.0 is now available. These are the changes since Beta 1. If there's nothing critical showing up I'll do a final release in a few weeks.

• Generation fixes (lots of them) 
• GLES/GL-only extensions should now be generated only in the appropriate directories 
• Extensions which are multi-api will show up in each API package (note: custom wrappers are still written per-api) 
• Freshly generated wrappers from the khronos API repository 
• Late/lazy binding of all entry points (that is, we do not even attempt to resolve any entry point ...

pip's changes to not install pre-release software caught me up on my bad habit of just leaving alphas and betas of little-used packages that pass testing up as the "final" release. While I'm going to have to get that habit quashed, I've updated OpenGLContext-full in the meantime to pull the correct betas and have pushed new betas for PyVRML97 and OpenGLContext.  Long story short, you can now do:

pip install "OpenGLContext-full==3.1.0b1"

and on Ubuntu 13.10, at least, you'll get a working OpenGLContext environment.  As usual, there are some caveats, such as needing ...

Went through my piled-up PyOpenGL email from the vacation and tried to address the various bugs and issues. Other than confirming a fix on hardware I don't have we should be pretty close to ready for a second beta. I regenerated the extensions based on the latest khronos api svn, so we should be pretty up-to-date, but I really need to get some GLES test cases to confirm that we do actually have basic GLES2 support working.

So I wanted to work on a little web-toy that would let kids "hunt" for high frequency words  (basically vocabulary words that need to be immediately recognized) in a field of words. But as they don't necessarily know the words yet, it needs to be something that's read out audibly "Click on <blah>" and then I ran smack into the number of high frequency words in even the first 4 years of school (it's 168 in our school).  That's a lot of words to read out, process, and save just to see if the web-toy is ...

We've had a binding/platform for the Off-Screen Mesa (OSMesa) library for a while now. It was originally coded such that it provided all of the OSMesa entry points from the platform package (not really appropriate, as these are the same level as things such as GLX and WGL). Long story short, they've been moved to OpenGL/osmesa instead. Code that uses OSMesa in PyOpenGL can just update the imports to

# from OpenGL.platform import *
from OpenGL.osmesa import *

to get the entry points that have moved.

So as part of getting a PyOpenGL demo running on the Raspberry Pi I wrote a trivial subset of the Broadcom graphics interface api in ctypes.  There's an (abandoned? not very recent, anyway) full wrapper in Cython, but even getting that compiled just took too long for me working on the Pi (far longer than writing a ctypes wrapper).

The little wrapper module needs work to be usable, but I don't really have the interest needed to do what needs to make it truly useful.  What really seems to be needed is to take the 5 or 6 ...