Unity Game Optimization

By : Dr. Davide Aversa , Dickinson

5 (1)

Buy this Book

Unity Game Optimization

5 (1)

By: Dr. Davide Aversa , 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

The Frame Debugger

Before we dive into how batching can save us draw calls, let's explore a useful tool that can help us to determine how batching is affecting our scene—the Frame Debugger.

We can open Frame Debugger by selecting Window | Analysis | Frame Debugger from the main window or clicking on the Frame Debugger button in Breakdown View Options in the rendering area of the Profiler. Either approach will open the Frame Debug window.

Clicking on the Enable button in the Frame Debug window will allow us to observe how our scene is being constructed, one draw call at a time. The following screenshot shows the user interface of the Frame Debugger, with a list of GPU instructions in the left-hand panel and more detailed information in the right-hand panel: