Neu kaufen

Loggen Sie sich ein, um 1-Click® einzuschalten.
Mit kostenloser Probeteilnahme bei Amazon Prime. Melden Sie sich während des Bestellvorgangs an.
Gebraucht kaufen
Gebraucht - Gut Informationen anzeigen
Preis: EUR 21,07

Jetzt eintauschen
und EUR 2,68 Gutschein erhalten
Alle Angebote
Möchten Sie verkaufen? Hier verkaufen
Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Keine Abbildung vorhanden

Den Verlag informieren!
Ich möchte dieses Buch auf dem Kindle lesen.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

Video Game Optimization [Englisch] [Taschenbuch]

Eric Preisz , Ben Garney

Preis: EUR 29,80 kostenlose Lieferung. Siehe Details.
  Alle Preisangaben inkl. MwSt.
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
Nur noch 1 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Lieferung bis Mittwoch, 23. April: Wählen Sie an der Kasse Morning-Express. Siehe Details.


31. März 2010
"Video Game Optimization" describes a process for increasing the performance of a video game for better gameplay and visual experience. Very few game developers understand the process of optimizing an entire video game, yet learning the process is surprisingly simple and applicable to a broad audience. The book tackles the process of optimization by first describing how to determine where a game is limited and then providing detailed solutions and examples to solving this limitation. All the examples covered in the book can be applied to a variety of game types and coverage of how to optimize system memory, CPU processing, graphics, and shaders is included.

Hinweise und Aktionen

  • 5-EUR-Gutschein für Drogerie- und Beauty-Artikel:
    Kaufen Sie für mind. 25 EUR aus den Bereichen PC-und Videogames, Musik, DVD/Blu-ray und Hörbücher sowie Kalender und Fremdsprachige Bücher ein; der 5-EUR-Gutschein wird in Ihrem Amazon-Konto automatisch nach Versand der Artikel hinterlegt. Die Aktion gilt nicht für Downloads. Zur Aktion| Weitere Informationen (Geschäftsbedingungen)

Kunden, die diesen Artikel gekauft haben, kauften auch


Mehr über den Autor

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



Introduction to Graphics Optimization. Chapter 1: PC Graphics System Overview. Chapter 2: The Optimization Process. Chapter 3: Intro to Optimization Tools. Chapter 4: More on Hardware. Chapter 5: Optimizing System Memory. Chapter 6: Optimizing CPU Processing. Chapter 7: Optimizing CPUs using Multi-threading. Chapter 8: Optimizing Graphics CPU Problems. Chapter 9: Optimizing Graphics GPU Problems. Chapter 10: Optimizing Shaders. Chapter 11: Conclusions.

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

Eine digitale Version dieses Buchs im Kindle-Shop verkaufen

Wenn Sie ein Verleger oder Autor sind und die digitalen Rechte an einem Buch haben, können Sie die digitale Version des Buchs in unserem Kindle-Shop verkaufen. Weitere Informationen


Es gibt noch keine Kundenrezensionen auf
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Sterne
Die hilfreichsten Kundenrezensionen auf (beta) 4.4 von 5 Sternen  7 Rezensionen
12 von 12 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Good introduction, but seems rushed 8. August 2010
Von Jan-Harald Fredriksen - Veröffentlicht auf
Format:Taschenbuch|Von Amazon bestätigter Kauf
I have worked in the graphics (but not game) industry for a few years. A book dedicated to optimizations sounded interesting both for my own benefit, and as learning material for new engineers on my team.

The Introduction could have used a "prerequisites" section. The chapters on graphics, especially, use terms without defining them, e.g. "consider a game with a CPU animation bottleneck caused by having too many bones", p.91. General knowledge of graphics algorithms and terminology is definitely a prerequisite for this book.

The two first chapters serve as a good introduction to the book. The concepts of the Optimization Lifecycle, the Levels of Optimization and the Performance Budget certainly seem like a sensible way to structure - and talk about - optimization work. Chapter 3, The Tools, is necessary, but the section on vendor-specific tools is already slightly out-of-date (does not cover Parallel Nsight). This is inevitable, though - and generally the book is very up-to-date.

