Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-02-25 18:02:05 +00:00
Code Issues Projects Releases Packages Wiki Activity

Start implement HAL Createsurface The code are from my test apps and base on Steffen Schulze, it need more modifaction before it is complete. for now it create primare and overlay with rgb and most graphic card does not support that thx again Steffen Schulze for the info

Browse source 
svn path=/trunk/; revision=21457
This commit is contained in:
Magnus Olsen 2006-04-05 05:43:18 +00:00
parent 636fd975d6
commit 36e69f31ea
4 changed files with 285 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

253
reactos/dll/directx/ddraw/hal/surface_hal.c
View file

@ -11,6 +11,259 @@
#include "rosdraw.h" #include "rosdraw.h"
HRESULT Hal_DirectDraw_CreateSurface (LPDIRECTDRAW7 iface, LPDDSURFACEDESC2 pDDSD, LPDIRECTDRAWSURFACE7 *ppSurf, IUnknown *pUnkOuter)
{
UINT i;
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
/* create primare surface now */
memset(&This->mddsdPrimary, 0, sizeof(DDSURFACEDESC));
This->mddsdPrimary.dwSize = sizeof(DDSURFACEDESC);
This->mddsdPrimary.dwFlags = DDSD_CAPS;
This->mddsdPrimary.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_VIDEOMEMORY | DDSCAPS_VISIBLE;
DDHAL_CANCREATESURFACEDATA mDdCanCreateSurface;
mDdCanCreateSurface.lpDD = &This->mDDrawGlobal;
mDdCanCreateSurface.CanCreateSurface = This->mCallbacks.HALDD.CanCreateSurface;
mDdCanCreateSurface.bIsDifferentPixelFormat = FALSE; //isDifferentPixelFormat;
mDdCanCreateSurface.lpDDSurfaceDesc = &This->mddsdPrimary; // pDDSD;
if (This->mHALInfo.lpDDCallbacks->CanCreateSurface(&mDdCanCreateSurface)== DDHAL_DRIVER_NOTHANDLED)
{
// derr(L"DirectDrawImpl[%08x]::__createPrimary Cannot create primary [%08x]", this, rv);
return DDERR_NOTINITIALIZED;
}
if (mDdCanCreateSurface.ddRVal != DD_OK)
{
return DDERR_NOTINITIALIZED;
}
memset(&This->mPrimaryGlobal, 0, sizeof(DDRAWI_DDRAWSURFACE_GBL));
This->mPrimaryGlobal.dwGlobalFlags = DDRAWISURFGBL_ISGDISURFACE;
This->mPrimaryGlobal.lpDD = &This->mDDrawGlobal;
This->mPrimaryGlobal.lpDDHandle = &This->mDDrawGlobal;
This->mPrimaryGlobal.wWidth = (WORD)This->mpModeInfos[0].dwWidth;
This->mPrimaryGlobal.wHeight = (WORD)This->mpModeInfos[0].dwHeight;
This->mPrimaryGlobal.lPitch = This->mpModeInfos[0].lPitch;
memset(&This->mPrimaryMore, 0, sizeof(DDRAWI_DDRAWSURFACE_MORE));
This->mPrimaryMore.dwSize = sizeof(DDRAWI_DDRAWSURFACE_MORE);
memset(&This->mPrimaryLocal, 0, sizeof(DDRAWI_DDRAWSURFACE_LCL));
This->mPrimaryLocal.lpGbl = &This->mPrimaryGlobal;
This->mPrimaryLocal.lpSurfMore = &This->mPrimaryMore;
This->mPrimaryLocal.dwProcessId = GetCurrentProcessId();
This->mPrimaryLocal.dwFlags = DDRAWISURF_PARTOFPRIMARYCHAIN|DDRAWISURF_HASOVERLAYDATA;
This->mPrimaryLocal.ddsCaps.dwCaps = This->mddsdPrimary.ddsCaps.dwCaps;
This->mpPrimaryLocals[0] = &This->mPrimaryLocal;
DDHAL_CREATESURFACEDATA mDdCreateSurface;
mDdCreateSurface.lpDD = &This->mDDrawGlobal;
mDdCreateSurface.CreateSurface = This->mCallbacks.HALDD.CreateSurface;
mDdCreateSurface.lpDDSurfaceDesc = &This->mddsdPrimary;//pDDSD;
mDdCreateSurface.lplpSList = This->mpPrimaryLocals; //cSurfaces;
mDdCreateSurface.dwSCnt = 1 ; //ppSurfaces;
if (This->mHALInfo.lpDDCallbacks->CreateSurface(&mDdCreateSurface) == DDHAL_DRIVER_NOTHANDLED)
{
return DDERR_NOTINITIALIZED;
}
if (mDdCreateSurface.ddRVal != DD_OK)
{
return mDdCreateSurface.ddRVal;
}
// -- Setup Clipper ---------------------------------------------------------
memset(&This->mPrimaryClipperGlobal, 0, sizeof(DDRAWI_DDRAWCLIPPER_GBL));
This->mPrimaryClipperGlobal.dwFlags = DDRAWICLIP_ISINITIALIZED;
This->mPrimaryClipperGlobal.dwProcessId = GetCurrentProcessId();
//mPrimaryClipperGlobal.hWnd = (ULONG_PTR)hwnd;
This->mPrimaryClipperGlobal.hWnd = (ULONG_PTR)GetDesktopWindow();
This->mPrimaryClipperGlobal.lpDD = &This->mDDrawGlobal;
This->mPrimaryClipperGlobal.lpStaticClipList = NULL;
memset(&This->mPrimaryClipperLocal, 0, sizeof(DDRAWI_DDRAWCLIPPER_LCL));
This->mPrimaryClipperLocal.lpGbl = &This->mPrimaryClipperGlobal;
//memset(&mPrimaryClipperInterface, 0, sizeof(DDRAWI_DDRAWCLIPPER_INT));
//mPrimaryClipperInterface.lpLcl = &mPrimaryClipperLocal;
//mPrimaryClipperInterface.dwIntRefCnt = 1;
//mPrimaryClipperInterface.lpLink = null;
//mPrimaryClipperInterface.lpVtbl = null;
This->mPrimaryLocal.lpDDClipper = &This->mPrimaryClipperLocal;
//mPrimaryMore.lpDDIClipper = &mPrimaryClipperInterface;
//mDdBlt.lpDDDestSurface = mpPrimaryLocals[0];
/* create primare surface is down now */
/*
*
*
*
*/
/* create overlay surface now */
memset(&This->mddsdOverlay, 0, sizeof(DDSURFACEDESC));
This->mddsdOverlay.dwSize = sizeof(DDSURFACEDESC);
This->mddsdOverlay.dwFlags = DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_BACKBUFFERCOUNT | DDSD_WIDTH | DDSD_HEIGHT;
This->mddsdOverlay.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM | DDSCAPS_COMPLEX | DDSCAPS_FLIP;
This->mddsdOverlay.dwWidth = 100; //pels;
This->mddsdOverlay.dwHeight = 100; // lines;
This->mddsdOverlay.dwBackBufferCount = 1; //cBuffers;
This->mddsdOverlay.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
This->mddsdOverlay.ddpfPixelFormat.dwFlags = DDPF_RGB;
This->mddsdOverlay.ddpfPixelFormat.dwRGBBitCount = 32;
//DDHAL_CANCREATESURFACEDATA mDdCanCreateSurface;
mDdCanCreateSurface.lpDD = &This->mDDrawGlobal;
mDdCanCreateSurface.CanCreateSurface = This->mCallbacks.HALDD.CanCreateSurface;
mDdCanCreateSurface.bIsDifferentPixelFormat = TRUE; //isDifferentPixelFormat;
mDdCanCreateSurface.lpDDSurfaceDesc = &This->mddsdOverlay; // pDDSD;
if (This->mHALInfo.lpDDCallbacks->CanCreateSurface(&mDdCanCreateSurface)== DDHAL_DRIVER_NOTHANDLED)
{
// derr(L"DirectDrawImpl[%08x]::__createPrimary Cannot create primary [%08x]", this, rv);
return DDERR_NOTINITIALIZED;
}
if (mDdCanCreateSurface.ddRVal != DD_OK)
{
return DDERR_NOTINITIALIZED;
}
memset(&This->mOverlayGlobal, 0, sizeof(DDRAWI_DDRAWSURFACE_GBL));
This->mOverlayGlobal.dwGlobalFlags = 0;
This->mOverlayGlobal.lpDD = &This->mDDrawGlobal;
This->mOverlayGlobal.lpDDHandle = &This->mDDrawGlobal;
This->mOverlayGlobal.wWidth = (WORD)This->mddsdOverlay.dwWidth;
This->mOverlayGlobal.wHeight = (WORD)This->mddsdOverlay.dwHeight;
This->mOverlayGlobal.lPitch = -1;
This->mOverlayGlobal.ddpfSurface = This->mddsdOverlay.ddpfPixelFormat;
// setup front- and backbuffer surfaces
UINT cSurfaces = This->mddsdOverlay.dwBackBufferCount + 1;
for (i = 0; i < cSurfaces; i++)
{
memset(&This->mOverlayMore[i], 0, sizeof(DDRAWI_DDRAWSURFACE_MORE));
This->mOverlayMore[i].dwSize = sizeof(DDRAWI_DDRAWSURFACE_MORE);
memset(&This->mOverlayLocal[i], 0, sizeof(DDRAWI_DDRAWSURFACE_LCL));
This->mOverlayLocal[i].lpGbl = &This->mOverlayGlobal;
This->mOverlayLocal[i].lpSurfMore = &This->mOverlayMore[i];
This->mOverlayLocal[i].dwProcessId = GetCurrentProcessId();
This->mOverlayLocal[i].dwFlags = (i == 0) ?
(DDRAWISURF_IMPLICITROOT|DDRAWISURF_FRONTBUFFER):
(DDRAWISURF_IMPLICITCREATE|DDRAWISURF_BACKBUFFER);
This->mOverlayLocal[i].dwFlags |=
DDRAWISURF_ATTACHED|DDRAWISURF_ATTACHED_FROM|
DDRAWISURF_HASPIXELFORMAT|
DDRAWISURF_HASOVERLAYDATA;
This->mOverlayLocal[i].ddsCaps.dwCaps = This->mddsdOverlay.ddsCaps.dwCaps;
This->mpOverlayLocals[i] = &This->mOverlayLocal[i];
}
for (i = 0; i < cSurfaces; i++)
{
UINT j = (i + 1) % cSurfaces;
/*if (!mHALInfo.lpDDSurfaceCallbacks->AddAttachedSurface(mpOverlayLocals[i], mpOverlayLocals[j]))
{
// derr(L"DirectDrawImpl[%08x]::__setupDevice DdAttachSurface(%d, %d) failed", this, i, j);
return DD_FALSE;
}*/
if (!DdAttachSurface(This->mpOverlayLocals[i], This->mpOverlayLocals[j]))
{
// derr(L"DirectDrawImpl[%08x]::__setupDevice DdAttachSurface(%d, %d) failed", this, i, j);
return DD_FALSE;
}
}
// DDHAL_CREATESURFACEDATA mDdCreateSurface;
mDdCreateSurface.lpDD = &This->mDDrawGlobal;
mDdCreateSurface.CreateSurface = This->mCallbacks.HALDD.CreateSurface;
mDdCreateSurface.lpDDSurfaceDesc = &This->mddsdOverlay;//pDDSD;
mDdCreateSurface.lplpSList = This->mpOverlayLocals; //cSurfaces;
mDdCreateSurface.dwSCnt = 1 ; //ppSurfaces;
if (This->mHALInfo.lpDDCallbacks->CreateSurface(&mDdCreateSurface) == DDHAL_DRIVER_NOTHANDLED)
{
return DDERR_NOTINITIALIZED;
}
if (mDdCreateSurface.ddRVal != DD_OK)
{
return mDdCreateSurface.ddRVal;
}
//mSrcRect.w = mddsdOverlay.dwWidth;
//mSrcRect.h = mddsdOverlay.dwHeight;
//__alignBounds();
DDHAL_UPDATEOVERLAYDATA mDdUpdateOverlay;
mDdUpdateOverlay.lpDD = &This->mDDrawGlobal;
mDdUpdateOverlay.UpdateOverlay = This->mCallbacks.HALDDSurface.UpdateOverlay;
mDdUpdateOverlay.lpDDDestSurface = This->mpPrimaryLocals[0];
mDdUpdateOverlay.lpDDSrcSurface = This->mpOverlayLocals[0];//pDDSurface;
mDdUpdateOverlay.dwFlags = DDOVER_SHOW;
/* if (flags & DDOVER_DDFX)
mDdUpdateOverlay.overlayFX = *pFx;
copyRect(&mDdUpdateOverlay.rDest, pdst);
copyRect(&mDdUpdateOverlay.rSrc, psrc);
*/
mDdUpdateOverlay.rDest.top = 0;
mDdUpdateOverlay.rDest.left = 0;
mDdUpdateOverlay.rDest.right = 50;
mDdUpdateOverlay.rDest.bottom = 50;
mDdUpdateOverlay.rSrc.top = 0;
mDdUpdateOverlay.rSrc.left = 0;
mDdUpdateOverlay.rSrc.right = 50;
mDdUpdateOverlay.rSrc.bottom = 50;
if ( mDdUpdateOverlay.UpdateOverlay(&mDdUpdateOverlay) == DDHAL_DRIVER_NOTHANDLED)
{
return DDERR_NOTINITIALIZED;
}
if (mDdUpdateOverlay.ddRVal != DD_OK)
{
return mDdUpdateOverlay.ddRVal;
}
return DD_OK;
}
HRESULT Hal_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface, LPRECT rDest, HRESULT Hal_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface, LPRECT rDest,
LPDIRECTDRAWSURFACE7 src, LPRECT rSrc, DWORD dwFlags, LPDDBLTFX lpbltfx) LPDIRECTDRAWSURFACE7 src, LPRECT rSrc, DWORD dwFlags, LPDDBLTFX lpbltfx)
{ {

79
reactos/dll/directx/ddraw/main/ddraw_main.c
View file

@ -230,6 +230,8 @@ Main_DirectDraw_QueryInterface (LPDIRECTDRAW7 iface,
HRESULT WINAPI Main_DirectDraw_CreateSurface (LPDIRECTDRAW7 iface, LPDDSURFACEDESC2 pDDSD, HRESULT WINAPI Main_DirectDraw_CreateSurface (LPDIRECTDRAW7 iface, LPDDSURFACEDESC2 pDDSD,
LPDIRECTDRAWSURFACE7 *ppSurf, IUnknown *pUnkOuter) LPDIRECTDRAWSURFACE7 *ppSurf, IUnknown *pUnkOuter)
{ {
HRESULT ret;
if (pUnkOuter!=NULL) if (pUnkOuter!=NULL)
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
@ -251,6 +253,7 @@ HRESULT WINAPI Main_DirectDraw_CreateSurface (LPDIRECTDRAW7 iface, LPDDSURFACEDE
That->lpVtbl = &DirectDrawSurface7_Vtable; That->lpVtbl = &DirectDrawSurface7_Vtable;
That->lpVtbl_v3 = &DDRAW_IDDS3_Thunk_VTable; That->lpVtbl_v3 = &DDRAW_IDDS3_Thunk_VTable;
*ppSurf = (LPDIRECTDRAWSURFACE7)That;
This->mDDrawGlobal.dsList = (LPDDRAWI_DDRAWSURFACE_INT)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->mDDrawGlobal.dsList = (LPDDRAWI_DDRAWSURFACE_INT)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
sizeof(DDRAWI_DDRAWSURFACE_INT)); sizeof(DDRAWI_DDRAWSURFACE_INT));
@ -260,89 +263,21 @@ HRESULT WINAPI Main_DirectDraw_CreateSurface (LPDIRECTDRAW7 iface, LPDDSURFACEDE
/* we alwasy set to use the DirectDrawSurface7_Vtable as internel */ /* we alwasy set to use the DirectDrawSurface7_Vtable as internel */
That->owner->mDDrawGlobal.dsList->lpVtbl = (PVOID) &DirectDrawSurface7_Vtable; That->owner->mDDrawGlobal.dsList->lpVtbl = (PVOID) &DirectDrawSurface7_Vtable;
*ppSurf = (LPDIRECTDRAWSURFACE7)That;
//This->mpLocal = (DDRAWI_DDRAWSURFACE_LCL* )DxHeapMemAlloc(sizeof(DDRAWI_DDRAWSURFACE_LCL) * This->cSurfaces);
//This->mppLocal = (DDRAWI_DDRAWSURFACE_LCL**)DxHeapMemAlloc(sizeof(DDRAWI_DDRAWSURFACE_LCL*) * This->cSurfaces); if (This->mDDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_CREATESURFACE)
/* start alloc memory */
if ((pDDSD->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
{ {
///* HAL Code */ ret = Hal_DirectDraw_CreateSurface (iface, pDDSD, ppSurf, pUnkOuter);
//DDHAL_CANCREATESURFACEDATA CanCreateData;
// memset(&CanCreateData, 0, sizeof(DDHAL_CANCREATESURFACEDATA));
// CanCreateData.lpDD = &This->mDDrawGlobal;
// CanCreateData.lpDDSurfaceDesc = &mddsdPrimary;
//
// if (mDDrawGlobal.lpDDCBtmp->HALDD.CanCreateSurface(&CanCreateData) == DDHAL_DRIVER_NOTHANDLED)
// {
// return DDERR_INVALIDPARAMS;
// }
//memset(&mPrimaryGlobal, 0, sizeof(DDRAWI_DDRAWSURFACE_GBL));
// mPrimaryGlobal.dwGlobalFlags = DDRAWISURFGBL_ISGDISURFACE;
// mPrimaryGlobal.lpDD = &mDDrawGlobal;
// mPrimaryGlobal.lpDDHandle = &mDDrawGlobal;
// mPrimaryGlobal.wWidth = (WORD)mpModeInfos[0].dwWidth;
// mPrimaryGlobal.wHeight = (WORD)mpModeInfos[0].dwHeight;
// mPrimaryGlobal.lPitch = mpModeInfos[0].lPitch;
//memset(&mPrimaryMore, 0, sizeof(DDRAWI_DDRAWSURFACE_MORE));
// mPrimaryMore.dwSize = sizeof(DDRAWI_DDRAWSURFACE_MORE);
// memset(&mPrimaryLocal, 0, sizeof(DDRAWI_DDRAWSURFACE_LCL));
// mPrimaryLocal.lpGbl = &mPrimaryGlobal;
// mPrimaryLocal.lpSurfMore = &mPrimaryMore;
// mPrimaryLocal.dwProcessId = GetCurrentProcessId();
// // mPrimaryLocal.dwFlags = DDRAWISURF_PARTOFPRIMARYCHAIN|DDRAWISURF_HASOVERLAYDATA;
//
// mPrimaryLocal.ddsCaps.dwCaps = mddsdPrimary.ddsCaps.dwCaps;
// mpPrimaryLocals[0] = &mPrimaryLocal;
//
// DDHAL_CREATESURFACEDATA CreateData;
// memset(&CreateData, 0, sizeof(DDHAL_CREATESURFACEDATA));
// CreateData.lpDD = &mDDrawGlobal;
// CreateData.lpDDSurfaceDesc = &mddsdPrimary;
// CreateData.dwSCnt = 1;
// CreateData.lplpSList = mpPrimaryLocals;
// CreateData.ddRVal = DD_FALSE;
//
// if (mDDrawGlobal.lpDDCBtmp->HALDD.CreateSurface(&CreateData)==DDHAL_DRIVER_NOTHANDLED)
// {
// return DD_FALSE;
// }
// if(CreateData.ddRVal != DD_OK)
// {
// return CreateData.ddRVal;
// }
// return DD_OK;
} }
else else
{ {
// Create system mmeory ret = Hel_DirectDraw_CreateSurface (iface, pDDSD, ppSurf, pUnkOuter);
//DDSCAPS_SYSTEMMEMORY
return DD_FALSE;
} }
// the real surface object creation // the real surface object creation
//return That->lpVtbl->Initialize (*ppSurf, (LPDIRECTDRAW)iface, pDDSD);
/* alloc memmory if we need it for diffent surface */
// DDSCAPS_VIDEOMEMORY graphic card alloc memmory */
// DDSCAPS_OFFSCREENPLAIN offcreen surface alloc memmory ??
// DDSCAPS_OVERLAY create overlay surface
// DDSCAPS_TEXTURE
// return That->lpVtbl->Initialize (*ppSurf, (LPDIRECTDRAW)iface, pDDSD);
return DD_OK; return DD_OK;
} }

19
reactos/dll/directx/ddraw/rosdraw.h
View file

@ -46,6 +46,22 @@ typedef struct
UINT mcTextures; UINT mcTextures;
DDSURFACEDESC *mpTextures; DDSURFACEDESC *mpTextures;
/* Surface */
DDRAWI_DDRAWSURFACE_GBL mPrimaryGlobal;
DDRAWI_DDRAWSURFACE_MORE mPrimaryMore;
DDRAWI_DDRAWSURFACE_LCL mPrimaryLocal;
DDRAWI_DDRAWSURFACE_LCL *mpPrimaryLocals[1];
DDRAWI_DDRAWCLIPPER_LCL mPrimaryClipperLocal;
DDRAWI_DDRAWCLIPPER_GBL mPrimaryClipperGlobal;
//DDRAWI_DDRAWCLIPPER_INT mPrimaryClipperInterface;
DDSURFACEDESC mddsdPrimary;
DDSURFACEDESC mddsdOverlay;
DDRAWI_DDRAWSURFACE_GBL mOverlayGlobal;
DDRAWI_DDRAWSURFACE_LCL mOverlayLocal[6];
DDRAWI_DDRAWSURFACE_LCL *mpOverlayLocals[6];
DDRAWI_DDRAWSURFACE_MORE mOverlayMore[6];
/* ExclusiveOwner */ /* ExclusiveOwner */
DDRAWI_DIRECTDRAW_LCL ExclusiveOwner; DDRAWI_DIRECTDRAW_LCL ExclusiveOwner;
@ -126,7 +142,7 @@ HRESULT Hal_DirectDraw_GetScanLine(LPDIRECTDRAW7 , LPDWORD );
HRESULT Hal_DirectDraw_FlipToGDISurface(LPDIRECTDRAW7 ); HRESULT Hal_DirectDraw_FlipToGDISurface(LPDIRECTDRAW7 );
HRESULT Hal_DirectDraw_SetDisplayMode (LPDIRECTDRAW7, DWORD, DWORD, DWORD, DWORD, DWORD ); HRESULT Hal_DirectDraw_SetDisplayMode (LPDIRECTDRAW7, DWORD, DWORD, DWORD, DWORD, DWORD );
HRESULT Hal_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7, LPRECT, LPDIRECTDRAWSURFACE7, LPRECT, DWORD, LPDDBLTFX ); HRESULT Hal_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7, LPRECT, LPDIRECTDRAWSURFACE7, LPRECT, DWORD, LPDDBLTFX );
HRESULT Hal_DirectDraw_CreateSurface (LPDIRECTDRAW7 iface, LPDDSURFACEDESC2 pDDSD, LPDIRECTDRAWSURFACE7 *ppSurf, IUnknown *pUnkOuter);
HRESULT Hel_DirectDraw_Initialize (LPDIRECTDRAW7 ); HRESULT Hel_DirectDraw_Initialize (LPDIRECTDRAW7 );
@ -138,6 +154,7 @@ HRESULT Hel_DirectDraw_GetScanLine(LPDIRECTDRAW7 , LPDWORD );
HRESULT Hel_DirectDraw_FlipToGDISurface(LPDIRECTDRAW7 ); HRESULT Hel_DirectDraw_FlipToGDISurface(LPDIRECTDRAW7 );
HRESULT Hel_DirectDraw_SetDisplayMode (LPDIRECTDRAW7 , DWORD , DWORD ,DWORD , DWORD , DWORD ); HRESULT Hel_DirectDraw_SetDisplayMode (LPDIRECTDRAW7 , DWORD , DWORD ,DWORD , DWORD , DWORD );
HRESULT Hel_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7, LPRECT, LPDIRECTDRAWSURFACE7, LPRECT, DWORD, LPDDBLTFX ); HRESULT Hel_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7, LPRECT, LPDIRECTDRAWSURFACE7, LPRECT, DWORD, LPDDBLTFX );
HRESULT Hel_DirectDraw_CreateSurface (LPDIRECTDRAW7 iface, LPDDSURFACEDESC2 pDDSD, LPDIRECTDRAWSURFACE7 *ppSurf, IUnknown *pUnkOuter);
/* Setting for HEL should be move to ros special reg key ? */ /* Setting for HEL should be move to ros special reg key ? */

4
reactos/dll/directx/ddraw/soft/surface_hel.c
View file

@ -11,6 +11,10 @@
#include "rosdraw.h" #include "rosdraw.h"
HRESULT Hel_DirectDraw_CreateSurface (LPDIRECTDRAW7 iface, LPDDSURFACEDESC2 pDDSD, LPDIRECTDRAWSURFACE7 *ppSurf, IUnknown *pUnkOuter)
{
DX_STUB;
}
HRESULT Hel_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface, LPRECT rdst, HRESULT Hel_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface, LPRECT rdst,
LPDIRECTDRAWSURFACE7 src, LPRECT rsrc, DWORD dwFlags, LPDDBLTFX lpbltfx) LPDIRECTDRAWSURFACE7 src, LPRECT rsrc, DWORD dwFlags, LPDDBLTFX lpbltfx)