| /* DirectDraw HAL driver |
| * |
| * Copyright 2001 TransGaming Technologies Inc. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include "config.h" |
| |
| #include <assert.h> |
| #include <stdarg.h> |
| #include <stdlib.h> |
| |
| #include "wine/debug.h" |
| #include "windef.h" |
| #include "winbase.h" |
| #include "wingdi.h" |
| #include "ddraw.h" |
| #include "ddrawi.h" |
| #include "d3dhal.h" |
| |
| #include "ddraw_private.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(ddraw); |
| |
| static const IDirectDraw7Vtbl HAL_DirectDraw_VTable; |
| |
| static DDVERSIONDATA hal_version; |
| static DD32BITDRIVERDATA hal_driverdata; |
| static HINSTANCE hal_instance; |
| |
| static const DDDEVICEIDENTIFIER2 hal_device = |
| { |
| "display", |
| "DirectDraw HAL", |
| { { 0x00010001, 0x00010001 } }, |
| 0, 0, 0, 0, |
| /* 40c1b248-9d7d-4a29-b7d7-4cd8109f3d5d */ |
| {0x40c1b248,0x9d7d,0x4a29,{0xd7,0xb7,0x4c,0xd8,0x10,0x9f,0x3d,0x5d}}, |
| 0 |
| }; |
| |
| HRESULT HAL_DirectDraw_Create(const GUID* pGUID, LPDIRECTDRAW7* pIface, |
| IUnknown* pUnkOuter, BOOL ex); |
| HRESULT HAL_DirectDraw_Initialize(IDirectDrawImpl*, const GUID*); |
| |
| static const ddraw_driver hal_driver = |
| { |
| &hal_device, |
| 100, /* we prefer the HAL */ |
| HAL_DirectDraw_Create, |
| HAL_DirectDraw_Initialize |
| }; |
| |
| static DDHAL_CALLBACKS dd_cbs; |
| static DDRAWI_DIRECTDRAW_GBL dd_gbl; |
| |
| static D3DHAL_GLOBALDRIVERDATA d3d_hal_data; |
| static D3DHAL_D3DEXTENDEDCAPS d3d_hal_extcaps; |
| static D3DHAL_CALLBACKS d3d_hal_cbs1; |
| static D3DHAL_CALLBACKS2 d3d_hal_cbs2; |
| |
| /* in real windoze, these entry points are 16-bit, but we can work in 32-bit */ |
| static BOOL WINAPI set_hal_info(LPDDHALINFO lpDDHalInfo, BOOL reset) |
| { |
| dd_cbs.HALDD = *lpDDHalInfo->lpDDCallbacks; |
| dd_cbs.HALDDSurface = *lpDDHalInfo->lpDDSurfaceCallbacks; |
| dd_cbs.HALDDPalette = *lpDDHalInfo->lpDDPaletteCallbacks; |
| if (lpDDHalInfo->lpDDExeBufCallbacks) |
| dd_cbs.HALDDExeBuf = *lpDDHalInfo->lpDDExeBufCallbacks; |
| |
| dd_gbl.lpDDCBtmp = &dd_cbs; |
| |
| dd_gbl.ddCaps = lpDDHalInfo->ddCaps; |
| dd_gbl.dwMonitorFrequency = lpDDHalInfo->dwMonitorFrequency; |
| dd_gbl.vmiData = lpDDHalInfo->vmiData; |
| dd_gbl.dwModeIndex = lpDDHalInfo->dwModeIndex; |
| dd_gbl.dwNumFourCC = lpDDHalInfo->ddCaps.dwNumFourCCCodes; |
| dd_gbl.lpdwFourCC = lpDDHalInfo->lpdwFourCC; |
| dd_gbl.dwNumModes = lpDDHalInfo->dwNumModes; |
| dd_gbl.lpModeInfo = lpDDHalInfo->lpModeInfo; |
| /* FIXME: dwFlags */ |
| dd_gbl.dwPDevice = (DWORD)lpDDHalInfo->lpPDevice; |
| dd_gbl.hInstance = lpDDHalInfo->hInstance; |
| /* DirectX 2 */ |
| if (lpDDHalInfo->lpD3DGlobalDriverData) |
| memcpy(&d3d_hal_data, (LPVOID)lpDDHalInfo->lpD3DGlobalDriverData, sizeof(D3DDEVICEDESC_V1)); |
| else |
| memset(&d3d_hal_data, 0, sizeof(D3DDEVICEDESC_V1)); |
| dd_gbl.lpD3DGlobalDriverData = (ULONG_PTR)&d3d_hal_data; |
| |
| if (lpDDHalInfo->lpD3DHALCallbacks) |
| memcpy(&d3d_hal_cbs1, (LPVOID)lpDDHalInfo->lpD3DHALCallbacks, sizeof(D3DHAL_CALLBACKS)); |
| else |
| memset(&d3d_hal_cbs1, 0, sizeof(D3DHAL_CALLBACKS)); |
| dd_gbl.lpD3DHALCallbacks = (ULONG_PTR)&d3d_hal_cbs1; |
| |
| if (lpDDHalInfo->dwFlags & DDHALINFO_GETDRIVERINFOSET) { |
| DDHAL_GETDRIVERINFODATA data; |
| data.dwSize = sizeof(DDHAL_GETDRIVERINFODATA); |
| data.dwFlags = 0; /* ? */ |
| data.dwContext = hal_driverdata.dwContext; /* ? */ |
| |
| data.guidInfo = GUID_D3DExtendedCaps; |
| data.dwExpectedSize = sizeof(D3DHAL_D3DEXTENDEDCAPS); |
| data.lpvData = &d3d_hal_extcaps; |
| data.dwActualSize = 0; |
| data.ddRVal = 0; |
| lpDDHalInfo->GetDriverInfo(&data); |
| d3d_hal_extcaps.dwSize = data.dwActualSize; |
| dd_gbl.lpD3DExtendedCaps = (ULONG_PTR)&d3d_hal_extcaps; |
| |
| data.guidInfo = GUID_D3DCallbacks2; |
| data.dwExpectedSize = sizeof(D3DHAL_CALLBACKS2); |
| data.lpvData = &d3d_hal_cbs2; |
| data.dwActualSize = 0; |
| data.ddRVal = 0; |
| lpDDHalInfo->GetDriverInfo(&data); |
| d3d_hal_cbs2.dwSize = data.dwActualSize; |
| dd_gbl.lpD3DHALCallbacks2 = (ULONG_PTR)&d3d_hal_cbs2; |
| } |
| |
| if( opengl_initialized && |
| (d3d_hal_data.hwCaps.dwFlags & D3DDD_WINE_OPENGL_DEVICE) ) { |
| /*GL_DirectDraw_Init(&dd_gbl);*/ |
| } |
| |
| return FALSE; |
| } |
| |
| static DDHALDDRAWFNS hal_funcs = { |
| sizeof(DDHALDDRAWFNS), |
| set_hal_info, |
| NULL, /* VidMemAlloc */ |
| NULL /* VidMemFree */ |
| }; |
| |
| /* Called from DllInit, which is synchronised so there are no threading |
| * concerns. */ |
| static BOOL initialize(void) |
| { |
| DCICMD cmd; |
| INT ncmd = DCICOMMAND; |
| BOOL ret; |
| HDC dc = CreateDCA("DISPLAY", NULL, NULL, NULL); |
| INT ver = Escape(dc, QUERYESCSUPPORT, sizeof(ncmd), (LPVOID)&ncmd, NULL); |
| if (ver != DD_HAL_VERSION) { |
| DeleteDC(dc); |
| TRACE("DirectDraw HAL not available\n"); |
| return FALSE; |
| } |
| cmd.dwVersion = DD_VERSION; |
| cmd.dwReserved = 0; |
| |
| /* the DDNEWCALLBACKFNS is supposed to give the 16-bit driver entry points |
| * in ddraw16.dll, but since Wine doesn't have or use 16-bit display drivers, |
| * we'll just work in 32-bit, who'll notice... */ |
| cmd.dwCommand = DDNEWCALLBACKFNS; |
| cmd.dwParam1 = (DWORD)&hal_funcs; |
| ExtEscape(dc, DCICOMMAND, sizeof(cmd), (LPVOID)&cmd, 0, NULL); |
| |
| /* next, exchange version information */ |
| cmd.dwCommand = DDVERSIONINFO; |
| cmd.dwParam1 = DD_RUNTIME_VERSION; /* not sure what should *really* go here */ |
| ExtEscape(dc, DCICOMMAND, sizeof(cmd), (LPVOID)&cmd, sizeof(hal_version), (LPVOID)&hal_version); |
| |
| /* get 32-bit driver data (dll name and entry point) */ |
| cmd.dwCommand = DDGET32BITDRIVERNAME; |
| ExtEscape(dc, DCICOMMAND, sizeof(cmd), (LPVOID)&cmd, sizeof(hal_driverdata), (LPVOID)&hal_driverdata); |
| /* we're supposed to load the DLL in hal_driverdata.szName, then GetProcAddress |
| * the hal_driverdata.szEntryPoint, and call it with hal_driverdata.dwContext |
| * as a parameter... but since this is only more remains from the 16-bit world, |
| * we'll ignore it */ |
| |
| /* finally, initialize the driver object */ |
| cmd.dwCommand = DDCREATEDRIVEROBJECT; |
| ret = ExtEscape(dc, DCICOMMAND, sizeof(cmd), (LPVOID)&cmd, sizeof(hal_instance), (LPVOID)&hal_instance); |
| if (ret) { |
| /* the driver should have called our set_hal_info now */ |
| if (!dd_gbl.lpDDCBtmp) ret = FALSE; |
| } |
| |
| /* init done */ |
| DeleteDC(dc); |
| |
| TRACE("%s DirectDraw HAL\n", ret ? "enabling" : "disabling"); |
| |
| return ret; |
| } |
| |
| static void cleanup(void) |
| { |
| DDHAL_DESTROYDRIVERDATA data; |
| |
| if (!dd_cbs.HALDD.DestroyDriver) return; |
| |
| data.lpDD = NULL; |
| data.ddRVal = 0; |
| data.DestroyDriver = dd_cbs.HALDD.DestroyDriver; |
| data.DestroyDriver(&data); |
| } |
| |
| static DWORD choose_mode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP, |
| DWORD dwRefreshRate, DWORD dwFlags) |
| { |
| int best = -1; |
| unsigned int i; |
| |
| if (!dd_gbl.dwNumModes) return 0; |
| |
| /* let's support HALs that cannot switch depths (XVidMode), |
| * these should return dwBPP == 0 for all their resolutions */ |
| #define BPP_MATCH(dd, bpp) ((!(dd)) || ((dd) == bpp)) |
| |
| /* FIXME: we should try to match the refresh rate too */ |
| |
| /* Choose the smallest mode that is large enough. */ |
| for (i=0; i < dd_gbl.dwNumModes; i++) |
| { |
| if (dd_gbl.lpModeInfo[i].dwWidth >= dwWidth && |
| dd_gbl.lpModeInfo[i].dwHeight >= dwHeight && |
| BPP_MATCH(dd_gbl.lpModeInfo[i].dwBPP, dwBPP)) |
| { |
| if (best == -1) best = i; |
| else |
| { |
| if (dd_gbl.lpModeInfo[i].dwWidth < dd_gbl.lpModeInfo[best].dwWidth || |
| dd_gbl.lpModeInfo[i].dwHeight < dd_gbl.lpModeInfo[best].dwHeight) |
| best = i; |
| } |
| } |
| } |
| |
| if (best == -1) |
| { |
| TRACE("all modes too small\n"); |
| /* ok, let's use the largest */ |
| |
| for (i=0; i < dd_gbl.dwNumModes; i++) |
| { |
| if (BPP_MATCH(dd_gbl.lpModeInfo[i].dwBPP, dwBPP)) |
| { |
| if (best == -1) best = i; |
| else |
| { |
| if (dd_gbl.lpModeInfo[i].dwWidth > dd_gbl.lpModeInfo[best].dwWidth || |
| dd_gbl.lpModeInfo[i].dwHeight > dd_gbl.lpModeInfo[best].dwHeight) |
| best = i; |
| } |
| } |
| } |
| } |
| #undef BPP_MATCH |
| |
| if (best == -1) |
| { |
| ERR("requested color depth (%ld) not available, try reconfiguring X server\n", dwBPP); |
| return dd_gbl.dwModeIndex; |
| } |
| |
| TRACE("using mode %d\n", best); |
| |
| return best; |
| } |
| |
| static HRESULT set_mode(IDirectDrawImpl *This, DWORD dwMode) |
| { |
| HRESULT hr = DD_OK; |
| |
| if (dwMode != dd_gbl.dwModeIndex) |
| { |
| DDHAL_SETMODEDATA data; |
| data.lpDD = &dd_gbl; |
| data.dwModeIndex = dwMode; |
| data.ddRVal = 0; |
| data.SetMode = dd_cbs.HALDD.SetMode; |
| data.inexcl = 0; |
| data.useRefreshRate = FALSE; |
| if (data.SetMode) |
| data.SetMode(&data); |
| hr = data.ddRVal; |
| if (SUCCEEDED(hr)) |
| dd_gbl.dwModeIndex = dwMode; |
| } |
| return hr; |
| } |
| |
| static HRESULT set_exclusive_mode(IDirectDrawImpl *This, DWORD dwEnterExcl) |
| { |
| DDHAL_SETEXCLUSIVEMODEDATA data; |
| |
| data.lpDD = &dd_gbl; |
| data.dwEnterExcl = dwEnterExcl; |
| data.dwReserved = 0; |
| data.ddRVal = 0; |
| data.SetExclusiveMode = dd_cbs.HALDD.SetExclusiveMode; |
| if (data.SetExclusiveMode) |
| data.SetExclusiveMode(&data); |
| return data.ddRVal; |
| } |
| |
| BOOL DDRAW_HAL_Init(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv) |
| { |
| if (fdwReason == DLL_PROCESS_ATTACH) |
| { |
| if (initialize()) |
| DDRAW_register_driver(&hal_driver); |
| } |
| else if (fdwReason == DLL_PROCESS_DETACH) |
| { |
| cleanup(); |
| } |
| |
| return TRUE; |
| } |
| |
| /* Not called from the vtable. */ |
| HRESULT HAL_DirectDraw_Construct(IDirectDrawImpl *This, BOOL ex) |
| { |
| HRESULT hr; |
| |
| TRACE("(%p,%d)\n", This, ex); |
| |
| hr = User_DirectDraw_Construct(This, ex); |
| if (FAILED(hr)) return hr; |
| |
| This->local.lpGbl = &dd_gbl; |
| |
| This->final_release = HAL_DirectDraw_final_release; |
| This->set_exclusive_mode = set_exclusive_mode; |
| |
| This->create_palette = HAL_DirectDrawPalette_Create; |
| |
| This->create_primary = HAL_DirectDraw_create_primary; |
| This->create_backbuffer = HAL_DirectDraw_create_backbuffer; |
| This->create_texture = HAL_DirectDraw_create_texture; |
| |
| ICOM_INIT_INTERFACE(This, IDirectDraw7, HAL_DirectDraw_VTable); |
| |
| /* merge HAL caps */ |
| This->caps.dwCaps |= dd_gbl.ddCaps.dwCaps; |
| This->caps.dwCaps2 |= dd_gbl.ddCaps.dwCaps2; |
| This->caps.dwCKeyCaps |= dd_gbl.ddCaps.dwCKeyCaps; |
| This->caps.dwFXCaps |= dd_gbl.ddCaps.dwFXCaps; |
| This->caps.dwPalCaps |= dd_gbl.ddCaps.dwPalCaps; |
| /* FIXME: merge more caps */ |
| This->caps.ddsCaps.dwCaps |= dd_gbl.ddCaps.ddsCaps.dwCaps; |
| This->caps.ddsCaps.dwCaps2 |= dd_gbl.ddsCapsMore.dwCaps2; |
| This->caps.ddsCaps.dwCaps3 |= dd_gbl.ddsCapsMore.dwCaps3; |
| This->caps.ddsCaps.dwCaps4 |= dd_gbl.ddsCapsMore.dwCaps4; |
| This->caps.ddsOldCaps.dwCaps = This->caps.ddsCaps.dwCaps; |
| |
| return S_OK; |
| } |
| |
| /* This function is called from DirectDrawCreate(Ex) on the most-derived |
| * class to start construction. |
| * Not called from the vtable. */ |
| HRESULT HAL_DirectDraw_Create(const GUID* pGUID, LPDIRECTDRAW7* pIface, |
| IUnknown* pUnkOuter, BOOL ex) |
| { |
| HRESULT hr; |
| IDirectDrawImpl* This; |
| |
| TRACE("\n"); |
| |
| assert(pUnkOuter == NULL); |
| |
| This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, |
| sizeof(IDirectDrawImpl) |
| + sizeof(HAL_DirectDrawImpl)); |
| if (This == NULL) return E_OUTOFMEMORY; |
| |
| /* Note that this relation does *not* hold true if the DD object was |
| * CoCreateInstanced then Initialized. */ |
| This->private = (HAL_DirectDrawImpl *)(This+1); |
| |
| /* Initialize the DDCAPS structure */ |
| This->caps.dwSize = sizeof(This->caps); |
| |
| hr = HAL_DirectDraw_Construct(This, ex); |
| if (FAILED(hr)) |
| HeapFree(GetProcessHeap(), 0, This); |
| else |
| *pIface = ICOM_INTERFACE(This, IDirectDraw7); |
| |
| return hr; |
| } |
| |
| /* This function is called from Uninit_DirectDraw_Initialize on the |
| * most-derived-class to start initialization. |
| * Not called from the vtable. */ |
| HRESULT HAL_DirectDraw_Initialize(IDirectDrawImpl *This, const GUID* guid) |
| { |
| HRESULT hr; |
| |
| TRACE("\n"); |
| |
| This->private = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, |
| sizeof(HAL_DirectDrawImpl)); |
| if (This->private == NULL) return E_OUTOFMEMORY; |
| |
| /* Initialize the DDCAPS structure */ |
| This->caps.dwSize = sizeof(This->caps); |
| |
| hr = HAL_DirectDraw_Construct(This, TRUE); /* XXX ex? */ |
| if (FAILED(hr)) |
| { |
| HeapFree(GetProcessHeap(), 0, This->private); |
| return hr; |
| } |
| |
| return DD_OK; |
| } |
| |
| /* Called from an internal function pointer. */ |
| void HAL_DirectDraw_final_release(IDirectDrawImpl *This) |
| { |
| if (dd_gbl.dwFlags & DDRAWI_MODECHANGED) set_mode(This, dd_gbl.dwModeIndexOrig); |
| User_DirectDraw_final_release(This); |
| } |
| |
| HRESULT HAL_DirectDraw_create_primary(IDirectDrawImpl* This, |
| const DDSURFACEDESC2* pDDSD, |
| LPDIRECTDRAWSURFACE7* ppSurf, |
| IUnknown* pUnkOuter) |
| { |
| if (This->cooperative_level & DDSCL_EXCLUSIVE) |
| return HAL_DirectDrawSurface_Create(This, pDDSD, ppSurf, pUnkOuter); |
| else |
| return User_DirectDrawSurface_Create(This, pDDSD, ppSurf, pUnkOuter); |
| } |
| |
| HRESULT HAL_DirectDraw_create_backbuffer(IDirectDrawImpl* This, |
| const DDSURFACEDESC2* pDDSD, |
| LPDIRECTDRAWSURFACE7* ppSurf, |
| IUnknown* pUnkOuter, |
| IDirectDrawSurfaceImpl* primary) |
| { |
| if (This->cooperative_level & DDSCL_EXCLUSIVE) |
| return HAL_DirectDrawSurface_Create(This, pDDSD, ppSurf, pUnkOuter); |
| else |
| return User_DirectDrawSurface_Create(This, pDDSD, ppSurf, pUnkOuter); |
| } |
| |
| HRESULT HAL_DirectDraw_create_texture(IDirectDrawImpl* This, |
| const DDSURFACEDESC2* pDDSD, |
| LPDIRECTDRAWSURFACE7* ppSurf, |
| LPUNKNOWN pOuter, |
| DWORD dwMipMapLevel) |
| { |
| return HAL_DirectDrawSurface_Create(This, pDDSD, ppSurf, pOuter); |
| } |
| |
| HRESULT WINAPI |
| HAL_DirectDraw_GetDeviceIdentifier(LPDIRECTDRAW7 iface, |
| LPDDDEVICEIDENTIFIER2 pDDDI, |
| DWORD dwFlags) |
| { |
| *pDDDI = hal_device; |
| return DD_OK; |
| } |
| |
| HRESULT WINAPI |
| HAL_DirectDraw_RestoreDisplayMode(LPDIRECTDRAW7 iface) |
| { |
| IDirectDrawImpl *This = (IDirectDrawImpl *)iface; |
| HRESULT hr; |
| |
| TRACE("(%p)\n", iface); |
| |
| if (!(dd_gbl.dwFlags & DDRAWI_MODECHANGED)) return DD_OK; |
| |
| hr = Main_DirectDraw_RestoreDisplayMode(iface); |
| if (SUCCEEDED(hr)) { |
| hr = set_mode(This, dd_gbl.dwModeIndexOrig); |
| if (SUCCEEDED(hr)) dd_gbl.dwFlags &= ~DDRAWI_MODECHANGED; |
| } |
| |
| return hr; |
| } |
| |
| HRESULT WINAPI |
| HAL_DirectDraw_SetDisplayMode(LPDIRECTDRAW7 iface, DWORD dwWidth, |
| DWORD dwHeight, DWORD dwBPP, |
| DWORD dwRefreshRate, DWORD dwFlags) |
| { |
| IDirectDrawImpl *This = (IDirectDrawImpl *)iface; |
| |
| HRESULT hr; |
| |
| TRACE("(%p)->(%ldx%ldx%ld,%ld Hz,%08lx)\n",This,dwWidth,dwHeight,dwBPP,dwRefreshRate,dwFlags); |
| hr = User_DirectDraw_SetDisplayMode(iface, dwWidth, dwHeight, dwBPP, |
| dwRefreshRate, dwFlags); |
| |
| if (SUCCEEDED(hr)) { |
| if (!(dd_gbl.dwFlags & DDRAWI_MODECHANGED)) dd_gbl.dwModeIndexOrig = dd_gbl.dwModeIndex; |
| hr = set_mode(This, choose_mode(dwWidth, dwHeight, dwBPP, dwRefreshRate, dwFlags)); |
| if (SUCCEEDED(hr)) dd_gbl.dwFlags |= DDRAWI_MODECHANGED; |
| } |
| |
| return hr; |
| } |
| |
| HRESULT WINAPI |
| HAL_DirectDraw_GetFourCCCodes(LPDIRECTDRAW7 iface, LPDWORD pNumCodes, |
| LPDWORD pCodes) |
| { |
| unsigned int i; |
| IDirectDrawImpl *This = (IDirectDrawImpl *)iface; |
| if (*pNumCodes) |
| *pNumCodes=dd_gbl.dwNumFourCC; |
| if (pCodes && dd_gbl.dwNumFourCC) |
| memcpy(pCodes,dd_gbl.lpdwFourCC,sizeof(pCodes[0])*dd_gbl.dwNumFourCC); |
| FIXME("(%p,%p,%p)\n",This,pNumCodes,pCodes); |
| if (dd_gbl.dwNumFourCC) { |
| if (pCodes && FIXME_ON(ddraw)) { |
| FIXME("returning: "); |
| for (i=0;i<dd_gbl.dwNumFourCC;i++) { |
| MESSAGE("%c%c%c%c,", |
| ((LPBYTE)(pCodes+i))[0], |
| ((LPBYTE)(pCodes+i))[1], |
| ((LPBYTE)(pCodes+i))[2], |
| ((LPBYTE)(pCodes+i))[3] |
| ); |
| } |
| MESSAGE("\n"); |
| } |
| } |
| return DD_OK; |
| } |
| |
| |
| static const IDirectDraw7Vtbl HAL_DirectDraw_VTable = |
| { |
| Main_DirectDraw_QueryInterface, |
| Main_DirectDraw_AddRef, |
| Main_DirectDraw_Release, |
| Main_DirectDraw_Compact, |
| Main_DirectDraw_CreateClipper, |
| Main_DirectDraw_CreatePalette, |
| Main_DirectDraw_CreateSurface, |
| Main_DirectDraw_DuplicateSurface, |
| User_DirectDraw_EnumDisplayModes, |
| Main_DirectDraw_EnumSurfaces, |
| Main_DirectDraw_FlipToGDISurface, |
| Main_DirectDraw_GetCaps, |
| Main_DirectDraw_GetDisplayMode, |
| HAL_DirectDraw_GetFourCCCodes, |
| Main_DirectDraw_GetGDISurface, |
| Main_DirectDraw_GetMonitorFrequency, |
| Main_DirectDraw_GetScanLine, |
| Main_DirectDraw_GetVerticalBlankStatus, |
| Main_DirectDraw_Initialize, |
| HAL_DirectDraw_RestoreDisplayMode, |
| Main_DirectDraw_SetCooperativeLevel, |
| HAL_DirectDraw_SetDisplayMode, |
| Main_DirectDraw_WaitForVerticalBlank, |
| Main_DirectDraw_GetAvailableVidMem, |
| Main_DirectDraw_GetSurfaceFromDC, |
| Main_DirectDraw_RestoreAllSurfaces, |
| Main_DirectDraw_TestCooperativeLevel, |
| HAL_DirectDraw_GetDeviceIdentifier, |
| Main_DirectDraw_StartModeTest, |
| Main_DirectDraw_EvaluateMode |
| }; |