Downloads
Please note that I’ve switched to using 7-zip in place of WinRAR for compression
Binary Only (20.4KB)
Full VS2010 Project Dir (26.8KB)

SVN Repository
As of this tutorial, I have created and added a Subversion repository on Assembla to store the code for the tutorial series. I will continue to upload the source for each tutorial – the SVN will merely contain the code as I write it, so you can feel free to play around with the code that I’m working on before I release a tutorial. Mostly, this is to help people play around with things if there’s a point where I’m slow to create the tutorial following the code (as was the case with this tutorial).

SVN URL: http://svn2.assembla.com/svn/d3dpong

Starting Words
Notice: This tutorial continues from where “C++/D3D Pong Tutorial 03” article left off. Please read it if you have not already.

Libraries
You will need to add a single library to the project to build with the code in this tutorial:
dinput.lib

Code Listing 1: CInputManager.h

#pragma once

// Global Header Files
#include <Windows.h>
#include <d3d9.h>
#include <d3dx9.h>
#include <dinput.h>

// Local Header Files
#include "CGameEngine.h"
#include "CKeyboardState.h"

namespace D3DPong
{
	class CInputManager
	{
	private:
		/** Constructor & Destructor **/
		CInputManager(void);						// ctor
		CInputManager(CInputManager const&) { }		// copy ctor
		~CInputManager(void);						// dtor

		static CInputManager* _instance;

		// DirectInput Devices
		LPDIRECTINPUT8			_device;	// Core DirectInput Object
		LPDIRECTINPUTDEVICE8	_keyboard;	// Keyboard

		// Keyboard-related Variables
		CKeyboardState* _preKeyboardState;
		CKeyboardState* _curKeyboardState;

		// Device Initialization
		bool initKeyboard(void);

	public:
		/** Singleton **/
		static CInputManager* Instance(void) { return CInputManager::_instance; }

		/** Public Functions **/
		bool Init(void);
		void Update(void);

		/** Keyboard Functions **/
		bool IsKeyDown(int);
		bool IsKeyUp(int);
		bool WasKeyPressed(int);
		bool WasKeyReleased(int);

		/** Accessors & Mutators **/
		LPDIRECTINPUT8 GetDevice(void) { return this->_device; }
		CKeyboardState* GetCurKeyboardState(void) { return this->_curKeyboardState; }
		CKeyboardState* GetPreKeyboardState(void) { return this->_preKeyboardState; }
	};
};

Here is the framework for our Input Manager. Again, we’re back down to lower source sizes – because we’re not trying to implement the world here. As we did with our Game Engine class, we’ve turned our Input Manager into a singleton – we only want one of them to be created throughout the application.

		// DirectInput Devices
		LPDIRECTINPUT8			_device;	// Core DirectInput Object
		LPDIRECTINPUTDEVICE8	_keyboard;	// Keyboard

		// Keyboard-related Variables
		CKeyboardState* _preKeyboardState;
		CKeyboardState* _curKeyboardState;

		// Device Initialization
		bool initKeyboard(void);

The first two variables are input devices – the first, as with our Direct3D object, we have an object that we will use to access the DirectInput system. The second is the actual object that we will use to access the keyboard device – when adding a Mouse or a Gamepad/Joystick, you will add another LPDIRECTINPUTDEVICE8. If you’ve noticed the 8, you’ll notice that this is something from DirectX 8 – DirectInput hasn’t changed since then. In all honesty, the use of DirectInput isn’t recommended by Microsoft, but it will suffice for our purposes. We then add two variables to store the keyboard state – the current keyboard state, which will contain the state as of the current frame, and the previous, which will (if you haven’t guessed) store the state of the last frame. We do this so that we can not only check whether a key is currently being pressed, but also whether it was pressed or released between the current and last frame. This makes things easier on us, in the long run, because we can wait for (for example) the escape key to be released before we end the game, and it will make managing our game menus much easier when we want to handle selection of menu options game console style. Finally, we define a private function that will initialize our keyboard. It will help keep our Init() function tidy for the future addition of controllers, mice, and other input devices.

		/** Public Functions **/
		bool Init(void);
		void Update(void);

These two functions are pretty obvious in what they do. Init() will initialize all of our input devices, and update will update the current/previous states of our devices. I’ll explain them more when we actually flesh them out.

		/** Keyboard Functions **/
		bool IsKeyDown(int);
		bool IsKeyUp(int);
		bool WasKeyPressed(int);
		bool WasKeyReleased(int);

Last on the list of things to look at is our key-checking functions. The first two will return whether the key is currently pressed or released, which can be useful for continuous motion checking, such as what we will be doing with our pong paddles. The latter two check if they key’s state has changed between this frame and the last (if the key has been pressed or released).

Code Listing 2: CInputManager.cpp

#include "CInputManager.h"
#include "CKeyboardState.h"

namespace D3DPong
{
	CInputManager* CInputManager::_instance = new CInputManager();

	CInputManager::CInputManager(void)
		: _device(NULL), _keyboard(NULL),
		_curKeyboardState(NULL), _preKeyboardState(NULL)
	{
	}

	CInputManager::~CInputManager(void)
	{
		if(this->_keyboard != NULL)
		{
			this->_keyboard->Unacquire();
			this->_keyboard->Release();
			this->_keyboard = NULL;
		}

		if(this->_device != NULL)
		{
			this->_device->Release();
			this->_device = NULL;
		}
	}

	bool CInputManager::Init(void)
	{
		// Initialize the DirectInput Device
		if(FAILED(DirectInput8Create(GetModuleHandle(NULL),	// Instance Handle
			DIRECTINPUT_VERSION,							// DirectInput Version
			IID_IDirectInput8, 								// Device Type
			(LPVOID*)&this->_device,						// Pointer to device storage
			NULL)))
		{
			MessageBox(NULL, L"Error initializing Input Manager", L"Error", MB_OK);
			return false;
		}

		// Initialize the Keyboard
		if(!this->initKeyboard())
			return false;

		// Call update once to populate the input states
		this->Update();

		return true;
	}

	bool CInputManager::initKeyboard(void)
	{
		if(FAILED(this->_device->CreateDevice(GUID_SysKeyboard,
			&this->_keyboard,
			NULL)))
		{
			MessageBox(NULL, L"Error initializing Keyboard", L"Error", MB_OK);
			return false;
		}

		if(FAILED(this->_keyboard->SetDataFormat(&c_dfDIKeyboard)))
		{
			MessageBox(NULL, L"Error setting keyboard data format", L"Error", MB_OK);
			return false;
		}

		if(FAILED(this->_keyboard->SetCooperativeLevel(CGameEngine::Instance()->GetWindowHandle(), DISCL_FOREGROUND | DISCL_NONEXCLUSIVE)))
		{
			MessageBox(NULL, L"Error setting keyboard cooperative level", L"Error", MB_OK);
			return false;
		}

		if(FAILED(this->_keyboard->Acquire()))
		{
			MessageBox(NULL, L"Error acquiring keyboard device", L"Error", MB_OK);
			return false;
		}

		// Create the keyboard states
		this->_curKeyboardState = new CKeyboardState();
		this->_preKeyboardState = new CKeyboardState();

		return true;
	}

	void CInputManager::Update(void)
	{
		// Update the keyboard
		this->_preKeyboardState->CopyKeyBuffer(this->_curKeyboardState->GetKeyStates());

		// Make sure we reacquire the keyboard if the device was lost
		if(this->_keyboard->GetDeviceState(this->_curKeyboardState->GetBufferSize(), this->_curKeyboardState->GetKeyBuffer()) == DIERR_INPUTLOST)
			this->_keyboard->Acquire();
	}

	bool CInputManager::IsKeyDown(int keyCode)
	{
		return this->_curKeyboardState->IsKeyDown(keyCode);
	}

	bool CInputManager::IsKeyUp(int keyCode)
	{
		return this->_curKeyboardState->IsKeyUp(keyCode);
	}

	bool CInputManager::WasKeyPressed(int keyCode)
	{
		if(this->_curKeyboardState->IsKeyDown(keyCode) && this->_preKeyboardState->IsKeyUp(keyCode))
			return true;
		else
			return false;
	}

	bool CInputManager::WasKeyReleased(int keyCode)
	{
		if(this->_curKeyboardState->IsKeyUp(keyCode) && this->_preKeyboardState->IsKeyDown(keyCode))
			return true;
		else
			return false;
	}
};

Here are the guts of our system. Not everything will need covered, because it will be pretty obvious based on other parts, but here goes:

	bool CInputManager::Init(void)
	{
		// Initialize the DirectInput Device
		if(FAILED(DirectInput8Create(GetModuleHandle(NULL),	// Instance Handle
			DIRECTINPUT_VERSION,							// DirectInput Version
			IID_IDirectInput8, 								// Device Type
			(LPVOID*)&this->_device,						// Pointer to device storage
			NULL)))
		{
			MessageBox(NULL, L"Error initializing Input Manager", L"Error", MB_OK);
			return false;
		}

		// Initialize the Keyboard
		if(!this->initKeyboard())
			return false;

		// Call update once to populate the input states
		this->Update();

		return true;
	}

