DirectX 11.1 Game Programming

Microsoft DirectX, first released in 1995, is a set of standard commands that can be used by developers to send instructions to video cards. In 2002, Microsoft released DirectX 9, and later in August 2004, DirectX 9.0c was released, which supported shader model 3.0.

DirectX 9 was only supported by the Xbox 360 console and Windows XP and later versions. DirectX 10 changed to a new pipeline and was only available on Windows Vista and later versions. DirectX 10.1, which was shipped with Service Pack 1 of Windows Vista, was the updated version of DirectX 10.

In 2008, Microsoft unveiled DirectX 11, which had some amazing features including a compute shader, dynamic shader linking, tessellation, multithreaded rendering, and shader model 5.0. DirectX 11 can be run on Windows Vista and Windows 7.

Now, Direct3D 11.1 is due to ship with Windows 8. In fact, everything in Windows 8 is based on DirectX 11.1; it comes with several new features, such as the following:

There are many other features, and we will introduce some of them in this book.

Why should we target Windows 8?

At the Game Developers Conference (GDC) 2013, Windows director of communications, Christopher Flores, said:

"60 million Windows 8 licenses had been sold during the first two months of launch, matching the "record-setting" sales in a similar time period for Windows 7. The Store had seen double digit growth in the number of visiting users week over week since its October launch, with 95 percent of the apps available having been downloaded."

According to the Steam Hardware and Software Survey of May 2013, Windows 8 (64-bit) surpasses Windows XP in popularity and is almost as popular as Windows 7 (32-bit).

Windows Store, which is only available with Windows 8, provides new opportunities for everyone. It's a big chance for developers to write games and sell them in the Store.

For distributing your game on Windows Store, you need to port your code to DirectX 11.1. Windows 8 is the only option for programming with DirectX 11.1; you need to use Visual Studio 2012 along with Windows 8.

Whenever you build your application, you can follow the instructions from the Windows Dev Center article for an introduction to publishing your applications on the Store. For more information, please check this article at the following link:

http://msdn.microsoft.com/en-us/library/windows/apps/br230836.aspx.

Windows 8 will be cross-platformed, which means your game can be run on Microsoft platforms supported by Windows 8, such as PCs, Microsoft tablets, and Windows Phone 8, but note that each platform has its own limitations.

The new generation of Microsoft's games console, Xbox One, runs on three separate operating systems. The one where games run is NT Core, which is shared between Windows 8, Windows Phone 8, Windows RT, and Windows Server 2012. This means that developers can easily port their code from Windows 8 to other platforms and there is no need to rewrite their code from the very first line.

Finally, the simplified UI programming of Metro Style development should not be forgotten. Microsoft introduces Metro Style development in C++, C#, XAML, HTML, and JavaScript for experienced as well as newbie developers.

Tip

A good game comes from a good design, not just good graphics!

If you prefer to work alone, you can try to create a simple game and publish it on Windows Store. However, your games will be more likely to succeed if you build a game with a team that includes a game designer, a concept designer, a sound designer, and an animator.

As you go through this book, it might be useful to start creating your own first game for Metro Style, writing and testing samples all by yourself; if you face any problems, you can check different websites, such as MSDN Code Gallery at http://code.msdn.microsoft.com, for improving your game code. The samples and articles of Microsoft DirectX SDK (June 2012): AMD Developer Central (http://developer.amd.com) and nvidia Developer Zone (http://developer.Nvidia.com) are the best references for getting started with DirectX.

The following are some essential prerequisites that should be considered before developing an application using DirectX 11.1:

Microsoft C++ with Component Extensions (C++/CX) is an update to Microsoft C++, which is the language for developing a Windows Store game running on DirectX 11.1. It is truly mapped out to the new generation of the native C++ programming and is similar to C++/CLI; it is actually native code and not managed code. C++/CX is needed when you want to write C++ code-behind for Windows Store applications which uses the XAML user interface. Alternatively, it creates a Dynamic Link Library (DLL) to be called out from a Windows Store application, which is built using JavaScript, C#, or Visual Basic. And finally, it writes the Windows Store game using DirectX 11.1.

C++/CX brings the power of C++ along with the ease of programming. Jim Springfield, an architect of the Visual C++ team, wrote in his MSDN blog:

Have a look at his blog at the following link:

http://blogs.msdn.com/b/vcblog/archive/2011/10/20/10228473.aspx

