Book Overview & Buying
Table Of Contents
Feedback & Rating

Unity Game Optimization - Third Edition

By : Dr. Davide Aversa, Chris Dickinson

5 (1)

Buy this Book

Unity Game Optimization

5 (1)

By: Dr. Davide Aversa, Chris Dickinson

Buy this Book

Overview of this book

Unity engine comes with a great set of features to help you build high-performance games. This Unity book is your guide to optimizing various aspects of your game development, from game characters and scripts, right through to animations. You’ll explore techniques for writing better game scripts and learn how to optimize a game using Unity technologies such as ECS and the Burst compiler. The book will also help you manage third-party tooling used with the Unity ecosystem. You’ll also focus on the problems in the performance of large games and virtual reality (VR) projects in Unity, gaining insights into detecting performance issues and performing root cause analysis. As you progress, you’ll discover best practices for your Unity C# script code and get to grips with usage patterns. Later, you’ll be able to optimize audio resources and texture files, along with effectively storing and using resource files. You’ll then delve into the Rendering Pipeline and learn how to identify performance problems in the pipeline. In addition to this, you’ll learn how to optimize the memory and processing unit of Unity. Finally, you’ll cover tips and tricks used by Unity professionals to improve the project workflow. By the end of this book, you’ll have developed the skills you need to build interactive games using Unity and its components.

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

Section 1: Base Scripting Optimization

Evaluating Performance Problems

Gathering profiling data using the Unity Profiler

Best approaches to performance analysis

Final thoughts on profiling and analysis

Summary

Scripting Strategies

Obtaining components using the fastest method

Removing empty callback definitions

Caching component references

Sharing calculation output

Update, coroutines, and InvokeRepeating

Faster GameObject null reference checks

Avoid retrieving string properties from GameObjects

Using appropriate data structures

Avoiding re-parenting transforms at runtime

Considering caching transform changes

Avoiding Find() and SendMessage() at runtime

Disabling unused scripts and objects

Using distance-squared over distance

Minimizing deserialization behavior

Loading scenes additively and asynchronously

Creating a custom Update() layer

Summary

Section 2: Graphical Optimizations

The Benefits of Batching

Draw calls

Materials and shaders

The Frame Debugger

Dynamic batching

Static batching

Summary

Optimizing Your Art Assets

Audio

Texture files

Mesh and animation files

Asset bundles and resources

Summary

Faster Physics

Understanding the physics engine

Physics performance optimizations

Summary

Dynamic Graphics

Exploring the Rendering Pipeline

Detecting performance issues

Rendering performance enhancements

Summary

Section 3: Advance Optimizations

Optimizations for Virtual and Augmented Reality

Overview of XR technology

Developing XR products

Performance enhancements in XR

Summary

Masterful Memory Management

The Mono platform

Code compilation

Profiling memory

Memory management performance enhancements

Summary

The Data-Oriented Technology Stack

The problem of multithreading

The Unity Job System

The new ECS

The burst compiler

Summary

Tactical Tips and Tricks

Editor hotkey tips

Editor UI tips

Scripting tips

Custom Editor scripts and menu tips

External tips

Other tips

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 (1)

5 star

100%

4 star

3 star

2 star

1 star

Evaluating Performance Problems

Performance evaluation for most software products is a very scientific process. First, we determine the maximum/minimum supported performance metrics, such as the allowed memory usage, acceptable CPU consumption, and the number of concurrent users. Next, we perform load testing against the application in scenarios with a version of the application built for the target platform, and test it while gathering instrumentation data. Once this data is collected, we analyze and search it for performance bottlenecks. If problems are discovered, we complete a Root Cause Analysis (RCA), and then make changes in the configuration or application code to fix the issue and repeat it.

Although game development is a very artistic process, it is still exceptionally technical. Our game should have a target audience in mind, which can tell us what hardware limitations...