This method initializes our input management system. The first thing that we must do is initialize our DirectInput device, because it will be used to create any DirectInput-based input systems later (keyboard, mouse, and joypad, for example). We then call initKeyboard() to initialize our keyboard (when adding a Mouse or Joystick, you would also add an initMouse/initJoystick function, just to keep things clean), make sure it worked properly, then capture the current state of the input system.

	bool CInputManager::initKeyboard(void)
	{
		if(FAILED(this->_device->CreateDevice(GUID_SysKeyboard,
			&this->_keyboard,
			NULL)))
		{
			MessageBox(NULL, L"Error initializing Keyboard", L"Error", MB_OK);
			return false;
		}

		if(FAILED(this->_keyboard->SetDataFormat(&c_dfDIKeyboard)))
		{
			MessageBox(NULL, L"Error setting keyboard data format", L"Error", MB_OK);
			return false;
		}

		if(FAILED(this->_keyboard->SetCooperativeLevel(CGameEngine::Instance()->GetWindowHandle(), DISCL_FOREGROUND | DISCL_NONEXCLUSIVE)))
		{
			MessageBox(NULL, L"Error setting keyboard cooperative level", L"Error", MB_OK);
			return false;
		}

		if(FAILED(this->_keyboard->Acquire()))
		{
			MessageBox(NULL, L"Error acquiring keyboard device", L"Error", MB_OK);
			return false;
		}

		// Create the keyboard states
		this->_curKeyboardState = new CKeyboardState();
		this->_preKeyboardState = new CKeyboardState();

		return true;
	}

Not much to see here, in spite of the length – most of it’s error checking. First, we use the DirectInput device to create our Keyboard device, then we follow up by setting the data format and cooperative level. The cooperative level sets how our application works with the operating system and other applications running, when it comes to handling input on the device. Setting a Foreground cooperative level makes it so that our game only responds to input when the game window is our active window. This way, if the player were to open Notepad and press the escape key, it wouldn’t close our game. Setting this to background, on the other hand, allows this to happen. The second piece of our cooperative level determines whether other applications will be allowed to access the input device when the game is using them. Nonexclusive means that the input device can be shared with others, and that works best to keep our application on friendly terms with any software our players may be using. The only time you really want to use exclusive mode is when using a mouse in a three-dimensional shooter game, to prevent our mouse from slipping out the side of the window when we’re turning. Finally, we capture (acquire) our input device, and create two empty instances to store the state of the keyboard.

	void CInputManager::Update(void)
	{
		// Update the keyboard
		this->_preKeyboardState->CopyKeyBuffer(this->_curKeyboardState->GetKeyStates());

		// Make sure we reacquire the keyboard if the device was lost
		if(this->_keyboard->GetDeviceState(this->_curKeyboardState->GetBufferSize(), this->_curKeyboardState->GetKeyBuffer()) == DIERR_INPUTLOST)
			this->_keyboard->Acquire();
	}

The update method updates our keyboard states. First, we use the CopyKeyBuffer (which, as you will see when we design our Keyboard State class, simply copies the key buffer array from another array). We then check to make sure that the device was not lost (for example, if the window is switched). If it is, we re-acquire it. When we use the GetDeviceState() function within the if() statement, we are also capturing the keyboard state – first, we pass the size of the buffer, then we pass a pointer to the buffer array. GetDeviceState will copy the state of our keyboard to the key buffer array.

Because the IsKeyUp and IsKeyDown functions directly map to functions of the same name on the current keyboard state, we’ve only one last thing to cover:

	bool CInputManager::WasKeyPressed(int keyCode)
	{
		if(this->_curKeyboardState->IsKeyDown(keyCode) && this->_preKeyboardState->IsKeyUp(keyCode))
			return true;
		else
			return false;
	}

This is pretty obvious, but I want to be completely clear on how we’re working this. If the state has been changed between the current frame and the last, we return true. In the case above, we are checking if the key has been pressed. We check the current state of the key against the previous state – if it was released (up) on the last frame, but is pressed (down) now, we return true – the key has been pressed between the current and last frames. Otherwise, it hasn’t, so we return false.

Code Listing 3: CKeyboardState.h

#pragma once

#include <Windows.h>

namespace D3DPong
{
	class CKeyboardState
	{
	private:
		char _keyStates[256];

	public:
		/** Constructor & Destructor **/
		CKeyboardState(void);
		~CKeyboardState(void);

		/** Public Methods **/
		bool IsKeyDown(int);
		bool IsKeyUp(int);
		void CopyKeyBuffer(char*);

		/** Accessors & Mutators **/
		char* GetKeyStates(void) { return this->_keyStates; }
		LPVOID GetKeyBuffer(void) { return (LPVOID)&this->_keyStates; }
		DWORD GetBufferSize(void) { return sizeof(this->_keyStates); }
	};
};

The only member variable here is our key buffer – which is a simple char array, exactly what will be set by the keyboard device’s GetDeviceState function. I’ll cover the functions below:

Code Listing 4: CKeyboardState.cpp

#include "CKeyboardState.h"

namespace D3DPong
{
	CKeyboardState::CKeyboardState(void)
	{
	}

	CKeyboardState::~CKeyboardState(void)
	{
	}

	bool CKeyboardState::IsKeyDown(int keyCode)
	{
		if(this->_keyStates[keyCode] & 0x80)
			return true;
		else
			return false;
	}

	bool CKeyboardState::IsKeyUp(int keyCode)
	{
		return !this->IsKeyDown(keyCode);
	}

	void CKeyboardState::CopyKeyBuffer(char* buffer)
	{
		for(int i = 0; i < 256; i++)
			this->_keyStates[i] = buffer[i];
	}
};

Here we go!

	bool CKeyboardState::IsKeyDown(int keyCode)
	{
		if(this->_keyStates[keyCode] & 0x80)
			return true;
		else
			return false;
	}

To check whether or not a key is up, we simply do a BITWISE AND operation against the key state (stored in our buffer) at the keycode in our array against 0×80. The keyCode integer will be a pre-defined DirectInput keycode, such as DIK_ESCAPE or DIK_HOME – you can find a list of DirectInput keycodes here. To find out if the key is up, we need only check if it is not down – so our IsKeyUp merely returns !IsKeyDown.

	void CKeyboardState::CopyKeyBuffer(char* buffer)
	{
		for(int i = 0; i < 256; i++)
			this->_keyStates[i] = buffer[i];
	}

Here, we actually copy the key buffer. There are only 256 indexes in the key buffer array, so that’s all we need to copy. In case you’re surprised, yes, arrays are simply glorified pointers with fixed sizes – and you can easily use an array as a pointer.

Wrapping it into our engine
Now, we need to make some ties to bring our singleton into the application. Open up WinMain.cpp, and let’s get started.

#define InputManager D3DPong::CInputManager::Instance()

Just as we did with the instance of the game engine, we are going to create a Macro to access our Input Manager singleton. Now, we can just use InputManager->WasKeyPressed instead of going out of our way to type D3DPong::CInputManager::Instance()->WasKeyPressed.

	// Initialize the Game Engine
	GEInstance->SetWindowHandle(hWnd);
	if(!GEInstance->Init(GEInstance->GetScreenWidth(), GEInstance->GetScreenHeight(), GEInstance->GetColorDepth()))
		return 0;

	if(!InputManager->Init())
		return 0;

	// Message Loop
	while(GEInstance->GetGameRunning())
	{
		while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}

		InputManager->Update();
		GEInstance->Update();
	}

The only changes here are the lines regarding the InputManager – these parts are all we need to tie the input manager into our engine. They’re quite obvious in what they do – initialize and update the input manager – so I doubt that I need to give much explanation.

Adding input to our test game
I’m only going to cover checking for the escape key on this, but if you look at the tutorial files, I’ve added some simple platformer-esque input handling to our earlier rendering and physics tests.

void GameUpdate(float delta)
{
	if(InputManager->WasKeyReleased(DIK_ESCAPE))
		GEInstance->SetGameRunning(false);

	// [...] The rest of our update method
}

Here, we check if the Escape key has been released – this will allow us to easily exit our window via a single keystroke. I choose to check for the release of the escape key out of personal preference, because I prefer acting on the release of most keystrokes, but you could achieve similar results by doing WasKeypressed – it would merely act when the key was pressed, instead of when it was released (</obvious>).

And there you have it, the (long awaited?) keyboard input tutorial. If I missed something between the downloadable source and what I’ve posted, please let me know so I can fix it – I wrote the code for this ages ago, and only finally got around to writing the tutorial portion recently.

Code Listing 1: CGameEngine.cpp -> CGameEngine::CGameEengine(void)
First, we’re going to correct an error with our game timer, which we never actually created an instance of in code – causing the GetRunTime feature to fail due to a member variable not being initialized (CGameTimer::_start). Replace the constructor for CGameEngine with the following, in CGameEngine.cpp

	CGameEngine::CGameEngine(void)
		: _windowHandle(NULL), _windowTitle(L"D3DPong"),
		_screenWidth(640), _screenHeight(480), _colorDepth(32),
		_gameRunning(true), _gameTimer(new CGameTimer())
	{
	}

Code Listing 2: CGameEngine.cpp -> CGameEngine::Update(void)
Our new Update method is much smaller than it was before. We’re still using fast-as-possible rendering and updating, so this isn’t going to fix the minor graphics tearing that you’ve no doubt noticed before this, but it is going to make things run a little better.

	void CGameEngine::Update(void)
	{
		float delta = this->_gameTimer->GetRunTime();

		GameUpdate(delta);

		this->_gameTimer->Reset();

		this->BeginRender();

		GameRender(delta);

		this->EndRender();
	}

Nicer, cleaner, shorter. This was caused by a bit of an inconsistency and laziness on my part, but things should run a bit smoother now. In the next tutorial, we’re going to be adding input, and will put the beginning pieces of our game into effect. I’ll cover enabling VSync at a later point, because I’m too lazy to deal with it right now. It’ll probably be in another “Maintenance” mini-tutorial.

Expect Tutorial 4 soon!

Tutorial Description
In the last tutorial, we finished getting Direct3D set up, implemented a timer system to allow us to calculate the time between each frame, and set up the framework that will grant us access to our game without interfering with the core engine. In this tutorial, we are going to implement a reusable Scene Object class, which will be the parent for all future classes that we wish to enable in a scene manager. The scope of this tutorial series makes a full-fledged instance management system overkill, so we will not be building one in here. However, as this tutorial series will act as the base for future tutorials that will implement a scene manager, I am going to implement the scene object class here.

