Customer Reviews

OpenGL SuperBible (3rd Edition)

5 star:		(8)
4 star:		(1)
3 star:		(1)
2 star:		(1)
1 star:		(1)

 

 

1173 pages of everything you need to know about how to program in Open GL and it's extensions in areas like shading. This is the third edition of this book, and like Microsoft's software, with the third release it's finally come together pretty well. It starts off with a pretty good introduction. I like that. So many computer books seem to leave out the first twenty pages that should describe just what it is that we're trying to do here.

After it says what we're trying to do, then it talks about where Open GL came from, why it came at all and where it's going. It starts simple with a program that's only about six lines of code. From there it gets as complex as you want to go.

Covers of computer books often say something like "For Beginning to Intermediate Users." It's rare that I find that this is true. Usually the books are too short to start out simple enough and then take it far enough to truly cover the intermediate lefe. This one does.

The worst part about programming books is most of them assume that you already know everything there is to know about the subject before you begin.

This book is incredible for learning OpenGL, in one month I had gone from absolutely zero programming knowledge about OpenGL, to creating an immersive 3d environment.

I recommend this book to anybody as the absolute best resource for OpenGL.

This book is so comprehensive and well written, its not just a Bible...its a SUPER Bible. The authors make everything very easy to understand and the CD it comes with has some really useful goodies on it. It assumes you have a working knowledge of C/C++, but not much beyond that. It makes 3D rendering very approachable.

I would class myself as an intermediate-level OpenGL programmer, concentrating mainly on Linux programming with nVidia hardware but also interested in Mac OS X. I bought this book because I was interested in learning about the more advanced OpenGL features: shaders, shadows and vertex buffer objects.

For my purposes, I have found this book to be shamefully poor. So bad that I am going to return it ASAP. The parts of the book which cover topics of interest to me appear to be factually incorrect and are accompanied by incorrect code. The descriptions are minimal and padded out with enormous amounts of code. The code compiles on all the machines I have tried in on but segfaults reliably at startup. Specifically, the bufferobject, occlusionquery, vertexblending and vertexshaders demos all segfault. The lowlevelshaders, highlevelshaders, bumpmapping, fragmentshaders, imageprocessing, lighting and proceduraltex demos also fail to work. I believe this is because they are not properly written and fail to make use of the available features, quitting when they discover that not all of the state-of-the-art features are available simultaneously. The only demos which do work are the trivial ones or the plagiarised ones.

Moreover, the parts of the book which cover basics are often either plagiarised verbatim or plain wrong (much better information and code can be found on the web, e.g. NeHe, and in the OpenGL Red Book). Many of the descriptions are needlessly convoluted. Many of the diagrams are huge and pointless. I suspect this is simply because the authors are way out of their depth.

I hope this review will help anyone else duped by the claim of Linux compatability. I would also caution readers interested in Mac OS X and Windows because the examples and code are likely to be misleading and are definitely not platform-independent. In the future, I would greatly appreciate more honest authors who stick to what they know.

Just starting to get use to all of the opengl features , and this book is great since it gives detail from various perspectives.

I am a complete beginner in computer graphics and have found this book to be clear and really helpful. I can recommend it to anyone who wants to start graphic programming.
I hope this helped someone.

OpenGL SuperBible (3rd Edition)

To me, this book is at average rating. The explanation of the book is quite confusing in some sense. First of all, if you follow the book sample coding by including "OpenGL.h" header file, you may find that it does not work. In fact, the header file name is "OpenGLSB.h". For this small thing which the author is failed to correct it before the publication of the book, it is a failure. For beginner like me, it is really a bad experience to have first sample coding does not run as expected.

Second, this book shares common mistake as done by other books. The author assume that you already know how to setup the OpenGL enviroment before you proceed with your programming. In fact, before you can program using OpenGL API, you need to setup the environment first. For this, you have to browse to OpenGL official site http://www.opengl.org for the OpenGL environment-setup details. For most beginner may think that the OpenGL API is to be used as common C/C++ program, which leading them to bulk of errors. To me, the author must tell the users what to do before program in OpenGL, but he didn't. It is another failure of the book.

The other reviewer has claimed that 12 chapters of the book can be finished in 12 hours. This claim is very subjective. For a beginner who know nothing about computer graphics, it is very impossible to finish that many chapters in that specified time as claimed by the reviewer.

At overall, this book is still the best OpenGL book in the market. This book does not use many of the mathematic jargons but still can make you a successful OpenGL programmer. This is the really great part of the book! However, for those who want to learn advance graphics programming, I don't think this is the book for you. It can serve only as reference where you want to refresh your OpenGL knowledge.

This is by far the best OpenGL reference I have ever come across. I keep it on the edge of my desk for easy access. It is easy to understand and formatted in such a way that allows me to find exactly what I need to know quickly. Excellent purchase.

My problem with this book can be surmised as
- it assumes the reader knows nothing about programming;
- it tediously explains the obvious;
- it is laced with irrelevent code that is over-documented to waste space;
- it wastes space with reference material that would be better suited on the CD (if the authors wanted to include it);
- and it ultimately doesn't _TEACH_ very much

"OpenGL Programming Guide: The Official Guide to Learning OpenGL"is by far a much better book to read. It has code examples, certainly, but there is only one very succinct example per chapter to demonstrate what the chatper taught.

