VNGError VngoDirect3D::init(char *targetName)
{
target = targetName;
if (target != NULL)
{
if (DirectDrawEnumerate(FindDeviceCallback,(LPVOID)this)==DD_OK)
{
if (dd==NULL)
err = DirectDrawCreate(&targetID, &dd, NULL);
if (err != DD_OK)
{
if (dd != NULL)
{
dd->Release();
dd = NULL;
}
err = DirectDrawCreate(NULL, &dd, NULL);
}
}
else
{
if (dd==NULL)
err = DirectDrawCreate(NULL, &dd, NULL);
}
}
else
{
if (dd==NULL)
err = DirectDrawCreate(NULL, &dd, NULL);
}
if (err != DD_OK)
return VNGO_INTERNAL_ERROR;
err = dd->QueryInterface(IID_IDirect3D2, (void**)&d3d);
if (err != DD_OK)
return VNGO_INTERNAL_ERROR;
VgSystem->D3DTx = new VngoTextureManager;
if (VgSystem->D3DTx)
{
VgSystem->D3DTx->screen = this;
}
else
{
term();
return VNGO_INTERNAL_ERROR;
}
type_info = SCREENTYPE_D3D;
return VNGO_NO_ERROR;
}
//------------------------------------------------------------
// 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;
}
Err GE2DLibOpen()
{
DDSURFACEDESC Desc;
HRESULT (WINAPI* DirectDrawCreate)( void*, LPDIRECTDRAW*, void* );
Module = LoadLibrary(T("DDRAW.DLL"));
*(FARPROC*)&DirectDrawCreate = GetProcAddress(Module,"DirectDrawCreate");
if (!DirectDrawCreate)
return 1;
if (DirectDrawCreate(NULL,&DD,NULL)!=DD_OK)
return 1;
IDirectDraw_SetCooperativeLevel(DD, NULL, DDSCL_NORMAL);
// get primary surface
memset(&Desc,0,sizeof(DDSURFACEDESC));
Desc.dwSize = sizeof(DDSURFACEDESC);
Desc.dwFlags = DDSD_CAPS;
Desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
if (IDirectDraw_CreateSurface(DD,&Desc,&DDPrimary,NULL) != DD_OK)
return 1;
return errNone;
}
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;
}
static int InitializeDDraw(int fs)
{
//only init the palette the first time through
if(firstInitialize) {
firstInitialize = false;
color_palette = (PALETTEENTRY*)malloc(256 * sizeof(PALETTEENTRY));
}
//(disvaccel&(1<<(fs?1:0)))?(GUID FAR *)DDCREATE_EMULATIONONLY:
ddrval = DirectDrawCreate((disvaccel&(1<<(fs?1:0)))?(GUID FAR *)DDCREATE_EMULATIONONLY:NULL, &lpDD, NULL);
if (ddrval != DD_OK)
{
ShowDDErr("Error creating DirectDraw object.");
return 0;
}
//mbg merge 7/17/06 changed:
ddrval = IDirectDraw_QueryInterface(lpDD,IID_IDirectDraw7,(LPVOID *)&lpDD7);
//ddrval = IDirectDraw_QueryInterface(lpDD,&IID_IDirectDraw7,(LPVOID *)&lpDD7);
IDirectDraw_Release(lpDD);
if (ddrval != DD_OK)
{
ShowDDErr("Error querying interface.");
return 0;
}
caps.dwSize=sizeof(caps);
if(IDirectDraw7_GetCaps(lpDD7,&caps,0)!=DD_OK)
{
ShowDDErr("Error getting capabilities.");
return 0;
}
return 1;
}
int DispInit()
{
int Ret=0,MemLen=0;
DisableDesktopWindowManager();
// Create the DirectDraw interface
pDD=NULL; Ret=DirectDrawCreate(NULL,&pDD,NULL);
if (Ret<0) return 1; if (pDD==NULL) return 1;
// Set cooperation level
pDD->SetCooperativeLevel(hFrameWnd,DDSCL_NORMAL);
// Make primary surface
Ret=MakePrimarySurface(); if (Ret!=0) return 1;
Ret=1;
if (TryOverlay) Ret=MakeOverlaySurface(); // Try overlay first
if (Ret!=0)
{
// Else make buffer surface
Ret=MakeBufferSurface(); if (Ret!=0) return 1;
}
// Render Init (precalc all colors)
RenderInit();
// Create the memory buffer
DispMemPitch=ScrnWidth*DispBpp;
MemLen=ScrnHeight*DispMemPitch;
DispMem=(unsigned char *)malloc(MemLen); if (DispMem==NULL) return 1;
memset(DispMem,0,MemLen);
return 0;
}
M4Err GetDisplayMode(DDContext *dd)
{
if (dd->switch_res) {
HRESULT hr;
Bool temp_dd = 0;;
if (!dd->pDD) {
LPDIRECTDRAW ddraw;
DirectDrawCreate(NULL, &ddraw, NULL);
#ifdef USE_DX_3
IDirectDraw_QueryInterface(ddraw, &IID_IDirectDraw, (LPVOID *)&dd->pDD);
#else
IDirectDraw_QueryInterface(ddraw, &IID_IDirectDraw7, (LPVOID *)&dd->pDD);
#endif
temp_dd = 1;
}
//we start with a hugde res and downscale
dd->fs_width = dd->fs_height = 50000;
#ifdef USE_DX_3
hr = IDirectDraw_EnumDisplayModes(dd->pDD, 0L, NULL, dd, (LPDDENUMMODESCALLBACK) EnumDisplayModes);
#else
hr = IDirectDraw7_EnumDisplayModes(dd->pDD, 0L, NULL, dd, (LPDDENUMMODESCALLBACK2) EnumDisplayModes);
#endif
if (temp_dd) SAFE_DD_RELEASE(dd->pDD);
if (FAILED(hr)) return M4IOErr;
} else {
dd->fs_width = GetSystemMetrics(SM_CXSCREEN);
dd->fs_height = GetSystemMetrics(SM_CYSCREEN);
}
return M4OK;
}
BOOL Game::startDirectDraw(HWND hwnd,HINSTANCE hinstance)
{
if ( SUCCEEDED(DirectDrawCreate(NULL,&theDirectDrawObject,NULL) ))
{
if ( SUCCEEDED(theDirectDrawObject->SetCooperativeLevel(hwnd,DDSCL_EXCLUSIVE|DDSCL_FULLSCREEN)) )
{
if ( SUCCEEDED(theDirectDrawObject->SetDisplayMode(theDisplayWidth,theDisplayHeight,theBitDepth)) )
{
return TRUE;
}
else
{
Logger::error("Couldn't set display mode (%d,%d,%d)",theDisplayWidth,theDisplayHeight,theBitDepth);
}
}
else
{
Logger::error("Couldn't set cooperative level");
}
}
else
{
Logger::error("Couldn't create DirectDraw object.");
}
return FALSE;
}
bool CDirectDraw::Initialize (HWND hWnd)
{
if(dDinitialized)
return true;
dErr = DirectDrawCreate (NULL, &lpDD, NULL);
if(FAILED(dErr))
return false;
dErr = lpDD -> CreateClipper (0, &lpDDClipper, NULL);
if(FAILED(dErr))
return false;
dErr = lpDDClipper->SetHWnd (0, hWnd);
if(FAILED(dErr))
return false;
if (!SetDisplayMode (GUI.FullscreenMode.width, GUI.FullscreenMode.height, max(GetFilterScale(GUI.Scale), GetFilterScale(GUI.ScaleHiRes)), GUI.FullscreenMode.depth, GUI.FullscreenMode.rate,
TRUE, GUI.DoubleBuffered))
{
MessageBox( GUI.hWnd, Languages[ GUI.Language].errModeDD, TEXT("Snes9X - DirectDraw(7)"), MB_OK | MB_ICONSTOP);
return (false);
}
dDinitialized = true;
return (true);
}
/*
* 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;
}
static int
DDCreateWindow(struct ggi_visual *vis)
{
directx_priv *priv = GGIDIRECTX_PRIV(vis);
int w = 640, h = 480; /* default window size */
int ws_flags = WS_OVERLAPPEDWINDOW & ~WS_MAXIMIZEBOX;
/* toplevel flags */
if (priv->hParent) {
/* determine the parent window size */
RECT r;
GetWindowRect(priv->hParent, &r);
w = r.right - r.left;
h = r.bottom - r.top;
/* flags for a child window */
ws_flags = WS_CHILD;
} else if (priv->fullscreen)
ws_flags = WS_VISIBLE | WS_POPUP;
else {
/* adjust the window size to accommodate for
* the client area
*/
RECT r;
r.left = r.top = 0;
r.right = w;
r.bottom = h;
AdjustWindowRectEx(&r, ws_flags, 0, 0);
w = r.right - r.left;
h = r.bottom - r.top;
}
/* create the window */
priv->hWnd = CreateWindowEx(0, NAME, TITLE, ws_flags,
CW_USEDEFAULT, 0, w, h,
priv->hParent, NULL,
priv->hInstance, vis);
if (!priv->hWnd) {
if (priv->hCursor)
DestroyCursor(priv->hCursor);
priv->hCursor = NULL;
return 0;
}
/* make sure the window is initially hidden */
ShowWindow(priv->hWnd, SW_HIDE);
/* initialize the DirectDraw interface */
DirectDrawCreate(NULL, &priv->lpdd, NULL);
IDirectDraw_QueryInterface(priv->lpdd, &IID_IDirectDraw2,
(LPVOID *) & priv->lpddext);
return 1;
}
static BOOL createdirectdraw(void)
{
HRESULT rc;
rc = DirectDrawCreate(NULL, &lpDD, NULL);
ok(rc==DD_OK || rc==DDERR_NODIRECTDRAWSUPPORT, "DirectDrawCreateEx returned: %x\n", rc);
if (!lpDD) {
trace("DirectDrawCreateEx() failed with an error %x\n", rc);
return FALSE;
}
return TRUE;
}
BOOL WINAPI dd_create_callback(LPGUID lpGuid, LPSTR lpDeviceDescription,
LPSTR lpDriverName, LPVOID lpUserArg, HMONITOR hm)
{
char * desired_driver = (char *)lpUserArg;
//PG: Changed this as I'm not shure wheter driver name is guaranteed to
//be unique even when using multiple displays.
//Using lpGuid instead, which certainly IS unique.
/*if (!stricmp(desired_driver,lpDriverName))
{
HRESULT res = DirectDrawCreate(lpGuid, &dx5_ddraw, 0);
return DDENUMRET_CANCEL;
}*/
if (!lpGuid) //is the primary display driver
{
for(int i=0; i<=sizeof(GUID); i++)
{
if (((w8 *)&i4_win32_startup_options.guid_screen)[i]!=0)
{
//is the saved guid a null-guid?
return DDENUMRET_OK;
}
}
i4_dx5_check(DirectDrawCreate(lpGuid,&dx5_ddraw,0));
return DDENUMRET_CANCEL;
}
if (memcmp(lpGuid,&i4_win32_startup_options.guid_screen,sizeof(GUID))==0)
{
HRESULT res=DirectDrawCreate(lpGuid,&dx5_ddraw,0);
if (!i4_dx5_check(res))
{
MessageBox(NULL,"The currently choosen display device failed to initialize.\n"
"Reverting to default (primary display driver)","DirectX initialisation failed",MB_OK);
ZeroMemory(&i4_win32_startup_options.guid_screen,sizeof(GUID));
i4_dx5_check(DirectDrawCreate(NULL,&dx5_ddraw,0));
}
return DDENUMRET_CANCEL;
}
return DDENUMRET_OK;
}
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;
}
BOOL DDPrimarySurfaceTest(HWND hWnd){
UINT TimerID;
MSG msg;
LPDIRECTDRAW lpDD = NULL;
LPDIRECTDRAWSURFACE lpDDSurface = NULL;
DDSURFACEDESC DDSurfaceDesc;
if(DirectDrawCreate(NULL, &lpDD, NULL) != DD_OK)
return FALSE;
if(lpDD->lpVtbl->SetCooperativeLevel(lpDD, hWnd, DDSCL_NORMAL) != DD_OK)
{
lpDD->lpVtbl->Release(lpDD);
return FALSE;
}
/* create our primary surface */
ZeroMemory(&DDSurfaceDesc, sizeof(DDSurfaceDesc));
DDSurfaceDesc.dwSize = sizeof(DDSurfaceDesc);
DDSurfaceDesc.dwFlags = DDSD_CAPS;
DDSurfaceDesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_3DDEVICE;
DDSurfaceDesc.dwBackBufferCount = 0;
if(lpDD->lpVtbl->CreateSurface(lpDD, &DDSurfaceDesc, &lpDDSurface, NULL) != DD_OK)
{
lpDD->lpVtbl->Release(lpDD);
return FALSE;
}
TimerID = SetTimer(hWnd, -1, (UINT)TEST_DURATION, NULL);
while (TRUE)
{
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
if (msg.message == WM_TIMER && TimerID == msg.wParam)
break;
TranslateMessage(&msg);
DispatchMessage(&msg);
if (msg.message == WM_PAINT)
DDRedrawFrame(lpDDSurface);
}
}
KillTimer(hWnd, TimerID);
lpDDSurface->lpVtbl->Release(lpDDSurface);
lpDD->lpVtbl->Release(lpDD);
return TRUE;
}
static BOOL createdirectdraw(void)
{
HRESULT rc;
SetRect(&rect_before_create, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
rc = DirectDrawCreate(NULL, &lpDD, NULL);
ok(rc==DD_OK || rc==DDERR_NODIRECTDRAWSUPPORT, "DirectDrawCreateEx returned: %x\n", rc);
if (!lpDD) {
trace("DirectDrawCreateEx() failed with an error %x\n", rc);
return FALSE;
}
return TRUE;
}
DWORD CViewGame::SetFullScreen()
{
HRESULT ddrval;
ddrval = DirectDrawCreate( NULL, &FrontDD, NULL );
if (ddrval)
return GERR_DD;
ddrval = FrontDD->SetCooperativeLevel(m_hWnd,DDSCL_EXCLUSIVE|DDSCL_FULLSCREEN|DDSCL_ALLOWREBOOT);
if (ddrval)
return GERR_DDCL;
ddrval = FrontDD->SetDisplayMode( 640, 480, 16 );
if (ddrval)
return GERR_DDDM;
return 0;
}
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;
}
//
// CDDrawObject::Initialize(): Just creates a DDraw object.
//
BOOL CDDrawObject::Initialize(HWND hWndApp)
{
DbgLog((LOG_TRACE, 5, TEXT("CDDrawObject::Initialize() entered"))) ;
HRESULT hr = DirectDrawCreate(NULL, &m_pDDObject, NULL) ;
if (FAILED(hr) || NULL == m_pDDObject)
{
MessageBox(hWndApp,
TEXT("Can't create a DirectDraw object.\nPress OK to end the app."),
TEXT("Error"), MB_OK | MB_ICONSTOP) ;
return FALSE ;
}
return TRUE;
}
// 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 BOOL WINAPI enum_dd_devices_cb(
GUID FAR* lpGUID, LPSTR lpDriverDescription, LPSTR lpDriverName, LPVOID lpContext)
{
ddlist_t dd;
dd.ddraw = NULL;
if (FAILED(DirectDrawCreate(lpGUID, &dd.ddraw, NULL)))
{
return D3DENUMRET_OK;
}
strncpy(dd.descStr, lpDriverDescription, 127);
strncpy(dd.nameStr, lpDriverName, 127);
ddList.push_back(dd);
return D3DENUMRET_OK;
}
void dd_init()
{
HRESULT hr = DirectDrawCreate(NULL, &dx_dd, NULL);
if (hr != DD_OK)
err("Could not create DirectDraw object.");
for(int i=16;i>0;i--)
dd_handles.push(i);
dd_handleCount=16;
WNDCLASS WndClass;
memset(&WndClass, 0, sizeof(WNDCLASS));
WndClass.hCursor = LoadCursor(0, IDC_ARROW);
WndClass.hIcon = LoadIcon(hMainInst, MAKEINTRESOURCE(1));
WndClass.lpszClassName = "xerxes-dd-gamewindow";
WndClass.hInstance = hMainInst;
WndClass.lpfnWndProc = win_gameWindowProc;
RegisterClass(&WndClass);
memset(&WndClass, 0, sizeof(WNDCLASS));
WndClass.hCursor = LoadCursor(0, IDC_ARROW);
WndClass.lpszClassName = "xerxes-dd-auxwindow";
WndClass.hInstance = hMainInst;
WndClass.lpfnWndProc = win_auxWindowProc;
RegisterClass(&WndClass);
dd_gameWindow = new dd_Window(true);
gameWindow = dynamic_cast<AuxWindow*>(dd_gameWindow);
hMainWnd = dd_gameWindow->hwnd;
dd_gameWindow->setVisibility(true);
if(automax)
{
ShowWindow(dd_gameWindow->hwnd,SW_SHOWMAXIMIZED);
}
vid_Close = dd_Close;
Flip = dd_Flip;
vid_createAuxWindow = dd_createAuxWindow;
vid_findAuxWindow = dd_findAuxWindow;
dd_initd = true;
}
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();
}
WSERR WSurface::Create(HWND hWnd,WCanvas &canvas)
{
if (data->ddraw) return WS_CREATEDDRAWFAIL;
if (DirectDrawCreate(NULL,&(data->ddraw),NULL)!=DD_OK) {
return WS_CREATEDDRAWFAIL;
}
LPDIRECTDRAW lpDD=data->ddraw;
lpDD->SetCooperativeLevel(hWnd,DDSCL_NORMAL);
lpDD->CreateClipper(0,&(data->clipper),0);
data->clipper->SetHWnd(0,hWnd);
m_hWnd=hWnd;
Canvas=&canvas;
data->window_style=::GetWindowLong(m_hWnd,GWL_STYLE);
::GetWindowRect(m_hWnd,&(data->window_rect));
return CreateSurface();
}
bool CDirectDraw::InitDirectDraw ()
{
if(DDinitialized)
return true;
dErr = DirectDrawCreate (NULL, &lpDD, NULL);
if(FAILED(dErr))
return false;
dErr = lpDD -> CreateClipper (0, &lpDDClipper, NULL);
if(FAILED(dErr))
return false;
dErr = lpDDClipper->SetHWnd (0, GUI.hWnd);
if(FAILED(dErr))
return false;
DDinitialized = true;
return (true);
}
VNGError VngoClear3D::init()
{
strcpy(hwName,"Clear3D");
if (clrInitLib(CLR_INIT_NORMAL | DEBUG_OFF))
{
term();
return VNGO_INTERNAL_ERROR;
}
err = DirectDrawCreate(NULL, &dd, NULL);
if (err != DD_OK)
{
term();
return VNGO_INTERNAL_ERROR;
}
pContext = clrCreateContext();
VertPool = (IvoryArena*)ivory_alloc(CLEAR3D_MAX_BATCH * 8 * sizeof (LL_Vert));
if (VertPool == NULL)
{
term();
return VNGO_MEMALLOC_ERROR;
}
ivory_arena_initialize(VertPool,CLEAR3D_MAX_BATCH * 8 * sizeof (LL_Vert));
VgSystem.CL3DTx = new VngoTextureManager;
if (VgSystem.CL3DTx == NULL)
{
term();
return VNGO_MEMALLOC_ERROR;
}
VgSystem.CL3DTx->screen = this;
type_info = SCREENTYPE_CLEAR3D;
return VNGO_NO_ERROR;
}
