The Code
Now that we've got that out of the way, we can get down and dirty with some actual code! Let's start off with this:
>#define WIN32_LEAN_AND_MEAN
>#include
>#include "dxutil.h"
>#include "ddutil.h"
Standard procedure here. We #define WIN32_LEAN_AND_MEAN, so all that icky MFC stuff doesn't bloat our program (just a good practice if you aren't using MFC). Then we include dxutil.h, and ddutil.h, the two centerpieces of this article. They provide shortcut classes to make programming with DirectX in general less taxing.
>//globals
>bool g_bActive = false;
>CDisplay *g_pDisplay = NULL;
>CSurface *g_pText = NULL;
>//function prototypes
>bool InitDD(HWND);
>void CleanUp();
>void GameLoop();
Pretty self explanatory. Our first global, g_bActive, is a flag to let our application know whether or not it's okay to run the game. If we didn't have this flag, our application could potentially attempt to draw something onto our DirectDraw surface after it's been destroyed. While this is usually a problem at the end of the program where it isn't that big of a deal, it generates an illegal operation error, and we don't want that, now do we? g_pDisplay is our display object. CDisplay is the main class in ddutil. It holds our front and back buffers, as well as functionality for accessing them, drawing surfaces onto them, creating surfaces, etc. g_pText is our text surface. We will draw text onto this surface (as you've probably figured out), and blit it onto our screen. Note how both objects are pointers, and are initialized to NULL.
Now for the function prototypes. InitDD() simply initializes DirectDraw. Thanks to the DDraw Common Files, this is a fairly simple procedure (but we'll get to that later). CleanUp() calls the destructor to our g_pDisplay object, which essentially shuts down DDraw, and cleans up all of our surfaces. GameLoop() is obviously where you'd put your game.
>LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
> switch(uMsg) {
> case WM_CREATE:
> InitDD(hWnd);
> g_bActive=true;
> break;
> case WM_CLOSE:
> g_bActive=false;
> CleanUp();
> DestroyWindow(hWnd);
> break;
> case WM_DESTROY:
> PostQuitMessage(0);
> break;
> case WM_MOVE:
> g_pDisplay->UpdateBounds();
> break;
> case WM_SIZE:
> g_pDisplay->UpdateBounds();
> break;
> default:
> return DefWindowProc(hWnd, uMsg, wParam, lParam);
> break;
> }
> return 0;
>}
Standard Windows Procedure function here. On the WM_CREATE event, we initialize DirectDraw, and set our g_bActive flag to true, so our GameLoop() function is executed. When WM_CLOSE is called, we want to set our active flag to false (again, so our app doesn't try to draw to our DDraw screen after its been destroyed), then call our CleanUp() function, and finally destroy our window. It's important that you handle the WM_MOVE and WM_SIZE events, because otherwise DirectDraw will not know the window has been moved or resized and will continue drawing in the same position on your screen, in spite of where on the screen the window has moved.