OpenGL Development Cookbook und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr
EUR 41,72
  • Alle Preisangaben inkl. MwSt.
Auf Lager.
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
OpenGL Development Cookbo... ist in Ihrem Einkaufwagen hinzugefügt worden
Ihren Artikel jetzt
eintauschen und
EUR 7,12 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
Alle 2 Bilder anzeigen

OpenGL Development Cookbook (Englisch) Taschenbuch – 25. Juni 2013

Alle 2 Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
"Bitte wiederholen"
EUR 41,72
EUR 41,72 EUR 46,37
6 neu ab EUR 41,72 2 gebraucht ab EUR 46,37
EUR 41,72 Kostenlose Lieferung. Auf Lager. Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.

Wird oft zusammen gekauft

OpenGL Development Cookbook + OpenGL 4 Shading Language Cookbook - Second Edition + OpenGL SuperBible: Comprehensive Tutorial and Reference
Preis für alle drei: EUR 127,63

Die ausgewählten Artikel zusammen kaufen
Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.


  • Taschenbuch: 326 Seiten
  • Verlag: Packt Publishing (25. Juni 2013)
  • Sprache: Englisch
  • ISBN-10: 1849695040
  • ISBN-13: 978-1849695046
  • Größe und/oder Gewicht: 19 x 1,9 x 23,5 cm
  • Durchschnittliche Kundenbewertung: 2.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
  • Amazon Bestseller-Rang: Nr. 253.762 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)

Mehr über den Autor

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


Über den Autor und weitere Mitwirkende

Muhammad Mobeen Movania