This book is like many computer books that assumes the reader knows next to nothing about programming. I think this is a poor way to write books on a particular subject. I believe that a book on computer graphics should be ABOUT computer graphics and should therefore assume the reader is already a competant programmer. You have to learn how to walk before you can run; and you have to have some idea of how to program before you can begin to think about programming graphics. Surely, then, the book should be aimed at people who can already program; and if someone can't program, they should buy a book on programming first.

For example, page 51 says:

"Listing 2.1 contains only one include file:

#include<OpenGL.h>

This file includes the gl.h and glut.h headers, whcih bring in the function prototypes used by the program."

Surely a potential reader should be expected to know why include files are included? (This section also raises the question; why not just #include GL/gl.h and GL/glut.h and be done with it? But I digress.) It continues;

"Next, we skip down to the entry of all C programs:

void main(void)
{"

Are the authors serious? If they are, then perhaps the next version of the book will begin with a tutorial on what a computer is and how to read English. (Incidentially, a discussion on "constructors to initialise variables" is on page 992; so it doesn't just stop at chapter 1)

I believe a graphics book should talk only about graphics priciples and use code only at a bare minimum. Code is just a vehicle for implementation; using it to replace or augment discussion only demonstrates an inability to express ideas. The book is heavily laced with irrelevent examples. For example, pages 550-554 tediously transcribe the code to draw a bold head, which is ultimately an extruded hexagon. What does the source code prove or demonstrate? Do the authors believe the reader's heads are completely full of dead insects and can figure out the code to draw an extruded hexagon for themselves? If you want to include code, anyway, why pad it with irrelevent space, like

// Done drawing the fan that covers the bottom
glEnd();

you could collapse the comment (which is largely irrelevent, anyway) and call to glEnd() to one line and save space. Sure, it's only one line; but this is ONE example from a book that wastes pages and pages with useless code examples. I guess it is aimed for readers who feel happy buying big, expensive books.

Heh, another example of the insane levels of over commenting:

float CubeRotation[3] /* rotation of cube */

cheers for that, Mr Authors Sir! I could never have guessed the purpose of the variable CUBE ROTATION represented the CUBE'S ROTATION. I'm so glad you're there to tell us these things.

The book also dedicates a LOT of space to detailing the manual pages of OpenGL which they've just grabbed from an online man(ual) page. So, this book is an expensive way of getting specification stuff that doesn't actually TEACH you anything. However, if the authors want to include man pages, why do they insist on expanding out the definitions? Other books on OpenGL that I have seen conveniently use well understood regular expressions to represent the vast range of OpenGL prototypes rather than tediously enumerating EVERY variant of the function. glVertex*(), for example, has 12 versions divided into 3 groups. Each group represents a different number of parameters (2, 3 or 4); and each member of that group has a different type (double, float, int, short). Most books write that explosion of types as glVertex~n~type(type v1, type v2, ...)... and that's it. Instead, the authors spend half a page listing each prototype... not just for glVertex, but for the MYRIAD of OpenGL prototypes that have a SIMILAR state-explosion. Great.

The book is certainly designed to be big and hefy and look important. It does that by uselessly padding space, including too many code examples without any point, and including reference material that the athors didn't write. Very little space is actually dedicated to TEACHING the reader about OpenGL.

Simply amazing. That is the best way to describe this book. The author uses the glut library to keep cross platform compatibility but has 3 chapters dedicated to each OS (Mac OS, Linux, windows) for those who would rather use OS specific windows/input/etc handlers. As long as you have glut installed and configured correctly on your machine you should have no problem getting the examples to run. He even goes over how to install and get glut running. I my self use SDL (simple direct media layer) to keep my app cross platform compatible and had no problems what so ever porting the very small amount glut code to SDL.

I was a little worried after reading the one and only review of this book that did not get 5 stars (as of this review), but found most if not all of the complaints to be unjustified after actually reading the book. Im sure the authors are in their "depth" seeing they were part of the ARB (OpenGL Architecture Review Board). Yes some of the examples did not work on my laptop but that was only because my laptop did not support some of the advanced topics that required OpenGL 1.4 or better. As for being worthless for Linux, I'm having a hard time seeing how this even applies since OpenGL is a standard and has nothing to do with the OS specifically. OpenGL does not provide a window for you to draw on (that's up to the OS to provide with glut, SDL, whatever). The only problem I found with this book was one of the chapters source code was missing on the CD, but since he lays out pretty much all the source code in the book in a very clean manner along with the output of each example this was not really even a problem.

I am not what you would call a fast reader by any means but I was able to read the first 12 chapters (around 700 pages) in about 12 hours with out much previous OpenGL experience. I don't think I have ever even read a book over 300 pages before this! I found this book almost impossible to put down which is also a first for me. I think this is attributed to the fact that the author made things so clear on why things worked the way they did and how to implement them in a very straightforward way. Even chapters I thought I would not like (for example OpenGL's powerful 2d imaging) turned out to be one of the best in the book. Another great thing about this book is that everything is laid out in order. He continues to build off of previous chapters which makes it really nice that you don't have to skip all over the book looking for stuff you have not learned yet. The author does not expect you to know anything about OpenGL or 3d graphics ahead of time. He also provides after every chapter ALL the gl/glu/glut commands he uses, detail descriptions and all the possible flags/options available at the time the book was written. This makes this book the ultimate reference as well. I could go on and on about this book, but will stop here. This book was well worth every penny.