Customer Reviews

OpenGL SuperBible: Comprehensive Tutorial and Reference (5th Edition)

5 star:		(7)
4 star:		(6)
3 star:		(4)
2 star:		(3)
1 star:		(3)

 

 

For years, books in the OpenGL SuperBible series were recommended for anyone looking for an excellent tutorial and thorough coverage of OpenGL features. But up to OpenGL 2.0, programming in OpenGL was done through the fixed function pipeline, and the OpenGL SuperBible books were the best place to start learning that. With GLSL introduced in OpenGL 2.0, OpenGL supported both the traditional fixed function pipeline and a new programmable pipeline where you can write your own shader programs and have much more control over the graphic card. OpenGL 2.0 tried to have the best of both worlds: if you liked the old OpenGL then you can use it, and if you wanted to experiment with modern OpenGL you can use that as well. That resulted in a huge API with conflicting design goals. This conflict can be seen in the OpenGL(R) SuperBible: Comprehensive Tutorial and Reference (4th Edition), reflecting the version of OpenGL it covered. The tutorial part focused exclusively on fixed-function OpenGL. That part was excellent and I still use it as a reference when I'm programming for old mobile devices that supported only OpenGL ES 1.0. The book also introduced shaders among other advanced topics in the second part. This introduction didn't really follow from what you learned in the tutorial part. It was a group of separate articles that were written in a different style and tone. I don't doubt you can easily pick it up and learn writing shaders from these chapters, but they didn't really go about teaching you how to write shaders, instead focusing more on showing you cool examples of stuff you can do with shaders. Given that a lot of what you do with shaders requires a mathematical background -- which the 4th edition got around by introducing only what's necessary, someone learning OpenGL without such a background would get confused when suddenly the later chapters are talking about cosines and other concepts.

Eventually, the OpenGL API evolved and the fixed function commands were all deprecated and later moved to a different profile. The new OpenGL was much leaner and only revolves about creating shaders and writing to buffers. The problem is that it's easy to teach the old OpenGL, you don't need to know the underlying details of how light is calculated or how transformations are performed to write a program in fixed function OpenGL. You can get away without teaching anything but basic mathematics, and you could still come up with strong examples. With modern OpenGL, things are different. There is no built in lighting equation, no matrix stack, no functions to rotate an object or set a camera. You have to write all of that yourself. A book teaching modern OpenGL, or the core profile of OpenGL 3.3, needs to teach you not only OpenGL, but also the fundamentals of 3D graphics. Such a book would be quite big, advanced for many users, and wouldn't be able to cover all the features of OpenGL. How can you create a simple and thorough book about modern OpenGL? If you can assume that the reader knows the fixed function pipeline, then it's easier to teach them the new features. But what if you can't assume that?

The authors of OpenGL SuperBible 5 found a way around, and it works quite well. The authors built a library that allows people to start writing impressive programs right away. They don't have to worry about setting up vertex buffer objects, writing shaders, or any of that. This way you can start teaching by giving practical examples, and you slowly teach OpenGL by introducing the concepts behind that library. Make no mistake, this book doesn't teach you to use that specific library, it teaches you OpenGL. Anything you do with the library you will learn to do yourself in OpenGL in later chapters. Shaders are introduced early and follow wonderfully from previous discussion. Many advanced features are covered in detail and you learn how to write shaders, and not just how to copy and paste example code. The result is fantastic; the tutorial part is by far the best introduction to modern OpenGL you'll find. You still don't need a mathematical background, and the 3D math chapter does a good job of introducing all the ingredients you will need to write programs.

The book is divided into 3 parts. The first part is an introduction and tutorial, the second part is about advanced topics such as buffers and dealing with geometry, and the final part is about platform specific issues including a coverage of OpenGL ES for mobile devices. The tutorial part is great and if the book constituted only of this part, it'd definitely be worth buying. The advanced topic coverage is really variable. Some topics are covered in great detail and with useful examples (I really liked the introduction to the geometry shader for example), other topics are introduced in a hurry and just throw examples at you without even explaining what the example is supposed to do or teach. I'm not sure if this is really a bad thing. You need to realize that some of these advanced topics are actually quite advanced, and the book doesn't assume much from the reader. Including them in the book is a benefit because once you've learned more from other sources or from your own experiments you can go back to these chapters and understand them better. None of these chapters is bad, they just don't follow from what you learned from the tutorial part. For example, the basic idea of multisampling is introduced early, which is good for an example where you just enable multisampling and see the result. Later chapters go into the fine details of how multisampling is implemented, based on the basic introduction. If you already understand multisampling then it'd all make sense, but if your only source is the book then it can be hard to follow. Another example is the chapter which introduces buffers, the sample program tries to 'look cool' where a simpler (and uglier) sample would have been more appropriate.