Muhammad Mobeen Movania received his PhD degree in Advanced Computer Graphics and Visualization from Nanyang Technological University (NTU), Singapore. He complete his Bachelor of Science Honors (BCS(H)) in Computer Sciences from Iqra University, Karachi. Before joining NTU, he was a junior graphics programmer at Data Communication and Control (DCC) Pvt. Ltd. Karachi, Pakistan. He was working on DirectX and OpenGL API for producing real-time interactive tactical simulators and dynamic integrated training simulators. His research interests include volumetric rendering, GPU technologies, real-time shadows, digital geometry processing, and hierarchical geometric data structures. He is also the author of an OpenCloth project ( ) which implements various cloth simulation algorithms in OpenGL. His blog ( lists a lot of useful graphics tips and tricks. When not involved with computer graphics, he composes music and is an avid squash player. He is currently working at a research institute in Singapore.

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?

In diesem Buch (Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Hier reinlesen und suchen:


2.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

Von ChrAu am 13. August 2014
Format: Kindle Edition Verifizierter Kauf
EditierenEigentlich sollte das Buch ja wie Rezepte aufgebaut sein, leider wird nicht beschrieben, wie man die Programme richtig zum Laufen bekommt. Die Beispiele sind auch nur bedingt geeignet für den Einstieg. Wenn man Ahnung von OpenGL hat sind die Beispiele vielleicht zu gebrauchen jedoch nicht für einen Leihen der die Ersten geh versuche mit OpenGL machen möchte.
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) 10 Rezensionen
8 von 8 Kunden fanden die folgende Rezension hilfreich
Great premise, average execution 25. August 2013
Von Lorenzo Mancini - Veröffentlicht auf
Format: Taschenbuch
I had great expectations when I first opened this book. In fact, I feel there is a big void right in the middle of published books about OpenGL.

At one side of the void there are either technical references or introductory texts, which explain the reader how to properly use the library but don't show practical applications: at the end of those books people know how to texture lookup from a vertex shader, not how to render realistic terrain from a height map.

At the other side there are collections of articles about very advanced rendering techniques, intended for people already well versed in graphics programming and hardly of any use for the everyday developer (think about the ShaderX or the GPU Pro series).

The premise of this book is to be the gap filler, which tells you about all the cool things you can do with OpenGL (in addition to rendering teapots) in a wide range of topics, while remaining practical enough for the average OpenGL developer.

While it's a good shot in that direction, it doesn't live up to this ambitious premise.

Let's start with what's good: recipes cover a vast range of applications, including mirrors, object picking, particle systems, GPU physics simulations, ray tracing, volume rendering and more.

OpenGL version of choice is 3.3 core profile, so all the recipes are implemented using modern OpenGL while still being compatible with most GPU hardware out there. Every recipe comes with a self-contained and working code example that you can run and tweak. All examples share coding style and conventions, which is great added value.

The toolchain of choice is Visual Studio for Windows, but the examples also build unmodified on Linux installations. Despite Mac OS X only supporting up to OpenGL 3.2, examples not requiring 3.3 features will build there as well with minor modifications (just be sure to use included GLUT.framework rather than freeglut, as the latter relies on XQuartz which isn't able to request an OpenGL 3 context).

Then, there's something that just doesn't work well. First, the formatting of code excerpts is terrible: long lines wrap twice or thrice with no leading spaces, so without highlighting it's nigh impossible to read the code right at first glance. Given that a good 30% of this book is code, this is really something that should be addressed in a second edition.

A somewhat deeper problem is about how recipes are presented. Most of them dive directly in a step-by-step sequence of code snippets, taking little time to explain the required background and the overall idea behind the implementation. On a related note, the book states that knowledge of OpenGL is just a "definite plus" to get through it, but after the very first recipe spends a total of three lines explaining what Vertex Array Objects are, before jumping into code that uses them, it becomes clear that being proficient with OpenGL is a requirement to appreciate the book.

The quality of the recipes varies a lot through the book: the best written and most interesting ones are from chapters 6, 7 and 8, which comes as no surprise as the author's research interests include the topics they cover. I would have exchanged many of the previous recipes, some of which are variations on the same theme, to be about techniques that both fit the recipe format and are relevant for any up-to-date rendering engine (depth of field, fur, caustics, etc...). On a related note, I think that perhaps the single biggest flaw of the book is that it's written by a single author, but to offer 50 great recipes a cookbook needs several ones, each master in her own trade and each offering the best of her knowledge.

In the end: if you're already well versed in OpenGL, have interest in the specific topics best covered by the author, and you're going to read each recipe at the computer to comfortably read code, OpenGL Development Cookbook has something to offer. While not the gapfiller I was initially looking for, the learning opportunity from having a code example for each recipe is remarkable.
3 von 3 Kunden fanden die folgende Rezension hilfreich
A diverse selection of graphical recipes for OpenGL 3.3 26. Juli 2013
Von Paul T. Miller - Veröffentlicht auf
Format: Taschenbuch
This book magically appeared about the time I began contemplating if and how I will update my older OpenGL 2.x code to the modern OpenGL "Core" API, introduced with OpenGL 3.0. The Core API removes all support for the older fixed-function pipeline that I have been using for 20+ years, and replaces it with an entirely shader-based model with basic support for buffer-based geometry descriptions in lieu of immediate mode.

I was hoping for an introductory chapter on techniques for migrating legacy immediate-mode code to the Core API, but the book assumes you'll be starting with at least OpenGL 3.3 and dives head-first into the first recipes within a few pages. The author is clearly writing for people with previous experience with OpenGL; don't consider this an introduction to OpenGL 3.x. In fact, the book's subtitle, "Over 40 recipes to help you learn, understand, and implement modern OpenGL in your applications", is about as perfect a description of the book as one could get.

The book gets off the ground quickly with a brief section on getting the development environment up and running with the demo programs. They are built for Visual Studio 2010 on Windows but can easily be built to run on other platforms, as they use the excellent and ubiquitous freeglut and GLEW libraries. Then a C++ shader class is introduced. It will be used throughout the rest of the book to streamline access to the various shaders required by all OpenGL 3.x programs.

The recipes start simply, with a filled triangle using trivial vertex and fragment shaders, followed by more complex recipes that build on previous concepts such as vertex manipulations with the vertex shader and geometry generation using the geometry shader.

Through later chapters, recipes get quite varied and more complex. There should be some good information in here for anyone doing modern OpenGL; the topics are very broad. I particularly enjoyed the implementation details for various types of cameras, loading/rendering of 3D models, and screen-space ambient occlusion (SSAO).

The best part of the book is the example projects that can easily be built and run to demonstrate each of the recipes. There is no better way to help fully understand the concepts involved than by running and possibly stepping through the code yourself.

I only have a few relatively minor complaints. Some of the recipes show specific concepts but there isn't any attempt to discuss when or why you would use certain techniques, and when one technique may be better/faster than another. As with any cookbook, it's assumed you know what you're looking for and the book doesn't go out of its way to tell you when it's more appropriate to serve an omelet or a soufflé. There is also a lot of duplication of relatively boiler-plate code in the chapter text, such as several lines of code that simply flips a texture vertically. This is something that should have been done by the image-loading library, SOIL. Taking up space for this in each recipe that used textures seemed wasteful. Going back to the cookbook analogy, this topic would have been better in an appendix on the proper way to prepare simple sugar or heat up butter for those crepes.

Nits aside, there is a huge amount of ready-to-run example code for a wide variety of complex OpenGL concepts. From lights to shadows to 3D objects, particles, and animation, this book is an excellent value for anyone wanting to develop some cool 3D projects with modern OpenGL.
2 von 2 Kunden fanden die folgende Rezension hilfreich
Can help moving forward with the graphics programming. 29. August 2013
Von Bartlomiej F. - Veröffentlicht auf
Format: Taschenbuch
What I like:

The structure of the book makes it pretty easy to follow. In the beginning, it is good to read the introduction and familiarize with the application framework. After that, a reader can read in whatever order he/she likes. Each of the items is written in a similar way. Topics are of course done by a single person, so there is no need to switch between writing styles.

Vast majority of items are very well done and explained. I liked chapter about Order Independent Transparency in particular. You have there very good explanation, pictures, code (with additional comments) and a comparison of techniques at the end.

Another great item relates to Volume rendering (3D Textures, ray casting, splatting). Before reading the chapter I thought that such topic is quite hard to implement. Now, it looks simpler and clearer. There is a detailed discussion about final quality of the output. More the slices (or texture samples) the better the result, but performance drops.

Technology chosen is, in my opinion, very suitable. We have Visual C++ 2010, freeGLUT, Glm and SOIL.Those additional libraries are small and very simple to understand (not to mention their popularity). There is no additional need to learn some complicated framework/engine.

What I dislike:

The level of topics is sometimes strange. We have a nice and easy item that describes basic lighting, or item about simple particle systems. Next to it we have advanced elements like OOIT using dual depth peeling or even more like Ray Tracing. I would prefer to have items that are more or less at the same level. Or at least change the "distance" between extremes.

Some more description would be nice. I know that it is hard to compress all that knowledge in only 300 pages. But for some topics the author could make a bit more effort. For instance when dealing with geometry shaders and subdivision of a quad just a little diagram/image could explain more. This could make the book more complete.

To sum up: The book is definitely worth reading for any developer who has already managed to render a triangle in OpenGL and wants to go further.
2 von 2 Kunden fanden die folgende Rezension hilfreich
Solid start for modern OpenGL programming 20. August 2013
Von sinan çanga - Veröffentlicht auf
Format: Taschenbuch
PACKT requested me to review their recently published OpenGL book. Content seemed interesting and i agreed to write a review about it.

Web is still full of legacy OpenGL stuff and finding useful information about modern OpenGL can be pain. This book has no legacy info in it and entirely focuses on modern OpenGL (OpenGL 3.3+ core profile). Book is written in cookbook style so i don't think it is for beginners. If you have past experience with OpenGL and want to migrate modern OpenGL then this book is for you. If you are complete newbie or want to know more about the way OpenGL works then you should look somewhere else. Generally author did a good job on demonstrating modern OpenGL features through practical graphics examples.

Book starts with setting up a OpenGL 3.3 core profile application on Windows. Altough source code relies on cross platform technologies (freeglut, GLEW, glm and SOIL ) build system is stricly tied to a specific IDE (Visual Studio 2010). Additional effort required to build samples if you don't have access Visual Studio 2010 and above or if you are not a Windows user. Building samples on Linux shouldn't be a problem. On the other hand current Mac OS X does not support OpenGL 3.3 yet. Of course this is not book's problem. What i would rather have: headless build systems. May be i'm asking a bit much but i hope book authors consider this. Since modern OpenGL is a shader driven API author first develops a C++ shader class and uses it through rest of the book. Book talks about vertex, geometry and fragment shader stages of the pipeline. There is no mention about tesellation control and tesellation evaluation shaders. I really wish author devote some chapters for tesellation and compute shaders. Don't get confused, book contains valuable information from broad range of topics.

Book progressively develops from fundemantals to more advanced graphics techniques. Start to end style reading may be beneficial for people who wants to learn about modern OpenGL. In this way reader will meet OpenGL constructs about shader management, geometry data & its management and pixel data management in order.

Book can also be read out of order. In fact it is more suitable for random reading. You will most likely find information about a graphics technique you want to implement. Author discusses and provides implementations about some advanced topics like: cloth simulation, order independent transparency, volume rendering and GPU path tracing. I particularly found interesting doing physically based simulations entirely on GPU. I also like sections about volume rendering because author gives multiple implementations of volume rendering. Since it is a cookbook, devoted pages for a graphics technique are sometimes quite limited but author generally gives reference links to techniques explained. At least lack of theory about a topic explained is reduced that way..

After all, this is a good book and may be useful for people who have already an OpenGL background. Author talks about broad range of graphics topics in context of modern OpenGL.
2 von 2 Kunden fanden die folgende Rezension hilfreich
Learn OpenGL by example (almost) 8. September 2013
Von David Jeske - Veröffentlicht auf
Format: Kindle Edition Verifizierter Kauf
If you want to learn OpenGL v3.3+ by doing, rather than by studying, this is the book for you, because it's ultra concise and driven by simple, practical examples.

This book does *not* however, explain 3d mathematics or 3d rasterization. If you don't understand those concepts, I would pair this book with 3D Math Primer for Graphics and Game Development (Wordware Game Math Library), which I find to be the most approachable coverage of 3d math and the 3d rendering process.

Why do I like this book?

Compared to other OpenGL books (including the "official" orange-book), OpenGL Development Cookbook doesn't deluge you with mountains of functions all at once, it doesn't include unwieldy 3-5 page code fragments, and it doesn't bury you in every detail of every function. This is an excellent choice, because too many of those details can get in the way of understanding the key parts of getting results. Nitty gritty function definitions are all available freely on the Internet, so this book doesn't bother with them. Instead it shows practical, concise examples of how to use available OpenGL features and functions to achieve actual results.

After you get your bearings and can get basic stuff on screen, if the examples and the Internet have made you comfortable with the OpenGL API itself, you can move onto advanced rendering techniques presented in books such as OpenGL 4.0 Shading Language CookbookGPU Gems 3, GPU Computing Gems Jade Edition (Applications of GPU Computing Series), or in examples you can find by searching for them on the Internet.

If you find moving beyond the examples in this book is difficult because you haven't developed enough understanding of the OpenGL API itself, then you need a reference book such as OpenGL Programming Guide: The Official Guide to Learning OpenGL, Versions 3.0 and 3.1 (7th Edition) or OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 4.3 (8th Edition), or OpenGL(R) Programming Guide: The Official Guide to Learning OpenGL(R), Version 2.1 (6th Edition). Be sure to pick the right one(s) for the version of OpenGL you are targeting.

No book is perfect. The things not perfect about OpenGL Development Cookbook are...

1) The book periodically makes a claim as if it's cause is obvious to the reader, when in fact it is far from obvious to anyone who needs this book. One such example is the insufficient description of Vertex Array Objects mentioned by another reviewer. Another is a side-note about performance improvements to instance matrices which is not sufficiently explained. There are other similar 'glossings over', which are missing-links in an otherwise excellent learn-by-example book.

2) It would be nice if either there was some coverage of OpenGL 2 and GLSL 1.2, or the book mentioned it is only v3.3+ in the name. The book covers OpenGL/GLSL 3.3+ only, which is nice in that it's the new modern OpenGL, whose concepts scale into OpenGL 4 well. However, the baseline minspec for the widest desktop hardware compatibility (in 2013) is still OpenGL 2 + GLSL 1.2. Those who need to support older hardware will need to learn those examples elsewhere, as this book is entirely focused on the modern, more efficient, and more flexible OpenGL 3.3 and GLSL 3.3 style uniform buffers and vertex-buffers, index-buffers.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.