CppCon 2024

Our game programmers and game engines involve fights between heroes and their foes. There are «classical», traditional ways to express heroes and monsters fighting each other, but contemporary C++ is particularly expressive and versatile language and with out language there are many ways for heroes and monsters to hit at each other. These techniques are what this talk will explore

In game development the building and optimisation of data for the game is an important but resource intensive and time consuming process. In this talk I will describe techniques used to improve the performance and efficiency of a data build system that was developed as part of a AAA game project.

I will briefly describe the differences between how the game code and data building code operate, how those differences impact processing performance, how a profiler can be used to identify trouble spots, and describe techniques I used to improve multithreaded processing performance.

While this is coming from a game development perspective the techniques can be applied to any task based parallel data processing system.

XOffsetDatastructure is a serialization library designed to reduce or even eliminate the performance consumption of serialization and deserialization in the game industry by utilizing zero-encoding and zero-decoding. It is also a collection of high-performance data structures designed for efficient read and in-place/non-in-place write, with performance comparable to STL. 

Custom allocators are used to keep fields in contiguous memory, enabling them to be sent directly. Offset pointers are used to maintain pointer validity after buffer resizing and memory movement caused by modifications to variable-size fields. Some other techniques, such as containers that support offset pointers and auto-resizing mechanisms, are involved.

The performance statistics demonstrate that XOffsetDatastructure is a high-performance library, offering advantages in terms of encoding and decoding time, read and write performance, and message size compared to other modern C++ serialization libraries.

Writing an emulator is truly transformative for any aspiring developer. In this session, we will be building parts of a lightning-fast Nintendo GameBoy (DMG-001) emulator library, complete with a webAssembly frontend.

We will introduce the concept of a 'fast' emulator, highlighting its significance beyond mere gaming authenticity. After setting clear limits as to what we aim to achieve within the allotted time, we will delve into some foundational aspects of modern computing by implementing the core components of a GameBoy emulator. Along the way, the need for various programming patterns will emerge naturally, showcasing their relevance in real-world development scenarios.

Additionally, we will demonstrate how integrating modern high-level C++ constructs streamlines our codebase, enhancing both readability and performance. You will witness firsthand how these constructs simplify development and yield significant speed enhancements (even when applied to emulating low-level systems).

This session aims not only to provide practical insights into modern emulator construction but also to invite collaboration on future enhancements and optimizations.

It is common knowledge that online mulltiplayer games are some of the hardest kinds of software to develop. Game developers have to deal with data packets coming with a substancial delay, in fact working with data from the past. The rollback technique allows to give the illusion of real-time by extrapolating input with a game simulation from the confirm frame to the current one. However, for the implemention to work there are several key factors that need to be taken into account. The game simulation update needs to be deterministic, the game state should be easily copyable, and the game state should be clearly separated from the graphics side of the game.

For multiplayer games, deterministic simulations have been a Holy Grail for a long while. Indeed, if we have perfectly deterministic simulations - we can simply pass all the inputs to all the clients, and rely on each client to produce the same results, reducing network traffic by orders of magnitude. While especially important for RTS games, all kinds of multiplayer games would benefit from it.
However, while determinism was achieved in practice for single-platform, it is known to be a next-to-impossible to achieve for cross-platform clients. We will discuss the (well-known) reasons for it first - and will proceed into discussing our approach to the solution (with our open-source lib actually providing some implementations).
This talk is important for multiplayer gamedevs - and for anybody who is interested in deterministic calculations.

Modern video games are complex beasts that contains multiple systems interacting with one another storing, transferring and processing large sets of data in real time. While some data structures from the standard library such as the std::vector gets you by 90% of the time you need to store and process data, there will be the occasional 10% that requires a unique take.

This presentation aims to discuss the unique data structures that are commonly used in video games / game engines that caters to the occasional 10%. We will go over several systems outlining their requirements, constraints and present custom data structures that gets the job done.