It is often useful to know how big text is that you are going to draw. GetTextSize() sets a SIZE structure with the width and height of the string if draw with the given font.

CreateFont() creates a normal win32 font. DrawText() get a pointer to the current surface, redirects GDI to this surface and uses the GDI text functions to draw the text. Here is some stripped down code to draw text suing GDI and DX. font is a font made with CreateFont(), x, y is where the text is drawn, fore is the text colour, back is the text background colour, s is the string to draw, and s is a SIZE structure to hold the size of the rendered text.

int CgsdxIO::DrawText(HFONT font, int x, int y, DWORD fore, DWORD back, LPCSTR s, SIZE *size);

    int err=0;
    HFONT oldFont;
    HRESULT hr;
    HDC lhdc;

    m_backSurface->GetDC(&lhdc);  // get a HDC that can be used by GDI functions
    if ( back & GSDX_TRANSPARENT_TEXT )
        {
        SetBkMode(lhdc, TRANSPARENT);
        }
    else
        {
        SetBkMode(lhdc, OPAQUE);
        SetBkColor(lhdc, back);
        }
    SetTextColor(lhdc, fore);
    if ( font )
        {
        oldFont=(HFONT )SelectObject(lhdc, font);
        TextOut(lhdc, x, y, s, strlen(s));
        if ( size )
            GetTextExtentPoint32(lhdc, s, strlen(s), size);
         
        SelectObject(lhdc, oldFont);
        }
    else
        {
        TextOut(lhdc, x, y, s, strlen(s));
        if ( size )
            GetTextExtentPoint32(lhdc, s, strlen(s), size);
        }

    m_backSurface->ReleaseDC(lhdc); // unlock the HDC

Blitting

"Bit Blit" means quickly copying a rectangular bitmap from one place to another. In practise this usually means drawing a small drawing on screen.

DX's DirectDraw supports hardware accelerated blitting. DX also supports "colour keying". Colour Keying means that all pixels in the source bitmap of a certain colour are not copied over - in effect they are transparent. The main steps for blitting are: load the images into video or system memory. Set up colour keying if wanted. Copy the pre-loaded image to display memory to "draw" it.

DX also supports copying part of a loaded bitmap to display memory. This is a good feature as you could have 10 small images in one bmp file, load the whole thing into video memory, then draw the image you want by specifying the source rectangle in the large bitmap. You can also "scale" bitmaps. By making the destination rectangle smaller or larger than the source rectangle DX will scale the bitmap to fit.

Loading images from drawing programs

CgsdxIO has a function called LoadBitmap() that loads bmps into video memory. It handles all the file decoding etc... required. Win32 and later versions of DX also have functions that can help simplify this task.

CgsdxIO::LoadBitmap() is also passed a RECT that indicates where on the whole bmp file this particular bitmap exists. LoadBitmap() can be called multiple times with the same BMP source file, but different RECT parameters to define where the images are on a single large BMP. LoadBitmap() only loads the main BMP to video memory once. LoadBitmap() does the following:

• load the bmp file from disk, and decode
• copy the bmp file to a DX surface
• store information about the surface for future use
• make whatever pixel is in the top, left corner of the main image the "colour key"
• return a pointer that can be used to draw the bitmap that RECT points to

    // pointers to bitmap info
    gsdxBitmap_t *topLeft;
    gsdxBitmap_t *topRight;
    gsdxBitmap_t *bottomLeft;
    gsdxBitmap_t *bottomRight;
    RECT r;
    CPoint dest;
    char temp[100];

    // load four bitmaps
    // each bitmap is actually a rectangle on one large bitmap.
    // LoadBitmap() knows it has loaded "square4.bmp" when it does
    // the second, third, and forth loads, so it returns pointers to
    // the different areas of the same main bitmap
    r.left=0;
    r.right=320;
    r.top=0;
    r.bottom=240;
    topLeft=dx.LoadBitmap("square4.bmp", &r);
    r.left=320;
    r.right=640;
    r.top=0;
    r.bottom=240;
    topRight=dx.LoadBitmap("square4.bmp", &r);
    r.left=0;
    r.right=320;
    r.top=240;
    r.bottom=480;
    bottomLeft=dx.LoadBitmap("square4.bmp", &r);
    r.left=320;
    r.right=640;
    r.top=240;
    r.bottom=480;
    bottomRight=dx.LoadBitmap("square4.bmp", &r);

    dx.RectFill(NULL, 0);  // clear screen to black
    dest.x=0;
    dest.y=0;
    dx.Blit(&dest, topLeft); // draw the bitmap
    dx.Flip();
    getch();

    dx.RectFill(NULL, 0);
    dest.x=0;
    dest.y=0;
    dx.Blit(&dest, topRight);
    dx.Flip();
    getch();

    dx.RectFill(NULL, 0);
    dest.x=0;
    dest.y=0;
    dx.Blit(&dest, bottomLeft);
    dx.Flip();
    getch();

    dx.RectFill(NULL, 0);
    dest.x=0;
    dest.y=0;
    dx.Blit(&dest, bottomRight);
    dx.Flip();
    getch();

    // draw scaled bitmaps
    // each time through this loop the bitmap is drawn larger
    r.left=0;
    r.right=topLeft->bmRect.right - topLeft->bmRect.left ;
    r.top=0;
    r.bottom=topLeft->bmRect.bottom - topLeft->bmRect.top;
    for ( i=0; i < 7; i++ )
        {
        // draw the "topLeft" bitmap to fit into the rectangle r
        dx.Blit(&r, topLeft, 0);

        // make r bigger, and move right and down
        r.left+=120;
        r.right+=150;
        r.top+=50;
        r.bottom+=80;
       
        dx.Flip();
        getch();
        }

typedef struct
    {
    int dx, dy;     // offset used to draw this frame, helps centre rotating sprite
    RECT collision; // defaults to the whole frame
    int numAttach;
    POINT *attach;
    gsdxBitmap_t *bitmap; // this frames bitmap
    }
spriteFrame_t;

typedef struct
    {
    DWORD ID;
    int numFrames;
    int delay;      // between frames in milli-seconds
    int direction;  // for pong
    DWORD changeMode;
    int currentFrame;  // index
    DWORD nextFrameTime; // time at which this the next frame is used
    spriteFrame_t *frames;
    }
sprite_t;

typedef struct
    {
    int numSprites;
    sprite_t *sprites;
    }
spriteBank_t;

// index is the index of the sprite within this "bank" of sprites
int CSprite::DrawSprite(int index, int x, int y)
{
    int err=0, dx, dy;
    POINT pnt;

    if ( m_bank )
        {
        if ( m_bank->sprites[index].numFrames < 1 )
            return 1;

        dx=m_bank->sprites[index].frames[m_bank->sprites[index].currentFrame].dx;
        dy=m_bank->sprites[index].frames[m_bank->sprites[index].currentFrame].dy;
        pnt.x=x + dx;
        pnt.y=y + dy;
        err=m_dx->Blit(&pnt, m_bank->sprites[index].frames[m_bank->sprites[index].currentFrame].bitmap, 1, m_hdc);
        }

    return err;
}