Downloads
Binary Only (18.8KB)
Full VS2010 Project Dir (28.4KB)

Starting Words
I just wanted to point out that this tutorial series borrows a lot of the structure of Jonathan Harbour’s Advanced2D game engine, from the book “Advanced 2D Game Development“. While I certainly believe it to be a wonderful book, and an excellent starting point for beginners (in fact, the reason for me borrowing the format for his engine is because I find the method well-suited for beginners), I find that I have a lot of personal quirks with Jonathan’s methods and programming habits, and there are a number of inconsistencies in it. Furthermore, there are some topics that are covered in the book that just aren’t well-suited for beginners, and can cause things to be a bit confusing and convoluted. In this tutorial series, I don’t plan to implement three-dimensional rendering, which he does cover briefly, and have no intention of including game scripting, though several more advanced tutorials will cover these aspects at a later date (read: when I stop being lazy). Anybody looking at learning to program two-dimensional games with DirectX and C++ should look into the book, but should remember that there will always be better ways to implement certain systems than what is shown to you in a book – or an online tutorial. Anybody that wants to gain a solid understanding and truly grasp the depth of these programming systems is highly encouraged to look up information on any subjects that they are unfamiliar with. I strongly recommend Safari Books Online – I read a lot of books there, and it’s certainly helped me improve myself. Advanced 2D Game Development is available on SBO, as well.

Notice: This tutorial continues from where “C++/D3D Pong Tutorial 02” article left off. Please read it if you have not already.

Libraries
You will not need to add any more libraries to your project at this time. As of the last tutorial, the following should be in your project:
d3d9.lib
d3dx9.lib
dxguid.lib

Fixing up some Bugs
While writing this tutorial, I’ve come across a bug in the engine that had remained unnoticed until now. Because of how we’ve set up the game engine to handle the end of the game (specifically, the destruction of the game window), we end up calling our GameEnd function twice, which will cause issues when deleting the game sprites that we are going to be creating in this tutorial. The following changes will fix the problem:

In CGameEngine.h, add:

void SetGameRunning(bool val) { this->_gameRunning = val; }

below the rest of the Mutator functions.

In CGameEngine.cpp, change:

	void CGameEngine::End(void)
	{
		this->_gameRunning = false;
		GameEnd();
	}

to

	void CGameEngine::End(void)
	{
		GameEnd();
	}

In WinMain.cpp, change

	case WM_QUIT:
	case WM_CLOSE:
	case WM_DESTROY:{
		GEInstance->End();
					} break;

to

	case WM_QUIT:
	case WM_CLOSE:
	case WM_DESTROY:{
		GEInstance->SetGameRunning(false);
					} break;

and add

	// End the Game
	GEInstance->End();

And our issues should be solved. The problem here is that WM_DESTROY is called a frame after WM_CLOSE/WM_QUIT are called, and the game will still execute a frame. Making these changes will make sure that “D3DPong::CGameEngine::Instance()->_gameRunning” is merely set to false, which we are checking in our Main loop, so that we can just stop execution of the frames.

There is one other error that I’ve uncovered. I’d forgotten to actually clear the scene before we begin rendering. In CGameEngine.cpp, add the following to the BeginRender() method, right after we check the Direct3D Device (and right before we Begin the scene).

		this->_device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0,0,0), 1.0f, 0);

…Holy hell, I think I wasn’t paying much attention when I first programmed this, but I guess that’s how programming goes. There will always be bugs to fix. Here’s the last one. Our Game Engine’s Update() method wasn’t taking the first frame into account. With how we were handling our delta calculation, that meant that our first frame would have an incredibly high delta. So, replace the update method with the following:

	void CGameEngine::Update(void)
	{
		static float lastFrame = 0.0f;
		static bool firstFrame = true;

		float delta = ((float)((int)this->_gameTimer->GetTime())) - lastFrame;
		lastFrame = ((float)((int)this->_gameTimer->GetTime()));

		if(firstFrame)
		{
			delta = 0;
			firstFrame = false;
		}

		GameUpdate(delta);

		this->BeginRender();

		GameRender(delta);

		this->EndRender();
	}

What we are implementing
Since we are starting to get into the juicier parts of the system, I am going to start by providing information on why we are doing things as we are doing them – what the point behind our systems, why certain design decisions are made, etc.

In a game as simple as Pong, we could easily get away with making every scene object a sprite, taking with it all of our rendering capabilities and continuing on with life. However, it is always important to be looking into the future. It’s much better (and easier) to upgrade an engine that you’ve already gotten a lot of work done on than it is to build a new one from scratch. Say, for example, that you are working on a two-dimensional adventure game, such as The Legend of Zelda: The Minish Cap. There are several points in such a game that having scene objects that don’t necessarily have rendering capabilities would be very useful, such as a hidden trap or a trigger area in which the player will constantly lose health. While you could define them and merely not have anything to render for them, they will still have space made for them in the system’s memory for the texture data and all of the little render flags, and rendering methods will always be called on them, creating extra overhead. Therefore, it would be much easier to have a base Scene Object class, without any of the extra rendering data, that would help us to cut down on the game’s resource usage.

For our Scene Object class, we are going to hold basic atomic data, such as the scene object’s position, size, rotation, velocity, acceleration, friction, and a three-dimensional gravity (allowing us to do horizontal “gravity” as well as the usual vertical gravity). We are going to use a three-dimensional vector provided to us by D3DX (the D3DXVECTOR3 struct), rather than defining our own to store this information. Position will be a basic value storing the object’s position, velocity will be a value added to our Position every frame (all of these will be curbed by the frame delta), acceleration will be added to velocity every frame, and friction will then be either added to or subtracted from the velocity before it is finalized. Friction will always go in the direction of a velocity of “zero,” and will have a check to ensure that it is a positive value before modifying the velocity. Gravity will be the last to be applied, and will be the very last thing to be accounted for within the scene object’s velocity.

Code Listing 1: CSceneObject.h

#pragma once

// Global Header Files
#include <Windows.h>
#include <d3d9.h>
#include <d3dx9.h>

namespace D3DPong
{
	class CSceneObject
	{
	private:
		// Position, Rotation, and Size data
		D3DXVECTOR2 _position;
		D3DXVECTOR2 _size;
		D3DXVECTOR2 _scale;
		float _rotation;

		// Velocity and other basic movement data
		D3DXVECTOR2 _velocity;
		D3DXVECTOR2 _acceleration;
		D3DXVECTOR2 _friction;
		D3DXVECTOR2 _gravity;

	protected:
		bool _canUpdate;
		bool _canRender;

	public:
		/** Constructor & Destructor **/
		CSceneObject();
		~CSceneObject();

		/** Function Declarations **/
		void Update(float);

		/** Accessors & Mutators **/
		bool CanRender(void) { return this->_canRender; }
		bool CanUpdate(void) { return this->_canUpdate; }

		float GetLeft(void) { return this->_position.x; }
		float GetRight(void) { return (this->_position.x + (this->_size.x * this->_scale.x)); }
		float GetTop(void) { return this->_position.y; }
		float GetBottom(void) { return (this->_position.y + (this->_size.y * this->_scale.y)); }
		float GetWidth(void) { return this->_size.x; }
		float GetHeight(void) { return this->_size.y; }
		D3DXVECTOR2 GetCenter(void) { return D3DXVECTOR2(((float)(this->_size.x * this->_scale.x)/2), ((float)(this->_size.y * this->_scale.y)/2)); }

		D3DXVECTOR2 GetPosition(void) { return this->_position; }
		void SetPosition(D3DXVECTOR2 val) { this->_position = val; }
		void SetPositionX(float val) { this->_position.x = val; }
		void SetPositionY(float val) { this->_position.y = val; }

		D3DXVECTOR2 GetSize(void) { return this->_size; }
		void SetSize(D3DXVECTOR2 val) { this->_size = val; }
		void SetWidth(float val) { this->_size.x = val; }
		void SetHeight(float val) { this->_size.y = val; }

		D3DXVECTOR2 GetScale(void) { return this->_scale; }
		void SetScale(D3DXVECTOR2 val) { this->_scale = val; }
		void SetScaleX(float val) { this->_scale.x = val; }
		void SetScaleY(float val) { this->_scale.y = val; }

		float GetRotation(void) { return this->_rotation; }
		void SetRotation(float val) { this->_rotation = val; }

		D3DXVECTOR2 GetVelocity(void) { return this->_velocity; }
		void SetVelocity(D3DXVECTOR2 val) { this->_velocity = val; }
		void SetVelocityX(float val) { this->_velocity.x = val; }
		void SetVelocityY(float val) { this->_velocity.y = val; }

		D3DXVECTOR2 GetAcceleration(void) { return this->_acceleration; }
		void SetAcceleration(D3DXVECTOR2 val) { this->_acceleration = val; }
		void SetAccelerationX(float val) { this->_acceleration.x = val; }
		void SetAccelerationY(float val) { this->_acceleration.y = val; }

		D3DXVECTOR2 GetFriction(void) { return this->_friction; }
		void SetFriction(D3DXVECTOR2 val) { this->_friction = val; }
		void SetFrictionX(float val) { this->_friction.x = val; }
		void SetFrictionY(float val) { this->_friction.y = val; }

		D3DXVECTOR2 GetGravity(void) { return this->_gravity; }
		void SetGravity(D3DXVECTOR2 val) { this->_gravity = val; }
		void SetGravityX(float val) { this->_gravity.x = val; }
		void SetGravityY(float val) { this->_gravity.y = val; }
	};
};

It looks big, but it’s not all that hard. Most of the code here is creating the Mutator and Accessor functions. Let’s get cracking, then:

		// Position, Rotation, and Size data
		D3DXVECTOR2 _position;
		D3DXVECTOR2 _size;
		D3DXVECTOR2 _scale;
		float _rotation;