Speaking of the sample programs, the code is generally well written and properly commented. Going through the source code for the book library is a great way to learn. Most of the samples compiled fine on Linux (using the binary Nvidia driver), but some gave me black screens or wrong results. I also had to make some changes to the code to make certain samples work. A few samples don't even come with makefiles for Linux. I sent an email about it to the author and it'll hopefully get fixed eventually. The google code repository where the samples are hosted does get updated so I wouldn't worry much about that.

Summary: if you want to learn modern OpenGL (post 3.0), then get the book. Even if you already have the 4th edition and know a bit about shaders and buffers, you will still benefit from the book because it covers many more advanced topics and I'm sure there will be a thing or two you didn't know about. While I spent some time talking about perceived problems like complex advanced chapters or few samples that don't work, I assure you that it's not as bad as I make it sound. I just thought it was fair to note these minor issues in case there was a 6th edition for OpenGL 5.0! I was worried about two things when I considered getting the 5th edition: (1) I already have the 4th edition so is this an incremental update or something completely new? And (2) if the book uses a library to hide some of the advanced features then does it spend a lot of time on that as opposed to teaching real OpenGL? The answer to the first question is that it's a completely new book that is exclusively about OpenGL 3.3. The answer to the second question is, like I said earlier, that the book library is there for a purpose, which is ultimately teaching you how to do things with nothing but OpenGL. I apologize for writing so much, I never wrote a book review before. :)

Shorter summary: buy the book!

I've learned OpenGL thanks to Richards books (the 2nd and 4th editions of the SuperBible), and today work as a professional 3D game engine programmer. Those books are very educational, and allow a newcomer to learn OpenGL faster than any other OpenGL programming book I've found. The 5th edition focuses on the new "core" OpenGL profile, which has deprecated the legacy "fixed function" API. The authors admit that they had a difficult task when rewriting the SuperBible - how do they lower the barrier of entry to a new API which is not beginner friendly? Their solution was to create a new OpenGL toolkit which simplifies access to core OpenGL. And this is the biggest issue with the 5th edition of the SuperBible - the book explains their custom toolkit, and not OpenGL itself. What a disappointment for someone wanting to learn modern OpenGL.

My recommendation for new comers to OpenGL and 3D programming: get the 4th edition of the SuperBible, and then grab the OpenGL ES 2.0 Programming Guide to learn about the "core" OpenGL profile. With OpenGL ES 2.0 (embedded systems), the Khronnos group have removed all the legacy accessors from OpenGL, and left only the bare minimal needed to create 3D applications using programmable shaders. The Khronnos group did such a good job with ES 2.0, that they decided to remove all legacy code from core OpenGL as well, and today (with the exception of geometry shaders), OpenGL ES2.0 and OpenGL 4.1 are essentially the same API. The ES2.0 programming guide also explains modern 3D graphics hardware design better than any other book I've discovered, and more importantly, it not only explains how to access the hardware using the new API, it explains WHY the API evolved to what it is today. Why is there a limit to number of attributes? What are the benefits of packing attributes? How to pack them? etc. All of this is covered in the ES 2.0 book. Richard Wright's SuperBible ignores them. The WHY is more important than the HOW.

Hopefully, Richard will correct his mistake with the 5th edition, and a rewritten 6th edition will be something magnificant.

Do NOT buy. See update below.

CONS:

> the book explains their custom toolkit, and not OpenGL itself.

1) I have to agree with this. There are some examples in Chapter 4 that are nothing but calls to their wrapper!

2) OpenGL 3.x and above is "all about shaders", but it takes them 7 chapters before they even bother to get around to discussing them.

3) The code examples aren't that good. Just lack of overall quality and most don't compile cleanly without a bunch of tinkering.

4) Author doesn't take feedback or bug reports to kindly :/

5) The author doesn't know his "target audience". Anyone learning OpenGL more than likely has some background and education in CS/Math - but he writes the book as if he is giving an "intro to 3d programming" to highschool kids. It's a really awkward disconnect and doesn't flow well.

6) It's called a "Super Bible", but doesn't live up to it's name. There are better documentation out there and think it is a bit arrogant of him to claim such a title for his book.

