| List Price: | |
| Price: | $47.99 & eligible for FREE Super Saver Shipping on orders over $25. Details... |
| You Save: | $0.00(0.00%) |
| Binding: | Kindle Edition |
| EAN: | |
| Feature: | |
| Label: | Addison-Wesley Professional |
| Publisher: | Addison-Wesley Professional |
| Studio: | Addison-Wesley Professional |
| Tags: |
Editorial Reviews
OpenGL® Shading Language, Third Edition, extensively updated for OpenGL 3.1, is the experienced application programmer’s guide to writing shaders. Part reference, part tutorial, this book thoroughly explains the shift from fixed-functionality graphics hardware to the new era of programmable graphics hardware and the additions to the OpenGL API that support this programmability. With OpenGL and shaders written in the OpenGL Shading Language, applications can perform better, achieving stunning graphics effects by using the capabilities of both the visual processing unit and the central processing unit.
In this book, you will find a detailed introduction to the OpenGL Shading Language (GLSL) and the new OpenGL function calls that support it. The text begins by describing the syntax and semantics of this high-level programming language. Once this foundation has been established, the book explores the creation and manipulation of shaders using new OpenGL function calls.
OpenGL® Shading Language, Third Edition, includes updated descriptions for the language and all the GLSL entry points added though OpenGL 3.1, as well as updated chapters that discuss transformations, lighting, shadows, and surface characteristics. The third edition also features shaders that have been updated to OpenGL Shading Language Version 1.40 and their underlying algorithms, including:
- Traditional OpenGL fixed functionality
- Stored textures and procedural procedural textures
- Image-based lighting
- Lighting with spherical harmonics
- Ambient occlusion and shadow mapping
- Volume shadows using deferred lighting
- Ward’s BRDF model
The color plate section illustrates the power and sophistication of the OpenGL Shading Language. The API Function Reference at the end of the book is an excellent guide to the API entry points that support the OpenGL Shading Language.
Related Reviews
The Future of OpenGL Programming
Excellent guide to OpenGL Shading Language
The recent trend in graphics hardware has been to replace fixed functionality with programmability in areas that have grown exceedingly complex (e.g., vertex processing and fragment processing). The OpenGL Shading Language has been designed to allow application programmers to express the processing that occurs at those programmable points of the OpenGL pipeline. Independently compilable units that are written in this language are called shaders. A program is a set of shaders that are compiled and linked together. The OpenGL Shading Language is based on ANSI C and many of the features have been retained except when they conflict with performance or ease of implementation. This shading language is without a doubt the most important addition to OpenGL since its inception, and this book provides an excellent guide to programming with it. The author was one of the primary contributors to the development of the language, and he provides a well-written and insightful explanation of the language and its use.
The book begins with a review of OpenGL basics, followed by an introduction to shaders and how they fit into the pipeline. It then covers the language itself, including data types, operators, interaction with the OpenGL state machine and fixed function pipeline, built-in functions, and more. It also introduces and explains the OpenGL APIs needed to use shaders.
The last half of the book focuses on shader development, including general process and workflow, and coverage of many specific techniques, such as procedural textures and GPU-based animation. It even includes a section on implementing the fixed function pipeline using shaders. The book ends with a handy comparison of OpenGL Shading Language with other shading languages, such as Cg, HLSL, and Renderman and a couple of appendices providing a language grammar and API reference.
I particularly liked chapters 6 through 8, which take you from a simple shading example -"brick"- through the specific steps of shader development that you would need to master regardless of the API you are using. Also the chapters on procedural textures and noise and the accompanying code examples helped clear up some matters that were murky when I read "Texturing & Modeling: A Procedural Approach" by Ebert et al. In summary, I highly recommend this book to anyone interested in implementing software shading, both from the standpoint of OpenGL and from the standpoint of the design process itself. I notice that Amazon does not show the table of contents for the second edition, so I do that here:
Chapter 1. REVIEW OF OPENGL BASICS
OpenGL History; OpenGL Evolution; Execution Mode; The Frame Buffer; State; Processing Pipeline; Drawing Geometry; Drawing Images; Coordinate Transforms; Texturing;
Chapter 2. BASICS
Introduction to the OpenGL Shading Language; Why Write Shaders?; OpenGL Programmable Processors; Language Overview; System Overview; Key Benefits;
Chapter 3. LANGUAGE DEFINITION
Example Shader Pair; Data Types; Initializers and Constructors; Type Conversions; Qualifiers and Interface to a Shader; Flow Control; Operations; Preprocessor; Preprocessor Expressions; Error Handling;
Chapter 4. THE OPENGL PROGRAMMABLE PIPELINE
The Vertex Processor; The Fragment Processor; Built-in Uniform Variables; Built-in Constants; Interaction with OpenGL Fixed Functionality;
Chapter 5. BUILT-IN FUNCTIONS
Angle and Trigonometry Functions; Exponential Functions; Common Functions; Geometric Functions; Matrix Functions; Vector Relational Functions; Texture Access Functions; Fragment Processing Functions; Noise Functions;
Chapter 6. SIMPLE SHADING EXAMPLE
Brick Shader Overview; Vertex Shader; Fragment Shader; Observations;
Chapter 7 OPENGL SHADING LANGUAGE API
Obtaining Version Information; Creating Shader Objects; Compiling Shader Objects; Linking and Using Shaders; Cleaning Up; Query Functions; Specifying Vertex Attributes; Specifying Uniform Variables; Samplers; Multiple Render Targets; Development Aids; Implementation-Dependent API Values; Application Code for Brick Shaders;
Chapter 8. SHADER DEVELOPMENT
General Principles; Performance Considerations; Shader Debugging; Shader Development Tools; Scene Graphs;
Chapter 9. EMULATING OPENGL FIXED FUNCTIONALITY
Transformation; Light Sources; Material Properties and Lighting; Two-Sided Lighting; No Lighting; Fog; Texture Coordinate Generation; User Clipping; Texture Application;
Chapter 10. STORED TEXTURE SHADERS
Access to Texture Maps from a Shader; Simple Texturing Example; Multitexturing Example; Cube Mapping Example; Another Environment Mapping Example; Glyph Bombing;
Chapter 11. PROCEDURAL TEXTURE SHADERS
Regular Patterns; Toy Ball; Lattice; Bump Mapping;
Chapter 12. LIGHTING
Hemisphere Lighting; Image-Based Lighting; Lighting with Spherical Harmonics; The *erLight Shader;
Chapter 13. SHADOWS
Ambient Occlusion; Shadow Maps; Deferred Shading for Volume Shadows;
Chapter 14. SURFACE CHARACTERISTICS
Refraction; Diffraction; BRDF Models; Polynomial Texture Mapping with BRDF Data;
Chapter 15. NOISE
Noise Defined; Noise Textures; Trade-offs; A Simple Noise Shader; Turbulence; Granite; Wood;
Chapter 16. ANIMATION
On/Off; Threshold; Translation; Morphing; Other Blending Effects; Vertex Noise; Particle Systems; Wobble;
Chapter 17. ANTIALIASING PROCEDURAL TEXTURES
Sources of Aliasing; Avoiding Aliasing; Increasing Resolution; Antialiased Stripe Example; Frequency Clamping;
Chapter 18. NON-PHOTOREALISTIC SHADERS
Hatching Example; Technical Illustration Example; Mandelbrot Example;
Chapter 19. SHADERS FOR IMAGING
Geometric Image Transforms; Mathematical Mappings; Lookup Table Operations; Color Space Conversions; Image Interpolation and Extrapolation; Blend Modes;
Chapter 20. REALWORLDZ
Features; RealWorldz Internals; Implementation; Atmospheric Effects; Ocean; Clouds;
Chapter 21. LANGUAGE COMPARISON
Chronology of Shading Languages; RenderMan; OpenGL Shader (ISL); HLSL; Cg;
Appendix A. Language Grammar
Appendix B. API Function Reference
The book begins with a review of OpenGL basics, followed by an introduction to shaders and how they fit into the pipeline. It then covers the language itself, including data types, operators, interaction with the OpenGL state machine and fixed function pipeline, built-in functions, and more. It also introduces and explains the OpenGL APIs needed to use shaders.
The last half of the book focuses on shader development, including general process and workflow, and coverage of many specific techniques, such as procedural textures and GPU-based animation. It even includes a section on implementing the fixed function pipeline using shaders. The book ends with a handy comparison of OpenGL Shading Language with other shading languages, such as Cg, HLSL, and Renderman and a couple of appendices providing a language grammar and API reference.
I particularly liked chapters 6 through 8, which take you from a simple shading example -"brick"- through the specific steps of shader development that you would need to master regardless of the API you are using. Also the chapters on procedural textures and noise and the accompanying code examples helped clear up some matters that were murky when I read "Texturing & Modeling: A Procedural Approach" by Ebert et al. In summary, I highly recommend this book to anyone interested in implementing software shading, both from the standpoint of OpenGL and from the standpoint of the design process itself. I notice that Amazon does not show the table of contents for the second edition, so I do that here:
Chapter 1. REVIEW OF OPENGL BASICS
OpenGL History; OpenGL Evolution; Execution Mode; The Frame Buffer; State; Processing Pipeline; Drawing Geometry; Drawing Images; Coordinate Transforms; Texturing;
Chapter 2. BASICS
Introduction to the OpenGL Shading Language; Why Write Shaders?; OpenGL Programmable Processors; Language Overview; System Overview; Key Benefits;
Chapter 3. LANGUAGE DEFINITION
Example Shader Pair; Data Types; Initializers and Constructors; Type Conversions; Qualifiers and Interface to a Shader; Flow Control; Operations; Preprocessor; Preprocessor Expressions; Error Handling;
Chapter 4. THE OPENGL PROGRAMMABLE PIPELINE
The Vertex Processor; The Fragment Processor; Built-in Uniform Variables; Built-in Constants; Interaction with OpenGL Fixed Functionality;
Chapter 5. BUILT-IN FUNCTIONS
Angle and Trigonometry Functions; Exponential Functions; Common Functions; Geometric Functions; Matrix Functions; Vector Relational Functions; Texture Access Functions; Fragment Processing Functions; Noise Functions;
Chapter 6. SIMPLE SHADING EXAMPLE
Brick Shader Overview; Vertex Shader; Fragment Shader; Observations;
Chapter 7 OPENGL SHADING LANGUAGE API
Obtaining Version Information; Creating Shader Objects; Compiling Shader Objects; Linking and Using Shaders; Cleaning Up; Query Functions; Specifying Vertex Attributes; Specifying Uniform Variables; Samplers; Multiple Render Targets; Development Aids; Implementation-Dependent API Values; Application Code for Brick Shaders;
Chapter 8. SHADER DEVELOPMENT
General Principles; Performance Considerations; Shader Debugging; Shader Development Tools; Scene Graphs;
Chapter 9. EMULATING OPENGL FIXED FUNCTIONALITY
Transformation; Light Sources; Material Properties and Lighting; Two-Sided Lighting; No Lighting; Fog; Texture Coordinate Generation; User Clipping; Texture Application;
Chapter 10. STORED TEXTURE SHADERS
Access to Texture Maps from a Shader; Simple Texturing Example; Multitexturing Example; Cube Mapping Example; Another Environment Mapping Example; Glyph Bombing;
Chapter 11. PROCEDURAL TEXTURE SHADERS
Regular Patterns; Toy Ball; Lattice; Bump Mapping;
Chapter 12. LIGHTING
Hemisphere Lighting; Image-Based Lighting; Lighting with Spherical Harmonics; The *erLight Shader;
Chapter 13. SHADOWS
Ambient Occlusion; Shadow Maps; Deferred Shading for Volume Shadows;
Chapter 14. SURFACE CHARACTERISTICS
Refraction; Diffraction; BRDF Models; Polynomial Texture Mapping with BRDF Data;
Chapter 15. NOISE
Noise Defined; Noise Textures; Trade-offs; A Simple Noise Shader; Turbulence; Granite; Wood;
Chapter 16. ANIMATION
On/Off; Threshold; Translation; Morphing; Other Blending Effects; Vertex Noise; Particle Systems; Wobble;
Chapter 17. ANTIALIASING PROCEDURAL TEXTURES
Sources of Aliasing; Avoiding Aliasing; Increasing Resolution; Antialiased Stripe Example; Frequency Clamping;
Chapter 18. NON-PHOTOREALISTIC SHADERS
Hatching Example; Technical Illustration Example; Mandelbrot Example;
Chapter 19. SHADERS FOR IMAGING
Geometric Image Transforms; Mathematical Mappings; Lookup Table Operations; Color Space Conversions; Image Interpolation and Extrapolation; Blend Modes;
Chapter 20. REALWORLDZ
Features; RealWorldz Internals; Implementation; Atmospheric Effects; Ocean; Clouds;
Chapter 21. LANGUAGE COMPARISON
Chronology of Shading Languages; RenderMan; OpenGL Shader (ISL); HLSL; Cg;
Appendix A. Language Grammar
Appendix B. API Function Reference
Twenty years ago, I used to program graphics on an Evans and Sutherland PS340. It was then one of the top of the line graphics computers (costing $100k). It could labouriously do shading, but only Phong and Gouraud. Nowadays, many PCs have this ability, and much faster. But a problem still persists, where often the shading methods are restricted to what is implemented on the graphics chips.
In contrast, you have the approach in this definitive book on OpenGL Shading Language. This lets you implement in your code, shading routines of your own devising. To be sure, given the same shading method, one done in this language, and one in the hardware, then the latter will have better performance. But it turns out that today's computers are fast enough, and have enough RAM, that the difference in response might not be appreciable.
The book describes an extensive set of built-in convenience functions that come with the language. And the language's API is explained in detail. The author rightly recommends that you come at it with some experience in the standard OpenGL.
Since the language is still quite new, you are more or less on your own, when looking at development tools. This dearth is expected to be remedied in a few years. But right now, you'll have to rely on your wits. Along with a chapter that gives general principles of how you should develop your own shader. What may be even more use, however, is the second half of the book. Devoted to case studies of many shaders. Understanding these may be more beneficial than any IDE.
Oh, as you might expect from a graphics book, there is a lovely set of colour plates in the middle of the book, showing what custom shaders can do. Treat it as inspiration if you wish.
In contrast, you have the approach in this definitive book on OpenGL Shading Language. This lets you implement in your code, shading routines of your own devising. To be sure, given the same shading method, one done in this language, and one in the hardware, then the latter will have better performance. But it turns out that today's computers are fast enough, and have enough RAM, that the difference in response might not be appreciable.
The book describes an extensive set of built-in convenience functions that come with the language. And the language's API is explained in detail. The author rightly recommends that you come at it with some experience in the standard OpenGL.
Since the language is still quite new, you are more or less on your own, when looking at development tools. This dearth is expected to be remedied in a few years. But right now, you'll have to rely on your wits. Along with a chapter that gives general principles of how you should develop your own shader. What may be even more use, however, is the second half of the book. Devoted to case studies of many shaders. Understanding these may be more beneficial than any IDE.
Oh, as you might expect from a graphics book, there is a lovely set of colour plates in the middle of the book, showing what custom shaders can do. Treat it as inspiration if you wish.
This book is excellent. It's easy to read, has solid examples in code and uses graphics sparingly (for a book on graphics) and effectively. Especially when it comes to graphics that explain the technology. For example, the graphics pipeline in chapter two is really handy.
The first two chapters stand out as a nice introduction to the topic and to the shading language in particular. After that the book is an on-and-off introduction and reference that will bring you up to speed today and act as a reference later on.
If I have one complaint it's that the reference materials, particularly in Appendix B could have been formatted and cross referenced a little better. As it stands they feel more like slightly reformatted UNIX man pages.
For those that need this book, and you know who you are, this an invaluable reference, and it's well written to boot.
Excellent book about realtime shader development
For beginners, the books gives an very good introduction into the OpenGL shading language. It starts with giving an overview over the previous OpenGL rendering architecture, smoothly motivating and introducing the shading language. Then, chapter by chapter it goes more and more into depth, containing interesting stuff for experts. This includes topics like advanced procedural texturing including antialiasing, NPR rendering and imaging techniques.
The language and structure of the book is clear, easy to follow and precise (especially compared to the Direct3D SDK documentation). Very useful is the appendix containing a shading language and API reference. Whoever works on realtime computer graphics should have this book in his shelf.
One minor warning for beginners: The book assumes that you are familar with OpenGL itself. The book does not replace an introduction into OpenGL.
The language and structure of the book is clear, easy to follow and precise (especially compared to the Direct3D SDK documentation). Very useful is the appendix containing a shading language and API reference. Whoever works on realtime computer graphics should have this book in his shelf.
One minor warning for beginners: The book assumes that you are familar with OpenGL itself. The book does not replace an introduction into OpenGL.
The authors honestly warn the user that this book is not intended to be read from start to finish in sequential order. Cannot agree more. The material is scattered through the book with little logical order. Very often I find myself putting the book aside and going to Internet after futile attempts to find even some basic information.
For example GLSL defines a number of special embedded variables, but you will not find a list of those variables and especially examples of using them. Instead they are scattered in the text.
A good part of the book is just examples of solving some fancy tasks. GLSL is a very interesting and exciting subject and I expected to find something more useful when ordering this book.
Save your money.
For example GLSL defines a number of special embedded variables, but you will not find a list of those variables and especially examples of using them. Instead they are scattered in the text.
A good part of the book is just examples of solving some fancy tasks. GLSL is a very interesting and exciting subject and I expected to find something more useful when ordering this book.
Save your money.
The OpenGL Shading Language is without doubt the most important addition to OpenGL since its inception, and this book provides an excellent guide to programming with it. As one of the primary contributors to the development of the language, Rost provides a clear and well-written explanation of the language and how to use it.
The book begins with a review of OpenGL basics, followed by an introduction to shaders and how they fit into the pipeline. It then covers the language itself, including data types, operators, interaction with the OpenGL state machine and fixed function pipeline, built-in functions, and more. It also introduces and explains the OpenGL APIs needed to use shaders.
The last half of the book focuses on shader development, including general process and workflow, and coverage of many specific techniques, such as procedural textures and GPU-based animation. It even includes a section on implementing the fixed function pipeline using shaders.
The book ends with a handy comparison of GLSL with other shading languages, such as Cg and HLSL, and a couple of appendices providing a language grammar and API reference.
If you're doing shader development with OpenGL, you'll definitely want this book on your desk. My only complaint about it is that it was written before GLSL was officially promoted to the core. When that happened, a number of important things were changed that aren't reflected in the book. However, determining the differences isn't difficult, so don't let that deter you from picking this up.
The book begins with a review of OpenGL basics, followed by an introduction to shaders and how they fit into the pipeline. It then covers the language itself, including data types, operators, interaction with the OpenGL state machine and fixed function pipeline, built-in functions, and more. It also introduces and explains the OpenGL APIs needed to use shaders.
The last half of the book focuses on shader development, including general process and workflow, and coverage of many specific techniques, such as procedural textures and GPU-based animation. It even includes a section on implementing the fixed function pipeline using shaders.
The book ends with a handy comparison of GLSL with other shading languages, such as Cg and HLSL, and a couple of appendices providing a language grammar and API reference.
If you're doing shader development with OpenGL, you'll definitely want this book on your desk. My only complaint about it is that it was written before GLSL was officially promoted to the core. When that happened, a number of important things were changed that aren't reflected in the book. However, determining the differences isn't difficult, so don't let that deter you from picking this up.
The book covers all you need to know to write opengl shaders. There are a number of examples covered, with source both in the book and available for download. The writing is understandable and comprehensive, if ponderous.
My only complaint is the encyclopedic nature of the book. Tons of man page like reference material in the back and throughout.
It lacks the inspiration of a book like Frank Luna's DirectX, where he develops techniques like normal mapping, cascaded shadow maps, etc.. with all the relevant math details.
But, if you have those details, this book has everything you need to implement them in GLSL. So a good buy.
My only complaint is the encyclopedic nature of the book. Tons of man page like reference material in the back and throughout.
It lacks the inspiration of a book like Frank Luna's DirectX, where he develops techniques like normal mapping, cascaded shadow maps, etc.. with all the relevant math details.
But, if you have those details, this book has everything you need to implement them in GLSL. So a good buy.
Broken Code, Incomplete Examples
The code is often broken, the book has typos, and the examples are rarely ever complete. The portions missing from the examples are the critical aspects for those new to GL 3.
where is the sample code for 3rd edition ?
Please anyone tell me where it is.
I only find source code for 2nd edition
I only find source code for 2nd edition
I definitely recommend this book for anyone working with OpenGL's new Shading Language. I would, however, say that probably the most difficult part of working with GLSL is getting it working in the first place. Especially on Linux, this is somewhat confusing - some cards support GL 2.0, some don't, but still support the GLSL if using the ARB function calls. I would also make sure to point out to new users that GLEW is close to essential when working with the GLSL - you can download it from sourceforge. It might be worth mentioning in future versions of the book, along with ARB functions which are the same as the GLSL standard functions shown in the book.
Not as useful as they're saying
By and large, the reviews here have found this book to be a great resource, to have helpful examples, and perhaps is THE book to have for all things GLSL.
After about chapter 3, it stops living up to the hype.
Up to that point, it does what it needs to do: it gives a decent coverage of the various parts of the language. It then provides one example that actually works.
It is after that that you begin to see that there is a great deal of synergy required between GLSL applications and OpenGL itself. The examples provide (mostly) working shaders without even a hint of the OpenGL code required to interface with them properly, or even what some of the required parts of the shaders are (largely textures described by name only). Also conspicuously absent from this tome is any CD of examples, a common feature of computer texts. In short, if you don't already know what you're doing for anything remotely complex, this book isn't going to tell you.
Save your money.
After about chapter 3, it stops living up to the hype.
Up to that point, it does what it needs to do: it gives a decent coverage of the various parts of the language. It then provides one example that actually works.
It is after that that you begin to see that there is a great deal of synergy required between GLSL applications and OpenGL itself. The examples provide (mostly) working shaders without even a hint of the OpenGL code required to interface with them properly, or even what some of the required parts of the shaders are (largely textures described by name only). Also conspicuously absent from this tome is any CD of examples, a common feature of computer texts. In short, if you don't already know what you're doing for anything remotely complex, this book isn't going to tell you.
Save your money.
A little chunky, but a good necessary work
I'm not a fan of the 'group of papers' style of book. But this book pulls it off nicely. The text is consistenly good throughout. And the illustrations and formulas are high quality and presented nicely.
I would have liked full color throughout, but I accept that it would have been cost prohibitive on a book of this heft. Speaking of heft, yeah, this is a doorstop of a book. I think some of the text could have been edited down and the formatting tightened up to reduce bulk.
I would have liked full color throughout, but I accept that it would have been cost prohibitive on a book of this heft. Speaking of heft, yeah, this is a doorstop of a book. I think some of the text could have been edited down and the formatting tightened up to reduce bulk.
The book is random set of GLSL topics, the examples are incomplete and most of them useless. If you are a beginner this book is not for you and if you are not then you already know most of the stuff so in any case you don't need this book, save you money!
I own a copy of this book. It's very well written, easy to understand, make learning shading language an ease. Wish the author will continue to write more books :)
Share your thoughts with other customers
Create your own review
Create your own review
Recently, programmable graphics hardware capable of rendering such algorithms in realtime has become inexpensive and widely available. The result-a small handful of proprietary shading languages created and proposed as standards for this new industry.
OpenGL Shading Language by Randi Rost (Addison-Wesley, 458 pages) describes the OpenGL Shading Language, the first shading language designed as a cross-platform open standard by a group of graphics hardware and software vendors.
The author is a veteran of the computer graphics industry. Rost started programming graphics on an Apple II in the late 1970s. He was working on programmable graphics hardware as early as 1983, when programmable graphics hardware meant little more than a framebuffer with a microcode interface.
Graphics hardware has advanced dramatically since then and continues to advance rapidly today. Most modern 3D hardware supports some type of programmable interface, and should support the Architectural Review Board (ARB)-approved OpenGL Shading Language in the near future. "We think the hardware designs are moving quite rapidly," said Rost. "It should only be a generation or two before all OpenGL hardware vendors fully support the OpenGL Shading Language."
The first chapter is a whirlwind overview of OpenGL. You might be tempted to skip this chapter. But before you do, consider that the author is one of only a few who have contributed to every major revision of OpenGL-who better to learn from? If you're a beginner or intermediate OpenGL programmer, you'll certainly learn something in this brief review.
Chapters 2 through 7 introduce the reader to the OpenGL Shading Language, covering topics such as language semantics, built-in functions, and OpenGL entry points for specifying shaders.
Chapter 8 discusses shader development and performance issues. As you might expect from a book on a shading language, much of the performance discussion concerns shaving cycles from vertex- and pixel-shaders. The information is practical and not obvious even to intermediate programmers, such as using min() or max() instead of clamp() when you know the variable will only exceed one end of a range. However, I found little discussion on how a developer might determine which stage of the rendering pipeline is the performance bottleneck. Since this subject is considered black magic by many young and enthusiastic graphics developers, Rost could have added value to his book with a short section on this subject.
In programming, a few lines of code are worth a thousand words. Rost demonstrates this principle in chapter 9 where he provides shader listings for implementing core OpenGL functionality. The OpenGL Specification is the ultimate definition of OpenGL internal functionality, but the spec is mostly text and formulas, with only a few code listings. A programmer can quickly learn what OpenGL is doing under the hood by reading through the listings in chapter 9. These well-written, concise, and efficient examples of shader code are both illuminating and instructive.
Chapters 10 through 16 provide the computer graphics developer with real-time working OpenGL Shading Language source code for implementing several major computer graphics algorithms and techniques from the past 25 years. Topic areas include lighting, Phong shading, texture mapping, bump mapping, multi-texturing, procedural texture mapping, lattice shaders, noise, turbulence, shadows, animation, particle systems, antialiasing, hatching and other non-photorealistic techniques, vertex and image blending, image convolution, and many more.
These examples demonstrate the range of OpenGL Shading Language applications, and give developers a basis for writing new shaders. Rost's explanations of the algorithms are easy to read and comprehend, and demonstrate the depth and breadth of knowledge he has accumulated during his 25-year career in graphics.
"Designing and implementing programmable graphics hardware and a compiler for the OpenGL Shading Language required a lot of hard work by everyone involved," said Rost. "But with those pieces in place, it turned out to be remarkably easy to write shaders for a variety of interesting shading tasks. When we got these shaders working for the first time, it was a jaw-dropping experience."
Conspicuously missing is any mention of global illumination algorithms such as ray tracing and radiosity. Such scene-based algorithms present obvious challenges to vertex- and pixel-based shading languages. Rost confessed they have a rough ray-tracing demo that was not ready for publication when this book went to press. He expressed optimism about the OpenGL Shading Language's ability to accelerate programs of this type. "In future revisions of hardware, we'll be able to implement more interesting algorithms [than currently appear in this book]."
While reading OpenGL Shading Language, I often found myself noting similarities and differences between the OpenGL Shading Language and interfaces to other programmable graphics hardware I've used. The book's final chapter covers this topic by comparing and contrasting the OpenGL Shading Language to current commercial shading languages, such as RenderMan, ISL, HLSL, and Cg.
Two appendices serve as useful reference material. Appendix A covers OpenGL Shading Language grammar, and Appendix B documents OpenGL entry points for creating and managing shaders. The book also contains an index, a glossary, an extensive bibliography, and several diagrams and color images.
In general, the computer industry often provides two solutions, one proprietary and the other an open standard. As the only open standard shading language available that is designed for modern graphics hardware, the OpenGL Shading Language is certain to be around for several years to come. OpenGL Shading Language stands on its own as both a programming guide and reference manual for this significant new industry standard.
However, this book goes further by providing real-time examples of classic computer graphics techniques. OpenGL Shading Language is a must-have algorithm book that should be on every computer graphics developer's bookshelf.