XNA Game Engine Tutorial Series

The XNA Game Engine Tutorial Series goes through the entirety of game engine development, using XNA and C#, starting with the basics like component design and working all the way through to advanced graphics and tools such as a level designer.

Chapter 1: Component and GameScreen

Chapter 1 of the tutorial describes the basics of designing components for the engine. A component can be a 2D or 3D entity, each of which have specific properties that describe their location and transformations. The GameScreen is a container for a group of components, useful for designing menus, pause screens, gameplay screens, etc.

Chapter 2: Engine, Content, and Services

In, Chapter 2 of the tutorial we build the Engine class, the core of the game engine, that handles Content loading through the custom content manager, service providers, such as cameras using the custom service container, as well as update and draw functions for the engine, gamescreens, and components.

Chapter 3: Utilities, Components, Actor, Camera

In Chapter 3 of the tutorial, we add some utilities to the engine for graphics and math, and build some example components. Then we start on some real components, an Actor class that handles the loading and drawing of a model, and a Camera that keeps track of values like view position, target, etc. Finally, we create an Actor and draw it on screen using a Camera.

Chapter 4: Draw Order

Chapter 4 of the tutorial leads us through the implementation of draw order on components, which allow components to be drawn in a specific order, no matter what order they were created in. This is important for things like sky boxes, which must be drawn first so as to appear infinite, and for drawing models with alpha blending (transparency), because they must be drawn back to front so they dont draw over eachother.

Chapter 5: Physics

In Chapter 5 of the tutorial, we implement JigLibX physics to simulate capsules, boxes, spheres, heightmaps, and triangle meshes in the engine. We finish by creating a stack of boxes and knocking it over.

Chapter 6: Input

In Chapter 6 of the tutorial, we design an input system to handle input from standard input devices like the Mouse, Keyboard, and GamePad, but leave room to add other devices.

Chapter 7: First Person Camera

In Chapter 7 of the tutorial, we build a First Person Camera, the type used in FPS games. We allows the camera to be controlled by the keyboard and mouse, and set it up to shoot boxes from the view point when the mouse button is pressed.

Chapter 8: Basic Terrain

In the 8th chapter of the tutorial, we build a class that builds a terrain from a 2D heightmap and applies a texture to it.

Chapter 9: Component Predicate and Materials

In Chapter 9 of the tutorial, we design a Component Predicate, a class that allows for the engine to decide which components to work with by asking the predicate whether or not to use it. We design a simple predicate to accomodate drawing components of a specific type: 2D, 3D, or both. However, this can be expanded later on for things like lighting, where you would only want to draw the components that are directly affected by the light you are working with.

Chapter 10: Post Processing

In Chapter 10 of the tutorial, we add a Post Processing system. Post processign allows you to take the rendered scene and apply affects to it like blur, bloom, color adjustment, etc. This can be further applied to allow effects like adding a red hue to tell the player they are taking damage.

Chapter 11: Serialization
In this tutorial, we add a serialization system to the engine. This allows us to save the state of the engine, by saving various properties for each component, which can then be loaded back later. This is useful for things like an editor, which would allow us to save our scenes to be loaded back in game.