7) it's quite costly.

PROS:

1) The chapter on textures isn't bad. It is adequate if you never worked with them before.

2) The book it's self has nice binding/pages.

UPDATE:

1) When I say the code is bad, it's really bad. The project/build is disorganized worse than some "last minute" undergrad projects! Very unprofessional. Secondly, the further along with the book you go, the worse the code becomes! Starting around Chapter 9 the code is just broke unless you are willing to put in hours to debug, clean up and fix their mess. It is very clear they do not have a professional build manager on their team.

2) Their is no maintenance/updates for this book. The release the book and let the code rot. They have the source on google's code site, but there are dozens of bugs that have been outstanding for awhile without being addressed. Once they have your money they have no motivation to update their code (other than say, professional integrity and pride at a job well done; but guess that isn't enough these days). Even if you submit bug fixes, they don't/won't update the code for others.

I'll add one more PRO 3) It does try to cover the "new" stuff (programmable pipeline). Generally this is what you want in a book unless you have to maintain old code.

Lastly: In my opinion what they should of done was start off with a FULL version of a textured Hello Triangle in pure OpenGL and C (only using freeglut for window management) and then spent the next 5 chapters explaining each part of it. Seriously their wrapper was a bad idea. It's like if you were to get a book on how to use the Standard lib or Boost (or any other large API), but instead they wrap all the functionality in another API because they though it was to difficult to teach. The entire reason for buying the book is the understand it and use it effectively! You can't do either of those if you hide everything behind a wrapper!

**If you want to learn OpenGL, get one of these books:**

Far as I know, these are the only books covering the "new" programmable pipeline (ie, 3.x+):

OpenGL ES 2.0 Programming Guide. - At chapter 2 they take you though "Hello Triangle" with REAL OpenGL code. ES is "close enough" to normal branch that if you understand it, you'll be able to easily convert your skills/code.

OpenGL Shading Language (3rd Edition) [the orange book] - Not an OpenGL book per say, but you will learn more about OpenGL in the first 4 "review" chapters than you will from this entire super bible. It's brief [in regards to opengl; not glsl], but comprehensive. They even tell you for certain the "new and correct" way of doing things (unlike SuperBible were it is fuzzy at times or even worse; using deprecated shaders like in chapter 8!)

I've heard bad things about the red book (see the amazon reviews); wait till they have a new edition (late 2011 I think).

The superbible lays out the OpenGL 3 core profile in a brief but thorough enough manner. This is currently the only book on the market that doesn't resort to the now deprecated immediate mode for OpenGL. It gives good coverage of all the basic and more advanced techniques of rendering, and successfully walks the fine line of keeping you motivated (through rewarding examples) and giving you a thorough enough education such that you aren't going to be completely stumped when you step off the beaten path.

The examples bundled with the book are however quite patchy, many fail to run successfully on Vista with a Nvidia GTX 280 (an OpenGL 3 capable card).

I'd change my review to a 5 once the issues with the samples get sorted out, as this book is a delight to read and Wright's teaching experience rings through in the pacing of the book.

What can I say. The examples in the book JUST DO NOT WORK. All the comments here on amazon here say it over and over. But I was thinking I could solve this like some of the others claim they have, but boy was I wrong. The source code REQUIRES two libraries. freeGlut and GLTools. The problem is not Glut32 / freeglut ( yes I even got freeglut to work ), the problem is GLTools. Its not compatible with ANYTHING. There is very little support for it. And this book uses it as their MAIN library. What a shame. In fact, the author gives you code that he supplies for the book, well that's cool but what good is it if the code is way too glitchy and refuses to compile.

The point here is, the author says in his book that he is using a MAC ( Under XCode IDE ). Windows and Linux users, hang it up. Your not going to get anywhere if your using another compiler other than Visual Studio. And what really is annoying is that he explains how Direct3D ( a product of Microsoft ) and OpenGL is at war with each other, and yet the author of the book promotes the use of Visual Studio throughout the book. So people who use GCC ( non microsoft compiler ) have no way to get help with this. I use Code::Blocks with MinGW. Like I said, I can get a working Glut / FreeGlut, heck even with a triangle, but GLTools has never worked. And sadly, that's all this book uses is the freeglut and GLTools libraries combined.

I did a ton of research all over google for answers, and even Visual Studio users were having trouble.

What it feels like when you read the book and try out the source code is that the author didn't run a clean copy of the code from scratch and worked out the bugs first before going public with the book. Rookie mistake. And that means he messed up when he switched to using MAC instead of trying this out thuroughly withy other compilers like MinGW / GCC.

