Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-20 06:15:26 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/dll/directx/ddraw/Surface/surface_main.c

934 lines
25 KiB
C
Raw Blame History

/*
* 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;
}
Reference in a new issue View git blame Copy permalink