HRESULT WINAPI
Main_D3D_FindDevice(LPDIRECT3D iface, LPD3DFINDDEVICESEARCH D3DDFS, LPD3DFINDDEVICERESULT D3DFDR)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_D3D_CreateMaterial(LPDIRECT3D iface,LPDIRECT3DMATERIAL* Direct3DLight,IUnknown* pUnkOuter)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_D3D_CreateViewport(LPDIRECT3D iface, LPDIRECT3DVIEWPORT* Viewport,IUnknown* pUnkOuter)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DirectDraw_GetCaps( LPDDRAWI_DIRECTDRAW_INT This, LPDDCAPS pDriverCaps,
LPDDCAPS pHELCaps)
{
HRESULT retVal = DDERR_INVALIDPARAMS;
DX_WINDBG_trace();
EnterCriticalSection( &ddcs );
_SEH2_TRY
{
if ((!pDriverCaps) && (!pHELCaps))
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
/*
* DDCAPS_DX6 and DDCAPS_DX7 have same size so
* we do not need check both only one of them
*/
if ( (pDriverCaps) &&
(pDriverCaps->dwSize != sizeof(DDCAPS_DX1) ) &&
(pDriverCaps->dwSize != sizeof(DDCAPS_DX3) ) &&
(pDriverCaps->dwSize != sizeof(DDCAPS_DX5) ) &&
(pDriverCaps->dwSize != sizeof(DDCAPS_DX7 )) )
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
/*
* DDCAPS_DX6 and DDCAPS_DX7 have same size so
* we do not need check both only one of them
*/
if ( (pHELCaps) &&
(pHELCaps->dwSize != sizeof(DDCAPS_DX1) ) &&
(pHELCaps->dwSize != sizeof(DDCAPS_DX3) ) &&
(pHELCaps->dwSize != sizeof(DDCAPS_DX5) ) &&
(pHELCaps->dwSize != sizeof(DDCAPS_DX7 )) )
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
if (pDriverCaps)
{
/* Setup hardware caps */
DDSCAPS2 ddscaps = { 0 };
LPDDCORECAPS CoreCaps = (LPDDCORECAPS)&This->lpLcl->lpGbl->ddCaps;
DWORD dwTotal = 0;
DWORD dwFree = 0;
Main_DirectDraw_GetAvailableVidMem4(This, &ddscaps, &dwTotal, &dwFree);
switch (pDriverCaps->dwSize)
{
case sizeof(DDCAPS_DX1):
{
LPDDCAPS_DX1 myCaps = (LPDDCAPS_DX1) pDriverCaps;
if (CoreCaps->dwSize == sizeof(DDCORECAPS))
{
memcpy(myCaps, CoreCaps, sizeof(DDCAPS_DX1));
}
myCaps->dwVidMemFree = dwFree;
myCaps->dwVidMemTotal = dwTotal;
myCaps->dwSize = sizeof(DDCAPS_DX1);
retVal = DD_OK;
}
break;
case sizeof(DDCAPS_DX3):
{
LPDDCAPS_DX3 myCaps = (LPDDCAPS_DX3) pDriverCaps;
if (CoreCaps->dwSize == sizeof(DDCORECAPS))
{
memcpy(&myCaps->dwCaps, &CoreCaps->dwCaps, sizeof(DDCAPS_DX3));
}
myCaps->dwVidMemFree = dwFree;
myCaps->dwVidMemTotal = dwTotal;
myCaps->dwSize = sizeof(DDCAPS_DX3);
retVal = DD_OK;
}
break;
case sizeof(DDCAPS_DX5):
{
LPDDCAPS_DX5 myCaps = (LPDDCAPS_DX5) pDriverCaps;
/* FIXME This->lpLcl->lpGbl->lpddNLVCaps are not set in startup.c
if (This->lpLcl->lpGbl->lpddNLVCaps->dwSize == sizeof(DDNONLOCALVIDMEMCAPS))
{
memcpy(&myCaps->dwNLVBCaps, This->lpLcl->lpGbl->lpddNLVCaps, sizeof(DDNONLOCALVIDMEMCAPS));
}
*/
memset(&myCaps->dwNLVBCaps,0,sizeof(DDNONLOCALVIDMEMCAPS));
if (CoreCaps->dwSize == sizeof(DDCORECAPS))
{
memcpy(&myCaps->dwCaps, &CoreCaps->dwCaps, sizeof(DDCORECAPS));
}
myCaps->dwVidMemFree = dwFree;
myCaps->dwVidMemTotal = dwTotal;
myCaps->dwSize = sizeof(DDCAPS_DX5);
retVal = DD_OK;
}
break;
/* DDCAPS_DX6 is same as DDCAPS_DX7 */
case sizeof(DDCAPS_DX7):
{
LPDDCAPS_DX7 myCaps = (LPDDCAPS_DX7) pDriverCaps;
/* FIXME This->lpLcl->lpGbl->lpddNLVCaps are not set in startup.c
if (This->lpLcl->lpGbl->lpddNLVCaps->dwSize == sizeof(DDNONLOCALVIDMEMCAPS))
{
memcpy(&myCaps->dwNLVBCaps, This->lpLcl->lpGbl->lpddNLVCaps, sizeof(DDNONLOCALVIDMEMCAPS));
}
*/
memset(&myCaps->dwNLVBCaps,0,sizeof(DDNONLOCALVIDMEMCAPS));
if (CoreCaps->dwSize == sizeof(DDCORECAPS))
{
memcpy(&myCaps->dwCaps, &CoreCaps->dwCaps, sizeof(DDCORECAPS));
}
myCaps->dwVidMemFree = dwFree;
myCaps->dwVidMemTotal = dwTotal;
myCaps->ddsCaps.dwCaps = myCaps->ddsOldCaps.dwCaps;
myCaps->ddsCaps.dwCaps2 = 0;
myCaps->ddsCaps.dwCaps3 = 0;
myCaps->ddsCaps.dwCaps4 = 0;
myCaps->dwSize = sizeof(DDCAPS_DX7);
retVal = DD_OK;
}
break;
default:
retVal = DDERR_INVALIDPARAMS;
break;
}
}
if (pHELCaps)
{
/* Setup software caps */
LPDDCORECAPS CoreCaps = (LPDDCORECAPS)&This->lpLcl->lpGbl->ddHELCaps;
DWORD dwTotal = 0;
DWORD dwFree = 0;
switch (pHELCaps->dwSize)
{
case sizeof(DDCAPS_DX1):
{
LPDDCAPS_DX1 myCaps = (LPDDCAPS_DX1) pHELCaps;
if (CoreCaps->dwSize == sizeof(DDCORECAPS))
{
memcpy(myCaps, CoreCaps, sizeof(DDCAPS_DX1));
}
myCaps->dwVidMemFree = dwFree;
myCaps->dwVidMemTotal = dwTotal;
myCaps->dwSize = sizeof(DDCAPS_DX1);
retVal = DD_OK;
}
break;
case sizeof(DDCAPS_DX3):
{
LPDDCAPS_DX3 myCaps = (LPDDCAPS_DX3) pHELCaps;
if (CoreCaps->dwSize == sizeof(DDCORECAPS))
{
memcpy(&myCaps->dwCaps, &CoreCaps->dwCaps, sizeof(DDCAPS_DX3));
}
myCaps->dwVidMemFree = dwFree;
myCaps->dwVidMemTotal = dwTotal;
myCaps->dwSize = sizeof(DDCAPS_DX3);
retVal = DD_OK;
}
break;
case sizeof(DDCAPS_DX5):
{
LPDDCAPS_DX5 myCaps = (LPDDCAPS_DX5) pHELCaps;
/* FIXME This->lpLcl->lpGbl->lpddNLVHELCaps are not set in startup.c
if (This->lpLcl->lpGbl->lpddNLVHELCaps->dwSize == sizeof(DDNONLOCALVIDMEMCAPS))
{
memcpy(&myCaps->dwNLVBCaps, This->lpLcl->lpGbl->lpddNLVHELCaps, sizeof(DDNONLOCALVIDMEMCAPS));
}
*/
memset(&myCaps->dwNLVBCaps,0,sizeof(DDNONLOCALVIDMEMCAPS));
if (CoreCaps->dwSize == sizeof(DDCORECAPS))
{
memcpy(&myCaps->dwCaps, &CoreCaps->dwCaps, sizeof(DDCORECAPS));
}
myCaps->dwVidMemFree = dwFree;
myCaps->dwVidMemTotal = dwTotal;
myCaps->dwSize = sizeof(DDCAPS_DX5);
retVal = DD_OK;
}
break;
/* DDCAPS_DX6 is same as DDCAPS_DX7 */
case sizeof(DDCAPS_DX7):
{
LPDDCAPS_DX7 myCaps = (LPDDCAPS_DX7) pHELCaps;
/* FIXME This->lpLcl->lpGbl->lpddNLVHELCaps are not set in startup.c
if (This->lpLcl->lpGbl->lpddNLVHELCaps->dwSize == sizeof(DDNONLOCALVIDMEMCAPS))
{
memcpy(&myCaps->dwNLVBCaps, This->lpLcl->lpGbl->lpddNLVHELCaps, sizeof(DDNONLOCALVIDMEMCAPS));
}
*/
memset(&myCaps->dwNLVBCaps,0,sizeof(DDNONLOCALVIDMEMCAPS));
if (CoreCaps->dwSize == sizeof(DDCORECAPS))
{
memcpy(&myCaps->dwCaps, &CoreCaps->dwCaps, sizeof(DDCORECAPS));
}
myCaps->dwVidMemFree = dwFree;
myCaps->dwVidMemTotal = dwTotal;
myCaps->ddsCaps.dwCaps = myCaps->ddsOldCaps.dwCaps;
myCaps->ddsCaps.dwCaps2 = 0;
myCaps->ddsCaps.dwCaps3 = 0;
myCaps->ddsCaps.dwCaps4 = 0;
myCaps->dwSize = sizeof(DDCAPS_DX7);
retVal = DD_OK;
}
break;
default:
retVal = DDERR_INVALIDPARAMS;
break;
}
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
retVal = DD_FALSE;
}
_SEH2_END;
LeaveCriticalSection( &ddcs );
return retVal;
}
HRESULT WINAPI
Main_DirectDraw_EnumDisplayModes(LPDDRAWI_DIRECTDRAW_INT This, DWORD dwFlags,
LPDDSURFACEDESC pDDSD, LPVOID pContext, LPDDENUMMODESCALLBACK pCallback)
{
HRESULT ret = DD_OK;
INT iMode = 0;
DEVMODE DevMode;
DX_WINDBG_trace();
ZeroMemory(&DevMode, sizeof(DEVMODE));
_SEH2_TRY
{
if (pDDSD != NULL)
{
if (pDDSD->dwSize != sizeof(DDSURFACEDESC))
{
ret = DDERR_INVALIDPARAMS;
}
}
if (IsBadCodePtr((LPVOID)pCallback))
{
ret = DDERR_INVALIDPARAMS;
}
else if ( ret == DD_OK)
{
DevMode.dmSize = sizeof(DEVMODE);
while (EnumDisplaySettingsEx(NULL, iMode, &DevMode, 0) == TRUE)
{
DDSURFACEDESC SurfaceDesc;
ZeroMemory(&SurfaceDesc, sizeof(DDSURFACEDESC));
iMode++;
SurfaceDesc.dwSize = sizeof (DDSURFACEDESC);
SurfaceDesc.dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_REFRESHRATE | DDSD_WIDTH | DDSD_PIXELFORMAT;
SurfaceDesc.dwHeight = DevMode.dmPelsHeight;
SurfaceDesc.dwWidth = DevMode.dmPelsWidth;
SurfaceDesc.lPitch = DevMode.dmPelsWidth * DevMode.dmBitsPerPel / 8;
SurfaceDesc.dwRefreshRate = DevMode.dmDisplayFrequency;
SurfaceDesc.ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
SurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_RGB;
// FIXME: get these
/*
SurfaceDesc.ddpfPixelFormat.dwRBitMask =
SurfaceDesc.ddpfPixelFormat.dwGBitMask =
SurfaceDesc.ddpfPixelFormat.dwBBitMask =
SurfaceDesc.ddpfPixelFormat.dwRGBAlphaBitMask =
*/
SurfaceDesc.ddpfPixelFormat.dwRGBBitCount = DevMode.dmBitsPerPel;
// FIXME1: This->lpLcl->lpGbl->dwMonitorFrequency is not set !
if(dwFlags & DDEDM_REFRESHRATES && SurfaceDesc.dwRefreshRate != This->lpLcl->lpGbl->dwMonitorFrequency)
{
//continue; // FIXME2: what is SurfaceDesc.dwRefreshRate supposed to be set to ?
}
// FIXME: Take case when DDEDM_STANDARDVGAMODES flag is not set in account
if(pDDSD)
{
if(pDDSD->dwFlags & DDSD_HEIGHT && pDDSD->dwHeight != SurfaceDesc.dwHeight)
continue;
else if(pDDSD->dwFlags & DDSD_WIDTH && pDDSD->dwWidth != SurfaceDesc.dwWidth)
continue;
else if(pDDSD->dwFlags & DDSD_PITCH && pDDSD->lPitch != SurfaceDesc.lPitch)
continue;
else if(pDDSD->dwFlags & DDSD_REFRESHRATE && pDDSD->dwRefreshRate != SurfaceDesc.dwRefreshRate)
continue;
else if(pDDSD->dwFlags & DDSD_PIXELFORMAT && pDDSD->ddpfPixelFormat.dwRGBBitCount != SurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
continue; // FIXME: test for the other members of ddpfPixelFormat as well
}
if((*pCallback)(&SurfaceDesc, pContext) == DDENUMRET_CANCEL)
break;
}
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_END;
return ret;
}
HRESULT WINAPI Main_DDrawSurface_Blt(LPDDRAWI_DDRAWSURFACE_INT ThisDest, LPRECT rdst,
LPDDRAWI_DDRAWSURFACE_INT ThisSrc, LPRECT rsrc, DWORD dwFlags, LPDDBLTFX lpbltfx)
{
DDHAL_BLTDATA mDdBlt;
DX_WINDBG_trace();
if (ThisDest == NULL)
{
return DDERR_INVALIDPARAMS;
}
/* Zero out members in DDHAL_BLTDATA */
ZeroMemory(&mDdBlt, sizeof(DDHAL_BLTDATA));
ZeroMemory(&mDdBlt.bltFX, sizeof(DDBLTFX));
/* Check if we got HAL support for this api */
if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
DDHAL_SURFCB32_BLT) == DDHAL_SURFCB32_BLT)
{
mDdBlt.Blt = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Blt;
}
/* Check if we got HEL support for this api */
else if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
DDHAL_SURFCB32_BLT) == DDHAL_SURFCB32_BLT)
{
mDdBlt.Blt = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Blt;
}
if (mDdBlt.Blt == NULL)
{
/* This API is unsupported */
return DDERR_UNSUPPORTED;
}
/* Prepare for draw, if we do not reset the DdResetVisrgn some graphics card will not draw on the screen */
if (!DdResetVisrgn( ThisDest->lpLcl->lpSurfMore->slist[0], NULL))
{
DX_STUB_str("DdResetVisrgn failed");
}
mDdBlt.lpDD = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
mDdBlt.lpDDDestSurface = ThisDest->lpLcl->lpSurfMore->slist[0];
ThisDest->lpLcl->lpSurfMore->slist[0]->hDC = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->hDC;
/* Setup Src */
if (( ThisSrc != NULL ) )
{
mDdBlt.lpDDSrcSurface = ThisSrc->lpLcl->lpSurfMore->slist[0];
ThisSrc->lpLcl->lpSurfMore->slist[0]->hDC = ThisSrc->lpLcl->lpSurfMore->lpDD_lcl->hDC;
if (rsrc != NULL)
{
memmove(&mDdBlt.rSrc, rsrc, sizeof (RECTL));
}
else
{
if(!GetWindowRect((HWND)ThisSrc->lpLcl->lpSurfMore->lpDD_lcl->hWnd,
(RECT *)&mDdBlt.rSrc))
{
DX_STUB_str("GetWindowRect failed");
}
}
/* FIXME
* compare so we do not write too far
* ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
* ThisDest->lpLcl->lpGbl->wHeight <- surface max height
* ThisDest->lpLcl->lpGbl->lPitch <- surface bpp
*/
}
/* Setup dest */
if (rdst != NULL)
{
memmove(&mDdBlt.rDest, rdst, sizeof (RECTL));
}
else
{
if (!GetWindowRect((HWND)ThisDest->lpLcl->lpSurfMore->lpDD_lcl->hWnd,
(RECT *)&mDdBlt.rDest))
{
DX_STUB_str("GetWindowRect failed");
}
}
/* FIXME
* compare so we do not write too far
* ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
* ThisDest->lpLcl->lpGbl->wHeight <- surface max height
* ThisDest->lpLcl->lpGbl->lPitch <- surface bpp
*/
/* setup bltFX */
if (lpbltfx != NULL)
{
memmove(&mDdBlt.bltFX, lpbltfx, sizeof (DDBLTFX));
}
/* setup value that are not config yet */
mDdBlt.dwFlags = dwFlags;
mDdBlt.IsClipped = FALSE;
mDdBlt.bltFX.dwSize = sizeof(DDBLTFX);
/* FIXME
BltData.dwRectCnt
BltData.dwROPFlags
BltData.IsClipped
BltData.prDestRects
BltData.rOrigDest
BltData.rOrigSrc
BltData.ddRVal
*/
if (mDdBlt.Blt(&mDdBlt) != DDHAL_DRIVER_HANDLED)
{
DX_STUB_str("mDdBlt DDHAL_DRIVER_HANDLED");
return DDERR_NOBLTHW;
}
return mDdBlt.ddRVal;
}
HRESULT WINAPI
Main_DDrawSurface_QueryInterface(LPDDRAWI_DDRAWSURFACE_INT This, REFIID riid, LPVOID* ppObj)
{
HRESULT retVal = DD_OK;
*ppObj = NULL;
DX_WINDBG_trace();
_SEH2_TRY
{
if (IsEqualGUID(&IID_IDirectDrawSurface7, riid))
{
if (This->lpVtbl != &DirectDrawSurface7_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawSurface7_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawSurface4, riid))
{
if (This->lpVtbl != &DirectDrawSurface4_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawSurface4_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawSurface3, riid))
{
if (This->lpVtbl != &DirectDrawSurface3_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawSurface3_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawSurface2, riid))
{
if (This->lpVtbl != &DirectDrawSurface2_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawSurface2_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawSurface, riid))
{
if (This->lpVtbl != &DirectDrawSurface_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawSurface_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawColorControl, riid))
{
if (This->lpVtbl != &DirectDrawColorControl_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawColorControl_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawGammaControl, riid))
{
if (This->lpVtbl != &DirectDrawGammaControl_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawGammaControl_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawSurfaceKernel, riid))
{
if (This->lpVtbl != &DirectDrawSurfaceKernel_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawSurfaceKernel_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirect3D, riid))
{
if (This->lpVtbl != &IDirect3D_Vtbl)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &IDirect3D_Vtbl;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirect3D2, riid))
{
if (This->lpVtbl != &IDirect3D2_Vtbl)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &IDirect3D2_Vtbl;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirect3D3, riid))
{
if (This->lpVtbl != &IDirect3D3_Vtbl)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &IDirect3D3_Vtbl;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirect3D7, riid))
{
if (This->lpVtbl != &IDirect3D7_Vtbl)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &IDirect3D7_Vtbl;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else
{
DX_STUB_str("E_NOINTERFACE");
retVal = E_NOINTERFACE;
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_END;
return retVal;
}
HRESULT WINAPI
Main_D3D_EvictManagedTextures(LPDIRECT3D7 iface)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI
Main_D3D_Release(LPDIRECT3D iface)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_D3D_EnumZBufferFormats(LPDIRECT3D7 iface, REFCLSID riidDevice, LPD3DENUMPIXELFORMATSCALLBACK lpEnumCallback,LPVOID lpContext)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI
Main_D3D_AddRef(LPDIRECT3D iface)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DirectDraw_QueryInterface (LPDDRAWI_DIRECTDRAW_INT This,
REFIID id,
LPVOID *obj)
{
HRESULT retVal = DD_OK;
DX_WINDBG_trace();
_SEH2_TRY
{
/* FIXME
the D3D object can be optained from here
Direct3D7
*/
if (IsEqualGUID(&IID_IDirectDraw7, id))
{
if (This->lpVtbl != &DirectDraw7_Vtable)
{
This = internal_directdraw_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDraw7_Vtable;
*obj = This;
Main_DirectDraw_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDraw4, id))
{
if (This->lpVtbl != &DirectDraw4_Vtable)
{
This = internal_directdraw_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDraw4_Vtable;
*obj = This;
Main_DirectDraw_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDraw2, id))
{
if (This->lpVtbl != &DirectDraw2_Vtable)
{
This = internal_directdraw_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDraw2_Vtable;
*obj = This;
Main_DirectDraw_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDraw, id))
{
if (This->lpVtbl != &DirectDraw_Vtable)
{
This = internal_directdraw_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDraw_Vtable;
*obj = This;
Main_DirectDraw_AddRef(This);
}
else
{
*obj = NULL;
DX_STUB_str("E_NOINTERFACE");
retVal = E_NOINTERFACE;
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_END;
return retVal;
}
HRESULT WINAPI
Main_DirectDraw_GetAvailableVidMem4(LPDDRAWI_DIRECTDRAW_INT This, LPDDSCAPS2 ddscaps,
LPDWORD dwTotal, LPDWORD dwFree)
{
HRESULT retVal = DD_OK;
DDHAL_GETAVAILDRIVERMEMORYDATA memdata;
DX_WINDBG_trace();
_SEH2_TRY
{
// There is no HEL implentation of this api
if (!(This->lpLcl->lpDDCB->HALDDMiscellaneous.dwFlags & DDHAL_MISCCB32_GETAVAILDRIVERMEMORY) ||
(This->lpLcl->lpGbl->dwFlags & DDRAWI_NOHARDWARE) )
{
retVal = DDERR_NODIRECTDRAWHW;
}
else
{
if ((!dwTotal && !dwFree) || !ddscaps)
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
if ( ddscaps->dwCaps & (DDSCAPS_BACKBUFFER | DDSCAPS_COMPLEX | DDSCAPS_FLIP |
DDSCAPS_FRONTBUFFER | DDSCAPS_PALETTE | DDSCAPS_SYSTEMMEMORY |
DDSCAPS_VISIBLE | DDSCAPS_WRITEONLY | DDSCAPS_OWNDC))
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
/* ddscaps->dwCaps2 & 0x01
this flag is outdate and are
set to 0 in ms dxsdk the name of
this flag is DDSCAPS2_HARDWAREDEINTERLACE
*/
if ( ddscaps->dwCaps2 & 0x01)
{
retVal = DDERR_INVALIDCAPS;
_SEH2_LEAVE;
}
if ( ddscaps->dwCaps3 & ~( DDSCAPS3_MULTISAMPLE_QUALITY_MASK | DDSCAPS3_MULTISAMPLE_MASK |
DDSCAPS3_RESERVED1 | DDSCAPS3_RESERVED2 |
DDSCAPS3_LIGHTWEIGHTMIPMAP | DDSCAPS3_AUTOGENMIPMAP |
DDSCAPS3_DMAP))
{
retVal = DDERR_INVALIDCAPS;
_SEH2_LEAVE;
}
if ( ddscaps->dwCaps4)
{
retVal = DDERR_INVALIDCAPS;
_SEH2_LEAVE;
}
ZeroMemory(&memdata, sizeof(DDHAL_GETAVAILDRIVERMEMORYDATA));
memdata.lpDD = This->lpLcl->lpGbl;
memdata.ddRVal = DDERR_INVALIDPARAMS;
memdata.ddsCapsEx.dwCaps2 = ddscaps->dwCaps2;
memdata.ddsCapsEx.dwCaps3 = ddscaps->dwCaps3;
This->lpLcl->lpGbl->hDD = This->lpLcl->hDD;
if (This->lpLcl->lpDDCB->HALDDMiscellaneous.GetAvailDriverMemory(&memdata) == DDHAL_DRIVER_NOTHANDLED)
{
retVal = DDERR_NODIRECTDRAWHW;
if (dwTotal)
*dwTotal = 0;
if (dwFree)
*dwFree = 0;
}
else
{
if (dwTotal)
*dwTotal = memdata.dwTotal;
if (dwFree)
*dwFree = memdata.dwFree;
retVal = memdata.ddRVal;
}
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_END;
return retVal;
}
HRESULT WINAPI
Main_DirectDraw_SetDisplayMode2 (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwWidth, DWORD dwHeight,
DWORD dwBPP, DWORD dwRefreshRate, DWORD dwFlags)
{
HRESULT ret = DD_OK;
DX_WINDBG_trace();
_SEH2_TRY
{
// FIXME: Check primary if surface is locked / busy etc.
// Check Parameters
if(dwFlags != 0)
{
ret = DDERR_INVALIDPARAMS;
}
else
{
if ((!dwHeight || This->lpLcl->lpGbl->vmiData.dwDisplayHeight == dwHeight) &&
(!dwWidth || This->lpLcl->lpGbl->vmiData.dwDisplayWidth == dwWidth) &&
(!dwBPP || This->lpLcl->lpGbl->vmiData.ddpfDisplay.dwRGBBitCount == dwBPP) &&
(!dwRefreshRate || This->lpLcl->lpGbl->dwMonitorFrequency == dwRefreshRate))
{
ret = DD_OK; // nothing to do here for us
}
else
{
LONG retval;
// Here we go
DEVMODE DevMode;
ZeroMemory(&DevMode, sizeof(DEVMODE));
DevMode.dmSize = sizeof(DEVMODE);
if (dwHeight)
DevMode.dmFields |= DM_PELSHEIGHT;
if (dwWidth)
DevMode.dmFields |= DM_PELSWIDTH;
if (dwBPP)
DevMode.dmFields |= DM_BITSPERPEL;
if (dwRefreshRate)
DevMode.dmFields |= DM_DISPLAYFREQUENCY;
DevMode.dmPelsHeight = dwHeight;
DevMode.dmPelsWidth = dwWidth;
DevMode.dmBitsPerPel = dwBPP;
DevMode.dmDisplayFrequency = dwRefreshRate;
DX_WINDBG_trace_res(dwWidth, dwHeight,dwBPP, dwRefreshRate);
retval = ChangeDisplaySettings(&DevMode, CDS_FULLSCREEN);
/* FIXME: Are we supposed to set CDS_SET_PRIMARY as well ? */
if(retval == DISP_CHANGE_BADMODE)
{
/* Note : it seam ms ddraw ignore this and try using the bad mode any case.
* tested with Ati HD2400 that only support 16 and 32 Bpp in windows
*/
DX_STUB_str("Warning ChangeDisplaySettings return DISP_CHANGE_BADMODE, but ddraw.dll ignore it\n");
//ret = DDERR_UNSUPPORTED;
BOOL ModeChanged;
This->lpLcl->lpGbl->hDD = This->lpLcl->hDD;
DdReenableDirectDrawObject(This->lpLcl->lpGbl, &ModeChanged);
StartDirectDraw((LPDIRECTDRAW)This, 0, TRUE);
}
else if(retval != DISP_CHANGE_SUCCESSFUL)
{
ret = DDERR_GENERIC;
}
else
{
// Update Interals
BOOL ModeChanged;
This->lpLcl->lpGbl->hDD = This->lpLcl->hDD;
DdReenableDirectDrawObject(This->lpLcl->lpGbl, &ModeChanged);
StartDirectDraw((LPDIRECTDRAW)This, 0, TRUE);
}
}
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_END;
return ret;
}
DWORD CALLBACK HelDdSurfUnlock(LPDDHAL_UNLOCKDATA lpUnLockData)
{
HDC hDC;
HBITMAP hImage = NULL;
HDC hMemDC = NULL;
HBITMAP hDCBmp = NULL;
BITMAP bm = {0};
DX_WINDBG_trace();
/* Get our hdc for the active window */
hDC = GetDC((HWND)lpUnLockData->lpDDSurface->lpSurfMore->lpDD_lcl->hFocusWnd);
if (hDC != NULL)
{
/* Create a memory bitmap to store a copy of current hdc surface */
/* fixme the rcarea are not store in the struct yet so the data will look corupted */
hImage = CreateCompatibleBitmap (hDC, lpUnLockData->lpDDSurface->lpGbl->wWidth, lpUnLockData->lpDDSurface->lpGbl->wHeight);
/* Create a memory hdc so we can draw on our current memory bitmap */
hMemDC = CreateCompatibleDC(hDC);
if (hMemDC != NULL)
{
/* Select our memory bitmap to our memory hdc */
hDCBmp = (HBITMAP) SelectObject (hMemDC, hImage);
/* Get our memory bitmap information */
GetObject(hImage, sizeof(BITMAP), &bm);
SetBitmapBits(hImage,bm.bmWidthBytes * bm.bmHeight, lpUnLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2);
BitBlt (hDC, 0, 0, bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
SelectObject (hMemDC, hDCBmp);
/* Setup return value */
lpUnLockData->ddRVal = DD_OK;
}
}
/* Cleanup after us */
if (hImage != NULL)
{
DeleteObject (hImage);
}
if (hMemDC != NULL)
{
DeleteDC (hMemDC);
}
if (lpUnLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2 != NULL)
{
HeapFree(GetProcessHeap(), 0, lpUnLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2 );
}
return DDHAL_DRIVER_HANDLED;
}
HRESULT WINAPI
Main_D3D_Initialize(LPDIRECT3D iface, REFIID refiid)
{
DX_WINDBG_trace();
DX_STUB;
}
DWORD CALLBACK HelDdSurfLock(LPDDHAL_LOCKDATA lpLockData)
{
HDC hDC;
HBITMAP hImage = NULL;
LONG cbBuffer = 0;
LPDWORD pixels = NULL;
HDC hMemDC = NULL;
HBITMAP hDCBmp = NULL;
BITMAP bm = {0};
DX_WINDBG_trace();
/* ToDo tell ddraw internal this surface is locked */
/* ToDo add support for dwFlags */
/* Get our hdc for the active window */
hDC = GetDC((HWND)lpLockData->lpDDSurface->lpSurfMore->lpDD_lcl->hFocusWnd);
if (hDC != NULL)
{
/* Create a memory bitmap to store a copy of current hdc surface */
if (!lpLockData->bHasRect)
{
hImage = CreateCompatibleBitmap (hDC, lpLockData->lpDDSurface->lpGbl->wWidth, lpLockData->lpDDSurface->lpGbl->wHeight);
}
else
{
hImage = CreateCompatibleBitmap (hDC, lpLockData->rArea.right, lpLockData->rArea.bottom);
}
/* Create a memory hdc so we can draw on our current memory bitmap */
hMemDC = CreateCompatibleDC(hDC);
if (hMemDC != NULL)
{
/* Select our memory bitmap to our memory hdc */
hDCBmp = (HBITMAP) SelectObject (hMemDC, hImage);
/* Get our memory bitmap information */
GetObject(hImage, sizeof(BITMAP), &bm);
if (!lpLockData->bHasRect)
{
BitBlt (hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, hDC, 0, 0, SRCCOPY);
}
else
{
BitBlt (hMemDC, lpLockData->rArea.top, lpLockData->rArea.left, lpLockData->rArea.right, lpLockData->rArea.bottom, hDC, 0, 0, SRCCOPY);
}
SelectObject (hMemDC, hDCBmp);
/* Allocate memory buffer for the bitmap pixel data */
cbBuffer = bm.bmWidthBytes * bm.bmHeight ;
pixels = (PDWORD) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbBuffer );
if (pixels != NULL)
{
/* Get the bitmap bits */
GetBitmapBits(hImage,cbBuffer,pixels);
/* Fixme HACK - check which member stores the HEL bitmap buffer */
lpLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2 = pixels;
/* Setup return value */
lpLockData->ddRVal = DD_OK;
lpLockData->lpSurfData = pixels;
}
}
}
/* Free the pixels buffer if we fail */
if ( (pixels != NULL) &&
(lpLockData->ddRVal != DD_OK) )
{
HeapFree(GetProcessHeap(), 0, pixels );
}
/* Cleanup after us */
if (hImage != NULL)
{
DeleteObject (hImage);
}
if (hMemDC != NULL)
{
DeleteDC (hMemDC);
}
return DDHAL_DRIVER_HANDLED;
}
HRESULT WINAPI
Main_D3D_EnumDevices(LPDIRECT3D iface, LPD3DENUMDEVICESCALLBACK Callback, LPVOID Context)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DDrawSurface_Lock (LPDDRAWI_DDRAWSURFACE_INT ThisDest, LPRECT prect,
LPDDSURFACEDESC2 pDDSD, DWORD flags, HANDLE events)
{
DDHAL_LOCKDATA mdLock;
DX_WINDBG_trace();
DX_WINDBG_trace_res( (DWORD)ThisDest->lpLcl->lpGbl->wWidth, (DWORD)ThisDest->lpLcl->lpGbl->wHeight, (DWORD)ThisDest->lpLcl->lpGbl->lPitch, (DWORD) 0);
/* Zero out members in DDHAL_LOCKDATA */
ZeroMemory(&mdLock, sizeof(DDHAL_LOCKDATA));
/* Check if we got HAL support for this api */
if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
DDHAL_SURFCB32_LOCK) == DDHAL_SURFCB32_LOCK)
{
mdLock.Lock = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Lock;
}
/* Check if we got HEL support for this api */
else if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
DDHAL_SURFCB32_LOCK) == DDHAL_SURFCB32_LOCK)
{
mdLock.Lock = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Lock;
}
if (mdLock.Lock == NULL)
{
/* This api are unsupported */
return DDERR_UNSUPPORTED;
}
if (events != NULL)
{
return DDERR_INVALIDPARAMS;
}
/* FIXME add a check see if lock support or not */
if (prect!=NULL)
{
mdLock.bHasRect = TRUE;
memcpy(&mdLock.rArea,prect,sizeof(RECTL));
}
else
{
mdLock.bHasRect = FALSE;
}
//FIXME check if it primary or not and use primary or pixelformat data, at moment it is hardcode to primary
mdLock.ddRVal = DDERR_CANTLOCKSURFACE;
mdLock.dwFlags = flags;
mdLock.lpDDSurface = ThisDest->lpLcl->lpSurfMore->slist[0];
mdLock.lpDD = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
mdLock.lpSurfData = NULL;
if (!DdResetVisrgn(ThisDest->lpLcl->lpSurfMore->slist[0], NULL))
{
DX_STUB_str("Here DdResetVisrgn lock");
// return DDERR_UNSUPPORTED;
}
if (mdLock.Lock(&mdLock)!= DDHAL_DRIVER_HANDLED)
{
DX_STUB_str("Here DDHAL_DRIVER_HANDLED lock");
return DDERR_UNSUPPORTED;
}
// FIXME ??? is this right ??
if (pDDSD != NULL)
{
ZeroMemory(pDDSD,sizeof(DDSURFACEDESC2));
pDDSD->dwSize = sizeof(DDSURFACEDESC2);
//if (pDDSD->dwSize == sizeof(DDSURFACEDESC2))
//{
// ZeroMemory(pDDSD,sizeof(DDSURFACEDESC2));
// // FIXME the internal mddsdPrimary shall be DDSURFACEDESC2
// memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
// pDDSD->dwSize = sizeof(DDSURFACEDESC2);
//}
//if (pDDSD->dwSize == sizeof(DDSURFACEDESC))
//{
// RtlZeroMemory(pDDSD,sizeof(DDSURFACEDESC));
// memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
// pDDSD->dwSize = sizeof(DDSURFACEDESC);
//}
pDDSD->lpSurface = (LPVOID) mdLock.lpSurfData;
pDDSD->dwHeight = ThisDest->lpLcl->lpGbl->wHeight;
pDDSD->dwWidth = ThisDest->lpLcl->lpGbl->wWidth;
pDDSD->ddpfPixelFormat.dwRGBBitCount = ThisDest->lpLcl->lpGbl->lpDD->lpModeInfo->dwBPP;// .lpModeInfo->dwBPP; //This->lpLcl->lpGbl->lPitch/ 8;
pDDSD->lPitch = ThisDest->lpLcl->lpGbl->lPitch;
pDDSD->dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH;
}
return mdLock.ddRVal;
}
HRESULT WINAPI
Main_D3D_CreateLight(LPDIRECT3D iface, LPDIRECT3DLIGHT* Light,IUnknown* pUnkOuter)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DDrawSurface_GetSurfaceDesc(LPDDRAWI_DDRAWSURFACE_INT This,
LPDDSURFACEDESC2 pDDSD)
{
DWORD dwSize;
DX_WINDBG_trace();
dwSize = pDDSD->dwSize;
if ((dwSize != sizeof(DDSURFACEDESC)) &&
(dwSize != sizeof(DDSURFACEDESC2)))
{
return DDERR_GENERIC;
}
ZeroMemory(pDDSD,dwSize);
if (dwSize == sizeof(DDSURFACEDESC))
{
LPDDSURFACEDESC lpDS = (LPDDSURFACEDESC) pDDSD;
memcpy(&lpDS->ddckCKDestBlt, &This->lpLcl->ddckCKDestBlt, sizeof(DDCOLORKEY));
memcpy(&lpDS->ddckCKDestOverlay, &This->lpLcl->ddckCKDestOverlay, sizeof(DDCOLORKEY));
memcpy(&lpDS->ddckCKSrcBlt, &This->lpLcl->ddckCKSrcBlt, sizeof(DDCOLORKEY));
memcpy(&lpDS->ddckCKSrcOverlay, &This->lpLcl->ddckCKSrcOverlay, sizeof(DDCOLORKEY));
memcpy(&lpDS->ddpfPixelFormat, &This->lpLcl->lpGbl->ddpfSurface, sizeof(DDPIXELFORMAT));
memcpy(&lpDS->ddsCaps, &This->lpLcl->ddsCaps, sizeof(DDSCAPS));
lpDS->dwAlphaBitDepth = This->lpLcl->dwAlpha;
lpDS->dwBackBufferCount = This->lpLcl->dwBackBufferCount;
/* FIXME setting the flags right */
// lpDS->dwFlags = This->lpLcl->dwFlags;
lpDS->dwHeight = This->lpLcl->lpGbl->wHeight;
lpDS->dwWidth = This->lpLcl->lpGbl->wWidth;
/* This two are a union in lpDS and in This->lpLcl->lpGbl
so I comment out lPitch
lpDS->lPitch = This->lpLcl->lpGbl->lPitch;
*/
lpDS->dwLinearSize = This->lpLcl->lpGbl->dwLinearSize;
/* This tree are a union */
//lpDS->dwMipMapCount
//lpDS->dwRefreshRate
//lpDS->dwZBufferBitDepth
/* Unknown */
// lpDS->dwReserved
// lpDS->lpSurface
}
else
{
memcpy(&pDDSD->ddckCKDestBlt, &This->lpLcl->ddckCKDestBlt, sizeof(DDCOLORKEY));
/*
pDDSD->dwEmptyFaceColor is a union to ddckCKDestOverlay
*/
memcpy(&pDDSD->ddckCKDestOverlay, &This->lpLcl->ddckCKDestOverlay, sizeof(DDCOLORKEY));
memcpy(&pDDSD->ddckCKSrcBlt, &This->lpLcl->ddckCKSrcBlt, sizeof(DDCOLORKEY));
memcpy(&pDDSD->ddckCKSrcOverlay, &This->lpLcl->ddckCKSrcOverlay, sizeof(DDCOLORKEY));
/*
pDDSD->dwFVF is a union to ddpfPixelFormat
*/
memcpy(&pDDSD->ddpfPixelFormat, &This->lpLcl->lpGbl->ddpfSurface, sizeof(DDPIXELFORMAT));
memcpy(&pDDSD->ddsCaps, &This->lpLcl->ddsCaps, sizeof(DDSCAPS));
pDDSD->dwAlphaBitDepth = This->lpLcl->dwAlpha;
pDDSD->dwBackBufferCount = This->lpLcl->dwBackBufferCount;
/* FIXME setting the flags right */
// lpDS->dwFlags = This->lpLcl->dwFlags;
pDDSD->dwHeight = This->lpLcl->lpGbl->wHeight;
pDDSD->dwWidth = This->lpLcl->lpGbl->wWidth;
/* This two are a union in lpDS and in This->lpLcl->lpGbl
so I comment out lPitch
lpDS->lPitch = This->lpLcl->lpGbl->lPitch;
*/
pDDSD->dwLinearSize = This->lpLcl->lpGbl->dwLinearSize;
/* This tree are a union */
// pDDSD->dwMipMapCount
// pDDSD->dwRefreshRate
// pDDSD->dwSrcVBHandle
/* Unknown */
// lpDS->dwReserved
// lpDS->lpSurface
// pDDSD->dwTextureStage
}
return DD_OK;
}
HRESULT WINAPI
Main_D3D_QueryInterface(LPDIRECT3D iface, REFIID riid, LPVOID * ppvObj)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DirectDraw_GetDeviceIdentifier7(LPDDRAWI_DIRECTDRAW_INT This,
LPDDDEVICEIDENTIFIER2 pDDDI, DWORD dwFlags)
{
HRESULT retVal = DDERR_INVALIDPARAMS;
BOOL found = FALSE;
DWORD iDevNum = 0;
DISPLAY_DEVICEA DisplayDeviceA;
HKEY hKey;
DWORD lpType = 0;
DWORD strSize = MAX_DDDEVICEID_STRING;
char *pdest;
char* pcCnvEnd;
long *lpdata;
DX_WINDBG_trace();
EnterCriticalSection( &ddcs );
_SEH2_TRY
{
if ( (IsBadWritePtr( pDDDI, sizeof(DDDEVICEIDENTIFIER2) ) ) ||
(dwFlags & ~DDGDI_GETHOSTIDENTIFIER))
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
/* now we can start getting the driver data */
while (1)
{
ZeroMemory(&DisplayDeviceA,sizeof(DISPLAY_DEVICEA));
DisplayDeviceA.cb = sizeof(DISPLAY_DEVICEA);
if ( EnumDisplayDevicesA( NULL, iDevNum, &DisplayDeviceA, 0) == 0)
{
retVal = DDERR_INVALIDPARAMS;
break;
}
if (_stricmp(DisplayDeviceA.DeviceName, This->lpLcl->lpGbl->cDriverName) != 0)
{
/* if we got another device like hardware mpeg decoder or video card or another drv */
found = TRUE;
}
else if (DisplayDeviceA.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
{
/* double check if it primary driver we just found */
if (!_stricmp( This->lpLcl->lpGbl->cDriverName, "DISPLAY"))
{
/* yeah we found it */
found = TRUE;
}
}
if (found == TRUE)
{
/* we found our driver now we start setup it */
if (!_strnicmp(DisplayDeviceA.DeviceKey,"\\REGISTRY\\Machine\\",18))
{
if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, &DisplayDeviceA.DeviceKey[18], 0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS )
{
if (RegQueryValueExA(hKey, "InstalledDisplayDrivers",0, &lpType, (LPBYTE)pDDDI->szDriver, &strSize) != ERROR_SUCCESS)
{
ZeroMemory(pDDDI->szDriver,MAX_DDDEVICEID_STRING);
}
else
{
strcat(pDDDI->szDriver,".dll");
}
RegCloseKey(hKey);
}
strcpy( pDDDI->szDescription, DisplayDeviceA.DeviceString);
pDDDI->liDriverVersion.HighPart = 0;
pDDDI->liDriverVersion.LowPart = 0;
pdest = strstr(DisplayDeviceA.DeviceID,"REV_");
pDDDI->dwRevision = strtol ( &pdest[4], &pcCnvEnd, 16);
pdest = strstr(DisplayDeviceA.DeviceID,"SUBSYS_");
pDDDI->dwSubSysId = strtol ( &pdest[7], &pcCnvEnd, 16);
pdest = strstr(DisplayDeviceA.DeviceID,"DEV_");
pDDDI->dwDeviceId = strtol ( &pdest[4], &pcCnvEnd, 16);
pdest = strstr(DisplayDeviceA.DeviceID,"VEN_");
pDDDI->dwVendorId =strtol ( &pdest[4], &pcCnvEnd, 16);
/* Count out the guidDeviceIdentifier */
memcpy(&pDDDI->guidDeviceIdentifier, &CLSID_DirectDraw,sizeof(GUID));
pDDDI->guidDeviceIdentifier.Data1 ^= pDDDI->dwVendorId;
lpdata = (long *)&pDDDI->guidDeviceIdentifier.Data2;
*lpdata ^= pDDDI->dwDeviceId;
lpdata = (long *)&pDDDI->guidDeviceIdentifier.Data4;
*lpdata = (*lpdata ^ pDDDI->dwSubSysId) ^ pDDDI->liDriverVersion.LowPart;
lpdata = (long *)&pDDDI->guidDeviceIdentifier.Data4[4];
*lpdata = (*lpdata ^ pDDDI->dwRevision) ^ pDDDI->liDriverVersion.HighPart;
/* FIXME pDDDI->dwWHQLLevel
* we leave this with no informations, I do not known
* if program care for it, I mark this api done, and
* tested, no bugs was found in it
*/
pDDDI->dwWHQLLevel = 0;
retVal = DD_OK;
}
break;
}
iDevNum++;
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
retVal = DD_FALSE;
}
_SEH2_END;
LeaveCriticalSection( &ddcs );
return retVal;
}
HRESULT WINAPI
Main_DirectDraw_SetCooperativeLevel (LPDDRAWI_DIRECTDRAW_INT This, HWND hwnd, DWORD cooplevel)
{
HRESULT retVal = DD_OK;
DX_WINDBG_trace();
_SEH2_TRY
{
if (hwnd && !IsWindow(hwnd))
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
// FIXME test if 0x20 exists as a flag and what thuse it do
if ( cooplevel & (~(DDSCL_FPUPRESERVE | DDSCL_FPUSETUP | DDSCL_MULTITHREADED | DDSCL_CREATEDEVICEWINDOW |
DDSCL_SETDEVICEWINDOW | DDSCL_SETFOCUSWINDOW | DDSCL_ALLOWMODEX | DDSCL_EXCLUSIVE |
DDSCL_NORMAL | DDSCL_NOWINDOWCHANGES | DDSCL_ALLOWREBOOT | DDSCL_FULLSCREEN)))
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
if (!( cooplevel & (DDSCL_NORMAL | DDSCL_EXCLUSIVE | DDSCL_SETFOCUSWINDOW)))
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
if ((cooplevel & DDSCL_FPUSETUP) && (cooplevel & DDSCL_FPUPRESERVE))
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
if ((cooplevel & DDSCL_EXCLUSIVE) && (!(cooplevel & DDSCL_FULLSCREEN)))
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
if ((cooplevel & DDSCL_ALLOWMODEX) && (!(cooplevel & DDSCL_FULLSCREEN)))
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
if ((cooplevel & (DDSCL_CREATEDEVICEWINDOW | DDSCL_SETFOCUSWINDOW)))
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
if (!cooplevel)
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
/* NORMAL MODE */
if(!(cooplevel & (~DDSCL_NORMAL)))
{
/* FIXME in setup.c set DDRAWI_UMODELOADED | DDRAWI_DISPLAYDRV | DDRAWI_EMULATIONINITIALIZED | DDRAWI_GDIDRV | DDRAWI_ATTACHEDTODESKTOP */
/* FIXME in setup.c This->lpLcl->lpGbl->dwFlags = */
This->lpLcl->dwLocalFlags = DDRAWILCL_SETCOOPCALLED | DDRAWILCL_DIRECTDRAW7 ;
This->lpLcl->hWnd = (ULONG_PTR) hwnd;
This->lpLcl->hFocusWnd = (ULONG_PTR) hwnd;
This->lpLcl->lpGbl->lpExclusiveOwner=NULL;
retVal = DD_OK;
_SEH2_LEAVE;
}
/* FULLSCREEN */
if ((!(cooplevel & (~(DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN)))) ||
(!(cooplevel & (~(DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX)))))
{
/* FIXME in setup.c This->lpLcl->lpGbl->dwFlags = */
if (hwnd == NULL)
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
if( (GetWindowLongPtr(hwnd, GWL_STYLE) & WS_CHILD) )
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
if( (This->lpLcl->lpGbl->lpExclusiveOwner != NULL) &&
(This->lpLcl->lpGbl->lpExclusiveOwner != This->lpLcl) )
{
retVal = DDERR_INVALIDPARAMS;
_SEH2_LEAVE;
}
This->lpLcl->lpGbl->lpExclusiveOwner = This-> lpLcl;
This->lpLcl->dwLocalFlags = DDRAWILCL_SETCOOPCALLED | DDRAWILCL_DIRECTDRAW7 | DDRAWILCL_HOOKEDHWND |
DDRAWILCL_HASEXCLUSIVEMODE | DDRAWILCL_ISFULLSCREEN | DDRAWILCL_ACTIVEYES |
DDRAWILCL_CURSORCLIPPED;
if (cooplevel & DDSCL_ALLOWMODEX)
{
This->lpLcl->dwLocalFlags = This->lpLcl->dwLocalFlags | DDRAWILCL_ALLOWMODEX;
}
This->lpLcl->hWnd = (ULONG_PTR) hwnd;
This->lpLcl->hFocusWnd = (ULONG_PTR) hwnd;
/* FIXME fullscreen are not finuish */
retVal = DD_OK;
_SEH2_LEAVE;
}
/*
* Code from wine, this functions have been cut and paste from wine 0.9.35
* and have been modify allot and are still in devloping so it match with
* msdn document struct and flags
*/
///* Handle those levels first which set various hwnds */
//if(cooplevel & DDSCL_SETFOCUSWINDOW)
//{
//
// if(This->lpLcl->dwLocalFlags & DDRAWILCL_SETCOOPCALLED)
// {
// retVal = DDERR_HWNDALREADYSET;
// _SEH2_LEAVE;
// }
// else if( (This->lpLcl->dwLocalFlags & DDRAWILCL_ISFULLSCREEN) && window)
// {
// retVal = DDERR_HWNDALREADYSET;
// _SEH2_LEAVE;
// }
// This->lpLcl->hFocusWnd = (ULONG_PTR) hwnd;
// /* Won't use the hwnd param for anything else */
// hwnd = NULL;
// /* Use the focus window for drawing too */
// This->lpLcl->hWnd = This->lpLcl->hFocusWnd;
//}
///* DDSCL_NORMAL or DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE */
//if(cooplevel & DDSCL_NORMAL)
//{
// /* Can't coexist with fullscreen or exclusive */
// if(cooplevel & (DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE) )
// {
// retVal = DDERR_INVALIDPARAMS;
// _SEH2_LEAVE;
// }
// /* Switching from fullscreen? */
// if(This->lpLcl->dwLocalFlags & DDRAWILCL_ISFULLSCREEN)
// {
// /* Restore the display mode */
// Main_DirectDraw_RestoreDisplayMode(iface);
// This->lpLcl->dwLocalFlags &= ~DDRAWILCL_ISFULLSCREEN;
// This->lpLcl->dwLocalFlags &= ~DDRAWILCL_HASEXCLUSIVEMODE;
// This->lpLcl->dwLocalFlags &= ~DDRAWILCL_ALLOWMODEX;
// }
// /* Don't override focus windows or private device windows */
// if( hwnd &&
// !(This->lpLcl->hFocusWnd) &&
// !(This->lpLcl->dwObsolete1) &&
// (hwnd != window) )
// {
// This->lpLcl->hWnd = (ULONG_PTR)hwnd;
// }
// /* FIXME GL
// IWineD3DDevice_SetFullscreen(This->wineD3DDevice,
// FALSE);
// */
// }
// else if(cooplevel & DDSCL_FULLSCREEN)
// {
// /* Needs DDSCL_EXCLUSIVE */
// if(!(cooplevel & DDSCL_EXCLUSIVE) )
// {
// retVal = DDERR_INVALIDPARAMS;
// _SEH2_LEAVE;
// }
// /* Switch from normal to full screen mode? */
// if (!(This->lpLcl->dwLocalFlags & DDRAWILCL_HASEXCLUSIVEMODE))
// {
// /* FIXME GL
// IWineD3DDevice_SetFullscreen(This->wineD3DDevice,
// TRUE);
// */
// }
// /* Don't override focus windows or private device windows */
// if( hwnd &&
// !(This->lpLcl->hFocusWnd) &&
// !(This->lpLcl->dwObsolete1) &&
// (hwnd != window) )
// {
// This->lpLcl->hWnd = (ULONG_PTR) hwnd;
// }
// }
// else if(cooplevel & DDSCL_EXCLUSIVE)
// {
// retVal = DDERR_INVALIDPARAMS;
// _SEH2_LEAVE;
// }
// if(cooplevel & DDSCL_CREATEDEVICEWINDOW)
// {
// /* Don't create a device window if a focus window is set */
// if( !This->lpLcl->hFocusWnd)
// {
// HWND devicewindow = CreateWindowExW(0, classname, L"DDraw device window",
// WS_POPUP, 0, 0,
// GetSystemMetrics(SM_CXSCREEN),
// GetSystemMetrics(SM_CYSCREEN),
// NULL, NULL, GetModuleHandleW(0), NULL);
// ShowWindow(devicewindow, SW_SHOW); /* Just to be sure */
// This->lpLcl->dwObsolete1 = (DWORD)devicewindow;
// }
// }
// if(cooplevel & DDSCL_MULTITHREADED && !(This->lpLcl->dwLocalFlags & DDRAWILCL_MULTITHREADED))
// {
// /* FIXME GL
// * IWineD3DDevice_SetMultithreaded(This->wineD3DDevice);
// */
// }
// /* Store the cooperative_level */
// /* FIXME GL
// * This->cooperative_level |= cooplevel;
// */
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_END;
return retVal;
}
