OpenGL Development Cookbook et plus d'un million d'autres livres sont disponibles pour le Kindle d'Amazon. En savoir plus

Identifiez-vous pour activer la commande 1-Click.
Amazon Rachète votre article
Recevez un chèque-cadeau de EUR 12,92
Amazon Rachète cet article
Plus de choix
Vous l'avez déjà ? Vendez votre exemplaire ici
Désolé, cet article n'est pas disponible en
Image non disponible pour la
couleur :
Image non disponible

Commencez à lire OpenGL Development Cookbook sur votre Kindle en moins d'une minute.

Vous n'avez pas encore de Kindle ? Achetez-le ici ou téléchargez une application de lecture gratuite.

OpenGL Development Cookbook [Anglais] [Broché]

Muhammad Mobeen Movania

Prix : EUR 41,72 Livraison à EUR 0,01 En savoir plus.
  Tous les prix incluent la TVA
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
En stock.
Expédié et vendu par Amazon. Emballage cadeau disponible.


Prix Amazon Neuf à partir de Occasion à partir de
Format Kindle EUR 17,30  
Broché EUR 41,72  

Description de l'ouvrage

25 juin 2013

Over 40 recipes to help you learn, understand, and implement modern OpenGL in your applications


  • Explores current graphics programming techniques including GPU-based methods from the outlook of modern OpenGL 3.3
  • Includes GPU-based volume rendering algorithms
  • Discover how to employ GPU-based path and ray tracing
  • Create 3D mesh formats and skeletal animation with GPU skinning
  • Explore graphics elements including lights and shadows in an easy to understand manner

In Detail

OpenGL is the leading cross-language, multi-platform API used by masses of modern games and applications in a vast array of different sectors. Developing graphics with OpenGL lets you harness the increasing power of GPUs and really take your visuals to the next level.

OpenGL Development Cookbook is your guide to graphical programming techniques to implement 3D mesh formats and skeletal animation to learn and understand OpenGL.

OpenGL Development Cookbook introduces you to the modern OpenGL. Beginning with vertex-based deformations, common mesh formats, and skeletal animation with GPU skinning, and going on to demonstrate different shader stages in the graphics pipeline. OpenGL Development Cookbook focuses on providing you with practical examples on complex topics, such as variance shadow mapping, GPU-based paths, and ray tracing. By the end you will be familiar with the latest advanced GPU-based volume rendering techniques.

What you will learn from this book

  • Create an OpenGL 3.3 rendering context
  • Get to grips with camera-based viewing and object picking techniques
  • Learn off-screen rendering and environment mapping techniques to render mirrors
  • Discover shadow mapping techniques, including variance shadow mapping
  • Implement a particle system using shaders
  • Learn about GPU-based methods for global illumination using spherical harmonics and SSAO
  • Understand translucent geometry and order independent transparency using dual depth peeling
  • Explore GPU-based volumetric lighting using half angle slicing and physically based simulation on the GPU using transform feedback


This hands-on Cookbook cuts through the preamble and gets straight to the point. OpenGL Development Cookbook is perfect for intermediate C++ programmers. Full of practical techniques for implementing amazing computer graphics and visualizations, using OpenGL. Crammed full of useful recipes, OpenGL Development Cookbook will help you exploit OpenGL to its full potential.

Who this book is written for

OpenGL Development Cookbook is geared toward intermediate OpenGL programmers to take you to the next level and create amazing OpenGL graphics in your applications.

Offres spéciales et liens associés

Descriptions du produit

Biographie de l'auteur

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.

Détails sur le produit

En savoir plus sur l'auteur

Découvrez des livres, informez-vous sur les écrivains, lisez des blogs d'auteurs et bien plus encore.

Quels sont les autres articles que les clients achètent après avoir regardé cet article?

Commentaires en ligne 

Il n'y a pas encore de commentaires clients sur
5 étoiles
4 étoiles
3 étoiles
2 étoiles
1 étoiles
Commentaires client les plus utiles sur (beta) 4.1 étoiles sur 5  9 commentaires
6 internautes sur 6 ont trouvé ce commentaire utile 
3.0 étoiles sur 5 Great premise, average execution 25 août 2013
Par Lorenzo Mancini - Publié sur
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 internautes sur 3 ont trouvé ce commentaire utile 
4.0 étoiles sur 5 A diverse selection of graphical recipes for OpenGL 3.3 26 juillet 2013
Par Paul T. Miller - Publié sur
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 internautes sur 2 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Learn OpenGL by example (almost) 8 septembre 2013
Par David Jeske - Publié sur
Format:Format Kindle|Achat vérifié
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.
1 internautes sur 1 ont trouvé ce commentaire utile 
4.0 étoiles sur 5 Can help moving forward with the graphics programming. 29 août 2013
Par Bartlomiej F. - Publié sur
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.
1 internautes sur 1 ont trouvé ce commentaire utile 
4.0 étoiles sur 5 Solid start for modern OpenGL programming 20 août 2013
Par sinan çanga - Publié sur
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.
Ces commentaires ont-ils été utiles ?   Dites-le-nous

Discussions entre clients

Le forum concernant ce produit
Discussion Réponses Message le plus récent
Pas de discussions pour l'instant

Posez des questions, partagez votre opinion, gagnez en compréhension
Démarrer une nouvelle discussion
Première publication:
Aller s'identifier

Rechercher parmi les discussions des clients
Rechercher dans toutes les discussions Amazon

Rechercher des articles similaires par rubrique


Souhaitez-vous compléter ou améliorer les informations sur ce produit ? Ou faire modifier les images?