DirectX Programming

DirectX Programming

DirectX Programming

DirectX Programming

1. DirectSound
2. DirectPlay
3. Direct3D

Overview

1. My name is Charlie Calvert
2. Code and information from this talk is availble on my Web site: http://www.elvenware.com.
3. The talk will focus primarily on DirectX, and on how to find DirectX resources
4. I can't cover everything, so I will pick DirectDraw as the technical focus of talk
5. But I will show other technologies such as DirectSound, DirectPlay and Direct3D

Why DirectX?

1. DirectX is about games, visualization, and simulations, but it is also about communication
2. Tens of millions of computer users are not primarily focused on business
3. They are interested in entertainment, education, science, games, information and communication
4. All of these fields can be enhanced by DirectX
5. So yes, its about games and simulations, but its also about the human side of computing, and that's not a trivial matter.

What is DirectX?

1. DirectX provides tools for multimedia programming in Windows.
2. From a graphics or sound programmers perspective, Windows is slow.
3. The problem is that Windows forces the programmer to access hardware through drivers (VxDs).
4. Drivers let you write once, run anywhere, and they let you share resources. But they are slow.
5. The solution is DirectX, which gives programmers direct access to hardware.
6. It gives you direct access to blocks of memory that exist on devices such as video cards of sound cards.
7. The goal is real time performance, as fast as DOS or game consoles.

Windows 95/98 vs Windows NT Installation

1. DirectX comes with NT and Windows 98, but does not come with Windows 95
2. Windows 95/98 users can download the latest drivers from http://www.microsoft.com/directx
3. You cannot update the drivers that come with Windows NT, but you can get services packs to upgrade to at least DirectX 3.
4. Win 2000 supports DirectX 7.0, which is the current version.

DirectX SDK

1. The DirectX SDK has samples, media, declarations.
2. There is a good help file and numerous long documents, approaching book length.
3. Go to www.microsoft.com/directx/default.asp
4. You can download the DirectX 6.0 SDK from the MS web site, a mere 91 MB, or ...
5. At selected times you can buy the SDK CDROM for $8.65 ($12.50 via airmail) if you are a US citizen, or $11.65 if you live outside the US.

What are the Direct X technologies?

1. The key technologies are DirectDraw, DirectSound, DirectInput, DirectPlay, DirectMusic and Direct3D.
2. DirectDraw gives you direct access to the video buffer.
3. DirectSound gives you direct access to the sound hardware.
4. DirectInput gives you access to mouse and joystick facilities.
5. DirectPlay helps you create networked games or simulations.
6. DirectMusic allows you to creating music on the fly, and provides advanced MIDI services.
7. The advantage of these technologies is speed. They are fast!

What about Direct3D?

1. Direct3D let's you manipulate triangles out of which 3D objects can be made.
2. Direct3D has two modes.
3. Immediate Mode provides 3D graphics primitives similar to the OpenGL specification.
4. Retained Mode provides high level routines that make 3D programming easier.
5. Direct3D provides specifications that hardware venders can write to.
6. This has brought us greatly enhanced 3D performance in the last few months and years.

DirectX and COM

1. DirectX is implemented through a serious of COM objects, which means it is OOP based from the ground up.
2. These are very simple COM objects, so you don't need to understand much about COM to use them.
3. Each technology provides simple functions that retrieve the COM object.
4. Rather than call CoCreateInstance and QueryInterface, you can just call these functions.
5. This technology shows that COM is a lot faster than many people suspected.
6. Be sure to call CoInitialize at the beginning and and CoUnitialize at the end of your program.

Hardware and Software Emulation

1. DirectX gives you direct access to hardware.
2. If possible, it will ask optimized routines built into the hardware to perform operations
3. For instance, if you want to draw a rectangle, blit a bitmap, or perform a transform on an object, it will ask the hardware to perform these tasks for you.
4. If hardware does not support a feature the Hardware Emulation Layer (HEL), will do it for you.
5. If hardware supports a particular feature, then it is handled by the Hardware Abstraction Layer, or HAL.
6. You don't have to understand these things. DirectX automatically takes advantage of features such as MMX or 3D hardware features.
7. Drivers that ship with DirectX automatically access these features.

Time to get more technical

