Author: Graham Sellers, Richard S. Wright & Nicholas Haemel
Publisher: Addison-Wesley
Pages: 848
ISBN: 978-0321902948
Audience: Those new to OpenGL
Rating: 3
Reviewer: Mike James

Subtitled "Comprehensive Tutorial and Reference" this tome looks as if it should be the authority on getting started with OpenGL. 

This is a thick book and part of a well-respected set produced by Addison-Wesley that is generally thought of almost as the standard OpenGL documentation. This particular volume, now in its 6th Edition, is a tutorial introduction to programming OpenGL using C.

There are two important aspects of the book that you might want to know because they might influence what you think of it.The first is the less worrying. All of the illustrations are in black and white and many are just black blobs. This isn't a problem if you are following the examples and actually running the code because then you get to see in full color what they do. Personally I don't think the figures are an issue.

The second aspect is more of a difficulty. All of the examples use a framework that you use to access the OpenGL facilities. This makes it a lot easier to get started, but it also means that you can't easily spot what is raw OpenGL and what is a framework function. In addition as the code isn't well maintained or documented if you encounter problems when you try the code out you can't be sure whether they are in the framework or the raw code.

If you want a book that takes a pure approach and only uses code in OpenGL, GLUT and GLFW then you need to look elsewhere.

The first part of the book is called Foundations and Chapters 1 and 2 do start out with some very basic first steps. First you get to draw a single pixel as an introduction to using shaders - a "hello world" of graphics. The first example didn't work for me and I still don't know why. The rest of the examples I tried mostly worked but small tweaks were often necessary. The biggest problem is that Chapter 1's introduction doesn't do much to get you to understand anything at all about OpenGL. The most likely response is "what's a shader?". 

It gets better, however, and at Chapter 3 we start to look in more depth at the pipeline and all its shaders in every form. The trouble is that it makes OpenGL seem very, very complicated. Overall OpenGL is complicated but there are ways of introducing it that doesn't simply blast you with all of the possibilities in one go. 

Next we have a discussion of the math needed to understand 3D graphics. Topics covered include vectors, matrices, transformation, and all the way up to quaternions. I'm not sure why it covers quaternions because it doesn't get us far enough to see how they might be useful in representing a rotation. It also covers the coordinate systems in use in OpenGL. Unfortunately it doesn't do a very good job of explaining the ideas of the perspective transformation which is fairly central to most 3D graphics. This is an important chapter but you do need a good grounding in math beforehand to make sense of it and you probably need to read some more to make sure you get a working understanding.

Chapters 5 and 6 are about the data types used by OpenGL and the structure of shaders. One of the things beginners find hard is the way OpenGL uses buffers and this doesn't do too much to help. It is a complete and fairly intense look at the topic and this doesn't make it easy to get into. 

Given the level of the previous two chapters, it might come as a shock to the beginner that that next section of the book is called "In Depth" and looks at the fine detail of creating graphics. Chapter 7 is on vertex processing and graphics commands; Chapter 8 is on primitive processing and Chapter 9 is on fragment processing and frame buffers. Chapter 10 is about compute shaders, which are used to do general computation and are not directly related to rendering. Chapter 11 rounds off the section with a look at how to control and monitor the pipeline.

The final part of the book is called "In Practice". It introduces many of the basic ideas and techniques of graphics - Phong shading, material properties and so on. Much of the difficulty in following the earlier parts of the book are due to the fact that you have to know something about what is in Part III to appreciate why you are doing things at all. If anything, this section is far too short and the nitty gritty of graphics is really only given one 80 page chapter. Chapter 13 moves on to debugging and Chapter 14 deals with system specific features and covers Windows, Mac OSX, Linux and mobile platforms via OpenGL ES. 

Overall this book makes it very difficult to see the wood for the trees. It doesn't distinguish well enough between its own framework and what is basic to OpenGL - for me this makes it a non-starter. It also covers a lot of fine detail without putting together well enough for the beginner to see the relevance of the detail. It most certainly isn't a book that will teach you how to program games, say, as it doesn't cover topics such as object intersection, collision and user interaction. It is more about the fine control of creating and rendering 3D from scratch. If this is the sort of book you want then it might well be a good choice, but as a tutorial for the beginner it is best avoided.