Chapters 4-10 is the core of the book. This is mostly very good - covering both CPU and GPU performance issues. The focus on "Holistic" optimization deserves special mention - it keeps the attention where it needs to be, which is on getting the overall game to run "fast enough" rather than needless cycle-optimization of code that's not on the critical path. That said, it's not perfect. Some parts feel slightly disorganized. For example, Chapter 8 has a section called "Locked Culling" - but there's no (explicit) mention of frustum culling in the preceding chapter. Similarly, including "Lights and Shadows" as one of the "Special Cases" seems quite strange. Also, I'd personally wished for more details - and further analysis of some of the performance results, but given that this is an introduction (and that the source is available) I can't complain too much.

Chapters 11-16 consists of various "bits and pieces" of varying usefulness. I got a lot out of the chapter on Managed Languages, which is an area I knew little about.
The chapter on Consoles felt unnecessary. It's short (10 pages), and all it really says it that with fixed hardware you can do more tricks. Perhaps focusing on one specific Console platform, or having a chapter on mobile game development (Android/iPhone) would have been more useful? Similarly, the chapter on GPGPU is too short to bring any real value. After an introduction to what GPUGPU is, there's only room for about a page of bottleneck-detection, and then it's finished.

Unfortunately, the book seems rushed, in that it's riddled with typos and minor errors.
A few examples:
* "such as OpenGL's GetLastError()", p.30. GetLastError is a Win32 API, glGetError is what's intended.
* "Consistency of frame rate, ..., is more important than the frame rate being too high.", p.33.. I assume "too low" is what's intended.
* Figure 10.1 and Figure 10.2 seem to be identical (except the x-axis is shifted). This is problematic since the text asks the reader to compare the graphs.
* "As you can see from this graph, ..", p.262. But there's no graph - only a formula.

There are also occasions where results are misquoted, e.g., "shows that it's about 100x faster", p.249, but the graph shows that it's about 6x faster. This is a shame since it reduces confidence in the numbers and figures quoted, which limits the usefulness of including these (otherwise very interesting) performance measurements in the first place.