1. So much for the overview. Let's look at some details.
2. I will cover DirectDraw first, then DirectSound, DirectPlay and finally Direct3D.
3. There will be code examples available for all these technologies, but time is limited.
4. Because DirectX is complex, I will show you several high level libraries that save work.

Creating a DirectDraw Object

1. To create a DirectDraw object, just call DirectDrawCreate, CoGetClassObject or CoCreateInstance.
2. Once you get the object back, you need to initialize DirectDraw.
3. This is a complex process, so I provide you with both raw code and C++ classes that do it automatically.
4. However, I want to discuss this technology in some depth, so I will look beneath the hood.

Initializing DirectDraw

1. Key methods: DirectDrawCreate, SetCooperativeLevel, SetDisplayMode, CreateSurface
2. Subjects covered: DirectX Modes, Palettes, Surfaces, Page Flipping, Exception Handling, Restoring Surfaces
3. We'll need to cover all subjects before you will fully understand the initialization
4. The complexity of this operation is why you need high level objects!

Calling DirectDrawCreate and CoCreateInstance

LPDirectDraw is a pointer to a DirectDraw Interface: IDirectDraw * LPDirectDraw

IDirectDraw and DirectDrawCreate are declared in DDraw.h

LPDIRECTDRAW DirectDraw; 
/* DirectDrawCreate(
     GUID            //   Emulation or Hardware, 
     LPDIRECTDRAW    //   Your DirectDraw Object, 
     PUnkOuter       //   Must be NULL); */
HRESULT hr = DirectDrawCreate(NULL, &DirectDraw, NULL);
if (SUCCEEDED(hr))
{
  // Party on your DirectDraw object
}

IDirectDraw is just a COM object, so you can initialize it by calling CoCreateInstance.

CoInitialize(NULL)
hr = CoCreateInstance(CLSID_DirectDraw, NULL, CLSCTX_ALL, 
  IID_IDirectDraw, (VOID **)&DirectDraw);