C++/CX is a great place for developing applications for those game programmers who come from a background of C#, such as XNA Platform, SlimDx, and SharpDx. Also, for those who come from the management background of C++ or native C++, C++/CX won't disappoint! As mentioned earlier, you can use C++/CX along with XAML, but it is only available under the Metro UI; this means that C++/CX only runs on Windows 8 platforms.

There is no need to use native C++ while using Windows Runtime C++ Template Library (WRL); instead, you can use C++/CX code as a high-level language for using WRL code. In other words, it helps you write simpler code.

According to MSDN, the purpose and design of the WRL is inspired by the Active Template Library (ATL), which is a set of template-based C++ classes that simplifies the programming of Component Object Model (COM) objects.

interface struct IGet
{
  int Get() = 0;
};
interface struct ISet
{
  void Set(int value) = 0;
};
ref class CProperty sealed : IGet, ISet
{
public:
  CProperty()
  {
    OutputDebugString(L"CProperty created. \n");
  }
  virtual int Get() { return this->field; }
  virtual void Set(int value) { this->field = value; }
private:
  ~CProperty() 
  {
  OutputDebugString(L"CProperty released. \n");
  };
  int field;
};

CProperty^ a = ref new CProperty();

ref class CProperty : IGet, ISet
{
internal:
  CProperty(){};
protected:
  virtual void GetType(){};
protected public:
  virtual void GetName(){};
public:
  virtual int Get() { return this->field; }
  virtual void Set(int value) { this->field = value; }
private:
  int field;
};
ref class CObject sealed : public CProperty
{
public:
  CObject(){};
protected:
  virtual void GetType() override
  {
    CProperty::GetType();
  };
};

namespace EVENT
{
  //Forward declaration
  ref class CEvent;
  public delegate void CEventHandler(CEvent^ sender, Platform::String^ e);
  void OnEvent(CEvent^ sender, Platform::String^ e)
  {
        //Do something
  }
  public ref class CEvent sealed
  {
  public:
    CEvent(){};
    event CEventHandler^ Event;
    void RiseEvent()
    {
      Event(this, L"CEvent raised");
    }
  };
}

CEvent^ c = ref new CEvent();
Windows::Foundation::EventRegistrationToken token = c->Event += ref new CEventHandler(&OnEvent);
  c->RiseEvent();
  c->Event -= token;

Prior to getting started with coding, it is crucial to discover what Metro Style applications are and whether they can be cross-platform.

Windows 8 introduces a new type of application called a Windows Store app. Your application can be written and sold on Windows Store. It is a great opportunity for developers to write applications that can be run on PCs, tablets, and Windows Phones, and it might even be possible to run on the new generation of Xbox; that is, Xbox One!

In Metro Style, you can develop in a variety of languages. If you are a web developer, you may prefer to develop with HTML5, CSS3, and JavaScript; if you are a .NET developer, you can develop with XAML with code-behind in C++, C#, or Visual Basic.

If you are a game programmer, you can use DirectX 11.1 with C++/CX and HLSL to develop your game; if you prefer the .NET platform for game development, it is possible to write a wrapper for C++/CX.

Please note that Windows Store application development is supported only by Windows 8. Visual Studio 2012 supports ARM development, hence all Metro Style applications in the Windows Store work on both ARM and x86/64. The x86/x64 processors are fast and powerful, but they require a lot of electricity; on the other hand, ARM processors are weak and need low power, and they are used for PDAs, smartphones, and tablets. Because of the difference in hardware, a program that is built on an x86/x64 processor cannot run on an ARM processor and vice versa.

For creating your project, the first step is opening Visual Studio 2012 and creating a new Windows Store project from the C++ tab by performing the following steps:

Don't worry if the code seems overwhelming. In the next section, we will guide you through writing your own framework in order to get a better understanding of it.

We have introduced C++/CX and ran our first sample; now it is time to build our own framework gradually in order to get familiar with DirectX 11.1 programming:

Let's check the pch.h and pch.cpp files from the source code. The pch.h file is shown in the following code:

#pragma once
#include <wrl/client.h>
#include <d3d11_1.h>
#include <DirectXMath.h>
#include <memory>
#include <ppl.h>
#include <ppltasks.h>
#include <agile.h>

If you are a C++ programmer, you will see unfamiliar header files named wrl, agile.h, ppl.h, and ppltasks.h. Also, DirectXMath.h is unfamiliar for DirectX programmers. What are they supposed to do?

wrl headers are needed to take advantage of the Windows 8 libraries, and agile.h is the header needed to enable threading model and marshaling behavior across COM.