Overall, this book has some good content, but it would have been easier to recommend if more of the bugs had been crushed before the book was published.
6 von 6 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen A Good Primer 7. Juli 2010
Von Eric Haines - Veröffentlicht auf
(I put this on my blog, with links, so thought I'd also post it here.)

I had the chance to spend some quality time with Preisz & Garney's recent book "Video Game Optimization" a few weeks back, as I was trapped in a 14 hour plane flight. I hardly spent all that time with it, though I probably should have spent more. Instead, "Shutter Island" and "It's Complicated" (with bad audio) are four hours out of my life I'll never get back.

This book goes from soup to nuts on the topic: types of optimization, how to set and achieve goals, discussion of specific tools (VTune, PIX, PerfHUD, etc.), where bottlenecks can occur and how to test for them, and in-depth coverage of CPU and GPU issues. Graphics and engine performance are the focus, including multicore and networking optimization, plus a chapter on consoles and another on managed languages. Some of the information is in the "obvious if you've done it before" category, but critical knowledge if you haven't, e.g., the first thing to do when optimizing is to create some good benchmark tests and lay down the baselines.

There are many specific tips, such as turning on the DirectX Debug runtime and seeing if any bugs are found. Even if your application appears to run fine with problems flagged, the fact that they're being flagged is a sign of lost performance (the API has to recover from your problem) or possible bugs. I hadn't really considered that aspect ("code works even with the warnings, why fix it?"), so plan to go back to work with renewed vigor in eliminating these when seen.

I also liked reading about how various optimizing compilers work nowadays. The main takeaway for me was to not worry about little syntactic tricks any more, most modern optimizers are good enough to make the code quite fast.

There's very little in this book with which I can find fault. I tested a few terms against the index. About the only lack I found was for the "small batch problem", where it pays to merge small static meshes into a single large mesh when possible. This topic does turn out to be covered (Chapter 8), but the index has nothing under "batch", "batching", "small batch", etc. There is also no index entry for "mesh". So the index, while present (and 12 pages long), does have at least one hole I could detect. There are other little index mismatches, like "NVIDIA PerfHUD Tool" and "NvPerfHud Tool" being separate entries, with different pages listed. Typo-wise, I found one small error on page 123, first line should say "stack" instead of "heap", I believe.

Executive summary: it's a worthwhile book for just about anyone interested in optimization. These guys are veteran experts in this field, and the book gives specific advice and practical tips in many areas. A huge range of topics are covered, the authors like to run various experiments and show where problems can occur (sometimes the cases are a bit pathological, but still interesting), and there are lots of bits of information to mull over. Long and short, recommended if you want to know about this subject.

One little update: Carmack's sqrt trick, mentioned in the book on page 155, is dated for the PC. According to Ian Ameline, "It has been obsolete since the Pentium 3 came out with SSE. The rsqrtss/rsqrtps instructions are faster still and have better and more predictable accuracy. Rsqrtss + one iteration of Newton/Raphson gives 22 (of 23) bits of accuracy, guaranteed."
5 von 6 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Somewhat disappointed 27. April 2010
Von Zachary Turner - Veröffentlicht auf
I was highly disappointed in this book. I had high hopes for it, even after browsing the table of contents it looked like it really hit the spot.

It does touch on all right points, but is almost completely devoid of detail in every area. It's basically just a lot of describing of what things ARE, with very little HOW or WHY. It'll tell you what vTune *is*, and what a cache miss *is*, and what a branch misprediction *is*, and what it means for something to be CPU bound vs GPU bound, but I found almost nothing in this book that I didn't already know. A lot was just definitions with very superficial explanations of what is going on behind the scenes.

What this book really needs are case studies at the end of every chapter. It needs before and after source code, an explanation of how a profiler was used to arrive at various conclusions and tune the code. Knowledge is useless if you can't apply it.

If you have a cursory understanding of the types of problems that arrive in optimization of graphical applications, then you might want to do a more thorough read of some of the pages fo the book before you make a final purchasing decision.

I gave it 3 stars because it's ok as one's first introduction to the subject. But if you have any practical experience, even if you just hear about other people talking about optimization, you might already know a lot of the material in the book.
2 von 2 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen A great book from cover to cover 28. April 2010
Von Avid Reader - Veröffentlicht auf
This is a highly readable book with a lot of useful information written by game industry veterans. This is not just a book about loop unrolling and the fastest square root algorithm (although these are covered). You will learn how to instrument your code to gain valuable performance insights. You will learn how to pinpoint the bottleneck in your application - is the the CPU or the GPU? Are you bound by the geometry of the scene or the fill-rate? How can you design your data structures to ensure optimal memory access? With the tools and techniques described in this book, you will be able to focus your time on the current bottleneck before tackling the next one. I can't recommend this book highly enough.
5 von 7 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen quite good 26. April 2010
Von anon - Veröffentlicht auf
Format:Taschenbuch|Von Amazon bestätigter Kauf
Lots of great stuff in this book. Having coded older system's custom chips at the register level, programmed in assembler, done some highly optimized C coding, and looked into this sort of stuff a lot in the past, a fair amount of it was familiar in the general sense but much has changed with modern PC CPU and GPU architectures and there was still a lot of good stuff to pick up- things have changed a lot and it helped to either solidify or alter various assumptions I had made about how things had changed. It really does a pretty solid job of covering many of the relevant points.

I believe there is a lot of invaluable stuff in here for modern day programmers in particular, many of whom seem to know less than nothing about writing optimized code and have never had to deal with programming in assembler or at the register level or with only 48K total memory and have either self-taught without ever bothering to think about issues of speed and efficiency or went through one of those programs where OO interpreted languages are treated as the second coming and if you must 'go to the metal' and use C++ make sure to go totally, absolutely crazy in object-orienting your C++ code to the nth to the nth degree (don't get too frightened though, it's not a book that by any remote means says to avoid OOP).
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Erster Beitrag:
Eingabe des Log-ins

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen

Ähnliche Artikel finden

Ihr Kommentar