These are three important variables. The first three are all two-dimensional vectors – they hold an X and a Y value. Position will store the object’s position in world space (in this series, world space and screen space are one and the same. In future series, when we implement a sort of two-dimensional camera or viewport system, the two will be different. Size stores the object’s size, in pixels, and will be used later when we implement our basic collision-detection system. The object’s scale represents how large it is. Our sprite class (for two-dimensional images) will scale the image on rendering to this value, and our GetBottom and GetRight take the scale into account. Again, this information will be very important for our collision detection system later. Our final variable, rotation, is a floating-point value representing the number of degrees that our object is rotated by – it can be from zero to three-hundred sixty, though higher (or lower) values will automatically wrap.

		// Velocity and other basic movement data
		D3DXVECTOR2 _velocity;
		D3DXVECTOR2 _acceleration;
		D3DXVECTOR2 _friction;
		D3DXVECTOR2 _gravity;

If these physics variables make you cringe in fear,then let me take this moment to ease your mind by saying that they aren’t even remotely complicated concepts. These are exactly as explained above – velocity is the object’s current, linear velocity, acceleration will be added to the velocity, friction will drag our velocity toward zero, and gravity will drag us toward a certain direction in game space.

	protected:
		bool _canUpdate;
		bool _canRender;

These protected variables will prove to be very important in future tutorials, when we implement an instance manager. Basically, each sub-class of CSceneObject will set these variables in their constructor. _canUpdate represents whether or not the class implements an Update() method, while _canRender represents whether or not it implements a Render() method.

		/** Function Declarations **/
		void Update(float);

Finally, we declare an Update() function. We are going to have a default Update() method defined because it is incredibly rare that we will ever need to have a scene object that doesn’t implement updating. We will be able to stop Update from being called, if needed, which can later be checked by an instance manager.

Code Listing 2: CSceneObject.cpp

#include "CSceneObject.h"

namespace D3DPong
{
	CSceneObject::CSceneObject(void)
		: _position(0,0), _size(0,0),
		_scale(1,1), _rotation(0),
		_velocity(0,0), _acceleration(0,0),
		_friction(0,0), _gravity(0,0),
		_canUpdate(true), _canRender(false)
	{
	}

	CSceneObject::~CSceneObject(void)
	{
	}

	void CSceneObject::Update(float delta)
	{
		// First, add our Acceleration to the object's velocity
		this->_velocity += this->_acceleration;

		// Now, we need to handle friction. This will be handled based on whether the velocity is positive or negative.
		if(this->_velocity.x > 0)
		{
			this->_velocity.x -= abs(this->_friction.x);
			if(this->_velocity.x < 0)
				this->_velocity.x = 0;
		}
		else if(this->_velocity.x < 0)
		{
			this->_velocity.x += abs(this->_friction.x);
			if(this->_velocity.x > 0)
				this->_velocity.x = 0;
		}

		if(this->_velocity.y > 0)
		{
			this->_velocity.y -= abs(this->_friction.y);
			if(this->_velocity.y < 0)
				this->_velocity.y = 0;
		}
		else if(this->_velocity.y < 0)
		{
			this->_velocity.y += abs(this->_friction.y);
			if(this->_velocity.y > 0)
				this->_velocity.y = 0;
		}

		// Finally, it's time to handle gravity
		this->_velocity -= this->_gravity;

		// And then we add the velocity (multiplied by the frame delta) to the position
		this->_position += (this->_velocity * (delta/100));
	}
};

This one’s not very large – really, the only important method here is the Update() function, so that’s what I’ll break down:

	void CSceneObject::Update(float delta)
	{
		// First, add our Acceleration to the object's velocity
		this->_velocity += this->_acceleration;

		// Now, we need to handle friction. This will be handled based on whether the velocity is positive or negative.
		if(this->_velocity.x > 0)
		{
			this->_velocity.x -= abs(this->_friction.x);
			if(this->_velocity.x < 0)
				this->_velocity.x = 0;
		}
		else if(this->_velocity.x < 0)
		{
			this->_velocity.x += abs(this->_friction.x);
			if(this->_velocity.x > 0)
				this->_velocity.x = 0;
		}

		if(this->_velocity.y > 0)
		{
			this->_velocity.y -= abs(this->_friction.y);
			if(this->_velocity.y < 0)
				this->_velocity.y = 0;
		}
		else if(this->_velocity.y < 0)
		{
			this->_velocity.y += abs(this->_friction.y);
			if(this->_velocity.y > 0)
				this->_velocity.y = 0;
		}

		// Finally, it's time to handle gravity
		this->_velocity -= this->_gravity;

		// And then we add the velocity (multiplied by the frame delta) to the position
		this->_position += (this->_velocity * (delta/100));
	}

The D3DXVECTOR2 structure provides operator support to allow us to easily add and multiply values and the vectors. We can add, multiply, subtract, etc, for example, two vectors, or even a vector and a floating-point value. Doing operations on a vector will perform that operation on both axes dealt with by the vector (X & Y), or on corresponding vectors in the case of vector-to-vector operations (so this->_velocity += this->_acceleration adds acceleration’s X to velocity’s X, and acceleration’s Y to velocity’s Y). My explanation may be a little confusing, but looking at the code should clarify things.

Code Listing 3: CTexture.h
Before we move on to defining the Game Sprite class, we need a class to store our game’s textures. While we could easily just lump this into the Game Sprite class, it makes more sense to move this to its own class – after all, what if we want to implement an object with rendering that doesn’t inherit from the game sprite class? So, here we go. This is pretty simple to implement.

#pragma once

// Global Header Files
#include <Windows.h>
#include <d3d9.h>
#include <d3dx9.h>

namespace D3DPong
{
	class CTexture
	{
	private:
		LPDIRECT3DTEXTURE9 _texture;
		D3DXIMAGE_INFO _imageInfo;

	public:
		CTexture(void);
		~CTexture(void);

		/** Function Declarations **/
		bool Load(LPCWSTR);

		/** Accessors **/
		LPDIRECT3DTEXTURE9 GetTexture(void) { return this->_texture; }
		float GetWidth(void) { return (float)this->_imageInfo.Width; }
		float GetHeight(void) { return (float)this->_imageInfo.Height; }
	};
};

		LPDIRECT3DTEXTURE9 _texture;
		D3DXIMAGE_INFO _imageInfo;

Just a couple small things in the declaration side. The first variable stores the Direct3D texture structure, and will hold the actual image data. The second variable provides us valuable information about the image, and will be populated before we actually load the image. This will allow us to automatically set the texture’s height, width, etc.

		bool Load(LPCWSTR);

This function takes one argument – the filename that we want to load. It can be either an absolute location (L”C:/Sprite.png”) or a relative location (“./media/img/Sprite.png”). In any project you run, you’ll generally want to use relative locations. The function will return true if it succeeded in loading the file, or false if it failed.

Code Listing 4: CTexture.cpp

#include "CTexture.h"

#include "CGameEngine.h"

namespace D3DPong
{
	CTexture::CTexture(void)
		: _texture(NULL)
	{
	}

	CTexture::~CTexture(void)
	{
		if(this->_texture != NULL)
			this->_texture->Release();
	}

	bool CTexture::Load(LPCWSTR fileName)
	{
		if(FAILED(D3DXGetImageInfoFromFile(fileName, &_imageInfo)))
		{
			this->_texture = NULL;
			return false;
		}

		if(FAILED(D3DXCreateTextureFromFileEx(CGameEngine::Instance()->GetDevice(),
			fileName, 											// File Name
			this->_imageInfo.Width, this->_imageInfo.Height, 1,	// Width, Height, and MIP Level Count
			D3DPOOL_DEFAULT, D3DFMT_UNKNOWN, D3DPOOL_DEFAULT,	// Usage method, Format, and Pool
			D3DX_DEFAULT, D3DX_DEFAULT,							// Image and MIP Filters
			D3DCOLOR_XRGB(255, 0, 255),							// Transparency Key (Magenta)
			&this->_imageInfo, NULL, &this->_texture			// Image information structure, color pallete, and destination texture
			)))
		{
			this->_texture = NULL;
			return false;
		}

		return true;
	}
};

Code Listing 5: CGameSprite.h

#pragma once

// Global Header Files
#include <Windows.h>
#include <d3d9.h>
#include <d3dx9.h>

// Local Header Files
#include "CSceneObject.h"
#include "CTexture.h"

namespace D3DPong
{
	class CGameSprite : public CSceneObject
	{
	private:
		/** Texture Data **/
		CTexture* _texture;
		bool _visible;
		D3DXMATRIX _matRotate, _matScale;

		/** Function Declarations **/
		void transform(void);

	public:
		/** Constructor & Destructor **/
		CGameSprite(void);
		~CGameSprite(void);

		/** Function Declarations **/
		bool Load(LPCWSTR);
		void Render(float);

		/** Accessors & Mutators **/
		CTexture* GetTexture(void) { return this->_texture; }
		void SetTexture(CTexture* val) { this->_texture = val; }

		bool IsVisible(void) { return this->_visible; }
		void SetVisible(bool val) { this->_visible = val; }
	};
};

And here’s our sprite class. Because we’re inheriting from CSceneObject, we don’t need to worry about all of the extra atomic data for the object. We’re going to have to store a texture for the sprite, store whether or not the object is visible (so that we can easily make an object appear and disappear), two Matrices to allow us to apply rotation. When using the D3DXSprite sprite handler, we can easily just provide a position and not worry about matrices at all – which works great for most games. However, because we want to implement scaling and rotation, we will have to use matrices. Matrices are used to provide translation (position), rotation, and scaling in three-dimensional games. They are also used in a number of two-dimensional games, to provide hardware-accelerated graphics functions. The transformation will be performed in the private “transform()” method, which will be called from our Render() method.

Code Listing 6: CGameSprite.cpp

#include "CGameSprite.h"

#include "CGameEngine.h"

namespace D3DPong
{
	CGameSprite::CGameSprite(void)
		: _texture(NULL), _visible(true)
	{
	}

	CGameSprite::~CGameSprite(void)
	{
		if(this->_texture != NULL)
			delete this->_texture;
	}

	void CGameSprite::transform(void)
	{
		D3DXMATRIX mat;

		D3DXMatrixTransformation2D(&mat, NULL, 0,
			&this->GetScale(), &this->GetCenter(), this->GetRotation(), &this->GetPosition());

		CGameEngine::Instance()->GetSpriteHandler()->SetTransform(&mat);
	}

	bool CGameSprite::Load(LPCWSTR fileName)
	{
		if(this->_texture != NULL)
			delete this->_texture;

		this->_texture = new CTexture();
		if(this->_texture->Load(fileName))
		{
			this->SetSize(D3DXVECTOR2(this->_texture->GetWidth(), this->_texture->GetHeight()));
			return true;
		}
		else
			return false;
	}

	void CGameSprite::Render(float)
	{
		this->transform();

		if(this->_texture != NULL && this->_visible)
			CGameEngine::Instance()->GetSpriteHandler()->Draw(this->_texture->GetTexture(), NULL, NULL, NULL, D3DCOLOR_XRGB(255, 255, 255));
	}
};

It doesn’t look all that difficult, I hope.

	void CGameSprite::transform(void)
	{
		D3DXMATRIX mat;

		D3DXMatrixTransformation2D(&mat, NULL, 0,
			&this->GetScale(), &this->GetCenter(), this->GetRotation(), &this->GetPosition());

		CGameEngine::Instance()->GetSpriteHandler()->SetTransform(&mat);
	}

The first method we handle, as explained, creates the transformation matrix, and then sets the current transformation on the sprite handler. We need a D3DXMATRIX variable to store the transformation Matrix, then we create the actual 2D transformation Matrix. We specify that the matrix to output to is our newly-defined mat variable, and we pass our Scale, Rotation, and Position vectors to the object. We also pass a new vector, that returns the center of the object, which will form the base around which our object rotates.

	void CGameSprite::Render(float)
	{
		this->transform();

		if(this->_texture != NULL && this->_visible)
			CGameEngine::Instance()->GetSpriteHandler()->Draw(this->_texture->GetTexture(), NULL, NULL, NULL, D3DCOLOR_XRGB(255, 255, 255));
	}

And here is our rendering method. First, we call our transform, so that we can get the object placed, rotated, and scaled properly. Next, we check to make sure that our texture is loaded, and whether or not our object is actually visible, before we render. This ensures that we don’t try to draw a NULL texture, which would cause our engine to crash. We pass the texture and a color to the Draw() method. The color we pass will saturate the image – we use white, to keep things as they are in the image.

bool CGameSprite::Load(LPCWSTR fileName)
	{
		if(this->_texture != NULL)
			delete this->_texture;

		this->_texture = new CTexture();
		if(this->_texture->Load(fileName))
		{
			this->SetSize(D3DXVECTOR2(this->_texture->GetWidth(), this->_texture->GetHeight()));
			return true;
		}
		else
			return false;
	}

Finally, we delete the old texture (if we want to load a new texture, we want to prevent memory leaks and clean up after ourselves). Then, we recreate the texture object and attempt to load the image, then set the object’s size to match that of the image. Simple, clean, efficient.

Code Listing 7: Game.cpp
We can keep the exact same Game.h that we created in the last project, and provide the following code to test our game engine’s most recent additions:

#include "Game.h"

#include "CGameEngine.h"

#define GEInstance D3DPong::CGameEngine::Instance()

D3DPong::CGameSprite* testSprite;

bool GamePreLoad(void)
{
	GEInstance->SetScreenWidth(800);
	GEInstance->SetScreenHeight(600);
	GEInstance->SetWindowTitle(L"Direct3D Pong Tutorial 03 - Scene Objects and Sprite Rendering");

	return true;
}

bool GameInit(void)
{
	// Load a test sprite
	testSprite = new D3DPong::CGameSprite();
	if(!testSprite->Load(L"./media/img/testSprite.png"))
		MessageBox(NULL, L"Failed to Load", L":(", MB_OK);

	float x = (float)(GEInstance->GetScreenWidth() - testSprite->GetWidth());
	float y = (float)(GEInstance->GetScreenHeight() / 2);

	testSprite->SetPositionX(x);
	testSprite->SetPositionY((y - testSprite->GetCenter().y));

	testSprite->SetVelocityX(-10);

	return true;
}

void GameUpdate(float delta)
{
	testSprite->Update(delta);

	if(testSprite->GetLeft() <= 0)
	{
		testSprite->SetVelocityX(0);
		testSprite->SetPositionX(0);
	}
}

void GameRender(float delta)
{
	testSprite->Render(delta);
}

void GameEnd(void)
{
	if(testSprite != NULL)
		delete testSprite;
}

All of the code in this test are pretty self-explanatory – we create and load the sprite, then we position it right and centered on the screen, and give the object a negative velocity on the X-axis – making it move to the left until it hits the end and stops.

Downloads
Binary Only (10.4KB)
Full VS2010 Project Dir (13.1MB)

Starting Words
Notice: This tutorial continues from where “C++/D3D Pong Tutorial 01” article left off. Please read it if you have not already.

Libraries
You will need to add the following three libraries to your project:
d3d9.lib
d3dx9.lib
dxguid.lib

Code Listing 1: CGameTimer.h

#pragma once

// Global Headers
#include <time.h>
#include <Windows.h>

namespace D3DPong
{
	class CGameTimer
	{
	private:
		// Marks the starting point of the timer
		DWORD _start;

	public:
		/** Constructor & Destructor **/
		CGameTimer(void);

		/** Function Declarations **/
		DWORD GetTime(void);		// Retrieve the current time (in milliseconds)
		DWORD GetStartTime(void);	// Get the Timer's start time (in milliseconds)
		DWORD GetRunTime(void);		// Get the Timer's running time (in millseconds)
		void Reset(void);			// Reset the timer.
	};
};

This small bit of code will mark the base of our game timing system. This system will make it possible to use delta timing, so that we do not have to cap the frame limit by using unnecessary processing. You will see how this works when we start setting up the rendering engine, but for now, allow me to give you an explanation of the class.

	private:
		// Marks the starting point of the timer
		DWORD _start;

The game timer’s only variable, this DWORD value will store the start time, in milliseconds, for when the timer started (its creation or a call to reset()).

		/** Function Declarations **/
		DWORD GetTime(void);		// Retrieve the current time (in milliseconds)
		DWORD GetStartTime(void);	// Get the Timer's start time (in milliseconds)
		DWORD GetRunTime(void);		// Get the Timer's running time (in millseconds)
		void Reset(void);			// Reset the timer.

Constructor declarations aren’t anything special, so I won’t bother going into detail about that. These four functions, however, are very important to the engine.

GetTime() will give us an easier method of getting the system time, in milliseconds. It takes away some of our reliance on the Windows API.
GetStartTime() will allow us to retrieve the time that the Timer was last started or reset.
GetRunTime() will give us the running time of our timer object. This will be vital when we implement Delta timing.
Reset() will reset the timer’s “start time.” This will allow us to more easily handle timed events, if a timer doesn’t need to continually run.

Code Listing 2: CGameTimer.cpp

#include "CGameTimer.h"

namespace D3DPong
{
	CGameTimer::CGameTimer(void)
	{
		this->_start = timeGetTime();
	}

	DWORD CGameTimer::GetTime(void)
	{
		return timeGetTime();
	}

	DWORD CGameTimer::GetStartTime(void)
	{
		return this->_start;
	}

	DWORD CGameTimer::GetRunTime(void)
	{
		return (timeGetTime() - this->_start);
	}

	void CGameTimer::Reset(void)
	{
		this->_start = this->GetTime();
	}
};

And here we are, the flesh and bones of the game timer class. All of these are single-line functions, but this will make a large portion of our engine’s logic. Most of it should be pretty obvious, if you read the descriptions above.

Creating our Entry Point
Before we get into the nitty-gritty portions of creating our engine framework and setting up Direct3D, I’m going to do two things. First, I’m going to show you where we are going to set up and handle our game logic, which will be separate from our Engine code. After that, I am going to give you a brief roadmap before jumping into the large bits of code that will make up our game engine.

Code Listing 3: Game.h

#pragma once

#include <windows.h>

extern bool GamePreLoad(void);
extern bool GameInit(void);
extern void GameUpdate(float);
extern void GameRender(float);
extern void GameEnd(void);

These functions, when fleshed out, will contain all of our game’s logic.
GamePreLoad() – Within this method, we will do some initial setup (such as setting up the game window dimensions)
GameInit() – And here, we will load our initial game resources and set up initial logic settings.
GameUpdate(delta) – This function will be called every frame, and will contain our game logic. The floating-point value that it is passed is the timing delta (the time between the last frame and this one). We will use this timing delta
GameRender(delta) – This function will also be called every frame, and will always be called after GameUpdate. Our rendering logic will be executed here.
GameEnd() – This will be called to execute last-minute cleanup for the game.

Code Listing 4: Game.cpp

#include "Game.h"

bool GamePreLoad(void)
{
	return true;
}

bool GameInit(void)
{
	return true;
}

void GameUpdate(float delta)
{
}

void GameRender(float delta)
{
}

void GameEnd(void)
{
}

This is just the empty framework for now. All of our game logic, when we begin work on it in future tutorials, will go here. We’ll modify this at the end of this tutorial to do some basic setup in the PreLoad function.

What Lies Ahead
Alright, we’ve got some fun work ahead of us. First, we are going to be setting up the game engine’s code. That will be a pretty decent-sized trek through the woods, but I’m going to try to cover it as thoroughly as I can without stepping into a discussion about the various pieces of clockwork that aren’t entirely necessary.

Code Listing 5: CGameEngine.h

#pragma once

// Global Header Files
#include <Windows.h>
#include <d3d9.h>
#include <d3dx9.h>

// Local Header Files
#include "CGameTimer.h"
#include "Game.h"

namespace D3DPong
{
	class CGameEngine
	{
	private:
		CGameEngine(void);						// ctor
		CGameEngine(CGameEngine const&) { };	// copy ctor
		virtual ~CGameEngine(void);				// dtor

		static CGameEngine* _instance;

		HWND	_windowHandle;

		LPDIRECT3D9			_d3d;
		LPDIRECT3DDEVICE9	_device;
		LPD3DXSPRITE 		_spriteHandler;

		LPCWSTR	_windowTitle;
		int		_screenWidth, _screenHeight, _colorDepth;

		const static D3DCOLOR _ambientColor;

		CGameTimer*	_gameTimer;
		bool		_gameRunning;

	public:
		static CGameEngine* Instance(void) { return _instance; }

		bool Init(int, int, int);
		void End(void);
		void Update(void);
		void BeginRender(void);
		void EndRender(void);

		LPDIRECT3DDEVICE9 GetDevice(void) { return this->_device; }
		LPD3DXSPRITE GetSpriteHandler(void) { return this->_spriteHandler; }
		HWND GetWindowHandle(void) { return this->_windowHandle; }
		LPCWSTR GetWindowTitle(void) { return this->_windowTitle; }
		int GetScreenWidth(void) { return this->_screenWidth; }
		int GetScreenHeight(void) { return this->_screenHeight; }
		int GetColorDepth(void) { return this->_colorDepth; }
		bool GetGameRunning(void) { return this->_gameRunning; }
		CGameTimer* GetGameTimer(void) { return this->_gameTimer; }

		void SetWindowHandle(HWND val) { this->_windowHandle = val; }
		void SetWindowTitle(LPCWSTR);
		void SetScreenWidth(int val) { this->_screenWidth = val; }
		void SetScreenHeight(int val) { this->_screenHeight = val; }
		void SetColorDepth(int val) { this->_colorDepth = val; }
	};
};

Aaaannnd here we go. Time for the explanations. I’ll leave out the accessor & mutators, as those should be second nature to anybody who has been able to follow along thus far.

		CGameEngine(void);						// ctor
		CGameEngine(CGameEngine const&) { };	// copy ctor
		virtual ~CGameEngine(void);				// dtor

		static CGameEngine* _instance;

Here, we have the constructor, copy constructor, and destructor. These are all defined in the private section because we only want to allow them to be initialized when the engine instance (which is a singleton) is first defined (in CGameEngine.cpp). The copy constructor is left empty (it wont be used at all), and the destructor is made virtual in case we decide to create a class that inherits from it at a later point (which is unlikely, but the option will still be available). Lastly, we create a static pointer that will serve as the singleton. We will be able to access the game engine at any time by calling CGameEngine::Instance().

		HWND	_windowHandle;

		LPDIRECT3D9			_d3d;
		LPDIRECT3DDEVICE9	_device;
		LPD3DXSPRITE 		_spriteHandler;

		LPCWSTR	_windowTitle;
		int		_screenWidth, _screenHeight, _colorDepth;

		const static D3DCOLOR _ambientColor;

		CGameTimer*	_gameTimer;
		bool		_gameRunning;

Most of the member variables are self-explanatory. The engine will need an instance of the game window’s handle for some of the Direct3D setup, as well as for other tasks, such as changing the window’s title. The three Direct3D variables are the Direct3D instance, which gives us access to a lot of the device creation features, the Direct3D device itself, which will handle our game’s rendering backbone, and then the D3DX sprite handler, which will allow us to do 2D rendering without going through the trouble of creating and texturing 3D quads, which anybody with experience doing that method of 2D will tell you is a royal pain in the ass. Finally, we create variables to store our window’s attributes (title, screen size, color depth), a static variable to store our ambient color (which will not change throughout the game), a boolean to keep track of whether or not the game is running (which will be important when we start modifying our game loop), and a game timer, which we will use to track the time between frames in the game.

		CGameEngine* Instance(void) { return _instance; }

Again, back to our Singleton implementation. Although this is simply an accessor, I wanted to point it out because of its importance to our singleton implementaiton.

		bool Init(int, int, int);
		void End(void);
		void Update(void);
		void BeginRender(void);
		void EndRender(void);

And these methods make up the meat of our game engine.
Init(width, height, depth) – This method will initialize the Direct3D systems, and will configure our render settings.
End() – This is called to end the game.
Update() – This method is called every frame, will calculate the timing delta and call our GameUpdate() and GameRender() methods.
BeginRender() – Basic rendering setup (starting the D3D device, starting the sprite handler, etc)
EndRender() – The inverse of our BeginRender function – this method ends the rendering systems started in BeginRender, then presents the scene (swaps the render buffers)

void SetWindowTitle(LPCWSTR);

You may have noticed this lonely mutator sitting here, undefined. Fight your urge to follow the other mutators on this one – we’re going to be defining this one in CGameEngine.cpp, so that if we would decide to change our window title in-game, we can, and doing so requires a touch more than changing the value of _windowTitle.

And here we go, the meat of our game engine.

Code Listing 6: CGameEngine.cpp

#include "CGameEngine.h"
#include "WinMain.h"

namespace D3DPong
{
	const D3DCOLOR CGameEngine::_ambientColor = D3DCOLOR_RGBA(255, 255, 255, 0);
	CGameEngine* CGameEngine::_instance = new CGameEngine();

	CGameEngine::CGameEngine(void)
		: _windowHandle(NULL), _windowTitle(L"D3DPong"),
		_screenWidth(640), _screenHeight(480), _colorDepth(32),
		_gameRunning(false),
	{
	}

	CGameEngine::~CGameEngine(void)
	{
		if(this->_gameRunning)
			this->_gameRunning = false;

		if(this->_spriteHandler)
			this->_spriteHandler->Release();

		if(this->_device)
			this->_device->Release();

		if(this->_d3d)
			this->_d3d->Release();

		delete this->_spriteHandler;
		delete this->_device;
		delete this->_d3d;
	}

	bool CGameEngine::Init(int width, int height, int depth)
	{
		// Set up Engine Vars
		this->_screenWidth = width;
		this->_screenHeight = height;
		this->_colorDepth = depth;
		// Initialize Direct3D
		this->_d3d = Direct3DCreate9(D3D_SDK_VERSION);
		if(!this->_d3d)
			return false;

		// Get the Display Mode (to ensure maximum compatibility)
		D3DDISPLAYMODE disp;
		this->_d3d->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &disp);

		// Presentation Parameters
		D3DPRESENT_PARAMETERS d3dpp;
		ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS));
		d3dpp.Windowed = true;
		d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
		d3dpp.EnableAutoDepthStencil = true;
		d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
		d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
		d3dpp.BackBufferFormat = disp.Format;
		d3dpp.BackBufferWidth = this->_screenWidth;
		d3dpp.BackBufferHeight = this->_screenHeight;
		d3dpp.hDeviceWindow = this->_windowHandle;

		// Create the Direct3D Device
		this->_d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, this->_windowHandle, D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &this->_device);

		if(!this->_device)
			return false;

		// Enable Z-buffering, set the fill mode, and set the ambient color (white)
		this->_device->SetRenderState(D3DRS_ZENABLE, true);
		this->_device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
		this->_device->SetRenderState(D3DRS_AMBIENT, this->_ambientColor);

		// Initialize the Sprite handler
		if(FAILED(D3DXCreateSprite(this->_device, &this->_spriteHandler)))
			return false;

		// Game Initialization
		if(!GameInit())
			return false;

		return true;
	}

	void CGameEngine::End(void)
	{
		this->_gameRunning = false;
		GameEnd();
	}

	void CGameEngine::Update(void)
	{
		static float lastFrame = 0.0f;

		float delta = ((float)((int)this->_gameTimer->GetTime())) - lastFrame;
		lastFrame = ((float)((int)this->_gameTimer->GetTime()));

		GameUpdate(delta);

		this->BeginRender();

		GameRender(delta);

		this->EndRender();
	}

	void CGameEngine::BeginRender(void)
	{
		if(!this->_device)
			return;

		if(FAILED(this->_device->BeginScene()))
			return;

		if(FAILED(this->_spriteHandler->Begin(D3DXSPRITE_ALPHABLEND)))
			return;
	}

	void CGameEngine::EndRender(void)
	{
		if(!this->_device)
			return;

		this->_spriteHandler->End();

		if(FAILED(this->_device->EndScene()))
			return;

		if(FAILED(this->_device->Present(NULL, NULL, NULL, NULL)))
			return;
	}

	void CGameEngine::SetWindowTitle(LPCWSTR val)
	{
		this->_windowTitle = val;

		if(this->_windowHandle)
			SetWindowText(this->_windowHandle, this->_windowTitle);
	}
};