In our project, we need an agile object type to create CoreWindow. If you want to access an instance of a class from both the UI thread and a background thread, define the class as agile. If you do not want to define it as agile, be aware of the behavior of this class at runtime. Remember that if you define a ref class in C++/CX, it is agile by default, and do not define a member that is not agile inside this type of class. According to MSDN, some classes cannot be agile for a variety of reasons.

We added ppl.h and ppltasks.h to use Windows runtime asynchronous tasks; we will see these headers in action later.

DirectXMath is a library designed for C++ developers, and it includes functions for common linear algebra and graphical math operations.

You may be familiar with precompiled headers; it is a performance feature supported by some compilers to reduce the compilation time and store the compiled state of code in a binary file. Because we want to create a precompiled header to compile and build the project more quickly, we need to change some properties. Follow the ensuing steps:

In the Scenes folder, there are the Window.h and Window.cpp files.

The Window.cpp file is responsible for creating a window and handling the events, and it must be inherited from IFrameworkView. The IFrameworkView interface is shown in the following screenshot:

The following are the methods seen in the preceding screenshot:

The following are other events for handling our window more easily:

Now that we have introduced the preceding methods and events, let's see their definition in the Window.cpp file as shown in the following screenshot:

void Window::Initialize(CoreApplicationView^ appView)
{
 appView->Activated += ref new TypedEventHandler<CoreApplicationView^, IActivatedEventArgs^>(this, &Window::OnActivated);

  CoreApplication::Suspending += ref new EventHandler<SuspendingEventArgs^>(this, &Window::OnSuspending);

  CoreApplication::Resuming += ref new EventHandler<Platform::Object^>(this, &Window::OnResuming);
}

According to the IFrameworkView interface, the entry argument of the Initialize method is CoreApplicationView, which is a pointer. We declare the Activated, Suspending, and Resuming events likewise. Just as in the Initialize method, we declared the events of the window, such as SizeChanged, VisibilityChanged, Closed, and Pointers, in the SetWindow method. Right now, there is no need to load the resource, so leave this method as it is for now.

void Window::Run()
{
  while (!isWindowClosed)
  {
    if (isWindowVisible)
    {
      CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
    }
    else
    {
      CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessOneAndAllPending);
    }
  }
}

The Run method is the main method of your application. This is an entry point to your game. While your app is not closed, it will check the visibility of your window; if the window is visible, it dispatches all currently available events in the queue. CoreProcessEventsOption::ProcessAllIfPresent calls the handlers for each input event that is currently in the message queue. If no events are pending, it returns immediately and waits for the next event.

Do not use Uninitialize, as there are no resources to be released right now; the same goes for OnWindowSizeChanged. Furthermore, OnPointerPressed, OnPointerPressed, and OnPointerMoved events are going to be used later in Chapter 3, Rendering a 3D Scene, for handling the input.

void Window::OnActivated(CoreApplicationView^ applicationView, 
  IActivatedEventArgs^ args)
{
  CoreWindow::GetForCurrentThread()->Activate();
}

When the OnActivated event triggers, you must activate the current thread. The CoreWindow::GetForCurrentThread() method gives you the current thread, and with the Activate method, you can activate this thread. Now we just need to create the main method with the array of the string as the entry arguments; so, add the following code to Window.h:

ref class App sealed : IFrameworkViewSource
{
public:
  virtual IFrameworkView^ CreateView();
};

The App class is inherited from IFrameworkViewSource; we need to add a public virtual method named CreateView to the App class in order to create IFrameworkView. At last, add the following code to Window.cpp:

IFrameworkView^ App::CreateView()
{
  return ref new Window();
}
[Platform::MTAThread]
int main(Platform::Array<Platform::String^>^)
{
  auto app = ref new App();
  CoreApplication::Run(app);
  return 0;
}

Press F5 to build your project. The result is just an empty Metro window.

In the next section, we are going to integrate our framework with time.

Time is the main element of any application; your game cannot be handled without time management. In this section, we are going to create a time manager. Open the Work with game time project from Chapter 1 and then open Timer.h from the FrameWork folder.

Timer is a ref class that is declared as sealed. Total and Delta are two properties that are used in the Timer class.

