//------------------------------------------------------------
// Name: Initiate
// Desc: Init everything
//------------------------------------------------------------
int Initiate()
{
// create dd object and test for an error
hr = DirectDrawCreate(NULL,&lpdd,NULL);
if (DDFailedCheck(hr, "DirectDrawCreate failed", cpErrorBuf ))
return 0;
// set cooperation level to windowed mode normal
hr = lpdd->SetCooperativeLevel(main_window_handle, DDSCL_ALLOWMODEX | DDSCL_FULLSCREEN |
DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT );
if (DDFailedCheck(hr, "SetCooperativeLevel", cpErrorBuf ))
return 0;
// set the display mode. use this for full screen programs
hr = lpdd->SetDisplayMode(WINDOW_WIDTH ,WINDOW_HEIGHT,16);
if (DDFailedCheck(hr, "SetDisplayMode", cpErrorBuf ))
return 0;
// Create the primary surface
memset(&ddsd,0,sizeof(ddsd));//clear ddsd structure
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
hr = lpdd->CreateSurface(&ddsd,&lpddsprimary,NULL);
if (DDFailedCheck(hr, "CreateSurface", cpErrorBuf ))
return 0;
// return success
return(1);
}//End Initiate
BOOL WINAPI DDEnumDevCallback(GUID FAR *lpGUID, LPSTR lpDriverDescription, LPSTR lpDriverName, LPVOID lpContext, HMONITOR hm)
{
LPDIRECTDRAW ddp;
LPDIRECTDRAW4 dd4p;
DDDEVICEIDENTIFIER ddDev;
BOOL ret = FALSE;
if (DirectDrawCreate(lpGUID,&ddp,0) == DD_OK)
{
if(ddp->QueryInterface(IID_IDirectDraw4,(void **)&dd4p) == S_OK)
{
ZeroMemory(&ddDev,sizeof(ddDev));
if(GetDeviceIdentifierEx(dd4p,&ddDev, DDGDI_GETHOSTIDENTIFIER) == DD_OK)
{
// add to table
USES_CONVERSION;
CUtilGPU::AddDisplayDevice(A2CT(lpDriverName), ddDev.dwVendorId, ddDev.dwDeviceId, ddDev.szDescription, ddDev.szDriver);
ret = TRUE;
}
dd4p->Release();
}
ddp->Release();
}
return ret;
}
HRESULT CUtilGPU::QueryVideoMemorySize(DWORD dwCaps, DWORD* pdwTotalMem, DWORD* pdwFreeMem)
{
LPDIRECTDRAW lpdd = NULL;
HRESULT hr = DirectDrawCreate(NULL, &lpdd, NULL);
if(SUCCEEDED(hr))
{
LPDIRECTDRAW7 lpdd7 = NULL;
hr = lpdd->QueryInterface(IID_IDirectDraw7, (LPVOID*)&lpdd7);
if(SUCCEEDED(hr))
{
DDSCAPS2 ddsCaps2;
DWORD dwTotal=0, dwFree=0;
// Initialize the structure.
ZeroMemory(&ddsCaps2, sizeof(ddsCaps2));
ddsCaps2.dwCaps = dwCaps;
hr = lpdd7->GetAvailableVidMem(&ddsCaps2, &dwTotal, &dwFree);
if(SUCCEEDED(hr))
{
if(pdwTotalMem)
*pdwTotalMem =(dwTotal>>20); //rounded to MB
if(pdwFreeMem)
*pdwFreeMem = (dwFree>>20); //rounded to MB
}
lpdd7->Release();
}
lpdd->Release();
}
return hr;
}
static vmResult win32ddraw_init(void)
{
LPDIRECTDRAW oldDraw;
int ret;
int x;
if (!win_registerDirectDrawWindowClass(myHInst, myHPreInst) ||
!win_createDirectDrawWindows(myHInst, mynCmdShow))
return vmInternalError;
// log("init\n");
for (x=0; x<16; x++)
win_rgbmap[x]=x;
win_rgbmap[16] = 15;
/* DirectDraw initialization */
ret = DirectDrawCreate((GUID *)NULL, &oldDraw, NULL);
if (ret != DD_OK)
DDFAIL("DirectDrawCreate", ret);
if (!SUCCEEDED(oldDraw->QueryInterface(IID_IDirectDraw2,
reinterpret_cast<void**>(&lpDD))))
DDFAIL("QueryInterface", -1);
// --
features|=FE_SHOWVIDEO|FE_VIDEO;
return vmOk;
}
/*
* Helpers.
*/
static LPDIRECTDRAW7 getDDRAW (void)
{
LPDIRECTDRAW7 pDDRAW = NULL;
LPDIRECTDRAW iface = NULL;
HRESULT rc = DirectDrawCreate (NULL, &iface, NULL);
if (rc != DD_OK)
{
LOGDDRAW(("DDRAW: Could not create DirectDraw interface rc= 0x%08X\n", rc));
}
else
{
rc = iface->QueryInterface (IID_IDirectDraw7, (void**)&pDDRAW);
if (rc != DD_OK)
{
LOGDDRAW(("DDRAW: Could not query DirectDraw 7 interface rc = 0x%08X\n", rc));
}
else
{
rc = pDDRAW->SetCooperativeLevel (NULL, DDSCL_NORMAL);
if (rc != DD_OK)
{
LOGDDRAW(("DDRAW: Could not set the DirectDraw cooperative level rc = 0x%08X\n", rc));
pDDRAW->Release ();
}
}
iface->Release();
}
return rc == DD_OK? pDDRAW: NULL;
}
HRESULT DDVideo::InitDirectDraw()
{
DDSURFACEDESC2 ddsd;
DDSCAPS2 ddscaps;
HRESULT hRet;
//Create the main DirectDraw object - updated to do it the hard way.... 7/10
LPDIRECTDRAW pDD;
HINSTANCE hInstDDraw;
LPDIRECTDRAWCREATE pDDCreate = NULL;
hInstDDraw = LoadLibrary("ddraw.dll");
pDDCreate = ( LPDIRECTDRAWCREATE )GetProcAddress( hInstDDraw, "DirectDrawCreate" );
pDDCreate( NULL, &pDD, NULL );
//hRet = DirectDrawCreate(NULL,&pDD, NULL);
hRet = pDD->QueryInterface(IID_IDirectDraw7, (LPVOID *) & m_lpDD);
//Set cooperative level
if (m_bWindowed) { //#112
m_lpDD->SetCooperativeLevel(m_hWnd, DDSCL_ALLOWREBOOT | DDSCL_NORMAL | DDSCL_MULTITHREADED);
} else {
hRet = m_lpDD->SetCooperativeLevel(m_hWnd,DDSCL_EXCLUSIVE |DDSCL_ALLOWREBOOT| DDSCL_ALLOWMODEX | DDSCL_FULLSCREEN | DDSCL_MULTITHREADED);
m_lpDD->SetDisplayMode(800,600,16,g_DX9Settings.m_refreshrate,0);
}
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
//#112
ddsd.dwFlags = (m_bWindowed) ? DDSD_CAPS : DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps = (m_bWindowed) ? DDSCAPS_PRIMARYSURFACE : DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
if (m_bWindowed) {
LPDIRECTDRAWCLIPPER lpClipper;
hRet = m_lpDD->CreateSurface(&ddsd, &m_lpDDSPrimary, NULL);
hRet = m_lpDD->CreateClipper( 0, &lpClipper, NULL );
hRet = lpClipper->SetHWnd( 0, m_hWnd );
hRet = m_lpDDSPrimary->SetClipper( lpClipper );
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
ddsd.dwWidth = 800;
ddsd.dwHeight = 600;
hRet = m_lpDD->CreateSurface(&ddsd, &m_lpDDSBack, NULL);
} else {
ddsd.dwBackBufferCount = 1;
hRet = m_lpDD->CreateSurface(&ddsd, &m_lpDDSPrimary, NULL);
ZeroMemory( &ddscaps, sizeof( ddscaps ) );
ddscaps.dwCaps=DDSCAPS_BACKBUFFER;
hRet = m_lpDDSPrimary->GetAttachedSurface(&ddscaps,&m_lpDDSBack);
}
pDD->Release();
return hRet;
}
extern "C" DLL void rglDDrawActivate(unsigned char active)
{
HRESULT rval;
if (WINDOWED || lpDD == NULL)
{
return;
}
if (active)
{
if (!bActive)
{
for (;;)
{
rval = lpDD->SetDisplayMode(SCRWIDTH, SCRHEIGHT, 16);
if (rval == DD_OK)
{
break;
}
if (rval == DDERR_SURFACELOST)
{
if (!restoreAll())
{
break;
}
}
}
bActive = TRUE;
}
}
else
{
if (bActive)
{
for (;;)
{
rval = lpDD->RestoreDisplayMode();
if (rval == DD_OK)
{
break;
}
if (rval == DDERR_SURFACELOST)
{
if (!restoreAll())
{
break;
}
}
}
bActive = FALSE;
}
}
}
~WSurfaceData() {
if (clipper) clipper->Release();
if (LeftBuffer) ((LPDIRECTDRAWSURFACE)LeftBuffer)->Release();
if (RightBuffer) ((LPDIRECTDRAWSURFACE)RightBuffer)->Release();
if (screen) screen->Release();
if (ddraw) {
if (!window_mode)
ddraw->RestoreDisplayMode();
ddraw->Release();
}
LeftBuffer=RightBuffer=0;
ddraw=0,screen=0;
}
int DDInitFullscreen(int width, int height, int bpp, HWND hwnd)
{
HRESULT ret;
// create object and test for error
if (DirectDrawCreate(NULL, &lpDD, NULL) != DD_OK) {
return(0);
}
// set cooperation level to windowed mode normal
if (lpDD->SetCooperativeLevel(hwnd, DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE) != DD_OK) {
return(0);
}
// set the display mode
if (lpDD->SetDisplayMode(width, height, bpp) != DD_OK) {
return(0);
}
// set globals
screen_height = height;
screen_width = width;
screen_bpp = bpp;
// Create the primary surface
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
// we need to let dd know that we want a complex
// flippable surface structure, set flags for that
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
// set the backbuffer count to 1
ddsd.dwBackBufferCount = 1;
// create the primary surface
ret = lpDD->CreateSurface(&ddsd, &lpDDSPrimary, NULL);
// query for the backbuffer i.e the secondary surface
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
lpDDSPrimary->GetAttachedSurface(&ddscaps, &lpDDSBack);
// clear out both primary and secondary surfaces
DDFillSurface(lpDDSPrimary, 0);
DDFillSurface(lpDDSBack, 0);
DDGetRGB16();
return 1;
}
//-----------------------------------------------------------------------------
HRESULT GetVideoMemoryViaDirectDraw( HMONITOR hMonitor, DWORD* pdwAvailableVidMem )
{
LPDIRECTDRAW pDDraw = nullptr;
LPDIRECTDRAWENUMERATEEXA pDirectDrawEnumerateEx = nullptr;
HRESULT hr;
bool bGotMemory = false;
*pdwAvailableVidMem = 0;
HINSTANCE hInstDDraw;
LPDIRECTDRAWCREATE pDDCreate = nullptr;
hInstDDraw = LoadLibrary( L"ddraw.dll" );
if( hInstDDraw )
{
DDRAW_MATCH match = {};
match.hMonitor = hMonitor;
pDirectDrawEnumerateEx = ( LPDIRECTDRAWENUMERATEEXA )GetProcAddress( hInstDDraw, "DirectDrawEnumerateExA" );
if( pDirectDrawEnumerateEx )
{
hr = pDirectDrawEnumerateEx( DDEnumCallbackEx, ( VOID* )&match, DDENUM_ATTACHEDSECONDARYDEVICES );
}
pDDCreate = ( LPDIRECTDRAWCREATE )GetProcAddress( hInstDDraw, "DirectDrawCreate" );
if( pDDCreate )
{
pDDCreate( &match.guid, &pDDraw, nullptr );
LPDIRECTDRAW7 pDDraw7;
if( SUCCEEDED( pDDraw->QueryInterface( IID_IDirectDraw7, ( VOID** )&pDDraw7 ) ) )
{
DDSCAPS2 ddscaps = {};
ddscaps.dwCaps = DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM;
hr = pDDraw7->GetAvailableVidMem( &ddscaps, pdwAvailableVidMem, nullptr );
if( SUCCEEDED( hr ) )
bGotMemory = true;
pDDraw7->Release();
}
}
FreeLibrary( hInstDDraw );
}
if( bGotMemory )
return S_OK;
else
return E_FAIL;
}
BOOL InitDDraw()
{
DDSURFACEDESC ddsd;
HRESULT ddrval;
DirectDrawCreate(NULL, &lpDD, NULL);//产生一个DDRAW对象。
/*第一个参数是要创建的驱动类型，设为NULL，表示使用当前的显示驱动
第三个参数用于今后与COM对象兼容，目前都设为NULL*/
lpDD->SetCooperativeLevel (hWnd, DDSCL_NORMAL);//设置协作级别
ZeroMemory( &ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS;
/*主页面的大小和像素格式都是由当前的显示模式决定的，
所以不能指定，否则发生错误*/
ddsd.ddsCaps .dwCaps = DDSCAPS_PRIMARYSURFACE;
ddrval = lpDD->CreateSurface (&ddsd, &lpDDSPrimary, NULL);
/*第三个参数也是用于与COM对象兼容，目前只能设为NULL*/
if(ddrval != DD_OK)
{
return FALSE;
}
ZeroMemory( &ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS| DDSD_HEIGHT| DDSD_WIDTH;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
ddsd.dwHeight = 600;
ddsd.dwWidth = 800;
/*页面的大小可以和实际图片大小不一样，但会产生失真*/
RectTemp.left = 0;
RectTemp.top = 0;
RectTemp.right = ddsd.dwWidth;
RectTemp.bottom = ddsd.dwHeight;
lpDD->CreateSurface (&ddsd, &lpDDSTemp, NULL);
if(ddrval != DD_OK)
{
return FALSE;
}
DDReLoadBitmap( lpDDSTemp, "gameover.bmp");
return TRUE;
}
void DDShutdown(void)
{
// release clipper
if (lpDDClipper) {
lpDDClipper->Release();
lpDDClipper = NULL;
}
// release the secondary surface
if (lpDDSBack) {
lpDDSBack->Release();
lpDDSBack = NULL;
}
// release the primary surface
if (lpDDSPrimary) {
lpDDSPrimary->Release();
lpDDSPrimary = NULL;
}
// finally, the main dd object
if (lpDD) {
lpDD->Release();
lpDD = NULL;
}
}
LPDIRECTDRAWSURFACE DDCreateSurface(int width, int height, int mem_flags)
{
DDSURFACEDESC ddsd; // working description
LPDIRECTDRAWSURFACE lpdds; // temporary surface
// set to access caps, width, and height
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
// set dimensions of the new bitmap surface
ddsd.dwWidth = width;
ddsd.dwHeight = height;
// set surface to offscreen plain
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | mem_flags;
// create the surface
if (lpDD->CreateSurface(&ddsd, &lpdds, NULL) != DD_OK) {
return(NULL);
}
// return surface
return(lpdds);
}
static void finiObjects(BOOL freeDD)
{
if (!bActive)
{
return;
}
if (lpDD != NULL)
{
if (PrimarySurface != NULL)
{
PrimarySurface->Release();
PrimarySurface = NULL;
}
if (BackSurface != NULL)
{
BackSurface->Release();
BackSurface = NULL;
}
if (freeDD)
{
lpDD->Release();
lpDD = NULL;
}
}
}
/*
* DDLoadBitmap:
* create a DirectDrawSurface from a bitmap resource.
*/
LPDIRECTDRAWSURFACE DDLoadBitmap(LPCSTR szBitmap, int dx, int dy)
{
HBITMAP hbm;
BITMAP bm;
DDSURFACEDESC ddsd;
IDirectDrawSurface *pdds;
hbm = (HBITMAP)LoadImage(NULL, szBitmap, IMAGE_BITMAP, dx, dy, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
if (hbm == NULL) {
return NULL;
}
// get size of the bitmap
GetObject(hbm, sizeof(bm), &bm); // get size of bitmap
// create a DirectDrawSurface for this bitmap
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
ddsd.dwWidth = bm.bmWidth;
ddsd.dwHeight = bm.bmHeight;
if (lpDD->CreateSurface(&ddsd, &pdds, NULL) != DD_OK) {
return NULL;
}
DDCopyBitmap(pdds, hbm, 0, 0, 0, 0);
DeleteObject(hbm);
return pdds;
}
static void
ReleaseAllObjects(void)
{
if (g_pDDSBack != NULL)
{
g_pDDSBack->Release();
g_pDDSBack = NULL;
}
if (g_pDDSPrimary != NULL)
{
g_pDDSPrimary->Release();
g_pDDSPrimary = NULL;
}
if (g_pDDSOne != NULL)
{
g_pDDSOne->Release();
g_pDDSOne = NULL;
}
if (g_pDDSTwo != NULL)
{
g_pDDSTwo->Release();
g_pDDSTwo = NULL;
}
if (g_pDD != NULL)
{
g_pDD->Release();
g_pDD = NULL;
}
}
static gxj_pixel_type*
startDirectPaint(int &dstWidth, int &dstHeight, int &dstYPitch) {
gxj_pixel_type *dst = NULL;
#if JWC_WINCE_USE_DIRECT_DRAW
if (isScreenRotated() || !isScreenFullyVisible() || editBoxShown) {
/* DDraw is not very reliable on an rotated screen. Use GDI instead. */
return NULL;
}
if (g_pDD == NULL) {
/* DirectDraw failed to initialize. Let's use GDI to Blit to the LCD. */
return NULL;
}
HRESULT hRet;
DDSURFACEDESC surfaceDesc;
DDSURFACEDESC ddsd;
if (g_pDDSPrimary == NULL) {
/* Create the primary surface with 0 back buffer */
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE ;
hRet = g_pDD->CreateSurface(&ddsd, &g_pDDSPrimary, NULL);
if (hRet != DD_OK) {
g_pDDSPrimary = NULL;
return NULL;
}
}
surfaceDesc.dwSize = sizeof(surfaceDesc);
hRet = g_pDDSPrimary->Lock(NULL, &surfaceDesc,
DDLOCK_DISCARD | DDLOCK_WRITEONLY, NULL);
if (hRet == DD_OK) {
dst = (gxj_pixel_type*)surfaceDesc.lpSurface;
dstWidth = surfaceDesc.dwWidth;
dstHeight = surfaceDesc.dwHeight;
dstYPitch = surfaceDesc.lPitch;
} else {
/* Release the DD resources. Maybe we'd get lucky and can allocate
* it next time.
*/
g_pDDSPrimary->Release();
g_pDDSPrimary = NULL;
return NULL;
}
#else
if (editBoxShown) {
return NULL;
}
dstWidth = gxDispProps.cxWidth;
dstHeight = gxDispProps.cyHeight;
dstYPitch = gxDispProps.cbyPitch;
dst = (gxj_pixel_type*)GXBeginDraw();
#endif
return dst;
}
HRESULT
CVWRenderRoot::CreateBackBuffer(LPDIRECTDRAW pdd, int cx, int cy, VARIANT_BOOL bUseHWAcceleration, IDirectDrawSurface **ppddsBackBuffer)
{
DDSURFACEDESC ddsd;
// it would be bad to try and create a zero-sized backbuffer
if (cx <= 0)
cx = 1;
if (cy <= 0)
cy = 1;
// Create a back buffer.
HRESULT hRes;
memset(&ddsd,0,sizeof(DDSURFACEDESC));
ddsd.dwSize = sizeof( ddsd );
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.dwWidth = cx;
ddsd.dwHeight = cy;
if (bUseHWAcceleration)
ddsd.ddsCaps.dwCaps = DDSCAPS_3DDEVICE | DDSCAPS_VIDEOMEMORY;
else
ddsd.ddsCaps.dwCaps = DDSCAPS_3DDEVICE | DDSCAPS_SYSTEMMEMORY;
hRes = pdd->CreateSurface( &ddsd, ppddsBackBuffer, NULL );
if (FAILED(hRes))
return hRes;
//
// attach the palette if one exists
//
if (m_pPalette && FAILED(hRes = (*ppddsBackBuffer)->SetPalette(m_pPalette)))
return hRes;
return S_OK;
}
// Direct3D 생성
BOOL CreateD3D()
{
// DirectDraw 인터페이스 생성
LPDIRECTDRAW lpdd;
// 설정된 DirectDraw Device
HRESULT hresult = DirectDrawCreate( NULL, &lpdd, NULL );
if ( hresult != DD_OK )
{
MESSAGE( "DirectDrawCreate" );
return FALSE;
}
// DirectDraw2 인터페이스 얻기
hresult = lpdd->QueryInterface( IID_IDirectDraw4, (LPVOID*)&lpDD );
if ( hresult != DD_OK )
{
MESSAGE( "lpdd->QueryInterface" );
return FALSE;
}
// DirectDraw 인터페이스 제거
lpdd->Release();
// Direct3D 인터페이스 얻기
hresult = lpDD->QueryInterface( IID_IDirect3D3, (LPVOID*)&lpD3D );
if ( hresult != DD_OK )
{
MESSAGE( "lpDD3->QueryInterface" );
return FALSE;
}
// Direct3D Device 인터페이스 얻기
hresult = lpD3D->EnumDevices( DeviceEnumCallback, (LPVOID)&lpDeviceDesc );
if ( hresult != DD_OK )
{
MESSAGE( "lpD3D->EnumDevices" );
return FALSE;
}
lpD3DDeviceDesc = FindBestDevice( lpDeviceDesc );
if ( !lpD3DDeviceDesc )
return FALSE;
return TRUE;
}
BOOL mfc_render_init(HWND hWnd)
{
DDSURFACEDESC ddsd;
DDCAPS ddcaps;
HRESULT hRet;
///////////////////////////////////////////////////////////////////////////
// Create the main DirectDraw object
///////////////////////////////////////////////////////////////////////////
hRet = DirectDrawCreate(NULL, &g_pDD, NULL);
if (hRet != DD_OK)
return PRINT_ERRMSG(TEXT("DirectDrawCreate FAILED"));
// Get exclusive mode
hRet = g_pDD->SetCooperativeLevel(hWnd, DDSCL_NORMAL);
if (hRet != DD_OK)
return PRINT_ERRMSG(TEXT("SetCooperativeLevel FAILED"));
// Get a primary surface interface pointer (only needed for init.)
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
hRet = g_pDD->CreateSurface(&ddsd, &g_pDDSPrimary, NULL);
if (hRet != DD_OK)
return PRINT_ERRMSG(TEXT("CreateSurface FAILED"));
// See if we can support overlays.
memset(&ddcaps, 0, sizeof(ddcaps));
ddcaps.dwSize = sizeof(ddcaps);
hRet = g_pDD->GetCaps(&ddcaps, NULL);
if (hRet != DD_OK)
return PRINT_ERRMSG(TEXT("GetCaps FAILED"));
if (ddcaps.dwOverlayCaps == 0)
return PRINT_ERRMSG(TEXT("Overlays are not supported in hardware!"));
// SW YUV->RGB conversion table initialization
_initConvTab();
return TRUE;
}
int DDInitWindowed(int width, int height, int bpp, HWND hwnd)
{
HRESULT ret;
// create object and test for error
if (DirectDrawCreate(NULL, &lpDD, NULL) != DD_OK) {
return(0);
}
// set cooperation level to windowed mode normal
if (lpDD->SetCooperativeLevel(hwnd, DDSCL_NORMAL) != DD_OK) {
return(0);
}
// set globals
screen_height = height;
screen_width = width;
screen_bpp = bpp;
// Create the primary surface
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS;
// all we need for windowed mode is access to the primary surface
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
// create the primary surface
ret = lpDD->CreateSurface(&ddsd, &lpDDSPrimary, NULL);
// create an offscreen and system mem back surface
lpDDSBack = DDCreateSurface(width, height, NULL);
lpDD->CreateClipper(0, &lpDDClipper, NULL);
lpDDClipper->SetHWnd(0, hwnd);
lpDDSPrimary->SetClipper(lpDDClipper);
// clear out both primary and secondary surfaces
DDFillSurface(lpDDSPrimary, 0);
DDFillSurface(lpDDSBack, 0);
DDGetRGB16();
return 1;
}
static void init_DirectDraw() {
/**
* Note: if DirectDraw fails to initialize, we will use GDI to
* draw to do the screenBuffer->LCD copying.
*/
HRESULT hRet;
hRet = DirectDrawCreate(NULL, &g_pDD, NULL);
if (hRet != DD_OK) {
return;
}
hRet = g_pDD->SetCooperativeLevel(hwndMain, DDSCL_NORMAL);
if (hRet != DD_OK) {
g_pDD->Release();
g_pDD = NULL;
return;
}
wince_init_fonts();
}
PRBool
nsWindowGfx::InitDDraw()
{
HRESULT hr;
hr = DirectDrawCreate(NULL, &glpDD, NULL);
NS_ENSURE_SUCCESS(hr, PR_FALSE);
hr = glpDD->SetCooperativeLevel(NULL, DDSCL_NORMAL);
NS_ENSURE_SUCCESS(hr, PR_FALSE);
DDSURFACEDESC ddsd;
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
hr = glpDD->CreateSurface(&ddsd, &glpDDPrimary, NULL);
NS_ENSURE_SUCCESS(hr, PR_FALSE);
hr = glpDD->CreateClipper(0, &glpDDClipper, NULL);
NS_ENSURE_SUCCESS(hr, PR_FALSE);
hr = glpDDPrimary->SetClipper(glpDDClipper);
NS_ENSURE_SUCCESS(hr, PR_FALSE);
// We do not use the cairo ddraw surface for IMAGE_DDRAW16. Instead, we
// use an 24bpp image surface, convert that to 565, then blit using ddraw.
if (!IsRenderMode(gfxWindowsPlatform::RENDER_IMAGE_DDRAW16)) {
gfxIntSize screen_size(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
gpDDSurf = new gfxDDrawSurface(glpDD, screen_size, gfxASurface::ImageFormatRGB24);
if (!gpDDSurf) {
/*XXX*/
fprintf(stderr, "couldn't create ddsurf\n");
return PR_FALSE;
}
}
return PR_TRUE;
}
//-----------------------------------------------------------------------------
// Name: ReleaseAllObjects()
// Desc: Finished with all objects we use; release them
//-----------------------------------------------------------------------------
static void ReleaseAllObjects(void)
{
if (g_pDDSPrimary != NULL)
{
g_pDDSPrimary->Release();
g_pDDSPrimary = NULL;
}
if (g_pDD != NULL)
{
g_pDD->Release();
g_pDD = NULL;
}
}
void nsWindowGfx::OnSettingsChangeGfx(WPARAM wParam)
{
#if defined(WINCE_WINDOWS_MOBILE)
if (wParam == SETTINGCHANGE_RESET) {
if (glpDDSecondary) {
glpDDSecondary->Release();
glpDDSecondary = NULL;
}
if(glpDD)
glpDD->RestoreAllSurfaces();
}
#endif
}
void q_initDD()
{
if (initialized)
return;
DirectDrawCreate(NULL, &g_pDD, NULL);
HRESULT h;
h = g_pDD->SetCooperativeLevel(0, DDSCL_NORMAL);
if (h != DD_OK)
qDebug() << "cooperation level failed";
h = g_pDD->TestCooperativeLevel();
if (h != DD_OK)
qDebug() << "cooperation level failed test";
DDSURFACEDESC ddsd;
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
h = g_pDD->CreateSurface(&ddsd, &g_pDDSSurface, NULL);
if (h != DD_OK)
qDebug() << "CreateSurface failed!";
if (g_pDDSSurface->GetCaps(&ddsCaps) != DD_OK)
qDebug() << "GetCaps failed";
q_lock();
q_unlock();
initialized = true;
}
LPDIRECTDRAWSURFACE TAGameAreaReDrawer::InitOwnSurface (LPDIRECTDRAW TADD)
{
if (NULL!=GameAreaSurfaceFront_ptr)
{
GameAreaSurfaceFront_ptr->Release ( );
GameAreaSurfaceFront_ptr= NULL;
}
if (NULL!=GameAreaSurfaceBack_ptr)
{
GameAreaSurfaceBack_ptr->Release ( );
GameAreaSurfaceBack_ptr= NULL;
}
RECT GameAreaRect;
if (TADD)
{
TAWGameAreaRect ( &GameAreaRect);
DDSURFACEDESC ddsd;
DDRAW_INIT_STRUCT(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
ddsd.dwWidth = GameAreaRect.right- GameAreaRect.left;
ddsd.dwHeight = GameAreaRect.bottom- GameAreaRect.top;
TADD->CreateSurface( &ddsd, &GameAreaSurfaceFront_ptr, NULL);
TADD->CreateSurface( &ddsd, &GameAreaSurfaceBack_ptr, NULL);
Cls ( );
}
return GameAreaSurfaceFront_ptr;
}
//------------------------------------------------------------
// Name: ShutDown
// Desc: Clean up everything.
//------------------------------------------------------------
int Shutdown()
{
// this function is where you shutdown your game and
// release all resources that you allocated
// first release the primary surface
if (lpddsprimary != NULL)
lpddsprimary->Release();
// release the directdraw object
if (lpdd != NULL)
lpdd->Release();
// return success
return(1);
} // end Shutdown
LPDIRECTDRAWSURFACE CreateSurfByGafFrame (LPDIRECTDRAW LpDD, PGAFFrame Cursor_P, bool VidMem)
{
//PCXPic.buffer= (unsigned char *)malloc ( SizeofResource ( HInstance, FResource));
if (NULL==Cursor_P)
{
return NULL;
}
PGAFFrame GafFrame= Cursor_P;
LPDIRECTDRAWSURFACE RetSurf= NULL;
LPBYTE GafBits;
POINT GafSize;
InstanceGAFFrame ( GafFrame, &GafBits, &GafSize);
DDSURFACEDESC ddsd;
DDRAW_INIT_STRUCT(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
if(VidMem)
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY;
else
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
ddsd.dwWidth = GafSize.x;
ddsd.dwHeight = GafSize.y;
LpDD->CreateSurface ( &ddsd, &RetSurf, NULL);
DDRAW_INIT_STRUCT(ddsd);
RetSurf->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL);
unsigned char *SurfPTR = (unsigned char*)ddsd.lpSurface;
if (NULL!=SurfPTR)
{
for(int i=0; i<GafSize.y; i++)
{
memcpy(&SurfPTR[i*ddsd.lPitch], &GafBits[i*GafSize.x], GafSize.x);
}
}
free ( GafBits);
RetSurf->Unlock(NULL);
return RetSurf;
}
//-----------------------------------------------------------------------------
// Name: CleanupGraphics()
// Desc:
//-----------------------------------------------------------------------------
VOID CleanupGraphics()
{
for( DWORD i=0; i<4; i++ )
if( g_pddsShip[i] )
g_pddsShip[i]->Release();
if( g_pddsNumbers )
g_pddsNumbers->Release();
if( g_pddsFrontBuffer )
g_pddsFrontBuffer->Release();
if( g_pArtPalette )
g_pArtPalette->Release();
if( g_pSplashPalette )
g_pSplashPalette->Release();
if( !g_bFullscreen && g_pddsBackBuffer )
g_pddsBackBuffer->Release();
if( g_pDD )
g_pDD->Release();
}
