Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.

  • Apple
  • Android
  • Windows Phone
  • Android

Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.

Kindle-Preis: EUR 19,98
inkl. MwSt.

Diese Aktionen werden auf diesen Artikel angewendet:

Einige Angebote können miteinander kombiniert werden, andere nicht. Für mehr Details lesen Sie bitte die Nutzungsbedingungen der jeweiligen Promotion.

An Ihren Kindle oder ein anderes Gerät senden

An Ihren Kindle oder ein anderes Gerät senden

Facebook Twitter Pinterest <Einbetten>
OpenGL Development Cookbook von [Movania, Muhammad Mobeen]
Anzeige für Kindle-App

OpenGL Development Cookbook Kindle Edition

2.0 von 5 Sternen 1 Kundenrezension

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Preis
Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
EUR 19,98

Länge: 328 Seiten Sprache: Englisch
  • Aufgrund der Dateigröße dauert der Download dieses Buchs möglicherweise länger.

August-Aktion: Englische eBooks stark reduziert
Entdecken Sie unsere Auswahl an englischen eBooks aus verschiedenen Genres für je 1,99 EUR. Die aktuelle Aktion läuft noch bis 31. August 2016.

Produktbeschreibungen

Kurzbeschreibung

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.

Approach

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

Ü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 (http://code.google.com/p/opencloth ) which implements various cloth simulation algorithms in OpenGL. His blog (http://mmmovania.blogspot.com) 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.


Produktinformation

  • Format: Kindle Edition
  • Dateigröße: 15006 KB
  • Seitenzahl der Print-Ausgabe: 328 Seiten
  • ISBN-Quelle für Seitenzahl: 1849695040
  • Verlag: Packt Publishing (25. Juni 2013)
  • Verkauf durch: Amazon Media EU S.à r.l.
  • Sprache: Englisch
  • ASIN: B00DN3KHFE
  • Text-to-Speech (Vorlesemodus): Aktiviert
  • X-Ray:
  • Word Wise: Nicht aktiviert
  • Verbesserter Schriftsatz: Nicht aktiviert
  • Durchschnittliche Kundenbewertung: 2.0 von 5 Sternen 1 Kundenrezension
  • Amazon Bestseller-Rang: #330.592 Bezahlt in Kindle-Shop (Siehe Top 100 Bezahlt in Kindle-Shop)

  •  Ist der Verkauf dieses Produkts für Sie nicht akzeptabel?

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

Kundenrezensionen

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

Top-Kundenrezensionen

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.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 4.1 von 5 Sternen 10 Rezensionen
9 von 9 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Great premise, average execution 25. August 2013
Von Lorenzo Mancini - Veröffentlicht auf Amazon.com
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.
5 von 5 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen A diverse selection of graphical recipes for OpenGL 3.3 26. Juli 2013
Von Paul T. Miller - Veröffentlicht auf Amazon.com
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.
3 von 3 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Can help moving forward with the graphics programming. 29. August 2013
Von Bartlomiej F. - Veröffentlicht auf Amazon.com
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
4.0 von 5 Sternen Solid start for modern OpenGL programming 20. August 2013
Von sinan çanga - Veröffentlicht auf Amazon.com
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.
1 von 1 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Good in parts 1. Dezember 2013
Von DC Bateman - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I found this be a real "Curate’s egg" of a book, that is, despite some marked shortcomings it was also very good in parts.

The book feels more like a more traditional textbook than a "cook book", rather than addressing specific problems general areas are tackled. Frequently recipes are not self-contained relying on previous recipes.

Clearly, the author isn't a native English speaker; the book uses rather idiosyncratic English, occasional clumsy phrasing, a mix of formal and informal English and inconsistent terminology leading to a curiously verbose style which is unfortunately at odds with the given format where brevity would be appreciated. A minor flaw, but it was distracting and wholly unnecessary, making the book difficult too read; a competent editor could have easily rephrased the text to use standard English (for example "the GLUT library was _written_" rather than "invented").

Despite the book being aimed at intermediate graphics programmers the first chapter covers many basic concepts, but confusingly, poorly and incompletely. Basics, such as setting up the development environment and supporting libraries, as well as an irrelevant background on earlier versions of OpenGL are covered, but shader compilation, program objects, the various buffers and their properties are not explained. Both could have been usefully included as appendices. One egregious flaw is the described shader class overloading the [] and () operators as accessors -- which is terrible coding practice.

Subsequent chapters are much stronger, considered, interesting and useful, providing insights and well coded, offering and contrasting several different approaches to a given problem.

The book is code heavy, with accompanying explanatory text but this rapidly becomes repetitious and much of the code is self-explanatory making explanation superfluous. New terms are frequently used but not explained until a later section, leading to confusion. Although not comprehensive (in truth an impossibility) a good range of topics are covered, including some crucial fundamentals.

I really wanted to like this book but found it to be a quite frustrating mix, despite some quite major flaws there are enough insights and good coding samples to make this book this book worthwhile, if approached with caution and appropriately managed expectations.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.
click to open popover