The Total property is used to measure the duration (in seconds) between the last call to the Reset method and the last call to the Update method. It returns the total time of the timer. The Delta property is used to measure the duration (in seconds) between two calls to the Update method. The Timer method uses the QueryPerformanceFrequency function to retrieve the frequency of the high resolution performance counter.

  void Update()
  {
    if (!QueryPerformanceCounter(&currentTime))
    {
      throw ref new Platform::FailureException();
    }
    totalTime = static_cast<float>(
      static_cast<double>(currentTime.QuadPart - startTime.QuadPart) / static_cast<double>(frequency.QuadPart));
    if (lastTime.QuadPart == startTime.QuadPart)
    {
      deltaTime = 1.0f / 60.0f;
    }
    else
    {
      deltaTime = static_cast<float>(static_cast<double>(currentTime.QuadPart - lastTime.QuadPart) /static_cast<double>(frequency.QuadPart));
    }
    lastTime = currentTime;
  }
};

Basically, you use QueryPerformanceFrequency to get the number of ticks per second and QueryPerformanceCounter to get a high resolution timer value.

To calculate totalTime, use (CurrentTime - StartTime) / frequency; for calculating deltaTime, use (CurrentTime - lastTime) / frequency.

The QueryPerformanceCounter method will only reassemble the frequency of the CPU. Please note that according to MSDN, the results of QueryPerformanceCounter may vary with different processors.

In the next section, we will create and configure the Direct3D device.

In the final section of this chapter, we are going to initialize and configure our device. As the window has been created and the time has been added to our framework, the next step is to obtain a reference to the device. Open the Initialize the device project from the source code.

Let's check the new headers and classes of this project step-by-step. First, open DXHelper.h from the Framework folder. The DXHelper.h file is shown in the following code:

#pragma once
#include "pch.h"
using namespace Platform;
namespace DXHelper
{
  inline void OutputDebug(Platform::String^ Msg)
  {
    auto data = std::wstring(Msg->Data());
    OutputDebugString(data.c_str());
  }
  inline void ThrowIfFailed(HRESULT hr)
  {
    if (FAILED(hr)) throw Exception::CreateException(hr);
  }
}

We need two methods to manage our exceptions and to show messages to the output debug window of Visual Studio. We defined them as inline methods inside the DXHelper namespace. Game is a class that is designed to be used as the base class of other scenes. ComPtr is in the Microsoft::WRL namespace, and Platform is vital for Agile. Open it from Game.h, which is in the Framework folder. You can see the following code in the Game.cpp file:

ref class Game abstract
{
internal: 
  Game();
private:
  void CreateDevice();
  void CreateWindowSize();
  void HandleDeviceLost();
protected private:
  //D3D Objects
  ComPtr<ID3D11Device1> d3dDevice;
  ComPtr<ID3D11DeviceContext1> d3dContext;
  ComPtr<IDXGISwapChain1> swapChain;	
  ComPtr<ID3D11RenderTargetView> renderTargetView;
  ComPtr<ID3D11DepthStencilView> depthStencilView;

You can declare the device as ID3D11Device1* or ComPtr<ID3D11Device1>; as mentioned earlier, the only difference is that ComPtr is a class that is responsible for automatically getting and releasing the object. It is not necessary to use it, but often it is more convenient to use ComPtr for the purposes of memory management.

D3D_FEATURE_LEVEL featureLevel;
  Size renderTargetSize;
  Rect windowBounds;
  Agile<CoreWindow> coreWindow;
DisplayOrientations displayOrientations;

public:
  virtual void Initialize(CoreWindow^ window);
  virtual void WindowSizeChanged();
  virtual void Render() = 0;
  virtual void Present(); 
};

In the preceding code, all the methods declared are virtual methods except Render, which is declared as a pure virtual method. In C++, a pure virtual function (declared using = 0) must be implemented by the derived classes. The following code shows the Game.cpp class. These three headers are the precompiled header, our framework helper, and the Game.h header:

#include "pch­.h"
#include "..\DXHelper.h"
#include "..\Game.h"