Ready? Here we go.

	const D3DCOLOR CGameEngine::_ambientColor = D3DCOLOR_RGBA(255, 255, 255, 0);
	CGameEngine* CGameEngine::_instance = new CGameEngine();

Here, we are creating and defining the singleton instance, and setting up the ambient color constant. Pretty simple.

	CGameEngine::CGameEngine(void)
		: _windowHandle(NULL), _windowTitle(L"D3DPong"),
		_screenWidth(640), _screenHeight(480), _colorDepth(32)
		_gameRunning(false),
	{
	}

Technically, this is an empty constructor, but we’re using a shorthand method of setting default values for some of our class’s member variables.

	CGameEngine::~CGameEngine(void)
	{
		if(this->_gameRunning)
			this->_gameRunning = false;

		if(this->_spriteHandler)
			this->_spriteHandler->Release();

		if(this->_device)
			this->_device->Release();

		if(this->_d3d)
			this->_d3d->Release();

		delete this->_spriteHandler;
		delete this->_device;
		delete this->_d3d;
	}

A standard cleanup within the Game Engine’s destructor. First, we have to release all of the DirectX devices, to ensure that none of them are currently being used, and so that they can do their internal cleanup. Finally, we delete the pointers, as a final cleanup. Because this will mark the end of the application, this wouldn’t cause any sort of memory leak, but I’d prefer not to rely on the operating system to clean up our leftovers.

	bool CGameEngine::Init(int width, int height, int depth)
	{
		// Set up Engine Vars
		this->_screenWidth = width;
		this->_screenHeight = height;
		this->_colorDepth = depth;
		// Initialize Direct3D
		this->_d3d = Direct3DCreate9(D3D_SDK_VERSION);
		if(!this->_d3d)
			return false;

		// Get the Display Mode (to ensure maximum compatibility)
		D3DDISPLAYMODE disp;
		this->_d3d->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &disp);

