|
OpenGL(R) Shading Language (2nd Edition) (OpenGL) | 
 enlarge | Author: Randi J. Rost
Publisher: Addison-Wesley Professional
Category: Book
List Price: $64.99
Buy New: $50.90
You Save: $14.09 (22%)
New (20) Used (6) from $45.97
Avg. Customer Rating:  9 reviews
Sales Rank: 75272
Media: Paperback
Edition: 2
Number Of Items: 1
Pages: 800
Shipping Weight (lbs): 3.5
Dimensions (in): 9.1 x 7 x 2
ISBN: 0321334892
Dewey Decimal Number: 006.686
EAN: 9780321334893
ASIN: 0321334892
Publication Date: February 4, 2006
Availability: Usually ships in 1-2 business days
Condition: All orders ship same business day via standard shipping (USPS Media Mail) if received by 1 PM CST.
|
| Also Available In:
|
| Similar Items:
|
| Customer Reviews: Read 4 more reviews...
Orange Book March 9, 2007
1 out of 1 found this review helpful
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.
A little chunky, but a good necessary work March 9, 2006
2 out of 10 found this review helpful
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.
Excellent guide to OpenGL Shading Language February 17, 2006
15 out of 23 found this review helpful
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
do your own shading?! February 8, 2006
12 out of 13 found this review helpful
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.
Joins the OpenGL canon April 12, 2005
8 out of 9 found this review helpful
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.
|
|
|
Copyright 2008 - RailroadBookstore.com
| |