void Game:: CreateDevice ()
{
HRESULT hr =  S_FALSE;
  UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
#if defined(_DEBUG)
  creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif

The D3D11_CREATE_DEVICE_DEBUG flag is used for enabling the debug layer when you want to check the errors and warnings of your code; for debugging, you need D3D11_1SDKLayers.dll; for getting this DLL, you must install SDK for Windows 8.

In Direct3D 11.1, a device can be created with some configuration flags that can be used in a majority of applications, but there are also several other driver types that must be considered; you can get more info about them from MSDN (http://msdn.microsoft.com/en-us/library/windows/desktop/ff476107(v=vs.85).aspx). An example of that is as follows:

D3D_FEATURE_LEVEL featureLevels[] = 
  {
    D3D_FEATURE_LEVEL_11_1,
    D3D_FEATURE_LEVEL_11_0,
  };

The D3D_FEATURE_LEVEL driver describes the set of features targeted by a Direct3D device. These features can be set from level 9_1 to level 11_1.

  ComPtr<ID3D11Device> device;
  ComPtr<ID3D11DeviceContext> context;	
  hr = D3D11CreateDevice(
      nullptr, 
      D3D_DRIVER_TYPE_HARDWARE,
      nullptr,
      creationFlags, 
      featureLevels, 
      ARRAYSIZE(featureLevels),
      D3D11_SDK_VERSION, 
      &device,
      &featureLevel, 
      &context);
   DXHelper::ThrowIfFailed(hr);  
  hr = device.As(&d3dDevice);
  hr = context.As(&d3dContext); 
}

With D3D11CreateDevice, we create the Direct3D device and get an immediate context. Just as we do in ComPtr, call QueryInterface to signify that the interface has been identified. It is always important to check the return value from the API calls to ensure the function has succeeded.

  if(swapChain != nullptr)
  {
    HRESULT hr = swapChain->ResizeBuffers(
      2, // Double-buffered swap chain.
      static_cast<UINT>(renderTargetSize.Width),
      static_cast<UINT>(renderTargetSize.Height),
      DXGI_FORMAT_B8G8R8A8_UNORM,
      0);
  }

  else
  {
    DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
    swapChainDesc.Width = static_cast<UINT>(renderTargetSize.Width);
    swapChainDesc.Height = static_cast<UINT>(renderTargetSize.Height);
    swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
    swapChainDesc.Stereo = false;
    swapChainDesc.SampleDesc.Count = 1; 
    swapChainDesc.SampleDesc.Quality = 0;
    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    swapChainDesc.BufferCount = 2;
    swapChainDesc.Scaling = DXGI_SCALING_NONE;
    swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
    swapChainDesc.Flags = 0;

    ComPtr<IDXGIDevice1>  dxgiDevice;
    hr = d3dDevice.As(&dxgiDevice);
    ComPtr<IDXGIAdapter> dxgiAdapter;
    hr = dxgiDevice->GetAdapter(&dxgiAdapter);
    ComPtr<IDXGIFactory2> dxgiFactory;
    hr = dxgiAdapter->GetParent(__uuidof(IDXGIFactory2), &dxgiFactory)
//__uuidof extracts the GUID attached to an object.

    CoreWindow^ window = coreWindow.Get();
    hr = dxgiFactory->CreateSwapChainForCoreWindow(d3dDevice.Get(), reinterpret_cast<IUnknown*>(window), &swapChainDesc, nullptr, &swapChain);
    hr = dxgiDevice->SetMaximumFrameLatency(3);
}

ComPtr<ID3D11Texture2D> backBuffer;
  hr = swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), &backBuffer);
  hr = d3dDevice->CreateRenderTargetView(backBuffer.Get(), nullptr, &renderTargetView);

CD3D11_TEXTURE2D_DESC depthStencilDesc(
    DXGI_FORMAT_D24_UNORM_S8_UINT, 
    static_cast<UINT>(renderTargetSize.Width), 
    static_cast<UINT>(renderTargetSize.Height), 
    1, 
    1, 
    D3D11_BIND_DEPTH_STENCIL);
  ComPtr<ID3D11Texture2D> depthStencil;
  hr = d3dDevice->CreateTexture2D(&depthStencilDesc, nullptr, 
    &depthStencil);
  CD3D11_DEPTH_STENCIL_VIEW_DESC 
    depthStencilViewDesc(D3D11_DSV_DIMENSION_TEXTURE2D);
  hr = d3dDevice->CreateDepthStencilView(depthStencil.Get(), 
    &depthStencilViewDesc, &depthStencilView );
  CD3D11_VIEWPORT viewport(
    0.0f, 
    0.0f, 
    renderTargetSize.Width, 
    renderTargetSize.Height);
  d3dContext->RSSetViewports(1, &viewport);
}

In this chapter, we have introduced the new features of Windows 8, DirectX 11.1, and the new extension of C++, which is called C++/CX. Also, we have set up our first project, added time to our new framework, and initialized the Direct3D device.

In the next chapter, we will cover the new features of HLSL in DirectX 11.1, buffers, and the compiled shader objects. Finally, we will outline the new additions of Direct3D 1.1.