if (SUCCEEDED(hr)
{
  hr = DirectDraw->Initialize(NULL);
  // Party on your DirectDraw object
}

DirectX Modes

1. Exclusive Mode vs Windowed Mode: determined by calling SetCooperativeLevel.
2. In Exclusive mode you own the whole screen, and can set it to whatever resolution you want.
3. This gives you fast access to the video buffer, so no one else is using it.
4. It gives you complete control over the palette.

Here's how you go into exclusive mode:

HRESULT ddrval = DirectDraw->SetCooperativeLevel(Handle, 
  DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);

For windowed mode, pass in DDSCL_NORMAL all by itself in the last parameter:

HRESULT ddrval = DirectDraw->SetCooperativeLevel(Handle, DDSCL_NORMAL); 

Setting the Display Mode

1. You can choose your display mode. For instance 640 X 480 or 1024 X 768 or even 320 X 200
2. You can also choose your bitdepth, which can be 8, 16, 24, etc, depending on your system.
3. This will work even if you are not in Exclusive mode, but it is best to be in exclusive mode.

// SetDisplayMode(Width, Height, BitDepth)
HRESULT ddrval = DirectDraw->SetDisplayMode(640, 480, 8)

Surfaces and Page Flipping

1. The idea is that you can write to a back buffer while the user is looking at a second image
2. When you are done drawing, Windows swaps your new picture into memory, in sync with refresh rate
3. The picture appears instantly to the user, which illiminates flickering
4. You can only call DirectDraw->Flip when in exclusive mode

Calling CreateSurface

1. In typical exclusive mode application you will have a Primary Surface and a Back Surface
2. You can create additional surfaces, typical one for each bitmap or set of bitmaps
3. The primary surface represents the area the user sees
4. The back surface is an off screen buffer you can draw to, as explained later in the talk

DDSURFACEDESC SurfaceDescription;
DDSCAPS ddscaps;

SurfaceDescription.dwSize = sizeof(SurfaceDescription);
SurfaceDescription.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
SurfaceDescription.ddsCaps.dwCaps = 
  DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
SurfaceDescription.dwBackBufferCount = 1;
hr = DirectDraw->CreateSurface(&SurfaceDescription, &PrimarySurface, NULL);
if SUCCEEDED(hr)
{
  // Get a pointer to the back buffer
  ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
  ddrval = PrimarySurface->GetAttachedSurface(&ddscaps, &BackSurface);
  ... // Party on
}

The DDUtil Routines

1. With the DirectX SDK, in the obscure sdk\misc directory comes a small file called DDUtil.cpp
2. This files contains all the missing routines you need to glue DirectX together

IDirectDrawPalette * DDLoadPalette(...);
IDirectDrawSurface * DDLoadBitmap(...);
HRESULT              DDReLoadBitmap(...);
HRESULT              DDCopyBitmap(...);
DWORD                DDColorMatch(...);
HRESULT              DDSetColorKey(...);

Palettes

1. I think of 256 color mode as having a palette, while higher bit depths just have RGB values.
2. In exclusive mode, you may want to work with a 256 color palette - smaller files, faster animation
3. In recent months, 256 color mode is finally showing signs of becoming obsolete. Almost all the new games support larger bit depths.
4. In windowed mode, you don't really have a palette, you just have X number of colors, unless you happen to be in 256 color mode

  // Get and set a palette from a bitmap
  lpDDPal = DDLoadPalette(DirectDraw, szBitmap);
  if (lpDDPal)
    lpDDSPrimary->SetPalette(lpDDPal);

  // Create an offscreen surface containing a bitmap
  ADirectDrawSurface = DDLoadBitmap(DirectDraw, szBitmap, 0, 0);

  if(ADirectDrawSurface == NULL )
  {
    return SomeErrorCode; // Exceptions handled later in talk
  }
  

Transparent Colors

1. You can specify a transparent color, or specify an index into a palette.
2. In 256 color mode you specify an index into a palette
3. In windowed mode, you specify the color as an RGB value

  // Set the transpareent color for a bitmap:
  DDSetColorKey(ADirectDrawSurface, RGB(0,0,0));

Flipping and Restoring the Focus

1. In exclusive mode, the user can usually still Alt-Tab from you application
2. You have to restore the surfaces when the alt tab back
3. IDirectDrawSurface->Restore() is the call.

  while(1)
  {
    HRESULT hr;
    hr = lpDDSPrimary->Flip(NULL, 0);

    if(hr == DD_OK)
      break;

    if(hr == DDERR_SURFACELOST)
    {
      hr = lpDDSPrimary->Restore();
      if (hr != DD_OK)
        break;
    }

    if((hr != DDERR_WASSTILLDRAWING) &&
       (hr != DDERR_SURFACELOST) &&
       (hr != DD_OK))
    {
      FActive = False;
      DirectDraw->FlipToGDISurface();
      throw Exception(IntToStr(hr));
    }
  }

Animation

1. To animate sprites, you must be in a very fast loop. You need fram rates of 30 plus per second.
2. A timer is not fast enough!
3. I use the OnIdle event, as explained in the next section
4. You can also call Application->ProcessMessages
5. Demo

  do {
    PerformAction(); // Party on
    Application->ProcessMessages();
  } while (FActive);

Idle Loopers

1. The application has an OnIdle event that you can hook
2. This is my preferred way to handle animation in the VCL
3. Always set Done to False if you want to be called again immediately

__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
  CoInitialize(NULL);  
  Application->OnIdle = IdleProc;  
}

Set Done to False or you want get called again till the user does something

void __fastcall TForm1::IdleProc(TObject *Sender, bool &Done)
{
  Done = False;     
  ... // Party on.
}

Exclusive Mode Exception Handling

1. If you are in exclusive mode and want to raise an exception, then call DirectDraw->FlipToGDISurface().
2. Especially in the early stages, you might want to debug in windowed mode and run in exclusive mode.
3. A general solution is to override the exception handler for your program:
4. Don't forget to turn off "Break on Exception!", and call FlipToGDISurface in your exception handler.
5. It definitely helps to debug on NT, as you can usually recover from exceptions, but not always on 98
6. Remote Debugging is another important solution

Examples on DDraw1B and DDraw1C

Working with sprites

1. You need to paint the sprites onto the surface in the proper order
2. Therefore you paint them to the BackSurface, then call Flip
3. I maintain a linked list of surfaces, and repaint each one before flipping
4. You can have a Visible property, along with the X and Y location

Clippers

1. Restricts output to a specific area
2. Useful for moving an object in from the edge of the screen
3. You don't have to restrict which part of a sprite is blited. The clipper handles it.
4. You can have "cliplists": lists of clipped regions owned by IDirectDrawClipper object.