This book is very informative and thorough in its coverage. Before reading this book I knew some 3d math, and a rough idea of some 3D rendering topics, but had no experience with any graphics APIs. After having just completed this book, I can definitely say I have a clear idea of how openGL pipeline works, as well as various techniques for creating different effects, and for improving performance. Overall I am quite happy with this book.
However this book is not without its flaws. There are a few major ones that jump out straight away:
1) The examples use a custom library written by the author called GLTools, which encapsulates most of the math, and geometry submission. I can see the motivation behind this, as it lets you quickly dive into running the examples without the 'boilerplate hump'. However the primary problem with GLTools is that is a major dependency of the entire book, and while it doesn't do anything too complex, much of it is not explained until the vey end of the book (and some of it is not explained at all). At least the source for GLTools is available. This was annoying for me because I wanted to start a mini-project after learning the basics to "cement" my knowledge before continuing with the advanced sections. However I needed to rely on GLTools, because it was intrinsic to the examples (geometry submission - which is not covered until chapter 12, the last chapter), and although the examples were running, I felt like I still didnt really know everything that was happening until I reached the end of the book. If you are new to OpenGL, you cant break off halfway through the book to make a simple app (without depending on GLTools), you must see it through to the end.
2) The book was written by 4 authors, and you can tell; If read cover-to-cover you get a few surprises with keywords or jargon that were never introduced earlier, but are talked about as if they were. This can be quite jarring. The first few chapters flow quite well, but it starts feeling a bit 'glued together' or rushed towards the end - especially chapters 11 (Advanced Shader Usage) & 12 (Advanced Geometry Management). The perfect example of this is in Chapter 11, there is a "Spring Mass System" physical simulation example (probably the coolest example in the book), which uses concepts that are only properly introduced in chapter 12 (Vertex Buffer Objects, Vertex Array Objects, Transform Feedback). Also, there was no source code on the website or svn for this example, even though the book mentions to just 'look at the source code'.
3) Math is touched on very breifly and avoided if possible. If I didn't have prior knowledge of vector and matrix math, I would have found this very frustrating.
4) Extending point 2, it feels like the book was ordered the wrong way around. I would have preferred to have been introduced to buffer management much earlier, and then have the various examples of different techniques and effects later on. It also seems like some of the examples and topics in the book have not been topologically sorted - they have been sorted for the ease of the writer to keep everything in one place, rather than the ease of the reader (i.e. taking into account what they have learnt so far), especially towards the end.
5) Pages 700-937 are just an OpenGL function reference. I cant see myself using this very often, as it would be much faster and more convenient to just look it up on the web/electronically. I would have preferred they instead spent these pages on getting deeper into each topic and covering some of the math. The reference section just feels like a waste of paper.
6) Some of the examples in the book have typos, or incorrect code, or code that doesnt match with the website's code (which mostly runs fine). Any other errors are fixed in the svn repo code. The code quality wasn't very high, and many iterative examples had old comments and redundant code from previous iterations/examples. However it was still clear what the code was doing. On windows, there are precompiled executables provided for the early chapters but not the later ones - a small but noteworthy ommission. As mentioned before there was an example entirely missing (Spring Mass System). I tried contacting the author but have not got any replies back. There are also some examples included in the code (e.g. normal mapping) that are not mentioned in the book (however quite easy to understand as an adaptation of similar examples).
7) There are some conceptual errors in some examples. For example, in the specular shading example, the shader does not take the view vector into account (even though it is explained in the book), and instead just uses the normal vector (i.e. just diffuse lighting with a higher luminosity 'peak' added to it at the same position). This 'mistake' is then carried through many of the examples that build off it. The reason why this may have passed unnoticed is that the light position is fixed. However when you animate the light position, it is obviously wrong (compared to a fixed version which uses the view vector). Mistakes like this made me lose some confidence in the examples.
Having said all of this, I still recommend this book:
1) It is the most up to date OpenGL book. In many ways it is one of the only options if you want to learn openGL 3.3+
2) It provides some very good examples, and does a good job at explaining concepts - what it does explain, it explains clearly and uses some good analogies.
3) It covers a lot of ground and explores performance options and tradeoffs.
This book is very much 'core' - it uses glut for the examples, but has an additional 4 chapters at the end for native platform-specific deployment (Windows, Mac, Linux, OpenGL ES / Mobile). There is no coverage of user input (all examples use glut, and keys to switch modes, simple navigation using arrow keys). There isnt any discussion of application architecture, data structures, models, content creation pipelines, tools, debuggers, etc. It is just focused purely on using OpenGL, and spends very little time discussing the other components or 'scaffolding' required in creating a real-world 3D app.
If you are new to OpenGL you will definitely have learned a lot after finishing this book.