📄 d3dnthal.h
字号:
// The handle could be 0, meaning that the current pixel shader is invalid
// (not set).
DWORD dwHandle;
} D3DNTHAL_DP2PIXELSHADER;
typedef D3DNTHAL_DP2PIXELSHADER *LPD3DNTHAL_DP2PIXELSHADER;
typedef struct _D3DNTHAL_DP2CREATEPIXELSHADER
{
DWORD dwHandle; // Shader handle
DWORD dwCodeSize; // Shader code size in bytes
// Shader code follows
} D3DNTHAL_DP2CREATEPIXELSHADER;
typedef D3DNTHAL_DP2CREATEPIXELSHADER *LPD3DNTHAL_DP2CREATEPIXELSHADER;
typedef struct _D3DNTHAL_DP2SETPIXELSHADERCONST
{
DWORD dwRegister; // Const register to start copying
DWORD dwCount; // Number of 4-float vectors to copy
// Data follows
} D3DNTHAL_DP2SETPIXELSHADERCONST;
typedef D3DNTHAL_DP2SETPIXELSHADERCONST *LPD3DNTHAL_DP2SETPIXELSHADERCONST;
// Flags that can be supplied to DRAWRECTPATCH and DRAWTRIPATCH
#define _NT_RTPATCHFLAG_HASSEGS 0x00000001L
#define _NT_RTPATCHFLAG_HASINFO 0x00000002L
typedef struct _D3DNTHAL_DP2DRAWRECTPATCH
{
DWORD Handle;
DWORD Flags;
// Optionally followed by D3DFLOAT[4] NumSegments and/or D3DRECTPATCH_INFO
} D3DNTHAL_DP2DRAWRECTPATCH;
typedef D3DNTHAL_DP2DRAWRECTPATCH *LPD3DNTHAL_DP2DRAWRECTPATCH;
typedef struct _D3DNTHAL_DP2DRAWTRIPATCH
{
DWORD Handle;
DWORD Flags;
// Optionally followed by D3DFLOAT[3] NumSegments and/or D3DTRIPATCH_INFO
} D3DNTHAL_DP2DRAWTRIPATCH;
typedef D3DNTHAL_DP2DRAWTRIPATCH *LPD3DNTHAL_DP2DRAWTRIPATCH;
typedef struct _D3DNTHAL_DP2VOLUMEBLT
{
DWORD dwDDDestSurface;// dest surface
DWORD dwDDSrcSurface; // src surface
DWORD dwDestX; // dest X (width)
DWORD dwDestY; // dest Y (height)
DWORD dwDestZ; // dest Z (depth)
D3DBOX srcBox; // src box
DWORD dwFlags; // blt flags
} D3DNTHAL_DP2VOLUMEBLT;
typedef D3DNTHAL_DP2VOLUMEBLT *LPD3DNTHAL_DP2VOLUMEBLT;
typedef struct _D3DNTHAL_DP2BUFFERBLT
{
DWORD dwDDDestSurface; // dest surface
DWORD dwDDSrcSurface; // src surface
DWORD dwOffset; // Offset in the dest surface (in BYTES)
D3DRANGE rSrc; // src range
DWORD dwFlags; // blt flags
} D3DNTHAL_DP2BUFFERBLT;
typedef D3DNTHAL_DP2BUFFERBLT *LPD3DNTHAL_DP2BUFFERBLT;
typedef struct _D3DNTHAL_DP2ADDDIRTYRECT
{
DWORD dwSurface; // Driver managed surface
RECTL rDirtyArea; // Area marked dirty
} D3DNTHAL_DP2ADDDIRTYRECT;
typedef D3DNTHAL_DP2ADDDIRTYRECT *LPD3DNTHAL_DP2ADDDIRTYRECT;
typedef struct _D3DNTHAL_DP2ADDDIRTYBOX
{
DWORD dwSurface; // Driver managed volume
D3DBOX DirtyBox; // Box marked dirty
} D3DNTHAL_DP2ADDDIRTYBOX;
typedef D3DNTHAL_DP2ADDDIRTYBOX *LPD3DNTHAL_DP2ADDDIRTYBOX;
// Macros to access vertex shader binary code
#define _NT_D3DSI_GETREGTYPE(token) (token & D3DSP_REGTYPE_MASK)
#define _NT_D3DSI_GETREGNUM(token) (token & D3DSP_REGNUM_MASK)
#define _NT_D3DSI_GETOPCODE(command) (command & D3DSI_OPCODE_MASK)
#define _NT_D3DSI_GETWRITEMASK(token) (token & D3DSP_WRITEMASK_ALL)
#define _NT_D3DVS_GETSWIZZLECOMP(source, component) (source >> ((component << 1) + 16) & 0x3)
#define _NT_D3DVS_GETSWIZZLE(token) (token & D3DVS_SWIZZLE_MASK)
#define _NT_D3DVS_GETSRCMODIFIER(token) (token & D3DSP_SRCMOD_MASK)
#define _NT_D3DVS_GETADDRESSMODE(token) (token & D3DVS_ADDRESSMODE_MASK)
#define _NT_D3DRS_DELETERTPATCH 169 // DDI only to delete high order patch
//-----------------------------------------------------------------------------
//
// DirectX 8.0's new driver info querying mechanism.
//
// How to handle the new driver info query mechanism.
//
// DirectX 8.0 utilizes an extension to GetDriverInfo() to query for
// additional information from the driver. Currently this mechanism is only
// used for querying for DX8 style D3D caps but it may be used for other
// information over time.
//
// This extension to GetDriverInfo takes the form of a GetDriverInfo call
// with the GUID GUID_GetDriverInfo2. When a GetDriverInfo call with this
// GUID is received by the driver the driver must check the data passed
// in the lpvData field of the DD_GETDRIVERINFODATA data structure to see
// what information is being requested.
//
// It is important to note that the GUID GUID_GetDriverInfo2 is, in fact,
// the same as the GUID_DDStereoMode. If you driver doesn't handle
// GUID_DDStereoMode this is not an issue. However, if you wish your driver
// to handle GUID_DDStereoMode as well as GUID_GetDriverInfo2 special action
// must be taken. When a call tp GetDriverInfo with the GUID
// GUID_GetDriverInfo2/GUID_DDStereoMode is made the runtime sets the
// dwHeight field of the DD_STEREOMODE structure to the special value
// D3DGDI2_MAGIC. In this way you can determine when the request is a
// stereo mode call or a GetDriverInfo2 call. The dwHeight field of
// DD_STEREOMODE corresponds to the dwMagic field of the
// DD_GETDRIVERINFO2DATA structure.
//
// The dwExpectedSize field of the DD_GETDRIVERINFODATA structure is not
// used by when a GetDriverInfo2 request is being made and should be
// ignored. The actual expected size of the data is found in the
// dwExpectedSize of the DD_GETDRIVERINFO2DATA structure.
//
// Once the driver has determined that this is a call to
// GetDriverInfo2 it must then determine the type of information being
// requested by the runtime. This type is contained in the dwType field
// of the DD_GETDRIVERINFO2DATA data structure.
//
// Finally, once the driver knows this is a GetDriverInfo2 request of a
// particular type it can copy the requested data into the data buffer.
// It is important to note that the lpvData field of the DD_GETDRIVERINFODATA
// data structure points to data buffer in which to copy your data. lpvData
// also points to the DD_GETDRIVERINFO2DATA structure. This means that the
// data returned by the driver will overwrite the DD_GETDRIVERINFO2DATA
// structure and, hence, the DD_GETDRIVERINFO2DATA structure occupies the
// first few DWORDs of the buffer.
//
// The following code fragment demonstrates how to handle GetDriverInfo2.
//
// D3DCAPS8 myD3DCaps8;
//
// DWORD CALLBACK
// DdGetDriverInfo(LPDDHAL_GETDRIVERINFODATA lpData)
// {
// if (MATCH_GUID((lpData->guidInfo), GUID_GetDriverInfo2) )
// {
// ASSERT(NULL != lpData);
// ASSERT(NULL != lpData->lpvData);
//
// // Is this a call to GetDriverInfo2 or DDStereoMode?
// if (((DD_GETDRIVERINFO2DATA*)(lpData->lpvData))->dwMagic == D3DGDI2_MAGIC)
// {
// // Yes, its a call to GetDriverInfo2, fetch the
// // DD_GETDRIVERINFO2DATA data structure.
// DD_GETDRIVERINFO2DATA* pgdi2 = lpData->lpvData;
// ASSERT(NULL != pgdi2);
//
// // What type of request is this?
// switch (pgdi2->dwType)
// {
// case D3DGDI2_TYPE_GETD3DCAPS8:
// {
// // The runtime is requesting the DX8 D3D caps so
// // copy them over now.
//
// // It should be noted that the dwExpectedSize field
// // of DD_GETDRIVERINFODATA is not used for
// // GetDriverInfo2 calls and should be ignored.
// size_t copySize = min(sizeof(myD3DCaps8), pgdi2->dwExpectedSize);
// memcpy(lpData->lpvData, &myD3DCaps8, copySize);
// lpData->dwActualSize = copySize;
// lpData->ddRVal = DD_OK;
// return DDHAL_DRIVER_HANDLED;
// }
// default:
// // For any other GetDriverInfo2 types not handled
// // or understood by the driver set an ddRVal of
// // DDERR_CURRENTLYNOTAVAIL and return
// // DDHAL_DRIVER_HANDLED.
// return DDHAL_DRIVER_HANDLED;
// }
// }
// else
// {
// // It must be a call a request for stereo mode support.
// // Fetch the stereo mode data
// DD_STEREOMODE* pStereoMode = lpData->lpvData;
// ASSERT(NULL != pStereoMode);
//
// // Process the stereo mode request...
// lpData->dwActualSize = sizeof(DD_STEREOMODE);
// lpData->ddRVal = DD_OK;
// return DDHAL_DRIVER_HANDLED;
// }
// }
//
// // Handle any other device GUIDs...
//
// } // DdGetDriverInfo
//
//-----------------------------------------------------------------------------
//
// The data structure which is passed to the driver when GetDriverInfo is
// called with a GUID of GUID_GetDriverInfo2.
//
// NOTE: Although the fields listed below are all read only this data
// structure is actually the first four DWORDs of the data buffer into
// which the driver writes the requested infomation. As such, these fields
// (and the entire data structure) are overwritten by the data returned by
// the driver.
//
typedef struct _DDNT_GETDRIVERINFO2DATA
{
DWORD dwReserved; // Reserved Field.
// Driver should not read or write this field.
DWORD dwMagic; // Magic Number. Has the value D3DGDI2_MAGIC if
// this is a GetDriverInfo2 call. Otherwise
// this structure is, in fact, a DD_STEREOMODE
// call.
// Driver should only read this field.
DWORD dwType; // Type of information requested. This field
// contains one of the DDGDI2_TYPE_ #defines
// listed below.
// Driver should only read (not write) this
// field.
DWORD dwExpectedSize; // Expected size of the information requested.
// Driver should only read (not write) this
// field.
// The remainder of the data buffer (beyond the first four DWORDs)
// follows here.
} DDNT_GETDRIVERINFO2DATA;
//
// IMPORTANT NOTE: This GUID has exactly the same value as GUID_DDStereoMode
// and as such you must be very careful when using it. If your driver needs
// to handle both GetDriverInfo2 and DDStereoMode it must have a single
// check for the shared GUID and then distinguish between which use of that
// GUID is being requested.
//
#define _NT_GUID_GetDriverInfo2 (GUID_DDStereoMode)
//
// Magic value used to determine whether a GetDriverInfo call with the
// GUID GUID_GetDriverInfo2/GUID_DDStereoMode is a GetDriverInfo2 request
// or a query about stereo capabilities. This magic number is stored in
// the dwHeight field of the DD_STEREOMODE data structure.
//
#define _NT_D3DGDI2_MAGIC (0xFFFFFFFFul)
//
// The types of information which can be requested from the driver via
// GetDriverInfo2.
//
#define _NT_D3DGDI2_TYPE_GETD3DCAPS8 (0x00000001ul) // Return the D3DCAPS8 data
#define _NT_D3DGDI2_TYPE_GETFORMATCOUNT (0x00000002ul) // Return the number of supported formats
#define _NT_D3DGDI2_TYPE_GETFORMAT (0x00000003ul) // Return a particular format
#define _NT_D3DGDI2_TYPE_DXVERSION (0x00000004ul) // Notify driver of current DX Version
//
// This data structure is returned by the driver in response to a
// GetDriverInfo2 query with the type D3DGDI2_TYPE_GETFORMATCOUNT. It simply
// gives the number of surface formats supported by the driver. Currently this
// structure consists of a single member giving the number of supported
// surface formats.
//
typedef struct _DDNT_GETFORMATCOUNTDATA
{
DDNT_GETDRIVERINFO2DATA gdi2; // [in/out] GetDriverInfo2 data
DWORD dwFormatCount; // [out] Number of supported surface formats
DWORD dwReserved; // Reserved
} DDNT_GETFORMATCOUNTDATA;
//
// This data structure is used to request a specific surface format from the
// driver. It is guaranteed that the requested format will be greater than or
// equal to zero and less that the format count reported by the driver from
// the preceeding D3DGDI2_TYPE_GETFORMATCOUNT request.
//
typedef struct _DDNT_GETFORMATDATA
{
DDNT_GETDRIVERINFO2DATA gdi2; // [in/out] GetDriverInfo2 data
DWORD dwFormatIndex; // [in] The format to return
DDPIXELFORMAT format; // [out] The actual format
} DDNT_GETFORMATDATA;
//
// This data structure is used to notify drivers about the DirectX version
// number. This is the value that is denoted as DD_RUNTIME_VERSION in the
// DDK headers.
//
typedef struct _DDNT_DXVERSION
{
DDNT_GETDRIVERINFO2DATA gdi2; // [in/out] GetDriverInfo2 data
DWORD dwDXVersion; // [in] The Version of DX
DWORD dwReserved; // Reserved
} DDNT_DXVERSION;
// New Caps that are not API visible that the driver exposes.
#define _NT_D3DDEVCAPS_HWVERTEXBUFFER 0x02000000L /* Device supports Driver Allocated Vertex Buffers*/
#define _NT_D3DDEVCAPS_HWINDEXBUFFER 0x04000000L /* Device supports Driver Allocated Index Buffers*/
#define _NT_D3DDEVCAPS_SUBVOLUMELOCK 0x08000000L /* Device supports locking a part of volume texture */
#define _NT_D3DPMISCCAPS_FOGINFVF 0x00002000L // Device supports separate fog value in the FVF
// New FVF flags that are not API visible but accessed by the driver
// Note, that D3DFVF_RESERVED2 includes this flag and should not be used for validation
#define _NT_D3DFVF_FOG 0x00002000L // There is a separate fog value in the FVF vertex
//
// This stuff is not API visible but should be DDI visible.
// Should be in Sync with d3d8types.h
//
#define _NT_D3DFMT_D32 (D3DFORMAT)71
#define _NT_D3DFMT_S1D15 (D3DFORMAT)72
#define _NT_D3DFMT_D15S1 (D3DFORMAT)73
#define _NT_D3DFMT_S8D24 (D3DFORMAT)74
#define _NT_D3DFMT_D24S8 (D3DFORMAT)75
#define _NT_D3DFMT_X8D24 (D3DFORMAT)76
#define _NT_D3DFMT_D24X8 (D3DFORMAT)77
#define _NT_D3DFMT_X4S4D24 (D3DFORMAT)78
#define _NT_D3DFMT_D24X4S4 (D3DFORMAT)79
// Vertex Shader 1.1 register limits. D3D device must provide at least
// specified number of registers
//
#define _NT_D3DVS_INPUTREG_MAX_V1_1 16
#define _NT_D3DVS_TEMPREG_MAX_V1_1 12
// This max required number. Device could have more registers. Check caps.
#define _NT_D3DVS_CONSTREG_MAX_V1_1 96
#define _NT_D3DVS_TCRDOUTREG_MAX_V1_1 8
#define _NT_D3DVS_ADDRREG_MAX_V1_1 1
#define _NT_D3DVS_ATTROUTREG_MAX_V1_1 2
#define _NT_D3DVS_MAXINSTRUCTIONCOUNT_V1_1 128
// Pixel Shader DX8 register limits. D3D device will have at most these
// specified number of registers
//
#define _NT_D3DPS_INPUTREG_MAX_DX8 8
#define _NT_D3DPS_TEMPREG_MAX_DX8 8
#define _NT_D3DPS_CONSTREG_MAX_DX8 8
#define _NT_D3DPS_TEXTUREREG_MAX_DX8 8
#endif // (DIRECT3D_VERSION >= 0x0800 )
#endif /* _D3DNTHAL_H */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -