Game Dev Explorations: Scrolling Game Development Kit

Look at lines 200-237, 419-446 where I make changes to the drawing implementation. What I'm doing is setting the destination resolution to fit the native widescreen aspect ratio, then centering SGDK's native 4:3 display within the widescreen (16:9 or 16:10) aspect ratio. It seems to eat more GPU juice, but the game will display with the correct aspect ratio AND you will be able to screen capture the playback with any screencapturing software at the gameplay's set framerate, meaning no missing tiles.

You can copy the code here into a new Visual C++ 6.0 file (*.cpp) or download it here. You will also have to download the complete source code for SGDK's graphics engine BMDXCtl at gamedev.sf.net, then compile it yourself. Alternately, you can download the complete precompiled dll here. The dll replaces the one in the SGDK installation folder. Make sure you rename the original dll before replacing it with this one, just in case.

I was developing my games on a modified SGDK IDE, too, and it seemed compatible with the modified BMDXCtls. However, make sure you are using SGDK 1.4.6.

Corrected Aspect Ratio for 16:10 or 16:9 monitor

//======================================================================
//
// Project: BMDXCtls - Ben Marty DirectX Controls
//
// Developed By Benjamin Marty
// Copyright © 1998,2000 Benjamin Marty
// Distibuted under the GNU General Public License
//    - see http://www.fsf.org/copyleft/gpl.html
//
// File: BMDXDisplay.cpp - Implementation of CBMDXDisplay
//
//======================================================================

#include "stdafx.h"
#include "resource.h"
#include <ddraw.h>
#include <stdio.h>

/////////////////////////////////////////////////////////////////////////////
// CBMDXDisplay

static const char NAME[]="BMDXDisplay";
CBMDXDisplay *pBMDXDisplay=NULL;
BOOL bDialogDisplayed=FALSE;

