Customer Reviews

The Cg Tutorial: The Definitive Guide to Programmable Real-Time Graphics

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

 

 

My review here is from an experienced OpenGL programmer's perspective.

This is an good introduction to the Cg shading language. It goes well beyond the free introductory PDFs on Cg that you can download from the nVidia site, and will quickly bring you up to speed. If you are unfamiliar with the new generation of graphics cards with programmable GPUs, you will love the introductory chapters. There is also an excellent chapter on bump mapping - the best, practical explanation of the technique I have ever seen. (Other books keep harping about tangent space, without explaining *why* you choose tangent space - never mentioning that it *is* possible to do it in object space.)

Now, for a few gripes:

1. There is no clear explanation for how exactly information (say, a calculated light position) should be passed from the vertex program to the fragment program. There are many ways to do this, and there is no suggested way of doing this. (eg: I can use out float3 var: POSITION, NORMAL, COLOR0, TEXCOORD0 - which one should I use and why?)

2. The vertex and fragment programs are given as such without any calling code. This may be really tough for beginners.

3. It does not provide a good reference to all the built in Cg functions. In many cases, you have to guess whether a function returns a value or modifes a parameter passed in. For example, there is only 1 line in the book about the faceforward(Ng, I, N) call. What is Ng? Does this function return any value?

4. The utility value of this book will plummet after you go through it once, since it is only an introduction. So I feel it should be priced accordingly. $45 is too much. I recommend getting it used, like I did, for half the price.

I like the book, but it is definitely not in the calibre of the Red book. (The OpenGL programming guide)

This is a well written book covering the Cg shading language. It contains a lot of useful information about Cg and graphics programming techniques in general. Unfortunately, I felt like it didn't cover as much of Cg as I would have liked, making the book less useful than it could have been.

The book starts with a history of shaders and programmable hardware, an overview of Cg, and a summary of related technologies, such as HLSL and CgFX. It then spends some time covering the syntax and semantics of Cg, and then moves on to the core material of the book, in which the authors explain key graphics pipeline functionality and how it can be implemented using Cg. The book concludes with several appendices covering the Cg runtime, CgFX file format, and Cg standard library, as well as other reference material.

The topics covered include transformations, animation, lighting, environment mapping, bump mapping, fog, shadow mapping, toon shading, and projective texturing. The explanations are all clear and understandable, in particular the chapter on bump mapping, which is one of the easiest introductions to the topic I've encountered. Features of Cg are introduced as needed while explaining these topics, rather than introducing them all at once, which is very conducive to learning. In addition, the authors include warnings and workarounds for techniques which may not be supported on older hardware, as well as advice on attaining optimal performance.

I have two primary complaints about the book. The first is that they never really discuss the application code using the shaders, which made it a bit difficult to understand how they fit in at times. The second is that the book isn't nearly as complete a reference as you might expect. For a great deal of the functions and functionality in Cg, they simply refer you to the Cg reference manual. Although this electronic document is freely available, it's fairly brief at times, so a more detailed explanation in the book would have been appreciated. Similarly, I would have liked to have seen more detailed explanation of CgFX, as well as examples of using it.

Overall, though, this book does a very good job of introducing the reader to Cg and to shaders in general. If you're new to these topics, I'd recommend it. Even if you're a DirectX programmer intending to use HLSL, you'll find this book useful since the languages are identical (though the usage is of course different). If you're already an experienced graphics programmer with some knowledge of shaders, then you'll likely be able to find everything you need in the freely available documentation instead.

This is an excellent book for the beginning or advanced Cg and Graphics programmer. This book not only does and excellent job of explaining the insides of Cg but also of laying out the math behind what's going on with the effects.

A must have.

I couldn't put this book down. Its the only Cg book out there as of now, and its written by the minds at nVidia; the creators of Cg. It does a fantastic job of explaining the language and the all-important vertex/fragment concepts in a good amount of detail. There are also many example effects featured in the book that you can try out yourself and see in action(providing you have the appropriate hardware support).

This book provides a solid introduction to Cg which is identical to microsoft's HLSL except that the compiler and runtime interface support both OpenGL and DirectX profiles. Chapters 7 and 8 on environment mapping and bump are very good and really cleared up the mysteries of tangent space and normalization cube maps for me. Chapter 9 is a bit sparse and tries to cover too much with not enough detail (Fog,Projective Texture Mapping, Shadow Maps and Composition of layers) in my opinion. Still an excellent book and seeing the picture of virtual Dawn and the possiblities that were once only available to Hollywood and Pixars Renderman is really inspiring.

This is a very decent introduction to Cg and shaders in general. It starts off by describing the programable pipeline, and then introduces the shaders. The chapters describe how shaders can be developed for most of the common stuff in real-time graphics. But the best aspect of this book is that it does not cater just to the cutting edge(cineFX/DX9) but also demonstrates how the shader can be developed for a baseline hardware system. Performance and cineFX tips are sprinkled throughout the book along with a collected Cg reference section.

Overall a very good way to start learning Cg and real-time programming using shaders.

This book is very good to get yourself started with Cg, but lacks technical details and advanced topics. Once you're on your way coding shaders, you're better off with NVidia's free cg_toolkit.pdf which is included with the Cg SDK.

The current generation of GPUs puts a huge amount of rendering power at your fingertips. This book gives a great intro to a range of highly versatile techniques, including bump maps, shadows, complex illumination models, fog, non-realistic rendering, and lots more. You need a little math, but only what's given here. For example, you'll need to know what a dot product is, and the formulas are given. You won't need to know all the extras, like the geometric and trigonometric properties of dot products - those are simply stated where they become useful. Best, the entire discussion is illustrated with simple, legible samples of working code. The cut&paster gets off to a running start. This book really delivers what the title promises: Cg, by means of clear discussion and useful examples.

The book does not deliver what the title does not promise. For example, the authors discuss the effect of finer or coarser tesselation on image quality, but give no idea how to create the geometric models. Because the authors discuss only what goes on inside the GPU, they scarcely mention how to get your shader programs into it, and scarcely mention vertex shaders at all. Those aren't defects in the book, they're choices made by the authors. This book does a lot, but you'll need other references, possibly more than one of them, if you want to build a complete application.

Advanced graphics programmers have probably seen most of this before, and the barest beginners are still struggling with their box's shrink-wrap code samples. If you're ready for the second and third steps of graphics programming, then this could be very helpful. The "gallery" section could be a bit longer and the images a bit bigger, but this is really a how-to book and succeeds nicely in what it set out to do.

-- wiredweird

Traditional graphics textbooks did not contain programmable real-time shading techniques. This book is a good example to fill in this gap. In my opinion, university can start a new course teaching programmable real-time shading....

This is one of the books highly recommended for learning hardware programming. Found it likewise.