OpenGL® Shading Language und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr
Ihren Artikel jetzt
eintauschen und
EUR 1,50 Gutschein erhalten.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Anhören Wird wiedergegeben... Angehalten   Sie hören eine Probe der Audible-Audioausgabe.
Weitere Informationen
Dieses Bild anzeigen

OpenGL Shading Language (Englisch) Taschenbuch – 2. Februar 2006

Alle 2 Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
"Bitte wiederholen"
EUR 66,88 EUR 6,77
6 neu ab EUR 66,88 9 gebraucht ab EUR 6,77

Dieses Buch gibt es in einer neuen Auflage:

OpenGL Shading Language
EUR 41,95
Auf Lager.
Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.


  • Taschenbuch: 740 Seiten
  • Verlag: Addison Wesley; Auflage: 2nd ed. (2. Februar 2006)
  • Sprache: Englisch
  • ISBN-10: 0321334892
  • ISBN-13: 978-0321334893
  • Größe und/oder Gewicht: 17,7 x 4,1 x 23 cm
  • Durchschnittliche Kundenbewertung: 5.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
  • Amazon Bestseller-Rang: Nr. 367.928 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
  • Komplettes Inhaltsverzeichnis ansehen

Mehr über die Autoren

Entdecken Sie Bücher, lesen Sie über Autoren und mehr



"As the 'Red Book' is known to be the gold standard for OpenGL, the 'Orange Book' is considered to be the gold standard for the OpenGL Shading Language. With Randi's extensive knowledge of OpenGL and GLSL, you can be assured you will be learning from a graphics industry veteran. Within the pages of the second edition you can find topics from beginning shader development to advanced topics such as the spherical harmonic lighting model and more." --David Tommeraasen, CEO/Programmer, Plasma Software "This will be the definitive guide for OpenGL shaders; no other book goes into this detail. Rost has done an excellent job at setting the stage for shader development, what the purpose is, how to do it, and how it all fits together. The book includes great examples and details, and good additional coverage of 2.0 changes!" --Jeffery Galinovsky, Director of Emerging Market Platform Development, Intel Corporation "The coverage in this new edition of the book is pitched just right to help many new shader-writers get started, but with enough deep information for the 'old hands.'

"--Marc Olano, Assistant Professor, University of Maryland "This is a really great book on GLSL--well written and organized, very accessible, and with good real-world examples and sample code. The topics flow naturally and easily, explanatory code fragments are inserted in very logical places to illustrate concepts, and all in all, this book makes an excellent tutorial as well as a reference." --John Carey, Chief Technology Officer, C.O.R.E. Feature Animation OpenGL(R) Shading Language, Second Edition, extensively updated for OpenGL 2.0, 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(R) Shading Language, Second Edition, includes updated descriptions for the language and all the GLSL entry points added to OpenGL 2.0; new chapters that discuss lighting, shadows, and surface characteristics; and an under-the-hood look at the implementation of RealWorldz, the most ambitious GLSL application to date. The second edition also features 18 extensive new examples of shaders and their underlying algorithms, including *Image-based lighting*Lighting with spherical harmonics*Ambient occlusion*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.Also included is a convenient Quick Reference Card to GLSL.

Über den Autor und weitere Mitwirkende

Randi Rost is an ISV Manager in the Software and Solutions Group at Intel. Previously he held several positions at 3Dlabs, Inc., the company that led the creation of the OpenGL Shading Language (GLSL). Randi was a core contributor to the development of GLSL and the OpenGL API that supports it, as well as one of the first programmers to design and implement shaders using this technology.


5.0 von 5 Sternen
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Sterne
Siehe die Kundenrezension
Sagen Sie Ihre Meinung zu diesem Artikel

Die hilfreichsten Kundenrezensionen

3 von 3 Kunden fanden die folgende Rezension hilfreich Von Duenisch am 21. Februar 2009
Format: Taschenbuch
Dieses Buch ist ein absolutes Muß, wenn man sich wirklich in die Materie der OpenGL Shader einarbeiten will.

Es beschreibt in sehr verständlicher Weise Grundlagen und Funktionsweise.
Besonders gelungen finde ich die Beispiele, welche vom Thema her sehr treffend gewählt wurden.

Da wären:
- ein simpler Shader als Vorgeschmack,
- statischer Texture Shader
- procedualer Texture Shader
- Beleuchtung
- Shadows
- Noise
- Animation
- fürs Antialiasing ein procedualer Shader
- Shader fürs Imaging
.... um nur einige zu nennen. Es werden immer die entsprechenden
Vertex / Fragment- Shader beschrieben.

Allerdings ist ein gewisses Vorstellungsvermögen des Lesers Vorraussetzung.

Ein Vergleich zwischen verschiedenen Shader Sprachen kann nützlich sein.

Abschließend ist noch eine umfassende Referenz und einliegende Quick-Referenz zu erwähnen.

Das Buch hat fast 800 Seiten und hat meine Erwartungen weit übertroffen.
Super !
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen

Die hilfreichsten Kundenrezensionen auf (beta) 8 Rezensionen
7 von 7 Kunden fanden die folgende Rezension hilfreich
do your own shading?! 8. Februar 2006
Von W Boudville - Veröffentlicht auf
Format: Taschenbuch
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.
15 von 18 Kunden fanden die folgende Rezension hilfreich
Excellent guide to OpenGL Shading Language 17. Februar 2006
Von calvinnme - Veröffentlicht auf
Format: Taschenbuch
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:
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;

Example Shader Pair; Data Types; Initializers and Constructors; Type Conversions; Qualifiers and Interface to a Shader; Flow Control; Operations; Preprocessor; Preprocessor Expressions; Error Handling;

The Vertex Processor; The Fragment Processor; Built-in Uniform Variables; Built-in Constants; Interaction with OpenGL Fixed Functionality;

Angle and Trigonometry Functions; Exponential Functions; Common Functions; Geometric Functions; Matrix Functions; Vector Relational Functions; Texture Access Functions; Fragment Processing Functions; Noise Functions;

Brick Shader Overview; Vertex Shader; Fragment Shader; Observations;

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;

General Principles; Performance Considerations; Shader Debugging; Shader Development Tools; Scene Graphs;

Transformation; Light Sources; Material Properties and Lighting; Two-Sided Lighting; No Lighting; Fog; Texture Coordinate Generation; User Clipping; Texture Application;

Access to Texture Maps from a Shader; Simple Texturing Example; Multitexturing Example; Cube Mapping Example; Another Environment Mapping Example; Glyph Bombing;

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;

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;

Sources of Aliasing; Avoiding Aliasing; Increasing Resolution; Antialiased Stripe Example; Frequency Clamping;

Hatching Example; Technical Illustration Example; Mandelbrot Example;

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;

Chronology of Shading Languages; RenderMan; OpenGL Shader (ISL); HLSL; Cg;
Appendix A. Language Grammar
Appendix B. API Function Reference
8 von 11 Kunden fanden die folgende Rezension hilfreich
Broken Code, Incomplete Examples 19. Januar 2010
Von Trousers - Veröffentlicht auf
Format: Taschenbuch
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.
2 von 3 Kunden fanden die folgende Rezension hilfreich
Orange Book 8. März 2007
Von Scott Johnson - Veröffentlicht auf
Format: Taschenbuch Verifizierter Kauf
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.
Good book for OpenGL 12. Februar 2013
Von platinumchair517 - Veröffentlicht auf
Format: Taschenbuch Verifizierter Kauf
I gave this book as a present. And, they loved this book a good learning tool for OpenGL. I highly recommend.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.