STDMETHODIMP CBMDXDisplay::InterfaceSupportsErrorInfo(REFIID riid)
{
   static const IID* arr[] = 
   {
      &IID_IBMDXDisplay,
   };
   for (int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
   {
      if (InlineIsEqualGUID(*arr[i],riid))
         return S_OK;
   }
   return S_FALSE;
}

long FAR PASCAL WindowProc( HWND hWnd, UINT message, 
                     WPARAM wParam, LPARAM lParam )
{
   if (!pBMDXDisplay)
      return DefWindowProc(hWnd, message, wParam, lParam);

switch (message)
   {
   case WM_MOUSEMOVE:
      pBMDXDisplay->OnMouseMove( wParam, LOWORD(lParam), HIWORD(lParam));
      break;
   case WM_KEYDOWN:
      if (!(lParam & (1<<30))) // If key was up
      {
         pBMDXDisplay->OnKeyDown( wParam, ((GetKeyState(VK_SHIFT) >> 15) & 1) | 
                                          ((GetKeyState(VK_CONTROL) >> 14) & 2) |
                                          ((GetKeyState(VK_MENU) >> 13) & 4));
      }
      break;
   case WM_SYSKEYDOWN:
      if ((lParam & (3<<29))==1<<29) // if SYSKEYDOWN was sent because of ALT and key was up
      {
         pBMDXDisplay->OnKeyDown( wParam, ((GetKeyState(VK_SHIFT) >> 15) & 1) | 
                                          ((GetKeyState(VK_CONTROL) >> 14) & 2) | 4);
      }
      break;
   case WM_KEYUP:
      pBMDXDisplay->OnKeyUp( wParam, ((GetKeyState(VK_SHIFT) >> 15) & 1) |
                                     ((GetKeyState(VK_CONTROL) >> 14) & 2) |
                                     ((GetKeyState(VK_MENU) >> 13) & 4));
      break;
   case WM_SYSKEYUP:
      if ((lParam & (1<<29)) || wParam==VK_MENU) // if SYSKEYUP was sent because of ALT
      {
         pBMDXDisplay->OnKeyUp( wParam, ((GetKeyState(VK_SHIFT) >> 15) & 1) |
                                        ((GetKeyState(VK_CONTROL) >> 14) & 2) | 4);
      }
      break;
   case WM_CHAR:
      pBMDXDisplay->OnChar( wParam , lParam);
      break;
   case WM_LBUTTONDOWN:
      pBMDXDisplay->OnLButtonDown(wParam, LOWORD(lParam), HIWORD(lParam));
      break;
   case WM_RBUTTONDOWN:
      pBMDXDisplay->OnRButtonDown(wParam, LOWORD(lParam), HIWORD(lParam));
      break;
   case WM_LBUTTONUP:
      pBMDXDisplay->OnLButtonUp(wParam, LOWORD(lParam), HIWORD(lParam));
      break;
   case WM_RBUTTONUP:
      pBMDXDisplay->OnRButtonUp(wParam, LOWORD(lParam), HIWORD(lParam));
      break;
   }

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

void DoEvents(HWND hWnd)
{
   MSG msg;
   while (::PeekMessage( &msg, hWnd, 0, 0, PM_REMOVE ) )
   {
      ::TranslateMessage(&msg);
      ::DispatchMessage(&msg);
   }
}

BOOL CALLBACK BMDXDlg( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
   switch(uMsg)
   {
   case WM_INITDIALOG:      
      return TRUE;
   case WM_COMMAND:
   case WM_CLOSE:
      DestroyWindow(hwndDlg);
      return TRUE;      
   default:
      return FALSE;
   }
}

STDMETHODIMP CBMDXDisplay::Open()
{
   HINSTANCE hInst=_Module.GetModuleInstance();
   WNDCLASS wc;
   HRESULT hr;
   DDSURFACEDESC ddsd={0};

if(m_hwnd)
   {
      Close();
      return Error(_T("Display was already open"), IID_IBMDXDisplay);
   }

if (!bDialogDisplayed) 
      ShowAbout();

if (!bDialogDisplayed)
      return E_FAIL;

/*
   * set up and register window class
   */
   wc.style = CS_HREDRAW | CS_VREDRAW;
   wc.lpfnWndProc = WindowProc;
   wc.cbClsExtra = 0;
   wc.cbWndExtra = 0;
   wc.hInstance = hInst;
   wc.hIcon = LoadIcon( NULL, IDI_WINLOGO );
   wc.hCursor = LoadCursor( hInst, MAKEINTRESOURCE( IDC_NOPOINTER ));
   wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
   wc.lpszMenuName = NULL;
   wc.lpszClassName = NAME;
   RegisterClass( &wc );
   
  /*
   * create a window
   */
   m_hwnd = CreateWindowEx(
      0,
      NAME,
      NAME,
      WS_POPUP,
      0,
      0,
      GetSystemMetrics(SM_CXSCREEN),
      GetSystemMetrics(SM_CYSCREEN),
      NULL,
      NULL,
      hInst,
      NULL );

if( !m_hwnd )
   {
      return Error(_T("Error creating display window"), IID_IBMDXDisplay);
   }

ShowWindow( m_hwnd, SW_SHOW );
   UpdateWindow( m_hwnd );
   SetFocus( m_hwnd );

hr = DirectDrawCreate( NULL, &m_lpDD, NULL );
   if (hr != DD_OK)
   {
      Close();
      return Error(_T("Error creating DirectDraw object"), IID_IBMDXDisplay);
   }

pBMDXDisplay=this;

// Get exclusive mode
   hr = m_lpDD->SetCooperativeLevel( m_hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT);
   if( hr != DD_OK )
   {
      Close();
      return Error(_T("Error setting direct draw to full screen"), IID_IBMDXDisplay);
   }

// Set the video mode (to 640x480x16 by default)
   //hr = m_lpDD->SetDisplayMode( m_nWidth, m_nHeight, m_nDepth);

//Set maximum screensize for compatibility with future widescreen displays
   //Center and scale 4:3 lower resolutions
   hr = m_lpDD->SetDisplayMode( GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), m_nDepth);
   if(hr != DD_OK)
   {
      Close();
      return Error(_T("Error setting display mode"), IID_IBMDXDisplay);
   }

// Create the primary surface with 1 back buffer
   ddsd.dwSize = sizeof( ddsd );
   ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
   ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
                         DDSCAPS_FLIP |
                         DDSCAPS_COMPLEX;
   ddsd.dwBackBufferCount = 1;
   hr = m_lpDD->CreateSurface( &ddsd, &m_lpDDSPrimary, NULL );
   if( hr != DD_OK )
   {
      Close();
      return Error(_T("Error creating drawing surface"), IID_IBMDXDisplay);
   }

ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
   hr = m_lpDDSPrimary->GetAttachedSurface(&ddsd.ddsCaps, &m_lpDDSBack);
   if( hr != DD_OK )
   {
      Close();
      return Error(_T("Error getting back buffer from drawing surface"), IID_IBMDXDisplay);
   }

DoEvents(m_hwnd);

return S_OK;
}

STDMETHODIMP CBMDXDisplay::Close()
{
   HRESULT hr;

Fire_Close();

ReleaseAllDCs();

hr=m_TileSets->ReleaseItems();

if (m_lpDDSBack)
   {
      m_lpDDSBack->Release();
      m_lpDDSBack=NULL;
   }
   if (m_lpDDSPrimary)
   {
      m_lpDDSPrimary->Release();
      m_lpDDSPrimary=NULL;
   }
   if (m_lpDD)
   {
      m_lpDD->Release();
      m_lpDD=NULL;
   }
   pBMDXDisplay=NULL;
   if(m_hwnd)
   {
      DestroyWindow(m_hwnd);
      m_hwnd=(HWND)0;
   }

return hr;
}

STDMETHODIMP CBMDXDisplay::DrawText(BSTR Text, long Left, long Top, VARIANT Width)
{
   long nWidth=m_nWidth;
   RECT rcText;
   HRESULT hr;
   HDC hDC;
   HFONT hFont;

USES_CONVERSION;

if (!m_lpDDSBack)
   {
      return Error(_T("Tried to draw text when no drawing surface is available"),IID_IBMDXDisplay);
   }

if(!(Width.vt == VT_ERROR))
   {
      if (VariantChangeType(&Width, &Width, 0, VT_I4) == S_OK)
      {
         nWidth = Width.lVal;
      }
   }

rcText.left=Left;
   rcText.top=Top;
   rcText.right=rcText.left+nWidth;
   if (rcText.right>m_nWidth-1)
      rcText.right=m_nWidth-1;
   rcText.bottom=m_nHeight-1;

if (m_hDCBack)
   {
      hDC = m_hDCBack;
   }
   else
   {
      if ((hr=m_lpDDSBack->GetDC(&hDC)) != DD_OK)
      {
         return hr;
      }
   }

if (m_pIFont)
   {
      if ((hr=m_pIFont->get_hFont(&hFont))!=S_OK)
      {
         if (m_hDCBack == NULL)
            m_lpDDSBack->ReleaseDC(hDC);
         return hr;
      }
      ::SelectObject(hDC, hFont);
   }

::SetBkMode(hDC, TRANSPARENT);
   ::SetTextColor(hDC, m_Color);
   ::DrawText(hDC, OLE2T(Text), SysStringLen(Text), &rcText, DT_LEFT | DT_NOPREFIX | (m_bWordWrap?DT_WORDBREAK:0) );

if (m_hDCBack == NULL)
   {
      if ((hr = m_lpDDSBack->ReleaseDC(hDC)) != DD_OK)
      {
         return hr;
      }
   }

return S_OK;
}

STDMETHODIMP CBMDXDisplay::SetFont(IUnknown * pFont)
{   
   if (m_pIFont)
   {
      m_pIFont->Release();
      m_pIFont=NULL;
   }

if (pFont->QueryInterface(__uuidof(IFont), (void **)&m_pIFont) != S_OK)
   {
      return Error(_T("SetFont requires a font object"),IID_IBMDXDisplay);
   }

return S_OK;
}

CBMDXDisplay::~CBMDXDisplay()
{
   //BMDXLog(_T("Destroying Display\n"));
   Close();
   if (m_pIFont)
   {
      m_pIFont->Release();
      m_pIFont=NULL;
   }
   m_TileSets->Release();
}

STDMETHODIMP CBMDXDisplay::get_ForeColor(long * pVal)
{
	*pVal=m_Color;

return S_OK;
}

STDMETHODIMP CBMDXDisplay::put_ForeColor(long newVal)
{

OleTranslateColor(newVal, NULL, &m_Color);

return S_OK;
}

STDMETHODIMP CBMDXDisplay::Flip()
{
   HRESULT hr;

if (m_hDCFore || m_hDCBack)
   {
      ReleaseAllDCs();
      return Error(_T("Function not available when DC is locked"), IID_IBMDXDisplay2);
   }

if (!m_lpDDSPrimary)
   {
      return Error(_T("Display must be open to flip"),IID_IBMDXDisplay);
   }

//obtain user desired size
   //m_nWidth and m_nHeight set in OenEX method
   float scaleFactor;
   long scrHeight, scrWidth;
   long adjW;
   RECT rcSrc;
   RECT rcDest;

scrWidth = (long)GetSystemMetrics(SM_CXSCREEN);
   scrHeight = (long)GetSystemMetrics(SM_CYSCREEN);

rcSrc.left=0;
	rcSrc.top=0;
	rcSrc.right= (long)m_nWidth;
	rcSrc.bottom=(long)m_nHeight;

scaleFactor=(float)((float)scrHeight)/((float)m_nHeight);

adjW = (long)(rcSrc.right*scaleFactor);

rcDest.left=(scrWidth - adjW)/2;
	 rcDest.top=0;		//Assume scale to fit height
	 rcDest.right=rcDest.left+adjW;
	 rcDest.bottom=scrHeight;

//Draw the rescaled and centered primary surface
	hr=m_lpDDSPrimary->Blt(&rcDest, m_lpDDSBack, &rcSrc, DDBLTFAST_WAIT, NULL);

/*
//Comment this out so doesnt draw unscaled surface
   if ((hr=m_lpDDSPrimary->Flip(NULL,DDFLIP_WAIT)) != DD_OK)
   {
      if (hr==DDERR_SURFACELOST)
      {
         m_lpDDSPrimary->Restore();
         m_TileSets->Restore();
      } else {
         return hr;
      }
   }

*/
	
   return S_OK;
}

void CBMDXDisplay::OnMouseMove(int nFlags, short x, short y)
{
   int Button=0;
   int Shift=0;

Button=0;
   Shift=0;
   if (nFlags & MK_LBUTTON) Button |= 1;
   if (nFlags & MK_RBUTTON) Button |= 2;
   if (nFlags & MK_MBUTTON) Button |= 4;
   if (nFlags & MK_SHIFT) Shift |= 1;
   if (nFlags & MK_CONTROL) Shift |= 2;
   Fire_MouseMove(Button, Shift, x, y);
}

void CBMDXDisplay::OnKeyDown(int nVirtKey, short Shift)
{
   Fire_KeyDown(nVirtKey, Shift);
}

void CBMDXDisplay::OnKeyUp(int nVirtKey, short Shift)
{
   Fire_KeyUp(nVirtKey, Shift);
}

void CBMDXDisplay::OnChar(TCHAR chCharCode, long lKeyData)
{
   Fire_KeyPress(chCharCode);
}

void CBMDXDisplay::OnLButtonDown(UINT Flags, short x, short y)
{
   short Shift=0;

if (Flags & MK_SHIFT) Shift |= 1;
   if (Flags & MK_CONTROL) Shift |=2;
   Shift |= GetKeyState(VK_MENU) >> 13;

Fire_MouseDown(1, Shift, x, y);
}

void CBMDXDisplay::OnRButtonDown(UINT Flags, short x, short y)
{
   short Shift=0;

if (Flags & MK_SHIFT) Shift |= 1;
   if (Flags & MK_CONTROL) Shift |=2;
   Shift |= GetKeyState(VK_MENU) >> 13;

Fire_MouseDown(2, Shift, x, y);
}

void CBMDXDisplay::OnLButtonUp(UINT Flags, short x, short y)
{
   short Shift=0;

if (Flags & MK_SHIFT) Shift |= 1;
   if (Flags & MK_CONTROL) Shift |=2;
   Shift |= GetKeyState(VK_MENU) >> 13;

Fire_MouseUp(1, Shift, x, y);
}

void CBMDXDisplay::OnRButtonUp(UINT Flags, short x, short y)
{
   short Shift=0;

if (Flags & MK_SHIFT) Shift |= 1;
   if (Flags & MK_CONTROL) Shift |=2;
   Shift |= GetKeyState(VK_MENU) >> 13;

Fire_MouseUp(2, Shift, x, y);
}

STDMETHODIMP CBMDXDisplay::Cls(long Color)
{
   DDBLTFX ddfx;
   COLORREF clrColor;
   DDPIXELFORMAT ddpf;
   DWORD clr=0;
   int i, ri, gi, bi;

if (m_hDCFore || m_hDCBack)
   {
      ReleaseAllDCs();
      return Error(_T("Function not available when DC is locked"), IID_IBMDXDisplay2);
   }

if (!m_lpDDSBack)
   {
      return Error(_T("Display must be open to clear screen"), IID_IBMDXDisplay);
   }

OleTranslateColor(Color, NULL, &clrColor);

ddfx.dwSize=sizeof(ddfx);

switch(m_nDepth)
   {
   case 16:
      clr = (clrColor & 0xF8) << 7;
      clr |= (clrColor & 0xF800) >> 6;
      clr |= (clrColor & 0xF80000) >> 19;
      break;
   default:
      clr = (clrColor & 0xFF) << 16;
      clr |= (clrColor & 0xFF00) ;
      clr |= (clrColor & 0xFF0000) >> 16;
      break;
   }

ddpf.dwSize=sizeof(ddpf);
   if (DD_OK==m_lpDDSPrimary->GetPixelFormat(&ddpf))
   {
      if (ddpf.dwFlags & DDPF_RGB)
      {
         clr=0;
         ri=7;
         gi=7;
         bi=7;
         for(i=31; i>=0; i--)
         {
            if (((1<<i) & ddpf.dwRBitMask) && (ri>=0))
            {
               clr |= (((clrColor & (1<<ri--))?1:0)<<i);
            }
            if (((1<<i) & ddpf.dwGBitMask) && (gi>=0))
            {
               clr |= (((clrColor & (1<<(8+gi--)))?1:0)<<i);
            }
            if (((1<<i) & ddpf.dwBBitMask) && (bi>=0))
            {
               clr |= (((clrColor & (1<<(16+bi--)))?1:0)<<i);
            }
         }
      }
   }

ddfx.dwFillColor=clr;

return m_lpDDSBack->Blt(NULL,NULL,NULL,DDBLT_COLORFILL | DDBLT_WAIT, &ddfx);

return S_OK;
}

STDMETHODIMP CBMDXDisplay::PaintPicture(IUnknown * pPicture, short X1, short Y1, VARIANT Width1, VARIANT Height1, VARIANT X2, VARIANT Y2, VARIANT Width2, VARIANT Height2)
{
   IPicture *pIPicture;
   HRESULT hr;
   HDC hDC;
	int nPixelsPerInchX;    // Pixels per logical inch along width
	int nPixelsPerInchY;    // Pixels per logical inch along height
   short nWidth1, nHeight1;
   long nX2=0, nY2=0;
   long nWidth2, nHeight2;
   OLE_XSIZE_HIMETRIC nPicWidth;
   OLE_YSIZE_HIMETRIC nPicHeight;

if (pPicture->QueryInterface(__uuidof(IPicture), (void **)&pIPicture) != S_OK)
   {
      return Error(_T("PaintPicture requires a Picture object"), IID_IBMDXDisplay);
   }

if (!m_lpDDSBack)
   {
      pIPicture->Release();
      return Error(_T("PaintPicture requires an open display"), IID_IBMDXDisplay);
   }

if (m_hDCBack)
   {
      hDC = m_hDCBack;
   }
   else
   {
      if ((hr=m_lpDDSBack->GetDC(&hDC)) != DD_OK)
      {
         pIPicture->Release();
         if (hr==DDERR_SURFACELOST)
         {
            m_lpDDSPrimary->Restore();
            m_TileSets->Restore();
            return S_OK;
         }
         return hr;
      }
   }

nPixelsPerInchX = GetDeviceCaps(hDC, LOGPIXELSX);
	nPixelsPerInchY = GetDeviceCaps(hDC, LOGPIXELSY);

pIPicture->get_Width(&nPicWidth);
   pIPicture->get_Height(&nPicHeight);

nWidth1 = MAP_LOGHIM_TO_PIX(nPicWidth, nPixelsPerInchX);
	nHeight1 = MAP_LOGHIM_TO_PIX(nPicHeight, nPixelsPerInchY);

nWidth2 = nPicWidth;
   nHeight2 = nPicHeight;

if (!(Width1.vt == VT_ERROR))
   {
      if (VariantChangeType(&Width1, &Width1, 0, VT_I2)==S_OK)
      {
         nWidth1 = Width1.iVal;
      }
   }

if (!(Height1.vt == VT_ERROR))
   {
      if (VariantChangeType(&Height1, &Height1, 0, VT_I2)==S_OK)
      {
         nHeight1 = Height1.iVal;
      }
   }

if (!(X2.vt == VT_ERROR))
   {
      if (VariantChangeType(&X2, &X2, 0, VT_I4)==S_OK)
      {
         nX2 = X2.lVal;
      }
   }

if (!(Y2.vt == VT_ERROR))
   {
      if (VariantChangeType(&Y2, &Y2, 0, VT_I4)==S_OK)
      {
         nY2 = Y2.lVal;
      }
   }

if (!(Width2.vt == VT_ERROR))
   {
      if (VariantChangeType(&Width2, &Width2, 0, VT_I4)==S_OK)
      {
         nWidth2 = Width2.lVal;
      }
   }

if (!(Height2.vt == VT_ERROR))
   {
      if (VariantChangeType(&Height2, &Height2, 0, VT_I4)==S_OK)
      {
         nHeight2 = Height2.lVal;
      }
   }

nY2 = nPicHeight - nY2;
   nHeight2 = -nHeight2;

if ((hr=pIPicture->Render(hDC, X1, Y1, nWidth1, nHeight1, nX2, nY2, nWidth2, nHeight2, NULL) != S_OK))
      {
      pIPicture->Release();
      if (m_hDCBack == NULL)
      {
         if ((hr = m_lpDDSBack->ReleaseDC(hDC)) != DD_OK)
         {
            return hr;
         }
      }
      return hr;
   }

pIPicture->Release();

if (m_hDCBack == NULL)
   {
      if ((hr = m_lpDDSBack->ReleaseDC(hDC)) != DD_OK)
      {
         return hr;
      }
   }

return S_OK;
}

STDMETHODIMP CBMDXDisplay::CreateTileSet(IUnknown * pPicture, short TileWidth, short TileHeight, IBMDXTileSet ** ppTileSet)
{
   DDSURFACEDESC ddsd;
   IPicture *pIPicture;
   HRESULT hr;
	int nPixelsPerInchX;    // Pixels per logical inch along width
	int nPixelsPerInchY;    // Pixels per logical inch along height
   OLE_XSIZE_HIMETRIC nPicWidth;
   OLE_YSIZE_HIMETRIC nPicHeight;
   CComObject<CBMDXTileSet> *pTileSet;
   CComVariant *pvar;
   VARIANT var;
   LPDIRECTDRAWSURFACE lpDDS;
   HDC hDC;
   DDCOLORKEY ddck;

if (m_hDCFore || m_hDCBack)
   {
      ReleaseAllDCs();
      return Error(_T("Function not available when DC is locked"), IID_IBMDXDisplay2);
   }

if (!m_lpDD | !m_lpDDSPrimary)
   {
      return Error(_T("CreateTileSet requires an open display"),IID_IBMDXDisplay);
   }

if (pPicture->QueryInterface(__uuidof(IPicture), (void **)&pIPicture) != S_OK)
   {
      return Error(_T("CreateTileSet requires a Picture object"),IID_IBMDXDisplay);
   }

CComObject<CBMDXTileSet>::CreateInstance(&pTileSet);
   pvar=new CComVariant(pTileSet);
   VariantInit(&var);
   pvar->Detach(&var);
   if ((hr=m_TileSets->Add(var)) != S_OK)
   {
      VariantClear(&var);
      delete pvar;
      delete pTileSet;
      pIPicture->Release();
      return Error(_T("Cannot add more TileSets"),IID_IBMDXDisplay);
   }
   VariantClear(&var);
   delete pvar;
   
   pTileSet->put_TileWidth(TileWidth);
   pTileSet->put_BaseWidth(TileWidth);
   pTileSet->put_TileHeight(TileHeight);
   pTileSet->put_BaseHeight(TileHeight);

hDC=::GetDC(NULL);
	nPixelsPerInchX = GetDeviceCaps(hDC, LOGPIXELSX);
	nPixelsPerInchY = GetDeviceCaps(hDC, LOGPIXELSY);
   ::ReleaseDC(NULL, hDC);

pIPicture->get_Width(&nPicWidth);
   pIPicture->get_Height(&nPicHeight);
   
   ddsd.dwSize  = sizeof(ddsd);
   ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
   ddsd.dwWidth = MAP_LOGHIM_TO_PIX(nPicWidth, nPixelsPerInchX);
   ddsd.dwHeight = MAP_LOGHIM_TO_PIX(nPicHeight, nPixelsPerInchY);
   ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;

if ((hr=m_lpDD->CreateSurface(&ddsd,&lpDDS,NULL))!=DD_OK)
   {
      m_TileSets->Remove(m_TileSets->m_nCount-1);
      delete pTileSet;
      pIPicture->Release();
      return hr;
   }

if ((hr=lpDDS->GetDC(&hDC)) != DD_OK)
   {
      lpDDS->Release();
      m_TileSets->Remove(m_TileSets->m_nCount-1);
      delete pTileSet;
      pIPicture->Release();
      return Error(_T("Error getting device context from surface"), IID_IBMDXDisplay);
   }

if ((hr=pIPicture->Render(hDC, 0, 0, ddsd.dwWidth, ddsd.dwHeight,
                             0, nPicHeight, nPicWidth, -nPicHeight, NULL)) != S_OK)
   {
      lpDDS->ReleaseDC(hDC);
      lpDDS->Release();
      m_TileSets->Remove(m_TileSets->m_nCount-1);
      delete pTileSet;
      pIPicture->Release();
      return Error(_T("Error rendering picture onto TileSet surface"), IID_IBMDXDisplay);
   }
   
   lpDDS->ReleaseDC(hDC);

ddsd.dwSize = sizeof(ddsd);
   while ((hr = lpDDS->Lock(NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING)
   ;

if (hr == DD_OK)
   {
      ddck.dwColorSpaceLowValue = *(DWORD *)ddsd.lpSurface;
      if (m_nDepth<32)
      {
         ddck.dwColorSpaceLowValue &= (1 << ddsd.ddpfPixelFormat.dwRGBBitCount)-1;
      }
      lpDDS->Unlock(NULL);
      ddck.dwColorSpaceHighValue = ddck.dwColorSpaceLowValue;
      lpDDS->SetColorKey(DDCKEY_SRCBLT, &ddck);
   }

if ((hr=pTileSet->AttachSurface(lpDDS)) != S_OK)
   {
      lpDDS->Release();
      m_TileSets->Remove(m_TileSets->m_nCount-1);
      delete pTileSet;
      pIPicture->Release();
      return Error(_T("Error creating surface"), IID_IBMDXDisplay);
   }

lpDDS->Release();
   hr = pTileSet->QueryInterface(IID_IBMDXTileSet,(void **)ppTileSet);
   pIPicture->Release();

return hr;
}

STDMETHODIMP CBMDXDisplay::get_TileSets(IBMDXTileSetCollection * * pVal)
{
   return m_TileSets->QueryInterface(IID_IBMDXTileSetCollection, (void **)pVal);
}

STDMETHODIMP CBMDXDisplay::DrawMap(IBMDXTileSet *pTileSet, IBMDXTileMap *pTileMap, long XOffset, long YOffset, short Left, short Top, short Width, short Height, BOOL Transparent)
{
   LPDIRECTDRAWSURFACE lpDDS;
   IUnknown *punk;
   HRESULT hr;
   short x, y;
   short nTileWidth, nTileHeight;
   short nUseWidth, nUseHeight;
   short nTileCols;
   BYTE nTile;
   RECT rcSrc;
   short DstX, DstY;
   BMDX_PERSPECTIVES Perspective;
   short nBaseWidth, nBaseHeight;
   short yBound1, yBound2, dy;
   short xBound1, xBound2, dx;

if (m_hDCFore || m_hDCBack)
   {
      ReleaseAllDCs();
      return Error(_T("Function not available when DC is locked"), IID_IBMDXDisplay2);
   }

if (!m_lpDDSBack)
      return Error(_T("DrawMap requires open display"),IID_IBMDXDisplay);

if (!pTileSet)
      return Error(_T("Invalid TileSet object"), IID_IBMDXDisplay);

if (!pTileMap)
      return Error(_T("Invalid TileMap object"), IID_IBMDXDisplay);

if ((hr = pTileSet->get_DDSurface(&punk)) != S_OK)
      return hr;

if ((hr = punk->QueryInterface(IID_IDirectDrawSurface, (void **)&lpDDS)) != S_OK)
   {
      punk->Release();
      punk=NULL;
      return hr;
   }

punk->Release();
   punk=NULL;

pTileSet->get_TileWidth(&nTileWidth);
   pTileSet->get_TileHeight(&nTileHeight);
   pTileSet->get_TileColumns(&nTileCols);
   pTileSet->get_BaseWidth(&nBaseWidth);
   pTileSet->get_BaseHeight(&nBaseHeight);
   pTileSet->get_Perspective(&Perspective);

yBound1 = (YOffset-nTileHeight+nBaseHeight)/nBaseHeight;
   yBound2 = ((YOffset+Height-1)/nBaseHeight);
   dy = 1;
   xBound1 = (XOffset-nTileWidth+nBaseWidth)/nBaseWidth;
   xBound2 = (XOffset+Width-1)/nBaseWidth;
   dx = 1;

switch(Perspective)
   {
   case BMDX_PerspectiveTopLeft:
      dx = -1;
      x = xBound1;
      xBound1 = xBound2;
      xBound2 = x - 1;
      yBound2++;
      break;
   case BMDX_PerspectiveBottomRight:
      dy = -1;
      y = yBound1;
      yBound1 = yBound2;
      yBound2 = y - 1;
      xBound2++;
      break;
   case BMDX_PerspectiveBottomLeft:
      dx = -1;
      x = xBound1;
      xBound1 = xBound2;
      xBound2 = x - 1;
      dy = -1;
      y = yBound1;
      yBound1 = yBound2;
      yBound2 = y - 1;
      break;
   default:
      yBound2++;
      xBound2++;
      break;
   }

for (y = yBound1; y != yBound2; y += dy)
   {
      for (x = xBound1; x != xBound2; x += dx)
      {
         if (pTileMap->get_TileValue(x,y,&nTile) != S_OK)
            nTile=0;
         if (Transparent && !nTile)
            continue;
         rcSrc.left=(nTile % nTileCols)*nTileWidth;
         rcSrc.top=(nTile / nTileCols)*nTileHeight;
         rcSrc.right=rcSrc.left + nTileWidth;
         rcSrc.bottom=rcSrc.top + nTileHeight;
         DstX=(short)(Left+x*nBaseWidth-XOffset);
         DstY=(short)(Top+y*nBaseHeight-YOffset);
		 nUseWidth = nTileWidth;
         nUseHeight = nTileHeight;
         if (DstX<Left)
         {
            rcSrc.left+=(Left - DstX);
            nUseWidth-=(Left - DstX);
            DstX=Left;
         }
         if (DstY<Top)
         {
            rcSrc.top+=(Top - DstY);
            nUseHeight-=(Top - DstY);
            DstY=Top;
         }
         if (DstX+nUseWidth>Left+Width)
            rcSrc.right-=(nUseWidth-(Left+Width-DstX));
         if (DstY+nUseHeight>Top+Height)
            rcSrc.bottom-=(nUseHeight-(Top+Height-DstY));

if ((hr=m_lpDDSBack->BltFast(DstX, DstY, lpDDS, &rcSrc, DDBLTFAST_WAIT | (Transparent?DDBLTFAST_SRCCOLORKEY:0))) != DD_OK)
         {
            if (hr==DDERR_SURFACELOST)
            {
               lpDDS->Release();
               m_lpDDSPrimary->Restore();
               m_TileSets->Restore();
               return S_OK;
            } else {
               lpDDS->Release();
               return hr;
            }
         }
      }
   }

lpDDS->Release();

return S_OK;
}

void CBMDXDisplay::OnTileSetLost(short Index)
{
   Fire_TileSetLost(Index);
}

STDMETHODIMP CBMDXDisplay::DrawTile(IBMDXTileSet * pTileSet, BYTE TileValue, short X, short Y, short ClipLeft, short ClipTop, short ClipWidth, short ClipHeight, BOOL Transparent)
{
   LPDIRECTDRAWSURFACE lpDDS;
   IUnknown *punk;
   HRESULT hr;
   short nTileWidth, nTileHeight;
   short nTileCols;
   RECT rcSrc;

if (m_hDCFore || m_hDCBack)
   {
      ReleaseAllDCs();
      return Error(_T("Function not available when DC is locked"), IID_IBMDXDisplay2);
   }

if (!m_lpDDSBack)
      return Error(_T("DrawMap requires open display"),IID_IBMDXDisplay);

if (!pTileSet)
      return Error(_T("Invalid TileSet object"), IID_IBMDXDisplay);

if ((hr = pTileSet->get_DDSurface(&punk)) != S_OK)
      return hr;

if ((hr = punk->QueryInterface(IID_IDirectDrawSurface, (void **)&lpDDS)) != S_OK)
   {
      punk->Release();
      punk=NULL;
      return hr;
   }

punk->Release();
   punk=NULL;

pTileSet->get_TileWidth(&nTileWidth);
   pTileSet->get_TileHeight(&nTileHeight);
   pTileSet->get_TileColumns(&nTileCols);

rcSrc.left=(TileValue % nTileCols)*nTileWidth;
   rcSrc.top=(TileValue / nTileCols)*nTileHeight;
   rcSrc.right=rcSrc.left + nTileWidth;
   rcSrc.bottom=rcSrc.top + nTileHeight;
   if (X<ClipLeft)
   {
      rcSrc.left+=(ClipLeft-X);
      nTileWidth-=(ClipLeft-X);
      X=ClipLeft;
   }
   if (Y<ClipTop)
   {
      rcSrc.top+=(ClipTop-Y);
      nTileHeight-=(ClipTop-Y);
      Y=ClipTop;
   }
   if (X+nTileWidth>ClipLeft+ClipWidth)
      rcSrc.right-=(nTileWidth-(ClipLeft+ClipWidth-X));
   if (Y+nTileHeight>ClipTop+ClipHeight)
      rcSrc.bottom-=(nTileHeight-(ClipTop+ClipHeight-Y));
   if ((rcSrc.left<rcSrc.right) && (rcSrc.top<rcSrc.bottom))
   {

if ((hr=m_lpDDSBack->BltFast(X, Y, lpDDS, &rcSrc, DDBLTFAST_WAIT | (Transparent?DDBLTFAST_SRCCOLORKEY:0))) != DD_OK)
      {
         if (hr==DDERR_SURFACELOST)
         {
            m_lpDDSPrimary->Restore();
            m_TileSets->Restore();
         } else {
            lpDDS->Release();
            return hr;
         }
      }
   }
   lpDDS->Release();

return S_OK;
}

STDMETHODIMP CBMDXDisplay::Hit(IBMDXTileSet * pTileSet1, IBMDXTileSet * pTileSet2, short Left1, short Top1, short Width1, short Height1, short Left2, short Top2, short Width2, short Height2, short DX, short DY, BOOL * pResult)
{
   LPDIRECTDRAWSURFACE lpDDS1, lpDDS2;
   HRESULT hr;
   int xOverlap, yOverlap;
   DDSURFACEDESC ddsd1, ddsd2;
   IUnknown *punk;
   int x,y;
   DWORD BGColor1, BGColor2;
   BYTE *pb1, *pb2;

*pResult=FALSE;

if (m_hDCFore || m_hDCBack)
   {
      ReleaseAllDCs();
      return Error(_T("Function not available when DC is locked"), IID_IBMDXDisplay2);
   }

// If rectangle 2 is completely to the right of rectangle 1, no intersection
   if (DX >= Width1)
      return S_OK;
   // If rectangle 1 is completely to the right of rectangle 2, no intersection
   if (-DX >= Width2)
      return S_OK;
   // If rectangle 2 is completely below rectangle 1, no intersection
   if (DY >= Height1)
      return S_OK;
   // If rectangle 1 is completely below rectangle 2, no intersection
   if (-DY >= Height2)
      return S_OK;

ddsd1.dwSize=sizeof(ddsd1);
   ddsd2.dwSize=sizeof(ddsd2);

if (!pTileSet1 || !pTileSet2)
      return Error(_T("Invalid TileSet object"),IID_IBMDXDisplay);

if ((hr=pTileSet1->get_DDSurface(&punk)) != S_OK)
      return Error(_T("DirectDraw surface from TileSet not available"), IID_IBMDXDisplay);

if ((hr=punk->QueryInterface(IID_IDirectDrawSurface, (void **)&lpDDS1)) != S_OK)
   {
      punk->Release();
      return Error(_T("Could not get DirectDraw Surface from TileSet"), IID_IBMDXDisplay);
   }

punk->Release();

if (pTileSet2 == pTileSet1)
      lpDDS2=lpDDS1;
   else
   {
      if ((hr=pTileSet2->get_DDSurface(&punk)) != S_OK)
      {
         lpDDS1->Release();
         return Error(_T("DirectDraw surface from TileSet2 not available"), IID_IBMDXDisplay);
      }
      if ((hr=punk->QueryInterface(IID_IDirectDrawSurface, (void **)&lpDDS2)) !=S_OK)
      {
         punk->Release();
         lpDDS1->Release();
         return Error(_T("Could not get DirectDraw surface from TileSet2"), IID_IBMDXDisplay);
      }
      punk->Release();
   }

if ((hr = lpDDS1->Lock(NULL, &ddsd1, DDLOCK_WAIT | DDLOCK_READONLY | DDLOCK_SURFACEMEMORYPTR, 0)) != DD_OK)
   {
      lpDDS1->Release();
      if (lpDDS1 != lpDDS2) lpDDS2->Release();
      if (hr==DDERR_SURFACELOST)
      {
         m_lpDDSPrimary->Restore();
         m_TileSets->Restore();
         return S_OK;
      }
      return Error(_T("Could not lock DirectDraw surface"), IID_IBMDXDisplay);
   }

if (lpDDS1 == lpDDS2)
      ddsd2=ddsd1;
   else
   {
      if ((hr = lpDDS2->Lock(NULL, &ddsd2, DDLOCK_WAIT | DDLOCK_READONLY | DDLOCK_SURFACEMEMORYPTR, 0)) != DD_OK)
      {
         lpDDS1->Unlock(NULL);
         lpDDS1->Release();
         lpDDS2->Release();
         return Error(_T("Could not lock DirectDraw surface on second TileSet"), IID_IBMDXDisplay);
      }
   }

if (DX<0) // If rectangle 2 starts to the left of rectangle 1
   {
      // The horizontal overlap is the lesser of the width of rectangle 1
      // and the portion of rectangle 2 to the right of rectangle 1's left side
      xOverlap=min(Width1, Width2+DX);
   } else { // Otherwise rectangle 1 starts to the left of rectangle 2
      // The horizontal overlap is the lesser of the width of rectangle 2
      // and the portion of rectangle 1 to the right of rectangle 2's left side
      xOverlap=min(Width2, Width1-DX);
   }

if (DY<0) // If rectacle 2 starts above rectangle 1
   {
      // The vertical overlap is the lesser of the height of rectangle 1
      // and the portion of rectangle 2 below the top of rectangle 1
      yOverlap = min(Height1, Height2+DY);
   } else { // Otherwise rectangle 1 starts above rectangle 2
      // The vertical overlap is the lesser of the height of rectangle 2
      // and the portion of rectangle 1 below the top of rectangle 2
      yOverlap = min(Height2, Height1-DY);
   }

if (16 == m_nDepth)
   {
      BGColor1=((short *)(ddsd1.lpSurface))[0];
      BGColor2=((short *)(ddsd2.lpSurface))[0];
   }
   else
   {
//      if (24 == m_nDepth)
//      {
         BGColor1=((DWORD *)(ddsd1.lpSurface))[0] & 0xFFFFFF; // Get first three bytes (24-bits)
         BGColor2=((DWORD *)(ddsd2.lpSurface))[0] & 0xFFFFFF;
//      }
//      else
//      {
//         BGColor1=((DWORD *)(ddsd1.lpSurface))[0];
//         BGColor2=((DWORD *)(ddsd2.lpSurface))[0];
//      }
   }

// For each pixel in the overlap area
   for (y=0; y<yOverlap; y++)
   {
      for(x=0; x<xOverlap; x++)
      {
         // Get the pixel from rectangle 1's source, and get the pixel in
         // rectangle 2's source which would be "above" the first pixel on
         // the destination surface (according to relative positions).
         // If they are both non-background then return TRUE because
         // there has been a collision of two "solid" pixels.
         // x and y represent offsets from the beginning of the overlap area.
         // For instance, if dx is positive, rectangle 2 is to the right, so
         // the pixel retrieved from rectangle 1 is offset by dx since the overlap
         // doesn't start on the left side.  But if dx is negative, the overlap
         // starts at the left side of rectangle 1, but may be offset from the
         // left side of rectangle 2.
         // This assumes that the background color is pure black

if (16 == m_nDepth)
         {
            pb1 = ((BYTE *)(ddsd1.lpSurface)+((Top1+y+max(DY,0))*ddsd1.lPitch+2*(Left1+x+max(DX,0))));
            pb2 = ((BYTE *)(ddsd2.lpSurface)+((Top2+y+max(-DY,0))*ddsd2.lPitch+2*(Left2+x+max(-DX,0))));
            if ((*((WORD *)(pb1)) != LOWORD(BGColor1)) &&
                (*((WORD *)(pb2)) != LOWORD(BGColor2)))
            {
               /*FILE *fp;
               fp=fopen("C:\\windows\\desktop\\tmp.txt","at");
               fprintf(fp,"%X, %X\n",
                        BGColor1, BGColor2);
               fprintf(fp,"%d,%d,%d,%d,%d,%d,%d,%d,%d,%d: %hX, %hX\n",
                        Left1, Top1, Width1, Height1, Left2, Top2, Width2, Height2, DX, DY,
                        *((WORD *)pb1),
                        *((WORD *)pb2)
                      );
               for (y=Top2; y<Top2+Height2; y++)
               {
                  for (x=Left2; x<Left2+Width2; x++)
                     fprintf(fp,"%hX ",*((WORD *)(((byte *)(ddsd2.lpSurface)+y*ddsd2.lPitch+x*2))));
                  fprintf(fp,"\n");
               }
               fclose(fp);*/
               *pResult = TRUE;
               break;
            }
         }
         else
         {
            if(24 == m_nDepth)
            {
               pb1 = ((BYTE *)(ddsd1.lpSurface)+((Top1+y+max(DY,0))*ddsd1.lPitch+3*(Left1+x+max(DX,0))));
               pb2 = ((BYTE *)(ddsd2.lpSurface)+((Top2+y+max(-DY,0))*ddsd2.lPitch+3*(Left2+x+max(-DX,0))));
               if (((*((DWORD *)(pb1)) & 0xFFFFFF) != BGColor1) &&
                   ((*((DWORD *)(pb2)) & 0xFFFFFF) != BGColor2)
                  )
               {
                  *pResult = TRUE;
                  break;
               }
            }
            else
            {
               pb1 = ((BYTE *)(ddsd1.lpSurface)+((Top1+y+max(DY,0))*ddsd1.lPitch+4*(Left1+x+max(DX,0))));
               pb2 = ((BYTE *)(ddsd2.lpSurface)+((Top2+y+max(-DY,0))*ddsd2.lPitch+4*(Left2+x+max(-DX,0))));
               if (((*((DWORD *)(pb1)) & 0xFFFFFF) != BGColor1) &&
                   ((*((DWORD *)(pb2)) & 0xFFFFFF) != BGColor2)
                  )
               {
                  /*FILE *fp;
                  fp=fopen("C:\\windows\\desktop\\tmp.txt","at");
                  fprintf(fp,"%X, %X\n",
                           BGColor1, BGColor2);
                  fprintf(fp,"%d,%d,%d,%d,%d,%d,%d,%d,%d,%d: %X, %X\n",
                           Left1, Top1, Width1, Height1, Left2, Top2, Width2, Height2, DX, DY,
                           *((DWORD *)(pb1)), *((DWORD *)(pb2)));
                  for (y=Top1; y<Top1+Height1; y++)
                  {
                     for (x=Left1; x<Left1+Width1; x++)
                        fprintf(fp,"%X ",(((DWORD *)(ddsd1.lpSurface))[y*ddsd1.lPitch+x]));
                     fprintf(fp,"\n");
                  }
                  fclose(fp);*/
                  *pResult = TRUE;
                  break;
               }
            }
         }
      }
      if (*pResult)
         break;
   }

lpDDS1->Unlock(NULL);
   if (lpDDS2 != lpDDS1)
      lpDDS2->Unlock(NULL);
   lpDDS1->Release();
   if (lpDDS2 != lpDDS1)
      lpDDS2->Release();

return S_OK;
}

STDMETHODIMP CBMDXDisplay::TileHit(IBMDXTileSet * pTileSet1, IBMDXTileSet * pTileSet2, BYTE TileIndex, short Left, short Top, short Width, short Height, short DX, short DY, BOOL * pResult)
{
   short nTileWidth, nTileHeight, nTileCols;
   HRESULT hr;

if (pTileSet1==NULL)
      return Error(_T("Invalid TileSet object"), IID_IBMDXDisplay);

pTileSet1->get_TileWidth(&nTileWidth);
   pTileSet1->get_TileHeight(&nTileHeight);
   if ((hr=pTileSet1->get_TileColumns(&nTileCols)) != S_OK)
      return hr;

return Hit( pTileSet1, pTileSet2,
               (TileIndex % nTileCols) * nTileWidth,
               (TileIndex / nTileCols) * nTileHeight,
               nTileWidth, nTileHeight,
               Left, Top, Width, Height, DX, DY, pResult);
}

STDMETHODIMP CBMDXDisplay::TileHitTile(IBMDXTileSet *pTileSet1, IBMDXTileSet *pTileSet2, short TileIndex1, short TileIndex2, short DX, short DY, BOOL *pResult)
{
   short nTileWidth1, nTileHeight1, nTileCols1;
   short nTileWidth2, nTileHeight2, nTileCols2;
   HRESULT hr;

if (pTileSet1==NULL)
      return Error(_T("First TileSet object invalid"), IID_IBMDXDisplay);

if (pTileSet2==NULL)
      return Error(_T("Second TileSet object invalid"), IID_IBMDXDisplay);

if ((hr=pTileSet1->get_TileColumns(&nTileCols1)) != S_OK)
      return hr;
   if ((hr=pTileSet2->get_TileColumns(&nTileCols2)) != S_OK)
      return hr;

pTileSet1->get_TileWidth(&nTileWidth1);
   pTileSet1->get_TileHeight(&nTileHeight1);
   pTileSet2->get_TileWidth(&nTileWidth2);
   pTileSet2->get_TileHeight(&nTileHeight2);

return Hit( pTileSet1, pTileSet2,
               (TileIndex1 % nTileCols1) * nTileWidth1,
               (TileIndex1 / nTileCols1) * nTileHeight1,
               nTileWidth1, nTileHeight1,
               (TileIndex2 % nTileCols2) * nTileWidth2,
               (TileIndex2 / nTileCols2) * nTileHeight2,
               nTileWidth2, nTileHeight2,
               DX, DY, pResult);
}

STDMETHODIMP CBMDXDisplay::ShowAbout()
{
   HINSTANCE hInst=_Module.GetModuleInstance();
   HWND hDialog;
   HWND hCtl;
   TCHAR buf[40];
   RECT rcCopyright;

hDialog = CreateDialog(hInst, MAKEINTRESOURCE(IDD_ABOUT), NULL, BMDXDlg);
   ShowWindow(hDialog, SW_SHOW);

DoEvents(hDialog);
   
   hCtl=GetDlgItem(hDialog, IDC_COPYRIGHT);
   GetWindowText(hCtl, buf, 40);
   GetWindowRect(hCtl, &rcCopyright);
   if (_tcsnccmp(buf,_T("Copyright © 1998-2005 Ben Marty"),31) || !IsWindowVisible(hCtl) || rcCopyright.right < 130 + rcCopyright.left || rcCopyright.bottom <8+rcCopyright.top)
      return Error(_T("Component has been illegally tampered with.  Contact bluemonkmn@users.sourceforge.net"), IID_IBMDXDisplay);

hCtl=GetDlgItem(hDialog, IDC_EMAIL);
   GetWindowText(hCtl, buf, 40);
   if (_tcsnccmp(buf,_T("email: bluemonkmn@users.sourceforge.net"),39) || !IsWindowVisible(hCtl))
      return Error(_T("Component has been tampered with.  Contact bluemonkmn@users.sourceforge.net"), IID_IBMDXDisplay);

while (IsWindow(hDialog))
      DoEvents(hDialog);
   
   bDialogDisplayed=TRUE;

return S_OK;
}

STDMETHODIMP CBMDXDisplay::CopyRect(IBMDXTileSet * pTileSet, short Left, short Top, short Width, short Height, short X, short Y, short ClipLeft, short ClipTop, short ClipWidth, short ClipHeight, BOOL Transparent)
{
   HRESULT hr;
   IUnknown *punk;
   LPDIRECTDRAWSURFACE lpDDS;
   RECT rcSrc;

if (m_hDCFore || m_hDCBack)
   {
      ReleaseAllDCs();
      return Error(_T("Function not available when DC is locked"), IID_IBMDXDisplay2);
   }

if (!m_lpDDSBack)
      return Error(_T("CopyRect required an open display"), IID_IBMDXDisplay);

if (pTileSet==NULL)
      return E_INVALIDARG;

if ((hr=pTileSet->get_DDSurface(&punk)) != S_OK)
      return Error(_T("DirectDraw surface from TileSet not available"), IID_IBMDXDisplay);

if ((hr=punk->QueryInterface(IID_IDirectDrawSurface, (void **)&lpDDS)) != S_OK)
   {
      punk->Release();
      return Error(_T("Could not get DirectDraw Surface from TileSet"), IID_IBMDXDisplay);
   }

punk->Release();

rcSrc.left=Left;
   rcSrc.top=Top;
   rcSrc.right=Left+Width;
   rcSrc.bottom=Top+Height;

if (X<ClipLeft)
   {
      rcSrc.left+=(ClipLeft-X);
      Width-=(ClipLeft-X);
      X=ClipLeft;
   }
   if (Y<ClipTop)
   {
      rcSrc.top+=(ClipTop-Y);
      Height-=(ClipTop-Y);
      Y=ClipTop;
   }
   if (X+Width>ClipLeft+ClipWidth)
      rcSrc.right-=(Width-(ClipLeft+ClipWidth-X));
   if (Y+Height>ClipTop+ClipHeight)
      rcSrc.bottom-=(Height-(ClipTop+ClipHeight-Y));
   if ((rcSrc.left<rcSrc.right) && (rcSrc.top<rcSrc.bottom))
   {
      if ((hr=m_lpDDSBack->BltFast(X, Y, lpDDS, &rcSrc, DDBLTFAST_WAIT | (Transparent?DDBLTFAST_SRCCOLORKEY:0))) != DD_OK)
      {
         if (hr==DDERR_SURFACELOST)
         {
            m_lpDDSPrimary->Restore();
            m_TileSets->Restore();
         } else {
            lpDDS->Release();
            return hr;
         }
      }
   }

lpDDS->Release();

return S_OK;
}

STDMETHODIMP CBMDXDisplay::HimetricToPixelX(long nHimetric, long * pnPixels)
{
   HRESULT hr;
   HDC hDC;
	int nPixelsPerInchX;    // Pixels per logical inch along width

if (m_lpDDSPrimary == NULL)
      return Error(_T("Display must be open"),IID_IBMDXDisplay);

if (m_hDCFore)
   {
      hDC = m_hDCFore;
   }
   else
   {
      if ((hr=m_lpDDSPrimary->GetDC(&hDC)) != DD_OK)
      {
         return hr;
      }
   }

nPixelsPerInchX = GetDeviceCaps(hDC, LOGPIXELSX);

*pnPixels = MAP_LOGHIM_TO_PIX(nHimetric, nPixelsPerInchX);

if (m_hDCFore == NULL)
   {
      if ((hr = m_lpDDSPrimary->ReleaseDC(hDC)) != DD_OK)
      {
         return hr;
      }
   }

return S_OK;
}

STDMETHODIMP CBMDXDisplay::HimetricToPixelY(long nHimetric, long * pnPixels)
{
   HRESULT hr;
   HDC hDC;
	int nPixelsPerInchY;    // Pixels per logical inch along height

if (m_lpDDSPrimary == NULL)
      return Error(_T("Display must be open"),IID_IBMDXDisplay);

if (m_hDCFore)
   {
      hDC = m_hDCFore;
   }
   else
   {
      if ((hr=m_lpDDSPrimary->GetDC(&hDC)) != DD_OK)
      {
         return hr;
      }
   }

nPixelsPerInchY = GetDeviceCaps(hDC, LOGPIXELSY);

*pnPixels = MAP_LOGHIM_TO_PIX(nHimetric, nPixelsPerInchY);

if (m_hDCFore == NULL)
   {
      if ((hr = m_lpDDSPrimary->ReleaseDC(hDC)) != DD_OK)
      {
         return hr;
      }
   }

return S_OK;
}

STDMETHODIMP CBMDXDisplay::PixelToHimetricX(long nPixels, long * pnHimetric)
{
   HRESULT hr;
   HDC hDC;
	int nPixelsPerInchX;    // Pixels per logical inch along width

if (m_lpDDSPrimary == NULL)
      return Error(_T("Display must be open"),IID_IBMDXDisplay);

if (m_hDCFore)
   {
      hDC = m_hDCFore;
   }
   else
   {
      if ((hr=m_lpDDSPrimary->GetDC(&hDC)) != DD_OK)
      {
         return hr;
      }
   }

nPixelsPerInchX = GetDeviceCaps(hDC, LOGPIXELSX);

*pnHimetric = (nPixels * HIMETRIC_PER_INCH + nPixelsPerInchX/2) / nPixelsPerInchX;

if (m_hDCFore == NULL)
   {
      if ((hr = m_lpDDSPrimary->ReleaseDC(hDC)) != DD_OK)
      {
         return hr;
      }
   }

return S_OK;
}

STDMETHODIMP CBMDXDisplay::PixelToHimetricY(long nPixels, long * pnHimetric)
{
   HRESULT hr;
   HDC hDC;
	int nPixelsPerInchY;    // Pixels per logical inch along height

if (m_lpDDSPrimary == NULL)
      return Error(_T("Display must be open"),IID_IBMDXDisplay);

if (m_hDCFore)
   {
      hDC = m_hDCFore;
   }
   else
   {
      if ((hr=m_lpDDSPrimary->GetDC(&hDC)) != DD_OK)
      {
         return hr;
      }
   }

nPixelsPerInchY = GetDeviceCaps(hDC, LOGPIXELSY);

*pnHimetric = (nPixels * HIMETRIC_PER_INCH + nPixelsPerInchY/2) / nPixelsPerInchY;

if (m_hDCFore == NULL)
   {
      if ((hr = m_lpDDSPrimary->ReleaseDC(hDC)) != DD_OK)
      {
         return hr;
      }
   }

return S_OK;
}

/*void BMDXLog(TCHAR *s, ...)
{
   va_list lst;
   FILE *fp;
   
   va_start(lst, s);

if ((fp=fopen("BMDX.LOG","at")))
   {
      _vftprintf(fp,s,lst);
      fclose(fp);
   }
}*/

STDMETHODIMP CBMDXDisplay::ScreenShot(IDispatch ** ppPicture)
{
   HRESULT hr;
   HDC hDCSrc;
   HDC hDCMem;
   HBITMAP hBmp, hBmpPrev;
   PICTDESC picDesc;

if (m_hDCFore)
   {
      ReleaseAllDCs();
      return Error(_T("Cannot ScreenShot when foreground DC is locked"), IID_IBMDXDisplay2);
   }

if (!m_lpDDSPrimary)
      return Error(_T("Display must be open"), IID_IBMDXDisplay);

if ((hr = m_lpDDSPrimary->GetDC(&hDCSrc)) != DD_OK)
      return hr;

if ((hDCMem = CreateCompatibleDC(hDCSrc)) == NULL)
   {
      m_lpDDSPrimary->ReleaseDC(hDCSrc);
      return Error(_T("Error creating device context"),IID_IBMDXDisplay);
   }

if ((hBmp=CreateCompatibleBitmap(hDCSrc, m_nWidth, m_nHeight)) == NULL)
   {
      DeleteDC(hDCMem);
      m_lpDDSPrimary->ReleaseDC(hDCSrc);
      return Error(_T("Error creating device context"),IID_IBMDXDisplay);
   }

hBmpPrev = (HBITMAP)SelectObject(hDCMem, hBmp);

if ((hr = BitBlt(hDCMem, 0, 0, m_nWidth, m_nHeight, hDCSrc, 0, 0, SRCCOPY)) == 0)
   {
      hBmp = (HBITMAP)SelectObject(hDCMem, hBmpPrev);
      DeleteObject(hBmp);
      DeleteDC(hDCMem);
      m_lpDDSPrimary->ReleaseDC(hDCSrc);
      return Error(_T("Error copying image"),IID_IBMDXDisplay);
   }

picDesc.cbSizeofstruct = sizeof(picDesc);
   picDesc.picType = PICTYPE_BITMAP;
   picDesc.bmp.hbitmap = hBmp;
   picDesc.bmp.hpal = NULL;

hr = OleCreatePictureIndirect(&picDesc, IID_IDispatch, TRUE, (void **)ppPicture);

hBmp = (HBITMAP)SelectObject(hDCMem, hBmpPrev);
   if (hr != S_OK)
      DeleteObject(hBmp);
   DeleteDC(hDCMem);
   m_lpDDSPrimary->ReleaseDC(hDCSrc);

return hr;
}

STDMETHODIMP CBMDXDisplay::ValidateLicense(BSTR License)
{
   WCHAR Buf[50];
   WCHAR ValidLicense[25];
   TCHAR FName[255];
   int Len, FLen;
   int pos;
   TCHAR *FPos;
   TCHAR *FPos2;

if (!GetVerString(L"InternalName", Buf, 50))
      return Error(_T("Program is unlicensable in its current state."),IID_IBMDXDisplay);

Len=wcslen(Buf);
   if (Len==0)
      return Error(_T("Program is unlicensable in its current state."),IID_IBMDXDisplay);

GetModuleFileName(NULL, FName, 255);
   FPos=_tcsrchr(FName,_T('\\'));
   if (!FPos)
      FPos=_tcsrchr(FName, _T(':'));

if(FPos)
   {
      for (FPos++, FPos2=FName; *FPos; *FPos2++=*FPos++);
      *FPos2=0;
   }

for(FPos=FName; *FPos; FPos++)
      *FPos=toupper(*FPos);

for(pos=0; pos<Len; pos++)
      Buf[pos]=toupper(Buf[pos]);

FLen=FPos2-FName;
   
   ValidLicense[24]=0;
   for (pos=0; pos<sizeof(ValidLicense)/sizeof(WCHAR)-1; pos++)
   {
      ValidLicense[pos]=((Len+pos + Buf[pos % Len] + FName[pos % FLen] + Buf[Len-((2*pos)%Len)-1]) % 52) + 65;
      if (ValidLicense[pos]>90) ValidLicense[pos]+=6;
   }

//MessageBoxW(NULL, ValidLicense, L"DEBUG", MB_OK);

if (wcscmp(License, ValidLicense))
	   return E_INVALIDARG;

bDialogDisplayed=TRUE;
   return S_OK;
}

STDMETHODIMP CBMDXDisplay::OpenEx(short nWidth, short nHeight, short nDepth)
{
   m_nWidth = nWidth;
   m_nHeight = nHeight;

if((nDepth != 16) && (nDepth != 24) && (nDepth != 32))
   {
      return Error(_T("BMDXCtls supports only 16-bit, 24-bit and 32-bit color; Depth must be 16, 24 or 32"), IID_IBMDXDisplay2);
   }

m_nDepth = nDepth;

return Open();

}

STDMETHODIMP CBMDXDisplay::GetDC(short nBuffer, long *hDC)
{
   HRESULT hr;

*hDC = 0;

if (!m_lpDDSPrimary)
      return Error(_T("Display must be open"), IID_IBMDXDisplay2);

switch(nBuffer)
   {
   case 0:
      if (m_hDCBack == NULL)
      {
         if (!m_lpDDSBack)
         {
            ReleaseAllDCs();
            return Error(_T("Back buffer not available"), IID_IBMDXDisplay2);
         }
         while ((hr = m_lpDDSBack->GetDC(&m_hDCBack)) != DD_OK)
         {
            if (hr==DDERR_SURFACELOST)
            {
               if (DD_OK != (hr=m_lpDDSPrimary->Restore()))
               {
                  ReleaseAllDCs();
                  return hr;
               }
               m_TileSets->Restore();
            } else {
               ReleaseAllDCs();
               return hr;
            }
         }
      }
      else
      {
         ReleaseAllDCs();
         return Error(_T("Device context was already retrieved"), IID_IBMDXDisplay2);
      }
      *hDC = (long)m_hDCBack;
      break;
   default:
      if (m_hDCFore == NULL)
      {
         while ((hr = m_lpDDSPrimary->GetDC(&m_hDCFore)) != DD_OK)
         {
            if (hr==DDERR_SURFACELOST)
            {
               if (DD_OK != (hr=m_lpDDSPrimary->Restore()))
               {
                  ReleaseAllDCs();
                  return hr;
               }
               m_TileSets->Restore();
            } else {
               ReleaseAllDCs();
               return hr;
            }
         }
      }
      else
      {
         ReleaseAllDCs();
         return Error(_T("Device context was already retrieved"), IID_IBMDXDisplay2);
      }
      *hDC = (long)m_hDCFore;
      break;
   }

return S_OK;
}

STDMETHODIMP CBMDXDisplay::ReleaseDC(short nBuffer)
{
   if (!m_lpDDSPrimary)
      return Error(_T("Display must be open"), IID_IBMDXDisplay2);

switch(nBuffer)
   {
   case 0:
      if (m_hDCBack == NULL)
      {
         ReleaseAllDCs();
         return Error(_T("Background device context was not locked"), IID_IBMDXDisplay2);
      }

// If this fails, there's no handling that would be appropriate!
      m_lpDDSBack->ReleaseDC(m_hDCBack); 
      m_hDCBack = NULL;
      break;
   default:
      if (m_hDCFore == NULL)
      {
         ReleaseAllDCs();
         return Error(_T("Foreground device context was not locked"), IID_IBMDXDisplay2);
      }

// If this fails, there's no handling that would be appropriate!
      m_lpDDSPrimary->ReleaseDC(m_hDCFore); 
      m_hDCFore = NULL;
      break;
   }

return S_OK;
}

void CBMDXDisplay::ReleaseAllDCs()
{
   if (m_hDCFore)
   {
      if (m_lpDDSPrimary)
         m_lpDDSPrimary->ReleaseDC(m_hDCFore);
      m_hDCFore = NULL;
   }

if (m_hDCBack)
   {
      if (m_lpDDSBack)
         m_lpDDSBack->ReleaseDC(m_hDCBack);
      m_hDCBack = NULL;
   }
}

STDMETHODIMP CBMDXDisplay::get_WordWrap(BOOL * pVal)
{
	*pVal = m_bWordWrap;

return S_OK;
}

STDMETHODIMP CBMDXDisplay::put_WordWrap(BOOL newVal)
{
	m_bWordWrap = newVal;

return S_OK;
}

STDMETHODIMP CBMDXDisplay::Restore(BOOL * bWasLost)
{
   HRESULT hr;

if (!m_lpDDSPrimary)
      return Error(_T("Display must be open"), IID_IBMDXDisplay2);

if (m_hDCFore || m_hDCBack)
   {
      ReleaseAllDCs();
      return Error(_T("Function not available when DC is locked"), IID_IBMDXDisplay2);
   }

if (DDERR_SURFACELOST == (hr=m_lpDDSPrimary->IsLost()))
   {
      *bWasLost = TRUE;
      hr = m_lpDDSPrimary->Restore();
      m_TileSets->Restore();
      return hr;
   } else {
      *bWasLost = FALSE;
      return hr;
   }
}

STDMETHODIMP CBMDXDisplay::get_DDSurface(short nBuffer, LPUNKNOWN *pVal)
{
   if (!m_lpDDSPrimary)
      return Error(_T("Display must be open"), IID_IBMDXDisplay3);

switch(nBuffer)
   {
   case 0:
      if (!m_lpDDSBack)
         return Error(_T("Back surface does not exist"), IID_IBMDXDisplay3);
      return m_lpDDSBack->QueryInterface(IID_IUnknown, (void **)pVal);
   case 1:
      return m_lpDDSPrimary->QueryInterface(IID_IUnknown, (void **)pVal);
   default:
      return Error(_T("nBuffer must be 0 (Back) or 1 (Primary)"), IID_IBMDXDisplay3);
   }
}

STDMETHODIMP CBMDXDisplay::FlipToGDISurface()
{
   if (!m_lpDD)
      return Error(_T("Display must be open"), IID_IBMDXDisplay3);

if (m_hDCFore || m_hDCBack)
   {
      ReleaseAllDCs();
      return Error(_T("Function not available when DC is locked"), IID_IBMDXDisplay3);
   }

return m_lpDD->FlipToGDISurface();
}

STDMETHODIMP CBMDXDisplay::get_hWnd(long * pVal)
{
	*pVal = (long)m_hwnd;

return S_OK;
}

STDMETHODIMP CBMDXDisplay::get_ExistingDC(long nBuffer, long * pVal)
{
   switch(nBuffer)
   {
   case 0:
      *pVal = (long)m_hDCBack;
      break;
   case 1:
      *pVal = (long)m_hDCFore;
      break;
   default:
      return Error(_T("nBuffer must be 0 (Back) or 1 (Primary)"), IID_IBMDXDisplay3);
   }

return S_OK;
}

STDMETHODIMP CBMDXDisplay::get_DirectDrawObject(LPUNKNOWN * pVal)
{
   if (!m_lpDD)
      return Error(_T("Display must be open"), IID_IBMDXDisplay3);

return m_lpDD->QueryInterface(IID_IUnknown, (void **)pVal);
}

Scrolling Game Development Kit 1.4.6 (Open Source)

Patching the BMDXCtls.dll to draw properly in widescreen monitors

Original by Ben Marty; Modified by Chongchen Saelee

Corrected Aspect Ratio for 16:10 or 16:9 monitor