Space Breakout - 2D Game Developed Using DirectX and C#

The next DirectDraw method (SetDisplayMode) sets the display mode for the game, the first two parameters indicate that the resolution will be 640 pixels by 480 pixels, the third specifies 16bit colour, the fourth is the refresh rate - by setting it to 0 DirectDraw will automatically use the best rate, the fifth argument indicates that no advanced resolutions are to be used.

Next properties are assigned to the Primary Surface descriptor variable, this variable will be used to create the Primary Surface. First we indicate that the description will specify the capabilities of the surface and it's Backbuffer count, this is done using the lflags property. The next line specifies the sets the capabilities of the surface, the first constant indicates that this will be a primary surface, the next constant indicates that we will be using page flipping to copy the backbuffer to the primary surface and the final constant is needed if we are using page flipping. The next line sets the back buffer count for the surface, it indicates that 1 backbuffer will be used. With the surface description configured the next line creates the primary surface using the CreateSurface() method of the DirectDraw object, the method takes a reference to the surface descriptor as it's one parameter.

With the Primary surface initialised the Backbuffer can then be created. We first need to set the caps property of the Backbuffer descriptor to indicate that this is a BackBuffer surface, we then use the GetAttachedSurface() method of the PrimarySurface object to create the Backbuffer.

Displaying Bitmaps

Bitmaps in DirectDraw must be loaded into new Surfaces and then copied onto the BackBuffer. Since there are a number of bitmap graphics in the game an abstract class (called BitmapObject) contains the code for bitmaps, this class is then inherited by each of the individual game object classes. The main variables used in the BitmapObject class to create a bitmap object and display it on the Backbuffer are:-

public const int BLACK_TRANSPARANT_SPRITE = 1;
public const int NORMAL_BITMAP = 0;
protected DDSURFACEDESC2 m_objDDSurfaceDescription;
private DirectDrawSurface7 m_objBitmapSurface;
protected RECT m_objSizeRECT;

The first two constants are used to indicate whether the object will be a sprite or a standard bitmap(a sprite is a non-square bitmap). Next m_objDDSurfaceDescription is a surface description object and is used to set the properties of the Surface object, m_objBitmapSurface is the DirectDraw surface object that will contain the bitmap. The remaining variable is a RECT which is an object containing rectangular information, it represents the rectangular dimensions of the surface and is used when the surface is copied to the backbuffer.

The surface description is configured in the function InitialiseSurfaceDescription() which is listed below, it contain two arguments which indicate the width and the height of the bitmap:-

InitialiseSurfaceDescription(int intBitmapWidth, int intBitmapHeight)
{
m_objDDSurfaceDescription.lFlags = CONST_DDSURFACEDESCFLAGS.DDSD_CAPS |
CONST_DDSURFACEDESCFLAGS.DDSD_WIDTH |
ONST_DDSURFACEDESCFLAGS.DDSD_HEIGHT;
m_objDDSurfaceDescription.ddsCaps.lCaps =
ONST_DDSURFACECAPSFLAGS.DDSCAPS_OFFSCREENPLAIN;
m_objDDSurfaceDescription.lWidth = intBitmapWidth;
m_objDDSurfaceDescription.lHeight = intBitmapHeight;
m_objSizeRECT.Bottom = intBitmapHeight;
m_objSizeRECT.Right = intBitmapWidth;
}

The first line of code sets the lFlags property of the surface descriptor, it indicates that the description will set the capabilities, the width and the height of the surface. The next line sets the capabilities of the surface specifying that it is an off screen surface. An off screen surface is a surface that exists in memory and is not itself physically visible to the user. The next two lines set the width and height of the surface and the final two lines set the width and the height of the RECT.

Once the surface description is setup the surface can be created, the code for this is in the InitialiseSurface() method. The method takes three arguments, the DirectDraw object for the application, a string indicating the source of the bitmap file and an integer indicating if a normal bitmap or a sprite is to be created. The code for the method is below:-