Onto the Initialization. This one’s a big one. First, we’re just setting our member variables, so that we can keep track of our size and depth changes. Initializing Direct3D itself is easy and straightforward – you just call Direct3DCreate9 to create a Direct3D 9 manager, and pass the SDK version (Always pass it as D3D_SDK_VERSION, to ensure that the engine is compatible with future Direct3D releases).

Finally, we get the display mode of the desktop. This will be used when we are setting the Direct3D Presentation Parameters, which define hour our rendering is handled with the graphics card. While we could stick with a generic D3DFMT_R5G6B5, which will work almost universally, this will ensure that the display format used is compatible with the current video card and monitor.

		// Presentation Parameters
		D3DPRESENT_PARAMETERS d3dpp;
		ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS));
		d3dpp.Windowed = true;
		d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
		d3dpp.EnableAutoDepthStencil = true;
		d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
		d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
		d3dpp.BackBufferFormat = disp.Format;
		d3dpp.BackBufferWidth = this->_screenWidth;
		d3dpp.BackBufferHeight = this->_screenHeight;
		d3dpp.hDeviceWindow = this->_windowHandle;

The presentation parameters are incredibly important to Direct3D. It tells the system how large to make the back buffer (we’re using our screen dimensions), what to do when it swaps the buffers (discards the currently-rendering, then displays the new buffer), and sets the window handle that is used.

		// Create the Direct3D Device
		this->_d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, this->_windowHandle, D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &this->_device);

		if(!this->_device)
			return false;

		// Enable Z-buffering, set the fill mode, and set the ambient color (white)
		this->_device->SetRenderState(D3DRS_ZENABLE, true);
		this->_device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
		this->_device->SetRenderState(D3DRS_AMBIENT, this->_ambientColor);

