Building stuff!

In the beginning, there was OpenGL 1. It didn’t even have the ‘1’ back then, it was just OpenGL. It was fairly basic, it had ‘Immediate Mode’, where you told it what you wanted it to draw as you went along, and a “Retained Mode” where you saved up a bunch of Immediate Mode instructions in display lists and told OpenGL to execute the contents of the display list when you needed it, or created arrays of data and had the system draw based on the contents of the arrays. The rendering pipeline was fixed, you turned on and off features as needed, and had to work within the constraints the pipeline imposed.

It was simple, generally easy to use, easy to understand. You could do a lot with it, and for some purposes it is still enough.

But as time passed, more features got bolted on in the form of ‘extensions’, until several of the most useful and commonly supported ones were squished into the standard, along with some new features, and OpenGL 2 was pushed blinking into the light of day. OpenGL 2 kept the fixed function pipeline, but introduced vertex shaders and fragment shaders, that optionally allowed you to replace chunks of the pipeline with completely programmable sections. If the standard, fixed pipeline couldn’t do something you wanted, or you could provide a faster, application-specific version? You could write shaders to do it – it combined the ease of use of OpenGL 1 with drastically more scope and power.

And then came OpenGL 3.

OpenGL 3 deprecated, and then removed, the fixed functionality, the immediate mode, and lots more on top. For people trying to squeeze the last drop of performance out of the graphics card – game programmers in particular – this didn’t even really register, as they’d already been using the features that were to be the future of OpenGL. But there are a lot of people out there that don’t fall into that camp – a lot of old software relies on the deprecated features, and the change turned OpenGL’s learning curve into a learning cliff.  It also makes hammering out quick tests, or simple features that don’t need absolute speed but do need rapid development, a lot harder to pull off. A special “compatibility” mode was added to the specification, which allows the use of the old commands and pipeline (essentially, it’s OpenGL2), and the major 3D graphics card manufacturers have gone on record as saying that they do not intend to actually remove this compatibility mode.

This means that the old features are going to be there for the long term… but  it has also meant is that, since the release of the OpenGL 3 spec in 2008, online tutorials and most books have practically been denying the deprecated features even exist (which I suppose is fair enough, as they are deprecated, but they do still serve a useful purpose, and make learning what you’re doing drastically easier).

What this means for me is mostly academic at the moment – I’m sat here with a GeForce 7900 from 2006, and I’m stuck with OpenGL 2.1 anyway. I’ll probably mostly be using features that haven’t been deprecated, too, so I might not even need to care…  Eventually I will probably need to worry about OpenGL3 and 4’s changes, but for now I have a good reference for 2.1, and a fairly good idea of how to filter what I can find online…

(Yes, there is an OpenGL 4, but the changes that introduced are nowhere near as significant as the 2.1 to 3.0 changes, so I’m not including it here.)