Game Engine Architecture Review

Game Engine Architecture - Jason Gregory

I’ve toyed around with building a very simple game engine over the last few months and made some progress in regards to the renderer of the engine but unfortunately during development, for every question I answered another 10 sprung up, with every new question and my frustration grew, and after the third re-planning of the engine core and the 4th rewrite, I gave into my frustration and just threw the engine on the back burner. Now why didnt I just get a book on game engines and move on from there, well I’ve read a few books on the topic of designing and creating game engines in the past, and they left me severely unimpressed and jaded, possibly some of the biggest wastes of paper out there and I guess that’s one of the reasons I avoided looking for a new book on the topic and just gave up.Then few months back this book popped up in my monthly amazon recommendations as an upcoming book and I was intrigued by it, I had already seen it briefly mentioned in the previous months GDMAG, so I went through the table of contents, browsed a few pages online and decided what the hell, it looked interesting and pre-ordered it.

So I bought the book and read it and am I glad I did? Hell yes! I sure am, this is by far one of the best game development books I own, this book has quickly become one of the stars in my library next to classics like “Real Time Rendering”, “C++ for game developers” and “Mathematics for Game Developers”.

The book covers the modern game development process and the general architecture of a modern game engine ( a full table of contents can be found here: http://www.gameenginebook.com/toc.html ) and all the relevant key sub-systems of the engine like the renderer, the animation system, resource and input management and so on. At this point by looking at the table of contents, you’d easily be fooled that this book will show you how to program a game engine from start to finish. It does not and for that I am beyond thankful, my main issue with all the previous game engine books I have read was that they were all of the “I’ve developed a basic game engine and this is how I did it” variety and on a very beginner level. Those books tend to cater for the amateur developers and the hobbyist programmers that want to quickly hammer out a simple game engine and so half the book is spent on teaching basic programming techniques and a 3D rendering API. If you are looking for a book that will teach you how to program a basic game engine from start to finish with example code, this is not the book for you!

As I said this book doesn’t follow that approach, what it does do is cover the modern game development cycle, a brief software engineering review, a c++ review and a very nice math primer in the first 4 chapters. Chapters 5 to 9 deal with the low level subsystems, chapters 10-12 handle the rendering aspects and the final two chapters deal with gameplay mechanics. Each chapter deals with a single sub-system of a game engine and gives a high level overview of all the requirements and associated issues, then zooms in on key requirements and offers semi-detailed explanations and most importantly points the reader to various solutions and resources with more information on the subject. It is impossible to cover all aspect in great details and luckily the author doesn’t attempt to do so but rather gives a general overview of various solutions for each problem, allowing a curious reader to further research the topic in his own time.

The author, Jason Gregory, is a senior developer at Naughty Dog studios, and has worked on large AAA titles such as “Uncharted” and “Medal of Honor: Airborne”. The overall writing style is very casual and light, and on more than one occasion I found myself forgetting that I was reading a “serious” book on game engines and even though each paragraph held a ton of technical information it’s a joy to read. This is the type of book that I can leave on my bedside table and read through a chapter before going to bed and yet still learn a lot. There is a large amount of skill involved in being able to cover advanced topics so casually and fluently, this highlights the author’s extensive experience in the field. To put it plainly this book is a pleasure to read. Each section is supplemented with informative graphs, snippets and figures from commercial games. Key topics are often explained using debugging screenshots and case studies from uncharted and other games the author has previously worked on in addition to a rough overview of how the game studio solved/implemented the problem or concept, all of which gave me a better idea of what is involved in implementing a working version of each engine subsystem, and gave me a head start on what problems I might expect to encounter during development. I cannot stress enough how well written this book is. The book is suitable for both amateur and experienced programmers alike, and wont alienate either. This in itself is an astonishing achievement.

As I’ve mentioned I have read several other books on the topic (3D game engine design, 3D game engine architecture and 3D Game Engine Programming) and those books simply annoyed and frustrated me, the authors treat the reader as an amateur and so they see no need to offer justification of their design decisions, the bulk of the books deal with the low level implementations of extremely basic versions of the key systems. They also suffered from bad writing style and a noticeable lack of experience with commercial engines. In my opinion experience comes from equal parts knowledge, “trial and error” and instruction, having a book instruct you on how to build an engine step by step has only taught you how to build that one engine and nothing more.

Jason Gregory, doesn’t take this approach and simply covers the tasks that the engine needs to solve and offers a few common solutions, for example given the problem of z-fighting during rendering, after a clear explanation of the problem and the causes, he then covers various techniques that can be implemented in the render that can improve the situation (z-buffer depth, w-buffers, etc ). Each chapter has several code snippets but doesn’t attempt to give you a cut and paste solution to the problem, the code is provided is very basic and serves only as an example (almost to the point of being pseudocode).

In the course of reading this book I have personally learned so much and have gotten a much clearer overview of what a game engine actually is, and what is involved in writing one. A ton of my previous questions were answered and while, as expected, another of questions replaced them, there was major difference in the level of questions that I asked myself. Whereas before this book most of my questions were high level planning and architecture based, not really sure what systems I needed and how I needed to couple them now the bulk of my questions are of a lower level along the lines of should drawable objects each have its own draw method or should the render have draw methods for each drawable object type?

My recommendation for anyone interested in how modern game engines work or that is thinking about starting to write one is to get their hands on this book! This book is simply one of the most important pieces of game development literature I have ever read and is a necessary addition to any wannabe game developer’s library.