Now we’re creating the Direct3D rendering device. We are configuring it as follows:
1) It will use the default adapter (the primary monitor/video card), everything will be handled on the hardware level (graphics card) for rendering, rather than software rendering (basically, use the GPU instead of the CPU), and we pass the presentation parameters and the address to map the newly created device to. Finally, we set three render states: Z-buffering, Solid fill mode, and ambient color. These settings will enhance our graphics quality, and give us some fun tools to use in later games. (Have you noticed, yet, that the engine is something that can easily be re-used in later projects?)

		// Initialize the Sprite handler
		if(FAILED(D3DXCreateSprite(this->_device, &this->_spriteHandler)))
			return false;

		// Game Initialization
		if(!GameInit())
			return false;

Getting back to more simple-to-comprehend steps. Here, we’re ensuring that we are able to create our sprite handler (which will make our two-dimensional rendering a lot easier to implement), and calling the game’s initialization method, so that it can handle game setup. And we’re done.

	void CGameEngine::End(void)
	{
		this->_gameRunning = false;
		GameEnd();
	}

This method will allow us to end the game. First, it changes the “running” flag, which will tell our engine to jump out of the loop, and then it calls the GameEnd method, allowing us to do some last-minute cleanup before the engine itself closes out.

	void CGameEngine::Update(void)
	{
		static float lastFrame = 0.0f;

		float delta = ((float)((int)this->_gameTimer->GetTime())) - lastFrame;
		lastFrame = ((float)((int)this->_gameTimer->GetTime()));

		GameUpdate(delta);

		this->BeginRender();

		GameRender(delta);

		this->EndRender();
	}

Another important one. The first thing we do is declare a static floating-point value, to store the time (in millseconds) of our last frame. We then calculate the delta (the time between calls to the Update() method) by subtracting the time the last frame started from the current game time. After calculating the delta, it changes frameTime to reflect the start of this frame. After that, we give a call to our GameUpdate method, passing the timing delta, start rendering, call GameRender, and then end rendering. In case you were wondering, the delta passed to GameRender is for animation purposes – the rendering method is the best place to put frame calculations for animations, in my opinion.

	void CGameEngine::BeginRender(void)
	{
		if(!this->_device)
			return;

		if(FAILED(this->_device->BeginScene()))
			return;

		if(FAILED(this->_spriteHandler->Begin(D3DXSPRITE_ALPHABLEND)))
			return;
	}

Here, we start rendering. First of all, if our device isn’t active, we’re going to crash if we try to call any methods on it, so we do a check to make sure it exists. Then, we begin the Direct3D scene, and begin 2D rendering within the sprite handler. By passing the D3DXSPRITE_ALPHABLEND parameter to the sprite handler, we ensure that alpha values will be honored by the rendering system, making transparency an easy task to deal with – it’s the artist’s problem now. Transparent PNGs are the best thing to use for two-dimensional game art, at the moment (excluding, of course, custom, optimized file formats created for an engine).

	void CGameEngine::EndRender(void)
	{
		if(!this->_device)
			return;

		this->_spriteHandler->End();

		if(FAILED(this->_device->EndScene()))
			return;

		if(FAILED(this->_device->Present(NULL, NULL, NULL, NULL)))
			return;
	}

Now, we’re doing the opposite. We still need to make sure our device exists before we stop rendering, but beyond that, we stop the systems in the order they were presented. The last method, Present, swaps the display buffers, and is required if we want our rendering to actually appear.

	void CGameEngine::SetWindowTitle(LPCWSTR val)
	{
		this->_windowTitle = val;

		if(this->_windowHandle)
			SetWindowText(this->_windowHandle, this->_windowTitle);
	}

Do you remember how I said our SetWindowTitle was a special mutator? Here it is. We could just stick with setting our _windowTitle member variable, but that would make this function useful only in the GamePreLoad method, which is called before the game window is created. This method, however, allows us to find out if the window has been created already. If it has, it updates the title there, as well, allowing for us to, for example, display the game score in the window’s title (not recommended, and I will not be showing you how to do so.)

Moving on
Well, we’ve got our engine laid out, and it’s something that we’ll be able to use in future projects as well as this one – we’ll just need to change the contents of our game functions (GamePreLoad, GameInit, etc), though we might want to replace the namespace (D3DPong) with another at a later date. Now that we’ve got the hard part out of the way, we are going to make changes to the WinMain.cpp file that we created in the last tutorial, so that we can call our GamePreLoad function and actually make use of the game engine. You just got done with a lot of code, so I won’t hold it against you if you go take a breather, get some soda, or play a game for a while.

Code Change Set 1: WinMain.cpp
All of these changes will be to the WinMain.cpp file.

For starters, scroll to the top of the file, and include CGameEngine.cpp after including WinMain.h

#include "WinMain.h"
#include "CGameEngine.h"

Remove g_bGameOver variable declaration. We’re going to be using our game engine’s GetGameRunning accessor in its place. Don’t worry about replacing it anywhere in code yet, we’ll do that on our way through.

We’re going to add a preprocessor directive to create an alias for CGameEngine::Instance(), to make it easier to access our game engine. Add the following after the two include directives:

#define GEInstance D3DPong::CGameEngine::Instance()

using namespace D3DPong;

This will allow us an easier method of getting our game engine’s instance (make sure you don’t add a semicolon to that preprocessor macro – if you do, we can’t use GEInstance->method. We are then telling our engine that this source file will be using the D3DPong namespace, so that we don’t have to prefix all of our engine features with D3DPong::.

Now, search for:

	case WM_QUIT:
	case WM_CLOSE:
	case WM_DESTROY:{
		g_bGameOver = true;
					} break;

and replace it with:

	case WM_QUIT:
	case WM_CLOSE:
	case WM_DESTROY:{
		GEInstance->End();
					} break;

Makes things easier, doesn’t it? It also ensures that our GameEnd function is called when we end the game.

Remove the initialization of g_bGameOver from our WinMain function.

	// Setup Globals
	g_bGameOver = false;

We want to allow our game the chance to set up the window and do some other system initialization before we set everything up, so add a call to GamePreLoad() where the g_bGameOver global used to be defined.

	WNDCLASSEX wc;	// Window Class Structure

	if(!GamePreLoad())
		return 0;

	// Fill the structure

Now, we want to update our CreateWindowEx call to use the engine’s width and height, which will be set in GamePreLoad() (or left to their default 640×480 values, if not set):
Replace the entire call with:

	// Create the Program Window
	hWnd = CreateWindowEx(NULL,										// dwExStyle
		L"GameWindow",												// Class Name - must match the lpszClassname of a registered window class
		GEInstance->GetWindowTitle(),								// Window Title
		WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,	// dwStyle
		0, 0,														// Screen Coordinates (X, Y)
		GEInstance->GetScreenWidth(), GEInstance->GetScreenHeight(),// Screen Size (Width, Height)
		NULL,														// Parent Window
		NULL,														// Menu
		hInstance,													// Instance Handle
		NULL);														// Extra Parameters

Below that, after we Show and Update the window, we wil make a call to the game engine’s Init function:

	// Initialize the Game Engine
	GEInstance->SetWindowHandle(hWnd);
	if(!GEInstance->Init(GEInstance->GetScreenWidth(), GEInstance->GetScreenHeight(), GEInstance->GetColorDepth()))
		return 0;

We pass the width, height, and color depth to the init function. It was designed this way, again, to allow later classes to inherit from the current engine. A note, for anybody who would do that: you’ll need to go into CGameEngine.cpp and change CGameEngine* CGameEngine::_instance = new CGameEngine(); to CGameEngine* CGameEngine::_instance = new NewClassName();. The singleton method that I used for this project is somewhat rough, and certainly isn’t the best method, but it’s one of the easiest to understand for new developers.

Finally, we update our application’s loop:

// Message Loop
	while(GEInstance->GetGameRunning())
	{
		while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}

		GEInstance->Update();
	}

