Why Learn OpenGL 2
With this though begs the question as to why I see OpenGL 2.x still being a valuable asset and why I continue to update the tutorials for it when everyone is using OpenGL 4.x or OpenGL ES(2), heck, even WebGL is building traction and I heard IE is going to start supporting it.
Well, I see OpenGL 2 as a learning tool these days. Anyone who wants to jump into computer graphics can either try wrapping their head around shaders and matrices, or they can play with the features provided in the OpenGL fixed function pipeline and get their head around the basics first.
I started learning OpenGL back when OpenGL 1.5 was big and 2.0 was on the way. I remember the release of 3.0 and the release of 4.0, with their minor increments in-between and I remember thinking about the massive learning curve involved in jumping from pure OpenGL 2.0 to OpenGL 4.0 with the complete removal of the fixed function capabilities. OpenGL 3.0 was a middle-ground where you had the option of using the fixed function pipeline and features were deprecated, but it all still worked even if it wasn’t guaranteed. Then OpenGL 4.0 came out and decided that everyone had to jump into this new way of programming computer graphics.
This also reminds me of when I first started programming in Direct3D. I even had a portion of this website dedicated to Direct3D at one point in time. But it was a difficult switch because I hadn’t touched shaders back then, I didn’t know how a translation matrix worked, yet Direct3D expected me to know all of those things. OpenGL 4.0 is much more similar to Direct3D in terms of what it expects you to know than OpenGL 2.0 is.
When I was a kid, I just wanted to draw pretty pictures on the screen!
So I continued on my OpenGL 2.0 path, outgrew it and started learning shaders, started doing research at my University where my job was the implement the graphics in AR systems and around this time OpenGL 3.0 came out. It was actually kind of an eye opener in the regard that I was having to copy the OpenGL matrices from OpenGL into my application and then from my application and into my shaders so I could do things such as shadowing. But now I was in control, I could do everything. GLM the OpenGL Maths library came out to help with the generation and use of these matrices and I realized that while OpenGL 2.0 was great and I could do what I had wanted with it, I was still restricted by what it wanted to do in the background. The control shifted though with OpenGL 2.0 to 4.0 from being in the hands of OpenGL, to being in my own hands.
BUT, while it’s great to get into the higher versions of OpenGL, OpenGL ES and WebGL, if you were like me and started young (about 13 years old for me) I didn’t have a clue what was going on in the background. All I knew was I could draw shapes, I could read in points to draw my shapes, I could put pictures on my shapes, I could call glTranslate and move my shapes. Over time I got an understanding of what was going on, but I was eased into it all thanks to this fixed function pipeline from OpenGL 2.0.
It is this easing-in period that I am trying to preserve by caring for the OpenGL 2 tutorials. You get a very basic understanding and capability with computer graphics that won’t scare you off and will also help you out later on. For glTranslate and glRotate to work correctly, you have to get an idea of ordering, which directly relates to how the matrices work and once you know how these calls work, you can jump into OpenGL 3/4 and start using GLM to interact directly with the matrices you require.
In short. OpenGL 2.0 is a precursor, a learning ground and a way to start programming in the big, scary world of computer graphics, without most of that scariness staring you straight in the face.