What you will learn in High Performance Unity Game Development
Using data-oriented design
Chapter by chapter
Chapter 1: Understanding data-oriented design
Introduces data-oriented design as a way to organize Unity game code around data flow, explains its main benefits, and distinguishes it from Unity DOTS and ECS.
What you learn in chapter 1 →Chapter 2: Structuring data for performance
The chapter introduction connects array-based data locality to performance and previews a closer look at how data is stored.
What you learn in chapter 2 →Chapter 3: Memory allocations and performance
The introduction explains why memory management matters to game performance and identifies garbage collection and fragmentation as risks explored later in the chapter.
What you learn in chapter 3 →Chapter 4: Data and logic
Introduces the survivor game used to illustrate a data-oriented architecture, distinguishing balance, runtime game data, and logic while outlining the example’s gameplay and pooling constraint.
What you learn in chapter 4 →Chapter 5: Game board and game loop
The introduction positions Board and Game as the remaining parts of the DOD architecture and explains why Unity is the setting for implementing them.
What you learn in chapter 5 →Chapter 6: Common data structures: List, Stack, and Queue
The introduction explains why arrays fit data-oriented design and why built-in collections, despite making dynamic changes easier, warrant scrutiny.
What you learn in chapter 6 →Chapter 7: Separating data and logic
The introduction presents separating data from logic and keeping code deliberately simple as ways to reduce complexity and make future features easier to add.
What you learn in chapter 7 →Chapter 8: Separating asset data and logic
This introduction explains why menu development benefits from separating dynamic UI asset data from static components and treating each menu’s needs independently.
What you learn in chapter 8 →Chapter 9: Tooltime data parsing
The introduction explains why separating balance data from Unity scene and runtime assets can improve designers’ workflow, reduce runtime checks, and support live updates and testing.
What you learn in chapter 9 →Chapter 10: DOD and Dictionaries
The introduction contrasts dictionary lookups with indexed arrays and explains why data-oriented design favors arrays for enemy balance data despite dictionaries’ O(1) complexity.
What you learn in chapter 10 →Chapter 11: Branching, performance, and extendibility
The introduction explains how branches affect code complexity and runtime performance, and how grouping data can remove checks from hot loops.
What you learn in chapter 11 →Chapter 12: Unity DOTS
The chapter introduction connects the existing data-oriented design to DOTS and distinguishes how SIMD and parallel processing increase throughput.
What you learn in chapter 12 →Concepts explained in this book
- data-oriented programmingAn approach to structuring software around the flow and transformation of data rather than relationships between objects.
- balance dataThe example game's designer-authored gameplay settings, kept separate from runtime state.
- object poolA preallocated collection of slots that holds data or objects for reuse.
- main loopA recurring control structure that advances a game through updates, input handling, rendering coordination, and other gameplay systems.
- data localityThe degree to which related data is stored or accessed close together in the memory hierarchy.
- complexity metricA measure of the structural intricacy and difficulty of understanding, modifying, or executing software code.
- validationThe process of checking data or references against validity constraints before use.
- stack memoryA region of runtime memory typically used for function call frames and short-lived local values.
- arrayAn indexed sequence of elements, typically stored in contiguous memory.
- branchControl flow that selects among different execution paths, commonly according to conditions.
- structA value-type language construct that groups related data fields and may define associated behavior.
- pass by valueA parameter-passing behavior in which a function receives a copy of an argument's value.
- classA language construct that defines the data and behavior of objects created from that type.
- backward compatibilityBackward compatibility is the ability of newer software or data formats to continue working with older versions or previously created data.
- MapA lookup table is a data structure that maps keys to corresponding values for retrieval.
- listA C# List is a dynamically sized sequence collection that stores elements in an internal array and provides indexed access and element operations.
- entity component systemECS is an architecture that represents entities separately from their data components and the systems that process those components.
- ScriptableObjectA Unity object type for storing data as reusable project assets independently of scene GameObjects and components.
- heapA region of runtime memory used for dynamically allocated data whose lifetime is managed separately from function call frames.
- live asset updateChanging or replacing application content without requiring a new application build.
- Singleton patternA singleton is a pattern that restricts a class to one shared instance and provides centralized access to it.
- menu systemA coordinated collection of game user-interface menus and the logic governing their transitions and interactions.
- direct couplingAn explicit dependency in which one software component directly refers to and relies on another component.
- data flowThe directed movement and transformation of data through the stages of a software system.
- memory fragmentationMemory fragmentation is the condition in which available memory is divided into separated holes that may not accommodate a requested contiguous allocation.
- garbage collectionThe automatic process of identifying and reclaiming memory occupied by unreachable objects.
- parsingAnalyzing encoded or structured input and converting it into program-readable values.
- asset bundleA Unity asset package that stores assets for loading at runtime independently of the main application build.
- asset dataAsset data is game content and configuration data representing resources loaded or assigned for use by a game.
- A/B testA/B testing is an experiment that compares two or more variants by assigning them to different user groups and measuring the resulting outcomes.
- null handlingA null check is a test that determines whether a reference or object represents no value or has been invalidated.
- branch predictionBranch prediction is processor hardware behavior that predicts the outcome of a conditional branch before it is resolved.
- BinaryWriterBinaryWriter is a .NET class that writes primitive types as binary data to a stream.
- array of classesAn array whose elements are references to class instances allocated separately on the heap.
- array of structsAn array whose elements are struct values stored together in the array's contiguous memory block.
- Unity DOTSUnity's Data-Oriented Technology Stack, a collection of packages for building data-oriented applications and games.
- tool timeThe development or preparation phase in which game data is created, processed, or validated before runtime.
- code duplicationThe practice of implementing the same or similar code in multiple places instead of sharing one implementation.
- binary formatA format that represents data as encoded bytes rather than human-readable text.
- serializationSerialization is the encoding of in-memory data into a storable or transferable representation.
- queueA data structure that stores elements for first-in, first-out retrieval.
- pass by referenceA parameter-passing behavior in which a function receives access to the original argument or its storage location rather than an independent copy.
- ref keywordThe C# ref keyword specifies that an argument is passed by reference so the called code can access the caller's variable directly.
- extensibilityThe property of software that allows new capabilities or content to be added with limited changes to existing code.
- data typeA specification of the kind of value a program element can represent and the operations and storage interpretation associated with it.
- TransformAccessArrayA Unity data structure that provides job-compatible access to GameObject transforms.
- JobsUnity's job-system mechanism for scheduling work that can execute asynchronously or in parallel.
- pure functionA function whose result depends only on its inputs and that produces no externally observable side effects.
- brute-force distance checkA collision-checking technique that tests distances between every pair of entities directly.
- finite-state machineA computational model that represents behavior as a finite set of states and transitions between them.
- temporary dataRuntime data whose lifetime spans only a short operation or update rather than the entire gameplay session.
- memory allocationThe reservation of memory space for storing program data during execution.
- ShortA fixed-width integer data type for representing relatively small whole-number values.
- logic dataData representing the state and rules of a game's simulation independently of its visual representation.
- visual dataVisual data represents the scene objects and presentation state used to display a game's simulation.
- branch mispredictionA branch misprediction is an incorrect processor prediction of the outcome or execution path of a conditional branch.
- live balance updateA live balance update is a change to gameplay-balance configuration delivered while players use the game without releasing a new game version.
- componentAn ECS data unit that stores an attribute or group of attributes associated with an entity.
- entityIn this section's ECS representation, an entity is an index in data arrays that identifies an individual record.
- systemIn this section's ECS representation, a system is logic that operates on data arrays.
- 16-byte guidelineA practical recommendation to keep structs at or below 16 bytes to limit copying costs and misuse.
- Resources folderA Unity project folder whose assets can be loaded at runtime through Unity's Resources asset-loading system.
- hash collisionA hash collision occurs when distinct keys produce the same hash value.
- hash chainA linked sequence of hash-table entries that share the same bucket because their keys produce colliding hash values.
- linear searchA search technique that examines elements sequentially until it finds a match or reaches the end.
- value typeA data type whose values are copied directly when passed or assigned, rather than passing a reference to the same object.
- cache lineA cache line is a contiguous chunk of memory data transferred into a processor cache as a unit.
- Unity sceneA Unity asset that contains a collection of scene objects, environment settings, and other state used to construct a playable or editable portion of a game.
- BurstUnity's optimizing compiler that converts compatible C# code into highly optimized native code.
- early returnAn early return is a control-flow technique in which a function exits before reaching its normal completion point.
- prefabA Unity asset template that stores a reusable GameObject hierarchy and its component configuration.
- cache missA memory access in which the requested data is not found in a processor cache and must be retrieved from another memory level.
- BinaryReaderBinaryReader is a .NET class that reads primitive types in binary from a stream.
- unique identifierA value assigned to an entity to distinguish it from other entities and preserve its identity across changes.
- vector normalizationThe operation of scaling a nonzero vector to have a magnitude of one while preserving its direction.
- contiguous memory layoutA region of memory in which elements occupy adjacent addresses without gaps between them.
- CPU cacheA small, fast memory near a processor core that stores data for quicker access than main memory.
- UnityA game engine and development platform for creating and running interactive real-time experiences.
- parallelismExecuting computational work concurrently by dividing it into tasks.
- stringA string is a sequence of text characters represented as a value that can be stored and manipulated by a program.
- first-in-last-out structureAn ordering discipline in which the most recently added item is the first removed.
- primitive typeA fundamental built-in data type representing basic values directly supported by a programming language.
- virtual joystickA touch- or pointer-driven on-screen control that represents directional input for a game character.
- static classA class that cannot be instantiated and whose members are associated with the class itself rather than with object instances.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