Build, run, and see if it comes up with a black screen for you.

Game Setup Test
Now we’re going to do a quick, easy test to make sure we can properly configure our game at startup (in GamePreLoad). Open Game.cpp, and change GamePreLoad to the following:

bool GamePreLoad(void)
{
	D3DPong::CGameEngine::Instance()->SetScreenWidth(800);
	D3DPong::CGameEngine::Instance()->SetScreenHeight(600);
	D3DPong::CGameEngine::Instance()->SetWindowTitle(L"Direct3D Pong Tutorial 02");

	return true;
}

Note: I recommend creating the same Macro we defined in WinMain.cpp, so that you can shorten calls as GEInstance.

Run it, and you should have an 800×600 window, titled “Direct3D Pong Tutorial 02″.

Conclusion
That concludes the second tutorial in the D3D Pong series. Stay tuned for the next tutorial series, where we create a class to handle and render game sprites and scene objects.

Welcome to the D3D Pong Tutorial Series
Throughout this tutorial series, we will be developing a two-dimensional Pong clone using C++ and Direct3D 9. The tutorial assumes basic knowledge of the C++ language, as well as basic familiarity with namespaces, pointers, and the Microsoft Visual Studio IDE.

System Requirements
This tutorial series assumes that the following are true:
1) You have the DirectX SDK installed and configured on your system.
2) You know how to configure your IDE to use the header files and libraries included within the DirectX SDK
3) You know how to set up a new Win32 project (vice the use of a console project) in your IDE
4) You know how to add static libraries to a project within your IDE

Tutorial Description
This tutorial covers the first part of the D3D Pong project. We will create a Windows Application project, add the appropriate libraries, and will create the game/application window. In the next tutorial, we will cover setting up Direct3D, and will lay out the framework for the game engine.

Starting Words
In this tutorial series, I’m not going to give instructions to any particular IDE. I personally use Visual Studio 2010 B2 right now, and will at least be assuming the use of Visual Studio as far as some code samples go. If your particular compiler toolchain doesn’t support the

#pragma once

directive, simply replace any instances of that with the following:

#ifndef _FILENAME_H_
#define _FILENAME_H_

and put a

#endif

at the end of your file. This should be habit for most C++ developers, but I’m including this notice for the people who aren’t as familiar as the rest of us.

Project Setup
Go ahead and create a new Win32 Project within your IDE. Make sure that you are creating an empty Windows Application project, without MFC or any other fancy ties.

At this point in the project, we’re only going to add a single library to the project: winmm.lib.

Code Listing 1: WinMain.h

#pragma once

// Trim the size of Windows.h
#define WIN32_LEAN_AND_MEAN

// Global Header Files
#include <Windows.h>

// Function Declarations
int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int);
LRESULT CALLBACK WinProc(HWND, UINT, WPARAM, LPARAM);

This header should look standard to anybody with any Win32 API experience. Defining WIN32_LEAN_AND_MEAN strips a lot of the contents of Windows.h that we’ll never need, which will shorten the build time for the project. After bringing in the Windows header, we declare the two primary functions of any Windows application: WinMain and WinProc. Onto the big one..

Code Listing 2: WinMain.cpp

#include "WinMain.h"

// Global Variables
bool g_bGameOver;

We start by including the WinMain.h header file that we created from the first code block, then define a global boolean variable called g_bGameOver. This variable will actually later be declared in our engine’s main header as an external variable, so that the rest of the game code can access it, but we are going to have the declaration done within WinMain.cpp.

// Window Callback
LRESULT CALLBACK WinProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch(uMsg)
	{
		// Called when the game window is closed
	case WM_QUIT:
	case WM_CLOSE:
	case WM_DESTROY:{
		g_bGameOver = true;
					} break;
	}

	return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

This is our Window procedure, which handles all events on the game window. We are only worried about three events, which all relate to the same thing: the user exited the game. Through this method, we can perform any last-minute computations before we actually exit the application.

// Application Entry Point
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow)
{
	// Local Variables
	MSG msg;		// Message Structure
	HWND hWnd;		// Window Handle
	WNDCLASSEX wc;	// Window Class Structure

	// Setup Globals
	g_bGameOver = false;

Moving onto the Application’s entry point, we declare three variables in the local scope to hold our messages, our window handle, and the window structure itself, then assign a value of false to the g_bGameOver global.

	// Fill the structure
	wc.cbSize = sizeof(WNDCLASSEX);
	wc.style = CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc = WinProc;
	wc.cbClsExtra = NULL;
	wc.cbWndExtra = NULL;
	wc.hInstance = hInstance;
	wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = NULL;
	wc.lpszMenuName = NULL;
	wc.lpszClassName = L"GameWindow";
	wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

	// Register the structure
	RegisterClassEx(&wc);

Standard Win32 structure filling. The things of note here are the assigning of a window icon, a cursor, a Small Icon, and most importantly, the window’s class name. The class name is important because it is what we will use to tell CreateWindowEx what it will use as window class when creating the application window.

	// Create the Program Window
	hWnd = CreateWindowEx(NULL,										// dwExStyle
		L"GameWindow",												// Class Name - must match the lpszClassname of a registered window class
		L"D3D Pong Tutorial",										// Window Title
		WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,	// dwStyle
		0, 0,														// Screen Coordinates (X, Y)
		640, 480,													// Screen Size (Width, Height)
		NULL,														// Parent Window
		NULL,														// Menu
		hInstance,													// Instance Handle
		NULL);														// Extra Parameters

	// Ensure that there were no creation errors
	if(!hWnd)
	{
		MessageBox(NULL, L"Error Creating Application Window", L"Fatal Error", MB_OK | MB_ICONERROR);
		return 0;
	}

Standard window creation code. Always make sure that you test pivotal objects and ensure that they were actually created before attempting to use them. If our window isn’t created, we can’t do anything at all. Note that, like in the class definition, we are putting an L in front of the strings – this casts native strings into the LPCWSTR type, which will ensure that it is formatted as intended for the window.

	// Display the window
	ShowWindow(hWnd, nCmdShow);
	UpdateWindow(hWnd);

	// Message Loop
	while(!g_bGameOver)
	{
		while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	// Exit
	return 0;
}

Finally, we show the window, do an initial Update call, and begin listening for messages. While this tutorial wasn’t much, especially for anybody experienced with the Win32 API, it provides us a firm ground on which we can start the rest of the tutorials in the series.

Code Listing 3: WinMain.cpp (Full Listing)
Just for reference, here is the complete WinMain.cpp file:

#include "WinMain.h"

// Global Variables
bool g_bGameOver;

// Window Callback
LRESULT CALLBACK WinProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch(uMsg)
	{
		// Called when the game window is closed
	case WM_QUIT:
	case WM_CLOSE:
	case WM_DESTROY:{
		g_bGameOver = true;
					} break;
	}

	return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

// Application Entry Point
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow)
{
	// Local Variables
	MSG msg;		// Message Structure
	HWND hWnd;		// Window Handle
	WNDCLASSEX wc;	// Window Class Structure

	// Setup Globals
	g_bGameOver = false;

	// Fill the structure
	wc.cbSize = sizeof(WNDCLASSEX);
	wc.style = CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc = WinProc;
	wc.cbClsExtra = NULL;
	wc.cbWndExtra = NULL;
	wc.hInstance = hInstance;
	wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = NULL;
	wc.lpszMenuName = NULL;
	wc.lpszClassName = L"GameWindow";
	wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

	// Register the structure
	RegisterClassEx(&wc);

	// Create the Program Window
	hWnd = CreateWindowEx(NULL,										// dwExStyle
		L"GameWindow",												// Class Name - must match the lpszClassname of a registered window class
		L"D3D Pong Tutorial",										// Window Title
		WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,	// dwStyle
		0, 0,														// Screen Coordinates (X, Y)
		640, 480,													// Screen Size (Width, Height)
		NULL,														// Parent Window
		NULL,														// Menu
		hInstance,													// Instance Handle
		NULL);														// Extra Parameters

	// Ensure that there were no creation errors
	if(!hWnd)
	{
		MessageBox(NULL, L"Error Creating Application Window", L"Fatal Error", MB_OK | MB_ICONERROR);
		return 0;
	}

	// Display the window
	ShowWindow(hWnd, nCmdShow);
	UpdateWindow(hWnd);

	// Message Loop
	while(!g_bGameOver)
	{
		while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	// Exit
	return 0;
}

The remaining tutorials in this series will be set up as a series of code blocks, vice this single, full-listing, except under certain circumstances. I included the full code listing for this because it doesn’t require a lot of explanation for people who are at least passingly familiar with the Win32 API.