|
|
/*==========================================================================;
* * Copyright (C) 1994-1999 Microsoft Corporation. All Rights Reserved. * * File: D3D8ddi.h * Content: Defines the interface between DirectDraw / Direct3D and the * OS specific layer (win32k.sys on NT and ddraw.dll on Win9X). *@@BEGIN_MSINTERNAL * History: * Date By Reason * ==== == ====== * 04-nov-99 smac initial implementation *@@END_MSINTERNAL * ***************************************************************************/#ifndef __D3D8DDI_INCLUDED__
#define __D3D8DDI_INCLUDED__
/*
* These definitions are required to allow polymorphic structure members (i.e. those * that are referred to both as DWORDs and as pointers) to resolve into a type * of correct size to hold the largest of those two types (i.e. pointer) on 64 bit * systems. For 32 bit environments, ULONG_PTR resolves to a DWORD. */#ifndef MAXULONG_PTR
#define ULONG_PTR DWORD
#define PULONG_PTR LPDWORD
#endif //MAXULONG_PTR
// Caps:
// Note this struct is identical in content to D3DHAL_GLOBALDRIVERDATA.
// The only thing that has changed is the name of the texture list, reflecting
// the fact that this struct holds a list of DX8-style pixel format operations.
typedef struct _D3DD8_GLOBALDRIVERDATA { DWORD dwSize; // Size of this structure
D3DDEVICEDESC_V1 hwCaps; // Capabilities of the hardware
DWORD dwNumVertices; // see following comment
DWORD dwNumClipVertices; // see following comment
DWORD GDD8NumSupportedFormatOps; DDSURFACEDESC *pGDD8SupportedFormatOps;} D3D8_GLOBALDRIVERDATA;
typedef struct _D3D8_DRIVERCAPS{ D3DCAPS8 D3DCaps; DWORD DisplayWidth; // Current display width
DWORD DisplayHeight; // Current display height
D3DFORMAT DisplayFormatWithoutAlpha; // Current display format
D3DFORMAT DisplayFormatWithAlpha; // Current display format
DWORD DisplayFrequency; // Current refresh rate
DWORD NLVCaps; // AGP->Video blt caps
DWORD SVBCaps; // Sys->Video blt caps
DWORD VSBCaps; // Video->Sys blt caps
DWORD SVBCaps2; // More Sys->Video blt caps
DWORD dwFlags; DWORD GDD8NumSupportedFormatOps; DDSURFACEDESC *pGDD8SupportedFormatOps; DWORD KnownDriverFlags;} D3D8_DRIVERCAPS, * PD3D8_DRIVERCAPS;
// Flags
#define DDIFLAG_D3DCAPS8 0x00000001
// Known driver flags
#define KNOWN_LIGHTWEIGHT 0x00000001 // Device can support lightweight surfaces
#define KNOWN_HWCURSOR 0x00000002 // Device can support hardware cursors in Hi-Res
#define KNOWN_MIPPEDCUBEMAPS 0x00000004 // Device can support mipped cubemaps
#define KNOWN_ZSTENCILDEPTH 0x00000010 // Device cannot support Z/Stencil depths different than the render target
#define KNOWN_HWCURSORLOWRES 0x00000020 // Device can support hardware cursors in LowRes
#define KNOWN_NOTAWINDOWEDBLTQUEUER 0x00000040 // Device has no drivers known to over-queue windowed presentation blts
#define KNOWN_D16_LOCKABLE 0x00000080 // Device supports lockable D16 format correctly
#define KNOWN_RTTEXTURE_R5G6B5 0x00000100 // RT+Tex formats that are supported
#define KNOWN_RTTEXTURE_X8R8G8B8 0x00000200
#define KNOWN_RTTEXTURE_A8R8G8B8 0x00000400
#define KNOWN_RTTEXTURE_A1R5G5B5 0x00000800
#define KNOWN_RTTEXTURE_A4R4G4B4 0x00001000
#define KNOWN_RTTEXTURE_X1R5G5B5 0x00002000
#define KNOWN_CANMISMATCHRT 0x00004000 // All given RT+Tex formats can be used regardless of current display depth.
// (If this bit is not set, then any known RT+Tex formats must match bitdepth of display)
/****************************************************************************
* * D3D8 structures for Surface Object callbacks * ***************************************************************************/
typedef struct _D3D8_BLTDATA{ HANDLE hDD; // driver struct
HANDLE hDestSurface;// dest surface
RECTL rDest; // dest rect
HANDLE hSrcSurface; // src surface
RECTL rSrc; // src rect
DWORD dwFlags; // blt flags
DWORD dwROPFlags; // ROP flags (valid for ROPS only)
DDBLTFX bltFX; // blt FX
union { BOOL IsClipped; // clipped blt?
HWND hWnd; // Window Handle to clip against
}; RECTL rOrigDest; // unclipped dest rect
// (only valid if IsClipped)
RECTL rOrigSrc; // unclipped src rect
// (only valid if IsClipped)
DWORD dwRectCnt; // count of dest rects
// (only valid if IsClipped)
LPRECT prDestRects; // array of dest rects
DWORD dwAFlags; // DDABLT_ flags (for AlphaBlt DDI)
DDARGB ddargbScaleFactors; // RGBA scaling factors (AlphaBlt)
DWORD msLastPresent; // Time of last blt with DDBLT_COPYVSYNC
DWORD threshold; // Display Frequency related for adapter need
// for DDBLT_COPYVSYNC
HRESULT ddRVal; // return value
} D3D8_BLTDATA, * PD3D8_BLTDATA;
typedef struct _D3D8_LOCKDATA{ HANDLE hDD; // driver struct
HANDLE hSurface; // surface struct
DWORD bHasRange; // range is valid
D3DRANGE range; // range for locking
DWORD bHasRect; // rArea is valid
RECTL rArea; // area being locked
DWORD bHasBox; // box is valid
D3DBOX box; // sub-box locking for volumes
LPVOID lpSurfData; // pointer to screen memory (return value)
long lPitch; // row pitch
long lSlicePitch;// slice pitch for volumes
DWORD dwFlags; // DDLOCK flags
} D3D8_LOCKDATA, * PD3D8_LOCKDATA;
typedef struct _D3D8_UNLOCKDATA{ HANDLE hDD; // driver struct
HANDLE hSurface; // surface struct
} D3D8_UNLOCKDATA, * PD3D8_UNLOCKDATA;
typedef struct _D3D8_FLIPDATA{ HANDLE hDD; // driver struct
HANDLE hSurfCurr; // current surface
HANDLE hSurfTarg; // target surface (to flip to)
HANDLE hSurfCurrLeft; // current surface
HANDLE hSurfTargLeft; // target surface (to flip to)
DWORD dwFlags; // flags
HRESULT ddRVal; // return value
} D3D8_FLIPDATA, * PD3D8_FLIPDATA;
typedef struct _D3D8_DESTROYSURFACEDATA{ HANDLE hDD; // driver struct
HANDLE hSurface; // surface struct
HRESULT ddRVal; // return value
} D3D8_DESTROYSURFACEDATA, * PD3D8_DESTROYSURFACEDATA;
typedef struct _D3D8_ADDATTACHEDSURFACEDATA{ HANDLE hDD; // driver struct
HANDLE hSurface; // surface struct
HANDLE hSurfAttached; // surface to attach
HRESULT ddRVal; // return value
} D3D8_ADDATTACHEDSURFACEDATA, * PD3D8_ADDATTACHEDSURFACEDATA;
typedef struct _D3D8_GETBLTSTATUSDATA{ HANDLE hDD; // driver struct
HANDLE hSurface; // surface struct
DWORD dwFlags; // flags
HRESULT ddRVal; // return value
} D3D8_GETBLTSTATUSDATA, * PD3D8_GETBLTSTATUSDATA;
typedef struct _D3D8_GETFLIPSTATUSDATA{ HANDLE hDD; // driver struct
HANDLE hSurface; // surface struct
DWORD dwFlags; // flags
HRESULT ddRVal; // return value
} D3D8_GETFLIPSTATUSDATA, * PD3D8_GETFLIPSTATUSDATA;
typedef struct _DDSURFACEINFO{ DWORD cpWidth; // For linear, surface and volume
DWORD cpHeight; // For surface and volume
DWORD cpDepth; // For volumes
BYTE *pbPixels; // Pointer to Memory for sys-mem surface
LONG iPitch; // Row Pitch for sys-mem surface
LONG iSlicePitch; // Slice Pitch for sys-mem volume
HANDLE hKernelHandle; // Handle returned by the kernel
} DDSURFACEINFO, *LPDDSURFACEINFO;
typedef struct _D3D8_CREATESURFACEDATA{ HANDLE hDD; // driver struct
LPDDSURFACEINFO pSList; // list of created surface objects
DWORD dwSCnt; // number of surfaces in SList
D3DRESOURCETYPE Type; // Type: MipMap, CubeMap, MipVolume, VertexBuffer, IndexBuffer, CommandBuffer
DWORD dwUsage; // Usage: Texture or RenderTarget
D3DPOOL Pool; // SysMem/VidMem/NonLocal
D3DFORMAT Format; // Format
D3DMULTISAMPLE_TYPE MultiSampleType; DWORD dwFVF; // FVF format for vertex buffers
BOOL bTreatAsVidMem; // Set if Sys-Mem object was created with POOL_DEFAULT by user.
BOOL bReUse; // Set if are trying to create driver managed surfaces marked deferred
} D3D8_CREATESURFACEDATA, * PD3D8_CREATESURFACEDATA;
#define DDWAITVB_I_TESTVB 0x80000006l
typedef struct _D3D8_WAITFORVERTICALBLANKDATA{ HANDLE hDD; // driver struct
DWORD dwFlags; // flags
DWORD bIsInVB; // is in vertical blank
HRESULT ddRVal; // return value
} D3D8_WAITFORVERTICALBLANKDATA, * PD3D8_WAITFORVERTICALBLANKDATA;
typedef struct _D3D8_SETMODEDATA{ HANDLE hDD; // driver struct
DWORD dwWidth; DWORD dwHeight; D3DFORMAT Format; DWORD dwRefreshRate; BOOL bRestore; HRESULT ddRVal; // return value
} D3D8_SETMODEDATA, * PD3D8_SETMODEDATA;
typedef struct _D3D8_GETSCANLINEDATA{ HANDLE hDD; // driver struct
DWORD dwScanLine; // returned scan line
BOOL bInVerticalBlank; HRESULT ddRVal; // return value
} D3D8_GETSCANLINEDATA, * PD3D8_GETSCANLINEDATA;
typedef struct _D3D8_SETEXCLUSIVEMODEDATA{ HANDLE hDD; // driver struct
DWORD dwEnterExcl; // TRUE if entering exclusive mode, FALSE is leaving
HRESULT ddRVal; // return value
} D3D8_SETEXCLUSIVEMODEDATA, * PD3D8_SETEXCLUSIVEMODEDATA;
typedef struct _D3D8_FLIPTOGDISURFACEDATA{ HANDLE hDD; // driver struct
DWORD dwToGDI; // TRUE if flipping to the GDI surface, FALSE if flipping away
HRESULT ddRVal; // return value
} D3D8_FLIPTOGDISURFACEDATA, * PD3D8_FLIPTOGDISURFACEDATA;
typedef struct _D3D8_SETCOLORKEYDATA{ HANDLE hDD; HANDLE hSurface; DWORD ColorValue; HRESULT ddRVal;} D3D8_SETCOLORKEYDATA, * PD3D8_SETCOLORKEYDATA;
typedef struct _D3D8_GETAVAILDRIVERMEMORYDATA{ HANDLE hDD; // driver struct
D3DPOOL Pool; // Pool they are interested in
DWORD dwUsage; // What the pool is used for
DWORD dwFree; // free memory for this kind of surface
HRESULT ddRVal; // return value
} D3D8_GETAVAILDRIVERMEMORYDATA, * PD3D8_GETAVAILDRIVERMEMORYDATA;
typedef struct _D3D8_GETDRIVERSTATEDATA{ DWORD dwFlags; // Flags to indicate the data
// required
ULONG_PTR dwhContext; // d3d context
LPDWORD lpdwStates; // ptr to the state data
// to be filled in by the
// driver
DWORD dwLength; HRESULT ddRVal; // return value
} D3D8_GETDRIVERSTATEDATA, * PD3D8_GETDRIVERSTATEDATA;
typedef struct _D3D8_DESTROYDDLOCALDATA{ DWORD dwFlags; HANDLE hDD; HRESULT ddRVal;} D3D8_DESTROYDDLOCALDATA, * PD3D8_DESTROYDDLOCALDATA;
typedef struct _D3D8_CONTEXTCREATEDATA{ HANDLE hDD; // in: Driver struct
HANDLE hSurface; // in: Surface to be used as target
HANDLE hDDSZ; // in: Surface to be used as Z
DWORD dwPID; // in: Current process id
ULONG_PTR dwhContext; // in/out: Context handle
HRESULT ddrval;
// Private buffer information. To make it similar to
// D3DNTHAL_CONTEXTCREATEI
PVOID pvBuffer; ULONG cjBuffer;} D3D8_CONTEXTCREATEDATA, * PD3D8_CONTEXTCREATEDATA;
typedef struct _D3D8_CONTEXTDESTROYDATA{ ULONG_PTR dwhContext; // in: Context handle
HRESULT ddrval; // out: Return value
} D3D8_CONTEXTDESTROYDATA, * PD3D8_CONTEXTDESTROYDATA;
typedef struct _D3D8_CONTEXTDESTROYALLDATA{ DWORD dwPID; // in: Process id to destroy contexts for
HRESULT ddrval; // out: Return value
} D3D8_CONTEXTDESTROYALLDATA, * PD3D8_CONTEXTDESTROYALLDATA;
typedef struct _D3D8_RENDERSTATEDATA{ ULONG_PTR dwhContext; // in: Context handle
DWORD dwOffset; // in: Where to find states in buffer
DWORD dwCount; // in: How many states to process
HANDLE hExeBuf; // in: Execute buffer containing data
HRESULT ddrval; // out: Return value
} D3D8_RENDERSTATEDATA, *PD3D8_RENDERSTATEDATA;
typedef struct _D3D8_RENDERPRIMITIVEDATA{ ULONG_PTR dwhContext; // in: Context handle
DWORD dwOffset; // in: Where to find primitive data in buffer
DWORD dwStatus; // in/out: Condition branch status
HANDLE hExeBuf; // in: Execute buffer containing data
DWORD dwTLOffset; // in: Byte offset in lpTLBuf for start of vertex data
HANDLE hTLBuf; // in: Execute buffer containing TLVertex data
D3DINSTRUCTION diInstruction; // in: Primitive instruction
HRESULT ddrval; // out: Return value
} D3D8_RENDERPRIMITIVEDATA, *PD3D8_RENDERPRIMITIVEDATA;
typedef struct _D3D8_DRAWPRIMITIVES2DATA{ ULONG_PTR dwhContext; // in: Context handle
DWORD dwFlags; // in: flags
DWORD dwVertexType; // in: vertex type
HANDLE hDDCommands; // in: vertex buffer command data
DWORD dwCommandOffset; // in: offset to start of vertex buffer commands
DWORD dwCommandLength; // in: number of bytes of command data
union { // based on D3DHALDP2_USERMEMVERTICES flag
HANDLE hDDVertex; // in: surface containing vertex data
LPVOID lpVertices; // in: User mode pointer to vertices
}; DWORD dwVertexOffset; // in: offset to start of vertex data
DWORD dwVertexLength; // in: number of vertices of vertex data
DWORD dwReqVertexBufSize; // in: number of bytes required for the next vertex buffer
DWORD dwReqCommandBufSize; // in: number of bytes required for the next commnand buffer
LPDWORD lpdwRStates; // in: Pointer to the array where render states are updated
union { DWORD dwVertexSize; // in: Size of each vertex in bytes
HRESULT ddrval; // out: return value
}; DWORD dwErrorOffset; // out: offset in lpDDCommands to first D3DHAL_COMMAND not handled
// Private data for the thunk
ULONG_PTR fpVidMem_CB; // out: fpVidMem for the command buffer
DWORD dwLinearSize_CB; // out: dwLinearSize for the command buffer
ULONG_PTR fpVidMem_VB; // out: fpVidMem for the vertex buffer
DWORD dwLinearSize_VB; // out: dwLinearSize for the vertex buffer
} D3D8_DRAWPRIMITIVES2DATA, *PD3D8_DRAWPRIMITIVES2DATA;
typedef struct _D3D8_VALIDATETEXTURESTAGESTATEDATA{ ULONG_PTR dwhContext; // in: Context handle
DWORD dwFlags; // in: Flags, currently set to 0
ULONG_PTR dwReserved; //
DWORD dwNumPasses; // out: Number of passes the hardware
// can perform the operation in
HRESULT ddrval; // out: return value
} D3D8_VALIDATETEXTURESTAGESTATEDATA, * PD3D8_VALIDATETEXTURESTAGESTATEDATA;
typedef struct _D3D8_SCENECAPTUREDATA{ ULONG_PTR dwhContext; // in: Context handle
DWORD dwFlag; // in: Indicates beginning or end
HRESULT ddrval; // out: Return value
} D3D8_SCENECAPTUREDATA, * PD3D8_SCENECAPTUREDATA;
typedef struct _D3D8_CLEAR2DATA{ ULONG_PTR dwhContext; // in: Context handle
// dwFlags can contain D3DCLEAR_TARGET, D3DCLEAR_ZBUFFER, and/or D3DCLEAR_STENCIL
DWORD dwFlags; // in: surfaces to clear
DWORD dwFillColor; // in: Color value for rtarget
D3DVALUE dvFillDepth; // in: Depth value for Z buffer (0.0-1.0)
DWORD dwFillStencil; // in: value used to clear stencil buffer
LPD3DRECT lpRects; // in: Rectangles to clear
DWORD dwNumRects; // in: Number of rectangles
HRESULT ddrval; // out: Return value
// This is extra stuff passed down to the thunk layer for emulation
// of Clear for those drivers (DX6) that cant do it themselves.
HANDLE hDDS; // in: render target
HANDLE hDDSZ; // in: Z buffer
} D3D8_CLEAR2DATA, * PD3D8_CLEAR2DATA;
typedef struct _D3D8_CLEARDATA{ ULONG_PTR dwhContext; // in: Context handle
// dwFlags can contain D3DCLEAR_TARGET or D3DCLEAR_ZBUFFER
DWORD dwFlags; // in: surfaces to clear
DWORD dwFillColor; // in: Color value for rtarget
DWORD dwFillDepth; // in: Depth value for Z buffer
LPD3DRECT lpRects; // in: Rectangles to clear
DWORD dwNumRects; // in: Number of rectangles
HRESULT ddrval; // out: Return value
} D3D8_CLEARDATA, * PD3D8_CLEARDATA;
typedef struct _D3D8_SETRENDERTARGETDATA{ ULONG_PTR dwhContext; // in: Context handle
HANDLE hDDS; // in: new render target
HANDLE hDDSZ; // in: new Z buffer
HRESULT ddrval; // out: Return value
BOOL bNeedUpdate;// out: Does runtime need to update
// driver state.
} D3D8_SETRENDERTARGETDATA, * PD3D8_SETRENDERTARGETDATA;
typedef struct _D3D8_SETPALETTEDATA{ HANDLE hDD; // in: Driver struct
HANDLE hSurface; // in: Surface to be used as target
DWORD Palette; // in: Palette identifier
HRESULT ddRVal; // out: Return value
} D3D8_SETPALETTEDATA, * PD3D8_SETPALETTEDATA;
typedef struct _D3D8_UPDATEPALETTEDATA{ HANDLE hDD; // in: Driver struct
DWORD Palette; // in: Palette identifier
LPPALETTEENTRY ColorTable; // in: 256 entry color table
HRESULT ddRVal; // out: Return value
} D3D8_UPDATEPALETTEDATA, * PD3D8_UPDATEPALETTEDATA;
//
// Driver callback table
//
DEFINE_GUID( GUID_D3D8Callbacks, 0xb497a1f3, 0x46cc, 0x4fc7, 0xb4, 0xf2, 0x32, 0xd8, 0x9e, 0xf9, 0xcc, 0x27);
typedef HRESULT (FAR PASCAL *PD3D8DDI_CREATESURFACE)(PD3D8_CREATESURFACEDATA);typedef HRESULT (FAR PASCAL *PD3D8DDI_DESTROYSURFACE)(PD3D8_DESTROYSURFACEDATA);typedef HRESULT (FAR PASCAL *PD3D8DDI_LOCK)(PD3D8_LOCKDATA);typedef HRESULT (FAR PASCAL *PD3D8DDI_UNLOCK)(PD3D8_UNLOCKDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_CONTEXTCREATE)(PD3D8_CONTEXTCREATEDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_CONTEXTDESTROY)(PD3D8_CONTEXTDESTROYDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_CONTEXTDESTROYALL)(PD3D8_CONTEXTDESTROYALLDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_RENDERSTATE) (PD3D8_RENDERSTATEDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_RENDERPRIMITIVE) (PD3D8_RENDERPRIMITIVEDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_DRAWPRIM2)(PD3D8_DRAWPRIMITIVES2DATA);typedef DWORD (FAR PASCAL *PD3D8DDI_GETDRIVERSTATE)(PD3D8_GETDRIVERSTATEDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_VALIDATETEXTURESTAGESTATE)(PD3D8_VALIDATETEXTURESTAGESTATEDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_SCENECAPTURE)(PD3D8_SCENECAPTUREDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_CLEAR2)(PD3D8_CLEAR2DATA);typedef DWORD (FAR PASCAL *PD3D8DDI_BLT)(PD3D8_BLTDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_GETSCANLINE)(PD3D8_GETSCANLINEDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_WAITFORVERTICALBLANK)(PD3D8_WAITFORVERTICALBLANKDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_FLIP)(PD3D8_FLIPDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_GETBLTSTATUS)(PD3D8_GETBLTSTATUSDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_GETFLIPSTATUS)(PD3D8_GETFLIPSTATUSDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_GETAVAILDRIVERMEMORY)(PD3D8_GETAVAILDRIVERMEMORYDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_SETMODE)(PD3D8_SETMODEDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_FLIPTOGDISURFACE)(PD3D8_FLIPTOGDISURFACEDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_SETCOLORKEY)(PD3D8_SETCOLORKEYDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_SETEXCLUSIVEMODE)(PD3D8_SETEXCLUSIVEMODEDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_DESTROYDDLOCAL)(PD3D8_DESTROYDDLOCALDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_SETRENDERTARGET)(PD3D8_SETRENDERTARGETDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_CLEAR)(PD3D8_CLEARDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_SETPALETTE)(PD3D8_SETPALETTEDATA);typedef DWORD (FAR PASCAL *PD3D8DDI_UPDATEPALETTE)(PD3D8_UPDATEPALETTEDATA);
typedef struct _D3D8_CALLBACKS{ PD3D8DDI_CREATESURFACE CreateSurface; PD3D8DDI_DESTROYSURFACE DestroySurface; PD3D8DDI_LOCK Lock; PD3D8DDI_UNLOCK Unlock; PD3D8DDI_CONTEXTCREATE CreateContext; PD3D8DDI_CONTEXTDESTROY ContextDestroy; PD3D8DDI_CONTEXTDESTROYALL ContextDestroyAll; PD3D8DDI_RENDERSTATE RenderState; PD3D8DDI_RENDERPRIMITIVE RenderPrimitive; PD3D8DDI_DRAWPRIM2 DrawPrimitives2; PD3D8DDI_GETDRIVERSTATE GetDriverState; PD3D8DDI_VALIDATETEXTURESTAGESTATE ValidateTextureStageState; PD3D8DDI_SCENECAPTURE SceneCapture; PD3D8DDI_CLEAR2 Clear2; PD3D8DDI_BLT Blt; PD3D8DDI_GETSCANLINE GetScanLine; PD3D8DDI_WAITFORVERTICALBLANK WaitForVerticalBlank; PD3D8DDI_FLIP Flip; PD3D8DDI_GETBLTSTATUS GetBltStatus; PD3D8DDI_GETFLIPSTATUS GetFlipStatus; PD3D8DDI_GETAVAILDRIVERMEMORY GetAvailDriverMemory; PD3D8DDI_GETBLTSTATUS GetSysmemBltStatus; PD3D8DDI_SETMODE SetMode; PD3D8DDI_SETEXCLUSIVEMODE SetExclusiveMode; PD3D8DDI_FLIPTOGDISURFACE FlipToGDISurface; PD3D8DDI_SETCOLORKEY SetColorkey;
PD3D8DDI_DESTROYDDLOCAL DestroyDDLocal; PD3D8DDI_SETRENDERTARGET SetRenderTarget; PD3D8DDI_CLEAR Clear; PD3D8DDI_SETPALETTE SetPalette; PD3D8DDI_UPDATEPALETTE UpdatePalette; LPVOID Reserved1; // For device alignment
LPVOID Reserved2; // For device alignment
} D3D8_CALLBACKS, * PD3D8_CALLBACKS;
//
// D3D8xxx function prototypes to replace the NT Ddxxxx prototypes from GDI32.
// On NT, these are internal functions, but on Win9X DDRAW.DLL must export
// them, so we will change the export names
//
#ifdef WIN95
#define D3D8CreateDirectDrawObject DdEntry1
#define D3D8QueryDirectDrawObject DdEntry2
#define D3D8DeleteDirectDrawObject DdEntry3
#define D3D8GetDC DdEntry4
#define D3D8ReleaseDC DdEntry5
#define D3D8ReenableDirectDrawObject DdEntry6
#define D3D8SetGammaRamp DdEntry7
#define D3D8BuildModeTable DdEntry8
#define D3D8IsDeviceLost DdEntry9
#define D3D8CanRestoreNow DdEntry10
#define D3D8RestoreDevice DdEntry11
#define D3D8DoVidmemSurfacesExist DdEntry12
#define D3D8SetMode DdEntry13
#define D3D8BeginProfile DdEntry14
#define D3D8EndProfile DdEntry15
#define D3D8GetMode DdEntry16
#define D3D8SetCooperativeLevel DdEntry17
#define D3D8IsDummySurface DdEntry18
#define D3D8LoseDevice DdEntry19
#define D3D8GetHALName DdEntry20
#endif
#ifdef __cplusplus
extern "C" {#endif
#ifdef WIN95
VOID APIENTRY D3D8CreateDirectDrawObject( LPGUID pGuid, char* szDeviceName, HANDLE* phDD, D3DDEVTYPE Type, HINSTANCE* phLibrary, VOID* pInitFunction );
#else
VOID APIENTRY D3D8CreateDirectDrawObject( HDC hdc, char* szDeviceName, HANDLE* phDD, D3DDEVTYPE Type, HINSTANCE* phLibrary, VOID* pInitFunction );
#endif
BOOL APIENTRY D3D8QueryDirectDrawObject( HANDLE hDD, PD3D8_DRIVERCAPS DriverCaps, PD3D8_CALLBACKS Callbacks, char* DeviceName, HINSTANCE hLibrary, D3D8_GLOBALDRIVERDATA* pGblDriverData, D3DHAL_D3DEXTENDEDCAPS* pExtendedCaps, LPDDSURFACEDESC pTextureFormats, LPDDPIXELFORMAT pZStencilFormats, UINT* pcTextureFormats, UINT* pcZStencilFormats );
HDC APIENTRY D3D8GetDC( HANDLE hSurface, LPPALETTEENTRY pPalette );
BOOL APIENTRY D3D8ReleaseDC( HANDLE hSurface, HDC hdc );
BOOL APIENTRY D3D8ReenableDirectDrawObject( HANDLE hDD, BOOL* pbNewMode );
BOOL APIENTRY D3D8SetGammaRamp( HANDLE hDD, HDC hdc, LPVOID lpGammaRamp );
VOID APIENTRY D3D8BuildModeTable( char* pDeviceName, D3DDISPLAYMODE* pModeTable, DWORD* pNumEntries, D3DFORMAT Unknown16, HANDLE hProfile, BOOL b16bppSupported, BOOL b32bppSupported );
BOOL APIENTRY D3D8IsDeviceLost( HANDLE hDD );
BOOL APIENTRY D3D8CanRestoreNow( HANDLE hDD );
VOID APIENTRY D3D8RestoreDevice( HANDLE hDD );
BOOL APIENTRY D3D8DoVidmemSurfacesExist( HANDLE hDD );
VOID APIENTRY D3D8DeleteDirectDrawObject( HANDLE hDD );
HANDLE APIENTRY D3D8BeginProfile( char* pDeviceName );
VOID APIENTRY D3D8EndProfile( HANDLE Handle );
DWORD APIENTRY D3D8GetMode( HANDLE Handle, char* pDeviceName, D3DDISPLAYMODE* pMode, D3DFORMAT Unknown16 );
DWORD APIENTRY D3D8SetMode( HANDLE Handle, char* pDeviceName, UINT Width, UINT Height, UINT BPP, UINT RefreshRate, BOOL bRestore );
DWORD APIENTRY D3D8SetCooperativeLevel( HANDLE hDD, HWND hWnd, DWORD dwFlags );
VOID APIENTRY D3D8LoseDevice( HANDLE hDD);
__inline DWORD D3D8GetDrawPrimHandle(HANDLE hSurface){ return *(DWORD *)(hSurface);}
BOOL APIENTRY D3D8IsDummySurface( HANDLE hSurface );
VOID APIENTRY D3D8GetHALName( char* pDisplayName, char *pDriverName );
#ifdef __cplusplus
}#endif
typedef struct _D3D8_DEVICEDATA{ D3D8_DRIVERCAPS DriverData; D3D8_CALLBACKS Callbacks; DWORD dwFlags; char DriverName[MAX_DRIVER_NAME];// RECT DeviceRect;
HDC hDC; GUID Guid; HANDLE hDD; D3DDEVTYPE DeviceType; HINSTANCE hLibrary; struct _D3D8_DEVICEDATA* pLink;// D3DDISPLAYMODE* pModeTable;
// DWORD dwNumModes;
} D3D8_DEVICEDATA, * PD3D8_DEVICEDATA;
#define DD_DISPLAYDRV 0x00000001
#define DD_GDIDRV 0x00000002
#endif
|