InitialiseSurface(DirectDraw7 DirectDraw, string strBackgroundBitmap, int intBitmapType)
{
try
{
m_objBitmapSurface = DirectDraw.CreateSurfaceFromFile( strBackgroundBitmap,
ref m_objDDSurfaceDescription );
}
catch ( Exception e)
{
System.Windows.Forms.MessageBox.Show( "Unexpected exception: " + e.ToString(), "Unexpected Exception" );
System.Windows.Forms.Application.Exit();
}
switch (intBitmapType)
{
case BitmapObject.BLACK_TRANSPARANT_SPRITE:
DDCOLORKEY objBlackKey;
objBlackKey.low = 0; objBlackKey.high = 0;
_objBitmapS
urface.SetColorKey( CONST_DDCKEYFLAGS.DDCKEY_SRCBLT, ref
bjBlackKey);break;
}

The first section of code attempts to create a DirectDraw surface object using the specified bitmap file. This is done using the CreateSurfaceFromFile() method of the applications DirectDraw object. CreateSurfaceFromFile() takes two parameters, a string indicating the source of the bitmap and the DirectDraw surface description object which was configured earlier.

The final section of code is used if a sprite is being created. As I mentioned earlier a sprite is a non-square graphic, unfortunately bitmap files can only be square therefore DirectDraw has to turn a square graphic into a sprite. This is done by defining a color key for the surface, DirectDraw will then make any part of the bitmap that is the specified colour transparent when it overlaid on another surface. All the sprites in the game use black for the colour key, the first line of code creates a DirectDraw colour key object and the next two lines set it's high and low colours to black. Next the SetColourKey() method of the bitmap surface object is called, the first parameter specifies that the colour key is to be applied to the bitmap surface object and not the surface that the object is being overlaid onto, the second parameter is a reference to the colour key object that was just created.

With the bitmap surface created it can be overlaid onto the Backbuffer surface, the process of overlaying one surface onto another is known as 'blitting' which is colloquial for "bit block transfer". To blit a bitmap surface onto the Backbuffer the BltFast() method is used, the following code is used in the BltFast() method of the games BitmapObject class to blit a sprite onto the backbuffer using the colour key for transparency:-

objBackBufferSurface.BltFast( this.XPosition, this.YPosition, m_objBitmapSurface, ref m_objSizeRECT, CONST_DDBLTFASTFLAGS.DDBLTFAST_SRCCOLORKEY | CONST_DDBLTFASTFLAGS.DDBLTFAST_WAIT );

The first parameter of the BltFast() method is the number of pixels from the left of the Backbuffer that the sprite will be placed; the next parameter is the number of pixels from the top to position the sprite; the third is the surface object of the sprite; the fourth is a RECT which indicates the size of the area being blitted to and the final parameter is the blitt flags to use; the two used indicate that we are using a colour key for the object and that DirectDraw is to wait until blitting is completed before moving to the next operation.

Flipping the Backbuffer to the primary surface

Once all the bitmaps for a frame have been blitted to the backbuffer it needs to be flipped to the Primary surface. This is done in the FlipBackBufferAndPrimary() method of the GameDirectDraw class. The method has one line of code which is:- this.PrimarySurface.Flip(this.BackBufferSurface, CONST_DDFLIPFLAGS.DDFLIP_WAIT); As you can see the Flip() method of the Primary Surface object is called, the method has two parameters. The first parameter is the Backbuffer surface object and the second is a flag indicating that DirectDraw should wait until the flipping is complete before moving onto the next operation. Once the flipping is complete the backbuffer can then be cleared and the next frame of animation blitted to it.

Conclusion

This article has detailed the core elements of building a game using DirectX and DirectDraw. DirectX is a huge topic but it is hoped that in conjunction with the source code for the Space Breakout game you'll have all you need to begin building your own 2D DirectX games.