You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
436 lines
21 KiB
436 lines
21 KiB
/*==========================================================================;
|
|
*
|
|
* Copyright (C) 1995 - 1998 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* File: d3di.h
|
|
* Content: Direct3D HAL driver include file
|
|
*
|
|
***************************************************************************/
|
|
|
|
#ifndef _HALDRV_H_
|
|
#define _HALDRV_H_
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "Direct3D HAL"
|
|
|
|
#define SURFACE_MEMORY(surf) \
|
|
(LPVOID)(((LPDDRAWI_DDRAWSURFACE_INT)(surf))->lpLcl->lpGbl->fpVidMem)
|
|
|
|
#ifdef TRACK_HAL_CALLS
|
|
#define RESET_HAL_CALLS(lpDevI) ((lpDevI)->hal_calls = 0)
|
|
#define TRACK_HAL_CALL(lpDevI) ((lpDevI)->hal_calls++)
|
|
#else
|
|
#define RESET_HAL_CALLS(lpDevI)
|
|
#define TRACK_HAL_CALL(lpDevI)
|
|
#endif
|
|
|
|
|
|
#define QUOTE(x) #x
|
|
#define QQUOTE(y) QUOTE(y)
|
|
#define REMIND(str) __FILE__ "(" QQUOTE(__LINE__) "):" str
|
|
|
|
|
|
#ifdef WIN95
|
|
|
|
extern void _stdcall GetpWin16Lock( LPVOID FAR *);
|
|
extern void _stdcall _EnterSysLevel( LPVOID );
|
|
extern void _stdcall _LeaveSysLevel( LPVOID );
|
|
extern LPVOID lpWin16Lock;
|
|
|
|
#define LOCK_HAL(ret, lpDevI) \
|
|
{ \
|
|
if (lpDevI->dwFEFlags & D3DFE_REALHAL) { \
|
|
_EnterSysLevel(lpWin16Lock); \
|
|
} \
|
|
ret = D3D_OK; \
|
|
}
|
|
|
|
#define UNLOCK_HAL(lpDevI) \
|
|
{ \
|
|
if (lpDevI->dwFEFlags & D3DFE_REALHAL) { \
|
|
_LeaveSysLevel(lpWin16Lock); \
|
|
} \
|
|
}
|
|
|
|
HRESULT D3DHAL_LockDibEngine(LPDIRECT3DDEVICEI lpDevI);
|
|
void D3DHAL_UnlockDibEngine(LPDIRECT3DDEVICEI lpDevI);
|
|
|
|
#define LOCK_DIBENGINE(ret, lpDevI) \
|
|
{ \
|
|
if (lpDevI->dwFEFlags & D3DFE_REALHAL) { \
|
|
ret = D3DHAL_LockDibEngine(lpDevI); \
|
|
} \
|
|
else { \
|
|
ret = D3D_OK; \
|
|
} \
|
|
}
|
|
|
|
#define UNLOCK_DIBENGINE(lpDevI) \
|
|
{ \
|
|
if (lpDevI->dwFEFlags & D3DFE_REALHAL) { \
|
|
D3DHAL_UnlockDibEngine(lpDevI); \
|
|
} \
|
|
}
|
|
|
|
#else // WIN95
|
|
|
|
#define LOCK_HAL(ret, lpDevI) ret = DD_OK
|
|
#define UNLOCK_HAL(lpDevI)
|
|
#define LOCK_DIBENGINE(ret, lpDevI) ret = DD_OK
|
|
#define UNLOCK_DIBENGINE(lpDevI)
|
|
|
|
#endif // WIN95
|
|
|
|
|
|
#define CALL_HALONLY_NOLOCK(ret, lpDevI, call, data) \
|
|
{ \
|
|
if (lpDevI->lpD3DHALCallbacks->call) { \
|
|
LOCK_DIBENGINE(ret, lpDevI); \
|
|
if (ret != DD_OK) { \
|
|
D3D_ERR("dibengine was busy, not calling HAL"); \
|
|
} else { \
|
|
ret = (*lpDevI->lpD3DHALCallbacks->call)(data); \
|
|
TRACK_HAL_CALL(lpDevI) \
|
|
UNLOCK_DIBENGINE(lpDevI); \
|
|
} \
|
|
} else { \
|
|
D3D_ERR("No HAL call available"); \
|
|
ret = DDHAL_DRIVER_NOTHANDLED; \
|
|
} \
|
|
}
|
|
|
|
#define CALL_HAL2ONLY_NOLOCK(ret, lpDevI, call, data) \
|
|
{ \
|
|
if (lpDevI->lpD3DHALCallbacks2->call) { \
|
|
LOCK_DIBENGINE(ret, lpDevI); \
|
|
if (ret != DD_OK) { \
|
|
D3D_ERR("dibengine was busy, not calling HAL"); \
|
|
} else { \
|
|
ret = (*lpDevI->lpD3DHALCallbacks2->call)(data); \
|
|
TRACK_HAL_CALL(lpDevI) \
|
|
UNLOCK_DIBENGINE(lpDevI); \
|
|
} \
|
|
} else { \
|
|
D3D_ERR("No HAL call available"); \
|
|
ret = DDHAL_DRIVER_NOTHANDLED; \
|
|
} \
|
|
}
|
|
|
|
#define CALL_HALCBONLY_NOLOCK(ret, lpDevI, call, data) \
|
|
{ \
|
|
if (lpDevI->lpD3DHALCommandBufferCallbacks->call) { \
|
|
LOCK_DIBENGINE(ret, lpDevI); \
|
|
if (ret != DD_OK) { \
|
|
D3D_ERR("dibengine was busy, not calling HAL"); \
|
|
} else { \
|
|
ret = (*lpDevI->lpD3DHALCommandBufferCallbacks->call)(data); \
|
|
TRACK_HAL_CALL(lpDevI) \
|
|
UNLOCK_DIBENGINE(lpDevI); \
|
|
} \
|
|
} else { \
|
|
D3D_ERR("No HAL call available"); \
|
|
ret = DDHAL_DRIVER_NOTHANDLED; \
|
|
} \
|
|
}
|
|
|
|
#define CALL_HAL3ONLY_NOLOCK(ret, lpDevI, call, data) \
|
|
{ \
|
|
if (lpDevI->lpD3DHALCallbacks3->call) { \
|
|
LOCK_DIBENGINE(ret, lpDevI); \
|
|
if (ret != DD_OK) { \
|
|
D3D_ERR("dibengine was busy, not calling HAL"); \
|
|
} else { \
|
|
ret = (*lpDevI->lpD3DHALCallbacks3->call)(data); \
|
|
TRACK_HAL_CALL(lpDevI) \
|
|
UNLOCK_DIBENGINE(lpDevI); \
|
|
} \
|
|
} else { \
|
|
D3D_ERR("No HAL call available"); \
|
|
ret = DDHAL_DRIVER_NOTHANDLED; \
|
|
} \
|
|
}
|
|
|
|
|
|
#define CALL_HALONLY(ret, lpDevI, call, data) \
|
|
{ \
|
|
BOOL locked; \
|
|
ret = DD_OK; \
|
|
LOCK_HAL(ret, lpDevI); \
|
|
if (ret == DD_OK) \
|
|
locked = TRUE; \
|
|
if (ret == DD_OK) { \
|
|
CALL_HALONLY_NOLOCK(ret, lpDevI, call, data); \
|
|
} \
|
|
if (locked) { \
|
|
UNLOCK_HAL(lpDevI); \
|
|
} \
|
|
}
|
|
|
|
#define CALL_HALCBONLY(ret, lpDevI, call, data) \
|
|
{ \
|
|
BOOL locked; \
|
|
ret = DD_OK; \
|
|
LOCK_HAL(ret, lpDevI); \
|
|
if (ret == DD_OK) \
|
|
locked = TRUE; \
|
|
if (ret == DD_OK) { \
|
|
CALL_HALCBONLY_NOLOCK(ret, lpDevI, call, data); \
|
|
} \
|
|
if (locked) { \
|
|
UNLOCK_HAL(lpDevI); \
|
|
} \
|
|
}
|
|
|
|
#define CALL_HAL2ONLY(ret, lpDevI, call, data) \
|
|
{ \
|
|
BOOL locked; \
|
|
ret = DD_OK; \
|
|
LOCK_HAL(ret, lpDevI); \
|
|
if (ret == DD_OK) \
|
|
locked = TRUE; \
|
|
if (ret == DD_OK) { \
|
|
CALL_HAL2ONLY_NOLOCK(ret, lpDevI, call, data); \
|
|
} \
|
|
if (locked) { \
|
|
UNLOCK_HAL(lpDevI); \
|
|
} \
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
// Call for callbacks that are not required to be implemented
|
|
//
|
|
#define CALL_HAL3ONLY_OPTIONAL(ret, lpDevI, call, data) \
|
|
{ \
|
|
BOOL locked; \
|
|
ret = DD_OK; \
|
|
if (lpDevI->lpD3DHALCallbacks3->call) \
|
|
{ \
|
|
CALL_HAL3ONLY(ret, lpDevI, call, data); \
|
|
} \
|
|
}
|
|
//-----------------------------------------------------------------------
|
|
#define CALL_HAL3ONLY(ret, lpDevI, call, data) \
|
|
{ \
|
|
BOOL locked; \
|
|
ret = DD_OK; \
|
|
LOCK_HAL(ret, lpDevI); \
|
|
if (ret == DD_OK) \
|
|
locked = TRUE; \
|
|
if (ret == DD_OK) { \
|
|
CALL_HAL3ONLY_NOLOCK(ret, lpDevI, call, data); \
|
|
} \
|
|
if (locked) { \
|
|
UNLOCK_HAL(lpDevI); \
|
|
} \
|
|
}
|
|
|
|
HRESULT D3DHAL_AllocateBuffer(LPDIRECT3DDEVICEI, LPD3DI_BUFFERHANDLE, LPD3DEXECUTEBUFFERDESC, LPDIRECTDRAWSURFACE*);
|
|
HRESULT D3DHAL_DeallocateBuffer(LPDIRECT3DDEVICEI, D3DI_BUFFERHANDLE);
|
|
HRESULT D3DHAL_DeallocateBuffers(LPDIRECT3DDEVICEI);
|
|
HRESULT D3DHAL_LockBuffer(LPDIRECT3DDEVICEI, D3DI_BUFFERHANDLE, LPD3DEXECUTEBUFFERDESC, LPDIRECTDRAWSURFACE*);
|
|
HRESULT D3DHAL_UnlockBuffer(LPDIRECT3DDEVICEI, D3DI_BUFFERHANDLE);
|
|
HRESULT D3DHAL_ExecuteClipped(LPDIRECT3DDEVICEI, LPD3DI_EXECUTEDATA);
|
|
HRESULT D3DHAL_ExecuteUnclipped(LPDIRECT3DDEVICEI, LPD3DI_EXECUTEDATA);
|
|
HRESULT D3DHAL_ExecutePick(LPDIRECT3DDEVICEI, LPD3DI_PICKDATA);
|
|
HRESULT D3DHAL_TextureCreate(LPDIRECT3DDEVICEI, LPD3DTEXTUREHANDLE, LPDIRECTDRAWSURFACE);
|
|
HRESULT D3DHAL_TextureDestroy(LPD3DI_TEXTUREBLOCK);
|
|
HRESULT D3DHAL_TextureSwap(LPDIRECT3DDEVICEI, D3DTEXTUREHANDLE, D3DTEXTUREHANDLE);
|
|
__declspec(dllexport) HRESULT D3DHAL_TextureGetSurf(LPDIRECT3DDEVICEI, D3DTEXTUREHANDLE, LPDIRECTDRAWSURFACE*);
|
|
HRESULT D3DHAL_MatrixCreate(LPDIRECT3DDEVICEI, LPD3DMATRIXHANDLE);
|
|
HRESULT D3DHAL_MatrixDestroy(LPDIRECT3DDEVICEI, D3DMATRIXHANDLE);
|
|
HRESULT D3DHAL_MatrixSetData(LPDIRECT3DDEVICEI, D3DMATRIXHANDLE, LPD3DMATRIX);
|
|
HRESULT D3DHAL_MatrixGetData(LPDIRECT3DDEVICEI, D3DMATRIXHANDLE, LPD3DMATRIX);
|
|
HRESULT D3DFE_SetViewportData(LPDIRECT3DDEVICEI, DWORD, LPD3DVIEWPORT2);
|
|
HRESULT D3DHAL_MaterialCreate(LPDIRECT3DDEVICEI, LPD3DMATERIALHANDLE, LPD3DMATERIAL);
|
|
HRESULT D3DHAL_MaterialDestroy(LPDIRECT3DDEVICEI, D3DMATERIALHANDLE);
|
|
HRESULT D3DHAL_MaterialSetData(LPDIRECT3DDEVICEI, D3DMATERIALHANDLE, LPD3DMATERIAL);
|
|
HRESULT D3DHAL_MaterialGetData(LPDIRECT3DDEVICEI, D3DMATERIALHANDLE, LPD3DMATERIAL);
|
|
HRESULT D3DHAL_LightSet(LPDIRECT3DDEVICEI, DWORD, LPD3DI_LIGHT);
|
|
HRESULT D3DHAL_SceneCapture(LPDIRECT3DDEVICEI, BOOL);
|
|
|
|
HRESULT D3DHAL_GetState(LPDIRECT3DDEVICEI, DWORD, LPD3DSTATE);
|
|
|
|
/*********************
|
|
* HEL Calls
|
|
*********************/
|
|
|
|
/*
|
|
* Calls to emulate instructions.
|
|
*/
|
|
extern HRESULT D3DHELInst_D3DOP_STATELIGHT(LPDIRECT3DDEVICEI, DWORD, LPD3DSTATE);
|
|
extern HRESULT D3DHELInst_D3DOP_TEXTURELOAD(LPDIRECT3DDEVICEI, DWORD, LPD3DTEXTURELOAD);
|
|
|
|
|
|
extern HRESULT D3DFE_Create(LPDIRECT3DDEVICEI lpDevI,
|
|
LPDIRECTDRAW lpDD,
|
|
LPDIRECTDRAWSURFACE lpDDS,
|
|
LPDIRECTDRAWSURFACE lpZ,
|
|
LPDIRECTDRAWPALETTE lpPal);
|
|
extern void D3DFE_Destroy(LPDIRECT3DDEVICEI lpDevI);
|
|
|
|
/*
|
|
* Transform calls.
|
|
*/
|
|
extern HRESULT D3DFE_TransformUnclippedVp(D3DFE_PROCESSVERTICES*, DWORD, D3DTRANSFORMDATAI*);
|
|
extern HRESULT D3DFE_TransformClippedVp(D3DFE_PROCESSVERTICES*, DWORD, D3DTRANSFORMDATAI*);
|
|
|
|
/*
|
|
* Lighting calls.
|
|
*/
|
|
extern HRESULT D3DFE_InitRGBLighting(LPDIRECT3DDEVICEI);
|
|
extern void D3DFE_DestroyRGBLighting(LPDIRECT3DDEVICEI);
|
|
|
|
DWORD D3DFE_QueryTextureFormat (LPDIRECT3DDEVICEI, LPDDSURFACEDESC*);
|
|
HRESULT D3DFE_UpdateTexture (LPDIRECT3DDEVICEI, DWORD, D3DTEXTUREHANDLE);
|
|
HRESULT D3DFE_Clear(LPDIRECT3DDEVICEI lpDevI, DWORD dwFlags, DWORD numRect, LPD3DRECT lpRect, D3DCOLORVALUE *pFillColor, D3DTEXTUREHANDLE dwTexture);
|
|
HRESULT D3DFE_Clear2(LPDIRECT3DDEVICEI lpDevI, DWORD dwFlags,DWORD numRect, LPD3DRECT lpRect, D3DCOLOR dwColor, D3DVALUE dvZ, DWORD dwStencil);
|
|
|
|
HRESULT D3DFE_SetMatrixProj(LPDIRECT3DDEVICEI lpDevI, D3DMATRIX *mat);
|
|
HRESULT D3DFE_SetMatrixView(LPDIRECT3DDEVICEI lpDevI, D3DMATRIX *mat);
|
|
HRESULT D3DFE_SetMatrixWorld(LPDIRECT3DDEVICEI lpDevI, D3DMATRIX *mat);
|
|
HRESULT D3DFE_MultMatrixProj(LPDIRECT3DDEVICEI lpDevI, D3DMATRIX *mat);
|
|
HRESULT D3DFE_MultMatrixView(LPDIRECT3DDEVICEI lpDevI, D3DMATRIX *mat);
|
|
HRESULT D3DFE_MultMatrixWorld(LPDIRECT3DDEVICEI lpDevI, D3DMATRIX *mat);
|
|
|
|
//---------------------------------------------------------------------
|
|
// This function is called from HALEXE.CPP and from device::SetRenderState
|
|
// Always use this function to update RSTATES.
|
|
//
|
|
HRESULT
|
|
SetDeviceRenderState(LPDIRECT3DDEVICEI lpDevI, D3DRENDERSTATETYPE type,
|
|
DWORD value);
|
|
|
|
#ifndef WIN95
|
|
__inline HRESULT CheckContextSurface(LPDIRECT3DDEVICEI lpDevI)
|
|
{
|
|
if(lpDevI->hSurfaceTarget != ((LPDDRAWI_DDRAWSURFACE_INT)lpDevI->lpDDSTarget)->lpLcl->hDDSurface)
|
|
{
|
|
D3DHAL_SETRENDERTARGETDATA rtData;
|
|
HRESULT ret;
|
|
|
|
rtData.dwhContext = lpDevI->dwhContext;
|
|
if (lpDevI->dwFEFlags & D3DFE_REALHAL)
|
|
{
|
|
if (lpDevI->lpDDSTarget)
|
|
rtData.lpDDSLcl = ((LPDDRAWI_DDRAWSURFACE_INT)lpDevI->lpDDSTarget)->lpLcl;
|
|
else
|
|
rtData.lpDDSLcl = NULL;
|
|
|
|
if (lpDevI->lpDDSZBuffer)
|
|
rtData.lpDDSZLcl = ((LPDDRAWI_DDRAWSURFACE_INT)lpDevI->lpDDSZBuffer)->lpLcl;
|
|
else
|
|
rtData.lpDDSZLcl = NULL;
|
|
}
|
|
else
|
|
{
|
|
rtData.lpDDS = lpDevI->lpDDSTarget;
|
|
rtData.lpDDSZ = lpDevI->lpDDSZBuffer;
|
|
}
|
|
|
|
rtData.ddrval = 0;
|
|
CALL_HAL2ONLY(ret, lpDevI, SetRenderTarget, &rtData);
|
|
if (ret != DDHAL_DRIVER_HANDLED)
|
|
{
|
|
D3D_ERR ( "Driver did not handle SetRenderTarget" );
|
|
// Need sensible return value in this case,
|
|
// currently we return whatever the lpDevI stuck in here.
|
|
return rtData.ddrval;
|
|
}
|
|
lpDevI->hSurfaceTarget = ((LPDDRAWI_DDRAWSURFACE_INT)lpDevI->lpDDSTarget)->lpLcl->hDDSurface;
|
|
}
|
|
return(D3D_OK);
|
|
}
|
|
|
|
__inline HRESULT CheckContextSurfaceNOLOCK (LPDIRECT3DDEVICEI lpDevI)
|
|
{
|
|
if(lpDevI->hSurfaceTarget != ((LPDDRAWI_DDRAWSURFACE_INT)lpDevI->lpDDSTarget)->lpLcl->hDDSurface)
|
|
{
|
|
D3DHAL_SETRENDERTARGETDATA rtData;
|
|
HRESULT ret;
|
|
|
|
rtData.dwhContext = lpDevI->dwhContext;
|
|
if (lpDevI->dwFEFlags & D3DFE_REALHAL)
|
|
{
|
|
if (lpDevI->lpDDSTarget)
|
|
rtData.lpDDSLcl = ((LPDDRAWI_DDRAWSURFACE_INT)lpDevI->lpDDSTarget)->lpLcl;
|
|
else
|
|
rtData.lpDDSLcl = NULL;
|
|
|
|
if (lpDevI->lpDDSZBuffer)
|
|
rtData.lpDDSZLcl = ((LPDDRAWI_DDRAWSURFACE_INT)lpDevI->lpDDSZBuffer)->lpLcl;
|
|
else
|
|
rtData.lpDDSZLcl = NULL;
|
|
|
|
}
|
|
else
|
|
{
|
|
rtData.lpDDS = lpDevI->lpDDSTarget;
|
|
rtData.lpDDSZ = lpDevI->lpDDSZBuffer;
|
|
}
|
|
rtData.ddrval = 0;
|
|
CALL_HAL2ONLY_NOLOCK(ret, lpDevI, SetRenderTarget, &rtData);
|
|
if (ret != DDHAL_DRIVER_HANDLED)
|
|
{
|
|
D3D_ERR( "Driver did not handle SetRenderTarget" );
|
|
// Need sensible return value in this case,
|
|
// currently we return whatever the lpDevI stuck in here.
|
|
return rtData.ddrval;
|
|
}
|
|
lpDevI->hSurfaceTarget = ((LPDDRAWI_DDRAWSURFACE_INT)lpDevI->lpDDSTarget)->lpLcl->hDDSurface;
|
|
}
|
|
return(D3D_OK);
|
|
}
|
|
#endif //WIN95
|
|
|
|
// This struct is used for FindLightingRange RampService
|
|
typedef struct tagRAMP_RANGE_INFO
|
|
{
|
|
DWORD base;
|
|
DWORD size;
|
|
LPVOID pTexRampMap;
|
|
BOOL specular;
|
|
}RAMP_RANGE_INFO;
|
|
|
|
// This inline is for calling RastService when nothing special is required.
|
|
inline HRESULT CallRastService(LPDIRECT3DDEVICEI lpDevI,
|
|
RastServiceType ServiceType,
|
|
DWORD arg1,
|
|
LPVOID arg2)
|
|
{
|
|
if (lpDevI->pfnRastService != NULL)
|
|
{
|
|
return lpDevI->pfnRastService(lpDevI->dwhContext,
|
|
ServiceType, arg1, arg2);
|
|
}
|
|
else
|
|
{
|
|
return D3D_OK;
|
|
}
|
|
}
|
|
|
|
// This inline is for calling RampService.
|
|
// bFlush is set to TRUE when DrawPrims needs to be flushed.
|
|
// Right now, it is set for SetMat and LightState-SetMat.
|
|
inline HRESULT CallRampService(LPDIRECT3DDEVICEI lpDevI,
|
|
RastRampServiceType ServiceType,
|
|
ULONG_PTR arg1,
|
|
LPVOID arg2,
|
|
BOOL bFlush = FALSE)
|
|
{
|
|
if (lpDevI->pfnRampService != NULL)
|
|
{
|
|
if (bFlush)
|
|
{
|
|
//time to flush DrawPrimitives
|
|
(*lpDevI->pfnFlushStates)( lpDevI );
|
|
}
|
|
// Call the service
|
|
return lpDevI->pfnRampService(lpDevI->dwhContext,
|
|
ServiceType, arg1, arg2);
|
|
}
|
|
else
|
|
{
|
|
return D3D_OK;
|
|
}
|
|
}
|
|
|
|
#endif /* _HALDRV_H_ */
|