Whats funny however is SuperBible 4th edition code works right out of the box. Go figure.

Since the release OpenGL 3.0 ( which deprecated the fixed pipeline ) we have not had a proper book to learn OpenGL. The OpenGL Programming Guide ( 7th Edition ) long considered the de-facto book for beginners was less than an ideal way to learn OpenGL ( to put it mildly ). The reader had to sift and filter through page after page of deprecated functionality to gather the required knowledge to use the programmable pipe-line.

The latest edition of OpenGL SuperBile fixes that situation. This edition has been a complete re-write over the previous edition and comprehensively teaches the usage of programmable OpenGL. Every aspect that an OpenGL programmer might need is covered is a easy-to-read and understand manner (3D Geometry, 3D Math, Basic Shaders, Textures, Advanced Texture Effects, Buffers, Fragment Operations). It would have been great to have a picking example which seems to be missing.

A combination of this book along-with the latest edition of OpenGL Shading Language completes my search for a Comprehensive OpenGL Tutorial.

The book is a mixed bag. Code samples starting with chapter 9 do not work. Even some earlier chapter code samples require you to make changes. Shaders are still written for GL 1.2. Quite disappointing. The book is for beginners. It has little value beyond the entry level.

OpenGL 3 has been out for a while, but the literature has failed to keep up. The popular red book, for example, did nothing more than apply a flaky patch to its existing content: deprecated features were marked as such, but there was no convenient way to learn "the way of OpenGL 3". It was rather disheartening to see how many features were deprecated with no references to the OpenGL 3 equivalents.

The SuperBible 5th Edition fixes all that. It contains pure OpenGL 3 content (focusing on the 3.3 core profile). In fact, it explicitly states that if you have any intention of learning/using the legacy profile (version 2.1), you should go purchase the 4th Edition. Owning both the 4th Edition and 5th Edition will certainly maximize your OpenGL firepower (version 2.1 is still very much relevant today), but the 5th Edition is perfectly fine on its own.

With the removal of the fixed functionality pipeline, this book does an excellent job of bringing GLSL (the shading language) to the foreground. OpenGL 3 is considerably lighter than OpenGL 2 in terms of API complexity, so the focus is right where it ought to be: in programming the GPU to render scenes the way you want them rendered. This gives the programmer a much greater understanding of what is actually going on underneath. Building shaders to achieve certain visual effects is much smoother than operating the 9,001 buttons, switches, and knobs that make up the old fixed pipeline.

Getting a shader up and running can be a struggle for someone relatively new to 3D graphics programming, but it becomes second nature early on. Fortunately, the examples in this book provide a well-written set of tools that simplify the process. This allows the reader to learn essential principles before having to deal with the dozens of necessary setup and cleanup commands. For veterans of OpenGL 2, it is an especially smooth process because the provided toolkit closely mimics the old commands for drawing in 3D (glBegin, glVertex, etc.).

The code examples are decent. There is a publicly accessible SVN repository for obtaining the latest source code files, so bugs are cleaned up as time goes on. The GLUT library works fine; the only program so far that struggled to work was the Windows-specific example (where it attempts to replace GLUT with WGL).

This book is crucial to learning OpenGL 3. There are no better sources for doing so. Hopefully, over time, more good OGL3 references will come out. Until then, this book is your best shot. Even after you have mastered the tools, the book will never leave you desk as it contains a complete API reference. You can read up on any individual function along with its parameters, error codes, constraints, etc.

In short, BUY IT RIGHT NOW.

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.

I'm completely new to OpenGL.

Good:

Taught you a lot about the basics about OpenGL and computer graphics as well.

Teachs you how to use freeglut which isn't part of OpenGL but a helper library to avoid having to set up system specific setups to use OpenGL.

Also showed examples on writing shaders for your programs.

Show you the 3.3 OpenGL core for reference.

Bad:

Took me awhile to figure out how to setup the first example had to do a lot of online search to figure out that all the heading files are scattered in their downloadable source files.

When I got to the chapter that tells me how to load and compile your custom built shaders It didn't work for me at all found an online one that kinda worked until I went to the 3D rendering part.

It's assumes you have prior knowledge for windows programming so you might as well find a good book on the that teaches you that.

This didn't affect the score but they put the color plate pages near the center of the book so the binding bends real easy there when you open it up and that tends to split the binding a litle till the color plates fall out.