mirror of
https://github.com/reactos/reactos.git
synced 2024-08-26 21:28:48 +00:00
935 lines
25 KiB
C
935 lines
25 KiB
C
/*
|
|
* COPYRIGHT: See COPYING in the top level directory
|
|
* PROJECT: ReactOS DirectX
|
|
* FILE: dll/directx/ddraw/Surface/surface_main.c
|
|
* PURPOSE: IDirectDrawSurface7 Implementation
|
|
* PROGRAMMER: Magnus Olsen, Maarten Bosma
|
|
*
|
|
*/
|
|
|
|
#include "rosdraw.h"
|
|
|
|
|
|
/* FIXME adding hal and hel stub
|
|
DestroySurface;
|
|
SetClipList;
|
|
AddAttachedSurface;
|
|
GetFlipStatus;
|
|
SetOverlayPosition;
|
|
SetPalette;
|
|
*/
|
|
|
|
LPDDRAWI_DDRAWSURFACE_INT
|
|
internal_directdrawsurface_int_alloc(LPDDRAWI_DDRAWSURFACE_INT This)
|
|
{
|
|
LPDDRAWI_DDRAWSURFACE_INT newThis;
|
|
DxHeapMemAlloc(newThis, sizeof(DDRAWI_DDRAWSURFACE_INT));
|
|
if (newThis)
|
|
{
|
|
newThis->lpLcl = This->lpLcl;
|
|
newThis->lpLink = This;
|
|
}
|
|
return newThis;
|
|
}
|
|
|
|
HRESULT WINAPI Main_DDrawSurface_Initialize (LPDDRAWI_DDRAWSURFACE_INT iface, LPDIRECTDRAW pDD, LPDDSURFACEDESC2 pDDSD2)
|
|
{
|
|
return DDERR_ALREADYINITIALIZED;
|
|
}
|
|
|
|
ULONG WINAPI Main_DDrawSurface_AddRef(LPDDRAWI_DDRAWSURFACE_INT This)
|
|
{
|
|
|
|
DX_WINDBG_trace();
|
|
|
|
if (This!=NULL)
|
|
{
|
|
This->dwIntRefCnt++;
|
|
This->lpLcl->dwLocalRefCnt++;
|
|
|
|
if (This->lpLcl->lpGbl != NULL)
|
|
{
|
|
This->lpLcl->lpGbl->dwRefCnt++;
|
|
}
|
|
}
|
|
return This->dwIntRefCnt;
|
|
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
|
|
ULONG WINAPI Main_DDrawSurface_Release(LPDDRAWI_DDRAWSURFACE_INT This)
|
|
{
|
|
/* FIXME
|
|
This is not right exiame how it should be done
|
|
*/
|
|
ULONG ret = --This->dwIntRefCnt;
|
|
if(!ret)
|
|
{
|
|
DX_STUB_str("Release is a bit simplistic right now\n");
|
|
AcquireDDThreadLock();
|
|
DxHeapMemFree(This);
|
|
ReleaseDDThreadLock();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
ULONG WINAPI Main_DDrawSurface_Release4(LPDDRAWI_DDRAWSURFACE_INT This)
|
|
{
|
|
ULONG ref = Main_DDrawSurface_Release(This) ;
|
|
|
|
if(ref == 0) Main_DirectDraw_Release(This->lpLcl->lpSurfMore->lpDD_int);
|
|
|
|
return ref;
|
|
}
|
|
|
|
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_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_DDrawSurface_Unlock (LPDDRAWI_DDRAWSURFACE_INT This, LPRECT pRect)
|
|
{
|
|
DDHAL_UNLOCKDATA mdUnLock;
|
|
|
|
DX_WINDBG_trace();
|
|
|
|
/* Zero out members in DDHAL_UNLOCKDATA */
|
|
ZeroMemory(&mdUnLock, sizeof(DDHAL_UNLOCKDATA));
|
|
|
|
/* Check if we got HAL support for this api */
|
|
if (( This->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
|
|
DDHAL_SURFCB32_UNLOCK) == DDHAL_SURFCB32_UNLOCK)
|
|
{
|
|
mdUnLock.Unlock = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Unlock;
|
|
}
|
|
/* Check if we got HEL support for this api */
|
|
else if (( This->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
|
|
DDHAL_SURFCB32_UNLOCK) == DDHAL_SURFCB32_UNLOCK)
|
|
{
|
|
mdUnLock.Unlock = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Unlock;
|
|
}
|
|
|
|
if (mdUnLock.Unlock == NULL)
|
|
{
|
|
/* This api are unsupported */
|
|
return DDERR_UNSUPPORTED;
|
|
}
|
|
|
|
mdUnLock.ddRVal = DDERR_NOTPALETTIZED;
|
|
mdUnLock.lpDD = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
|
|
mdUnLock.lpDDSurface = This->lpLcl->lpSurfMore->slist[0];
|
|
|
|
if (!DdResetVisrgn( mdUnLock.lpDDSurface, NULL))
|
|
{
|
|
DX_STUB_str("DdResetVisrgn fail");
|
|
//return DDERR_UNSUPPORTED; /* this can fail */
|
|
}
|
|
|
|
if (mdUnLock.Unlock(&mdUnLock)!= DDHAL_DRIVER_HANDLED)
|
|
{
|
|
DX_STUB_str("unLock fail");
|
|
return DDERR_UNSUPPORTED;
|
|
}
|
|
|
|
return mdUnLock.ddRVal;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DDrawSurface_AddAttachedSurface(LPDDRAWI_DDRAWSURFACE_INT iface,
|
|
LPDDRAWI_DDRAWSURFACE_INT pAttach)
|
|
{
|
|
|
|
// LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
|
|
// LPDDRAWI_DDRAWSURFACE_INT That = (LPDDRAWI_DDRAWSURFACE_INT)pAttach;
|
|
|
|
DX_WINDBG_trace();
|
|
|
|
DX_STUB;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DDrawSurface_GetAttachedSurface(LPDDRAWI_DDRAWSURFACE_INT This,
|
|
LPDDSCAPS2 pCaps,
|
|
LPDDRAWI_DDRAWSURFACE_INT* ppSurface)
|
|
{
|
|
/* FIXME hacked */
|
|
|
|
|
|
DX_WINDBG_trace();
|
|
|
|
*ppSurface = This->lpLcl->lpGbl->lpDD->dsList;
|
|
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DDrawSurface_GetBltStatus(LPDDRAWI_DDRAWSURFACE_INT This, DWORD dwFlags)
|
|
{
|
|
|
|
DX_WINDBG_trace();
|
|
|
|
if (!(This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_FLIP))
|
|
{
|
|
return DDERR_GENERIC;
|
|
}
|
|
|
|
DX_STUB;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DDrawSurface_GetCaps(LPDDRAWI_DDRAWSURFACE_INT This, LPDDSCAPS2 pCaps)
|
|
{
|
|
|
|
DX_WINDBG_trace();
|
|
|
|
if (This == NULL)
|
|
{
|
|
return DDERR_INVALIDOBJECT;
|
|
}
|
|
|
|
if (pCaps == NULL)
|
|
{
|
|
return DDERR_INVALIDPARAMS;
|
|
}
|
|
|
|
RtlZeroMemory(pCaps,sizeof(DDSCAPS2));
|
|
|
|
pCaps->dwCaps = This->lpLcl->ddsCaps.dwCaps;
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DDrawSurface_GetClipper(LPDDRAWI_DDRAWSURFACE_INT This,
|
|
LPDIRECTDRAWCLIPPER* ppClipper)
|
|
{
|
|
|
|
DX_WINDBG_trace();
|
|
|
|
if (This == NULL)
|
|
{
|
|
return DDERR_INVALIDOBJECT;
|
|
}
|
|
|
|
if (ppClipper == NULL)
|
|
{
|
|
return DDERR_INVALIDPARAMS;
|
|
}
|
|
|
|
if (This->lpLcl->lp16DDClipper == NULL)
|
|
{
|
|
return DDERR_NOCLIPPERATTACHED;
|
|
}
|
|
|
|
*ppClipper = (LPDIRECTDRAWCLIPPER)This->lpLcl->lp16DDClipper;
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DDrawSurface_SetClipper (LPDDRAWI_DDRAWSURFACE_INT This,
|
|
LPDIRECTDRAWCLIPPER pDDClipper)
|
|
{
|
|
|
|
DX_WINDBG_trace();
|
|
|
|
if (This == NULL)
|
|
{
|
|
return DDERR_INVALIDOBJECT;
|
|
}
|
|
|
|
if(pDDClipper == NULL)
|
|
{
|
|
if(!This->lpLcl->lp16DDClipper)
|
|
return DDERR_NOCLIPPERATTACHED;
|
|
|
|
DirectDrawClipper_Release((LPDIRECTDRAWCLIPPER)This->lpLcl->lp16DDClipper);
|
|
This->lpLcl->lp16DDClipper = NULL;
|
|
return DD_OK;
|
|
}
|
|
|
|
// FIXME: Check Surface type and return DDERR_INVALIDSURFACETYPE
|
|
|
|
DirectDrawClipper_AddRef((LPDIRECTDRAWCLIPPER)pDDClipper);
|
|
This->lpLcl->lp16DDClipper = (LPDDRAWI_DDRAWCLIPPER_INT)pDDClipper;
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DDrawSurface_GetDC(LPDDRAWI_DDRAWSURFACE_INT This, HDC *phDC)
|
|
{
|
|
|
|
DX_WINDBG_trace();
|
|
|
|
if (This == NULL)
|
|
{
|
|
return DDERR_INVALIDOBJECT;
|
|
}
|
|
|
|
if (phDC == NULL)
|
|
{
|
|
return DDERR_INVALIDPARAMS;
|
|
}
|
|
|
|
|
|
*phDC = (HDC)This->lpLcl->lpSurfMore->lpDD_lcl->hDC;
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DDrawSurface_GetPixelFormat(LPDDRAWI_DDRAWSURFACE_INT This,
|
|
LPDDPIXELFORMAT pDDPixelFormat)
|
|
{
|
|
HRESULT retVale = DDERR_INVALIDPARAMS;
|
|
|
|
DX_WINDBG_trace();
|
|
|
|
if (pDDPixelFormat != NULL)
|
|
{
|
|
if (This->lpLcl->dwFlags & DDRAWISURF_HASPIXELFORMAT)
|
|
{
|
|
memcpy(pDDPixelFormat,&This->lpLcl->lpGbl->ddpfSurface,sizeof(DDPIXELFORMAT));
|
|
}
|
|
else
|
|
{
|
|
memcpy(pDDPixelFormat,&This->lpLcl->lpSurfMore->
|
|
lpDD_lcl->lpGbl->vmiData.ddpfDisplay,sizeof(DDPIXELFORMAT));
|
|
}
|
|
retVale = DD_OK;
|
|
}
|
|
|
|
return retVale;
|
|
}
|
|
|
|
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_DDrawSurface_ReleaseDC(LPDDRAWI_DDRAWSURFACE_INT This, HDC hDC)
|
|
{
|
|
DX_WINDBG_trace();
|
|
|
|
if (This == NULL)
|
|
{
|
|
return DDERR_INVALIDOBJECT;
|
|
}
|
|
|
|
if (hDC == NULL)
|
|
{
|
|
return DDERR_INVALIDPARAMS;
|
|
}
|
|
|
|
/* FIXME check if surface exits or not */
|
|
|
|
|
|
if ((HDC)This->lpLcl->hDC == NULL)
|
|
{
|
|
return DDERR_GENERIC;
|
|
}
|
|
|
|
return DD_OK;
|
|
}
|
|
|
|
HRESULT WINAPI
|
|
Main_DDrawSurface_SetColorKey (LPDDRAWI_DDRAWSURFACE_INT This,
|
|
DWORD dwFlags, LPDDCOLORKEY pCKey)
|
|
{
|
|
|
|
DDHAL_SETCOLORKEYDATA ColorKeyData;
|
|
|
|
DX_WINDBG_trace();
|
|
|
|
ColorKeyData.ddRVal = DDERR_COLORKEYNOTSET;
|
|
|
|
if (This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_SETCOLORKEY)
|
|
{
|
|
|
|
ColorKeyData.lpDD = This->lpLcl->lpGbl->lpDD;
|
|
ColorKeyData.SetColorKey = This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.SetColorKey;
|
|
|
|
//ColorKeyData.lpDDSurface = &This->lpLcl->hDDSurface;
|
|
ColorKeyData.dwFlags = dwFlags;
|
|
/* FIXME
|
|
ColorKeyData.ckNew = ?
|
|
add / move dwFlags to This->lpLcl->dwFlags ??
|
|
*/
|
|
|
|
if (ColorKeyData.SetColorKey(&ColorKeyData) == DDHAL_DRIVER_HANDLED )
|
|
{
|
|
return ColorKeyData.ddRVal;
|
|
}
|
|
}
|
|
return DDERR_COLORKEYNOTSET;
|
|
}
|
|
|
|
|
|
|
|
HRESULT WINAPI
|
|
Main_DDrawSurface_SetOverlayPosition (LPDDRAWI_DDRAWSURFACE_INT This, LONG X, LONG Y)
|
|
{
|
|
|
|
DDHAL_SETOVERLAYPOSITIONDATA OverLayPositionData;
|
|
|
|
DX_WINDBG_trace();
|
|
|
|
OverLayPositionData.ddRVal = DDERR_COLORKEYNOTSET;
|
|
|
|
if (This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_SETOVERLAYPOSITION)
|
|
{
|
|
|
|
OverLayPositionData.lpDD = This->lpLcl->lpGbl->lpDD;
|
|
OverLayPositionData.SetOverlayPosition = This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.SetOverlayPosition;
|
|
|
|
//OverLayPositionData.lpDDSrcSurface = This->lpLcl->lpSurfaceOverlaying->lpLcl->hDDSurface;
|
|
//OverLayPositionData.lpDDDestSurface = This->lpLcl->hDDSurface;
|
|
|
|
OverLayPositionData.lXPos = X;
|
|
OverLayPositionData.lYPos = Y;
|
|
|
|
|
|
/* FIXME
|
|
Should X and Y be save ??
|
|
*/
|
|
|
|
if (OverLayPositionData.SetOverlayPosition(&OverLayPositionData) == DDHAL_DRIVER_HANDLED )
|
|
{
|
|
return OverLayPositionData.ddRVal;
|
|
}
|
|
}
|
|
|
|
return DDERR_GENERIC;
|
|
}
|