Direct3D Rendering Cookbook: For C# .NET developers this is the ultimate cookbook for Direct3D rendering in PC games. Covering all the latest innovations, it teaches everything from debugging to character animation, supported throughout by illustrations and sample code.

Code for rendering complex scenes can soon become quite difficult to organize. To improve this, we will build a simple rendering framework. This framework will take care of the low-level device and swap chain management, assist with device resource lifecycle management, and allow the application to focus on the elements of the scene instead.

All 3D objects ultimately consist of one or more vertices that together form one of these core primitive shapes: points, lines, or triangles. As we discussed in the previous chapter, vertices can include information such as position, color or texture coordinate, and a normal vector. In this chapter we will learn how to define these structures in shaders and the Input Assembler (IA) fixed pipeline stage.

A vital component to any 3D scene is setting up the camera and projection. We will learn how to initialize each of these and where vertices are transformed from the local object or model space into the World/View/Projection (WVP) space ...

To work with complex scenes more easily, we are going to explore a set of classes that will serve as our simple rendering framework throughout the book. This framework will take care of initializing our Direct3D device, swap chain and render targets, and provide appropriate methods and events for implementing the Direct3D resource lifecycle management in our example applications.

The three key elements of this framework include the following:

In this recipe, we will see how the included sample framework deals with the initialization of device-dependent Direct3D resources and how our custom classes can make use of this throughout this book.

In this recipe, we will look at how the included sample framework deals with the initialization of size-dependent Direct3D resources within the base Direct3D application class. We review the base class's implementation, and then implement an override for a descending class.

We also review two important graphics pipeline preparation steps that are dependent upon the render target size: creating the viewport for the Rasterizer Stage (RS) and creating a depth/stencil buffer and view for the Output Merger (OM) stage.

In this recipe, we will look at the final component of our sample rendering framework, the renderer. These are classes that implement specific rendering logic, such as drawing a mesh or utility classes that wish to participate within the Direct3D resource lifecycle management of the rendering framework.

Now that we have our rendering framework ready, we can finally work on the more interesting stuff—actually rendering something!

All rendered objects, at their simplest form, are made up of one or more primitives: points, lines, or triangles which are made up of one or more vertices. In this recipe, we will render the following primitives:

We will also implement our WVP matrix and see how multisampling affects the rendered image. The final result is shown in the following figure:

Rendering primitives final output

In this recipe, we will enable multisample antialiasing (MSAA) to smoothen lines and edges.

In this recipe we are going to take the quad and triangle renderers from the previous example and apply some texture using a shader resource view (SRV), a sampler state object, and changes to the shader program.

The final output from the example will look something like the following figure:

Textured triangle and quad

Getting ready

For this recipe, we will continue from where we left of in the Rendering primitives recipe.

There are two texture files included with the sample code that you will also need. Alternatively, you may use any BMP, JPG, PNG, or even DDS formats. For reference, the two textures used in this project are shown in the following figure:

The two 256x256 textures used in this recipe