Customer Reviews

OpenGL Programming Guide: The Official Guide to Learning OpenGL, Versions 3.0 and 3.1 (7th Edition)

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

 

 

Much like the other reviewer, I have to admit being underwhelmed. Back at the OpenGL BOF at Siggraph in 2008, it was announced that the authors were working on an updated "Red Book". I waited patiently for this new edition, fully expecting a book that concisely covered the new 3.0-3.1 openGL api programming philosophy. Having used the Red Books for 6 years now, I looked forward to a straightforward narrative that would be easier to read than the spec and a pile of extensions.

Now, to give credit where it's due, this book does talk about the new APIs, (hence the 3 stars). But it is unfortunately littered with page after page of material on deprecated API bits. I can't imagine why the authors would do this, apart from maybe the publisher pushing a page count?

[...edit - I went on and on...]

Anyway, guys, please, if you're reading this, in the next edition, trim the fat. If it's not 3.1-compliant, cut it out. There are plenty of 2.1 references out there if someone has to learn outdated code.

I have been relying on the red books for years. I am fairly disappointed with this particular edition because most of the book, as others have pointed out, covers deprecated APIs. Personally I don't mind that, since we are likely to encounter legacy code, may also need to port it, and an understanding of the history can be useful. The trouble is not with the deprecated APIs, it's with the authors often not explaining what it has been superseded by. The chapter on selection and feedback is a perfect example of this. A chapter will go on for several dozen pages, but begin with a small note at the beginning of the chapter with words to the effect of "everything you are about to read is deprecated".

Extremely disappointed with this book. I was eagerly looking forward to this book hoping that this would enable me to learn the new programming model of OpenGL ( programmable pipe-line )which is substantially different from the previous versions. The initial description of this book ( before it was actually released )had mentioned that this edition would have 70% new material ( text and code ) and would completely cover the new approach. Not sure as to what happened but this book is mostly a re-print of the 6th edition with a small table next to each API which indicates whether the API is deprecated or not ( Most of it are deprecated and I'm not sure why we need a book that explains all the deprecated API's and how to program with deprecated features). Will wait for OpenGL SuperBible 5th Edition now ( Hopefully there is something like that in the works ).

I'm honestly not sure that this books will very useful to many people at all.
If you are both new to OpenGL and will have to deal with old OpenGL code, then it might just be worth it, otherwise, forget it.

First, literally 85-90% of the pages in the book relate to functions that have been deprecated.
Second, it doesn't make it all that clear exactly what has or hasn't been deprecated so it's rather a mess to dig through to find the relevant bits.
Finally, it covers rather little beyond the very basics of GLSL, which is basically what OpenGL 3.0+ is all about.

Let me put it this way:

If you will have to deal with old code base but already know OpenGL pre-3.0 well then you already know how to deal with old OpenGL code base and since the new stuff is so buried and so sparse what does this get you?

If you are new to OpenGL and won't have to deal with an old code base why bother with all the deprecated junk? You do not want to be starting off new code doing it the old ways. In this case:

If you need to know the basics of the 3D graphics, don't try to learn it from this book, get a solid, general purpose 3D graphics book for that (or at least something like "Advanced Graphics Programming using OpenGL" which also uses largely deprecated functions but it's written in a better style for this purpose).

For a basic introduction on how to use OpenGL (to get yourself up to speed on the basic outline of the API), get something like "Beginning OpenGL Game Programming 2nd ed" just get you started. It'll quickly show you the basic ropes of OpenGL and what you need to do to get the system initialized, viewports set, shaders initialized, rendering attached to Windows windows and some basic info on vertex buffers and such. Just looking at the basic, free SDK/docs it would tricky to figure out where to begin, this will show you. After that, for more advanced commands dealing with buffers you can just look at the free OpenGL documents/search the web to learn what more you need, it should all make sense once you know the basic outline of OpenGL.

To learn more about the new shader model and changes to GLSL get a book like "OpenGL Shading Language - 3rd ed", way more useful than the few pages in this book on that topic.

So:
If you already know OpenGL 2.0 just get "OpenGL Shading Language - 3rd ed" and download the latest free OpenGL 3.3 (or whatever version) docs and you are good to go, don't even bother with this book.

If you know nothing about OpenGL but do know about 3D graphics then just get "Beginning OpenGL Game Programming 2nd ed" to get you introduced to the API and then get"OpenGL Shading Language - 3rd ed" and download the latest free OpenGL 3.3 (or whatever version) docs and you are good to go, don't even bother with this book.

