Video Game Optimization 1st Edition

by Eric Preisz (Author), Ben Garney (Author)

10 ratings

ISBN-13: 978-1598634358

ISBN-10: 1598634356

Why is ISBN important?

Paperback

$92.95

Other Sellers

from

Other Sellers

See all 3 versions

More Buying Choices

10 Used from $30.98

Used (10) from $30.98

See All Buying Options

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

More items to explore

Page 1 of 1 Start overPage 1 of 1

Customers who bought this item also bought

Page 1 of 1 Start overPage 1 of 1

Anthony Williams
83
Paperback
$53.57

Get everything you need

Page 1 of 1 Start overPage 1 of 1

Anthony Williams
83
Paperback
$53.57
Fletcher Dunn
77
Hardcover
$130.00
Eldad Eilam
131
Paperback
$20.77
Jason Gregory
136
Hardcover
$81.89

Special offers and product promotions

Amazon Business: Make the most of your Amazon Business account with exclusive tools and savings. Login now

Editorial Reviews

About the Author

Eric Preisz is the course director for optimization at Full Sail Real World Education's game design bachelor's program. His practical experience began while optimizing video games and simulation software. Eric is the founder of C2C Simulation, a company that provides visual application development for the modeling, simulation, and training community as well as the location based entertainment industry. His experience involves work with NASA, Army, Department of Homeland Security and other government agencies.

Ben Garney works at PushButton Labs, where he is the lead developer on the PushButton Engine, an open source Flash game framework. Before he got into Flash game development, Ben spent five years at GarageGames, working on Torque engine technology. During that time, he helped ship several games, most notably Marble Blast Ultra on the XBox 360.

Product details

Publisher ‏ : ‎ Cengage Learning PTR; 1st edition (March 1, 2010)
Language ‏ : ‎ English
Paperback ‏ : ‎ 368 pages
ISBN-10 ‏ : ‎ 1598634356
ISBN-13 ‏ : ‎ 978-1598634358
Item Weight ‏ : ‎ 1.6 pounds
Dimensions ‏ : ‎ 7.5 x 0.75 x 9.5 inches

Best Sellers Rank: #3,586,985 in Books (See Top 100 in Books)
- #2,583 in Game Programming
- #3,003 in Computer Graphics

Customer Reviews:
10 ratings

Customer reviews

5 star		58%
4 star		25%
3 star		17%
2 star 0% (0%)		0%
1 star 0% (0%)		0%

How are ratings calculated?

Top reviews from the United States

There was a problem filtering reviews right now. Please try again later.

Amazon Customer

Excellent book for optimization novice

Reviewed in the United States on December 31, 2011

Verified Purchase

I have been a professional software engineer (C++, 3D simulations) for 10+ years, but have never had a need to work with low-level CPU / GPU optimization until recently.

This is an excellent introduction that explains (refreshes) the hardware components, their interactions, and various optimization interactions and techniques. I read the book from cover to cover and am glad I did--it was worth the investment.

I expect if you have spent a year or more in a position where you need to optimize a 3D game or application, then this wouldn't be as valuable to you.

Note: I expect books to be accurate overall and worth their value and not to be perfect. This one lives up to that expectation.

Helpful

Jan-Harald Fredriksen

Good introduction, but seems rushed

Reviewed in the United States on August 8, 2010

Verified Purchase

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.

12 people found this helpful

Helpful

anon

quite good

Reviewed in the United States on April 26, 2010

Verified Purchase

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

5 people found this helpful

Helpful

Pages with related products. See and discover other items: 2d design