【プログラムファイル ddmain.cpp 】

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

LPDIRECTDRAW4 g_pDD = NULL;
LPDIRECTDRAWSURFACE4 g_pDDSPrimary = NULL;
LPDIRECTDRAWSURFACE4 g_pDDSOffScreen = NULL;
LPDIRECTDRAWPALETTE g_pDDPal = NULL;
LPDIRECTDRAWSURFACE4 g_pDDSOne = NULL;
DWORD g_dwEraseColor;
static char *szBitmap = MAKEINTRESOURCE(IDB_BITMAP1);

#define SCREEN_BIT_DEPTH 8



//--------------------------------------------------------
// Name: InitDD()
// ダイレクトドロー を 初期化する。
//--------------------------------------------------------
HRESULT
InitDD(HWND hWnd)
{
DDSURFACEDESC2 ddsd;
HRESULT hRet;
LPDIRECTDRAW pDD;

hRet = DirectDrawCreate(NULL, &pDD, NULL);
if (hRet != DD_OK)
return InitFail(hWnd, hRet, "DirectDrawCreate FAILED");

hRet = pDD->QueryInterface(IID_IDirectDraw4, (LPVOID *) & g_pDD);
if (hRet != DD_OK)
return InitFail(hWnd, hRet, "QueryInterface FAILED");

hRet = pDD->SetCooperativeLevel(hWnd, DDSCL_EXCLUSIVE|DDSCL_FULLSCREEN);
if (hRet != DD_OK)
return InitFail(hWnd, hRet, "SetCooperativeLevel FAILED");

hRet = pDD->SetDisplayMode(640,480,SCREEN_BIT_DEPTH);
if (hRet != DD_OK)
return InitFail(hWnd, hRet, "SetDisplayMode FAILED");

ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS|DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE|DDSCAPS_FLIP|DDSCAPS_COMPLEX;
ddsd.dwBackBufferCount = 1;
hRet = g_pDD->CreateSurface(&ddsd, &g_pDDSPrimary, NULL);
if (hRet != DD_OK)
return InitFail(hWnd, hRet, "CreateSurface FAILED");

DDSCAPS2 ddsc;
ddsc.dwCaps = DDSCAPS_BACKBUFFER;
hRet = g_pDDSPrimary->GetAttachedSurface(&ddsc,&g_pDDSOffScreen);
if (hRet != DD_OK)
return InitFail(hWnd,hRet,"GetAttachedSurface FAILED");

if (SCREEN_BIT_DEPTH > 8){
g_pDDPal=NULL;
}else{
g_pDDPal = DDLoadPalette(g_pDD, szBitmap);
if (g_pDDPal){
g_pDDSPrimary->SetPalette(g_pDDPal);
g_pDDPal->Release();
g_pDDPal=NULL;
}
}

g_dwEraseColor = DDColorMatch(g_pDDSPrimary,
(120<<16)
+(120<<8)
+36);

g_pDDSOne = DDLoadBitmap(g_pDD, szBitmap, 0, 0);
if (g_pDDSOne == NULL)
return InitFail(hWnd, hRet, "DDLoadBitmap FAILED");
return DD_OK;
}



HRESULT InitFail(HWND hWnd, HRESULT hRet, LPCTSTR szError,...)
{

char szBuff[128];
va_list vl;

va_start(vl, szError);
vsprintf(szBuff, szError, vl);
ReleaseDD();
MessageBox(hWnd, szBuff, "Initialization Failed.", MB_OK);
DestroyWindow(hWnd);
va_end(vl);
return hRet;
}



//--------------------------------------------------------
// Name: ReleaseDD()
// すべてのダイレクトドロー Object を Release する。
//--------------------------------------------------------
void ReleaseDD(void)
{
if (g_pDD != NULL)
{
g_pDD->RestoreDisplayMode();
if (g_pDDPal != NULL){
g_pDDPal->Release();
g_pDDPal = NULL;
}
if (g_pDDSOne != NULL)
{
g_pDDSOne->Release();
g_pDDSOne = NULL;
}
if (g_pDDSPrimary != NULL)
{
g_pDDSPrimary->SetPalette(NULL);
g_pDDSPrimary->Release();
g_pDDSPrimary = NULL;
}
g_pDD->Release();
g_pDD = NULL;
}
}