If you know nothing about 3D graphics or OpenGL then get the above two books and add some general references on 3D graphics and don't even bother with this book.

EDIT: Also the new 5th edition of OpenGL SuperBible is WAY more worthwhile that this title.

Only if you are both new and will also need to deal with an advanced, but old, code base, bother with this book.

If you're new to OpenGL (and computer graphics in general) this book will confuse you to the point of tears. Apparently OpenGL changed quite a bit from the 2.x versions to the 3.x versions. This book explains the 2.x paradigms, then mentions that most of the stuff you just read doesn't apply in version 3.x.

It's hard to figure out what's what. For example, Chapter 8 (Drawing Pixels, Bitmaps, Fonts, and Images) sounds very important but the first page of that chapter notes, "Much of the functionality discussed in this chapter was deprecated in OpenGL Version 3.0, and was removed from Version 3.1. It was replaced with more capable functionality using framebuffer objects, which are described in Chapter 10."

Great, so we can tear out the 68 pages of Chapter 8 to use as kindling (no pun intended) and move on to Chapter 10. But (and it's a big "but") Chapter 10 notes, "In OpenGL Version 3.1, some of the techniques and functions described in this chapter were removed through deprecation. The concepts are still relevant, but are available using more modern features." By now anyone new to OpenGL and who wants to learn about its latest version would be disgusted with this confusion.

OpenGL is now in version 4.x, and a new version of this book is slated for release before the end of 2011. Hopefully the authors will have found a way to present the most current material clearly, with references, perhaps, to earlier versions for those who need that information.

Pros:
1. Learn OpenGL straight from the horse's mouth

2. Authoritative reference

3. A few good tutorials

Cons:
1. Not very user friendly

2. User-unfriendly when explaining fundamental concepts

I have a digital version of this edition on my Kindle DX; I returned the corresponding box set unopened, and bought instead the sixth edition covering OpenGL 2.1. (I prefer hard copy for ease of browsing, except when my hard copy isn't with me.)

OpenGL is going through an uncomfortable transition, and the other reviews slam this book for an issue with OpenGL, not this book. My newest hardware, bought within the week, "only" supports OpenGL 2.1, which is fine by me. Sure, these OpenGL manuals are expensive, and many of us have obsolete editions on our bookshelves, but that's no reason to buy an edition that is "too new" for one's hardware. Value your time, and buy exactly the edition that matches your current hardware.

Current list of books that I have found work- C Primer Plus(Sams), Xhtml(thomson), Flash CS4 digital Classroom(Gerantabee, yes I had buyers remourse as it was easy), Programming Python(reilly), Javascript the definitive guide(reilly), Programming Perl(reilly), Direct3d Programming-Kick Start(walnum), Php and Mysql(reilly), Programming Ruby(reilly), Shell Scripting(reilly), Programming with c++(schaum's)

Current list of books that do not work- Opengl Programming Guide(addison/wesley)

I have had this book for about 5 months now and can not learn anything from it.
If anyone from this company would care to help teach me some of the basics to be able to use this book correctly then I would change my review as customer service is as important as content sometimes. Or possibly just a working example(thats all I freaking need).

This book is named "learning" and it will help you do nothing if you do not already know opengl. Example would be the very first code snipit, the first line is-
#include <whateverYouNeed.h> (uhh I got a book that teaches so it could tell me what I need)
so I have added windows.h(obviously), glut.h, gl/gl.h, and a couple other opengl includes + stdlib/stdio and I can not get the first "chunk of Opengl Code" in the book to work, makes a book that is suppose to teach me pretty useless.
Here is the entire first program in the book, I will let you decide:

#include <whateverYouNeed.h>/*here is my problem, it literally says whateveryouneed*/
main() {
InitializeAWindowPlease();/*should know how to use win32 before attempting 3d(comment is not in book)*/
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
glBegin(GL_POLYGON);
glVertex3f(0.25, 0.25, 0.0);
glVertex3f(0.75, 0.25, 0.0);
glVertex3f(0.75, 0.75, 0.0);
glVertex3f(0.25, 0.75, 0.0);
glEnd();
glFlush();
UpdateTheWindowAndCheckForEvents();
}

Heres my program explaining how I feel:
#include <stdlib.h>
int main(void){
char howifeel[17]="fitkhliespbuowogk";
for (x=0; x<18; x+=2) printf("%c", howifeel[x]);
}