//--------------------------------------------------------
// Name: DDColorPick()
// 指定された座標のカラーデータを読み出す。
//--------------------------------------------------------
static DWORD
DDColorPick(IDirectDrawSurface4 * pdds, int x, int y)
{
DWORD dw = CLR_INVALID;
DDSURFACEDESC2 ddsd;
HRESULT hres;
BYTE *ptr;

ddsd.dwSize = sizeof(ddsd);
while ((hres = pdds->Lock(NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING)
;
if (hres == DD_OK)
{
ptr = (BYTE*)ddsd.lpSurface;
ptr += ddsd.lPitch * y;
ptr += (ddsd.ddpfPixelFormat.dwRGBBitCount / 8) * x;
dw = *(DWORD *)ptr;
if (ddsd.ddpfPixelFormat.dwRGBBitCount < 32)
dw &= (1 << ddsd.ddpfPixelFormat.dwRGBBitCount) - 1;
pdds->Unlock(NULL);
}
return dw;
}



//--------------------------------------------------------
// Name: DDColorKeyFromPoint()
// 指定された座標のカラーで、カラーキーを設定する。
//--------------------------------------------------------
extern "C" HRESULT
DDSetColorKeyFromPoint(IDirectDrawSurface4 * pdds, int x, int y)
{
DDCOLORKEY ddck;
ddck.dwColorSpaceLowValue = DDColorPick(pdds, x, y);
ddck.dwColorSpaceHighValue = ddck.dwColorSpaceLowValue;
return pdds->SetColorKey(DDCKEY_SRCBLT, &ddck);
}



//---------------------------------------------------------
// Name: DDColorKey()
// サーフェイスに対してカラーキーを設定します
// 引数は、RGB 形式で渡す。
//---------------------------------------------------------
extern "C" HRESULT
DDSetColorKey(IDirectDrawSurface4 * pdds, COLORREF rgb)
{
DDCOLORKEY ddck;

ddck.dwColorSpaceLowValue = DDColorMatch(pdds, rgb);
ddck.dwColorSpaceHighValue = ddck.dwColorSpaceLowValue;
return pdds->SetColorKey(DDCKEY_SRCBLT, &ddck);
}



//---------------------------------------------------
// Name: DDColorMatch()
// 論理的に指定されたカラーコード(RGB形式)を、
// ビデオメモリ上のカラーコードに変換する。
//---------------------------------------------------
extern "C" DWORD
DDColorMatch(IDirectDrawSurface4 * pdds, COLORREF rgb)
{
COLORREF rgbT;
HDC hdc;
DWORD dw = CLR_INVALID;
DDSURFACEDESC2 ddsd;
HRESULT hres;

if (rgb != CLR_INVALID && pdds->GetDC(&hdc) == DD_OK)
{
rgbT = GetPixel(hdc, 0, 0);
SetPixel(hdc, 0, 0, rgb);
pdds->ReleaseDC(hdc);
}
ddsd.dwSize = sizeof(ddsd);
while ((hres = pdds->Lock(NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING)
;
if (hres == DD_OK)
{
dw = *(DWORD *) ddsd.lpSurface;
if (ddsd.ddpfPixelFormat.dwRGBBitCount < 32)
dw &= (1 << ddsd.ddpfPixelFormat.dwRGBBitCount) - 1;
pdds->Unlock(NULL);
}
if (rgb != CLR_INVALID && pdds->GetDC(&hdc) == DD_OK)
{
SetPixel(hdc, 0, 0, rgbT);
pdds->ReleaseDC(hdc);
}
return dw;
}



//---------------------------------------------
// Name: RestoreAll()
// タスクスイッチングなどで、サーフェイスが
// 失われた場合に、それを復帰させる。
//---------------------------------------------
BOOL
RestoreAll(void)
{
BOOL bRet;
bRet = g_pDDSPrimary->Restore() == DD_OK &&
g_pDDSOffScreen->Restore() == DD_OK &&
DDReLoadBitmap(g_pDDSOne, szBitmap) == DD_OK;
IgnoreTime();
return bRet;
}



//----------------------------------------------------------
// Name: DDLoadBitmap()
// DirectDraw サーフェイスを作成して、
// リソースもしくは、bmpファイルから、ビットマップを
// 読み込む。
//----------------------------------------------------------
extern "C" IDirectDrawSurface4 *
DDLoadBitmap(IDirectDraw4 * pdd, LPCSTR szBitmap, int dx, int dy)
{
HBITMAP hbm;
BITMAP bm;
DDSURFACEDESC2 ddsd;
IDirectDrawSurface4 *pdds;

hbm = (HBITMAP) LoadImage(GetModuleHandle(NULL), szBitmap, IMAGE_BITMAP, dx,
dy, LR_CREATEDIBSECTION);
if (hbm == NULL)
hbm = (HBITMAP) LoadImage(NULL, szBitmap, IMAGE_BITMAP, dx, dy,
LR_LOADFROMFILE | LR_CREATEDIBSECTION);
if (hbm == NULL)
return NULL;
GetObject(hbm, sizeof(bm), &bm);
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_SYSTEMMEMORY;
ddsd.dwWidth = bm.bmWidth;
ddsd.dwHeight = bm.bmHeight;
if (pdd->CreateSurface(&ddsd, &pdds, NULL) != DD_OK)
return NULL;
DDCopyBitmap(pdds, hbm, 0, 0, 0, 0);
DeleteObject(hbm);
return pdds;
}



//----------------------------------------------------------
// Name: DDReLoadBitmap()
// 指定されたサーフェイスに対して、
// リソースもしくは、bmpファイルから、ビットマップを
// 読み込む。
//----------------------------------------------------------
HRESULT
DDReLoadBitmap(IDirectDrawSurface4 * pdds, LPCSTR szBitmap)
{
HBITMAP hbm;
HRESULT hr;

hbm = (HBITMAP) LoadImage(GetModuleHandle(NULL), szBitmap, IMAGE_BITMAP, 0,
0, LR_CREATEDIBSECTION);
if (hbm == NULL)
hbm = (HBITMAP) LoadImage(NULL, szBitmap, IMAGE_BITMAP, 0, 0,
LR_LOADFROMFILE | LR_CREATEDIBSECTION);
if (hbm == NULL)
{
return E_FAIL;
}
hr = DDCopyBitmap(pdds, hbm, 0, 0, 0, 0);
DeleteObject(hbm);
return hr;
}



//----------------------------------------------------------
// Name: DDCopyBitmap()
// システムメモリ上のビットマップを、
// DirectDrawSurace へコピーする。
//----------------------------------------------------------
extern "C" HRESULT
DDCopyBitmap(IDirectDrawSurface4 * pdds, HBITMAP hbm, int x, int y,
int dx, int dy)
{
HDC hdcImage;
HDC hdc;
BITMAP bm;
DDSURFACEDESC2 ddsd;
HRESULT hr;

if (hbm == NULL || pdds == NULL)
return E_FAIL;
pdds->Restore();
hdcImage = CreateCompatibleDC(NULL);
SelectObject(hdcImage, hbm);
GetObject(hbm, sizeof(bm), &bm);
dx = dx == 0 ? bm.bmWidth : dx;
dy = dy == 0 ? bm.bmHeight : dy;
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_HEIGHT | DDSD_WIDTH;
pdds->GetSurfaceDesc(&ddsd);

if ((hr = pdds->GetDC(&hdc)) == DD_OK)
{
StretchBlt(hdc, 0, 0, ddsd.dwWidth, ddsd.dwHeight, hdcImage, x, y,
dx, dy, SRCCOPY);
pdds->ReleaseDC(hdc);
}
DeleteDC(hdcImage);
return hr;
}



extern "C" IDirectDrawPalette *
DDLoadPalette(IDirectDraw4 * pdd, LPCSTR szBitmap)
{
IDirectDrawPalette *ddpal;
int i;
int n;
HANDLE fh;
HRSRC h;
LPBITMAPINFOHEADER lpbi;
PALETTEENTRY ape[256];
RGBQUAD *prgb;

for (i = 0; i < 256; i++)
{
ape[i].peRed = (BYTE) (((i >> 5) & 0x07) * 255 / 7);
ape[i].peGreen = (BYTE) (((i >> 2) & 0x07) * 255 / 7);
ape[i].peBlue = (BYTE) (((i >> 0) & 0x03) * 255 / 3);
ape[i].peFlags = (BYTE) 0;
}
if (szBitmap && (h = FindResource(NULL, szBitmap, RT_BITMAP)))
{
lpbi = (LPBITMAPINFOHEADER) LockResource(LoadResource(NULL, h));
prgb = (RGBQUAD *) ((BYTE *) lpbi + lpbi->biSize);
if (lpbi == NULL || lpbi->biSize < sizeof(BITMAPINFOHEADER))
n = 0;
else if (lpbi->biBitCount > 8)
n = 0;
else if (lpbi->biClrUsed == 0)
n = 1 << lpbi->biBitCount;
else
n = lpbi->biClrUsed;
for (i = 0; i < n; i++)
{
ape[i].peRed = prgb[i].rgbRed;
ape[i].peGreen = prgb[i].rgbGreen;
ape[i].peBlue = prgb[i].rgbBlue;
ape[i].peFlags = 0;
}
}
else if (szBitmap &&
INVALID_HANDLE_VALUE !=
(fh = CreateFile(
szBitmap,GENERIC_READ,0,NULL,OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN,NULL))
)
{
BITMAPFILEHEADER bf;
BITMAPINFOHEADER bi;
DWORD br;
ReadFile(fh,(void*)&bf,sizeof(bf),&br,NULL);
ReadFile(fh,(void*)&bi,sizeof(bi),&br,NULL);
ReadFile(fh,(void*)ape,sizeof(ape),&br,NULL);
CloseHandle(fh);
if (bi.biSize != sizeof(BITMAPINFOHEADER))
n = 0;
else if (bi.biBitCount > 8)
n = 0;
else if (bi.biClrUsed == 0)
n = 1 << bi.biBitCount;
else
n = bi.biClrUsed;
for (i = 0; i < n; i++)
{
BYTE r = ape[i].peRed;
ape[i].peRed = ape[i].peBlue;
ape[i].peBlue = r;
}
}
pdd->CreatePalette(DDPCAPS_8BIT, ape, &ddpal, NULL);
return ddpal;
}